/*

* 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 and constants for the class CATStorageServerSession

*

*/

// INCLUDE FILES

#include    <utf.h>

#include    <analyzetool/analyzetooltraceconstants.h>

#include    "atstorageserversession.h"

#include    "atstorageserver.h"

#include    "atstorageservercommon.h"

#include    "atmemoryentry.h"

#include    "atlog.h"

#include    "atdynprocessinfo.h"

#include    "atdriveinfo.h"

// CONSTANTS

// New file name start and end index.

const TInt KNameIndexStart = 1;

const TInt KNameIndexEnd = 100;

// ==================== MEMBER FUNCTIONS for TAllocInfo ========================

// -----------------------------------------------------------------------------

// TAllocInfo::TAllocInfo

// Implementation for the constructor of the class TAllocInfo

// -----------------------------------------------------------------------------

//

TAllocInfo::TAllocInfo( TUint32 aMemAddress, TInt aAllocSize ) :

    iMemAddress( aMemAddress ),

    iAllocSize( aAllocSize )

    {

    }

// ============== MEMBER FUNCTIONS for CATStorageServerSession =================

// -----------------------------------------------------------------------------

// CATStorageServerSession::CATStorageServerSession

// C++ default constructor. It Does not contain any code that

// might leave.

// -----------------------------------------------------------------------------

//

CATStorageServerSession::CATStorageServerSession( CATStorageServer& aStorageServer ) :

    iStorageServer( aStorageServer ),

    iError( 0 ),

    iLeakArray( KLeakArrayGranularity ),

    iProcessId( KNullProcessId ),

    iLoggingOngoing( EFalse ),

    iLogOption( KDefaultLoggingMode ),

    iCurAllocSize( 0 ),

    iMaxAllocs( 0 ),

    iMaxAllocSize( 0 ),

    iLogFile( KEmpty() ),

    iIsUdeb( 1 )

    {

    LOGSTR1( "STSE CATStorageServerSession::CATStorageServerSession()" );

    // Initialize iMicroSecondsAt1970

    TTime time( KJanuaryFirst1970 );

    iMicroSecondsAt1970 = time.Int64();

    // Increment the server's session count by one (1)

    iStorageServer.IncSessionCount();

    }

// -----------------------------------------------------------------------------

// CATStorageServerSession::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CATStorageServerSession::ConstructL()

    {

    // Intentionally left empty

    }

// -----------------------------------------------------------------------------

