FileDir.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: Comprehensive file directory tree using DLinkList.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/FileDir.h>
#include <uLib/UtilFunc.h>
#include <uLib/StrFunc.h>
#include <uLib/LargeInt.h>
#include <uLib/Debug.h>

#define FILEDIR_VER  3

static CCSTR ANY_FNAME = _T("*.*");
ScanDirCtx _defScanCtx; // Default scanning context if none provided.

ScanDirCtx::ScanDirCtx( UINT Depth )
{
    MaxNest = Depth;
    NestDepth = 0;
    Flags = SCF_FILES| SCF_DIRS;
    UserData = NULL;
    ErrorDirs = NULL;
    memset( CurrentDir, 0, sizeof(CurrentDir) );
    PathEnd = CurrentDir;
}

ScanDirCtx::~ScanDirCtx()
{
    if (ErrorDirs)
    {
        ErrorDirs->RemoveAll( StringEntry::_delete );
        delete ErrorDirs;
    }
}

//==---------------------------------------------------------------------------

PFileEntry __stdcall __new_FileEntry( LPWIN32_FIND_DATA pfd, PDirEntry pDir, PScanDirCtx pCtx ) {
    return new FileEntry( pfd, pDir, pCtx );
    }
PDirEntry  __stdcall __new_DirEntry( LPWIN32_FIND_DATA pfd, PDirEntry pDir, PScanDirCtx pCtx ) {
    return new DirEntry( pfd, pDir, pCtx );
    }

// Two function pointers to allow DirEntry/FileEntry polymorphism during Scan().

PFileEntry (__stdcall *NewFileEntry)( LPWIN32_FIND_DATA pfd, PDirEntry pDir, PScanDirCtx pCtx )
    = __new_FileEntry;

PDirEntry (__stdcall *NewDirEntry)( LPWIN32_FIND_DATA pfd, PDirEntry pDir, PScanDirCtx pCtx )
    = __new_DirEntry;

// DLinkList::QuickSort callback to sort directories alphabetically.

static int __stdcall __sort_DirEntry( PLIST_ENTRY X, PLIST_ENTRY Y, void* pData )
{
    PDirEntry pItem1 = (PDirEntry)X, pItem2 = (PDirEntry)Y;
    int rc = 0;
    if (pItem1 && pItem2) { // Case insensitive alphabetical sort
        rc = _tcsicmp( pItem1->Name, pItem2->Name );
    } else { // Handle the error gracefully. (This case has *never* occured.)
        if (pItem1) rc = -1; else if (pItem2) rc = 1;
    }
    return rc;
}

//==---------------------------------------------------------------------------
#if _DEBUG // Debugging utility callbacks
//==---------------------------------------------------------------------------

bool __stdcall FileEntry::_dump( PLIST_ENTRY Entry, void* pData )
{
    PFileEntry pFile = (PFileEntry) Entry;
    if (pFile) {
      #if 0 // Show full file pathname
        TCHAR pathname[ MAX_PATH ];
        pFile->GetPathName( pathname, MAX_PATH );
        DPrint( DP_DEBUG, _T("  File: %s\r\n"), pathname );
      #else
        DPrint( DP_DEBUG, _T("  File: %s\r\n"), pFile->Name );
      #endif
    }
    return true;
}

bool __stdcall DirEntry::_dump( PLIST_ENTRY Entry, void* pData )
{
    PDirEntry pDir = (PDirEntry) Entry;
    if (pDir) {
      #if 1 // Show full directory path
        TCHAR path[ MAX_PATH ];
        pDir->GetFullPath( path, MAX_PATH );
        DPrint( DP_DEBUG, _T("Dir: %s\r\n"), path );
      #else
        DPrint( DP_DEBUG, _T("Dir: %s\r\n"), pDir->Name );
      #endif
        if (pDir->SubDir) pDir->SubDir->ForEach( DirEntry::_dump );
        if (pDir->Files) pDir->Files->ForEach( FileEntry::_dump );
    }
    return true;
}
#endif //_DEBUG

//==---------------------------------------------------------------------------
//  FileEntry
//==---------------------------------------------------------------------------

PFnFileAddAction FileEntry::AddAction = NULL; // static
PFnFileAction    FileEntry::DelAction = NULL; // static

