1.17

1 files changed, 623 insertions, 179 deletions

diff --git a/library/fileHandling.cpp b/library/fileHandling.cpp
index cda81ef5..0dccdec7 100644
--- a/library/fileHandling.cpp
+++ b/library/fileHandling.cpp
@@ -6,7 +6,16 @@
 
 #ifdef FFS_WIN
 #include <wx/msw/wrapwin.h> //includes "windows.h"
-#endif  // FFS_WIN
+
+#elif defined FFS_LINUX
+#include <sys/stat.h>
+#include <time.h>
+#include <utime.h>
+#include <fstream>
+#include <unistd.h>
+#include <dirent.h>
+#include <errno.h>
+#endif
 
 
 class RecycleBin
@@ -40,7 +49,7 @@ public:
         fileOp.wFunc  = FO_DELETE;
         fileOp.pFrom  = filenameDoubleNull.c_str();
         fileOp.pTo    = NULL;
-        fileOp.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_SILENT;
+        fileOp.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
         fileOp.fAnyOperationsAborted = false;
         fileOp.hNameMappings         = NULL;
         fileOp.lpszProgressTitle     = NULL;
@@ -75,10 +84,35 @@ bool moveToRecycleBin(const Zstring& filename) throw(RuntimeException)
 }
 
 
-inline
+bool FreeFileSync::fileExists(const Zstring& filename)
+{ //symbolic links (broken or not) are also treated as existing files!
+#ifdef FFS_WIN
+    // we must use GetFileAttributes() instead of the ANSI C functions because
+    // it can cope with network (UNC) paths unlike them
+    const DWORD ret = ::GetFileAttributes(filename.c_str());
+
+    return (ret != INVALID_FILE_ATTRIBUTES) && !(ret & FILE_ATTRIBUTE_DIRECTORY);
+
+#elif defined FFS_LINUX
+    struct stat fileInfo;
+    return (lstat(filename.c_str(), &fileInfo) == 0 &&
+            (S_ISLNK(fileInfo.st_mode) || S_ISREG(fileInfo.st_mode)));
+#endif
+}
+
+
 void FreeFileSync::removeFile(const Zstring& filename, const bool useRecycleBin)
 {
-    if (!wxFileExists(filename.c_str())) return; //this is NOT an error situation: the manual deletion relies on it!
+    //no error situation if file is not existing! manual deletion relies on it!
+#ifdef FFS_WIN
+    if (GetFileAttributes(filename.c_str()) == INVALID_FILE_ATTRIBUTES)
+        return; //neither file nor any other object with that name existing
+
+#elif defined FFS_LINUX
+    struct stat fileInfo;
+    if (lstat(filename.c_str(), &fileInfo) != 0)
+        return; //neither file nor any other object (e.g. broken symlink) with that name existing
+#endif
 
     if (useRecycleBin)
     {
@@ -103,61 +137,218 @@ void FreeFileSync::removeFile(const Zstring& filename, const bool useRecycleBin)
         Zstring errorMessage = Zstring(_("Error deleting file:")) + wxT("\n\"") + filename + wxT("\"");
         throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
     }
-#else
-    if (!wxRemoveFile(filename.c_str()))
-        throw FileError(Zstring(_("Error deleting file:")) + wxT("\n\"") + filename + wxT("\""));
+#elif defined FFS_LINUX
+    if (unlink(filename.c_str()) != 0)
+    {
+        Zstring errorMessage = Zstring(_("Error deleting file:")) + wxT("\n\"") + filename + wxT("\"");
+        throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+    }
 #endif
 }
 
 
-void FreeFileSync::removeDirectory(const Zstring& directory, const bool useRecycleBin)
+class FilesDirsOnlyTraverser : public FreeFileSync::FullDetailFileTraverser
 {
-    if (!wxDirExists(directory)) return; //this is NOT an error situation: the manual deletion relies on it!
+public:
+    FilesDirsOnlyTraverser(std::vector<Zstring>& files, std::vector<Zstring>& dirs) :
+            m_files(files),
+            m_dirs(dirs) {}
 
-    if (useRecycleBin)
+    virtual wxDirTraverseResult OnFile(const Zstring& filename, const FreeFileSync::FileInfo& details)
     {
-        if (!moveToRecycleBin(directory))
-            throw FileError(Zstring(_("Error moving to Recycle Bin:")) + wxT("\n\"") + directory + wxT("\""));
-        return;
+        m_files.push_back(filename);
+        return wxDIR_CONTINUE;
+    }
+    virtual wxDirTraverseResult OnDir(const Zstring& dirname)
+    {
+        m_dirs.push_back(dirname);
+        return wxDIR_IGNORE; //DON'T traverse into subdirs, removeDirectory works recursively!
+    }
+    virtual wxDirTraverseResult OnError(const Zstring& errorText)
+    {
+        throw FileError(errorText);
     }
 
-    std::vector<Zstring> fileList;
-    std::vector<Zstring> dirList;
+private:
+    std::vector<Zstring>& m_files;
+    std::vector<Zstring>& m_dirs;
+};
 
-    getAllFilesAndDirs(directory, fileList, dirList);
 
