/*

* Copyright (c) 2000 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

*

*/

// INCLUDES

#ifdef __TARM_SYMBIAN_CONVERGENCY

 #include <devman.h>

 #include <dmtreenode.h>

#else

 #include <nsmldmdbhandler.h>

#endif

#include "ACLStorage.h"

#include "debug.h"

// CONSTANTS

_LIT( KStorageFile, "C:\\private\\10207843\\aclnodes.ini");

_LIT( KStorageTempFile, "C:\\private\\10207843\\aclnodes.tmp");

_LIT( KStorageBackupFile, "C:\\private\\10207843\\aclnodes.bak");

#ifdef __TARM_SYMBIAN_CONVERGENCY

_LIT8(KNSmlDmAclAddEqual, "Add=");

_LIT8(KNSmlDmAclGetEqual, "Get=");

_LIT8(KNSmlDmAclDeleteEqual, "Delete=");

_LIT8(KNSmlDmAclReplaceEqual, "Replace=");

_LIT8(KNSmlDmAclSeparator, "&");

_LIT8(KNSmlDmAclExecEqual, "Exec=");

#else

 const TInt KStatusRef = 0;

 const TInt KResultRef = 1;

#endif

namespace

{

	TBool CompareCertInfos( const TCertInfo& aCertInfo1, const TCertInfo& aCertInfo2)

	{

		TBool retVal = ( aCertInfo1.iSerialNo == aCertInfo2.iSerialNo ) &&

					   ( aCertInfo1.iFingerprint == aCertInfo2.iFingerprint ) &&	

					   ( aCertInfo1.iIssuerDNInfo.iCommonName == aCertInfo2.iIssuerDNInfo.iCommonName ) &&	

					   ( aCertInfo1.iIssuerDNInfo.iCountry == aCertInfo2.iIssuerDNInfo.iCountry ) &&	

					   ( aCertInfo1.iIssuerDNInfo.iLocality == aCertInfo2.iIssuerDNInfo.iLocality ) &&	

					   ( aCertInfo1.iIssuerDNInfo.iOrganization == aCertInfo2.iIssuerDNInfo.iOrganization ) &&	

					   ( aCertInfo1.iIssuerDNInfo.iOrganizationUnit == aCertInfo2.iIssuerDNInfo.iOrganizationUnit );

		return retVal;

	}

	TBool CompareCommands( const CCommand& aCommand1, const CCommand& aCommand2)

	{

		TBool match = EFalse;

		if ( aCommand1.iCommand == aCommand2.iCommand)

		{

			if ( aCommand1.iServerId && *aCommand1.iServerId == *aCommand2.iServerId)

			{

				match = ETrue;	

			}

			else

			{

				//Compare certficates

				match = CompareCertInfos( aCommand1.iCertInfo, aCommand2.iCertInfo); 

			}

		}

		return match;

	}	

}

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

// CCommand::NewL()

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

CCommand* CCommand::NewL( const TCertInfo& aCertInfo, const TAclCommands& aCommand)

{

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

	self->iCertInfo = aCertInfo;

	self->iCommand = aCommand;

	return self;

}

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

// CCommand::NewL()

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

CCommand* CCommand::NewL( const TDesC8& aServerUid, const TAclCommands& aCommand)

{

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

	CleanupStack::PushL( self);	

	self->iServerId = aServerUid.AllocL();

	self->iCommand = aCommand;

	CleanupStack::Pop( self);	

	return self;	

}

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

// CCommand::NewL()

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

void CCommand::CommandString( TDes8& aStr)

{

	switch ( iCommand)

	{

		case EACLAdd:

			aStr.Append( KNSmlDmAclAddEqual);

		break;

		case EACLDelete:

			aStr.Append( KNSmlDmAclDeleteEqual);

		break;

		case EACLExec:

			aStr.Append( KNSmlDmAclExecEqual);

		break;

		case EACLGet:

			aStr.Append( KNSmlDmAclGetEqual);

		break;

		case EACLReplace:

			aStr.Append( KNSmlDmAclReplaceEqual);

		break;

		default:

		break;

	}

	aStr.Append( *iServerId);

}

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

// CCommand::Length()

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

TInt CCommand::Length()

{

	//Calculate serialized command length 

	TPckg<TCertInfo> certPck( iCertInfo);

	TPckg<TAclCommands> cmdPck( iCommand);

	return 	certPck.Length() + cmdPck.Length();

}

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

// CCommand::SaveStringL()

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

HBufC8 * CCommand::SaveStringL()

