5.3

1 files changed, 258 insertions, 149 deletions

diff --git a/lib/dir_lock.cpp b/lib/dir_lock.cpp
index 87864ce4..402892c6 100644
--- a/lib/dir_lock.cpp
+++ b/lib/dir_lock.cpp
@@ -25,6 +25,8 @@
 #include <tlhelp32.h>
 #include <zen/win.h> //includes "windows.h"
 #include <zen/long_path_prefix.h>
+#include <Sddl.h> //login sid
+#include <Lmcons.h> //UNLEN
 
 #elif defined FFS_LINUX
 #include <sys/stat.h>
@@ -37,12 +39,12 @@ using namespace std::rel_ops;
 
 namespace
 {
-const size_t EMIT_LIFE_SIGN_INTERVAL =  5000; //show life sign;        unit [ms]
-const size_t POLL_LIFE_SIGN_INTERVAL =  6000; //poll for life sign;    unit [ms]
-const size_t DETECT_EXITUS_INTERVAL  = 30000; //assume abandoned lock; unit [ms]
+const size_t EMIT_LIFE_SIGN_INTERVAL   =  5000; //show life sign;        unit: [ms]
+const size_t POLL_LIFE_SIGN_INTERVAL   =  4000; //poll for life sign;    unit: [ms]
+const size_t DETECT_ABANDONED_INTERVAL = 30000; //assume abandoned lock; unit: [ms]
 
 const char LOCK_FORMAT_DESCR[] = "FreeFileSync";
-const int LOCK_FORMAT_VER = 1; //lock file format version
+const int LOCK_FORMAT_VER = 2; //lock file format version
 }
 
 //worker thread
@@ -66,7 +68,7 @@ public:
         }
         catch (const std::exception& e) //exceptions must be catched per thread
         {
-            wxSafeShowMessage(wxString(_("An exception occurred!")) + wxT("(Dirlock)"), utf8CvrtTo<wxString>(e.what())); //simple wxMessageBox won't do for threads
+            wxSafeShowMessage(_("An exception occurred!") + L" (Dirlock)", utf8CvrtTo<wxString>(e.what())); //simple wxMessageBox won't do for threads
         }
     }
 
@@ -97,9 +99,10 @@ public:
             return;
 
         DWORD bytesWritten = 0;
+        /*bool rv = */
         ::WriteFile(fileHandle,    //__in         HANDLE hFile,
                     buffer,        //__out        LPVOID lpBuffer,
-                    1,             //__in         DWORD nNumberOfBytesToRead,
+                    1,             //__in         DWORD nNumberOfBytesToWrite,
                     &bytesWritten, //__out_opt    LPDWORD lpNumberOfBytesWritten,
                     nullptr);      //__inout_opt  LPOVERLAPPED lpOverlapped
 
@@ -129,17 +132,17 @@ UInt64 getLockFileSize(const Zstring& filename) //throw FileError, ErrorNotExist
     if (searchHandle != INVALID_HANDLE_VALUE)
     {
         ::FindClose(searchHandle);
-        return zen::UInt64(fileInfo.nFileSizeLow, fileInfo.nFileSizeHigh);
+        return UInt64(fileInfo.nFileSizeLow, fileInfo.nFileSizeHigh);
     }
 
 #elif defined FFS_LINUX
     struct ::stat fileInfo = {};
     if (::stat(filename.c_str(), &fileInfo) == 0) //follow symbolic links
-        return zen::UInt64(fileInfo.st_size);
+        return UInt64(fileInfo.st_size);
 #endif
 
     const ErrorCode lastError = getLastError();
-    const std::wstring errorMessage = _("Error reading file attributes:") + L"\n\"" + filename + L"\"" + L"\n\n" + getLastErrorFormatted(lastError);
+    const std::wstring errorMessage = replaceCpy(_("Cannot read file attributes of %x."), L"%x", fmtFileName(filename)) + L"\n\n" + getLastErrorFormatted(lastError);
 
     if (errorCodeForNotExisting(lastError))
         throw ErrorNotExisting(errorMessage);
