dir.c File Reference

#include "precomp.h"

Include dependency graph for dir.c:

Go to the source code of this file.

Classes
struct	_DirSwitchesFlags
struct	_DIRFINDSTREAMNODE
struct	_DIRFINDINFO
struct	_DIRFINDLISTNODE

Typedefs
typedef struct _DirSwitchesFlags	DIRSWITCHFLAGS
typedef struct _DirSwitchesFlags *	LPDIRSWITCHFLAGS
typedef struct _DIRFINDSTREAMNODE	DIRFINDSTREAMNODE
typedef struct _DIRFINDSTREAMNODE *	PDIRFINDSTREAMNODE
typedef struct _DIRFINDINFO	DIRFINDINFO
typedef struct _DIRFINDINFO *	PDIRFINDINFO
typedef struct _DIRFINDLISTNODE	DIRFINDLISTNODE
typedef struct _DIRFINDLISTNODE *	PDIRFINDLISTNODE
typedef BOOL(WINAPI *	PGETFREEDISKSPACEEX) (LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER)

Enumerations
enum	ETimeField { TF_CREATIONDATE = 0 , TF_MODIFIEDDATE = 1 , TF_LASTACCESSEDDATE = 2 }
enum	EOrderBy {   ORDER_NAME = 0 , ORDER_SIZE = 1 , ORDER_DIRECTORY = 2 , ORDER_EXTENSION = 3 ,   ORDER_TIME = 4 }

Functions
static VOID	DirHelp (VOID)
FORCEINLINE BOOL	IsDotDirectory (IN LPCTSTR pszPath)
FORCEINLINE BOOL	IsDotDirectoryN (IN const TCHAR *pPath, IN SIZE_T Length)
static BOOL	DirReadParam (LPTSTR Line, LPTSTR **params, LPINT entries, LPDIRSWITCHFLAGS lpFlags)
static BOOL	DirPrintf (LPDIRSWITCHFLAGS lpFlags, LPTSTR szFormat,...)
static BOOL	PrintDirectoryHeader (LPCTSTR szPath, LPDIRSWITCHFLAGS lpFlags)
static VOID	DirPrintFileDateTime (TCHAR *lpDate, TCHAR *lpTime, LPWIN32_FIND_DATA lpFile, LPDIRSWITCHFLAGS lpFlags)
INT	FormatDate (TCHAR *lpDate, LPSYSTEMTIME dt, BOOL b4Digit)
INT	FormatTime (TCHAR *lpTime, LPSYSTEMTIME dt)
static VOID	GetUserDiskFreeSpace (LPCTSTR lpRoot, PULARGE_INTEGER lpFreeSpace)
static INT	PrintSummary (LPCTSTR szPath, ULONG ulFiles, ULONG ulDirs, ULONGLONG u64Bytes, LPDIRSWITCHFLAGS lpFlags, BOOL TotalSummary)
TCHAR *	getExt (const TCHAR *file)
static LPTSTR	getName (const TCHAR *file, TCHAR *dest)
static VOID	DirPrintNewList (PDIRFINDINFO ptrFiles[], DWORD dwCount, LPCTSTR szCurPath, LPDIRSWITCHFLAGS lpFlags)
static VOID	DirPrintWideList (PDIRFINDINFO ptrFiles[], DWORD dwCount, LPCTSTR szCurPath, LPDIRSWITCHFLAGS lpFlags)
static VOID	DirPrintOldList (PDIRFINDINFO ptrFiles[], DWORD dwCount, LPCTSTR szCurPath, LPDIRSWITCHFLAGS lpFlags)
static VOID	DirPrintBareList (PDIRFINDINFO ptrFiles[], DWORD dwCount, LPCTSTR szCurPath, LPDIRSWITCHFLAGS lpFlags)
static VOID	DirPrintFiles (PDIRFINDINFO ptrFiles[], DWORD dwCount, LPCTSTR szCurPath, LPDIRSWITCHFLAGS lpFlags)
static BOOL	CompareFiles (PDIRFINDINFO lpFile1, PDIRFINDINFO lpFile2, LPDIRSWITCHFLAGS lpFlags)
static VOID	QsortFiles (PDIRFINDINFO ptrArray[], int i, int j, LPDIRSWITCHFLAGS lpFlags)
static VOID	DirNodeCleanup (PDIRFINDLISTNODE ptrStartNode, PDWORD pdwCount)
static INT	DirList (IN OUT LPTSTR szFullPath, IN LPTSTR pszFilePart, LPDIRSWITCHFLAGS lpFlags)
static VOID	ResolvePattern (IN LPTSTR pszPattern, IN DWORD nBufferLength, OUT LPTSTR pszFullPath, OUT LPTSTR *ppszPatternPart OPTIONAL)
INT	CommandDir (LPTSTR rest)

Variables
static ULONG	recurse_dir_cnt
static ULONG	recurse_file_cnt
static ULONGLONG	recurse_bytes

Typedef Documentation

DIRFINDINFO

typedef struct _DIRFINDINFO DIRFINDINFO

DIRFINDLISTNODE

typedef struct _DIRFINDLISTNODE DIRFINDLISTNODE

DIRFINDSTREAMNODE

typedef struct _DIRFINDSTREAMNODE DIRFINDSTREAMNODE

DIRSWITCHFLAGS

typedef struct _DirSwitchesFlags DIRSWITCHFLAGS

LPDIRSWITCHFLAGS

typedef struct _DirSwitchesFlags * LPDIRSWITCHFLAGS

PDIRFINDINFO

typedef struct _DIRFINDINFO * PDIRFINDINFO

PDIRFINDLISTNODE

typedef struct _DIRFINDLISTNODE * PDIRFINDLISTNODE

PDIRFINDSTREAMNODE

typedef struct _DIRFINDSTREAMNODE * PDIRFINDSTREAMNODE

PGETFREEDISKSPACEEX

typedef BOOL(WINAPI * PGETFREEDISKSPACEEX) (LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER)

Definition at line 215 of file dir.c.

Enumeration Type Documentation

EOrderBy

enum EOrderBy

Enumerator
ORDER_NAME
ORDER_SIZE
ORDER_DIRECTORY
ORDER_EXTENSION
ORDER_TIME

Definition at line 156 of file dir.c.

{
    ORDER_NAME      = 0,
    ORDER_SIZE      = 1,
    ORDER_DIRECTORY = 2,
    ORDER_EXTENSION = 3,
    ORDER_TIME      = 4
};

ETimeField

enum ETimeField

Enumerator
TF_CREATIONDATE
TF_MODIFIEDDATE
TF_LASTACCESSEDDATE

Definition at line 148 of file dir.c.

{
    TF_CREATIONDATE     = 0,
    TF_MODIFIEDDATE     = 1,
    TF_LASTACCESSEDDATE = 2
};

Function Documentation

CommandDir()

INT CommandDir

(

LPTSTR

rest

)

Definition at line 1835 of file dir.c.