{

	//Create buffer for string

	HBufC8 * buf = HBufC8::NewL( Length());

	TPtr8 ptr = buf->Des();

	//create descriptor packs

	TPckg<TCertInfo> certPck( iCertInfo);

	TPckg<TAclCommands> cmdPck( iCommand);

	//add serialized data to buffer

	ptr.Append( certPck);

	ptr.Append( cmdPck);

	return buf;

}

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

// CCommand::LoadFromStringL()

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

CCommand * CCommand::LoadFromStringL( TPtrC8& aString)

{

	CCommand * command = new (ELeave) CCommand();

	TPtrC8 ptr( aString);

	//Certificate 

	TPckg<TCertInfo> certPck( command->iCertInfo);

	certPck.Copy( ptr.Ptr(), certPck.Length());

	ptr.Set( ptr.Mid( certPck.Length()));	

	//Commands

	TPckg<TAclCommands> cmdPck( command->iCommand);

	cmdPck.Copy( ptr.Ptr(), cmdPck.Length());

	ptr.Set( ptr.Mid( cmdPck.Length()));	

	return command;	

}

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

// CACLNode::CACLNode()

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

CACLNode::CACLNode()

	: iURI(0)

{	

}

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

// CACLNode::CACLNode()

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

CACLNode::~CACLNode()

{

	delete iURI;

	iCommands.Close();	

}

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

// CACLNode::CompareElements()

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

TInt CACLNode::CompareElements( CACLNode const& aNode1, CACLNode const& aNode2)

{

	RDEBUG("CACLNode::CompareElements()");

	RDEBUG8_2("	-> Node1 URI = %S", &aNode1.iURIPtr );

	RDEBUG8_2("	-> Node2 URI = %S", &aNode2.iURIPtr );

	TInt result = (aNode1.iURIPtr).Compare( aNode2.iURIPtr);

	RDEBUG_2("	-> comparison result = %d", result);

	return result;

}

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

// CACLNode::FindCorrespondingCommand()

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

CCommand* CACLNode::FindCorrespondingCommand( const CCommand* aCommand)

{

	CCommand* retVal = 0;

	//find corresponding command from command list

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

	{

		CCommand* command = iCommands[i];

		if ( CompareCommands( *command, *aCommand))

		{

			retVal = command;

			break;

		}

	}

	return retVal;

}

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

// CACLNode::GetNodeACLStringL()

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

HBufC8 * CACLNode::GetNodeACLStringL()

{

	RDEBUG("CACLNode::GetNodeACLStringL()");

	HBufC8 * buf = HBufC8::NewL( iCommands.Count() * 21);

	TPtr8 ptr = buf->Des();

	for ( TInt i(0); i < iCommands.Count();)

	{

		TBuf8<30> command;

		iCommands[i++]->CommandString( command);

		ptr.Append( command);

		if ( i != iCommands.Count() )

		{

			ptr.Append(KNSmlDmAclSeparator);

		}

	}

	return buf;

}

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

// CACLNode::SetURIL()

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

void CACLNode::SetURIL( const TDesC8& aURI )

{

	delete iURI;

	iURI = NULL;

	iURIPtr.Set( KNullDesC8);

	iURI = aURI.AllocL();

	iURIPtr.Set( *iURI);

}

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

// CACLNode::ClearACL()

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

void CACLNode::ClearACL()

{

	//find all command which concern specific command remove them from list

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

	{

#ifdef _DEBUG

			TBuf8<30> command;

			iCommands[i]->CommandString( command);

			RDEBUG8_2("DMUtilServer: Remove command %S", &command);

#endif //_DEBUG

		delete iCommands[i];

		iCommands.Remove( i--);

	}

}

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

// CACLNode::SetServerIdToACLL()

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

void CACLNode::SetServerIdToACLL( const TAclCommands& aCommandType, const TDesC8& aServerId)

{

	RDEBUG("CACLStorage::SetServerIdToACLL()");

	//check first that command isn't already exist

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

	{

		CCommand * command = iCommands[i];

		if ( (command->iCommand == aCommandType || aCommandType == EACLAll )

			 && *command->iServerId == aServerId)

		{

			return;

		}

	}

	//and if command is new, create new CCommand for it

	CCommand * command = CCommand::NewL( aServerId, aCommandType);

	CleanupStack::PushL( command);

	iCommands.AppendL( command);

	CleanupStack::Pop( command);

#ifdef _DEBUG

	TBuf8<30> commandStr;

	command->CommandString( commandStr);

	RDEBUG8_2("DMUtilServer: New command %S", &commandStr);

#endif //_DEBUG	

}

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

// CACLNode::Length()

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