-    for (unsigned int j = 0; j < fileList.size(); ++j)
-        removeFile(fileList[j], false);
+void FreeFileSync::removeDirectory(const Zstring& directory, const bool useRecycleBin)
+{
+    //no error situation if directory is not existing! manual deletion relies on it!
+#ifdef FFS_WIN
+    const DWORD dirAttr = GetFileAttributes(directory.c_str()); //name of a file or directory
+    if (dirAttr == INVALID_FILE_ATTRIBUTES)
+        return; //neither directory nor any other object with that name existing
 
-    dirList.insert(dirList.begin(), directory);   //parent directory will be deleted last
+#elif defined FFS_LINUX
+    struct stat dirInfo;
+    if (lstat(directory.c_str(), &dirInfo) != 0)
+        return; //neither directory nor any other object (e.g. broken symlink) with that name existing
+#endif
 
-    for (int j = int(dirList.size()) - 1; j >= 0 ; --j)
+    if (useRecycleBin)
     {
+        if (!moveToRecycleBin(directory))
+            throw FileError(Zstring(_("Error moving to Recycle Bin:")) + wxT("\n\"") + directory + wxT("\""));
+        return;
+    }
+
+//attention: check if directory is a symlink! Do NOT traverse into it deleting contained files!!!
 #ifdef FFS_WIN
-        //initialize file attributes
-        if (!SetFileAttributes(
-                    dirList[j].c_str(),     // address of directory name
-                    FILE_ATTRIBUTE_NORMAL)) // attributes to set
+    if (dirAttr & FILE_ATTRIBUTE_REPARSE_POINT)
+    {   //remove symlink directly, support for \\?\-prefix
+        if (RemoveDirectory(directory.c_str()) == 0)
         {
-            Zstring errorMessage = Zstring(_("Error deleting directory:")) + wxT("\n\"") + dirList[j] + wxT("\"");
+            Zstring errorMessage = Zstring(_("Error deleting directory:")) + wxT("\n\"") + directory + wxT("\"");
             throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
         }
+        return;
+    }
 
-        //remove directory, support for \\?\-prefix
-        if (RemoveDirectory(dirList[j].c_str()) == 0)
+#elif defined FFS_LINUX
+    if (S_ISLNK(dirInfo.st_mode))
+    {
+        if (unlink(directory.c_str()) != 0)
         {
-            Zstring errorMessage = Zstring(_("Error deleting directory:")) + wxT("\n\"") + dirList[j] + wxT("\"");
+            Zstring errorMessage = Zstring(_("Error deleting directory:")) + wxT("\n\"") + directory + wxT("\"");
             throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
         }
+        return;
+    }
+#endif
+
+    std::vector<Zstring> fileList;
+    std::vector<Zstring> dirList;
+
+    //get all files and directories from current directory (WITHOUT subdirectories!)
+    FilesDirsOnlyTraverser traverser(fileList, dirList);
+    FreeFileSync::traverseInDetail(directory, false, &traverser); //don't traverse into symlinks to directories
+
+    //delete files
+    for (std::vector<Zstring>::const_iterator j = fileList.begin(); j != fileList.end(); ++j)
+        FreeFileSync::removeFile(*j, false);
+
+    //delete directories recursively
+    for (std::vector<Zstring>::const_iterator j = dirList.begin(); j != dirList.end(); ++j)
+        FreeFileSync::removeDirectory(*j, false); //call recursively to correctly handle symbolic links
+
+    //parent directory is deleted last
+#ifdef FFS_WIN
+    //initialize file attributes
+    if (!SetFileAttributes(
+                directory.c_str(),      // address of directory name
+                FILE_ATTRIBUTE_NORMAL)) // attributes to set
+    {
+        Zstring errorMessage = Zstring(_("Error deleting directory:")) + wxT("\n\"") + directory + wxT("\"");
+        throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+    }
+
+    //remove directory, support for \\?\-prefix
+    if (!RemoveDirectory(directory.c_str()))
+    {
+        Zstring errorMessage = Zstring(_("Error deleting directory:")) + wxT("\n\"") + directory + wxT("\"");
+        throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+    }
 #else
-        if (!wxRmdir(dirList[j].c_str()))
-            throw FileError(Zstring(_("Error deleting directory:")) + wxT("\n\"") + dirList[j] + wxT("\""));
+    if (rmdir(directory.c_str()) != 0)
+    {
+        Zstring errorMessage = Zstring(_("Error deleting directory:")) + wxT("\n\"") + directory + wxT("\"");
+        throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+    }
 #endif
+}
+
+
+#ifdef FFS_WIN
+class CloseHandleOnExit
+{
+public:
+    CloseHandleOnExit(HANDLE searchHandle) : m_searchHandle(searchHandle) {}
+
+    ~CloseHandleOnExit()
+    {
+        FindClose(m_searchHandle);
     }
+
+private:
+    HANDLE m_searchHandle;
+};
+
+
+typedef DWORD WINAPI (*GetFinalPath)(
+    HANDLE hFile,
+    LPTSTR lpszFilePath,
+    DWORD cchFilePath,
+    DWORD dwFlags);
+
+
+class DllHandler //dynamically load windows API functions
+{
+public:
+    DllHandler() :
+            getFinalPathNameByHandle(NULL),
+            hKernel(NULL)
+    {
+        //get a handle to the DLL module containing required functionality
+        hKernel = ::LoadLibrary(wxT("kernel32.dll"));
+        if (hKernel)
+            getFinalPathNameByHandle = (GetFinalPath)(::GetProcAddress(hKernel, "GetFinalPathNameByHandleW")); //load unicode version!
+    }
+
+    ~DllHandler()
+    {
+        if (hKernel) ::FreeLibrary(hKernel);
+    }
+
+    GetFinalPath getFinalPathNameByHandle;
+
+private:
+    HINSTANCE hKernel;
+};
+
+//global instance
+DllHandler dynamicWinApi;
+
+
+Zstring resolveDirectorySymlink(const Zstring& dirLinkName) //get full target path of symbolic link to a directory
+{
+    //open handle to target of symbolic link
+    HANDLE hDir = CreateFile(dirLinkName.c_str(),
+                             0,
+                             FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                             NULL,
+                             OPEN_EXISTING,
+                             FILE_FLAG_BACKUP_SEMANTICS,
+                             NULL);
+    if (hDir == INVALID_HANDLE_VALUE)
+        return Zstring();
+
+    CloseHandleOnExit dummy(hDir);
+
+    if (dynamicWinApi.getFinalPathNameByHandle == NULL )
+        throw FileError(Zstring(_("Error loading library function:")) + wxT("\n\"") + wxT("GetFinalPathNameByHandleW") + wxT("\""));
+
+    const unsigned BUFFER_SIZE = 10000;
+    TCHAR targetPath[BUFFER_SIZE];
+
+    const DWORD rv = dynamicWinApi.getFinalPathNameByHandle(
+                         hDir,
+                         targetPath,
+                         BUFFER_SIZE,
+                         0);
+
+    if (rv >= BUFFER_SIZE || rv == 0)
+        return Zstring();
+
+    return targetPath;
 }
