7.0

26 files changed, 564 insertions, 872 deletions

diff --git a/zen/dir_watcher.cpp b/zen/dir_watcher.cpp
index 26645157..a948a5e8 100644
--- a/zen/dir_watcher.cpp
+++ b/zen/dir_watcher.cpp
@@ -11,7 +11,7 @@
 #include "scope_guard.h"
 
 #ifdef ZEN_WIN
-    #include "notify_removal.h"
+    #include "device_notify.h"
     #include "win.h" //includes "windows.h"
     #include "long_path_prefix.h"
 
@@ -161,12 +161,11 @@ public:
         //end of constructor, no need to start managing "hDir"
     }
 
-    ReadChangesAsync(ReadChangesAsync&& other) :
-        hDir(INVALID_HANDLE_VALUE)
+    ReadChangesAsync(ReadChangesAsync&& other) : shared_(std::move(other.shared_)),
+        dirpathPf(std::move(other.dirpathPf)),
+        hDir(other.hDir)
     {
-        shared_   = std::move(other.shared_);
-        dirpathPf = std::move(other.dirpathPf);
-        std::swap(hDir, other.hDir);
+        other.hDir = INVALID_HANDLE_VALUE;
     }
 
     ~ReadChangesAsync()
@@ -271,15 +270,24 @@ private:
 };
 
 
-class HandleVolumeRemoval : public NotifyRequestDeviceRemoval
+class HandleVolumeRemoval
 {
 public:
     HandleVolumeRemoval(HANDLE hDir,
+                        const Zstring& displayPath,
                         boost::thread& worker) :
-        NotifyRequestDeviceRemoval(hDir), //throw FileError
-        worker_(worker),
-        removalRequested(false),
-        operationComplete(false) {}
+        notificationHandle(registerFolderRemovalNotification(hDir, //throw FileError
+                                                             displayPath,
+                                                             [this]                 { this->onRequestRemoval (); },   //noexcept!
+    [this](bool successful) { this->onRemovalFinished(); })), //
+    worker_(worker),
+    removalRequested(false),
+    operationComplete(false) {}
+
+    ~HandleVolumeRemoval()
+    {
+        unregisterDeviceNotification(notificationHandle);
+    }
 
     //all functions are called by main thread!
 
@@ -287,7 +295,7 @@ public:
     bool finished() const { return operationComplete; }
 
 private:
-    void onRequestRemoval(HANDLE hnd) override
+    void onRequestRemoval() //noexcept!
     {
         //must release hDir immediately => stop monitoring!
         if (worker_.joinable()) //= join() precondition: play safe; can't trust Windows to only call-back once
@@ -300,8 +308,9 @@ private:
         removalRequested = true;
     } //don't throw!
 
-    void onRemovalFinished(HANDLE hnd, bool successful) override { operationComplete = true; } //throw()!
+    void onRemovalFinished() { operationComplete = true; } //noexcept!
 
+    DeviceNotificationHandle* notificationHandle;
     boost::thread& worker_;
     bool removalRequested;
     bool operationComplete;
@@ -313,20 +322,18 @@ struct DirWatcher::Pimpl
 {
     boost::thread worker;
     std::shared_ptr<SharedData> shared;
-
-    Zstring dirpath;
     std::unique_ptr<HandleVolumeRemoval> volRemoval;
 };
 
 
-DirWatcher::DirWatcher(const Zstring& directory) : //throw FileError
+DirWatcher::DirWatcher(const Zstring& dirPath) : //throw FileError
+    baseDirPath(dirPath),
     pimpl_(zen::make_unique<Pimpl>())
 {
     pimpl_->shared = std::make_shared<SharedData>();
-    pimpl_->dirpath = directory;
 
-    ReadChangesAsync reader(directory, pimpl_->shared); //throw FileError
-    pimpl_->volRemoval = zen::make_unique<HandleVolumeRemoval>(reader.getDirHandle(), pimpl_->worker); //throw FileError
+    ReadChangesAsync reader(dirPath, pimpl_->shared); //throw FileError
+    pimpl_->volRemoval = zen::make_unique<HandleVolumeRemoval>(reader.getDirHandle(), dirPath, pimpl_->worker); //throw FileError
     pimpl_->worker = boost::thread(std::move(reader));
 }
 
@@ -347,6 +354,7 @@ DirWatcher::~DirWatcher()
 std::vector<DirWatcher::Entry> DirWatcher::getChanges(const std::function<void()>& processGuiMessages) //throw FileError
 {
     std::vector<Entry> output;
+    pimpl_->shared->fetchChanges(output); //throw FileError
 
     //wait until device removal is confirmed, to prevent locking hDir again by some new watch!
     if (pimpl_->volRemoval->requestReceived())
@@ -360,10 +368,9 @@ std::vector<DirWatcher::Entry> DirWatcher::getChanges(const std::function<void()
             boost::thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(50));
         }
 
-        output.emplace_back(ACTION_DELETE, pimpl_->dirpath); //report removal as change to main directory
+        output.emplace_back(ACTION_DELETE, baseDirPath); //report removal as change to main directory
     }
-    else //the normal case...
-        pimpl_->shared->fetchChanges(output); //throw FileError
+
     return output;
 }
 
@@ -373,32 +380,35 @@ struct DirWatcher::Pimpl
 {
     Pimpl() : notifDescr() {}
 
-    Zstring basedirpath;
     int notifDescr;
     std::map<int, Zstring> watchDescrs; //watch descriptor and (sub-)directory name (postfixed with separator) -> owned by "notifDescr"
 };
 
 
-DirWatcher::DirWatcher(const Zstring& directory) : //throw FileError
+DirWatcher::DirWatcher(const Zstring& dirPath) : //throw FileError
+    baseDirPath(dirPath),
     pimpl_(zen::make_unique<Pimpl>())
 {
     //get all subdirectories
-    Zstring dirpathFmt = directory;
-    if (endsWith(dirpathFmt, FILE_NAME_SEPARATOR))
-        dirpathFmt.resize(dirpathFmt.size() - 1);
+    std::vector<Zstring> fullDirList { baseDirPath };
+    {
+        std::function<void (const Zstring& path)> traverse;
 
-    std::vector<Zstring> fullDirList { dirpathFmt };
+        traverse = [&traverse, &fullDirList](const Zstring& path)
+        {
+            traverseFolder(path, nullptr,
+            [&](const DirInfo& di ) { fullDirList.push_back(di.fullPath); traverse(di.fullPath); },
+            nullptr, //don't traverse into symlinks (analog to windows build)
+            [&](const std::wstring& errorMsg) { throw FileError(errorMsg); });
+        };
 
-traverseFolder(dirpathFmt, nullptr, 
-				[&](const DirInfo& di ){ fullDirList.push_back(di.fullPath); }, 
-				nullptr, //don't traverse into symlinks (analog to windows build)
-[&](const std::wstring& errorMsg){ throw FileError(errorMsg); });
+        traverse(baseDirPath);
+    }
 
     //init
-    pimpl_->basedirpath = directory;
-    pimpl_->notifDescr = ::inotify_init();
+    pimpl_->notifDescr  = ::inotify_init();
     if (pimpl_->notifDescr == -1)
-        throwFileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(directory)), L"inotify_init", getLastError());
+        throwFileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(baseDirPath)), L"inotify_init", getLastError());
 
     zen::ScopeGuard guardDescr = zen::makeGuard([&] { ::close(pimpl_->notifDescr); });
 
@@ -410,12 +420,12 @@ traverseFolder(dirpathFmt, nullptr,
             initSuccess = ::fcntl(pimpl_->notifDescr, F_SETFL, flags | O_NONBLOCK) != -1;
     }
     if (!initSuccess)
-        throwFileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(directory)), L"fcntl", getLastError());
+        throwFileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(baseDirPath)), L"fcntl", getLastError());
 
     //add watches
-    for (const Zstring& subdir : fullDirList)
+    for (const Zstring& subDirPath : fullDirList)
     {
-        int wd = ::inotify_add_watch(pimpl_->notifDescr, subdir.c_str(),
+        int wd = ::inotify_add_watch(pimpl_->notifDescr, subDirPath.c_str(),
                                      IN_ONLYDIR     | //"Only watch pathname if it is a directory."
                                      IN_DONT_FOLLOW | //don't follow symbolic links
                                      IN_CREATE   	|
@@ -430,12 +440,13 @@ traverseFolder(dirpathFmt, nullptr,
         {
             const auto ec = getLastError();
             if (ec == ENOSPC) //fix misleading system message "No space left on device"
-                throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(subdir)), formatSystemError(L"inotify_add_watch", ec, L"The user limit on the total number of inotify watches was reached or the kernel failed to allocate a needed resource."));
+                throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(subDirPath)),
+				      formatSystemError(L"inotify_add_watch", ec, L"The user limit on the total number of inotify watches was reached or the kernel failed to allocate a needed resource."));
 
-            throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(subdir)), formatSystemError(L"inotify_add_watch", ec));
+            throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(subDirPath)), formatSystemError(L"inotify_add_watch", ec));
         }
 
-        pimpl_->watchDescrs.emplace(wd, appendSeparator(subdir));
+        pimpl_->watchDescrs.emplace(wd, appendSeparator(subDirPath));
     }
 
     guardDescr.dismiss();
@@ -465,7 +476,7 @@ std::vector<DirWatcher::Entry> DirWatcher::getChanges(const std::function<void()
         if (errno == EAGAIN)  //this error is ignored in all inotify wrappers I found
             return std::vector<Entry>();
 
-        throwFileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(pimpl_->basedirpath)), L"read", getLastError());
+        throwFileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(baseDirPath)), L"read", getLastError());
     }
 
     std::vector<Entry> output;
@@ -523,7 +534,7 @@ void eventCallback(ConstFSEventStreamRef streamRef,
         //events are aggregated => it's possible to see a single event with flags
         //kFSEventStreamEventFlagItemCreated | kFSEventStreamEventFlagItemModified | kFSEventStreamEventFlagItemRemoved
 
-		//https://developer.apple.com/library/mac/documentation/Darwin/Reference/FSEvents_Ref/index.html#//apple_ref/doc/constant_group/FSEventStreamEventFlags
+        //https://developer.apple.com/library/mac/documentation/Darwin/Reference/FSEvents_Ref/index.html#//apple_ref/doc/constant_group/FSEventStreamEventFlags
         if (eventFlags[i] & kFSEventStreamEventFlagItemCreated ||
             eventFlags[i] & kFSEventStreamEventFlagMount)
             changedFiles.emplace_back(DirWatcher::ACTION_CREATE, paths[i]);
@@ -555,12 +566,13 @@ struct DirWatcher::Pimpl
 };
 
 
-DirWatcher::DirWatcher(const Zstring& directory) :
+DirWatcher::DirWatcher(const Zstring& dirPath) :
+    baseDirPath(dirPath),
     pimpl_(zen::make_unique<Pimpl>())
 {
-    CFStringRef dirpathCf = osx::createCFString(directory.c_str()); //returns nullptr on error
+    CFStringRef dirpathCf = osx::createCFString(baseDirPath.c_str()); //returns nullptr on error
     if (!dirpathCf)
-        throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(directory)), L"Function call failed: createCFString"); //no error code documented!
+        throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(baseDirPath)), L"Function call failed: createCFString"); //no error code documented!
     ZEN_ON_SCOPE_EXIT(::CFRelease(dirpathCf));
 
     CFArrayRef dirpathCfArray = ::CFArrayCreate(nullptr,    //CFAllocatorRef allocator,
@@ -568,7 +580,7 @@ DirWatcher::DirWatcher(const Zstring& directory) :
                                                 1,          //CFIndex numValues,
                                                 nullptr);   //const CFArrayCallBacks* callBacks
     if (!dirpathCfArray)
-        throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(directory)), L"Function call failed: CFArrayCreate"); //no error code documented!
+        throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(baseDirPath)), L"Function call failed: CFArrayCreate"); //no error code documented!
     ZEN_ON_SCOPE_EXIT(::CFRelease(dirpathCfArray));
 
     FSEventStreamContext context = {};
@@ -594,7 +606,7 @@ DirWatcher::DirWatcher(const Zstring& directory) :
     zen::ScopeGuard guardRunloop = zen::makeGuard([&] { ::FSEventStreamInvalidate(pimpl_->eventStream); });
 
     if (!::FSEventStreamStart(pimpl_->eventStream))
-        throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(directory)), L"Function call failed: FSEventStreamStart"); //no error code documented!
+        throw FileError(replaceCpy(_("Cannot monitor directory %x."), L"%x", fmtFileName(baseDirPath)), L"Function call failed: FSEventStreamStart"); //no error code documented!
 
     guardCreate .dismiss();
     guardRunloop.dismiss();
