/*

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

#include "DMUtilClient.h"

#include "PMUtilInternalCRKeys.h"

#include <eikenv.h>

#include <centralrepository.h>

#include <s32mem.h>

// CONSTANTS

const TUid KUidPolicyEngineUi = { 0x10207817 };

const TUint KDelimeterChar = '|';

_LIT8( KUserAcceptMark, "A");

const TInt KMaxServerIdLength = 250;

const TInt KMaxLabelIdLength = 25;

const TInt KMaxCertSize = 1024;

_LIT(KSymbianCertificateStoreLabel, "Software certificate store");

_LIT(KDMTrustedCertLabel,"DMTrustedServer_");

_LIT8(KNoKeyFound,"");

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

    iCertBuffer=NULL;

    delete iStore;

    ////

    ResetRequestContext();

	delete iRequestBuffer;

	CPolicyEngineServer::RemoveActiveObject( this);

}

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

// CPolicyProcessor::ConstructL()

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

//

void CPolicyProcessor::ConstructL()

{

	CPolicyEngineServer::AddActiveObjectL( this);

}

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

// CPolicyProcessor::AddCertificateToStoreL()

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

//

TInt CPolicyProcessor::AddCertificateToStoreL(const RMessage2& aMessage)

    {

    RDEBUG("CPolicyProcessor::AddCertificateToStore" );

    TInt size = aMessage.Int1();

    TBuf<KMaxCertSize> certData;    

    aMessage.ReadL(0, certData, 0);     

    iCertBuffer = HBufC8::NewL(size);     

    iCertBuffer->Des().Copy(certData);

    //check if the trust already exists with same server

    TInt result = CheckCurrentServerIdFromCR();     

    if(result == KErrInUse)

        {       

        return KErrInUse;    

        }

    iStore = CCertStore::NewL();

    TInt res = iStore->AddCert(iCertBuffer);

    if(res == KErrNone)

        {        

        //update the new counter value in CR

        iStore->UpdateLabelCounterInCR();  

        // return the newly generated label

        aMessage.WriteL( 2, iStore->GetCurrentCertLabel()->Des() );     

        }

    return res; 

    }

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

// CPolicyProcessor::RemoveCertificateFromStoreL()

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

//

TInt CPolicyProcessor::RemoveCertificateFromStoreL(const RMessage2& aMessage)

    {

    RDEBUG("CPolicyProcessor::RemoveCertificateFromStoreL" );

    TBuf<128> certLabel;

    aMessage.ReadL(0, certLabel, 0);   

    HBufC *label = HBufC::NewL(aMessage.GetDesLength(0));

    label->Des().Copy(certLabel);  

    TInt result = CheckCurrentServerIdFromCR();

    //check if the trust already exists with same server

    if(result == KErrInUse)

        {

        RDEBUG("CPolicyProcessor::RemoveCertificateFromStore -14" );

        return KErrInUse;    

        }

    if ( iStore != NULL )

       {

       delete iStore;

       iStore = NULL;

       }

    iStore = CCertStore::NewL();

    TInt res;

    if(label->Des() == KNullDesC)

        {

        // If NULL is passed for removing label then remove the current label

        HBufC* rLabel = iStore->GetCurrentCertLabel()->AllocL();

        res = iStore->RemoveCert(*rLabel);

        delete rLabel;

        }

    else

        {

        res = iStore->RemoveCert(*label); 

        }

    delete label;

    label = NULL;

    return res;

    }

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

// CPolicyProcessor::CheckCurrentServerIdFromCR()

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

//

TInt CPolicyProcessor::CheckCurrentServerIdFromCR()

    {

    RDEBUG("CPolicyProcessor::CheckCurrentServerIdFromCR" );

    TBuf8<KMaxServerIdLength>  serverIdCR;         

    TRAPD( err, 

           {

           CRepository* rep = CRepository::NewL( KCRUidPolicyManagementUtilInternalKeys );

           CleanupStack::PushL( rep );

           rep->Get( KTrustedServerId, serverIdCR );

           CleanupStack::PopAndDestroy( rep );

           } );

    if(err!=KErrNone)

        {

        return err;

        }    

    TBool result = CPolicyStorage::PolicyStorage()->IsServerIdValid(serverIdCR);    

    if(result)

        {

        return KErrInUse;

        }

    else

        {

        return KErrNone;

        }

    }

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

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

				}