6.8

1 files changed, 235 insertions, 208 deletions

diff --git a/zen/file_traverser.cpp b/zen/file_traverser.cpp
index 65d95f4a..d8f2d0cf 100644
--- a/zen/file_traverser.cpp
+++ b/zen/file_traverser.cpp
@@ -8,9 +8,10 @@
 #include "sys_error.h"
 #include "assert_static.h"
 #include "symlink_target.h"
+#include "int64.h"
 
 #ifdef ZEN_WIN
-#include <zen/win_ver.h>
+#include "win_ver.h"
 #include "long_path_prefix.h"
 #include "dst_hack.h"
 #include "file_handling.h" //remove this huge dependency when getting rid of DST hack!! until then we need "setFileTime"
@@ -18,7 +19,7 @@
 #include "FindFilePlus/find_file_plus.h"
 
 #elif defined ZEN_MAC
-#include <zen/osx_string.h>
+#include "osx_string.h"
 #endif
 
 #if defined ZEN_LINUX || defined ZEN_MAC
@@ -29,7 +30,7 @@
 
 using namespace zen;
 
-
+ 
 namespace
 {
 //implement "retry" in a generic way:
@@ -78,7 +79,7 @@ bool tryReportingItemError(Command cmd, zen::TraverseCallback& callback, const Z
 
 
 #ifdef ZEN_WIN
-void getInfoFromFileSymlink(const Zstring& linkName, zen::TraverseCallback::FileInfo& output) //throw FileError
+TraverseCallback::FileInfo getInfoFromFileSymlink(const Zstring& linkName) //throw FileError
 {
     //open handle to target of symbolic link
     HANDLE hFile = ::CreateFile(zen::applyLongPathPrefix(linkName).c_str(),              //_In_      LPCTSTR lpFileName,
@@ -104,11 +105,12 @@ void getInfoFromFileSymlink(const Zstring& linkName, zen::TraverseCallback::File
     if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
         throw FileError(replaceCpy(_("Cannot resolve symbolic link %x."), L"%x", fmtFileName(linkName)), formatSystemError(L"GetFileInformationByHandle", static_cast<DWORD>(ERROR_FILE_INVALID)));
 
-    //write output
-    output.fileSize      = UInt64(fileInfo.nFileSizeLow, fileInfo.nFileSizeHigh);
-    output.lastWriteTime = toTimeT(fileInfo.ftLastWriteTime);
-    output.id            = extractFileID(fileInfo); //consider detection of moved files: allow for duplicate file ids, renaming affects symlink, not target, ...
+    TraverseCallback::FileInfo output;
+    output.fileSize      = get64BitUInt(fileInfo.nFileSizeLow, fileInfo.nFileSizeHigh);
+    output.lastWriteTime = filetimeToTimeT(fileInfo.ftLastWriteTime);
+    output.id            = extractFileId(fileInfo); //consider detection of moved files: allow for duplicate file ids, renaming affects symlink, not target, ...
     //output.symlinkInfo -> not filled here
+    return output;
 }
 
 
@@ -154,17 +156,17 @@ struct TraverserPolicy //see "policy based design"
 typedef ... DirHandle;
 typedef ... FindData;
 
-static void create(const Zstring& directory, DirHandle& hnd); //throw FileError - *no* concession to FindFirstFile(): open handle only, *no* return of data!
+static DirHandle create(const Zstring& directory); //throw FileError - don't follow FindFirstFile() design: open handle only, *no* return of data!
 static void destroy(DirHandle hnd); //throw()
 
 static bool getEntry(DirHandle hnd, const Zstring& directory, FindData& fileInfo) //throw FileError, NeedFallbackToWin32Traverser -> fallback to FindFirstFile()/FindNextFile()
 
 //FindData "member" functions
-static void extractFileInfo            (const FindData& fileInfo, DWORD volumeSerial, TraverseCallback::FileInfo& output); //volumeSerial may be 0 if not available!
-static Int64 getModTime                (const FindData& fileInfo);
+static TraverseCallback::FileInfo extractFileInfo(const FindData& fileInfo, DWORD volumeSerial); //volumeSerial may be 0 if not available!
+static std::int64_t getModTime         (const FindData& fileInfo);
 static const FILETIME& getModTimeRaw   (const FindData& fileInfo); //yet another concession to DST hack
 static const FILETIME& getCreateTimeRaw(const FindData& fileInfo); //
-static const wchar_t* getShortName     (const FindData& fileInfo);
+static const wchar_t* getItemName      (const FindData& fileInfo);
 static bool isDirectory                (const FindData& fileInfo);
 static bool isSymlink                  (const FindData& fileInfo);
 }
@@ -177,40 +179,41 @@ struct Win32Traverser
 {
     struct DirHandle
     {
-        DirHandle() : searchHandle(nullptr), haveData(true), data() {}
+		DirHandle(HANDLE hnd, const WIN32_FIND_DATA& d) : searchHandle(hnd), haveData(true), data(d) {}
+		explicit DirHandle(HANDLE hnd)                  : searchHandle(hnd), haveData(false) {}
 
         HANDLE searchHandle;
-
         bool haveData;
         WIN32_FIND_DATA data;
     };
 
     typedef WIN32_FIND_DATA FindData;
 
-    static void create(const Zstring& dirname, DirHandle& hnd) //throw FileError
+    static DirHandle create(const Zstring& dirpath) //throw FileError
     {
-        const Zstring& dirnamePf = appendSeparator(dirname);
+        const Zstring& dirpathPf = appendSeparator(dirpath);
 
-        hnd.searchHandle = ::FindFirstFile(applyLongPathPrefix(dirnamePf + L'*').c_str(), &hnd.data);
+		WIN32_FIND_DATA fileData = {};
+        HANDLE hnd = ::FindFirstFile(applyLongPathPrefix(dirpathPf + L'*').c_str(), &fileData);
         //no noticable performance difference compared to FindFirstFileEx with FindExInfoBasic, FIND_FIRST_EX_CASE_SENSITIVE and/or FIND_FIRST_EX_LARGE_FETCH
-        if (hnd.searchHandle == INVALID_HANDLE_VALUE)
+        if (hnd == INVALID_HANDLE_VALUE)
         {
             const DWORD lastError = ::GetLastError(); //copy before making other system calls!
-            hnd.haveData = false;
             if (lastError == ERROR_FILE_NOT_FOUND)
             {
                 //1. directory may not exist *or* 2. it is completely empty: not all directories contain "., .." entries, e.g. a drive's root directory; NetDrive
                 // -> FindFirstFile() is a nice example of violation of API design principle of single responsibility
-                if (dirExists(dirname)) //yes, a race-condition, still the best we can do
-                    return;
+                if (dirExists(dirpath)) //yes, a race-condition, still the best we can do
+                    return DirHandle(hnd);
             }
-            throwFileError(replaceCpy(_("Cannot open directory %x."), L"%x", fmtFileName(dirname)), L"FindFirstFile", lastError);
+            throwFileError(replaceCpy(_("Cannot open directory %x."), L"%x", fmtFileName(dirpath)), L"FindFirstFile", lastError);
         }
+		return DirHandle(hnd, fileData);
     }
 
     static void destroy(const DirHandle& hnd) { ::FindClose(hnd.searchHandle); } //throw()
 
-    static bool getEntry(DirHandle& hnd, const Zstring& dirname, FindData& fileInfo) //throw FileError
+    static bool getEntry(DirHandle& hnd, const Zstring& dirpath, FindData& fileInfo) //throw FileError
     {
         if (hnd.searchHandle == INVALID_HANDLE_VALUE) //handle special case of "truly empty directories"
             return false;
@@ -228,22 +231,25 @@ struct Win32Traverser
             if (lastError == ERROR_NO_MORE_FILES) //not an error situation
                 return false;
             //else we have a problem... report it:
-            throwFileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirname)), L"FindNextFile", lastError);
+            throwFileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirpath)), L"FindNextFile", lastError);
         }
         return true;
     }
 
