--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/policymanagement/policyengine/policyengineserver/src/SettingEnforcementManager.cpp	Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,445 @@
+/*
+* 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 "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))	
+		{
+			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)
+	{
+		iActiveEnforcementBase->FinishEnforcementL( aFlushSettings);
+		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->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;
+}
+
+
+
+
+
+
+