diff --git a/zen/dir_watcher.h b/zen/dir_watcher.h
index b5255898..cdc80165 100644
--- a/zen/dir_watcher.h
+++ b/zen/dir_watcher.h
@@ -21,7 +21,8 @@ namespace zen
 //watch directory including subdirectories
 /*
 !Note handling of directories!:
-	Windows: removal of top watched directory is NOT notified (e.g. brute force usb stick removal)
+	Windows: removal of top watched directory is NOT notified when watching the dir handle, e.g. brute force usb stick removal,
+			 (watchting for GUID_DEVINTERFACE_WPD OTOH works fine!)
 	         however manual unmount IS notified (e.g. usb stick removal, then re-insert), but watching is stopped!
 			 Renaming of top watched directory handled incorrectly: Not notified(!) + additional changes in subfolders
 			 now do report FILE_ACTION_MODIFIED for directory (check that should prevent this fails!)
@@ -36,7 +37,7 @@ namespace zen
 class DirWatcher
 {
 public:
-    DirWatcher(const Zstring& directory); //throw FileError
+    DirWatcher(const Zstring& dirPath); //throw FileError
     ~DirWatcher();
 
     enum ActionType
@@ -62,6 +63,8 @@ private:
     DirWatcher           (const DirWatcher&) = delete;
     DirWatcher& operator=(const DirWatcher&) = delete;
 
+    const Zstring baseDirPath;
+
     struct Pimpl;
     std::unique_ptr<Pimpl> pimpl_;
 };
diff --git a/zen/file_access.cpp b/zen/file_access.cpp
index ffbdc813..b1b781ee 100644
--- a/zen/file_access.cpp
+++ b/zen/file_access.cpp
@@ -12,8 +12,8 @@
 #include "file_traverser.h"
 #include "scope_guard.h"
 #include "symlink_target.h"
-#include "file_io.h"
 #include "file_id_def.h"
+#include "serialize.h"
 
 #ifdef ZEN_WIN
     #include <Aclapi.h>
@@ -133,67 +133,38 @@ bool zen::somethingExists(const Zstring& objname)
 namespace
 {
 #ifdef ZEN_WIN
-//fast ::GetVolumePathName() clone: let's hope it's not too simple (doesn't honor mount points)
-Zstring getVolumeNameFast(const Zstring& filepath)
+bool isFatDrive(const Zstring& filePath) //throw()
 {
-    //this call is expensive: ~1.5 ms!
-    //    if (!::GetVolumePathName(filepath.c_str(), //__in   LPCTSTR lpszFileName,
-    //                             fsName,           //__out  LPTSTR lpszVolumePathName,
-    //                             BUFFER_SIZE))     //__in   DWORD cchBufferLength
-    // ...
-    //    Zstring volumePath = appendSeparator(fsName);
-
-    const Zstring nameFmt = appendSeparator(removeLongPathPrefix(filepath)); //throw()
+    const DWORD bufferSize = MAX_PATH + 1;
+    std::vector<wchar_t> buffer(bufferSize);
 
-    if (startsWith(nameFmt, Zstr("\\\\"))) //UNC path: "\\ComputerName\SharedFolder\"
-    {
-        size_t nameSize = nameFmt.size();
-        const size_t posFirstSlash = nameFmt.find(Zstr("\\"), 2);
-        if (posFirstSlash != Zstring::npos)
-        {
-            nameSize = posFirstSlash + 1;
-            const size_t posSecondSlash = nameFmt.find(Zstr("\\"), posFirstSlash + 1);
-            if (posSecondSlash != Zstring::npos)
-                nameSize = posSecondSlash + 1;
-        }
-        return Zstring(nameFmt.c_str(), nameSize); //include trailing backslash!
-    }
-    else //local path: "C:\Folder\"
+    //this call is expensive: ~1.5 ms!
+    if (!::GetVolumePathName(filePath.c_str(), //__in   LPCTSTR lpszFileName,
+                             &buffer[0],       //__out  LPTSTR lpszVolumePathName,
+                             bufferSize))      //__in   DWORD cchBufferLength
     {
-        const size_t pos = nameFmt.find(Zstr(":\\"));
-        if (pos == 1) //expect single letter volume
-            return Zstring(nameFmt.c_str(), 3);
-    }
-
-    return Zstring();
-}
-
-
-bool isFatDrive(const Zstring& filepath) //throw()
-{
-    const Zstring volumePath = getVolumeNameFast(filepath);
-    if (volumePath.empty())
+        assert(false);
         return false;
+    }
 
-    const DWORD bufferSize = MAX_PATH + 1;
-    wchar_t fsName[bufferSize] = {};
+    const Zstring volumePath = appendSeparator(&buffer[0]);
 
     //suprisingly fast: ca. 0.03 ms per call!
-    if (!::GetVolumeInformation(appendSeparator(volumePath).c_str(), //__in_opt   LPCTSTR lpRootPathName,
+    if (!::GetVolumeInformation(volumePath.c_str(), //__in_opt   LPCTSTR lpRootPathName,
                                 nullptr,     //__out      LPTSTR lpVolumeNameBuffer,
                                 0,           //__in       DWORD nVolumeNameSize,
                                 nullptr,     //__out_opt  LPDWORD lpVolumeSerialNumber,
                                 nullptr,     //__out_opt  LPDWORD lpMaximumComponentLength,
                                 nullptr,     //__out_opt  LPDWORD lpFileSystemFlags,
-                                fsName,      //__out      LPTSTR lpFileSystemNameBuffer,
+                                &buffer[0],  //__out      LPTSTR lpFileSystemNameBuffer,
                                 bufferSize)) //__in       DWORD nFileSystemNameSize
     {
-        assert(false); //shouldn't happen
+        assert(false);
         return false;
     }
-    //DST hack seems to be working equally well for FAT and FAT32 (in particular creation time has 10^-2 s precision as advertised)
-    return fsName == Zstring(L"FAT") ||
-           fsName == Zstring(L"FAT32");
+
+    return &buffer[0] == Zstring(L"FAT") ||
+           &buffer[0] == Zstring(L"FAT32");
 }
 
 
@@ -267,7 +238,7 @@ std::uint64_t zen::getFilesize(const Zstring& filepath) //throw FileError
 }
 
 
-std::uint64_t zen::getFreeDiskSpace(const Zstring& path) //throw FileError
+std::uint64_t zen::getFreeDiskSpace(const Zstring& path) //throw FileError, returns 0 if not available
 {
 #ifdef ZEN_WIN
     ULARGE_INTEGER bytesFree = {};
@@ -275,14 +246,15 @@ std::uint64_t zen::getFreeDiskSpace(const Zstring& path) //throw FileError
                               &bytesFree,                    //__out_opt  PULARGE_INTEGER lpFreeBytesAvailable,
                               nullptr,                       //__out_opt  PULARGE_INTEGER lpTotalNumberOfBytes,
                               nullptr))                      //__out_opt  PULARGE_INTEGER lpTotalNumberOfFreeBytes
-        throwFileError(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtFileName(path)), L"GetDiskFreeSpaceEx", getLastError());
+        throwFileError(replaceCpy(_("Cannot determine free disk space for %x."), L"%x", fmtFileName(path)), L"GetDiskFreeSpaceEx", getLastError());
 
+	//return 0 if info is not available: "The GetDiskFreeSpaceEx function returns zero for lpFreeBytesAvailable for all CD requests"
     return get64BitUInt(bytesFree.LowPart, bytesFree.HighPart);
 
 #elif defined ZEN_LINUX || defined ZEN_MAC
     struct ::statfs info = {};
     if (::statfs(path.c_str(), &info) != 0)
-        throwFileError(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtFileName(path)), L"statfs", getLastError());
+		throwFileError(replaceCpy(_("Cannot determine free disk space for %x."), L"%x", fmtFileName(path)), L"statfs", getLastError());
 
     return static_cast<std::uint64_t>(info.f_bsize) * info.f_bavail;
 #endif
@@ -293,8 +265,8 @@ bool zen::removeFile(const Zstring& filepath) //throw FileError
 {
 #ifdef ZEN_WIN
     const wchar_t functionName[] = L"DeleteFile";
-    const Zstring& filepathFmt = applyLongPathPrefix(filepath);
-    if (!::DeleteFile(filepathFmt.c_str()))
+
+    if (!::DeleteFile(applyLongPathPrefix(filepath).c_str()))
 #elif defined ZEN_LINUX || defined ZEN_MAC
     const wchar_t functionName[] = L"unlink";
     if (::unlink(filepath.c_str()) != 0)
@@ -304,9 +276,9 @@ bool zen::removeFile(const Zstring& filepath) //throw FileError
 #ifdef ZEN_WIN
         if (lastError == ERROR_ACCESS_DENIED) //function fails if file is read-only
         {
-            ::SetFileAttributes(filepathFmt.c_str(), FILE_ATTRIBUTE_NORMAL); //(try to) normalize file attributes
+            ::SetFileAttributes(applyLongPathPrefix(filepath).c_str(), FILE_ATTRIBUTE_NORMAL); //(try to) normalize file attributes
 
-            if (::DeleteFile(filepathFmt.c_str())) //now try again...
+            if (::DeleteFile(applyLongPathPrefix(filepath).c_str())) //now try again...
                 return true;
             lastError = ::GetLastError();
         }
@@ -380,7 +352,7 @@ void renameFile_sub(const Zstring& oldName, const Zstring& newName) //throw File
                 }
             }
         }
-
+        //begin of "regular" error reporting
         const std::wstring errorMsg = replaceCpy(replaceCpy(_("Cannot move file %x to %y."), L"%x", L"\n" + fmtFileName(oldName)), L"%y", L"\n" + fmtFileName(newName));
         std::wstring errorDescr = formatSystemError(L"MoveFileEx", lastError);
 
@@ -480,8 +452,8 @@ bool have8dot3NameClash(const Zstring& filepath)
 
         if (!shortName.empty() &&
             !longName .empty() &&
-            EqualFilename()(origName,  shortName) &&
-            !EqualFilename()(shortName, longName))
+            EqualFilePath()(origName,  shortName) &&
+            !EqualFilePath()(shortName, longName))
         {
             //for filepath short and long file name are equal and another unrelated file happens to have the same short name
             //e.g. filepath == "TESTWE~1", but another file is existing named "TestWeb" with short name ""TESTWE~1"
@@ -526,21 +498,21 @@ private:
 
 
 //rename file: no copying!!!
-void zen::renameFile(const Zstring& oldName, const Zstring& newName) //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
+void zen::renameFile(const Zstring& itemPathOld, const Zstring& itemPathNew) //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
 {
     try
     {
-        renameFile_sub(oldName, newName); //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
+        renameFile_sub(itemPathOld, itemPathNew); //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
     }
     catch (const ErrorTargetExisting&)
     {
 #ifdef ZEN_WIN
         //try to handle issues with already existing short 8.3 file names on Windows
-        if (have8dot3NameClash(newName))
+        if (have8dot3NameClash(itemPathNew))
         {
-            Fix8Dot3NameClash dummy(newName); //throw FileError; move clashing filepath to the side
+            Fix8Dot3NameClash dummy(itemPathNew); //throw FileError; move clashing filepath to the side
             //now try again...
-            renameFile_sub(oldName, newName); //throw FileError
+            renameFile_sub(itemPathOld, itemPathNew); //throw FileError
             return;
         }
 #endif
@@ -964,8 +936,8 @@ void zen::setFileTime(const Zstring& filepath, std::int64_t modTime, ProcSymlink
     // - utimensat() is supposed to obsolete utime/utimes and is also used by "touch"
     //=> let's give utimensat another chance:
     struct ::timespec newTimes[2] = {};
-    newTimes[0].tv_nsec = UTIME_OMIT; //omit access time
-    newTimes[1].tv_sec  = modTime;    //modification time (seconds)
+    newTimes[0].tv_sec = modTime; //access time: using UTIME_OMIT for tv_nsec would trigger even more bugs!! https://sourceforge.net/p/freefilesync/discussion/open-discussion/thread/218564cf/
+    newTimes[1].tv_sec = modTime; //modification time (seconds)
 
     if (procSl == ProcSymlink::FOLLOW)
     {
@@ -1016,13 +988,16 @@ bool zen::supportsPermissions(const Zstring& dirpath) //throw FileError
 #ifdef ZEN_WIN
     const DWORD bufferSize = MAX_PATH + 1;
     std::vector<wchar_t> buffer(bufferSize);
+
     if (!::GetVolumePathName(dirpath.c_str(), //__in   LPCTSTR lpszFileName,
                              &buffer[0],      //__out  LPTSTR lpszVolumePathName,
                              bufferSize))     //__in   DWORD cchBufferLength
         throwFileError(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtFileName(dirpath)), L"GetVolumePathName", getLastError());
 
+    const Zstring volumePath = appendSeparator(&buffer[0]);
+
     DWORD fsFlags = 0;
-    if (!::GetVolumeInformation(&buffer[0], //__in_opt   LPCTSTR lpRootPathName,
+    if (!::GetVolumeInformation(volumePath.c_str(), //__in_opt   LPCTSTR lpRootPathName,
                                 nullptr,    //__out      LPTSTR  lpVolumeNameBuffer,
                                 0,          //__in       DWORD   nVolumeNameSize,
                                 nullptr,    //__out_opt  LPDWORD lpVolumeSerialNumber,
@@ -1309,7 +1284,7 @@ void makeDirectoryRecursively(const Zstring& directory) //FileError, ErrorTarget
 
     try
     {
-        makeDirectoryPlain(directory, Zstring(), false); //throw FileError, ErrorTargetExisting, ErrorTargetPathMissing
+        copyNewDirectory(Zstring(), directory, false /*copyFilePermissions*/); //throw FileError, ErrorTargetExisting, ErrorTargetPathMissing
     }
     catch (const ErrorTargetPathMissing&)
     {
@@ -1322,10 +1297,10 @@ void makeDirectoryRecursively(const Zstring& directory) //FileError, ErrorTarget
             {
                 makeDirectoryRecursively(dirParent); //throw FileError, (ErrorTargetExisting)
             }
-            catch (const ErrorTargetExisting&) { /*parent directory created externally in the meantime? => NOT AN ERROR*/ }
+			catch (const ErrorTargetExisting&) {} //parent directory created externally in the meantime? => NOT AN ERROR; not a directory? fail in next step!
 
             //now try again...
-            makeDirectoryPlain(directory, Zstring(), false); //throw FileError, (ErrorTargetExisting), (ErrorTargetPathMissing)
+            copyNewDirectory(Zstring(), directory, false /*copyFilePermissions*/); //throw FileError, (ErrorTargetExisting), (ErrorTargetPathMissing)
             return;
         }
         throw;
@@ -1334,7 +1309,7 @@ void makeDirectoryRecursively(const Zstring& directory) //FileError, ErrorTarget
 }
 
 
-void zen::makeDirectory(const Zstring& directory, bool failIfExists) //throw FileError, ErrorTargetExisting
+void zen::makeNewDirectory(const Zstring& directory) //throw FileError, ErrorTargetExisting
 {
     //remove trailing separator (even for C:\ root directories)
     const Zstring dirFormatted = endsWith(directory, FILE_NAME_SEPARATOR) ?
@@ -1345,40 +1320,22 @@ void zen::makeDirectory(const Zstring& directory, bool failIfExists) //throw Fil
     {
         makeDirectoryRecursively(dirFormatted); //FileError, ErrorTargetExisting
     }
-    catch (const ErrorTargetExisting&)
-    {
-        //avoid any file system race-condition by *not* checking directory existence again here!!!
-        if (failIfExists)
-            throw;
-    }
-    catch (const FileError&)
+    catch (const ErrorTargetExisting&) //*something* existing: folder or FILE!
     {
-        /*
-        could there be situations where a directory/network path exists,
-        but creation fails with error different than "ErrorTargetExisting"??
-        - creation of C:\ fails with ERROR_ACCESS_DENIED rather than ERROR_ALREADY_EXISTS
-        */
-        if (somethingExists(directory)) //a file system race-condition! don't use dirExists() => harmonize with ErrorTargetExisting!
-        {
-            assert(false);
-            if (failIfExists)
-                throw; //do NOT convert to ErrorTargetExisting: if "failIfExists", not getting a ErrorTargetExisting *atomically* is unexpected!
-        }
-        else
+       //avoid any file system race-condition by *not* checking existence again here!!!
             throw;
     }
 }
 
 