+#endif
 
 
-void FreeFileSync::createDirectory(const Zstring& directory, const int level)
+void createDirectoryRecursively(const Zstring& directory, const Zstring& templateDir, const bool copyDirectorySymLinks, const int level)
 {
     if (wxDirExists(directory.c_str()))
         return;
@@ -165,193 +356,355 @@ void FreeFileSync::createDirectory(const Zstring& directory, const int level)
     if (level == 50) //catch endless recursion
         return;
 
-    //try to create directory, support for \\?\-prefix
-#ifdef FFS_WIN
-    if (CreateDirectory(
-                directory.c_str(),	// pointer to a directory path string
-                NULL               	// pointer to a security descriptor
-            ) != 0)
-        return;
-#else
-    if (wxMkdir(directory.c_str())) //wxMkDir has different signature under Linux!
-        return;
-#endif
-
-    //if not successfull try to create parent folders first
-    Zstring parentDir;
-    if (endsWithPathSeparator(directory)) //may be valid on first level of recursion at most! Usually never true!
+    //try to create parent folders first
+    const Zstring dirParent = directory.BeforeLast(GlobalResources::FILE_NAME_SEPARATOR);
+    if (!dirParent.empty() && !wxDirExists(dirParent))
     {
-        parentDir = directory.BeforeLast(GlobalResources::FILE_NAME_SEPARATOR);
-        parentDir = parentDir.BeforeLast(GlobalResources::FILE_NAME_SEPARATOR);
+        //call function recursively
+        const Zstring templateParent = templateDir.BeforeLast(GlobalResources::FILE_NAME_SEPARATOR);
+        createDirectoryRecursively(dirParent, templateParent, false, level + 1); //don't create symbolic links in recursion!
     }
-    else
-        parentDir = directory.BeforeLast(GlobalResources::FILE_NAME_SEPARATOR);
-
-    if (parentDir.empty()) return;
-
-    //call function recursively
-    createDirectory(parentDir, level + 1);
 
     //now creation should be possible
 #ifdef FFS_WIN
-    if (CreateDirectory(
-                directory.c_str(), // pointer to a directory path string
-                NULL 	           // pointer to a security descriptor
-            ) == 0)
+    const DWORD templateAttr = ::GetFileAttributes(templateDir.c_str()); //replaces wxDirExists(): also returns successful for broken symlinks
+    if (templateAttr == INVALID_FILE_ATTRIBUTES) //fallback
     {
-        if (level == 0)
+        if (CreateDirectory(
+                    directory.c_str(), // pointer to a directory path string
+                    NULL) == 0 && level == 0)
         {
-            Zstring errorMessage = Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\"");
+            const Zstring errorMessage = Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\"");
             throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
         }
     }
