Fix canonicalPath for drives (c:)

Author: TheOneRing

src/gui/folderman.cpp

@@ -421,7 +421,7 @@ Folder *FolderMan::folderForPath(const QString &path, QString *relativePath)
     for (auto *folder : std::as_const(_folders)) {
         const QString folderPath = folder->cleanPath() + QLatin1Char('/');
 
-        if (absolutePath.startsWith(folderPath, (Utility::isWindows() || Utility::isMac()) ? Qt::CaseInsensitive : Qt::CaseSensitive)) {
+        if (FileSystem::isChildPathOf2(absolutePath, folderPath).testAnyFlag(FileSystem::ChildResult::IsChild)) {
             if (relativePath) {
                 *relativePath = absolutePath.mid(folderPath.length());
                 relativePath->chop(1); // we added a '/' above
@@ -541,25 +541,36 @@ QString FolderMan::trayTooltipStatusString(
     return folderMessage;
 }
 
-// QFileInfo::canonicalPath returns an empty string if the file does not exist.
+// canonicalPath returns an empty string if the file does not exist.
 // This function also works with files that does not exist and resolve the symlinks in the
 // parent directories.
-static QString canonicalPath(const QString &path)
-{
-    QFileInfo selFile(path);
-    if (!selFile.exists()) {
-        const auto parentPath = selFile.dir().path();
-
-        // It's possible for the parentPath to match the path
-        // (possibly we've arrived at a non-existant drive root on Windows)
-        // and recursing would be fatal.
-        if (parentPath == path) {
-            return path;
+static std::filesystem::path canonicalPath(const std::filesystem::path &p)
+{
+    std::error_code ec;
+    if (!std::filesystem::exists(p, ec) && !ec) {
+        const auto parentPath = p.lexically_normal().parent_path();
+        // last invocation will return /
+        if (parentPath == p) {
+            return p;
         }
 
-        return canonicalPath(parentPath) + QLatin1Char('/') + selFile.fileName();
+        return canonicalPath(parentPath) / p.filename();
+    }
+    if (ec) {
+        qCWarning(lcFolderMan) << "Failed to check existence of path:" << p << ec.message();
     }
-    return selFile.canonicalFilePath();
+    const auto out = std::filesystem::canonical(p, ec);
+    if (ec) {
+        qCWarning(lcFolderMan) << "Failed to canonicalize path:" << p << ec.message();
+        return p;
+    }
+    return out;
+}
+
+static QString canonicalPath(const QString &p)
+{
+    // clean path to normalize path back to Qt form
+    return QDir::cleanPath(FileSystem::fromFilesystemPath(canonicalPath(FileSystem::toFilesystemPath(p))));
 }
 
 static QString checkPathForSyncRootMarkingRecursive(const QString &path, FolderMan::NewFolderType folderType, const QUuid &accountUuid)
@@ -645,17 +656,18 @@ QString FolderMan::checkPathValidityRecursive(const QString &path, FolderMan::Ne
 QString FolderMan::checkPathValidityForNewFolder(const QString &path, NewFolderType folderType, const QUuid &accountUuid) const
 {
     // check if the local directory isn't used yet in another sync
-    const auto cs = Utility::fsCaseSensitivity();
-
-    const QString userDir = QDir::cleanPath(canonicalPath(path)) + QLatin1Char('/');
+    if (path.isEmpty()) {
+        return u"Passingg an empty path is not supported"_s;
+    }
+    const QString userDir = canonicalPath(path) + QLatin1Char('/');
     for (auto f : _folders) {
-        const QString folderDir = QDir::cleanPath(canonicalPath(f->path())) + QLatin1Char('/');
+        const QString folderDir = canonicalPath(f->path()) + QLatin1Char('/');
 
-        if (QString::compare(folderDir, userDir, cs) == 0) {
+        const auto isChild = FileSystem::isChildPathOf2(folderDir, userDir);
+        if (isChild.testFlag(FileSystem::ChildResult::IsEqual)) {
             return tr("There is already a sync from the server to this local folder. "
                       "Please pick another local folder!");
-        }
-        if (FileSystem::isChildPathOf(folderDir, userDir)) {
+        } else if (isChild.testFlag(FileSystem::ChildResult::IsChild)) {
             return tr("The local folder »%1« already contains a folder used in a folder sync connection. "
                       "Please pick another local folder!")
                 .arg(QDir::toNativeSeparators(path));
@@ -681,13 +693,15 @@ QString FolderMan::findGoodPathForNewSyncFolder(
     OC_ASSERT(!accountUuid.isNull() || folderType == FolderMan::NewFolderType::SpacesSyncRoot);
 
     // reserve extra characters to allow appending of a number
-    const QString normalisedPath = FileSystem::createPortableFileName(basePath, FileSystem::pathEscape(newFolder), std::string_view(" (100)").size());
+    const QString normalisedPath = FileSystem::createPortableFileName(basePath, newFolder, std::string_view(" (100)").size());
 
     // If the parent folder is a sync folder or contained in one, we can't
     // possibly find a valid sync folder inside it.
     // Example: Someone syncs their home directory. Then ~/foobar is not
     // going to be an acceptable sync folder path for any value of foobar.
-    if (FolderMan::instance()->folderForPath(QFileInfo(normalisedPath).canonicalPath())) {
+    // If relativePath is empty, the path is equal to newFolder, and we will find a name in the following loop
+    QString relativePath;
+    if (FolderMan::instance()->folderForPath(canonicalPath(normalisedPath), &relativePath) && !relativePath.isEmpty()) {
         // Any path with that parent is going to be unacceptable,
         // so just keep it as-is.
         return canonicalPath(normalisedPath);

src/libsync/common/filesystembase.cpp

@@ -556,7 +556,6 @@ QString FileSystem::createPortableFileName(const QString &path, const QString &f
     tmp.resize(std::min<qsizetype>(tmp.size(), fileNameMaxC - reservedSize));
     // remove eventual trailing whitespace after the resize
     tmp = tmp.trimmed();
-
     return QDir::cleanPath(path + QLatin1Char('/') + tmp);
 }
 

src/libsync/propagateuploadtus.cpp

@@ -235,8 +235,6 @@ void PropagateUploadFileTUS::slotChunkFinished()
         propagator()->_anotherSyncNeeded = true;
         if (!_finished) {
             abortWithError(SyncFileItem::Message, fileChangedMessage());
-            // FIXME:  the legacy code was retrying for a few seconds.
-            //         and also checking that after the last chunk, and removed the file in case of INSTRUCTION_NEW
             return;
         }
     }

test/testfolderman.cpp

@@ -105,7 +105,7 @@ private Q_SLOTS:
         QVERIFY(!folderman->checkPathValidityForNewFolder(dirPath + QStringLiteral("/sub/OpenCloud1/some/sub/path"), type, uuid).isNull());
         QVERIFY(!folderman->checkPathValidityForNewFolder(dirPath + QStringLiteral("/OpenCloud2/blublu"), type, uuid).isNull());
         QVERIFY(!folderman->checkPathValidityForNewFolder(dirPath + QStringLiteral("/sub/OpenCloud1/folder/g/h"), type, uuid).isNull());
-        QVERIFY(!folderman->checkPathValidityForNewFolder(dirPath + QStringLiteral("/link3/folder/neu_folder"), type, uuid).isNull());
+        QCOMPARE_NE(folderman->checkPathValidityForNewFolder(dirPath + QStringLiteral("/link3/folder/neu_folder"), type, uuid), QString());
 
         // Subfolder of links
         QVERIFY(folderman->checkPathValidityForNewFolder(dirPath + QStringLiteral("/link1/subfolder"), type, uuid).isNull());