void FileEntry::_init( CSTR name, PDirEntry dir )
{
    //Flink = Blink = PLIST_ENTRY(&Flink);
    InitializeListEntry( this ); // Flink = Blink = this;
    //
    // Note: (this) != (&Flink), since FileEntry has a virtual destructor,
    // which means it must have a v-table, and (this) points to *it* rather
    // than the first data member, which is an unfortunate design choice
    // in the compiler. It would have been better to put the v-table
    // pointer at (this-sizeof(ptr)) so that (this) always pointed to
    // the member data, whether the class had a v-table or not.
    //
    pData = NULL;
    pDir = dir; // Back pointer to containing directory
    Rename( name );
  #if USE_FILE_ENTRY_SIZEATTR
    Size = 0;
    Attr = 0;
    //Time = uLib::LargeInt( 0 );
    Time = uLib::Now( uLib::SYSTEM_TIME );
  #endif
}

FileEntry::FileEntry( CSTR name, PDirEntry dir, PScanDirCtx pCtx )
: Name( NULL ), Ext( NULL )
{
    _init( name, dir );
    UNUSED( pCtx );
}

FileEntry::FileEntry( LPWIN32_FIND_DATA pfd, PDirEntry dir, PScanDirCtx pCtx )
: Name( NULL ), Ext( NULL )
{
    _init( pfd->cFileName, dir );
  #if USE_FILE_ENTRY_SIZEATTR
    Attr =  pfd->dwFileAttributes;
    ULARGE_INTEGER ul = {{ pfd->nFileSizeLow, pfd->nFileSizeHigh }};
    Size = ul.QuadPart;
    Time = pfd->ftLastWriteTime;
  #endif
    UNUSED( pCtx );
}

FileEntry::~FileEntry()
{
    if (DelAction) DelAction( this, NULL ); // Callback
    // PONDER: [uLib:FileDir.cpp] It there a way to pass the pCtx without storing it in every FileEntry..?
    Name = deleteStr( Name );
}

bool __stdcall FileEntry::_delete( PLIST_ENTRY Entry, void* pData ) // static
{
    PFileEntry pFile = (PFileEntry) Entry;
    if (pFile) delete pFile;
    return true;
}

CSTR FileEntry::Rename( CSTR newName )
{
    CSTR pNewName = newStr( newName );
    if (pNewName)
    {
        deleteStr( Name );
        Name = pNewName;
        Ext = _tcsrchr( Name, DOT );
        if (!Ext) Ext = _tcschr( Name, 0 );
    }
    return pNewName;
}

bool FileEntry::RemoveFromParent() // Remove this from it's containing DLinkList
{
    bool ok = (pDir != NULL && pDir->Files != NULL);
    IF_DEBUG( if (!ok) DPrint( DP_ERROR, _F("Orphaned entry: %s\n"), Name ); )

    PLIST_ENTRY pEntry = ok ? pDir->Files->RemoveEntry( this ) : NULL;
    return (pEntry != NULL);
}

UINT FileEntry::GetPathName( TSTR Buff, UINT BufLen ) // Full path name for this file
{
    UINT len = 0;
    if (pDir) {
        len = pDir->GetFullPath( Buff, BufLen );
        if (len)
        {
            _tcscpy_s( &Buff[len], BufLen-len, Name );
            len += (UINT)_tcslen( Name );
        }
    } else {
        len = (UINT)_tcslen( Name );
        _tcscpy_s( Buff, BufLen, Name );
    }
    return len;
}

bool FileEntry::GetFindData( LPWIN32_FIND_DATA pFData )
{
    TCHAR fullName[ MAX_PATH ];
    bool ok = (GetPathName( fullName, dimof(fullName) ) > 0);
    if (ok) ok = GetWin32FileData( fullName, pFData );
    return ok;
}

//==---------------------------------------------------------------------------
//  DirEntry
//==---------------------------------------------------------------------------

PFnDirAddAction DirEntry::AddAction = NULL; // static
PFnDirAction    DirEntry::DelAction = NULL; // static
PFnAbortScan    DirEntry::Abort = NULL;     // static

void DirEntry::_init( CSTR name, PDirEntry parent )
{
    InitializeListEntry( this ); //Flink = Blink = this;
    SubDir = Files = NULL;
    pData = NULL;
    pParent = parent; // Back pointer to parent directory
    Name = newStr( name );
  #if USE_FILE_ENTRY_SIZEATTR
    Attr = 0;
  #endif
}