-#else
-    if (!wxMkdir(directory.c_str())) //wxMkDir has different signature under Linux!
+    else
     {
-        if (level == 0)
-            throw FileError(Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\""));
+        //symbolic link handling
+        if (!copyDirectorySymLinks && templateAttr & FILE_ATTRIBUTE_REPARSE_POINT) //create directory based on target of symbolic link
+        {
+            //get target directory of symbolic link
+            const Zstring targetPath = resolveDirectorySymlink(templateDir);
+            if (targetPath.empty())
+            {
+                if (level == 0)
+                    throw FileError(Zstring(_("Error resolving symbolic link:")) + wxT("\n\"") + templateDir + wxT("\""));
+            }
+            else
+            {
+                if (CreateDirectoryEx(          // this function automatically copies symbolic links if encountered
+                            targetPath.c_str(), // pointer to path string of template directory
+                            directory.c_str(),	// pointer to a directory path string
+                            NULL) == 0 && level == 0)
+                {
+                    const Zstring errorMessage = Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\"");
+                    throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+                }
+            }
+        }
+        else //in all other cases
+        {
+            if (CreateDirectoryEx(           // this function automatically copies symbolic links if encountered
+                        templateDir.c_str(), // pointer to path string of template directory
+                        directory.c_str(),	 // pointer to a directory path string
+                        NULL) == 0 && level == 0)
+            {
+                const Zstring errorMessage = Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\"");
+                throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+            }
+        }
     }
-#endif
-}
-
-
-void FreeFileSync::copyFolderAttributes(const Zstring& source, const Zstring& target)
-{
-#ifdef FFS_WIN
-    DWORD attr = GetFileAttributes(source.c_str()); // address of the name of a file or directory
-    if (attr ==  0xFFFFFFFF)
+#elif defined FFS_LINUX
+    //symbolic link handling
+    if (copyDirectorySymLinks)
     {
-        Zstring errorMessage = Zstring(_("Error reading folder attributes:")) + wxT("\n\"") + source + wxT("\"");
-        throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+        //test if templateDir is a symbolic link
+        struct stat linkInfo;
+        if (lstat(templateDir.c_str(), &linkInfo) == 0 && S_ISLNK(linkInfo.st_mode))
+        {
+            //copy symbolic link
+            const int BUFFER_SIZE = 10000;
+            char buffer[BUFFER_SIZE];
+            const int bytesWritten = readlink(templateDir.c_str(), buffer, BUFFER_SIZE);
+            if (bytesWritten < 0 || bytesWritten == BUFFER_SIZE)
+            {
+                Zstring errorMessage = Zstring(_("Error resolving symbolic link:")) + wxT("\n\"") + templateDir + wxT("\"");
+                if (bytesWritten < 0) errorMessage += Zstring(wxT("\n\n")) + FreeFileSync::getLastErrorFormatted();
+                throw FileError(errorMessage);
+            }
+            //set null-terminating char
+            buffer[bytesWritten] = 0;
+
+            if (symlink(buffer, directory.c_str()) != 0)
+            {
+                Zstring errorMessage = Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\"");
+                throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+            }
+            return; //symlink created successfully
+        }
     }
 
-    if (!SetFileAttributes(
-                target.c_str(), // address of filename
-                attr))          // address of attributes to set
+    //default directory creation
+    if (mkdir(directory.c_str(), 0755) != 0 && level == 0)
     {
-        Zstring errorMessage = Zstring(_("Error writing folder attributes:")) + wxT("\n\"") + target + wxT("\"");
+        Zstring errorMessage = Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\"");
         throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
     }
-#elif defined FFS_LINUX
-//Linux doesn't use attributes for files or folders
+
+//copy directory permissions: not sure if this is a good idea: if a directory is read-only copying/sync'ing of files will fail...
+    /*
+        if (templateDirExists)
+        {
+            struct stat fileInfo;
+            if (stat(templateDir.c_str(), &fileInfo) != 0) //read permissions from template directory
+                throw FileError(Zstring(_("Error reading file attributes:")) + wxT("\n\"") + templateDir + wxT("\""));
+
+            // reset the umask as we want to create the directory with exactly the same permissions as the template
+            wxCHANGE_UMASK(0);
+
+            if (mkdir(directory.c_str(), fileInfo.st_mode) != 0 && level == 0)
+                throw FileError(Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\""));
+        }
+        else
+        {
+            if (mkdir(directory.c_str(), 0777) != 0 && level == 0)
+                throw FileError(Zstring(_("Error creating directory:")) + wxT("\n\"") + directory + wxT("\""));
+        }
+    */
 #endif
 }
 
 
