// Copyright (c) 2008-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:

// e32utils\d_exc\d_exc.cpp

// Trap and log user-side exceptions and panics.

// USAGE:

// d_exc

// Trap panics and exceptions forever.  Prompt whether to log.

// Logs go on C: drive.

// d_exc [-m] [-nN] [-pN] [-b] [-d log_path]

// -m	minimal logging (no stack dump)

// -nN	stop after N exceptions/panics

// -pN	log to serial port N instead of C: drive

// -b	do not prompt; always log

// -d  specify the path for log files.  If not given, logs are

// written to the root of the system drive.  If just a path

// name is given, logs are written to that directory (must

// start with a \) on the system drive.

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32svr.h>

#include <d32comm.h>

#include <f32file.h>

#include "minkda.h"

RNotifier Notifier;				// The "UI"

RMinKda Trapper;

RFs FileSession;

TBuf16<KMaxFileName> LogPath; // to specify log file location

// Possible outputs where crash information can be dumped

enum TOutputType{ EFile, ESerial };

// Variables shared between DumpLine() and the various functions used

// to format crash info.

TOutputType ActiveOutput = EFile;	

TBool IoError;						// ETrue after I/O error

RBusDevComm CommPort;				// Handle to serial port used

RFile File;							// Handle to text file used

// Maximum length in characters of a line in the file containing

// textual information about the crash.

const TInt KMaxLineLength = KMaxFullName + 32;

class TLexNew : public TLex16

	{

public:

	inline TLexNew(const TDesC16& aDes) {Assign(aDes);}

	TInt ExtractParameter(TDes16 &aParam);

	};

TInt TLexNew::ExtractParameter(TDes16 &aParam)

	{

	TBuf16<512> token;

	TBuf16<512> param;

	TBool GetNext = EFalse;

	//exit..if it's empty (empty option at the end of command)

	if (!Peek())

		return KErrArgument;

	// remove any space between option and the rest of param..

	SkipSpace();

	// just see, what's next.. 

	// if there this a param with spaces- should be in "quotes"

	if (Peek() == '"')

		{

		GetNext = ETrue;

		Inc(); // skip this quote " and move to next position..   

		}

	// remove spaces after quotes ("  param...")

	SkipSpace();

	// ..mark next character position as a start of our token 

	Mark();

	// move until the end of our token (next space).. 

	SkipCharacters();

	//and get it!!

	token.Copy(MarkedToken());

	// if.. there was one-word param.. with quotes..shrink it..and don't try to search next one..

	if (*(token.MidTPtr(token.Length()-1).Ptr()) == '"')

		{

		// just shrink it by that ending quote..

		token.SetLength(token.Length()-1);

		GetNext=EFalse;

		}

	// This is at least beginning of our param.. let's use it!

	// add this to beginning of our param..

	param.Append(token);

	// if this was param specified in quotes..search for the ending quote..

	while (GetNext)

		{

		// Next is space.. 

		SkipSpace();

		// before taking next one..check it - if '-' on the beginning..

		// it's either next param specifier..(no ending quote at all) 

		if (Peek() == '-')

			return KErrArgument;

		// get the next one..

		token.Copy(NextToken());

		// was there any token more? ..if not- we're at the end..

		// so the ending quote still wasn't found...

		if (!token.Length())

			return KErrArgument;

		// is this the last one - with quote" at the end?

		if (*(token.MidTPtr(token.Length()-1).Ptr()) == '"')

			{

			// just shrink it by that ending quote..

			token.SetLength(token.Length()-1);

			GetNext=EFalse;

			}

		param.Append(_L(" ")); // there was space in orig. param..restore it..

		param.Append(token); // and append this token to our param..

		}

	// if there was any space at the end..(e.g. if specified: -d"c:\logs  ")

	// - remove it

	param.TrimRight();

	//finally - copy param to the referenced descriptor

	aParam.Copy(param);

	return KErrNone;

	}