-    static void extractFileInfo(const FindData& fileInfo, DWORD volumeSerial, TraverseCallback::FileInfo& output)
+    static TraverseCallback::FileInfo extractFileInfo(const FindData& fileInfo, DWORD volumeSerial)
     {
-        output.fileSize      = UInt64(fileInfo.nFileSizeLow, fileInfo.nFileSizeHigh);
+        TraverseCallback::FileInfo output;
+        output.fileSize      = get64BitUInt(fileInfo.nFileSizeLow, fileInfo.nFileSizeHigh);
         output.lastWriteTime = getModTime(fileInfo);
-        output.id = FileId();
+        //output.id = FileId();
+        //output.symlinkInfo = nullptr;
+        return output;
     }
 
-    static Int64           getModTime      (const FindData& fileInfo) { return toTimeT(fileInfo.ftLastWriteTime); }
+    static std::int64_t    getModTime      (const FindData& fileInfo) { return filetimeToTimeT(fileInfo.ftLastWriteTime); }
     static const FILETIME& getModTimeRaw   (const FindData& fileInfo) { return fileInfo.ftLastWriteTime; }
     static const FILETIME& getCreateTimeRaw(const FindData& fileInfo) { return fileInfo.ftCreationTime; }
-    static const wchar_t*  getShortName    (const FindData& fileInfo) { return fileInfo.cFileName; }
+    static const wchar_t*  getItemName     (const FindData& fileInfo) { return fileInfo.cFileName; }
     static bool            isDirectory     (const FindData& fileInfo) { return (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0; }
     static bool            isSymlink       (const FindData& fileInfo) { return zen::isSymlink(fileInfo); } //[!] keep namespace
 };
