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

// f32\etshell\ts_com.cpp

// Shell commands

// 

//

#ifdef __VC32__

  // Solve compilation problem caused by non-English locale

  #pragma setlocale("english")

#endif

#include "ts_std.h"

#include <hal.h>

#include <d32locd.h>

#include <e32math.h>

#include "u32std.h"

#include <u32hal.h>

#include <nkern/nk_trace.h>

#include "filesystem_fat.h"

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

_LIT(KNl, "\n");

    TPtrC ptrFormatHelp=_L("Drive:[\\] [fat12|fat16|fat32] [spc:X] [rs:Y] [ft:Z] [/Q][/S][/E][/F]\nfat12 or fat16 or fat32 specifies explicit FAT type\nspc:X specifies \"X\" sectors per cluster\nrs:Y specifies \"Y\" reserved sectors\nft:Z specifies \"Z\" FAT tables (1 or 2)\n\n/q - QuickFormat, /s - SpecialFormat, /e - ForcedErase\n/f - force formatting (ignore volume being in use)");

TPtrC ptrMountHelp=_L("Drive:[\\]  <fsy:X> <fs:Y> [pext:Z] [/S][/U][/F][/R]\n'X' *.fsy module name, like elocal.fsy\n'Y' file system name, like 'FAT'\n'Z' optional primary extension module name\n/U - dismount FS from the drive e.g 'mount d: /u' \n/U /F force dismounting the FS even if there are opened files on it \n/F - force mounting with dismounting existing FS \n/S - mount drive as synchronous\n/R - remount the file system ");

TBool CShell::iDbgPrint = EFalse;

//	lint -e40,e30