TInt ValidatePath(TDes16 &aLogPath)

	{

	// check the length first.. (20 chars for file name..)

	if (aLogPath.Length() >(KMaxFileName - 20))

		{

		Notifier.InfoPrint(_L("directory name too long.."));

		return KErrArgument;

		}

	// if it hasn't drive letter (colon wasn't second..)

	if (*(aLogPath.MidTPtr(1).Ptr()) != ':')

		{

		// if it starts with "\" use system drive.. 

		if (*(aLogPath.MidTPtr(0).Ptr()) == '\\')

			{

			// if someone specified param like: "\ path\" ...obviously..

			if (*(aLogPath.MidTPtr(1).Ptr()) == ' ')

				return KErrArgument;

			TBuf16<2> drive;

			drive.Append(RFs::GetSystemDriveChar());

			drive.LowerCase();

			drive.Append(_L(":"));

			aLogPath.Insert(0, drive);

			}

		else //otherwise -path not valid.. 

			{

			return KErrArgument;

			}

		}

	// and add backslash if needed

	if (*(aLogPath.MidTPtr(aLogPath.Length()-1).Ptr()) != '\\')

		aLogPath.Append(_L("\\"));

	//open file session..

	if (FileSession.Connect() != KErrNone)

		return KErrGeneral;

	RDir dir;

	TInt err=KErrNone;

	if (dir.Open(FileSession, aLogPath, KEntryAttMatchExclusive) != KErrNone)

		{

		Notifier.InfoPrint(_L("specified directory doesn't exist"));

		LogPath.Zero(); //clear global path..

		err = KErrArgument;

		}

	else

		{

		dir.Close();

		}

	// close file session..

	FileSession.Close();

	return err;

	}

// Open specified serial port and push handle on the cleanup stack.

void OpenCommPortLC(TInt aPortNum)

	{

#ifdef __WINS__	

	_LIT(KPdd, "ECDRV");

#else

	_LIT(KPdd, "EUART");

#endif

	_LIT(KLdd, "ECOMM");

	_LIT(KErrPdd, "Failed to load serial PDD");

	_LIT(KErrLdd, "Failed to load serial LDD");

	_LIT(KErrOpen, "Failed to open comm port");

	_LIT(KErrCfg, "Failed to configure comm port");

	TInt r = User::LoadPhysicalDevice(KPdd);

	if (r != KErrNone && r != KErrAlreadyExists)

		{

		Notifier.InfoPrint(KErrPdd);

		User::Leave(r);

		}

	r = User::LoadLogicalDevice(KLdd);

	if (r != KErrNone && r != KErrAlreadyExists)

		{

		Notifier.InfoPrint(KErrLdd);

		User::Leave(r);

		}

	r = CommPort.Open(aPortNum);

	if (r != KErrNone)

		{

		Notifier.InfoPrint(KErrOpen);

		User::Leave(r);

		}

	CleanupClosePushL(CommPort);

	TCommConfig cfgBuf;

	TCommConfigV01& cfg=cfgBuf();

	CommPort.Config(cfgBuf);

	cfg.iRate=EBps115200;

	cfg.iDataBits=EData8;

	cfg.iStopBits=EStop1;

	cfg.iParity=EParityNone;

	cfg.iHandshake=KConfigObeyXoff|KConfigSendXoff;

	cfg.iFifo=EFifoEnable;

	cfg.iTerminatorCount=0;

	cfg.iSIREnable=ESIRDisable;

	r = CommPort.SetConfig(cfgBuf);

	if (r != KErrNone)

		{

		Notifier.InfoPrint(KErrCfg);

		User::Leave(r);

		}

	}

