/*

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

#include "PolicyEngineServer.h"

#include "EMailEnforcement.h"

#include "CommsDatEnforcement.h"

#include "IMEnforcement.h"

#include "dcmoenforcement.h"

#include "datasyncmlenforcement.h"

#include "ElementBase.h"

#include "PolicyStorage.h"

#include "elements.h"

#include "DataTypes.h"

#include "XACMLconstants.h"

#include "ErrorCodes.h"

#include "debug.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS ====================

// ================= MEMBER FUNCTIONS =======================

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

// CSettingEnforcementManager::CSettingEnforcementManager()

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

//

CSettingEnforcementManager::CSettingEnforcementManager()

	: CActive( EPriorityLow)

{

}

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

// CSettingEnforcementManager::~CSettingEnforcementManager()

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

//

CSettingEnforcementManager::~CSettingEnforcementManager()

{

	iEnforcementElements.ResetAndDestroy();

	iEnforcementElements.Close();

	iValidEditorsForSetting.ResetAndDestroy();

	iValidEditorsForSetting.Close();

	delete iActiveEnforcementBase;

}

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

// CSettingEnforcementManager::NewL()

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

//

CSettingEnforcementManager* CSettingEnforcementManager::NewL()

{

	return new (ELeave) CSettingEnforcementManager();

}

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

// CSettingEnforcementManager::StartEnforcementSessionL()

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

//		

void CSettingEnforcementManager::StartEnforcementSessionL( TRequestStatus& aRequestStatus, const TCertInfo& aCertInfo)

{

	//reset context

	iEnforcementElements.ResetAndDestroy();

	iValidEditorsForSetting.ResetAndDestroy();

	iExternalRequestStatus = &aRequestStatus;

	aRequestStatus = KRequestPending;

	iCertInfo = aCertInfo;

	//Add object to active scheduler

	if ( !IsAdded())

	{

		CActiveScheduler::Add( this);

	}

}

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

// CSettingEnforcementManager::AddModifiedElementL()

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

//

void CSettingEnforcementManager::AddModifiedElementL( const CElementBase* aElement)

{

	using namespace PolicyLanguage::Constants;

	__ASSERT_ALWAYS( aElement, User::Panic( Panics::SettingEnforcementManagerPanic, KErrAbort));

	HBufC8 * elementName = aElement->ExternalId();

	//If element has external id

	if ( elementName)

	{

		//and if element is enforcement element

		if ( CEmailEnforcement::ValidEnforcementElement( *elementName) ||

			 CCommsDatEnforcement::ValidEnforcementElement( *elementName) ||

			 CDataSyncMLEnforcement::ValidEnforcementElement( *elementName) ||

			 CImEnforcement::ValidEnforcementElement(*elementName)	||

			 CDcmoEnforcement::ValidEnforcementElement(*elementName))	

		{

			iEnforcementElements.AppendL( elementName->Alloc());

		}

	}

}

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

// CSettingEnforcementManager::ExecuteEnforcementSessionL()

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

//

void CSettingEnforcementManager::ExecuteEnforcementSessionL()

{

	//Reset operation state

	iOperationCounter = 0;

	iOperationState = 0;

	//Start scheduling

	SetActive();

	TRequestStatus * status = &iStatus;

	User::RequestComplete( status, KErrNone);

}

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

// CSettingEnforcementManager::CommitChanges()

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

//

void CSettingEnforcementManager::CommitChanges()

{

	//Commit changes....

}

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

// CSettingEnforcementManager::EndEnforcementSessionL()

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

//

void CSettingEnforcementManager::EndEnforcementSession( TBool aFlushSettings)

{

	//finish active enforcement base

	if ( iActiveEnforcementBase)

	{

		delete iActiveEnforcementBase;

		iActiveEnforcementBase = 0;

	}

	//destroy editor list (this must be valid until FinishEnforcementL is called for enforcementbase)

	iValidEditorsForSetting.ResetAndDestroy();

}

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

// CSettingEnforcementManager::RunL()

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

//

void CSettingEnforcementManager::RunL()

{

	using namespace PolicyLanguage::Constants;

	if ( iStatus.Int() != KErrNone)

	{

		User::RequestComplete( iExternalRequestStatus, iStatus.Int());

		return;

	}

	if ( iOperationCounter < iEnforcementElements.Count())

	{

		TBool requested = ETrue;

		TInt requestStatus = KErrNone;

		switch ( iOperationState )

		{

			case 0:

			if ( iOperationState == 0)

			{

				//reset arrays and get new editors for setting

				iValidEditorsForSetting.ResetAndDestroy();

				iActivelementName = iEnforcementElements[ iOperationCounter];

				TUint32 elementId = CPolicyStorage::PolicyStorage()->MapRealIdL( *iActivelementName, EFalse );

				if ( elementId != 0)

				{

					ResolveValidEditorsForSettingL( elementId);

				}

				requested = EFalse;

				iOperationState++;

				//select active enforment base

				__ASSERT_ALWAYS( iActivelementName, User::Panic( Panics::SettingEnforcementManagerPanic, KErrAbort));

				SetActiveEnforcementBaseL( *iActivelementName);

			}

			break;

			case 1:

			if ( iOperationState == 1)

			{

				if ( iActiveEnforcementBase->InitReady())

				{

					requested = EFalse;

					iOperationState++;

				}

				else

				{

					iActiveEnforcementBase->InitEnforcementL( iStatus);

				}

			}

			break;

			case 2:

			if ( iOperationState == 2)

			{

				if ( iActiveEnforcementBase->EnforcementReady())

				{

					//when enforcement is ready...

					requested = EFalse;

					iOperationState = 0;

					iOperationCounter++;

				}

				else

				{

					//and the next rounds are dedicated for doing enforcement until enforcement is ready

					iActiveEnforcementBase->DoEnforcementL( iStatus);

				}

			}

			break;

		}

		//Continue scheduling...

		SetActive();

		if ( !requested )

		{

			TRequestStatus * status = &iStatus;

			User::RequestComplete( status, requestStatus);

		}

	}

	else

	{

		User::RequestComplete( iExternalRequestStatus, KErrNone);

	}

}

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

// CSettingEnforcementManager::RunError()

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

//

TInt CSettingEnforcementManager::RunError( TInt aError)

{

	RDEBUG_2("	**** ERROR, CSettingEnforcementManager::RunError( %d )", aError );

	//Complete external request with error value

	User::RequestComplete( iExternalRequestStatus, aError);

	return KErrNone;

}

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

// CSettingEnforcementManager::DoCancel()

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

//

void CSettingEnforcementManager::DoCancel()

{

	RunError( KErrAbort);

}

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

// CSettingEnforcementManager::SetActiveEnforcementBaseL()

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

//

void CSettingEnforcementManager::SetActiveEnforcementBaseL(  const TDesC8& aEnforcementId)

{	

	//delete old enforcement base

	delete iActiveEnforcementBase;

	iActiveEnforcementBase = 0;

	//and if element is enforcement element

	iActiveEnforcementBase = CEmailEnforcement::NewL( aEnforcementId);

	if ( !iActiveEnforcementBase)

	{

		iActiveEnforcementBase = CCommsDatEnforcement::NewL( aEnforcementId);

	}

	if ( !iActiveEnforcementBase)

	{

		iActiveEnforcementBase = CDataSyncMLEnforcement::NewL( aEnforcementId);

	}

	if ( !iActiveEnforcementBase)

	{

		iActiveEnforcementBase = CImEnforcement::NewL( aEnforcementId);

	}

	if ( !iActiveEnforcementBase)

	{

		iActiveEnforcementBase = CDcmoEnforcement::NewL( aEnforcementId);

	}

	if ( iActiveEnforcementBase )

	{

		iActiveEnforcementBase->AccessRightList( iValidEditorsForSetting);

		iActiveEnforcementBase->SetSessionCertificate( iCertInfo );

	}

}

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

// CSettingEnforcementManager::ResolveValidEditorsForSettingL()

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

//

void CSettingEnforcementManager::ResolveValidEditorsForSettingL( TUint32 iElementId)

{

	using namespace PolicyLanguage::NativeLanguage::Functions;

	using namespace PolicyLanguage::Constants;

	//get and reserve element

	CElementBase * policyElement = CPolicyStorage::PolicyStorage()->GetEditableElementL( iElementId);

	if ( policyElement == NULL)

	{

		return;	

	}

	if ( policyElement->ElementType() != EPolicy)

	{

		return;

	}

	TElementReserver policyReserver( policyElement);

	CPolicyStorage::PolicyStorage()->CheckElementL( policyElement);

	//Find Subjectmatch element, they determines who has right to modifie settings	

	RElementArray rules;	

	policyElement->FindAttributesL( ERule, rules);

	CleanupClosePushL( rules);

	for ( TInt j(0); j < rules.Count(); j++)

	{

		CRule* rule = (CRule*)rules[ j];

		TElementReserver ruleReserver( rule);

		CPolicyStorage::PolicyStorage()->CheckElementL( rule);

		if ( rule->Effect() == EPermit)

		{

			//Find Subjectmatch element, they determines who has right to modifie settings	

			RElementArray attributes;	

			rule->FindAttributesL( ESubjectMatch, attributes);

			CleanupClosePushL( attributes);

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

			{

				CElementBase * element = attributes[i];

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

				{

					TElementReserver elementReserver( attributes[i]);

					CPolicyStorage::PolicyStorage()->CheckElementL( element);

					CMatchObject* subjectMatch = (CMatchObject*)element;

					//Search TrustedSubjectMatch attributes													

					if ( *subjectMatch->MatchId() == TrustedSubjectMatch )

					{

						//and add valid editors (Trusted subjects) to valid editors list...

						if ( subjectMatch->AttributeDesignator()->GetAttributeid() == PolicyEngineXACML::KTrustedSubject )

						{

							iValidEditorsForSetting.AppendL( subjectMatch->AttributeValue()->Data()->Value().AllocL());

						}

					}		

					elementReserver.Release();

				}

			}

			CleanupStack::PopAndDestroy( &attributes);

		}

		ruleReserver.Release();			

	}

	policyReserver.Release();

	CleanupStack::PopAndDestroy( &rules);

}

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

// CSettingEnforcementManager::SessionCertificate()

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

//

TCertInfo& CSettingEnforcementManager::SessionCertificate()

{

	return iCertInfo;

}

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

// CEnforcementBase::SetSessionCertificate()

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

//

void CEnforcementBase::SetSessionCertificate( TCertInfo& aCertInfo)

{

	iCertInfo = &aCertInfo;

}

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

// CEnforcementBase::SetSessionCertificate()

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

//

TCertInfo& CEnforcementBase::SessionCertificate()

{

	return *iCertInfo;

}