// commands.cpp

// 

// Copyright (c) 2006 - 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 <e32debug.h>

#include <e32rom.h>

#include <f32dbg.h>

#include <f32image.h>

#include <hal.h>

#include <fshell/common.mmh>

#include <fshell/ltkutils.h>

#include <fshell/descriptorutils.h>

#include <fshell/heaputils.h>

using LtkUtils::RAllocatorHelper;

#ifdef FSHELL_MEMORY_ACCESS_SUPPORT

#include <fshell/memoryaccess.h>

#endif

#include "fshell.h"

#include "commands.h"

#include "command_factory.h"

#include "string_utils.h"

//

// Constants.

//

_LIT(KOptVerbose, "verbose");

_LIT(KOptHuman, "human");

_LIT(KNewLine, "\r\n");

_LIT(KTab, "\t");

_LIT(KRepeatCount, "REPEAT_COUNT");

const TInt KBlockSize = 512;

_LIT(KMatchAll, "*");

//

// CCmdHelp.

//

CCommandBase* CCmdHelp::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdHelp::~CCmdHelp()

	{

	delete iFormatter;

	}

CCmdHelp::CCmdHelp() : CCommandBase(ECompleteOnRunL)

	{

	}

const TDesC& CCmdHelp::Name() const

	{

	_LIT(KCmdHelpName, "help");

	return KCmdHelpName;

	}

void CCmdHelp::DoRunL()

	{

	if (iOptions.IsPresent(&iCount))

		{

		const TInt count = gShell->CommandFactory().CountUniqueCommandsL();

		Complete(_L("%d\r\n"), count);

		}

	else

		{

		RArray<TPtrC> commands;

		CleanupClosePushL(commands);

		gShell->CommandFactory().ListCommandsL(commands);

		if (!Stdout().AttachedToConsole())

			{

			// Print them one per line (like how ls does it when not attached to a console)

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

				{

				// The async writing is a legacy from when help was a local command. We don't need to observe it now.

				Printf(_L("%S\r\n"), &commands[i]);

				}

			Complete();

			}

		else

			{

			iFormatter = CTextFormatter::NewL(Stdout());

			iFormatter->ColumnizeL(0, 2, commands.Array());

			Stdout().Write(iFormatter->Descriptor(), iStatus);

			SetActive();

			}

		CleanupStack::PopAndDestroy(&commands);

		}

	}

void CCmdHelp::OptionsL(RCommandOptionList& aOptions)

	{

	_LIT(KOptCount, "count");

	aOptions.AppendBoolL(iCount, KOptCount);

	}

//

// CCmdExit.

//

CCommandBase* CCmdExit::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdExit::~CCmdExit()

	{

	}

CCmdExit::CCmdExit()

	{

	}

const TDesC& CCmdExit::Name() const

	{

	_LIT(KCmdExitName, "exit");

	return KCmdExitName;

	}

void CCmdExit::DoRunL()

	{

	// Note, this command should never execute as 'exit' has handled explicitly by CParser.

	// It exists so that 'exit' appears in fshell's help list and also to support 'exit --help'.

	LeaveIfErr(KErrGeneral, _L("Invalid context for 'exit' command (must be run as a bare command, not in a pipe-line)"));

	}

//

// CCmdLs.

//

CCommandBase* CCmdLs::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CCmdLs::~CCmdLs()

	{

	delete iFormatter;

	}

CCmdLs::CCmdLs()

	{

	}

void CCmdLs::ConstructL()

	{

	BaseConstructL();

	}

void CCmdLs::PrintDirContentL(RDir& aDir)

	{

	TInt err = KErrNone;

	TEntry entry;

	while (err == KErrNone)

		{

		err = aDir.Read(entry);

		if (err == KErrNone)

			{

			FormatEntryL(entry);

			Write(iFormatter->Descriptor());

			iFormatter->Zero();

			if (iOptRecurse && entry.IsDir())

				{

				RecursiveScanDirL(entry.iName);

				}

			}

		}

	if (err == KErrEof)

		{

		err = KErrNone;

		}

	User::LeaveIfError(err);

	}

void CCmdLs::PrintDirContentL(const CDir& aDir)

	{

	IoUtils::CTextBuffer* buf = IoUtils::CTextBuffer::NewLC(0x100);

	const TInt numEntries = aDir.Count();

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

		{

		const TEntry& entry = aDir[i];

		buf->AppendL(entry.iName);

		buf->AppendL(_L("\t"));

		}

	iFormatter->ColumnizeL(0, 2, buf->Descriptor());

	Write(iFormatter->Descriptor());

	CleanupStack::PopAndDestroy(buf);

	}