@@ -256,23 +262,25 @@ struct FilePlusTraverser
 {
     struct DirHandle
     {
-        DirHandle() : searchHandle(nullptr) {}
+        explicit DirHandle(findplus::FindHandle hnd) : searchHandle(hnd) {}
 
         findplus::FindHandle searchHandle;
     };
 
     typedef findplus::FileInformation FindData;
 
-    static void create(const Zstring& dirname, DirHandle& hnd) //throw FileError
+    static DirHandle create(const Zstring& dirpath) //throw FileError
     {
-        hnd.searchHandle = ::openDir(applyLongPathPrefix(dirname).c_str());
-        if (hnd.searchHandle == nullptr)
-            throwFileError(replaceCpy(_("Cannot open directory %x."), L"%x", fmtFileName(dirname)), L"openDir", getLastError());
+		const findplus::FindHandle hnd = ::openDir(applyLongPathPrefix(dirpath).c_str());
+        if (!hnd)
+		throwFileError(replaceCpy(_("Cannot open directory %x."), L"%x", fmtFileName(dirpath)), L"openDir", getLastError());
+
+		return DirHandle(hnd);
     }
 
     static void destroy(DirHandle hnd) { ::closeDir(hnd.searchHandle); } //throw()
 
-    static bool getEntry(DirHandle hnd, const Zstring& dirname, FindData& fileInfo) //throw FileError, NeedFallbackToWin32Traverser
+    static bool getEntry(DirHandle hnd, const Zstring& dirpath, FindData& fileInfo) //throw FileError, NeedFallbackToWin32Traverser
     {
         if (!::readDir(hnd.searchHandle, fileInfo))
         {
@@ -289,23 +297,26 @@ struct FilePlusTraverser
             //fallback should apply to whole directory sub-tree! => client needs to handle duplicate file notifications!
 
             //else we have a problem... report it:
-            throwFileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirname)), L"readDir", lastError);
+            throwFileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirpath)), L"readDir", lastError);
         }
 
         return true;
     }
 
-    static void extractFileInfo(const FindData& fileInfo, DWORD volumeSerial, TraverseCallback::FileInfo& output)
+    static TraverseCallback::FileInfo extractFileInfo(const FindData& fileInfo, DWORD volumeSerial)
     {
-        output.fileSize      = fileInfo.fileSize.QuadPart;
+        TraverseCallback::FileInfo output;
+        output.fileSize      = fileInfo.fileSize;
         output.lastWriteTime = getModTime(fileInfo);
-        output.id            = extractFileID(volumeSerial, fileInfo.fileId);
+        output.id            = extractFileId(volumeSerial, fileInfo.fileId);
+        //output.symlinkInfo = nullptr;
+        return output;
     }
 
-    static Int64           getModTime      (const FindData& fileInfo) { return toTimeT(fileInfo.lastWriteTime); }
+    static std::int64_t    getModTime      (const FindData& fileInfo) { return filetimeToTimeT(fileInfo.lastWriteTime); }
     static const FILETIME& getModTimeRaw   (const FindData& fileInfo) { return fileInfo.lastWriteTime; }
     static const FILETIME& getCreateTimeRaw(const FindData& fileInfo) { return fileInfo.creationTime; }