DirEntry::DirEntry( CSTR name, PDirEntry parent, PScanDirCtx pCtx )
{
    _init( name, parent );
    UNUSED( pCtx );
}

DirEntry::DirEntry( LPWIN32_FIND_DATA pfd, PDirEntry parent, PScanDirCtx pCtx )
{
    _init( pfd->cFileName, parent );
  #if USE_FILE_ENTRY_SIZEATTR
    Attr = pfd->dwFileAttributes;
  #endif
    UNUSED( pCtx );
}

DirEntry::~DirEntry()
{
    if (DelAction) DelAction( this, NULL ); // Call while node data still exist.
    // PONDER: [uLib:FileDir.cpp]
    // Is there a way to pass the pCtx here without storing it in every DirEntry..?
    // Put the pCtx in thread local storage ?

    if (SubDir)
    {
        SubDir->RemoveAll( DirEntry::_delete ); // Recursive...
        delete SubDir;
    }
    if (Files)
    {
        Files->RemoveAll( FileEntry::_delete );
        delete Files;
    }
    Name = deleteStr( Name );
}

bool __stdcall DirEntry::_delete( PLIST_ENTRY Entry, void* pData ) // static
{
    PDirEntry pDir = (PDirEntry) Entry;
    if (pDir) delete pDir; // Note: The recursion occurs here..
    return true;
}

//#
//# ScanDir is the main (static) entry point for building a directory file tree
//#

#if (FILEDIR_VER == 1)
PDirEntry DirEntry::ScanDir(
    CSTR BaseDir, UINT Depth, PDirEntry Parent, PUINT pCount, PScanDirCtx pCtx
    )
{
    PDirEntry pDir = NULL;
    UINT nFiles = 0;

    CSTR orgDir = ChangeDirectory( BaseDir ); // Safe: orgDir allocated as needed
    if (orgDir) // NULL means SetCurrentDirectory failed, or out of memory.
    {
        if (!pCtx) pCtx = &_defScanCtx;
        if (!pCtx->Flags) pCtx->Flags = SCF_FILES| SCF_DIRS;
        pCtx->MaxNest = Depth ? Depth : MAX_DIRECTORY_DEPTH;
        pCtx->NestDepth = 0;

        WIN32_FIND_DATA fd = {0};
        GetWin32FileData( BaseDir, &fd );
        _tcscpy_s( fd.cFileName, dimof(fd.cFileName), WithoutBackslash( BaseDir )); // Full path.
        pDir = NewDirEntry( &fd, Parent );
        if (pDir)
        {
            nFiles = pDir->Scan( pCtx ); // Recursively scan the whole branch
          #if 1 // Sort the first level of the tree
            if (pDir->SubDir)
                pDir->SubDir->QuickSort( __sort_DirEntry, NULL );
          #endif
        }
        orgDir = DoneDirectory( orgDir );
    }
    if (pCount) *pCount = nFiles;
    return pDir;
}
#else // v2++ : Per-thread current directory
  #ifdef _WIN64
    #define DISABLE_FS_REDIR 0
  #elif !defined( DISABLE_FS_REDIR )
    #if _WIN32_WINNT >= 0x0501 || defined(WINBASE_DECLARE_GET_SYSTEM_WOW64_DIRECTORY)
      #define DISABLE_FS_REDIR 1
    #else
      #define DISABLE_FS_REDIR 0
    #endif
  #endif

  #if 1
    PDirEntry DirEntry::ScanDir(
        CSTR BaseDir, UINT Depth, PDirEntry Parent, PUINT pCount, PScanDirCtx pCtx
        )
    {
        PDirEntry pDir = NULL;
        UINT nFiles = 0;

        if (!pCtx) pCtx = &_defScanCtx;
        if (!pCtx->Flags) pCtx->Flags = SCF_FILES| SCF_DIRS;
        pCtx->PathEnd = pCtx->CurrentDir;
        *pCtx->PathEnd = 0;
        pCtx->MaxNest = Depth ? Depth : MAX_DIRECTORY_DEPTH;
        pCtx->NestDepth = 0;

        WIN32_FIND_DATA fd;
        IF_DEBUG( memset( &fd, 0, sizeof(fd) ));
        GetWin32FileData( BaseDir, &fd );
        _tcsncpyz( fd.cFileName, WithoutBackslash( BaseDir ), dimof(fd.cFileName) );

        pDir = NewDirEntry( &fd, Parent, pCtx );
        if (pDir)
        {
          #if DISABLE_FS_REDIR
            // PONDER: Include this, or leave it up to application to call it?
            // In the latter case, include a notice in ScanDir doc.

            //PVOID prdVal;
            //BOOL prdOk = Wow64DisableWow64FsRedirection( &prdVal );
          #endif

            nFiles = pDir->Scan( pCtx ); // Recursively scan the whole branch

          #if DISABLE_FS_REDIR
            //prdOk = Wow64RevertWow64FsRedirection( prdVal );
          #endif
          #if 1 // Sort the first level of the tree
            if (pDir->SubDir)
                pDir->SubDir->QuickSort( __sort_DirEntry, NULL );
          #endif
        }

        if (pCount) *pCount = nFiles;
        return pDir;
    }
  #else //SCF_SPLIT
    PDirEntry DirEntry::ScanDir(
        CSTR BaseDir, UINT Depth, PDirEntry Parent, PUINT pCount, PScanDirCtx pCtx
        )
    {
        PDirEntry pDir = NULL;
        UINT nFiles = 0;

        if (!pCtx) pCtx = &_defScanCtx;
        if (!pCtx->Flags) pCtx->Flags = SCF_FILES| SCF_DIRS;
        pCtx->PathEnd = pCtx->CurrentDir;
        *pCtx->PathEnd = 0;
        pCtx->MaxNest = Depth ? Depth : MAX_DIRECTORY_DEPTH;
        pCtx->NestDepth = 0;

        WIN32_FIND_DATA fd = {0};
        if (!HAVE_BITS( pCtx->Flags, SCF_SPLIT))
        {
            GetWin32FileData( BaseDir, &fd );
            _tcsncpyz( fd.cFileName, WithoutBackslash( BaseDir ), dimof(fd.cFileName) );
            pDir = NewDirEntry( &fd, Parent, pCtx );
            if (pDir)
            {
                nFiles = pDir->Scan( pCtx ); // Recursively scan the whole branch

                #if 1 // Sort the first level of the tree
                if (pDir->SubDir)
                    pDir->SubDir->QuickSort( __sort_DirEntry, NULL );
                #endif
            }
        }
        else // SCF_SPLIT
        {
            // Still under consideration...
            // Split composite root into subdir hierarchy
            // Create empty dir nodes for each subpath in Basedir,
            // and commence scanning at the last one (Basedir).
            // Finally return ptr to the first (root) dirnode created.
        }

        if (pCount) *pCount = nFiles;
        return pDir;
    }
  #endif