TInt CACLNode::Length()

{

	TInt testvalue;

	TPckgC<TInt> valueLength( testvalue);

	TPckgC<TACLDestination> destLength( iDestination);

	TInt size = valueLength.Length() * 2 + destLength.Length() + iURI->Length();

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

	{

		size += iCommands[i]->Length();

	}

	RDEBUG_2("DMUtilServer: CACLNode::Length - End (returned size: %d)", size);

	return size;

}

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

// CACLNode::SaveStringL()

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

HBufC8 * CACLNode::SaveStringL()

{

	RDEBUG("DMUtilServer: CACLNode::SaveStringL - Start");

	//create buffer for string

	HBufC8* buf = HBufC8::NewL( Length());

	TPtr8 ptr = buf->Des();

	//clearflag

	TPckgC<TInt> flagPck( iClearFlag);

	ptr.Append( flagPck);

	//destPack

	TPckgC<TACLDestination> destPck( iDestination);

	ptr.Append( destPck);

	//uri

	TInt uriLength( iURI->Length());

	TPckgC<TInt> uriPck( uriLength);

	ptr.Append( uriPck);

	ptr.Append( *iURI);

	//append commands to string

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

	{

		//get command save string

		HBufC8* buf = iCommands[i]->SaveStringL();

		ptr.Append( *buf);

		delete buf;

	}

	RDEBUG("DMUtilServer: CACLNode::SaveStringL - End");

	return buf;

}

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

// CACLNode::LoadFromStringL()

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

CACLNode * CACLNode::LoadFromStringL( TDes8& aString)

{

	RDEBUG("DMUtilServer: CACLNode::LoadFromStringL - Start");

	CACLNode * node = new (ELeave) CACLNode();

	TPtrC8 ptr( aString);

	//Clear flag

	TPckg<TInt> flagPck( node->iClearFlag);

	flagPck.Copy( ptr.Ptr(), flagPck.Length());

	ptr.Set( ptr.Mid( flagPck.Length()));	

	//destPack

	TPckg<TACLDestination> destPck( node->iDestination);

	destPck.Copy( ptr.Ptr(), destPck.Length());

	ptr.Set( ptr.Mid( destPck.Length()));	

	//get uri length

	TInt uriLength;

	TPckg<TInt> intPck( uriLength);

	intPck.Copy( ptr.Ptr(), intPck.Length());

	ptr.Set( ptr.Mid( intPck.Length()));	

	//get URI and save it to node

	node->iURI = HBufC8::NewL( uriLength);

	node->iURI->Des().Copy( ptr.Ptr(), uriLength);

	node->iURIPtr.Set( *(node->iURI));

	ptr.Set( ptr.Mid( uriLength));	

	TInt len( ptr.Length() );

	while ( len )

	{

		//Read buffer

		CCommand * command = CCommand::LoadFromStringL( ptr);

		//Set Pointer	

		ptr.Set( ptr.Mid( command->Length()));	

		len = ptr.Length();

		//append readen command to command list

		CleanupStack::PushL( command);

		node->iCommands.AppendL( command);

		CleanupStack::Pop( command);

	}	

	RDEBUG("DMUtilServer: CACLNode::LoadFromStringL - End");

	return node;

}

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

// CACLNode::SetCertificateToACLL()

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

void CACLNode::SetCertificateToACLL( const TACLDestination& aDestination, const TAclCommands& aCommandType, const TCertInfo& aCertInfo)

{

	RDEBUG("DMUtilServer: CACLNode::SetCertificateToACLL - Start");

	//check first that command isn't already exist

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

	{

		CCommand * command = iCommands[i];

		if ( (command->iCommand == aCommandType || aCommandType == EACLAll )

			 && CompareCertInfos( command->iCertInfo, aCertInfo ))

		{

			return;

		}

	}

	//and if command is new, create new CCommand for it

	CCommand * command = CCommand::NewL( aCertInfo, aCommandType);

	CleanupStack::PushL( command);

	iCommands.AppendL( command);

	CleanupStack::Pop( command);

	iDestination = aDestination;

	RDEBUG("DMUtilServer: CACLNode::SetCertificateToACLL - End");

}

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

// CACLNode::CreateACLL()

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

CACLNode * CACLNode::CreateACLL( const TDesC8& aACLString)

{

	RDEBUG("DMUtilServer: CACLNode::CreateACLL - Start");

	//Create ACL node

	CACLNode * node = new (ELeave) CACLNode();

	TPtrC8 ptr( aACLString);

	TInt err( KErrNone);

	//decode acl string

	while ( ptr.Length() && err == KErrNone)