{
    TCHAR   dircmd[MAX_PATH];   /* A variable to store the DIRCMD environment variable */
    TCHAR   prev_volume[MAX_PATH];
    TCHAR   szFullPath[MAX_PATH];
    LPTSTR* params = NULL;
    LPTSTR  pszFilePart;
    TCHAR   cPathSep;
    INT     entries = 0;
    UINT    loop = 0;
    DIRSWITCHFLAGS stFlags;
    INT ret = 1;
    BOOL ChangedVolume;
 
    /* Initialize Switch Flags < Default switches are set here! > */
    stFlags.b4Digit = TRUE;
    stFlags.bBareFormat = FALSE;
    stFlags.bDataStreams = FALSE;
    stFlags.bLowerCase = FALSE;
    stFlags.bNewLongList = TRUE;
    stFlags.bPause = FALSE;
    stFlags.bRecursive = FALSE;
    stFlags.bShortName = FALSE;
    stFlags.bTSeparator = TRUE;
    stFlags.bUser = FALSE;
    stFlags.bWideList = FALSE;
    stFlags.bWideListColSort = FALSE;
    stFlags.stTimeField.eTimeField = TF_MODIFIEDDATE;
    stFlags.stAttribs.dwAttribMask = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
    stFlags.stAttribs.dwAttribVal = 0L;
    stFlags.stOrderBy.sCriteriaCount = 0;
 
    nErrorLevel = 0;
 
    /* Read the parameters from the DIRCMD environment variable */
    if (GetEnvironmentVariable (_T("DIRCMD"), dircmd, ARRAYSIZE(dircmd)))
    {
        if (!DirReadParam(dircmd, &params, &entries, &stFlags))
        {
            nErrorLevel = 1;
            goto cleanup;
        }
    }
 
    /* Read the parameters */
    if (!DirReadParam(rest, &params, &entries, &stFlags) || CheckCtrlBreak(BREAK_INPUT))
    {
        nErrorLevel = 1;
        goto cleanup;
    }
 
    /* Default to current directory */
    if (entries == 0)
    {
        if (!add_entry(&entries, &params, _T("*")))
        {
            nErrorLevel = 1;
            goto cleanup;
        }
    }
 
    prev_volume[0] = _T('\0');
 
    /* Reset paging state */
    if (stFlags.bPause)
        ConOutPrintfPaging(TRUE, _T(""));
 
    for (loop = 0; loop < (UINT)entries; loop++)
    {
        if (CheckCtrlBreak(BREAK_INPUT))
        {
            nErrorLevel = 1;
            goto cleanup;
        }
 
        recurse_dir_cnt = 0L;
        recurse_file_cnt = 0L;
        recurse_bytes = 0;
 
        /* <Debug :>
           Uncomment this to show the final state of switch flags*/
        {
            int i;
            TRACE("Attributes mask/value %x/%x\n",stFlags.stAttribs.dwAttribMask,stFlags.stAttribs.dwAttribVal);
            TRACE("(B) Bare format : %i\n", stFlags.bBareFormat);
            TRACE("(C) Thousand : %i\n", stFlags.bTSeparator);
            TRACE("(W) Wide list : %i\n", stFlags.bWideList);
            TRACE("(D) Wide list sort by column : %i\n", stFlags.bWideListColSort);
            TRACE("(L) Lowercase : %i\n", stFlags.bLowerCase);
            TRACE("(N) New : %i\n", stFlags.bNewLongList);
            TRACE("(O) Order : %i\n", stFlags.stOrderBy.sCriteriaCount);
            for (i =0;i<stFlags.stOrderBy.sCriteriaCount;i++)
                TRACE(" Order Criteria [%i]: %i (Reversed: %i)\n",i, stFlags.stOrderBy.eCriteria[i], stFlags.stOrderBy.bCriteriaRev[i]);
            TRACE("(P) Pause : %i\n", stFlags.bPause);
            TRACE("(Q) Owner : %i\n", stFlags.bUser);
            TRACE("(R) Data stream : %i\n", stFlags.bDataStreams);
            TRACE("(S) Recursive : %i\n", stFlags.bRecursive);
            TRACE("(T) Time field : %i\n", stFlags.stTimeField.eTimeField);
            TRACE("(X) Short names : %i\n", stFlags.bShortName);
            TRACE("Parameter : %s\n", debugstr_aw(params[loop]));
        }
 
        /* Print the drive header if the volume changed */
        ChangedVolume = TRUE;
 
        if (!stFlags.bBareFormat &&
            GetVolumePathName(params[loop], szFullPath, ARRAYSIZE(szFullPath)))
        {
            if (!_tcscmp(szFullPath, prev_volume))
                ChangedVolume = FALSE;
            else
                _tcscpy(prev_volume, szFullPath);
        }
 
        /* Resolve the pattern */
        ResolvePattern(params[loop], ARRAYSIZE(szFullPath), szFullPath, &pszFilePart);
 
        /* Print the header */
        cPathSep = pszFilePart[-1];
        pszFilePart[-1] = _T('\0'); /* Truncate to directory name only */
        if (ChangedVolume && !stFlags.bBareFormat &&
            !PrintDirectoryHeader(szFullPath, &stFlags))
        {
            nErrorLevel = 1;
            goto cleanup;
        }
        pszFilePart[-1] = cPathSep;
 
        /* Perform the actual directory listing */
        if (DirList(szFullPath, pszFilePart, &stFlags) != 0)
        {
            nErrorLevel = 1;
            goto cleanup;
        }
 
        /* Print the footer */
        pszFilePart[-1] = _T('\0'); /* Truncate to directory name only */
        PrintSummary(szFullPath,
                     recurse_file_cnt,
                     recurse_dir_cnt,
                     recurse_bytes,
                     &stFlags,
                     TRUE);
    }
 
    ret = 0;
 
cleanup:
    freep(params);
 
    return ret;
}

CompareFiles()