-void zen::makeDirectoryPlain(const Zstring& directory, //throw FileError, ErrorTargetExisting, ErrorTargetPathMissing
-                             const Zstring& templateDir,
+void zen::copyNewDirectory(const Zstring& sourcePath, const Zstring& targetPath, //throw FileError, ErrorTargetExisting, ErrorTargetPathMissing
                              bool copyFilePermissions)
 {
 #ifdef ZEN_WIN
     //special handling for volume root: trying to create existing root directory results in ERROR_ACCESS_DENIED rather than ERROR_ALREADY_EXISTS!
-    Zstring dirTmp = removeLongPathPrefix(endsWith(directory, FILE_NAME_SEPARATOR) ?
-                                          beforeLast(directory, FILE_NAME_SEPARATOR) :
-                                          directory);
+    Zstring dirTmp = removeLongPathPrefix(endsWith(targetPath, FILE_NAME_SEPARATOR) ?
+                                          beforeLast(targetPath, FILE_NAME_SEPARATOR) :
+                                          targetPath);
     if (dirTmp.size() == 2 &&
         std::iswalpha(dirTmp[0]) && dirTmp[1] == L':')
     {
@@ -1398,19 +1355,19 @@ void zen::makeDirectoryPlain(const Zstring& directory, //throw FileError, ErrorT
     //- it may fail with "wrong parameter (error code 87)" when source is on mapped online storage
     //- automatically copies symbolic links if encountered: unfortunately it doesn't copy symlinks over network shares but silently creates empty folders instead (on XP)!
     //- it isn't able to copy most junctions because of missing permissions (although target path can be retrieved alternatively!)
-    if (!::CreateDirectory(applyLongPathPrefixCreateDir(directory).c_str(), //__in      LPCTSTR lpPathName,
+    if (!::CreateDirectory(applyLongPathPrefixCreateDir(targetPath).c_str(), //__in      LPCTSTR lpPathName,
                            nullptr))                                        //__in_opt  LPSECURITY_ATTRIBUTES lpSecurityAttributes
     {
         DWORD lastError = ::GetLastError(); //copy before directly or indirectly making other system calls!
 
         //handle issues with already existing short 8.3 file names on Windows
         if (lastError == ERROR_ALREADY_EXISTS)
-            if (have8dot3NameClash(directory))
+            if (have8dot3NameClash(targetPath))
             {
-                Fix8Dot3NameClash dummy(directory); //throw FileError; move clashing object to the side
+                Fix8Dot3NameClash dummy(targetPath); //throw FileError; move clashing object to the side
 
                 //now try again...
-                if (::CreateDirectory(applyLongPathPrefixCreateDir(directory).c_str(), nullptr))
+                if (::CreateDirectory(applyLongPathPrefixCreateDir(targetPath).c_str(), nullptr))
                     lastError = ERROR_SUCCESS;
                 else
                     lastError = ::GetLastError();
@@ -1418,7 +1375,7 @@ void zen::makeDirectoryPlain(const Zstring& directory, //throw FileError, ErrorT
 
         if (lastError != ERROR_SUCCESS)
         {
-            const std::wstring errorMsg = replaceCpy(_("Cannot create directory %x."), L"%x", fmtFileName(directory));
+            const std::wstring errorMsg = replaceCpy(_("Cannot create directory %x."), L"%x", fmtFileName(targetPath));
             const std::wstring errorDescr = formatSystemError(L"CreateDirectory", lastError);
 
             if (lastError == ERROR_ALREADY_EXISTS)
@@ -1433,18 +1390,18 @@ void zen::makeDirectoryPlain(const Zstring& directory, //throw FileError, ErrorT
     mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO; //= default for newly created directory
 
     struct ::stat dirInfo = {};
-    if (!templateDir.empty())
-        if (::stat(templateDir.c_str(), &dirInfo) == 0)
+    if (!sourcePath.empty())
+        if (::stat(sourcePath.c_str(), &dirInfo) == 0)
         {
             mode = dirInfo.st_mode; //analog to "cp" which copies "mode" (considering umask) by default
             mode |= S_IRWXU; //FFS only: we need full access to copy child items! "cp" seems to apply permissions *after* copying child items
         }
     //=> need copyItemPermissions() only for "chown" and umask-agnostic permissions
 
-    if (::mkdir(directory.c_str(), mode) != 0)
+    if (::mkdir(targetPath.c_str(), mode) != 0)
     {
         const int lastError = errno; //copy before directly or indirectly making other system calls!
-        const std::wstring errorMsg = replaceCpy(_("Cannot create directory %x."), L"%x", fmtFileName(directory));
+        const std::wstring errorMsg = replaceCpy(_("Cannot create directory %x."), L"%x", fmtFileName(targetPath));
         const std::wstring errorDescr = formatSystemError(L"mkdir", lastError);
 
         if (lastError == EEXIST)
@@ -1455,11 +1412,11 @@ void zen::makeDirectoryPlain(const Zstring& directory, //throw FileError, ErrorT
     }
 #endif
 
-    if (!templateDir.empty())
+    if (!sourcePath.empty())
     {
 #ifdef ZEN_WIN
         //optional: try to copy file attributes (dereference symlinks and junctions)
-        const HANDLE hDirSrc = ::CreateFile(zen::applyLongPathPrefix(templateDir).c_str(),          //_In_      LPCTSTR lpFileName,
+        const HANDLE hDirSrc = ::CreateFile(zen::applyLongPathPrefix(sourcePath).c_str(),          //_In_      LPCTSTR lpFileName,
                                             0,                                                      //_In_      DWORD dwDesiredAccess,
                                             FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, //_In_      DWORD dwShareMode,
                                             nullptr,                                                //_In_opt_  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
@@ -1474,16 +1431,16 @@ void zen::makeDirectoryPlain(const Zstring& directory, //throw FileError, ErrorT
             BY_HANDLE_FILE_INFORMATION dirInfo = {};
             if (::GetFileInformationByHandle(hDirSrc, &dirInfo))
             {
-                ::SetFileAttributes(applyLongPathPrefix(directory).c_str(), dirInfo.dwFileAttributes);
+                ::SetFileAttributes(applyLongPathPrefix(targetPath).c_str(), dirInfo.dwFileAttributes);
                 //copy "read-only and system attributes": http://blogs.msdn.com/b/oldnewthing/archive/2003/09/30/55100.aspx
 
                 const bool isEncrypted  = (dirInfo.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED)  != 0;
                 const bool isCompressed = (dirInfo.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) != 0;
 
                 if (isEncrypted)
-                    ::EncryptFile(directory.c_str()); //seems no long path is required (check passed!)
+                    ::EncryptFile(targetPath.c_str()); //seems no long path is required (check passed!)
 
-                HANDLE hDirTrg = ::CreateFile(applyLongPathPrefix(directory).c_str(), //_In_      LPCTSTR lpFileName,
+                HANDLE hDirTrg = ::CreateFile(applyLongPathPrefix(targetPath).c_str(), //_In_      LPCTSTR lpFileName,
                                               GENERIC_READ | GENERIC_WRITE,           //_In_      DWORD dwDesiredAccess,
                                               /*read access required for FSCTL_SET_COMPRESSION*/
                                               FILE_SHARE_READ  |
@@ -1521,14 +1478,14 @@ void zen::makeDirectoryPlain(const Zstring& directory, //throw FileError, ErrorT
         }
 
 #elif defined ZEN_MAC
-        /*int rv =*/ ::copyfile(templateDir.c_str(), directory.c_str(), 0, COPYFILE_XATTR);
+        /*int rv =*/ ::copyfile(sourcePath.c_str(), targetPath.c_str(), 0, COPYFILE_XATTR);
 #endif
 
-        zen::ScopeGuard guardNewDir = zen::makeGuard([&] { try { removeDirectory(directory); } catch (FileError&) {} }); //ensure cleanup:
+        zen::ScopeGuard guardNewDir = zen::makeGuard([&] { try { removeDirectory(targetPath); } catch (FileError&) {} }); //ensure cleanup:
 
         //enforce copying file permissions: it's advertized on GUI...
         if (copyFilePermissions)
-            copyItemPermissions(templateDir, directory, ProcSymlink::FOLLOW); //throw FileError
+            copyItemPermissions(sourcePath, targetPath, ProcSymlink::FOLLOW); //throw FileError
 
         guardNewDir.dismiss(); //target has been created successfully!
     }
@@ -1663,7 +1620,7 @@ bool canCopyAsSparse(DWORD fileAttrSource, const Zstring& targetFile) //throw ()
         return false; //small perf optimization: don't check "targetFile" if not needed
 
     //------------------------------------------------------------------------------------
-    const DWORD bufferSize = 10000;
+    const DWORD bufferSize = MAX_PATH + 1;
     std::vector<wchar_t> buffer(bufferSize);
 
     //full pathName need not yet exist!
@@ -1672,8 +1629,10 @@ bool canCopyAsSparse(DWORD fileAttrSource, const Zstring& targetFile) //throw ()
                              bufferSize))        //__in   DWORD cchBufferLength
         return false;
 
+    const Zstring volumePath = appendSeparator(&buffer[0]);
+
     DWORD fsFlagsTarget = 0;
-    if (!::GetVolumeInformation(&buffer[0],     //__in_opt   LPCTSTR lpRootPathName
+    if (!::GetVolumeInformation(volumePath.c_str(), //__in_opt   LPCTSTR lpRootPathName
                                 nullptr,        //__out_opt  LPTSTR lpVolumeNameBuffer,
                                 0,              //__in       DWORD nVolumeNameSize,
                                 nullptr,        //__out_opt  LPDWORD lpVolumeSerialNumber,
@@ -1715,10 +1674,9 @@ bool canCopyAsSparse(const Zstring& sourceFile, const Zstring& targetFile) //thr
 
 
 //precondition: canCopyAsSparse() must return "true"!
-void copyFileWindowsSparse(const Zstring& sourceFile,
-                           const Zstring& targetFile,
-                           const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus,
-                           InSyncAttributes* newAttrib) //throw FileError, ErrorTargetExisting, ErrorFileLocked
+InSyncAttributes copyFileWindowsSparse(const Zstring& sourceFile, //throw FileError, ErrorTargetExisting, ErrorFileLocked
+                                       const Zstring& targetFile,
+                                       const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus)
 {
     assert(canCopyAsSparse(sourceFile, targetFile));
 
@@ -1810,13 +1768,11 @@ void copyFileWindowsSparse(const Zstring& sourceFile,
         throwFileError(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtFileName(targetFile)), L"GetFileInformationByHandle", getLastError());
 
     //return up-to-date file attributes
-    if (newAttrib)
-    {
-        newAttrib->fileSize         = get64BitUInt(fileInfoSource.nFileSizeLow, fileInfoSource.nFileSizeHigh);
-        newAttrib->modificationTime = filetimeToTimeT(fileInfoSource.ftLastWriteTime); //no DST hack (yet)
-        newAttrib->sourceFileId     = extractFileId(fileInfoSource);
-        newAttrib->targetFileId     = extractFileId(fileInfoTarget);
-    }
+    InSyncAttributes newAttrib = {};
+    newAttrib.fileSize         = get64BitUInt(fileInfoSource.nFileSizeLow, fileInfoSource.nFileSizeHigh);
+    newAttrib.modificationTime = filetimeToTimeT(fileInfoSource.ftLastWriteTime); //no DST hack (yet)
+    newAttrib.sourceFileId     = extractFileId(fileInfoSource);
+    newAttrib.targetFileId     = extractFileId(fileInfoTarget);
 
     //#################### copy NTFS compressed attribute #########################
     const bool sourceIsCompressed = (fileInfoSource.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) != 0;
@@ -1860,7 +1816,7 @@ void copyFileWindowsSparse(const Zstring& sourceFile,
     }
 
     //----------------------------------------------------------------------
-    const DWORD BUFFER_SIZE = 128 * 1024; //must be greater than sizeof(WIN32_STREAM_ID)
+    const DWORD BUFFER_SIZE = std::max(128 * 1024, static_cast<int>(sizeof(WIN32_STREAM_ID))); //must be greater than sizeof(WIN32_STREAM_ID)!
     std::vector<BYTE> buffer(BUFFER_SIZE);
 
     LPVOID contextRead  = nullptr; //manage context for BackupRead()/BackupWrite()
@@ -1886,7 +1842,7 @@ void copyFileWindowsSparse(const Zstring& sourceFile,
             throwFileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(sourceFile)), L"BackupRead", getLastError()); //better use fine-granular error messages "reading/writing"!
 
         if (bytesRead > BUFFER_SIZE)
-            throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(sourceFile)), L"buffer overflow"); //user should never see this
+            throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(sourceFile)), L"BackupRead: buffer overflow."); //user should never see this
 
         if (bytesRead < BUFFER_SIZE)
             eof = true;
@@ -1902,7 +1858,7 @@ void copyFileWindowsSparse(const Zstring& sourceFile,
             throwFileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(targetFile)), L"BackupWrite", getLastError());
 
         if (bytesWritten != bytesRead)
-            throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(targetFile)), L"incomplete write"); //user should never see this
+            throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(targetFile)), L"BackupWrite: incomplete write."); //user should never see this
 
         //total bytes transferred may be larger than file size! context information + ADS or smaller (sparse, compressed)!
 
@@ -1918,7 +1874,7 @@ void copyFileWindowsSparse(const Zstring& sourceFile,
     //::BackupRead() silently fails reading encrypted files -> double check!
     if (!someBytesWritten && get64BitUInt(fileInfoSource.nFileSizeLow, fileInfoSource.nFileSizeHigh) != 0U)
         //note: there is no guaranteed ordering relation beween bytes transferred and file size! Consider ADS (>) and compressed/sparse files (<)!
-        throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(sourceFile)), L"unknown error"); //user should never see this -> this method is called only if "canCopyAsSparse()"
+        throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(sourceFile)), L"BackupRead: unknown error"); //user should never see this -> this method is called only if "canCopyAsSparse()"
 
     //time needs to be set at the end: BackupWrite() changes modification time
     if (!::SetFileTime(hFileTarget,
@@ -1928,6 +1884,7 @@ void copyFileWindowsSparse(const Zstring& sourceFile,
         throwFileError(replaceCpy(_("Cannot write modification time of %x."), L"%x", fmtFileName(targetFile)), L"SetFileTime", getLastError());
 
     guardTarget.dismiss();
+    return newAttrib;
 }
 
 
@@ -2049,13 +2006,12 @@ DWORD CALLBACK copyCallbackInternal(LARGE_INTEGER totalFileSize,
 
 
 const bool supportNonEncryptedDestination = winXpOrLater(); //encrypted destination is not supported with Windows 2000
-//caveat: function scope static initialization is not thread-safe in VS 2010!
+//caveat: function scope static initialization is not thread-safe in VS 2010! -> still not sufficient if multiple threads access during static init!!!
 
 
-void copyFileWindowsDefault(const Zstring& sourceFile,
-                            const Zstring& targetFile,
-                            const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus,
-                            InSyncAttributes* newAttrib) //throw FileError, ErrorTargetExisting, ErrorFileLocked, ErrorShouldCopyAsSparse
+InSyncAttributes copyFileWindowsDefault(const Zstring& sourceFile, //throw FileError, ErrorTargetExisting, ErrorFileLocked, ErrorShouldCopyAsSparse
+                                        const Zstring& targetFile,
+                                        const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus)
 {
     //try to get backup read and write privileges: who knows, maybe this helps solve some obscure "access denied" errors
     try { activatePrivilege(SE_BACKUP_NAME); }
@@ -2129,7 +2085,7 @@ void copyFileWindowsDefault(const Zstring& sourceFile,
             if (lastError == ERROR_INVALID_PARAMETER &&
                 isFatDrive(targetFile) &&
                 getFilesize(sourceFile) >= 4U * std::uint64_t(1024U * 1024 * 1024)) //throw FileError
-                errorDescr += L"\nFAT volumes cannot store files larger than 4 gigabyte.";
+                errorDescr += L"\nFAT volumes cannot store files larger than 4 gigabytes.";
             //see "Limitations of the FAT32 File System": http://support.microsoft.com/kb/314463/en-us
 
             //note: ERROR_INVALID_PARAMETER can also occur when copying to a SharePoint server or MS SkyDrive and the target filepath is of a restricted type.
@@ -2139,47 +2095,45 @@ void copyFileWindowsDefault(const Zstring& sourceFile,
         throw FileError(errorMsg, errorDescr);
     }
 
-    if (newAttrib)
-    {
-        newAttrib->fileSize         = get64BitUInt(cbd.fileInfoSrc.nFileSizeLow, cbd.fileInfoSrc.nFileSizeHigh);
-        newAttrib->modificationTime = filetimeToTimeT(cbd.fileInfoSrc.ftLastWriteTime);
-        newAttrib->sourceFileId     = extractFileId(cbd.fileInfoSrc);
-        newAttrib->targetFileId     = extractFileId(cbd.fileInfoTrg);
-    }
-
     //caveat: - ::CopyFileEx() silently *ignores* failure to set modification time!!! => we always need to set it again but with proper error checking!
     //	      - perf: recent measurements show no slow down at all for buffered USB sticks!
     setFileTimeRaw(targetFile, &cbd.fileInfoSrc.ftCreationTime, cbd.fileInfoSrc.ftLastWriteTime, ProcSymlink::FOLLOW); //throw FileError
 
     guardTarget.dismiss(); //target has been created successfully!
+
+    InSyncAttributes newAttrib = {};
+    newAttrib.fileSize         = get64BitUInt(cbd.fileInfoSrc.nFileSizeLow, cbd.fileInfoSrc.nFileSizeHigh);
+    newAttrib.modificationTime = filetimeToTimeT(cbd.fileInfoSrc.ftLastWriteTime);
+    newAttrib.sourceFileId     = extractFileId(cbd.fileInfoSrc);
+    newAttrib.targetFileId     = extractFileId(cbd.fileInfoTrg);
+    return newAttrib;
 }
 
 
 //another layer to support copying sparse files
 inline
-void copyFileWindowsSelectRoutine(const Zstring& sourceFile, const Zstring& targetFile, const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus, InSyncAttributes* sourceAttr)
+InSyncAttributes copyFileWindowsSelectRoutine(const Zstring& sourceFile, const Zstring& targetFile, const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus)
 {
     try
     {
-        copyFileWindowsDefault(sourceFile, targetFile, onUpdateCopyStatus, sourceAttr); //throw FileError, ErrorTargetExisting, ErrorFileLocked, ErrorShouldCopyAsSparse
+        return copyFileWindowsDefault(sourceFile, targetFile, onUpdateCopyStatus); //throw FileError, ErrorTargetExisting, ErrorFileLocked, ErrorShouldCopyAsSparse
     }
     catch (ErrorShouldCopyAsSparse&) //we quickly check for this condition within callback of ::CopyFileEx()!
     {
-        copyFileWindowsSparse(sourceFile, targetFile, onUpdateCopyStatus, sourceAttr); //throw FileError, ErrorTargetExisting, ErrorFileLocked
+        return copyFileWindowsSparse(sourceFile, targetFile, onUpdateCopyStatus); //throw FileError, ErrorTargetExisting, ErrorFileLocked
     }
 }
 
 
 //another layer of indirection solving 8.3 name clashes
 inline
-void copyFileOsSpecific(const Zstring& sourceFile,
-                        const Zstring& targetFile,
-                        const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus,
-                        InSyncAttributes* sourceAttr)
+InSyncAttributes copyFileOsSpecific(const Zstring& sourceFile,
+                                    const Zstring& targetFile,
+                                    const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus)
 {
     try
     {
-        copyFileWindowsSelectRoutine(sourceFile, targetFile, onUpdateCopyStatus, sourceAttr); //throw FileError, ErrorTargetExisting, ErrorFileLocked
+        return copyFileWindowsSelectRoutine(sourceFile, targetFile, onUpdateCopyStatus); //throw FileError, ErrorTargetExisting, ErrorFileLocked
     }
     catch (const ErrorTargetExisting&)
     {
@@ -2187,8 +2141,7 @@ void copyFileOsSpecific(const Zstring& sourceFile,
         if (have8dot3NameClash(targetFile))
         {
             Fix8Dot3NameClash dummy(targetFile); //throw FileError; move clashing filepath to the side
-            copyFileWindowsSelectRoutine(sourceFile, targetFile, onUpdateCopyStatus, sourceAttr); //throw FileError; the short filepath name clash is solved, this should work now
-            return;
+            return copyFileWindowsSelectRoutine(sourceFile, targetFile, onUpdateCopyStatus); //throw FileError; the short filepath name clash is solved, this should work now
         }
         throw;
     }
@@ -2196,10 +2149,9 @@ void copyFileOsSpecific(const Zstring& sourceFile,
 
 
 #elif defined ZEN_LINUX || defined ZEN_MAC
-void copyFileOsSpecific(const Zstring& sourceFile,
-                        const Zstring& targetFile,
-                        const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus,
-                        InSyncAttributes* newAttrib) //throw FileError, ErrorTargetExisting
+InSyncAttributes copyFileOsSpecific(const Zstring& sourceFile, //throw FileError, ErrorTargetExisting
+                                    const Zstring& targetFile,
+                                    const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus)
 {
     FileInput fileIn(sourceFile); //throw FileError
 
@@ -2221,40 +2173,31 @@ void copyFileOsSpecific(const Zstring& sourceFile,
 
         throw FileError(errorMsg, errorDescr);
     }
+    if (onUpdateCopyStatus) onUpdateCopyStatus(0); //throw X!
 
+    InSyncAttributes newAttrib = {};
     zen::ScopeGuard guardTarget = zen::makeGuard([&] { try { removeFile(targetFile); } catch (FileError&) {} });
     //transactional behavior: place guard after ::open() and before lifetime of FileOutput:
     //=> don't delete file that existed previously!!!
     {
         FileOutput fileOut(fdTarget, targetFile); //pass ownership
+        if (onUpdateCopyStatus) onUpdateCopyStatus(0); //throw X!
 
-        std::vector<char> buffer(128 * 1024);
-        do
-        {
-            const size_t bytesRead = fileIn.read(&buffer[0], buffer.size()); //throw FileError
-
-            fileOut.write(&buffer[0], bytesRead); //throw FileError
-
-            if (onUpdateCopyStatus)
-                onUpdateCopyStatus(bytesRead); //throw X!
-        }
-        while (!fileIn.eof());
+        copyStream(fileIn, fileOut, std::min(fileIn .optimalBlockSize(),
+                                             fileOut.optimalBlockSize()), onUpdateCopyStatus); //throw FileError, X
 
         struct ::stat targetInfo = {};
         if (::fstat(fileOut.getHandle(), &targetInfo) != 0)
             throwFileError(replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtFileName(targetFile)), L"fstat", getLastError());
 
-        if (newAttrib) //return file statistics
-        {
-            newAttrib->fileSize         = sourceInfo.st_size;
+        newAttrib.fileSize         = sourceInfo.st_size;
 #ifdef  ZEN_MAC
-            newAttrib->modificationTime = sourceInfo.st_mtimespec.tv_sec; //use same time variable like setFileTimeRaw() for consistency
+        newAttrib.modificationTime = sourceInfo.st_mtimespec.tv_sec; //use same time variable like setFileTimeRaw() for consistency
 #else
-            newAttrib->modificationTime = sourceInfo.st_mtime;
+        newAttrib.modificationTime = sourceInfo.st_mtime;
 #endif
-            newAttrib->sourceFileId     = extractFileId(sourceInfo);
-            newAttrib->targetFileId     = extractFileId(targetInfo);
-        }
+        newAttrib.sourceFileId     = extractFileId(sourceInfo);
+        newAttrib.targetFileId     = extractFileId(targetInfo);
 
 #ifdef ZEN_MAC
         //using ::copyfile with COPYFILE_DATA seems to trigger bugs unlike our stream-based copying!
@@ -2265,6 +2208,8 @@ void copyFileOsSpecific(const Zstring& sourceFile,
         if (::fcopyfile(fileIn.getHandle(), fileOut.getHandle(), 0, COPYFILE_XATTR) != 0)
             throwFileError(replaceCpy(replaceCpy(_("Cannot copy attributes from %x to %y."), L"%x", L"\n" + fmtFileName(sourceFile)), L"%y", L"\n" + fmtFileName(targetFile)), L"copyfile", getLastError());
 #endif
+
+fileOut.close(); //throw FileError -> optional, but good place to catch errors when closing stream!
     } //close output file handle before setting file time
 
     //we cannot set the target file times (::futimes) while the file descriptor is still open after a write operation:
@@ -2272,7 +2217,7 @@ void copyFileOsSpecific(const Zstring& sourceFile,
     //Linux: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=340236
     //       http://comments.gmane.org/gmane.linux.file-systems.cifs/2854
     //OS X:  https://sourceforge.net/p/freefilesync/discussion/help/thread/881357c0/
-#ifdef  ZEN_MAC
+#ifdef ZEN_MAC
     setFileTimeRaw(targetFile, &sourceInfo.st_birthtimespec, sourceInfo.st_mtimespec, ProcSymlink::FOLLOW); //throw FileError
     //sourceInfo.st_birthtime; -> only seconds-precision
     //sourceInfo.st_mtime;     ->
@@ -2281,6 +2226,7 @@ void copyFileOsSpecific(const Zstring& sourceFile,
 #endif
 
     guardTarget.dismiss(); //target has been created successfully!
+    return newAttrib;
 }
 #endif
 
@@ -2288,25 +2234,21 @@ void copyFileOsSpecific(const Zstring& sourceFile,
                ------------------
                |File Copy Layers|
                ------------------
-                  copyFile (setup transactional behavior)
+                  copyNewFile
                         |
-                copyFileWithPermissions
-                        |
-               copyFileOsSpecific (solve 8.3 issue)
+               copyFileOsSpecific (solve 8.3 issue on Windows)
                         |
 			  copyFileWindowsSelectRoutine
 	          /                           \
 copyFileWindowsDefault(::CopyFileEx)  copyFileWindowsSparse(::BackupRead/::BackupWrite)
 */
+}
 
-inline
-void copyFileWithPermissions(const Zstring& sourceFile,
-                             const Zstring& targetFile,
-                             bool copyFilePermissions,
-                             const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus,
-                             InSyncAttributes* sourceAttr)
+
+InSyncAttributes zen::copyNewFile(const Zstring& sourceFile, const Zstring& targetFile, bool copyFilePermissions, //throw FileError, ErrorTargetExisting, ErrorFileLocked
+                                  const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus)
 {
-    copyFileOsSpecific(sourceFile, targetFile, onUpdateCopyStatus, sourceAttr); //throw FileError, ErrorTargetExisting, ErrorFileLocked
+    const InSyncAttributes attr = copyFileOsSpecific(sourceFile, targetFile, onUpdateCopyStatus); //throw FileError, ErrorTargetExisting, ErrorFileLocked
 
     if (copyFilePermissions)
     {
@@ -2317,67 +2259,6 @@ void copyFileWithPermissions(const Zstring& sourceFile,
 
         guardTargetFile.dismiss(); //target has been created successfully!
     }
-}
-}
-
-
-void zen::copyFile(const Zstring& sourceFile, //throw FileError, ErrorFileLocked
-                   const Zstring& targetFile,
-                   bool copyFilePermissions,
-                   bool transactionalCopy,
-                   const std::function<void()>& onDeleteTargetFile,
-                   const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus,
-                   InSyncAttributes* sourceAttr)
-{
-    if (transactionalCopy)
-    {
-        Zstring tmpTarget = targetFile + TEMP_FILE_ENDING;
-
-        for (int i = 0;; ++i)
-            try
-            {
-                copyFileWithPermissions(sourceFile, tmpTarget, copyFilePermissions, onUpdateCopyStatus, sourceAttr); //throw FileError, ErrorTargetExisting, ErrorFileLocked
-                break;
-            }
-            catch (const ErrorTargetExisting&) //optimistic strategy: assume everything goes well, but recover on error -> minimize file accesses
-            {
-                if (i == 10) throw; //avoid endless recursion in pathological cases, e.g. https://sourceforge.net/p/freefilesync/discussion/open-discussion/thread/36adac33
-                tmpTarget = targetFile + Zchar('_') + numberTo<Zstring>(i) + TEMP_FILE_ENDING;
-            }
-
-        //transactional behavior: ensure cleanup; not needed before copyFileWithPermissions() which is already transactional
-        zen::ScopeGuard guardTempFile = zen::makeGuard([&] { try { removeFile(tmpTarget); } catch (FileError&) {} });
-
-        //have target file deleted (after read access on source and target has been confirmed) => allow for almost transactional overwrite
-        if (onDeleteTargetFile)
-            onDeleteTargetFile(); //throw X
-
-        //perf: this call is REALLY expensive on unbuffered volumes! ~40% performance decrease on FAT USB stick!
-        renameFile(tmpTarget, targetFile); //throw FileError
-
-        /*
-        CAVEAT on FAT/FAT32: the sequence of deleting the target file and renaming "file.txt.ffs_tmp" to "file.txt" does
-        NOT PRESERVE the creation time of the .ffs_tmp file, but SILENTLY "reuses" whatever creation time the old "file.txt" had!
-        This "feature" is called "File System Tunneling":
-        http://blogs.msdn.com/b/oldnewthing/archive/2005/07/15/439261.aspx
-        http://support.microsoft.com/kb/172190/en-us
-        */
-
-        guardTempFile.dismiss();
-    }
-    else
-    {
-        /*
-           Note: non-transactional file copy solves at least four problems:
-            	-> skydrive - doesn't allow for .ffs_tmp extension and returns ERROR_INVALID_PARAMETER
-            	-> network renaming issues
-            	-> allow for true delete before copy to handle low disk space problems
-            	-> higher performance on non-buffered drives (e.g. usb sticks)
-        */
 
-        if (onDeleteTargetFile)
-            onDeleteTargetFile();
-
-        copyFileWithPermissions(sourceFile, targetFile, copyFilePermissions, onUpdateCopyStatus, sourceAttr); //throw FileError, ErrorTargetExisting, ErrorFileLocked
-    }
+    return attr;
 }
diff --git a/zen/file_access.h b/zen/file_access.h
index bd1b0168..0dfb650e 100644
--- a/zen/file_access.h
+++ b/zen/file_access.h
@@ -29,7 +29,7 @@ void setFileTime(const Zstring& filepath, std::int64_t modificationTime, ProcSym
 
 //symlink handling: always evaluate target
 std::uint64_t getFilesize(const Zstring& filepath); //throw FileError
-std::uint64_t getFreeDiskSpace(const Zstring& path); //throw FileError
+std::uint64_t getFreeDiskSpace(const Zstring& path); //throw FileError, returns 0 if not available
 
 bool removeFile(const Zstring& filepath); //throw FileError; return "false" if file is not existing
 void removeDirectory(const Zstring& directory, //throw FileError
@@ -37,17 +37,18 @@ void removeDirectory(const Zstring& directory, //throw FileError
                      const std::function<void (const Zstring& dirpath )>& onBeforeDirDeletion  = nullptr); //one call for each *existing* object!
 
 //rename file or directory: no copying!!!
-void renameFile(const Zstring& oldName, const Zstring& newName); //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
+void renameFile(const Zstring& itemPathOld, const Zstring& itemPathNew); //throw FileError, ErrorDifferentVolume, ErrorTargetExisting
 
 bool supportsPermissions(const Zstring& dirpath); //throw FileError, dereferences symlinks
 
 //if parent directory not existing: create recursively:
-void makeDirectory(const Zstring& directory, bool failIfExists = false); //throw FileError, ErrorTargetExisting
+void makeNewDirectory(const Zstring& directory); //throw FileError, ErrorTargetExisting
 
 //fail if already existing or parent directory not existing:
 //directory should not end with path separator
-//templateDir may be empty
-void makeDirectoryPlain(const Zstring& directory, const Zstring& templateDir, bool copyFilePermissions); //throw FileError, ErrorTargetExisting, ErrorTargetPathMissing
+void copyNewDirectory(const Zstring& sourcePath, const Zstring& targetPath, bool copyFilePermissions); //throw FileError, ErrorTargetExisting, ErrorTargetPathMissing
+
+void copySymlink(const Zstring& sourceLink, const Zstring& targetLink, bool copyFilePermissions); //throw FileError
 
 struct InSyncAttributes
 {
@@ -57,24 +58,9 @@ struct InSyncAttributes
     FileId targetFileId;
 };
 
-void copyFile(const Zstring& sourceFile, //throw FileError, ErrorFileLocked (Windows-only)
-              const Zstring& targetFile, //symlink handling: dereference source
-              bool copyFilePermissions,
-              bool transactionalCopy,
-              //if target is existing user needs to implement deletion: copyFile() NEVER overwrites target if already existing!
-              //if transactionalCopy == true, full read access on source had been proven at this point, so it's safe to delete it.
-              const std::function<void()>& onDeleteTargetFile, //may be nullptr; may throw!
-              //accummulated delta != file size! consider ADS, sparse, compressed files
-              const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus, //may be nullptr; may throw!
-
-              InSyncAttributes* newAttrib = nullptr);  //return current attributes at the time of copy
-
-//Note: it MAY happen that copyFile() leaves temp files behind, e.g. temporary network drop.
-// => clean them up at an appropriate time (automatically set sync directions to delete them). They have the following ending:
-
-const Zchar TEMP_FILE_ENDING[] = Zstr(".ffs_tmp"); //don't use Zstring as global constant: avoid static initialization order problem in global namespace!
-
-void copySymlink(const Zstring& sourceLink, const Zstring& targetLink, bool copyFilePermissions); //throw FileError
+InSyncAttributes copyNewFile(const Zstring& sourceFile, const Zstring& targetFile, bool copyFilePermissions, //throw FileError, ErrorTargetExisting, ErrorFileLocked
+                             //accummulated delta != file size! consider ADS, sparse, compressed files
+                             const std::function<void(std::int64_t bytesDelta)>& onUpdateCopyStatus); //may be nullptr; throw X!
 }
 
 #endif //FILE_ACCESS_H_8017341345614857
diff --git a/zen/file_id_def.h b/zen/file_id_def.h
index a96e978b..7a2059a6 100644
--- a/zen/file_id_def.h
+++ b/zen/file_id_def.h
@@ -23,7 +23,8 @@ namespace zen
 typedef DWORD DeviceId;
 typedef ULONGLONG FileIndex;
 
-typedef std::pair<DeviceId, FileIndex> FileId;
+typedef std::pair<DeviceId, FileIndex> FileId; //optional! (however, always set on Linux, and *generally* available on Windows)    
+
 
 inline
 FileId extractFileId(const BY_HANDLE_FILE_INFORMATION& fileInfo)
diff --git a/zen/file_io.cpp b/zen/file_io.cpp
index d4bfdd9b..a5412f19 100644
--- a/zen/file_io.cpp
+++ b/zen/file_io.cpp
@@ -5,6 +5,7 @@
 // **************************************************************************
 
 #include "file_io.h"
+#include "file_access.h"
 
 #ifdef ZEN_WIN
     #include "long_path_prefix.h"
@@ -75,10 +76,10 @@ void checkForUnsupportedType(const Zstring& filepath) //throw FileError
 }
 
 
-FileInput::FileInput(FileHandle handle, const Zstring& filepath) : FileInputBase(filepath), fileHandle(handle) {}
+FileInput::FileInput(FileHandle handle, const Zstring& filepath) : FileBase(filepath), fileHandle(handle) {}
 
 
-FileInput::FileInput(const Zstring& filepath) : FileInputBase(filepath) //throw FileError
+FileInput::FileInput(const Zstring& filepath) : FileBase(filepath) //throw FileError, ErrorFileLocked
 {
 #ifdef ZEN_WIN
     auto createHandle = [&](DWORD dwShareMode)
@@ -135,6 +136,7 @@ FileInput::FileInput(const Zstring& filepath) : FileInputBase(filepath) //throw
                 const Zstring procList = getLockingProcessNames(filepath); //throw()
                 if (!procList.empty())
                     errorDescr = _("The file is locked by another process:") + L"\n" + procList;
+                throw ErrorFileLocked(errorMsg, errorDescr);
             }
             throw FileError(errorMsg, errorDescr);
         }
@@ -169,62 +171,50 @@ FileInput::~FileInput()
 
 size_t FileInput::read(void* buffer, size_t bytesToRead) //throw FileError; returns actual number of bytes read
 {
-    assert(!eof() || bytesToRead == 0);
-#ifdef ZEN_WIN
-    if (bytesToRead == 0) return 0;
-
-    DWORD bytesRead = 0;
-    if (!::ReadFile(fileHandle, //__in         HANDLE hFile,
-                    buffer,     //__out        LPVOID lpBuffer,
-                    static_cast<DWORD>(bytesToRead), //__in         DWORD nNumberOfBytesToRead,
-                    &bytesRead, //__out_opt    LPDWORD lpNumberOfBytesRead,
-                    nullptr))   //__inout_opt  LPOVERLAPPED lpOverlapped
-        throwFileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(getFilename())), L"ReadFile", getLastError());
-
-    if (bytesRead < bytesToRead) //verify only!
-        setEof();                //
-
-    if (bytesRead > bytesToRead)
-        throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(getFilename())), L"buffer overflow"); //user should never see this
-
-    return bytesRead;
-
-#elif defined ZEN_LINUX || defined ZEN_MAC
-    //Compare copy_reg() in copy.c: ftp://ftp.gnu.org/gnu/coreutils/coreutils-8.23.tar.xz
     size_t bytesReadTotal = 0;
 
-    while (bytesToRead > 0 && !eof()) //"read() with a count of 0 returns zero" => indistinguishable from eof! => check!
+    while (bytesToRead > 0) //"read() with a count of 0 returns zero" => indistinguishable from end of file! => check!
     {
+#ifdef ZEN_WIN
+        //test for end of file: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365690%28v=vs.85%29.aspx
+        DWORD bytesRead = 0;
+        if (!::ReadFile(fileHandle, //__in         HANDLE hFile,
+                        buffer,     //__out        LPVOID lpBuffer,
+                        static_cast<DWORD>(bytesToRead), //__in         DWORD nNumberOfBytesToRead,
+                        &bytesRead, //__out_opt    LPDWORD lpNumberOfBytesRead,
+                        nullptr))   //__inout_opt  LPOVERLAPPED lpOverlapped
+            throwFileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(getFilePath())), L"ReadFile", getLastError());
+
+#elif defined ZEN_LINUX || defined ZEN_MAC
         ssize_t bytesRead = 0;
         do
         {
             bytesRead = ::read(fileHandle, buffer, bytesToRead);
         }
-        while (bytesRead < 0 && errno == EINTR);
+        while (bytesRead < 0 && errno == EINTR); //Compare copy_reg() in copy.c: ftp://ftp.gnu.org/gnu/coreutils/coreutils-8.23.tar.xz
 
         if (bytesRead < 0)
-            throwFileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(getFilename())), L"read", getLastError());
-        else if (bytesRead == 0) //"zero indicates end of file"
-            setEof();
-        else if (bytesRead > static_cast<ssize_t>(bytesToRead)) //better safe than sorry
-            throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(getFilename())), L"buffer overflow"); //user should never see this
+            throwFileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(getFilePath())), L"read", getLastError());
+#endif
+        if (bytesRead == 0) //"zero indicates end of file"
+            return bytesReadTotal;
+        else if (static_cast<size_t>(bytesRead) > bytesToRead) //better safe than sorry
+            throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(getFilePath())), L"ReadFile: buffer overflow."); //user should never see this
 
         //if ::read is interrupted (EINTR) right in the middle, it will return successfully with "bytesRead < bytesToRead" => loop!
         buffer = static_cast<char*>(buffer) + bytesRead; //suppress warning about pointer arithmetics on void*
         bytesToRead -= bytesRead;
         bytesReadTotal += bytesRead;
     }
-
     return bytesReadTotal;
-#endif
 }
 
 //----------------------------------------------------------------------------------------------------
 
-FileOutput::FileOutput(FileHandle handle, const Zstring& filepath) : FileOutputBase(filepath), fileHandle(handle) {}
+FileOutput::FileOutput(FileHandle handle, const Zstring& filepath) : FileBase(filepath), fileHandle(handle) {}
 
 
-FileOutput::FileOutput(const Zstring& filepath, AccessFlag access) : FileOutputBase(filepath) //throw FileError, ErrorTargetExisting
+FileOutput::FileOutput(const Zstring& filepath, AccessFlag access) : FileBase(filepath) //throw FileError, ErrorTargetExisting
 {
 #ifdef ZEN_WIN
     const DWORD dwCreationDisposition = access == FileOutput::ACC_OVERWRITE ? CREATE_ALWAYS : CREATE_NEW;
@@ -307,12 +297,45 @@ FileOutput::FileOutput(const Zstring& filepath, AccessFlag access) : FileOutputB
 }
 
 
+namespace
+{
+inline
+FileHandle getInvalidHandle()
+{
+#ifdef ZEN_WIN
+    return INVALID_HANDLE_VALUE;
+#elif defined ZEN_LINUX || defined ZEN_MAC
+    return -1;
+#endif
+}
+}
+
+
 FileOutput::~FileOutput()
 {
+    if (fileHandle != getInvalidHandle())
+        try
+        {
+            close(); //throw FileError
+        }
+        catch (FileError&) { assert(false); }
+}
+ 
+    
+void FileOutput::close() //throw FileError
+{
+    if (fileHandle == getInvalidHandle())
+        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilePath())), L"Contract error: close() called more than once.");
+    ZEN_ON_SCOPE_EXIT(fileHandle = getInvalidHandle());
+
+	//no need to clean-up on failure here (just like there is no clean on FileOutput::write failure!) => FileOutput is not transactional! 
+
 #ifdef ZEN_WIN
