/*

* Copyright (c) 2004 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 "TrkEngine.h"

#include "TrkDispatchLayer.h"

#include "DateTimeConverter.h"

#ifndef __TEXT_SHELL__

#include "TrkSwInstall.h"

#endif

//

// Macros

//

//

// Version Information

//

#define MAJOR_VERSION_NUMBER	3

#define MINOR_VERSION_NUMBER	2

#define BUILD_NUMBER			4

//

// Support Information

//

#define DS_SUPPORT_MASK_00_07	0x7E	// kDSConnect, kDSDisconnect, kDSReset, kDSVersions, kDSSupportMask, kDSCPUType */

#define DS_SUPPORT_MASK_08_0F	0x00

#define DS_SUPPORT_MASK_10_17	0x4f	// R/W Memory, R/W Registers, FlushCache

#define DS_SUPPORT_MASK_18_1F	0x5f	// kDSContinue, kDSStep, kDSStop, kDSSetBreak, kDSClearBreak

#define DS_SUPPORT_MASK_20_27	0x01	// kDSNotifyFileInput

#define DS_SUPPORT_MASK_28_2F	0x00

#define DS_SUPPORT_MASK_30_37	0x00

#define DS_SUPPORT_MASK_38_3F	0x00

#define DS_SUPPORT_MASK_40_47	0x0f	// OS Create/Delete Item, OS Read/Write Info

#define DS_SUPPORT_MASK_48_4F	0x1f	// OS Read/Write/Open/Close/Position File

#define DS_SUPPORT_MASK_50_57	0x00

#define DS_SUPPORT_MASK_58_5F	0x00

#define DS_SUPPORT_MASK_60_67	0x00

#define DS_SUPPORT_MASK_68_6F	0x00

#define DS_SUPPORT_MASK_70_77	0x00

#define DS_SUPPORT_MASK_78_7F	0x00

#define DS_SUPPORT_MASK_80_87	0x01	// kDSReplyACK

#define DS_SUPPORT_MASK_88_8F	0x00

#define DS_SUPPORT_MASK_90_97	0x11	// kDSNotifyStopped, kDSNotifyStopped2

#define DS_SUPPORT_MASK_98_9F	0x00

#define DS_SUPPORT_MASK_A0_A7	0x03	// kDSOSNotifyCreated, kDSOSNotifyDeleted

#define DS_SUPPORT_MASK_A8_AF	0x00

#define DS_SUPPORT_MASK_B0_B7	0x00

#define DS_SUPPORT_MASK_B8_BF	0x00

#define DS_SUPPORT_MASK_C0_C7	0x00

#define DS_SUPPORT_MASK_C8_CF	0x00

#define DS_SUPPORT_MASK_D0_D7	0x03	// kDSWriteFile, kDSReadFile

#define DS_SUPPORT_MASK_D8_DF	0x00

#define DS_SUPPORT_MASK_E0_E7	0x00

#define DS_SUPPORT_MASK_E8_EF	0x00

#define DS_SUPPORT_MASK_F0_F7	0x00

#define DS_SUPPORT_MASK_F8_FF	0x80	// kDSReplyNAK

#define KProcessKilled 0x4B696C6C // "Kill"

#ifdef EKA2

#define EUSER_LIBPATH _L("Z:\\Sys\\Bin\\euser.dll")

#else

#define EUSER_LIBPATH _L("Z:\\System\\Libs\\euser.dll")

#endif

#ifdef __OEM_TRK__

#define TRK_TYPE_DESCRIPTION _L8("System TRK")

#else

#define TRK_TYPE_DESCRIPTION _L8("Application TRK")

#endif

//

// Swap2

//

// Byte-swaps a 2-byte value.  Used to convert to/from little/big endian.

//

static TUint16 Swap2(TUint16 aSource)

{

	TUint16 dest = 0;

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

	{

		dest <<= 8;

		dest |= aSource & 0xFF;

		aSource >>= 8;

	}

	return dest;

} 

