// kill.cpp
// 
// Copyright (c) 2005 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//

#include "kill.h"
#include <fshell/common.mmh>

CCommandBase* CCmdKill::NewLC()
	{
	CCmdKill* self = new(ELeave) CCmdKill();
	CleanupStack::PushL(self);
	self->BaseConstructL();
	return self;
	}

CCmdKill::~CCmdKill()
	{
	delete iPanicCategory;
	delete iMatch;
	}

CCmdKill::CCmdKill()
	{
	}

const TDesC& CCmdKill::Name() const
	{
	_LIT(KName, "kill");
	return KName;
	}

void CCmdKill::DoRunL()
	{
	if (iTerminate && iPanicCategory)
		{
		PrintError(KErrArgument, _L("Options --terminate and --panic are mutually exclusive"));
		User::Leave(KErrArgument);
		}

	if (iMatch)
		{
		FindIdAndKillL(*iMatch);
		}
	else if (iArguments.IsPresent(&iId))
		{
		KillIdL(iId);
		}
	else
		{
		LeaveIfErr(KErrArgument, _L("You must specify either an id or a match string"));
		}
	}

template <class T>
void CCmdKill::DoKillByHandleL(TUint aId)
	{
	T handle;
	LeaveIfErr(handle.Open(aId, EOwnerThread), _L("Unable to open handle id %u"), aId);
	TName name(handle.Name());
	
	if (handle.ExitType() != EExitPending)
		{
		Printf(_L("%S (id=%u) has already exited"), &name, aId);
		handle.Close();
		return;
		}

	if (iTerminate)
		{
		handle.Terminate(iReason);
		Printf(_L("Terminated %S (id=%u) with %d\r\n"), &name, aId, iReason);
		}
	else if (iPanicCategory)
		{
		handle.Panic(*iPanicCategory, iReason);
		Printf(_L("Panicked %S (id=%u) with %S %d\r\n"), &name, aId, iPanicCategory, iReason);
		}
	else
		{
		handle.Kill(iReason);
		Printf(_L("Killed %S (id=%u) with %d\r\n"), &name, aId, iReason);
		}

	handle.Close();
	}

void CCmdKill::FindIdAndKillL(const TDesC& aPattern)
	{
	if (iThread) DoFindIdAndKillL<RThread, TFindThread>(aPattern);
	else DoFindIdAndKillL<RProcess, TFindProcess>(aPattern);
	}

template <class RProcessOrThread, class TFindProcessOrThread>
void CCmdKill::DoFindIdAndKillL(const TDesC& aPattern)
	{
	TFullName fullName;
	TInt numFound = 0;
	TFindProcessOrThread finder(aPattern);
	while (finder.Next(fullName) == KErrNone)
		{
		RProcessOrThread handle;
		TInt err = handle.Open(finder, EOwnerThread);
		if ((err == KErrNone) && (handle.ExitType() == EExitPending))
			{
			++numFound;
			TUint id = handle.Id().Id();
			handle.Close();
			if (iAll || numFound == 1)
				{
				KillIdL(id);
				}
			}
		else if (err)
			{
			PrintWarning(_L("Couldn't open %S (err=%d)"), &fullName);
			}
		}
	if (!iAll)
		{
		if (numFound == 0)
			{
			LeaveIfErr(KErrNotFound, _L("No matches for pattern \"%S\", or all matches are zombies"), &aPattern);
			}
		else if (numFound > 1)
			{
			PrintWarning(_L("%d further matches for pattern \"%S\" found, be more specific or use --all option"), numFound-1, &aPattern);
			}
		}
	}

void CCmdKill::DoKillThreadL(TUint aId)
	{
#ifdef FSHELL_MEMORY_ACCESS_SUPPORT
	LoadMemoryAccessL();

	RThread thread;
	LeaveIfErr(iMemAccess.RThreadForceOpen(thread, aId), _L("Unable to open thread"));
	TName name(thread.FullName());
	if (thread.ExitType() != EExitPending)
		{
		Printf(_L("%S (id=%u) has already exited"), &name, aId);
		thread.Close();
		return;
		}

	CleanupClosePushL(thread);
	TExitType type = EExitKill;
	if (iTerminate)
		{
		type = EExitTerminate;
		}
	else if (iPanicCategory)
		{
		type = EExitPanic;
		}
	TInt err = iMemAccess.ObjectDie(EThread, aId, NULL, type, iReason, iPanicCategory ? *iPanicCategory : KNullDesC());
	LeaveIfErr(err, _L("Couldn't kill thread id %u"), aId);

	if (iTerminate)
		{
		Printf(_L("Terminated %S (id=%u) with %d\r\n"), &name, aId, iReason);
		}
	else if (iPanicCategory)
		{
		Printf(_L("Panicked %S (id=%u) with %S %d\r\n"), &name, aId, iPanicCategory, iReason);
		}
	else
		{
		Printf(_L("Killed %S (id=%u) with %d\r\n"), &name, aId, iReason);
		}
	CleanupStack::PopAndDestroy(&thread);

#else
	DoKillByHandleL<RThread>(aId);
#endif
	}

void CCmdKill::OptionsL(RCommandOptionList& aOptions)
	{
	_LIT(KOptReason, "reason");
	_LIT(KOptThread, "thread");
	_LIT(KOptTerminate, "terminate");
	_LIT(KOptPanic, "panic");
	_LIT(KOptMatch, "match");
	_LIT(KOptAll, "all");
	aOptions.AppendIntL(iReason, KOptReason);
	aOptions.AppendBoolL(iTerminate, KOptTerminate);
	aOptions.AppendStringL(iPanicCategory, KOptPanic);
	aOptions.AppendBoolL(iThread, KOptThread);
	aOptions.AppendStringL(iMatch, KOptMatch);
	aOptions.AppendBoolL(iAll, KOptAll);
	}

void CCmdKill::ArgumentsL(RCommandArgumentList& aArguments)
	{
	_LIT(KArgId, "id");
	aArguments.AppendUintL(iId, KArgId);
	}

#ifdef EXE_BUILD
EXE_BOILER_PLATE(CCmdKill)
#endif

void CCmdKill::KillIdL(TUint aId)
	{
	if (iThread)
		{
		DoKillThreadL(aId);
		}
	else
		{
		DoKillByHandleL<RProcess>(aId);
		}
	}