-    ::CloseHandle(fileHandle);
+    if (!::CloseHandle(fileHandle))
+        throwFileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilePath())), L"CloseHandle", getLastError());
 #elif defined ZEN_LINUX || defined ZEN_MAC
-    ::close(fileHandle);
+    if (::close(fileHandle) != 0)
+        throwFileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilePath())), L"close", getLastError());
 #endif
 }
 
@@ -326,10 +349,10 @@ void FileOutput::write(const void* buffer, size_t bytesToWrite) //throw FileErro
                      static_cast<DWORD>(bytesToWrite),  //__in         DWORD nNumberOfBytesToWrite,
                      &bytesWritten, //__out_opt    LPDWORD lpNumberOfBytesWritten,
                      nullptr))      //__inout_opt  LPOVERLAPPED lpOverlapped
-        throwFileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilename())), L"WriteFile", getLastError());
+        throwFileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilePath())), L"WriteFile", getLastError());
 
     if (bytesWritten != bytesToWrite) //must be fulfilled for synchronous writes!
-        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilename())), L"Incomplete write."); //user should never see this
+        throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilePath())), L"WriteFile: incomplete write."); //user should never see this
 
 #elif defined ZEN_LINUX || defined ZEN_MAC
     while (bytesToWrite > 0)