//

// Swap4

//

// Byte-swaps a 4-byte value.  Used to convert to/from little/big endian.

//

static TUint32 Swap4(TUint32 aSource)

{

	TUint32 dest = 0;

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

	{

		dest <<= 8;

		dest |= aSource & 0xFF;

		aSource >>= 8;

	}

	return dest;

} 

//

// Swap4xN

//

//	Byte-swaps N 4-byte values *in place*.  Used to convert to/from little/big endian.

//

void Swap4xN(TUint32 *aSource, TInt aCount)

{

	while (aCount--)

	{

		TUint32 temp = Swap4(*aSource);

		*aSource++ = temp;

	}

} 

//

//

// CExitTrapper implementation

//

//

//

// CExitTrapper constructor

//

// Accepts CTrkDispatchLayer interface and the process ID of the

// process to watch

//

CExitTrapper::CExitTrapper(CTrkDispatchLayer *aDispatch, TUint32 aProcessId)

	: CActive(EPriorityStandard),

	  iProcessId(aProcessId),

	  iDispatch(aDispatch)

{

	CActiveScheduler::Add(this);

	TInt error = iProcess.Open(iProcessId);

	if (KErrNone != error)

		User::Panic(_L("Unable to open process"), __LINE__);

}

//

// CExitTrapper destructor

//

CExitTrapper::~CExitTrapper()

{

	Cancel();

	Deque();

	iProcess.Close();

}

//

// CExitTrapper::Watch

//

// Watch for the process to exit

//

void CExitTrapper::Watch()

{

	iProcess.Logon(iStatus);

	SetActive();

}

//

// CExitTrapper::RunL

//

// Called when the process exits

//

void CExitTrapper::RunL()

{

	// sometimes this is run when the process has yet to exit

	if (iProcess.ExitType() == EExitPending)

	{

		iProcess.LogonCancel(iStatus);

		Watch();

	}

	else

	{

		iDispatch->DoNotifyProcessDiedL(iProcessId, iProcess.ExitReason());

	}

}

//

// CExitTrapper::DoCancel

//

// Stop waiting for this process to exit

//

void CExitTrapper::DoCancel()

{

	iProcess.LogonCancel(iStatus);

}

//

//

// CEventTrapper implementation

//

//

//

// CEventTrapper constructor

//

// Accepts CTrkDispatchLayer interface

//

CEventTrapper::CEventTrapper(CTrkDispatchLayer *aDispatch)

	: CActive(CActive::EPriorityStandard),

	  iDispatch(aDispatch)

{

	CActiveScheduler::Add(this);

}

//

// CEventTrapper destructor

//

CEventTrapper::~CEventTrapper()

{

	Cancel();

	Deque();

}

//

// CEventTrapper::Watch

//

// Start listening for events

//

void CEventTrapper::Watch()

{

	iDispatch->iKernelDriver.GetEvent(iStatus, iEventInfo);

	SetActive();

}

//

// CEventTrapper::RunL

//

// Called when an event occurs

//

void CEventTrapper::RunL()

