diff -r 000000000000 -r b497e44ab2fc policymanagement/policyengine/centreptoolserver/src/RepositorySession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/policymanagement/policyengine/centreptoolserver/src/RepositorySession.cpp Thu Dec 17 09:07:52 2009 +0200 @@ -0,0 +1,2181 @@ +/* +* Copyright (c) 2002-2004 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: Implementation of policymanagement components +* +*/ + + +// INCLUDE FILES + +#include "RepositorySession.h" +#include "IniFileHelper.h" +#include "constants.h" +#include "debug.h" +#include "PolicyEnginePrivateCRKeys.h" + +#include +#include + +const TUid KCentralRepositoryUID = { 0x10202BE9 }; + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::CRepositoryContent() +// ----------------------------------------------------------------------------- +// + +CRepositoryContent::CRepositoryContent( const TUid& aUid, HBufC* aContent) + : iContentPtr( *aContent), iContent( aContent), iUid( aUid) +{ +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::CRepositoryContent() +// ----------------------------------------------------------------------------- +// +CRepositoryContent::CRepositoryContent( const TUid& aUid) + : iUid( aUid) +{ +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::~CRepositoryContent() +// ----------------------------------------------------------------------------- +// + +CRepositoryContent::~CRepositoryContent() +{ + ReleaseResources(); + + iRangeSettings.Close(); + iIndividualSettings.Close(); + iRangeMetas.Close(); +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::NewL() +// ----------------------------------------------------------------------------- +// +CRepositoryContent * CRepositoryContent::NewL( const TUid& aUid) +{ + CRepositoryContent *self = new (ELeave) CRepositoryContent( aUid); + CleanupStack::PushL( self); + + self->ConstructL(); + + CleanupStack::Pop( self); + return self; +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::NewL() +// ----------------------------------------------------------------------------- +// +CRepositoryContent * CRepositoryContent::NewL( const TUid& aUid, HBufC* aContent) +{ + CRepositoryContent *self = new (ELeave) CRepositoryContent( aUid, aContent); + CleanupStack::PushL( self); + + self->ConstructL(); + + CleanupStack::Pop( self); + return self; +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::ConstructL() +// ----------------------------------------------------------------------------- +// +void CRepositoryContent::ConstructL() +{ + RDEBUG("CentRepTool: New CRepostioryContent"); + iDefaultSetting = new (ELeave) CDefaultSetting(); +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::ReleaseResources() +// ----------------------------------------------------------------------------- +// + +void CRepositoryContent::ReleaseResources() +{ + RDEBUG("CentRepTool: Release CRepository content resources"); + + delete iContent; + iContent = 0; + + delete iDefaultSetting; + iDefaultSetting = 0; + + iRangeSettings.ResetAndDestroy(); + iIndividualSettings.ResetAndDestroy(); + iRangeMetas.ResetAndDestroy(); + + +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::ReadHeaderL() +// ----------------------------------------------------------------------------- +// + +void CRepositoryContent::ReadHeaderL() +{ + RDEBUG("CentRepTool: Read ini-file header(.txt format)"); + + + using namespace IniConstants; + + TInt index = iContentPtr.FindF( KPlatSecSection); + User::LeaveIfError( index); + + //separate each section to own ptr's + iHeaderPtr.Set( iContentPtr.Left( index + KPlatSecStringLength)); //content before [platsec] + iContentPtr.Set( iContentPtr.Mid( index + KPlatSecStringLength)); //content after [platsec] (platsec and settings) + + iDefaultMetaPtr.Set( KNullDesC); + iOwnerPtr.Set( KNullDesC); + + //locate owner section and insulate it own ptr + index = iHeaderPtr.FindF( KOwnerSection); + TPtrC * lastPart = 0; + + if ( index >= 0) + { + iOwnerPtr.Set( iHeaderPtr.Mid( index + KOwnerStringLength)); //content after [owner] + //pointer to the last section before [platsec] section + lastPart = &iOwnerPtr; + } + else + { + //pointer to the last section before [platsec] section + lastPart = &iHeaderPtr; + } + + //locate default meta section + index = lastPart->FindF( KDefaultMetaSection); + + + if ( index >= 0) + { + iDefaultMetaPtr.Set( lastPart->Mid( index + KDefaultMetaStringLength)); //content after [defaultmeta] + lastPart->Set( lastPart->Left( index)); + lastPart = &iDefaultMetaPtr; + } + + //set last section length... + index = lastPart->FindF( KPlatSecSection); + User::LeaveIfError( index); + + lastPart->Set( lastPart->Left( index)); +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::ReadDefaultMetaL() +// ----------------------------------------------------------------------------- +// +void CRepositoryContent::ReadOptionalDataL() +{ + RDEBUG("CentRepTool: Read ini-file optional data(.txt format)"); + + TPtrC owner = iOwnerPtr; + + //read next line from owner section + TPtrC line; + TIniFileHelper::NextLine( owner, line); + + //read owner secure id from line + if ( line.Length()) + { + TLex lex( line); + TInt32 value; + User::LeaveIfError( TIniFileHelper::ReadNumber( value, lex)); + iOwner.iUid = value; + } + + //read + TPtrC defaultMeta = iDefaultMetaPtr; + + do + { + line.Set( KNullDesC); + TIniFileHelper::NextLine( defaultMeta, line); + + //try to create RangeMeta data + TLex lex( line); + CRangeMeta * rangeMeta = CRangeMeta::NewL( lex); + + //if the line content is not a range meta data check is the content is it default meta data + if ( rangeMeta) + { + iRangeMetas.AppendL( rangeMeta); + } + else + { + if ( !lex.Eos()) + { + User::LeaveIfError( TIniFileHelper::ReadUNumber( iDefaultMeta, lex)); + User::LeaveIfError( !lex.Eos()); + } + } + + } while ( defaultMeta.Length()); + +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::ReadPlatSecL() +// ----------------------------------------------------------------------------- +// + +void CRepositoryContent::ReadPlatSecL() +{ + RDEBUG("CentRepTool: Read ini-file platsec-section(.txt format)"); + + using namespace IniConstants; + + TInt index = iContentPtr.FindF( KMainSection ); + User::LeaveIfError( index); + + TPtrC platSecPtr = iContentPtr.Left( index); + + do + { + TPtrC sectionPtr = platSecPtr; + + TIniFileHelper::NextLine( platSecPtr, sectionPtr); + + if ( !sectionPtr.Length()) + { + break; + } + + TLex lex( sectionPtr); + CRangeSetting* rangeSetting = CRangeSetting::NewL( lex); + + if ( rangeSetting ) + { + iRangeSettings.AppendL( rangeSetting); + } + else + { + CDefaultSetting* defaultSetting = CDefaultSetting::NewL( lex); + + if ( defaultSetting ) + { + if ( iDefaultSetting && iDefaultSetting->ContainsSecuritySettings()) + { + //there can be only one default settings in the repository -> Corrupted + User::Leave( KErrCorrupt); + } + else + { + delete iDefaultSetting; + iDefaultSetting = defaultSetting; + } + } + else + { + //line contains invalid format -> Corrupted + User::Leave( KErrCorrupt); + } + } + + + } while ( platSecPtr.Length()); + + iContentPtr.Set( iContentPtr.Mid( index + IniConstants::KMainSectionStringLength)); +} +// ----------------------------------------------------------------------------- +// CRepositoryContent::FindIndividualSetting() +// ----------------------------------------------------------------------------- +// +CIndividualSetting* CRepositoryContent::FindIndividualSetting( const TUint32 aSettingId) +{ + //Find individual setting which has same id and return it... + for ( TInt i(0); i < iIndividualSettings.Count(); i++) + { + if ( iIndividualSettings[i]->iSettingId == aSettingId) + { + return iIndividualSettings[i]; + } + } + + return 0; +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::WriteFileL() +// ----------------------------------------------------------------------------- +// + +void CRepositoryContent::WriteFileL( RFile& aFile) +{ + TBuf<600> buffer; + + TIniFileHelper ini; + + ini.StartWrite( aFile); + + ini.WriteToFile( iHeaderPtr); + ini.LineFeed(); + + if ( iDefaultSetting) + { + ini.WriteToFile( iDefaultSetting->SecurityString( buffer)); + ini.LineFeed(); + } + + for ( TInt i(0); i < iRangeSettings.Count(); i++) + { + ini.WriteToFile( iRangeSettings[i]->SettingDefinition( buffer)); + ini.WriteToFile( iRangeSettings[i]->SecurityString( buffer)); + ini.LineFeed(); + } + + ini.WriteToFile( IniConstants::KMainSection); + ini.LineFeed(); + + for ( TInt i(0); i < iIndividualSettings.Count(); i++) + { + ini.WriteToFile( iIndividualSettings[i]->SettingDefinition( buffer)); + ini.WriteToFile( iIndividualSettings[i]->SecurityString( buffer)); + ini.LineFeed(); + } + + ini.FinishWrite(); +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::CheckRangeValidity() +// ----------------------------------------------------------------------------- +// + +TBool CRepositoryContent::CheckRangeValidity() +{ + RDEBUG("CentRepTool: Check range setting validity"); + + //evaluate range setting validity (range setting start value must be greater than previous setting end value) + TLinearOrder linearOrder( &TIniFileHelper::CompareElements); + iRangeSettings.Sort( linearOrder); + + TBool rangesValid = ETrue; + + TInt rangeCount = iRangeSettings.Count(); + for ( TInt i(0); i < rangeCount; i++) + { + if ( i + 1 < rangeCount) + { + if ( iRangeSettings[i]->iEnd >= iRangeSettings[i+1]->iStart) + { + rangesValid = EFalse; + break; + } + } + } + + return rangesValid; +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::CreateMaskBackupL() +// ----------------------------------------------------------------------------- +// +void CRepositoryContent::CreateMaskBackupL( RPointerArray& aSettings, TUint32 aCompareValue, TUint32 aMask) +{ + RDEBUG_3("CentRepTool: Turn backup flag on for mask ( %d mask:%d)", aCompareValue, aMask); + + TInt rangeCount = iRangeMetas.Count(); + + //search existing settings + for ( TInt i(0); i < rangeCount; i++) + { + CRangeMeta * setting = iRangeMetas[i]; + + if ( setting->Type() != EMaskSetting ) + { + continue; + } + + if ( setting->iStart == aCompareValue && setting->iMask == aMask) + { + aSettings.AppendL( setting); + } + } + + //create new one, if setting doesn't exist + if ( !aSettings.Count() ) + { + CRangeMeta * setting = CRangeMeta::NewL( aCompareValue, 0, aMask, KBackupBitMask); + aSettings.Append( setting ); + iRangeMetas.Append( setting); + } +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::CreateRangeBackupL() +// ----------------------------------------------------------------------------- +// + +void CRepositoryContent::CreateRangeBackupL( RPointerArray& aSettings, TUint32 aRangeStart, TUint32 aRangeEnd) +{ + RDEBUG_3("CentRepTool: Create new range setting (%d -> %d)", aRangeStart, aRangeEnd); + + //evaluate range setting validity (range setting start value must be greater than previous setting end value) + //evaluate range setting validity (range setting start value must be greater than previous setting end value) + TLinearOrder linearOrder( &TIniFileHelper::CompareElements); + iRangeMetas.Sort( linearOrder); + + + TInt rangeCount = iRangeMetas.Count(); + for ( TInt i(0); i < rangeCount; i++) + { + if ( i + 1 < rangeCount) + { + if ( iRangeMetas[i]->iEnd >= iRangeMetas[i+1]->iStart) + { + User::Leave( KErrCorrupt); + } + } + } + + //search existing settings + for ( TInt i(0); i < rangeCount; i++) + { + CRangeMeta * setting = iRangeMetas[i]; + + if ( setting->Type() != ERangeSetting ) + { + continue; + } + + if ( setting->iStart == aRangeStart && setting->iEnd == aRangeEnd) + { + aSettings.AppendL( setting); + } + } + + //create new one, if setting doesn't exist + if ( !aSettings.Count() ) + { + CRangeMeta * setting = CRangeMeta::NewL( aRangeStart, aRangeEnd, 0, KBackupBitMask); + aSettings.Append( setting ); + iRangeMetas.Append( setting); + } + + iRangeMetas.Sort( linearOrder); + +} + + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::FindRangeSetting() +// ----------------------------------------------------------------------------- +// + +void CRepositoryContent::CreateRangeSettingsL( RPointerArray& aSettings, TUint32 aRangeStart, TUint32 aRangeEnd) +{ + RDEBUG_3("CentRepTool: Create new range setting (%d -> %d)", aRangeStart, aRangeEnd); + + //evaluate range setting validity (range setting start value must be greater than previous setting end value) + //evaluate range setting validity (range setting start value must be greater than previous setting end value) + TLinearOrder linearOrder( &TIniFileHelper::CompareElements); + iRangeSettings.Sort( linearOrder); + + + TInt rangeCount = iRangeSettings.Count(); + for ( TInt i(0); i < rangeCount; i++) + { + if ( i + 1 < rangeCount) + { + if ( iRangeSettings[i]->iEnd >= iRangeSettings[i+1]->iStart) + { + User::Leave( KErrCorrupt); + } + } + } + + //search existing settings + for ( TInt i(0); i < rangeCount; i++) + { + CRangeSetting * setting = iRangeSettings[i]; + + if ( setting->Type() != ERangeSetting ) + { + continue; + } + + if ( setting->iStart == aRangeStart && setting->iEnd == aRangeEnd) + { + aSettings.AppendL( setting); + } + } + + //create new one, if setting doesn't exist + if ( !aSettings.Count() ) + { + CRangeSetting * setting = CRangeSetting::NewL( aRangeStart, aRangeEnd, 0); + aSettings.Append( setting ); + iRangeSettings.Append( setting); + } + + iRangeSettings.Sort( linearOrder); + +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::CreateMaskSettingsL() +// ----------------------------------------------------------------------------- +// +void CRepositoryContent::CreateMaskSettingsL( RPointerArray& aSettings, TUint32 aCompareValue, TUint32 aMask) +{ + RDEBUG_3("CentRepTool: Create new mask setting ( %d mask:%d)", aCompareValue, aMask); + + TInt rangeCount = iRangeSettings.Count(); + + //search existing settings + for ( TInt i(0); i < rangeCount; i++) + { + CRangeSetting * setting = iRangeSettings[i]; + + if ( setting->Type() != EMaskSetting ) + { + continue; + } + + if ( setting->iStart == aCompareValue && setting->iMask == aMask) + { + aSettings.AppendL( setting); + } + } + + //create new one, if setting doesn't exist + if ( !aSettings.Count() ) + { + CRangeSetting * setting = CRangeSetting::NewL( aCompareValue, 0, aMask); + aSettings.Append( setting ); + iRangeSettings.Append( setting); + } + + +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::ReadMainL() +// Read main secttion (individual settings) from CentRep ini. +// ----------------------------------------------------------------------------- +// + +void CRepositoryContent::ReadMainL() +{ + do + { + //get next setting from inifile + TPtrC settingPtr = iContentPtr; + TIniFileHelper::NextLine( iContentPtr, settingPtr); + + //Create new CIndividual setting + TLex lex( settingPtr); + + if ( lex.Eos()) + { + break; + } + + CIndividualSetting * setting = CIndividualSetting::NewL( lex); + + if ( setting ) + { + //add settting to settings list + AddIndividualSettingL( setting); + } + else + { + //file is corrupted if setting is not valid + User::Leave( KErrCorrupt); + } + + //repeat until contetn left + } while ( iContentPtr.Length()); +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::FindSettingOrCreateL() +// ----------------------------------------------------------------------------- +// +CIndividualSetting* CRepositoryContent::FindSettingOrCreateL( const TUint32& aSettingId) +{ + //try to find element with same id + TLinearOrder linearOrder( &CIndividualSetting::CompareElements); + CIndividualSetting* referenceElement = new (ELeave) CIndividualSetting( aSettingId); + + TInt index = iIndividualSettings.FindInOrder( referenceElement, linearOrder); + + CIndividualSetting * element = NULL; + if ( index >= 0) + { + //if element exists return it and delete reference element... + element = iIndividualSettings[index]; + delete referenceElement; + } + else + { + //...or if not use reference elemetn and add it to setting list... + element = referenceElement; + AddIndividualSettingL( element); + } + + //...return element + return element; + +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::AddElementL() +// ----------------------------------------------------------------------------- +// +void CRepositoryContent::AddIndividualSettingL( CIndividualSetting* aSetting) +{ + if ( aSetting->ContainsSecuritySettings()) + { + iSingleSecuritySettingCount++; + } + + TLinearOrder linearOrder( &CIndividualSetting::CompareElements); + iIndividualSettings.InsertInOrder( aSetting, linearOrder); +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::CheckAccess() +// ----------------------------------------------------------------------------- +// +TBool CRepositoryContent::CheckAccess( const RMessage2& aMessage, TUint32 aSettingId, TAccessType aAccessType) +{ + TBool retVal( ETrue); + + for ( TInt i(0); i < iRangeSettings.Count(); i++) + { + CRangeSetting* setting = iRangeSettings[ i]; + + if ( setting->Mask()) + { + TUint32 masked = aSettingId & setting->Mask(); + if ( masked == setting->Start()) + { + retVal = setting->CheckAccess( aMessage, aAccessType); + if ( !retVal ) + { + return EFalse; + } + } + } + else + { + if ( setting->Start() <= aSettingId && aSettingId <= setting->End()) + { + retVal = setting->CheckAccess( aMessage, aAccessType); + if ( !retVal ) + { + return EFalse; + } + } + } + } + + if ( iDefaultSetting) + { + retVal = iDefaultSetting->CheckAccess( aMessage, aAccessType); + } + + return retVal; +} + + + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::CRepositorySession() +// ----------------------------------------------------------------------------- +// + +CRepositorySession::CRepositorySession( TUid aRepositoryId) + : iRepositoryId( aRepositoryId), iRepositoryInUse( EFalse) +{ +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::~CRepositorySession() +// ----------------------------------------------------------------------------- +// + +CRepositorySession::~CRepositorySession() +{ + //if session is not committed, restore file! + + + //release resources.... + ReleaseResources(); + + //close file server sessions + iFile.Close(); + iFs.Close(); + +} + + +// ----------------------------------------------------------------------------- +// CRepositorySession::ReleaseResources() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::ReleaseResources() +{ + delete iRepContent; + iRepContent = 0; + + } + + +// ----------------------------------------------------------------------------- +// CRepositorySession::NewL() +// ----------------------------------------------------------------------------- +// + +CRepositorySession * CRepositorySession::NewL( TUid aRepositoryId) +{ + CRepositorySession * self = new(ELeave) CRepositorySession( aRepositoryId); + + CleanupStack::PushL( self); +// self->ConstructL(); + CleanupStack::Pop( self); + + return self; +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::CheckCommitStateL() +// ----------------------------------------------------------------------------- +// + +void CRepositorySession::CheckCommitStateL() +{ + //Get commit flag state from centrep + CRepository * iCentRep = CRepository::NewLC( KPolicyEngineRepositoryID ); + + TInt state; + __ASSERT_ALWAYS( KErrNone == iCentRep->Get( KCommitFlag, state), User::Panic( IniConstants::KCentRepToolPanic, KErrCorrupt)); + + if ( state == EFalse) + { + //restore backup if changes are not committed + RestoreBackupL(); + } + + //remove backup + RemoveBackupL(); + + CleanupStack::PopAndDestroy(); //CRepository +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::RestoreBackupL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::RestoreBackupL() +{ + + using namespace IniConstants; + + RFs rfs; + User::LeaveIfError( rfs.Connect() ); + CleanupClosePushL( rfs); + + //Open directory and get file list + RDir dir; + CleanupClosePushL( dir); + + TInt err = dir.Open( rfs, KBackupPath, KEntryAttNormal); + + if ( err == KErrPathNotFound) + { + CreatePath(); + err = dir.Open( rfs, KBackupPath, KEntryAttNormal); + } + + User::LeaveIfError( err); + + err = KErrNone; + do + { + //read entries (files) + TEntryArray array; + err = dir.Read( array); + if ( KErrEof != err) + { + User::LeaveIfError( err); + } + + for ( TInt i = 0; i < array.Count(); i++) + { + const TEntry& entry = array[i]; + + TBuf backupFile; + backupFile.Append( KBackupPath); + TBuf name; + name.Append( KDriveC); + + + //repository backup + //original file name and location + name.Append( entry.iName); + + //backup file name and location + backupFile.Append( entry.iName); + //copy file to work directory + CFileMan * fileMan = CFileMan::NewL( rfs); + CleanupStack::PushL( fileMan); + + //Copy file to work directory + User::LeaveIfError( fileMan->Copy( backupFile, name)); + + CleanupStack::PopAndDestroy(); //fileMan + } + } while ( err == KErrNone); + + CleanupStack::PopAndDestroy(2); //RFs +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::RemoveBackupL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::RemoveBackupL() +{ + using namespace IniConstants; + + RFs rfs; + User::LeaveIfError( rfs.Connect() ); + CleanupClosePushL( rfs); + + //Open directory and get file list + RDir dir; + CleanupClosePushL( dir); + + TInt err = dir.Open( rfs, KBackupPath, KEntryAttNormal); + + if ( err == KErrPathNotFound) + { + CreatePath(); + err = dir.Open( rfs, KBackupPath, KEntryAttNormal); + } + + User::LeaveIfError( err); + + err = KErrNone; + do + { + //read entries (files) + TEntryArray array; + err = dir.Read( array); + if ( KErrEof != err) + { + User::LeaveIfError( err); + } + + + for ( TInt i = 0; i < array.Count(); i++) + { + const TEntry& entry = array[i]; + + TBuf name; + name.Append( KBackupPath); + name.Append( entry.iName); + + User::LeaveIfError( rfs.Delete( name)); + } + } while ( err == KErrNone ); + + CleanupStack::PopAndDestroy(2); //RFs, RDir +} + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::InitRepositorySessionL() +// ----------------------------------------------------------------------------- +// + +void CRepositorySession::InitRepositorySessionL() +{ + using namespace IniConstants; + + //Establish connection + User::LeaveIfError( iFs.Connect() ); + + //Buffer for file name (without extension) + iRepName.Zero(); + iRepName.NumFixedWidth( iRepositoryId.iUid, EHex, KUidLengthRep); + + //open repository file + if ( KErrNone != ReadRAML( EFalse)) + { + CreateAndReadROML(); + } + + + //buffer for path and file name + TBuf repFileName; + repFileName.Append( KDriveC); //drive and path + TInt pathLength = repFileName.Length(); + repFileName.Append( iRepName); //file name + repFileName.Append( KRepositoryFileExtensionCre); //and extension + + //create timer + RTimer timer; + User::LeaveIfError( timer.CreateLocal()); + + //open or create RAM file for + TInt counter = 0; + TInt err = KErrNone; + + do + { + err = iFile.Open( iFs, repFileName, EFileShareExclusive|EFileRead|EFileWrite ); + CheckRepositoryState( err); + + if ( err != KErrNone) + { + iFile.Close(); + + //or if file is reserved, wait a moment... + TRequestStatus status; + timer.After( status, KFileOpenPeriod); + User::WaitForRequest( status); + } + + } while ( counter++ < KFileOpenAttemps && ( err != KErrNone)); + + //close timer + timer.Close(); + + User::LeaveIfError( err); + + + //create backup file... + if ( err == KErrNone) + { + MakeBackupL( iFile); + } + + //file is not opened + User::LeaveIfError( err); +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::ReadRAML() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::CheckRepositoryState( TInt& aFileOpenResult) +{ + if ( aFileOpenResult != KErrNone) + { + return; + } + + //check is repository in use + CRepository* rep = 0; + TRAPD( err, rep = CRepository::NewL( iRepositoryId)); + delete rep; + + if ( err == KErrNone ) + { + iRepositoryInUse = ETrue; + } +} + + +// ----------------------------------------------------------------------------- +// CRepositorySession::ReadRAML() +// ----------------------------------------------------------------------------- +// +TInt CRepositorySession::ReadRAML( TBool aOnlyHeader) +{ + RDEBUG("CentRepTool: Read repository from RAM-drive"); + + + using namespace IniConstants; + + RFile file; + + //buffer for path and file name + TBuf repFileName; + repFileName.Append( KDriveC); //drive and path + TInt pathLength = repFileName.Length(); + repFileName.Append( iRepName); //file name + repFileName.Append( KRepositoryFileExtensionCre); //and extension + + //Open file + TInt err = file.Open( iFs, repFileName, EFileRead); + RDEBUG_2("CentRepTool: Open repository - %S", &repFileName); + + if ( err != KErrNone) + { + return err; + } + + //Open file stream + CDirectFileStore* directFileStore = CDirectFileStore::FromLC ( file); + TStreamId rootStreamId = directFileStore->Root() ; + + //setup read stream + RStoreReadStream rootStream ; + rootStream.OpenLC( *directFileStore, rootStreamId); + + //Internalize the repository + iRepContent = CRepositoryContent::NewL( iRepositoryId); + iRepContent->ReadStreamL( rootStream, aOnlyHeader); + + CleanupStack::PopAndDestroy( 2, directFileStore); + + return KErrNone; +} + + +// ----------------------------------------------------------------------------- +// CRepositorySession::CreateROMFileL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::CreateAndReadROML() +{ + using namespace IniConstants; + + //read content from ROM + iRepContent = ReadROMFileL( ETrue); + + __UHEAP_MARK; + + //buffer for path and file name + TBuf tmpFileName; + tmpFileName.Append( KBackupPath); //drive and path + TInt pathLength = tmpFileName.Length(); + tmpFileName.Append( iRepName); //file name + tmpFileName.Append( KRepositoryFileExtensionTmp); //and extension + + RFile file; + CleanupClosePushL( file); + + //Create RAM file. + User::LeaveIfError( file.Replace( iFs, tmpFileName, EFileShareExclusive|EFileRead|EFileWrite )); + + //Open file stream. RFile ownership changes for CDirectFileStore + CDirectFileStore * directFileStore = CDirectFileStore::NewL( file); + CleanupStack::Pop( &file); + CleanupStack::PushL( directFileStore); + + //setup write stream + directFileStore->SetTypeL( TUidType(KDirectFileStoreLayoutUid, KNullUid, KCentralRepositoryUID)) ; + + RStoreWriteStream rootStream ; + TStreamId rootStreamId = rootStream.CreateLC(*directFileStore) ; + + //Externalize .cre file.... + iRepContent->WriteStreamL( rootStream); + rootStream.CommitL(); + + directFileStore->SetRootL(rootStreamId); + directFileStore->CommitL(); + + //destroy + CleanupStack::PopAndDestroy( 2, directFileStore); + + + //copy file to work directory + CFileMan * fileMan = CFileMan::NewL( iFs); + CleanupStack::PushL( fileMan); + + //buffer for path and file name + TBuf repFileName; + repFileName.Append( KDriveC); //drive and path + pathLength = repFileName.Length(); + repFileName.Append( iRepName); //file name + repFileName.Append( KRepositoryFileExtensionCre); //and extension + + //Copy file to work directory + User::LeaveIfError( fileMan->Copy( tmpFileName, repFileName)); + User::LeaveIfError( fileMan->Delete( tmpFileName)); + + CleanupStack::PopAndDestroy( fileMan); //fileMan + + __UHEAP_MARKEND; +} + + +// ----------------------------------------------------------------------------- +// CRepositorySession::CommitRepositoryL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::CommitRepositoryL() +{ + RDEBUG("CentRepTool: CommitRepositoryL"); + + + using namespace IniConstants; + + //buffer for path and file name + TBuf tmpFileName; + tmpFileName.Append( KBackupPath); //drive and path + tmpFileName.Append( KTempFile); //file name + + //Create RAM file + RFile file; + TInt err = file.Create( iFs, tmpFileName, EFileShareExclusive|EFileRead|EFileWrite ); + + if ( err == KErrAlreadyExists) + { + User::LeaveIfError( file.Open( iFs, tmpFileName, EFileShareExclusive|EFileRead|EFileWrite )); + User::LeaveIfError( file.SetSize(0)); + } + + //Open file stream + CDirectFileStore * directFileStore = CDirectFileStore::NewLC( file); + + //setup write stream + directFileStore->SetTypeL( TUidType(KDirectFileStoreLayoutUid, KNullUid, KCentralRepositoryUID)) ; + + RStoreWriteStream rootStream ; + TStreamId rootStreamId = rootStream.CreateLC(*directFileStore) ; + + //Externalize .cre file.... + iRepContent->WriteStreamL( rootStream); + rootStream.CommitL(); + + directFileStore->SetRootL(rootStreamId); + directFileStore->CommitL(); + + RDEBUG("CentRepTool: Repository streamed to temp-file"); + + //destroy + CleanupStack::PopAndDestroy( 2, directFileStore); + + //copy temp file to repository file + User::LeaveIfError( file.Open( iFs, tmpFileName, EFileRead)); + CleanupClosePushL( file); + + TInt size = 0; + User::LeaveIfError( file.Size( size)); + + HBufC8 * buf = HBufC8::NewLC( size); + TPtr8 ptr = buf->Des(); + User::LeaveIfError( file.Read( ptr)); + + //seek to start of the file + TInt seekOffset(0); + + User::LeaveIfError( iFile.Seek( ESeekStart, seekOffset)); + User::LeaveIfError( iFile.Write( *buf)); + User::LeaveIfError( iFile.SetSize( size)); + + User::LeaveIfError( iFile.Flush()); + + RDEBUG_2("CentRepTool: Persist repository file (.cre) committed from temp file (size: %d bytes)", size); + + + //enforce central repository to re-read setting from .cre file... + if ( iRepositoryInUse) + { + RDEBUG("CentRepTool: Repository is already used by central repository - "); + + //create repository session... + CRepository* repository = CRepository::NewLC( iRepositoryId); + + //in next phase try to modifie CentRep setting. Because .cre file is locked by CRepositorySession + //CentRep cannot make update and causes that repostiory goes to inconsistent state. Inconsistent + //state ensures that new security settings are readed from drive before any other operation + TInt errx = repository->Create( 0, 0); + if ( errx == KErrAlreadyExists ) + { + errx = repository->Set( 0, 0); + } + + RDEBUG_2("CentRepTool: Enforce Central Repository file inconsistent state (CR state %d, must be != KErrNone)", errx); + CleanupStack::PopAndDestroy( repository); + } + + CleanupStack::PopAndDestroy( 2, &file); +} + + + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::ReadFileL() +// ----------------------------------------------------------------------------- +// +CRepositoryContent* CRepositorySession::ReadROMFileL( TBool aReadSettings) +{ + using namespace IniConstants; + + RDEBUG("CentRepTool: Read repository from ROM-drive"); + + CRepositoryContent* retVal = 0; + + //buffer for path and file name + TBuf repFileName; + repFileName.Append( KDriveZ); //drive and path + TInt pathLength = repFileName.Length(); + repFileName.Append( iRepName); //file name + repFileName.Append( KRepositoryFileExtensionTxt); //and extension + + //ROM file should always be ready to open + RFile file; + TInt err = file.Open( iFs, repFileName, EFileRead); + + if ( err == KErrNone ) + { + RDEBUG("CentRepTool: ROM repository found (.txt)"); + RDEBUG_2("CentRepTool: Open repository - %S", &repFileName); + + CleanupClosePushL( file); + + //read file content and set iContentPtr + TIniFileHelper ini; + HBufC16 * content = ini.ReadFileL( file); + + retVal = CRepositoryContent::NewL( iRepositoryId, content); + CleanupStack::PushL( retVal); + + //read sections from ini file + retVal->ReadHeaderL(); + retVal->ReadOptionalDataL(); + retVal->ReadPlatSecL(); + + if (aReadSettings) + { + retVal->ReadMainL(); + } + + CleanupStack::Pop( retVal); + CleanupStack::PopAndDestroy( &file); + + } + else + { + RDEBUG("CentRepTool: ROM repository not found (.txt), try .cre-repository"); + + repFileName.Replace( repFileName.Length() - 4, 4, KRepositoryFileExtensionCre); + User::LeaveIfError( file.Open( iFs, repFileName, EFileRead)); + + RDEBUG_2("CentRepTool: Open repository - %S", &repFileName); + + retVal = CRepositoryContent::NewL( iRepositoryId); + CleanupStack::PushL( retVal); + + //Open file stream + CDirectFileStore* directFileStore = CDirectFileStore::FromLC ( file); + TStreamId rootStreamId = directFileStore->Root() ; + + //setup read stream + RStoreReadStream rootStream ; + rootStream.OpenLC( *directFileStore, rootStreamId); + + //Internalize the repository + retVal->ReadStreamL( rootStream, !aReadSettings); + + CleanupStack::PopAndDestroy( 2, directFileStore); + CleanupStack::Pop( retVal); + + } + + RDEBUG("CentRepTool: Repository read successfully"); + + return retVal; +} + + + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::MakeBackupL() +// ----------------------------------------------------------------------------- +// + +void CRepositorySession::MakeBackupL( RFile& aFile) +{ + using namespace IniConstants; + + //Because file is already opened, CFileMan cannot be used! + //seek to start of the file + TInt seekOffset(0); + aFile.Seek( ESeekStart, seekOffset); + + TInt size; + User::LeaveIfError( aFile.Size(size)); + + //create buffer for content + HBufC8* buf = HBufC8::NewLC(size); + TPtr8 ptr = buf->Des(); + + //read file + aFile.Read( ptr); + + + //backup file name + TBuf backupFile; + iFs.PrivatePath( backupFile); + backupFile.Append( iRepName); //file name + backupFile.Append( KRepositoryFileExtensionCre); //and extension + + //create backup file + RFile backup; + CleanupClosePushL( backup); + + TInt err = backup.Replace( iFs, backupFile, EFileWrite); + if ( err == KErrPathNotFound) + { + err = CreatePath(); + } + + User::LeaveIfError( err); + + //write to file + User::LeaveIfError( backup.Write( ptr)); + + //ensures that if file close fails, error is detected + User::LeaveIfError( backup.Flush()); + + CleanupStack::PopAndDestroy(2); //backup, HBufC + +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::CreatePath() +// ----------------------------------------------------------------------------- +// +TInt CRepositorySession::CreatePath() +{ + //create private path + + RFs rfs; + TInt err = rfs.Connect(); + + if ( err == KErrNone ) + { + err = rfs.CreatePrivatePath( EDriveC); + } + + rfs.Close(); + + return err; +} + + + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::SetSecurityIdForSetting() +// ----------------------------------------------------------------------------- +// + +void CRepositorySession::SetSecurityIdForSettingL( const RMessage2& aMessage) +{ + __UHEAP_MARK; + + TIniFileHelper ini; + + //read setting id from RMessage + TUint32 settingUid; + TPckg settingUidPack( settingUid); + aMessage.ReadL(0, settingUidPack); + + //read SID from RMessage + TUid applicationUid; + TPckg applicationUidPack( applicationUid); + aMessage.ReadL(1, applicationUidPack); + + CIndividualSetting * setting = iRepContent->FindIndividualSetting( settingUid); + + if ( !setting ) + { + User::Leave( KErrNotFound); + } + + User::LeaveIfError( setting->AddSid( applicationUid)); + + + __UHEAP_MARKEND; +} + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::SetSecurityIdForRange() +// ----------------------------------------------------------------------------- +// + +void CRepositorySession::SetSecurityIdForRangeL( const RMessage2& aMessage) +{ + //read range start from RMessage + TUint32 rangeStart; + TPckg rangeStartPack( rangeStart); + aMessage.ReadL(0, rangeStartPack); + + //read range end from RMessage + TUint32 rangeEnd; + TPckg rangeEndPack( rangeEnd); + aMessage.ReadL(1, rangeEndPack); + + //read SID from RMessage + TUid applicationUid; + TPckg applicationUidPack( applicationUid); + aMessage.ReadL(2, applicationUidPack); + + + //Find range setting + RPointerArray settings; + CleanupClosePushL( settings); + iRepContent->CreateRangeSettingsL( settings, rangeStart, rangeEnd); + + //Add SIDs for setting inside of the range + for ( TInt i(0); i < settings.Count(); i++) + { + User::LeaveIfError( settings[i]->AddSid( applicationUid)); + } + + + CleanupStack::PopAndDestroy( &settings); +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::CleanSecurityIdForSetting() +// ----------------------------------------------------------------------------- +// + +void CRepositorySession::RestoreSettingL( const RMessage2& aMessage) +{ + using namespace IniConstants; + + __UHEAP_MARK; + + TIniFileHelper ini; + + //read setting id from RMessage + TUint32 settingUid; + TPckg settingUidPack( settingUid); + aMessage.ReadL(0, settingUidPack); + + CIndividualSetting * setting = iRepContent->FindIndividualSetting( settingUid); + + if ( !setting ) + { + User::Leave( KErrNotFound); + } + + + + User::LeaveIfError( setting->RemoveSid()); + + + __UHEAP_MARKEND; + +} + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::WriteStreamL() +// ----------------------------------------------------------------------------- +// +void CRepositoryContent::WriteStreamL( RWriteStream& aStream ) +{ + RDEBUG("CentRepTool: Streaming"); + RDEBUG("CentRepTool: initialization data"); + + //read initialization data + aStream << IniConstants::KPersistsVersion; + aStream << iUid; + aStream << iOwner; + + //write single policies + TInt32 numElements = SingleSecuritySettingsCount(); //Count + RDEBUG_2("CentRepTool: Single policies (count %d)", numElements); + aStream << numElements; + + for ( TInt i = 0; i < numElements; i++) + { + if ( iIndividualSettings[i]->ContainsSecuritySettings()) + { + iIndividualSettings[i]->ExternalizePlatSecL( aStream); + } + } + + //read range policies + numElements = iRangeSettings.Count(); + aStream << numElements; + RDEBUG_2("CentRepTool: Range policies (count %d)", numElements); + + for ( TInt i = 0; i < iRangeSettings.Count(); i++) + { + aStream << *(iRangeSettings[i]); + } + + RDEBUG("CentRepTool: Default policies"); + + //read default policies (read and write)... + aStream << (*iDefaultSetting); + + RDEBUG("CentRepTool: Default meta data"); + //read default meta + aStream << iDefaultMeta; + + //read range meta data + numElements = iRangeMetas.Count(); + RDEBUG_2("CentRepTool: Range metadata (count %d)", numElements); + aStream << numElements; + + for ( TInt i = 0; i < iRangeMetas.Count(); i++) + { + aStream << *(iRangeMetas[i]); + } + + //read time stamp + aStream << iTimeStamp.Int64(); + RDEBUG_2("CentRepTool: Timestamp %d", iTimeStamp.Int64()); + + //read setting values + numElements = iIndividualSettings.Count(); + aStream << numElements; + RDEBUG_2("CentRepTool: Individual settings (count %d)", numElements); + + for ( TInt i = 0; i < iIndividualSettings.Count(); i++) + { + iIndividualSettings[i]->ExternalizeDataL( aStream); + } + + RDEBUG("CentRepTool: Streaming finished"); +} + + +// ----------------------------------------------------------------------------- +// CRepositoryContent::SingleSecurituSettingsCount() +// ----------------------------------------------------------------------------- +// +TInt CRepositoryContent::SingleSecuritySettingsCount() +{ + return iSingleSecuritySettingCount; +} + +// ----------------------------------------------------------------------------- +// CRepositoryContent::ReadStreamL() +// ----------------------------------------------------------------------------- +// +void CRepositoryContent::ReadStreamL( RReadStream& aStream, TBool aOnlyHeader) +{ + RDEBUG("CentRepTool: Streaming"); + RDEBUG("CentRepTool: initialization data"); + + //read initialization data + TUint8 version; + aStream >> version; + aStream >> iUid; + aStream >> iOwner; + + //read single policies + TUint32 countUint32; + aStream >> countUint32; + + RDEBUG_2("CentRepTool: Single policies (count %d)", countUint32); + + for ( TInt i = 0; i < countUint32; i++) + { + CIndividualSetting* singlePolicy = new(ELeave) CIndividualSetting(); + singlePolicy->InternalizePlatSecL( aStream); + AddIndividualSettingL( singlePolicy); + } + + //read range policies + TInt32 countInt32; + aStream >> countInt32; + + RDEBUG_2("CentRepTool: Range policies (count %d)", countInt32); + + for ( TInt i = 0; i < countInt32; i++) + { + CRangeSetting* rangePolicy = new(ELeave) CRangeSetting(); + aStream >> *rangePolicy; + User::LeaveIfError( iRangeSettings.Append( rangePolicy)); + } + + + //read default policies (read and write)... + RDEBUG("CentRepTool: Default policies"); + aStream >> (*iDefaultSetting); + + //read default meta + RDEBUG("CentRepTool: Default meta data"); + aStream >> iDefaultMeta; + + //read range meta data + aStream >> countInt32; + RDEBUG_2("CentRepTool: Range metadata (count %d)", countInt32); + + for ( TInt i = 0; i < countInt32; i++) + { + CRangeMeta* rangeMeta = new(ELeave) CRangeMeta(); + aStream >> (*rangeMeta); + User::LeaveIfError( iRangeMetas.Append( rangeMeta)); + } + + //read time stamp + TInt64 timeStampInt ; + aStream >> timeStampInt ; + iTimeStamp = timeStampInt ; + RDEBUG_2("CentRepTool: Timestamp %d", iTimeStamp.Int64()); + + if ( !aOnlyHeader) + { + //read setting values + aStream >> countInt32; + RDEBUG_2("CentRepTool: Individual settings (count %d)", countInt32); + + for ( TInt i = 0; i < countInt32; i++) + { + //find setting id from stream and check is there already setting for that id + TUint32 settingId = 0; + aStream >> settingId; + CIndividualSetting* setting = FindSettingOrCreateL( settingId); + + //get setting data + setting->InternalizeDataL( aStream); + } + } + + RDEBUG("CentRepTool: Streaming finished"); +} + + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::CleanSecurityIdForRange() +// ----------------------------------------------------------------------------- +// + +void CRepositorySession::RestoreRangeL( const RMessage2& aMessage) +{ + + //read range start from RMessage + TUint32 rangeStart; + TPckg rangeStartPack( rangeStart); + aMessage.ReadL(0, rangeStartPack); + + //read range end from RMessage + TUint32 rangeEnd; + TPckg rangeEndPack( rangeEnd); + aMessage.ReadL(1, rangeEndPack); + + CRepositoryContent* romContent = ReadROMFileL( EFalse); + CleanupStack::PushL( romContent); + + for ( TInt i(0); i < iRepContent->iRangeSettings.Count(); i++) + { + CRangeSetting * setting = iRepContent->iRangeSettings[i]; + if ( setting->Type() != ERangeSetting ) + { + continue; + } + + if ( (setting->iStart > rangeStart && setting->iStart < rangeEnd ) || + (setting->iEnd > rangeStart && setting->iEnd < rangeEnd )) + { + delete setting; + iRepContent->iRangeSettings.Remove( i--); + } + } + + for ( TInt i(0); i < romContent->iRangeSettings.Count(); i++) + { + CRangeSetting * setting = romContent->iRangeSettings[i]; + if ( setting->Type() != ERangeSetting ) + { + continue; + } + + if ( (setting->iStart > rangeStart && setting->iStart < rangeEnd ) || + (setting->iEnd > rangeStart && setting->iEnd < rangeEnd )) + { + iRepContent->iRangeSettings.AppendL( setting); + romContent->iRangeSettings.Remove( i--); + } + } + + CleanupStack::PopAndDestroy( romContent); +} + + + +// ----------------------------------------------------------------------------- +// CRepositorySession::AddSidForDefaultsL() +// ----------------------------------------------------------------------------- +// + +void CRepositorySession::AddSidForDefaultsL( const RMessage2& aMessage) +{ + using namespace IniConstants; + + TIniFileHelper ini; + + //read SID from RMessage + TUid applicationUid; + TPckg applicationUidPack( applicationUid); + aMessage.ReadL(0, applicationUidPack); + + + if ( iRepContent->iDefaultSetting ) + { + iRepContent->iDefaultSetting->AddSid( applicationUid); + } + + for ( TInt i(0); i < iRepContent->iRangeSettings.Count(); i++) + { + iRepContent->iRangeSettings[i]->AddSid( applicationUid); + } + +/* for ( TInt i(0); i < iIndividualSettings.Count(); i++) + { + iIndividualSettings[i]->AddSID( applicationUid); + } +*/ +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::RestoreDefaultsL() +// ----------------------------------------------------------------------------- +// + + +void CRepositorySession::RestoreDefaultsL( const RMessage2& /*aMessage*/) +{ + using namespace IniConstants; + + CRepositoryContent* romContent = ReadROMFileL( EFalse); + CleanupStack::PushL( romContent); + + //delete RAM policies + delete iRepContent->iDefaultSetting; + iRepContent->iRangeSettings.ResetAndDestroy(); + + //..and append new policies from rom (default, range and mask policies) + iRepContent->iDefaultSetting = romContent->iDefaultSetting; + romContent->iDefaultSetting = 0; + + for ( TInt i(0); i < romContent->iRangeSettings.Count(); i++) + { + CRangeSetting * setting = romContent->iRangeSettings[i]; + iRepContent->iRangeSettings.AppendL( setting); + romContent->iRangeSettings.Remove( i--); + } + + + + CleanupStack::PopAndDestroy( romContent); + +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::SetSecurityIdForMaskL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::SetSecurityIdForMaskL( const RMessage2& aMessage ) + { + RDEBUG("CRepositorySession::SetSecurityIdForMaskL() ... "); + + //read range start from RMessage + TUint32 compareValue; + TPckg compareValuePack( compareValue ); + aMessage.ReadL(0, compareValuePack ); + + //read range end from RMessage + TUint32 mask; + TPckg maskPack( mask ); + aMessage.ReadL( 1, maskPack ); + + //read SID from RMessage + TUid applicationUid; + TPckg applicationUidPack( applicationUid ); + aMessage.ReadL( 2, applicationUidPack ); + + //Find range setting + RPointerArray settings; + CleanupClosePushL( settings ); + iRepContent->CreateMaskSettingsL( settings, compareValue, mask ); + + if( settings.Count() == 0 ) + { + RDEBUG(" **** settings count was 0 !"); + } + + //Add SIDs for setting inside of the range + for ( TInt i( 0 ); i < settings.Count(); i++ ) + { + RDEBUG_3(" Adding sid: %d/%d", i, settings.Count() ); + User::LeaveIfError( settings[ i ]->AddSid( applicationUid ) ); + } + + CleanupStack::PopAndDestroy( &settings ); + RDEBUG("CRepositorySession::SetSecurityIdForMaskL() ... DONE!"); + } + + +// ----------------------------------------------------------------------------- +// CRepositorySession::RestoreMaskL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::RestoreMaskL( const RMessage2& aMessage) +{ + __UHEAP_MARK; + + //read range start from RMessage + TUint32 compareValue; + TPckg compareValuePack( compareValue); + aMessage.ReadL(0, compareValuePack); + + //read range end from RMessage + TUint32 mask; + TPckg maskPack( mask); + aMessage.ReadL(1, maskPack); + + CRepositoryContent* romContent = ReadROMFileL( EFalse); + CleanupStack::PushL( romContent); + + //remove old mask settings + for ( TInt i(0); i < iRepContent->iRangeSettings.Count(); i++) + { + CRangeSetting * setting = iRepContent->iRangeSettings[i]; + if ( setting->Type() != EMaskSetting ) + { + continue; + } + + if ( setting->iMask == mask && setting->iStart == compareValue ) + { + delete setting; + iRepContent->iRangeSettings.Remove( i--); + } + } + + //restore original settings from rom.. + for ( TInt i(0); i < romContent->iRangeSettings.Count(); i++) + { + CRangeSetting * setting = romContent->iRangeSettings[i]; + if ( setting->Type() != EMaskSetting ) + { + continue; + } + + if ( setting->iMask == mask && setting->iStart == compareValue ) + { + iRepContent->iRangeSettings.AppendL( setting); + romContent->iRangeSettings.Remove( i--); + } + } + + CleanupStack::PopAndDestroy( romContent); + + __UHEAP_MARKEND; + + + +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::RemoveBackupForMaskL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::RemoveBackupForMaskL( const RMessage2& aMessage) +{ + //read range start from RMessage + TUint32 compareValue; + TPckg compareValuePack( compareValue); + aMessage.ReadL(0, compareValuePack); + + //read range end from RMessage + TUint32 mask; + TPckg maskPack( mask); + aMessage.ReadL(1, maskPack); + + //Find range setting + RPointerArray settings; + CleanupClosePushL( settings); + iRepContent->CreateMaskBackupL( settings, compareValue, mask); + + //Add SIDs for setting inside of the range + for ( TInt i(0); i < settings.Count(); i++) + { + //turn backup bit OFF. + TUint32& meta( settings[i]->iMeta); + meta = meta & (~KBackupBitMask); + } + + + CleanupStack::PopAndDestroy( &settings); +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::RestoreMaskBackupL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::RestoreMaskBackupL( const RMessage2& aMessage) +{ + __UHEAP_MARK; + + //read range start from RMessage + TUint32 compareValue; + TPckg compareValuePack( compareValue); + aMessage.ReadL(0, compareValuePack); + + //read range end from RMessage + TUint32 mask; + TPckg maskPack( mask); + aMessage.ReadL(1, maskPack); + + CRepositoryContent* romContent = ReadROMFileL( EFalse); + CleanupStack::PushL( romContent); + + //remove old mask settings + for ( TInt i(0); i < iRepContent->iRangeMetas.Count(); i++) + { + CRangeMeta * setting = iRepContent->iRangeMetas[i]; + if ( setting->Type() != EMaskSetting ) + { + continue; + } + + if ( setting->iMask == mask && setting->iStart == compareValue ) + { + delete setting; + iRepContent->iRangeMetas.Remove( i--); + } + } + + //restore original settings from rom.. + for ( TInt i(0); i < romContent->iRangeMetas.Count(); i++) + { + CRangeMeta * setting = romContent->iRangeMetas[i]; + if ( setting->Type() != EMaskSetting ) + { + continue; + } + + if ( setting->iMask == mask && setting->iStart == compareValue ) + { + iRepContent->iRangeMetas.AppendL( setting); + romContent->iRangeMetas.Remove( i--); + } + } + + CleanupStack::PopAndDestroy( romContent); + + __UHEAP_MARKEND; +} + + +void CRepositorySession::RemoveBackupForRangeL( const RMessage2& aMessage) +{ + //read range start from RMessage + TUint32 startValue; + TPckg startPack( startValue); + aMessage.ReadL(0, startPack); + + //read range end from RMessage + TUint32 endValue; + TPckg endPack( endValue); + aMessage.ReadL(1, endPack); + + //Find range setting + RPointerArray settings; + CleanupClosePushL( settings); + iRepContent->CreateRangeBackupL( settings, startValue, endValue); + + //Add SIDs for setting inside of the range + for ( TInt i(0); i < settings.Count(); i++) + { + //turn backup bit OFF. + TUint32& meta( settings[i]->iMeta); + meta = meta & (~KBackupBitMask); + } + + + CleanupStack::PopAndDestroy( &settings); +} + +void CRepositorySession::RestoreRangeBackupL( const RMessage2& aMessage) +{ + __UHEAP_MARK; + + //read range start from RMessage + TUint32 startValue; + TPckg startPack( startValue); + aMessage.ReadL(0, startPack); + + //read range end from RMessage + TUint32 endValue; + TPckg endPack( endValue); + aMessage.ReadL(1, endPack); + + + CRepositoryContent* romContent = ReadROMFileL( EFalse); + CleanupStack::PushL( romContent); + + //remove old mask settings + for ( TInt i(0); i < iRepContent->iRangeMetas.Count(); i++) + { + CRangeMeta * setting = iRepContent->iRangeMetas[i]; + if ( setting->Type() != EMaskSetting ) + { + continue; + } + + if ( setting->iStart == startValue && setting->iEnd == endValue ) + { + delete setting; + iRepContent->iRangeMetas.Remove( i--); + } + } + + //restore original settings from rom.. + for ( TInt i(0); i < romContent->iRangeMetas.Count(); i++) + { + CRangeMeta * setting = romContent->iRangeMetas[i]; + if ( setting->Type() != EMaskSetting ) + { + continue; + } + + if ( setting->iStart == startValue && setting->iEnd == endValue ) + { + iRepContent->iRangeMetas.AppendL( setting); + romContent->iRangeMetas.Remove( i--); + } + } + + CleanupStack::PopAndDestroy( romContent); + + __UHEAP_MARKEND; +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::RemoveDefaultBackup() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::RemoveDefaultBackup() +{ + using namespace IniConstants; + + TIniFileHelper ini; + + //turn backup bit OFF. + TUint32& meta( iRepContent->iDefaultMeta); + meta = meta & (~KBackupBitMask); + + + for ( TInt i(0); i < iRepContent->iRangeMetas.Count(); i++) + { + //turn backup bit OFF. + TUint32& meta( iRepContent->iRangeMetas[i]->iMeta); + meta = meta & (~KBackupBitMask); + + } +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::RestoreDefaultBackupL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::RestoreDefaultBackupL() +{ + using namespace IniConstants; + + CRepositoryContent* romContent = ReadROMFileL( EFalse); + CleanupStack::PushL( romContent); + + //delete RAM policies + iRepContent->iDefaultMeta = romContent->iDefaultMeta; + + for ( TInt i(0); i < romContent->iRangeMetas.Count(); i++) + { + CRangeMeta * setting = romContent->iRangeMetas[i]; + iRepContent->iRangeMetas.AppendL( setting); + romContent->iRangeMetas.Remove( i--); + } + + CleanupStack::PopAndDestroy( romContent); +} + +// ----------------------------------------------------------------------------- +// CRepositorySession::RestoreDefaultBackupL() +// ----------------------------------------------------------------------------- +// +void CRepositorySession::CheckAccessL( const RMessage2& aMessage) +{ + using namespace IniConstants; + + TUint32 settingid; + TPckg idPack( settingid); + aMessage.ReadL(0, idPack); + + TAccessType type; + TPckg atPack( type); + aMessage.ReadL(1, atPack); + + //Establish connection + TInt err = iFs.Connect(); + if( err != KErrNone ) + { + RDEBUG_2("**** CRepositorySession::CheckAccess - failed to connect to RFs: %d", err ); + } + + //delete old repositories + delete iRepContent; + iRepContent = 0; + + + //Buffer for file name (without extension) + iRepName.Zero(); + iRepName.NumFixedWidth( iRepositoryId.iUid, EHex, KUidLengthRep); + + //open repository file (only headers) + if ( KErrNone != ReadRAML( ETrue)) + { + iRepContent = ReadROMFileL( EFalse); + } + + TBool retVal = iRepContent->CheckAccess( aMessage, settingid, type); + + TPckg rvPack( retVal); + aMessage.WriteL(2, rvPack); +}