/*

* 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 DAnalyzeToolChannel.

*

*/

// INCLUDE FILES

#include "analyzetoolchannel.h"

#include "analyzetooldevice.h"

#include "analyzetooleventhandler.h"

#include <kernel/kern_priv.h>

#ifdef __WINSCW__

#include <emulator.h>

#endif // __WINSCW__

#include "atlog.h"

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

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

// DAnalyzeToolChannel::DoCreate()

// Creates the logical channel.

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

//

TInt DAnalyzeToolChannel::DoCreate( TInt /*aUnit*/, 

    const TDesC8* /*aInfo*/, const TVersion &aVer )

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::DoCreate()" );

    // Check client version.

    if ( !Kern::QueryVersionSupported( KAnalyzeToolLddVersion(), aVer ) )

        {

        return KErrNotSupported;

        }

    TInt error = Kern::DynamicDfcQCreate( iOwnDfcQ, 

                                          KAnalyzeToolThreadPriority, 

                                          KAnalyzeToolThreadName );

    if ( KErrNone != error )

        {

        return error;

        }

    SetDfcQ( iOwnDfcQ );

    iMsgQ.Receive();

    // Create the event handler

    iEventHandler = new DAnalyzeToolEventHandler( iOwnDfcQ );

    // Check that everything is OK

    if ( !iEventHandler )

        {

        return KErrNoMemory;

        }

    // 2nd stage constructor for event handler

    return iEventHandler->Create( iDevice, Kern::CurrentProcess().iId );

    }

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

// DAnalyzeToolChannel::DAnalyzeToolChannel()

// Constructor.

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

//

DAnalyzeToolChannel::DAnalyzeToolChannel()

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::DAnalyzeToolChannel()" );

    }

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

// DAnalyzeToolChannel::~DAnalyzeToolChannel()

// Destructor.

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

//

DAnalyzeToolChannel::~DAnalyzeToolChannel()

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::~DAnalyzeToolChannel()" );

    if ( iEventHandler )

        {

        // Cancel all processing that we may be doing

        DoCancel();

        // Client code should use Close() instead the operator delete 

        // to destroy the event handler. 

        TInt error( iEventHandler->Close() );

        if ( KErrNone != error )

            {

            LOGSTR2( "ATDD iEventHandler->Close(%d)", error );

            }

        }

    #ifdef __WINSCW__

        iCodeSeg.Close();

    #endif // __WINSCW__

    // Destroy the queqe

    if ( iOwnDfcQ )

        {

        iOwnDfcQ->Destroy();

        }

    }

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

// DAnalyzeToolChannel::DoControl()

// Handles a client request.

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

//

TInt DAnalyzeToolChannel::DoControl( TInt aFunction, 

                                     TAny* a1, 

                                     TAny* /*a2*/, 

                                     TThreadMessage& aMessage )

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::Request()" );

    TInt ret( KErrNone );

    // Check the requested function

    switch (aFunction)

        {

        case RAnalyzeTool::EGetProcessInfo:

            ret = GetProcessInfo( a1, aMessage );

            break;

        case RAnalyzeTool::EGetCodesegInfo:

            ret = GetCodesegInfo( a1, aMessage );

            break;

        case RAnalyzeTool::EGetLibraryInfo:

            ret = GetLibraryInfo( a1, aMessage );

            break;

        case RAnalyzeTool::ECancelLibraryEvent:

            iEventHandler->CancelInformLibraryEvent();

            break;

        case RAnalyzeTool::ECurrentClientCount:

            ret = ClientCount( a1, aMessage );

            break;

        case RAnalyzeTool::EMainThreadAlloctor:

            ret = MainThreadAllocator( a1, aMessage );

            break;

        case RAnalyzeTool::EThreadStack:

             ret = ThreadStack( a1, aMessage );

             break;

        case RAnalyzeTool::EGetProcessHandle:

            ret = GetProcessHandleInfo( a1, aMessage );

            break;

        case RAnalyzeTool::EGetCurrentHandles:

            ret = GetCurrentHandleCount( a1, aMessage );

            break;

        case RAnalyzeTool::EGetMemoryModel:

            ret = GetMemoryModel( a1, aMessage );

            break;

        // Unsupported function. Panic

        default:

            Kern::PanicCurrentThread( KClientPanic, EPanicUnsupportedRequest );

            break;

        }

    return ret;

    }

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

// DAnalyzeToolChannel::DoRequest()

// Handles a client asynchronous request.

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

//

TInt DAnalyzeToolChannel::DoRequest( TInt aFunction, 

                                     TRequestStatus* aStatus, 

                                     TAny* a1, 

                                     TAny* /*a2*/,

                                     TThreadMessage& aMessage )

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::DoRequest()" );

    // Check the requested function

    switch (aFunction)

        {

        case RAnalyzeTool::ELibraryEvent:

            iEventHandler->InformLibraryEvent( aStatus, a1, aMessage );

            break;

        // Unsupported function. Panic

        default:

            aMessage.PanicClient( KClientPanic, EPanicUnsupportedRequest );

            break;

        }

    return KErrNone;

    }

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