void ParseCmdLineL(TInt& aPortNum, TInt& aMaxTrapCount, TBool& aInteractive, TBool& aDumpStack)

	{

	_LIT(KInvalidArg, "Invalid command-line");

	HBufC* cl = HBufC::NewLC(User::CommandLineLength());

	TPtr clp = cl->Des();

	User::CommandLine(clp);

	// If started from UIKON shell, ignore command-line and use defaults

	if (clp.Match(_L("?:\\*")) == 0)

		return;

	TLexNew lex(*cl);

	while (! lex.Eos())

		{

		TInt r = KErrArgument;

		if (lex.Get() == '-')

			{

			switch (lex.Get())

				{

			case 'n':

				r = lex.Val(aMaxTrapCount);

				break;

			case 'p':

				r = lex.Val(aPortNum);

				if (r == KErrNone)

					ActiveOutput = ESerial;

				break;

			case 'b':

				aInteractive = EFalse;

				r = KErrNone;

				break;

			case 'm':

				aDumpStack = EFalse;

				r = KErrNone;

				break;

			case 'd':

				//try to extract path and store it in global buffer

				r = lex.ExtractParameter(LogPath);

				// check, if specified path is valid

				if (r == KErrNone)  

					r = ValidatePath(LogPath);  

				break;

				}

			}

		if (r != KErrNone)

			{

			Notifier.InfoPrint(KInvalidArg);

			User::Leave(KErrArgument);

			}

		lex.SkipSpace();

		}

	CleanupStack::PopAndDestroy(cl);

	}

// Dump specified line + CRLF on the selected output.  Set IoError to

// ETrue if an error occurs.

void DumpLine(TDes8& aLine)

	{

	TInt r;

	_LIT8(KCrLf, "\r\n");

	aLine.Append(KCrLf);

	if (ActiveOutput == ESerial)

		{

		TRequestStatus s;

		CommPort.Write(s, aLine);

		User::WaitForRequest(s);

		r = s.Int();

		}

	else

		r = File.Write(aLine);

	if (r != KErrNone)

		IoError = ETrue;

	}

void DumpExcInfo(const TDbgCpuExcInfo& aInfo, TDes8& aLine)

	{

	_LIT8(KHdr, "\r\nUNHANDLED EXCEPTION:");

	aLine = KHdr;

	DumpLine(aLine);

#ifdef __MARM__

	_LIT8(KFmt1, "code=%d PC=%08x FAR=%08x FSR=%08x");

	aLine.Format(KFmt1, aInfo.iExcCode, aInfo.iFaultPc, aInfo.iFaultAddress, aInfo.iFaultStatus);

	DumpLine(aLine);

	_LIT8(KFmt2, "R13svc=%08x R14svc=%08x SPSRsvc=%08x");

	aLine.Format(KFmt2, aInfo.iR13Svc, aInfo.iR14Svc, aInfo.iSpsrSvc); 

	DumpLine(aLine);

#else

	(void) aInfo; // silence warning

#endif

	}

void DumpRegisters(const TDbgRegSet& aRegs, TDes8& aLine)

	{

#if defined(__MARM__)

	_LIT8(KHdr, "\r\nUSER REGISTERS:");

	aLine = KHdr;

	DumpLine(aLine);

	_LIT8(KFmtCpsr, "CPSR=%08x");

	aLine.Format(KFmtCpsr, aRegs.iCpsr);

	DumpLine(aLine);

	for (TInt i=0; i<TDbgRegSet::KRegCount; i+=4)

		{

		_LIT8(KFmtReg, "r%02d=%08x %08x %08x %08x");

		aLine.Format(KFmtReg, i, aRegs.iRn[i], aRegs.iRn[i+1], aRegs.iRn[i+2], aRegs.iRn[i+3]);

		DumpLine(aLine);

		}

#else

	(void) aRegs; // silence warnings

	(void) aLine; 

#endif

	}