#endif

// Used by DirEntry::Scan to log access errors.

static void LogScanError( CSTR Op, CSTR subDir, PScanDirCtx pCtx )
{
    DWORD err = GetLastError();
    CSTR pathBuf = pCtx->CurrentDir;
    *pCtx->PathEnd = 0; // Cut away "*.*" temporarily

    // FIXME: LogScanError is susceptible to oversize pathnames and may go GPF.
    // F.ex: GPF occurred after encountering a "recursive symlink" file structure flaw..

    if (!pCtx->ErrorDirs) pCtx->ErrorDirs = new DLinkList;
    if (pCtx->ErrorDirs) pCtx->ErrorDirs->Append( new StringEntry( pathBuf, err ));

    TRACE( DP_ERROR, _T("%s (%s) failed: %s\n"), Op, pathBuf, SysErrorMsg( err ));
    *pCtx->PathEnd = _T('*'); // Put it back
}

// PONDER: Change doc strategy to put lengthy details in the .cpp rather than the .h ??

//-! <p> DirEntry::Scan is the workhorse of the FileDir hierarchy.\n
//-! It recursively scans the path specified in the constructor, to the depth\n
//-! specified in pCtx, adding files and subdirectories to the appropriate lists.\n
//-! The creation of entries are handled by NewDirEntry/NewFileEntry function pointers,\n
//-! thus enabling polymorphism or entry filtering by using customized functions.\n
//-! In addition, new entries can have optional post-creation action functions\n
//-! invoked, to perform additional initialization for descendant custom entries,\n
//-! and the scan is abortable by an installable function.\n