{

	// determine the type of event and handle accordingly

	switch (iEventInfo.iEventType)

	{

		case SEventInfo::EThreadBreakPoint:

		{

			iDispatch->DoNotifyStoppedL(iEventInfo.iProcessId, iEventInfo.iThreadId, iEventInfo.iCurrentPC, KNullDesC8);

			break;

		}

		case SEventInfo::EThreadException:

		{

			TBuf8<100> buf;

			switch(iEventInfo.iExceptionNumber)

			{

				case EExcIntegerDivideByZero:

				{

					buf.Format(_L8("An integer divide by zero exception has occurred."));

					break;

				}

				case EExcIntegerOverflow:

				{

					buf.Format(_L8("An integer overflow exception has occurred."));

					break;

				}

				case EExcBoundsCheck:

				{

					buf.Format(_L8("An bounds check exception has occurred."));

					break;

				}

				case EExcInvalidOpCode:

				{

					buf.Format(_L8("An invalid instruction exception has occurred."));

					break;

				}

				case EExcDoubleFault:

				{

					buf.Format(_L8("A double fault exception has occurred."));

					break;

				}

				case EExcStackFault:

				{

					buf.Format(_L8("A stack fault exception has occurred."));

					break;

				}

				case EExcAccessViolation:

				{

					buf.Format(_L8("An access violation exception has occurred."));

					break;

				}

				case EExcPrivInstruction:

				{

					buf.Format(_L8("A priveledged instruction exception has occurred."));

					break;

				}

				case EExcAlignment:

				{

					buf.Format(_L8("An alignment exception has occurred."));

					break;

				}

				case EExcPageFault:

				{

					buf.Format(_L8("A page fault exception has occurred."));

					break;

				}

				case EExcFloatDenormal:

				case EExcFloatDivideByZero:

				case EExcFloatInexactResult:

				case EExcFloatInvalidOperation:

				case EExcFloatOverflow:

				case EExcFloatStackCheck:

				case EExcFloatUnderflow:

				{

					buf.Format(_L8("A floating point exception has occurred."));

					break;

				}

				case EExcAbort:

				{

					buf.Format(_L8("An abort exception has occurred."));

					break;

				}

				case EExcUserInterrupt:

				{

					buf.Format(_L8("A user interrupt exception has occurred."));

					break;

				}

				case EExcDataAbort:

				{

					buf.Format(_L8("A data abort exception has occurred."));

					break;

				}

				case EExcCodeAbort:

				{

					buf.Format(_L8("A code abort exception has occurred."));

					break;

				}				

				case EExcGeneral:

				case EExcSingleStep:

				case EExcBreakPoint:

				case EExcKill:

				case EExcMaxNumber:

				case EExcInvalidVector:

				default:

				{

					buf.Format(_L8("An unknown exception (%d) has occurred."), iEventInfo.iExceptionNumber);

					break;				

				}

			}

			iDispatch->DoNotifyStoppedL(iEventInfo.iProcessId, iEventInfo.iThreadId, iEventInfo.iCurrentPC, buf);

			break;

		}

		case SEventInfo::EThreadPanic:

		{

			TBuf8<100> buf;

//			buf.Format(_L8("Thread 0x%x has panicked.\nCategory: %S\nReason: %d"), iEventInfo.iThreadId, &iEventInfo.iPanicCategory, iEventInfo.iExceptionNumber);

			buf.Format(_L8("Thread 0x%x has panicked. Category: %S; Reason: %d"), iEventInfo.iThreadId, &iEventInfo.iPanicCategory, iEventInfo.iPanicReason);

			iDispatch->DoNotifyStoppedL(iEventInfo.iProcessId, iEventInfo.iThreadId, iEventInfo.iCurrentPC, buf, true, iEventInfo.iExceptionNumber);

			break;

		}

		case SEventInfo::EProcessPanic:

		{

			TBuf8<100> buf;

			buf.Format(_L8("Process 0x%x has panicked.\nCategory: %S\nReason: %d"), iEventInfo.iProcessId, &iEventInfo.iPanicCategory, iEventInfo.iExceptionNumber);

			iDispatch->DoNotifyStoppedL(iEventInfo.iProcessId, iEventInfo.iThreadId, iEventInfo.iCurrentPC, buf);

			break;

		}

		case SEventInfo::ELibraryLoaded:

		{

			// a library has been loaded.  we get statically linked library loaded notifications

			// the very first time the process is created.  we want to ignore these because we

			// handle static libs in another way.  if the process the library was loaded for is

			// not being debugging, just resume the thread and ignore the event.  if the process

			// is being debugged but it hasn't yet been created, then this must be a static lib

			// and we ignore it.  note that we do not bother resuming the thread since it has not

			// been started yet!

			TBool created = EFalse;

			TBool found = EFalse;

			for (TInt i=0; i<iDispatch->iDebugProcessList.Count(); i++)

			{

				if (iDispatch->iDebugProcessList[i]->ProcessId() == iEventInfo.iProcessId)

				{

					created = iDispatch->iDebugProcessList[i]->iReadyForLibraryLoadNotification;

					found = ETrue;

					break;

				}

			}

		#ifndef EKA2

			if (!iEventInfo.iCodeAddress)

			{

				TBuf<KMaxPath> libName;

				libName.Copy(iEventInfo.iFileName);

				RLibrary lib;

				TInt err = lib.LoadRomLibrary(libName, KNullDesC);

				if (KErrNone == err)

				{

					iEventInfo.iCodeAddress = (TUint32)lib.EntryPoint();

					lib.Close();

				}

			}

		#endif

			if (!created || !iEventInfo.iCodeAddress || !found)

			{

				iDispatch->iKernelDriver.ResumeThread(iEventInfo.iThreadId);

			}

			else

			{

				iDispatch->DoNotifyLibraryLoadedL(iEventInfo.iFileName, iEventInfo.iProcessId, iEventInfo.iThreadId, iEventInfo.iCodeAddress, iEventInfo.iDataAddress);

			}

			break;

		}

		case SEventInfo::ELibraryUnloaded:

		{

			TBool found = EFalse;

			for (TInt i=0; i<iDispatch->iDebugProcessList.Count(); i++)

			{

				if (iDispatch->iDebugProcessList[i]->ProcessId() == iEventInfo.iProcessId)

				{

					found = ETrue;

					break;

				}

			}

			if (!found)

			{

				iDispatch->iKernelDriver.ResumeThread(iEventInfo.iThreadId);

			}

			else

			{

				iDispatch->DoNotifyLibraryUnloadedL(iEventInfo.iFileName, iEventInfo.iProcessId, iEventInfo.iThreadId);

			}

			break;

		}

		case SEventInfo::EUserTrace:

		{

			iDispatch->DoNotifyUserTraceL(iEventInfo.iTraceData);

			break;

		}

		case SEventInfo::EProcessAdded:

		{

			iDispatch->DoNotifyProcessAddedL(iEventInfo.iFileName, iEventInfo.iProcessId, 

											 iEventInfo.iThreadId, iEventInfo.iUid, 

											 iEventInfo.iCodeAddress, iEventInfo.iDataAddress);

			break;

		}

		case SEventInfo::EUnknown:

		default:

			User::Panic(_L("Unknown event type"), __LINE__);

			break;

	}

	// reset the values

	iEventInfo.Reset();

	// keep listening for more events

	Watch();

}

//

// CEventTrapper::DoCancel

//

// Stop listening for events

//

void CEventTrapper::DoCancel()

{

	iDispatch->iKernelDriver.CancelGetEvent();

}

//

//

// CDebugProcess implementation

//

//

//

// CDebugProcess::NewL

//

// Accepts CTrkDispatchLayer interface and the process ID and main

// thread ID of a process being debugged

//

CDebugProcess* CDebugProcess::NewL(CTrkDispatchLayer *aDispatch, TUint32 aProcessId, TUint32 aMainThreadId)

{

	CDebugProcess* self = new(ELeave) CDebugProcess();

	self->ConstructL(aDispatch, aProcessId, aMainThreadId);

	return self;

}

//

// CDebugProcess::ConstructL

//

// Accepts CTrkDispatchLayer interface and the process ID and main

// thread ID of a process being debugged

//

void CDebugProcess::ConstructL(CTrkDispatchLayer *aDispatch, TUint32 aProcessId, TUint32 aMainThreadId)

{

	iProcessId = aProcessId;

	iMainThreadId = aMainThreadId;

	iReadyForLibraryLoadNotification = EFalse;