--- /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 <centralrepository.h>
+#include <s32file.h>
+
+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<CRangeSetting> 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<CRangeMeta>& 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<CRangeMeta>& 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<CRangeMeta> 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<CRangeSetting>& 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<CRangeSetting> 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<CRangeSetting>& 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<CIndividualSetting> 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<CIndividualSetting> 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<KPathLength> backupFile;
+ backupFile.Append( KBackupPath);
+ TBuf<KPathLength> 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<KPathLength> 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<KPathLength> 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<KPathLength> 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<KPathLength> 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<KPathLength> 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<KPathLength> 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<KPathLength> 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<KPathLength> 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<TUint32> settingUidPack( settingUid);
+ aMessage.ReadL(0, settingUidPack);
+
+ //read SID from RMessage
+ TUid applicationUid;
+ TPckg<TUid> 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<TUint32> rangeStartPack( rangeStart);
+ aMessage.ReadL(0, rangeStartPack);
+
+ //read range end from RMessage
+ TUint32 rangeEnd;
+ TPckg<TUint32> rangeEndPack( rangeEnd);
+ aMessage.ReadL(1, rangeEndPack);
+
+ //read SID from RMessage
+ TUid applicationUid;
+ TPckg<TUid> applicationUidPack( applicationUid);
+ aMessage.ReadL(2, applicationUidPack);
+
+
+ //Find range setting
+ RPointerArray<CRangeSetting> 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<TUint32> 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<TUint32> rangeStartPack( rangeStart);
+ aMessage.ReadL(0, rangeStartPack);
+
+ //read range end from RMessage
+ TUint32 rangeEnd;
+ TPckg<TUint32> 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<TUid> 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<TUint32> compareValuePack( compareValue );
+ aMessage.ReadL(0, compareValuePack );
+
+ //read range end from RMessage
+ TUint32 mask;
+ TPckg<TUint32> maskPack( mask );
+ aMessage.ReadL( 1, maskPack );
+
+ //read SID from RMessage
+ TUid applicationUid;
+ TPckg<TUid> applicationUidPack( applicationUid );
+ aMessage.ReadL( 2, applicationUidPack );
+
+ //Find range setting
+ RPointerArray<CRangeSetting> 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<TUint32> compareValuePack( compareValue);
+ aMessage.ReadL(0, compareValuePack);
+
+ //read range end from RMessage
+ TUint32 mask;
+ TPckg<TUint32> 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<TUint32> compareValuePack( compareValue);
+ aMessage.ReadL(0, compareValuePack);
+
+ //read range end from RMessage
+ TUint32 mask;
+ TPckg<TUint32> maskPack( mask);
+ aMessage.ReadL(1, maskPack);
+
+ //Find range setting
+ RPointerArray<CRangeMeta> 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<TUint32> compareValuePack( compareValue);
+ aMessage.ReadL(0, compareValuePack);
+
+ //read range end from RMessage
+ TUint32 mask;
+ TPckg<TUint32> 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<TUint32> startPack( startValue);
+ aMessage.ReadL(0, startPack);
+
+ //read range end from RMessage
+ TUint32 endValue;
+ TPckg<TUint32> endPack( endValue);
+ aMessage.ReadL(1, endPack);
+
+ //Find range setting
+ RPointerArray<CRangeMeta> 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<TUint32> startPack( startValue);
+ aMessage.ReadL(0, startPack);
+
+ //read range end from RMessage
+ TUint32 endValue;
+ TPckg<TUint32> 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<TUint32> idPack( settingid);
+ aMessage.ReadL(0, idPack);
+
+ TAccessType type;
+ TPckg<TAccessType> 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<TBool> rvPack( retVal);
+ aMessage.WriteL(2, rvPack);
+}