-class FilesDirsOnlyTraverser : public FreeFileSync::FullDetailFileTraverser
+void FreeFileSync::createDirectory(const Zstring& directory, const Zstring& templateDir, const bool copyDirectorySymLinks)
 {
-public:
-    FilesDirsOnlyTraverser(std::vector<Zstring>& files, std::vector<Zstring>& dirs) :
-            m_files(files),
-            m_dirs(dirs) {}
+    //remove trailing separator
+    Zstring dirFormatted;
+    if (FreeFileSync::endsWithPathSeparator(directory))
+        dirFormatted = directory.BeforeLast(GlobalResources::FILE_NAME_SEPARATOR);
+    else
+        dirFormatted = directory;
 
-    virtual wxDirTraverseResult OnFile(const Zstring& filename, const FreeFileSync::FileInfo& details)
-    {
-        m_files.push_back(filename);
-        return wxDIR_CONTINUE;
-    }
-    virtual wxDirTraverseResult OnDir(const Zstring& dirname)
+    Zstring templateFormatted;
+    if (FreeFileSync::endsWithPathSeparator(templateDir))
+        templateFormatted = templateDir.BeforeLast(GlobalResources::FILE_NAME_SEPARATOR);
+    else
+        templateFormatted = templateDir;
+
+    createDirectoryRecursively(dirFormatted, templateFormatted, copyDirectorySymLinks, 0);
+}
+
+
+#ifdef FFS_LINUX
+struct MemoryAllocator
+{
+    MemoryAllocator()
     {
-        m_dirs.push_back(dirname);
-        return wxDIR_CONTINUE;
+        buffer = new char[bufferSize];
     }
-    virtual wxDirTraverseResult OnError(const Zstring& errorText)
+
+    ~MemoryAllocator()
     {
-        throw FileError(errorText);
+        delete [] buffer;
     }
 
-private:
-    std::vector<Zstring>& m_files;
-    std::vector<Zstring>& m_dirs;
+    static const unsigned int bufferSize = 512 * 1024;
+    char* buffer;
 };
 
 
-void FreeFileSync::getAllFilesAndDirs(const Zstring& sourceDir, std::vector<Zstring>& files, std::vector<Zstring>& directories) throw(FileError)
+void FreeFileSync::copyFile(const Zstring& sourceFile,
+                            const Zstring& targetFile,
+                            const bool copyFileSymLinks,
+                            CopyFileCallback callback,
+                            void* data)
 {
-    files.clear();
-    directories.clear();
+    try
+    {
+        if (FreeFileSync::fileExists(targetFile.c_str()))
+            throw FileError(Zstring(_("Error copying file:")) + wxT("\n\"") + sourceFile +  wxT("\" -> \"") + targetFile + wxT("\"\n")
+                            + _("Target file already existing!"));
 
-    //get all files and directories from current directory (and subdirectories)
-    FilesDirsOnlyTraverser traverser(files, directories);
-    traverseInDetail(sourceDir, false, &traverser);
-}
+        //symbolic link handling
+        if (copyFileSymLinks)
+        {
+            //test if sourceFile is a symbolic link
+            struct stat linkInfo;
+            if (lstat(sourceFile.c_str(), &linkInfo) != 0)
+            {
+                Zstring errorMessage = Zstring(_("Error reading file attributes:")) + wxT("\n\"") + sourceFile + wxT("\"");
+                throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+            }
 
+            if (S_ISLNK(linkInfo.st_mode))
+            {
+                //copy symbolic link
+                const unsigned BUFFER_SIZE = 10000;
+                char buffer[BUFFER_SIZE];
+                const int bytesWritten = readlink(sourceFile.c_str(), buffer, BUFFER_SIZE - 1);
+                if (bytesWritten < 0)
+                {
+                    Zstring errorMessage = Zstring(_("Error resolving symbolic link:")) + wxT("\n\"") + sourceFile + wxT("\"");
+                    throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+                }
+                //set null-terminating char
+                buffer[bytesWritten] = 0;
 
-#ifdef FFS_WIN
-class CloseOnExit
-{
-public:
-    CloseOnExit(HANDLE searchHandle) : m_searchHandle(searchHandle) {}
+                if (symlink(buffer, targetFile.c_str()) != 0)
+                {
+                    Zstring errorMessage = Zstring(_("Error writing file:")) + wxT("\n\"") + targetFile + wxT("\"");
+                    throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+                }
 
-    ~CloseOnExit()
-    {
-        FindClose(m_searchHandle);
+                return; //symlink created successfully
+            }
+        }
+
+        //begin of regular file copy
+        struct stat fileInfo;
+        if (stat(sourceFile.c_str(), &fileInfo) != 0) //read file attributes from source file (resolve symlinks)
+        {
+            Zstring errorMessage = Zstring(_("Error reading file attributes:")) + wxT("\n\"") + sourceFile + wxT("\"");
+            throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+        }
+
+        //open sourceFile for reading
+        std::ifstream fileIn(sourceFile.c_str(), std::ios_base::binary);
+        if (fileIn.fail())
+            throw FileError(Zstring(_("Error opening file:")) + wxT("\n\"") + sourceFile +  wxT("\""));
+
+        //create targetFile and open it for writing
+        std::ofstream fileOut(targetFile.c_str(), std::ios_base::binary);
+        if (fileOut.fail())
+            throw FileError(Zstring(_("Error opening file:")) + wxT("\n\"") + targetFile + wxT("\""));
+
+        //copy contents of sourceFile to targetFile
+        wxULongLong totalBytesTransferred;
+        static MemoryAllocator memory;
+        while (true)
+        {
+            fileIn.read(memory.buffer, memory.bufferSize);
+            if (fileIn.eof())  //end of file? fail bit is set in this case also!
+            {
+                fileOut.write(memory.buffer, fileIn.gcount());
+                if (fileOut.bad())
+                    throw FileError(Zstring(_("Error writing file:")) + wxT("\n\"") + targetFile + wxT("\""));
+                break;
+            }
+            else if (fileIn.fail())
+                throw FileError(Zstring(_("Error reading file:")) + wxT("\n\"") + sourceFile + wxT("\""));
+
+
+            fileOut.write(memory.buffer, memory.bufferSize);
+            if (fileOut.bad())
+                throw FileError(Zstring(_("Error writing file:")) + wxT("\n\"") + targetFile + wxT("\""));
+
+            totalBytesTransferred += memory.bufferSize;
+
+            //invoke callback method to update progress indicators
+            if (callback)
+                callback(totalBytesTransferred, data);
+        }
+
+        //close streams before changing attributes
+        fileIn.close();
+        fileOut.close();
+
+        //adapt file modification time:
+        struct utimbuf newTimes;
+        time(&newTimes.actime); //set file access time to current time
+        newTimes.modtime = fileInfo.st_mtime;
+        if (utime(targetFile.c_str(), &newTimes) != 0)
+        {
+            Zstring errorMessage = Zstring(_("Error changing modification time:")) + wxT("\n\"") + targetFile + wxT("\"");
+            throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+        }
+
+        //set file access rights
+        if (chmod(targetFile.c_str(), fileInfo.st_mode) != 0)
+        {
+            Zstring errorMessage = Zstring(_("Error writing file attributes:")) + wxT("\n\"") + targetFile + wxT("\"");
+            throw FileError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted());
+        }
     }
+    catch (...)
+    {   //try to delete target file if error occured, or exception was thrown in callback function
+        if (FreeFileSync::fileExists(targetFile.c_str()))
+            wxRemoveFile(targetFile.c_str()); //don't handle error situations!
 
-private:
-    HANDLE m_searchHandle;
-};
+        throw;
+    }
+}
+#endif
 
 
+#ifdef FFS_WIN
 inline
