/*

* 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:

* Implementation of the new MemSpyServer

*/

// System includes

#include <e32svr.h>

#include <e32cmn.h>

#include <e32base.h>

#include <w32std.h>

//#include <apgtask.h>

//#include <apgwgnam.h>

//user includes

#include "MemSpyServerSession.h"

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyenginelogger.h>

#include <memspyengineclientinterface.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyenginehelperchunk.h>

#include <memspy/engine/memspyenginehelpercodesegment.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyenginehelperstack.h>

#include <memspy/engine/memspyenginehelperthread.h>

#include <memspy/engine/memspyenginehelperprocess.h>

#include <memspy/engine/memspyenginehelperfilesystem.h>

#include <memspy/engine/memspyenginehelperram.h>

#include <memspy/engine/memspyenginehelpersysmemtracker.h>

#include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>

#include <memspy/engine/memspyenginehelperkernelcontainers.h>

#include <memspy/engine/memspyenginehelperserver.h>

//cigasto

#include <memspysession.h>

//#include <memspy/driver/memspydriverclient.h>

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

// CMemSpyServerSession( CMemSpyEngine& aEngine )

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

//

CMemSpyServerSession::CMemSpyServerSession( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {	

    }

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

// ~CMemSpyServerSession()

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

//

CMemSpyServerSession::~CMemSpyServerSession()

    {

#ifdef _DEBUG

    TPtrC pThreadName( KNullDesC );

    if  ( iClientThreadName )

        {

        pThreadName.Set( *iClientThreadName );

        }

    RDebug::Print( _L("[MemSpy] CMemSpyServerSession::~CMemSpyServerSession() - DEAD SESSION - this: 0x%08x, id: %4d, name: %S"), this, iClientThreadId, iClientThreadName );

#endif

    delete iClientThreadName;

    }

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

// ConstructL( const RMessage2& aMessage )

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

//

void CMemSpyServerSession::ConstructL( const RMessage2& aMessage )

    {

	RThread thread;

    const TInt error = aMessage.Client( thread );

    CleanupClosePushL( thread );

    TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::ConstructL() - this: 0x%08x - opening client thread - err: %d", this, error ) );

    User::LeaveIfError( error );

    const TFullName threadName( thread.FullName() );

    iClientThreadName = threadName.AllocL();

    iClientThreadId = thread.Id();

    CleanupStack::PopAndDestroy( &thread );

    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyServerSession::ConstructL() - NEW SESSION - this: 0x%08x, id: %4d, client: %S"), this, iClientThreadId, iClientThreadName ) );

    }

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

// NewL( CMemSpyEngine& aEngine, const RMessage2& aMessage )

// Two-phased constructor

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

//

CMemSpyServerSession* CMemSpyServerSession::NewL( CMemSpyEngine& aEngine, const RMessage2& aMessage )

    {

    CMemSpyServerSession* self = new(ELeave) CMemSpyServerSession( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL( aMessage );

    CleanupStack::Pop( self );

    return self;

    }

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

// ServiceL( const RMessage2& aMessage )

// Method from which the clients request arrives

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

//

void CMemSpyServerSession::ServiceL( const RMessage2& aMessage )

    {

    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyServerSession::ServiceL() - START - this: 0x%08x, fn: 0x%08x, id: %4d, client: %S"), this, aMessage.Function(), iClientThreadId, iClientThreadName ) );   

    TRAPD( error, DoServiceL( aMessage ) );

    if  ( error != KErrNone )

        {

        RDebug::Print( _L("[MemSpy] CMemSpyServerSession::ServiceL() - SERVICE ERROR - this: 0x%08x, fn: %d, err: %d, client: %S"), this, aMessage.Function(), error, iClientThreadName );

        }

    aMessage.Complete( error );

    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyServerSession::ServiceL() - END - this: 0x%08x, fn: 0x%08x, id: %4d, client: %S"), this, aMessage.Function(), iClientThreadId, iClientThreadName ) );

	}

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

// DoCmdServiceL( const RMessage2& aMessage )

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

//

void CMemSpyServerSession::DoCmdServiceL( const RMessage2& aMessage )

    {

    TInt error = KErrNone;

    // Check function attributes

    const TInt function = aMessage.Function() & KMemSpyOpFlagsTypeMask;    

    const TInt argSpec = aMessage.Function() & KMemSpyOpFlagsInclusionMask;

    const TBool byThreadId = ( argSpec == KMemSpyOpFlagsIncludesThreadId );

    const TBool byThreadName = ( argSpec == KMemSpyOpFlagsIncludesThreadName );

    TRACE( RDebug::Printf( "[MemSpy] CMemSpyServerSession::DoServiceL() - START - unmodified function: 0x%08x, opCode: %d [TID: %d, TN: %d]", aMessage.Function(), function, byThreadId, byThreadName ) );   

    switch (function)

    	{

		case EGetProcessCount:

			{

			aMessage.WriteL(0, TPckgBuf<TInt>(iEngine.Container().Count()));

			break;

			}

		case EGetProcesses:

			{

			CMemSpyEngineObjectContainer& list = iEngine.Container();

			TPckgBuf<TInt> a0;

			aMessage.ReadL(0, a0);

			TInt realCount = Min(a0(), list.Count());

			for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyProcessData))

				{

				CMemSpyProcess& process = iEngine.Container().At(i);

				TMemSpyProcessData data;

				data.iId = process.Id();

				data.iName.Copy(process.Name());

				TPckgBuf<TMemSpyProcessData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				}

			a0 = list.Count();

			aMessage.WriteL(0, a0);

			break;

			}

		case EProcessSystemPermanentOrCritical:

			{

			TBool ret = EFalse;

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			process.Open();

			if  ( process.IsSystemPermanent() || process.IsSystemCritical() )

				{

				ret = ETrue;

				}

			TPckgBuf<TBool> retBuf( ret );

			aMessage.WriteL( 1, retBuf );

			break;

			}

		case EEndProcess:

			{

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			TPckgBuf<TEndType> type;

			aMessage.ReadL( 1, type );

			CMemSpyEngineObjectContainer& container = iEngine.Container();			

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			switch ( type() )

				{

				case ETerminate:

					{

					process.TerminateL();

					break;

					}

				case EPanic:

					{

					process.PanicL();

					break;

					}

				case EKill:

					{

					process.KillL();

					break;

					}

				}																

			break;

			}

		case ESwitchToProcess:

			{/*

		    TInt wgCount;

		    RWsSession wsSession;

		    User::LeaveIfError( wsSession.Connect() );

		    CleanupClosePushL( wsSession );

		    User::LeaveIfError( wgCount = wsSession.NumWindowGroups() );

		    RArray<RWsSession::TWindowGroupChainInfo> wgArray;

		    CleanupClosePushL( wgArray );

		    User::LeaveIfError( wsSession.WindowGroupList( &wgArray ) );

		    TApaTask task( wsSession );

		    TBool brought( EFalse );

		    TInt wgId( KErrNotFound );

		    TThreadId threadId;

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

			CMemSpyProcess& process = container.ProcessByIdL( id() );

			// loop trough threads in a process

			for ( TInt i = 0; i < process.MdcaCount(); i++ )

				{

				TInt wgCountLocal = wgCount;

				// loop trough all window groups and see if a thread id matches

				while( !brought && wgCountLocal-- )

					{

					wgId = wgArray[wgCountLocal].iId;

					User::LeaveIfError( wsSession.GetWindowGroupClientThreadId( wgId, threadId ) );

					if ( threadId == process.At( i ).Id() )

						{

						CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, wgId );

						task.SetWgId( wgId );

						if ( !wgName->Hidden() && task.Exists() )

							{

							task.BringToForeground();

							brought = ETrue;                        

							}

						CleanupStack::PopAndDestroy( wgName );

						}

					}

				}

			TPckgBuf<TBool> ret( brought );

			aMessage.WriteL( 1, ret );

			break;*/

			}

		case EGetThreadCount:

			{

			TPckgBuf<TProcessId> pid;

			aMessage.ReadL(1, pid);

			CMemSpyProcess& process = iEngine.Container().ProcessByIdL(pid());

			process.Open();

			aMessage.WriteL(0, TPckgBuf<TInt>(process.Count()));

			process.Close();

			break;

			}

		case EGetThreads:

			{

			TPckgBuf<TProcessId> pid;

			aMessage.ReadL(2, pid);

			CMemSpyProcess& list = iEngine.Container().ProcessByIdL(pid());

			list.Open();

			TPckgBuf<TInt> a0;

			aMessage.ReadL(0, a0);

			TInt realCount = Min(a0(), list.Count());

			for(TInt i=0, offset = 0; i<realCount; i++, offset += sizeof(TMemSpyThreadData))

				{

				CMemSpyThread& thread = list.At(i);

				thread.Open();

				TMemSpyThreadData data;

				data.iId = thread.Id();

				data.iName.Copy(thread.Name());

				data.iThreadPriority = thread.Priority();

				TPckgBuf<TMemSpyThreadData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				thread.Close();

				}

			a0 = list.Count();

			aMessage.WriteL(0, a0);

			list.Close();

			break;

			}

		case ESetThreadPriority:

			{

			TPckgBuf<TThreadId> tid;

			TPckgBuf<TInt> priority;

			aMessage.ReadL(0, tid);

			aMessage.ReadL(1, priority);

			CMemSpyProcess* process = NULL;

			CMemSpyThread* thread = NULL; 

			User::LeaveIfError(iEngine.Container().ProcessAndThreadByThreadId(tid(), process, thread));

			if (thread)

				{				

				thread->Open();

				thread->SetPriorityL(static_cast<TThreadPriority>(priority()));				

				thread->Close();

				}					

			break;

			}

		case EThreadSystemPermanentOrCritical:

			{

			TBool ret = EFalse;

			TPckgBuf<TThreadId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();            

            CMemSpyProcess* process = NULL;

            CMemSpyThread* thread = NULL; 

            User::LeaveIfError( container.ProcessAndThreadByThreadId( id(), process, thread ) );

            if ( thread )

            	{				

				thread->Open();

				if  ( thread->IsSystemPermanent() || thread->IsSystemCritical() )

					{			

					ret = ETrue;					

					}

				thread->Close();

            	}

            TPckgBuf<TBool> retBuf( ret );

            aMessage.WriteL( 1, retBuf );

			break;

			}

		case EEndThread:

			{

			TPckgBuf<TThreadId> id;

			aMessage.ReadL( 0, id );

			TPckgBuf<TEndType> type;

			aMessage.ReadL( 1, type );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

			CMemSpyProcess* process = NULL;

			CMemSpyThread* thread = NULL; 

			User::LeaveIfError( container.ProcessAndThreadByThreadId( id(), process, thread ) );

			if( thread )

				{

				switch ( type() )

					{

					case ETerminate:

						{

						thread->TerminateL();

						break;

						}

					case EPanic:

						{

						thread->PanicL();

						break;

						}

					case EKill:

						{

						thread->KillL();

						break;

						}

					}				

				}			

			break;

			}

		// --- KernelObjects related functions ---

		case EGetKernelObjectTypeCount:

			{

			TInt iCount = EMemSpyDriverContainerTypeLast - EMemSpyDriverContainerTypeFirst;

			TPckgBuf<TInt> ret( iCount );

			aMessage.WriteL(0, ret);			

			break;

			}

		case EGetKernelObjects:

			{

			TPckgBuf<TInt> count;

			aMessage.ReadL(0, count);

			CMemSpyEngineGenericKernelObjectContainer* model = iEngine.HelperKernelContainers().ObjectsAllL(); //contains all the objects

			CleanupStack::PushL( model );

			for( TInt i=0, offset = 0; i<count(); i++, offset += sizeof( TMemSpyKernelObjectData ) )

				{

				TMemSpyKernelObjectData data;

				TPtrC name(model->At(i).Name().Mid(1));

				TInt tabPos = name.Locate('\t');

				if (tabPos != KErrNotFound)

					name.Set(name.Left(tabPos));

				data.iName.Copy(name);

				data.iType = model->At(i).Type();

				data.iCount = model->At(i).Count();											

				data.iSize = model->At(i).Count() * model->At(i).Count();

				TPckgBuf<TMemSpyKernelObjectData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				}			

			aMessage.WriteL(0, count);

			CleanupStack::PopAndDestroy( model );

			break;

			}

		case EGetKernelObjectItemsCount:

			{

			TPckgBuf<TMemSpyDriverContainerType> tempType;

			aMessage.ReadL(1, tempType); //get type of kernel object

			TMemSpyDriverContainerType type = tempType();

			CMemSpyEngineHelperKernelContainers& kernelContainerManager = iEngine.HelperKernelContainers();

			CMemSpyEngineGenericKernelObjectList* iObjectList = kernelContainerManager.ObjectsForSpecificContainerL( type );

			CleanupStack::PushL( iObjectList );

			TInt count = iObjectList->Count();

			TPckgBuf<TInt> ret( count );

			aMessage.WriteL( 0, ret );

			CleanupStack::PopAndDestroy( iObjectList );

			break;

			}

		case EGetKernelObjectItems:

			{

			TPckgBuf<TInt> count;

			TPckgBuf<TMemSpyDriverContainerType> tempType;

			aMessage.ReadL( 0, count ); //get count of items

			aMessage.ReadL(1, tempType); //get type of kernel object

			TInt c = count();

			CMemSpyEngineHelperKernelContainers& kernelContainerManager = iEngine.HelperKernelContainers();

			CMemSpyEngineGenericKernelObjectList* iObjectList = kernelContainerManager.ObjectsForSpecificContainerL( tempType() );

			CleanupStack::PushL( iObjectList );

			for( TInt i=0, offset = 0; i<c; i++, offset += sizeof( TMemSpyDriverHandleInfoGeneric ) )

				{

				TMemSpyDriverHandleInfoGeneric data;								

				data = iObjectList->At( i );

				TPckgBuf<TMemSpyDriverHandleInfoGeneric> buffer(data);

				aMessage.WriteL(2, buffer, offset);

				}			

			CleanupStack::PopAndDestroy( iObjectList );			

			break;

			}

		// --- Kernel Heap related functions ---

		case EGetHeap:

			{

			TMemSpyHeapInfo heapInfo;			

			iEngine.HelperHeap().GetHeapInfoKernelL( heapInfo );

			TMemSpyHeapData data = iEngine.HelperHeap().NewHeapRawInfo( heapInfo );

			TPckgBuf<TMemSpyHeapData> buffer(data);

			aMessage.WriteL(0, buffer);

			break;

			}

    	}

//    else if( function == EProcessByIndex )

//    	{

//		TMemSpyProcess iProcess;

//		TInt in;

//		TPckgBuf<TInt> index( in );

//		aMessage.ReadL( 0, index );

//		CMemSpyProcess& process = iEngine.Container().At( index() );

//		//fill the data structure

//		iProcess.iId = process.Id(); //process ID

//		iProcess.iName.Append( process.Name() ); //raw process name

//		iProcess.iThreadCount = process.Count(); //thread count

//		iProcess.iPriority = process.Priority();

//		//			

//		TPckgBuf<TMemSpyProcess> buf( iProcess );

//		aMessage.WriteL( 1, buf );

//		aMessage.Complete( KErrNone );

//    	}

//    else if( function == EProcessIndexById )

//    	{

//		TProcessId iId;

//		TPckgBuf<TProcessId> buf( iId );

//    	aMessage.ReadL( 0, buf );

//    	TInt index = iEngine.Container().ProcessIndexById( buf() );

//    	TPckgBuf<TInt> out( index );

//    	aMessage.WriteL( 1, out );

//    	aMessage.Complete( KErrNone );

//    	}

//    else if( function == EOutputProcessInfo )

//    	{