-    static const wchar_t*  getShortName    (const FindData& fileInfo) { return fileInfo.shortName; }
+    static const wchar_t*  getItemName     (const FindData& fileInfo) { return fileInfo.shortName; }
     static bool            isDirectory     (const FindData& fileInfo) { return (fileInfo.fileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0; }
     static bool            isSymlink       (const FindData& fileInfo) { return zen::isSymlink(fileInfo.fileAttributes, fileInfo.reparseTag); } //[!] keep namespace
 };
@@ -320,139 +331,15 @@ public:
     }
 
 private:
-    DirTraverser(const Zstring& baseDirectory, TraverseCallback& sink, DstHackCallback* dstCallback) :
-        needDstHack(dstCallback ? dst::isFatDrive(baseDirectory) : false)
-    {
-        try //traversing certain folders with restricted permissions requires this privilege! (but copying these files may still fail)
-        {
-            activatePrivilege(SE_BACKUP_NAME); //throw FileError
-        }
-        catch (FileError&) {} //don't cause issues in user mode
-
-        if (::openDir && ::readDir && ::closeDir)
-        {
-            try
-            {
-                traverse<FilePlusTraverser>(baseDirectory, sink, retrieveVolumeSerial(baseDirectory)); //throw NeedFallbackToWin32Traverser; retrieveVolumeSerial returns 0 on error
-            }
-            catch (NeedFallbackToWin32Traverser&) { traverse<Win32Traverser>(baseDirectory, sink, 0); }
-        }
-        else //fallback
-            traverse<Win32Traverser>(baseDirectory, sink, 0);
-
-        //apply daylight saving time hack AFTER file traversing, to give separate feedback to user
-        if (needDstHack)
-            if (dstCallback) //bound if "needDstHack == true"
-                applyDstHack(*dstCallback);
-    }
-
-    DirTraverser(const DirTraverser&);
-    DirTraverser& operator=(const DirTraverser&);
+    DirTraverser(const Zstring& baseDirectory, TraverseCallback& sink, DstHackCallback* dstCallback);
+    DirTraverser           (const DirTraverser&) = delete;
+    DirTraverser& operator=(const DirTraverser&) = delete;
 
     template <class Trav>