-void getWin32FileInformation(const WIN32_FIND_DATA& input, FreeFileSync::FileInfo& output)
+void setWin32FileInformation(const FILETIME& lastWriteTime, const DWORD fileSizeHigh, const DWORD fileSizeLow, FreeFileSync::FileInfo& output)
 {
     //convert UTC FILETIME to ANSI C format (number of seconds since Jan. 1st 1970 UTC)
-    wxULongLong writeTimeLong(input.ftLastWriteTime.dwHighDateTime, input.ftLastWriteTime.dwLowDateTime);
+    wxLongLong writeTimeLong(lastWriteTime.dwHighDateTime, lastWriteTime.dwLowDateTime);
     writeTimeLong /= 10000000;                     //reduce precision to 1 second (FILETIME has unit 10^-7 s)
-    writeTimeLong -= wxULongLong(2, 3054539008UL); //timeshift between ansi C time and FILETIME in seconds == 11644473600s
-    assert(writeTimeLong.GetHi() == 0);            //it should fit into a 32bit variable now
-    output.lastWriteTimeRaw = writeTimeLong.GetLo();
+    writeTimeLong -= wxLongLong(2, 3054539008UL); //timeshift between ansi C time and FILETIME in seconds == 11644473600s
+    output.lastWriteTimeRaw = writeTimeLong;
 
-    output.fileSize = wxULongLong(input.nFileSizeHigh, input.nFileSizeLow);
+    output.fileSize = wxULongLong(fileSizeHigh, fileSizeLow);
 }
 
-#elif defined FFS_LINUX
-class EnhancedFileTraverser : public wxDirTraverser
+inline
+bool setWin32FileInformationFromSymlink(const Zstring linkName, FreeFileSync::FileInfo& output)
 {
-public:
-    EnhancedFileTraverser(FreeFileSync::FullDetailFileTraverser* sink) : m_sink(sink) {}
+    //open handle to target of symbolic link
+    HANDLE hFile = CreateFile(linkName.c_str(),
+                              0,
+                              FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                              NULL,
+                              OPEN_EXISTING,
+                              FILE_FLAG_BACKUP_SEMANTICS,
+                              NULL);
+    if (hFile == INVALID_HANDLE_VALUE)
+        return false;
 
-    wxDirTraverseResult OnFile(const wxString& filename) //virtual impl.
-    {
-        struct stat fileInfo;
-        if (stat(filename.c_str(), &fileInfo) != 0)
-            return m_sink->OnError(Zstring(_("Could not retrieve file info for:")) + wxT("\n\"") + filename.c_str() + wxT("\""));
+    CloseHandleOnExit dummy(hFile);
 
-        FreeFileSync::FileInfo details;
-        details.lastWriteTimeRaw = fileInfo.st_mtime; //UTC time(ANSI C format); unit: 1 second
-        details.fileSize         = fileInfo.st_size;
+    BY_HANDLE_FILE_INFORMATION fileInfoByHandle;
 
-        return m_sink->OnFile(filename.c_str(), details);
-    }
+    if (!GetFileInformationByHandle(
+                hFile,
+                &fileInfoByHandle))
+        return false;
 
-    wxDirTraverseResult OnDir(const wxString& dirname) //virtual impl.
-    {
-        return m_sink->OnDir(dirname.c_str());
-    }
+    //write output
+    setWin32FileInformation(fileInfoByHandle.ftLastWriteTime, fileInfoByHandle.nFileSizeHigh, fileInfoByHandle.nFileSizeLow, output);
+
+    return true;
+}
+
+#elif defined FFS_LINUX
+class CloseDirOnExit
+{
+public:
+    CloseDirOnExit(DIR* dir) : m_dir(dir) {}
 
-    wxDirTraverseResult OnOpenError(const wxString& errorText) //virtual impl.
+    ~CloseDirOnExit()
     {
-        return m_sink->OnError(errorText.c_str());
+        closedir(m_dir); //no error handling here
     }
 
 private:
-    FreeFileSync::FullDetailFileTraverser* m_sink;
+    DIR* m_dir;
 };
 #endif
 
 