@@ -346,10 +369,10 @@ void FileOutput::write(const void* buffer, size_t bytesToWrite) //throw FileErro
             if (bytesWritten == 0) //comment in safe-read.c suggests to treat this as an error due to buggy drivers
                 errno = ENOSPC;
 
-            throwFileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilename())), L"write", getLastError());
+            throwFileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilePath())), L"write", getLastError());
         }
         if (bytesWritten > static_cast<ssize_t>(bytesToWrite)) //better safe than sorry
-            throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilename())), L"buffer overflow"); //user should never see this
+            throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(getFilePath())), L"write: buffer overflow."); //user should never see this
 
         //if ::write() is interrupted (EINTR) right in the middle, it will return successfully with "bytesWritten < bytesToWrite"!
         buffer = static_cast<const char*>(buffer) + bytesWritten; //suppress warning about pointer arithmetics on void*
diff --git a/zen/file_io.h b/zen/file_io.h
index ee7841ca..648bafe8 100644
--- a/zen/file_io.h
+++ b/zen/file_io.h
@@ -7,7 +7,6 @@
 #ifndef FILEIO_89578342758342572345
 #define FILEIO_89578342758342572345
 
-#include "file_io_base.h"
 #include "file_error.h"
 
 #ifdef ZEN_WIN
@@ -31,30 +30,56 @@ namespace zen
     typedef int FileHandle;
 #endif
 
-class FileInput : public FileInputBase
+class FileBase
 {
 public:
-    FileInput(const Zstring& filepath);                    //throw FileError
+    const Zstring& getFilePath() const { return filename_; }
+
+protected:
+    FileBase(const Zstring& filename) : filename_(filename)  {}
+
+private:
+    FileBase           (const FileBase&) = delete;
+    FileBase& operator=(const FileBase&) = delete;
+
+    const Zstring filename_;
+};
+
+//-----------------------------------------------------------------------------------------------
+
+class FileInput : public FileBase
+{
+public:
+    FileInput(const Zstring& filepath);                    //throw FileError, ErrorFileLocked
     FileInput(FileHandle handle, const Zstring& filepath); //takes ownership!
     ~FileInput();
 
-    size_t read(void* buffer, size_t bytesToRead) override; //throw FileError; returns actual number of bytes read
+    size_t read(void* buffer, size_t bytesToRead); //throw FileError; returns "bytesToRead", unless end of file!
     FileHandle getHandle() { return fileHandle; }
+    size_t optimalBlockSize() const { return 128 * 1024; }
 
 private:
     FileHandle fileHandle;
 };
 
 
-class FileOutput : public FileOutputBase
+class FileOutput : public FileBase
 {
 public:
+    enum AccessFlag
+    {
+        ACC_OVERWRITE,
+        ACC_CREATE_NEW
+    };
+
     FileOutput(const Zstring& filepath, AccessFlag access); //throw FileError, ErrorTargetExisting
     FileOutput(FileHandle handle, const Zstring& filepath); //takes ownership!
     ~FileOutput();
+    void close(); //throw FileError   -> optional, but good place to catch errors when closing stream!
 
-    void write(const void* buffer, size_t bytesToWrite) override; //throw FileError
+    void write(const void* buffer, size_t bytesToWrite); //throw FileError
     FileHandle getHandle() { return fileHandle; }
+    size_t optimalBlockSize() const { return 128 * 1024; }
 
 private:
     FileHandle fileHandle;
diff --git a/zen/file_io_base.h b/zen/file_io_base.h
deleted file mode 100644
index 9b6b27ca..00000000
--- a/zen/file_io_base.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// **************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0        *
-// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved        *
-// **************************************************************************
-
-#ifndef FILEIO_BASE_H_INCLUDED_23432431789615314
-#define FILEIO_BASE_H_INCLUDED_23432431789615314
-
-#include "zstring.h"
-
-namespace zen
-{
-class FileBase
-{
-public:
-    const Zstring& getFilename() const { return filename_; }
-
-protected:
-    FileBase(const Zstring& filename) : filename_(filename)  {}
-    ~FileBase() {}
-
-private:
-    FileBase           (const FileBase&) = delete;
-    FileBase& operator=(const FileBase&) = delete;
-
-    const Zstring filename_;
-};
-
-
-class FileInputBase : public FileBase
-{
-public:
-    virtual size_t read(void* buffer, size_t bytesToRead) = 0; //throw FileError; returns actual number of bytes read
-    bool eof() const { return eofReached; } //end of file reached
-
-protected:
-    FileInputBase(const Zstring& filename) : FileBase(filename), eofReached(false) {}
-    ~FileInputBase() {}
-    void setEof() { eofReached = true; }
-
-private:
-    bool eofReached;
-};
-
-
-class FileOutputBase : public FileBase
-{
-public:
-    enum AccessFlag
-    {
-        ACC_OVERWRITE,
-        ACC_CREATE_NEW
-    };
-    virtual void write(const void* buffer, size_t bytesToWrite) = 0; //throw FileError
-
-protected:
-    FileOutputBase(const Zstring& filename) : FileBase(filename) {}
-    ~FileOutputBase() {}
-};
-
-}
-
-#endif //FILEIO_BASE_H_INCLUDED_23432431789615314
diff --git a/zen/file_traverser.cpp b/zen/file_traverser.cpp
index baf40e9e..66dcd198 100644
--- a/zen/file_traverser.cpp
+++ b/zen/file_traverser.cpp
@@ -13,12 +13,12 @@
     #include "file_access.h"
     #include "symlink_target.h"
 #elif defined ZEN_MAC
-        #include "osx_string.h"
+    #include "osx_string.h"
 #endif
 
 #if defined ZEN_LINUX || defined ZEN_MAC
     #include <cstddef> //offsetof
-	#include <unistd.h> //::pathconf()
+    #include <unistd.h> //::pathconf()
     #include <sys/stat.h>
     #include <dirent.h>
 #endif
@@ -27,9 +27,9 @@ using namespace zen;
 
 
 void zen::traverseFolder(const Zstring& dirPath,
-                         const std::function<void (const FileInfo&    fi)>& onFile,         
-                         const std::function<void (const DirInfo&     di)>& onDir,          
-                         const std::function<void (const SymlinkInfo& si)>& onLink,         
+                         const std::function<void (const FileInfo&    fi)>& onFile,
+                         const std::function<void (const DirInfo&     di)>& onDir,
+                         const std::function<void (const SymlinkInfo& si)>& onLink,
                          const std::function<void (const std::wstring& errorMsg)>& onError)
 {
     try
@@ -51,13 +51,12 @@ void zen::traverseFolder(const Zstring& dirPath,
         }
         ZEN_ON_SCOPE_EXIT(::FindClose(hDir));
 
-		bool firstIteration = true;
+        bool firstIteration = true;
         for (;;)
-        {			
-			if (firstIteration) //keep ::FindNextFile at the start of the for-loop to support "continue"!
-				firstIteration = false;
-			else
-            if (!::FindNextFile(hDir, &findData))
+        {
+            if (firstIteration) //keep ::FindNextFile at the start of the for-loop to support "continue"!
+                firstIteration = false;
+            else if (!::FindNextFile(hDir, &findData))
             {
                 const DWORD lastError = ::GetLastError();
                 if (lastError == ERROR_NO_MORE_FILES) //not an error situation
@@ -69,7 +68,7 @@ void zen::traverseFolder(const Zstring& dirPath,
             //skip "." and ".."
             const Zchar* const shortName = findData.cFileName;
 
-			if (shortName[0] == 0) throw FileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirPath)), L"Data corruption: Found item without name.");
+            if (shortName[0] == 0) throw FileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirPath)), L"FindNextFile: Data corruption, found item without name.");
             if (shortName[0] == L'.' &&
                 (shortName[1] == 0 || (shortName[1] == L'.' && shortName[2] == 0)))
                 continue;
@@ -94,32 +93,27 @@ void zen::traverseFolder(const Zstring& dirPath,
         }
 
 #elif defined ZEN_LINUX || defined ZEN_MAC
-        const Zstring dirPathFmt = //remove trailing slash
-            dirPath.size() > 1 && endsWith(dirPath, FILE_NAME_SEPARATOR) ?  //exception: allow '/'
-            beforeLast(dirPath, FILE_NAME_SEPARATOR) :
-            dirPath;
-
         /* quote: "Since POSIX.1 does not specify the size of the d_name field, and other nonstandard fields may precede
                    that field within the dirent structure, portable applications that use readdir_r() should allocate
                    the buffer whose address is passed in entry as follows:
                        len = offsetof(struct dirent, d_name) + pathconf(dirPath, _PC_NAME_MAX) + 1
                        entryp = malloc(len); */
-        const size_t nameMax = std::max<long>(::pathconf(dirPathFmt.c_str(), _PC_NAME_MAX), 10000); //::pathconf may return long(-1)
-		std::vector<char> buffer(offsetof(struct ::dirent, d_name) + nameMax + 1);
+        const size_t nameMax = std::max<long>(::pathconf(dirPath.c_str(), _PC_NAME_MAX), 10000); //::pathconf may return long(-1)
+        std::vector<char> buffer(offsetof(struct ::dirent, d_name) + nameMax + 1);
 #ifdef ZEN_MAC
-		std::vector<char> bufferUtfDecomposed;
+        std::vector<char> bufferUtfDecomposed;
 #endif
 
-        DIR* dirObj = ::opendir(dirPathFmt.c_str()); //directory must NOT end with path separator, except "/"
+        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(dirPathFmt)), L"opendir", getLastError());
+            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;
             if (::readdir_r(dirObj, reinterpret_cast< ::dirent*>(&buffer[0]), &dirEntry) != 0)
-                throwFileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirPathFmt)), L"readdir_r", getLastError());
+                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
@@ -128,7 +122,7 @@ void zen::traverseFolder(const Zstring& dirPath,
             //don't return "." and ".."
             const char* shortName = dirEntry->d_name;
 
-			if (shortName[0] == 0) throw FileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirPath)), L"Data corruption: Found item without name.");
+            if (shortName[0] == 0) throw FileError(replaceCpy(_("Cannot enumerate directory %x."), L"%x", fmtFileName(dirPath)), L"readdir_r: Data corruption, found item without name.");
             if (shortName[0] == '.' &&
                 (shortName[1] == 0 || (shortName[1] == '.' && shortName[2] == 0)))
                 continue;