void CCmdLs::FormatEntryL(const TEntry& aEntry)

	{

	if (iOptLong)

		{

		iFormatter->AppendFormatL(_L("%c%c%c%c%c  "), aEntry.IsDir() ? 'd' : '-', aEntry.IsReadOnly() ? 'r' : '-', aEntry.IsHidden() ? 'h' : '-', aEntry.IsSystem() ? 's' : '-', aEntry.IsArchive() ? 'a' : '-');

		if (iOptHuman)

			{

			iFormatter->AppendHumanReadableSizeL(aEntry.iSize);

			iFormatter->AppendL(_L("  "));

			}

		else

			{

			iFormatter->AppendFormatL(_L("%+ 10d  "), aEntry.iSize);

			}

		aEntry.iModified.FormatL(iTempBuf, _L("%1%/1%2%/2%3 %H%:1%T%:2%S "));

		TPtrC pathRelativeToBaseDir = iFileName.Mid(iBaseDir.Length());

		iFormatter->AppendFormatL(_L("%S%S%S\r\n"), &iTempBuf, &pathRelativeToBaseDir, &aEntry.iName);

		}

	else

		{

		TPtrC pathRelativeToBaseDir = iFileName.Mid(iBaseDir.Length());

		iFormatter->AppendFormatL(_L("%S%S\r\n"), &pathRelativeToBaseDir, &aEntry.iName);

		}

	}

const TDesC& CCmdLs::Name() const

	{

	_LIT(KCmdLsName, "ls");

	return KCmdLsName;

	}

void CCmdLs::DoRunL()

	{

	if (iFileName.Length() == 0)

		{

		iFileName = Env().Pwd();

		}

	if (!iFileName.IsWild() && !iFileName.IsDriveRoot())

		{

		LeaveIfFileNotFound(iFileName);

		if (iFileName.IsDirL(FsL()))

			{

			iFileName.SetIsDirectoryL();

			}

		}

	if (iOptRecurse || iOptLong || !Stdout().AttachedToConsole())

		{

		iOptOnePerLine = ETrue;

		}

	iFormatter = CTextFormatter::NewL(Stdout());

	iBaseDir.Set(TParsePtrC(iFileName).DriveAndPath());

	if (iOptOnePerLine)

		{

		DoScanDirL();

		}

	else

		{

		CDir* files;

		LeaveIfErr(FsL().GetDir(iFileName, iOptAll ? KEntryAttMaskSupported : KEntryAttNormal | KEntryAttDir, ESortByName, files), _L("Couldn't read whole directory into memory - try using -1"));

		CleanupStack::PushL(files);

		PrintDirContentL(*files);

		CleanupStack::PopAndDestroy(files);

		}

	}

void CCmdLs::OptionsL(RCommandOptionList& aOptions)

	{

	_LIT(KCmdLsOptAll, "all");

	_LIT(KCmdLsOptLong, "long");

	_LIT(KCmdLsOptHuman, "human");

	_LIT(KCmdLsOptOnePerLine, "one");

	_LIT(KCmdLsOpRecurse, "recurse");

	aOptions.AppendBoolL(iOptAll, KCmdLsOptAll);

	aOptions.AppendBoolL(iOptLong, KCmdLsOptLong);

	aOptions.AppendBoolL(iOptHuman, KCmdLsOptHuman);

	aOptions.AppendBoolL(iOptOnePerLine, KCmdLsOptOnePerLine);

	aOptions.AppendBoolL(iOptRecurse, KCmdLsOpRecurse);

	}

void CCmdLs::ArgumentsL(RCommandArgumentList& aArguments)

	{

	_LIT(KCmdLsArg, "dir_name");

	aArguments.AppendFileNameL(iFileName, KCmdLsArg);

	}

void CCmdLs::RecursiveScanDirL(const TDesC& aName)

	{

	TInt currentDirectoryLen = iFileName.Length();

	iFileName.AppendComponentL(aName, TFileName2::EDirectory);

	DoScanDirL();

	iFileName.SetLength(currentDirectoryLen); // Since this is called recursively, restore iTempName to what it was previously

	}

void CCmdLs::DoScanDirL()

	{

	RDir dir;

	User::LeaveIfError(dir.Open(FsL(), iFileName, iOptAll ? KEntryAttMaskSupported : KEntryAttNormal | KEntryAttDir));

	CleanupClosePushL(dir);

	iFileName.SetLength(TParsePtrC(iFileName).DriveAndPath().Length()); // Remove any possible wildcard or name from the end of iFileName before recursing

	PrintDirContentL(dir);

	CleanupStack::PopAndDestroy(&dir);

	}

//

// CCmdCd.

//

CCommandBase* CCmdCd::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdCd::~CCmdCd()

	{

	}

CCmdCd::CCmdCd()

	: iDir(TFileName2::EDirectory)

	{

	}