UINT DirEntry::Scan( PScanDirCtx pCtx )
{
    // Performance profile: DirEntry overhead is small.
    // The lion's share of CPU time is FindFirstFile/FindMoreFiles.
    // Stats from Xeon E3 @ 3.1/3.4 GHz:
    // FindFirstFile takes ~112.8 QPC ticks, and FindMoreFiles ~44.7 ticks.
    // Adding a DirEntry takes ~4.68 QPC ticks (mostly malloc).
    // Adding a FileEntry takes ~4.124 QPC ticks (mostly malloc).

    HANDLE hf; // FindFile handle.
    WIN32_FIND_DATA fd;

    UINT N = 0;
    pCtx->NestDepth++;
    if (pCtx->Flags && (pCtx->NestDepth <= pCtx->MaxNest))
    {
        // Update per-context current dir..

        CSTR dirName = WithBackslash( Name );
        TSTR pathEnd = pCtx->PathEnd;
        long int ccRemain = dimof(pCtx->CurrentDir) - CharIndex( pCtx->CurrentDir, pathEnd );
        // Check that there's enough buffer space left over...
        if (ccRemain < ((long)_tcslen( dirName ) + 4 )) // +4 since we need to add a "*.*" and NUL.
        {
            TRACE( DP_ERROR, _F("Concatenated path too long: %s + %s\\*.*\n"), pCtx->CurrentDir, dirName );
            BREAK();
            goto done_Scan; // Bypasses init of 'hf'. That's ok, since we're not gonna touch it.
        }
        pCtx->PathEnd = _tcsnecpy( pathEnd, dirName, ccRemain );
        _tcsncpyz( pCtx->PathEnd, ANY_FNAME, ccRemain - _tcslen( dirName )); // add "*.*"

        // Enter recursive scanner..

        hf = CheckHandle( FindFirstFile( pCtx->CurrentDir, &fd )); // ~112.8 QPC ticks
        if (!hf)
            LogScanError(_T("[DirEntry::Scan] FindFirstFile"), NULL, pCtx );
        else do {
            if (IsDir( &fd )) {
                if (pCtx->Flags & SCF_DIRS) {
                    if (IsSubdirName( fd.cFileName )) // Exclude "." and ".."
                    {
                        PDirEntry pDir = NewDirEntry( &fd, this, pCtx );
                        if (pDir)
                        {
                            if (!SubDir) SubDir = new DLinkList();
                            SubDir->Append( pDir );
                            if (DirEntry::AddAction)
                            {
                                if (!DirEntry::AddAction( pDir, &fd, pCtx )) // Callback
                                {
                                    pCtx->Flags &= ~SCF_DIRS; // Stop adding DirEntries
                                    goto done_Scan;
                                }
                            }
                            N += pDir->Scan( pCtx ); // RECURSION
                        }
                    }
                }
            } else {
                if (pCtx->Flags & SCF_FILES)
                {
                    PFileEntry pFile = NewFileEntry( &fd, this, pCtx );
                    if (pFile)
                    {
                        if (!Files) Files = new DLinkList();
                        Files->Append( pFile );
                        if (FileEntry::AddAction)
                        {
                            if (!FileEntry::AddAction( pFile, &fd, pCtx )) // Callback
                            {
                                pCtx->Flags &= ~SCF_FILES; // Stop adding FileEntries
                                goto done_Scan;
                            }
                        }
                        N++;
                    }
                }
            }
            if (Abort) if (Abort( this, pCtx )) break;

        } while( FindMoreFiles( hf, &fd /*,3*/ )); // ~44.7 ticks
    done_Scan:
        pCtx->PathEnd = pathEnd;
        *pathEnd = 0;
    }
    pCtx->NestDepth--;
    return N;
}

CSTR DirEntry::GetName()
{
    CSTR pName;
    if (pParent) pName = Name; // Subdirs don't have a composite path
    else
    {
        pName = _tcsrchr( Name, BSLASH ); // Base dirs may have composite path.
      #if 1
        if (pName) pName++; else pName = Name; // Last subpath directory name.
      #else
        // Cope with cases where Name could have a terminal backslash.
        // Note: ScanDir always removes any terminal backslash from a base dir,
        // making this just a forward precution against future mishaps.
        if (!pName) pName = Name;
        else
        {
            if (!*(++pName)) // Name with a terminal backslash produce an empty string.
            {
                TSTR pz = (TSTR) pName - 2; // Don't wanna mess up Name, so keep BSLASH
                while( *pz != BSLASH && pz > Name ) pz--;
                pName = pz + 1;
            }
        }
      #endif
    }
    return pName;
}

