/*

* 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

#include "elements.h"

#include "PolicyParser.h"

#include "XACMLconstants.h"

#include "DataTypes.h"

#include "PolicyProcessor.h"

#include "PolicyStorage.h"

#include "ErrorCodes.h"

#include "debug.h"

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

// RContentBuilder::RContentBuilder()

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

//

RContentBuilder::RContentBuilder()

	: RPointerArray<HBufC8>(), iSize(0)

	{	

	}

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

// RContentBuilder::AddContentL()

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

//

void RContentBuilder::AddContentL( HBufC8 * aBuffer)

	{

	//Append buffer to pointer array

	CleanupStack::PushL( aBuffer);

	User::LeaveIfError( Append( aBuffer));

	CleanupStack::Pop( aBuffer);

	//calculate new total size

	iSize += aBuffer->Length();

	}

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

// RContentBuilder::ContentL()

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

//

HBufC8 * RContentBuilder::ContentL()

	{

	//create buffer for new content

	HBufC8 * buffer = HBufC8::NewL( iSize);		

	TPtr8 ptr = buffer->Des();

	//and append content of pointer array to buffer (step by step)

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

		{

		ptr.Append( *operator[]( i));

		}

	//return buffer

	return buffer;

	}

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

// RContentBuilder::ContentLC()

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

//

HBufC8 * RContentBuilder::ContentLC()

	{

	//create buffer and push it to cleanupstack

	HBufC8 * buffer = ContentL();

	CleanupStack::PushL( buffer);

	//return buffer

	return buffer;

	}

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

// RContentBuilder::Close()

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

//

void RContentBuilder::Close()

	{

	//destroy pointer array content

	ResetAndDestroy();

	//and close array (parent class)

	RPointerArray<HBufC8>::Close();

	}

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

// CApply::CApply()

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

//

CApply::CApply()

	{	

	iElementType = EApply;

	iElementName.Set( PolicyLanguage::NativeLanguage::Expressions::Apply);

	iSaveType = ESubElement;	

	}

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

// CApply::~CApply()

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

//

CApply::~CApply()

{

	delete iResponseValue;

	delete iFunctionId;

}

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

// CApply::NewL()

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

//

CApply * CApply::NewL()

{

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

	CleanupStack::PushL( self);

	self->ConstructL();

	CleanupStack::Pop ( self);

	return self;

}

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

// CApply::ConstructL()

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

//

void CApply::ConstructL()

{

	iResponseValue = CAttributeValue::NewL();

}

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

// CApply::IdentificateType()

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

//

TBool CApply::IdentificateType( const TDesC8& aElementName)

{

	return ( aElementName == PolicyLanguage::NativeLanguage::Expressions::Apply);			

}

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

// CApply::DecodeElementL

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

//

HBufC8 * CApply::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode)

{

	RDEBUG("PolicyEngineServer: Decode Apply element");

	__ASSERT_ALWAYS ( iFunctionId, User::Panic(PolicyParserPanic, KErrCorrupt));

	//reserve all...

	CheckAllElementsL();

	TElementReserver reserver( Container());

	TInt size = 9;

	size += 2 * PolicyLanguage::Expressions::Apply[ aLanguage].Length();

	size += PolicyLanguage::Expressions::FunctionId[ aLanguage].Length();

	const TDesC8& functionId = SelectCorrectValue( aLanguage, *iFunctionId);

	size += functionId.Length();

	RContentBuilder builder;

	CleanupClosePushL( builder);

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

	{

		CElementBase * element = Element(i);

		if ( element->ElementType() == EApply )

		{

			builder.AddContentL( DecodeElementOrIdL( aLanguage, element, aMode));

		}

		else

		{

			builder.AddContentL( DecodeElementOrIdL( aLanguage, element, EFullMode));

		}

	}	

	HBufC8* applies	= builder.ContentL();

	CleanupStack::PopAndDestroy( &builder);

	CleanupStack::PushL( applies);

	if (applies) size += applies->Length();

	HBufC8 * hbuf = HBufC8::NewLC( size);

	TPtr8 ptr = hbuf->Des();

	ptr.Append('<');

	ptr.Append(PolicyLanguage::Expressions::Apply[ aLanguage]);

	ptr.Append(' ');

	ptr.Append(PolicyLanguage::Expressions::FunctionId[ aLanguage]);

	ptr.Append( _L8("=\""));

	ptr.Append( functionId);

	ptr.Append( _L8("\">"));

	if (applies) ptr.Append(*applies);	

	ptr.Append(_L8("</"));

	ptr.Append(PolicyLanguage::Expressions::Apply[ aLanguage]);

	ptr.Append('>');											   

	CleanupStack::Pop( hbuf);

	CleanupStack::PopAndDestroy( applies);

	reserver.Release();

	return hbuf;

}

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

// CApply::AddAttributeL

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

//

void CApply::AddAttributeL( CPolicyParser *aParser, const TDesC8& aName, const TDesC8& aValue)

{

	if ( aName == PolicyLanguage::NativeLanguage::Expressions::FunctionId)

	{

		aParser->HandleErrorL( iFunctionId , ParserErrors::UnexpectedAttribute, aName);	

		iFunctionId = aValue.AllocL();

		aParser->CheckFunctionIdL( EApply, *iFunctionId);

	}

	else

	{

		aParser->HandleErrorL( ParserErrors::UnexpectedAttribute, aName );	

	}	

}

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

// CApply::AddElementL

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

//

void CApply::AddElementL( CPolicyParser *aParser, CElementBase * aElement)

{

	TNativeElementTypes type = aElement->ElementType();

	if ( type == EApply ||

		 type == EAttributeValue ||

		 type == ESubjectAttributeDesignator ||  

		 type == EEnvironmentAttributeDesignator ||

		 type == EResourceAttributeDesignator ||

		 type == EActionAttributeDesignator ) 

	{

		AddToElementListL( aElement, ETrue);

	}

	else

	{	

		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());

	}	

}

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

// CApply::AddIdElementL

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

//

void CApply::AddIdElementL( CElementBase * aElement)

{

	__ASSERT_ALWAYS ( aElement, User::Panic(PolicyParserPanic, KErrCorrupt));

	AddToElementListL( aElement, EFalse);	

}

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

// CApply::ValidElement

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

//

TBool CApply::ValidElement()

{

	TBool returnValue = EFalse;

	//function id is needed...

	if ( iFunctionId)

	{

		returnValue = FunctionHelper::IsAcceptableParamsForFunction( *iFunctionId, Container());

	}

	return returnValue;

}

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

// CApply::ApplyValueL

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

//

CAttributeValue * CApply::ApplyValueL( CPolicyProcessor* aPolicyProcessor)

{

#ifndef __POLICY_BASE_CREATOR_TOOL

	//reserve elements

	CheckAllElementsL();

	TElementReserver reserver( Container());

	//create parameter list add it cleanup stack

	RParameterList params;

	CleanupClosePushL( params);

	//search attributedesignators and apply elements

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

	{

		CElementBase * element = Element( i);

		switch ( element->ElementType())

		{

			case EApply:

			{

				//get parameter value from apply-element and append it parameter list

				params.AppendL( ((CApply*)element)->ApplyValueL( aPolicyProcessor));

			}

			break;

			case ESubjectAttributeDesignator:

			case EEnvironmentAttributeDesignator:

			case EResourceAttributeDesignator:

			case EActionAttributeDesignator:

			{

				//get parameter value from request context (via attribute designators)			

				CAttribute* attribute = ((CAttributeDesignator*) element)->GetAttributeFromRequestContext( aPolicyProcessor);

				if( attribute )

					{

					params.AppendL( attribute->AttributeValue());

					}

				if ( !attribute) 

					{

					RDEBUG("PolicyEngineServer: PolicyProcessor: attribute not found");	

				//	aPolicyProcessor->HandleErrorL( RequestErrors::MissingAttribute );

					}

				//append value to paramer list

				//params.AppendL( attribute->AttributeValue());

			}

			break;

			case EAttributeValue:

			{

				//attribute value is valid parameter type

				params.AppendL( (CAttributeValue*)element);

			}

			break;

			default:

				User::Panic( Panics::PolicyExecutionPanic, KErrAbort);

			break;

		}

	}

	//execute function

	aPolicyProcessor->FunctionL( *iFunctionId, params, iResponseValue );

	CleanupStack::PopAndDestroy( &params);	//params.Close()

	reserver.Release();

	return iResponseValue;

#endif //#ifndef __POLICY_BASE_CREATOR_TOOL

}

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

// CApply::ReturnDataType

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

//

const TPtrC8 CApply::ReturnDataType()

{

	__ASSERT_ALWAYS ( iFunctionId, User::Panic(PolicyParserPanic, KErrCorrupt));

	using namespace PolicyLanguage::NativeLanguage::Functions;

	TPtrC8 ptr;

	//set return data tpye

	if ( *iFunctionId == FunctionStringEqualId ||

		 *iFunctionId == FunctionBooleanEqualId ||

		 *iFunctionId == FunctionOr ||

		 *iFunctionId == FunctionAnd ||

		 *iFunctionId == FunctionNot ||

		 *iFunctionId == FunctionCertificatedSession ||

		 *iFunctionId == FunctionUserAcceptCorpPolicy ||

		 *iFunctionId == FunctionRuleTargetStructure )

	{

		ptr.Set( PolicyLanguage::NativeLanguage::AttributeValues::BooleanDataType);

	}

	return ptr;

}

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

// CCondition::CCondition

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

//

CCondition::CCondition()

{

	iElementType = ECondition;

	iElementName.Set( PolicyLanguage::NativeLanguage::Expressions::Condition);

	iSaveType = ESubElement;

}

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

// CCondition::~CCondition

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

//

CCondition::~CCondition()

{

}

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

// CCondition::NewL

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

//

CCondition * CCondition::NewL()

{

	return new (ELeave) CCondition();

}

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

// CCondition::IdentificateType

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

//

TBool CCondition::IdentificateType( const TDesC8& aElementName)

{

	return ( aElementName == PolicyLanguage::NativeLanguage::Expressions::Condition);			

}

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

// CCondition::DecodeElementL

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

//

HBufC8 * CCondition::DecodeElementL( const  TLanguageSelector &aLanguage, const TDecodeMode &aMode)

{

	RDEBUG("PolicyEngineServer: Decode Condition element");

	__ASSERT_ALWAYS ( iExpression, User::Panic(PolicyParserPanic, KErrCorrupt));

	CheckAllElementsL();

	TElementReserver reserver( Container());

	TInt size(5);

	TPtrC8 conditionPtr = PolicyLanguage::Expressions::Condition[ aLanguage];

	size += 2 * conditionPtr.Length();

	HBufC8 * expression = DecodeElementOrIdL( aLanguage, iExpression, aMode);

	CleanupStack::PushL( expression);

	size += expression->Length();

	HBufC8 * hbuf = HBufC8::NewLC( size);

	TPtr8 ptr = hbuf->Des();

	ptr.Append( '<');

	ptr.Append( conditionPtr);

	ptr.Append( '>');

	ptr.Append( *expression);

	ptr.Append(_L8("</"));

	ptr.Append( conditionPtr);

	ptr.Append( '>');

	CleanupStack::Pop( hbuf);

	CleanupStack::PopAndDestroy( expression);

	reserver.Release();

	return hbuf;

}

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

// CCondition::AddElementL

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

//

void CCondition::AddElementL( CPolicyParser *aParser, CElementBase * aElement)

{

	if ( aElement->ElementType() == EApply ) 

	{

		aParser->HandleErrorL( iExpression, ParserErrors::UnexpectedElement, aParser->ActiveElementName());	

		AddToElementListL( aElement, ETrue);

		iExpression = aElement;

	}

	else

	{	

		aParser->HandleErrorL( ParserErrors::UnexpectedElement, aParser->ActiveElementName());

	}	

}

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

// CCondition::AddIdElementL

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

//	

void CCondition::AddIdElementL( CElementBase * aElement)