// DAnalyzeToolChannel::DoCancel()

// Cancels outstanding asynchronous request.

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

//

void DAnalyzeToolChannel::DoCancel()

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::DoCancel()" );

    iEventHandler->CancelInformLibraryEvent();

    }

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

// DAnalyzeToolChannel::HandleMsg()

// Processes a message for this logical channel.

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

//

void DAnalyzeToolChannel::HandleMsg(TMessageBase* aMsg)

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::HandleMsg()" );

    TThreadMessage& message = *(TThreadMessage*)aMsg;

    // Get message type

    TInt id = message.iValue;

    // Decode the message type and dispatch it to the relevent handler function...

    if ( id == (TInt) ECloseMsg )

        {

        // Channel Close

        DoCancel();

        message.Complete( KErrNone, EFalse );

        }

    else if ( id == KMaxTInt )

        {

        // DoCancel

        DoCancel();

        message.Complete( KErrNone, ETrue );

        }

    else if ( id < 0 )

        {

        // DoRequest

        TRequestStatus* status = (TRequestStatus*) message.Ptr0();

        TInt error = DoRequest( ~id, status, message.Ptr1(), message.Ptr2(), message );

        if ( KErrNone != error )

            {

            Kern::RequestComplete( message.Client(), status, error);

            }

        message.Complete(KErrNone, ETrue );

        }

    else

        {

        // DoControl

        TInt ret = DoControl( id, message.Ptr0(), message.Ptr1(), message );

        message.Complete( ret, ETrue );

        }

    }

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

// DAnalyzeToolChannel::GetProcessInfo()

// Acquires current process information

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

//

TInt DAnalyzeToolChannel::GetProcessInfo( TAny* aProcessInfo, 

                                          TThreadMessage& aMessage )

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::GetProcessInfo()" );

    // Variable for reading parameters from user side

    TProcessIdentityParamsBuf params;

    // Reads a descriptor from a thread's process.

    TInt error = Kern::ThreadDesRead( aMessage.Client(), aProcessInfo, params, 0 );  

    if ( KErrNone != error )

        {

        LOGSTR2( "ATDD ThreadDesRead error %d", error );

        return error;

        } 

    // Gets the current process

    Kern::Containers()[ EProcess ]->Wait();

    DProcess& process = *Kern::ProcessFromId( params().iProcessId );  

    Kern::Containers()[ EProcess ]->Signal();

    if ( NULL == &process )

        {        

        return KErrNotFound;

        }

    // Temporary variable for collecting information from the process

    TProcessIdentityParamsBuf info;

    // Collect needed information from the process

    process.AppendName( info().iProcessName );//lint !e64 !e1514

    // Gets the current thread

    Kern::Containers()[ EThread ]->Wait(); 

    DThread& thread = *Kern::ThreadFromId( params().iThreadId );

    Kern::Containers()[ EThread ]->Signal();

    if ( NULL == &thread )

        {

        return KErrNotFound;

        }     

    // Stack address of the main thread

    info().iStackAddress = thread.iUserStackRunAddress;

    info().iStackSize    = thread.iUserStackSize;  

    // Enters thread critical section and acquires code segment mutex.

    Kern::AccessCode();

    // Collect needed information from the process

    info().iDynamicCount = process.iDynamicCode.Count();

    // Temporary queue for acquiring the count of codesegments

    SDblQue queue;

    // Acquire the count of codesegments

    TInt codesegCount = process.TraverseCodeSegs( &queue, 

                                                  NULL, 

                                                  DCodeSeg::EMarkDebug, 

                                                  DProcess::ETraverseFlagAdd );

    #ifndef __WINSCW__

        info().iCodesegCount = codesegCount;    

    #else

    // Reset codesegment array

    iCodeSeg.Reset();

    if ( codesegCount > 0 )

        {

        SDblQueLink* link = queue.iA.iNext;

        TCodesegInfo codeinfo;

        // Iterate through codesegments

        for ( TInt i = 0; i < codesegCount; ++i, link = link->iNext )

            {

            DWin32CodeSeg* codeseg = 

                (DWin32CodeSeg*)_LOFF( link, DCodeSeg, iTempLink );

            // Aqcuire codeseg information

            codeinfo.iFileEntryPoint = codeseg->iFileEntryPoint;

            codeinfo.iSize = codeseg->iSize;

            codeinfo.iFullName.Copy( codeseg->iRootName );

            codeinfo.iRunAddress = codeseg->iRunAddress;

            iCodeSeg.Append( codeinfo );

            }

        }

    // Add dependency codesegments

    DWin32CodeSeg* pcodeSeg = (DWin32CodeSeg*)process.iCodeSeg;

    // Get dependency codesegments

    GetModuleDependencies( pcodeSeg->iModuleHandle );

    // Set codesegment count

    info().iCodesegCount = iCodeSeg.Count();

    #endif

    // Removes all code segments from a queue and clear specified mark(s)

    DCodeSeg::EmptyQueue( queue, DCodeSeg::EMarkDebug );

    // Exits thread critical section and releases code segment mutex.

    Kern::EndAccessCode();

    // Writes a descriptor to a thread's process.

    error = Kern::ThreadDesWrite( aMessage.Client(), aProcessInfo, info, 0 );  

    if ( KErrNone != error )

        {

        LOGSTR2( "ATDD ThreadDesWrite error %d", error );

        return error;

        } 

    return KErrNone;

    }

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