const TDesC& CCmdCd::Name() const

	{

	_LIT(KCmdCdName, "cd");

	return KCmdCdName;

	}

void CCmdCd::DoRunL()

	{

	if (iDir.IsDriveRoot()) // For some reason best known to the designers of F32, it's not possible to retrieve a TEntry object for the root of a drive (fails with KErrBadName).

		{

		TDriveList driveList;

		LeaveIfErr(FsL().DriveList(driveList), _L("Couldn't get drive list"));

		TInt driveNum = TChar(iDir[0]).GetUpperCase() - 'A';

		if (driveNum >= KMaxDrives)

			{

			Complete(KErrArgument, _L("Invalid drive letter"));

			return;

			}

		if (!driveList[driveNum])

			{

			Complete(KErrNotReady, _L("Drive not present"));

			return;

			}

		}

	else

		{

		iDir.Normalize(FsL());

		LeaveIfFileNotFound(iDir);

		if (!iDir.IsDirL(FsL()))

			{

			Complete(KErrBadName, _L("%S is not a directory"), &iDir);

			return;

			}

		}

	Env().SetPwdL(iDir);

	}

void CCmdCd::ArgumentsL(RCommandArgumentList& aArguments)

	{

	_LIT(KCmdCdArg, "directory");

	aArguments.AppendFileNameL(iDir, KCmdCdArg);

	}

//

// CCmdClear.

//

CCommandBase* CCmdClear::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdClear::~CCmdClear()

	{

	}

CCmdClear::CCmdClear()

	{

	}

const TDesC& CCmdClear::Name() const

	{

	_LIT(KCmdClearName, "clear");

	return KCmdClearName;

	}

void CCmdClear::DoRunL()

	{

	if (iFormFeed)

		{

		TInt consoleHeight = Stdout().GetScreenSizeL().iHeight;

		Stdout().SetCursorPosAbsL(TPoint(0, consoleHeight-1));

		RBuf buf;

		buf.CreateL(consoleHeight * 2);

		while (consoleHeight--) buf.Append(KNewLine);

		Stdout().Write(buf);

		buf.Close();

		Stdout().SetCursorPosAbsL(TPoint(0,0));

		}

	else

		{

		Stdout().ClearScreenL();

		Stdin().SetMode(RIoReadWriteHandle::EText);

		Stdout().SetMode(RIoReadWriteHandle::EText);

		Stderr().SetMode(RIoReadWriteHandle::EText);

		}

	}

void CCmdClear::OptionsL(RCommandOptionList& aOptions)

	{

	_LIT(KOptFormFeed, "formfeed");

	aOptions.AppendBoolL(iFormFeed, KOptFormFeed);

	}

//

// CForegroundAdjuster

//

class CForegroundAdjuster : public CActive

	{

public:

	static CForegroundAdjuster* NewL(CCommandBase& aCommand, TInt aJobId, TBool aToForeground);

	~CForegroundAdjuster();

private: // From CActive.

	virtual void RunL();

	virtual void DoCancel();

	virtual TInt RunError(TInt aError);

private:

	CForegroundAdjuster(CCommandBase& aCommand, TInt aJobId, TBool aToForeground);

private:

	CCommandBase& iCommand;

	TInt iJobId;

	TBool iToForeground;

	};

CForegroundAdjuster* CForegroundAdjuster::NewL(CCommandBase& aCommand, TInt aJobId, TBool aToForeground)

	{

	return new(ELeave) CForegroundAdjuster(aCommand, aJobId, aToForeground);

	}

void CForegroundAdjuster::RunL()

	{

	gShell->ClaimJobsLockLC();

	if (iToForeground)

		{

		gShell->BringJobToForeground(iJobId);

		}

	else

		{

		gShell->SendJobToBackground(iJobId);

		}

	CleanupStack::PopAndDestroy(); // jobs lock.

	iCommand.Complete();

	}

void CForegroundAdjuster::DoCancel()

	{

	}

TInt CForegroundAdjuster::RunError(TInt aError)

	{

	iCommand.Complete(aError);

	return KErrNone;

	}

CForegroundAdjuster::CForegroundAdjuster(CCommandBase& aCommand, TInt aJobId, TBool aToForeground)

	: CActive(CActive::EPriorityStandard), iCommand(aCommand), iJobId(aJobId), iToForeground(aToForeground)

	{

	CActiveScheduler::Add(this);

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}

CForegroundAdjuster::~CForegroundAdjuster()

	{

	}

//

// CCmdFg.

//

void ParseJobSpecL(const TDesC& aString, TInt& aJobId)

	{

	TLex lex(aString);

	lex.SkipSpace();

	if (lex.Peek() == '%')

		{

		lex.Get();

		}

	User::LeaveIfError(lex.Val(aJobId));

	}

CCommandBase* CCmdFg::NewLC()