@@ -152,20 +146,20 @@ void zen::traverseFolder(const Zstring& dirPath,
             //const char* sampleDecomposed  = "\x6f\xcc\x81.txt";
             //const char* samplePrecomposed = "\xc3\xb3.txt";
 #endif
-            const Zstring& itempath = appendSeparator(dirPathFmt) + shortName;
+            const Zstring& itempath = appendSeparator(dirPath) + shortName;
 
             struct ::stat statData = {};
-			try
-			{
-					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());
-			}
-		    catch (const FileError& e)
-			{
-				if (onError)
-					onError(e.toString());
-				continue; //ignore error: skip file
-			}           
+            try
+            {
+                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());
+            }
+            catch (const FileError& e)
+            {
+                if (onError)
+                    onError(e.toString());
+                continue; //ignore error: skip file
+            }
 
             if (S_ISLNK(statData.st_mode)) //on Linux there is no distinction between file and directory symlinks!
             {
diff --git a/zen/long_path_prefix.h b/zen/long_path_prefix.h
index 19b838ef..dfdf60ba 100644
--- a/zen/long_path_prefix.h
+++ b/zen/long_path_prefix.h
@@ -120,8 +120,8 @@ Zstring zen::ntPathToWin32Path(const Zstring& path) //noexcept
         {
             std::vector<wchar_t> buf(bufSize);
             const DWORD charsWritten = ::GetEnvironmentVariable(L"SystemRoot", //_In_opt_   LPCTSTR lpName,
-                                                          &buf[0],       //_Out_opt_  LPTSTR lpBuffer,
-                                                          bufSize);      //_In_       DWORD nSize
+                                                                &buf[0],       //_Out_opt_  LPTSTR lpBuffer,
+                                                                bufSize);      //_In_       DWORD nSize
 
             if (0 < charsWritten && charsWritten < bufSize)
                 return replaceCpy(path, L"\\SystemRoot\\", appendSeparator(Zstring(&buf[0], charsWritten)), false);
diff --git a/zen/notify_removal.cpp b/zen/notify_removal.cpp
deleted file mode 100644
index f528e81b..00000000
--- a/zen/notify_removal.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-// **************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0        *
-// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved        *
-// **************************************************************************
-
-#include "notify_removal.h"
-#include <set>
-#include <algorithm>
-#include <dbt.h>
-#include "scope_guard.h"
-
-using namespace zen;
-
-
-class MessageProvider //administrates a single dummy window to receive messages
-{
-public:
-    static MessageProvider& instance() //throw FileError
-    {
-        static MessageProvider inst;
-        return inst;
-    }
-
-    struct Listener
-    {
-        virtual ~Listener() {}
-        virtual void onMessage(UINT message, WPARAM wParam, LPARAM lParam) = 0; //throw()!
-    };
-    void   registerListener(Listener& l) { listener.insert(&l); }
-    void unregisterListener(Listener& l) { listener.erase(&l); } //don't unregister objects with static lifetime
-
-    HWND getWnd() const { return windowHandle; } //get handle in order to register additional notifications
-
-private:
-    MessageProvider();
-    ~MessageProvider();
-    MessageProvider           (const MessageProvider&) = delete;
-    MessageProvider& operator=(const MessageProvider&) = delete;
-
-    static const wchar_t dummyClassName[];
-
-    static LRESULT CALLBACK topWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
-
-    void processMessage(UINT message, WPARAM wParam, LPARAM lParam);
-
-    const HINSTANCE hMainModule;
-    HWND windowHandle;
-
-    std::set<Listener*> listener;
-};
-
-
-const wchar_t MessageProvider::dummyClassName[] = L"E6AD5EB1-527B-4EEF-AC75-27883B233380"; //random name
-
-
-LRESULT CALLBACK MessageProvider::topWndProc(HWND hwnd,     //handle to window
-                                             UINT uMsg,     //message identifier
-                                             WPARAM wParam, //first message parameter
-                                             LPARAM lParam) //second message parameter
-{
-    if (auto pThis = reinterpret_cast<MessageProvider*>(::GetWindowLongPtr(hwnd, GWLP_USERDATA)))
-        try
-        {
-            pThis->processMessage(uMsg, wParam, lParam); //not supposed to throw!
-        }
-        catch (...) { assert(false); }
-
-    return ::DefWindowProc(hwnd, uMsg, wParam, lParam);
-}
-
-
-MessageProvider::MessageProvider() :
-    hMainModule(::GetModuleHandle(nullptr)), //get program's module handle
-    windowHandle(nullptr)
-{
-    if (!hMainModule)
-        throwFileError(_("Unable to register to receive system messages."), L"GetModuleHandle", getLastError());
-
-    //register the main window class
-    WNDCLASS wc = {};
-    wc.lpfnWndProc   = topWndProc;
-    wc.hInstance     = hMainModule;
-    wc.lpszClassName = dummyClassName;
-
-    if (::RegisterClass(&wc) == 0)
-        throwFileError(_("Unable to register to receive system messages."), L"RegisterClass", getLastError());
-
-    ScopeGuard guardConstructor = zen::makeGuard([&] { this->~MessageProvider(); });
-
-    //create dummy-window
-    windowHandle = ::CreateWindow(dummyClassName, //_In_opt_  LPCTSTR lpClassName,
-                                  nullptr,        //_In_opt_  LPCTSTR lpWindowName,
-                                  0,           //_In_      DWORD dwStyle,
-                                  0, 0, 0, 0,  //_In_      int x, y, nWidth, nHeight,
-                                  nullptr,     //_In_opt_  HWND hWndParent; we need a toplevel window to receive device arrival events, not a message-window (HWND_MESSAGE)!
-                                  nullptr,     //_In_opt_  HMENU hMenu,
-                                  hMainModule, //_In_opt_  HINSTANCE hInstance,
-                                  nullptr);    //_In_opt_  LPVOID lpParam
-    if (!windowHandle)
-        throwFileError(_("Unable to register to receive system messages."), L"CreateWindow", getLastError());
-
-    //store this-pointer for topWndProc() to use: do this AFTER CreateWindow() to avoid processing messages while this constructor is running!!!
-    //unlike: http://blogs.msdn.com/b/oldnewthing/archive/2014/02/03/10496248.aspx
-    ::SetLastError(ERROR_SUCCESS); //[!] required for proper error handling, see MSDN, SetWindowLongPtr
-    if (::SetWindowLongPtr(windowHandle, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this)) == 0 && ::GetLastError() != ERROR_SUCCESS)
-        throwFileError(_("Unable to register to receive system messages."), L"SetWindowLongPtr", ::GetLastError());
-
-    guardConstructor.dismiss();
-}
-
-
-MessageProvider::~MessageProvider()
-{
-    //clean-up in reverse order
-    if (windowHandle)
-        ::DestroyWindow(windowHandle);
-    ::UnregisterClass(dummyClassName, //LPCTSTR lpClassName OR ATOM in low-order word!
-                      hMainModule);   //HINSTANCE hInstance
-}
-
-
-void MessageProvider::processMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
-    for (Listener* ls : listener)
-        ls->onMessage(message, wParam, lParam);
-}
-
-//####################################################################################################
-
-class NotifyRequestDeviceRemoval::Pimpl : private MessageProvider::Listener
-{
-public:
-    Pimpl(NotifyRequestDeviceRemoval& parent, HANDLE hDir) : //throw FileError
-        parent_(parent)
-    {
-        MessageProvider::instance().registerListener(*this); //throw FileError
-
-        ScopeGuard guardProvider = makeGuard([&] { MessageProvider::instance().unregisterListener(*this); });
-
-        //register handles to receive notifications
-        DEV_BROADCAST_HANDLE filter = {};
-        filter.dbch_size = sizeof(filter);
-        filter.dbch_devicetype = DBT_DEVTYP_HANDLE;
-        filter.dbch_handle = hDir;
-
-        hNotification = ::RegisterDeviceNotification(MessageProvider::instance().getWnd(), //__in  HANDLE hRecipient,
-                                                     &filter,                              //__in  LPVOID NotificationFilter,
-                                                     DEVICE_NOTIFY_WINDOW_HANDLE);         //__in  DWORD Flags
-        if (!hNotification)
-        {
-            const DWORD lastError = ::GetLastError(); //copy before directly or indirectly making other system calls!
-            if (lastError != ERROR_CALL_NOT_IMPLEMENTED   && //fail on SAMBA share: this shouldn't be a showstopper!
-                lastError != ERROR_SERVICE_SPECIFIC_ERROR && //neither should be fail for "Pogoplug" mapped network drives
-                lastError != ERROR_INVALID_DATA)             //this seems to happen for a NetDrive-mapped FTP server
-                throwFileError(_("Unable to register to receive system messages."), L"RegisterDeviceNotification", lastError);
-        }
-
-        guardProvider.dismiss();
-    }
-
-    ~Pimpl()
-    {
-        if (hNotification)
-            ::UnregisterDeviceNotification(hNotification);
-        MessageProvider::instance().unregisterListener(*this);
-    }
-
-private:
-    Pimpl           (const Pimpl&) = delete;
-    Pimpl& operator=(const Pimpl&) = delete;
-
-    void onMessage(UINT message, WPARAM wParam, LPARAM lParam) override //throw()!
-    {
-        //DBT_DEVICEQUERYREMOVE example: http://msdn.microsoft.com/en-us/library/aa363427(v=VS.85).aspx
-        if (message == WM_DEVICECHANGE)
-            if (wParam == DBT_DEVICEQUERYREMOVE       ||
-                wParam == DBT_DEVICEQUERYREMOVEFAILED ||
-                wParam == DBT_DEVICEREMOVECOMPLETE)
-            {
-                PDEV_BROADCAST_HDR header = reinterpret_cast<PDEV_BROADCAST_HDR>(lParam);
-                if (header->dbch_devicetype == DBT_DEVTYP_HANDLE)
-                {
-                    PDEV_BROADCAST_HANDLE body = reinterpret_cast<PDEV_BROADCAST_HANDLE>(lParam);
-
-                    if (body->dbch_hdevnotify == hNotification) //is it for the notification we registered?
-                        switch (wParam)
-                        {
-                            case DBT_DEVICEQUERYREMOVE:
-                                parent_.onRequestRemoval(body->dbch_handle);
-                                break;
-                            case DBT_DEVICEQUERYREMOVEFAILED:
-                                parent_.onRemovalFinished(body->dbch_handle, false);
-                                break;
-                            case DBT_DEVICEREMOVECOMPLETE:
-                                parent_.onRemovalFinished(body->dbch_handle, true);
-                                break;
-                        }
-                }
-            }
-    }
-
-    NotifyRequestDeviceRemoval& parent_;
-    HDEVNOTIFY hNotification;
-};
-
-//####################################################################################################
-
-NotifyRequestDeviceRemoval::NotifyRequestDeviceRemoval(HANDLE hDir) : pimpl(zen::make_unique<Pimpl>(*this, hDir)) {}
-
-
-NotifyRequestDeviceRemoval::~NotifyRequestDeviceRemoval() {} //make sure ~unique_ptr() works with complete type
diff --git a/zen/notify_removal.h b/zen/notify_removal.h
deleted file mode 100644
index 08d75818..00000000
--- a/zen/notify_removal.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// **************************************************************************
-// * This file is part of the FreeFileSync project. It is distributed under *
-// * GNU General Public License: http://www.gnu.org/licenses/gpl-3.0        *
-// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved        *
-// **************************************************************************
-
-#ifndef NOTIFY_H_INCLUDED_257804267562
-#define NOTIFY_H_INCLUDED_257804267562
-
-#include <memory>
-#include "win.h" //includes "windows.h"
-#include "file_error.h"
-
-//handle (user-) request for device removal via template method pattern
-//evaluate directly after processing window messages
-class NotifyRequestDeviceRemoval
-{
-public:
-    NotifyRequestDeviceRemoval(HANDLE hDir); //throw FileError
-    virtual ~NotifyRequestDeviceRemoval();
-
-private:
-    virtual void onRequestRemoval(HANDLE hnd) = 0; //throw()!
-    //NOTE: onRemovalFinished is NOT guaranteed to execute after onRequestRemoval()! but most likely will
-    virtual void onRemovalFinished(HANDLE hnd, bool successful) = 0; //throw()!
-
-    NotifyRequestDeviceRemoval           (NotifyRequestDeviceRemoval&) = delete;
-    NotifyRequestDeviceRemoval& operator=(NotifyRequestDeviceRemoval&) = delete;
-
-    class Pimpl;
-    std::unique_ptr<Pimpl> pimpl;
-};
-
-#endif //NOTIFY_H_INCLUDED_257804267562
diff --git a/zen/perf.h b/zen/perf.h
index 53519274..f43bc00f 100644
--- a/zen/perf.h
+++ b/zen/perf.h
@@ -30,41 +30,82 @@ public:
 
     ZEN_DEPRECATE
     PerfTimer() : //throw TimerError
-        ticksPerSec_(ticksPerSec()), startTime(getTicks()), resultShown(false)
+        ticksPerSec_(ticksPerSec()),
+        resultShown(false),
+        startTime(getTicksNow()),
+        paused(false),
+        elapsedUntilPause(0)
     {
         //std::clock() - "counts CPU time in Linux GCC and wall time in VC++" - WTF!???
-
-        if (ticksPerSec_ == 0 || !startTime.isValid())
+        if (ticksPerSec_ == 0)
             throw TimerError();
     }
 
-    ~PerfTimer() { if (!resultShown) showResult(); }
+	~PerfTimer() { if (!resultShown) try { showResult(); } catch (TimerError&){} }
+
+    void pause()
+    {
+        if (!paused)
+        {
+            paused = true;
+            elapsedUntilPause += dist(startTime, getTicksNow());
+        }
+    }
+
+    void resume()
+    {
+        if (paused)
+        {
+            paused = false;
+            startTime = getTicksNow();
+        }
+    }
+
+    void restart()
+    {
+        startTime = getTicksNow();
+        paused = false;
+        elapsedUntilPause = 0;
+    }
+	
+    int64_t timeMs() const
+    {
+        int64_t ticksTotal = elapsedUntilPause;
+        if (!paused)
+            ticksTotal += dist(startTime, getTicksNow());
+        return 1000 * ticksTotal / ticksPerSec_;
+    }
 
     void showResult()
     {
-        const TickVal now = getTicks();
-        if (!now.isValid())
-            throw TimerError();
+		const bool wasRunning = !paused;
+		if (wasRunning) pause(); //don't include call to MessageBox()!
+        ZEN_ON_SCOPE_EXIT(if (wasRunning) resume());
 
-        const std::int64_t delta = 1000 * dist(startTime, now) / ticksPerSec_;
 #ifdef ZEN_WIN
         std::wostringstream ss;
-        ss << delta << L" ms";
+        ss << timeMs() << L" ms";
         ::MessageBox(nullptr, ss.str().c_str(), L"Timer", MB_OK);
 #else
-        std::clog << "Perf: duration: " << delta << " ms\n";
+        std::clog << "Perf: duration: " << timeMs() << " ms\n";
 #endif
         resultShown = true;
+    }
 
-        startTime = getTicks(); //don't include call to MessageBox()!
-        if (!startTime.isValid())
+private:
+    TickVal getTicksNow() const
+    {
+        const TickVal now = getTicks();
+        if (!now.isValid())
             throw TimerError();
+        return now;
     }
 
-private:
     const std::int64_t ticksPerSec_;
-    TickVal startTime;
     bool resultShown;
+    TickVal startTime;
+    bool paused;
+    int64_t elapsedUntilPause;
 };
 }
 
