fix(quota): protect local files from deletion when quota blocked upload.

src/common/syncjournaldb.cpp

@@ -1,10 +1,10 @@
 /*
  * SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2014 ownCloud GmbH
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #include <QCryptographicHash>
 #include <QFile>
 #include <QJsonArray>
 #include <QJsonDocument>
@@ -219,7 +219,7 @@
 
     // Since the list is sorted, we can do a binary search.
     // If the path is a prefix of another item or right after in the lexical order.
     auto it = std::lower_bound(list.cbegin(), list.cend(), pathSlash);
 
     if (it != list.cend() && *it == pathSlash) {
         return true;
@@ -1061,7 +1061,7 @@
         return tr("Failed to connect database."); // checkConnect failed.
     }
 
     int plen = record._path.length();
 
     QByteArray etag(record._etag);
     if (etag.isEmpty()) {
@@ -1169,7 +1169,7 @@
     return true;
 }
 
 bool SyncJournalDb::listAllE2eeFoldersWithEncryptionStatusLessThan(const int status, const std::function<void(const SyncJournalFileRecord &)> &rowCallback)
 {
     QMutexLocker locker(&_mutex);
 
@@ -1487,7 +1487,7 @@
 
 bool SyncJournalDb::getFileRecordsByFileId(const QByteArray &fileId, const std::function<void(const SyncJournalFileRecord &)> &rowCallback)
 {
     QMutexLocker locker(&_mutex);
 
     if (fileId.isEmpty() || _metadataTableIsEmpty) {
         return true; // no error, yet nothing found (rec->isValid() == false)
@@ -2171,6 +2171,36 @@
     return entry;
 }
 
+bool SyncJournalDb::renameErrorBlacklistPaths(const QString &from, const QString &to)
+{
+    QMutexLocker locker(&_mutex);
+    if (!checkConnect()) {
+        return false;
+    }
+
+    SqlQuery countQuery(_db);
+    countQuery.prepare("SELECT COUNT(*) FROM blacklist "
+                      "WHERE errorCategory = ?1 "
+                      "AND (path = ?2 OR (path > (?2 || '/') AND path < (?2 || '0')))");
+    countQuery.bindValue(1, SyncJournalErrorBlacklistRecord::InsufficientRemoteStorage);
+    countQuery.bindValue(2, from);
+    const bool hasQuotaEntries = countQuery.exec() && countQuery.next().hasData && countQuery.intValue(0) > 0;
+
+    // Update the exact folder entry and all entries whose path starts with "from/".
+    // Uses the same range trick as IS_PREFIX_PATH_OR_EQUAL: '/' + 1 == '0'.
+    SqlQuery query(_db);
+    query.prepare("UPDATE blacklist "
+                  "SET path = ?2 || substr(path, length(?1) + 1) "
+                  "WHERE path == ?1 OR (path > (?1 || '/') AND path < (?1 || '0'))");
+    query.bindValue(1, from);
+    query.bindValue(2, to);
+    if (!query.exec()) {
+        sqlFail(QStringLiteral("renameErrorBlacklistPaths"), query);
+    }
+
+    return hasQuotaEntries;
+}
+
 bool SyncJournalDb::deleteStaleErrorBlacklistEntries(const QSet<QString> &keep)
 {
     QMutexLocker locker(&_mutex);

src/common/syncjournaldb.h

@@ -7,7 +7,7 @@
 #ifndef SYNCJOURNALDB_H
 #define SYNCJOURNALDB_H
 
 #include <QObject>
 #include <QDateTime>
 #include <QHash>
 #include <QMutex>
@@ -145,6 +145,7 @@
 
     SyncJournalErrorBlacklistRecord errorBlacklistEntry(const QString &);
     [[nodiscard]] bool deleteStaleErrorBlacklistEntries(const QSet<QString> &keep);
+    bool renameErrorBlacklistPaths(const QString &from, const QString &to);
 
     /// Delete flags table entries that have no metadata correspondent
     void deleteStaleFlagsEntries();

src/libsync/discovery.cpp

@@ -1,3 +1,3 @@
 /*
  * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2018 ownCloud GmbH
@@ -29,7 +29,7 @@
 namespace
 {
 constexpr const char *editorNamesForDelayedUpload[] = {"PowerPDF"};
 constexpr const char *fileExtensionsToCheckIfOpenForSigning[] = {".pdf"};
 constexpr auto delayIntervalForSyncRetryForOpenedForSigningFilesSeconds = 60;
 constexpr auto delayIntervalForSyncRetryForFilesExceedQuotaSeconds = 60;
 }
@@ -61,7 +61,7 @@
     computePinState(parent->_pinState);
 }
 
 ProcessDirectoryJob::ProcessDirectoryJob(DiscoveryPhase *data, PinState basePinState, const PathTuple &path, const SyncFileItemPtr &dirItem, const SyncFileItemPtr &parentDirItem, QueryMode queryLocal, qint64 lastSyncTimestamp, QObject *parent)
         : QObject(parent)
         , _dirItem(dirItem)
         , _dirParentItem(parentDirItem)
@@ -252,7 +252,7 @@
     QTimer::singleShot(0, _discoveryData, &DiscoveryPhase::scheduleMoreJobs);
 }
 
 bool ProcessDirectoryJob::handleExcluded(const QString &path, const Entries &entries, const std::map<QString, Entries> &allEntries, const bool isHidden, const bool isBlacklisted)
 {
     const auto isDirectory = entries.localEntry.isDirectory || entries.serverEntry.isDirectory;
 
@@ -276,7 +276,7 @@
                                             || excluded == CSYNC_FILE_EXCLUDE_TRAILING_SPACE
                                             || excluded == CSYNC_FILE_EXCLUDE_LEADING_AND_TRAILING_SPACE;
 
     const auto leadingAndTrailingSpacesFilesAllowed = !_discoveryData->_shouldEnforceWindowsFileNameCompatibility || _discoveryData->_leadingAndTrailingSpacesFilesAllowed.contains(_discoveryData->_localDir + path);
 #if defined Q_OS_WINDOWS
     if (hasLeadingOrTrailingSpaces && leadingAndTrailingSpacesFilesAllowed) {
 #else
@@ -403,7 +403,7 @@
             } else {
                 char invalid = '\0';
                 constexpr QByteArrayView invalidChars("\\:?*\"<>|");
                 for (const auto x : invalidChars) {
                     if (item->_file.contains(x)) {
                         invalid = x;
                         break;
@@ -425,7 +425,7 @@
             }
             item->_status = SyncFileItem::FileNameInvalid;
             break;
         case CSYNC_FILE_EXCLUDE_TRAILING_SPACE:
             item->_errorString = tr("Filename contains trailing spaces.");
             item->_status = SyncFileItem::FileNameInvalid;
             if (isLocal && !maybeRenameForWindowsCompatibility(_discoveryData->_localDir + item->_file, excluded)) {
@@ -1059,9 +1059,14 @@
         } else {
             // we need to make a request to the server to know that the original file is deleted on the server
             _pendingAsyncJobs++;
+            // Mark this path as a pending rename check so that children blocked from upload
+            // because of quota errors inside a queued deleted-directory job do not cancel the
+            // parent's REMOVE instruction before rename detection can claim it.
+            _discoveryData->_pendingRenameSourcePaths.insert(originalPath);
             const auto job = new RequestEtagJob(_discoveryData->_account, _discoveryData->_remoteFolder + originalPath, this);
             connect(job, &RequestEtagJob::finishedWithResult, this, [=, this](const HttpResult<QByteArray> &etag) mutable {
                 _pendingAsyncJobs--;
+                _discoveryData->_pendingRenameSourcePaths.remove(originalPath);
                 QTimer::singleShot(0, _discoveryData, &DiscoveryPhase::scheduleMoreJobs);
                 if (etag || etag.error().code != 404 ||
                     // Somehow another item claimed this original path, consider as if it existed
@@ -1231,6 +1236,11 @@
             }
 
             item->_status = SyncFileItem::Status::NormalError;
+            // Mark as a quota error so blacklistUpdate writes an InsufficientRemoteStorage entry.
+            // Without this, _httpErrorCode would be 0 and blacklistUpdate would not create an
+            // entry, leaving the file unprotected by checkNewDeleteConflict if the remote parent
+            // folder is deleted before the quota situation is resolved.
+            item->_httpErrorCode = 507;
             _discoveryData->_anotherSyncNeeded = true;
             _discoveryData->_filesNeedingScheduledSync.insert(path._original, delayIntervalForSyncRetryForFilesExceedQuotaSeconds);
         }
@@ -1467,7 +1477,7 @@
         return;
     }
 
-    if (checkNewDeleteConflict(item)) {
+    if (checkNewDeleteConflict(item, localEntry.size)) {
         return;
     }
 
@@ -1570,7 +1580,7 @@
     const auto isE2eeMove = isMove && (base.isE2eEncrypted() || isInsideEncryptedTree());
     const auto isCfApiVfsMode = _discoveryData->_syncOptions._vfs && _discoveryData->_syncOptions._vfs->mode() == Vfs::WindowsCfApi;
     const bool isOnlineOnlyItem = isCfApiVfsMode && (localEntry.isDirectory || _discoveryData->_syncOptions._vfs->isDehydratedPlaceholder(_discoveryData->_localDir + path._local));
     const auto isE2eeMoveOnlineOnlyItemWithCfApi = isE2eeMove && isOnlineOnlyItem;
 
     if (isE2eeMove) {
         qCDebug(lcDisco) << "requesting permanent deletion for" << originalPath;
@@ -1650,7 +1660,7 @@
         return;
     }
 
     auto wasDeletedOnClient = _discoveryData->findAndCancelDeletedJob(originalPath);
 
     auto processRename = [item, originalPath, base, this](PathTuple &path) {
         auto adjustedOriginalPath = _discoveryData->adjustRenamedPath(originalPath, SyncFileItem::Down);
@@ -1694,7 +1704,7 @@
         if (base.isVirtualFile() && isVfsWithSuffix())
             chopVirtualFileSuffix(serverOriginalPath);
         auto job = new RequestEtagJob(_discoveryData->_account, serverOriginalPath, this);
         connect(job, &RequestEtagJob::finishedWithResult, this, [=, this](const HttpResult<QByteArray> &etag) mutable {
 
 
             if (!etag || (etag.get() != base._etag && !item->isDirectory()) || _discoveryData->isRenamed(originalPath)
@@ -1740,7 +1750,7 @@
     // If there's no content hash, use heuristics
     if (serverEntry.checksumHeader.isEmpty()) {
         // If the size or mtime is different, it's definitely a conflict.
         bool isConflict = (serverEntry.size != localEntry.size) || (serverEntry.modtime != localEntry.modtime) || (dbEntry.isValid() && dbEntry._modtime != localEntry.modtime && serverEntry.modtime == localEntry.modtime);
 
         // It could be a conflict even if size and mtime match!
         //
@@ -1896,7 +1906,7 @@
         item->_direction = _dirItem->_direction;
     }
 
     {
         const auto isImportantInstruction = item->_instruction != CSYNC_INSTRUCTION_NONE;
         if (isImportantInstruction) {
             qCInfo(lcDisco).noquote() << item->_discoveryResult;
@@ -2117,7 +2127,7 @@
     }
 
     const auto isMatchingFileExtension = std::find_if(std::cbegin(fileExtensionsToCheckIfOpenForSigning), std::cend(fileExtensionsToCheckIfOpenForSigning),
         [path](const auto &matchingExtension) {
             return path._local.endsWith(matchingExtension, Qt::CaseInsensitive);
         }) != std::cend(fileExtensionsToCheckIfOpenForSigning);
 
@@ -2130,7 +2140,7 @@
 
     for (const auto &detectedEditorName : editorsKeepingFileBusy) {
         const auto isMatchingEditorFound = std::find_if(std::cbegin(editorNamesForDelayedUpload), std::cend(editorNamesForDelayedUpload),
             [detectedEditorName](const auto &matchingEditorName) {
                 return detectedEditorName.processName.startsWith(matchingEditorName, Qt::CaseInsensitive);
             }) != std::cend(editorNamesForDelayedUpload);
         if (isMatchingEditorFound) {
@@ -2213,6 +2223,13 @@
                 // Do not remove a directory that has ignored files
                 qCInfo(lcDisco) << "Child ignored for a folder to remove" << _dirItem->_file << "direction" << _dirItem->_direction;
                 _dirItem->_instruction = CSYNC_INSTRUCTION_NONE;
+                // Invalidate the parent directory's etag so the next sync queries it from
+                // the server instead of using a ParentNotChanged cache hit.  Without this, a
+                // parent whose etag has not changed since the server side deletion uses its DB
+                // record as a proxy for server state and keeps issuing NONE for this folder.
+                const auto slashPos = _dirItem->_file.lastIndexOf(QLatin1Char('/'));
+                const auto parentPath = slashPos >= 0 ? _dirItem->_file.left(slashPos) : QString();
+                _discoveryData->_statedb->schedulePathForRemoteDiscovery(parentPath.toUtf8());
             }
         }
         emit finished();
@@ -2483,7 +2500,7 @@
     case CSYNC_FILE_EXCLUDE_LEADING_SPACE:
     case CSYNC_FILE_EXCLUDE_TRAILING_SPACE:
     {
         const auto removeTrailingSpaces = [] (QString string) -> QString {
             for (int n = string.size() - 1; n >= 0; -- n) {
                 if (!string.at(n).isSpace()) {
                     string.truncate(n + 1);
@@ -2504,18 +2521,67 @@
     return result;
 }
 
-bool ProcessDirectoryJob::checkNewDeleteConflict(const SyncFileItemPtr &item) const
+bool ProcessDirectoryJob::checkNewDeleteConflict(const SyncFileItemPtr &item, int64_t localFileSize)
 {
-    if (_discoveryData->recursiveCheckForDeletedParents(item->_file)) {
-        qCWarning(lcDisco) << "Removing local file inside a remotely deleted folder" << item->_file;
-        item->_instruction = CSYNC_INSTRUCTION_REMOVE;
-        item->_direction = SyncFileItem::Down;
-        item->_wantsSpecificActions = SyncFileItem::SynchronizationOptions::MoveToClientTrashBin;
+    if (!_discoveryData->recursiveCheckForDeletedParents(item->_file)) {
+        return false;
+    }
+
+    // Deleting the local copy could result in permanent data loss if the file was never in the
+    // server and blocked from being uploaded by a quota error.
+    // Protect it instead and let the user resolve the storage situation first.
+    if (const auto blacklistEntry = _discoveryData->_statedb->errorBlacklistEntry(item->_file);
+        blacklistEntry.isValid()
+        && blacklistEntry._errorCategory == SyncJournalErrorBlacklistRecord::InsufficientRemoteStorage) {
+        qCWarning(lcDisco) << "Not removing local file inside a remotely deleted folder: "
+                              "file was never uploaded due to storage quota —"
+                           << item->_file;
+        item->_instruction = CSYNC_INSTRUCTION_ERROR;
+        item->_status = SyncFileItem::SoftError;
+        // Keep _httpErrorCode at 507 so blacklistUpdate recreates the InsufficientRemoteStorage
+        // entry if the ignore duration later expires.
+        item->_httpErrorCode = 507;
+        item->_errorString = tr("\"%1\" was not deleted because its latest changes were not synced "
+                                "and your server quota was exceeded. "
+                                "Please manage your storage and try syncing again.")
+                                 .arg(item->_file);
+        // Prevent the parent directory from being deleted while a file with an error exists.
+        _childIgnored = true;
         emit _discoveryData->itemDiscovered(item);
         return true;
     }
 
-    return false;
+    // No prior blacklist entry. For files blocked from upload due to a quota error in the same
+    // sync as the folder deletion, check the parent folder's last known quota from the DB.
+    if (!item->isDirectory() && localFileSize > 0 && _dirItem) {
+        SyncJournalFileRecord dirItemDbRecord;
+        if (_discoveryData->_statedb->getFileRecord(_dirItem->_file, &dirItemDbRecord)
+            && dirItemDbRecord.isValid()) {
+            const auto bytesAvailable = dirItemDbRecord._folderQuota.bytesAvailable;
+            if (bytesAvailable >= 0 && localFileSize > bytesAvailable) {
+                qCWarning(lcDisco) << "Not removing local file inside a remotely deleted folder: "
+                                      "file would exceed last known parent folder quota —"
+                                   << item->_file;
+                item->_instruction = CSYNC_INSTRUCTION_ERROR;
+                item->_status = SyncFileItem::SoftError;
+                item->_httpErrorCode = 507;
+                item->_errorString = tr("\"%1\" was not deleted because its latest changes were not synced "
+                                        "and your server quota was exceeded. "
+                                        "Please manage your storage and try syncing again.")
+                                         .arg(item->_file);
+                _childIgnored = true;
+                emit _discoveryData->itemDiscovered(item);
+                return true;
+            }
+        }
+    }
+
+    qCWarning(lcDisco) << "Removing local file inside a remotely deleted folder" << item->_file;
+    item->_instruction = CSYNC_INSTRUCTION_REMOVE;
+    item->_direction = SyncFileItem::Down;
+    item->_wantsSpecificActions = SyncFileItem::SynchronizationOptions::MoveToClientTrashBin;
+    emit _discoveryData->itemDiscovered(item);
+    return true;
 }
 
 }

src/libsync/discovery.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
 #include <QObject>
 #include <cstdint>
 #include "csync_exclude.h"
 #include "discoveryphase.h"
@@ -249,10 +249,10 @@
      */
     void setupDbPinStateActions(SyncJournalFileRecord &record);
 
     bool maybeRenameForWindowsCompatibility(const QString &absoluteFileName,
                                             CSYNC_EXCLUDE_TYPE excludeReason);
 