BEGIN_STRSAFE_OVERRIDE

// DirEntry::GetFullPath - Get full path (from base) for this dir.
// Always end it with a backslash.

static UINT _add_DirEntryToPath( PDirEntry pDir, TSTR& pDst, INT& remain )
{
    // Copy dir name to the end of the buffer.
    // NOTA BENE: Can *not* use strcpy_s for this, since it clobbers the buffer.

    UINT N = (UINT)_tcslen( pDir->Name );
    if ((remain -= N) < 0) return 0;

    pDst -= N; // Move back to subpath insert point.
    _tcsncpy( pDst, pDir->Name, N ); // Add subpath (excl. terminator)
    if (pDir->pParent) *--pDst = BSLASH; // Prepend with backslash

    return N;
}

UINT DirEntry::GetFullPath( TSTR Buffer, UINT BufLen )
{
    if (!Buffer || !BufLen) {
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
        }
    // We'll build the concatenated path at the *end* of the buffer,
    // proceeding backwards for each level, and finally copy the
    // resulting path to the front of the buffer.

    PDirEntry pPrev;
    INT  remain = BufLen-1;
    TSTR pDst = Buffer + remain; // Point to *end* of buffer

    *pDst-- = 0;
    *pDst = BSLASH; // Add terminal backslash.

    if (!_add_DirEntryToPath( this, pDst, remain ))
        goto gfp_Failure;

    // Backtrack to base DirEntry (which has pParent == NULL),
    // prepending each part in front of the previous.

    pPrev = pParent;
    while( pPrev )
    {
        if (!_add_DirEntryToPath( pPrev, pDst, remain ))
            goto gfp_Failure;
        pPrev = pPrev->pParent;
    }

    _tcscpy( Buffer, pDst ); // Copy result to front of buffer.
    // NOTA BENE: Can *not* use _tcscpy_s for this, since it clobbers the buffer.
    return (UINT)_tcslen( Buffer );

gfp_Failure:
    *Buffer = 0;
    SetLastError( ERROR_INSUFFICIENT_BUFFER );
    return 0;
}

END_STRSAFE_OVERRIDE

//==---------------------------------------------------------------------------

static bool __stdcall __count_Dirs( PLIST_ENTRY Entry, void* pData )
{
    PDirEntry pDir = (PDirEntry) Entry;
    IF_DEBUG( if (!pDir) DebugBreak(); ) // Should not be possible

    if (pDir && pDir->SubDir)
    {
        *(PUINT)pData += pDir->SubDir->Count;
        pDir->SubDir->ForEach( __count_Dirs, pData );
    }
    return true;
}
UINT DirEntry::GetBranchCount()  // Get recursive count of subdirectories (excl this).
{
    UINT nDirs = 0; // Exclude this directory
    __count_Dirs( this, &nDirs );
    return nDirs;
}

static bool __stdcall __count_Files( PLIST_ENTRY Entry, void* pData )
{
    PDirEntry pDir = (PDirEntry) Entry;
    IF_DEBUG( if (!pDir) DebugBreak(); )
    // pDir NULL is only possible if someone forces it
    // in on purpose, but better safe than sorry.
    if (pDir)
    {
        if (pDir->Files)
            *(PUINT)pData += pDir->Files->Count;
        if (pDir->SubDir)
            pDir->SubDir->ForEach( __count_Files, pData );
    }
    return true;
}
UINT DirEntry::GetFileCount() // Get recursive count of files.
{
    UINT nFiles = 0;
    __count_Files( this, &nFiles );
    return nFiles;
}

static bool __stdcall __accumulate_FileSize( PLIST_ENTRY Entry, void* pData )
{
    PFileEntry pFile = (PFileEntry) Entry;
    *(PUINT64)pData += pFile->Size;
    return true;
}
UINT64 DirEntry::GetSizeOfFiles() // Accumulated size of contained files.
{
    UINT64 size = 0;
    if (Files) Files->ForEach( __accumulate_FileSize, &size );
    return size;
}

