/*

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

*

*/

#include "MemSpyEngineServer.h"

// System includes

#include <e32svr.h>

#include <w32std.h>

#include <APGTASK.H>

#include <APGWGNAM.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/memspyengineobjectthreadinfocontainer.h>

#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>

#include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>

#include <memspy/engine/memspyenginehelperserver.h>

#include <memspy/engine/memspyenginehelperecom.h>

#include <memspy/engine/memspyprocessdata.h>

#include <memspy/engine/memspythreaddata.h>

#include <memspy/engine/memspykernelobjectdata.h>

#include <memspy/engine/memspythreadinfoitemdata.h>

#include <memspy/engine/memspymemorytrackingcycledata.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyenginehelperactiveobject.h>

#include <memspy/engine/memspyserverdata.h>

#include <memspysession.h>

#include <memspy/engine/memspyecomdata.h>

inline CShutdown::CShutdown() :CTimer(-1)

    {

    CActiveScheduler::Add(this);

    }

inline void CShutdown::ConstructL()

    {

    CTimer::ConstructL();

    }

inline void CShutdown::Start()

    {

    After(KMyShutdownDelay);

    }

void CShutdown::RunL()

    //

    // Initiate server exit when the timer expires

    //

    {

    CActiveScheduler::Stop();

    }

CMemSpyEngineServer::CMemSpyEngineServer( CMemSpyEngine& aEngine )

:   CServer2( EPriorityNormal ), iEngine( aEngine )

    {

    }

CMemSpyEngineServer::~CMemSpyEngineServer()

    {

    }

void CMemSpyEngineServer::ConstructL()

    {

    StartL( KMemSpyServerName );

    iShutdown.ConstructL();

    // ensure that the server still exits even if the 1st client fails to connect

    iShutdown.Start();

    }

CMemSpyEngineServer* CMemSpyEngineServer::NewL( CMemSpyEngine& aEngine )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CSession2* CMemSpyEngineServer::NewSessionL( const TVersion& aVersion, const RMessage2& aMessage ) const

    {

    if  ( aVersion.iMajor != KMemSpyClientServerVersion )

        {

        RDebug::Printf( "[MemSpy] CMemSpyEngineSession::NewSessionL() - BAD VERSION" );

        User::Leave( KErrNotSupported );

        }

    //

    CMemSpyEngineSession* session = CMemSpyEngineSession::NewL( iEngine, aMessage );

	return session;

    }

void CMemSpyEngineServer::AddSession(TBool aCliRequest)

    {

    if (aCliRequest)

        {

        iCliConnected = ETrue;

        }

    else

        {

        ++iSessionCount;

        }

    iShutdown.Cancel();

    }

void CMemSpyEngineServer::DropSession(TBool aCliRequest)

    {

    if (!aCliRequest)

        {

        --iSessionCount;

        }

    if (iSessionCount == 0 && !iCliConnected)

        {

        iShutdown.Start();

        }

    }

