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.
1413 lines
35 KiB
1413 lines
35 KiB
/*++
|
|
|
|
Copyright (c) 1988-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
display.c
|
|
|
|
Abstract:
|
|
|
|
Output routines for DIR
|
|
|
|
--*/
|
|
|
|
#include "cmd.h"
|
|
|
|
extern TCHAR ThousandSeparator[];
|
|
|
|
// Entry is displayed.
|
|
// If not /b,
|
|
// Cursor is left at end of entry on screen.
|
|
// FileCnt, FileCntTotal, FileSiz, FileSizTotal are updated.
|
|
// If /b,
|
|
// Cursor is left at beginning of next line.
|
|
// Cnt's and Siz's aren't updated.
|
|
//
|
|
// Create a manager for these totals
|
|
|
|
//
|
|
// New format:
|
|
// 0123456789012345678901234567890123456789012345678901234567890123456789
|
|
// 02/23/2001 05:12p 14,611 build.log
|
|
// 02/23/2001 05:12p 14,611 ... build.log
|
|
// 02/26/2001 04:58p 13 VERYLO~1 verylongfilename
|
|
// 02/26/2001 04:58p 13 VERYLO~1 ... verylongfilename
|
|
//
|
|
// <date><space><space><time><space><space><18-char-size><space><15-char-short-name><space><22-char-ownername><space><longfilename>
|
|
// Old format:
|
|
// build log 14,611 02/23/2001 05:12p
|
|
// <8.3-name><space><18-char-size><space><date><space><space><time>
|
|
//
|
|
// Since the size of dates and times is *VARIABLE*, we presize these on each DIR call
|
|
//
|
|
|
|
|
|
ULONG WidthOfTimeDate = 19;
|
|
ULONG WidthOfFileSize = 17;
|
|
ULONG WidthOfShortName = 12;
|
|
ULONG WidthOfOwnerName = 22;
|
|
|
|
#define SPACES_AFTER_SIZE 1
|
|
#define SPACES_AFTERDATETIME 1
|
|
#define DIR_NEW_PAST_DATETIME (WidthOfTimeDate + SPACES_AFTERDATETIME)
|
|
#define DIR_NEW_PAST_DATETIME_SPECIAL (WidthOfTimeDate + SPACES_AFTERDATETIME + 3)
|
|
#define DIR_NEW_PAST_SIZE (WidthOfTimeDate + SPACES_AFTERDATETIME + WidthOfFileSize + SPACES_AFTER_SIZE)
|
|
#define DIR_NEW_PAST_OWNER (WidthOfTimeDate + SPACES_AFTERDATETIME + WidthOfFileSize + SPACES_AFTER_SIZE + WidthOfOwnerName + 1)
|
|
#define DIR_NEW_PAST_SHORTNAME (WidthOfTimeDate + SPACES_AFTERDATETIME + WidthOfFileSize + SPACES_AFTER_SIZE + WidthOfShortName + 1)
|
|
#define DIR_NEW_PAST_SHORTNAME_OWNER (WidthOfTimeDate + SPACES_AFTERDATETIME + WidthOfFileSize + SPACES_AFTER_SIZE + WidthOfShortName + 1 + WidthOfOwnerName + 1)
|
|
|
|
#define DIR_OLD_PAST_SHORTNAME (WidthOfShortName + 2)
|
|
#define DIR_OLD_PAST_SIZE (WidthOfShortName + 2 + WidthOfFileSize + SPACES_AFTER_SIZE)
|
|
|
|
extern TCHAR Fmt09[], Fmt26[] ;
|
|
extern BOOL CtrlCSeen;
|
|
extern ULONG YearWidth;
|
|
BOOLEAN GetDrive( PTCHAR , PTCHAR );
|
|
VOID SortFileList( PFS, PSORTDESC, ULONG);
|
|
|
|
STATUS
|
|
NewDisplayFileListHeader(
|
|
IN PFS FileSpec,
|
|
IN PSCREEN pscr,
|
|
IN PVOID Data
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Display the header for a complete file list. This will include
|
|
the current directory.
|
|
|
|
Arguments:
|
|
|
|
FileSpec - PFS for directory being enumerated
|
|
|
|
pscr - screen handle
|
|
|
|
data - PVOID to pdpr
|
|
|
|
|
|
Return Value:
|
|
|
|
SUCCESS if everything was correctly displayed
|
|
|
|
--*/
|
|
{
|
|
PDRP pdrp = (PDRP) Data;
|
|
|
|
pdrp->rgfSwitches &= ~HEADERDISPLAYED;
|
|
|
|
//
|
|
// We suppress the header:
|
|
//
|
|
// For bare format
|
|
// Recursing (we display the header after we've actually found something)
|
|
//
|
|
|
|
if ((pdrp->rgfSwitches & (BAREFORMATSWITCH | RECURSESWITCH)) != 0) {
|
|
return( SUCCESS );
|
|
}
|
|
|
|
CHECKSTATUS ( WriteEol( pscr ));
|
|
|
|
return( WriteMsgString(pscr, MSG_DIR_OF, ONEARG, FileSpec->pszDir) );
|
|
}
|
|
|
|
STATUS
|
|
NewDisplayFile(
|
|
IN PFS FileSpec,
|
|
IN PFF CurrentFF,
|
|
IN PSCREEN pscr,
|
|
IN PVOID Data
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Displays a single file in 1 of several formats.
|
|
|
|
Arguments:
|
|
|
|
FileSpec - PFS of directory being enumerated
|
|
|
|
CurrentFF - PFF to current file
|
|
|
|
pscr - screen handle for output
|
|
|
|
Data - PVOID to pdpr with switches
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
PDRP pdrp = (PDRP) Data;
|
|
STATUS rc = SUCCESS;
|
|
PWIN32_FIND_DATA pdata;
|
|
LARGE_INTEGER cbFile;
|
|
|
|
pdata = &(CurrentFF->data);
|
|
|
|
cbFile.LowPart = pdata->nFileSizeLow;
|
|
cbFile.HighPart = pdata->nFileSizeHigh;
|
|
FileSpec->cbFileTotal.QuadPart += cbFile.QuadPart;
|
|
|
|
//
|
|
// If we're in a recursive display, there might not be a header
|
|
// displayed. Check the state and print out one if needed.
|
|
//
|
|
|
|
if ((pdrp->rgfSwitches & RECURSESWITCH) != 0) {
|
|
|
|
if ((pdrp->rgfSwitches & HEADERDISPLAYED) == 0) {
|
|
pdrp->rgfSwitches &= ~RECURSESWITCH;
|
|
rc = NewDisplayFileListHeader( FileSpec, pscr, Data );
|
|
pdrp->rgfSwitches |= RECURSESWITCH;
|
|
if (rc != SUCCESS) {
|
|
return rc;
|
|
}
|
|
pdrp->rgfSwitches |= HEADERDISPLAYED;
|
|
}
|
|
}
|
|
|
|
if ((pdrp->rgfSwitches & BAREFORMATSWITCH) != 0) {
|
|
|
|
rc = DisplayBare( pscr, pdrp->rgfSwitches, FileSpec->pszDir, pdata);
|
|
|
|
} else if ((pdrp->rgfSwitches & WIDEFORMATSWITCH) != 0) {
|
|
|
|
rc = DisplayWide( pscr, pdrp->rgfSwitches, pdata );
|
|
|
|
} else if ((pdrp->rgfSwitches & (NEWFORMATSWITCH | SHORTFORMATSWITCH)) != 0) {
|
|
|
|
rc = DisplayNewRest(pscr, pdrp->dwTimeType, pdrp->rgfSwitches, pdata);
|
|
|
|
if (rc == SUCCESS) {
|
|
|
|
if ((pdrp->rgfSwitches & SHORTFORMATSWITCH) != 0) {
|
|
|
|
if (CurrentFF->obAlternate != 0) {
|
|
|
|
FillToCol( pscr, DIR_NEW_PAST_SIZE );
|
|
rc = DisplayDotForm( pscr,
|
|
pdrp->rgfSwitches,
|
|
&(pdata->cFileName[CurrentFF->obAlternate]),
|
|
pdata
|
|
);
|
|
|
|
}
|
|
|
|
FillToCol( pscr, DIR_NEW_PAST_SHORTNAME );
|
|
} else {
|
|
FillToCol( pscr, DIR_NEW_PAST_SIZE );
|
|
}
|
|
|
|
#ifndef WIN95_CMD
|
|
if ((pdrp->rgfSwitches & DISPLAYOWNER) != 0) {
|
|
TCHAR FullPath[MAX_PATH];
|
|
PBYTE SecurityDescriptor;
|
|
TCHAR Name[MAX_PATH];
|
|
ULONG NameSize = sizeof( Name );
|
|
TCHAR Domain[MAX_PATH];
|
|
ULONG DomainSize = sizeof( Name );
|
|
DWORD dwNeeded;
|
|
PSID SID = NULL;
|
|
BOOL OwnerDefaulted;
|
|
SID_NAME_USE snu;
|
|
|
|
SecurityDescriptor = mkstr( 65536 * sizeof( TCHAR ));
|
|
if (SecurityDescriptor == NULL) {
|
|
WriteString( pscr, TEXT( "..." ));
|
|
} else {
|
|
|
|
if (AppendPath( FullPath, MAX_PATH, FileSpec->pszDir, pdata->cFileName ) != SUCCESS) {
|
|
WriteString( pscr, TEXT( "..." ));
|
|
} else if (!GetFileSecurity( FullPath,
|
|
OWNER_SECURITY_INFORMATION,
|
|
SecurityDescriptor,
|
|
65536 * sizeof( TCHAR ),
|
|
&dwNeeded )) {
|
|
WriteString( pscr, TEXT( "..." ));
|
|
} else if (!GetSecurityDescriptorOwner( SecurityDescriptor,
|
|
&SID,
|
|
&OwnerDefaulted)) {
|
|
WriteString( pscr, TEXT( "..." ));
|
|
} else if (!LookupAccountSid( NULL,
|
|
SID,
|
|
Name,
|
|
&NameSize,
|
|
Domain,
|
|
&DomainSize,
|
|
&snu)) {
|
|
WriteString( pscr, TEXT( "..." ));
|
|
SID = NULL;
|
|
} else {
|
|
WriteString( pscr, Domain );
|
|
WriteString( pscr, TEXT( "\\" ));
|
|
WriteString( pscr, Name );
|
|
SID = NULL;
|
|
}
|
|
|
|
FreeStr( SecurityDescriptor );
|
|
}
|
|
FillToCol( pscr,
|
|
(pdrp->rgfSwitches & SHORTFORMATSWITCH) != 0
|
|
? DIR_NEW_PAST_SHORTNAME_OWNER
|
|
: DIR_NEW_PAST_OWNER );
|
|
}
|
|
#endif
|
|
|
|
rc = DisplayDotForm( pscr, pdrp->rgfSwitches, pdata->cFileName, pdata );
|
|
}
|
|
|
|
CHECKSTATUS( WriteFlushAndEol( pscr ) );
|
|
|
|
} else {
|
|
rc = DisplaySpacedForm( pscr,
|
|
pdrp->rgfSwitches,
|
|
CurrentFF->obAlternate ?
|
|
&(pdata->cFileName[CurrentFF->obAlternate]) :
|
|
pdata->cFileName,
|
|
pdata
|
|
);
|
|
if (rc == SUCCESS) {
|
|
FillToCol( pscr, DIR_OLD_PAST_SHORTNAME );
|
|
rc = DisplayOldRest( pscr, pdrp->dwTimeType, pdrp->rgfSwitches, pdata );
|
|
}
|
|
CHECKSTATUS( WriteFlushAndEol( pscr ) );
|
|
}
|
|
|
|
return( rc );
|
|
}
|
|
|
|
|
|
STATUS
|
|
NewDisplayFileList(
|
|
IN PFS FileSpec,
|
|
IN PSCREEN pscr,
|
|
IN PVOID Data
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Displays a list of files and directories in the specified format. The files
|
|
have been buffered in the PFS structure.
|
|
|
|
Arguments:
|
|
|
|
FileSpec - PFS containing set of files to display
|
|
|
|
pscr - PSCREEN for display
|
|
|
|
Data - PVOID pointer to DRP
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG irgpff;
|
|
ULONG cffColMax;
|
|
ULONG crowMax;
|
|
ULONG crow, cffCol;
|
|
|
|
STATUS rc = SUCCESS;
|
|
PDRP pdrp = (PDRP) Data;
|
|
BOOL PrintedEarly = (pdrp->rgfSwitches & (WIDEFORMATSWITCH | SORTSWITCH)) == 0;
|
|
ULONG cff = FileSpec->cff;
|
|
|
|
LARGE_INTEGER cbFile;
|
|
|
|
pdrp->FileCount += FileSpec->FileCount;
|
|
pdrp->DirectoryCount += FileSpec->DirectoryCount;
|
|
pdrp->TotalBytes.QuadPart += FileSpec->cbFileTotal.QuadPart;
|
|
|
|
if (!PrintedEarly && cff != 0) {
|
|
|
|
//
|
|
// Sort the data if needed
|
|
//
|
|
|
|
if ((pdrp->rgfSwitches & SORTSWITCH) != 0) {
|
|
SortFileList( FileSpec, pdrp->rgsrtdsc, pdrp->dwTimeType );
|
|
}
|
|
|
|
//
|
|
// Compute the tab spacing on the line from the size of the file names.
|
|
// add 3 spaces to seperate each field
|
|
//
|
|
// If multiple files per line then base tabs on the max file/dir size
|
|
//
|
|
|
|
if ((pdrp->rgfSwitches & WIDEFORMATSWITCH) != 0) {
|
|
SetTab( pscr, (USHORT)(GetMaxCbFileSize( FileSpec ) + 3) );
|
|
} else {
|
|
SetTab( pscr, 0 );
|
|
}
|
|
|
|
DEBUG((ICGRP, DISLVL, "\t count of files %d",cff));
|
|
|
|
if ((pdrp->rgfSwitches & SORTDOWNFORMATSWITCH) != 0) {
|
|
|
|
//
|
|
// no. of files on a line.
|
|
//
|
|
|
|
cffColMax = (pscr->ccolMax / pscr->ccolTab);
|
|
|
|
//
|
|
// number of row required for entire list
|
|
//
|
|
|
|
if (cffColMax == 0) // wider than a line
|
|
goto abort_wide; // abort wide format for this list
|
|
else
|
|
crowMax = (cff + cffColMax) / cffColMax;
|
|
|
|
//
|
|
// move down each rown picking the elements cffCols aport down the list.
|
|
//
|
|
|
|
for (crow = 0; crow < crowMax; crow++) {
|
|
for (cffCol = 0, irgpff = crow;
|
|
cffCol < cffColMax;
|
|
cffCol++, irgpff += crowMax) {
|
|
|
|
if (CtrlCSeen) {
|
|
return FAILURE;
|
|
}
|
|
|
|
if (irgpff < cff) {
|
|
|
|
cbFile.LowPart = FileSpec->prgpff[irgpff]->data.nFileSizeLow;
|
|
cbFile.HighPart = FileSpec->prgpff[irgpff]->data.nFileSizeHigh;
|
|
pdrp->TotalBytes.QuadPart += cbFile.QuadPart;
|
|
|
|
rc = NewDisplayFile( FileSpec,
|
|
FileSpec->prgpff[irgpff],
|
|
pscr,
|
|
Data );
|
|
|
|
if (rc != SUCCESS) {
|
|
return rc;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// If we have run past the end of the file list terminate
|
|
// line and start over back inside the line
|
|
//
|
|
CHECKSTATUS( WriteEol(pscr) );
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
} else if (!PrintedEarly) {
|
|
abort_wide:
|
|
if (CtrlCSeen) {
|
|
return FAILURE;
|
|
}
|
|
|
|
for (irgpff = 0; irgpff < cff; irgpff++) {
|
|
|
|
if (CtrlCSeen) {
|
|
return FAILURE;
|
|
}
|
|
|
|
cbFile.LowPart = FileSpec->prgpff[irgpff]->data.nFileSizeLow;
|
|
cbFile.HighPart = FileSpec->prgpff[irgpff]->data.nFileSizeHigh;
|
|
pdrp->TotalBytes.QuadPart += cbFile.QuadPart;
|
|
|
|
rc = NewDisplayFile( FileSpec,
|
|
FileSpec->prgpff[irgpff],
|
|
pscr,
|
|
Data );
|
|
if (rc != SUCCESS) {
|
|
return rc;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Before writing the tailer make sure buffer is
|
|
// empty. (Could have something from doing WIDEFORMATSWITCH
|
|
//
|
|
|
|
CHECKSTATUS( WriteFlushAndEol( pscr ) );
|
|
|
|
}
|
|
|
|
if ((pdrp->rgfSwitches & BAREFORMATSWITCH) == 0) {
|
|
if (FileSpec->FileCount + FileSpec->DirectoryCount != 0) {
|
|
CHECKSTATUS( DisplayFileSizes( pscr, &FileSpec->cbFileTotal, FileSpec->FileCount, pdrp->rgfSwitches ));
|
|
}
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
STATUS
|
|
DisplayBare (
|
|
|
|
IN PSCREEN pscr,
|
|
IN ULONG rgfSwitches,
|
|
IN PTCHAR pszDir,
|
|
IN PWIN32_FIND_DATA pdata
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Displays a single file in bare format. This is with no header, tail and
|
|
no file information other then it's name. If it is a recursive catalog
|
|
then the full file path is displayed. This mode is used to feed other
|
|
utitilies such as grep.
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
rgfSwitches - command line switch (controls formating)
|
|
pszDir - current directory (used for full path information)
|
|
pdata - data gotten back from FindNext API
|
|
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
TCHAR szDirString[MAX_PATH + 2];
|
|
STATUS rc;
|
|
|
|
DEBUG((ICGRP, DISLVL, "DisplayBare `%ws'", pdata->cFileName));
|
|
|
|
//
|
|
// Do not display '.' and '..' in a bare listing
|
|
//
|
|
if ((_tcscmp(pdata->cFileName, TEXT(".")) == 0) || (_tcscmp(pdata->cFileName, TEXT("..")) == 0)) {
|
|
|
|
return( SUCCESS );
|
|
|
|
}
|
|
|
|
//
|
|
// If we are recursing down then display full name else just the
|
|
// name in the find buffer
|
|
//
|
|
|
|
if (rgfSwitches & RECURSESWITCH) {
|
|
|
|
mystrcpy(szDirString, pszDir);
|
|
if (rgfSwitches & LOWERCASEFORMATSWITCH) {
|
|
|
|
_tcslwr(szDirString);
|
|
}
|
|
|
|
CHECKSTATUS( WriteString(pscr, szDirString) );
|
|
|
|
if (*lastc(szDirString) != BSLASH) {
|
|
CHECKSTATUS( WriteString(pscr, TEXT("\\")));
|
|
}
|
|
|
|
}
|
|
|
|
if ((rc = DisplayDotForm(pscr, rgfSwitches, pdata->cFileName, pdata)) == SUCCESS) {
|
|
|
|
return( WriteEol(pscr));
|
|
|
|
} else {
|
|
|
|
return( rc );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
SetDotForm (
|
|
IN PTCHAR pszFileName,
|
|
IN ULONG rgfSwitches
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
If FATFORMAT and there is a '.' with a blank extension, the '.' is
|
|
removed so it does not get displayed. This is by convension and is very
|
|
strange but that's life. Also a lower case mapping is done.
|
|
|
|
Arguments:
|
|
|
|
pszFileName - file to remove '.' from.
|
|
rgfSwitches - command line switches (tell wither in FATFORMAT or not)
|
|
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
PTCHAR pszT;
|
|
|
|
if (rgfSwitches & FATFORMAT) {
|
|
|
|
//
|
|
// Under DOS if there is a . with a blank extension
|
|
// then do not display '.'.
|
|
//
|
|
if (pszT = mystrrchr(pszFileName, DOT)) {
|
|
//
|
|
// FAT will not allow foo. ba as a valid name so
|
|
// see of any blanks in extensions and if so then assume
|
|
// the entire extension is blank
|
|
//
|
|
if (mystrchr(pszT, SPACE)) {
|
|
*pszT = NULLC;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
STATUS
|
|
DisplayDotForm (
|
|
|
|
IN PSCREEN pscr,
|
|
IN ULONG rgfSwitches,
|
|
IN PTCHAR pszFileName,
|
|
IN PWIN32_FIND_DATA pdata
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Displays a single file in DOT form (see SetDotForm).
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
rgfSwitches - command line switch (tell wither to lowercase or not)
|
|
pdata - data gotten back from FindNext API
|
|
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
TCHAR szFileName[MAX_PATH + 2];
|
|
|
|
mystrcpy(szFileName, pszFileName);
|
|
SetDotForm(szFileName, rgfSwitches);
|
|
if (rgfSwitches & LOWERCASEFORMATSWITCH) {
|
|
_tcslwr(szFileName);
|
|
}
|
|
|
|
if (WriteString( pscr, szFileName ) )
|
|
return FAILURE;
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
STATUS
|
|
DisplaySpacedForm(
|
|
|
|
IN PSCREEN pscr,
|
|
IN ULONG rgfSwitches,
|
|
IN PTCHAR pszName,
|
|
IN PWIN32_FIND_DATA pdata
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Display name in expanded format. name <spaces> ext.
|
|
This is ONLY called for a FAT partition. This is controled by the
|
|
NEWFORMATSWITCH. This is set for any file system other then FAT. There
|
|
is no OLDFORMATSWITCH so we can never be called on an HPFS or NTFS
|
|
volume. If this is changed then the entire spacing of the display will
|
|
be blown due to non-fixed max file names. (i.e. 8.3).
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
rgfSwitches - command line switch (tell wither to lowercase or not)
|
|
pszname - name string to use (short name format only)
|
|
pdata - data gotten back from FindNext API
|
|
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
TCHAR szFileName[MAX_PATH + 2];
|
|
PTCHAR pszExt;
|
|
USHORT cbName;
|
|
STATUS rc;
|
|
#ifdef FE_SB
|
|
int i;
|
|
int l;
|
|
#endif
|
|
|
|
mytcsnset(szFileName, SPACE, MAX_PATH + 2);
|
|
|
|
cbName = 0;
|
|
if ((_tcscmp(pszName, TEXT(".")) == 0) || (_tcscmp(pszName, TEXT("..")) == 0)) {
|
|
|
|
//
|
|
// If it is either of these then do not get it
|
|
// confused with extensions
|
|
//
|
|
pszExt = NULL;
|
|
|
|
} else {
|
|
|
|
pszExt = mystrrchr(pszName, (int)DOT);
|
|
cbName = (USHORT)(pszExt - pszName)*sizeof(WCHAR);
|
|
}
|
|
|
|
//
|
|
// if no extension or name is extension only
|
|
//
|
|
if ((pszExt == NULL) || (cbName == 0)) {
|
|
|
|
cbName = (USHORT)_tcslen(pszName)*sizeof(TCHAR);
|
|
|
|
}
|
|
|
|
memcpy(szFileName, pszName, cbName );
|
|
|
|
#if defined(FE_SB)
|
|
//
|
|
// If we had an extension then print it after
|
|
// all the spaces
|
|
//
|
|
i = 9;
|
|
if (IsDBCSCodePage()) {
|
|
for (l=0 ; l<8 ; l++) {
|
|
if (IsFullWidth(szFileName[l]))
|
|
i--;
|
|
}
|
|
}
|
|
|
|
if (pszExt) {
|
|
|
|
mystrcpy(szFileName + i, pszExt + 1);
|
|
}
|
|
|
|
//
|
|
// terminate at max end for a FAT name
|
|
//
|
|
|
|
szFileName[i+3] = NULLC;
|
|
if (pszExt &&
|
|
IsDBCSCodePage()) {
|
|
//
|
|
// Only 1 of three can be full width, since 3/2=1.
|
|
// If the first isn't, only the second could be.
|
|
//
|
|
if (IsFullWidth(*(pszExt+1)) || IsFullWidth(*(pszExt+2)))
|
|
szFileName[i+2] = NULLC;
|
|
}
|
|
#else
|
|
if (pszExt) {
|
|
|
|
//
|
|
// move pszExt past dot. use 9 not 8 to pass
|
|
// over 1 space between name and extension
|
|
//
|
|
mystrcpy(szFileName + 9, pszExt + 1);
|
|
|
|
}
|
|
|
|
//
|
|
// terminate at max end for a FAT name
|
|
//
|
|
szFileName[12] = NULLC;
|
|
#endif
|
|
|
|
if (rgfSwitches & LOWERCASEFORMATSWITCH) {
|
|
_tcslwr(szFileName);
|
|
}
|
|
|
|
rc = WriteString( pscr, szFileName );
|
|
return rc;
|
|
}
|
|
|
|
STATUS
|
|
DisplayOldRest(
|
|
|
|
IN PSCREEN pscr,
|
|
IN ULONG dwTimeType,
|
|
IN ULONG rgfSwitches,
|
|
IN PWIN32_FIND_DATA pdata
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Used with DisplaySpacedForm to write out file information such as size
|
|
and last write time.
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
pdata - data gotten back from FindNext API
|
|
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR szSize [ MAX_PATH ];
|
|
DWORD Length;
|
|
LARGE_INTEGER FileSize;
|
|
|
|
//
|
|
// If directory put <DIR> after name instead of file size
|
|
//
|
|
if (pdata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
|
|
|
|
CHECKSTATUS( WriteMsgString(pscr, MSG_DIR,0) );
|
|
|
|
} else {
|
|
|
|
FileSize.LowPart = pdata->nFileSizeLow;
|
|
FileSize.HighPart = pdata->nFileSizeHigh;
|
|
Length = FormatFileSize( rgfSwitches, &FileSize, 0, szSize );
|
|
FillToCol(pscr, DIR_OLD_PAST_SIZE - SPACES_AFTER_SIZE - Length);
|
|
WriteFmtString(pscr, TEXT( "%s" ), (PVOID)szSize);
|
|
|
|
}
|
|
|
|
FillToCol(pscr, DIR_OLD_PAST_SIZE);
|
|
return( DisplayTimeDate( pscr, dwTimeType, rgfSwitches, pdata) );
|
|
|
|
}
|
|
|
|
STATUS
|
|
DisplayTimeDate (
|
|
|
|
IN PSCREEN pscr,
|
|
IN ULONG dwTimeType,
|
|
IN ULONG rgfSwitches,
|
|
IN PWIN32_FIND_DATA pdata
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Display time/data information for a file
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
pdata - data gotten back from FindNext API
|
|
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
struct tm FileTime;
|
|
TCHAR szT[ MAX_PATH + 1];
|
|
TCHAR szD[ MAX_PATH + 1];
|
|
FILETIME ft;
|
|
|
|
switch (dwTimeType) {
|
|
|
|
case LAST_ACCESS_TIME:
|
|
|
|
ft = pdata->ftLastAccessTime;
|
|
break;
|
|
|
|
case LAST_WRITE_TIME:
|
|
|
|
ft = pdata->ftLastWriteTime;
|
|
break;
|
|
|
|
case CREATE_TIME:
|
|
|
|
ft = pdata->ftCreationTime;
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
ConvertFILETIMETotm( &ft, &FileTime );
|
|
|
|
//
|
|
// Display four digit year iff the year width is specified
|
|
// in the locale or if it was requested on the command line
|
|
//
|
|
|
|
PrintDate( &FileTime,
|
|
(YearWidth == 4 || (rgfSwitches & YEAR2000) != 0)
|
|
? PD_DIR2000
|
|
: PD_DIR,
|
|
szD, MAX_PATH );
|
|
CHECKSTATUS( WriteFmtString( pscr, TEXT("%s "), szD ));
|
|
PrintTime( &FileTime, PT_DIR, szT, MAX_PATH ) ;
|
|
CHECKSTATUS( WriteFmtString(pscr, TEXT("%s"), szT) );
|
|
|
|
WidthOfTimeDate = SizeOfHalfWidthString( szD ) + 2 + SizeOfHalfWidthString( szT );
|
|
|
|
return( SUCCESS );
|
|
}
|
|
|
|
STATUS
|
|
DisplayNewRest(
|
|
IN PSCREEN pscr,
|
|
IN ULONG dwTimeType,
|
|
IN ULONG rgfSwitches,
|
|
IN PWIN32_FIND_DATA pdata
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Display file information for new format (comes before file name).
|
|
This is used with NEWFORMATSWITCH which is active on any non-FAT
|
|
partition.
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
pdata - data gotten back from FindNext API
|
|
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
STATUS rc;
|
|
DWORD MsgNo;
|
|
LARGE_INTEGER FileSize;
|
|
|
|
rc = DisplayTimeDate( pscr, dwTimeType, rgfSwitches, pdata);
|
|
|
|
if (rc == SUCCESS) {
|
|
|
|
//
|
|
// If reparse point, special formatting.
|
|
//
|
|
// If it's an NSS reparse tag, we want to end up in the
|
|
// normal file path below.
|
|
if ((pdata->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
|
|
(pdata->dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) == 0 &&
|
|
IsReparseTagNameSurrogate( pdata->dwReserved0 )) {
|
|
|
|
FillToCol( pscr, DIR_NEW_PAST_DATETIME_SPECIAL );
|
|
MsgNo = MSG_DIR_MOUNT_POINT;
|
|
rc = WriteMsgString(pscr, MsgNo, 0);
|
|
|
|
} else
|
|
|
|
//
|
|
// If directory put <DIR> after name instead of file size
|
|
//
|
|
if (pdata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
|
|
FillToCol( pscr, DIR_NEW_PAST_DATETIME_SPECIAL );
|
|
rc = WriteMsgString(pscr, MSG_DIR, 0);
|
|
|
|
} else {
|
|
TCHAR szSize [ MAX_PATH ];
|
|
DWORD Length;
|
|
|
|
FillToCol(pscr, DIR_NEW_PAST_DATETIME);
|
|
|
|
FileSize.LowPart = pdata->nFileSizeLow;
|
|
FileSize.HighPart = pdata->nFileSizeHigh;
|
|
Length = FormatFileSize( rgfSwitches, &FileSize, 0, szSize );
|
|
|
|
//
|
|
// Show file sizes of high latency reparse points in parens to
|
|
// tell user it will be slow to retreive.
|
|
//
|
|
if ((pdata->dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) != 0) {
|
|
Length += 2;
|
|
FillToCol(pscr, DIR_NEW_PAST_SIZE - SPACES_AFTER_SIZE - Length);
|
|
rc = WriteFmtString(pscr, TEXT("(%s)"), (PVOID)szSize);
|
|
} else {
|
|
FillToCol(pscr, DIR_NEW_PAST_SIZE - SPACES_AFTER_SIZE - Length);
|
|
rc = WriteFmtString(pscr, TEXT( "%s" ), (PVOID)szSize);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return( rc );
|
|
|
|
}
|
|
|
|
|
|
STATUS
|
|
DisplayWide (
|
|
|
|
IN PSCREEN pscr,
|
|
IN ULONG rgfSwitches,
|
|
IN PWIN32_FIND_DATA pdata
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Displays a single file used in the /w or /d Switches. That is with a
|
|
multiple file column display.
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
rgfSwitches - command line Switches (controls formating)
|
|
pdata - data gotten back from FindNext API
|
|
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
TCHAR szFileName[MAX_PATH + 2];
|
|
PTCHAR pszFmt;
|
|
STATUS rc;
|
|
|
|
pszFmt = TEXT( "%s" ); // assume non-dir format
|
|
|
|
//
|
|
// Provides [] around directories
|
|
//
|
|
if (pdata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
|
|
pszFmt = Fmt09;
|
|
|
|
}
|
|
|
|
mystrcpy(szFileName, pdata->cFileName);
|
|
SetDotForm(szFileName, rgfSwitches);
|
|
if (rgfSwitches & LOWERCASEFORMATSWITCH) {
|
|
_tcslwr(szFileName);
|
|
}
|
|
rc = WriteFmtString(pscr, pszFmt, szFileName);
|
|
|
|
if (rc == SUCCESS) {
|
|
|
|
rc = WriteTab(pscr);
|
|
|
|
}
|
|
return( rc );
|
|
|
|
}
|
|
|
|
USHORT
|
|
GetMaxCbFileSize(
|
|
IN PFS pfsFiles
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determines the longest string size in a file list. Used in computing
|
|
the number of possible columns in a catalog listing.
|
|
|
|
Arguments:
|
|
|
|
pfsFiles - file list.
|
|
|
|
Return Value:
|
|
|
|
return # of characters in largest file name
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
|
|
ULONG cff;
|
|
ULONG irgff;
|
|
USHORT cb;
|
|
PFF pffCur;
|
|
|
|
cb = 0;
|
|
for (irgff = 0, cff = pfsFiles->cff, pffCur = pfsFiles->prgpff[irgff];
|
|
irgff < cff;
|
|
irgff++) {
|
|
|
|
#if defined(FE_SB)
|
|
if (IsDBCSCodePage())
|
|
cb = max(cb, (USHORT)SizeOfHalfWidthString(((pfsFiles->prgpff[irgff])->data).cFileName));
|
|
else
|
|
cb = max(cb, (USHORT)mystrlen( ((pfsFiles->prgpff[irgff])->data).cFileName ));
|
|
#else
|
|
cb = max(cb, (USHORT)mystrlen( ((pfsFiles->prgpff[irgff])->data).cFileName ));
|
|
#endif
|
|
|
|
}
|
|
|
|
return( cb );
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
STATUS
|
|
DisplayFileSizes(
|
|
IN PSCREEN pscr,
|
|
IN PLARGE_INTEGER cbFileTotal,
|
|
IN ULONG cffTotal,
|
|
IN ULONG rgfSwitches
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Does tailer display of # of files displayed and # of bytes
|
|
in all files displayed.
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
cbFileTotal - bytes in all files displayed
|
|
cffTotal - number of files displayed.
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR szSize [ MAX_PATH];
|
|
|
|
FillToCol(pscr, 6);
|
|
|
|
FormatFileSize( rgfSwitches, cbFileTotal, 14, szSize );
|
|
return( WriteMsgString(pscr, MSG_FILES_COUNT_FREE, TWOARGS,
|
|
(UINT_PTR)argstr1(TEXT("%5lu"), cffTotal ),
|
|
szSize ) );
|
|
}
|
|
|
|
STATUS
|
|
DisplayTotals(
|
|
IN PSCREEN pscr,
|
|
IN ULONG cffTotal,
|
|
IN PLARGE_INTEGER cbFileTotal,
|
|
IN ULONG rgfSwitches
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Does tailer display of # of files displayed and # of bytes
|
|
in all files displayed.
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
cbFileTotal - bytes in all files displayed
|
|
cffTotal - number of files displayed.
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
STATUS rc;
|
|
|
|
if ((rc = WriteMsgString(pscr, MSG_FILE_TOTAL, 0) ) == SUCCESS ) {
|
|
|
|
if ((rc = DisplayFileSizes( pscr, cbFileTotal, cffTotal, rgfSwitches )) == SUCCESS) {
|
|
|
|
rc = WriteFlush(pscr) ;
|
|
|
|
}
|
|
|
|
}
|
|
return( rc );
|
|
|
|
|
|
}
|
|
|
|
STATUS
|
|
DisplayDiskFreeSpace(
|
|
IN PSCREEN pscr,
|
|
IN PTCHAR pszDrive,
|
|
IN ULONG rgfSwitches,
|
|
IN ULONG DirectoryCount
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Displays total free space on volume.
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
pszDrive - volume drive letter
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
{
|
|
TCHAR szPath [ MAX_PATH + 2];
|
|
ULARGE_INTEGER cbFree;
|
|
|
|
CheckPause( pscr );
|
|
|
|
#ifdef WIN95_CMD
|
|
if (!GetDrive( pszDrive, szPath )) {
|
|
return SUCCESS;
|
|
}
|
|
mystrcat( szPath, TEXT( "\\" ));
|
|
#else
|
|
mystrcpy( szPath, pszDrive );
|
|
|
|
if (IsDrive( szPath )) {
|
|
mystrcat( szPath, TEXT("\\") );
|
|
}
|
|
#endif
|
|
|
|
cbFree.LowPart = cbFree.HighPart = 0;
|
|
|
|
#ifdef WIN95_CMD
|
|
{
|
|
DWORD dwSectorsPerCluster;
|
|
DWORD dwBytesPerSector;
|
|
DWORD dwNumberOfFreeClusters;
|
|
DWORD dwTotalNumberOfClusters;
|
|
if (GetDiskFreeSpace( szPath,&dwSectorsPerCluster, &dwBytesPerSector,
|
|
&dwNumberOfFreeClusters, &dwTotalNumberOfClusters)) {
|
|
|
|
cbFree.QuadPart = UInt32x32To64(dwSectorsPerCluster, dwNumberOfFreeClusters);
|
|
cbFree.QuadPart = cbFree.QuadPart * dwBytesPerSector;
|
|
}
|
|
}
|
|
#else
|
|
{
|
|
ULARGE_INTEGER lpTotalNumberOfBytes;
|
|
ULARGE_INTEGER lpTotalNumberOfFreeBytes;
|
|
GetDiskFreeSpaceEx( szPath, &cbFree,
|
|
&lpTotalNumberOfBytes,
|
|
&lpTotalNumberOfFreeBytes);
|
|
}
|
|
|
|
#endif
|
|
|
|
FillToCol(pscr, 6);
|
|
|
|
FormatFileSize( rgfSwitches, (PLARGE_INTEGER) &cbFree, 14, szPath );
|
|
|
|
return( WriteMsgString(pscr,
|
|
MSG_FILES_TOTAL_FREE,
|
|
TWOARGS,
|
|
(UINT_PTR)argstr1(TEXT("%5lu"), DirectoryCount ),
|
|
szPath ));
|
|
|
|
}
|
|
|
|
STATUS
|
|
DisplayVolInfo(
|
|
IN PSCREEN pscr,
|
|
IN PTCHAR pszDrive
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Displays the volume trailer information. Used before switching to
|
|
a catalog of another drive (dir a:* b:*)
|
|
|
|
Arguments:
|
|
|
|
pscr - screen handle
|
|
pszDrive - volume drive letter
|
|
|
|
Return Value:
|
|
|
|
return SUCCESS
|
|
FAILURE
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
DWORD Vsn[2];
|
|
TCHAR szVolName[MAX_PATH + 2];
|
|
TCHAR szVolRoot[MAX_PATH + 2];
|
|
TCHAR szT[256];
|
|
STATUS rc = SUCCESS;
|
|
|
|
if (!GetDrive(pszDrive, szVolRoot)) {
|
|
return SUCCESS;
|
|
}
|
|
|
|
mystrcat(szVolRoot, TEXT("\\"));
|
|
|
|
if (!GetVolumeInformation(szVolRoot,szVolName,MAX_PATH,Vsn,NULL,NULL,NULL,0)) {
|
|
|
|
DEBUG((ICGRP, DISLVL, "DisplayVolInfo: GetVolumeInformation ret'd %d", GetLastError())) ;
|
|
// don't fail if we're a substed drive
|
|
if (GetLastError() == ERROR_DIR_NOT_ROOT) {
|
|
return SUCCESS;
|
|
}
|
|
PutStdErr(GetLastError(), NOARGS);
|
|
return( FAILURE ) ;
|
|
|
|
} else {
|
|
|
|
if (szVolRoot[0] == BSLASH) {
|
|
*lastc(szVolRoot) = NULLC;
|
|
} else {
|
|
|
|
szVolRoot[1] = NULLC;
|
|
}
|
|
|
|
if (szVolName[0]) {
|
|
|
|
rc = WriteMsgString(pscr,
|
|
MSG_DR_VOL_LABEL,
|
|
TWOARGS,
|
|
szVolRoot,
|
|
szVolName ) ;
|
|
} else {
|
|
|
|
rc = WriteMsgString(pscr,
|
|
MSG_HAS_NO_LABEL,
|
|
ONEARG,
|
|
szVolRoot ) ;
|
|
|
|
}
|
|
|
|
if ((rc == SUCCESS) && (Vsn)) {
|
|
|
|
_sntprintf(szT,256,Fmt26,(Vsn[0] & 0xffff0000)>>16, (Vsn[0] & 0xffff) );
|
|
rc = WriteMsgString(pscr, MSG_DR_VOL_SERIAL, ONEARG, szT);
|
|
}
|
|
}
|
|
|
|
return( rc );
|
|
}
|
|
|
|
|
|
ULONG
|
|
FormatFileSize(
|
|
IN DWORD rgfSwitches,
|
|
IN PLARGE_INTEGER FileSize,
|
|
IN DWORD Width,
|
|
OUT PTCHAR FormattedSize
|
|
)
|
|
{
|
|
TCHAR Buffer[ 100 ];
|
|
PTCHAR s, s1;
|
|
ULONG DigitIndex;
|
|
ULONGLONG Digit;
|
|
ULONG nThousandSeparator;
|
|
ULONGLONG Size;
|
|
|
|
nThousandSeparator = _tcslen(ThousandSeparator);
|
|
s = &Buffer[ 99 ];
|
|
*s = TEXT('\0');
|
|
DigitIndex = 0;
|
|
Size = FileSize->QuadPart;
|
|
while (Size != 0) {
|
|
Digit = (Size % 10);
|
|
Size = Size / 10;
|
|
*--s = (TCHAR)(TEXT('0') + Digit);
|
|
if ((++DigitIndex % 3) == 0 && (rgfSwitches & THOUSANDSEPSWITCH)) {
|
|
// If non-null Thousand separator, insert it.
|
|
if (nThousandSeparator) {
|
|
s -= nThousandSeparator;
|
|
_tcsncpy(s, ThousandSeparator, nThousandSeparator);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (DigitIndex == 0) {
|
|
*--s = TEXT('0');
|
|
} else
|
|
if ((rgfSwitches & THOUSANDSEPSWITCH) && !_tcsncmp(s, ThousandSeparator, nThousandSeparator)) {
|
|
s += nThousandSeparator;
|
|
}
|
|
|
|
Size = _tcslen( s );
|
|
if (Width != 0 && Size < Width) {
|
|
s1 = FormattedSize;
|
|
while (Width > Size) {
|
|
Width -= 1;
|
|
*s1++ = SPACE;
|
|
}
|
|
_tcscpy( s1, s );
|
|
} else {
|
|
_tcscpy( FormattedSize, s );
|
|
}
|
|
|
|
return _tcslen( FormattedSize );
|
|
}
|