// DAnalyzeToolChannel::GetCodesegInfo()

// Acquires codeseg information.

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

//

TInt DAnalyzeToolChannel::GetCodesegInfo( TAny* aCodesegInfo, 

                                          TThreadMessage& aMessage )

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::GetCodesegInfo()" );

    // Temporary variable for collecting information from the codeseg

    TCodesegInfoBuf params;

    TInt error( KErrArgument );

    // Reads a descriptor from a thread's process.

    error = Kern::ThreadDesRead( aMessage.Client(), aCodesegInfo, params, 0 );  

    if ( KErrNone != error )

        {

        LOGSTR2( "ATDD ThreadDesRead error %d", error );

        return error;

        } 

    if ( params().iIndex < 0 )

        {

        return KErrArgument;

        }

    // Gets the current process

    Kern::Containers()[ EProcess ]->Wait();

    DProcess& process = *Kern::ProcessFromId( params().iProcessId );

    Kern::Containers()[ EProcess ]->Signal();

    if ( NULL == &process )

        {

        return KErrNotFound;

        }

    // Temporary variable for collecting information 

    TCodesegInfoBuf output;

    // Enters thread critical section and acquires code segment mutex.

    Kern::AccessCode();

    #ifndef __WINSCW__

    // Temporary queue for acquiring the codesegments

    SDblQue queue;

    // Acquire the codesegments

    TInt actcount = process.TraverseCodeSegs( &queue, 

                                              NULL, 

                                              DCodeSeg::EMarkDebug, 

                                              DProcess::ETraverseFlagAdd );

    if ( actcount >= params().iIndex )

        {

        LOGSTR1( "ATDD DAnalyzeToolChannel::GetCodesegInfo() - actcount >= params.iIndex" );

        SDblQueLink* link = queue.iA.iNext;

        // Iterate through codesegments

        for (TInt i = 0; i < actcount; ++i, link = link->iNext)

            {

            DCodeSeg* codeseg = _LOFF( link, DCodeSeg, iTempLink );

            // Is the codesegments which information client wants

            if ( i == params().iIndex )

                {

                // Aqcuire codeseg information

                output().iFileEntryPoint = codeseg->iFileEntryPoint;

                output().iSize = codeseg->iSize;

                output().iFullName.Copy( codeseg->iRootName );

                output().iRunAddress = codeseg->iRunAddress;

                error = codeseg->GetMemoryInfo( output().iMemoryInfo, &process );

                if ( KErrNone == error )

                    {

                    // Writes a descriptor to a thread's process.

                    error = Kern::ThreadDesWrite( aMessage.Client(), 

                                                  aCodesegInfo, 

                                                  output, 

                                                  0 );   

                    if ( KErrNone != error )

                        {

                        LOGSTR2( "ATDD ThreadDesWrite error %d", error );

                        } 

                    }

                break;

                }

            }

        }

    // Removes all code segments from a queue and clear specified mark(s).

    DCodeSeg::EmptyQueue( queue, DCodeSeg::EMarkDebug );

    // Exits thread critical section and releases code segment mutex.

    Kern::EndAccessCode();

    return error;

    #else // WINSCW

    if ( iCodeSeg.Count() > params().iIndex )

        {

        // Aqcuire codeseg information

        output().iSize = iCodeSeg[params().iIndex].iSize;

        output().iFullName.Copy( iCodeSeg[params().iIndex].iFullName );

        output().iRunAddress = iCodeSeg[params().iIndex].iRunAddress;

        // Writes a descriptor to a thread's process.

        error = Kern::ThreadDesWrite( aMessage.Client(), aCodesegInfo, output, 0 ); 

        if ( KErrNone != error )

            {

            LOGSTR2( "ATDD ThreadDesWrite error %d", error );

            }

        }

    // Exits thread critical section and releases code segment mutex.

    Kern::EndAccessCode();

    return error;

    #endif

    }

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

// DAnalyzeToolChannel::GetLibraryInfo()

// Acquires library information.

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

//

TInt DAnalyzeToolChannel::GetLibraryInfo( TAny* aLibraryInfo, 

                                          TThreadMessage& aMessage )

    {

    LOGSTR1( "ATDD DAnalyzeToolChannel::GetLibraryInfo()" );

    // Temporary variable for reading informationfrom the user side

    TLibraryInfoBuf params;

    // Reads a descriptor from a thread's process.

    TInt error = Kern::ThreadDesRead( aMessage.Client(), aLibraryInfo, params, 0 );  

    if ( KErrNone != error )

        {