You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1175 lines
31 KiB
1175 lines
31 KiB
/*++
|
|
|
|
Copyright (c) 1988-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
del.c
|
|
|
|
Abstract:
|
|
|
|
Process the DEL/ERASE command
|
|
|
|
--*/
|
|
|
|
#include "cmd.h"
|
|
|
|
#define Wild(spec) ((spec)->flags & (CI_NAMEWILD))
|
|
|
|
VOID ResetCtrlC();
|
|
|
|
extern unsigned msglen;
|
|
|
|
extern TCHAR Fmt11[], Fmt19[], Fmt17[];
|
|
extern TCHAR CurDrvDir[] ;
|
|
|
|
extern TCHAR SwitChar;
|
|
extern unsigned DosErr ;
|
|
extern BOOL CtrlCSeen;
|
|
extern ULONG DCount ;
|
|
|
|
|
|
STATUS DelPatterns (PDRP );
|
|
|
|
PTCHAR GetWildPattern( ULONG, PPATDSC );
|
|
|
|
STATUS
|
|
ParseRmDirParms (
|
|
IN PTCHAR pszCmdLine,
|
|
OUT PDRP pdrp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Parse the command line translating the tokens into values
|
|
placed in the parameter structure. The values are or'd into
|
|
the parameter structure since this routine is called repeatedly
|
|
to build up values (once for the environment variable DIRCMD
|
|
and once for the actual command line).
|
|
|
|
Arguments:
|
|
|
|
pszCmdLine - pointer to command line user typed
|
|
|
|
|
|
Return Value:
|
|
|
|
pdrp - parameter data structure
|
|
|
|
Return: TRUE - if valid command line.
|
|
FALSE - if not.
|
|
|
|
--*/
|
|
{
|
|
|
|
PTCHAR pszTok;
|
|
|
|
TCHAR szT[10] ;
|
|
USHORT irgchTok;
|
|
BOOLEAN fToggle;
|
|
PPATDSC ppatdscCur;
|
|
int tlen;
|
|
|
|
//
|
|
// Tokensize the command line (special delimeters are tokens)
|
|
//
|
|
szT[0] = SwitChar ;
|
|
szT[1] = NULLC ;
|
|
pszTok = TokStr(pszCmdLine, szT, TS_SDTOKENS) ;
|
|
|
|
ppatdscCur = &(pdrp->patdscFirst);
|
|
//
|
|
// If there was a pattern put in place from the environment.
|
|
// just add any new patterns on. So move to the end of the
|
|
// current list.
|
|
//
|
|
if (pdrp->cpatdsc) {
|
|
|
|
while (ppatdscCur->ppatdscNext) {
|
|
|
|
ppatdscCur = ppatdscCur->ppatdscNext;
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// At this state pszTok will be a series of zero terminated strings.
|
|
// "/o foo" wil be /0o0foo0
|
|
//
|
|
for ( irgchTok = 0; *pszTok ; pszTok += tlen+1, irgchTok = 0) {
|
|
tlen = mystrlen(pszTok);
|
|
|
|
DEBUG((ICGRP, DILVL, "PRIVSW: pszTok = %ws", pszTok)) ;
|
|
|
|
//
|
|
// fToggle control wither to turn off a switch that was set
|
|
// in the DIRCMD environment variable.
|
|
//
|
|
fToggle = FALSE;
|
|
if (pszTok[irgchTok] == (TCHAR)SwitChar) {
|
|
|
|
if (pszTok[irgchTok + 2] == MINUS) {
|
|
|
|
//
|
|
// disable the previously enabled the switch
|
|
//
|
|
fToggle = TRUE;
|
|
irgchTok++;
|
|
}
|
|
|
|
switch (_totupper(pszTok[irgchTok + 2])) {
|
|
case QUIETCH:
|
|
|
|
fToggle ? (pdrp->rgfSwitches ^= QUIETSWITCH) : (pdrp->rgfSwitches |= QUIETSWITCH);
|
|
if (pszTok[irgchTok + 3]) {
|
|
PutStdErr(MSG_PARAMETER_FORMAT_NOT_CORRECT, ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
return( FAILURE );
|
|
}
|
|
break;
|
|
|
|
case TEXT('S'):
|
|
|
|
fToggle ? (pdrp->rgfSwitches ^= RECURSESWITCH) : (pdrp->rgfSwitches |= RECURSESWITCH);
|
|
if (pszTok[irgchTok + 3]) {
|
|
PutStdErr(MSG_PARAMETER_FORMAT_NOT_CORRECT, ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
return( FAILURE );
|
|
}
|
|
break;
|
|
|
|
case QMARK:
|
|
|
|
BeginHelpPause();
|
|
PutStdOut(MSG_HELP_DIR, NOARGS);
|
|
EndHelpPause();
|
|
return( FAILURE );
|
|
break;
|
|
|
|
|
|
default:
|
|
|
|
szT[0] = SwitChar;
|
|
szT[1] = pszTok[2];
|
|
szT[2] = NULLC;
|
|
PutStdErr(MSG_INVALID_SWITCH,
|
|
ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
|
|
return( FAILURE );
|
|
|
|
} // switch
|
|
|
|
//
|
|
// TokStr parses /N as /0N0 so we need to move over the
|
|
// switchar in or to move past the actual switch value
|
|
// in for loop.
|
|
//
|
|
pszTok += 2;
|
|
|
|
} else {
|
|
|
|
mystrcpy( pszTok, StripQuotes( pszTok ) );
|
|
|
|
//
|
|
// If there already is a list the extend it else put info
|
|
// directly into structure.
|
|
//
|
|
if (pdrp->cpatdsc) {
|
|
|
|
ppatdscCur->ppatdscNext = (PPATDSC)gmkstr(sizeof(PATDSC));
|
|
ppatdscCur = ppatdscCur->ppatdscNext;
|
|
ppatdscCur->ppatdscNext = NULL;
|
|
|
|
}
|
|
|
|
pdrp->cpatdsc++;
|
|
ppatdscCur->pszPattern = (PTCHAR)gmkstr(_tcslen(pszTok)*sizeof(TCHAR) + sizeof(TCHAR));
|
|
mystrcpy(ppatdscCur->pszPattern, pszTok);
|
|
ppatdscCur->fIsFat = TRUE;
|
|
|
|
|
|
}
|
|
|
|
|
|
} // for
|
|
|
|
return( SUCCESS );
|
|
}
|
|
|
|
STATUS
|
|
ParseDelParms (
|
|
IN PTCHAR pszCmdLine,
|
|
OUT PDRP pdrp
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Parse the command line translating the tokens into values
|
|
placed in the parameter structure. The values are or'd into
|
|
the parameter structure since this routine is called repeatedly
|
|
to build up values (once for the environment variable DIRCMD
|
|
and once for the actual command line).
|
|
|
|
Arguments:
|
|
|
|
pszCmdLine - pointer to command line user typed
|
|
|
|
|
|
Return Value:
|
|
|
|
pdrp - parameter data structure
|
|
|
|
Return: TRUE - if valid command line.
|
|
FALSE - if not.
|
|
|
|
--*/
|
|
{
|
|
|
|
PTCHAR pszTok;
|
|
|
|
TCHAR szT[10] ;
|
|
USHORT irgchTok;
|
|
BOOLEAN fToggle;
|
|
PPATDSC ppatdscCur;
|
|
|
|
//
|
|
// Tokensize the command line (special delimeters are tokens)
|
|
//
|
|
szT[0] = SwitChar ;
|
|
szT[1] = NULLC ;
|
|
pszTok = TokStr(pszCmdLine, szT, TS_SDTOKENS) ;
|
|
|
|
ppatdscCur = &(pdrp->patdscFirst);
|
|
//
|
|
// If there was a pattern put in place from the environment.
|
|
// just add any new patterns on. So move to the end of the
|
|
// current list.
|
|
//
|
|
if (pdrp->cpatdsc) {
|
|
|
|
while (ppatdscCur->ppatdscNext) {
|
|
|
|
ppatdscCur = ppatdscCur->ppatdscNext;
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// At this state pszTok will be a series of zero terminated strings.
|
|
// "/o foo" wil be /0o0foo0
|
|
//
|
|
for ( irgchTok = 0; *pszTok ; pszTok += mystrlen(pszTok)+1, irgchTok = 0) {
|
|
|
|
DEBUG((ICGRP, DILVL, "PRIVSW: pszTok = %ws", (ULONG_PTR)pszTok)) ;
|
|
|
|
//
|
|
// fToggle control wither to turn off a switch that was set
|
|
// in the DIRCMD environment variable.
|
|
//
|
|
fToggle = FALSE;
|
|
if (pszTok[irgchTok] == (TCHAR)SwitChar) {
|
|
|
|
if (pszTok[irgchTok + 2] == MINUS) {
|
|
|
|
//
|
|
// disable the previously enabled the switch
|
|
//
|
|
fToggle = TRUE;
|
|
irgchTok++;
|
|
}
|
|
|
|
switch (_totupper(pszTok[irgchTok + 2])) {
|
|
|
|
|
|
case TEXT('P'):
|
|
|
|
fToggle ? (pdrp->rgfSwitches ^= PROMPTUSERSWITCH) : (pdrp->rgfSwitches |= PROMPTUSERSWITCH);
|
|
if (pszTok[irgchTok + 3]) {
|
|
PutStdErr(MSG_PARAMETER_FORMAT_NOT_CORRECT, ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
return( FAILURE );
|
|
}
|
|
break;
|
|
|
|
|
|
case TEXT('S'):
|
|
|
|
fToggle ? (pdrp->rgfSwitches ^= RECURSESWITCH) : (pdrp->rgfSwitches |= RECURSESWITCH);
|
|
if (pszTok[irgchTok + 3]) {
|
|
PutStdErr(MSG_PARAMETER_FORMAT_NOT_CORRECT, ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
return( FAILURE );
|
|
}
|
|
break;
|
|
|
|
case TEXT('F'):
|
|
|
|
fToggle ? (pdrp->rgfSwitches ^= FORCEDELSWITCH) : (pdrp->rgfSwitches |= FORCEDELSWITCH);
|
|
if (pszTok[irgchTok + 3]) {
|
|
PutStdErr(MSG_PARAMETER_FORMAT_NOT_CORRECT, ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
return( FAILURE );
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
case QMARK:
|
|
|
|
BeginHelpPause();
|
|
PutStdOut(MSG_HELP_DEL_ERASE, NOARGS);
|
|
EndHelpPause();
|
|
return( FAILURE );
|
|
break;
|
|
|
|
case QUIETCH:
|
|
|
|
fToggle ? (pdrp->rgfSwitches ^= QUIETSWITCH) : (pdrp->rgfSwitches |= QUIETSWITCH);
|
|
if (pszTok[irgchTok + 3]) {
|
|
PutStdErr(MSG_PARAMETER_FORMAT_NOT_CORRECT, ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
return( FAILURE );
|
|
}
|
|
break;
|
|
|
|
case TEXT('A'):
|
|
|
|
if (fToggle) {
|
|
if ( _tcslen( &(pszTok[irgchTok + 2]) ) > 1) {
|
|
PutStdErr(MSG_PARAMETER_FORMAT_NOT_CORRECT, ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
return( FAILURE );
|
|
}
|
|
pdrp->rgfAttribs = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
|
|
pdrp->rgfAttribsOnOff = 0;
|
|
break;
|
|
}
|
|
|
|
if (SetAttribs(&(pszTok[irgchTok + 3]), pdrp) ) {
|
|
return( FAILURE );
|
|
}
|
|
|
|
if (pdrp->rgfAttribsOnOff & FILE_ATTRIBUTE_READONLY) {
|
|
pdrp->rgfSwitches |= FORCEDELSWITCH;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
szT[0] = SwitChar;
|
|
szT[1] = pszTok[2];
|
|
szT[2] = NULLC;
|
|
PutStdErr(MSG_INVALID_SWITCH,
|
|
ONEARG,
|
|
(UINT_PTR)(&(pszTok[irgchTok + 2])) );
|
|
|
|
return( FAILURE );
|
|
|
|
} // switch
|
|
|
|
//
|
|
// TokStr parses /N as /0N0 so we need to move over the
|
|
// switchar in or to move past the actual switch value
|
|
// in for loop.
|
|
//
|
|
pszTok += 2;
|
|
|
|
} else {
|
|
|
|
//
|
|
// If there already is a list then extend it else put info
|
|
// directly into structure.
|
|
//
|
|
if (pdrp->cpatdsc) {
|
|
|
|
ppatdscCur->ppatdscNext = (PPATDSC)gmkstr(sizeof(PATDSC));
|
|
ppatdscCur = ppatdscCur->ppatdscNext;
|
|
ppatdscCur->ppatdscNext = NULL;
|
|
|
|
}
|
|
|
|
pdrp->cpatdsc++;
|
|
ppatdscCur->pszPattern = (PTCHAR)gmkstr(_tcslen(pszTok)*sizeof(TCHAR) + sizeof(TCHAR));
|
|
mystrcpy(ppatdscCur->pszPattern, StripQuotes(pszTok));
|
|
ppatdscCur->fIsFat = TRUE;
|
|
}
|
|
|
|
|
|
} // for
|
|
|
|
return( SUCCESS );
|
|
}
|
|
|
|
int
|
|
DelWork (
|
|
TCHAR *pszCmdLine
|
|
) {
|
|
|
|
//
|
|
// drp - structure holding current set of parameters. It is initialized
|
|
// in ParseDelParms function. It is also modified later when
|
|
// parameters are examined to determine if some turn others on.
|
|
//
|
|
DRP drpCur = {0, 0, 0, 0,
|
|
{{0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}},
|
|
0, 0, NULL, 0, 0, 0, 0} ;
|
|
|
|
//
|
|
// szCurDrv - Hold current drive letter
|
|
//
|
|
TCHAR szCurDrv[MAX_PATH + 2];
|
|
|
|
//
|
|
// OldDCount - Holds the level number of the heap. It is used to
|
|
// free entries off the stack that might not have been
|
|
// freed due to error processing (ctrl-c etc.)
|
|
ULONG OldDCount;
|
|
|
|
STATUS rc;
|
|
|
|
OldDCount = DCount;
|
|
|
|
//
|
|
// Setup defaults
|
|
//
|
|
//
|
|
// Display everything but system and hidden files
|
|
// rgfAttribs set the attribute bits to that are of interest and
|
|
// rgfAttribsOnOff says wither the attributs should be present
|
|
// or not (i.e. On or Off)
|
|
//
|
|
drpCur.rgfAttribs = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
|
|
drpCur.rgfAttribsOnOff = 0;
|
|
|
|
//
|
|
// Number of patterns present. A pattern is a string that may have
|
|
// wild cards. It is used to match against files present in the directory
|
|
// 0 patterns will show all files (i.e. mapped to *.*)
|
|
//
|
|
drpCur.cpatdsc = 0;
|
|
|
|
//
|
|
// default time is LAST_WRITE_TIME.
|
|
//
|
|
drpCur.dwTimeType = LAST_WRITE_TIME;
|
|
|
|
//
|
|
//
|
|
//
|
|
if (ParseDelParms(pszCmdLine, &drpCur) == FAILURE) {
|
|
|
|
return( FAILURE );
|
|
}
|
|
|
|
//
|
|
// Must have some pattern on command line
|
|
//
|
|
//
|
|
|
|
GetDir((PTCHAR)szCurDrv, GD_DEFAULT);
|
|
if (drpCur.cpatdsc == 0) {
|
|
|
|
PutStdErr(MSG_BAD_SYNTAX, NOARGS);
|
|
return(FAILURE);
|
|
}
|
|
|
|
|
|
//
|
|
// Print out this particular pattern. If the recursion switch
|
|
// is set then this will descend down the tree.
|
|
//
|
|
|
|
drpCur.rgfSwitches |= DELPROCESSEARLY;
|
|
rc = DelPatterns( &drpCur );
|
|
|
|
mystrcpy(CurDrvDir, szCurDrv);
|
|
|
|
//
|
|
// Free unneeded memory
|
|
//
|
|
|
|
FreeStack( OldDCount );
|
|
|
|
return( (int)rc );
|
|
|
|
}
|
|
|
|
STATUS
|
|
NewEraseFile (
|
|
IN PFS CurrentFS,
|
|
IN PFF CurrentFF,
|
|
IN PSCREEN pscr,
|
|
IN PVOID Data
|
|
)
|
|
{
|
|
TCHAR szFile[MAX_PATH + 2];
|
|
STATUS rc;
|
|
PTCHAR LastComponent;
|
|
PTCHAR pszPattern;
|
|
TCHAR szFilePrompt[MAX_PATH + 2];
|
|
int incr;
|
|
|
|
PDRP pdrp = (PDRP) Data;
|
|
PWIN32_FIND_DATA pdata = &CurrentFF->data;
|
|
USHORT obAlternate = CurrentFF->obAlternate;
|
|
BOOLEAN fPrompt = FALSE;
|
|
BOOLEAN fQuiet = FALSE;
|
|
|
|
if (pdrp->rgfSwitches & PROMPTUSERSWITCH) {
|
|
fPrompt = TRUE;
|
|
}
|
|
|
|
if (pdrp->rgfSwitches & QUIETSWITCH) {
|
|
fQuiet = TRUE;
|
|
}
|
|
|
|
//
|
|
// Global delete prompt
|
|
//
|
|
|
|
if (
|
|
// Not prompting on each file
|
|
!fPrompt &&
|
|
|
|
// Global prompt not issued yet
|
|
!CurrentFS->fDelPrompted &&
|
|
|
|
// not suppressing global prompt
|
|
!fQuiet &&
|
|
|
|
// global pattern in delete
|
|
(pszPattern = GetWildPattern( CurrentFS->cpatdsc, CurrentFS->ppatdsc ))) {
|
|
|
|
//
|
|
// Form complete path for prompt
|
|
//
|
|
|
|
if (AppendPath( szFile, MAX_PATH + 2, CurrentFS->pszDir, pszPattern ) != SUCCESS) {
|
|
PutStdErr(MSG_PATH_TOO_LONG, TWOARGS, CurrentFS->pszDir, pszPattern );
|
|
return( FAILURE );
|
|
}
|
|
|
|
//
|
|
// Prompt the user and see if we can continue
|
|
//
|
|
|
|
CurrentFS->fDelPrompted = TRUE;
|
|
if (PromptUser( szFile, MSG_ARE_YOU_SURE, MSG_NOYES_RESPONSE_DATA ) != 1) {
|
|
return( FAILURE );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Directories succeed here
|
|
//
|
|
|
|
if ((pdata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
|
|
return SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Form a short name for the delete operation. This gives us the best
|
|
// chance to delete a really long path.
|
|
//
|
|
|
|
if (AppendPath( szFile, MAX_PATH + 2, CurrentFS->pszDir, pdata->cFileName + obAlternate) != SUCCESS) {
|
|
PutStdErr(MSG_PATH_TOO_LONG, TWOARGS, CurrentFS->pszDir, pdata->cFileName + obAlternate );
|
|
return( FAILURE );
|
|
}
|
|
|
|
//
|
|
// Form a long name for the prompt. If it's too long, then use the short name for prompt
|
|
//
|
|
|
|
if (AppendPath( szFilePrompt, MAX_PATH + 2, CurrentFS->pszDir, pdata->cFileName ) != SUCCESS) {
|
|
_tcscpy( szFilePrompt, szFile );
|
|
}
|
|
|
|
|
|
//
|
|
// Prompt the user for this one file
|
|
//
|
|
|
|
if (fPrompt && PromptUser( szFilePrompt, MSG_CMD_DELETE, MSG_NOYES_RESPONSE_DATA ) != 1) {
|
|
if (CtrlCSeen) {
|
|
return( FAILURE );
|
|
}
|
|
return( SUCCESS );
|
|
}
|
|
|
|
//
|
|
// If we are forcibly deleteing everything and this is a read-only file
|
|
// then turn off R/O.
|
|
//
|
|
|
|
if ((pdrp->rgfSwitches & FORCEDELSWITCH) != 0 &&
|
|
pdata->dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
|
|
|
|
if (!SetFileAttributes( szFile, pdata->dwFileAttributes & ~FILE_ATTRIBUTE_READONLY )) {
|
|
PutStdErr( GetLastError(), NOARGS );
|
|
return( FAILURE );
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Delete the file. Display error if we got a failure
|
|
//
|
|
|
|
if (!DeleteFile( szFile )) {
|
|
rc = GetLastError( );
|
|
} else {
|
|
rc = SUCCESS;
|
|
}
|
|
|
|
if (rc != SUCCESS) {
|
|
if (rc == ERROR_REQUEST_ABORTED) {
|
|
return FAILURE;
|
|
}
|
|
|
|
cmd_printf( Fmt17, szFilePrompt );
|
|
PutStdErr( rc, NOARGS );
|
|
|
|
} else {
|
|
|
|
pdrp->FileCount++;
|
|
|
|
if (fEnableExtensions && (pdrp->rgfSwitches & RECURSESWITCH)) {
|
|
PutStdOut(MSG_FILE_DELETED, ONEARG, szFilePrompt);
|
|
}
|
|
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
|
|
STATUS
|
|
DelPatterns (
|
|
IN PDRP pdpr
|
|
)
|
|
{
|
|
|
|
PPATDSC ppatdscCur;
|
|
PPATDSC ppatdscX;
|
|
PFS pfsFirst;
|
|
PFS pfsCur;
|
|
ULONG i;
|
|
STATUS rc;
|
|
ULONG cffTotal = 0;
|
|
TCHAR szSearchPath[MAX_PATH+2];
|
|
|
|
DosErr = 0;
|
|
if (BuildFSFromPatterns(pdpr, TRUE, FALSE, &pfsFirst ) == FAILURE) {
|
|
|
|
return( FAILURE );
|
|
|
|
}
|
|
|
|
for( pfsCur = pfsFirst; pfsCur; pfsCur = pfsCur->pfsNext) {
|
|
|
|
rc = WalkTree( pfsCur,
|
|
NULL,
|
|
pdpr->rgfAttribs,
|
|
pdpr->rgfAttribsOnOff,
|
|
(BOOLEAN)(pdpr->rgfSwitches & RECURSESWITCH),
|
|
|
|
pdpr,
|
|
NULL, // Error
|
|
NULL, // Pre
|
|
NewEraseFile, // Scan
|
|
NULL ); // Post
|
|
|
|
//
|
|
// If we had a general failure, just return
|
|
//
|
|
|
|
if (rc == FAILURE) {
|
|
return rc;
|
|
}
|
|
|
|
//
|
|
// If we had a failure that we don't understand, print the error and
|
|
// exit
|
|
//
|
|
|
|
if (rc != SUCCESS && rc != ERROR_FILE_NOT_FOUND) {
|
|
PutStdErr( rc, NOARGS );
|
|
return rc;
|
|
}
|
|
|
|
//
|
|
// If we got FILE_NOT_FOUND then build the full name and
|
|
// display the file not-found message
|
|
//
|
|
|
|
if (rc == ERROR_FILE_NOT_FOUND) {
|
|
rc = AppendPath( szSearchPath,
|
|
sizeof( szSearchPath ) / sizeof( TCHAR ),
|
|
pfsCur->pszDir,
|
|
pfsCur->ppatdsc->pszPattern );
|
|
if (rc == SUCCESS) {
|
|
PutStdErr( MSG_NOT_FOUND, ONEARG, szSearchPath );
|
|
}
|
|
|
|
//
|
|
// We leave the status code alone here. If we succeeded in
|
|
// generating the message, then the del command "succeeded"
|
|
// in that the named file is not there.
|
|
//
|
|
}
|
|
|
|
//
|
|
// Have walked down and back up the tree, but in the case of
|
|
// deleting directories we have not deleted the top most directory
|
|
// do so now.
|
|
//
|
|
|
|
FreeStr(pfsCur->pszDir);
|
|
for(i = 1, ppatdscCur = pfsCur->ppatdsc;
|
|
i <= pfsCur->cpatdsc;
|
|
i++, ppatdscCur = ppatdscX) {
|
|
|
|
ppatdscX = ppatdscCur->ppatdscNext;
|
|
FreeStr(ppatdscCur->pszPattern);
|
|
FreeStr(ppatdscCur->pszDir);
|
|
FreeStr((PTCHAR)ppatdscCur);
|
|
}
|
|
}
|
|
|
|
return(rc);
|
|
}
|
|
|
|
STATUS
|
|
RemoveDirectoryForce(
|
|
PTCHAR pszDirectory
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes a directory, even if it is read-only.
|
|
|
|
Arguments:
|
|
|
|
pszDirectory - Supplies the name of the directory to delete.
|
|
|
|
Return Value:
|
|
|
|
SUCCESS - Success.
|
|
other - Windows error code.
|
|
|
|
--*/
|
|
{
|
|
STATUS Status = SUCCESS;
|
|
BOOL Ok;
|
|
DWORD Attr;
|
|
TCHAR szRootPath[ 4 ];
|
|
TCHAR *pFilePart;
|
|
|
|
if (GetFullPathName(pszDirectory, 4, szRootPath, &pFilePart) == 3 &&
|
|
szRootPath[1] == COLON &&
|
|
szRootPath[2] == BSLASH
|
|
) {
|
|
//
|
|
// Don't waste time trying to delete the root directory.
|
|
//
|
|
return SUCCESS;
|
|
}
|
|
|
|
if ( !RemoveDirectory( pszDirectory ) ) {
|
|
|
|
Status = (STATUS)GetLastError();
|
|
|
|
if ( Status == ERROR_ACCESS_DENIED ) {
|
|
|
|
Attr = GetFileAttributes( pszDirectory );
|
|
|
|
if ( Attr != 0xFFFFFFFF &&
|
|
Attr & FILE_ATTRIBUTE_READONLY ) {
|
|
|
|
Attr &= ~FILE_ATTRIBUTE_READONLY;
|
|
|
|
if ( SetFileAttributes( pszDirectory, Attr ) ) {
|
|
|
|
if ( RemoveDirectory( pszDirectory ) ) {
|
|
Status = SUCCESS;
|
|
} else {
|
|
Status = GetLastError();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
STATUS
|
|
RmDirSlashS(
|
|
IN PTCHAR pszDirectory,
|
|
OUT PBOOL AllEntriesDeleted
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine deletes the given directory including all
|
|
of its files and subdirectories.
|
|
|
|
Arguments:
|
|
|
|
pszDirectory - Supplies the name of the directory to delete.
|
|
AllEntriesDeleted - Returns whether or not all files were deleted.
|
|
|
|
Return Value:
|
|
|
|
SUCCESS - Success.
|
|
other - Windows error code.
|
|
|
|
--*/
|
|
{
|
|
HANDLE find_handle;
|
|
DWORD attr;
|
|
STATUS s;
|
|
BOOL all_deleted;
|
|
int dir_len, new_len;
|
|
TCHAR *new_str;
|
|
WIN32_FIND_DATA find_data;
|
|
TCHAR pszFileBuffer[MAX_PATH];
|
|
|
|
*AllEntriesDeleted = TRUE;
|
|
|
|
dir_len = _tcslen(pszDirectory);
|
|
|
|
if (dir_len == 0) {
|
|
return ERROR_BAD_PATHNAME;
|
|
}
|
|
|
|
//
|
|
// If this path is so long that we can't append \* to it then
|
|
// it can't have any subdirectories.
|
|
//
|
|
|
|
if (dir_len + 3 > MAX_PATH) {
|
|
return RemoveDirectoryForce(pszDirectory);
|
|
}
|
|
|
|
|
|
// Compute the findfirst pattern for enumerating the files
|
|
// in the given directory.
|
|
|
|
_tcscpy(pszFileBuffer, pszDirectory);
|
|
if (dir_len && pszDirectory[dir_len - 1] != COLON &&
|
|
pszDirectory[dir_len - 1] != BSLASH) {
|
|
|
|
_tcscat(pszFileBuffer, TEXT("\\"));
|
|
dir_len++;
|
|
}
|
|
_tcscat(pszFileBuffer, TEXT("*"));
|
|
|
|
|
|
// Initiate findfirst loop.
|
|
|
|
find_handle = FindFirstFile(pszFileBuffer, &find_data);
|
|
if (find_handle == INVALID_HANDLE_VALUE) {
|
|
return RemoveDirectoryForce(pszDirectory);
|
|
}
|
|
|
|
do {
|
|
|
|
// Check for control-C.
|
|
|
|
if (CtrlCSeen) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Replace previous file name with new one, checking against MAX_PATH
|
|
// Using the short name where possible lets us go deeper before we hit
|
|
// the MAX_PATH limit.
|
|
//
|
|
new_len = _tcslen(new_str = find_data.cAlternateFileName);
|
|
if (!new_len)
|
|
new_len = _tcslen(new_str = find_data.cFileName);
|
|
|
|
if (dir_len + new_len >= MAX_PATH) {
|
|
*AllEntriesDeleted = FALSE;
|
|
PutStdErr( MSG_PATH_TOO_LONG, 2, pszDirectory, new_str );
|
|
break;
|
|
}
|
|
_tcscpy(&pszFileBuffer[dir_len], new_str);
|
|
|
|
attr = find_data.dwFileAttributes;
|
|
|
|
//
|
|
// If the entry is a directory and not a reparse directory descend into it
|
|
//
|
|
|
|
if (IsDirectory( attr ) && !IsReparse( attr )) {
|
|
|
|
if (!_tcscmp(find_data.cFileName, TEXT(".")) ||
|
|
!_tcscmp(find_data.cFileName, TEXT(".."))) {
|
|
continue;
|
|
}
|
|
|
|
s = RmDirSlashS(pszFileBuffer, &all_deleted);
|
|
|
|
// Don't report error if control-C
|
|
|
|
if (CtrlCSeen) {
|
|
break;
|
|
}
|
|
|
|
if (s != ESUCCESS) {
|
|
*AllEntriesDeleted = FALSE;
|
|
if (s != ERROR_DIR_NOT_EMPTY || all_deleted) {
|
|
PutStdErr(MSG_FILE_NAME_PRECEEDING_ERROR, 1, pszFileBuffer);
|
|
PutStdErr(GetLastError(), NOARGS);
|
|
}
|
|
}
|
|
} else {
|
|
|
|
if (attr&FILE_ATTRIBUTE_READONLY) {
|
|
SetFileAttributes(pszFileBuffer,
|
|
attr&(~FILE_ATTRIBUTE_READONLY));
|
|
}
|
|
|
|
//
|
|
// Two ways of removal:
|
|
// if reparse and dir call RemoveDirectoryForce
|
|
// else call DeleteFile
|
|
//
|
|
// If either call fails
|
|
//
|
|
|
|
|
|
if ( (IsDirectory( attr ) && IsReparse( attr ) && RemoveDirectoryForce( pszFileBuffer ) != SUCCESS) ||
|
|
(!IsDirectory( attr ) && !DeleteFile( pszFileBuffer ))) {
|
|
|
|
s = GetLastError();
|
|
if ( s == ERROR_REQUEST_ABORTED )
|
|
break;
|
|
|
|
//
|
|
// Win32 always reports file names that are too long as
|
|
// ERROR_PATH_NOT_FOUND. So, when we get this error back,
|
|
// we test to see if the path was too long
|
|
// and attempt to map the error.
|
|
//
|
|
|
|
if (s == ERROR_PATH_NOT_FOUND && _tcsnicmp( pszFileBuffer, TEXT( "\\\\?\\"), 4) ) {
|
|
int Length = GetFullPathName( pszFileBuffer, 0, NULL, NULL );
|
|
|
|
if (Length > MAX_PATH) {
|
|
SetLastError( ERROR_BUFFER_OVERFLOW );
|
|
}
|
|
}
|
|
|
|
|
|
if (_tcslen(find_data.cAlternateFileName)) {
|
|
pszFileBuffer[dir_len] = 0;
|
|
|
|
if (dir_len + _tcslen(find_data.cFileName) >= MAX_PATH) {
|
|
_tcscat(pszFileBuffer, find_data.cAlternateFileName);
|
|
PutStdErr(MSG_FILE_NAME_PRECEEDING_ERROR, 1, pszFileBuffer);
|
|
}
|
|
else {
|
|
_tcscat(pszFileBuffer, find_data.cFileName);
|
|
PutStdErr(MSG_FILE_NAME_PRECEEDING_ERROR, 1, pszFileBuffer);
|
|
pszFileBuffer[dir_len] = 0;
|
|
_tcscat(pszFileBuffer, find_data.cAlternateFileName);
|
|
}
|
|
} else {
|
|
PutStdErr(MSG_FILE_NAME_PRECEEDING_ERROR, 1, pszFileBuffer);
|
|
}
|
|
PutStdErr(GetLastError(), NOARGS);
|
|
SetFileAttributes(pszFileBuffer, attr);
|
|
*AllEntriesDeleted = FALSE;
|
|
}
|
|
}
|
|
} while (FindNextFile( find_handle, &find_data ));
|
|
|
|
FindClose(find_handle);
|
|
|
|
// If control-C was hit then don't bother trying to remove the
|
|
// directory.
|
|
|
|
if (CtrlCSeen) {
|
|
return SUCCESS;
|
|
}
|
|
|
|
return RemoveDirectoryForce(pszDirectory);
|
|
}
|
|
|
|
|
|
int
|
|
RdWork (
|
|
TCHAR *pszCmdLine
|
|
) {
|
|
|
|
//
|
|
// drp - structure holding current set of parameters. It is initialized
|
|
// in ParseDelParms function. It is also modified later when
|
|
// parameters are examined to determine if some turn others on.
|
|
//
|
|
DRP drpCur = {0, 0, 0, 0,
|
|
{{0,0}, {0,0}, {0,0}, {0,0}, {0,0}, {0,0}},
|
|
0, 0, NULL, 0, 0, 0, 0} ;
|
|
|
|
//
|
|
// szCurDrv - Hold current drive letter
|
|
//
|
|
TCHAR szCurDrv[MAX_PATH + 2];
|
|
|
|
//
|
|
// OldDCount - Holds the level number of the heap. It is used to
|
|
// free entries off the stack that might not have been
|
|
// freed due to error processing (ctrl-c etc.)
|
|
ULONG OldDCount;
|
|
|
|
PPATDSC ppatdscCur;
|
|
ULONG cpatdsc;
|
|
STATUS rc, s;
|
|
BOOL all_deleted;
|
|
|
|
rc = SUCCESS;
|
|
OldDCount = DCount;
|
|
|
|
//
|
|
// Setup defaults
|
|
//
|
|
//
|
|
// Display everything but system and hidden files
|
|
// rgfAttribs set the attribute bits to that are of interest and
|
|
// rgfAttribsOnOff says wither the attributs should be present
|
|
// or not (i.e. On or Off)
|
|
//
|
|
|
|
drpCur.rgfAttribs = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
|
|
drpCur.rgfAttribsOnOff = 0;
|
|
|
|
//
|
|
// Number of patterns present. A pattern is a string that may have
|
|
// wild cards. It is used to match against files present in the directory
|
|
// 0 patterns will show all files (i.e. mapped to *.*)
|
|
//
|
|
drpCur.cpatdsc = 0;
|
|
|
|
//
|
|
// default time is LAST_WRITE_TIME.
|
|
//
|
|
drpCur.dwTimeType = LAST_WRITE_TIME;
|
|
|
|
//
|
|
//
|
|
//
|
|
if (ParseRmDirParms(pszCmdLine, &drpCur) == FAILURE) {
|
|
|
|
return( FAILURE );
|
|
}
|
|
|
|
GetDir((PTCHAR)szCurDrv, GD_DEFAULT);
|
|
|
|
//
|
|
// If no patterns on the command line then syntax error out
|
|
//
|
|
|
|
if (drpCur.cpatdsc == 0) {
|
|
|
|
PutStdErr(MSG_BAD_SYNTAX, NOARGS);
|
|
return( FAILURE );
|
|
|
|
}
|
|
|
|
for (ppatdscCur = &(drpCur.patdscFirst),cpatdsc = drpCur.cpatdsc;
|
|
cpatdsc;
|
|
ppatdscCur = ppatdscCur->ppatdscNext, cpatdsc--) {
|
|
|
|
if (mystrlen( ppatdscCur->pszPattern ) == 0) {
|
|
PutStdErr( MSG_BAD_SYNTAX, NOARGS );
|
|
return rc = FAILURE;
|
|
}
|
|
}
|
|
|
|
for (ppatdscCur = &(drpCur.patdscFirst),cpatdsc = drpCur.cpatdsc;
|
|
cpatdsc;
|
|
ppatdscCur = ppatdscCur->ppatdscNext, cpatdsc--) {
|
|
|
|
if (drpCur.rgfSwitches & RECURSESWITCH) {
|
|
if (!(drpCur.rgfSwitches & QUIETSWITCH) &&
|
|
PromptUser(ppatdscCur->pszPattern, MSG_ARE_YOU_SURE, MSG_NOYES_RESPONSE_DATA) != 1
|
|
) {
|
|
rc = FAILURE;
|
|
} else {
|
|
s = RmDirSlashS(ppatdscCur->pszPattern, &all_deleted);
|
|
if (s != SUCCESS && (s != ERROR_DIR_NOT_EMPTY || all_deleted)) {
|
|
PutStdErr(rc = s, NOARGS);
|
|
}
|
|
}
|
|
} else {
|
|
if (!RemoveDirectory(ppatdscCur->pszPattern)) {
|
|
PutStdErr(rc = GetLastError(), NOARGS);
|
|
}
|
|
}
|
|
}
|
|
mystrcpy(CurDrvDir, szCurDrv);
|
|
|
|
//
|
|
// Free unneeded memory
|
|
//
|
|
FreeStack( OldDCount );
|
|
|
|
#ifdef _CRTHEAP_
|
|
//
|
|
// Force the crt to release heap we may have taken on recursion
|
|
//
|
|
if (drpCur.rgfSwitches & RECURSESWITCH) {
|
|
_heapmin();
|
|
}
|
|
#endif
|
|
|
|
return( (int)rc );
|
|
|
|
}
|
|
|
|
PTCHAR
|
|
GetWildPattern(
|
|
|
|
IN ULONG cpatdsc,
|
|
IN PPATDSC ppatdsc
|
|
)
|
|
|
|
/*
|
|
|
|
return pointer to a pattern if it contains only a wild card
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
ULONG i;
|
|
PTCHAR pszT;
|
|
|
|
for(i = 1; i <= cpatdsc; i++, ppatdsc = ppatdsc->ppatdscNext) {
|
|
|
|
pszT = ppatdsc->pszPattern;
|
|
if (!_tcscmp(pszT, TEXT("*")) ||
|
|
!_tcscmp(pszT, TEXT("*.*")) ||
|
|
!_tcscmp(pszT, TEXT("????????.???")) ) {
|
|
|
|
return( pszT );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return( NULL );
|
|
|
|
}
|