detect NTFS file system type to avoid permissions check

NTFS file system on Linux reports wrong permissions

client believes they need to be fixed but as they cannot, we end-up
having an infinite loop

Signed-off-by: Matthieu Gallien <[email protected]>

Author: mgallien

src/csync/vio/csync_vio_local.h

@@ -18,8 +18,8 @@ class Vfs;
 
 csync_vio_handle_t OCSYNC_EXPORT *csync_vio_local_opendir(const QString &name);
 int OCSYNC_EXPORT csync_vio_local_closedir(csync_vio_handle_t *dhandle);
-std::unique_ptr<csync_file_stat_t> OCSYNC_EXPORT csync_vio_local_readdir(csync_vio_handle_t *dhandle, OCC::Vfs *vfs);
+std::unique_ptr<csync_file_stat_t> OCSYNC_EXPORT csync_vio_local_readdir(csync_vio_handle_t *dhandle, OCC::Vfs *vfs, bool checkPermissionsValidity);
 
-int OCSYNC_EXPORT csync_vio_local_stat(const QString &uri, csync_file_stat_t *buf);
+int OCSYNC_EXPORT csync_vio_local_stat(const QString &uri, csync_file_stat_t *buf, bool checkPermissionsValidity);
 
 #endif /* _CSYNC_VIO_LOCAL_H */

src/csync/vio/csync_vio_local_unix.cpp

@@ -23,8 +23,8 @@
 #include "vio/csync_vio_local.h"
 #include "common/vfs.h"
 
-#include <QtCore/QLoggingCategory>
-#include <QtCore/QFile>
+#include <QLoggingCategory>
+#include <QFile>
 
 Q_LOGGING_CATEGORY(lcCSyncVIOLocal, "nextcloud.sync.csync.vio_local", QtInfoMsg)
 
@@ -37,7 +37,7 @@ struct csync_vio_handle_t {
   QByteArray path;
 };
 
