static INT
PrintVolumeHeader (LPTSTR pszRootPath)
{
TCHAR szVolName[80];
DWORD dwSerialNr;
/* get the volume information of the drive */
if (!GetVolumeInformation(pszRootPath,
szVolName,
80,
&dwSerialNr,
NULL,
NULL,
NULL,
0))
{
ErrorMessage(GetLastError (), _T(""));
return 1;
}
/* print drive info */
if (szVolName[0] != '\0')
{
ConOutResPrintf(STRING_VOL_HELP1, pszRootPath[0],szVolName);
}
else
{
ConOutResPrintf(STRING_VOL_HELP2, pszRootPath[0]);
}
/* print the volume serial number */
ConOutResPrintf(STRING_VOL_HELP3, HIWORD(dwSerialNr), LOWORD(dwSerialNr));
return 0;
}
static VOID
PrintElapsedTime (DWORD time,INT format)
{
DWORD h,m,s,ms;
TRACE ("PrintElapsedTime(%d,%d)",time,format);
switch (format)
{
case 0:
ConOutResPrintf(STRING_TIMER_HELP1, time);
break;
case 1:
ms = time % 1000;
time /= 1000;
s = time % 60;
time /=60;
m = time % 60;
h = time / 60;
ConOutResPrintf(STRING_TIMER_HELP2,
h, cTimeSeparator,
m, cTimeSeparator,
s, cDecimalSeparator, ms/10);
break;
}
}
BOOL
OnOffCommand(LPTSTR param, LPBOOL flag, INT message)
{
TCHAR *p2;
if (_tcsnicmp(param, D_OFF, sizeof(D_OFF)/sizeof(TCHAR) - 1) == 0)
{
p2 = param + sizeof(D_OFF)/sizeof(TCHAR) - 1;
while (_istspace(*p2))
p2++;
if (*p2 == _T('\0'))
{
*flag = FALSE;
return TRUE;
}
}
else if (_tcsnicmp(param, D_ON, sizeof(D_ON)/sizeof(TCHAR) - 1) == 0)
{
p2 = param + sizeof(D_ON)/sizeof(TCHAR) - 1;
while (_istspace(*p2))
p2++;
if (*p2 == _T('\0'))
{
*flag = TRUE;
return TRUE;
}
}
else if (*param == _T('\0'))
{
ConOutResPrintf(message, *flag ? D_ON : D_OFF);
return TRUE;
}
return FALSE;
}
static INT MoveOverwrite (LPTSTR fn)
{
/*ask the user if they want to override*/
INT res;
ConOutResPrintf(STRING_MOVE_HELP1, fn);
res = FilePromptYNA (0);
return res;
}
static VOID
PrintDateString (VOID)
{
switch (nDateFormat)
{
case 0: /* mmddyy */
default:
ConOutResPrintf(STRING_DATE_HELP1, cDateSeparator, cDateSeparator);
break;
case 1: /* ddmmyy */
ConOutResPrintf(STRING_DATE_HELP2, cDateSeparator, cDateSeparator);
break;
case 2: /* yymmdd */
ConOutResPrintf(STRING_DATE_HELP3, cDateSeparator, cDateSeparator);
break;
}
}
INT CommandMemory (LPTSTR param)
{
MEMORYSTATUSEX msex;
TCHAR szMemoryLoad[20];
TCHAR szTotalPhys[40];
TCHAR szAvailPhys[40];
TCHAR szTotalPageFile[40];
TCHAR szAvailPageFile[40];
TCHAR szTotalVirtual[40];
TCHAR szAvailVirtual[40];
BOOL (WINAPI *GlobalMemoryStatusEx)(LPMEMORYSTATUSEX);
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_MEMMORY_HELP1);
return 0;
}
GlobalMemoryStatusEx
= (BOOL (WINAPI *)(LPMEMORYSTATUSEX))GetProcAddress(GetModuleHandle(_T("KERNEL32")), "GlobalMemoryStatusEx");
if (GlobalMemoryStatusEx)
{
msex.dwLength = sizeof(MEMORYSTATUSEX);
GlobalMemoryStatusEx(&msex);
}
else
{
MEMORYSTATUS ms;
ms.dwLength = sizeof(MEMORYSTATUS);
GlobalMemoryStatus(&ms);
msex.dwMemoryLoad = ms.dwMemoryLoad;
msex.ullTotalPhys = ms.dwTotalPhys;
msex.ullAvailPhys = ms.dwAvailPhys;
msex.ullTotalPageFile = ms.dwTotalPageFile;
msex.ullAvailPageFile = ms.dwAvailPageFile;
msex.ullTotalVirtual = ms.dwTotalVirtual;
msex.ullAvailVirtual = ms.dwAvailVirtual;
}
ConvertULargeInteger(msex.dwMemoryLoad, szMemoryLoad, 20, FALSE);
ConvertULargeInteger(msex.ullTotalPhys, szTotalPhys, 40, TRUE);
ConvertULargeInteger(msex.ullAvailPhys, szAvailPhys, 40, TRUE);
ConvertULargeInteger(msex.ullTotalPageFile, szTotalPageFile, 40, TRUE);
ConvertULargeInteger(msex.ullAvailPageFile, szAvailPageFile, 40, TRUE);
ConvertULargeInteger(msex.ullTotalVirtual, szTotalVirtual, 40, TRUE);
ConvertULargeInteger(msex.ullAvailVirtual, szAvailVirtual, 40, TRUE);
ConOutResPrintf(STRING_MEMMORY_HELP2,
szMemoryLoad, szTotalPhys, szAvailPhys, szTotalPageFile,
szAvailPageFile, szTotalVirtual, szAvailVirtual);
return 0;
}
VOID ShortVersion (VOID)
{
OSVERSIONINFO VersionInfo;
unsigned RosVersionLen;
LPTSTR RosVersion;
ConOutResPrintf(STRING_CMD_SHELLINFO, _T(KERNEL_RELEASE_STR), _T(KERNEL_VERSION_BUILD_STR));
VersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
memset(VersionInfo.szCSDVersion, 0, sizeof(VersionInfo.szCSDVersion));
if (GetVersionEx(&VersionInfo))
{
RosVersion = VersionInfo.szCSDVersion + _tcslen(VersionInfo.szCSDVersion) + 1;
RosVersionLen = sizeof(VersionInfo.szCSDVersion) / sizeof(VersionInfo.szCSDVersion[0]) -
(RosVersion - VersionInfo.szCSDVersion);
if (7 <= RosVersionLen && 0 == _tcsnicmp(RosVersion, _T("IRTriage"), 7))
{
ConOutResPrintf(STRING_VERSION_RUNVER, RosVersion);
}
}
ConOutPuts (_T("\n"));
}
INT CommandAssoc (LPTSTR param)
{
/* print help */
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_ASSOC_HELP);
return 0;
}
nErrorLevel = 0;
if (_tcslen(param) == 0)
PrintAllAssociations();
else
{
LPTSTR lpEqualSign = _tcschr(param, _T('='));
if (lpEqualSign != NULL)
{
LPTSTR fileType = lpEqualSign + 1;
LPTSTR extension = cmd_alloc((lpEqualSign - param + 1) * sizeof(TCHAR));
_tcsncpy(extension, param, lpEqualSign - param);
extension[lpEqualSign - param] = (TCHAR)0;
if (_tcslen(fileType) == 0)
/* if the equal sign is the last character
in the string, then delete the key */
{
RemoveAssociation(extension);
}
else
/* otherwise, add the key and print out the association*/
{
AddAssociation( extension, fileType);
PrintAssociation(extension);
}
cmd_free(extension);
}
else
{
/* no equal sign, print all associations */
INT retval = PrintAssociation(param);
if (retval == 0) /* if nothing printed out */
ConOutResPrintf(STRING_ASSOC_ERROR, param);
}
}
return 0;
}
INT cmd_path (LPTSTR param)
{
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_PATH_HELP1);
return 0;
}
nErrorLevel = 0;
/* if param is empty, display the PATH environment variable */
if (!param || !*param)
{
DWORD dwBuffer;
LPTSTR pszBuffer;
pszBuffer = (LPTSTR)cmd_alloc (ENV_BUFFER_SIZE * sizeof(TCHAR));
dwBuffer = GetEnvironmentVariable (_T("PATH"), pszBuffer, ENV_BUFFER_SIZE);
if (dwBuffer == 0)
{
cmd_free(pszBuffer);
ConOutResPrintf(STRING_VOL_HELP2, _T("PATH"));
return 0;
}
else if (dwBuffer > ENV_BUFFER_SIZE)
{
pszBuffer = (LPTSTR)cmd_realloc (pszBuffer, dwBuffer * sizeof (TCHAR));
GetEnvironmentVariable (_T("PATH"), pszBuffer, dwBuffer);
}
ConOutPrintf (_T("PATH=%s\n"), pszBuffer);
cmd_free (pszBuffer);
return 0;
}
/* skip leading '=' */
if (*param == _T('='))
param++;
/* set PATH environment variable */
if (!SetEnvironmentVariable (_T("PATH"), param))
{
nErrorLevel = 1;
return 1;
}
return 0;
}
/* makes the replace */
INT replace(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], DWORD dwFlags, BOOL *doMore)
{
TCHAR d[MAX_PATH];
TCHAR s[MAX_PATH];
HANDLE hFileSrc, hFileDest;
DWORD dwAttrib, dwRead, dwWritten;
LPBYTE buffer;
BOOL bEof = FALSE;
FILETIME srcCreationTime, destCreationTime, srcLastAccessTime, destLastAccessTime;
FILETIME srcLastWriteTime, destLastWriteTime;
GetPathCase(source, s);
GetPathCase(dest, d);
s[0] = _totupper(s[0]);
d[0] = _totupper(d[0]);
// ConOutPrintf(_T("old-src: %s\n"), s);
// ConOutPrintf(_T("old-dest: %s\n"), d);
// ConOutPrintf(_T("src: %s\n"), source);
// ConOutPrintf(_T("dest: %s\n"), dest);
/* Open up the sourcefile */
hFileSrc = CreateFile (source, GENERIC_READ, FILE_SHARE_READ,NULL, OPEN_EXISTING, 0, NULL);
if (hFileSrc == INVALID_HANDLE_VALUE)
{
ConOutResPrintf(STRING_COPY_ERROR1, source);
return 0;
}
/*
* Get the time from source file to be used in the comparison
* with dest time if update switch is set.
*/
GetFileTime (hFileSrc, &srcCreationTime, &srcLastAccessTime, &srcLastWriteTime);
/*
* Retrieve the source attributes so that they later on
* can be inserted in to the destination.
*/
dwAttrib = GetFileAttributes (source);
if (IsExistingFile (dest))
{
/*
* Resets the attributes to avoid probles with read only files,
* checks for read only has been made earlier.
*/
SetFileAttributes(dest,FILE_ATTRIBUTE_NORMAL);
/*
* Is the update flas set? The time has to be controled so that
* only older files are replaced.
*/
if (dwFlags & REPLACE_UPDATE)
{
/* Read destination time */
hFileDest = CreateFile(dest, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
0, NULL);
if (hFileSrc == INVALID_HANDLE_VALUE)
{
ConOutResPrintf(STRING_COPY_ERROR1, dest);
return 0;
}
/* Compare time */
GetFileTime (hFileDest, &destCreationTime, &destLastAccessTime, &destLastWriteTime);
if (!((srcLastWriteTime.dwHighDateTime > destLastWriteTime.dwHighDateTime) ||
(srcLastWriteTime.dwHighDateTime == destLastWriteTime.dwHighDateTime &&
srcLastWriteTime.dwLowDateTime > destLastWriteTime.dwLowDateTime)))
{
CloseHandle (hFileSrc);
CloseHandle (hFileDest);
return 0;
}
CloseHandle (hFileDest);
}
/* Delete the old file */
DeleteFile (dest);
}
/* Check confirm flag, and take appropriate action */
if (dwFlags & REPLACE_CONFIRM)
{
/* Output depending on add flag */
if (dwFlags & REPLACE_ADD)
ConOutResPrintf(STRING_REPLACE_HELP9, dest);
else
ConOutResPrintf(STRING_REPLACE_HELP10, dest);
if ( !FilePromptYNA (0))
return 0;
}
/* Output depending on add flag */
if (dwFlags & REPLACE_ADD)
ConOutResPrintf(STRING_REPLACE_HELP11, dest);
else
ConOutResPrintf(STRING_REPLACE_HELP5, dest);
/* Make sure source and destination is not the same */
if (!_tcscmp(s, d))
{
ConOutResPaging(TRUE, STRING_REPLACE_ERROR7);
CloseHandle (hFileSrc);
*doMore = FALSE;
return 0;
}
/* Open destination file to write to */
hFileDest = CreateFile (dest, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
if (hFileDest == INVALID_HANDLE_VALUE)
{
CloseHandle (hFileSrc);
ConOutResPaging(TRUE, STRING_REPLACE_ERROR7);
*doMore = FALSE;
return 0;
}
/* Get buffer for the copy process */
buffer = VirtualAlloc(NULL, BUFF_SIZE, MEM_COMMIT, PAGE_READWRITE);
if (buffer == NULL)
{
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
ConOutResPaging(TRUE, STRING_ERROR_OUT_OF_MEMORY);
return 0;
}
/* Put attribute and time to the new destination file */
SetFileAttributes (dest, dwAttrib);
SetFileTime (hFileDest, &srcCreationTime, &srcLastAccessTime, &srcLastWriteTime);
do
{
/* Read data from source */
ReadFile (hFileSrc, buffer, BUFF_SIZE, &dwRead, NULL);
/* Done? */
if (dwRead == 0)
break;
/* Write to destination file */
WriteFile (hFileDest, buffer, dwRead, &dwWritten, NULL);
/* Done! or ctrl break! */
if (dwWritten != dwRead || CheckCtrlBreak(BREAK_INPUT))
{
ConOutResPuts(STRING_COPY_ERROR3);
VirtualFree (buffer, 0, MEM_RELEASE);
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
nErrorLevel = 1;
return 0;
}
}
while (!bEof);
/* Return memory and close files */
VirtualFree (buffer, 0, MEM_RELEASE);
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
/* Return one file replaced */
return 1;
}
INT cmd_replace (LPTSTR param)
{
LPTSTR *arg;
INT argc, i,filesReplaced = 0, nFiles, srcIndex = -1, destIndex = -1;
DWORD dwFlags = 0;
TCHAR szDestPath[MAX_PATH], szSrcPath[MAX_PATH], tmpSrcPath[MAX_PATH];
BOOL doMore = TRUE;
/* Help wanted? */
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_REPLACE_HELP1);
return 0;
}
/* Divide the argument in to an array of c-strings */
arg = split (param, &argc, FALSE, FALSE);
nFiles = argc;
/* Read options */
for (i = 0; i < argc; i++)
{
if (arg[i][0] == _T('/'))
{
if (_tcslen(arg[i]) == 2)
{
switch (_totupper(arg[i][1]))
{
case _T('A'):
dwFlags |= REPLACE_ADD;
break;
case _T('P'):
dwFlags |= REPLACE_CONFIRM;
break;
case _T('R'):
dwFlags |= REPLACE_READ_ONLY;
break;
case _T('S'):
dwFlags |= REPLACE_SUBDIR;
break;
case _T('W'):
dwFlags |= REPLACE_DISK;
break;
case _T('U'):
dwFlags |= REPLACE_UPDATE;
break;
default:
invalid_switch(arg[i]);
return 0;
}
}
else
{
invalid_switch(arg[i]);
freep(arg);
return 0;
}
nFiles--;
}
else
{
if (srcIndex == -1)
{
srcIndex = i;
}
else if (destIndex == -1)
{
destIndex = i;
}
else
{
invalid_switch(arg[i]);
freep(arg);
return 0;
}
}
}
/* See so that at least source is there */
if (nFiles < 1)
{
ConOutResPaging(TRUE,STRING_REPLACE_HELP2);
ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
freep(arg);
return 1;
}
/* Check so that not both update and add switch is added and subdir */
if ((dwFlags & REPLACE_UPDATE || dwFlags & REPLACE_SUBDIR) && (dwFlags & REPLACE_ADD))
{
ConOutResPaging(TRUE,STRING_REPLACE_ERROR4);
ConOutResPaging(TRUE,STRING_REPLACE_HELP7);
freep(arg);
return 1;
}
/* If we have a destination get the full path */
if (destIndex != -1)
{
if (_tcslen(arg[destIndex]) == 2 && arg[destIndex][1] == ':')
GetRootPath(arg[destIndex],szDestPath,MAX_PATH);
else
{
/* Check for wildcards in destination directory */
if (_tcschr (arg[destIndex], _T('*')) != NULL ||
_tcschr (arg[destIndex], _T('?')) != NULL)
{
ConOutResPrintf(STRING_REPLACE_ERROR2,arg[destIndex]);
ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
freep(arg);
return 1;
}
getPath(szDestPath, arg[destIndex]);
/* Make sure that destination exists */
if (!IsExistingDirectory(szDestPath))
{
ConOutResPrintf(STRING_REPLACE_ERROR2, szDestPath);
ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
freep(arg);
return 1;
}
}
}
else
{
/* Dest is current dir */
GetCurrentDirectory(MAX_PATH,szDestPath);
}
/* Get the full source path */
if (!(_tcslen(arg[srcIndex]) == 2 && arg[srcIndex][1] == ':'))
getPath(szSrcPath, arg[srcIndex]);
else
_tcscpy(szSrcPath,arg[srcIndex]);
/* Source does not have wildcards */
if (_tcschr (arg[srcIndex], _T('*')) == NULL &&
_tcschr (arg[srcIndex], _T('?')) == NULL)
{
/* Check so that source is not a directory, because that is not allowed */
if (IsExistingDirectory(szSrcPath))
{
ConOutResPrintf(STRING_REPLACE_ERROR6, szSrcPath);
ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
freep(arg);
return 1;
}
/* Check if the file exists */
if (!IsExistingFile(szSrcPath))
{
ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
freep(arg);
return 1;
}
}
/* /w switch is set so wait for any key to be pressed */
if (dwFlags & REPLACE_DISK)
{
msg_pause();
cgetchar();
}
/* Add an extra \ to the destination path if needed */
if (szDestPath[_tcslen(szDestPath) - 1] != _T('\\'))
_tcscat(szDestPath, _T("\\"));
/* Save source path */
_tcscpy(tmpSrcPath,szSrcPath);
/* Replace in dest dir */
filesReplaced += recReplace(dwFlags, tmpSrcPath, szDestPath, &doMore);
/* If subdir switch is set replace in the subdirs to */
if (dwFlags & REPLACE_SUBDIR && doMore)
{
filesReplaced += recFindSubDirs(dwFlags, szSrcPath, szDestPath, &doMore);
}
/* If source == dest write no more */
if (filesReplaced != -1)
{
/* No files replaced */
if (filesReplaced==0)
{
/* Add switch dependent output */
if (dwFlags & REPLACE_ADD)
ConOutResPaging(TRUE,STRING_REPLACE_HELP7);
else
ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
}
/* Some files replaced */
else
{
/* Add switch dependent output */
if (dwFlags & REPLACE_ADD)
ConOutResPrintf(STRING_REPLACE_HELP8, filesReplaced);
else
ConOutResPrintf(STRING_REPLACE_HELP4, filesReplaced);
}
}
/* Return memory */
freep(arg);
return 1;
}
/* just makes a print out if there is a problem with the switches */
void invalid_switch(LPTSTR is)
{
ConOutResPrintf(STRING_REPLACE_ERROR1,is);
ConOutResPaging(TRUE,STRING_REPLACE_HELP3);
}
/* Function to iterate over source files and call replace for each of them */
INT recReplace(DWORD dwFlags,
TCHAR szSrcPath[MAX_PATH],
TCHAR szDestPath[MAX_PATH],
BOOL *doMore)
{
TCHAR tmpDestPath[MAX_PATH], tmpSrcPath[MAX_PATH];
INT filesReplaced=0;
INT_PTR i;
DWORD dwAttrib = 0;
HANDLE hFile;
WIN32_FIND_DATA findBuffer;
/* Get file handel to the sourcefile(s) */
hFile = FindFirstFile (szSrcPath, &findBuffer);
/*
* Strip the paths back to the folder they are in, so that
* the different filenames can be added if more than one.
*/
for(i = (_tcslen(szSrcPath) - 1); i > -1; i--)
{
if (szSrcPath[i] != _T('\\'))
szSrcPath[i] = _T('\0');
else
break;
}
/* Go through all the soursfiles and copy/replace them */
do
{
if (CheckCtrlBreak(BREAK_INPUT))
{
return filesReplaced;
}
/* Problem with file handler */
if (hFile == INVALID_HANDLE_VALUE)
return filesReplaced;
/* We do not want to replace any .. . ocr directory */
if (!_tcscmp (findBuffer.cFileName, _T(".")) ||
!_tcscmp (findBuffer.cFileName, _T(".."))||
findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
/* Add filename to destpath */
_tcscpy(tmpDestPath,szDestPath);
_tcscat (tmpDestPath, findBuffer.cFileName);
dwAttrib = GetFileAttributes(tmpDestPath);
/* Check add flag */
if (dwFlags & REPLACE_ADD)
{
if (IsExistingFile(tmpDestPath))
continue;
else
dwAttrib = 0;
}
else
{
if (!IsExistingFile(tmpDestPath))
continue;
}
/* Check if file is read only, if so check if that should be ignored */
if (dwAttrib & FILE_ATTRIBUTE_READONLY)
{
if (!(dwFlags & REPLACE_READ_ONLY))
{
ConOutResPrintf(STRING_REPLACE_ERROR5, tmpDestPath);
*doMore = FALSE;
break;
}
}
/* Add filename to sourcepath, insted of wildcards */
_tcscpy(tmpSrcPath,szSrcPath);
_tcscat (tmpSrcPath, findBuffer.cFileName);
/* Make the replace */
if (replace(tmpSrcPath,tmpDestPath, dwFlags, doMore))
{
filesReplaced++;
}
else if (!*doMore)
{
/* The file to be replaced was the same as the source */
filesReplaced = -1;
break;
}
/* Take next sourcefile if any */
} while(FindNextFile (hFile, &findBuffer));
return filesReplaced;
}
INT
copy(TCHAR source[MAX_PATH],
TCHAR dest[MAX_PATH],
INT append,
DWORD lpdwFlags,
BOOL bTouch)
{
FILETIME srctime,NewFileTime;
HANDLE hFileSrc;
HANDLE hFileDest;
LPBYTE buffer;
DWORD dwAttrib;
DWORD dwRead;
DWORD dwWritten;
BOOL bEof = FALSE;
TCHAR TrueDest[MAX_PATH];
TCHAR TempSrc[MAX_PATH];
TCHAR * FileName;
SYSTEMTIME CurrentTime;
/* Check Breaker */
if (CheckCtrlBreak(BREAK_INPUT))
return 0;
TRACE ("checking mode\n");
if (bTouch)
{
hFileSrc = CreateFile (source, GENERIC_WRITE, FILE_SHARE_READ,
NULL, OPEN_EXISTING, 0, NULL);
if (hFileSrc == INVALID_HANDLE_VALUE)
{
ConOutResPrintf(STRING_COPY_ERROR1, source);
nErrorLevel = 1;
return 0;
}
GetSystemTime(&CurrentTime);
SystemTimeToFileTime(&CurrentTime, &NewFileTime);
if (SetFileTime(hFileSrc,(LPFILETIME) NULL, (LPFILETIME) NULL, &NewFileTime))
{
CloseHandle(hFileSrc);
nErrorLevel = 1;
return 1;
}
else
{
CloseHandle(hFileSrc);
return 0;
}
}
dwAttrib = GetFileAttributes (source);
hFileSrc = CreateFile (source, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, 0, NULL);
if (hFileSrc == INVALID_HANDLE_VALUE)
{
ConOutResPrintf(STRING_COPY_ERROR1, source);
nErrorLevel = 1;
return 0;
}
TRACE ("getting time\n");
GetFileTime (hFileSrc, &srctime, NULL, NULL);
TRACE ("copy: flags has %s\n",
lpdwFlags & COPY_ASCII ? "ASCII" : "BINARY");
/* Check to see if /D or /Z are true, if so we need a middle
man to copy the file too to allow us to use CopyFileEx later */
if (lpdwFlags & COPY_DECRYPT)
{
GetEnvironmentVariable(_T("TEMP"),TempSrc,MAX_PATH);
_tcscat(TempSrc,_T("\\"));
FileName = _tcsrchr(source,_T('\\'));
FileName++;
_tcscat(TempSrc,FileName);
/* This is needed to be on the end to prevent an error
if the user did "copy /D /Z foo bar then it would be copied
too %TEMP%\foo here and when %TEMP%\foo when it sets it up
for COPY_RESTART, this would mean it is copying to itself
which would error when it tried to open the handles for ReadFile
and WriteFile */
_tcscat(TempSrc,_T(".decrypt"));
if (!CopyFileEx(source, TempSrc, NULL, NULL, FALSE, COPY_FILE_ALLOW_DECRYPTED_DESTINATION))
{
CloseHandle (hFileSrc);
nErrorLevel = 1;
return 0;
}
_tcscpy(source, TempSrc);
}
if (lpdwFlags & COPY_RESTART)
{
_tcscpy(TrueDest, dest);
GetEnvironmentVariable(_T("TEMP"),dest,MAX_PATH);
_tcscat(dest,_T("\\"));
FileName = _tcsrchr(TrueDest,_T('\\'));
FileName++;
_tcscat(dest,FileName);
}
if (!IsExistingFile (dest))
{
TRACE ("opening/creating\n");
hFileDest =
CreateFile (dest, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
}
else if (!append)
{
TRACE ("SetFileAttributes (%s, FILE_ATTRIBUTE_NORMAL);\n", debugstr_aw(dest));
SetFileAttributes (dest, FILE_ATTRIBUTE_NORMAL);
TRACE ("DeleteFile (%s);\n", debugstr_aw(dest));
DeleteFile (dest);
hFileDest = CreateFile (dest, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
}
else
{
LONG lFilePosHigh = 0;
if (!_tcscmp (dest, source))
{
CloseHandle (hFileSrc);
return 0;
}
TRACE ("opening/appending\n");
SetFileAttributes (dest, FILE_ATTRIBUTE_NORMAL);
hFileDest =
CreateFile (dest, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
/* Move to end of file to start writing */
SetFilePointer (hFileDest, 0, &lFilePosHigh,FILE_END);
}
if (hFileDest == INVALID_HANDLE_VALUE)
{
CloseHandle (hFileSrc);
ConOutResPuts(STRING_ERROR_PATH_NOT_FOUND);
nErrorLevel = 1;
return 0;
}
/* A page-aligned buffer usually give more speed */
buffer = VirtualAlloc(NULL, BUFF_SIZE, MEM_COMMIT, PAGE_READWRITE);
if (buffer == NULL)
{
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
ConOutResPuts(STRING_ERROR_OUT_OF_MEMORY);
nErrorLevel = 1;
return 0;
}
do
{
ReadFile (hFileSrc, buffer, BUFF_SIZE, &dwRead, NULL);
if (lpdwFlags & COPY_ASCII)
{
LPBYTE pEof = memchr(buffer, 0x1A, dwRead);
if (pEof != NULL)
{
bEof = TRUE;
dwRead = pEof-buffer+1;
break;
}
}
if (dwRead == 0)
break;
WriteFile (hFileDest, buffer, dwRead, &dwWritten, NULL);
if (dwWritten != dwRead || CheckCtrlBreak(BREAK_INPUT))
{
ConOutResPuts(STRING_COPY_ERROR3);
VirtualFree (buffer, 0, MEM_RELEASE);
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
nErrorLevel = 1;
return 0;
}
}
while (!bEof);
TRACE ("setting time\n");
SetFileTime (hFileDest, &srctime, NULL, NULL);
if ((lpdwFlags & COPY_ASCII) && !bEof)
{
/* we're dealing with ASCII files! */
buffer[0] = 0x1A;
TRACE ("appending ^Z\n");
WriteFile (hFileDest, buffer, sizeof(CHAR), &dwWritten, NULL);
}
VirtualFree (buffer, 0, MEM_RELEASE);
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
TRACE ("setting mode\n");
SetFileAttributes (dest, dwAttrib);
/* Now finish off the copy if needed with CopyFileEx */
if (lpdwFlags & COPY_RESTART)
{
if (!CopyFileEx(dest, TrueDest, NULL, NULL, FALSE, COPY_FILE_RESTARTABLE))
{
nErrorLevel = 1;
DeleteFile(dest);
return 0;
}
/* Take care of file in the temp folder */
DeleteFile(dest);
}
if (lpdwFlags & COPY_DECRYPT)
DeleteFile(TempSrc);
return 1;
}
INT cmd_copy(LPTSTR param)
{
LPTSTR *arg;
INT argc, i, nFiles, nOverwrite = 0, nSrc = -1, nDes = -1;
/* this is the path up to the folder of the src and dest ie C:\windows\ */
TCHAR szDestPath[MAX_PATH];
TCHAR szSrcPath[MAX_PATH];
DWORD dwFlags = 0;
/* If this is the type of copy where we are adding files */
BOOL bAppend = FALSE;
WIN32_FIND_DATA findBuffer;
HANDLE hFile = NULL;
BOOL bTouch = FALSE;
/* Used when something like "copy c*.exe d*.exe" during the process of
figuring out the new name */
/* Pointer to keep track of how far through the append input(file1+file2+file3) we are */
TCHAR * appendPointer = _T("\0");
/* The full path to src and dest. This has drive letter, folders, and filename */
TCHAR tmpDestPath[MAX_PATH];
TCHAR tmpSrcPath[MAX_PATH];
/* A bool on weather or not the destination name will be taking from the input */
BOOL bSrcName = FALSE;
/* Seems like a waste but it is a pointer used to copy from input to PreserveName */
TCHAR * UseThisName;
/* for CMDCOPY env */
TCHAR *evar;
int size;
TCHAR * szTouch;
BOOL bHasWildcard, bDone = FALSE, bMoreFiles = FALSE;
BOOL bMultipleSource = FALSE, bMultipleDest = FALSE;
/* Show help/usage info */
if (!_tcsncmp(param, _T("/?"), 2))
{
ConOutResPaging(TRUE, STRING_COPY_HELP2);
return 0;
}
nErrorLevel = 0;
/* Get the envor value if it exists */
evar = cmd_alloc(512 * sizeof(TCHAR));
if (evar == NULL)
size = 0;
else
size = GetEnvironmentVariable (_T("COPYCMD"), evar, 512);
if (size > 512)
{
TCHAR *old_evar = evar;
evar = cmd_realloc(evar,size * sizeof(TCHAR) );
if (evar!=NULL)
size = GetEnvironmentVariable (_T("COPYCMD"), evar, size);
else
{
size=0;
evar = old_evar;
}
}
/* check see if we did get any env variable */
if (size != 0)
{
int t = 0;
/* scan and set the flags */
for (t = 0; t < size; t++)
{
if (_tcsncicmp(_T("/A"),&evar[t],2) == 0)
{
dwFlags |=COPY_ASCII;
t++;
}
else if (_tcsncicmp(_T("/B"),&evar[t],2) == 0)
{
dwFlags |= COPY_BINARY;
t++;
}
else if (_tcsncicmp(_T("/D"),&evar[t],2) == 0)
{
dwFlags |= COPY_DECRYPT;
t++;
}
else if (_tcsncicmp(_T("/V"),&evar[t],2) == 0)
{
dwFlags |= COPY_VERIFY;
t++;
}
else if (_tcsncicmp(_T("/N"),&evar[t],2) == 0)
{
dwFlags |= COPY_SHORTNAME;
t++;
}
else if (_tcsncicmp(_T("/Y"),&evar[t],2) == 0)
{
dwFlags |= COPY_NO_PROMPT;
t++;
}
else if (_tcsncicmp(_T("/-Y"),&evar[t],3) == 0)
{
dwFlags |= COPY_PROMPT;
t+=2;
}
else if (_tcsncicmp(_T("/Z"),&evar[t],2) == 0)
{
dwFlags |= COPY_PROMPT;
t++;
}
}
}
cmd_free(evar);
/* Split the user input into array */
arg = split(param, &argc, FALSE, TRUE);
nFiles = argc;
/* Read switches and count files */
for (i = 0; i < argc; i++)
{
if (*arg[i] == _T('/'))
{
if (_tcslen(arg[i]) >= 2)
{
switch (_totupper(arg[i][1]))
{
case _T('A'):
dwFlags |= COPY_ASCII;
break;
case _T('B'):
dwFlags |= COPY_BINARY;
break;
case _T('D'):
dwFlags |= COPY_DECRYPT;
break;
case _T('V'):
dwFlags |= COPY_VERIFY;
break;
case _T('N'):
dwFlags |= COPY_SHORTNAME;
break;
case _T('Y'):
dwFlags |= COPY_NO_PROMPT;
dwFlags &= ~COPY_PROMPT;
break;
case _T('-'):
if (_tcslen(arg[i]) >= 3)
if (_totupper(arg[i][2]) == _T('Y'))
{
dwFlags &= ~COPY_NO_PROMPT;
dwFlags |= COPY_PROMPT;
}
break;
case _T('Z'):
dwFlags |= COPY_RESTART;
break;
default:
/* Invalid switch */
ConOutResPrintf(STRING_ERROR_INVALID_SWITCH, _totupper(arg[i][1]));
nErrorLevel = 1;
freep (arg);
return 1;
break;
}
}
/* If it was a switch, subtract from total arguments */
nFiles--;
}
else
{
/* If it isn't a switch then it is the source or destination */
if (nSrc == -1)
{
nSrc = i;
}
else if (*arg[i] == _T('+'))
{
/* Next file should be appended */
bMoreFiles = TRUE;
nFiles -= 1;
}
else if (bMoreFiles)
{
/* Add this file to the source string
this way we can do all checks
directly on source string later on */
TCHAR * ptr;
int length = (_tcslen(arg[nSrc]) + _tcslen(arg[i]) + 2) * sizeof(TCHAR);
ptr = cmd_alloc(length);
if (ptr)
{
_tcscpy(ptr, arg[nSrc]);
_tcscat(ptr, _T("|"));
_tcscat(ptr, arg[i]);
cmd_free(arg[nSrc]);
arg[nSrc] = ptr;
nFiles -= 1;
}
bMoreFiles = FALSE;
}
else if (nDes == -1)
{
nDes = i;
}
}
}
/* keep quiet within batch files */
if (bc != NULL)
{
dwFlags |= COPY_NO_PROMPT;
dwFlags &= ~COPY_PROMPT;
}
if (nFiles < 1)
{
/* There are not enough files, there has to be at least 1 */
ConOutResPuts(STRING_ERROR_REQ_PARAM_MISSING);
freep(arg);
return 1;
}
if (nFiles > 2)
{
/* There are too many file names in command */
ConErrResPrintf(STRING_ERROR_TOO_MANY_PARAMETERS,_T(""));
nErrorLevel = 1;
freep(arg);
return 1;
}
if ((_tcschr(arg[nSrc], _T('|')) != NULL) ||
(_tcschr(arg[nSrc], _T('*')) != NULL) ||
(_tcschr(arg[nSrc], _T('?')) != NULL) ||
IsExistingDirectory(arg[nSrc]))
{
bMultipleSource = TRUE;
}
/* Reusing the number of files variable */
nFiles = 0;
/* Check if no destination argument is passed */
if (nDes == -1)
{
/* If no destination was entered then just use
the current directory as the destination */
GetCurrentDirectory(MAX_PATH, szDestPath);
}
else
{
/* Check if the destination is 'x:' */
if ((arg[nDes][1] == _T(':')) && (arg[nDes][2] == _T('\0')))
{
GetRootPath(arg[nDes], szDestPath, MAX_PATH);
}
else
{
/* If the user entered two file names then form the full string path */
GetFullPathName(arg[nDes], MAX_PATH, szDestPath, NULL);
}
/* Make sure there is an ending slash to the path if the dest is a folder */
if ((_tcschr(szDestPath, _T('*')) == NULL) &&
IsExistingDirectory(szDestPath))
{
bMultipleDest = TRUE;
if (szDestPath[_tcslen(szDestPath) - 1] != _T('\\'))
_tcscat(szDestPath, _T("\\"));
}
/* Check if the destination uses wildcards */
if ((_tcschr(arg[nDes], _T('*')) != NULL) ||
(_tcschr(arg[nDes], _T('?')) != NULL))
{
bMultipleDest = TRUE;
}
}
if (nDes != -1) /* you can only append files when there is a destination */
{
if (bMultipleSource && !bMultipleDest)
{
/* We have multiple source files, but not multiple destination
files. This means we are appending the soruce files. */
bAppend = TRUE;
if (_tcschr(arg[nSrc], _T('|')) != NULL)
appendPointer = arg[nSrc];
}
}
/* Save the name the user entered */
UseThisName = _tcsrchr(szDestPath,_T('\\'));
if (UseThisName)
{
/* Split the name from the path */
*UseThisName++ = _T('\0');
/* Check if the dest path ends with '\*' or '\' */
if (((UseThisName[0] == _T('*')) && (UseThisName[1] == _T('\0'))) ||
(UseThisName[0] == _T('\0')))
{
/* In this case we will be using the same name as the source file
for the destination file because destination is a folder */
bSrcName = TRUE;
UseThisName = NULL;
}
}
else
{
/* Something's seriously wrong! */
UseThisName = szDestPath;
}
do
{
/* Get the full string of the path to the source file */
if (_tcschr(arg[nSrc], _T('|')) != NULL)
{
/* Reset the source path */
szSrcPath[0] = _T('\0');
/* Loop through the source file name and copy all
the chars one at a time until it gets too + */
while(TRUE)
{
if (appendPointer[0] == _T('|'))
{
/* Skip the | and go to the next file name */
appendPointer++;
break;
}
else if (appendPointer[0] == _T('\0'))
{
bDone = TRUE;
break;
}
_tcsncat(szSrcPath, appendPointer, 1);
appendPointer++;
}
if (_tcschr(arg[nSrc], _T(',')) != NULL)
{
/* Only time there is a , in the source is when they are using touch
Cant have a destination and can only have on ,, at the end of the string
Cant have more then one file name */
szTouch = _tcsstr(arg[nSrc], _T("|"));
if (_tcsncmp(szTouch,_T("|,,\0"), 4) || (nDes != -1))
{
ConErrResPrintf(STRING_ERROR_INVALID_PARAM_FORMAT,arg[nSrc]);
nErrorLevel = 1;
freep (arg);
return 1;
}
bTouch = TRUE;
bDone = TRUE;
}
}
else
{
bDone = TRUE;
_tcscpy(szSrcPath, arg[nSrc]);
}
/* "x:" is not a valid source path format. */
if ((szSrcPath[1] == _T(':')) && (szSrcPath[2] == _T('\0')))
{
ConOutPrintf(_T("%s\n"), szSrcPath);
ConOutFormatMessage(ERROR_FILE_NOT_FOUND, szSrcPath);
nErrorLevel = 1;
break;
}
/* From this point on, we can assume that the shortest path is 3 letters long
and that would be [DriveLetter]:\ */
/* Check if the path has a wildcard */
bHasWildcard = (_tcschr(szSrcPath, _T('*')) != NULL);
/* If there is no * in the path name and it is a folder then we will
need to add a wildcard to the pathname so FindFirstFile comes up
with all the files in that folder */
if (!bHasWildcard && IsExistingDirectory(szSrcPath))
{
/* If it doesnt have a \ at the end already then on needs to be added */
if (szSrcPath[_tcslen(szSrcPath) - 1] != _T('\\'))
_tcscat(szSrcPath, _T("\\"));
_tcscat(szSrcPath, _T("*"));
bHasWildcard = TRUE;
}
/* If the path ends with '\' add a wildcard at the end */
if (szSrcPath[_tcslen(szSrcPath) - 1] == _T('\\'))
{
_tcscat(szSrcPath, _T("*"));
bHasWildcard = TRUE;
}
/* Get a list of all the files */
hFile = FindFirstFile(szSrcPath, &findBuffer);
/* If it couldnt open the file handle, print out the error */
if (hFile == INVALID_HANDLE_VALUE)
{
/* only print source name when more then one file */
if (bMultipleSource)
ConOutPrintf(_T("%s\n"), szSrcPath);
ConOutFormatMessage(GetLastError(), szSrcPath);
freep(arg);
nErrorLevel = 1;
return 1;
}
/* Strip the paths back to the folder they are in */
for (i = (_tcslen(szSrcPath) - 1); i > -1; i--)
if (szSrcPath[i] != _T('\\'))
szSrcPath[i] = _T('\0');
else
break;
do
{
/* Check Breaker */
if (CheckCtrlBreak(BREAK_INPUT))
{
FindClose(hFile);
freep(arg);
return 1;
}
/* Set the override to yes each new file */
nOverwrite = 1;
/* Ignore the . and .. files */
if (!_tcscmp(findBuffer.cFileName, _T(".")) ||
!_tcscmp(findBuffer.cFileName, _T("..")) ||
findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
continue;
}
/* Copy the base folder over to a tmp string */
_tcscpy(tmpDestPath, szDestPath);
_tcscat(tmpDestPath, _T("\\"));
/* Can't put a file into a folder that isn't there */
if (_tcscmp(tmpDestPath, _T("\\\\.\\")) &&
!IsExistingDirectory(tmpDestPath))
{
FindClose(hFile);
ConOutFormatMessage(GetLastError(), szSrcPath);
freep(arg);
nErrorLevel = 1;
return 1;
}
/* Copy over the destination path name */
if (bSrcName)
_tcscat(tmpDestPath, findBuffer.cFileName);
else
{
/* If there is no wildcard you can use the name the user entered */
if ((_tcschr(UseThisName, _T('*')) == NULL) &&
(_tcschr(UseThisName, _T('?')) == NULL))
{
_tcscat(tmpDestPath, UseThisName);
}
else
{
TCHAR DoneFile[MAX_PATH];
BuildFileName(findBuffer.cFileName,
UseThisName,
DoneFile);
/* Add the filename to the tmp string path */
_tcscat(tmpDestPath, DoneFile);
}
}
/* Build the string path to the source file */
_tcscpy(tmpSrcPath,szSrcPath);
_tcscat (tmpSrcPath, findBuffer.cFileName);
/* Check to see if the file is the same file */
if (!bTouch && !_tcscmp(tmpSrcPath, tmpDestPath))
{
ConOutResPrintf(STRING_COPY_ERROR2);
nErrorLevel = 1;
break;
}
/* only print source name when more then one file */
if (bMultipleSource)
ConOutPrintf(_T("%s\n"), tmpSrcPath);
/* Handle any overriding / prompting that needs to be done */
if (((!(dwFlags & COPY_NO_PROMPT) && IsExistingFile (tmpDestPath)) || dwFlags & COPY_PROMPT) && !bTouch)
nOverwrite = CopyOverwrite(tmpDestPath);
if (nOverwrite == PROMPT_NO || nOverwrite == PROMPT_BREAK)
continue;
if (nOverwrite == PROMPT_ALL || (nOverwrite == PROMPT_YES && bAppend))
dwFlags |= COPY_NO_PROMPT;
/* Tell weather the copy was successful or not */
if (copy(tmpSrcPath,tmpDestPath, bAppend, dwFlags, bTouch))
{
nFiles++;
//LoadString(CMD_ModuleHandle, STRING_MOVE_ERROR1, szMsg, RC_STRING_MAX_SIZE);
}
else
{
/* print out the error message */
ConOutResPrintf(STRING_COPY_ERROR3);
ConOutFormatMessage (GetLastError(), szSrcPath);
nErrorLevel = 1;
}
/* Loop through all wildcard files */
} while (FindNextFile(hFile, &findBuffer));
/* Loop through all files in src string with a + */
} while(!bDone);
/* print out the number of files copied */
ConOutResPrintf(STRING_COPY_FILE, bAppend ? 1 : nFiles);
if (hFile) FindClose(hFile);
if (arg != NULL)
freep(arg);
return 0;
}
/*
* display shell version info internal command.
*/
INT cmd_ver (LPTSTR param)
{
INT i;
nErrorLevel = 0;
if (_tcsstr(param, _T("/?")) != NULL)
{
ConOutResPaging(TRUE,STRING_VERSION_HELP1);
return 0;
}
ConOutResPrintf(STRING_CMD_SHELLINFO, _T(KERNEL_RELEASE_STR), _T(KERNEL_VERSION_BUILD_STR));
ConOutChar(_T('\n'));
ConOutResPuts(STRING_VERSION_RUNNING_ON);
PrintOSVersion();
/* Basic copyright notice */
if (param[0] != _T('\0'))
{
ConOutPuts(_T("\n\n"));
ConOutPuts(_T("Copyright (C) 1994-1998 Tim Norman and others.\n"));
ConOutPuts(_T("Copyright (C) 1998-") _T(COPYRIGHT_YEAR) _T(" ReactOS Team\n"));
for (i = 0; param[i]; i++)
{
/* Skip spaces */
if (param[i] == _T(' '))
continue;
if (param[i] == _T('/'))
{
/* Is this a lone '/' ? */
if (param[i + 1] == 0)
{
error_invalid_switch(_T(' '));
return 1;
}
continue;
}
if (_totupper(param[i]) == _T('W'))
{
/* Warranty notice */
ConOutResPuts(STRING_VERSION_HELP3);
}
else if (_totupper(param[i]) == _T('R'))
{
/* Redistribution notice */
ConOutResPuts(STRING_VERSION_HELP4);
}
else if (_totupper(param[i]) == _T('C'))
{
/* Developer listing */
ConOutResPuts(STRING_VERSION_HELP6);
ConOutResPuts(STRING_FREEDOS_DEV);
ConOutResPuts(STRING_VERSION_HELP7);
ConOutResPuts(STRING_REACTOS_DEV);
}
else
{
error_invalid_switch(_totupper(param[i]));
return 1;
}
}
/* Bug report notice */
ConOutResPuts(STRING_VERSION_HELP5);
}
ConOutChar(_T('\n'));
return 0;
}
INT cmd_time (LPTSTR param)
{
LPTSTR *arg;
INT argc;
INT i;
INT nTimeString = -1;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_TIME_HELP1);
return 0;
}
nErrorLevel = 0;
/* build parameter array */
arg = split (param, &argc, FALSE, FALSE);
/* check for options */
for (i = 0; i < argc; i++)
{
if (_tcsicmp (arg[i], _T("/t")) == 0)
{
/* Display current time in short format */
SYSTEMTIME st;
TCHAR szTime[20];
GetLocalTime(&st);
FormatTime(szTime, &st);
ConOutPuts(szTime);
freep(arg);
return 0;
}
if ((*arg[i] != _T('/')) && (nTimeString == -1))
nTimeString = i;
}
if (nTimeString == -1)
{
ConOutResPrintf(STRING_LOCALE_HELP1);
ConOutPrintf(_T(": %s\n"), GetTimeString());
}
while (1)
{
if (nTimeString == -1)
{
TCHAR s[40];
ConOutResPuts(STRING_TIME_HELP2);
ConInString (s, 40);
TRACE ("\'%s\'\n", debugstr_aw(s));
while (*s && s[_tcslen (s) - 1] < _T(' '))
s[_tcslen(s) - 1] = _T('\0');
if (ParseTime (s))
{
freep (arg);
return 0;
}
}
else
{
if (ParseTime (arg[nTimeString]))
{
freep (arg);
return 0;
}
/* force input the next time around. */
nTimeString = -1;
}
ConErrResPuts(STRING_TIME_ERROR1);
nErrorLevel = 1;
}
freep (arg);
return 0;
}
INT CommandExpand (LPTSTR param)
{
/*cmd is the command that was given, in this case it will always be "expand"
param is whatever is given after the command*/
LPTSTR *arg = NULL;
INT args;
INT i;
INT nEvalArgs = 0; /* nunber of evaluated arguments */
DWORD dwFlags = 0;
DWORD dwAttrFlags = 0;
DWORD dwFiles = 0;
LONG ch;
TCHAR szOrginalArg[MAX_PATH];
/*checks the first two chars of param to see if it is /?
this however allows the following command to not show help
"expand frog.cab /?" */
if (!StringsLoaded)
{
LoadStrings();
}
if (!_tcsncmp (param, _T("/?"), 2))
{
//ConOutResPaging(TRUE,STRING_DEL_HELP1);
return 0;
}
nErrorLevel = 0;
arg = split (param, &args, FALSE);
if (args == 0)
{
/* only command given */
error_req_param_missing ();
freep (arg);
return 1;
}
/* check for options anywhere in command line */
for (i = 0; i < args; i++)
{
if (*arg[i] == _T('-'))
{
/*found a command, but check to make sure it has something after it*/
if (_tcslen (arg[i]) >= 2)
{
ch = _totupper (arg[i][1]);
if (ch == _T('R'))
{
dwFlags |= EXPAND_RENAME;
}
else if (ch == _T('D'))
{
dwFlags |= EXPAND_DISPLAY;
}
else if (ch == _T('F'))
{
dwFlags |= EXPAND_FILES;
}
else if (ch == _T('Y'))
{
dwFlags |= EXPAND_YES;
}
}
nEvalArgs++;
}
}
/* there are only options on the command line --> error!!!
there is the same number of args as there is flags, so none of the args were filenames*/
if (args == nEvalArgs)
{
error_req_param_missing ();
freep (arg);
return 1;
}
/* check for filenames anywhere in command line */
for (i = 0; i < args && !(dwFiles & 0x80000000); i++)
{
/*this checks to see if it isnt a flag, if it isnt, we assume it is a file name*/
if((*arg[i] == _T('/')) || (*arg[i] == _T('-')))
continue;
/* We want to make a copies of the argument */
freep (arg);
/*Based on MS cmd, we only tell what files are being deleted when /S is used */
if (dwFlags & DEL_TOTAL)
{
dwFiles &= 0x7fffffff;
if (dwFiles < 2)
{
ConOutResPrintf(STRING_DEL_HELP3, dwFiles);
}
else
{
ConOutResPrintf(STRING_DEL_HELP4, dwFiles);
}
}
return 0;
}
INT cmd_label (LPTSTR param)
{
TCHAR szRootPath[] = _T("A:\\");
TCHAR szLabel[80];
TCHAR szOldLabel[80];
DWORD dwSerialNr;
/* set empty label string */
szLabel[0] = _T('\0');
nErrorLevel = 0;
/* print help */
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_LABEL_HELP1);
return 0;
}
/* get parameters */
if (param[0] != _T('\0') && param[1] == _T(':'))
{
szRootPath[0] = (TCHAR)toupper(*param);
param += 2;
while (_istspace(*param))
param++;
}
else
{
/* get label of current drive */
TCHAR szCurPath[MAX_PATH];
GetCurrentDirectory (MAX_PATH, szCurPath);
szRootPath[0] = szCurPath[0];
}
_tcsncat(szLabel, param, 79);
/* check root path */
if (!IsValidPathName (szRootPath))
{
error_invalid_drive ();
nErrorLevel = 1;
return 1;
}
if (szLabel[0] == _T('\0'))
{
GetVolumeInformation(szRootPath, szOldLabel, 80, &dwSerialNr,
NULL, NULL, NULL, 0);
/* print drive info */
if (szOldLabel[0] != _T('\0'))
{
ConOutResPrintf(STRING_LABEL_HELP2, _totupper(szRootPath[0]), szOldLabel);
}
else
{
ConOutResPrintf(STRING_LABEL_HELP3, _totupper(szRootPath[0]));
}
/* print the volume serial number */
ConOutResPrintf(STRING_LABEL_HELP4, HIWORD(dwSerialNr), LOWORD(dwSerialNr));
ConOutResPuts(STRING_LABEL_HELP5);
ConInString(szLabel, 80);
}
if (!SetVolumeLabel(szRootPath, szLabel))
{
ConOutFormatMessage(GetLastError());
nErrorLevel = 1;
return 1;
}
return 0;
}
INT CommandTimer (LPTSTR param)
{
// all timers are kept
static DWORD clksT[10];
// timers status
// set all the clocks off by default
static BOOL clksS[10]={FALSE,FALSE,FALSE,FALSE,
FALSE,FALSE,FALSE,FALSE,FALSE,FALSE};
// TRUE if /S in command line
BOOL bS = FALSE;
// avoid to set clk_n more than once
BOOL bCanNSet = TRUE;
INT NewClkStatus = NCS_NOT_SPECIFIED;
// the clock number specified on the command line
// 1 by default
INT clk_n=1;
// output format
INT iFormat=1;
// command line parsing variables
INT argc;
LPTSTR *p;
INT i;
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutResPrintf(STRING_TIMER_HELP3, cTimeSeparator, cTimeSeparator, cDecimalSeparator);
return 0;
}
nErrorLevel = 0;
p = split (param, &argc, FALSE, FALSE);
//read options
for (i = 0; i < argc; i++)
{
//set timer on
if (!(_tcsicmp(&p[i][0],_T("on"))) && NewClkStatus == NCS_NOT_SPECIFIED)
{
NewClkStatus = NCS_ON;
continue;
}
//set timer off
if (!(_tcsicmp(&p[i][0],_T("off"))) && NewClkStatus == NCS_NOT_SPECIFIED)
{
NewClkStatus = NCS_OFF;
continue;
}
// other options
if (p[i][0] == _T('/'))
{
// set timer number
if (_istdigit(p[i][1]) && bCanNSet)
{
clk_n = p[i][1] - _T('0');
bCanNSet = FALSE;
continue;
}
// set s(plit) option
if (_totupper(p[i][1]) == _T('S'))
{
bS = TRUE;
continue;
}
// specify format
if (_totupper(p[i][1]) == _T('F'))
{
iFormat = p[i][2] - _T('0');
continue;
}
}
}
// do stuff (start/stop/read timer)
if (NewClkStatus == NCS_ON)
{
cT=GetTickCount();
cS=TRUE;
ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
ConOutPuts(GetTimeString());
freep(p);
return 0;
}
if (bS)
{
if (cS)
{
ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
ConOutPrintf(_T("%s\n"), GetTimeString());
PrintElapsedTime(GetTickCount()-cT, iFormat);
freep(p);
return 0;
}
cT=GetTickCount();
cS=TRUE;
ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
ConOutPuts(GetTimeString());
freep(p);
return 0;
}
if (NewClkStatus == NCS_NOT_SPECIFIED)
{
if (cS)
{
cS=FALSE;
ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
ConOutPrintf(_T("%s\n"), GetTimeString());
PrintElapsedTime(GetTickCount()-cT, iFormat);
freep(p);
return 0;
}
cT=GetTickCount();
cS=TRUE;
ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
ConOutPuts(GetTimeString());
freep(p);
return 0;
}
if (NewClkStatus == NCS_OFF)
{
if (cS)
{
cS=FALSE;
ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
ConOutPrintf(_T("%s\n"), GetTimeString());
PrintElapsedTime(GetTickCount()-cT, iFormat);
freep(p);
return 0;
}
ConOutResPrintf (STRING_TIMER_TIME,clk_n,cS?_T("ON"):_T("OFF"));
ConOutPuts(GetTimeString());
freep(p);
return 0;
}
freep(p);
return 0;
}
static VOID
PrintDiskInfo (LPTSTR szDisk)
{
TCHAR szMsg[RC_STRING_MAX_SIZE];
TCHAR szRootPath[4] = _T("A:\\");
TCHAR szDrive[2] = _T("A");
TCHAR szVolume[64];
TCHAR szSerial[10];
TCHAR szTotal[40];
TCHAR szUsed[40];
TCHAR szFree[40];
DWORD dwSerial;
ULONGLONG uliSize;
DWORD dwSecPerCl;
DWORD dwBytPerSec;
DWORD dwFreeCl;
DWORD dwTotCl;
if (_tcslen (szDisk) < 2 || szDisk[1] != _T(':'))
{
ConErrResPrintf(STRING_FREE_ERROR1);
return;
}
szRootPath[0] = szDisk[0];
szDrive[0] = _totupper (szRootPath[0]);
if (!GetVolumeInformation (szRootPath, szVolume, 64, &dwSerial,
NULL, NULL, NULL, 0))
{
LoadString(CMD_ModuleHandle, STRING_FREE_ERROR1, szMsg, RC_STRING_MAX_SIZE);
ConErrPrintf(_T("%s %s:\n"), szMsg, szDrive);
return;
}
if (szVolume[0] == _T('\0'))
{
LoadString(CMD_ModuleHandle, STRING_FREE_ERROR2, szMsg, RC_STRING_MAX_SIZE);
_tcscpy (szVolume, szMsg);
}
_stprintf (szSerial,
_T("%04X-%04X"),
HIWORD(dwSerial),
LOWORD(dwSerial));
if (!GetDiskFreeSpace (szRootPath, &dwSecPerCl,
&dwBytPerSec, &dwFreeCl, &dwTotCl))
{
LoadString(CMD_ModuleHandle, STRING_FREE_ERROR1, szMsg, RC_STRING_MAX_SIZE);
ConErrPrintf(_T("%s %s:\n"), szMsg, szDrive);
return;
}
uliSize = dwSecPerCl * dwBytPerSec * (ULONGLONG)dwTotCl;
ConvertULargeInteger(uliSize, szTotal, 40, TRUE);
uliSize = dwSecPerCl * dwBytPerSec * (ULONGLONG)(dwTotCl - dwFreeCl);
ConvertULargeInteger(uliSize, szUsed, 40, TRUE);
uliSize = dwSecPerCl * dwBytPerSec * (ULONGLONG)dwFreeCl;
ConvertULargeInteger(uliSize, szFree, 40, TRUE);
ConOutResPrintf(STRING_FREE_HELP1, szDrive, szVolume, szSerial, szTotal, szUsed, szFree);
}
INT cmd_move (LPTSTR param)
{
LPTSTR *arg;
INT argc, i, nFiles;
LPTSTR pszDest;
TCHAR szDestPath[MAX_PATH];
TCHAR szFullDestPath[MAX_PATH];
TCHAR szSrcDirPath[MAX_PATH];
TCHAR szSrcPath[MAX_PATH];
TCHAR szFullSrcPath[MAX_PATH];
DWORD dwFlags = 0;
INT nOverwrite = 0;
WIN32_FIND_DATA findBuffer;
HANDLE hFile;
/* used only when source and destination directories are on different volume*/
HANDLE hDestFile;
WIN32_FIND_DATA findDestBuffer;
TCHAR szMoveDest[MAX_PATH];
TCHAR szMoveSrc[MAX_PATH];
LPTSTR pszDestDirPointer;
LPTSTR pszSrcDirPointer;
INT nDirLevel = 0;
LPTSTR pszFile;
BOOL OnlyOneFile;
BOOL FoundFile;
BOOL MoveStatus;
DWORD dwMoveFlags = 0;
DWORD dwMoveStatusFlags = 0;
if (!_tcsncmp (param, _T("/?"), 2))
{
#if 0
ConOutPuts (_T("Moves files and renames files and directories.\n\n"
"To move one or more files:\n"
"MOVE [/N][/Y|/-Y][drive:][path]filename1[,...] destination\n"
"\n"
"To rename a directory:\n"
"MOVE [/N][/Y|/-Y][drive:][path]dirname1 dirname2\n"
"\n"
" [drive:][path]filename1 Specifies the location and name of the file\n"
" or files you want to move.\n"
" /N Nothing. Don everthing but move files or direcories.\n"
" /Y\n"
" /-Y\n"
"..."));
#else
ConOutResPaging(TRUE,STRING_MOVE_HELP2);
#endif
return 0;
}
nErrorLevel = 0;
arg = splitspace(param, &argc);
/* read options */
for (i = 0; i < argc; i++)
{
if (!_tcsicmp(arg[i], _T("/N")))
dwFlags |= MOVE_NOTHING;
else if (!_tcsicmp(arg[i], _T("/Y")))
dwFlags |= MOVE_OVER_YES;
else if (!_tcsicmp(arg[i], _T("/-Y")))
dwFlags |= MOVE_OVER_NO;
else
break;
}
nFiles = argc - i;
if (nFiles < 1)
{
/* there must be at least one pathspec */
error_req_param_missing();
freep(arg);
return 1;
}
if (nFiles > 2)
{
/* there are more than two pathspecs */
error_too_many_parameters(param);
freep(arg);
return 1;
}
/* If no destination is given, default to current directory */
pszDest = (nFiles == 1) ? _T(".") : arg[i + 1];
/* check for wildcards in source and destination */
if (_tcschr(pszDest, _T('*')) != NULL || _tcschr(pszDest, _T('?')) != NULL)
{
/* '*'/'?' in dest, this doesnt happen. give folder name instead*/
error_invalid_parameter_format(pszDest);
freep(arg);
return 1;
}
if (_tcschr(arg[i], _T('*')) != NULL || _tcschr(arg[i], _T('?')) != NULL)
{
dwMoveStatusFlags |= MOVE_SOURCE_HAS_WILD;
}
/* get destination */
GetFullPathName (pszDest, MAX_PATH, szDestPath, NULL);
TRACE ("Destination: %s\n", debugstr_aw(szDestPath));
/* get source folder */
GetFullPathName(arg[i], MAX_PATH, szSrcDirPath, &pszFile);
if (pszFile != NULL)
*pszFile = _T('\0');
TRACE ("Source Folder: %s\n", debugstr_aw(szSrcDirPath));
hFile = FindFirstFile (arg[i], &findBuffer);
if (hFile == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), arg[i]);
freep (arg);
return 1;
}
/* check for special cases "." and ".." and if found skip them */
FoundFile = TRUE;
while(FoundFile &&
(_tcscmp(findBuffer.cFileName,_T(".")) == 0 ||
_tcscmp(findBuffer.cFileName,_T("..")) == 0))
FoundFile = FindNextFile (hFile, &findBuffer);
if (!FoundFile)
{
/* what? we don't have anything to move? */
error_file_not_found();
FindClose(hFile);
freep(arg);
return 1;
}
OnlyOneFile = TRUE;
/* check if there can be found files as files have first priority */
if (findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
dwMoveStatusFlags |= MOVE_SOURCE_IS_DIR;
else
dwMoveStatusFlags |= MOVE_SOURCE_IS_FILE;
while(OnlyOneFile && FindNextFile(hFile,&findBuffer))
{
if (!(findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
ConOutPrintf(_T(""));
if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE) OnlyOneFile = FALSE;
else
{ /* this has been done this way so that we don't disturb other settings if they have been set before this */
dwMoveStatusFlags |= MOVE_SOURCE_IS_FILE;
dwMoveStatusFlags &= ~MOVE_SOURCE_IS_DIR;
}
}
}
FindClose(hFile);
TRACE ("Do we have only one file: %s\n", OnlyOneFile ? "TRUE" : "FALSE");
/* we have to start again to be sure we don't miss any files or folders*/
hFile = FindFirstFile (arg[i], &findBuffer);
if (hFile == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), arg[i]);
freep (arg);
return 1;
}
/* check for special cases "." and ".." and if found skip them */
FoundFile = TRUE;
while(FoundFile &&
(_tcscmp(findBuffer.cFileName,_T(".")) == 0 ||
_tcscmp(findBuffer.cFileName,_T("..")) == 0))
FoundFile = FindNextFile (hFile, &findBuffer);
if (!FoundFile)
{
/* huh? somebody removed files and/or folders which were there */
error_file_not_found();
FindClose(hFile);
freep(arg);
return 1;
}
/* check if source and destination paths are on different volumes */
if (szSrcDirPath[0] != szDestPath[0])
dwMoveStatusFlags |= MOVE_PATHS_ON_DIF_VOL;
/* move it */
do
{
TRACE ("Found file/directory: %s\n", debugstr_aw(findBuffer.cFileName));
nOverwrite = 1;
dwMoveFlags = 0;
dwMoveStatusFlags &= ~MOVE_DEST_IS_FILE &
~MOVE_DEST_IS_DIR &
~MOVE_SRC_CURRENT_IS_DIR &
~MOVE_DEST_EXISTS;
_tcscpy(szFullSrcPath,szSrcDirPath);
if(szFullSrcPath[_tcslen(szFullSrcPath) - 1] != _T('\\'))
_tcscat (szFullSrcPath, _T("\\"));
_tcscat(szFullSrcPath,findBuffer.cFileName);
_tcscpy(szSrcPath, szFullSrcPath);
if (IsExistingDirectory(szSrcPath))
{
/* source is directory */
if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE)
{
dwMoveStatusFlags |= MOVE_SRC_CURRENT_IS_DIR; /* source is file but at the current round we found a directory */
continue;
}
TRACE ("Source is dir: %s\n", debugstr_aw(szSrcPath));
dwMoveFlags = MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
}
/* if source is file we don't need to do anything special */
if (IsExistingDirectory(szDestPath))
{
/* destination is existing directory */
TRACE ("Destination is directory: %s\n", debugstr_aw(szDestPath));
dwMoveStatusFlags |= MOVE_DEST_IS_DIR;
/*build the dest string(accounts for *)*/
_tcscpy (szFullDestPath, szDestPath);
/*check to see if there is an ending slash, if not add one*/
if(szFullDestPath[_tcslen(szFullDestPath) - 1] != _T('\\'))
_tcscat (szFullDestPath, _T("\\"));
_tcscat (szFullDestPath, findBuffer.cFileName);
if (IsExistingFile(szFullDestPath) || IsExistingDirectory(szFullDestPath))
dwMoveStatusFlags |= MOVE_DEST_EXISTS;
dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
}
if (IsExistingFile(szDestPath))
{
/* destination is a file */
TRACE ("Destination is file: %s\n", debugstr_aw(szDestPath));
dwMoveStatusFlags |= MOVE_DEST_IS_FILE | MOVE_DEST_EXISTS;
_tcscpy (szFullDestPath, szDestPath);
dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
}
TRACE ("Move Status Flags: 0x%X\n",dwMoveStatusFlags);
if (dwMoveStatusFlags & MOVE_SOURCE_IS_DIR &&
dwMoveStatusFlags & MOVE_DEST_IS_DIR &&
dwMoveStatusFlags & MOVE_SOURCE_HAS_WILD)
{
/* We are not allowed to have existing source and destination dir when there is wildcard in source */
error_syntax(NULL);
FindClose(hFile);
freep(arg);
return 1;
}
if (!(dwMoveStatusFlags & (MOVE_DEST_IS_FILE | MOVE_DEST_IS_DIR)))
{
/* destination doesn't exist */
_tcscpy (szFullDestPath, szDestPath);
if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE) dwMoveStatusFlags |= MOVE_DEST_IS_FILE;
if (dwMoveStatusFlags & MOVE_SOURCE_IS_DIR) dwMoveStatusFlags |= MOVE_DEST_IS_DIR;
dwMoveFlags |= MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH | MOVEFILE_COPY_ALLOWED;
}
if (dwMoveStatusFlags & MOVE_SOURCE_IS_FILE &&
dwMoveStatusFlags & MOVE_DEST_IS_FILE &&
!OnlyOneFile)
{
/*source has many files but there is only one destination file*/
error_invalid_parameter_format(pszDest);
FindClose(hFile);
freep (arg);
return 1;
}
/*checks to make sure user wanted/wants the override*/
if((dwFlags & MOVE_OVER_NO) &&
(dwMoveStatusFlags & MOVE_DEST_EXISTS))
continue;
if(!(dwFlags & MOVE_OVER_YES) &&
(dwMoveStatusFlags & MOVE_DEST_EXISTS))
nOverwrite = MoveOverwrite (szFullDestPath);
if (nOverwrite == PROMPT_NO || nOverwrite == PROMPT_BREAK)
continue;
if (nOverwrite == PROMPT_ALL)
dwFlags |= MOVE_OVER_YES;
ConOutPrintf (_T("%s => %s "), szSrcPath, szFullDestPath);
/* are we really supposed to do something */
if (dwFlags & MOVE_NOTHING)
continue;
/*move the file*/
if (!(dwMoveStatusFlags & MOVE_SOURCE_IS_DIR &&
dwMoveStatusFlags & MOVE_PATHS_ON_DIF_VOL))
/* we aren't moving source folder to different drive */
MoveStatus = MoveFileEx (szSrcPath, szFullDestPath, dwMoveFlags);
else
{ /* we are moving source folder to different drive */
_tcscpy(szMoveDest, szFullDestPath);
_tcscpy(szMoveSrc, szSrcPath);
DeleteFile(szMoveDest);
MoveStatus = CreateDirectory(szMoveDest, NULL); /* we use default security settings */
if (MoveStatus)
{
_tcscat(szMoveDest,_T("\\"));
_tcscat(szMoveSrc,_T("\\"));
nDirLevel = 0;
pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
_tcscpy(pszSrcDirPointer,_T("*.*"));
hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
if (hDestFile == INVALID_HANDLE_VALUE)
MoveStatus = FALSE;
else
{
BOOL FirstTime = TRUE;
FoundFile = TRUE;
MoveStatus = FALSE;
while(FoundFile)
{
if (FirstTime)
FirstTime = FALSE;
else
FoundFile = FindNextFile (hDestFile, &findDestBuffer);
if (!FoundFile)
{ /* Nothing to do in this folder so we stop working on it */
FindClose(hDestFile);
(pszSrcDirPointer)--;
(pszDestDirPointer)--;
_tcscpy(pszSrcDirPointer,_T(""));
_tcscpy(pszDestDirPointer,_T(""));
if (nDirLevel > 0)
{
TCHAR szTempPath[MAX_PATH];
INT nDiff;
FoundFile = TRUE; /* we need to continue our seek for files */
nDirLevel--;
RemoveDirectory(szMoveSrc);
GetDirectory(szMoveSrc,szTempPath,0);
nDiff = _tcslen(szMoveSrc) - _tcslen(szTempPath);
pszSrcDirPointer = pszSrcDirPointer - nDiff;
_tcscpy(pszSrcDirPointer,_T(""));
GetDirectory(szMoveDest,szTempPath,0);
nDiff = _tcslen(szMoveDest) - _tcslen(szTempPath);
pszDestDirPointer = pszDestDirPointer - nDiff;
_tcscpy(pszDestDirPointer,_T(""));
if(szMoveSrc[_tcslen(szMoveSrc) - 1] != _T('\\'))
_tcscat (szMoveSrc, _T("\\"));
if(szMoveDest[_tcslen(szMoveDest) - 1] != _T('\\'))
_tcscat (szMoveDest, _T("\\"));
pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
_tcscpy(pszSrcDirPointer,_T("*.*"));
hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
if (hDestFile == INVALID_HANDLE_VALUE)
continue;
FirstTime = TRUE;
}
else
{
MoveStatus = TRUE; /* we moved everything so lets tell user about it */
RemoveDirectory(szMoveSrc);
}
continue;
}
/* if we find "." or ".." we'll skip them */
if (_tcscmp(findDestBuffer.cFileName,_T(".")) == 0 ||
_tcscmp(findDestBuffer.cFileName,_T("..")) == 0)
continue;
_tcscpy(pszSrcDirPointer, findDestBuffer.cFileName);
_tcscpy(pszDestDirPointer, findDestBuffer.cFileName);
if (IsExistingFile(szMoveSrc))
{
FoundFile = CopyFile(szMoveSrc, szMoveDest, FALSE);
if (!FoundFile) continue;
DeleteFile(szMoveSrc);
}
else
{
FindClose(hDestFile);
CreateDirectory(szMoveDest, NULL);
_tcscat(szMoveDest,_T("\\"));
_tcscat(szMoveSrc,_T("\\"));
nDirLevel++;
pszDestDirPointer = szMoveDest + _tcslen(szMoveDest);
pszSrcDirPointer = szMoveSrc + _tcslen(szMoveSrc);
_tcscpy(pszSrcDirPointer,_T("*.*"));
hDestFile = FindFirstFile(szMoveSrc, &findDestBuffer);
if (hDestFile == INVALID_HANDLE_VALUE)
{
FoundFile = FALSE;
continue;
}
FirstTime = TRUE;
}
}
}
}
}
if (MoveStatus)
ConOutResPrintf(STRING_MOVE_ERROR1);
else
ConOutResPrintf(STRING_MOVE_ERROR2);
}
while ((!OnlyOneFile || dwMoveStatusFlags & MOVE_SRC_CURRENT_IS_DIR ) &&
!(dwMoveStatusFlags & MOVE_SOURCE_IS_DIR) &&
FindNextFile (hFile, &findBuffer));
FindClose (hFile);
freep (arg);
return 0;
}
INT CommandDelete (LPTSTR param)
{
/*cmd is the command that was given, in this case it will always be "del" or "delete"
param is whatever is given after the command*/
LPTSTR *arg = NULL;
INT args;
INT i;
INT nEvalArgs = 0; /* nunber of evaluated arguments */
DWORD dwFlags = 0;
DWORD dwAttrFlags = 0;
DWORD dwFiles = 0;
LONG ch;
TCHAR szOrginalArg[MAX_PATH];
/*checks the first two chars of param to see if it is /?
this however allows the following command to not show help
"del frog.txt /?" */
if (!StringsLoaded)
{
LoadStrings();
}
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutResPaging(TRUE,STRING_DEL_HELP1);
return 0;
}
nErrorLevel = 0;
arg = split (param, &args, FALSE);
if (args == 0)
{
/* only command given */
error_req_param_missing ();
freep (arg);
return 1;
}
/* check for options anywhere in command line */
for (i = 0; i < args; i++)
{
if (*arg[i] == _T('/'))
{
/*found a command, but check to make sure it has something after it*/
if (_tcslen (arg[i]) >= 2)
{
ch = _totupper (arg[i][1]);
if (ch == _T('N'))
{
dwFlags |= DEL_NOTHING;
}
else if (ch == _T('P'))
{
dwFlags |= DEL_PROMPT;
}
else if (ch == _T('Q'))
{
dwFlags |= DEL_QUIET;
}
else if (ch == _T('F'))
{
dwFlags |= DEL_FORCE;
}
else if (ch == _T('S'))
{
dwFlags |= DEL_SUBDIR;
}
else if (ch == _T('T'))
{
dwFlags |= DEL_TOTAL;
}
else if (ch == _T('W'))
{
dwFlags |= DEL_WIPE;
}
else if (ch == _T('Y'))
{
dwFlags |= DEL_YES;
}
else if (ch == _T('A'))
{
dwFlags |= DEL_ATTRIBUTES;
/*the proper syntax for /A has a min of 4 chars
i.e. /A:R or /A:-H */
if (_tcslen (arg[i]) < 4)
{
error_invalid_parameter_format(arg[i]);
return 0;
}
ch = _totupper (arg[i][3]);
if (_tcslen (arg[i]) == 4)
{
if(ch == _T('A'))
{
dwAttrFlags |= ATTR_ARCHIVE;
}
if(ch == _T('H'))
{
dwAttrFlags |= ATTR_HIDDEN;
}
if(ch == _T('S'))
{
dwAttrFlags |= ATTR_SYSTEM;
}
if(ch == _T('R'))
{
dwAttrFlags |= ATTR_READ_ONLY;
}
}
if (_tcslen (arg[i]) == 5)
{
if(ch == _T('-'))
{
ch = _totupper (arg[i][4]);
if(ch == _T('A'))
{
dwAttrFlags |= ATTR_N_ARCHIVE;
}
if(ch == _T('H'))
{
dwAttrFlags |= ATTR_N_HIDDEN;
}
if(ch == _T('S'))
{
dwAttrFlags |= ATTR_N_SYSTEM;
}
if(ch == _T('R'))
{
dwAttrFlags |= ATTR_N_READ_ONLY;
}
}
}
}
}
nEvalArgs++;
}
}
/* there are only options on the command line --> error!!!
there is the same number of args as there is flags, so none of the args were filenames*/
if (args == nEvalArgs)
{
error_req_param_missing ();
freep (arg);
return 1;
}
/* keep quiet within batch files */
if (bc != NULL)
dwFlags |= DEL_QUIET;
/* check for filenames anywhere in command line */
for (i = 0; i < args && !(dwFiles & 0x80000000); i++)
{
/*this checks to see if it isnt a flag, if it isnt, we assume it is a file name*/
if((*arg[i] == _T('/')) || (*arg[i] == _T('-')))
continue;
/* We want to make a copies of the argument */
if(_tcslen(arg[i]) == 2 && arg[i][1] == _T(':'))
{
/* Check for C: D: ... */
GetRootPath(arg[i],szOrginalArg,MAX_PATH);
}
else
{
_tcscpy(szOrginalArg,arg[i]);
}
dwFiles += ProcessDirectory(szOrginalArg, &dwFlags, dwAttrFlags);
}
freep (arg);
/*Based on MS cmd, we only tell what files are being deleted when /S is used */
if (dwFlags & DEL_TOTAL)
{
dwFiles &= 0x7fffffff;
if (dwFiles < 2)
{
ConOutResPrintf(STRING_DEL_HELP3, dwFiles);
}
else
{
ConOutResPrintf(STRING_DEL_HELP4, dwFiles);
}
}
return 0;
}
/* Print the current OS version, suitable for VER command and PROMPT $V format */
VOID PrintOSVersion(VOID)
{
ConOutResPrintf(STRING_VERSION_RUNVER, szOSName,
osvi.dwMajorVersion, osvi.dwMinorVersion,
osvi.dwBuildNumber, osvi.szCSDVersion);
}