-    void traverse(const Zstring& dirname, zen::TraverseCallback& sink, DWORD volumeSerial /*may be 0!*/) //throw NeedFallbackToWin32Traverser
-    {
-        //no need to check for endless recursion: Windows seems to have an internal path limit of about 700 chars
-
-        typename Trav::DirHandle searchHandle;
-
-        if (!tryReportingDirError([&] { Trav::create(dirname, searchHandle); /*throw FileError*/ }, sink))
-            return; //ignored error
-        ZEN_ON_SCOPE_EXIT(Trav::destroy(searchHandle));
-
-        typename Trav::FindData findData = {};
-
-        for (;;)
-        {
-            bool gotEntry = false;
-            tryReportingDirError([&]
-            {
-                gotEntry = Trav::getEntry(searchHandle, dirname, findData); //throw FileError, NeedFallbackToWin32Traverser
-            }, sink);
-            if (!gotEntry) //no more items or ignored error
-                return;
-
-            //skip "." and ".."
-            const Zchar* const shortName = Trav::getShortName(findData);
-            if (shortName[0] == L'.' &&
-                (shortName[1] == 0 || (shortName[1] == L'.' && shortName[2] == 0)))
-                continue;
-
-            const Zstring& fullName = appendSeparator(dirname) + shortName;
-
-            if (Trav::isSymlink(findData)) //check first!
-            {
-                TraverseCallback::SymlinkInfo linkInfo;
-                linkInfo.lastWriteTime = Trav::getModTime (findData);
-
-                switch (sink.onSymlink(shortName, fullName, linkInfo))
-                {
-                    case TraverseCallback::LINK_FOLLOW:
-                        if (Trav::isDirectory(findData))
-                        {
-                            if (TraverseCallback* trav = sink.onDir(shortName, fullName))
-                            {
-                                ZEN_ON_SCOPE_EXIT(sink.releaseDirTraverser(trav));
-                                try
-                                {
-                                    traverse<Trav>(fullName, *trav, retrieveVolumeSerial(fullName)); //throw NeedFallbackToWin32Traverser; symlink may link to different volume => redetermine volume serial!
-                                }
-                                catch (NeedFallbackToWin32Traverser&) { traverse<Win32Traverser>(fullName, *trav, 0); }
-                            }
-                        }
-                        else //a file
-                        {
-                            TraverseCallback::FileInfo targetInfo;
-                            const bool validLink = tryReportingItemError([&] //try to resolve symlink (and report error on failure!!!)
-                            {
-                                getInfoFromFileSymlink(fullName, targetInfo); //throw FileError
-                                targetInfo.symlinkInfo = &linkInfo;
-                            }, sink, shortName);
-
-                            if (validLink)
-                                sink.onFile(shortName, fullName, targetInfo);
-                            // else //broken symlink -> ignore: it's client's responsibility to handle error!
-                        }
-                        break;
-
-                    case TraverseCallback::LINK_SKIP:
-                        break;
-                }
-            }
-            else if (Trav::isDirectory(findData))
-            {
-                if (TraverseCallback* trav = sink.onDir(shortName, fullName))
-                {
-                    ZEN_ON_SCOPE_EXIT(sink.releaseDirTraverser(trav));
-                    try
-                    {
-                        traverse<Trav>(fullName, *trav, volumeSerial); //throw NeedFallbackToWin32Traverser
-                    }
-                    catch (NeedFallbackToWin32Traverser&) { traverse<Win32Traverser>(fullName, *trav, 0); }
-                }
-            }
-            else //a file
-            {
-                TraverseCallback::FileInfo fileInfo;
-                Trav::extractFileInfo(findData, volumeSerial, fileInfo);
-
-                //####################################### DST hack ###########################################
-                if (needDstHack)
-                {
-                    const dst::RawTime rawTime(Trav::getCreateTimeRaw(findData), Trav::getModTimeRaw(findData));
-
-                    if (dst::fatHasUtcEncoded(rawTime)) //throw std::runtime_error
-                        fileInfo.lastWriteTime = toTimeT(dst::fatDecodeUtcTime(rawTime)); //return real UTC time; throw std::runtime_error
-                    else
-                        markForDstHack.push_back(std::make_pair(fullName, toTimeT(rawTime.writeTimeRaw)));
-                }
-                //####################################### DST hack ###########################################
-
-                sink.onFile(shortName, fullName, fileInfo);
-            }
-        }
-    }
+    void traverse(const Zstring& dirpath, TraverseCallback& sink, DWORD volumeSerial);
 
+    template <class Trav>
+    void traverseWithException(const Zstring& dirpath, TraverseCallback& sink, DWORD volumeSerial /*may be 0!*/); //throw FileError, NeedFallbackToWin32Traverser
 
     //####################################### DST hack ###########################################
     void applyDstHack(zen::DstHackCallback& dstCallback)
@@ -482,7 +369,7 @@ private:
             //even at this point it's not sure whether data was written correctly, again cloud storages tend to lie about success status
             if (filesToValidate-- > 0)
             {
-                const dst::RawTime encodedTime = dst::fatEncodeUtcTime(toFileTime(it->second)); //throw std::runtime_error
+                const dst::RawTime encodedTime = dst::fatEncodeUtcTime(timetToFileTime(it->second)); //throw std::runtime_error
 
                 //dst hack: verify data written; attention: this check may fail for "sync.ffs_lock"
                 WIN32_FILE_ATTRIBUTE_DATA debugeAttr = {};
@@ -502,11 +389,144 @@ private:
     }
 
     const bool needDstHack;
-    typedef std::vector<std::pair<Zstring, Int64>> FilenameTimeList;
+    typedef std::vector<std::pair<Zstring, std::int64_t>> FilenameTimeList;
     FilenameTimeList markForDstHack;
     //####################################### DST hack ###########################################
 };
 