diff --git a/zen/recycler.cpp b/zen/recycler.cpp
index 3b5ac421..ed6669ef 100644
--- a/zen/recycler.cpp
+++ b/zen/recycler.cpp
@@ -75,10 +75,9 @@ void zen::recycleOrDelete(const std::vector<Zstring>& itempaths, const std::func
 {
     if (itempaths.empty())
         return;
-    //::SetFileAttributes(applyLongPathPrefix(itempath).c_str(), FILE_ATTRIBUTE_NORMAL);
     //warning: moving long file paths to recycler does not work!
-    //both ::SHFileOperation() and ::IFileOperation() cannot delete a folder named "System Volume Information" with normal attributes but shamelessly report success
-    //both ::SHFileOperation() and ::IFileOperation() can't handle \\?\-prefix!
+    //both ::SHFileOperation() and ::IFileOperation cannot delete a folder named "System Volume Information" with normal attributes but shamelessly report success
+    //both ::SHFileOperation() and ::IFileOperation can't handle \\?\-prefix!
 
     if (vistaOrLater()) //new recycle bin usage: available since Vista
     {
@@ -95,20 +94,28 @@ void zen::recycleOrDelete(const std::vector<Zstring>& itempaths, const std::func
         for (auto it = itempaths.begin(); it != itempaths.end(); ++it) //CAUTION: do not create temporary strings here!!
             cNames.push_back(it->c_str());
 
+
+
         CallbackData cbd(notifyDeletionStatus);
         if (!moveToRecycleBin(&cNames[0], cNames.size(), onRecyclerCallback, &cbd))
         {
             if (cbd.exception)
                 std::rethrow_exception(cbd.exception);
 
-            std::wstring itempathFmt = fmtFileName(itempaths[0]); //probably not the correct file name for file lists larger than 1!
-            if (itempaths.size() > 1)
-                itempathFmt += L", ..."; //give at least some hint that there are multiple files, and the error need not be related to the first one
+            if (cNames.size() == 1)
+                throw FileError(replaceCpy(_("Unable to move %x to the recycle bin."), L"%x", fmtFileName(itempaths[0])), getLastErrorMessage());
 
-            throw FileError(replaceCpy(_("Unable to move %x to the recycle bin."), L"%x", itempathFmt), getLastErrorMessage()); //already includes details about locking errors!
+            //batch recycling failed: retry one-by-one to get a better error message; see FileOperation.dll
+            for (size_t i = 0; i < cNames.size(); ++i)
+            {
+                if (notifyDeletionStatus) notifyDeletionStatus(itempaths[i]);
+
+                if (!moveToRecycleBin(&cNames[i], 1, nullptr, nullptr))
+                    throw FileError(replaceCpy(_("Unable to move %x to the recycle bin."), L"%x", fmtFileName(itempaths[i])), getLastErrorMessage()); //already includes details about locking errors!
+            }
         }
     }
-    else //regular recycle bin usage: available since XP
+    else //regular recycle bin usage: available since XP: 1. bad error reporting 2. early failure
     {
         Zstring itempathsDoubleNull;
         for (const Zstring& itempath : itempaths)
@@ -122,7 +129,7 @@ void zen::recycleOrDelete(const std::vector<Zstring>& itempaths, const std::func
         fileOp.wFunc  = FO_DELETE;
         fileOp.pFrom  = itempathsDoubleNull.c_str();
         fileOp.pTo    = nullptr;
-        fileOp.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
+        fileOp.fFlags = FOF_ALLOWUNDO | FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI;
         fileOp.fAnyOperationsAborted = false;
         fileOp.hNameMappings         = nullptr;
         fileOp.lpszProgressTitle     = nullptr;
@@ -130,7 +137,10 @@ void zen::recycleOrDelete(const std::vector<Zstring>& itempaths, const std::func
         //"You should use fully-qualified path names with this function. Using it with relative path names is not thread safe."
         if (::SHFileOperation(&fileOp) != 0 || fileOp.fAnyOperationsAborted)
         {
-            throw FileError(replaceCpy(_("Unable to move %x to the recycle bin."), L"%x", fmtFileName(itempaths[0]))); //probably not the correct file name for file list larger than 1!
+            std::wstring itempathFmt = fmtFileName(itempaths[0]); //probably not the correct file name for file lists larger than 1!
+            if (itempaths.size() > 1)
+                itempathFmt += L", ..."; //give at least some hint that there are multiple files, and the error need not be related to the first one
+            throw FileError(replaceCpy(_("Unable to move %x to the recycle bin."), L"%x", itempathFmt));
         }
     }
 }
@@ -143,7 +153,7 @@ bool zen::recycleOrDelete(const Zstring& itempath) //throw FileError
         return false; //neither file nor any other object with that name existing: no error situation, manual deletion relies on it!
 
 #ifdef ZEN_WIN
-	recycleOrDelete({ itempath }, nullptr); //throw FileError
+    recycleOrDelete({ itempath }, nullptr); //throw FileError
 
 #elif defined ZEN_LINUX
     GFile* file = ::g_file_new_for_path(itempath.c_str()); //never fails according to docu
@@ -157,7 +167,7 @@ bool zen::recycleOrDelete(const Zstring& itempath) //throw FileError
         const std::wstring errorMsg = replaceCpy(_("Unable to move %x to the recycle bin."), L"%x", fmtFileName(itempath));
 
         if (!error)
-            throw FileError(errorMsg, L"Unknown error."); //user should never see this
+            throw FileError(errorMsg, L"g_file_trash: unknown error."); //user should never see this
 
         //implement same behavior as in Windows: if recycler is not existing, delete permanently
         if (error->code == G_IO_ERROR_NOT_SUPPORTED)
diff --git a/zen/serialize.h b/zen/serialize.h
index 54baf75a..4af12af1 100644
--- a/zen/serialize.h
+++ b/zen/serialize.h
@@ -25,12 +25,13 @@ binary container for data storage: must support "basic" std::vector interface (e
 
 //binary container reference implementations
 typedef Zbase<char> Utf8String; //ref-counted + COW text stream + guaranteed performance: exponential growth
-class BinaryStream;             //ref-counted       byte stream + guaranteed performance: exponential growth -> no COW, but 12% faster than Utf8String (due to no null-termination?)
+class ByteArray;                //ref-counted       byte stream + guaranteed performance: exponential growth -> no COW, but 12% faster than Utf8String (due to no null-termination?)
 
-class BinaryStream //essentially a std::vector<char> with ref-counted semantics, but no COW! => *almost* value type semantics, but not quite
+
+class ByteArray //essentially a std::vector<char> with ref-counted semantics, but no COW! => *almost* value type semantics, but not quite
 {
 public:
-    BinaryStream() : buffer(std::make_shared<std::vector<char>>()) {}
+    ByteArray() : buffer(std::make_shared<std::vector<char>>()) {}
 
     typedef std::vector<char>::value_type value_type;
     typedef std::vector<char>::iterator iterator;
@@ -46,7 +47,7 @@ public:
     size_t size() const { return buffer->size(); }
     bool empty() const { return buffer->empty(); }
 
-    inline friend bool operator==(const BinaryStream& lhs, const BinaryStream& rhs) { return *lhs.buffer == *rhs.buffer; }
+    inline friend bool operator==(const ByteArray& lhs, const ByteArray& rhs) { return *lhs.buffer == *rhs.buffer; }
 
 private:
     std::shared_ptr<std::vector<char>> buffer; //always bound!
@@ -65,7 +66,7 @@ template <class BinContainer> BinContainer loadBinStream(const Zstring& filepath
 -----------------------------
 struct BinInputStream
 {
-    const void* requestRead(size_t len); //expect external read of len bytes
+	size_t read(void* data, size_t len); //return "len" bytes unless end of stream!
 };
 
 ------------------------------
@@ -73,58 +74,62 @@ struct BinInputStream
 ------------------------------
 struct BinOutputStream
 {
-    void* requestWrite(size_t len); //expect external write of len bytes
+    void write(const void* data, size_t len);
 };
 */
 
-//binary input/output stream reference implementation
-class UnexpectedEndOfStreamError {};
+//binary input/output stream reference implementations:
 
-struct BinStreamIn //throw UnexpectedEndOfStreamError
+template <class BinContainer>
+struct MemoryStreamIn
 {
-    BinStreamIn(const BinaryStream& cont) : buffer(cont), pos(0) {} //this better be cheap!
+    MemoryStreamIn(const BinContainer& cont) : buffer(cont), pos(0) {} //this better be cheap!
 
-    const void* requestRead(size_t len) //throw UnexpectedEndOfStreamError
+    size_t read(void* data, size_t len) //return "len" bytes unless end of stream!
     {
-        if (len == 0) return nullptr; //don't allow for possibility to access empty buffer
-        if (pos + len > buffer.size())
-            throw UnexpectedEndOfStreamError();
-        size_t oldPos = pos;
-        pos += len;
-        return &*buffer.begin() + oldPos;
+        static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes
+        const size_t bytesRead = std::min(len, buffer.size() - pos);
+        auto itFirst = buffer.begin() + pos;
+        std::copy(itFirst, itFirst + bytesRead, static_cast<char*>(data));
+		pos += bytesRead;
+        return bytesRead;
     }
 
 private:
-    BinaryStream buffer;
+    const BinContainer buffer;
     size_t pos;
 };
 
-struct BinStreamOut
+template <class BinContainer>
+struct MemoryStreamOut
 {
-    void* requestWrite(size_t len)
+    void write(const void* data, size_t len)
     {
-        if (len == 0) return nullptr; //don't allow for possibility to access empty buffer
+        static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes
         const size_t oldSize = buffer.size();
         buffer.resize(oldSize + len);
-        return &*buffer.begin() + oldSize;
+        std::copy(static_cast<const char*>(data), static_cast<const char*>(data) + len, buffer.begin() + oldSize);
     }
 
-    BinaryStream get() { return buffer; }
+    const BinContainer& ref() const { return buffer; }
 
 private:
-    BinaryStream buffer;
+    BinContainer buffer;
 };
 
 //----------------------------------------------------------------------
 //functions based on binary stream abstraction
+template <class BinInputStream, class BinOutputStream>
+void copyStream(BinInputStream& streamIn, BinOutputStream& streamOut, const std::function<void(std::int64_t bytesDelta)>& onNotifyCopyStatus); //optional
+
 template <class N, class BinOutputStream> void writeNumber   (BinOutputStream& stream, const N& num);                 //
 template <class C, class BinOutputStream> void writeContainer(BinOutputStream& stream, const C& str);                 //throw ()
 template <         class BinOutputStream> void writeArray    (BinOutputStream& stream, const void* data, size_t len); //
 
 //----------------------------------------------------------------------
-
-template <class N, class BinInputStream> N    readNumber   (BinInputStream& stream); //
-template <class C, class BinInputStream> C    readContainer(BinInputStream& stream); //throw UnexpectedEndOfStreamError (corrupted data)
+class UnexpectedEndOfStreamError {};
+template <class N, class BinInputStream> N    readNumber   (BinInputStream& stream); //throw UnexpectedEndOfStreamError (corrupted data)
+template <class C, class BinInputStream> C    readContainer(BinInputStream& stream); //
 template <         class BinInputStream> void readArray    (BinInputStream& stream, void* data, size_t len); //
 
 
@@ -135,66 +140,54 @@ template <         class BinInputStream> void readArray    (BinInputStream& stre
 
 
 //-----------------------implementation-------------------------------
-template <class BinContainer> inline
-void saveBinStream(const Zstring& filepath, //throw FileError
-                   const BinContainer& cont,
-                   const std::function<void(std::int64_t bytesDelta)>& onUpdateStatus) //optional
+template <class BinInputStream, class BinOutputStream> inline
+void copyStream(BinInputStream& streamIn, BinOutputStream& streamOut, size_t blockSize,
+                const std::function<void(std::int64_t bytesDelta)>& onNotifyCopyStatus) //optional
 {
-    static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes (until further)
-
-    FileOutput fileOut(filepath, zen::FileOutput::ACC_OVERWRITE); //throw FileError
-    if (!cont.empty())
+	assert(blockSize > 0);
+    std::vector<char> buffer(blockSize);
+    for (;;)
     {
-        const size_t blockSize = 128 * 1024;
-        auto bytePtr = &*cont.begin();
-        size_t bytesLeft = cont.size();
+        const size_t bytesRead = streamIn.read(&buffer[0], buffer.size());
+        streamOut.write(&buffer[0], bytesRead);
 
-        while (bytesLeft > blockSize)
-        {
-            fileOut.write(bytePtr, blockSize); //throw FileError
-            bytePtr += blockSize;
-            bytesLeft -= blockSize;
-            if (onUpdateStatus) onUpdateStatus(blockSize);
-        }
+        if (onNotifyCopyStatus)
+            onNotifyCopyStatus(bytesRead); //throw X!
 
-        fileOut.write(bytePtr, bytesLeft); //throw FileError
-        if (onUpdateStatus) onUpdateStatus(bytesLeft);
+        if (bytesRead != buffer.size()) //end of file
+            break;
     }
 }
 
 
 template <class BinContainer> inline
-BinContainer loadBinStream(const Zstring& filepath, //throw FileError
-                           const std::function<void(std::int64_t bytesDelta)>& onUpdateStatus) //optional
+void saveBinStream(const Zstring& filepath, //throw FileError
+                   const BinContainer& cont,
+                   const std::function<void(std::int64_t bytesDelta)>& onUpdateStatus) //optional
 {
-    static_assert(sizeof(typename BinContainer::value_type) == 1, ""); //expect: bytes (until further)
-
-    FileInput fileIn(filepath); //throw FileError
-
-    BinContainer contOut;
-    const size_t blockSize = 128 * 1024;
-    do
-    {
-        contOut.resize(contOut.size() + blockSize); //container better implement exponential growth!
-
-        const size_t bytesRead = fileIn.read(&*contOut.begin() + contOut.size() - blockSize, blockSize); //throw FileError
-        if (bytesRead < blockSize)
-            contOut.resize(contOut.size() - (blockSize - bytesRead)); //caveat: unsigned arithmetics
+    MemoryStreamIn<BinContainer> streamIn(cont);
+    FileOutput streamOut(filepath, zen::FileOutput::ACC_OVERWRITE); //throw FileError, (ErrorTargetExisting)
+	if (onUpdateStatus) onUpdateStatus(0); //throw X!
+    copyStream(streamIn, streamOut, streamOut.optimalBlockSize(), onUpdateStatus); //throw FileError
+}
 
-        if (onUpdateStatus) onUpdateStatus(bytesRead);
-    }
-    while (!fileIn.eof());
 
-    return contOut;
+template <class BinContainer> inline
+BinContainer loadBinStream(const Zstring& filepath, //throw FileError
+                           const std::function<void(std::int64_t bytesDelta)>& onUpdateStatus) //optional
+{
+    FileInput streamIn(filepath); //throw FileError, ErrorFileLocked
+	if (onUpdateStatus) onUpdateStatus(0); //throw X!
+    MemoryStreamOut<BinContainer> streamOut;
+    copyStream(streamIn, streamOut, streamIn.optimalBlockSize(), onUpdateStatus); //throw FileError
+    return streamOut.ref();
 }
 
 
 template <class BinOutputStream> inline
 void writeArray(BinOutputStream& stream, const void* data, size_t len)
 {
-    std::copy(static_cast<const char*>(data),
-              static_cast<const char*>(data) + len,
-              static_cast<      char*>(stream.requestWrite(len)));
+    stream.write(data, len);
 }
 
 
@@ -219,9 +212,9 @@ void writeContainer(BinOutputStream& stream, const C& cont) //don't even conside
 template <class BinInputStream> inline
 void readArray(BinInputStream& stream, void* data, size_t len) //throw UnexpectedEndOfStreamError
 {
-    //expect external write of len bytes:
-    const char* const src = static_cast<const char*>(stream.requestRead(len)); //throw UnexpectedEndOfStreamError
-    std::copy(src, src + len, static_cast<char*>(data));
+    const size_t bytesRead = stream.read(data, len);
+    if (bytesRead < len)
+        throw UnexpectedEndOfStreamError();
 }
 
 
diff --git a/zen/string_base.h b/zen/string_base.h
index b1d7102e..be3b532e 100644
--- a/zen/string_base.h
+++ b/zen/string_base.h
@@ -287,8 +287,8 @@ template <class Char, template <class, class> class SP, class AP> inline Zbase<C
 template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(const Zbase<Char, SP, AP>& lhs,       Char                 rhs) { return Zbase<Char, SP, AP>(lhs) += rhs; }
 
 //don't use unified first argument but save one move-construction in the r-value case instead!
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(Zbase<Char, SP, AP>&& lhs, const Zbase<Char, SP, AP>& rhs) { return std::move(lhs += rhs); } //is the move really needed?
-template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(Zbase<Char, SP, AP>&& lhs, const Char*                rhs) { return std::move(lhs += rhs); } //lhs, is an l-vlaue in the function body...
+template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(Zbase<Char, SP, AP>&& lhs, const Zbase<Char, SP, AP>& rhs) { return std::move(lhs += rhs); } //the move *is* needed!!!
+template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(Zbase<Char, SP, AP>&& lhs, const Char*                rhs) { return std::move(lhs += rhs); } //lhs, is an l-value parameter...
 template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(Zbase<Char, SP, AP>&& lhs,       Char                 rhs) { return std::move(lhs += rhs); } //and not a local variable => no copy elision
 
 template <class Char, template <class, class> class SP, class AP> inline Zbase<Char, SP, AP> operator+(      Char          lhs, const Zbase<Char, SP, AP>& rhs) { return Zbase<Char, SP, AP>(lhs) += rhs; }
diff --git a/zen/string_tools.h b/zen/string_tools.h
index 35a07b64..c8591522 100644
--- a/zen/string_tools.h
+++ b/zen/string_tools.h
@@ -35,7 +35,8 @@ template <class S, class T> S afterFirst (const S& str, const T& term); //return
 template <class S, class T> S beforeFirst(const S& str, const T& term); //returns the whole string if term not found
 
 template <class S, class T> std::vector<S> split(const S& str, const T& delimiter);
-template <class S> void trim(S& str, bool fromLeft = true, bool fromRight = true);
+template <class S> void trim   (      S& str, bool fromLeft = true, bool fromRight = true);
+template <class S> S    trimCpy(const S& str, bool fromLeft = true, bool fromRight = true);
 template <class S, class T, class U> void replace   (      S& str, const T& oldTerm, const U& newTerm, bool replaceAll = true);
 template <class S, class T, class U> S    replaceCpy(const S& str, const T& oldTerm, const U& newTerm, bool replaceAll = true);
 
@@ -331,9 +332,9 @@ void trim(S& str, bool fromLeft, bool fromRight)
     assert(fromLeft || fromRight);
     typedef typename GetCharType<S>::Type CharType; //don't use value_type! (wxString, Glib::ustring)
 
-    const CharType* const oldBegin = str.c_str();
-    const CharType* newBegin = oldBegin;
-    const CharType* newEnd   = oldBegin + str.length();
+    const CharType* const oldBegin = strBegin(str);
+    const CharType*       newBegin = oldBegin;
+    const CharType*       newEnd   = oldBegin + strLength(str);
 
     if (fromRight)
         while (newBegin != newEnd && isWhiteSpace(newEnd[-1]))
@@ -350,6 +351,16 @@ void trim(S& str, bool fromLeft, bool fromRight)
 }
 
 
+template <class S> inline
+S trimCpy(const S& str, bool fromLeft, bool fromRight)
+{
+	//implementing trimCpy() in terms of trim(), instead of the other way round, avoids memory allocations when trimming from right!
+	S tmp = str; 
+	trim(tmp, fromLeft, fromRight);
+	return tmp;
+}
+
+
 namespace implementation
 {
 template <class S, class T>
diff --git a/zen/string_traits.h b/zen/string_traits.h
index 8bc55a6a..8c4775f4 100644
--- a/zen/string_traits.h
+++ b/zen/string_traits.h
@@ -176,8 +176,8 @@ size_t cStringLength(const C* str) //naive implementation seems somewhat faster
 }
 
 
-template <class S> inline
-const typename GetCharType<S>::Type* strBegin(const S& str, typename EnableIf<implementation::StringTraits<S>::isStringClass>::Type* = nullptr) //SFINAE: T must be a "string"
+template <class S, typename = typename EnableIf<implementation::StringTraits<S>::isStringClass>::Type> inline
+const typename GetCharType<S>::Type* strBegin(const S& str) //SFINAE: T must be a "string"
 {
     return str.c_str();
 }
@@ -190,8 +190,8 @@ inline const char*    strBegin(const StringRef<char   >& ref) { return ref.data(
 inline const wchar_t* strBegin(const StringRef<wchar_t>& ref) { return ref.data(); }
 
 
-template <class S> inline
-size_t strLength(const S& str, typename EnableIf<implementation::StringTraits<S>::isStringClass>::Type* = nullptr) //SFINAE: T must be a "string"
+template <class S, typename = typename EnableIf<implementation::StringTraits<S>::isStringClass>::Type> inline
+size_t strLength(const S& str) //SFINAE: T must be a "string"
 {
     return str.length();
 }
diff --git a/zen/symlink_target.h b/zen/symlink_target.h
index 9239385a..c895d9a0 100644
--- a/zen/symlink_target.h
+++ b/zen/symlink_target.h
@@ -165,13 +165,13 @@ Zstring getResolvedFilePath_impl(const Zstring& linkPath) //throw FileError
 
 
     const HANDLE hFile = ::CreateFile(applyLongPathPrefix(linkPath).c_str(),                  //_In_      LPCTSTR lpFileName,
-                                     0,                                                      //_In_      DWORD dwDesiredAccess,
-                                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, //_In_      DWORD dwShareMode,
-                                     nullptr,                    //_In_opt_  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-                                     OPEN_EXISTING,              //_In_      DWORD dwCreationDisposition,
-                                     //needed to open a directory:
-                                     FILE_FLAG_BACKUP_SEMANTICS, //_In_      DWORD dwFlagsAndAttributes,
-                                     nullptr);                   //_In_opt_  HANDLE hTemplateFile
+                                      0,                                                      //_In_      DWORD dwDesiredAccess,
+                                      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, //_In_      DWORD dwShareMode,
+                                      nullptr,                    //_In_opt_  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+                                      OPEN_EXISTING,              //_In_      DWORD dwCreationDisposition,
+                                      //needed to open a directory:
+                                      FILE_FLAG_BACKUP_SEMANTICS, //_In_      DWORD dwFlagsAndAttributes,
+                                      nullptr);                   //_In_opt_  HANDLE hTemplateFile
     if (hFile == INVALID_HANDLE_VALUE)
         throwFileError(replaceCpy(_("Cannot determine final path for %x."), L"%x", fmtFileName(linkPath)), L"CreateFile", getLastError());
     ZEN_ON_SCOPE_EXIT(::CloseHandle(hFile));
diff --git a/zen/thread.h b/zen/thread.h
index d860abd0..c9b4c76f 100644
--- a/zen/thread.h
+++ b/zen/thread.h
@@ -101,7 +101,7 @@ auto async(Function fun) -> boost::unique_future<decltype(fun())>
 #endif
     auto fut = pt.get_future();
     boost::thread(std::move(pt)).detach(); //we have to explicitly detach since C++11: [thread.thread.destr] ~thread() calls std::terminate() if joinable()!!!
-    return std::move(fut); //compiler error without "move", why needed???
+    return fut;
 }
 
 
diff --git a/zen/time.h b/zen/time.h
index 996593c8..9d821a1f 100644
--- a/zen/time.h
+++ b/zen/time.h
@@ -218,7 +218,7 @@ String formatTime(const String2& format, const TimeComp& comp, UserDefinedFormat
     std::mktime(&ctc); // unfortunately std::strftime() needs all elements of "struct tm" filled, e.g. tm_wday, tm_yday
     //note: although std::mktime() explicitly expects "local time", calculating weekday and day of year *should* be time-zone and DST independent
 
-	CharType buffer[256] = {};
+    CharType buffer[256] = {};
     const size_t charsWritten = strftimeWrap(buffer, 256, strBegin(format), &ctc);
     return String(buffer, charsWritten);
 }
@@ -237,11 +237,11 @@ TimeComp localTime(time_t utc)
 {
     struct ::tm lt = {};
 
-	//use thread-safe variants of localtime()!
+    //use thread-safe variants of localtime()!
 #ifdef ZEN_WIN
     if (::localtime_s(&lt, &utc) != 0)
 #else
-	if (::localtime_r(&utc, &lt) == nullptr)
+    if (::localtime_r(&utc, &lt) == nullptr)
 #endif
         return TimeComp();
 
diff --git a/zen/type_traits.h b/zen/type_traits.h
index 082baea9..e03085d9 100644
--- a/zen/type_traits.h
+++ b/zen/type_traits.h
@@ -38,10 +38,10 @@ struct ResultType
 
 //Herb Sutter's signedness conversion helpers: http://herbsutter.com/2013/06/13/gotw-93-solution-auto-variables-part-2/
 template<class T> inline
-typename std::make_signed<T>::type makeSigned(T t) { return typename std::make_signed<T>::type(t); }
+typename std::make_signed<T>::type makeSigned(T t) { return static_cast<typename std::make_signed<T>::type>(t); }
 
 template<class T> inline
-typename std::make_unsigned<T>::type makeUnsigned(T t) { return typename std::make_unsigned<T>::type(t); }
+typename std::make_unsigned<T>::type makeUnsigned(T t) { return static_cast<typename std::make_unsigned<T>::type>(t); }
 
 //################# Built-in Types  ########################
 //Example: "IsSignedInt<int>::value" evaluates to "true"
diff --git a/zen/win_ver.h b/zen/win_ver.h
index 611a27c0..2e8f1ee7 100644
--- a/zen/win_ver.h
+++ b/zen/win_ver.h
@@ -40,7 +40,7 @@ const OsVersion osVersionWin2000      (5, 0);
 /*
 	NOTE: there are two basic APIs to check Windows version: (empiric study following)
 		GetVersionEx      -> reports version considering compatibility mode (and compatibility setting in app manifest since Windows 8.1)
-		VerifyVersionInfo -> always reports *real* Windows Version 
+		VerifyVersionInfo -> always reports *real* Windows Version
 								*) Win10 Technical preview caveat: VerifyVersionInfo returns 6.3 unless manifest entry is added!!!
 */
 
@@ -118,11 +118,17 @@ bool runningWOW64() //test if process is running under WOW64: http://msdn.micros
 }
 
 
+template <bool is64BitBuild> inline
+bool running64BitWindowsImpl() { return true; }
+
+template <> inline
+bool running64BitWindowsImpl<false>() { return runningWOW64(); }
+
 inline
 bool running64BitWindows() //http://blogs.msdn.com/b/oldnewthing/archive/2005/02/01/364563.aspx
 {
     static_assert(zen::is32BitBuild || zen::is64BitBuild, "");
-    return is64BitBuild || runningWOW64(); //should we bother to give a compile-time result in the first case?
+    return running64BitWindowsImpl<is64BitBuild>();
 }
 }
 
diff --git a/zen/xml_io.cpp b/zen/xml_io.cpp
index a070b526..a1bf05d0 100644
--- a/zen/xml_io.cpp
+++ b/zen/xml_io.cpp
@@ -16,36 +16,26 @@ XmlDoc zen::loadXmlDocument(const Zstring& filepath) //throw FileError
 {
     //can't simply use zen::loadBinStream() due to the short-circuit xml-validation below!
 
-    std::string stream;
-
-    FileInput inputFile(filepath); //throw FileError
+    FileInput fileStreamIn(filepath); //throw FileError
+    MemoryStreamOut<std::string> memStreamOut;
     {
         //quick test whether input is an XML: avoid loading large binary files up front!
         const std::string xmlBegin = "<?xml version=";
-        stream.resize(strLength(BYTE_ORDER_MARK_UTF8) + xmlBegin.size());
+        std::vector<char> buf(xmlBegin.size() + strLength(BYTE_ORDER_MARK_UTF8));
 
-        const size_t bytesRead = inputFile.read(&stream[0], stream.size()); //throw FileError
-        stream.resize(bytesRead);
+        const size_t bytesRead = fileStreamIn.read(&buf[0], buf.size());
+        memStreamOut.write(&buf[0], bytesRead);
 
-        if (!startsWith(stream, xmlBegin) &&
-            !startsWith(stream, BYTE_ORDER_MARK_UTF8 + xmlBegin)) //allow BOM!
+        if (!startsWith(memStreamOut.ref(), xmlBegin) &&
+            !startsWith(memStreamOut.ref(), BYTE_ORDER_MARK_UTF8 + xmlBegin)) //allow BOM!
             throw FileError(replaceCpy(_("File %x does not contain a valid configuration."), L"%x", fmtFileName(filepath)));
     }
 
-    const size_t blockSize = 128 * 1024;
-    do
-    {
-        stream.resize(stream.size() + blockSize);
-
-        const size_t bytesRead = inputFile.read(&*stream.begin() + stream.size() - blockSize, blockSize); //throw FileError
-        if (bytesRead < blockSize)
-            stream.resize(stream.size() - (blockSize - bytesRead)); //caveat: unsigned arithmetics
-    }
-    while (!inputFile.eof());
+    copyStream(fileStreamIn, memStreamOut, fileStreamIn.optimalBlockSize(), nullptr); //throw FileError
 
     try
     {
-        return parse(stream); //throw XmlParsingError
+        return parse(memStreamOut.ref()); //throw XmlParsingError
     }
     catch (const XmlParsingError& e)
     {
diff --git a/zen/zstring.cpp b/zen/zstring.cpp
index f803f160..73ef3ee9 100644
--- a/zen/zstring.cpp
+++ b/zen/zstring.cpp
@@ -17,7 +17,7 @@
 #endif
 
 #ifndef NDEBUG
-    #include <mutex>
+    #include "thread.h"
     #include <iostream>
 #endif
 
@@ -39,14 +39,14 @@ public:
 
     void insert(const void* ptr, size_t size)
     {
-        std::lock_guard<std::mutex> dummy(lockActStrings);
+        boost::lock_guard<boost::mutex> dummy(lockActStrings);
         if (!activeStrings.emplace(ptr, size).second)
             reportProblem("Serious Error: New memory points into occupied space: " + rawMemToString(ptr, size));
     }
 
     void remove(const void* ptr)
     {
-        std::lock_guard<std::mutex> dummy(lockActStrings);
+        boost::lock_guard<boost::mutex> dummy(lockActStrings);
         if (activeStrings.erase(ptr) != 1)
             reportProblem("Serious Error: No memory available for deallocation at this location!");
     }
@@ -92,15 +92,15 @@ private:
 #else
         std::cerr << message;
 #endif
-		throw std::logic_error("Memory leak! " + message + "\n" + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+        throw std::logic_error("Memory leak! " + message + "\n" + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
     }
 
-    std::mutex lockActStrings;
+    boost::mutex lockActStrings;
     std::unordered_map<const void*, size_t> activeStrings;
 };
 
 //caveat: function scope static initialization is not thread-safe in VS 2010!
-auto& dummy = LeakChecker::get();
+auto& dummy = LeakChecker::get(); //still not sufficient if multiple threads access during static init!!!
 }
 
 void z_impl::leakCheckerInsert(const void* ptr, size_t size) { LeakChecker::get().insert(ptr, size); }
@@ -143,8 +143,8 @@ const LCID ZSTRING_INVARIANT_LOCALE = zen::winXpOrLater() ?
 typedef int (WINAPI* CompareStringOrdinalFunc)(LPCWSTR lpString1, int cchCount1,
                                                LPCWSTR lpString2, int cchCount2, BOOL bIgnoreCase);
 const SysDllFun<CompareStringOrdinalFunc> compareStringOrdinal = SysDllFun<CompareStringOrdinalFunc>(L"kernel32.dll", "CompareStringOrdinal");
+//watch for dependencies in global namespace!!!
 //caveat: function scope static initialization is not thread-safe in VS 2010!
-//No global dependencies => no static initialization order problem in global namespace!
 }
 
 
@@ -158,7 +158,7 @@ int cmpFileName(const Zstring& lhs, const Zstring& rhs)
                                             static_cast<int>(rhs.size()), //__in  int cchCount2,
                                             true);                        //__in  BOOL bIgnoreCase
         if (rv <= 0)
-			throw std::runtime_error("Error comparing strings (CompareStringOrdinal). " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+            throw std::runtime_error("Error comparing strings (CompareStringOrdinal). " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
         else
             return rv - 2; //convert to C-style string compare result
     }
@@ -184,7 +184,7 @@ int cmpFileName(const Zstring& lhs, const Zstring& rhs)
                               static_cast<int>(minSize), //__in   int cchSrc,
                               strOut,                    //__out  LPTSTR lpDestStr,
                               static_cast<int>(minSize)) == 0) //__in   int cchDest
-			throw std::runtime_error("Error comparing strings (LCMapString). " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+                throw std::runtime_error("Error comparing strings (LCMapString). " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
         };
 
         auto eval = [&](wchar_t* bufL, wchar_t* bufR)
@@ -231,7 +231,7 @@ Zstring makeUpperCopy(const Zstring& str)
                       len,                      //__in   int cchSrc,
                       &*output.begin(),         //__out  LPTSTR lpDestStr,
                       len) == 0)                //__in   int cchDest
-				throw std::runtime_error("Error comparing strings (LCMapString). " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
+        throw std::runtime_error("Error comparing strings (LCMapString). " + std::string(__FILE__) + ":" + numberTo<std::string>(__LINE__));
 
     return output;
 }
@@ -240,7 +240,8 @@ Zstring makeUpperCopy(const Zstring& str)
 #elif defined ZEN_MAC
 int cmpFileName(const Zstring& lhs, const Zstring& rhs)
 {
-    return ::strcasecmp(lhs.c_str(), rhs.c_str()); //locale-dependent!
+	const int rv = ::strcasecmp(lhs.c_str(), rhs.c_str()); //locale-dependent!
+    return rv;
 }
 
 
diff --git a/zen/zstring.h b/zen/zstring.h
index 0610a27f..7dcfbb69 100644
--- a/zen/zstring.h
+++ b/zen/zstring.h
@@ -68,12 +68,12 @@ typedef zen::Zbase<Zchar, zen::StorageRefCountThreadSafe, AllocatorFreeStoreChec
 //Compare filepaths: Windows does NOT distinguish between upper/lower-case, while Linux DOES
 int cmpFileName(const Zstring& lhs, const Zstring& rhs);
 
-struct LessFilename //case-insensitive on Windows, case-sensitive on Linux
+struct LessFilePath //case-insensitive on Windows, case-sensitive on Linux
 {
     bool operator()(const Zstring& lhs, const Zstring& rhs) const { return cmpFileName(lhs, rhs) < 0; }
 };
 
-struct EqualFilename //case-insensitive on Windows, case-sensitive on Linux
+struct EqualFilePath //case-insensitive on Windows, case-sensitive on Linux
 {
     bool operator()(const Zstring& lhs, const Zstring& rhs) const { return cmpFileName(lhs, rhs) == 0; }
 };
@@ -85,10 +85,35 @@ struct EqualFilename //case-insensitive on Windows, case-sensitive on Linux
 inline
 Zstring appendSeparator(Zstring path) //support rvalue references!
 {
-    return zen::endsWith(path, FILE_NAME_SEPARATOR) ? path : (path += FILE_NAME_SEPARATOR);
+    return zen::endsWith(path, FILE_NAME_SEPARATOR) ? path : (path += FILE_NAME_SEPARATOR); //returning a by-value parameter implicitly converts to r-value!
 }
 
 
+inline
+Zstring getFileExtension(const Zstring& filePath)
+{
+    const Zstring shortName = afterLast(filePath, FILE_NAME_SEPARATOR); //returns the whole string if term not found
+
+    return contains(shortName, Zchar('.')) ?
+           afterLast(filePath, Zchar('.')) :
+           Zstring();
+}
+
+
+inline
+bool pathStartsWith(const Zstring& str, const Zstring& prefix)
+{
+    return str.size() >= prefix.size() &&
+           EqualFilePath()(Zstring(str.begin(), str.begin() + prefix.size()), prefix);
+}
+
+
+inline
+bool pathEndsWith(const Zstring& str, const Zstring& postfix)
+{
+    return str.size() >= postfix.size() &&
+           EqualFilePath()(Zstring(str.end() - postfix.size(), str.end()), postfix);
+}