@@ -158,73 +161,186 @@ Zstring deleteAbandonedLockName(const Zstring& lockfilename) //make sure to NOT
 }
 
 
-namespace
+class CheckedLockReader : public CheckedReader
 {
-std::string getComputerId() //returns empty string on error
+public:
+    CheckedLockReader(wxInputStream& stream, const Zstring& errorObjName) : CheckedReader(stream), errorObjName_(errorObjName) {}
+    virtual void throwException() const { throw FileError(replaceCpy(_("Cannot read file %x."), L"%x", fmtFileName(errorObjName_))); }
+
+private:
+    const Zstring errorObjName_;
+};
+
+class CheckedLockWriter : public CheckedWriter
 {
-    const wxString fhn = ::wxGetFullHostName();
-    if (fhn.empty()) return std::string();
+public:
+    CheckedLockWriter(wxOutputStream& stream, const Zstring& errorObjName) : CheckedWriter(stream), errorObjName_(errorObjName) {}
+    virtual void throwException() const { throw FileError(replaceCpy(_("Cannot write file %x."), L"%x", fmtFileName(errorObjName_))); }
+
+private:
+    const Zstring errorObjName_;
+};
+
+
 #ifdef FFS_WIN
-    return "Windows " + utf8CvrtTo<std::string>(fhn);
-#elif defined FFS_LINUX
-    return "Linux " + utf8CvrtTo<std::string>(fhn);
-#endif
+std::wstring getLoginSid() //throw FileError
+{
+    HANDLE hToken = 0;
+    if (!::OpenProcessToken(::GetCurrentProcess(), //__in   HANDLE ProcessHandle,
+                            TOKEN_ALL_ACCESS,      //__in   DWORD DesiredAccess,
+                            &hToken))              //__out  PHANDLE TokenHandle
+        throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted());
+    ZEN_ON_SCOPE_EXIT(::CloseHandle(hToken));
+
+    DWORD bufferSize = 0;
+    ::GetTokenInformation(hToken, TokenGroups, nullptr, 0, &bufferSize);
+
+    std::vector<char> buffer(bufferSize);
+    if (!::GetTokenInformation(hToken,       //__in       HANDLE TokenHandle,
+                               TokenGroups,  //__in       TOKEN_INFORMATION_CLASS TokenInformationClass,
+                               &buffer[0],   //__out_opt  LPVOID TokenInformation,
+                               bufferSize,   //__in       DWORD TokenInformationLength,
+                               &bufferSize)) //__out      PDWORD ReturnLength
+        throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted());
+
+    auto groups = reinterpret_cast<const TOKEN_GROUPS*>(&buffer[0]);
+
+    for (DWORD i = 0; i < groups->GroupCount; ++i)
+        if ((groups->Groups[i].Attributes & SE_GROUP_LOGON_ID) != 0)
+        {
+            LPTSTR sidStr = nullptr;
+            if (!::ConvertSidToStringSid(groups->Groups[i].Sid, //__in   PSID Sid,
+                                         &sidStr))              //__out  LPTSTR *StringSid
+                throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted());
+            ZEN_ON_SCOPE_EXIT(::LocalFree(sidStr));
+
+            return sidStr;
+        }
+    throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted() + L"(no login found)"); //shouldn't happen
 }
+#endif
+
 
+class FromCurrentProcess {}; //tag
 
