/*

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

		TInt err = KErrNone;

		TRAP(err, aSettings.AppendL( setting ));

		if(err != KErrNone)

		    {

		    delete setting;

			User::Leave( err );

		    }

		else

		    {

		    TRAP(err, iRangeMetas.AppendL( setting));

		    if(err != KErrNone)

		        {

		        TInt indx = aSettings.Find( setting );

		        if(indx != KErrNotFound)

		            {

		            aSettings.Remove(indx);

					User::Leave( err );

		            }

		        }

		    }

	}

}

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

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