/*

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

// CONSTANTS

const TUid KUidPolicyEngineUi = { 0x10207817 };

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

// 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::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::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()

{

	ResetRequestContext();

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

				}

				CAttribute * attribute = CAttribute::NewL( aAttributeId, 

													   aAttributeValue, 

													   aDataType);

				//append attribute to attribute list

				list->AppendL( attribute);

			}

		}

		iProcessorState++;		

		SetActive();

		TRequestStatus * status = &iStatus;

		User::RequestComplete( status, KErrNone);

		return;	

	}

	if ( CPolicyEngineServer::StatusFlags()->iProcessorActive && !CPolicyEngineServer::StatusFlags()->iUiActive )

	{

		//Start new execution only if no other executions active or

		//if execution is ongoing in state

		SetActive();

		TRequestStatus * status = &iStatus;

		User::RequestComplete( status, KErrNone);

		return;		

	}

	//tell other processors that processor is reserved

	CPolicyEngineServer::StatusFlags()->iProcessorActive = ETrue;

	//make request

	TMatchResponse matchResponse;

	RDEBUG("PolicyEngineServer: RunL - start request execution");

	TRAPD( err, DoRequestExecutionL( matchResponse, EFalse));

	RDEBUG("PolicyEngineServer: RunL - stop request execution");

	if ( err != KErrNone)

	{

		matchResponse = EIndeterminate;

	}

	//set default response

	TResponse response;

	response.SetResponseValue( EResponseIndeterminate);

	//convert internal response to external response

	switch ( matchResponse )

	{

		case EDeny :

		{

			RDEBUG("PolicyEngineServer: Request executed - response deny");

			response.SetResponseValue( EResponseDeny);

			break;

		}

		case EPermit :

		{

			RDEBUG("PolicyEngineServer: Request executed - response permit");

			response.SetResponseValue( EResponsePermit);

			break;

		}

		case ENotApplicable :

		{

			RDEBUG("PolicyEngineServer: Request executed - response not applicable");

			response.SetResponseValue( EResponseNotApplicable);

			break;

		}

		case EIndeterminate :

		{

			RDEBUG("PolicyEngineServer: Request executed - response indeterminate");

			response.SetResponseValue( EResponseIndeterminate);

			break;

		}

		default:

		{

			RDEBUG("PolicyEngineServer: Request executed - response indeterminate");

			response.SetResponseValue( EResponseIndeterminate);

			break;

		}

	}	

	//tell other processors that processor is free

	CPolicyEngineServer::StatusFlags()->iProcessorActive = EFalse;

	CompleteMessage( KErrNone, response);

}

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

// CPolicyProcessor::DoCancel()

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

//

void CPolicyProcessor::DoCancel()

{

	RunError( KErrAbort);

}

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

// CPolicyProcessor::RunError()

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

//

TInt CPolicyProcessor::RunError( TInt /*aError*/)

{

	TResponse resp;

	resp.SetResponseValue( EResponseIndeterminate);

	CompleteMessage( KErrAbort, resp );

	return KErrNone;	

}

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

// CPolicyProcessor::CompleteMessage()

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

//

void CPolicyProcessor::CompleteMessage( TInt aError, TResponse aResponse)

	{

	RDEBUG_2("PolicyEngineServer: CPolicyProcessor::CompleteMessage( %d )", aError );

	delete iRequestBuffer; 	

	iRequestBuffer = NULL;

	//write response to msg (to client side)

	TPckg< TResponse> pack( aResponse);

	TRAPD( err, iMessage->WriteL(1, pack) );	

	if( err != KErrNone )

		{

		iMessage->Complete( err );

		}

	else

		{

		iMessage->Complete( aError );

		}

	RDEBUG("PolicyEngineServer: CPolicyProcessor::CompleteMessage - end");

	}

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

// CPolicyProcessor::DoRequestExecutionL()

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

//

void CPolicyProcessor::DoRequestExecutionL( TMatchResponse &aResponse, TBool iUseEditableElements)

{

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

	//get root element, execution starts from root  

	CElementBase * rootElement = 0;

	if ( iUseEditableElements )

	{

		rootElement = CPolicyStorage::PolicyStorage()->GetEditableElementL( PolicyLanguage::Constants::RootElement);

	}

	else

	{

		rootElement = CPolicyStorage::PolicyStorage()->GetElementL( PolicyLanguage::Constants::RootElement);