-struct LockInformation
+struct LockInformation //throw FileError
 {
-    LockInformation()
-    {
-        lockId = zen::generateGUID();
+    explicit LockInformation(FromCurrentProcess) :
+        lockId(zen::generateGUID()),
 #ifdef FFS_WIN
-        procDescr.processId = ::GetCurrentProcessId();
-#elif defined FFS_LINUX
-        procDescr.processId = ::getpid();
-#endif
-        procDescr.computerId = getComputerId();
+        sessionId(utf8CvrtTo<std::string>(getLoginSid())), //throw FileError
+        processId(::GetCurrentProcessId()) //never fails
+    {
+        DWORD bufferSize = 0;
+        ::GetComputerNameEx(ComputerNameDnsFullyQualified, nullptr, &bufferSize); //get required buffer size
+
+        std::vector<wchar_t> buffer(bufferSize);
+        if (!GetComputerNameEx(ComputerNameDnsFullyQualified, //__in     COMPUTER_NAME_FORMAT NameType,
+                               &buffer[0],                    //__out    LPTSTR lpBuffer,
+                               &bufferSize))                  //__inout  LPDWORD lpnSize
+            throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted());
+        computerName = "Windows." + utf8CvrtTo<std::string>(&buffer[0]);
+
+        bufferSize = UNLEN + 1;
+        buffer.resize(bufferSize);
+        if (!::GetUserName(&buffer[0],   //__out    LPTSTR lpBuffer,
+                           &bufferSize)) //__inout  LPDWORD lpnSize
+            throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted());
+        userId = utf8CvrtTo<std::string>(&buffer[0]);
     }
-
-    LockInformation(wxInputStream& stream) //read
+#elif defined FFS_LINUX
+        processId(::getpid()) //never fails
     {
-        char formatDescr[sizeof(LOCK_FORMAT_DESCR)] = {};
-        stream.Read(formatDescr, sizeof(LOCK_FORMAT_DESCR));         //file format header
-        const int lockFileVersion = readPOD<boost::int32_t>(stream); //
-        (void)lockFileVersion;
+        std::vector<char> buffer(10000);
+        if (::gethostname(&buffer[0], buffer.size()) != 0)
+            throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted());
 
-        //some format checking here?
+        computerName += "Linux."; //distinguish linux/windows lock files
+        computerName += &buffer[0];
 
-        lockId = readString<std::string>(stream);
-        procDescr.processId  = static_cast<ProcessId>(readPOD<std::uint64_t>(stream)); //possible loss of precision (32/64 bit process) covered by buildId
-        procDescr.computerId = readString<std::string>(stream);
+        if (::getdomainname(&buffer[0], buffer.size()) != 0)
+            throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted());
+        computerName += ".";
+        computerName += &buffer[0];
+
+        uid_t userIdTmp = ::getuid(); //never fails
+        userId.assign(reinterpret_cast<const char*>(&userIdTmp), sizeof(userIdTmp));
+
+        pid_t sessionIdTmp = ::getsid(0); //new after each restart!
+        if (sessionIdTmp == -1)
+            throw FileError(_("Cannot get process information.") + L"\n\n" + getLastErrorFormatted());
+        sessionId.assign(reinterpret_cast<const char*>(&sessionIdTmp), sizeof(sessionIdTmp));
     }
+#endif
 
-    void toStream(wxOutputStream& stream) const //write
+    explicit LockInformation(CheckedLockReader& reader)
     {
-        assert_static(sizeof(ProcessId) <= sizeof(std::uint64_t)); //ensure portability
+        char tmp[sizeof(LOCK_FORMAT_DESCR)] = {};
+        reader.readArray(&tmp, sizeof(tmp));                          //file format header
+        const int lockFileVersion = reader.readPOD<boost::int32_t>(); //
+
+        if (!std::equal(std::begin(tmp), std::end(tmp), std::begin(LOCK_FORMAT_DESCR)) ||
+            lockFileVersion != LOCK_FORMAT_VER)
+            reader.throwException();
+
+        reader.readString(lockId);
+        reader.readString(computerName);
+        reader.readString(userId);
+        reader.readString(sessionId);
+        processId = static_cast<decltype(processId)>(reader.readPOD<std::uint64_t>()); //[!] conversion
+    }
+
+    void toStream(CheckedLockWriter& writer) const
+    {
+        writer.writeArray(LOCK_FORMAT_DESCR, sizeof(LOCK_FORMAT_DESCR));
+        writer.writePOD<boost::int32_t>(LOCK_FORMAT_VER);
 
-        stream.Write(LOCK_FORMAT_DESCR, sizeof(LOCK_FORMAT_DESCR));
-        writePOD<boost::int32_t>(stream, LOCK_FORMAT_VER);
+        assert_static(sizeof(processId) <= sizeof(std::uint64_t)); //ensure portability
 
-        writeString(stream, lockId);
-        writePOD<std::uint64_t>(stream, procDescr.processId);
-        writeString(stream, procDescr.computerId);
+        writer.writeString(lockId);
+        writer.writeString(computerName);
+        writer.writeString(userId);
+        writer.writeString(sessionId);
+        writer.writePOD<std::uint64_t>(processId);
     }
 