// CATStorageServerSession::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CATStorageServerSession* CATStorageServerSession::NewL( CATStorageServer& aStorageServer )

    { 

    CATStorageServerSession* self = NewLC( aStorageServer );

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CATStorageServerSession::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CATStorageServerSession* CATStorageServerSession::NewLC( CATStorageServer& aStorageServer )

    { 

    CATStorageServerSession* self = new ( ELeave ) CATStorageServerSession( aStorageServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// -----------------------------------------------------------------------------

// CATStorageServerSession::~CATStorageServerSession

// Destructor

// -----------------------------------------------------------------------------

CATStorageServerSession::~CATStorageServerSession()

    {

    LOGSTR1( "STSE CATStorageServerSession::~CATStorageServerSession()" );

    // Empty the array and delete the referenced objects

    iLeakArray.ResetAndDestroy();

    // Close the leak array

    iLeakArray.Close();

    // Close the allocation info array

    iAllocInfoArray.Close();

    // Check if process closed abnormal

    if ( iProcessId != KNullProcessId && 

         iLoggingOngoing && iLogOption != EATLoggingOff && 

         iError != KErrNoMemory )

        {

        LogAbnormalEnd();

        }

    // Close the file and the handle to the file server

    CloseFsAndFile();

    // Remove the process with the current PID from the server's array of processes

    TRAP_IGNORE( iStorageServer.RemoveProcessL( iProcessId ) );

    // Decrement the server's session count by one (1)

    iStorageServer.DecSessionCount();

    }

// -----------------------------------------------------------------------------

// CATStorageServerSession::ServiceL

// This function is called by the client/server framework

// -----------------------------------------------------------------------------

//

void CATStorageServerSession::ServiceL( const RMessage2& aMessage )

    {

    LOGSTR1( "STSE void CATStorageServerSession::ServiceL()" );

    // If logging has been cancelled for this session, return immediately

    if( iLogOption == EATLoggingOff )

        {

        aMessage.Complete( KErrCancel );

        return;

        }

    switch ( aMessage.Function() )

        {

        case CATStorageServer::EProcessStarted:

            {

            // If logging is not ongoing, set the log option

            if( !iLoggingOngoing )

                {

                // Set the operation mode

                SetLogOption( aMessage );

                }

            switch ( iLogOption )

                {

                case EATLogToTrace:

                    {

                    iError = LogProcessStartTraceL( aMessage );

                    }

                break;

                case EATLogToFile:

                    {

                    iError = LogProcessStartedL( aMessage );

                    }

                break;

                default:

                    {

                    // Panic the client and set iError KErrCancel, because being

                    // here implies that an illegal log option has been given.

                    PanicClient( EAToolIllegalLogOption, aMessage );

                    iError = KErrCancel;

                    }

                break;

                }

            } 

        break;

        case CATStorageServer::EDllLoaded:

            {

            switch ( iLogOption )

                {

                case EATLogToTrace:

                    {

                    iError = LogDllLoadTraceL( aMessage );

                    }

                break;

                case EATLogToFile:

                    {

                    iError = LogDllLoadedL( aMessage );

                    }

                break;

                default:

                    {

                    // Panic the client and set iError KErrCancel, because being

                    // here implies that an illegal log option has been given.

                    PanicClient( EAToolIllegalLogOption, aMessage );

                    iError = KErrCancel;

                    }

                break;

                }

            }

        break;

        case CATStorageServer::EDllUnloaded:

            {

            switch ( iLogOption )

                {

                case EATLogToTrace:

                    {

                    iError = LogDllUnloadTraceL( aMessage );

                    }

                break;

                case EATLogToFile:

                    {

                    iError = LogDllUnloadedL( aMessage );

                    }

                break;

                default:

                    {

                    // Panic the client and set iError KErrCancel, because being

                    // here implies that an illegal log option has been given.

                    PanicClient( EAToolIllegalLogOption, aMessage );

                    iError = KErrCancel;

                    }

                break;

                }

            }

        break;

        case CATStorageServer::EMemoryAllocated:

            {

            switch ( iLogOption )

                {

                case EATLogToTrace:

                    {

                    iError = LogMemoryAllocTraceL( aMessage );

                    }

                break;

                case EATLogToFile:

                    {

                    iError = LogMemoryAllocatedL( aMessage );

                    }

                break;

                default:

                    {

                    // Panic the client and set iError KErrCancel, because being

                    // here implies that an illegal log option has been given.

                    PanicClient( EAToolIllegalLogOption, aMessage );

                    iError = KErrCancel;

                    }

                break;

                }

            }

        break;

        case CATStorageServer::EMemoryFreed:

            {

            switch ( iLogOption )

                {

                case EATLogToTrace:

                    {

                    iError = LogMemoryFreedTraceL( aMessage );

                    }

                break;

                case EATLogToFile:

                    {

                    iError = LogMemoryFreedL( aMessage );

                    }

                break;

                default:

                    {

                    // Panic the client and set iError KErrCancel, because being

                    // here implies that an illegal log option has been given.

                    PanicClient( EAToolIllegalLogOption, aMessage );

                    iError = KErrCancel;

                    }

                break;

                }

            }

        break;

        case CATStorageServer::EProcessEnded:

            {

            switch ( iLogOption )

                {

                case EATLogToTrace:

                    {

                    iError = LogProcessEndTraceL( aMessage );

                    }

                break;

                case EATLogToFile:

                    {

                    iError = LogProcessEndedL( aMessage );

                    }

                break;

                default:

                    {

                    // Panic the client and set iError KErrCancel, because being

                    // here implies that an illegal log option has been given.

                    PanicClient( EAToolIllegalLogOption, aMessage );

                    iError = KErrCancel;

                    }

                break;

                }

            }

        break;

        case CATStorageServer::EMemoryCheck:

            {

            switch ( iLogOption )

                {

                case EATLogToTrace:

                    {

                    iError = CheckMemoryAddressTrace( aMessage );

                    }

                break;

                case EATLogToFile:

                    {

                    iError = CheckMemoryAddressL( aMessage );

                    }

                break;

                default:

                    {

                    // Panic the client and set iError KErrCancel, because being

                    // here implies that an illegal log option has been given.

                    PanicClient( EAToolIllegalLogOption, aMessage );

                    iError = KErrCancel;

                    }

                break;

                }

            }

        break;

        case CATStorageServer::EGetProcesses:

            {

            iError = GetProcessesL( aMessage );

            }

        break;

        case CATStorageServer::EGetDlls:

            {

            iError = GetDllsL( aMessage );

            }

        break;

        case CATStorageServer::EGetLoggingMode:

            {

            iError = GetLoggingModeL( aMessage );

            }

        break;

        case CATStorageServer::ESubtestStart:

            {

            iError = StartSubtestL( aMessage );

            }

        break;

        case CATStorageServer::ESubtestStop:

            {

            iError = StopSubtestL( aMessage );

            }

        break;

        case CATStorageServer::ESubtestStart2:

            {

            iError = StartSubtest2L( aMessage );

            }

        break;

        case CATStorageServer::ESubtestStop2:

            {

            iError = StopSubtest2( aMessage );

            }

        break;

        case CATStorageServer::EGetCurrentAllocs:

            {

            iError = GetCurrentAllocsL( aMessage );

            }

        break;

        case CATStorageServer::EGetMaxAllocs:

            {

            iError = GetMaxAllocsL( aMessage );

            }

        break;

        case CATStorageServer::ECancelLogging:

            {

            iError = CancelLoggingL( aMessage );

            }

        break;

        case CATStorageServer::EGetUdeb:

            {

            iError = GetUdebL( aMessage );

            }

        break;

        case CATStorageServer::EGetLoggingFile:

            {

            iError = GetLoggingFileL( aMessage );

            }

        break;

        case CATStorageServer::EProcessUdeb:

            {

            SetUdeb( aMessage );

            }

        break;

        case CATStorageServer::EIsMemoryAdded:

            {

            iError = IsMemoryAdded( aMessage );

            LOGSTR2( "STSE > IsMemoryAdded err = %i", iError );

            }

        break;       

        default:

            {

            // Panic both the client and server, because being here implies

            // that there is an internal error in the client/server.

            PanicClient( EAToolBadRequest, aMessage );

            StorageServerPanic( KCategoryServer, EAToolBadRequest );

            }

        break;

        }

    // Complete the message, if it has not been already cancelled.

    if ( iError != KErrCancel )

        {

        // Log the error code. Only KErrNoMemory errors are logged.

        if ( iLogOption == EATLogToFile && iError == KErrNoMemory  )

            {

            HandleError( iError );

            }

        else if ( iLogOption == EATLogToTrace && iError == KErrNoMemory )

            {

            HandleErrorTrace( iError );

            }

        // Complete serving the message 

        aMessage.Complete( iError );

        }

    }

// -----------------------------------------------------------------------------

// CATStorageServerSession::LogProcessStartedL()

// Opens a logging file with the requested name and then writes information

// on process start into the file.

// -----------------------------------------------------------------------------

//

TInt CATStorageServerSession::LogProcessStartedL( const RMessage2& aMessage )

    {

    LOGSTR1( "STSE TInt CATStorageServerSession::LogProcessStartedL()" );

    // Panic the client and return, if this method has already been called for this

    // session object (and a logging file has been opened)

    if ( iLoggingOngoing )

        {

        PanicClient( EAToolNotAllowed, aMessage );

        return KErrCancel;

        }

    iError = KErrNone;

    LOGMEM;

    // READ THE FIRST ARGUMENT (descriptor)  

    // Length of the first argument (index 0)

    TInt length = aMessage.GetDesLength( 0 );

    LOGSTR2( "STSE length of the fileName: %i", length );

    // Return if errors

    if ( length == KErrArgument || length == KErrBadDescriptor )

        {