const TShellCommand CShell::iCommand[ENoShellCommands]=

	{

	TShellCommand(_L("ATTRIB"),_L("Displays or changes file attributes"),_L("[drive:][path][filename] [+R | -R] [+H |-H] [+S | -S] [+A | -A] [/p]\n\n  /p - Pause after each screen of information"), TShellCommand::EPSwitch, ShellFunction::Attrib),

	TShellCommand(_L("CD"),_L("Change the current directory for a drive"),_L("[path] [/d]\n\n  /d - Change drive"),TShellCommand::EDSwitch,ShellFunction::Cd),

	TShellCommand(_L("CHKDEPS"),_L("Check the dependencies of an executable or a Dll (ARM only)"),_L("[Filename.EXE] or [Filename.DLL]"),0,ShellFunction::ChkDeps),

	TShellCommand(_L("CHKDSK"),_L("Check disk for corruption"),_L("[drive:] [/s][/f|/u]\n\n/s - start ScanDrive instead of CheckDisk\n/f - finalise drive\n/u - unfinalise drive"),TShellCommand::ESSwitch|TShellCommand::EFSwitch|TShellCommand::EUSwitch,ShellFunction::ChkDsk),

	TShellCommand(_L("COPY"),_L("Copy one (or more) file(s), overwriting existing one(s)"),_L("source [destination]"),TShellCommand::ESSwitch,ShellFunction::Copy),

	TShellCommand(_L("DEL"),_L("Delete one file"),_L("[drive:][path][filename]"),TShellCommand::ESSwitch,ShellFunction::Del),

	TShellCommand(_L("DIR"),_L("Show directory contents"),_L("[drive:][path][filename] [/p][/w]\n\n  /p - Pause after each screen of information\n  /w - Wide format"),TShellCommand::EPSwitch|TShellCommand::EWSwitch|TShellCommand::EASwitch,ShellFunction::Dir),

    TShellCommand(_L("FORMAT"),_L("Format a disk"),ptrFormatHelp,TShellCommand::EQSwitch|TShellCommand::ESSwitch|TShellCommand::EESwitch|TShellCommand::EFSwitch,ShellFunction::Format),

    TShellCommand(_L("GOBBLE"),_L("Create a file"),_L("[filename] size [/e]\n\n /e - create an empty file, without writing any data"),TShellCommand::EESwitch,ShellFunction::Gobble),

	TShellCommand(_L("HEXDUMP"),_L("Display the contents of a file in hexadecimal"),_L("[drive:][path][filename] [/p]\n\n  /p - Pause after each screen of information\n\n  Hit escape to exit from hexdump "),TShellCommand::EPSwitch,ShellFunction::Hexdump),

	TShellCommand(_L("LABEL"),_L("Set or return the volume label"),_L("[newlabel]"),0,ShellFunction::VolumeLabel),

	TShellCommand(_L("MD"),_L("Make a new directory"),_L("name"),0,ShellFunction::Md),

	TShellCommand(_L("MOVE"),_L("Move files"),_L("name [destination]"),TShellCommand::ESSwitch,ShellFunction::Move),

	TShellCommand(_L("PS"),_L("Display information about processes"),_L(""),0,ShellFunction::Ps),

	TShellCommand(_L("RENAME"),_L("Rename a file"),_L("oldfilename newfilename"),TShellCommand::ESSwitch,ShellFunction::Rename),

	TShellCommand(_L("RD"),_L("Delete one directory"),_L("[drive:][path]directoryname"),TShellCommand::ESSwitch,ShellFunction::Rd),

	TShellCommand(_L("START"),_L("Run a program in a separate window"),_L("filename[.exe]"),0,ShellFunction::Start),

	TShellCommand(_L("TIME"),_L("Display the system time"),_L(""),0,ShellFunction::Time),

	TShellCommand(_L("TRACE"),_L("Set the debug trace mask"),_L("[mask value in hex] [index] [/S/L/F/T/I/N/M/O/C/H]\n  /S - KFSERV\n  /L - KFLDR\n  /F - KFSYS\n  /T - KLFFS\n  /I - KISO9660\n  /N - KNTFS\n  /M - KTHRD\n  /O - KROFS\n  /C - KCOMPFS\n  /H - KCACHE"),TShellCommand::ELSwitch|TShellCommand::ESSwitch|TShellCommand::EFSwitch|TShellCommand::ETSwitch|TShellCommand::EISwitch|TShellCommand::ENSwitch|TShellCommand::EMSwitch|TShellCommand::EOSwitch|TShellCommand::ECSwitch|TShellCommand::EHSwitch,ShellFunction::Trace),

	TShellCommand(_L("TREE"),_L("Graphically display the directory structure"),_L("[drive:][path] [/f][/p]\n\n  /f - Show files\n  /p - Pause after each screen of information"),TShellCommand::EFSwitch|TShellCommand::EPSwitch,ShellFunction::Tree),

	TShellCommand(_L("TYPE"),_L("Display the contents of a text file"),_L("[drive:][path]filename [/p]\n\n  /p - Pause after each screen of information"),TShellCommand::EPSwitch,ShellFunction::Type),

	TShellCommand(_L("VNAME"),_L("Check whether a filename is valid.  Return any invalid character"),_L("[drive:][path]filename \n\n "),0,ShellFunction::ValidName),

	TShellCommand(_L("LOCK"),_L("Lock a password-enabled media"),_L("drive-number cur-pswd new-pswd [/s]"), TShellCommand::ESSwitch, ShellFunction::Lock),

	TShellCommand(_L("UNLOCK"),_L("Unlock a locked password-enabled media"),_L("drive-number cur-pswd [/s]"), TShellCommand::ESSwitch, ShellFunction::Unlock),

	TShellCommand(_L("CLEAR"),_L("Clear password from password-enabled media"),_L("drive-number cur-pswd"), 0x00000000, ShellFunction::Clear),

	TShellCommand(_L("SETSIZE"),_L("Set size of a file"),_L("[filename] size"),0,ShellFunction::SetSize),

	TShellCommand(_L("DEBUGPORT"),_L("Set or get debug port"),_L("[port]"),0,ShellFunction::DebugPort),

	TShellCommand(_L("PLUGIN"),_L("Manage Plugins"),_L("[name][/A][/R][/M][/D]"),TShellCommand::EASwitch|TShellCommand::ERSwitch|TShellCommand::EMSwitch|TShellCommand::EDSwitch,ShellFunction::Plugin),

    TShellCommand(_L("DRVINFO"),_L("Print information about present drive(s) in the system"),_L("[DriveLetter:[\\]] [/p]\n/p - pause after each drive"),TShellCommand::EPSwitch,ShellFunction::DrvInfo),

	TShellCommand(_L("SYSINFO"),_L("Print information about system features and status"),_L(""),0,ShellFunction::SysInfo),

    TShellCommand(_L("MOUNT"),_L("Mount / dismount file system on specified drive"),ptrMountHelp,TShellCommand::EUSwitch|TShellCommand::ESSwitch|TShellCommand::EFSwitch|TShellCommand::ERSwitch,ShellFunction::MountFileSystem),

    TShellCommand(_L("ECHO"),_L("Print out the command line to the console and standard debug port."),_L("[line to print out] [/Y/N]\n /Y turn ON copying console output to debug port\n /N turn it OFF "),TShellCommand::EYSwitch|TShellCommand::ENSwitch,ShellFunction::ConsoleEcho),

	TShellCommand(_L("RUNEXEC"),_L("Run a program in a loop"),_L("count filename[.exe] [/E/S/R]\n	/E - exit early on error\n	/S - count in seconds\n	     zero - run forever\n	/R - reset debug regs after each run"),TShellCommand::EESwitch|TShellCommand::ESSwitch|TShellCommand::ERSwitch,ShellFunction::RunExec),

    };