+    std::string lockId; //16 byte GUID - a universal identifier for this lock (no matter what the path is, considering symlinks, distributed network, etc.)
+
+    std::string computerName; //format: HostName.DomainName
+    std::string userId;    //non-readable!
+    std::string sessionId; //
 #ifdef FFS_WIN
-    typedef DWORD ProcessId; //same size on 32 and 64 bit windows!
+    DWORD processId;
 #elif defined FFS_LINUX
-    typedef pid_t ProcessId;
+    pid_t processId;
 #endif
+};
 
-    std::string lockId; //16 byte UUID
 
-    struct ProcessDescription
-    {
-        ProcessId processId;
-        std::string computerId;
-    } procDescr;
-};
+//wxGetFullHostName() is a performance killer for some users, so don't touch!
+
+
+void writeLockInfo(const Zstring& lockfilename) //throw FileError
+{
+    FileOutputStream stream(lockfilename); //throw FileError
+    CheckedLockWriter writer(stream, lockfilename);
+    LockInformation(FromCurrentProcess()).toStream(writer); //throw FileError
+}
+
+
+LockInformation retrieveLockInfo(const Zstring& lockfilename) //throw FileError, ErrorNotExisting
+{
+    FileInputStream stream(lockfilename); //throw FileError, ErrorNotExisting
+    CheckedLockReader reader(stream, lockfilename);
+    return LockInformation(reader); //throw FileError
+}
+
+
+inline
+std::string retrieveLockId(const Zstring& lockfilename) //throw FileError, ErrorNotExisting
+{
+    return retrieveLockInfo(lockfilename).lockId;
+}
 
 
 //true: process not available, false: cannot say anything
@@ -235,20 +351,24 @@ enum ProcessStatus
     PROC_STATUS_ITS_US,
     PROC_STATUS_NO_IDEA
 };
-ProcessStatus getProcessStatus(const LockInformation::ProcessDescription& procDescr)
+ProcessStatus getProcessStatus(const LockInformation& lockInfo) //throw FileError
 {
-    if (procDescr.computerId != getComputerId() ||
-        procDescr.computerId.empty()) //both names are empty
-        return PROC_STATUS_NO_IDEA; //lock owned by different computer
+    const LockInformation localInfo((FromCurrentProcess())); //throw FileError
 
-#ifdef FFS_WIN
-    if (procDescr.processId == ::GetCurrentProcessId()) //may seem obscure, but it's possible: deletion failed or a lock file is "stolen" and put back while the program is running
+    if (lockInfo.computerName != localInfo.computerName ||
+        lockInfo.userId != localInfo.userId) //another user may run a session right now!
+        return PROC_STATUS_NO_IDEA; //lock owned by different computer in this network
+
+    if (lockInfo.sessionId != localInfo.sessionId)
+        return PROC_STATUS_NOT_RUNNING; //different session but same user? there can be only one
+
+    if (lockInfo.processId == localInfo.processId) //obscure, but possible: deletion failed or a lock file is "stolen" and put back while the program is running
         return PROC_STATUS_ITS_US;
 
-    //note: ::OpenProcess() is no option as it may successfully return for crashed processes!
-    HANDLE snapshot = ::CreateToolhelp32Snapshot(
-                          TH32CS_SNAPPROCESS, //__in  DWORD dwFlags,
-                          0);                 //__in  DWORD th32ProcessID
+#ifdef FFS_WIN
+    //note: ::OpenProcess() is no alternative as it may successfully return for crashed processes! -> remark: "WaitForSingleObject" may identify this case!
+    HANDLE snapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, //__in  DWORD dwFlags,
+                                                 0);                 //__in  DWORD th32ProcessID
     if (snapshot == INVALID_HANDLE_VALUE)
         return PROC_STATUS_NO_IDEA;
     ZEN_ON_SCOPE_EXIT(::CloseHandle(snapshot));
