/*

* 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 "PolicyStorage.h"

#include "PolicyEngineServer.h"

#include "ElementBase.h"

#include "XACMLconstants.h"

#include "PolicyParser.h"

#include "SettingEnforcementManager.h"

#include "debug.h"

#include "ErrorCodes.h"

#include "PolicyEnginePrivateCRKeys.h"

#include "policymnginternalpskeys.h"

#include <centralrepository.h>

#include "CentRepToolClient.h"

#include <e32property.h>

#include <s32file.h>

_LIT( KCDrive, "C:\\private\\10207815\\");

_LIT( KZDrive, "Z:\\private\\10207815\\");

_LIT( KCDriveLetter, "C:");

_LIT( KZDriveLetter, "Z:");

_LIT( KFileExtensio, ".txt");

_LIT( KBackupPath, "C:\\private\\10207815\\backup\\");

_LIT8( KEmptyBackup, "|Empty|");

_LIT( KServerIdFile, "C:\\private\\10207815\\serverids.dat");

_LIT( KServerIdFileTmp, "C:\\private\\10207815\\backup\\serverids.tmp");

const TInt KUidLength = 10;

const TInt KFileNameLength = 14;

const TChar KElementStartMark		 = '<';

const TInt KFullFileNameLength = 80;

const TInt KDriveLetterLength = 2;

// not in use anymore: KSettingSpaceLength = 100;

const TInt KCacheLimit = 100;

// ==================== LOCAL FUNCTIONS ====================

TInt CompareIDs( TUint32 const& aId1, TUint32 const& aId2)

{

	if ( aId1 == aId2) return 0;

	return ( aId1 < aId2 ? -1 : 1 );

}

TInt CompareStrings( HBufC8 const& aString1, HBufC8 const& aString2)

{

	return aString1.Compare( aString2);

}

// ================= MEMBER FUNCTIONS =======================

CPolicyStorage* CPolicyStorage::iPolicyStorage = 0;

// -----------------------------------------------------------------------------

// CPolicyStorage::CPolicyStorage()

// -----------------------------------------------------------------------------

//

CPolicyStorage::CPolicyStorage()

{

}

// -----------------------------------------------------------------------------

// CPolicyStorage::~CPolicyStorage()

// -----------------------------------------------------------------------------

//

CPolicyStorage::~CPolicyStorage()

{

	RDEBUG("CPolicyStorage::~CPolicyStorage()");

	delete iCentRep;

	delete iCentRepBackup;

	delete iParser;

	//release memory used in element cache	

	for ( TInt i(0); i < iElementCache.Count(); i++)

	{

		CElementBase * element = iElementCache[i];

		__ASSERT_ALWAYS ( element->iReferenceCount == 0, User::Panic(PolicyStoragePanic, KErrGeneral));

		delete element;

	}

	//release memory used in depricated element cache

	for ( TInt i(0); i < iDepricatedElements.Count(); i++)

	{

		CElementBase * element = iDepricatedElements[i];

		__ASSERT_ALWAYS ( element->iReferenceCount == 0, User::Panic(PolicyStoragePanic, KErrGeneral));

		delete element;

	}

	//release memory used in depricated element cache

	for ( TInt i(0); i < iEditedElements.Count(); i++)

	{

		CElementBase * element = iEditedElements[i];

		__ASSERT_ALWAYS ( element->iReferenceCount == 0, User::Panic(PolicyStoragePanic, KErrGeneral));

		delete element;

	}

	//release resources

	iElementCache.Close();

	iDepricatedElements.Close();

	iEditedElements.Close();

	iSearchedUids.Close();

	iServerIdList.ResetAndDestroy();

	iServerIdList.Close();

	iInvalidServerIds.ResetAndDestroy();

	iInvalidServerIds.Close();

	iRFs.Close();

}

// -----------------------------------------------------------------------------

// CPolicyStorage::PolicyStorage()

// -----------------------------------------------------------------------------

//

CPolicyStorage * CPolicyStorage::PolicyStorage()

{

	return iPolicyStorage;

}

// -----------------------------------------------------------------------------

// CPolicyStorage::ConstructL()

// -----------------------------------------------------------------------------

//

void CPolicyStorage::ConstructL()

{

	RDEBUG("PolicyEngineServer: CPolicyStorage::ConstructL - start");

	iCommitted = ETrue;

	//open sessions to repotories and file server

	iCentRep = CRepository::NewL( KPolicyEngineRepositoryID);

	RDEBUG("PolicyEngineServer: Connected to repository");

	iCentRepBackup = CRepository::NewL( KPolicyEngineBackupRepositoryID);

	RDEBUG("PolicyEngineServer: Connected to backup repository");

	User::LeaveIfError( iRFs.Connect() );

	//Create and set up parser

	iParser = CPolicyParser::NewL( this);

	RDEBUG("PolicyEngineServer: Policy parser created");

	iParser->SetExternalIdChecked( KNoExternalIdCheck);

	//check commit state (restore and/or delete backup if needed)

	CheckCommitStateL();

	//load server id list...

	LoadServerIdListL();

	RDEBUG("PolicyEngineServer: CPolicyStorage::ConstructL - end");

}

// -----------------------------------------------------------------------------

// CPolicyStorage::NewL()

// -----------------------------------------------------------------------------

//

CPolicyStorage * CPolicyStorage::NewL()

{

	CPolicyStorage * self = new(ELeave) CPolicyStorage();

	CleanupStack::PushL( self);

	self->ConstructL();

	CleanupStack::Pop( self);

	return self;

}

// -----------------------------------------------------------------------------

// CPolicyStorage::ReleaseElements()

// -----------------------------------------------------------------------------

//

void CPolicyStorage::ReleaseElements()

{

	RDEBUG("PolicyEngineServer: Try to release unused elements!");

	//release memory used in element cache	

	for ( TInt i(0); i < iElementCache.Count(); i++)

	{

		CElementBase * element = iElementCache[i];

		if ( element->iReferenceCount == 0)

		{

			delete element;

			iElementCache.Remove(i--);

			RDEBUG_2("PolicyEngineServer: Element removed from cache (Cache count %d)", iElementCache.Count());

		}

	}

	//release memory used in depricated element cache

	for ( TInt i(0); i < iDepricatedElements.Count(); i++)

	{

		CElementBase * element = iDepricatedElements[i];

		if ( element->iReferenceCount == 0)

		{

			delete element;

			iDepricatedElements.Remove(i--);

			RDEBUG_2("PolicyEngineServer: Element removed from cache (Depricated element count %d)", iDepricatedElements.Count());

		}

	}

}

// -----------------------------------------------------------------------------

// CPolicyStorage::SetElementL()

// -----------------------------------------------------------------------------

//

TInt CPolicyStorage::SetElementL( TUint32 aId, const TDesC8& aDescription)

{

	//resolve element file name

	TBuf<KUidLength> elementFile;

	elementFile.NumFixedWidth( aId, EDecimal, KUidLength);

	//buffer for file name (C-drive)

	TBuf<KFullFileNameLength> fileName;

	fileName.Append( KCDrive);

	fileName.Append( elementFile);

	fileName.Append( KFileExtensio);

	RDEBUG_2("PolicyEngineServer: Write element to disk (%S)", &fileName);

	MakeBackupL( fileName);

	//try open existing file

	RFile file;

	TInt err = file.Open( iRFs, fileName, EFileWrite);

	if ( err == KErrPathNotFound)

	{

		err = CreatePaths();

		//this ensures, that also element file will be created

		if ( err == KErrNone)

		{

			err = KErrNotFound;

		}

	}

	//and if file doesn't not exist create it

	if ( err == KErrNotFound  )

	{

		err = file.Create( iRFs, fileName, EFileWrite);

	}

	//write to file...

	if ( err == KErrNone)

	{

		err = file.Write( 0, aDescription);

	}

	//...and set size

	if ( err == KErrNone )

	{

		err = file.SetSize( aDescription.Length());

		if ( err == KErrNone )

		{

			err = file.Flush();

		}

	}	

	file.Close();

	RDEBUG_2("PolicyEngineServer: Write OK (%S)", &fileName);

	return err;

}

// -----------------------------------------------------------------------------

// CPolicyStorage::MakeBackUpL()

// -----------------------------------------------------------------------------

//

void CPolicyStorage::MakeBackupL( const TDesC& aFileName)

{

	//buffer for file name (C-drive)

	TBuf<KFullFileNameLength> backupName;

	backupName.Append( KBackupPath);

	backupName.Append( aFileName.Right( KFileNameLength));

	CFileMan * fileMan = CFileMan::NewL( iRFs);

	//create backup

	TInt err = fileMan->Copy( aFileName, backupName, 0);

	delete fileMan;

	//if file doesn't exist in workarea, create empty file which indicates that in original state file is not exist

	if ( err == KErrNotFound)

	{

		RFile file;

		CleanupClosePushL( file);

		User::LeaveIfError( file.Create( iRFs, backupName, EFileWrite));

		RDEBUG_2("PolicyEngineServer: Element backup: %S indicates new element in policy storage", &backupName);

		CleanupStack::PopAndDestroy( &file);

	}

	else

	{

		User::LeaveIfError( err);

		RDEBUG_3("PolicyEngineServer: Element backup: %S -> %S", &aFileName, &backupName);

	}

}

// -----------------------------------------------------------------------------

// CPolicyStorage::MakeBackUpL()

// -----------------------------------------------------------------------------

//

void CPolicyStorage::MakeBackupL( const TUint32& aSettingId)

{

	//TInt settings

	TInt value = 0;

	TInt err = iCentRep->Get( aSettingId, value);

	RDEBUG_2("PolicyEngineServer: Backup for CentRep value setting: %d", aSettingId);

	//for "empty backup"

	if ( err == KErrNotFound )

	{

		//Set backupvalue

		TInt err = iCentRepBackup->Create( aSettingId, KEmptyBackup);

		//if value is already exist, it is a original value of setting is must be saved

		if ( err == KErrAlreadyExists)

		{

			err = KErrNone;

		}

		//Leave if backupfails

		User::LeaveIfError( err);		

	}

	else

	{

		//Set backupvalue

		TInt err = iCentRepBackup->Create( aSettingId, value);

		if ( err == KErrAlreadyExists)

		{

			//if value is already exist, it is a original value of setting is must be saved

			err = KErrNone;

		}

		//Leave if backupfails

		User::LeaveIfError( err);		

	}

}

void CPolicyStorage::RestoreBackupL()

{

	//Open directory and get file list

	RDir dir;

	CleanupClosePushL( dir);

	TInt err = dir.Open( iRFs, KBackupPath, KEntryAttNormal);

	//create private and backuppaths	

	if ( err == KErrPathNotFound)

	{

		CreatePaths();

		err = dir.Open( iRFs, 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];

			//original file name

			TBuf<KFullFileNameLength> fileName;

			fileName.Append( KCDrive);

			fileName.Append( entry.iName);

			//if file size is zero, remove file from work directory

			if ( entry.iSize == 0)

			{

				RDEBUG_2("PolicyEngineServer: Restoring backup: %S removed", &fileName);

				TInt err = iRFs.Delete( fileName);

				if ( err == KErrNotFound)

				{	

					err = KErrNone;	

				}

				User::LeaveIfError( err );

			}

			else

			{

				//Create backup file name

				TBuf<KFullFileNameLength> backupName;

				backupName.Append( KBackupPath);

				backupName.Append( entry.iName);

				//otherwise copy file to work directory

				CFileMan * fileMan = CFileMan::NewL( iRFs);

				CleanupStack::PushL( fileMan);

				//Copy file to work directory

				User::LeaveIfError( fileMan->Copy( backupName, fileName));

				RDEBUG_3("PolicyEngineServer: Restoring backup: %S -> %S", &backupName, &fileName);

				CleanupStack::Pop( fileMan);  //fileMan		

			}

		}

	} while ( err == KErrNone);

	//id list 

	RArray<TUint32> ids;

	CleanupClosePushL( ids);

	//find all ids

	iCentRepBackup->FindL( 0, 0x0, ids);

	for ( TInt i(0); i < ids.Count(); i++)

	{

		TUint32 id = ids[i];

		RDEBUG_2("PolicyEngineServer: Restoring centrep setting %d", id);

		//get value

		TBuf8<200> buffer;

		TInt err = iCentRepBackup->Get( id, buffer);

		if ( err != KErrNone)

		{

			TInt value = 0;

			User::LeaveIfError( iCentRepBackup->Get( id, value));

			User::LeaveIfError( iCentRep->Set( id, value));

		}

		else

		{

			if ( buffer == KEmptyBackup)

			{

				User::LeaveIfError( iCentRep->Delete( id));

			}

			else

			{

				User::LeaveIfError( iCentRep->Set( id, buffer));

			}

		}

	}

	CleanupStack::PopAndDestroy(2, &dir);	//RArray<TUint32>, RDir

}

// -----------------------------------------------------------------------------

// CPolicyStorage::RemoveBackupL()

// -----------------------------------------------------------------------------

//

void CPolicyStorage::RemoveBackupL()

{

	//Open directory and get file list

	RDir dir;

	CleanupClosePushL( dir);

	TInt err = dir.Open( iRFs, KBackupPath, KEntryAttNormal);

	//create private and backuppaths	

	if ( err == KErrPathNotFound)

	{

		CreatePaths();

		err = dir.Open( iRFs, 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<KFullFileNameLength> backupName;

			backupName.Append( KBackupPath);

			backupName.Append( entry.iName);