+
+template <> inline
+void DirTraverser::traverse<Win32Traverser>(const Zstring& dirpath, TraverseCallback& sink, DWORD volumeSerial)
+{
+    tryReportingDirError([&]
+    {
+        traverseWithException<Win32Traverser>(dirpath, sink, 0); //throw FileError
+    }, sink);
+}
+
+
+template <> inline
+void DirTraverser::traverse<FilePlusTraverser>(const Zstring& dirpath, TraverseCallback& sink, DWORD volumeSerial)
+{
+    try
+    {
+        tryReportingDirError([&]
+        {
+            traverseWithException<FilePlusTraverser>(dirpath, sink, volumeSerial); //throw FileError, NeedFallbackToWin32Traverser
+        }, sink);
+    }
+    catch (NeedFallbackToWin32Traverser&) { traverse<Win32Traverser>(dirpath, sink, 0); }
+}
+
+
+inline
+DirTraverser::DirTraverser(const Zstring& baseDirectory, TraverseCallback& sink, DstHackCallback* dstCallback) :
+    needDstHack(dstCallback ? dst::isFatDrive(baseDirectory) : false)
+{
+    try //traversing certain folders with restricted permissions requires this privilege! (but copying these files may still fail)
+    {
+        activatePrivilege(SE_BACKUP_NAME); //throw FileError
+    }
+    catch (FileError&) {} //don't cause issues in user mode
+
+    if (::openDir && ::readDir && ::closeDir)
+        traverse<FilePlusTraverser>(baseDirectory, sink, retrieveVolumeSerial(baseDirectory)); //retrieveVolumeSerial returns 0 on error
+    else //fallback
+        traverse<Win32Traverser>(baseDirectory, sink, 0);
+
+    //apply daylight saving time hack AFTER file traversing, to give separate feedback to user
+    if (needDstHack)
+        if (dstCallback) //bound if "needDstHack == true"
+            applyDstHack(*dstCallback);
+}
+
+
+template <class Trav>
+void DirTraverser::traverseWithException(const Zstring& dirpath, TraverseCallback& sink, DWORD volumeSerial /*may be 0!*/) //throw FileError, NeedFallbackToWin32Traverser
+{
+    //no need to check for endless recursion: Windows seems to have an internal path limit of about 700 chars
+
+    typename Trav::DirHandle searchHandle = Trav::create(dirpath); //throw FileError
+    ZEN_ON_SCOPE_EXIT(Trav::destroy(searchHandle));
+
+    typename Trav::FindData findData = {};
+
+    while (Trav::getEntry(searchHandle, dirpath, findData)) //throw FileError, NeedFallbackToWin32Traverser
+        //don't retry but restart dir traversal on error! http://blogs.msdn.com/b/oldnewthing/archive/2014/06/12/10533529.aspx
+    {
+        //skip "." and ".."
+        const Zchar* const shortName = Trav::getItemName(findData);
+        if (shortName[0] == L'.' &&
+            (shortName[1] == 0 || (shortName[1] == L'.' && shortName[2] == 0)))
+            continue;
+
+        const Zstring& itempath = appendSeparator(dirpath) + shortName;
+
+        if (Trav::isSymlink(findData)) //check first!
+        {
+            TraverseCallback::SymlinkInfo linkInfo;
+            linkInfo.lastWriteTime = Trav::getModTime (findData);
+
+            switch (sink.onSymlink(shortName, itempath, linkInfo))
+            {
+                case TraverseCallback::LINK_FOLLOW:
+                    if (Trav::isDirectory(findData))
+                    {
+                        if (TraverseCallback* trav = sink.onDir(shortName, itempath))
+                        {
+                            ZEN_ON_SCOPE_EXIT(sink.releaseDirTraverser(trav));
+                            traverse<Trav>(itempath, *trav, retrieveVolumeSerial(itempath)); //symlink may link to different volume => redetermine volume serial!
+                        }
+                    }
+                    else //a file
+                    {
+                        TraverseCallback::FileInfo targetInfo;
+                        const bool validLink = tryReportingItemError([&] //try to resolve symlink (and report error on failure!!!)
+                        {
+                            targetInfo = getInfoFromFileSymlink(itempath); //throw FileError
+                            targetInfo.symlinkInfo = &linkInfo;
+                        }, sink, shortName);
+
+                        if (validLink)
+                            sink.onFile(shortName, itempath, targetInfo);
+                        // else //broken symlink -> ignore: it's client's responsibility to handle error!
+                    }
+                    break;
+
+                case TraverseCallback::LINK_SKIP:
+                    break;
+            }
+        }
+        else if (Trav::isDirectory(findData))
+        {
+            if (TraverseCallback* trav = sink.onDir(shortName, itempath))
+            {
+                ZEN_ON_SCOPE_EXIT(sink.releaseDirTraverser(trav));
+                traverse<Trav>(itempath, *trav, volumeSerial);
+            }
+        }
+        else //a file
+        {
+            TraverseCallback::FileInfo fileInfo = Trav::extractFileInfo(findData, volumeSerial);
+
+            //####################################### DST hack ###########################################
+            if (needDstHack)
+            {
+                const dst::RawTime rawTime(Trav::getCreateTimeRaw(findData), Trav::getModTimeRaw(findData));
+
+                if (dst::fatHasUtcEncoded(rawTime)) //throw std::runtime_error
+                    fileInfo.lastWriteTime = filetimeToTimeT(dst::fatDecodeUtcTime(rawTime)); //return real UTC time; throw std::runtime_error
+                else
+                    markForDstHack.push_back(std::make_pair(itempath, filetimeToTimeT(rawTime.writeTimeRaw)));
+            }
+            //####################################### DST hack ###########################################
+
+            sink.onFile(shortName, itempath, fileInfo);
+        }
+    }
+}
+
+
 #elif defined ZEN_LINUX || defined ZEN_MAC
 class DirTraverser
 {
@@ -535,32 +555,34 @@ private:
         traverse(directoryFormatted, sink);
     }
 