@@ -258,122 +378,104 @@ ProcessStatus getProcessStatus(const LockInformation::ProcessDescription& procDe
 
     if (!::Process32First(snapshot,       //__in     HANDLE hSnapshot,
                           &processEntry)) //__inout  LPPROCESSENTRY32 lppe
-        return PROC_STATUS_NO_IDEA;
+        return PROC_STATUS_NO_IDEA; //ERROR_NO_MORE_FILES not possible
     do
     {
-        if (processEntry.th32ProcessID == procDescr.processId)
+        if (processEntry.th32ProcessID == lockInfo.processId)
             return PROC_STATUS_RUNNING; //process still running
     }
     while (::Process32Next(snapshot, &processEntry));
+    if (::GetLastError() != ERROR_NO_MORE_FILES) //yes, they call it "files"
+        return PROC_STATUS_NO_IDEA;
 
     return PROC_STATUS_NOT_RUNNING;
 
 #elif defined FFS_LINUX
-    if (procDescr.processId == ::getpid()) //may seem obscure, but it's possible: a lock file is "stolen" and put back while the program is running
-        return PROC_STATUS_ITS_US;
-
-    if (procDescr.processId <= 0 || procDescr.processId >= 65536)
+    if (lockInfo.processId <= 0 || lockInfo.processId >= 65536)
         return PROC_STATUS_NO_IDEA; //invalid process id
 
-    return zen::dirExists(Zstr("/proc/") + zen::numberTo<Zstring>(procDescr.processId)) ? PROC_STATUS_RUNNING : PROC_STATUS_NOT_RUNNING;
+    return zen::dirExists("/proc/" + zen::numberTo<Zstring>(lockInfo.processId)) ? PROC_STATUS_RUNNING : PROC_STATUS_NOT_RUNNING;
 #endif
 }
 
 