void DumpCodeSegs(TUint aPid, TDes8& aLine)

	{

	_LIT(KPanicCodeMods, "DEXC-CODEMOD");

	_LIT8(KHdr, "\r\nCODE SEGMENTS:");

	_LIT8(KFmtOverflow, "Only first %d code modules displayed");

	_LIT8(KFmtMod, "%08X-%08X %S");

	aLine = KHdr;

	DumpLine(aLine);

	// :FIXME: improve API

	// :FIXME: suspend/resume all threads in process

	const TInt KMaxCount = 128;

	TAny* handles[KMaxCount];

	TInt c = KMaxCount;

	TInt r = Trapper.GetCodeSegs(aPid, handles, c);

	__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicCodeMods, r));

	if (c > KMaxCount)

		{

		aLine.Format(KFmtOverflow, c);

		DumpLine(aLine);

		c = KMaxCount;

		}

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

		{

		TDbgCodeSegInfo info;

		r = Trapper.GetCodeSegInfo(handles[i], aPid, info);

		if (r == KErrNone)

			{

			TBuf8<KMaxFileName> path;

			path.Copy(info.iPath);

			aLine.Format(KFmtMod, info.iCodeBase, info.iCodeBase+info.iCodeSize, &path);

			DumpLine(aLine);

			}

		}

	}

void DumpTextInfo(const TDbgCrashInfo& aCrashInfo, const TDbgThreadInfo& aThreadInfo)

	{

	_LIT(KFmtTextFile, "d_exc_%d.txt");

	_LIT(KErrTextOpen, "text file open error");

	_LIT(KErrTextWrite, "text file write error");

	if (ActiveOutput == EFile)

		{

		TBuf16<KMaxFileName> name;

		name.Format(KFmtTextFile, aCrashInfo.iTid);

		// if -d param wasn't specified, use default location..(root dir on system drive)

		if(!LogPath.Length())

			{

			LogPath.Append(RFs::GetSystemDriveChar());

			LogPath.LowerCase();

			LogPath.Append(_L(":\\"));

			}

		TBuf16<KMaxFileName> filename;

		filename.Copy(LogPath); 

		filename.Append(name);

		TInt r = File.Replace(FileSession, filename, EFileWrite+EFileShareAny+EFileStream);

		if (r != KErrNone)

			{

			Notifier.InfoPrint(KErrTextOpen);

			return;

			}

		}

	IoError = EFalse;

	// Note that following buffer is passed to callee functions and

	// reuse to minimise stack footprint.

	TBuf8<KMaxLineLength> line;

	line.Fill('-', 76);

	DumpLine(line);

	_LIT8(KHdr, "EKA2 USER CRASH LOG");

	line = KHdr;

	DumpLine(line);

	line.Copy(aThreadInfo.iFullName);

	_LIT8(KName, "Thread Name: ");

	line.Insert(0, KName);

	DumpLine(line);

	_LIT8(KFmtTid, "Thread ID: %u");

	line.Format(KFmtTid, aCrashInfo.iTid);

	DumpLine(line);

	_LIT8(KFmtStack, "User Stack %08X-%08X");

	line.Format(KFmtStack, aThreadInfo.iStackBase,

				aThreadInfo.iStackBase+aThreadInfo.iStackSize);

	DumpLine(line);

	if (aCrashInfo.iType == TDbgCrashInfo::EPanic)

		{

		TBuf8<KMaxExitCategoryName> cat;

		cat.Copy(aThreadInfo.iExitCategory);

		_LIT8(KFmtPanic, "Panic: %S-%d");

		line.Format(KFmtPanic, &cat, aThreadInfo.iExitReason);

		DumpLine(line);

		}

	else

		DumpExcInfo(aCrashInfo.iCpu, line);

	DumpRegisters(aThreadInfo.iCpu, line);

	DumpCodeSegs(aThreadInfo.iPid, line);

	line.Zero();

	DumpLine(line);

	if (IoError)

		Notifier.InfoPrint(KErrTextWrite);

	if (ActiveOutput == EFile)

		File.Close();

	}

// Output stack on selected output.  If serial port, use

// human-readable format.  If file, use binary format.