LOCAL_C TInt pswd_DrvNbr(TDes &aPath, TInt &aDN);

LOCAL_C TInt pswd_Password(TDes &aPath, TInt aPWNbr, TMediaPassword &aPW);

void CShell::NewLine()

	{

	Printf(KNl);

	}

//

// Skip the hexadecimal prefix if present and return EHex.  Return

// EDecimal otherwise.

//

static TRadix ParseHexaPrefixIfAny(TLex& aLex)

	{

	_LIT(KPrefix, "0x");

	if (aLex.Remainder().Length() > 2)

		{

		aLex.Mark();

		aLex.Inc(2);

		if (aLex.MarkedToken().MatchF(KPrefix) != KErrNotFound)

			return EHex;

		else

			aLex.UnGetToMark();

		}

	return EDecimal;

	}

//

//	TWord class

//	Used to locate spaces in the command line, and return the next word

//

TWord::TWord(const TDesC& aDes)

	: iSpace(0),iNextSpace(0)

//

//	Constructor

//

	{

	Init(aDes);

	}

void TWord::Init(const TDesC& aDes)

//

// Resets to the start of the buffer

//

	{

	iDes.Set(aDes);

	}

TInt TWord::FindNextWord(TDes& aWord)

//

//	Returns the next word from the buffer

//

	{

	iSpace=aWord.Locate(' ');

	if (iSpace==KErrNotFound)		//	No spaces in command line

		{

		if (aWord.Length()==0)		//	Command line has zero length:

			return (KErrNotFound);	//	User just typed "command"

		else

			{						//	User typed "command aWord"

			iRightString=aWord;

			iNextWord=aWord;

			return (0);

			}

		}

	else if (iSpace<aWord.Length())	//	Spaces may be command switches or part of the filename

		{

		iRightString=(aWord.Right((aWord.Length()-iSpace)-1));

		iNextSpace=iRightString.Locate(' ');	//	Check for another space

		if (iNextSpace==KErrNotFound)			//	No more spaces

			{

			iNextWord=iRightString;

			return((iDes.Length())-(iRightString.Length()));//	Position of the (last) word

			}

		if (iNextSpace<iRightString.Length())	//	More spaces - assign iNextWord to be

			{									//	the text in between the two spaces

			iNextWord=(iRightString.Left(iNextSpace));

			return ((iDes.Length())-(iRightString.Length()));//	Position of the word

			}

		else

			return(KErrNotFound);

		}

	else

		return(KErrNotFound);

	}

//-------------------------------------------------------------------------

TInt ShellFunction::Cd(TDes& aPath,TUint aSwitches)

//

// Change directory

