diff -r 7fdc9a71d314 -r 8ad140f3dd41 analyzetool/storageserver/server/src/atstorageserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/analyzetool/storageserver/server/src/atstorageserver.cpp Wed Oct 13 16:17:58 2010 +0300 @@ -0,0 +1,452 @@ +/* +* Copyright (c) 2009 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: Definitions for the class CATStorageServer. Includes also the +* entry point of the atoolstorageserver.exe executable. +* +*/ + + + + +// INCLUDE FILES + +#include "atstorageserver.h" +#include "atstorageserversession.h" +#include "atstorageservercommon.h" +#include "atlog.h" +#include "atdynprocessinfo.h" + + +// CONSTANTS + + +// The amount of different ranges of requests specified for this policy server. +// In a policy server, different actions can be determined for different ranges +// of requests. +const TUint8 KAmountOfRanges = 2; + + +const TInt ranges[KAmountOfRanges] = + { + CATStorageServer::EProcessStarted, + CATStorageServer::EOutOfBounds + }; + + +const TUint8 actionForRange[ KAmountOfRanges ] = + { 0, CPolicyServer::ENotSupported }; + + +const CPolicyServer::TPolicyElement elements[] = + { + + { _INIT_SECURITY_POLICY_C1( ECapability_None ), + CPolicyServer::EFailClient } + + }; + + +const CPolicyServer::TPolicy policy = + { + CPolicyServer::EAlwaysPass, // On connect + KAmountOfRanges, // Range count + ranges, + actionForRange, + elements, + }; + + + +// ENTRY POINT + +TInt E32Main() + { + LOGSTR1( "STSE TInt E32Main() in ATStorageServer.cpp" ); + + __UHEAP_MARK; + + // Create a cleanup stack + CTrapCleanup* cleanup = CTrapCleanup::New(); + + TInt errorCode( KErrNoMemory ); + + // If there was enough memory to create a cleanup stack, + // create and start the server. + if( cleanup ) + { + // If RunServerL() doesn't leave, errorCode will be set to KErrNone + TRAP( errorCode, CATStorageServer::RunServerL() ); + delete cleanup; + } + + // Signal the client that server creation failed, if a leave occured during + // the call to 'RunServerL()' function + if( errorCode != KErrNone ) + { + RProcess::Rendezvous( errorCode ); + } + + __UHEAP_MARKEND; + + return errorCode; + + } + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CATStorageServer::CATStorageServer +// C++ default constructor can NOT contain any code that +// might leave. +// ----------------------------------------------------------------------------- +// +CATStorageServer::CATStorageServer( TInt aPriority ) : + CPolicyServer( aPriority, policy, ESharableSessions ), + iSessionCount( 0 ) + { + LOGSTR1( "STSE CATStorageServer::CATStorageServer()" ); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CATStorageServer::ConstructL() + { + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CATStorageServer* CATStorageServer::NewL() + { + CATStorageServer* self = NewLC(); + CleanupStack::Pop( self ); + + return self; + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CATStorageServer* CATStorageServer::NewLC() + { + CATStorageServer* self = new ( ELeave ) CATStorageServer( EPriorityStandard ); + CleanupStack::PushL( self ); + self->ConstructL(); + self->StartL( KStorageServerName ); + return self; + } + +// Destructor +CATStorageServer::~CATStorageServer() + { + LOGSTR1( "STSE CATStorageServer::~CATStorageServer()" ); + + iProcesses.Close(); + iProcessesDyn.ResetAndDestroy(); + iProcessesDyn.Close(); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::NewSessionL +// Create a new server session. +// ----------------------------------------------------------------------------- +// +CSession2* CATStorageServer::NewSessionL( + const TVersion &aVersion, + const RMessage2& /*aMessage*/ ) const + { + LOGSTR1( "STSE CSession2* CATStorageServer::NewSessionL()" ); + + // The server's version + TVersion version( KVersionNumberMaj, KVersionNumberMin, + KVersionNumberBld ); + + // Check this is a high enough version of the server + if ( !User::QueryVersionSupported(version, aVersion) ) + { + User::Leave( KErrNotSupported ); + } + + // Construct and return a new session object + return CATStorageServerSession::NewL( const_cast(*this) ); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::RunServerL +// Create active scheduler and a server object +// ----------------------------------------------------------------------------- +// +void CATStorageServer::RunServerL() + { + LOGSTR1( "STSE void CATStorageServer::RunServerL()" ); + + // Create and install an active scheduler + CActiveScheduler* activeSched = new (ELeave) CActiveScheduler; + CleanupStack::PushL( activeSched ); + CActiveScheduler::Install( activeSched ); + + // Create server + CATStorageServer::NewLC(); + + // The initialization performed alright, signal the client + RProcess::Rendezvous( KErrNone ); + + // Start the active scheduler + CActiveScheduler::Start(); + + // Remove the server and active scheduler from the cleanup stack + CleanupStack::PopAndDestroy( 2, activeSched ); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::IncSessionCount +// Increments the count of active sessions for this server. +// ----------------------------------------------------------------------------- +// +void CATStorageServer::IncSessionCount() + { + LOGSTR1( "STSE void CATStorageServer::IncSessionCount()" ); + + iSessionCount++; + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::DecSessionCount +// Decrements the count of active sessions for this server. +// ----------------------------------------------------------------------------- +// +void CATStorageServer::DecSessionCount() + { + LOGSTR1( "STSE void CATStorageServer::DecSessionCount()" ); + + iSessionCount--; + + // Cancels all outstanding messages and stops the active scheduler, + // if there are no other sessions open at the moment + if ( iSessionCount <= 0 ) + { + this->Cancel(); + CActiveScheduler::Stop(); + } + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::AddProcessL +// ----------------------------------------------------------------------------- +// +TInt CATStorageServer::AddProcessL( const TDesC8& aProcessName, + TUint aProcessId, + CATStorageServerSession* aSessionObject, + const TInt64& aStartTime ) + { + LOGSTR1( "STSE TInt CATStorageServer::AddProcessL()" ); + + TInt error( KErrNone ); + TATProcessInfo processInfo; + + processInfo.iProcessId = aProcessId; + processInfo.iProcessName.Copy( aProcessName ); + processInfo.iStartTime = aStartTime; + + // Insert the static process info into the iProcesses array + error = iProcesses.InsertInUnsignedKeyOrder( processInfo ); + + // Return if an error occured + if ( error != KErrNone) + { + return error; + } + + // Construct a CATDynProcessInfo object with the given process ID and logging mode + CATDynProcessInfo* dynProcessInfo = + new (ELeave) CATDynProcessInfo( aProcessId, + aSessionObject ); + + // Insert the dynamic process info into the iProcessesDyn array + TLinearOrder order( CATDynProcessInfo::Compare ); + error = iProcessesDyn.InsertInOrder( dynProcessInfo, order ); + + return error; + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::RemoveProcessL +// ----------------------------------------------------------------------------- +// +TInt CATStorageServer::RemoveProcessL( TUint aProcessId ) + { + LOGSTR1( "STSE TInt CATStorageServer::RemoveProcessL()" ); + + TATProcessInfo processInfo; + processInfo.iProcessId = aProcessId; + + TInt index = iProcesses.FindInUnsignedKeyOrder( processInfo ); + + // Return, if a process with the requested process ID was not found + if ( index == KErrNotFound ) + { + return index; + } + + // Remove the TATProcessInfo object at "index" from the array + iProcesses.Remove( index ); + + // Now, start removing the associated dynamic process info object + + // Construct a CATDynProcessInfo object with the given process ID + CATDynProcessInfo* dynProcessInfo = + new (ELeave) CATDynProcessInfo( aProcessId ); + + // Find the index of a CATDynProcessInfo object with the given ID in the array + TLinearOrder order( CATDynProcessInfo::Compare ); + index = iProcessesDyn.FindInOrder( dynProcessInfo, order ); + delete dynProcessInfo; + dynProcessInfo = NULL; + + // Return, if a process with the requested process ID was not found + if ( index == KErrNotFound ) + { + return index; + } + + // Otherwise, delete the object and remove the pointer at "index" + delete iProcessesDyn[index]; + iProcessesDyn.Remove( index ); + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::AddDllL +// ----------------------------------------------------------------------------- +// +TInt CATStorageServer::AddDllL( TUint aProcessId, + const TATDllInfo aDllInfo ) + { + LOGSTR1( "STSE TInt CATStorageServer::AddDllL()" ); + + // Construct a CATDynProcessInfo object with the given process ID + CATDynProcessInfo* dynProcessInfo = + new (ELeave) CATDynProcessInfo( aProcessId ); + + // Find out if a process with this ID can be found in the dynamic process array + TLinearOrder order( CATDynProcessInfo::Compare ); + TInt index = iProcessesDyn.FindInOrder( dynProcessInfo, order ); + delete dynProcessInfo; + dynProcessInfo = NULL; + + // Return, if a process with the requested process ID was not found + if ( index == KErrNotFound ) + { + return index; + } + + // If we are here, the wanted process was found at index => append a DLL for it + dynProcessInfo = iProcessesDyn[index]; + + // Get the DLL array from this dynamic process info object + RArray& dllArray = dynProcessInfo->iDlls; + + // Let's see if the DLL to be added already exists + TIdentityRelation matcher( TATDllInfo::Match ); + index = dllArray.Find( aDllInfo, matcher ); + + // If so, return KErrAlreadyExists + if ( index != KErrNotFound ) + { + return KErrAlreadyExists; + } + + // Otherwise append this DLL to the array and return + return dynProcessInfo->iDlls.Append( aDllInfo ); + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::RemoveDllL +// ----------------------------------------------------------------------------- +// +TInt CATStorageServer::RemoveDllL( TUint aProcessId, + const TDesC8& aDllName ) + { + LOGSTR1( "STSE TInt CATStorageServer::RemoveDllL()" ); + + // Construct a CATDynProcessInfo object with the given process ID + CATDynProcessInfo* dynProcessInfo = + new (ELeave) CATDynProcessInfo( aProcessId ); + + // Find out if a process with this ID can be found in the dynamic process array + TLinearOrder order( CATDynProcessInfo::Compare ); + TInt index = iProcessesDyn.FindInOrder( dynProcessInfo, order ); + delete dynProcessInfo; + dynProcessInfo = NULL; + + // Return, if a process with the requested process ID was not found + if ( index == KErrNotFound ) + { + return index; + } + + // If we are here, the wanted process was found at index + dynProcessInfo = iProcessesDyn[index]; + + // Get the DLL array from this dynamic process info object + RArray& dllArray = dynProcessInfo->iDlls; + + // Try to find wanted DLL + TIdentityRelation matcher( TATDllInfo::Match ); + index = dllArray.Find( TATDllInfo( 0, 0, 0, aDllName ), matcher ); + + // Return, if a process with the requested process ID was not found + if ( index == KErrNotFound ) + { + return index; + } + + // Otherwise remove the found DLL at "index" + dllArray.Remove( index ); + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::ProcessInfoArray +// ----------------------------------------------------------------------------- +// +const RArray& CATStorageServer::ProcessInfoArray() + { + LOGSTR1( "STSE RArray& CATStorageServer::ProcessInfoArray()" ); + + return iProcesses; + } + +// ----------------------------------------------------------------------------- +// CATStorageServer::DynProcessInfoArray +// ----------------------------------------------------------------------------- +// +const RPointerArray& CATStorageServer::DynProcessInfoArray() + { + LOGSTR1( "STSE RPointerArray& CATStorageServer::DynProcessInfoArray()" ); + + return iProcessesDyn; + } + +// End of File