void DumpStack(TUint aTid, const TDbgThreadInfo& aInfo)

	{

	_LIT(KFmtStackFile, "d_exc_%d.stk");

	_LIT(KErrStackOpen, "stack file open error");

	_LIT(KErrStackWrite, "stack file write error");

	_LIT(KPanicReadStack, "DEXC-READSTACK");

	TInt r;

	IoError = EFalse;

	RFile file;

	if (ActiveOutput == EFile)

		{

		TBuf16<KMaxFileName> name;

		name.Format(KFmtStackFile, aTid);

		// if -d param wasn't specified, use default location..(root dir on system drive)

		if(!LogPath.Length())

			{

			LogPath.Append(RFs::GetSystemDriveChar());

			LogPath.LowerCase();

			LogPath.Append(_L(":\\"));

			}

		TBuf16<KMaxFileName> filename;

		filename.Copy(LogPath); 

		filename.Append(name);

		r = file.Replace(FileSession, filename, EFileWrite+EFileShareAny+EFileStream);

		if (r != KErrNone)

			{

			Notifier.InfoPrint(KErrStackOpen);

			return;

			}

		}

	const TInt KBufSize = 256;

	TBuf8<KBufSize> buf;

	TLinAddr top = aInfo.iStackBase + aInfo.iStackSize;

	for (TLinAddr base = aInfo.iStackBase; base < top; base += KBufSize)

		{

		// Read chunk of stack.  Should always succeeds as thread has

		// been suspended by LDD.

		r = Trapper.ReadMem(aTid, base, buf);

		__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicReadStack, r));

		if (ActiveOutput == ESerial)

			{

			TBuf8<80> out;

			TBuf8<20> ascii;

			TUint a = base;

			TInt len = buf.Length();

			TInt offset = 0;

			while(len>0)

				{

				out.Zero();

				ascii.Zero();

				out.AppendNumFixedWidth(a,EHex,8);

				out.Append(_L8(": "));

				TUint b;

				for (b=0; b<16; b++)

					{

					TUint8 c=*(buf.Ptr()+offset+b);

					out.AppendNumFixedWidth(c,EHex,2);

					out.Append(' ');

					if (c<0x20 || c>=0x7f)

						c=0x2e;

					ascii.Append(TChar(c));

					}

				out.Append(ascii);

				DumpLine(out);

				a+=16;

				offset += 16;

				len-=16;

				} 

			}

		else

			{

			if (file.Write(buf) != KErrNone)

				IoError = ETrue;

			}

		}

	if (IoError)

		Notifier.InfoPrint(KErrStackWrite);

	if (ActiveOutput == EFile)

		file.Close();

	}

// Display a dialog box containing basic facts about the crash and ask

// the user whether to dump detailed information or skip this crash.

enum TDebugChoice { EDoDebug, EDoNotDebug }; 

TDebugChoice CrashDialog(TDbgCrashInfo::TType aCrashType, const TDbgThreadInfo& aInfo)

	{

	_LIT(KExc, "Exception");

	_LIT(KPanic, "Panic %S:%d");

	_LIT(KBut1, "Do Not Debug");

	_LIT(KBut2, "Debug");

	TBuf<64> line1;

	if (aCrashType == TDbgCrashInfo::EException)

		line1 = KExc;

	else

		line1.Format(KPanic, &aInfo.iExitCategory, aInfo.iExitReason);

	TInt r;

	TRequestStatus s;

	Notifier.Notify(line1, aInfo.iFullName, KBut1, KBut2, r, s);

	User::WaitForRequest(s);

	return r == 0 ? EDoNotDebug : EDoDebug;

	}

