/*

* 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 client side handle class RATStorageServer

*

*/

// INCLUDE FILES

#include    "atstorageserverclnt.h"

#include    "atstorageserver.h"

#include    "atlog.h"

#include    "atstorageservercommon.h"

// CONSTANTS

// ============================ MEMBER FUNCTIONS ===============================

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

// RATStorageServer::RATStorageServer

// C++ default constructor.

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

//

EXPORT_C RATStorageServer::RATStorageServer() :

    RSessionBase(), iStackBuf( NULL )

    {

    LOGSTR1( "STSE RATStorageServer::RATStorageServer()" );

    }

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

// RATStorageServer::Connect

// A function for connecting to the server

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

//

EXPORT_C TInt RATStorageServer::Connect()

    {

    LOGSTR1( "STSE TInt RATStorageServer::Connect()" );

    TInt errorCode( KErrNone );

    errorCode = CreateProcess();

    // If process's creation failed, return the error code

    if ( errorCode != KErrNone )

        {

        return errorCode;

        }

    // Otherwise create a new session    

    errorCode = CreateSession( KStorageServerName, Version() );

    // If creation of a new session failed, return the error code

    if ( errorCode != KErrNone )

        {

        return errorCode;

        }

    // Construct a buffer for call stack's memory addresses. If the function leaves,

    // the leave code is put in "errorCode". 

    TRAP( errorCode, ConstructBuffersL() ); 

    return errorCode;

    }

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

// RATStorageServer::Close

// Destroys all memory reserved by this class, and calls RSessionBase::Close()

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

//

EXPORT_C void RATStorageServer::Close()

    {

    LOGSTR1( "STSE void RATStorageServer::Close()" );

    // Delete iStackBuf

    delete iStackBuf;

    iStackBuf = NULL;

    // Call the base class' Close()

    RSessionBase::Close(); 

    }

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

// RATStorageServer::LogProcessStarted

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

//