-    [[nodiscard]] bool checkNewDeleteConflict(const SyncFileItemPtr &item) const;
+    [[nodiscard]] bool checkNewDeleteConflict(const SyncFileItemPtr &item, int64_t localFileSize = 0);
 
     qint64 _lastSyncTimestamp = 0;
 

src/libsync/discoveryphase.cpp

@@ -120,7 +120,7 @@
 
         // it is not too big, put it in the white list (so we will not do more query for the children) and and do not block.
         const auto sanitisedPath = Utility::trailingSlashPath(path);
         _selectiveSyncWhiteList.insert(std::upper_bound(_selectiveSyncWhiteList.begin(), _selectiveSyncWhiteList.end(), sanitisedPath), sanitisedPath);
         return callback(false);
     });
 }
@@ -237,6 +237,12 @@
             continue;
         }
 
+        // Async 404 in flight: rename source candidate, not a confirmed deletion.
+        if (_pendingRenameSourcePaths.contains(currentParentFolder)) {
+            qCDebug(lcDiscovery()) << "deleted parent is a pending rename candidate, skipping" << currentParentFolder;
+            continue;
+        }
+
         qCDebug(lcDiscovery()) << "deleted parent found";
         result = true;
         break;
@@ -441,7 +447,7 @@
 void DiscoverySingleDirectoryJob::start()
 {
     // Start the actual HTTP job
     auto *lsColJob = new LsColJob(_account, _subPath);
 
     const auto props = LsColJob::defaultProperties(_isRootPath ? LsColJob::FolderType::RootFolder : LsColJob::FolderType::ChildFolder,
                                                    _account);
@@ -544,7 +550,7 @@
         }
     } else {
         RemoteInfo result;
         int slash = file.lastIndexOf(u'/');
         result.name = file.mid(slash + 1);
         result.size = -1;
         LsColJob::propertyMapToRemoteInfo(map,
@@ -654,7 +660,7 @@
 
     const auto jsonMetadata = statusCode == 404 ? QByteArray{} : json.toJson(QJsonDocument::Compact);
     const auto jsonMetadataVersion = FolderMetadata::setupVersionFromExistingMetadata(jsonMetadata);
     switch (jsonMetadataVersion) {
     case FolderMetadata::MetadataVersion::VersionUndefined:
     case FolderMetadata::MetadataVersion::Version1:
     case FolderMetadata::MetadataVersion::Version1_2:
@@ -671,12 +677,12 @@
         break;
     }
 
     const auto e2EeFolderMetadata = new FolderMetadata(_account,
                                                        _remoteRootFolderPath,
                                                        jsonMetadata,
                                                        RootEncryptedFolderInfo(Utility::fullRemotePathToRemoteSyncRootRelative(topLevelFolderPath, _remoteRootFolderPath)),
                                                        job->signature());
     connect(e2EeFolderMetadata, &FolderMetadata::setupComplete, this, [this, e2EeFolderMetadata] {
         e2EeFolderMetadata->deleteLater();
         if (!e2EeFolderMetadata->isValid()) {
             emit finished(HttpError{0, tr("Encrypted metadata setup error!")});
@@ -718,7 +724,7 @@
         emit finished(_results);
         deleteLater();
     });
 }
 
 void DiscoverySingleDirectoryJob::metadataError(const QByteArray &fileId, int httpReturnCode)
 {

src/libsync/discoveryphase.h

@@ -283,6 +283,14 @@ class DiscoveryPhase : public QObject
     /// contains files/folder names that are requested to be deleted permanently
     QSet<QString> _permanentDeletionRequests;
 
+    /** Paths with an async 404 in flight to confirm server deletion.
+     *
+     * While a path is here, children blocked from upload because of quota errors must not
+     * prevent the parent folder from being removed. Rename detection takes priority and
+     * will claim the path once the 404 confirms deletion.
+     */
+    QSet<QString> _pendingRenameSourcePaths;
+
     void markPermanentDeletionRequests();
 
 public:

src/libsync/owncloudpropagator.cpp

@@ -1,3 +1,3 @@
 /*
  * SPDX-FileCopyrightText: 2018 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2013 ownCloud GmbH
@@ -160,6 +160,9 @@
 
     if (item._httpErrorCode == 507) {
         entry._errorCategory = SyncJournalErrorBlacklistRecord::InsufficientRemoteStorage;
+        // Quota can change at any time (user frees space, admin adjusts limits).
+        // Always retry on the next sync rather than backing off exponentially.
+        entry._ignoreDuration = 0;
     }
 
     return entry;
@@ -390,7 +393,7 @@
     case CSYNC_INSTRUCTION_UPDATE_ENCRYPTION_METADATA:
     {
         const auto rootE2eeFolderPath = item->_file.split('/').first();
         const auto rootE2eeFolderPathFullRemotePath = fullRemotePath(rootE2eeFolderPath);
         return new UpdateMigratedE2eeMetadataJob(this, item, rootE2eeFolderPathFullRemotePath, remotePath());
     }
     case CSYNC_INSTRUCTION_IGNORE:
@@ -696,7 +699,7 @@
             (item->_instruction == CSYNC_INSTRUCTION_NEW || item->_instruction == CSYNC_INSTRUCTION_SYNC);
         const auto isVirtualFile = item->_type == ItemTypeVirtualFile;
         const auto isEncrypted = item->_e2eEncryptionStatus != SyncFileItem::EncryptionStatus::NotEncrypted;
         const auto shouldAddBulkPropagateDownloadItem = isDownload && isVirtualFile && isVfsCfApi && !isEncrypted;
 
         if (shouldAddBulkPropagateDownloadItem) {
             addBulkPropagateDownloadItem(item, directories);
@@ -724,7 +727,7 @@
                                                               }
                                                               );
 
     if (foundBulkPrpagatorDownloadJobIt == std::cend(directories.top().second->_subJobs._jobsToDo)) {
         bulkPropagatorDownloadJob = new BulkPropagatorDownloadJob(this, directories.top().second);
         directories.top().second->appendJob(bulkPropagatorDownloadJob);
     } else {
@@ -741,7 +744,7 @@
         const auto rootE2eeFolderPathWithSlash = QString(rootE2eeFolderPath + "/");
 
         QPair<QString, PropagateDirectory *> foundDirectory = {QString{}, nullptr};
         for (auto it = std::rbegin(directories); it != std::rend(directories); ++it) {
             if (it->first == rootE2eeFolderPathWithSlash) {
                 foundDirectory = *it;
                 break;
@@ -1384,7 +1387,7 @@
 
 void PropagateDirectory::willDeleteItemToClientTrashBin(const SyncFileItemPtr &item)
 {
     auto deleteFolderJob = dynamic_cast<PropagateLocalRemove*>(_firstJob.get());
     if (!deleteFolderJob) {
         return;
     }
@@ -1509,7 +1512,7 @@
             if (!_item->_remotePerm.isNull() &&
                 !_item->_remotePerm.hasPermissionsForReadWrite()) {
                 try {
                     if (const auto fileName = propagator()->fullLocalPath(_item->_file); FileSystem::fileExists(fileName)) {
                         FileSystem::setFolderPermissions(fileName, FileSystem::FolderPermissions::ReadOnly);
                         Q_EMIT propagator()->touchedFile(fileName);
                     }
@@ -1586,6 +1589,22 @@
             }
         }
     }
+
+    // For a DOWN rename where the directory itself succeeded (PropagateLocalRename
+    // ran OK) but one or more children had errors, still persist the renamed
+    // directory's path and fileId in the database. Without this record a
+    // subsequent server side rename of the same directory cannot be matched via
+    // fileId lookup, causing the client to treat it as a DELETE + NEW instead of
+    // following the move.
+    if (!_item->isEmpty()
+        && status != SyncFileItem::Success
+        && status != SyncFileItem::FatalError
+        && _item->_status == SyncFileItem::Success
+        && _item->_instruction == CSYNC_INSTRUCTION_RENAME
+        && _item->_direction == SyncFileItem::Down) {
+        propagator()->updateMetadata(*_item);
+    }
+
     _state = Finished;
     qCDebug(lcDirectory()) << "PropagateDirectory::slotSubJobsFinished" << "emit finished" << status;
     emit finished(status);
@@ -1790,7 +1809,7 @@
     return _remoteFolder + tmp_file_name;
 }
 
 QString OwncloudPropagator::fulllRemotePathToPathInSyncJournalDb(const QString &fullRemotePath) const
 {
     auto result = _remoteFolder != QStringLiteral("/") ? fullRemotePath.mid(_remoteFolder.size()) : fullRemotePath;
     if (result.startsWith("/")) {

src/libsync/propagateremotemove.cpp

@@ -305,6 +305,9 @@ void PropagateRemoteMove::finalize()
             done(SyncFileItem::FatalError, tr("Error writing metadata to the database"), ErrorCategory::GenericError);
             return;
         }
+        if (propagator()->_journal->renameErrorBlacklistPaths(_item->_file, _item->_renameTarget)) {
+            emit propagator()->insufficientRemoteStorage();
+        }
     }
 
     propagator()->_journal->commit("Remote Rename");

src/libsync/propagatorjobs.cpp

@@ -65,7 +65,7 @@
                                                        },
                                                        nullptr,
                                                        nullptr,
                                                        [this] (const QString &itemPath, QString *removeError) -> bool {
                                                            auto result = false;
 
                                                            if (_deleteToClientTrashBin.contains(itemPath)) {
@@ -138,7 +138,7 @@
         {
             qCWarning(lcPropagateLocalRemove) << "exception when checking parent folder read only status" << e.what();
         }
         catch (...)
         {
             qCWarning(lcPropagateLocalRemove) << "exception when checking parent folder read only status";
         }
@@ -202,7 +202,7 @@
     _deleteExistingFile = enabled;
 }
 
 void PropagateLocalMkdir::startLocalMkdir()
 {
     QDir newDir(propagator()->fullLocalPath(_item->_file));
     QString newDirStr = QDir::toNativeSeparators(newDir.path());
@@ -523,7 +523,7 @@
         }
     } else if (!fileAlreadyMoved) {
         qCDebug(lcPropagateLocalRename) << "propagate child items after move from" << existingFile << "to" << targetFile;
         const auto dbQueryResult = propagator()->_journal->getFilesBelowPath(previousNameInDb.toUtf8(), [previousNameInDb, this] (const SyncJournalFileRecord &record) -> void {
             const auto oldFileNameString = propagator()->adjustRenamedPath(QString::fromUtf8(record._path));
             auto newFileNameString = oldFileNameString;
             newFileNameString.replace(0, previousNameInDb.length(), _item->_renameTarget);
@@ -561,6 +561,9 @@
             done(SyncFileItem::FatalError, tr("Failed to rename file"), ErrorCategory::GenericError);
             return;
         }
+        if (propagator()->_journal->renameErrorBlacklistPaths(oldFile, _item->_renameTarget)) {
+            emit propagator()->insufficientRemoteStorage();
+        }
     }
     if (pinState != PinState::Inherited && !vfs->setPinState(_item->_renameTarget, pinState)) {
         done(SyncFileItem::NormalError, tr("Error setting pin state"), ErrorCategory::GenericError);

src/libsync/syncengine.cpp

@@ -143,6 +143,16 @@
 
     item._hasBlacklistEntry = true;
 
+    // Discovery already produced a deliberate error for items protected in checkNewDeleteConflict.
+    // Keep its instruction and message intact so the specific reason is displayed.
+    // Still show the quota notification if applicable.
+    if (item._instruction == CSYNC_INSTRUCTION_ERROR) {
+        if (entry._errorCategory == SyncJournalErrorBlacklistRecord::InsufficientRemoteStorage) {
+            slotInsufficientRemoteStorage();
+        }
+        return true;
+    }
+
     // If duration has expired, it's not blacklisted anymore
     time_t now = Utility::qDateTimeToTime_t(QDateTime::currentDateTimeUtc());
     if (now >= entry._lastTryTime + entry._ignoreDuration) {
@@ -241,7 +251,7 @@
 
     // Delete the stales chunk on the server.
     if (account()->capabilities().chunkingNg()) {
         for (uint transferId : std::as_const(ids)) {
             if (!transferId)
                 continue; // Was not a chunked upload
             QUrl url = Utility::concatUrlPath(account()->url(), QLatin1String("remote.php/dav/uploads/") + account()->davUser() + QLatin1Char('/') + QString::number(transferId));
@@ -397,7 +407,7 @@
 
             // Update on-disk virtual file metadata
             if (modificationHappened && item->_type == ItemTypeVirtualFile) {
                 auto r = _syncOptions._vfs->updateMetadata(*item, filePath, {});
                 if (!r) {
                     item->_status = SyncFileItem::Status::NormalError;
                     item->_instruction = CSYNC_INSTRUCTION_ERROR;
@@ -474,7 +484,7 @@
     _needsUpdate = true;
 
     // Insert sorted
     auto it = std::lower_bound( _syncItems.begin(), _syncItems.end(), item ); // the _syncItems is sorted
     _syncItems.insert( it, item );
 
     slotNewItem(item);
@@ -502,10 +512,10 @@
 
         if (!e2EeLockedFolders.isEmpty()) {
             for (const auto &e2EeLockedFolder : e2EeLockedFolders) {
                 const auto folderId = e2EeLockedFolder.first;
                 qCInfo(lcEngine()) << "start unlock job for folderId:" << folderId;
                 const auto folderToken = EncryptionHelper::decryptStringAsymmetric(_account->e2e()->getCertificateInformation(), _account->e2e()->paddingMode(), *_account->e2e(), e2EeLockedFolder.second);
                 if (!folderToken) {
                     qCWarning(lcEngine()) << "decrypt failed";
                     return;
                 }
@@ -700,7 +710,7 @@
     connect(_discoveryPhase.get(), &DiscoveryPhase::itemDiscovered, this, &SyncEngine::slotItemDiscovered);
     connect(_discoveryPhase.get(), &DiscoveryPhase::newBigFolder, this, &SyncEngine::newBigFolder);
     connect(_discoveryPhase.get(), &DiscoveryPhase::existingFolderNowBig, this, &SyncEngine::existingFolderNowBig);
     connect(_discoveryPhase.get(), &DiscoveryPhase::fatalError, this, [this](const QString &errorString, ErrorCategory errorCategory) {
         Q_EMIT syncError(errorString, errorCategory);
         finalize(false);
     });
@@ -917,7 +927,7 @@
     detectFileLock(item);
 }
 
 void SyncEngine::slotPropagationFinished(OCC::SyncFileItem::Status status)
 {
     if (_propagator->_anotherSyncNeeded && _anotherSyncNeeded == NoFollowUpSync) {
         _anotherSyncNeeded = ImmediateFollowUp;
@@ -1177,7 +1187,7 @@
     }
     const auto filesDeletedThresholdExceeded = deletionCounter > ConfigFile().deleteFilesThreshold();
 
     if ((allFilesDeleted || filesDeletedThresholdExceeded) && displayDialog) {
         qCWarning(lcEngine) << "Many files are going to be deleted, asking the user";
         int side = 0; // > 0 means more deleted on the server.  < 0 means more deleted on the client
         for (const auto &it : std::as_const(_syncItems)) {
@@ -1278,7 +1288,7 @@
     _leadingAndTrailingSpacesFilesAllowed.append(filePath);
 }
 
 void SyncEngine::setLocalDiscoveryEnforceWindowsFileNameCompatibility(bool value)
 {
     _shouldEnforceWindowsFileNameCompatibility = value;
 }