/*++
Copyright (c) 1988-1999 Microsoft Corporation
Module Name:
tree.c
Abstract:
Tree walking
--*/
#include "cmd.h"
extern TCHAR CurDrvDir[] ;
extern TCHAR *SaveDir ;
extern DWORD DosErr ;
extern BOOL CtrlCSeen;
PTCHAR SetWildCards( PTCHAR, BOOLEAN );
BOOLEAN IsFATDrive( PTCHAR );
VOID SortFileList( PFS, PSORTDESC, ULONG);
BOOLEAN FindFirstNt( PTCHAR, PWIN32_FIND_DATA, PHANDLE );
BOOLEAN FindNextNt ( PWIN32_FIND_DATA, HANDLE );
STATUS
BuildFSFromPatterns (
IN PDRP pdpr,
IN BOOLEAN fPrintErrors,
IN BOOLEAN fAddWild,
OUT PFS * ppfs
)
{
PCPYINFO pcisFile;
TCHAR szCurDir[MAX_PATH + 2];
TCHAR szFilePattern[MAX_PATH + 2];
PTCHAR pszPatternCur;
PPATDSC ppatdscCur;
PFS pfsFirst;
PFS pfsCur;
ULONG cbPath;
BOOLEAN fFatDrive;
ULONG i;
PTCHAR pszT;
//
// determine FAT drive from original pattern.
// Used in several places to control name format etc.
//
DosErr = 0;
//
// Run through each pattern making all sorts of FAT etc. specific
// changes to it and creating the directory list for it. Then
// combine groups of patterns into common directories and recurse
// for each directory group.
//
*ppfs = pfsFirst = (PFS)gmkstr(sizeof(FS));
pfsFirst->pfsNext = NULL;
pfsFirst->pszDir = NULL;
pfsCur = pfsFirst;
pfsCur->cpatdsc = 1;
for(i = 1, ppatdscCur = &(pdpr->patdscFirst);
i <= pdpr->cpatdsc;
i++, ppatdscCur = ppatdscCur->ppatdscNext) {
pszPatternCur = ppatdscCur->pszPattern;
if (!(fFatDrive = IsFATDrive(pszPatternCur)) && DosErr) {
//
// Error in determining file system type so get out.
//
if (fPrintErrors) PutStdErr(DosErr, NOARGS);
return( FAILURE );
}
ppatdscCur->fIsFat = fFatDrive;
//
// Do any alterations that require wild cards for searching
// such as change .xxx to *.xxx for FAT file system requests
//
// Note that if the return values is a different buffer then
// the input the input will be freed when we are done with the
// Dir command.
//
//
// Note that though SetWildCards will allocate heap for the
// modified pattern this will get freed when FreeStack is
// called at the end of the Dir call.
//
// An out of memory is the only reason to fail and we would not
// return from that but go through the abort call in gmstr
//
if (fAddWild) {
pszT = SetWildCards(pszPatternCur, fFatDrive);
FreeStr(pszPatternCur);
pszPatternCur = pszT;
}
//
// Convert the current pattern into a path and file part
//
// Save the current directory in SaveDir, change to new directory
// and parse pattern into a copy information structure. This also
// converts pszPatternCur into the current directory which also produces
// a fully qualified name.
//
DosErr = 0;
DEBUG((ICGRP, DILVL, "PrintPattern pattern `%ws'", pszPatternCur));
if ((pcisFile = SetFsSetSaveDir(pszPatternCur)) == (PCPYINFO) FAILURE) {
//
// DosErr is set in SetFs.. from GetLastError
//
if (fPrintErrors)
PutStdErr(DosErr, NOARGS);
return( FAILURE );
}
DEBUG((ICGRP, DILVL, "PrintPattern fullname `%ws'", pcisFile->fnptr));
//
// CurDrvDir ends in '\' (old code also and a DOT but I do not
// understand where this would come from I will leave it in for now.
// Remove the final '\' from a copy of the current directory and
// print that version out.
//
mystrcpy(szCurDir,CurDrvDir);
//
// SetFsSetSaveDir changes directories as a side effect. Since all
// work will be in fully qualified paths we do not need this. Also
// since we will change directories for each pattern that is examined
// we will force the directory back to the original each time.
//
// This can not be done until after all use of the current directory
// is made.
//
RestoreSavedDirectory( );
DEBUG((ICGRP, DILVL, "PrintPattern Current Drive `%ws'", szCurDir));
cbPath = mystrlen(szCurDir);
if (cbPath > 3) {
if (fFatDrive && *penulc(szCurDir) == DOT) {
szCurDir[cbPath-2] = NULLC;
} else {
szCurDir[cbPath-1] = NULLC;
}
}
//
// If no room for filename then return
//
if (cbPath >= MAX_PATH -1) {
if (fPrintErrors) PutStdErr( ERROR_FILE_NOT_FOUND, NOARGS );
return(FAILURE);
}
//
// Add filename and possibly ext to szSearchPath
// if no filename or ext, use "*"
//
// If pattern was just extension the SetWildCard had already
// added * to front of extension.
//
if (*(pcisFile->fnptr) == NULLC) {
mystrcpy(szFilePattern, TEXT("*"));
} else {
mystrcpy(szFilePattern, pcisFile->fnptr);
}
DEBUG((ICGRP, DILVL, "DIR:PrintPattern Pattern to search for `%ws'", szFilePattern));
//
// Is name too long
//
if ((cbPath + mystrlen(szFilePattern) + 1) > MAX_PATH ) {
if (fPrintErrors) PutStdErr(ERROR_BUFFER_OVERFLOW, NOARGS);
return( FAILURE );
} else {
//
// If this is a FAT drive and there was a filename with
// no extension then add '.*' (and there is room)
//
if (*pcisFile->fnptr && (!pcisFile->extptr || !*pcisFile->extptr) &&
((mystrlen(szFilePattern) + 2) < MAX_PATH) && fFatDrive && fAddWild) {
mystrcat(szFilePattern, TEXT(".*")) ;
}
}
//
// ppatdscCur->pszPattern will be freed at end of command when everything
// else is freed.
//
ppatdscCur->pszPattern = (PTCHAR)gmkstr(_tcslen(szFilePattern)*sizeof(TCHAR) + sizeof(TCHAR));
mystrcpy(ppatdscCur->pszPattern, szFilePattern);
ppatdscCur->pszDir = (PTCHAR)gmkstr(_tcslen(szCurDir)*sizeof(TCHAR) + sizeof(TCHAR));
mystrcpy(ppatdscCur->pszDir, szCurDir);
if (pfsCur->pszDir) {
//
// changing directories so change directory grouping.
//
if (_tcsicmp(pfsCur->pszDir, ppatdscCur->pszDir)) {
pfsCur->pfsNext = (PFS)gmkstr(sizeof(FS));
pfsCur = pfsCur->pfsNext;
pfsCur->pszDir = (PTCHAR)gmkstr(_tcslen(ppatdscCur->pszDir)*sizeof(TCHAR) + sizeof(TCHAR));
mystrcpy(pfsCur->pszDir, ppatdscCur->pszDir);
pfsCur->pfsNext = NULL;
pfsCur->fIsFat = ppatdscCur->fIsFat;
pfsCur->ppatdsc = ppatdscCur;
pfsCur->cpatdsc = 1;
} else {
pfsCur->cpatdsc++;
}
} else {
//
// Have not filled in current fs descriptor yet.
//
pfsCur->pszDir = (PTCHAR)gmkstr(_tcslen(ppatdscCur->pszDir)*sizeof(TCHAR) + 2*sizeof(TCHAR));
mystrcpy(pfsCur->pszDir, ppatdscCur->pszDir);
pfsCur->fIsFat = ppatdscCur->fIsFat;
pfsCur->ppatdsc = ppatdscCur;
}
} // while for running through pattern list
return( SUCCESS );
}
STATUS
AppendPath(
OUT PTCHAR Buffer,
IN ULONG BufferCount,
IN PTCHAR Prefix,
IN PTCHAR Suffix
)
{
if (mystrlen( Prefix ) + 1 + mystrlen( Suffix ) + 1 > BufferCount) {
return(ERROR_BUFFER_OVERFLOW);
}
mystrcpy( Buffer, Prefix );
//
// Append a \ if there isn't one already at the end of the prefix
//
if (*lastc( Buffer ) != TEXT('\\')) {
mystrcat( Buffer, TEXT( "\\" ));
}
mystrcat( Buffer, Suffix );
return( SUCCESS );
}
STATUS
ExpandAndApplyToFS(
IN PFS FileSpec,
IN PSCREEN pscr,
IN ULONG AttribMask,
IN ULONG AttribValues,
IN PVOID Data OPTIONAL,
IN VOID (*ErrorFunction) (STATUS, PTCHAR, PVOID) OPTIONAL,
IN STATUS (*PreScanFunction) (PFS, PSCREEN, PVOID) OPTIONAL,
IN STATUS (*ScanFunction) (PFS, PFF, PSCREEN, PVOID) OPTIONAL,
IN STATUS (*PostScanFunction) (PFS, PSCREEN, PVOID) OPTIONAL
)
/*++
Routine Description:
Expand a given FS and apply the dispatch functions to it. The pff field is
set to point to the packed set of Win32 find records and the array of pointers
is set up as well.
Arguments:
FileSpec - FS pointer to expand.
AttribMask - mask for attributes we care about when matching
AttribValues - attributes that must match to satisfy the enumeration
Data - pointer to caller data passed to functions
ErrorFunction - routine to call on pattern matching errors
PreScanFunction - routine to call before enumeration begins
ScanFunction - routine to call during enumeration
PostScanFunction - routine to call after enumeration is complete
Return Value:
If any of the applied functions returns a non-SUCCESS status, we return that.
If no matching file is ever found then ERROR_FILE_NOT_FOUND.
Otherwise SUCCESS.
--*/
{
PFF CurrentFF; // Pointer to FF begin built
HANDLE FindHandle; // Find handle
ULONG MaxFFSize = CBFILEINC; // Current max size of FF buffer
ULONG CurrentFFSize = 0; // Bytes in use in FF
PPATDSC CurrentPattern; // Current pattern being expanded
#define SEARCHBUFFERLENGTH (MAX_PATH + 2)
TCHAR szSearchPath[SEARCHBUFFERLENGTH];
ULONG i; // loop count for patterns
PTCHAR p;
STATUS Status;
BOOL FoundAnyFile = FALSE;
DosErr = SUCCESS;
//
// Initialize the FS structure:
// Allocate default size FF array
// Indicate no files stored
//
FileSpec->pff = CurrentFF = (PFF)gmkstr( MaxFFSize );
FileSpec->cff = 0;
FileSpec->FileCount = 0;
FileSpec->DirectoryCount = 0;
FileSpec->cbFileTotal.QuadPart = 0;
for(i = 1, CurrentPattern = FileSpec->ppatdsc;
i <= FileSpec->cpatdsc;
i++, CurrentPattern = CurrentPattern->ppatdscNext ) {
//
// Check immediately if a control-c was hit before
// doing file I/O (which may take a long time on a slow link)
//
if (CtrlCSeen) {
return FAILURE;
}
//
// Build enumeration path. Handle buffer overflow.
//
if (AppendPath( szSearchPath, SEARCHBUFFERLENGTH,
FileSpec->pszDir, CurrentPattern->pszPattern) != SUCCESS) {
return ERROR_BUFFER_OVERFLOW;
}
if (PreScanFunction != 0) {
Status = PreScanFunction( FileSpec, pscr, Data );
if (Status != SUCCESS) {
return Status;
}
}
//
// Fetch all files since we may looking for a file with a attribute that
// is not set (a non-directory etc.
//
if (!FindFirstNt(szSearchPath, &(CurrentFF->data), &FindHandle)) {
if (DosErr) {
//
// Map NO_MORE_FILES/ACCESS_DENIED into FILE_NOT_FOUND
//
if (DosErr == ERROR_NO_MORE_FILES
|| DosErr == ERROR_ACCESS_DENIED) {
DosErr = ERROR_FILE_NOT_FOUND;
}
if (DosErr == ERROR_FILE_NOT_FOUND || DosErr == ERROR_PATH_NOT_FOUND) {
if (ErrorFunction != NULL) {
ErrorFunction( DosErr, szSearchPath, Data );
}
}
}
} else {
do {
//
// Check immediately if a control-c was hit before
// doing file I/O (which may take a long time on a slow link)
//
if (CtrlCSeen) {
findclose( FindHandle );
return(FAILURE);
}
//
// Before allowing this entry to be put in the list check it
// for the proper attribs
//
// AttribMask is a bit mask of attribs we care to look at
// AttribValues is the state these selected bits must be in
// for them to be selected.
//
// IMPORTANT: both of these must be in the same bit order
//
DEBUG((ICGRP, DILVL, " found %ws", CurrentFF->data.cFileName)) ;
DEBUG((ICGRP, DILVL, " attribs %x", CurrentFF->data.dwFileAttributes)) ;
if ((CurrentFF->data.dwFileAttributes & AttribMask) !=
(AttribValues & AttribMask) ) {
continue;
}
//
// We have an entry that matches. Set up FF
//
// Compute the true size of the ff entry and don't forget the zero
// and the DWORD alignment factor.
// Note that CurrentFF->cb is a USHORT to save space. The
// assumption is that MAX_PATH is quite a bit less then 32k
//
// To compute remove the size of the filename field since it is at MAX_PATH.
// also take out the size of the alternative name field
// then add back in the actual size of the field plus 1 byte termination
//
FoundAnyFile = TRUE;
p = (PTCHAR)CurrentFF->data.cFileName;
p += mystrlen( p ) + 1;
mystrcpy( p, CurrentFF->data.cAlternateFileName );
if (*p == TEXT('\0')) {
CurrentFF->obAlternate = 0;
} else {
CurrentFF->obAlternate = (USHORT)(p - CurrentFF->data.cFileName);
}
p += mystrlen( p ) + 1;
CurrentFF->cb = (USHORT)((PBYTE)p - (PBYTE)CurrentFF);
//
// Adjust count to align on DWORD boundaries for mips and risc
// machines
//
CurrentFF->cb = (CurrentFF->cb + sizeof( DWORD ) - 1) & (-(int)sizeof( DWORD ));
if ((CurrentFF->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
FileSpec->FileCount++;
} else {
FileSpec->DirectoryCount++;
}
//
// The FF is built. Call the enumeration function
//
if (ScanFunction != NULL) {
Status = ScanFunction( FileSpec, CurrentFF, pscr, Data );
if (Status != SUCCESS) {
findclose( FindHandle );
return Status;
}
}
//
// If there's no scanning function, save the results
//
if (ScanFunction == NULL) {
FileSpec->cff ++;
//
// Update the accounting information for file buffer info.
//
CurrentFFSize += CurrentFF->cb;
CurrentFF = (PFF) ((PBYTE)CurrentFF + CurrentFF->cb);
//
// Make sure we can handle a max sized entry. If not, resize the buffer.
//
if (CurrentFFSize + sizeof( FF ) >= MaxFFSize ) {
MaxFFSize += 64 * 1024;
DEBUG((ICGRP, DILVL, "\t size of new pff %d", MaxFFSize ));
FileSpec->pff = (PFF)resize( FileSpec->pff, MaxFFSize );
if (FileSpec->pff == NULL) {
DEBUG((ICGRP, DILVL, "\t Could not resize pff" ));
return MSG_NO_MEMORY;
}
CurrentFF = (PFF)((PBYTE)FileSpec->pff + CurrentFFSize);
DEBUG((ICGRP, DILVL, "\t resized CurrentFF new value %lx", CurrentFF)) ;
}
}
} while (FindNextNt(&CurrentFF->data, FindHandle));
findclose( FindHandle );
}
//
// We have an error left over from the FindNext. If it is NO_MORE_FILES then we
// continue only if we have more than one directory.
//
if (DosErr != SUCCESS && DosErr != ERROR_NO_MORE_FILES) {
//
// If not doing multiple file list then error
// If multiple have failed but still have files from previous pattern
//
if (FileSpec->cpatdsc <= 1) {
return DosErr ;
}
}
}
//
// If we did no scan processing, then we must create the pointers since
// SOMEONE is interested in this data.
//
if (ScanFunction == NULL && FileSpec->cff != 0) {
FileSpec->prgpff = (PPFF)gmkstr( sizeof(PFF) * FileSpec->cff );
CurrentFF = FileSpec->pff;
for (i = 0; i < FileSpec->cff; i++) {
FileSpec->prgpff[i] = CurrentFF;
CurrentFF = (PFF) ((PBYTE)CurrentFF + CurrentFF->cb);
}
}
//
// Perform post processing
//
Status = SUCCESS;
if (PostScanFunction != NULL) {
Status = PostScanFunction( FileSpec, pscr, Data );
}
if (Status == SUCCESS && !FoundAnyFile) {
return ERROR_FILE_NOT_FOUND;
} else {
return Status;
}
}
STATUS
WalkTree(
IN PFS FileSpec,
IN PSCREEN pscr,
IN ULONG AttribMask,
IN ULONG AttribValues,
IN BOOL Recurse,
IN PVOID Data OPTIONAL,
IN VOID (*ErrorFunction) (STATUS, PTCHAR, PVOID) OPTIONAL,
IN STATUS (*PreScanFunction) (PFS, PSCREEN, PVOID) OPTIONAL,
IN STATUS (*ScanFunction) (PFS, PFF, PSCREEN, PVOID) OPTIONAL,
IN STATUS (*PostScanFunction) (PFS, PSCREEN, PVOID) OPTIONAL
)
/*++
Routine Description:
Expand a given FS and apply the dispatch functions to it. The pff field is
set to point to the packed set of Win32 find records and the array of pointers
is set up as well. Recurse if necessary.
Arguments:
FileSpec - FS pointer to expand.
pscr - screen for output
AttribMask - mask for attributes we care about when matching
AttribValues - attributes that must match to satisfy the enumeration
Recurse - TRUE => perform the operation in a directory and then descend to
children
Data - pointer to caller data passed to functions
ErrorFunction - routine to call on pattern matching errors
PreScanFunction - routine to call before enumeration begins
ScanFunction - routine to call during enumeration
PostScanFunction - routine to call after enumeration is complete
Return Value:
If any of the applied functions returns a non-SUCCESS status, we return that.
If no matching file is ever found then ERROR_FILE_NOT_FOUND.
Otherwise SUCCESS.
--*/
{
STATUS Status;
FS DirectorySpec;
FS ChildFileSpec;
ULONG i;
BOOL FoundAnyFile = FALSE;
//
// Check for ^C often
//
if (CtrlCSeen) {
return FAILURE;
}
Status = ExpandAndApplyToFS( FileSpec,
pscr,
AttribMask,
AttribValues,
Data,
ErrorFunction,
PreScanFunction,
ScanFunction,
PostScanFunction );
//
// If we succeeded, remember that we did some work
//
if (Status == SUCCESS) {
FoundAnyFile = TRUE;
//
// If we got an unknown error, or we got FILE_NOT_FOUND and we're not
// recursing, return that error
//
} else if ((Status != ERROR_FILE_NOT_FOUND && Status != ERROR_PATH_NOT_FOUND)
|| !Recurse) {
return Status;
}
//
// Free up buffer holding files since we no longer need these.
// Move on to determine if we needed to go to another directory
//
FreeStr((PTCHAR)(FileSpec->pff));
FileSpec->pff = NULL;
if (CtrlCSeen) {
return FAILURE;
}
if (!Recurse)
return SUCCESS;
//
// Build up a copy of the FileSpec and build a list of all
// immediate child directories
//
DirectorySpec.pszDir = (PTCHAR)gmkstr( (_tcslen( FileSpec->pszDir ) + 1 ) * sizeof( TCHAR ));
mystrcpy( DirectorySpec.pszDir, FileSpec->pszDir );
DirectorySpec.ppatdsc = (PPATDSC)gmkstr( sizeof( PATDSC ) );
DirectorySpec.cpatdsc = 1;
DirectorySpec.fIsFat = FileSpec->fIsFat;
DirectorySpec.pfsNext = NULL;
if (FileSpec->fIsFat) {
DirectorySpec.ppatdsc->pszPattern = TEXT("*.*");
} else {
DirectorySpec.ppatdsc->pszPattern = TEXT("*");
}
DirectorySpec.ppatdsc->pszDir = (PTCHAR)gmkstr( (_tcslen( FileSpec->pszDir ) + 1) * sizeof(TCHAR));
mystrcpy( DirectorySpec.ppatdsc->pszDir, DirectorySpec.pszDir );
DirectorySpec.ppatdsc->ppatdscNext = NULL;
Status = ExpandAndApplyToFS( &DirectorySpec,
pscr,
FILE_ATTRIBUTE_DIRECTORY,
FILE_ATTRIBUTE_DIRECTORY,
NULL,
NULL,
NULL,
NULL,
NULL );
//
// If we got an error enumerating the directories, pretend that
// we just didn't find any at all.
//
if (Status != SUCCESS) {
DirectorySpec.cff = 0;
Status = SUCCESS;
}
//
// Check for CtrlC again after calling GetFS because
// GetFS may have returned failure because CtrlC was hit
// inside the GetFS function call
//
if (CtrlCSeen) {
return( FAILURE );
}
//
// Walk the list of found directories, processing each one
//
for (i = 0; i < DirectorySpec.cff; i++) {
PTCHAR DirectoryName;
ULONG NameLength;
//
// Skip recursing on . and ..
//
DirectoryName = DirectorySpec.prgpff[i]->data.cFileName;
if (!_tcscmp( DirectoryName, TEXT(".") )
|| !_tcscmp( DirectoryName, TEXT("..") )) {
continue;
}
//
// Form the new name we will descend into
//
NameLength = _tcslen( FileSpec->pszDir ) + 1 +
_tcslen( DirectoryName ) + 1;
if (NameLength > MAX_PATH) {
PutStdErr( MSG_DIR_TOO_LONG, TWOARGS, FileSpec->pszDir, DirectoryName );
return ERROR_BUFFER_OVERFLOW;
}
memset( &ChildFileSpec, 0, sizeof( ChildFileSpec ));
ChildFileSpec.pszDir = (PTCHAR)gmkstr( NameLength * sizeof( TCHAR ));
AppendPath( ChildFileSpec.pszDir, NameLength, FileSpec->pszDir, DirectoryName );
ChildFileSpec.ppatdsc = FileSpec->ppatdsc;
ChildFileSpec.cpatdsc = FileSpec->cpatdsc;
ChildFileSpec.fIsFat = FileSpec->fIsFat;
Status = WalkTree( &ChildFileSpec,
pscr,
AttribMask,
AttribValues,
Recurse,
Data,
ErrorFunction,
PreScanFunction,
ScanFunction,
PostScanFunction );
FreeStr( (PTCHAR) ChildFileSpec.pff );
ChildFileSpec.pff = NULL;
FreeStr( (PTCHAR) ChildFileSpec.prgpff );
ChildFileSpec.prgpff = NULL;
FreeStr( ChildFileSpec.pszDir );
ChildFileSpec.pszDir = NULL;
//
// If we succeeded, then remember that we actually did something
//
if (Status == SUCCESS) {
FoundAnyFile = TRUE;
//
// If we just couldn't find what we wanted, keep on working
//
} else if (Status == ERROR_BUFFER_OVERFLOW
|| Status == ERROR_FILE_NOT_FOUND
|| Status == ERROR_PATH_NOT_FOUND) {
Status = SUCCESS;
} else if ((DirectorySpec.prgpff[i]->data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
Status = SUCCESS;
} else {
break;
}
}
//
// At bottom of directory tree, free buffer holding
// list of directories.
//
FreeStr( (PTCHAR)DirectorySpec.pszDir );
FreeStr( (PTCHAR)DirectorySpec.pff );
FreeStr( (PTCHAR)DirectorySpec.prgpff );
if (Status == SUCCESS && !FoundAnyFile) {
return ERROR_FILE_NOT_FOUND;
} else {
return Status;
}
}