/*

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

#include "PolicyStorage.h"

#include "PolicyParser.h"

#include "elements.h"

#include "ElementBase.h"

#include "DataTypes.h"

#include "ErrorCodes.h"

#include "TrustedSession.h"

#include "XACMLconstants.h"

#include "PolicyEngineServer.h"

#include "PolicyEngineClientServer.h"

#include "debug.h"

#include <hbdevicedialogsymbian.h>

#include <hbdevicenotificationdialogsymbian.h>

#include <hbtextresolversymbian.h>

// CONSTANTS

const TUid KUidPolicyEngineUi = { 0x10207817 };

const TUint KDelimeterChar = '|';

_LIT8( KUserAcceptMark, "A");

enum TUserResponse

    {

    EUserAccept,

    EUserDeny,

    };

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

// RAttributeContainer::AppendL()

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

//

void RAttributeContainer::AppendL( AttributeContainerHelper::TAttributeTypes aAttributeTypes, CAttribute* aAttribute)

{

	//temporary to cleanup stack

	CleanupStack::PushL( aAttribute);

	//create container for attribute

	AttributeContainerHelper::TContainer * container = new (ELeave) AttributeContainerHelper::TContainer;

	CleanupStack::PushL( container);

	//set container properties

	container->iAttribute = aAttribute;

	container->iAttributeType = aAttributeTypes; 

	//append to list

	RArray<AttributeContainerHelper::TContainer*>::AppendL( container);

	//remove from cleanup

	CleanupStack::Pop( 2, aAttribute);

}

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

// RAttributeContainer::Close()

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

//

void RAttributeContainer::Close()

{

	//delete attributes and container...

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

	{

		AttributeContainerHelper::TContainer * container = operator[]( i);

		delete container->iAttribute;

		delete container;

	}

	RArray<AttributeContainerHelper::TContainer*>::Close();

}

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

// CPolicyProcessor::CPolicyProcessor()

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

//

CPolicyProcessor::CPolicyProcessor()

	: CActive( EPriorityStandard)

{

}

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

// CPolicyProcessor::NewL()

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

//

CPolicyProcessor * CPolicyProcessor::NewL()

{

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

	CleanupStack::PushL( self);

	self->ConstructL();

	CleanupStack::Pop( self);

	return self;

}

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

// CPolicyProcessor::~CPolicyProcessor()

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

//

CPolicyProcessor::~CPolicyProcessor()

	delete iRequestBuffer;

	CPolicyEngineServer::RemoveActiveObject( this);

}

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

// CPolicyProcessor::ConstructL()

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

//

void CPolicyProcessor::ConstructL()

{

	CPolicyEngineServer::AddActiveObjectL( this);

}

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

// CPolicyProcessor::HandleErrorL()

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

//

void CPolicyProcessor::HandleErrorL( const TDesC8& aText	)

{

	RDEBUG("CPolicyProcessor::HandleErrorL");

	//error handling for processor

	RDEBUG_2("XACML request indeterminate: %S", &aText);

	User::Leave( KErrAbort);	

}

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

// CPolicyProcessor::ResetRequestContext()

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

//

void CPolicyProcessor::ResetRequestContext()

{

	if ( iDeleteAttributes )

	{

		//delete subject attributes and closes RArray

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

		{

			CAttribute * attribute = iSubjects[i];

			delete attribute;

		}

		//delete actions attributes and closes RArray

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

		{

			CAttribute * attribute = iActions[i];

			delete attribute;

		}

		//delete resources attributes and closes RArray

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

		{

			CAttribute * attribute = iResources[i];

			delete attribute;

		}

		//delete environments attributes and closes RArray

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

		{

			CAttribute * attribute = iEnvironments[i];

			delete attribute;

		}

	}

	iSubjects.Close();

	iActions.Close();

	iResources.Close();

	iEnvironments.Close();

}

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

// CPolicyProcessor::ResetRequestContext()

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

//

TPtrC8 CPolicyProcessor::NextToken( TPtrC8& aText)

{

	if ( !aText.Length() ) return aText;

	//remove first delimiter

	if ( aText[0] == KMessageDelimiterChar)

	{

		aText.Set( aText.Mid(1));

	}

	//find next delimiter

	TPtrC8 retVal = aText;

	TInt index = aText.Locate( KMessageDelimiterChar);		    	

	if ( index != KErrNotFound )

	{

		//set retVal to point token and aText to remaining part

		retVal.Set( aText.Left( index));

		aText.Set( aText.Mid( index ));

	}

	return retVal;

}

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

// CPolicyProcessor::ExecuteRequestL()

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

//

void CPolicyProcessor::ExecuteRequestL( RAttributeContainer &aAttributes, TMatchResponse &aResponse)

{

	iDeleteAttributes = EFalse;

	iUseEditedElements = ETrue;

	//reset request context

	ResetRequestContext();

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

	{

		RAttributeList * list = 0;

		using namespace AttributeContainerHelper;

		TContainer * container = aAttributes[i];

		switch ( container->iAttributeType )

		{

			case ESubjectAttributes :

			{

				list = &iSubjects;

				break;		

			}

			case EActionAttributes :

			{

				list = &iActions;

				break;		

			}

			case EResourceAttributes :

			{

				list = &iResources;

				break;		

			}

			case EEnvironmentAttributes :

			{

				list = &iEnvironments;

				break;		

			}

			default:

				User::Panic( PolicyParserPanic, KErrCorrupt);

			break;

		}

		//append attribute to attribute list

		list->AppendL( container->iAttribute);

	}

	//make request

	DoRequestExecutionL( aResponse, ETrue);

}

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

// CPolicyProcessor::ExecuteRequestL()

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

//

void CPolicyProcessor::ExecuteRequestL( const RMessage2& aMessage)

{

	iUseEditedElements = EFalse;

	iDeleteAttributes = ETrue;

	RDEBUG("PolicyEngineServer: CPolicyProcessor::ExecuteRequestL");

	//reset request context

	ResetRequestContext();

	iMessage = &aMessage;

	iProcessorState = 0;

	//Add object to active scheduler

	if ( !IsAdded())

	{

		CActiveScheduler::Add( this);

	}

	//complete own request

	SetActive();

	TRequestStatus * status = &iStatus;

	User::RequestComplete( status, KErrNone);

}

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

// CPolicyProcessor::RunL()

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

//

void CPolicyProcessor::RunL()

{

	RDEBUG("PolicyEngineServer: CPolicyProcessor::RunL");

	CPolicyEngineServer::SetActiveSubSession( this);	

	if ( iProcessorState == 0)

	{

		//Read request context from client

		delete iRequestBuffer;

		iRequestBuffer = NULL;

		iRequestBuffer = HBufC8::NewL( iMessage->GetDesLength(0));

		TPtr8 msg = iRequestBuffer->Des();

		iMessage->ReadL(0, msg, 0);	

		TPtrC8 ptr = msg;

		TBool continueLoop( ETrue);

		//read msg from client, msg contain request attributes

		while ( continueLoop )

		{

			TPtrC8 type = NextToken( ptr);	

			RAttributeList * list;

			//identifie attribute type (subject, action, resource or env)

			if ( type == _L8("S"))

			{

				list = &iSubjects;

			}

			else

			if ( type == _L8("A"))

			{

				list = &iActions;

			}

			else

			if ( type == _L8("R"))

			{

				list = &iResources;

			}

			else

			if ( type == _L8("E"))

			{

				list = &iEnvironments;

			}

			else

			{

				//no more attributes

				continueLoop = EFalse;

			}

			if ( continueLoop )

			{

				//read attribute id, value and datatype

				TPtrC8 aAttributeId( NextToken( ptr));

				TPtrC8 aAttributeValue( NextToken( ptr));

				TPtrC8 aDataType( CPolicyParser::ConvertValues( EXACML, NextToken( ptr)));

				//types, which contains default values must be converted to native language

				if ( aDataType == PolicyLanguage::NativeLanguage::AttributeValues::BooleanDataType )

				{

					aAttributeValue.Set( CPolicyParser::ConvertValues( EXACML, aAttributeValue));

				}