CMemSpyEngineSession::CMemSpyEngineSession( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

CMemSpyEngineSession::~CMemSpyEngineSession()

    {

#ifdef _DEBUG

    TPtrC pThreadName( KNullDesC );

    if  ( iClientThreadName )

        {

        pThreadName.Set( *iClientThreadName );

        }

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

#endif

    delete iClientThreadName;

    Server().DropSession(iIsCliRequest);

    }

void CMemSpyEngineSession::ConstructL( const RMessage2& aMessage )

    {

	RThread thread;

    const TInt error = aMessage.Client( thread );

    CleanupClosePushL( thread );

    TRACE( RDebug::Printf( "[MemSpy] CMemSpyEngineSession::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 );

    const TUid KCliUid3 = { 0x2002129D };

    iIsCliRequest = aMessage.SecureId() == TSecureId(KCliUid3);

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

    }

void CMemSpyEngineSession::CreateL()

    {   

    Server().AddSession(iIsCliRequest);

    }

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

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aMessage );

    CleanupStack::Pop( self );

    return self;

    }

void CMemSpyEngineSession::ServiceL( const RMessage2& aMessage )

    {

    TRACE( RDebug::Print( _L("[MemSpy] CMemSpyEngineSession::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] CMemSpyEngineSession::ServiceL() - SERVICE ERROR - this: 0x%08x, fn: %d, err: %d, client: %S"), this, aMessage.Function(), error, iClientThreadName );

        }

    if ((aMessage.Function() & KMemSpyOpFlagsAsyncOperation) == 0 || error != KErrNone)

    	{

		aMessage.Complete( error );

    	}

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

	}

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

// DoServiceL( const RMessage2& aMessage )

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

//

void CMemSpyEngineSession::DoServiceL( const RMessage2& aMessage )

	{

	TInt function = aMessage.Function() & KMemSpyOpFlagsTypeMask;

	if (function >= EMemSpyClientServerOpMarkerUiFirst && 

		function < EMemSpyClientServerOpMarkerUiLast)

		DoUiServiceL(aMessage);

	else

		DoCmdServiceL(aMessage);

	}

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

// DoUiServiceL( const RMessage2& aMessage )

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

//

void CMemSpyEngineSession::DoUiServiceL( const RMessage2& aMessage )

    {

	switch (aMessage.Function() & KMemSpyOpFlagsTypeMask)

		{

	    case EMemSpyClientServerOpGetOutputSink:

	        {

	        TMemSpySinkType sink = iEngine.SinkType();

	        TPckgBuf<TMemSpySinkType> type( sink );

	        aMessage.WriteL( 0, type );

	        break;

	        }

		case EMemSpyClientServerOpGetProcessCount:

			{

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

			break;

			}

		case EMemSpyClientServerOpGetProcesses:

			{

			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.iIsDead = process.IsDead();

				data.iId = process.Id();

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

				data.iThreadCount = process.Count();

				data.iPriority = process.Priority();

				data.iExitType = process.ExitType();

				data.iExitReason = process.ExitReason();

				data.iExitCategory = process.ExitCategory();

				data.iSID = process.SID();

				TPckgBuf<TMemSpyProcessData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				}

			a0 = list.Count();

			aMessage.WriteL(0, a0);

			break;

			}

		case EMemSpyClienServerOpGetProcessIdByName:

			{

			TFullName processName;

			aMessage.ReadL(0, processName);

			TBool found(EFalse);

			for (TInt i=0; i<iEngine.Container().Count(); i++)

				{

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

				if (process.Name().FindF(processName) >= 0)

					{

					found = ETrue;

					TPckgBuf<TProcessId> procId(process.Id());

					aMessage.WriteL(1, procId);

					}

				}

			if (!found)

				{

				User::Leave(KErrNotFound);

				}

			break;

			}

		case EMemSpyClientServerOpProcessSystemPermanentOrCritical:

			{

			TBool ret = EFalse;

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();

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

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

				{

				ret = ETrue;

				}

			TPckgBuf<TBool> retBuf( ret );

			aMessage.WriteL( 1, retBuf );

			break;

			}

		case EMemSpyClientServerOpEndProcess:

			{

			TPckgBuf<TProcessId> id;

			aMessage.ReadL( 0, id );

			TPckgBuf<TMemSpyEndType> 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 EMemSpyClientServerOpSwitchToProcess:

			{/*

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

			{

			TPckgBuf<TProcessId> pid;

			aMessage.ReadL(1, pid);

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

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

			break;

			}

		case EMemSpyClientServerOpGetThreads:

			{

			TPckgBuf<TProcessId> pid;

			aMessage.ReadL(2, pid);

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

			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);

				TMemSpyThreadData data;

				data.iId = thread.Id();

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

				data.iThreadPriority = thread.Priority();

				TPckgBuf<TMemSpyThreadData> buffer(data);

				aMessage.WriteL(1, buffer, offset);

				}

			a0 = list.Count();

			aMessage.WriteL(0, a0);

			break;

			}

		case EMemSpyClientServerOpSetThreadPriority:

			{

			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->SetPriorityL(static_cast<TThreadPriority>(priority()));

				}					

			break;

			}

		case EMemSpyClientServerOpThreadSystemPermanentOrCritical:

			{

			TPckgBuf<TThreadId> id;

			aMessage.ReadL( 0, id );

			CMemSpyEngineObjectContainer& container = iEngine.Container();            

			CMemSpyProcess* process = NULL;

			CMemSpyThread* thread = NULL; 

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

			TBool ret = thread && ( thread->IsSystemPermanent() || thread->IsSystemCritical() );

			TPckgBuf<TBool> retBuf( ret );

			aMessage.WriteL( 1, retBuf );

			break;

			}

		case EMemSpyClientServerOpEndThread:

			{

			TPckgBuf<TThreadId> id;

			aMessage.ReadL( 0, id );

			TPckgBuf<TMemSpyEndType> 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() )