static BOOL CompareFiles ( PDIRFINDINFO  lpFile1, PDIRFINDINFO  lpFile2, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 1192 of file dir.c.

{
  ULARGE_INTEGER u64File1;
  ULARGE_INTEGER u64File2;
  int i;
  long iComp = 0;   /* The comparison result */
 
    /* Calculate criteria by order given from user */
    for (i = 0; i < lpFlags->stOrderBy.sCriteriaCount; i++)
    {
 
        /* Calculate criteria */
        switch (lpFlags->stOrderBy.eCriteria[i])
        {
        case ORDER_SIZE:        /* Order by size /o:s */
            /* concat the 32bit integers to a 64bit */
            u64File1.LowPart = lpFile1->stFindInfo.nFileSizeLow;
            u64File1.HighPart = lpFile1->stFindInfo.nFileSizeHigh;
            u64File2.LowPart = lpFile2->stFindInfo.nFileSizeLow;
            u64File2.HighPart = lpFile2->stFindInfo.nFileSizeHigh;
 
            /* In case that difference is too big for a long */
            if (u64File1.QuadPart < u64File2.QuadPart)
                iComp = -1;
            else if (u64File1.QuadPart > u64File2.QuadPart)
                iComp = 1;
            else
                iComp = 0;
            break;
 
        case ORDER_DIRECTORY:   /* Order by directory attribute /o:g */
            iComp = ((lpFile2->stFindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)-
                (lpFile1->stFindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY));
            break;
 
        case ORDER_EXTENSION:   /* Order by extension name /o:e */
            iComp = _tcsicmp(getExt(lpFile1->stFindInfo.cFileName),getExt(lpFile2->stFindInfo.cFileName));
            break;
 
        case ORDER_NAME:        /* Order by filename /o:n */
            iComp = _tcsicmp(lpFile1->stFindInfo.cFileName, lpFile2->stFindInfo.cFileName);
            break;
 
        case ORDER_TIME:        /* Order by file's time /o:t */
            /* We compare files based on the time field selected by /t */
            switch (lpFlags->stTimeField.eTimeField)
            {
            case TF_CREATIONDATE:
                /* concat the 32bit integers to a 64bit */
                u64File1.LowPart = lpFile1->stFindInfo.ftCreationTime.dwLowDateTime;
                u64File1.HighPart = lpFile1->stFindInfo.ftCreationTime.dwHighDateTime ;
                u64File2.LowPart = lpFile2->stFindInfo.ftCreationTime.dwLowDateTime;
                u64File2.HighPart = lpFile2->stFindInfo.ftCreationTime.dwHighDateTime ;
                break;
            case TF_LASTACCESSEDDATE :
                /* concat the 32bit integers to a 64bit */
                u64File1.LowPart = lpFile1->stFindInfo.ftLastAccessTime.dwLowDateTime;
                u64File1.HighPart = lpFile1->stFindInfo.ftLastAccessTime.dwHighDateTime ;
                u64File2.LowPart = lpFile2->stFindInfo.ftLastAccessTime.dwLowDateTime;
                u64File2.HighPart = lpFile2->stFindInfo.ftLastAccessTime.dwHighDateTime ;
                break;
            case TF_MODIFIEDDATE:
                /* concat the 32bit integers to a 64bit */
                u64File1.LowPart = lpFile1->stFindInfo.ftLastWriteTime.dwLowDateTime;
                u64File1.HighPart = lpFile1->stFindInfo.ftLastWriteTime.dwHighDateTime ;
                u64File2.LowPart = lpFile2->stFindInfo.ftLastWriteTime.dwLowDateTime;
                u64File2.HighPart = lpFile2->stFindInfo.ftLastWriteTime.dwHighDateTime ;
                break;
            }
 
            /* In case that difference is too big for a long */
            if (u64File1.QuadPart < u64File2.QuadPart)
                iComp = -1;
            else if (u64File1.QuadPart > u64File2.QuadPart)
                iComp = 1;
            else
                iComp = 0;
            break;
        }
 
        /* Reverse if desired */
        if (lpFlags->stOrderBy.bCriteriaRev[i])
            iComp *= -1;
 
        /* If that criteria was enough for distinguishing
           the files/dirs,there is no need to calculate the others*/
        if (iComp != 0) break;
    }
 
    /* Translate the value of iComp to boolean */
    return iComp > 0;
}

Referenced by QsortFiles().

DirHelp()

static VOID DirHelp ( VOID  )

static

Definition at line 231 of file dir.c.

{
    ConOutResPaging(TRUE, STRING_DIR_HELP1);
}

Referenced by DirReadParam().

DirList()

static INT DirList ( IN OUT LPTSTR  szFullPath, IN LPTSTR  pszFilePart, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 1357 of file dir.c.

{
    HANDLE hSearch;                     /* The handle of the search */
    HANDLE hRecSearch;                  /* The handle for searching recursively */
    HANDLE hStreams;                    /* The handle for alternate streams */
    WIN32_FIND_DATA wfdFileInfo;        /* The info of file that found */
    PDIRFINDINFO * ptrFileArray;        /* An array of pointers with all the files */
    PDIRFINDLISTNODE ptrStartNode;      /* The pointer to the first node */
    PDIRFINDLISTNODE ptrNextNode;       /* A pointer used for relatives references */
    TCHAR szSubPath[MAX_PATH];          /* The full path used for the recursive search */
    LPTSTR pszSubFilePart;
    TCHAR cPathSep;
    DWORD dwCount;                      /* A counter of files found in directory */
    DWORD dwCountFiles;                 /* Counter for files */
    DWORD dwCountDirs;                  /* Counter for directories */
    ULONGLONG u64CountBytes;            /* Counter for bytes */
    ULARGE_INTEGER u64Temp;             /* A temporary counter */
    WIN32_FIND_STREAM_DATA wfsdStreamInfo;
    PDIRFINDSTREAMNODE * ptrCurNode;    /* The pointer to the first stream */
    static HANDLE (WINAPI *pFindFirstStreamW)(LPCWSTR, STREAM_INFO_LEVELS, LPVOID, DWORD);
    static BOOL (WINAPI *pFindNextStreamW)(HANDLE, LPVOID);
 
    /* Initialize variables */
    ptrStartNode = NULL;
    ptrNextNode = NULL;
    dwCount = 0;
    dwCountFiles = 0;
    dwCountDirs = 0;
    u64CountBytes = 0;
 
    /* Prepare the linked list, first node is allocated */
    ptrStartNode = cmd_alloc(sizeof(DIRFINDLISTNODE));
    if (ptrStartNode == NULL)
    {
        WARN("Cannot allocate memory for ptrStartNode!\n");
        return 1;   /* Error cannot allocate memory for 1st object */
    }
    ptrStartNode->stInfo.ptrHead = NULL;
    ptrNextNode = ptrStartNode;
 
    /* Collect the results for the current directory */
    hSearch = FindFirstFile(szFullPath, &wfdFileInfo);
    if (hSearch != INVALID_HANDLE_VALUE)
    {
        do
        {
            if ((wfdFileInfo.dwFileAttributes & lpFlags->stAttribs.dwAttribMask) ==
                (lpFlags->stAttribs.dwAttribMask & lpFlags->stAttribs.dwAttribVal))
            {
                ptrNextNode->ptrNext = cmd_alloc(sizeof(DIRFINDLISTNODE));
                if (ptrNextNode->ptrNext == NULL)
                {
                    WARN("Cannot allocate memory for ptrNextNode->ptrNext!\n");
                    DirNodeCleanup(ptrStartNode, &dwCount);
                    FindClose(hSearch);
                    return 1;
                }
 
                /* Copy the info of search at linked list */
                memcpy(&ptrNextNode->ptrNext->stInfo.stFindInfo,
                       &wfdFileInfo,
                       sizeof(WIN32_FIND_DATA));
 
                /* If lower case is selected do it here */
                if (lpFlags->bLowerCase)
                {
                    _tcslwr(ptrNextNode->ptrNext->stInfo.stFindInfo.cAlternateFileName);
                    _tcslwr(ptrNextNode->ptrNext->stInfo.stFindInfo.cFileName);
                }
 
                /* No streams (yet?) */
                ptrNextNode->ptrNext->stInfo.ptrHead = NULL;
 
                /* Alternate streams are only displayed with new long list */
                if (lpFlags->bNewLongList && lpFlags->bDataStreams)
                {
                    if (!pFindFirstStreamW)
                    {
                        pFindFirstStreamW = (PVOID)GetProcAddress(GetModuleHandle(_T("kernel32")), "FindFirstStreamW");
                        pFindNextStreamW = (PVOID)GetProcAddress(GetModuleHandle(_T("kernel32")), "FindNextStreamW");
                    }
 
                    /* Try to get stream information */
                    if (pFindFirstStreamW && pFindNextStreamW)
                    {
                        hStreams = pFindFirstStreamW(wfdFileInfo.cFileName, FindStreamInfoStandard, &wfsdStreamInfo, 0);
                    }
                    else
                    {
                        hStreams = INVALID_HANDLE_VALUE;
                        ERR("FindFirstStreamW not supported!\n");
                    }
 
                    if (hStreams != INVALID_HANDLE_VALUE)
                    {
                        /* We totally ignore first stream. It contains data about ::$DATA */
                        ptrCurNode = &ptrNextNode->ptrNext->stInfo.ptrHead;
                        while (pFindNextStreamW(hStreams, &wfsdStreamInfo))
                        {
                            *ptrCurNode = cmd_alloc(sizeof(DIRFINDSTREAMNODE));
                            if (*ptrCurNode == NULL)
                            {
                                WARN("Cannot allocate memory for *ptrCurNode!\n");
                                DirNodeCleanup(ptrStartNode, &dwCount);
                                FindClose(hStreams);
                                FindClose(hSearch);
                                return 1;
                            }
 
                            memcpy(&(*ptrCurNode)->stStreamInfo, &wfsdStreamInfo,
                                   sizeof(WIN32_FIND_STREAM_DATA));
 
                            /* If lower case is selected do it here */
                            if (lpFlags->bLowerCase)
                            {
                                _tcslwr((*ptrCurNode)->stStreamInfo.cStreamName);
                            }
 
                            ptrCurNode = &(*ptrCurNode)->ptrNext;
                        }
 
                        FindClose(hStreams);
                        *ptrCurNode = NULL;
                    }
                }
 
                /* Continue at next node at linked list */
                ptrNextNode = ptrNextNode->ptrNext;
                dwCount++;
 
                /* Grab statistics */
                if (wfdFileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                {
                    /* Directory */
                    dwCountDirs++;
                }
                else
                {
                    /* File */
                    dwCountFiles++;
                    u64Temp.HighPart = wfdFileInfo.nFileSizeHigh;
                    u64Temp.LowPart = wfdFileInfo.nFileSizeLow;
                    u64CountBytes += u64Temp.QuadPart;
                }
            }
        } while (FindNextFile(hSearch, &wfdFileInfo));
        FindClose(hSearch);
    }
 
    /* Terminate list */
    ptrNextNode->ptrNext = NULL;
 
    /* Calculate and allocate space need for making an array of pointers */
    ptrFileArray = cmd_alloc(sizeof(PDIRFINDINFO) * dwCount);
    if (ptrFileArray == NULL)
    {
        WARN("Cannot allocate memory for ptrFileArray!\n");
        DirNodeCleanup(ptrStartNode, &dwCount);
        return 1;
    }
 
    /*
     * Create an array of pointers from the linked list
     * this will be used to sort and print data, rather than the list
     */
    ptrNextNode = ptrStartNode;
    dwCount = 0;
    while (ptrNextNode->ptrNext)
    {
        ptrFileArray[dwCount] = &ptrNextNode->ptrNext->stInfo;
        ptrNextNode = ptrNextNode->ptrNext;
        dwCount++;
    }
 
    /* Sort Data if requested */
    if (lpFlags->stOrderBy.sCriteriaCount > 0)
        QsortFiles(ptrFileArray, 0, dwCount-1, lpFlags);
 
    /* Print Data */
    cPathSep = pszFilePart[-1];
    pszFilePart[-1] = _T('\0'); /* Truncate to directory name only */
    DirPrintFiles(ptrFileArray, dwCount, szFullPath, lpFlags);
 
    if (lpFlags->bRecursive)
    {
        PrintSummary(szFullPath,
                     dwCountFiles,
                     dwCountDirs,
                     u64CountBytes,
                     lpFlags,
                     FALSE);
    }
    pszFilePart[-1] = cPathSep;
 
    /* Free array */
    cmd_free(ptrFileArray);
 
    /* Free linked list */
    DirNodeCleanup(ptrStartNode, &dwCount);
 
    if (CheckCtrlBreak(BREAK_INPUT))
        return 1;
 
    /* Add statistics to recursive statistics */
    recurse_dir_cnt += dwCountDirs;
    recurse_file_cnt += dwCountFiles;
    recurse_bytes += u64CountBytes;
 
    /*
     * Do the recursive job if requested.
     * The recursion is done on ALL (independent of their attributes)
     * directories of the current one.
     */
    if (lpFlags->bRecursive)
    {
        /* The new search is involving any *.* file */
        memcpy(szSubPath, szFullPath, (pszFilePart - szFullPath) * sizeof(TCHAR));
        _tcscpy(&szSubPath[pszFilePart - szFullPath], _T("*.*"));
 
        hRecSearch = FindFirstFile(szSubPath, &wfdFileInfo);
        if (hRecSearch != INVALID_HANDLE_VALUE)
        {
            do
            {
                /* We search for directories other than "." and ".." */
                if (!IsDotDirectory(wfdFileInfo.cFileName) &&
                    (wfdFileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
                {
                    /* Concat the path and the directory to do recursive */
                    memcpy(szSubPath, szFullPath, (pszFilePart - szFullPath) * sizeof(TCHAR));
                    _tcscpy(&szSubPath[pszFilePart - szFullPath], wfdFileInfo.cFileName);
                    _tcscat(szSubPath, _T("\\"));
                    pszSubFilePart = &szSubPath[_tcslen(szSubPath)];
                    _tcscat(pszSubFilePart, pszFilePart);
 
                    /* We do the same for the directory */
                    if (DirList(szSubPath, pszSubFilePart, lpFlags) != 0)
                    {
                        FindClose(hRecSearch);
                        return 1;
                    }
                }
            } while (FindNextFile(hRecSearch, &wfdFileInfo));
        }
        FindClose(hRecSearch);
    }
 
    return 0;
}

Referenced by CommandDir(), and DirList().

DirNodeCleanup()

static VOID DirNodeCleanup ( PDIRFINDLISTNODE  ptrStartNode, PDWORD  pdwCount  )

static

Definition at line 1331 of file dir.c.

{
    PDIRFINDLISTNODE ptrNextNode;
    PDIRFINDSTREAMNODE ptrFreeNode;
    while (ptrStartNode)
    {
        ptrNextNode = ptrStartNode->ptrNext;
        while (ptrStartNode->stInfo.ptrHead)
        {
            ptrFreeNode = ptrStartNode->stInfo.ptrHead;
            ptrStartNode->stInfo.ptrHead = ptrFreeNode->ptrNext;
            cmd_free(ptrFreeNode);
        }
        cmd_free(ptrStartNode);
        ptrStartNode = ptrNextNode;
        --(*pdwCount);
    }
}

Referenced by DirList().

DirPrintBareList()

static VOID DirPrintBareList ( PDIRFINDINFO  ptrFiles[], DWORD  dwCount, LPCTSTR  szCurPath, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 1102 of file dir.c.

{
    DWORD i;
 
    for (i = 0; i < dwCount && !CheckCtrlBreak(BREAK_INPUT); i++)
    {
        if (IsDotDirectory(ptrFiles[i]->stFindInfo.cFileName))
        {
            /* At bare format we don't print the dot-directories "." and ".." */
            continue;
        }
        if (lpFlags->bRecursive)
        {
            /* At recursive mode we print full path of file */
            DirPrintf(lpFlags, _T("%s\\%s\n"), szCurPath, ptrFiles[i]->stFindInfo.cFileName);
        }
        else
        {
            /* If we are not in recursive mode we print the file names */
            DirPrintf(lpFlags, _T("%s\n"), ptrFiles[i]->stFindInfo.cFileName);
        }
    }
}

Referenced by DirPrintFiles().

DirPrintf()

static BOOL DirPrintf ( LPDIRSWITCHFLAGS  lpFlags, LPTSTR  szFormat,   ...  )

static

Definition at line 577 of file dir.c.

{
    BOOL Done = TRUE;
    va_list arg_ptr;
    va_start(arg_ptr, szFormat);
    if (lpFlags->bPause)
        Done = ConPrintfVPaging(&StdOutPager, FALSE, szFormat, arg_ptr);
    else
        ConPrintfV(StdOut, szFormat, arg_ptr);
    va_end(arg_ptr);
    return Done;
}

Referenced by DirPrintBareList(), DirPrintFiles(), DirPrintNewList(), DirPrintOldList(), DirPrintWideList(), PrintDirectoryHeader(), and PrintSummary().

DirPrintFileDateTime()

static VOID DirPrintFileDateTime ( TCHAR *  lpDate, TCHAR *  lpTime, LPWIN32_FIND_DATA  lpFile, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 639 of file dir.c.

{
    FILETIME ft;
    SYSTEMTIME dt;
 
    /* Select the right time field */
    switch (lpFlags->stTimeField.eTimeField)
    {
        case TF_CREATIONDATE:
            if (!FileTimeToLocalFileTime(&lpFile->ftCreationTime, &ft))
                return;
            FileTimeToSystemTime(&ft, &dt);
            break;
 
        case TF_LASTACCESSEDDATE :
            if (!FileTimeToLocalFileTime(&lpFile->ftLastAccessTime, &ft))
                return;
            FileTimeToSystemTime(&ft, &dt);
            break;
 
        case TF_MODIFIEDDATE:
            if (!FileTimeToLocalFileTime(&lpFile->ftLastWriteTime, &ft))
                return;
            FileTimeToSystemTime(&ft, &dt);
            break;
    }
 
    FormatDate(lpDate, &dt, lpFlags->b4Digit);
    FormatTime(lpTime, &dt);
}

Referenced by DirPrintNewList(), and DirPrintOldList().

DirPrintFiles()

static VOID DirPrintFiles ( PDIRFINDINFO  ptrFiles[], DWORD  dwCount, LPCTSTR  szCurPath, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 1136 of file dir.c.

{
    TCHAR szMsg[RC_STRING_MAX_SIZE];
    TCHAR szTemp[MAX_PATH]; /* A buffer to format the directory header */
 
    /* Print trailing backslash for root directory of drive */
    _tcscpy(szTemp, szCurPath);
    if (_tcslen(szTemp) == 2 && szTemp[1] == _T(':'))
        _tcscat(szTemp, _T("\\"));
 
    /* Condition to print header:
       We are not printing in bare format
       and if we are in recursive mode... we must have results */
    if (!lpFlags->bBareFormat && !(lpFlags->bRecursive && (dwCount <= 0)))
    {
        LoadString(CMD_ModuleHandle, STRING_DIR_HELP7, szMsg, ARRAYSIZE(szMsg));
        if (!DirPrintf(lpFlags, szMsg, szTemp))
            return;
    }
 
    if (lpFlags->bBareFormat)
    {
        /* Bare format */
        DirPrintBareList(ptrFiles, dwCount, szCurPath, lpFlags);
    }
    else if (lpFlags->bShortName)
    {
        /* New list style / Short names */
        DirPrintNewList(ptrFiles, dwCount, szCurPath, lpFlags);
    }
    else if (lpFlags->bWideListColSort || lpFlags->bWideList)
    {
        /* Wide list */
        DirPrintWideList(ptrFiles, dwCount, szCurPath, lpFlags);
    }
    else if (lpFlags->bNewLongList )
    {
        /* New list style*/
        DirPrintNewList(ptrFiles, dwCount, szCurPath, lpFlags);
    }
    else
    {
        /* If nothing is selected old list is the default */
        DirPrintOldList(ptrFiles, dwCount, szCurPath, lpFlags);
    }
}

Referenced by DirList().

DirPrintNewList()

static VOID DirPrintNewList ( PDIRFINDINFO  ptrFiles[], DWORD  dwCount, LPCTSTR  szCurPath, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 873 of file dir.c.

{
    DWORD i;
    TCHAR szSize[30];
    TCHAR szShortName[15];
    TCHAR szDate[20];
    TCHAR szTime[20];
    INT iSizeFormat;
    ULARGE_INTEGER u64FileSize;
    PDIRFINDSTREAMNODE ptrCurStream;
 
    for (i = 0; i < dwCount && !CheckCtrlBreak(BREAK_INPUT); i++)
    {
        /* Calculate size */
        if (ptrFiles[i]->stFindInfo.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
        {
            /* Junction */
            iSizeFormat = -14;
            _tcscpy(szSize, _T("<JUNCTION>"));
        }
        else if (ptrFiles[i]->stFindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            /* Directory */
            iSizeFormat = -14;
            _tcscpy(szSize, _T("<DIR>"));
        }
        else
        {
            /* File */
            iSizeFormat = 14;
            u64FileSize.HighPart = ptrFiles[i]->stFindInfo.nFileSizeHigh;
            u64FileSize.LowPart = ptrFiles[i]->stFindInfo.nFileSizeLow;
            ConvertULargeInteger(u64FileSize.QuadPart, szSize, 20, lpFlags->bTSeparator);
        }
 
        /* Calculate short name */
        szShortName[0] = _T('\0');
        if (lpFlags->bShortName)
            _stprintf(szShortName, _T(" %-12s"), ptrFiles[i]->stFindInfo.cAlternateFileName);
 
        /* Format date and time */
        DirPrintFileDateTime(szDate, szTime, &ptrFiles[i]->stFindInfo, lpFlags);
 
        /* Print the line */
        DirPrintf(lpFlags, _T("%10s  %-6s    %*s%s %s\n"),
                  szDate,
                  szTime,
                  iSizeFormat,
                  szSize,
                  szShortName,
                  ptrFiles[i]->stFindInfo.cFileName);
 
        /* Now, loop on the streams */
        ptrCurStream = ptrFiles[i]->ptrHead;
        while (ptrCurStream)
        {
            ConvertULargeInteger(ptrCurStream->stStreamInfo.StreamSize.QuadPart, szSize, 20, lpFlags->bTSeparator);
 
            /* Print the line */
            DirPrintf(lpFlags, _T("%10s  %-6s    %*s%s %s%s\n"),
                      L"",
                      L"",
                      16,
                      szSize,
                      L"",
                      ptrFiles[i]->stFindInfo.cFileName,
                      ptrCurStream->stStreamInfo.cStreamName);
            ptrCurStream = ptrCurStream->ptrNext;
        }
    }
}

Referenced by DirPrintFiles().

DirPrintOldList()

static VOID DirPrintOldList ( PDIRFINDINFO  ptrFiles[], DWORD  dwCount, LPCTSTR  szCurPath, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 1037 of file dir.c.

{
    DWORD i;                        /* An indexer for "for"s */
    TCHAR szName[10];               /* The name of file */
    TCHAR szExt[5];                 /* The extension of file */
    TCHAR szDate[30],szTime[30];    /* Used to format time and date */
    TCHAR szSize[30];               /* The size of file */
    int iSizeFormat;                /* The format of size field */
    ULARGE_INTEGER u64FileSize;     /* The file size */
 
    for (i = 0; i < dwCount && !CheckCtrlBreak(BREAK_INPUT); i++)
    {
        /* Broke 8.3 format */
        if (*ptrFiles[i]->stFindInfo.cAlternateFileName )
        {
            /* If the file is long named then we read the alter name */
            getName( ptrFiles[i]->stFindInfo.cAlternateFileName, szName);
            _tcscpy(szExt, getExt( ptrFiles[i]->stFindInfo.cAlternateFileName));
        }
        else
        {
            /* If the file is not long name we read its original name */
            getName( ptrFiles[i]->stFindInfo.cFileName, szName);
            _tcscpy(szExt, getExt( ptrFiles[i]->stFindInfo.cFileName));
        }
 
        /* Calculate size */
        if (ptrFiles[i]->stFindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            /* Directory, no size it's a directory */
            iSizeFormat = -17;
            _tcscpy(szSize, _T("<DIR>"));
        }
        else
        {
            /* File */
            iSizeFormat = 17;
            u64FileSize.HighPart = ptrFiles[i]->stFindInfo.nFileSizeHigh;
            u64FileSize.LowPart = ptrFiles[i]->stFindInfo.nFileSizeLow;
            ConvertULargeInteger(u64FileSize.QuadPart, szSize, 20, lpFlags->bTSeparator);
        }
 
        /* Format date and time */
        DirPrintFileDateTime(szDate,szTime,&ptrFiles[i]->stFindInfo,lpFlags);
 
        /* Print the line */
        DirPrintf(lpFlags, _T("%-8s %-3s  %*s %s  %s\n"),
                  szName,       /* The file's 8.3 name */
                  szExt,        /* The file's 8.3 extension */
                  iSizeFormat,  /* print format for size column */
                  szSize,       /* The size of file or "<DIR>" for dirs */
                  szDate,       /* The date of file/dir */
                  szTime);      /* The time of file/dir */
    }
}

Referenced by DirPrintFiles().

DirPrintWideList()

static VOID DirPrintWideList ( PDIRFINDINFO  ptrFiles[], DWORD  dwCount, LPCTSTR  szCurPath, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 955 of file dir.c.

{
    SHORT iScreenWidth;
    USHORT iColumns;
    USHORT iLines;
    UINT_PTR iLongestName;
    TCHAR szTempFname[MAX_PATH];
    DWORD i;
    DWORD j;
    DWORD temp;
 
    /* Calculate longest name */
    iLongestName = 1;
    for (i = 0; i < dwCount; i++)
    {
        if (ptrFiles[i]->stFindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            /* Directories need 2 additional characters for brackets */
            if ((_tcslen(ptrFiles[i]->stFindInfo.cFileName) + 2) > iLongestName)
                iLongestName = _tcslen(ptrFiles[i]->stFindInfo.cFileName) + 2;
        }
        else
        {
            if (_tcslen(ptrFiles[i]->stFindInfo.cFileName) > iLongestName)
                iLongestName = _tcslen(ptrFiles[i]->stFindInfo.cFileName);
        }
    }
 
    /* Count the highest number of columns */
    GetScreenSize(&iScreenWidth, NULL);
    iColumns = (USHORT)(iScreenWidth / iLongestName);
 
    /* Check if there is enough space for spaces between names */
    if (((iLongestName * iColumns) + iColumns) >= (UINT)iScreenWidth)
        iColumns --;
 
    /* A last check at iColumns to avoid division by zero */
    if (!iColumns) iColumns = 1;
 
    /* Calculate the lines that will be printed */
    iLines = (USHORT)((dwCount + iColumns - 1) / iColumns);
 
    for (i = 0; i < iLines && !CheckCtrlBreak(BREAK_INPUT); i++)
    {
        for (j = 0; j < iColumns; j++)
        {
            if (lpFlags->bWideListColSort)
            {
                /* Print Column sorted */
                temp = (j * iLines) + i;
            }
            else
            {
                /* Print Line sorted */
                temp = (i * iColumns) + j;
            }
 
            if (temp >= dwCount) break;
 
            if (ptrFiles[temp]->stFindInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                _stprintf(szTempFname, _T("[%s]"), ptrFiles[temp]->stFindInfo.cFileName);
            else
                _stprintf(szTempFname, _T("%s"), ptrFiles[temp]->stFindInfo.cFileName);
 
            DirPrintf(lpFlags, _T("%-*s"), iLongestName + 1, szTempFname);
        }
 
        /* Add a new line after the last item in the column */
        DirPrintf(lpFlags, _T("\n"));
    }
}

Referenced by DirPrintFiles().

DirReadParam()

static BOOL DirReadParam ( LPTSTR  Line, LPTSTR **  params, LPINT  entries, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 264 of file dir.c.

{
    TCHAR cCurSwitch;   /* The current switch */
    TCHAR cCurChar;     /* Current examined character */
    TCHAR cCurUChar;    /* Current upper examined character */
    BOOL bNegative;     /* Negative switch */
    BOOL bPNegative;    /* Negative switch parameter */
    BOOL bIntoQuotes;   /* A flag showing if we are in quotes (") */
    LPTSTR ptrStart;    /* A pointer to the first character of a parameter */
    LPTSTR ptrEnd;      /* A pointer to the last character of a parameter */
    BOOL bOrderByNoPar; /* A flag to indicate /O with no switch parameter */
    LPTSTR temp;
 
    /* Initialize parameter array */
    *params = NULL;
    *entries = 0;
 
    /* Initialize variables; */
    cCurSwitch = _T(' ');
    bNegative = FALSE;
    bPNegative = FALSE;
 
    /* We suppose that switch parameters
       were given to avoid setting them to default
       if the switch was not given */
    bOrderByNoPar = FALSE;
 
    /* Main Loop (see README_DIR.txt) */
    /* scan the command line char per char, and we process its char */
    while (*Line)
    {
        /* we save current character as it is and its upper case */
        cCurChar = *Line;
        cCurUChar = _totupper(*Line);
 
        /* 1st section (see README_DIR.txt) */
        /* When a switch is expecting */
        if (cCurSwitch == _T('/'))
        {
            while (_istspace(*Line))
                Line++;
 
            bNegative = (*Line == _T('-'));
            Line += bNegative;
 
            cCurChar = *Line;
            cCurUChar = _totupper(*Line);
 
            if ((cCurUChar == _T('A')) ||(cCurUChar == _T('T')) || (cCurUChar == _T('O')))
            {
                /* If positive, prepare for parameters... if negative, reset to defaults */
                switch (cCurUChar)
                {
                case _T('A'):
                    lpFlags->stAttribs.dwAttribVal = 0L;
                    lpFlags->stAttribs.dwAttribMask = 0L;
                    if (bNegative)
                        lpFlags->stAttribs.dwAttribMask = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
                    break;
                case _T('T'):
                    if (bNegative)
                        lpFlags->stTimeField.eTimeField = TF_MODIFIEDDATE;
                    break;
                case _T('O'):
                    bOrderByNoPar = !bNegative;
                    lpFlags->stOrderBy.sCriteriaCount = 0;
                    break;
                }
 
                if (!bNegative)
                {
                    /* Positive switch, so it can take parameters. */
                    cCurSwitch = cCurUChar;
                    Line++;
                    /* Skip optional leading colon */
                    if (*Line == _T(':'))
                        Line++;
                    continue;
                }
            }
            else if (cCurUChar == _T('L'))
                lpFlags->bLowerCase = ! bNegative;
            else if (cCurUChar == _T('B'))
                lpFlags->bBareFormat = ! bNegative;
            else if (cCurUChar == _T('C'))
                lpFlags->bTSeparator = ! bNegative;
            else if (cCurUChar == _T('W'))
                lpFlags->bWideList = ! bNegative;
            else if (cCurUChar == _T('D'))
                lpFlags->bWideListColSort = ! bNegative;
            else if (cCurUChar == _T('N'))
                lpFlags->bNewLongList = ! bNegative;
            else if (cCurUChar == _T('P'))
                lpFlags->bPause = ! bNegative;
            else if (cCurUChar == _T('Q'))
                lpFlags->bUser = ! bNegative;
            else if (cCurUChar == _T('S'))
                lpFlags->bRecursive = ! bNegative;
            else if (cCurUChar == _T('X'))
                lpFlags->bShortName = ! bNegative;
            else if (cCurUChar == _T('R'))
                lpFlags->bDataStreams = ! bNegative;
            else if (cCurChar == _T('4'))
                lpFlags->b4Digit = ! bNegative;
            else if (cCurChar == _T('?'))
            {
                DirHelp();
                return FALSE;
            }
            else
            {
                error_invalid_switch ((TCHAR)_totupper(*Line));
                return FALSE;
            }
 
            /* Make sure there's no extra characters at the end of the switch */
            if (Line[1] && Line[1] != _T('/') && !_istspace(Line[1]))
            {
                error_parameter_format(Line[1]);
                return FALSE;
            }
 
            cCurSwitch = _T(' ');
        }
        else if (cCurSwitch == _T(' '))
        {
            /* 2nd section (see README_DIR.txt) */
            /* We are expecting parameter or the unknown */
 
            if (cCurChar == _T('/'))
                cCurSwitch = _T('/');
            else if (_istspace(cCurChar))
                /* do nothing */;
            else
            {
                /* This is a file/directory name parameter. Find its end */
                ptrStart = Line;
                bIntoQuotes = FALSE;
                while (*Line)
                {
                    if (!bIntoQuotes && (*Line == _T('/') || _istspace(*Line)))
                        break;
                    bIntoQuotes ^= (*Line == _T('"'));
                    Line++;
                }
                ptrEnd = Line;
 
                /* Copy it to the entries list */
                temp = cmd_alloc((ptrEnd - ptrStart + 1) * sizeof(TCHAR));
                if (!temp)
                    return FALSE;
                memcpy(temp, ptrStart, (ptrEnd - ptrStart) * sizeof(TCHAR));
                temp[ptrEnd - ptrStart] = _T('\0');
                StripQuotes(temp);
                if (!add_entry(entries, params, temp))
                {
                    cmd_free(temp);
                    freep(*params);
                    return FALSE;
                }
 
                cmd_free(temp);
                continue;
            }
        }
        else
        {
            /* 3rd section (see README_DIR.txt) */
            /* We are waiting for switch parameters */
 
            /* Check if there are no more switch parameters */
            if ((cCurChar == _T('/')) || _istspace(cCurChar))
            {
                /* Wrong decision path, reprocess current character */
                cCurSwitch = _T(' ');
                continue;
            }
            /* Process parameter switch */
            switch (cCurSwitch)
            {
            case _T('A'):   /* Switch parameters for /A (attributes filter) */
                if (cCurChar == _T('-'))
                    bPNegative = TRUE;
                else if (cCurUChar == _T('D'))
                {
                    lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_DIRECTORY;
                    if (bPNegative)
                        lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_DIRECTORY;
                    else
                        lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_DIRECTORY;
                }
                else if (cCurUChar == _T('R'))
                {
                    lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_READONLY;
                    if (bPNegative)
                        lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_READONLY;
                    else
                        lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_READONLY;
                }
                else if (cCurUChar == _T('H'))
                {
                    lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_HIDDEN;
                    if (bPNegative)
                        lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_HIDDEN;
                    else
                        lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_HIDDEN;
                }
                else if (cCurUChar == _T('A'))
                {
                    lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_ARCHIVE;
                    if (bPNegative)
                        lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_ARCHIVE;
                    else
                        lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_ARCHIVE;
                }
                else if (cCurUChar == _T('S'))
                {
                    lpFlags->stAttribs.dwAttribMask |= FILE_ATTRIBUTE_SYSTEM;
                    if (bPNegative)
                        lpFlags->stAttribs.dwAttribVal &= ~FILE_ATTRIBUTE_SYSTEM;
                    else
                        lpFlags->stAttribs.dwAttribVal |= FILE_ATTRIBUTE_SYSTEM;
                }
                else
                {
                    error_parameter_format((TCHAR)_totupper (*Line));
                    return FALSE;
                }
                break;
            case _T('T'):   /* Switch parameters for /T (time field) */
                if (cCurUChar == _T('C'))
                    lpFlags->stTimeField.eTimeField= TF_CREATIONDATE ;
                else if (cCurUChar == _T('A'))
                    lpFlags->stTimeField.eTimeField= TF_LASTACCESSEDDATE ;
                else if (cCurUChar == _T('W'))
                    lpFlags->stTimeField.eTimeField= TF_MODIFIEDDATE  ;
                else
                {
                    error_parameter_format((TCHAR)_totupper (*Line));
                    return FALSE;
                }
                break;
            case _T('O'):   /* Switch parameters for /O (order) */
                /* Ok a switch parameter was given */
                bOrderByNoPar = FALSE;
 
                if (cCurChar == _T('-'))
                    bPNegative = TRUE;
                else if (cCurUChar == _T('N'))
                {
                    if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
                    lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
                    lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_NAME;
                }
                else if (cCurUChar == _T('S'))
                {
                    if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
                    lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
                    lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_SIZE;
                }
                else if (cCurUChar == _T('G'))
                {
                    if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
                    lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
                    lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_DIRECTORY;
                }
                else if (cCurUChar == _T('E'))
                {
                    if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
                    lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
                    lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_EXTENSION;
                }
                else if (cCurUChar == _T('D'))
                {
                    if (lpFlags->stOrderBy.sCriteriaCount < 3) lpFlags->stOrderBy.sCriteriaCount++;
                    lpFlags->stOrderBy.bCriteriaRev[lpFlags->stOrderBy.sCriteriaCount - 1] = bPNegative;
                    lpFlags->stOrderBy.eCriteria[lpFlags->stOrderBy.sCriteriaCount - 1] = ORDER_TIME;
                }
 
                else
                {
                    error_parameter_format((TCHAR)_totupper (*Line));
                    return FALSE;
                }
 
 
            }
            /* We check if we calculated the negative value and release the flag */
            if ((cCurChar != _T('-')) && bPNegative)
                bPNegative = FALSE;
        }
 
        Line++;
    }
 
    /* /O with no switch parameters acts like /O:GN */
    if (bOrderByNoPar)
    {
        lpFlags->stOrderBy.sCriteriaCount = 2;
        lpFlags->stOrderBy.eCriteria[0] = ORDER_DIRECTORY;
        lpFlags->stOrderBy.bCriteriaRev[0] = FALSE;
        lpFlags->stOrderBy.eCriteria[1] = ORDER_NAME;
        lpFlags->stOrderBy.bCriteriaRev[1] = FALSE;
    }
 
    return TRUE;
}

Referenced by CommandDir().

FormatDate()

INT FormatDate	(	TCHAR *	lpDate,
		LPSYSTEMTIME	dt,
		BOOL	b4Digit
	)

Definition at line 674 of file dir.c.

{
    /* Format date */
    WORD wYear = b4Digit ? dt->wYear : dt->wYear%100;
    switch (nDateFormat)
    {
        case 0: /* mmddyy */
        default:
            return _stprintf(lpDate, _T("%02d%c%02d%c%0*d"),
                    dt->wMonth, cDateSeparator,
                    dt->wDay, cDateSeparator,
                    b4Digit?4:2, wYear);
            break;
 
        case 1: /* ddmmyy */
            return _stprintf(lpDate, _T("%02d%c%02d%c%0*d"),
                    dt->wDay, cDateSeparator, dt->wMonth,
                    cDateSeparator, b4Digit?4:2, wYear);
            break;
 
        case 2: /* yymmdd */
            return _stprintf(lpDate, _T("%0*d%c%02d%c%02d"),
                    b4Digit?4:2, wYear, cDateSeparator,
                    dt->wMonth, cDateSeparator, dt->wDay);
            break;
    }
}

Referenced by DirPrintFileDateTime(), GetDateString(), and GetEnhancedVar().

FormatTime()

INT FormatTime	(	TCHAR *	lpTime,
		LPSYSTEMTIME	dt
	)

Definition at line 703 of file dir.c.

{
    /* Format Time */
    switch (nTimeFormat)
    {
        case 0: /* 12 hour format */
        default:
            return _stprintf(lpTime,_T("%02d%c%02u %cM"),
                    (dt->wHour == 0 ? 12 : (dt->wHour <= 12 ? dt->wHour : dt->wHour - 12)),
                    cTimeSeparator,
                     dt->wMinute, (dt->wHour <= 11 ? _T('A') : _T('P')));
            break;
 
        case 1: /* 24 hour format */
            return _stprintf(lpTime, _T("%02d%c%02u"),
                    dt->wHour, cTimeSeparator, dt->wMinute);
            break;
    }
}

Referenced by cmd_time(), DirPrintFileDateTime(), and GetEnhancedVar().

getExt()

TCHAR * getExt

(

const TCHAR *

file

)

Definition at line 829 of file dir.c.

{
    static TCHAR *NoExt = _T("");
    TCHAR* lastdot = _tcsrchr(file, _T('.'));
    return (lastdot != NULL ? lastdot + 1 : NoExt);
}

Referenced by CompareFiles(), and DirPrintOldList().

getName()

static LPTSTR getName ( const TCHAR *  file, TCHAR *  dest  )

static

Definition at line 842 of file dir.c.

{
    INT_PTR iLen;
    LPTSTR end;
 
    /* Check for dot-directories "." and ".." */
    if (IsDotDirectory(file))
    {
        _tcscpy(dest, file);
        return dest;
    }
 
    end = _tcsrchr(file, _T('.'));
    if (!end)
        iLen = _tcslen(file);
    else
        iLen = (end - file);
 
    _tcsncpy(dest, file, iLen);
    *(dest + iLen) = _T('\0');
 
    return dest;
}

Referenced by DirPrintOldList().

GetUserDiskFreeSpace()

static VOID GetUserDiskFreeSpace ( LPCTSTR  lpRoot, PULARGE_INTEGER  lpFreeSpace  )

static

Definition at line 725 of file dir.c.

{
    PGETFREEDISKSPACEEX pGetFreeDiskSpaceEx;
    HINSTANCE hInstance;
    DWORD dwSecPerCl;
    DWORD dwBytPerSec;
    DWORD dwFreeCl;
    DWORD dwTotCl;
    ULARGE_INTEGER TotalNumberOfBytes, TotalNumberOfFreeBytes;
 
    lpFreeSpace->QuadPart = 0;
 
    hInstance = GetModuleHandle(_T("KERNEL32"));
    if (hInstance != NULL)
    {
        pGetFreeDiskSpaceEx = (PGETFREEDISKSPACEEX)GetProcAddress(hInstance,
#ifdef _UNICODE
                                                "GetDiskFreeSpaceExW");
#else
                                                "GetDiskFreeSpaceExA");
#endif
        if (pGetFreeDiskSpaceEx != NULL)
        {
            if (pGetFreeDiskSpaceEx(lpRoot, lpFreeSpace, &TotalNumberOfBytes, &TotalNumberOfFreeBytes) != FALSE)
                return;
        }
    }
 
    GetDiskFreeSpace(lpRoot,
                     &dwSecPerCl,
                     &dwBytPerSec,
                     &dwFreeCl,
                     &dwTotCl);
 
    lpFreeSpace->QuadPart = dwSecPerCl * dwBytPerSec * dwFreeCl;
}

Referenced by PrintSummary().

IsDotDirectory()

FORCEINLINE BOOL IsDotDirectory

(

IN LPCTSTR

pszPath

)

Definition at line 239 of file dir.c.

{
    return (  pszPath[0] == _T('.') &&
            ( pszPath[1] == 0 || /* pszPath[1] == _T('\\') || */
             (pszPath[1] == _T('.') && (pszPath[2] == 0 /* || pszPath[2] == _T('\\') */))
            ) );
}

Referenced by DirList(), DirPrintBareList(), getName(), and ResolvePattern().

IsDotDirectoryN()

FORCEINLINE BOOL IsDotDirectoryN	(	IN const TCHAR *	pPath,
		IN SIZE_T	Length
	)

Definition at line 250 of file dir.c.

{
    return ((Length == 1 && pPath[0] == _T('.')) ||
            (Length == 2 && pPath[0] == _T('.') && pPath[1] == _T('.')));
}

Referenced by ResolvePattern().

PrintDirectoryHeader()

static BOOL PrintDirectoryHeader ( LPCTSTR  szPath, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 597 of file dir.c.

{
    TCHAR szMsg[RC_STRING_MAX_SIZE];
    LPCTSTR szFullDir;
    TCHAR szRootName[MAX_PATH];
    TCHAR szVolName[80];
    DWORD dwSerialNr;
 
    if (lpFlags->bBareFormat)
        return TRUE;
 
    szFullDir = szPath;
 
    /* Get the media ID of the drive */
    if (!GetVolumePathName(szFullDir, szRootName, ARRAYSIZE(szRootName)) ||
        !GetVolumeInformation(szRootName, szVolName, ARRAYSIZE(szVolName),
                              &dwSerialNr, NULL, NULL, NULL, 0))
    {
        return TRUE;
    }
 
    /* Print drive info */
    if (szVolName[0] != _T('\0'))
    {
        LoadString(CMD_ModuleHandle, STRING_DIR_HELP2, szMsg, ARRAYSIZE(szMsg));
        DirPrintf(lpFlags, szMsg, _totupper(szRootName[0]), szVolName);
    }
    else
    {
        LoadString(CMD_ModuleHandle, STRING_DIR_HELP3, szMsg, ARRAYSIZE(szMsg));
        DirPrintf(lpFlags, szMsg, _totupper(szRootName[0]));
    }
 
    /* Print the volume serial number if the return was successful */
    LoadString(CMD_ModuleHandle, STRING_DIR_HELP4, szMsg, ARRAYSIZE(szMsg));
    DirPrintf(lpFlags, szMsg, HIWORD(dwSerialNr), LOWORD(dwSerialNr));
 
    return TRUE;
}

Referenced by CommandDir().

PrintSummary()

static INT PrintSummary ( LPCTSTR  szPath, ULONG  ulFiles, ULONG  ulDirs, ULONGLONG  u64Bytes, LPDIRSWITCHFLAGS  lpFlags, BOOL  TotalSummary  )

static

Definition at line 770 of file dir.c.

{
    TCHAR szMsg[RC_STRING_MAX_SIZE];
    TCHAR szBuffer[64];
    ULARGE_INTEGER uliFree;
 
    /* Here we check if we didn't find anything */
    if (!(ulFiles + ulDirs))
    {
        if (!lpFlags->bRecursive || (TotalSummary && lpFlags->bRecursive))
            error_file_not_found();
        return 1;
    }
 
    /* In bare format we don't print results */
    if (lpFlags->bBareFormat)
        return 0;
 
    /* Print recursive specific results */
 
    /* Take this code offline to fix /S does not print double info */
    if (TotalSummary && lpFlags->bRecursive)
    {
        ConvertULargeInteger(u64Bytes, szBuffer, ARRAYSIZE(szBuffer), lpFlags->bTSeparator);
        LoadString(CMD_ModuleHandle, STRING_DIR_HELP5, szMsg, ARRAYSIZE(szMsg));
        DirPrintf(lpFlags, szMsg, ulFiles, szBuffer);
    }
    else
    {
        /* Print File Summary */
        /* Condition to print summary is:
        If we are not in bare format and if we have results! */
        ConvertULargeInteger(u64Bytes, szBuffer, ARRAYSIZE(szBuffer), lpFlags->bTSeparator);
        LoadString(CMD_ModuleHandle, STRING_DIR_HELP8, szMsg, ARRAYSIZE(szMsg));
        DirPrintf(lpFlags, szMsg, ulFiles, szBuffer);
    }
 
    /* Print total directories and free space */
    if (!lpFlags->bRecursive || TotalSummary)
    {
        GetUserDiskFreeSpace(szPath, &uliFree);
        ConvertULargeInteger(uliFree.QuadPart, szBuffer, ARRAYSIZE(szBuffer), lpFlags->bTSeparator);
        LoadString(CMD_ModuleHandle, STRING_DIR_HELP6, szMsg, ARRAYSIZE(szMsg));
        DirPrintf(lpFlags, szMsg, ulDirs, szBuffer);
    }
 
    return 0;
}

Referenced by CommandDir(), and DirList().

QsortFiles()

static VOID QsortFiles ( PDIRFINDINFO  ptrArray[], int  i, int  j, LPDIRSWITCHFLAGS  lpFlags  )

static

Definition at line 1293 of file dir.c.

{
    PDIRFINDINFO lpTemp;   /* A temporary pointer */
    BOOL Way;
 
    if (i < j)
    {
        int First = i, Last = j, Temp;
        Way = TRUE;
        while (i != j)
        {
            if (Way == CompareFiles(ptrArray[i], ptrArray[j], lpFlags))
            {
                /* Swap the pointers of the array */
                lpTemp = ptrArray[i];
                ptrArray[i]= ptrArray[j];
                ptrArray[j] = lpTemp;
 
                /* Swap the indexes for inverting sorting */
                Temp = i;
                i = j;
                j =Temp;
 
                Way = !Way;
            }
 
            j += (!Way - Way);
        }
 
        QsortFiles(ptrArray,First, i-1, lpFlags);
        QsortFiles(ptrArray,i+1,Last, lpFlags);
    }
}

Referenced by DirList(), and QsortFiles().

ResolvePattern()

static VOID ResolvePattern ( IN LPTSTR  pszPattern, IN DWORD  nBufferLength, OUT LPTSTR  pszFullPath, OUT LPTSTR *ppszPatternPart  OPTIONAL  )

static

Definition at line 1610 of file dir.c.

{
    LPTSTR pCurDir, pNextDir, ptr;
    LPTSTR pszPatternPart;
    TCHAR  szNewPattern[MAX_PATH];
 
    /*
     * We are going to use GetFullPathName() to properly determine the actual
     * full path from the pattern. However, due to the fact GetFullPathName()
     * strips parts of the file name component in case the pattern contains
     * path specification with trailing dots, it is required to perform a
     * pre-treatment on the pattern and a post-treatment on the obtained path.
     * This is mandatory in order to use the correct file search criterion.
     *
     * One particular case is when the pattern specifies a dots-only directory
     * followed by either the "." or ".." special directories. In this case the
     * GetFullPathName() function may completely miss the dots-only directory.
     * An example is given by the pattern (C-string notation) "\\...\\." .
     * To cope with this problem we need to partially canonicalize the pattern
     * by collapsing any "." or ".." special directory that immediately follows
     * a dots-only directory. We collapse in addition consecutive backslashes.
     *
     * Finally, trailing dots are skipped by GetFullPathName(). Therefore
     * a pattern that matches files with no extension, for example: "*." ,
     * or: "dir\\noextfile." , are reduced to simply "*" or "dir\\noextfile",
     * that match files with extensions. Or, a pattern specifying a trailing
     * dots-only directory: "dir\\..." gets completely ignored and only the
     * full path to "dir" is returned.
     * To fix this second problem we need to restore the last part of the path
     * pattern using the pattern that has been first partially canonicalized.
     *
     * Note however that the "." or ".." special directories are always
     * interpreted correctly by GetFullPathName().
     */
 
    /* Make a copy of the path pattern */
    ASSERT(_tcslen(pszPattern) < ARRAYSIZE(szNewPattern));
    _tcscpy(szNewPattern, pszPattern);
    pszPattern = szNewPattern;
 
    TRACE("Original pszPattern: %S\n", pszPattern);
 
    /* Convert slashes into backslashes */
    pNextDir = pszPattern;
    while ((pNextDir = _tcschr(pNextDir, _T('/'))))
        *pNextDir++ = _T('\\');
 
    /*
     * Find any dots-only directory and collapse any "." or ".." special
     * directory that immediately follows it.
     * Note that we just start looking after the first path separator. Indeed,
     * dots-only directories that are not preceded by a path separator, and so
     * appear first in the pattern, for example: "...\dir", or: "..." , are
     * either correctly handled by GetFullPathName() because they are followed
     * by a non-pathological directory, or because they are handled when we
     * restore the trailing dots pattern piece in the next step.
     */
    pNextDir = pszPattern;
    while (pNextDir)
    {
        pCurDir = pNextDir;
 
        /* Find the next path separator in the pattern */
        pNextDir = _tcschr(pNextDir, _T('\\'));
        if (!pNextDir)
            break;
 
        /* Ignore the special "." and ".." directories that are correctly handled */
        if ((pNextDir - pCurDir == 0) || IsDotDirectoryN(pCurDir, pNextDir - pCurDir))
        {
            /* Found such a directory, ignore */
            ++pNextDir;
            continue;
        }
 
        /* Check whether this is a dots-only directory */
        for (ptr = pCurDir; ptr < pNextDir; ++ptr)
        {
            if (*ptr != _T('.'))
                break;
        }
        if (ptr < pNextDir)
        {
            /* Not a dots-only directory, ignore */
            ++pNextDir;
            continue;
        }
 
        /* Skip any consecutive backslashes */
        for (ptr = pNextDir; *ptr == _T('\\'); ++ptr) ;
 
        /* pCurDir is a dots-only directory, perform partial canonicalization */
 
        /* Remove any following "." directory */
        if (ptr[0] == _T('.') && (ptr[1] == _T('\\') || ptr[1] == 0))
        {
            memmove(pNextDir, ptr + 1, (_tcslen(ptr + 1) + 1) * sizeof(TCHAR));
        }
        /* Remove any following ".." directory */
        else if (ptr[0] == _T('.') && ptr[1] == _T('.') && (ptr[2] == _T('\\') || ptr[2] == 0))
        {
            /* Skip any consecutive backslashes before the next directory */
            for (ptr = ptr + 2; *ptr == _T('\\'); ++ptr) ;
 
            memmove(pCurDir, ptr, (_tcslen(ptr) + 1) * sizeof(TCHAR));
            pNextDir = pCurDir;
        }
        else
        {
            ++pNextDir;
 
            /* Collapse consecutive backslashes */
            if (ptr > pNextDir)
                memmove(pNextDir, ptr, (_tcslen(ptr) + 1) * sizeof(TCHAR));
        }
    }
 
    /* An empty pattern means we enumerate all files in the current directory */
    if (!*pszPattern)
        _tcscpy(pszPattern, _T("*"));
 
    TRACE("New pszPattern: %S\n", pszPattern);
 
    /* Create the full path */
    if (GetFullPathName(pszPattern, nBufferLength, pszFullPath, &pszPatternPart) == 0)
    {
        _tcscpy(pszFullPath, pszPattern);
        pszPatternPart = NULL;
    }
 
    TRACE("pszFullPath (1): %S\n", pszFullPath);
    TRACE("pszPatternPart (1): %S\n", pszPatternPart);
 
    /*
     * Restore the correct file name component in case the pattern contained
     * trailing dots that have been skipped by GetFullPathName().
     */
 
    /* Find the last path separator in the original szPath */
    pNextDir = _tcsrchr(pszPattern, _T('\\'));
    if (pNextDir)
    {
        /* Skip past the separator and look at the path */
        ++pNextDir;
    }
    else
    {
        /* The pattern is the path we need to look at */
        pNextDir = pszPattern;
    }
 
    /*
     * When pszPatternPart == NULL this means that pszFullPath should be a
     * directory; however it might have happened that the original pattern
     * was specifying a dots-only directory, that has been stripped off by
     * GetFullPathName(). In both these cases we need to restore these as
     * they are part of the actual directory path; the exception being if
     * these are the special "." or ".." directories.
     */
    if (_istalpha(pNextDir[0]) && pNextDir[1] == _T(':') && pNextDir[2] != _T('\\'))
    {
        /*
         * The syntax "<drive_letter>:" without any trailing backslash actually
         * means: "current directory on this drive".
         */
    }
    else if (pszPatternPart == NULL)
    {
        ASSERT(pszFullPath[_tcslen(pszFullPath)-1] == _T('\\'));
 
        /* Anything NOT being "." or ".." (the special directories) must be fully restored */
        if (*pNextDir && !IsDotDirectory(pNextDir))
        {
            pszPatternPart = &pszFullPath[_tcslen(pszFullPath)];
            _tcscpy(pszPatternPart, pNextDir);
            pszPatternPart = NULL;
        }
    }
    else if (_tcscmp(pNextDir, pszPatternPart) != 0)
    {
        /*
         * For example, pszPatternPart == "." or ".." and we do not need to
         * do anything for these, or pszPatternPart == "dir\\noextfile." and
         * we need to restore all the trailing points.
         */
        TRACE("pszPatternPart: %S is DIFFERENT from file criterion: %S\n", pszPatternPart, pNextDir);
 
        /* Anything NOT being "." or ".." (the special directories) must be fully restored */
        if (*pNextDir && !IsDotDirectory(pNextDir))
        {
            /* Restore the correct file criterion */
            _tcscpy(pszPatternPart, pNextDir);
        }
    }
 
    TRACE("pszFullPath (2): %S\n", pszFullPath);
 
    /*
     * If no wildcard or file was specified and this is a directory,
     * display all files in it.
     */
    if (pszPatternPart == NULL || IsExistingDirectory(pszFullPath))
    {
        pszPatternPart = &pszFullPath[_tcslen(pszFullPath)];
        if (pszPatternPart[-1] != _T('\\'))
            *pszPatternPart++ = _T('\\');
        _tcscpy(pszPatternPart, _T("*"));
    }
 
    TRACE("pszPatternPart (2): %S\n", pszPatternPart);
 
    if (ppszPatternPart)
        *ppszPatternPart = pszPatternPart;
}

Referenced by CommandDir().

Variable Documentation

recurse_bytes

ULONGLONG recurse_bytes

static

Definition at line 222 of file dir.c.

Referenced by CommandDir(), and DirList().

recurse_dir_cnt

ULONG recurse_dir_cnt

static

Definition at line 220 of file dir.c.

Referenced by CommandDir(), and DirList().

recurse_file_cnt

ULONG recurse_file_cnt

static

Definition at line 221 of file dir.c.

Referenced by CommandDir(), and DirList().