diff -r 000000000000 -r b497e44ab2fc policymanagement/policyengine/policyengineserver/src/PolicyEngineServer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/policymanagement/policyengine/policyengineserver/src/PolicyEngineServer.cpp Thu Dec 17 09:07:52 2009 +0200 @@ -0,0 +1,848 @@ +/* +* Copyright (c) 2000 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 +* +*/ + + +// INCLUDES + +#include "PolicyEngineServer.h" +#include "PolicyParser.h" +#include "TrustedSession.h" +#include "PolicyStorage.h" +#include "PolicyManager.h" +#include "PolicyProcessor.h" +#include "PolicyEngineClientServerDefs.h" +#include "debug.h" + +#include +#include +#include "DMUtilClient.h" + + +CPolicyEngineServer* CPolicyEngineServer::iServer = 0; + +#ifdef _DEBUG +namespace DebugUtility +{ + _LIT( PolicyCheckFile, "c:\\policy_check_off_file.txt"); + + TBool PolicyCheckActive() + { + TBool response = ETrue; + + RFs rfs; + TInt err = rfs.Connect(); + if( err != KErrNone ) + { + return EFalse; + } + + RFile file; + + //Check is file exist + if ( KErrNone == file.Open( rfs, PolicyCheckFile, EFileRead)) + { + response = EFalse; + } + + file.Close(); + rfs.Close(); + + return response; + } +} +#endif + + +// ---------------------------------------------------------------------------------------- +// Server startup code +// ---------------------------------------------------------------------------------------- + +static void RunServerL() + { + // naming the server thread after the server helps to debug panics + User::LeaveIfError(User::RenameThread(KPolicyEngineServerName)); + + // create and install the active scheduler + CActiveScheduler* s=new(ELeave) CActiveScheduler; + CleanupStack::PushL(s); + CActiveScheduler::Install(s); + + // create the server (leave it on the cleanup stack) + CPolicyEngineServer::NewLC(); + // Initialisation complete, now signal the client + + RProcess::Rendezvous(KErrNone); + + // Ready to run + RDEBUG("Policy engine server is running"); + + CActiveScheduler::Start(); + + // Cleanup the server and scheduler + CleanupStack::PopAndDestroy(2); + } + +// Server process entry-point +TInt E32Main() + { + __UHEAP_MARK; + RDEBUG( "PolicyEngineServer: E32Main"); + CTrapCleanup* cleanup=CTrapCleanup::New(); + TInt r=KErrNoMemory; + if (cleanup) + { + TRAP(r,RunServerL()); + delete cleanup; + } + __UHEAP_MARKEND; + return r; + } + +// ---------------------------------------------------------------------------------------- +// PanicClient +// ---------------------------------------------------------------------------------------- + +void PanicClient(const RMessagePtr2& aMessage,TPolicyEnginePanic aPanic) + { + _LIT(KPanic,"PolicyEngineServer"); + aMessage.Panic(KPanic,aPanic); + } + +// ---------------------------------------------------------------------------------------- +// CShutDown::CShutdown() +// ---------------------------------------------------------------------------------------- + +inline CShutdown::CShutdown() + :CTimer(-1) + { + CActiveScheduler::Add(this); + } + +// ---------------------------------------------------------------------------------------- +// CShutDown::ConstructL() +// ---------------------------------------------------------------------------------------- + +inline void CShutdown::ConstructL() + { + CTimer::ConstructL(); + } + +// ---------------------------------------------------------------------------------------- +// CShutDown::Start() +// ---------------------------------------------------------------------------------------- + +inline void CShutdown::Start() + { + RDEBUG("PolicyEngineServer: starting selfcheck timeout"); + iSelfCheckCounter = 0; + After( KPolicyEngineSelfCheckDelay); + } + +// ---------------------------------------------------------------------------------------- +// CShutDown::RunL() +// ---------------------------------------------------------------------------------------- + +void CShutdown::RunL() +{ + RDEBUG("Policy engine server selfcheck timeout..."); + iSelfCheckCounter++; + + + if ( iSelfCheckCounter == KPolicyEngineReleaseElementsDelay) + { + RDEBUG("PolicyEngineServer: Release cache elements..."); + CPolicyStorage::PolicyStorage()->ReleaseElements(); + } + + if ( iSelfCheckCounter >= KPolicyEngineShutdownDelay) + { + RDEBUG("PolicyEngineServer: Shutdown..."); + CActiveScheduler::Stop(); + } + else + { + After( KPolicyEngineSelfCheckDelay); + } + +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::CPolicyEngineServer +// ---------------------------------------------------------------------------------------- + +inline CPolicyEngineServer::CPolicyEngineServer() + : CPolicyServer(0, KPolicyEngineSecurityPolicy, ESharableSessions) + { + CPolicyEngineServer::iServer = this; + } + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::~CPolicyEngineServer +// ---------------------------------------------------------------------------------------- + +CPolicyEngineServer::~CPolicyEngineServer() +{ + RDEBUG("CPolicyEngineServer::~CPolicyEngineServer()"); + delete iPolicyStorage; + delete iCertificateMaps; + delete iFlags; + delete iContainerIndex; + + iActiveObjectCancelList.Close(); +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::NewLC() +// ---------------------------------------------------------------------------------------- + +CServer2* CPolicyEngineServer::NewLC() +{ + RDEBUG("PolicyEngineServer: CPolicyEngineServer::NewLC"); + + CPolicyEngineServer* self=new(ELeave) CPolicyEngineServer; + CleanupStack::PushL(self); + + self->ConstructL(); + return self; +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::ConstructL() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineServer::ConstructL() + { + RDEBUG("CPolicyEngineServer::ConstructL() begin"); + // 2nd phase construction - ensure the timer and server objects are running + + StartL (KPolicyEngineServerName); + iContainerIndex = CObjectConIx::NewL(); + //create storage and set static reference + iPolicyStorage = CPolicyStorage::NewL(); + CPolicyStorage::iPolicyStorage = iPolicyStorage; + + iCertificateMaps = CCertificateMaps::NewL(); + iFlags = new (ELeave) CServerStatusFlags(); + iFlags->iUiActive =EFalse; + iFlags->iManagementActive =EFalse; + iFlags->iProcessorActive =EFalse; + + iShutdown.ConstructL(); + // ensure that the server still exits even if the 1st client fails to connect + iShutdown.Start(); + RDEBUG("CPolicyEngineServer::ConstructL() end"); + } + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::NewSessionL() +// ---------------------------------------------------------------------------------------- + +CSession2* CPolicyEngineServer::NewSessionL( const TVersion&, const RMessage2&) const + { + // Create a new client session. This should really check the version number + + RDEBUG("PolicyEngineServer: CPolicyEngineServer::NewSessionL"); + + return new (ELeave) CPolicyEngineSession(); + } + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::AddSession() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineServer::AddSession() +{ + // A new session is being created + RDEBUG("PolicyEngineServer: CPolicyEngineServer::AddSession"); + ++iSessionCount; + + // Cancel the shutdown timer if it was running + iShutdown.Cancel(); +} + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::DropSession() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineServer::DropSession() +{ + // A session is being destroyed + RDEBUG("PolicyEngineServer: CPolicyEngineServer::DropSession"); + + // Start the shutdown timer if it is the last session + if (--iSessionCount==0) + { + iShutdown.Start(); + } +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::DropSession() +// ---------------------------------------------------------------------------------------- + +CServerStatusFlags* CPolicyEngineServer::StatusFlags() +{ + return CPolicyEngineServer::iServer->iFlags; +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::NewContainerL() +// ---------------------------------------------------------------------------------------- + +CObjectCon* CPolicyEngineServer::NewContainerL() +{ + //create new container and return pointer + return iContainerIndex->CreateL(); +} + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::CertificateMaps() +// ---------------------------------------------------------------------------------------- +CCertificateMaps * CPolicyEngineServer::CertificateMaps() +{ + //return pointer to global certificate maps instance + return CPolicyEngineServer::iServer->iCertificateMaps; +} + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::SetActiveSubSession() +// ---------------------------------------------------------------------------------------- +void CPolicyEngineServer::SetActiveSubSession( const CBase* iBase) +{ + RDEBUG("CPolicyEngineServer::SetActiveSubSession()"); + CPolicyEngineServer::iServer->iSubSessionObjects = 0; + + CPolicyEngineServer::iServer->iSessionIter.SetToFirst(); + for ( ; CPolicyEngineServer::iServer->iSessionIter != 0 ; CPolicyEngineServer::iServer->iSessionIter++) + { + CSession2 * session = CPolicyEngineServer::iServer->iSessionIter; + CPolicyEngineSession* policyenginesession = (CPolicyEngineSession*) session; + CSubSessionObjects* objects = policyenginesession->GetSubSessionObjects( iBase); + + if ( objects ) + { + CPolicyEngineServer::iServer->iSubSessionObjects = objects; + break; + } + } +} + + + + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::AddActiveObjectL() +// ---------------------------------------------------------------------------------------- +void CPolicyEngineServer::AddActiveObjectL( CActive* aActiveObject) +{ + CPolicyEngineServer::iServer->iActiveObjectCancelList.AppendL( aActiveObject); +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::RemoveActiveObject() +// ---------------------------------------------------------------------------------------- +void CPolicyEngineServer::RemoveActiveObject( CActive* aActiveObject) +{ + for ( TInt i(0); i < CPolicyEngineServer::iServer->iActiveObjectCancelList.Count(); i++) + { + if ( aActiveObject == CPolicyEngineServer::iServer->iActiveObjectCancelList[i]) + { + CPolicyEngineServer::iServer->iActiveObjectCancelList.Remove( i); + break; + } + } +} + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::RemoveActiveObject() +// ---------------------------------------------------------------------------------------- +void CPolicyEngineServer::StopAllPendingRequests() +{ + RDEBUG("CPolicyEngineServer::StopAllPendingRequests()"); + for ( TInt i(0); i < CPolicyEngineServer::iServer->iActiveObjectCancelList.Count(); i++) + { + TInt count = CPolicyEngineServer::iServer->iActiveObjectCancelList.Count(); + CPolicyEngineServer::iServer->iActiveObjectCancelList[i]->Cancel(); + + //if request cancelling has caused some changes in active object list, then start list from beginning + if ( CPolicyEngineServer::iServer->iActiveObjectCancelList.Count() != count) + { + i = 0; + } + } +} + + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer::CustomSecurityCheckL() +// ---------------------------------------------------------------------------------------- +CPolicyServer::TCustomResult CPolicyEngineServer::CustomSecurityCheckL(const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/) +{ + RDEBUG("PolicyEngineServer: Custom security check"); + + //Three custom check function... + __ASSERT_ALWAYS( aMsg.Function() == ECreateManagementSubSession || + aMsg.Function() == ECloseManagementSubSession || + aMsg.Function() == EExecuteOperation || + aMsg.Function() == RMessage2::EConnect, User::Panic( KPolicyEngineServerName,EPanicIllegalFunction)); + + CPolicyServer::TCustomResult customResult = EFail; + + if ( aMsg.HasCapability( ECapabilityWriteDeviceData) && aMsg.HasCapability( ECapabilityReadDeviceData)) + { + RDEBUG("PolicyEngineServer: Client has CapabilityWriteDeviceData & ECapabilityReadDeviceData - ok"); + RDEBUG_3("PolicyEngineServer: Client SID: %d & VID %d",aMsg.SecureId().iId,aMsg.VendorId().iId); + + customResult = EPass; //Every process can try to make policy management, valid SIDs are + //defined in policies. Certificate usega is allowed only for DM process (check from platformsecuritypolicies.h) + } + else + { + RDEBUG("PolicyEngineServer: PlatSec failed! Missing cababilities!"); + customResult = EFail; + } + + return customResult; +} + + + + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::CPolicyEngineSession() +// ---------------------------------------------------------------------------------------- + +inline CPolicyEngineSession::CPolicyEngineSession() + { + RDEBUG("CPolicyEngineSession::CPolicyEngineSession"); + } + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::Server() +// ---------------------------------------------------------------------------------------- + +inline CPolicyEngineServer& CPolicyEngineSession::Server() +{ + //return pointer to Server instance + return *static_cast(const_cast(CSession2::Server())); +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::CreateL() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineSession::CreateL() +{ + // 2nd phase construct for sessions + RDEBUG("PolicyEngineSession: CPolicyEngineSession::CreateL"); + + //create session specific objects + iSessionsObjects = CObjectIx::NewL(); + iContainer = Server().NewContainerL(); + + //add session to server + Server().AddSession(); +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::~CPolicyEngineSession() +// ---------------------------------------------------------------------------------------- + +CPolicyEngineSession::~CPolicyEngineSession() +{ + RDEBUG("CPolicyEngineSession::~CPolicyEngineSession"); + + delete iSessionsObjects; + + Server().DropSession(); +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::ServiceL() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineSession::ServiceL( const RMessage2& aMessage) +{ + RDEBUG("CPolicyEngineSession::ServiceL"); + TRAPD(err,DispatchMessageL(aMessage)); + + RDEBUG_2("CPolicyEngineSession::ServiceL, Error status: %d", err); + + //only KErrGeneral errors + if ( err != KErrNone && err != KErrNotFound ) + { + err = KErrGeneral; + } + + //no completion for asynch methods + switch (aMessage.Function()) + { + case EExecuteOperation: + case EPolicyRequest: + //No completion + break; + default: + aMessage.Complete(err); + break; + } + +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::DispatchMessageL() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineSession::DispatchMessageL(const RMessage2& aMessage) + { + RDEBUG_2("CPolicyEngineSession::DispatchMessageL: %d",aMessage.Function()); + + //Subsession management + switch (aMessage.Function()) + { + case ECreateRequestSubSession: + case ECreateManagementSubSession: + { + NewSubSessionL( aMessage); + return; + } + case ECloseManagementSubSession: + case ECloseRequestSubSessio: + { + DeleteSubSession( aMessage); + return; + } + case EPerformPMRFS : + { + PerformRFSL(); + return; + } + } + + //Trusted session operations + CSubSessionObjects * subSession = SubSessionFromHandle( aMessage); + + switch (aMessage.Function()) + { + case EExecuteOperation : + { + subSession->iPolicyManager->ExecuteOperation( subSession->iTrustedSession, aMessage); + } + break; + case EGetElementListLength: + case EReadElementList: + { + subSession->iPolicyManager->GetElementListL( aMessage); + } + break; + case EGetElementDescriptionAndChildListLength : + case EReadElementAndChildList : + { + subSession->iPolicyManager->GetElementInfoL( aMessage); + } + break; + case EGetElementXACMLLength : + case EReadElementXACML : + { + subSession->iPolicyManager->GetElementXACMLDescriptionL( aMessage); + } + break; + case EPolicyRequest : + { + subSession->iPolicyProcessor->ExecuteRequestL( aMessage); + } + break; + case EAddSessionTrust : + { + subSession->iTrustedSession->MakeSessionTrustL( aMessage); + } + break; + case EIsServerIdValid : + { + subSession->iPolicyManager->IsServerIdValidL( aMessage); + return; + } + case ECertificateRole : + { + subSession->iPolicyManager->GetCertificateRoleL( aMessage); + } + break; + default: + break; + } + +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::PerformRFS() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineSession::PerformRFSL() +{ + RDEBUG("PolicyEngineServer: Restory factory setting operation started"); + //RFS steps in Policy Management subsystem + // 1. Remove policy files (RAM) from PolicyEngineServers private directory + // 2. Remove backup files (RAM) from PolicyEngineServers private directory + // 3. Remove Central Repository (RAM), handled by CentralRepository + + //stop all requests... + CPolicyEngineServer::StopAllPendingRequests(); + + //clean private directory + RFs rfs; + User::LeaveIfError( rfs.Connect() ); + CleanupClosePushL( rfs); + + TBuf<100> privatePath; + TInt err = rfs.PrivatePath( privatePath); + + if ( err == KErrNone) + { + //remove files from private directory, also backups + CFileMan* file = CFileMan::NewL( rfs); + + privatePath.Append(_L("*.*")); + err = file->Delete( privatePath, CFileMan::ERecurse); + delete file; + } + + + CleanupStack::PopAndDestroy( &rfs); + + RDEBUG("PolicyEngineServer: Restory factory setting operation finished"); +} + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::GetSubSessionObjects() +// ---------------------------------------------------------------------------------------- + +CSubSessionObjects* CPolicyEngineSession::GetSubSessionObjects( const CBase* iBase) +{ + CSubSessionObjects* retVal = 0; + + + for ( TInt i(0); i < iSessionsObjects->ActiveCount() ; i++) + { + CSubSessionObjects* objects = (CSubSessionObjects*)((*iSessionsObjects)[i]); + + if ( objects->iPolicyProcessor == iBase || + objects->iPolicyManager == iBase || + objects->iTrustedSession == iBase) + { + retVal = objects; + break; + } + + } + + return retVal; +} + + + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::CSubSessionObjects() +// ---------------------------------------------------------------------------------------- + +CSubSessionObjects* CPolicyEngineSession::SubSessionFromHandle( const RMessage2& aMessage) +{ + //return pointer to trusted session from handle + CSubSessionObjects* subSession = (CSubSessionObjects*)iSessionsObjects->At(aMessage.Int3()); + + if ( subSession == NULL) + { + PanicClient( aMessage, EBadSubsessionHandle); + } + + CPolicyEngineServer::iServer->iSubSessionObjects = subSession; + + return subSession; +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::NewSubSessionL() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineSession::NewSubSessionL( const RMessage2& aMessage) + { + //add new session objects object into container and object index + CPolicyProcessor * policyProcessor = CPolicyProcessor::NewL(); + CTrustedSession * trustedSession = CTrustedSession::NewL(); + trustedSession->AddSessionSIDL( aMessage.SecureId()); + policyProcessor->SetSessionTrust( trustedSession); + CPolicyManager * policyManager = NULL; + + if ( aMessage.Function() == ECreateManagementSubSession) + { + policyManager = CPolicyManager::NewL( policyProcessor); + } + + //Create new subsession object for subsession + CSubSessionObjects * subSessionObjects = CSubSessionObjects::NewL( policyProcessor, policyManager, trustedSession); + + iContainer->AddL( subSessionObjects); + TInt handle = iSessionsObjects->AddL( subSessionObjects); + + //transmit handle to client + TPckg handlePckg(handle); + TRAPD( r, aMessage.WriteL(3, handlePckg)) + + if ( r != KErrNone) + { + iSessionsObjects->Remove(handle); + PanicClient( aMessage, EBadDescriptor); + return; + } + + iSubsessionCount++; + } + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::DeleteSubSession() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineSession::DeleteSubSession( const RMessage2& aMessage) +{ + // panic if bad handle + CSubSessionObjects* subSessionObjects = (CSubSessionObjects*)iSessionsObjects->At(aMessage.Int3()); + + if ( subSessionObjects == NULL) + { + PanicClient( aMessage, EBadSubsessionHandle); + } + + iSessionsObjects->Remove(aMessage.Int3()); + iSubsessionCount--; +} + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineSession::ServiceError() +// ---------------------------------------------------------------------------------------- + +void CPolicyEngineSession::ServiceError(const RMessage2& aMessage,TInt aError) +{ + // Handle an error from CPolicyEngineSession::ServiceL() + RDEBUG_2("CPolicyEngineSession::ServiceError %d",aError); + + CSession2::ServiceError(aMessage,aError); +} + + +// ---------------------------------------------------------------------------------------- +// CSubSessionObjects::CSubSessionObjects() +// ---------------------------------------------------------------------------------------- + +CSubSessionObjects::CSubSessionObjects( CPolicyProcessor * aPolicyProcessor, + CPolicyManager * aPolicyManager, + CTrustedSession * aTrustedSession) + : iPolicyProcessor( aPolicyProcessor), iPolicyManager( aPolicyManager), iTrustedSession( aTrustedSession) +{ + +} + + +// ---------------------------------------------------------------------------------------- +// CSubSessionObjects::NewL() +// ---------------------------------------------------------------------------------------- + +CSubSessionObjects * CSubSessionObjects::NewL( CPolicyProcessor * aPolicyProcessor, + CPolicyManager * aPolicyManager, + CTrustedSession * aTrustedSession) +{ + return new (ELeave) CSubSessionObjects( aPolicyProcessor, aPolicyManager, aTrustedSession); +} + +// ---------------------------------------------------------------------------------------- +// CSubSessionObjects::~CSubSessionObjects() +// ---------------------------------------------------------------------------------------- + +CSubSessionObjects::~CSubSessionObjects() +{ + delete iPolicyProcessor; + delete iPolicyManager; + delete iTrustedSession; +} + + +// ---------------------------------------------------------------------------------------- +// CSubSessionObjects::~CSubSessionObjects() +// ---------------------------------------------------------------------------------------- + +CASyncHandler::CASyncHandler() + : CActive( EPriorityStandard) +{ + RDEBUG("PolicyEngineServer: CASyncHandler constructor( EPriorityStandard) "); +} + +CASyncHandler::~CASyncHandler() +{ + CPolicyEngineServer::RemoveActiveObject( this); +} + + +CASyncHandler* CASyncHandler::NewLC() +{ + CASyncHandler* self = new (ELeave) CASyncHandler(); + CleanupStack::PushL( self); + + RDEBUG("PolicyEngineServer: CASyncHandler created"); + CPolicyEngineServer::AddActiveObjectL( self); + + return self; +} + + +TRequestStatus& CASyncHandler::GetRequestStatus() +{ + RDEBUG("PolicyEngineServer: CASyncHandler::GetRequestStatus()"); + return iStatus; +} + +void CASyncHandler::WaitForRequest() +{ + RDEBUG("PolicyEngineServer: CASyncHandler::WaitForRequest()"); + + CActiveScheduler::Add( this); + SetActive(); + + RDEBUG("PolicyEngineServer: CASyncHandler - WaitScheduler start"); + iWaitScheduler.Start(); + RDEBUG("PolicyEngineServer: CASyncHandler - WaitScheduler stopped"); +} + + +void CASyncHandler::RunL() +{ + RDEBUG("PolicyEngineServer: CASyncHandler::RunL - Stop WaitScheduler!"); + iWaitScheduler.AsyncStop(); +} + +void CASyncHandler::DoCancel() +{ + RDEBUG("PolicyEngineServer: CASyncHandler::DoCancel()"); + iWaitScheduler.AsyncStop(); +} + +