policymanagement/policyengine/policyengineserver/src/SettingEnforcementManager.cpp
--- /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;
+}
+
+
+
+
+
+
+