//

	{

	ShellFunction::StripQuotes(aPath);

	TBool drvNameOnly=aPath.Length()==2 && aPath[1]==KDriveDelimiter;

	TBool dSwitchSet=aSwitches&TShellCommand::EDSwitch;

	if (aPath.Length()==0 || (drvNameOnly && !dSwitchSet))

		{

		TInt drvNum=(aPath.Length() ? aPath[0] : TheShell->currentPath[0])-'A';

		if (drvNum<0 || drvNum>=KMaxDrives)

			return(KErrBadName);

		CShell::TheConsole->Printf(_L("%S\n"),&TheShell->drivePaths[drvNum]);

		return(KErrNone);

		}

	if (aPath.Find(_L("*"))!=KErrNotFound)

		return(KErrBadName);

	if (aPath[aPath.Length()-1]!=KPathDelimiter && !drvNameOnly)

		aPath.Append(KPathDelimiter);

	aPath.Append('*');

	TChar drvLetter = aPath[0];

	drvLetter.UpperCase();

	aPath[0] = (TText) drvLetter;

	TParse dirParse;

	TInt r=GetFullPath(aPath,dirParse);

	if (r!=KErrNone)

		return(KErrBadName);

	TPtrC fullName=dirParse.FullName();

	RDir dir;

	r=dir.Open(TheShell->TheFs,fullName,KEntryAttMaskSupported);

	if (r!=KErrNone)

		return(r);

	dir.Close();

	if (dSwitchSet || fullName[0]==TheShell->currentPath[0])

		r=TheShell->TheFs.SetSessionPath(dirParse.DriveAndPath());

	if (r==KErrNone)

		TheShell->SetDrivePath(dirParse.DriveAndPath());

	return(r);

	}

TInt ShellFunction::ChkDeps(TDes& aPath,TUint /*aSwitches*/)

	{

	ShellFunction::StripQuotes(aPath);

	aPath.Trim();

	TBool appendedExe=EFalse;

//	Determine whether aPath is an executable or a Dll

	TInt r=aPath.FindF(_L(".EXE"));

	if (r==KErrNotFound)

		{

		r=aPath.FindF(_L(".DLL"));

		if (r==KErrNotFound)//	aPath does not include .exe or .dll extensions

			{

			aPath.Append(_L(".EXE"));	//	append a .exe extension

			appendedExe=ETrue;

			}

		}

	if (aPath.Length()>2 && aPath[1]==':' && aPath[2]!='\\')

		{

		TInt drive;

		__ASSERT_ALWAYS(RFs::CharToDrive(aPath[0],drive)==KErrNone,User::Panic(_L("Invalid drive letter"),0));

 		TheShell->currentPath=TheShell->drivePaths[drive];

   		aPath.Delete(0,2);

   		aPath.Insert(0,TheShell->currentPath);

		}

	if (aPath.Length()>2 && aPath[1]!=':')

		{

		if (aPath[0]!='\\')

    		aPath.Insert(0,TheShell->currentPath);

		else

			aPath.Insert(0,TheShell->currentPath.Left(2));

		}

	RFile64 file;

	r=file.Open(CShell::TheFs,aPath,EFileStream);

	if (r!=KErrNone)	//		File could not be opened

		{

		if (appendedExe)	//	If .EXE was appended earlier

			{

//	Remove .EXE and append .DLL instead.  Try to open the file again

//	If this fails too, the user entered an invalid filename that is neither

//	an executable or a Dll

			aPath.Delete(aPath.Length()-4,4);

			appendedExe=EFalse;

			aPath.Append(_L(".DLL"));	//	Try a .DLL extension

			r=file.Open(CShell::TheFs,aPath,EFileStream);

			if (r!=KErrNone)	//	Still could not open file

				return(r);	//	Neither an executable or a Dll

		//	Runs to here if the file is opened -> .DLL extension appended

			}

		else

			return(r);	//	User had typed in an incorrect filename with

						//	a .DLL or .EXE extension

		}

	file.Close();

	CDllChecker check;

	TRAPD(leaveCode,check.ConstructL());//	Allocates 4 elements at a time

	if (leaveCode!=KErrNone)	//	If function leaves

		return(leaveCode);		//	return the leave code

	TRAPD(result,check.GetImportDataL(aPath,NULL));

	if (result==KErrGeneral)

		{

		CShell::TheConsole->Printf(_L(" %S has no import data\n"),&aPath);

		return(KErrNone);

		}

	else

		check.ListArray();	//	Print out the results of DllCheck

	return(KErrNone);

	}