static bool __stdcall __accumulate_DirSize( PLIST_ENTRY Entry, void* pData )
{
    PDirEntry pDir = (PDirEntry) Entry;
    PUINT64 pSize = (PUINT64) pData;
    *pSize += pDir->GetSizeOfFiles();
    if (pDir->SubDir) pDir->SubDir->ForEach( __accumulate_DirSize, pSize ); // Recurse
    return true;
}
UINT64 DirEntry::GetSizeOfBranch() // Total recursive size of branch files.
{
    UINT64 size = 0;
    __accumulate_DirSize( this, &size );
    return size;
}

PDirEntry DirEntry::AddSubDir( CSTR pzDir, PScanDirCtx pCtx )
{
    PDirEntry Entry = NULL;
    WIN32_FIND_DATA fd;
    memset( &fd, 0, sizeof(fd) );

    _tcscpy_s( fd.cFileName, dimof(fd.cFileName), pzDir );
    fd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;

    Entry = NewDirEntry( &fd, this, pCtx );
    if (Entry)
    {
        if (!SubDir) SubDir = new DLinkList();
        SubDir->Append( Entry );
    }
    return Entry;
}

PFileEntry DirEntry::AddFile( LPWIN32_FIND_DATA pFd, PScanDirCtx pCtx )
{
    PFileEntry Entry = NewFileEntry( pFd, this, pCtx );
    if (Entry)
    {
        if (!Files) Files = new DLinkList();
        Files->Append( Entry );
    }
    return Entry;
}

bool DirEntry::RemoveFromParent() // Remove this from it's containing DLinkList
{
    bool ok = (pParent != NULL && pParent->SubDir != NULL);
    IF_DEBUG( if (!ok) DPrint( DP_ERROR, _F("Orphaned entry: %s\n"), Name );)

    if (ok) ok = (this == pParent->SubDir->RemoveEntry( this ));
    if (!ok) SetLastError( ERROR_INVALID_BLOCK );
    // ERROR_INVALID_BLOCK, ERROR_INVALID_DATA, ERROR_INVALID_ADDRESS,
    // ERROR_OBJECT_NO_LONGER_EXISTS, ERROR_DS_NOT_ON_BACKLINK,
    return ok;
}

//==---------------------------------------------------------------------------
//  Non-member APIs
//==---------------------------------------------------------------------------

static CSTR nextPathSep( CSTR Path )
{
    CSTR pzEnd = _tcschr( Path, BSLASH );
    if (!pzEnd) pzEnd = _tcschr( Path, SLASH );
    if (!pzEnd) pzEnd = _tcschr( Path, 0 );
    return pzEnd;
}

// Oops... Forgot about PathCommonPrefix()..
// This produces the same result as PathCommonPrefix(), except when only the
// drive letter is common, LongestCommonPath does not include the backslash.

CSTR LongestCommonPath( CSTR PathName1, CSTR PathName2 )
{
    static TCHAR szBuf[ MAX_PATH ]; // Return

    CSTR pzPath1, pzPath2, pzEnd1, pzEnd2;
    UINT ccPath1, ccPath2;
    UINT ccMatch = 0;

    pzPath1 = pzEnd1 = PathName1;
    pzPath2 = pzEnd2 = PathName2;

    while( true )
    {
        pzEnd1 = nextPathSep( pzEnd1 );
        pzEnd2 = nextPathSep( pzEnd2 );
        ccPath1 = (UINT) CharIndex( pzPath1, pzEnd1 );
        ccPath2 = (UINT) CharIndex( pzPath2, pzEnd2 );

        if ((ccPath1 != ccPath2) || !ccPath1 || !ccPath2) break;
        if (_tcsnicmp( pzPath1, pzPath2, ccPath1 ) != 0) break;
        ccMatch += ccPath1;

        pzPath1 = pzEnd1; if (*pzEnd1) pzEnd1++;
        pzPath2 = pzEnd2; if (*pzEnd2) pzEnd2++;
    }
  #if _DEBUG
    memset( szBuf, 0, sizeof(szBuf) );
  #else
    szBuf[0] = 0;
  #endif
    if (ccMatch >= dimof(szBuf)) SetLastError( ERROR_BUFFER_OVERFLOW );
    else if (!ccMatch) SetLastError( ERROR_NOT_FOUND ); // ERROR_BAD_PATHNAME, ERROR_MOD_NOT_FOUND,
    else _tcsncpyz( szBuf, PathName1, ccMatch+1 );

    return szBuf;
}

//==---------------------------------------------------------------------------
// EOF