+template <bool traverseDirectorySymlinks>
 class TraverseRecursively
 {
 public:
-    TraverseRecursively(const bool traverseSymbolicLinks, FreeFileSync::FullDetailFileTraverser* sink) :
-            m_traverseSymbolicLinks(traverseSymbolicLinks),
-            m_sink(sink) {}
+    TraverseRecursively(FreeFileSync::FullDetailFileTraverser* sink) : m_sink(sink) {}
 
     bool traverse(const Zstring& directory, const int level)
     {
-#ifdef FFS_WIN
-        if (level == 50) //catch endless recursion
+        if (level == 100) //catch endless recursion
         {
             if (m_sink->OnError(Zstring(_("Error traversing directory:")) + wxT("\n\"") + directory + wxT("\"")) == wxDIR_STOP)
                 return false;
@@ -359,6 +712,7 @@ public:
                 return true;
         }
 
+#ifdef FFS_WIN
         Zstring directoryFormatted = directory;
         if (!FreeFileSync::endsWithPathSeparator(directoryFormatted))
             directoryFormatted += GlobalResources::FILE_NAME_SEPARATOR;
@@ -376,13 +730,13 @@ public:
                 return true;
 
             //else: we have a problem... report it:
-            Zstring errorMessage = Zstring(_("Error traversing directory:")) + wxT("\n\"") + directory + wxT("\" ") ;
+            Zstring errorMessage = Zstring(_("Error traversing directory:")) + wxT("\n\"") + directory + wxT("\"") ;
             if (m_sink->OnError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(lastError)) == wxDIR_STOP)
                 return false;
             else
                 return true;
         }