EXPORT_C TInt RATStorageServer::LogProcessStarted( const TDesC& aFileName,

                                                   const TDesC8& aProcessName,

                                                   TUint aProcessId,

                                                   TUint32 aLogOption, TUint32 aIsDebug )

    {

    LOGSTR1( "STSE TInt RATStorageServer::LogProcessStarted()" );

    // Panic always if aFileName or aProcessName are longer than allowed.

    __ASSERT_ALWAYS( aFileName.Length() <= KMaxFileName &&

                     aProcessName.Length() <= KMaxProcessName,

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    // Panic (in debug builds) if aProcessId is KNullProcessId

    __ASSERT_DEBUG( aProcessId != KNullProcessId,

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    // This information is optional -> ignoring error

    // Must be before EProcessStarted in order to append udeb/urel

    // information to LogProcessStarted

    TIpcArgs ipcArgs2( aIsDebug );

    SendReceive( CATStorageServer::EProcessUdeb, ipcArgs2 );

    TIpcArgs ipcArgs( &aFileName, &aProcessName, aProcessId, aLogOption );

    TInt error( 0 );

    error = SendReceive( CATStorageServer::EProcessStarted, ipcArgs );

    // Return, if error is not KErrNone.

    if ( error != KErrNone )

        {

        return error;

        }

    return KErrNone;

    }

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

// RATStorageServer::LogDllLoaded

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

//

EXPORT_C TInt RATStorageServer::LogDllLoaded( const TDesC8& aDllName,

                                              TUint32 aStartAddress,

                                              TUint32 aEndAddress )

    {

    LOGSTR1( "STSE TInt RATStorageServer::LogDllLoaded()" );

    // Panic always if aDllName is longer than allowed.

    __ASSERT_ALWAYS( aDllName.Length() <= KMaxLibraryName,

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    // Panic (in debug builds) if aStartAddress is greater than aEndAddress

    __ASSERT_DEBUG( aStartAddress <= aEndAddress,

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    TIpcArgs ipcArgs( &aDllName, aStartAddress, aEndAddress );

    return SendReceive( CATStorageServer::EDllLoaded, ipcArgs );

    }

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

// RATStorageServer::LogDllUnloaded

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

//

EXPORT_C TInt RATStorageServer::LogDllUnloaded( const TDesC8& aDllName,

                                                TUint32 aStartAddress,

                                                TUint32 aEndAddress )

    {

    LOGSTR1( "STSE TInt RATStorageServer::LogDllUnloaded()" );

    // Panic always if aDllName is longer than allowed.

    __ASSERT_ALWAYS( aDllName.Length() <= KMaxLibraryName,

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    // Panic (in debug builds) if aStartAddress is greater than aEndAddress

    __ASSERT_DEBUG( aStartAddress <= aEndAddress,

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    TIpcArgs ipcArgs( &aDllName, aStartAddress, aEndAddress );

    return SendReceive( CATStorageServer::EDllUnloaded, ipcArgs );

    }    

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

// RATStorageServer::LogMemoryAllocated

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

//

EXPORT_C TInt RATStorageServer::LogMemoryAllocated( TUint32 aMemAddress,

                                                    TFixedArray<TUint32, KATMaxCallstackLength>& aCallstack,

                                                    TInt aSize )

    {

    LOGSTR1( "STSE TInt RATStorageServer::LogMemoryAllocated()" );

    TInt count=0;

    // The number of memory addresses in aCallstack

    for ( TInt i = 0; i < KATMaxCallstackLength; i++ )

        {

        if( aCallstack[i] == 0 )

            {

            break;

            }

        count++;

        }

    LOGSTR2( "STSE The number of memory addresses in the current call stack: %d", count );

    // The maximum number of call stack's memory addresses this server can handle

    // is KMaxCallstackLength

    if ( count > KATMaxCallstackLength )

        {

        count = KATMaxCallstackLength;

        }

    // Panic (in debug builds) if the parameters are faulty

    __ASSERT_DEBUG( aMemAddress != 0 && count >= 0 && aSize >= 0,

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    // Buffer position

    TInt pos = 0;  

    TUint32 callStackAddr;

    // Write the number of memory addresses of aCallstack (one word) into

    // the beginning of the call stack buffer

    iStackBuf->Write( pos, &count, KWordSize );

    // Increase the position by one word

    pos += KWordSize; 

    // Write all the memory addresses of aCallStack into the buffer 

    for ( TInt i = 0; i < count; i++ )

        {

        callStackAddr = aCallstack[i];

        // Write the current memory address (the length of an address is one word)

        iStackBuf->Write( pos, &callStackAddr, KWordSize ); 

        // Move the pos variable one word (4 bytes) onwards.

        pos += KWordSize;        

        }  

    TPtr8 bufPtr( iStackBuf->Ptr(0) );       

    TIpcArgs ipcArgs( aMemAddress, &bufPtr, aSize );

    return SendReceive( CATStorageServer::EMemoryAllocated, ipcArgs );  

    }

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

// RATStorageServer::LogMemoryFreed

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

//

EXPORT_C TInt RATStorageServer::LogMemoryFreed( TUint32 aMemAddress,

        TFixedArray<TUint32, KATMaxFreeCallstackLength>& aFreeCallstack )

    {

    LOGSTR1( "STSE TInt RATStorageServer::LogMemoryFreed()" );

    TInt count=0;

    // The number of memory addresses in aFreeCallstack

    for ( TInt i = 0; i < KATMaxCallstackLength; i++ )

        {

        if( aFreeCallstack[i] == 0 )

            {

            break;

            }

        count++;

        }

    LOGSTR3( "STSE > aFreeCallstack.Count() ( %i ), address( %x )", 

    		count, aMemAddress );

    // The maximum number of call stack's memory addresses this server can handle

	// is KMaxCallstackLength

	if ( count > KATMaxFreeCallstackLength )

		{

		count = KATMaxFreeCallstackLength;

		}

	// Buffer position

	TInt pos = 0;	

	TUint32 callStackAddr;

	// Write the number of memory addresses of aFreeCallstack (one word) into

	// the beginning of the call stack buffer

	iStackBuf->Write( pos, &count, KWordSize );

	// Increase the position by one word

	pos += KWordSize; 

	// Write all the memory addresses of aFreeCallstack into the buffer 

	for ( TInt i = 0; i < count; i++ )

		{

		callStackAddr = aFreeCallstack[i];

		// Write the current memory address (the length of an address is one word)

		iStackBuf->Write( pos, &callStackAddr, KWordSize ); 

		// Move the pos variable one word (4 bytes) onwards.

		pos += KWordSize;        

		}  

	TPtr8 bufPtr( iStackBuf->Ptr( 0 ) );	 

	TIpcArgs ipcArgs( aMemAddress, &bufPtr );

    return SendReceive( CATStorageServer::EMemoryFreed, ipcArgs );

    }        

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

// RATStorageServer::LogProcessEnded

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

//

EXPORT_C TInt RATStorageServer::LogProcessEnded( TUint aProcessId,

                                                 TUint aHandleLeaks )

    {

    LOGSTR1( "STSE TInt RATStorageServer::LogProcessEnded()" );

    // Panic (in debug builds) if the parameters are faulty

    __ASSERT_DEBUG( aProcessId != KNullProcessId,        

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    TIpcArgs ipcArgs( aProcessId, aHandleLeaks );

    return SendReceive( CATStorageServer::EProcessEnded, ipcArgs );

    }

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

// RATStorageServer::Version()

// Returns the version number.

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

//

EXPORT_C TVersion RATStorageServer::Version() const

    {

    LOGSTR1( "STSE TInt RATStorageServer::Version()" );

    return TVersion(KLowestVersionNumberMaj, KLowestVersionNumberMin,

                                                KLowestVersionNumberBld);

    }

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

// RATStorageServer::CheckMemoryAddress

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

//

EXPORT_C TInt RATStorageServer::CheckMemoryAddress( TUint32 aMemAddress ) const

    {

    LOGSTR1( "STSE TInt RATStorageServer::CheckMemoryAddress()" );

    // Panic (in debug builds) if the parameters are faulty

    __ASSERT_DEBUG( aMemAddress != 0, 

            StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    TIpcArgs ipcArgs( aMemAddress );

    return SendReceive( CATStorageServer::EMemoryCheck, ipcArgs ); 

    }

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

// RATStorageServer::GetProcessesL

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

//    

EXPORT_C TInt RATStorageServer::GetProcessesL( RArray<TATProcessInfo>& aProcesses )

    {

    LOGSTR1( "STSE TInt RATStorageServer::GetProcessesL()" );

    TInt error( KErrNone );

    TInt sizeOfProcessInfo = sizeof( TATProcessInfo );

    // Reset the sent array

    aProcesses.Reset();

    // Calculate the length of the buffer to be constructed for processes.

    // One word will be reserved for the length of the array.

    TInt bufferLength = KWordSize + KATMaxProcesses * sizeOfProcessInfo; 

    CBufFlat* processBuf;

    // Construct processBuf and expand it before the beginning (index 0)

    processBuf = CBufFlat::NewL( bufferLength );

    CleanupStack::PushL( processBuf );

    processBuf->ExpandL( 0, bufferLength );

    TPtr8 bufPtr( processBuf->Ptr(0) );

    // Send the buffer to the server, which will fill it.

    TIpcArgs ipcArgs( &bufPtr );  

    error = SendReceive( CATStorageServer::EGetProcesses, ipcArgs ); 

    // Return with the error code if the operation failed

    if ( error != KErrNone )

        {

        CleanupStack::PopAndDestroy( processBuf );

        return error;

        }

    // A variable for the number of TATProcessInfo objects

    TInt count( 0 );

     // A variable for the position

    TInt pos( 0 );

    // Read the value for count 

    processBuf->Read( pos, &count, KWordSize );

    // Return if we got an illegal value for count     

    if ( count < 0 || count > KATMaxProcesses )

        {

        CleanupStack::PopAndDestroy( processBuf );

        return KErrGeneral;

        }    

    // Move the position one word onwards.    

    pos += KWordSize;

    TATProcessInfo processInfo;

    // Go through all TATProcessInfo objects sent to the server 

    for ( TInt j = 0; j < count; j++ )

        {

        // Read one of the TATProcessInfo objects stored in the buffer.

        processBuf->Read( pos, &processInfo, sizeOfProcessInfo );

        // Append this processInfo to the array

        error = aProcesses.Append( processInfo );

        if ( error != KErrNone )

            {

            CleanupStack::PopAndDestroy( processBuf );

            return error;

            }

        // Move the pos variable one word onwards.

        pos += sizeOfProcessInfo;

        }  

    CleanupStack::PopAndDestroy( processBuf );

    return error;

    }

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

// RATStorageServer::GetLoadedDllsL

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

//    

EXPORT_C TInt RATStorageServer::GetLoadedDllsL( TUint aProcessId, 

                                                RArray< TBuf8<KMaxLibraryName> >& aDlls )

    {

    LOGSTR1( "STSE TInt RATStorageServer::GetLoadedDllsL()" );

    // Panic (in debug builds) if aProcessId is faulty

    __ASSERT_DEBUG( aProcessId != KNullProcessId,        

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    TInt error( KErrNone );

    // Size of a DLL descriptor

    TInt sizeOfDllDesc = sizeof( TBuf8<KMaxLibraryName> );

    // Reset the sent array

    aDlls.Reset();

    // Calculate the length of the buffer to be constructed for DLL names.

    // One word will be reserved for the length of the array.

    TInt bufferLength = KWordSize + KATMaxDlls * sizeOfDllDesc; 

    CBufFlat* dllBuf;

    // Construct dllBuf and expand it before the beginning (index 0)

    dllBuf = CBufFlat::NewL( bufferLength );

    CleanupStack::PushL( dllBuf );

    dllBuf->ExpandL( 0, bufferLength );

    TPtr8 bufPtr( dllBuf->Ptr(0) );

    // Call the server with the given arguments

    TIpcArgs ipcArgs( aProcessId, &bufPtr );  

    error = SendReceive( CATStorageServer::EGetDlls, ipcArgs );

    // Return, if error is not KErrNone.

    if ( error != KErrNone )

        {

        CleanupStack::PopAndDestroy( dllBuf );      

        return error;

        }

    // A variable for the number of objects in the buffer

    TInt count( 0 );

     // A variable for the position

    TInt pos( 0 );

    // Read the value for count 

    dllBuf->Read( pos, &count, KWordSize );

    // Return if we got an illegal value for count

    if ( count < 0 || count > KATMaxDlls )

        {

        CleanupStack::PopAndDestroy( dllBuf );

        return KErrGeneral;

        }

    // Move the position one word onwards.    

    pos += KWordSize;

    TBuf8<KMaxLibraryName> dllName;

    // Go through all DLL names objects sent to the server 

    for ( TInt j = 0; j < count; j++ )

        {

        // Read one of the DLL names stored in the buffer.

        dllBuf->Read( pos, &dllName, sizeOfDllDesc );

        // Append this DLL name to the array

        error = aDlls.Append( dllName );

        if ( error != KErrNone )

            {

            return error;

            }

        // Move the pos variable one word onwards.

        pos += sizeOfDllDesc;

        }  

    CleanupStack::PopAndDestroy( dllBuf );

    return error;

    }    

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

// RATStorageServer::GetLoggingModeL

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

//    

EXPORT_C TInt RATStorageServer::GetLoggingModeL( TUint aProcessId,

                                                TATLogOption& aLoggingMode )

    {

    LOGSTR1( "STSE TInt RATStorageServer::GetLoggingModeL()" );

    // Panic (in debug builds) if aProcessId is illegal

    __ASSERT_DEBUG( aProcessId != KNullProcessId,        

        StorageServerPanic( KCategoryClient, EAToolBadArgument ) );

    TInt error(0);