// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// Provides the debug agent server implementation.

// 

//

#include <e32base.h>

#include <e32base_private.h>

#include <e32cons.h>

#include <trkkerneldriver.h>

#include "d_rmdebugserver.h"

#include "d_rmdebugclient.h"

#include "t_rmdebug.h"

CDebugServServer::CDebugServServer(CActive::TPriority aActiveObjectPriority)

   : CServer2(aActiveObjectPriority)

//

// Server constructor

//

	{

	}

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

//

// Session constructor

//

	{

	// make sure the kernel side device driver is not already loaded

   TInt err;

	err = User::LoadLogicalDevice(KDebugDriverFileName);

	if ((KErrNone == err) || (KErrAlreadyExists == err))

       {

       return new(ELeave) CDebugServSession();

       }

   else

       {

       return (NULL);

       }

	}   

CDebugServSession::CDebugServSession()

// Session implementation

	{

   TInt err;

	TMetroTrkDriverInfo info;

   info.iUserLibraryEnd = 0;

   err = iKernelDriver.Open(info);

   if (KErrNone != err)

		{

 		User::Leave(err);

		}          

	}

CDebugServSession::~CDebugServSession()

//

// Session destructor

//

	{

	// stop the kernel side driver

	iKernelDriver.Close();

	User::FreeLogicalDevice(KDebugDriverName);

	}

void CDebugServSession::ServiceL(const RMessage2& aMessage)

//

// Session service handler