//

// Check disk for corruption

//

// Spec:

//

// ChkDsk DriveLetter:[\] [/S] [/F] [/U]

//

//			/S : Starts a ScanDrive instead of CheckDisk

//			/F : Finalise given drive

//			/U : UnFinalise given drive

TInt ShellFunction::ChkDsk(TDes& aPath,TUint aSwitches)

	{

	ShellFunction::StripQuotes(aPath);

    const TBool bRunScanDrv     = aSwitches & TShellCommand::ESSwitch;

    const TBool bFinaliseDrv    = aSwitches & TShellCommand::EFSwitch;

    const TBool bUnFinaliseDrv  = aSwitches & TShellCommand::EUSwitch; 

    TInt nRes;

    TInt drive=EDriveZ;

	if(aPath.Length() < 1)

    {

        nRes = KErrArgument;

    }

    else

    {

        nRes=CShell::TheFs.CharToDrive(aPath[0], drive);

	}

    if (nRes != KErrNone)

	{

    	CShell::TheConsole->Printf(_L("Wrong drive specified!\n"));

        return nRes;

    }

    if(bRunScanDrv)

    {//-- run ScanDrive on the specified drive

        CShell::TheConsole->Printf(_L("Starting ScanDrive...\n"));

        nRes=TheShell->TheFs.ScanDrive(aPath);

        if(nRes == KErrNone)

        {

            CShell::TheConsole->Printf(_L("No errors.\n"));

        }

    }

    else if(bFinaliseDrv)

    {//-- finalise the drive

        nRes = CShell::TheFs.FinaliseDrive(drive, RFs::EFinal_RW);

        if(nRes != KErrNone)

            return nRes;

        CShell::TheConsole->Printf(_L("Drive %c: is finalised RW\n"), 'A'+drive);

    }

    else if(bUnFinaliseDrv)

    {//-- Unfinalise the drive

        nRes = CShell::TheFs.FinaliseDrive(drive, RFs::EForceUnfinalise);

        if(nRes != KErrNone)

            return nRes;

        CShell::TheConsole->Printf(_L("Drive %c: is Unfinalised\n"), 'A'+drive);

    }

    else

    {//-- run CheckDisk on the specified drive

        nRes=TheShell->TheFs.CheckDisk(aPath);

	    if (nRes<0)

		    return(nRes);

	    //-- this is, actually, FAT FS specific error codes. Other file systems can report different values.

	    switch(nRes)

		    {

	    case 0:

		    CShell::TheConsole->Printf(_L("Completed - no errors found\n"));

		    break;

	    case 1:

		    CShell::TheConsole->Printf(_L("Error - File cluster chain contains a bad value (<2 or >maxCluster)\n"));

		    break;

	    case 2:

		    CShell::TheConsole->Printf(_L("Error - Two files are linked to the same cluster\n"));

		    break;

	    case 3:

		    CShell::TheConsole->Printf(_L("Error - Unallocated cluster contains a value != 0\n"));

		    break;

	    case 4:

		    CShell::TheConsole->Printf(_L("Error - Size of file != number of clusters in chain\n"));

		    break;

	    default:

		    CShell::TheConsole->Printf(_L("Undefined Error value\n"));

		    }

	 }

    return nRes;

	}

TInt ShellFunction::Copy(TDes& aPath,TUint aSwitches)

//

// DOS spec:

//

// COPY [/A | /B] source [/A | /B] [+ source [/A | /B] [+ ...]] [destination] [/A | /B]] [/V] [/N]

// source		Specifies the file or files to be copied.

// /A			Indicates an ASCII text file.

