diff -r 000000000000 -r b497e44ab2fc policymanagement/policyengine/centreptoolserver/src/CentRepToolServer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/policymanagement/policyengine/centreptoolserver/src/CentRepToolServer.cpp Thu Dec 17 09:07:52 2009 +0200 @@ -0,0 +1,466 @@ +/* +* 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 "CentRepToolServer.h" +#include "RepositorySession.h" +#include "debug.h" + +#include "CentRepToolClientServer.h" +#include + + +// ---------------------------------------------------------------------------------------- +// Server startup code +// ---------------------------------------------------------------------------------------- + +static void RunServerL() + { + // naming the server thread after the server helps to debug panics + User::LeaveIfError(User::RenameThread(KCentRepToolServerName)); + + // 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) + CCentRepToolServer::NewLC(); + // Initialisation complete, now signal the client + + RProcess::Rendezvous(KErrNone); + + // Ready to run + RDEBUG("Centrep tool server is running"); + CActiveScheduler::Start(); + + // Cleanup the server and scheduler + CleanupStack::PopAndDestroy(2); + } + +// Server process entry-point +TInt E32Main() + { + __UHEAP_MARK; + RDEBUG( "CentRepToolServer: E32Main"); + CTrapCleanup* cleanup=CTrapCleanup::New(); + TInt r=KErrNoMemory; + if (cleanup) + { + TRAP(r,RunServerL()); + delete cleanup; + } + __UHEAP_MARKEND; + return r; + } + +// RMessagePtr2::Panic() also completes the message. This is: +// (a) important for efficient cleanup within the kernel +// (b) a problem if the message is completed a second time +void PanicClient(const RMessagePtr2& aMessage, TCentRepToolServerPanic aPanic) + { + RDEBUG("CentRepTool PanicClient"); + aMessage.Panic( IniConstants::KCentRepToolPanic,aPanic); + } + + +// ---------------------------------------------------------------------------------------- +// CShutDown +// ---------------------------------------------------------------------------------------- +inline CShutdown::CShutdown() + :CTimer(-1) + { + CActiveScheduler::Add(this); + } + +inline void CShutdown::ConstructL() + { + CTimer::ConstructL(); + } + +inline void CShutdown::Start() + { + RDEBUG("CentRepToolServer: starting shutdown timeout"); + After(KPolicyEngineShutdownDelay); + } + +void CShutdown::RunL() + { + RDEBUG("CentRepToolServer timeout ... closing"); + CActiveScheduler::Stop(); + } + +// ---------------------------------------------------------------------------------------- +// CPolicyEngineServer +// ---------------------------------------------------------------------------------------- +inline CCentRepToolServer::CCentRepToolServer() + :CPolicyServer(0, CentRepToolSecurityPolicy,ESharableSessions) + { + } + +CServer2* CCentRepToolServer::NewLC() + { + CentRepToolSecurityPolicy.iOnConnect = KCentRepToolSecurityElementsIndex[2]; //Specifis that only policy engine may connect to server + CentRepToolSecurityPolicy.iRangeCount = KCentRepToolRangeCount; //number of ranges + CentRepToolSecurityPolicy.iRanges = KCentRepToolRanges; + CentRepToolSecurityPolicy.iElementsIndex = KCentRepToolSecurityElementsIndex; + CentRepToolSecurityPolicy.iElements = KCentRepToolSecurityElements; + + RDEBUG("CentRepToolServer: CentRepToolServer::NewLC"); + + CCentRepToolServer* self=new(ELeave) CCentRepToolServer; + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CCentRepToolServer::~CCentRepToolServer() +{ + delete iContainerIndex; +} + +// 2nd phase construction - ensure the timer and server objects are running +void CCentRepToolServer::ConstructL() + { + StartL(KCentRepToolServerName); + + iContainerIndex = CObjectConIx::NewL(); + + iShutdown.ConstructL(); + // ensure that the server still exits even if the 1st client fails to connect + iShutdown.Start(); + } + + +// Create a new client session. This should really check the version number. +CSession2* CCentRepToolServer::NewSessionL(const TVersion&,const RMessage2&) const + { + RDEBUG("CentRepToolServer: CCentRepToolServer::NewSessionL"); + return new (ELeave) CCentRepToolSession(); + } + +// A new session is being created +// Cancel the shutdown timer if it was running +void CCentRepToolServer::AddSession() + { + RDEBUG("CentRepToolServer: CPolicyEngineServer::AddSession"); + ++iSessionCount; + iShutdown.Cancel(); + } + +// A session is being destroyed +// Start the shutdown timer if it is the last session. +void CCentRepToolServer::DropSession() + { + RDEBUG("CentRepToolServer: CPolicyEngineServer::DropSession"); + if (--iSessionCount==0) + iShutdown.Start(); + } + +CObjectCon* CCentRepToolServer::NewContainerL() + { + return iContainerIndex->CreateL(); + } + +inline CCentRepToolSession::CCentRepToolSession() + { + RDEBUG("CentRepToolServer: CCentRepToolSession::CCentRepToolSession"); + } + +inline CCentRepToolServer& CCentRepToolSession::Server() + { + return *static_cast(const_cast(CSession2::Server())); + } + +// 2nd phase construct for sessions - called by the CServer framework +void CCentRepToolSession::CreateL() + { + RDEBUG("CentRepTool Server: CCentRepToolSession::CreateL"); + + iRepositorySessions = CObjectIx::NewL(); + iContainer = Server().NewContainerL(); + + Server().AddSession(); + } + +CCentRepToolSession::~CCentRepToolSession() + { + RDEBUG("CentRepTool Server: CCentRepToolSession::~CCentRepToolSession"); + + delete iRepositorySessions; + + Server().DropSession(); + } + + + + + + +void CCentRepToolSession::ServiceL(const RMessage2& aMessage) +{ + iCurrentSession = 0; + TRAPD(err,DispatchMessageL(aMessage)); + + aMessage.Complete(err); +} + +void CCentRepToolSession::DispatchMessageL(const RMessage2& aMessage) + { + //Subsession management + switch (aMessage.Function()) + { + case ECreateRepositorySubSession: + case ECreateCheckAccessSession: + { + RDEBUG("CentRepTool: New repository session"); + NewRepositorySessionL( aMessage); + return; + } + case ECloseRepositorySubSession: + case ECloseCheckAcceessSession: + { + RDEBUG("CentRepTool: Close repository session"); + DeleteRepositorySession( aMessage); + return; + } + case ECheckCommitState : + { + RDEBUG("CentRepTool: Check last commit state"); + CRepositorySession::CheckCommitStateL(); + return; + } + case EPerformCentRepToolRFS : + { + RDEBUG("CentRepTool: Perform RFS"); + PerformRFSL(); + return; + } + } + + //Trusted session operations + CRepositorySession * repositorySession = RepositorySessionFromHandle( aMessage); + iCurrentSession = repositorySession; + + switch (aMessage.Function()) + { + case EInitRepositorySession: + { + RDEBUG("CentRepTool: Init repository session"); + repositorySession->InitRepositorySessionL(); + } + break; + case ESetSIDWRForSetting : + { + RDEBUG("CentRepTool: Add SID for individual setting"); + repositorySession->SetSecurityIdForSettingL( aMessage); + } + break; + case ESetSIDWRForRange: + { + RDEBUG("CentRepTool: Add SID for range"); + repositorySession->SetSecurityIdForRangeL( aMessage); + } + break; + case ERestoreSetting : + { + RDEBUG("CentRepTool: Restore individual setting"); + repositorySession->RestoreSettingL( aMessage); + } + break; + case ERestoreRange : + { + RDEBUG("CentRepTool: Restore range"); + repositorySession->RestoreRangeL( aMessage); + } + break; + case EAddSIDWRForDefaults : + { + RDEBUG("CentRepTool: Add SID for all settings (default, range, mask)"); + repositorySession->AddSidForDefaultsL( aMessage); + } + break; + case ERestoreDefaults : + { + RDEBUG("CentRepTool: "); + RDEBUG("CentRepTool: Remove SID from all settings (default, range, mask)"); + repositorySession->RestoreDefaultsL( aMessage); + } + break; + case EFlushRepository : + { + RDEBUG("CentRepTool: Commit security changes in repository"); + repositorySession->CommitRepositoryL(); + } + break; + case ESetSIDWRForMask : + { + RDEBUG("CentRepTool: Set SID for mask setting"); + repositorySession->SetSecurityIdForMaskL( aMessage); + } + break; + case ERestoreMask : + { + RDEBUG("CentRepTool: Restore mask setting"); + repositorySession->RestoreMaskL( aMessage); + } + break; + case ERemoveBackupFlagForMask: + { + RDEBUG("CentRepTool: Set backup flag for mask"); + repositorySession->RemoveBackupForMaskL( aMessage); + } + break; + case ERestoreBackupFlagForMask: + { + RDEBUG("CentRepTool: Restore backup flag for mask"); + repositorySession->RestoreMaskBackupL( aMessage); + } + break; + case ERemoveBackupFlagForDefaults: + { + RDEBUG("CentRepTool: Set backup flag for defaults"); + repositorySession->RemoveDefaultBackup(); + } + break; + case ERestoreBackupFlagForDefaults: + { + RDEBUG("CentRepTool: Restore backup flag for defaults"); + repositorySession->RestoreDefaultBackupL(); + } + break; + case ERemoveBackupFlagForRange: + { + RDEBUG("CentRepTool: Set backup flag for range"); + repositorySession->RemoveBackupForRangeL( aMessage); + } + break; + case ERestoreBackupFlagForRange: + { + RDEBUG("CentRepTool: Restore backup flag for range"); + repositorySession->RestoreRangeBackupL( aMessage); + } + break; + case ECheckAccess: + { + RDEBUG("CentRepTool: Check access"); + repositorySession->CheckAccessL( aMessage); + } + break; + default: + break; + } + +} + +void CCentRepToolSession::PerformRFSL() +{ + RDEBUG("CentRepToolSession: Restore factory setting operation started"); + //RFS tasks in centrep tool + // 1. restory setting enforcements + // 2. remove backup and temp files from private directory + + + //clean private directory + RFs rfs; + TInt err = rfs.Connect(); + if( err != KErrNone ) + { + RDEBUG_2("**** CCentRepToolSession::PerformRFSL() - failed to connect to RFs: %d", err ); + return; + } + + CleanupClosePushL( rfs); + + TBuf<100> privatePath; + 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("CentRepToolSession: Restore factory setting operation finished"); +} + + +CRepositorySession* CCentRepToolSession::RepositorySessionFromHandle( const RMessage2& aMessage) + { + CRepositorySession* repositorySession = (CRepositorySession*)iRepositorySessions->At(aMessage.Int3()); + + if (repositorySession == NULL) + { + PanicClient( aMessage, EBadSubsessionHandle); + } + + return repositorySession; + } + + +// Create a new counter; pass back its handle via the message +void CCentRepToolSession::NewRepositorySessionL( const RMessage2& aMessage) + { + + TUid repositoryUid; + TPckg repositoryUidPack( repositoryUid); + aMessage.ReadL(0, repositoryUidPack); + + //add new CTrustedSession object into container and object index + CRepositorySession * repositorySession = CRepositorySession::NewL( repositoryUid); + + iContainer->AddL( repositorySession); + TInt handle = iRepositorySessions->AddL( repositorySession); + + //transmit handle to client + TPckg handlePckg(handle); + TRAPD( r, aMessage.WriteL(3, handlePckg)) + + if ( r != KErrNone) + { + iRepositorySessions->Remove(handle); + PanicClient( aMessage, EBadDescriptor); + return; + } + + iSubsessionCount++; + } + +void CCentRepToolSession::DeleteRepositorySession( const RMessage2& aMessage) +{ + // panic if bad handle + CRepositorySession* repositorySession = (CRepositorySession*)iRepositorySessions->At(aMessage.Int3()); + if (repositorySession == NULL) + PanicClient( aMessage, EBadSubsessionHandle); + iRepositorySessions->Remove(aMessage.Int3()); + + iSubsessionCount--; +} + + +// Handle an error from CentRepTool::ServiceL() +void CCentRepToolSession::ServiceError(const RMessage2& aMessage,TInt aError) + { + RDEBUG_2("CentRepTool: CentRepTool::ServiceError %d",aError); + CSession2::ServiceError(aMessage,aError); + }