//

	{

	TInt res = KErrNone;

	switch(aMessage.Function())

		{

		case EDebugServResumeThread:

			res = ResumeThread(aMessage);

			break;

		case EDebugServSuspendThread:

			res = SuspendThread(aMessage);

			break;          

//		case EDebugServReadProcessInfo:

//			res = ReadProcessInfo(aMessage);

//			break;        

//

//		case EDebugServReadThreadInfo:

//			res = ReadThreadInfo(aMessage);

//			break;

		case EDebugServReadMemory:

			res = ReadMemory(aMessage);

			break;        

		case EDebugServWriteMemory:

			res = WriteMemory(aMessage);

			break;        

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	aMessage.Complete(res);

	}

TInt CDebugServSession::SuspendThread(const RMessage2& aMessage)

//

// Session suspend thread

//

	{

	TInt err;

	err = iKernelDriver.SuspendThread(aMessage.Int0());

	return err;

	}

TInt CDebugServSession::ResumeThread(const RMessage2& aMessage)

//

// Server resume thread

//

	{

	TInt err;

	err = iKernelDriver.ResumeThread(aMessage.Int0());

	return err;

	}

//TInt CDebugServSession::ReadProcessInfo(const RMessage2& aMessage)

////

//// Server read process information

////

//	{

//	TInt err;

//	TProcessInfo procinfo;

//	TMetroTrkTaskInfo processInfo(0);

//

//	err = iKernelDriver.GetProcessInfo(aMessage.Int0(), processInfo);

//

//	if (KErrNone == err)

//		{

//		procinfo.iProcessID = processInfo.iId;

//		procinfo.iPriority = processInfo.iPriority;

//		procinfo.iName.Copy(processInfo.iName);

//

//		TPckgBuf<TProcessInfo> p(procinfo);

//		aMessage.WriteL(1,p);        

//		}

//

//	return err;

//	}

//

//TInt CDebugServSession::ReadThreadInfo(const RMessage2& aMessage)

////

//// Server read thread information

////

//	{

//	TInt err;

//	TThreadInfo thrdinfo;

//	TMetroTrkTaskInfo threadInfo(aMessage.Int1()); // Sets OtherID to the second input parameter in aMessage

//

//	// aMessage.Int0 is the index into the thread list for the process

//	err = iKernelDriver.GetThreadInfo(aMessage.Int0(), threadInfo);	   

//

//	if (KErrNone == err)

//		{

//		thrdinfo.iThreadID = threadInfo.iId;

//		thrdinfo.iPriority = threadInfo.iPriority;

//		thrdinfo.iName.Copy(threadInfo.iName);

//		thrdinfo.iOwningProcessID = threadInfo.iOtherId;

//

//		TPckgBuf<TThreadInfo> p(thrdinfo);

//

//		// Write out the results to the third argument passed in (pointer to the threadinfo structure)

//		aMessage.WriteL(2,p);           

//		}

//

//	return err;

//	}

TInt CDebugServSession::ReadMemory(const RMessage2& aMessage)

//

// Server read process memory

//

	{   

	TInt err;

	TUint32 threadId = aMessage.Int0();

	TPckgBuf<TMemoryInfo> pckg = *(TPckgBuf<TMemoryInfo> *)(aMessage.Ptr1());

	TMemoryInfo* InputMemoryInfo = &pckg();

	TPtr8 *ptrtst = InputMemoryInfo->iDataPtr;

	err = iKernelDriver.ReadMemory(threadId, InputMemoryInfo->iAddress, InputMemoryInfo->iSize, *ptrtst);

	return err;

	}

TInt CDebugServSession::WriteMemory(const RMessage2& aMessage)

//

// Server write process memory

//

	{

	TInt err;

	TUint32 threadId = aMessage.Int0();

	TPckgBuf<TMemoryInfo> pckg = *(TPckgBuf<TMemoryInfo> *)(aMessage.Ptr1());

	TMemoryInfo* InputMemoryInfo = &pckg();

	TPtr8 *ptrtst = InputMemoryInfo->iDataPtr;

	err = iKernelDriver.WriteMemory(threadId, InputMemoryInfo->iAddress, InputMemoryInfo->iSize, *ptrtst);

	return err;

	}

GLDEF_C TInt CDebugServServer::ThreadFunction(TAny*)

//

// Server thread function, continues until active scheduler stops

//

	{

	CTrapCleanup* cleanup=CTrapCleanup::New();

	if (cleanup == NULL)

		{

		User::Leave(KErrNoMemory);

		}

	CActiveScheduler *pA=new CActiveScheduler;

	CDebugServServer *pS=new CDebugServServer(EPriorityStandard);

	CActiveScheduler::Install(pA);

	TInt err = pS->Start(KDebugServerName);

	if (err != KErrNone)

		{

		User::Leave(KErrNone);

		}

	RThread::Rendezvous(KErrNone);

	CActiveScheduler::Start();

	delete pS;

	delete pA;

	delete cleanup;

	return (KErrNone);

	}

EXPORT_C TInt StartThread(RThread& aServerThread)

//

// Start the server thread

//

	{

	TInt res=KErrNone;

	TFindServer finddebugserver(KDebugServerName);

	TFullName name;

	if (finddebugserver.Next(name) != KErrNone)

		{

		res = aServerThread.Create( KDebugServerName,

									CDebugServServer::ThreadFunction,

									KDefaultStackSize,

									KDefaultHeapSize,

									KDefaultHeapSize,

									NULL

									);

		if (res == KErrNone)

			{

			TRequestStatus rendezvousStatus;

			aServerThread.SetPriority(EPriorityNormal);

			aServerThread.Rendezvous(rendezvousStatus);

			aServerThread.Resume();

			User::WaitForRequest(rendezvousStatus);

			}                                 

		else

			{

			aServerThread.Close();

			}

		}

	return res;

	}

RDebugServSession::RDebugServSession()

//

// Server session constructor

//

	{

	}

TInt RDebugServSession::Open()

//

// Session open

//

	{

	TInt r = StartThread(iServerThread);

	if (r == KErrNone)

		{

		r=CreateSession(KDebugServerName, Version(), KDefaultMessageSlots);

		}

	return r;

	}

TVersion RDebugServSession::Version(void) const

//

// Session version

//

	{

	return (TVersion(KDebugServMajorVersionNumber, KDebugServMinorVersionNumber, KDebugServBuildVersionNumber));

	}

TInt RDebugServSession::SuspendThread(const TInt aThreadID)

//

// Session suspend thread request

//

	{

	TIpcArgs args(aThreadID);

	TInt res;

	res = SendReceive(EDebugServSuspendThread, args);

	return res;

	}

TInt RDebugServSession::ResumeThread(const TInt aThreadID)

//

// Session resume thread request

//

	{

	TIpcArgs args(aThreadID);

	TInt res;

	res = SendReceive(EDebugServResumeThread, args);

	return res;

	}

//TInt RDebugServSession::ReadProcessInfo(const TInt aIndex, TProcessInfo* aInfo)

////

//// Session read process information request

////

//	{

//	TPckgBuf<TProcessInfo> pckg;

//	pckg = *aInfo;

//

//	TIpcArgs args(aIndex, &pckg);

//

//	TInt res;

//

//	res = SendReceive(EDebugServReadProcessInfo, args);

//

//	*aInfo = pckg();

//

//	return res;

//

//	}

//

//TInt RDebugServSession::ReadThreadInfo(const TInt aIndex, const TInt aProc, TThreadInfo* aInfo)

////

//// Session read thread information request

////

//	{

//	TPckgBuf<TThreadInfo> pckg;

//	pckg = *aInfo;

//

//	TIpcArgs args(aIndex, aProc, &pckg);

//

//	TInt res;

//

//	res = SendReceive(EDebugServReadThreadInfo, args);

//

//	*aInfo = pckg();

//

//	return res;

//

//	}

TInt RDebugServSession::ReadMemory(const TUint32 aThreadID, TMemoryInfo* aInfo)

//

// Session read thread memory request

//

	{

	TPckgBuf<TMemoryInfo> pckg;

	pckg = *aInfo;

	TIpcArgs args(aThreadID, &pckg);

	TInt res;

	res = SendReceive(EDebugServReadMemory, args);

	*aInfo = pckg();

	return res;

	}

TInt RDebugServSession::WriteMemory(const TUint32 aThreadID, TMemoryInfo* aInfo)

//

// Session write thread memory request

//

	{

	TPckgBuf<TMemoryInfo> pckg;

	pckg = *aInfo;

	TIpcArgs args(aThreadID, &pckg);

	TInt res;

	res = SendReceive(EDebugServWriteMemory, args);

	return res;

	}

TInt RDebugServSession::Close()

//

// Session close the session and thread

//

	{

	RSessionBase::Close();

	iServerThread.Close();

	return KErrNone;

	}