-    DirTraverser(const DirTraverser&);
-    DirTraverser& operator=(const DirTraverser&);
+    DirTraverser           (const DirTraverser&) = delete;
+    DirTraverser& operator=(const DirTraverser&) = delete;
 
-    void traverse(const Zstring& dirname, zen::TraverseCallback& sink)
+    void traverse(const Zstring& dirpath, TraverseCallback& sink)
     {
-        //no need to check for endless recursion: Linux has a fixed limit on the number of symbolic links in a path
+        tryReportingDirError([&]
+        {
+            traverseWithException(dirpath, sink); //throw FileError
+        }, sink);
+    }
 
-        DIR* dirObj = nullptr;
-        if (!tryReportingDirError([&]
+    void traverseWithException(const Zstring& dirpath, TraverseCallback& sink) //throw FileError
     {
-        dirObj = ::opendir(dirname.c_str()); //directory must NOT end with path separator, except "/"
-            if (!dirObj)
-                throwFileError(replaceCpy(_("Cannot open directory %x."), L"%x", fmtFileName(dirname)), L"opendir", getLastError());
-        }, sink))
-        return; //ignored error
+        //no need to check for endless recursion: Linux has a fixed limit on the number of symbolic links in a path
+
+        DIR* dirObj = ::opendir(dirpath.c_str()); //directory must NOT end with path separator, except "/"
+        if (!dirObj)
+            throwFileError(replaceCpy(_("Cannot open directory %x."), L"%x", fmtFileName(dirpath)), L"opendir", getLastError());
         ZEN_ON_SCOPE_EXIT(::closedir(dirObj)); //never close nullptr handles! -> crash
 
         for (;;)
         {
             struct ::dirent* dirEntry = nullptr;
-            tryReportingDirError([&]
-            {
-                if (::readdir_r(dirObj, reinterpret_cast< ::dirent*>(&buffer[0]), &dirEntry) != 0)
-                    throwFileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirname)), L"readdir_r", getLastError());
-            }, sink);
-            if (!dirEntry) //no more items or ignored error
+            if (::readdir_r(dirObj, reinterpret_cast< ::dirent*>(&buffer[0]), &dirEntry) != 0)
+                throwFileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirpath)), L"readdir_r", getLastError());
+            //don't retry but restart dir traversal on error! http://blogs.msdn.com/b/oldnewthing/archive/2014/06/12/10533529.aspx
+
+            if (!dirEntry) //no more items
                 return;
 
             //don't return "." and ".."
@@ -588,13 +610,13 @@ private:
             //const char* sampleDecomposed  = "\x6f\xcc\x81.txt";
             //const char* samplePrecomposed = "\xc3\xb3.txt";
 #endif
-            const Zstring& fullName = appendSeparator(dirname) + shortName;
+            const Zstring& itempath = appendSeparator(dirpath) + shortName;
 
             struct ::stat statData = {};
             if (!tryReportingItemError([&]
         {
-            if (::lstat(fullName.c_str(), &statData) != 0) //lstat() does not resolve symlinks
-                    throwFileError(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtFileName(fullName)), L"lstat", getLastError());
+            if (::lstat(itempath.c_str(), &statData) != 0) //lstat() does not resolve symlinks
+                    throwFileError(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtFileName(itempath)), L"lstat", getLastError());
             }, sink, shortName))
             continue; //ignore error: skip file
 