void MainL()

	{

	_LIT(KErrFs, "Failed to connect to file server");

	_LIT(KErrLoadLdd, "Failed to load KDA LDD");

	_LIT(KErrOpenLdd, "Failed to open KDA LDD");

	_LIT(KLddPath, "MINKDA");

	_LIT(KStarted, "D_EXC started");

	_LIT(KCrash, "Crash detected");

	_LIT(KPanicThreadInfo, "DEXC-THREADINFO");

	TInt portNum;

	TInt maxTrapCount = -1;

	TBool isInteractive = ETrue;

	TBool dumpStack = ETrue;

	ParseCmdLineL(portNum, maxTrapCount, isInteractive, dumpStack);

	// Open selected output and push resulting handle on cleanup

	// stack.

	TInt r;

	if (ActiveOutput == EFile)

		{

		if ((r = FileSession.Connect()) != KErrNone)

			{

			Notifier.InfoPrint(KErrFs);

			User::Leave(r);

			}

		CleanupClosePushL(FileSession);

		}

	else

		OpenCommPortLC(portNum);

	r = User::LoadLogicalDevice(KLddPath);

	if (r != KErrNone && r != KErrAlreadyExists)

		{

		Notifier.InfoPrint(KErrLoadLdd);

		User::Leave(r);

		}

// See comment near __KHEAP_MARKEND

//	 __KHEAP_MARK;

	r = Trapper.Open();

	if (r != KErrNone)

		{

		Notifier.InfoPrint(KErrOpenLdd);

		User::Leave(r);

		}

	CleanupClosePushL(Trapper);

	Notifier.InfoPrint(KStarted);

	// Main loop

	TRequestStatus s;

	TDbgCrashInfo crashInfo;

	Trapper.Trap(s, crashInfo);

	for (TInt crashCount = 0; maxTrapCount<0 || crashCount<maxTrapCount; ++crashCount)

		{

		User::WaitForRequest(s);

		// Get more info about crashed thread.  Should always succeeds

		// as the thread has been suspended by LDD.

		TDbgThreadInfo threadInfo;

		TInt r = Trapper.GetThreadInfo(crashInfo.iTid, threadInfo);

		__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicThreadInfo, r));

		if (! isInteractive)

			Notifier.InfoPrint(KCrash);

		if (! isInteractive || CrashDialog(crashInfo.iType, threadInfo) == EDoDebug)

			{

			DumpTextInfo(crashInfo, threadInfo);

			if (dumpStack)

				DumpStack(crashInfo.iTid, threadInfo);

			}

		Trapper.Trap(s, crashInfo);

		Trapper.KillCrashedThread();

		}

	Trapper.CancelTrap();

	CleanupStack::PopAndDestroy(&Trapper);

	CleanupStack::PopAndDestroy(); // FileSession or CommPort

// Commented out because the InfoPrint thread may or may not have

// terminated when we reach this point.  It if hasn't a spurious

// memory leak will be reported.

// #ifdef _DEBUG

// 	User::After(3000000);

// 	 __KHEAP_MARKEND;

// #endif

	User::FreeLogicalDevice(KKdaLddName);

	}

TInt E32Main()

	{

	_LIT(KPanicNtf, "DEXC-NO-NTF");

	_LIT(KPanicLeave, "DEXC-LEAVE");

	_LIT(KPanicOom, "DEXC-NO-CLEANUP");

	// :FIXME: remove when platform security is always on

	RProcess().DataCaging(RProcess::EDataCagingOn);

#ifdef _DEBUG

	TInt phcStart;

	TInt thcStart;

	RThread().HandleCount(phcStart, thcStart);

#endif

	TInt r = Notifier.Connect();

	__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicNtf, r));

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	__ASSERT_ALWAYS(cleanup, User::Panic(KPanicOom, KErrNoMemory));

	TRAP(r, MainL());

 	__ASSERT_ALWAYS(r == KErrNone, User::Panic(KPanicLeave, r));

	delete cleanup;

	__UHEAP_MARKEND;

	Notifier.Close();

#ifdef _DEBUG

	TInt phcEnd;

	TInt thcEnd;

	RThread().HandleCount(phcEnd, thcEnd);

	__ASSERT_DEBUG(phcStart == phcEnd, User::Panic(_L("DEXC-PHC"), phcEnd-phcStart));

	__ASSERT_DEBUG(thcStart == thcEnd, User::Panic(_L("DEXC-THC"), thcEnd-thcStart));

#endif

	return r;

	}