// /B			Indicates a binary file.

// destination	Specifies the directory and/or filename for the new file(s).

// /V			Verifies that new files are written correctly.

// /Y			Supresses prompting to confirm you want to overwrite existing destination file

// /N			Uses short filename, if available, when copying a file with a non-8dot3 name.

//

// To append files, specify a single file for destination, but multiple files

// for source (using wildcards or file1+file2+file3 format).

//

// Overwrites existing file(s).

//

// My spec:

//

// COPY source [destination]

// source		Specifies the file or files to be copied to the current directory

// Modified November 1997 to allow spaces in filenames

	{

	if (aPath.Length() == 0)

	    return KErrNotFound;    // no source file

	ShellFunction::StripQuotes(aPath);

	TBuf<KShellMaxCommandLine> destination;

	TBuf<KShellMaxCommandLine> tempPath;

	TWord word(aPath);

	TBool endOfCommandLine=EFalse;

//	Check if the word returned is a valid filename.  If not, scan the next

//	word too in case the filename contains spaces.  If, at the end of the

//	the line, the filename is not recognised, it is invalid.  If there are no

//	spaces the user has not used the correct format for this command.

	TInt r=word.FindNextWord(aPath);

	do	{

		TParse dirPath;

		if (r==0)	//	No destination was specified

			{

		//	Work out the destination

			tempPath.SetLength(0);

			r=GetFullPath(tempPath,dirPath);

			if (r!=KErrNone)

				return(r);

			destination=dirPath.FullName();

		//	Now get the path of the source

			tempPath=aPath;

			r=GetFullPath(tempPath,dirPath);

			if (r!=KErrNone)

				return(r);

			endOfCommandLine=ETrue;	//	So we don't get stuck in an infinite loop

			}

		else

			{

		//	Work out the destination

			destination=aPath.Right(aPath.Length()-r);

			if (!destination.Compare(_L(".")))

				GetFullPath(destination,dirPath);

		//	Now get the path of the source

			tempPath=aPath;

			tempPath.SetLength(r);

			r=GetFullPath(tempPath,dirPath);

			if (r!=KErrNone)

				return(r);

			}

		TBool recursive=((aSwitches&TShellCommand::ESSwitch)!=0);

		// Automatically overwrites existing file(s)

		TUint switches=(recursive) ? CFileMan::EOverWrite|CFileMan::ERecurse : CFileMan::EOverWrite;

		r=CShell::TheFileMan->Copy(dirPath.FullName(),destination,switches);

		if (r==KErrNone)

			return(r);	//	Copy was successful

		else			//	Not a valid filename - move one word along the command line

			r=word.FindNextWord(word.iRightString);

		} while ((r>=0)&&(!endOfCommandLine));

	if (r<0)			//	Some error

		return (r);

	else				//	End of command line, user typed invalid line, return not found

		return (KErrNotFound);

	}

TInt ShellFunction::VolumeLabel(TDes& aPath,TUint /*aSwitches*/)

/**

Sets or returns the default path

@param aPath The volume label being set or returned

*/

	{

	ShellFunction::StripQuotes(aPath);

	TVolumeInfo vol;

	TInt drive;

	TInt r=CShell::TheFs.CharToDrive(CShell::currentPath[0], drive);

	if (r!=KErrNone)

		return(r);

	if (aPath.Length()==0)

		{

		r=CShell::TheFs.Volume(vol, drive);

		if (r==KErrNone)

		return(r);

		}

	r=CShell::TheFs.SetVolumeLabel(aPath, drive);

	return(r);

	}

TInt ShellFunction::Del(TDes& aPath,TUint aSwitches)

	{

	TParse filePath;

	if (aPath.Length()==0)

		return(KErrNone);

	ShellFunction::StripQuotes(aPath);

	GetFullPath(aPath,filePath);

	TBool recursive=((aSwitches&TShellCommand::ESSwitch)!=0);

	TUint switches=(recursive) ? CFileMan::ERecurse : 0;

	TInt r=CShell::TheFileMan->Delete(filePath.FullName(),switches);

	return(r);

	}