/*

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

#include "elements.h"

#include "DataTypes.h"

#include "PolicyParser.h"

#include "ElementBase.h"

#include "PolicyProcessor.h"

#include "TrustedSession.h"

#include "ErrorCodes.h"

#include "OperationParser.h"

#include "OperationParserConstants.h"

#include "SettingEnforcementManager.h"

#include "PolicyEngineServer.h"

#include "PolicyEngineXACML.h"

#include "debug.h"

#include "DMUtilClient.h"

#include <PolicyEngineClientServer.h>

#include <ManagementContext.h>

// CONSTANTS

const TInt KMaxServerIdLength = 250;

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

// CPolicyManager::CPolicyManager()

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

//

CPolicyManager::CPolicyManager( CPolicyProcessor * aPolicyProcessor)

	: CActive( EPriorityLow),  iPolicyProcessor( aPolicyProcessor)

{

	iPolicyStorage = CPolicyStorage::PolicyStorage();

}

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

// CPolicyManager::~CPolicyManager()

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

//

CPolicyManager::~CPolicyManager()

{

	//CSettingEnforcementManager

	delete iSEManager;

	//descriptors used in operations 

	delete iActiveChildList;

	delete iActiveXACMLContent;

	delete iActiveElementList;

	delete iOperationParser;

	delete iCurrentManagementCommand;

	CPolicyEngineServer::RemoveActiveObject( this);

}

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

// CPolicyManager::ConstructL()

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

//

void CPolicyManager::ConstructL()

{

	CPolicyEngineServer::AddActiveObjectL( this);

	iSEManager = CSettingEnforcementManager::NewL();

}

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

// CPolicyStorage::NewL()

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

//

CPolicyManager * CPolicyManager::NewL( CPolicyProcessor * aPolicyProcessor)

{

	CPolicyManager * self = new(ELeave) CPolicyManager( aPolicyProcessor);

	CleanupStack::PushL( self);

	self->ConstructL();

	CleanupStack::Pop( self);

	return self;

}

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

// CPolicyManager::ExecuteOperationL()

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

//

void CPolicyManager::ExecuteOperation( CTrustedSession * aSession, const RMessage2& aMessage)

{

	iMessage = &aMessage;

	//Only one management session is accepted

	if ( CPolicyEngineServer::StatusFlags()->iManagementActive )

	{

		CompleteOperation( KErrInUse);

		return;

	}

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

	//set pointer to trusted session and save reference to RMessage

	iTrustedSession = aSession;

	//initialize states

	iOperationStatus = 0;

	iUseBearerCertificate = EFalse;

	iCertificateUpdates = EFalse;

	//Add this active object active scheduler	

	if ( !IsAdded())

	{

		CActiveScheduler::Add( this);

	}

	//Complete own request

	SetActive();

	TRequestStatus * status = &iStatus;

	User::RequestComplete( status, KErrNone);

}

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

// CPolicyManager::RunL()

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

//

void CPolicyManager::RunL()

{

	CPolicyEngineServer::SetActiveSubSession( this);	

	//management operations are allowed only when server is free

 	if ( CPolicyEngineServer::StatusFlags()->iProcessorActive )

	{

		SetActive();

		TRequestStatus * status = &iStatus;

		User::RequestComplete( status, KErrNone);

		return;		

	}

	if ( iOperationStatus == 0)

	{

		//Start management session for next operations

		iPolicyStorage->StartCommitSessionL();

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

		//Read policy description	

		TPtr8 ptr = iCurrentManagementCommand->Des(); 

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

		iOperationParser = COperationParser::NewL( ptr);

		//parse operations, "iMsg" stores error message

		iOperationParser->ParseOperationsL( iMsg);

	}

	else if ( (iOperationStatus - 1) < iOperationParser->OperationCount())

	{

		//Execute operations, "this" is pointer to callback function 

		iCertificateUpdates = EFalse;

		iOperationParser->ExecuteL( iOperationStatus - 1, this);

		if ( iCertificateUpdates)

		{

			CPolicyEngineServer::CertificateMaps()->NewMappingsAvailable();

		}			

	}

	if ( iOperationStatus == iOperationParser->OperationCount() + 2)

	{

		//Finish management session and commit changes in repository

		iMsg = ManagementErrors::OperationOk;

		if ( iStatus.Int() == KErrNone)

		{

			CommitChangesL();	

			CompleteOperation( iStatus.Int());

			CPolicyStorage::PolicyStorage()->ReleaseElements();

		}

		else

		{

			RunError( iStatus.Int());			

		}

	}

	else

	if ( iOperationStatus == iOperationParser->OperationCount() + 1)

	{

		//Make setting enforcements...

		MakeEnforcementL( KErrNone);

	}

	else

	{

		SetActive();

		TRequestStatus * status = &iStatus;

		User::RequestComplete( status, KErrNone);

	}

	iOperationStatus++;

}

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

// CPolicyManager::DoCancel()

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

//

void CPolicyManager::DoCancel()

{

	RunError( KErrAbort);

}

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

// CPolicyManager::DoCancel()

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

//

TInt CPolicyManager::RunError( TInt aError)

{

	RDEBUG("CPolicyManager::RunError");

	RDEBUG8_2("Policy engine operation error message: %S", &iMsg);

	//restores possible changes in policy storage

	TRAPD( err, iPolicyStorage->CommitChangesL( EFalse))

	if ( err != KErrNone )

	{

		aError = err;	

	}

	//complete operation

	CompleteOperation( aError);	

	return KErrNone;

}

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

// CPolicyManager::MakeEnforcementL()

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

//

void CPolicyManager::MakeEnforcementL( TInt aError)

{

	//initialize enforcement session

	iSEManager->StartEnforcementSessionL( iStatus, iTrustedSession->SessionCertificate());

	//get modified elements 

	iPolicyStorage->GetEditedElementsL( iSEManager);

	//start enforcement session enforcement policies

	if ( aError == KErrNone)

	{

		iSEManager->ExecuteEnforcementSessionL();

	}

	//set active (waiting for enforcement completing)

	SetActive();	

}

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

// CPolicyManager::CompleteOperation()

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

//

void CPolicyManager::CompleteOperation( TInt aError )

	{

	RDEBUG_2("CPolicyManager::CompleteOperation( %d )", aError );

	if( aError != KErrNone && aError != KErrParser && KErrOpParser != aError && KErrPolicyManager != aError)

		{

		iMsg = KNullDesC8;

		aError = KErrGeneral;

		}

	else

		{

		aError = KErrNone;

		}

	//finish storage session and enforcement session

	iPolicyStorage->ResetEditableMemory();

	iSEManager->EndEnforcementSession( KErrNone == aError );

	if ( iCertificateUpdates )

		{

		CPolicyEngineServer::CertificateMaps()->NewMappingsAvailable();

		}	

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

	//release resources

	delete iOperationParser;

	iOperationParser = NULL;

	delete iCurrentManagementCommand;

	iCurrentManagementCommand = NULL;

	//write return message to client process

	TParserResponse response( iMsg);

	TPckgC<TParserResponse> retPack(response);

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

	if( err != KErrNone )

		{

		iMessage->Complete( err );

		return;

		}

	iMessage->Complete( aError);

	}

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

// CPolicyManager::UpdateStateFlags()

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

//

void CPolicyManager::UpdateStateFlagsL()

{

	RDEBUG("CPolicyManager::UpdateStateFlagsL - start");

	RDMUtil dmutil;

	User::LeaveIfError( dmutil.Connect());

	CleanupClosePushL( dmutil);

	TBool securityActive = EFalse;

	User::LeaveIfError( dmutil.UpdatePolicyMngStatusFlags( EPolicyChanged));

	//Check is terminal security activated

	CElementBase * iElement = iPolicyStorage->GetElementL( PolicyLanguage::Constants::RolesMappingPolicy);	

	if (iElement)

	{

		TElementReserver reserver(iElement);

		iPolicyStorage->CheckElementL(iElement);

		//check child elements, any rule child means that terminal security is acticated

		for (TInt i(0); i < iElement->ElementCount(); i++) {

			CElementBase * element = iElement->Element(i);

			if (element->ElementType() == ERule) {

				RDEBUG("CPolicyManager::UpdateStateFlagsL -> securityActive = ETrue");

				securityActive = ETrue;

				break;

			}

		}

		reserver.Release();

	}

	//update policy management flags	

	if ( securityActive)

	{

		User::LeaveIfError( dmutil.UpdatePolicyMngStatusFlags( ETerminalSecurityActive));

	}

	else

	{

		User::LeaveIfError( dmutil.UpdatePolicyMngStatusFlags( ETerminalSecurityDeactive));

	}

	CleanupStack::PopAndDestroy( &dmutil);

	RDEBUG("CPolicyManager::UpdateStateFlagsL - end");

}

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

// CPolicyManager::CommitChangesL()

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

//

void CPolicyManager::CommitChangesL()

{

	//Accept or decline changes to storage...

	iPolicyStorage->SaveEditableMemoryL();

	//This ensures that enforcement settings are committed

	iSEManager->CommitChanges();	

	//This ensures that all changes are commited (also enforcement)

	iPolicyStorage->CommitChangesL( ETrue);	

	//update state flags

	UpdateStateFlagsL();

	RDEBUG8_2("Policy engine operation message: %S", &iMsg);

}

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

// CPolicyManager::NewPolicy()

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

//

void CPolicyManager::NewElementL( const TInt& aLineOffset, const TDesC8& aTargetElement, const TDesC8& aElementDescription, const TBool& aUseBearerCertificate )

{

	RDEBUG("PolicyEngineServer: CPolicyManager::NewElementL");

	//initialize policy parser...

	CPolicyParser * parser = CPolicyParser::NewL( iPolicyStorage);

	CleanupStack::PushL( parser);

	parser->SetExternalIdChecked( KNoExternalIdConflictsAllowed);

	parser->SetLineOffset( aLineOffset);

	iUseBearerCertificate = aUseBearerCertificate;

	//Parse native model from XACML description

	TInt err(KErrNone);	

	TBuf8<KMaxReturnMessageLength> msg;

	CElementBase * element = parser->ParseXACMLObjects( err, aElementDescription, msg);	

	CleanupStack::PopAndDestroy( parser); //Parser

	if ( err != KErrNone )

	{

		iMsg = msg;

		User::Leave( KErrParser);	

	}

	//Add element to policy storage (storage take responsibility to delete object)

	RDEBUG_2("PolicyEngineServer: Element parsed and id created(id %d)", element->GetId());

	element->CreateIdL();

	element->CreateExternalId();

	iPolicyStorage->AddNewElementL( element);

	TElementReserver newElement( element);

	//Check is the policy valid and if so, add element to temporary storage

	AssignElementL( aTargetElement, element);

	newElement.Release();

}

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

// CPolicyManager::ReplaceElementL()

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

//

void CPolicyManager::ReplaceElementL( const TInt& aLineOffset, const TDesC8& aTargetElement, const TDesC8& aElementDescription )

{

	RDEBUG("PolicyEngineServer: CPolicyManager::ReplaceElementL");

	//initialize policy parser...

	CPolicyParser * parser = CPolicyParser::NewL( iPolicyStorage);

	CleanupStack::PushL( parser);

	parser->SetExternalIdChecked( KSameExternalIdAllowedForRoot);

	parser->SetLineOffset( aLineOffset);

	//Parse native model from XACML description

	TInt err(KErrNone);	

	TBuf8<KMaxReturnMessageLength> msg;

	CElementBase * element = parser->ParseXACMLObjects( err, aElementDescription, msg);	

	CleanupStack::PopAndDestroy( parser); //Parser

	if ( err != KErrNone )

	{

		iMsg = msg;

		User::Leave( KErrParser);	

	}

	//Add element to policy storage (storage take responsibility to delete object)

	RDEBUG_2("PolicyEngineServer: Element parsed and id created(id %d)", element->GetId());

	element->CreateIdL();

	element->CreateExternalId();

	iPolicyStorage->AddNewElementL( element);

	TElementReserver newElement( element);

	//Check is the policy valid and if so, add element to temporary storage

	ReAssignElementL( aTargetElement, element);

	newElement.Release();

}

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

// CPolicyManager::AssignPolicyL()

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

//

void CPolicyManager::AssignElementL( const TDesC8& aTargetElement, CElementBase * aElement)

{

	RDEBUG("PolicyEngineServer: CPolicyManager::AssignElementL");

	//get parent element and load it

	CElementBase * parentElement = iPolicyStorage->GetEditableElementL( aTargetElement);

	//if parent eleemnt is valid

	if ( !parentElement)

	{

		RDEBUG("PolicyEngineServer: Target element not found");

		iMsg = ManagementErrors::ElementNotFound;

		User::Leave( KErrPolicyManager);

	}

	TElementReserver assignReserver( parentElement);

	iPolicyStorage->CheckElementL( parentElement);

	//add parant id to components

	aElement->AddParentIdL( parentElement->GetId());

	//Check is assignment acceptable

	IsAssigmentAcceptableL( parentElement, aElement, ETrue);

	assignReserver.Release();

	//Add element to parent element, check is assigment valid

	parentElement->AddIdElementL( aElement);

	parentElement->iElementState = EEditedElement;

}