@@ -603,7 +625,7 @@ private:
                 TraverseCallback::SymlinkInfo linkInfo;
                 linkInfo.lastWriteTime = statData.st_mtime; //UTC time (ANSI C format); unit: 1 second
 
-                switch (sink.onSymlink(shortName, fullName, linkInfo))
+                switch (sink.onSymlink(shortName, itempath, linkInfo))
                 {
                     case TraverseCallback::LINK_FOLLOW:
                     {
@@ -611,28 +633,28 @@ private:
                         struct ::stat statDataTrg = {};
                         bool validLink = tryReportingItemError([&]
                         {
-                            if (::stat(fullName.c_str(), &statDataTrg) != 0)
-                                throwFileError(replaceCpy(_("Cannot resolve symbolic link %x."), L"%x", fmtFileName(fullName)), L"stat", getLastError());
+                            if (::stat(itempath.c_str(), &statDataTrg) != 0)
+                                throwFileError(replaceCpy(_("Cannot resolve symbolic link %x."), L"%x", fmtFileName(itempath)), L"stat", getLastError());
                         }, sink, shortName);
 
                         if (validLink)
                         {
                             if (S_ISDIR(statDataTrg.st_mode)) //a directory
                             {
-                                if (TraverseCallback* trav = sink.onDir(shortName, fullName))
+                                if (TraverseCallback* trav = sink.onDir(shortName, itempath))
                                 {
                                     ZEN_ON_SCOPE_EXIT(sink.releaseDirTraverser(trav));
-                                    traverse(fullName, *trav);
+                                    traverse(itempath, *trav);
                                 }
                             }
                             else //a file or named pipe, ect.
                             {
                                 TraverseCallback::FileInfo fileInfo;
-                                fileInfo.fileSize      = zen::UInt64(statDataTrg.st_size);
+                                fileInfo.fileSize      = statDataTrg.st_size;
                                 fileInfo.lastWriteTime = statDataTrg.st_mtime; //UTC time (time_t format); unit: 1 second
-                                fileInfo.id            = extractFileID(statDataTrg);
+                                fileInfo.id            = extractFileId(statDataTrg);
                                 fileInfo.symlinkInfo   = &linkInfo;
-                                sink.onFile(shortName, fullName, fileInfo);
+                                sink.onFile(shortName, itempath, fileInfo);
                             }
                         }
                         // else //broken symlink -> ignore: it's client's responsibility to handle error!
@@ -645,20 +667,20 @@ private:
             }
             else if (S_ISDIR(statData.st_mode)) //a directory
             {
-                if (TraverseCallback* trav = sink.onDir(shortName, fullName))
+                if (TraverseCallback* trav = sink.onDir(shortName, itempath))
                 {
                     ZEN_ON_SCOPE_EXIT(sink.releaseDirTraverser(trav));
-                    traverse(fullName, *trav);
+                    traverse(itempath, *trav);
                 }
             }
             else //a file or named pipe, ect.
             {
                 TraverseCallback::FileInfo fileInfo;
-                fileInfo.fileSize      = zen::UInt64(statData.st_size);
+                fileInfo.fileSize      = statData.st_size;
                 fileInfo.lastWriteTime = statData.st_mtime; //UTC time (time_t format); unit: 1 second
-                fileInfo.id            = extractFileID(statData);
+                fileInfo.id            = extractFileId(statData);
 
-                sink.onFile(shortName, fullName, fileInfo);
+                sink.onFile(shortName, itempath, fileInfo);
             }
             /*
             It may be a good idea to not check "S_ISREG(statData.st_mode)" explicitly and to not issue an error message on other types to support these scenarios:
@@ -679,7 +701,12 @@ private:
 }
 
 
-void zen::traverseFolder(const Zstring& dirname, TraverseCallback& sink, DstHackCallback* dstCallback)
+void zen::traverseFolder(const Zstring& dirpath, TraverseCallback& sink, DstHackCallback* dstCallback)
 {
-    DirTraverser::execute(dirname, sink, dstCallback);
+	warn_static("let's tentatively disable the DST hack:")
+	DirTraverser::execute(dirpath, sink, nullptr);
+	return;
+#if 0
+    DirTraverser::execute(dirpath, sink, dstCallback);
+#endif
 }