-void writeLockInfo(const Zstring& lockfilename) //throw FileError
-{
-    //write GUID at the beginning of the file: this ID is a universal identifier for this lock (no matter what the path is, considering symlinks, distributed network, etc.)
-    FileOutputStream lockFile(lockfilename); //throw FileError
-    LockInformation().toStream(lockFile);
-}
-
-
-LockInformation retrieveLockInfo(const Zstring& lockfilename) //throw FileError, ErrorNotExisting
-{
-    //read GUID from beginning of file
-    FileInputStream lockFile(lockfilename); //throw FileError, ErrorNotExisting
-    return LockInformation(lockFile);
-}
-
-
-std::string retrieveLockId(const Zstring& lockfilename) //throw FileError, ErrorNotExisting
-{
-    return retrieveLockInfo(lockfilename).lockId;
-}
-}
-
-
 void waitOnDirLock(const Zstring& lockfilename, DirLockCallback* callback) //throw FileError
 {
-    const std::wstring infoMsg = replaceCpy(_("Waiting while directory is locked (%x)..."), L"%x", std::wstring(L"\"") + lockfilename + L"\"");
+    const std::wstring infoMsg = replaceCpy(_("Waiting while directory is locked (%x)..."), L"%x", fmtFileName(lockfilename));
 
     if (callback)
         callback->reportInfo(infoMsg);
     //---------------------------------------------------------------
     try
     {
-        const LockInformation lockInfo = retrieveLockInfo(lockfilename); //throw FileError, ErrorNotExisting
-
-        bool lockOwnderDead = false; //convenience optimization: if we know the owning process crashed, we needn't wait DETECT_EXITUS_INTERVAL sec
-        switch (getProcessStatus(lockInfo.procDescr))
+        //convenience optimization only: if we know the owning process crashed, we needn't wait DETECT_ABANDONED_INTERVAL sec
+        bool lockOwnderDead = false;
+        std::string originalLockId; //empty if it cannot be retrieved
+        try
         {
-            case PROC_STATUS_ITS_US: //since we've already passed LockAdmin, the lock file seems abandoned ("stolen"?) although it's from this process
-            case PROC_STATUS_NOT_RUNNING:
-                lockOwnderDead = true;
-                break;
-            case PROC_STATUS_RUNNING:
-            case PROC_STATUS_NO_IDEA:
-                break;
+            const LockInformation& lockInfo = retrieveLockInfo(lockfilename); //throw FileError, ErrorNotExisting
+            originalLockId = lockInfo.lockId;
+            switch (getProcessStatus(lockInfo)) //throw FileError
+            {
+                case PROC_STATUS_ITS_US: //since we've already passed LockAdmin, the lock file seems abandoned ("stolen"?) although it's from this process
+                case PROC_STATUS_NOT_RUNNING:
+                    lockOwnderDead = true;
+                    break;
+                case PROC_STATUS_RUNNING:
+                case PROC_STATUS_NO_IDEA:
+                    break;
+            }
         }
+        catch (FileError&) {} //logfile may be only partly written -> this is no error!
 
-        zen::UInt64 fileSizeOld;
-        wxLongLong lockSilentStart = wxGetLocalTimeMillis();
+        UInt64 fileSizeOld;
+        wxMilliClock_t lastLifeSign = wxGetLocalTimeMillis();
 
         while (true)
         {
-            const zen::UInt64 fileSizeNew = ::getLockFileSize(lockfilename); //throw FileError, ErrorNotExisting
-            wxLongLong currentTime = wxGetLocalTimeMillis();
+            wxMilliClock_t currentTime = wxGetLocalTimeMillis();
+            const UInt64 fileSizeNew = ::getLockFileSize(lockfilename); //throw FileError, ErrorNotExisting
 
             if (fileSizeNew != fileSizeOld) //received life sign from lock
             {
-                fileSizeOld     = fileSizeNew;
-                lockSilentStart = currentTime;
+                fileSizeOld  = fileSizeNew;
+                lastLifeSign = currentTime;
             }
 
             if (lockOwnderDead || //no need to wait any longer...
-                currentTime - lockSilentStart > DETECT_EXITUS_INTERVAL)
+                currentTime - lastLifeSign > DETECT_ABANDONED_INTERVAL)
             {
                 DirLock dummy(deleteAbandonedLockName(lockfilename), callback); //throw FileError
 
                 //now that the lock is in place check existence again: meanwhile another process may have deleted and created a new lock!
 
-                if (retrieveLockId(lockfilename) != lockInfo.lockId) //throw FileError, ErrorNotExisting
-                    return; //another process has placed a new lock, leave scope: the wait for the old lock is technically over...
+                if (!originalLockId.empty())
+                    if (retrieveLockId(lockfilename) != originalLockId) //throw FileError, ErrorNotExisting -> since originalLockId is filled, we are not expecting errors!
+                        return; //another process has placed a new lock, leave scope: the wait for the old lock is technically over...
 
-                if (getLockFileSize(lockfilename) != fileSizeOld) //throw FileError, ErrorNotExisting
-                    continue; //belated lifesign
+                if (::getLockFileSize(lockfilename) != fileSizeOld) //throw FileError, ErrorNotExisting
+                    continue; //late life sign
 
                 removeFile(lockfilename); //throw FileError
                 return;
             }
 
             //wait some time...
-            const size_t GUI_CALLBACK_INTERVAL = 100;
+            assert_static(POLL_LIFE_SIGN_INTERVAL % GUI_CALLBACK_INTERVAL == 0);
             for (size_t i = 0; i < POLL_LIFE_SIGN_INTERVAL / GUI_CALLBACK_INTERVAL; ++i)
             {
                 if (callback) callback->requestUiRefresh();
                 wxMilliSleep(GUI_CALLBACK_INTERVAL);
 
-                //show some countdown on abandoned locks
                 if (callback)
                 {
-                    if (currentTime - lockSilentStart > EMIT_LIFE_SIGN_INTERVAL) //one signal missed: it's likely this is an abandoned lock:
+                    //one signal missed: it's likely this is an abandoned lock => show countdown
+                    if (currentTime - lastLifeSign > EMIT_LIFE_SIGN_INTERVAL)
                     {
-                        long remainingSeconds = ((DETECT_EXITUS_INTERVAL - (wxGetLocalTimeMillis() - lockSilentStart)) / 1000).ToLong();
+                        long remainingSeconds = ((DETECT_ABANDONED_INTERVAL - (wxGetLocalTimeMillis() - lastLifeSign)) / 1000).ToLong();
                         remainingSeconds = std::max(0L, remainingSeconds);
 
                         const std::wstring remSecMsg = replaceCpy(_P("1 sec", "%x sec", remainingSeconds), L"%x", numberTo<std::wstring>(remainingSeconds));
-
                         callback->reportInfo(infoMsg + L" " + remSecMsg);
                     }
                     else
@@ -411,30 +513,32 @@ bool tryLock(const Zstring& lockfilename) //throw FileError
                                            nullptr);
     if (fileHandle == INVALID_HANDLE_VALUE)
     {
-        if (::GetLastError() == ERROR_FILE_EXISTS)
+        const DWORD lastError = ::GetLastError();
+        if (lastError == ERROR_FILE_EXISTS || //confirmed to be used
+            lastError == ERROR_ALREADY_EXISTS) //comment on msdn claims, this one is used on Windows Mobile 6
             return false;
         else
-            throw FileError(_("Error setting directory lock:") + L"\n\"" + lockfilename + L"\"" + L"\n\n" + getLastErrorFormatted());
+            throw FileError(replaceCpy(_("Cannot set directory lock %x."), L"%x", fmtFileName(lockfilename)) + L"\n\n" + getLastErrorFormatted());
     }
     ::CloseHandle(fileHandle);
 
 #elif defined FFS_LINUX
     //O_EXCL contains a race condition on NFS file systems: http://linux.die.net/man/2/open
-    ::umask(0); //important!
+    ::umask(0); //important! -> why?
     const int fileHandle = ::open(lockfilename.c_str(), O_CREAT | O_WRONLY | O_EXCL, S_IRWXU | S_IRWXG | S_IRWXO);
     if (fileHandle == -1)
     {
         if (errno == EEXIST)
             return false;
         else
-            throw FileError(_("Error setting directory lock:") + L"\n\"" + lockfilename + L"\"" + L"\n\n" + getLastErrorFormatted());
+            throw FileError(replaceCpy(_("Cannot set directory lock %x."), L"%x", fmtFileName(lockfilename)) + L"\n\n" + getLastErrorFormatted());
     }
     ::close(fileHandle);
 #endif
 
     ScopeGuard guardLockFile = zen::makeGuard([&] { removeFile(lockfilename); });
 
-    //write UUID at the beginning of the file: this ID is a universal identifier for this lock (no matter what the path is, considering symlinks, etc.)
+    //write housekeeping info: user, process info, lock GUID
     writeLockInfo(lockfilename); //throw FileError
 
     guardLockFile.dismiss(); //lockfile created successfully
@@ -485,32 +589,32 @@ public:
     //create or retrieve a SharedDirLock
     std::shared_ptr<SharedDirLock> retrieve(const Zstring& lockfilename, DirLockCallback* callback) //throw FileError
     {
-        //optimization: check if there is an active(!) lock for "lockfilename"
-        FileToUuidMap::const_iterator iterUuid = fileToUuid.find(lockfilename);
-        if (iterUuid != fileToUuid.end())
-        {
-            if (const std::shared_ptr<SharedDirLock>& activeLock = findActive(iterUuid->second)) //returns null-lock if not found
+        tidyUp();
+
+        //optimization: check if we already own a lock for this path
+        auto iterGuid = fileToGuid.find(lockfilename);
+        if (iterGuid != fileToGuid.end())
+            if (const std::shared_ptr<SharedDirLock>& activeLock = getActiveLock(iterGuid->second)) //returns null-lock if not found
                 return activeLock; //SharedDirLock is still active -> enlarge circle of shared ownership
-        }
 
-        try //actual check based on lock UUID, deadlock prevention: "lockfilename" may be an alternative name for an already active lock
+        try //check based on lock GUID, deadlock prevention: "lockfilename" may be an alternative name for a lock already owned by this process
         {
             const std::string lockId = retrieveLockId(lockfilename); //throw FileError, ErrorNotExisting
-            if (const std::shared_ptr<SharedDirLock>& activeLock = findActive(lockId)) //returns null-lock if not found
+            if (const std::shared_ptr<SharedDirLock>& activeLock = getActiveLock(lockId)) //returns null-lock if not found
             {
-                fileToUuid[lockfilename] = lockId; //perf-optimization: update relation
+                fileToGuid[lockfilename] = lockId; //found an alias for one of our active locks
                 return activeLock;
             }
         }
-        catch (FileError&) {} //catch everything, let SharedDirLock constructor deal with errors, e.g. 0-sized/corrupted lock file
+        catch (FileError&) {} //catch everything, let SharedDirLock constructor deal with errors, e.g. 0-sized/corrupted lock files
 
-        //not yet in buffer, so create a new directory lock
+        //lock not owned by us => create a new one
         auto newLock = std::make_shared<SharedDirLock>(lockfilename, callback); //throw FileError
-        const std::string& newLockId = retrieveLockId(lockfilename); //throw FileError, ErrorNotExisting
+        const std::string& newLockGuid = retrieveLockId(lockfilename); //throw FileError, ErrorNotExisting
 
         //update registry
-        fileToUuid[lockfilename] = newLockId; //throw()
-        uuidToLock[newLockId]    = newLock;   //
+        fileToGuid[lockfilename] = newLockGuid; //throw()
+        guidToLock[newLockGuid]  = newLock;     //
 
         return newLock;
     }
@@ -518,19 +622,24 @@ public:
 private:
     LockAdmin() {}
 
-    std::shared_ptr<SharedDirLock> findActive(const std::string& lockId) //returns null-lock if not found
+    typedef std::string UniqueId;
+    typedef std::map<Zstring, UniqueId, LessFilename>        FileToGuidMap; //n:1 handle uppper/lower case correctly
+    typedef std::map<UniqueId, std::weak_ptr<SharedDirLock>> GuidToLockMap; //1:1
+
+    std::shared_ptr<SharedDirLock> getActiveLock(const UniqueId& lockId) //returns null if none found
     {
-        auto iterLock = uuidToLock.find(lockId);
-        return iterLock != uuidToLock.end() ?
-               iterLock->second.lock() : nullptr; //try to get shared_ptr; throw()
+        auto iterLock = guidToLock.find(lockId);
+        return iterLock != guidToLock.end() ? iterLock->second.lock() : nullptr; //try to get shared_ptr; throw()
     }
 
-    typedef std::string UniqueId;
-    typedef std::map<Zstring, UniqueId, LessFilename>        FileToUuidMap; //n:1 handle uppper/lower case correctly
-    typedef std::map<UniqueId, std::weak_ptr<SharedDirLock>> UuidToLockMap; //1:1
+    void tidyUp() //remove obsolete lock entries
+    {
+        map_remove_if(guidToLock, [ ](const GuidToLockMap::value_type& v) { return !v.second.lock(); });
+        map_remove_if(fileToGuid, [&](const FileToGuidMap::value_type& v) { return guidToLock.find(v.second) == guidToLock.end(); });
+    }
 
-    FileToUuidMap fileToUuid; //lockname |-> UUID; locks can be referenced by a lockfilename or alternatively a UUID
-    UuidToLockMap uuidToLock; //UUID |-> "shared lock ownership"
+    FileToGuidMap fileToGuid; //lockname |-> GUID; locks can be referenced by a lockfilename or alternatively a GUID
+    GuidToLockMap guidToLock; //GUID |-> "shared lock ownership"
 };
 
 
@@ -549,5 +658,5 @@ DirLock::DirLock(const Zstring& lockfilename, DirLockCallback* callback) //throw
     }
 #endif
 
-    sharedLock = LockAdmin::instance().retrieve(lockfilename, callback);
+    sharedLock = LockAdmin::instance().retrieve(lockfilename, callback); //throw FileError
 }