-        CloseOnExit dummy(searchHandle);
+        CloseHandleOnExit dummy(searchHandle);
 
         do
         {   //don't return "." and ".."
@@ -394,7 +748,7 @@ public:
 
             const Zstring fullName = directoryFormatted + name;
 
-            if (fileMetaData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) //a directory...
+            if (fileMetaData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) //a directory... (for directory symlinks this flag is set too!)
             {
                 switch (m_sink->OnDir(fullName))
                 {
@@ -402,7 +756,7 @@ public:
                     break;
                 case wxDIR_CONTINUE:
                     //traverse into symbolic links, junctions, etc. if requested only:
-                    if (m_traverseSymbolicLinks || (~fileMetaData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
+                    if (traverseDirectorySymlinks || (~fileMetaData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
                         if (!this->traverse(fullName, level + 1))
                             return false;
                     break;
@@ -410,25 +764,25 @@ public:
                     return false;
                 default:
                     assert(false);
-                    break;
                 }
             }
             else //a file...
             {
                 FreeFileSync::FileInfo details;
-                getWin32FileInformation(fileMetaData, details);
 
-                switch (m_sink->OnFile(fullName, details))
+                if (fileMetaData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) //dereference symlinks!
                 {
-                case wxDIR_IGNORE:
-                case wxDIR_CONTINUE:
-                    break;
-                case wxDIR_STOP:
-                    return false;
-                default:
-                    assert(false);
-                    break;
+                    if (!setWin32FileInformationFromSymlink(fullName, details)) //broken symlink
+                    {
+                        details.lastWriteTimeRaw = 0; //we are not interested in the modifiation time of the link
+                        details.fileSize         = 0;
+                    }
                 }
+                else
+                    setWin32FileInformation(fileMetaData.ftLastWriteTime, fileMetaData.nFileSizeHigh, fileMetaData.nFileSizeLow, details);
+
+                if (m_sink->OnFile(fullName, details) == wxDIR_STOP)
+                    return false;
             }
         }
         while (FindNextFile(searchHandle,	 // handle to search
@@ -439,42 +793,131 @@ public:
             return true; //everything okay
 
         //else: we have a problem... report it:
-        Zstring errorMessage = Zstring(_("Error traversing directory:")) + wxT("\n\"") + directory + wxT("\" ") ;
+        Zstring errorMessage = Zstring(_("Error traversing directory:")) + wxT("\n\"") + directory + wxT("\"") ;
         if (m_sink->OnError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted(lastError)) == wxDIR_STOP)
             return false;
         else
             return true;
+
 #elif defined FFS_LINUX
+        Zstring directoryFormatted = directory;
+        if (FreeFileSync::endsWithPathSeparator(directoryFormatted))
+            directoryFormatted = directoryFormatted.BeforeLast(GlobalResources::FILE_NAME_SEPARATOR);
 
-        //use standard file traverser and enrich output with additional file information
-        //could be improved with custom traversing algorithm for optimized performance
-        EnhancedFileTraverser traverser(m_sink);
+        DIR* dirObj = opendir(directoryFormatted.c_str());
+        if (dirObj == NULL)
+        {
+            Zstring errorMessage = Zstring(_("Error traversing directory:")) + wxT("\n\"") + directoryFormatted + wxT("\"") ;
+            if (m_sink->OnError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()) == wxDIR_STOP)
+                return false;
+            else
+                return true;
+        }
+        CloseDirOnExit dummy(dirObj);
 
-        wxDir dir(directory.c_str());
-        if (dir.IsOpened())
-            dir.Traverse(traverser);
+        struct dirent* dirEntry;
+        while (!(errno = 0) && (dirEntry = readdir(dirObj)) != NULL) //set errno to 0 as unfortunately this isn't done when readdir() returns NULL when it is finished
+        {
+            //don't return "." and ".."
+            const wxChar* name = dirEntry->d_name;
+            if (      name[0] == wxChar('.') &&
+                      ((name[1] == wxChar('.') && name[2] == wxChar('\0')) ||
+                       name[1] == wxChar('\0')))
+                continue;
 
-        return true;
-#else
-        adapt this
+            const Zstring fullName = directoryFormatted + GlobalResources::FILE_NAME_SEPARATOR + name;
+
+            struct stat fileInfo;
+            if (lstat(fullName.c_str(), &fileInfo) != 0) //lstat() does not resolve symlinks
+            {
+                const Zstring errorMessage = Zstring(_("Error reading file attributes:")) + wxT("\n\"") + fullName + wxT("\"");
+                if (m_sink->OnError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()) == wxDIR_STOP)
+                    return false;
+                continue;
+            }
+
+            const bool isSymbolicLink = S_ISLNK(fileInfo.st_mode);
+            if (isSymbolicLink) //dereference symbolic links
+            {
+                if (stat(fullName.c_str(), &fileInfo) != 0) //stat() resolves symlinks
+                {
+                    //a broken symbolic link
+                    FreeFileSync::FileInfo details;
+                    details.lastWriteTimeRaw = 0; //we are not interested in the modifiation time of the link
+                    details.fileSize         = 0;
+
+                    if (m_sink->OnFile(fullName, details) == wxDIR_STOP)
+                        return false;
+                    continue;
+                }
+            }
+
+
+            if (S_ISDIR(fileInfo.st_mode)) //a directory... (note: symbolic links need to be dereferenced to test if they point to a directory!)
+            {
+                switch (m_sink->OnDir(fullName))
+                {
+                case wxDIR_IGNORE:
+                    break;
+                case wxDIR_CONTINUE:
+                    if (traverseDirectorySymlinks || !isSymbolicLink) //traverse into symbolic links if requested only
+                    {
+                        if (!this->traverse(fullName, level + 1))
+                            return false;
+                    }
+                    break;
+                case wxDIR_STOP:
+                    return false;
+                default:
+                    assert(false);
+                }
+            }
+            else //a file...
+            {
+                FreeFileSync::FileInfo details;
+                details.lastWriteTimeRaw = fileInfo.st_mtime; //UTC time(ANSI C format); unit: 1 second
+                details.fileSize         = fileInfo.st_size;
+
+                if (m_sink->OnFile(fullName, details) == wxDIR_STOP)
+                    return false;
+            }
+        }
+
+        if (errno == 0)
+            return true; //everything okay
+
+        //else: we have a problem... report it:
+        const Zstring errorMessage = Zstring(_("Error traversing directory:")) + wxT("\n\"") + directoryFormatted + wxT("\"") ;
+        if (m_sink->OnError(errorMessage + wxT("\n\n") + FreeFileSync::getLastErrorFormatted()) == wxDIR_STOP)
+            return false;
+        else
+            return true;
 #endif
     }
 
 private:
-    const bool m_traverseSymbolicLinks;
     FreeFileSync::FullDetailFileTraverser* m_sink;
 };
 
 
 void FreeFileSync::traverseInDetail(const Zstring& directory,
-                                    const bool traverseSymbolicLinks,
+                                    const bool traverseDirectorySymlinks,
                                     FullDetailFileTraverser* sink)
 {
-    TraverseRecursively filewalker(traverseSymbolicLinks, sink);
-    filewalker.traverse(directory, 0);
+    if (traverseDirectorySymlinks)
+    {
+        TraverseRecursively<true> filewalker(sink);
+        filewalker.traverse(directory, 0);
+    }
+    else
+    {
+        TraverseRecursively<false> filewalker(sink);
+        filewalker.traverse(directory, 0);
+    }
 }
 
 
+/*
 #ifdef FFS_WIN
 inline
 Zstring getDriveName(const Zstring& directoryName) //GetVolume() doesn't work under Linux!
@@ -500,3 +943,4 @@ bool FreeFileSync::isFatDrive(const Zstring& directoryName)
     return Zstring(fileSystem).StartsWith(wxT("FAT"));
 }
 #endif  //FFS_WIN
+*/