-static int _csync_vio_local_stat_mb(const mbchar_t *wuri, csync_file_stat_t *buf);
+static int _csync_vio_local_stat_mb(const mbchar_t *wuri, csync_file_stat_t *buf, bool checkPermissionsValidity);
 
 csync_vio_handle_t *csync_vio_local_opendir(const QString &name) {
     auto handle = std::make_unique<csync_vio_handle_t>();
@@ -59,7 +59,7 @@ int csync_vio_local_closedir(csync_vio_handle_t *dhandle) {
     return rc;
 }
 
-std::unique_ptr<csync_file_stat_t> csync_vio_local_readdir(csync_vio_handle_t *handle, OCC::Vfs *vfs) {
+std::unique_ptr<csync_file_stat_t> csync_vio_local_readdir(csync_vio_handle_t *handle, OCC::Vfs *vfs, bool checkPermissionsValidity) {
 
   struct _tdirent *dirent = nullptr;
   std::unique_ptr<csync_file_stat_t> file_stat;
@@ -102,7 +102,7 @@ std::unique_ptr<csync_file_stat_t> csync_vio_local_readdir(csync_vio_handle_t *h
   if (file_stat->path.isNull())
       return file_stat;
 
-  if (_csync_vio_local_stat_mb(fullPath.constData(), file_stat.get()) < 0) {
+  if (_csync_vio_local_stat_mb(fullPath.constData(), file_stat.get(), checkPermissionsValidity) < 0) {
       // Will get excluded by _csync_detect_update.
       file_stat->type = ItemTypeSkip;
   }
@@ -119,12 +119,12 @@ std::unique_ptr<csync_file_stat_t> csync_vio_local_readdir(csync_vio_handle_t *h
 }
 
 
-int csync_vio_local_stat(const QString &uri, csync_file_stat_t *buf)
+int csync_vio_local_stat(const QString &uri, csync_file_stat_t *buf, bool checkPermissionsValidity)
 {
-    return _csync_vio_local_stat_mb(QFile::encodeName(uri).constData(), buf);
+    return _csync_vio_local_stat_mb(QFile::encodeName(uri).constData(), buf, checkPermissionsValidity);
 }
 
-static int _csync_vio_local_stat_mb(const mbchar_t *wuri, csync_file_stat_t *buf)
+static int _csync_vio_local_stat_mb(const mbchar_t *wuri, csync_file_stat_t *buf, bool checkPermissionsValidity)
 {
     csync_stat_t sb;
 
@@ -157,6 +157,9 @@ static int _csync_vio_local_stat_mb(const mbchar_t *wuri, csync_file_stat_t *buf
   buf->inode = sb.st_ino;
   buf->modtime = sb.st_mtime;
   buf->size = sb.st_size;
+  if (checkPermissionsValidity) {
+      buf->isPermissionsInvalid = (sb.st_mode & S_IWOTH) == S_IWOTH;
+  }
 
   return 0;
 }

src/libsync/discovery.cpp

@@ -1005,7 +1005,7 @@ void ProcessDirectoryJob::processFileAnalyzeRemoteInfo(const SyncFileItemPtr &it
 
         if (!base.isDirectory()) {
             csync_file_stat_t buf;
-            if (csync_vio_local_stat(_discoveryData->_localDir + originalPathAdjusted, &buf)) {
+            if (csync_vio_local_stat(_discoveryData->_localDir + originalPathAdjusted, &buf, true)) {
                 qCInfo(lcDisco) << "Local file does not exist anymore." << originalPathAdjusted;
                 return;
             }
@@ -2331,7 +2331,7 @@ void ProcessDirectoryJob::setFolderQuota(const FolderQuota &folderQuota)
 void ProcessDirectoryJob::startAsyncLocalQuery()
 {
     QString localPath = _discoveryData->_localDir + _currentFolder._local;
-    auto localJob = new DiscoverySingleLocalDirectoryJob(_discoveryData->_account, localPath, _discoveryData->_syncOptions._vfs.data());
+    auto localJob = new DiscoverySingleLocalDirectoryJob(_discoveryData->_account, localPath, _discoveryData->_syncOptions._vfs.data(), _discoveryData->_fileSystemReliablePermissions);
 
     _discoveryData->_currentlyActiveJobs++;
     _pendingAsyncJobs++;

src/libsync/discoveryphase.cpp

@@ -302,8 +302,17 @@ void DiscoveryPhase::slotItemDiscovered(const OCC::SyncFileItemPtr &item)
     }
 }
 
-DiscoverySingleLocalDirectoryJob::DiscoverySingleLocalDirectoryJob(const AccountPtr &account, const QString &localPath, OCC::Vfs *vfs, QObject *parent)
- : QObject(parent), QRunnable(), _localPath(localPath), _account(account), _vfs(vfs)
+DiscoverySingleLocalDirectoryJob::DiscoverySingleLocalDirectoryJob(const AccountPtr &account,
+                                                                   const QString &localPath,
+                                                                   OCC::Vfs *vfs,
+                                                                   bool fileSystemReliablePermissions,
+                                                                   QObject *parent)
+    : QObject{parent}
+    , QRunnable{}
+    , _localPath{localPath}
+    , _account{account}
+    , _vfs{vfs}
+    , _fileSystemReliablePermissions{fileSystemReliablePermissions}
 {
     qRegisterMetaType<QVector<OCC::LocalInfo> >("QVector<OCC::LocalInfo>");
 }
@@ -336,7 +345,7 @@ void DiscoverySingleLocalDirectoryJob::run() {
     QVector<LocalInfo> results;
     while (true) {
         errno = 0;
-        auto dirent = csync_vio_local_readdir(dh, _vfs);
+        auto dirent = csync_vio_local_readdir(dh, _vfs, _fileSystemReliablePermissions);
         if (!dirent)
             break;
         if (dirent->type == ItemTypeSkip)

src/libsync/discoveryphase.h

@@ -76,7 +76,11 @@ class DiscoverySingleLocalDirectoryJob : public QObject, public QRunnable
 {
     Q_OBJECT
 public:
-    explicit DiscoverySingleLocalDirectoryJob(const AccountPtr &account, const QString &localPath, OCC::Vfs *vfs, QObject *parent = nullptr);
+    explicit DiscoverySingleLocalDirectoryJob(const AccountPtr &account,
+                                              const QString &localPath,
+                                              OCC::Vfs *vfs,
+                                              bool fileSystemReliablePermissions,
+                                              QObject *parent = nullptr);
 
     void run() override;
 signals:
@@ -91,6 +95,7 @@ private slots:
     QString _localPath;
     AccountPtr _account;
     OCC::Vfs* _vfs;
+    bool _fileSystemReliablePermissions = false;
 public:
 };
 
@@ -315,6 +320,8 @@ class DiscoveryPhase : public QObject
 
     bool _noCaseConflictRecordsInDb = false;
 
+    bool _fileSystemReliablePermissions = false;
+
     QSet<QString> _topLevelE2eeFolderPaths;
 
 signals:

src/libsync/filesystem.cpp

@@ -176,7 +176,7 @@ time_t FileSystem::getModTime(const QString &filename)
 {
     csync_file_stat_t stat;
     time_t result = -1;
-    if (csync_vio_local_stat(filename, &stat) != -1 && (stat.modtime != 0)) {
+    if (csync_vio_local_stat(filename, &stat, true) != -1 && (stat.modtime != 0)) {
         result = stat.modtime;
     } else {
         result = Utility::qDateTimeToTime_t(QFileInfo(filename).lastModified());
@@ -337,7 +337,7 @@ bool FileSystem::removeRecursively(const QString &path, const std::function<void
 bool FileSystem::getInode(const QString &filename, quint64 *inode)
 {
     csync_file_stat_t fs;
-    if (csync_vio_local_stat(filename, &fs) == 0) {
+    if (csync_vio_local_stat(filename, &fs, true) == 0) {
         *inode = fs.inode;
         return true;
     }

src/libsync/syncengine.cpp

@@ -48,6 +48,7 @@
 #include <QProcess>
 #include <QElapsedTimer>
 #include <QFileInfo>
+#include <QStorageInfo>
 #include <qtextcodec.h>
 
 namespace OCC {
@@ -632,6 +633,19 @@ void SyncEngine::startSync()
     _remnantReadOnlyFolders.clear();
 
     _discoveryPhase = std::make_unique<DiscoveryPhase>();
+
+#if defined Q_OS_LINUX
+    const auto fileSystemInfo = QStorageInfo{_localPath};
+    qCInfo(lcEngine()) << "File system type for current sync folder:" << fileSystemInfo.fileSystemType();
+    if (fileSystemInfo.fileSystemType() == "NTFS") {
+        _discoveryPhase->_fileSystemReliablePermissions = false;
+    } else {
+        _discoveryPhase->_fileSystemReliablePermissions = true;
+    }
+#else
+    _discoveryPhase->_fileSystemReliablePermissions = true;
+#endif
+
     _discoveryPhase->_leadingAndTrailingSpacesFilesAllowed = _leadingAndTrailingSpacesFilesAllowed;
     _discoveryPhase->_account = _account;
     _discoveryPhase->_excludes = _excludedFiles.data();

test/csync/vio_tests/check_vio_ext.cpp

@@ -135,7 +135,7 @@ static void create_dirs( const char *path )
  * whole tree.
  *
  */
-static void traverse_dir(void **state, const QString &dir, int *cnt)
+static void traverse_dir(void **state, const QString &dir, int *cnt, bool checkPermissionsValidity)
 {
     csync_vio_handle_t *dh = nullptr;
     std::unique_ptr<csync_file_stat_t> dirent;
@@ -149,7 +149,7 @@ static void traverse_dir(void **state, const QString &dir, int *cnt)
     assert_non_null(dh);
 
     OCC::Vfs *vfs = nullptr;
-    while( (dirent = csync_vio_local_readdir(dh, vfs)) ) {
+    while( (dirent = csync_vio_local_readdir(dh, vfs, checkPermissionsValidity)) ) {
         assert_non_null(dirent.get());
         if (!dirent->original_path.isEmpty()) {
             sv->ignored_dir = dirent->original_path;
@@ -178,7 +178,7 @@ static void traverse_dir(void **state, const QString &dir, int *cnt)
         }
         output(subdir_out.constData());
         if( is_dir ) {
-            traverse_dir(state, QString::fromUtf8(subdir), cnt);
+            traverse_dir(state, QString::fromUtf8(subdir), cnt, checkPermissionsValidity);
         }
     }
 
@@ -198,11 +198,12 @@ static void check_readdir_shorttree(void **state)
 {
     auto sv = (statevar*) *state;
 
+    bool checkPermissionsValidity = true;
     const char *t1 = "alibaba/und/die/vierzig/räuber/";
     create_dirs( t1 );
     int files_cnt = 0;
 
-    traverse_dir(state, CSYNC_TEST_DIR, &files_cnt);
+    traverse_dir(state, CSYNC_TEST_DIR, &files_cnt, checkPermissionsValidity);
 
     assert_string_equal(sv->result.constData(),
         QString::fromUtf8("<DIR> %1/alibaba"
@@ -221,14 +222,15 @@ static void check_readdir_with_content(void **state)
     auto sv = (statevar*) *state;
     int files_cnt = 0;
 
+    bool checkPermissionsValidity = true;
     const char *t1 = "warum/nur/40/Räuber/";
     create_dirs( t1 );
 
     create_file( t1, "Räuber Max.txt", "Der Max ist ein schlimmer finger");
     create_file( t1, "пя́тница.txt", "Am Freitag tanzt der Ürk");
 
 
-    traverse_dir(state, CSYNC_TEST_DIR, &files_cnt);
+    traverse_dir(state, CSYNC_TEST_DIR, &files_cnt, checkPermissionsValidity);
 
     assert_string_equal(sv->result.constData(),
         QString::fromUtf8("<DIR> %1/warum"
@@ -247,6 +249,8 @@ static void check_readdir_longtree(void **state)
 {
     auto sv = (statevar*) *state;
 
+    bool checkPermissionsValidity = true;
+
     /* Strange things here: Compilers only support strings with length of 4k max.
      * The expected result string is longer, so it needs to be split up in r1, r2 and r3
      */
@@ -306,7 +310,7 @@ static void check_readdir_longtree(void **state)
     /* assemble the result string ... */
     const auto result = (r1 + r2 + r3).toUtf8();
     int files_cnt = 0;
-    traverse_dir(state, CSYNC_TEST_DIR, &files_cnt);
+    traverse_dir(state, CSYNC_TEST_DIR, &files_cnt, checkPermissionsValidity);
     assert_int_equal(files_cnt, 0);
     /* and compare. */
     assert_string_equal(sv->result.constData(), result.constData());
@@ -321,6 +325,7 @@ static void check_readdir_bigunicode(void **state)
 //    3: ? ASCII: 191 - BF
 //    4: ASCII: 32    - 20
 
+    bool checkPermissionsValidity = true;
     QString p = QStringLiteral("%1/%2").arg(CSYNC_TEST_DIR, QStringLiteral("goodone/"));
     int rc = oc_mkdir(p);
     assert_int_equal(rc, 0);
@@ -332,7 +337,7 @@ static void check_readdir_bigunicode(void **state)
     assert_int_equal(rc, 0);
 
     int files_cnt = 0;
-    traverse_dir(state, CSYNC_TEST_DIR, &files_cnt);
+    traverse_dir(state, CSYNC_TEST_DIR, &files_cnt, checkPermissionsValidity);
     const auto expected_result = QStringLiteral("<DIR> %1/goodone"
                                                 "<DIR> %1/goodone/ugly\xEF\xBB\xBF\x32.txt")
                                      .arg(CSYNC_TEST_DIR);

test/testlongpath.cpp

@@ -128,7 +128,7 @@ private Q_SLOTS:
         file.close();
 
         csync_file_stat_t buf;
-        QVERIFY(csync_vio_local_stat(longPath.filePath(), &buf) != -1);
+        QVERIFY(csync_vio_local_stat(longPath.filePath(), &buf, true) != -1);
         QVERIFY(buf.size == data.size());
         QVERIFY(buf.size == longPath.size());