feat: Handle Adobe lock files (InDesign, Premiere) in classic sync

src/libsync/filesystem.cpp

@@ -1,3 +1,3 @@
 /*
  * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2014 ownCloud GmbH
@@ -16,11 +16,14 @@
 #include <QDir>
 #include <QDirIterator>
 #include <QCoreApplication>
+#include <QRegularExpression>
 
 #include <array>
+#include <map>
 #include <optional>
 #include <ranges>
 #include <string_view>
+#include <vector>
 
 #ifdef Q_OS_WIN
 #include <securitybaseapi.h>
@@ -80,6 +83,96 @@
     });
 }
 
+// Unlike Office (`~$…`) and LibreOffice (`.~lock.…#`) lock files, Adobe lock file
+// names do not encode the guarded document's own extension, only its base name.
+// The guarded document has to be located among the lock file's siblings.
+// - `idlk`: InDesign documents (`indd`) and InCopy stories (`icml`).
+// - `prlock`: Premiere Pro projects (`prproj`).
+static const std::map<std::string_view, std::vector<std::string_view>> adobeLockFileDocumentExtensions = {
+    {"idlk", {"indd", "icml"}},
+    {"prlock", {"prproj"}},
+};
+
+bool isAdobeLockFileExtension(const QString &path)
+{
+    const auto suffix = QFileInfo{path}.suffix().toLower().toStdString();
+    return adobeLockFileDocumentExtensions.contains(suffix);
+}
+
+// Returns the candidate document extensions guarded by the given Adobe lock file
+// extension (lowercased, without the dot), in lookup order. Returns std::nullopt
+// if the extension is not a recognised Adobe lock file extension.
+std::optional<QList<QString>> adobeDocumentExtensionsFor(const QString &lockExtension)
+{
+    const auto lockExt = lockExtension.toStdString();
+    const auto it = adobeLockFileDocumentExtensions.find(lockExt);
+    if (it == adobeLockFileDocumentExtensions.cend()) {
+        return std::nullopt;
+    }
+    QList<QString> result;
+    result.reserve(static_cast<int>(it->second.size()));
+    for (const auto &documentExtension : it->second) {
+        result.append(QString::fromStdString(std::string(documentExtension)));
+    }
+    return result;
+}
+
+// Parses the document base name embedded in an Adobe lock file name.
+//   - InDesign / InCopy (.idlk): `Test` is extracted from `~Test~0kjyv(.idlk`.
+//   - Premiere Pro (.prlock): `Test` is extracted from `Test.prlock`.
+// Adobe lock file names drop the guarded document's own extension, so only the
+// base name can be recovered here. Returns std::nullopt if \a lockExtension is
+// not a recognised Adobe lock file extension, or if \a lockFileName does not
+// match the naming pattern expected for it.
+std::optional<QString> adobeLockFileDocumentBaseName(const QString &lockFileName, const QString &lockExtension)
+{
+    static const QRegularExpression idlkPattern(QStringLiteral(R"(^~(?<base>.+)~[^~]*\(\.idlk$)"),
+                                                QRegularExpression::CaseInsensitiveOption);
+    static const QRegularExpression prlockPattern(QStringLiteral(R"(^(?<base>.+)\.prlock$)"),
+                                                 QRegularExpression::CaseInsensitiveOption);
+
+    const auto pattern = lockExtension == QLatin1String("idlk")    ? &idlkPattern
+        : lockExtension == QLatin1String("prlock") ? &prlockPattern
+                                                   : nullptr;
+    if (!pattern) {
+        return std::nullopt;
+    }
+
+    const auto match = pattern->match(lockFileName);
+    if (!match.hasMatch()) {
+        return std::nullopt;
+    }
+    return match.captured(QStringLiteral("base"));
+}
+
+// Resolve the document guarded by an Adobe lock file by matching a sibling file
+// in the same directory by base name and expected document extension. Returns
+// the guarded document's absolute file path, or an empty string if no matching
+// document is found.
+std::optional<QString> adobeLockFileTargetFilePath(const QString &lockFilePath)
+{
+    const QFileInfo lockFileInfo{lockFilePath};
+    const auto lockExtension = QFileInfo{lockFileInfo.fileName()}.suffix().toLower();
+    const auto documentExtensions = adobeDocumentExtensionsFor(lockExtension);
+    if (!documentExtensions || documentExtensions->isEmpty()) {
+        return std::nullopt;
+    }
+
+    const auto baseName = adobeLockFileDocumentBaseName(lockFileInfo.fileName(), lockExtension);
+    if (!baseName || baseName->isEmpty()) {
+        return std::nullopt;
+    }
+
+    const QDir dir = lockFileInfo.dir();
+    for (const auto &documentExtension : *documentExtensions) {
+        const auto candidatePath = dir.absoluteFilePath(*baseName + QLatin1Char('.') + documentExtension);
+        if (QFileInfo::exists(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return std::nullopt;
+}
+
 // iterates through the dirPath to find the matching fileName
 QString findMatchingUnlockedFileInDir(const QString &dirPath, const QString &lockFileName)
 {
@@ -88,10 +181,10 @@
     const auto entryList = dir.entryInfoList(QDir::Files);
     for (const auto &candidateUnlockedFileInfo : entryList) {
         const auto candidateUnlockFileName = candidateUnlockedFileInfo.fileName();
         const auto lockFilePatternFoundIt = std::find_if(std::cbegin(lockFilePatterns), std::cend(lockFilePatterns), [&candidateUnlockFileName](std::string_view pattern) {
             return candidateUnlockFileName.contains(QString::fromStdString(std::string(pattern)));
         });
         if (lockFilePatternFoundIt != std::cend(lockFilePatterns)) {
             continue;
         }
         if (candidateUnlockFileName.contains(lockFileName)) {
@@ -129,6 +222,14 @@
         return QStringLiteral(".") + suffix;
     }
 
+    // Adobe lock files (.idlk / .prlock) are identified by extension, not prefix.
+    const auto suffix = QFileInfo{pathSplit.last()}.suffix().toLower().toStdString();
+    if (adobeLockFileDocumentExtensions.contains(suffix)) {
+        const auto pattern = QStringLiteral(".") + QString::fromStdString(suffix);
+        qCDebug(OCC::lcFileSystem) << "Found an Adobe lock file with extension:" << pattern << "in path:" << path;
+        return pattern;
+    }
+
     return {};
 }
 
@@ -139,11 +240,20 @@
     return std::find(std::cbegin(officeFileExtensions), std::cend(officeFileExtensions), extension) != std::cend(officeFileExtensions);
 }
 
 bool FileSystem::isMatchingAutoCADDocumentExtension(const QString &path)
 {
     return QFileInfo{path}.suffix().toLower().toStdString() == autoCADDocumentExtension;
 }
 
+bool FileSystem::isMatchingAdobeDocumentExtension(const QString &path)
+{
+    const auto pathSplit = path.split(QLatin1Char('.'));
+    const auto extension = pathSplit.size() > 1 ? pathSplit.last().toLower().toStdString() : std::string{};
+    return std::ranges::any_of(adobeLockFileDocumentExtensions, [&extension](const auto &entry) {
+        return std::ranges::any_of(entry.second, [&extension](const auto &documentExtension) { return documentExtension == extension; });
+    });
+}
+
 FileSystem::FileLockingInfo FileSystem::lockFileTargetFilePath(const QString &lockFilePath, const QString &lockFileNamePattern)
 {
     FileLockingInfo result;
@@ -155,7 +265,7 @@
     // the watcher does not prematurely unlock the document.
     if (isAutoCADLockFileExtension(lockFilePath)) {
         const auto targetPath = autoCADLockFileTargetFilePath(lockFilePath);
         if (targetPath) {
             result.path = *targetPath;
             if (QFile::exists(lockFilePath)) {
                 result.type = FileLockingInfo::Type::Locked;
@@ -166,6 +276,18 @@
         return result;
     }
 
+    // Adobe lock files (.idlk / .prlock) are resolved by sibling lookup — the lock
+    // file name carries only the document base name, not its extension.
+    if (isAdobeLockFileExtension(lockFilePath)) {
+        const auto adobeResolvedPath = adobeLockFileTargetFilePath(lockFilePath);
+        if (adobeResolvedPath) {
+            result.path = *adobeResolvedPath;
+            if (!result.path.isEmpty())
+                result.type = QFile::exists(lockFilePath) ? FileLockingInfo::Type::Locked : FileLockingInfo::Type::Unlocked;
+        }
+        return result;
+    }
+
     if (lockFileNamePattern.isEmpty()) {
         return result;
     }
@@ -179,19 +301,19 @@
 
     auto extensionSanitized = lockFilePathWithoutPrefixSplit.takeLast().toStdString();
     // remove possible non-alphabetical characters at the end of the extension
     extensionSanitized.erase(std::remove_if(extensionSanitized.begin(),
                                             extensionSanitized.end(),
                                             [](const auto &ch) {
                                                 return !std::isalnum(ch);
                                             }),
                              extensionSanitized.end());
 
     lockFilePathWithoutPrefixSplit.push_back(QString::fromStdString(extensionSanitized));
     const auto lockFilePathWithoutPrefixNew = lockFilePathWithoutPrefixSplit.join(QLatin1Char('.'));
 
     qCDebug(lcFileSystem) << "Assumed locked/unlocked file path" << lockFilePathWithoutPrefixNew << "Going to try to find matching file";
     auto splitFilePath = lockFilePathWithoutPrefixNew.split(QLatin1Char('/'));
     if (splitFilePath.size() > 1) {
         const auto lockFileNameWithoutPrefix = splitFilePath.takeLast();
         // some software will modify lock file name such that it does not correspond to original file (removing some symbols from the name, so we will
         // search for a matching file
@@ -271,7 +393,7 @@
     FilePermissionsRestore restore(filename, FileSystem::FolderPermissions::ReadWrite);
 #endif
 
     int rc = c_utimes(filename, modTime);
     if (rc != 0) {
         qCWarning(lcFileSystem) << "Error setting mtime for" << filename
                                 << "failed: rc" << rc << ", errno:" << errno;
@@ -329,14 +451,14 @@
 }
 
 // Code inspired from Qt5's QDir::removeRecursively
 bool FileSystem::removeRecursively(const QString &path,
                                    const std::function<void(const QString &path, bool isDir)> &onDeleted,
                                    QStringList *errors,
                                    const std::function<void(const QString &path, bool isDir)> &onError,
                                    const std::function<bool (const QString &, QString*)> &customDeleteFunction)
 {
     if (!FileSystem::setFolderPermissions(path, FileSystem::FolderPermissions::ReadWrite)) {
         if (onError) {
             onError(path, true);
         }
     }
@@ -372,7 +494,7 @@
                     errors->append(QCoreApplication::translate("FileSystem", "Error removing \"%1\": %2")
                                        .arg(QDir::toNativeSeparators(di.filePath()), removeError));
                 }
                 if (onError) {
                     onError(di.filePath(), false);
                 }
                 qCWarning(lcFileSystem) << "Error removing " << di.filePath() << ':' << removeError;
@@ -432,7 +554,7 @@
 bool FileSystem::getInode(const QString &filename, quint64 *inode)
 {
     csync_file_stat_t fs;
     if (csync_vio_local_stat(filename, &fs, true) == 0) {
         *inode = fs.inode;
         return true;
     }
@@ -457,7 +579,7 @@
 
     permissionsDidChange = true;
 #else
     const auto stdStrPath = path.toStdWString();
 
     try
     {
@@ -466,7 +588,7 @@
         const auto currentPermissions = std::filesystem::status(stdStrPath).permissions();
         qCDebug(lcFileSystem()).nospace() << "current permissions path=" << path << " perms=" << Qt::showbase << Qt::oct << static_cast<int>(currentPermissions);
 
         switch (permissions) {
         case OCC::FileSystem::FolderPermissions::ReadOnly: {
             qCDebug(lcFileSystem()).nospace() << "ensuring folder is read only path=" << path;
 
@@ -651,7 +773,7 @@
     {
         qCWarning(lcFileSystem()) << "exception when modifying folder permissions" << e.what() << "- path:" << path;
     }
     catch (...)
     {
         qCWarning(lcFileSystem()) << "exception when modifying folder permissions -  path:" << path;
     }
@@ -664,7 +786,7 @@
     }
 }
 
 bool FileSystem::uncheckedRenameReplace(const QString &originFileName, const QString &destinationFileName, QString *errorString)
 {
 #ifndef Q_OS_WIN
     bool success = false;
@@ -673,8 +795,8 @@
     // Qt 5.1 has QSaveFile::renameOverwrite we could use.
     // ### FIXME
     success = true;
     bool destExists = fileExists(destinationFileName);
     if (destExists && !QFile::remove(destinationFileName)) {
         *errorString = orig.errorString();
         qCWarning(lcFileSystem) << "Target file could not be removed.";
         success = false;

src/libsync/filesystem.h

@@ -6,7 +6,7 @@
 
 #pragma once
 
 #include "config.h"
 
 #include "owncloudlib.h"
 #include "common/filesystembase.h"
@@ -33,7 +33,7 @@
  * @brief This file contains file system helper
  */
 namespace FileSystem {
     class OWNCLOUDSYNC_EXPORT FilePermissionsRestore {
     public:
         explicit FilePermissionsRestore(const QString &path,
                                         FileSystem::FolderPermissions temporaryPermissions);
@@ -58,6 +58,8 @@
     bool OWNCLOUDSYNC_EXPORT isMatchingOfficeFileExtension(const QString &path);
     // check if it is an AutoCAD document (by .dwg extension), ONLY call it for files
     bool OWNCLOUDSYNC_EXPORT isMatchingAutoCADDocumentExtension(const QString &path);
+    // check if it is an Adobe document guarded by an Adobe lock file (by extension), ONLY call it for files
+    bool OWNCLOUDSYNC_EXPORT isMatchingAdobeDocumentExtension(const QString &path);
     // finds and fetches FileLockingInfo for the corresponding file that we are locking/unlocking
     FileLockingInfo OWNCLOUDSYNC_EXPORT lockFileTargetFilePath(const QString &lockFilePath, const QString &lockFileNamePattern);
     // lists all files matching a lockfile pattern in dirPath
@@ -127,10 +129,10 @@
 
     bool OWNCLOUDSYNC_EXPORT isFolderReadOnly(const std::filesystem::path &path) noexcept;
 
     /**
      * Rename the file \a originFileName to \a destinationFileName, and
      * overwrite the destination if it already exists - without extra checks.
      */
     bool OWNCLOUDSYNC_EXPORT uncheckedRenameReplace(const QString &originFileName,
                                                     const QString &destinationFileName,
                                                     QString *errorString);

src/libsync/syncengine.cpp

@@ -1,3 +1,3 @@
 /*
  * SPDX-FileCopyrightText: 2020 Nextcloud GmbH and Nextcloud contributors
  * SPDX-FileCopyrightText: 2014 ownCloud GmbH
@@ -383,7 +383,7 @@
                 const auto lockOwnerTypeToSkipReadonly = _account->capabilities().filesLockTypeAvailable()
                     ? SyncFileItem::LockOwnerType::TokenLock
                     : SyncFileItem::LockOwnerType::UserLock;
                 if (item->_locked == SyncFileItem::LockStatus::LockedItem
                     && (item->_lockOwnerType != lockOwnerTypeToSkipReadonly || item->_lockOwnerId != account()->davUser())) {
                     qCDebug(lcEngine()) << filePath << "file is locked: making it read only";
                     FileSystem::setFileReadOnly(filePath, true);
@@ -397,7 +397,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;
@@ -501,15 +501,15 @@
         const auto e2EeLockedFolders = _journal->e2EeLockedFolders();
 
         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;
                 }
                 // TODO: We need to rollback changes done to metadata in case we have an active lock, this needs to be implemented on the server first
                 const auto unlockJob = new OCC::UnlockEncryptFolderApiJob(_account, folderId, *folderToken, _journal, this);
                 unlockJob->setShouldRollbackMetadataChanges(true);
                 unlockJob->start();
@@ -638,7 +638,7 @@
     _discoveryPhase->_account = _account;
     _discoveryPhase->_excludes = _excludedFiles.data();
     const QString excludeFilePath = _localPath + QStringLiteral(".sync-exclude.lst");
     if (FileSystem::fileExists(excludeFilePath)) {
         _discoveryPhase->_excludes->addExcludeFilePath(excludeFilePath);
         _discoveryPhase->_excludes->reloadExcludeFiles();
     }
@@ -700,7 +700,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);
     });
@@ -721,7 +721,7 @@
         const auto databaseFingerprint = _journal->dataFingerprint();
         _discoveryPhase->_dataFingerprint = databaseFingerprint;
         ProcessDirectoryJob::PathTuple path = {};
         path._local = path._original = path._server = path._target = singleItemDiscoveryOptions().discoveryPath;
 
         SyncJournalFileRecord rec;
         const auto localQueryMode = _journal->getFileRecord(singleItemDiscoveryOptions().discoveryDirItem->_file, &rec) && rec.isValid()
@@ -871,8 +871,8 @@
         item->_direction == SyncFileItem::Up && item->_status == SyncFileItem::Success;
 
     if (isNewlyUploadedFile && item->_locked != SyncFileItem::LockStatus::LockedItem && _account->capabilities().filesLockAvailable() &&
-        (FileSystem::isMatchingOfficeFileExtension(item->_file) || FileSystem::isMatchingAutoCADDocumentExtension(item->_file))) {
+        (FileSystem::isMatchingOfficeFileExtension(item->_file) || FileSystem::isMatchingAutoCADDocumentExtension(item->_file) || FileSystem::isMatchingAdobeDocumentExtension(item->_file))) {
         {
             SyncJournalFileRecord rec;
             if (!_journal->getFileRecord(item->_file, &rec) || !rec.isValid()) {
                 qCWarning(lcEngine) << "Newly-created office file just uploaded but not in sync journal. Not going to lock it." << item->_file;
@@ -917,7 +917,7 @@
     detectFileLock(item);
 }
 
 void SyncEngine::slotPropagationFinished(OCC::SyncFileItem::Status status)
 {
     if (_propagator->_anotherSyncNeeded && _anotherSyncNeeded == NoFollowUpSync) {
         _anotherSyncNeeded = ImmediateFollowUp;
@@ -1032,7 +1032,7 @@
     }
 }
 
 void SyncEngine::cancelSyncOrContinue(bool cancel)
 {
     if (cancel) {
         qCInfo(lcEngine) << "User aborted sync";
@@ -1144,7 +1144,7 @@
         return false;
     }
 
     for (const auto &syncItem : _syncItems) {
         // If there's at least one remove instruction to be propagated to the remote: bail out, we might have lost a local rename.
         if (syncItem->_instruction == CSYNC_INSTRUCTION_REMOVE && syncItem->_direction == SyncFileItem::Up) {
             return true;
@@ -1153,7 +1153,7 @@
     return false;
 }
 
 bool SyncEngine::handleMassDeletion()
 {
     const auto displayDialog = ConfigFile().promptDeleteFiles() && !_syncOptions.isCmd();
     const auto allFilesDeleted = !_hasNoneFiles && _hasRemoveFile;
@@ -1163,11 +1163,11 @@
         if (oneItem->_instruction == CSYNC_INSTRUCTION_REMOVE) {
             if (oneItem->isDirectory()) {
                 const auto result = _journal->listFilesInPath(oneItem->_file.toUtf8(), [&deletionCounter] (const auto &oneRecord) {
                     if (oneRecord.isFile()) {
                         ++deletionCounter;
                     }
                 });
                 if (!result) {
                     qCDebug(lcEngine()) << "unable to find the number of files within a deleted folder:" << oneItem->_file;
                 }
             } else {
@@ -1177,7 +1177,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)) {
@@ -1186,7 +1186,7 @@
             }
         }
 
         promptUserBeforePropagation([this, side](auto &&callback){
             emit aboutToRemoveAllFiles(side >= 0 ? SyncFileItem::Down : SyncFileItem::Up, callback);
         });
         return true;
@@ -1211,7 +1211,7 @@
         slotAddTouchedFile(_localPath + oneFolder->_file);
 
         if (oneFolder->_type == ItemType::ItemTypeDirectory) {
             const auto deletionCallback = [this] (const QString &deleteItem, bool) {
                 slotAddTouchedFile(deleteItem);
             };
 
@@ -1228,7 +1228,7 @@
 {
     QPointer<QObject> guard = new QObject();
     QPointer<QObject> self = this;
     auto callback = [this, self, guard](bool cancel) -> void {
         // use a guard to ensure its only called once...
         // qpointer to self to ensure we still exist
         if (!guard || !self) {
@@ -1278,7 +1278,7 @@
     _leadingAndTrailingSpacesFilesAllowed.append(filePath);
 }
 
 void SyncEngine::setLocalDiscoveryEnforceWindowsFileNameCompatibility(bool value)
 {
     _shouldEnforceWindowsFileNameCompatibility = value;
 }
@@ -1315,14 +1315,14 @@
     // This invariant is used in SyncEngine::shouldDiscoverLocally
     QString prev;
     auto it = _localDiscoveryPaths.begin();
     while(it != _localDiscoveryPaths.end()) {
         if (!prev.isNull() && it->startsWith(prev) && (prev.endsWith('/') || *it == prev || it->at(prev.size()) <= '/')) {
             it = _localDiscoveryPaths.erase(it);
         } else {
             prev = *it;
             ++it;
         }
     }
 }
 
 void SyncEngine::setSingleItemDiscoveryOptions(const SingleItemDiscoveryOptions &singleItemDiscoveryOptions)
@@ -1335,7 +1335,7 @@
     return _singleItemDiscoveryOptions;
 }
 
 void SyncEngine::setFilesystemPermissionsReliable(bool reliable)
 {
     _filesystemPermissionsReliable = reliable;
 }
@@ -1573,7 +1573,7 @@
          it != _discoveryPhase->_filesNeedingScheduledSync.cend();
          ++it) {
 
         const auto file = it.key();
         const auto syncScheduledSecs = it.value();
 
         // We don't want to schedule syncs again for files we have already discovered needing a

sync-exclude.lst

@@ -5,6 +5,13 @@
 .~lock.*
 ~*.tmp
 
+# Adobe lock files: InDesign/InCopy (.idlk) and Premiere Pro (.prlock)
+# lock files. Unlike Office/LibreOffice lock files they do not encode the
+# guarded document's extension, but excluding them by extension is safe as
+# no legitimate user document uses it.
+*.idlk
+*.prlock
+
 # AutoCAD lock files (.dwl / .dwl2) created when opening a .dwg drawing.
 # Both share the document's base name and are deleted when it is closed.
 *.dwl

test/testexcludedfiles.cpp

@@ -8,7 +8,7 @@
  * any purpose.
  */
 
 #include <QtTest>
 #include <QTemporaryDir>
 
 #include "csync_exclude.h"
@@ -182,6 +182,18 @@
         QCOMPARE(check_file_full("my.~directory"), CSYNC_FILE_EXCLUDE_AND_REMOVE);
         QCOMPARE(check_file_full("/a_folder/my.~directory"), CSYNC_FILE_EXCLUDE_AND_REMOVE);
 
+        /* Adobe lock files are excluded by extension (.idlk/.prlock) */
+        QCOMPARE(check_file_full("Test.idlk"), CSYNC_FILE_EXCLUDE_LIST);
+        QCOMPARE(check_file_full("~Test~0kjyv(.idlk"), CSYNC_FILE_EXCLUDE_LIST);
+        QCOMPARE(check_file_full("subdir/Test.idlk"), CSYNC_FILE_EXCLUDE_LIST);
+        QCOMPARE(check_file_full("Test.prlock"), CSYNC_FILE_EXCLUDE_LIST);
+        QCOMPARE(check_file_full("subdir/Test.prlock"), CSYNC_FILE_EXCLUDE_LIST);
+
+        /* Adobe documents themselves are NOT excluded */
+        QCOMPARE(check_file_full("Test.indd"), CSYNC_NOT_EXCLUDED);
+        QCOMPARE(check_file_full("Test.icml"), CSYNC_NOT_EXCLUDED);
+        QCOMPARE(check_file_full("Test.prproj"), CSYNC_NOT_EXCLUDED);
+
         /* Not excluded because the pattern .netscape/cache requires directory. */
         QCOMPARE(check_file_full(".netscape/cache"), CSYNC_NOT_EXCLUDED);
 

test/testlockfile.cpp

@@ -1,9 +1,9 @@
 /*
  * SPDX-FileCopyrightText: 2022 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "lockfilejobs.h"
 
 #include "account.h"
 #include "accountstate.h"
@@ -828,6 +828,33 @@
         QCOMPARE(lockFileDetectedNewlyUploadedSpy.count(), 1);
     }
 
+    void testLockFile_lockFile_detect_newly_uploaded_adobe_idlk()
+    {
+        // InDesign: opening a .indd creates `~{base}~{token}(.idlk`, which carries
+        // only the document's base name. The guarded document is resolved by
+        // matching a sibling .indd/.icml file in the same directory.
+        const auto testFileName = QStringLiteral("document.indd");
+        const auto testLockFileName = QStringLiteral("~document~0kjyv(.idlk");
+
+        const auto testDocumentsDirName = "documents";
+
+        FakeFolder fakeFolder{FileInfo{}};
+        fakeFolder.localModifier().mkdir(testDocumentsDirName);
+        // Adobe lock files are excluded from sync by the default exclude list;
+        // the FakeFolder does not load it, so replicate the exclusion here.
+        fakeFolder.syncEngine().excludedFiles().addManualExclude(QStringLiteral("*.idlk"));
+
+        fakeFolder.syncEngine().account()->setCapabilities({{"files", QVariantMap{{"locking", QByteArray{"1.0"}}}}});
+        QSignalSpy lockFileDetectedNewlyUploadedSpy(&fakeFolder.syncEngine(), &OCC::SyncEngine::lockFileDetected);
+
+        fakeFolder.localModifier().insert(testDocumentsDirName + QStringLiteral("/") + testLockFileName);
+        fakeFolder.localModifier().insert(testDocumentsDirName + QStringLiteral("/") + testFileName);
+
+        QVERIFY(fakeFolder.syncOnce());
+
+        QCOMPARE(lockFileDetectedNewlyUploadedSpy.count(), 1);
+    }
+
     void testLockFile_autoCADLockFileTargetFilePath_resolution()
     {
         QTemporaryDir dir;
@@ -883,6 +910,105 @@
         QVERIFY(orphan.path.isEmpty());
     }
 
+    void testLockFile_lockFile_detect_newly_uploaded_adobe_prlock()
+    {
+        // Premiere Pro: opening a .prproj creates `{base}.prlock`.
+        const auto testFileName = QStringLiteral("project.prproj");
+        const auto testLockFileName = QStringLiteral("project.prlock");
+
+        const auto testDocumentsDirName = "documents";
+
+        FakeFolder fakeFolder{FileInfo{}};
+        fakeFolder.localModifier().mkdir(testDocumentsDirName);
+        fakeFolder.syncEngine().excludedFiles().addManualExclude(QStringLiteral("*.prlock"));
+
+        fakeFolder.syncEngine().account()->setCapabilities({{"files", QVariantMap{{"locking", QByteArray{"1.0"}}}}});
+        QSignalSpy lockFileDetectedNewlyUploadedSpy(&fakeFolder.syncEngine(), &OCC::SyncEngine::lockFileDetected);
+
+        fakeFolder.localModifier().insert(testDocumentsDirName + QStringLiteral("/") + testLockFileName);
+        fakeFolder.localModifier().insert(testDocumentsDirName + QStringLiteral("/") + testFileName);
+
+        QVERIFY(fakeFolder.syncOnce());
+
+        QCOMPARE(lockFileDetectedNewlyUploadedSpy.count(), 1);
+    }
+
+    void testLockFile_adobeLockFileTargetFilePath_resolution()
+    {
+        QTemporaryDir dir;
+        QVERIFY(dir.isValid());
+        const auto dirPath = dir.path() + QLatin1Char('/');
+
+        // InDesign: `~{base}~{token}(.idlk` guards `{base}.indd`.
+        const auto inddPath = dirPath + QStringLiteral("Test.indd");
+        const auto idlkPath = dirPath + QStringLiteral("~Test~0kjyv(.idlk");
+        QVERIFY(QFile{inddPath}.open(QIODevice::WriteOnly));
+        QVERIFY(QFile{idlkPath}.open(QIODevice::WriteOnly));
+
+        const auto idlkResolved = OCC::FileSystem::lockFileTargetFilePath(idlkPath, QString{});
+        QCOMPARE(idlkResolved.path, inddPath);
+        QCOMPARE(idlkResolved.type, OCC::FileSystem::FileLockingInfo::Type::Locked);
+
+        // Removing the lock file marks the document as unlocked (sibling still present).
+        QVERIFY(QFile::remove(idlkPath));
+        const auto idlkUnlocked = OCC::FileSystem::lockFileTargetFilePath(idlkPath, QString{});
+        QCOMPARE(idlkUnlocked.path, inddPath);
+        QCOMPARE(idlkUnlocked.type, OCC::FileSystem::FileLockingInfo::Type::Unlocked);
+
+        // Premiere Pro: `{base}.prlock` guards `{base}.prproj`.
+        const auto prprojPath = dirPath + QStringLiteral("project.prproj");
+        const auto prlockPath = dirPath + QStringLiteral("project.prlock");
+        QVERIFY(QFile{prprojPath}.open(QIODevice::WriteOnly));
+        QVERIFY(QFile{prlockPath}.open(QIODevice::WriteOnly));
+
+        const auto prlockResolved = OCC::FileSystem::lockFileTargetFilePath(prlockPath, QString{});
+        QCOMPARE(prlockResolved.path, prprojPath);
+        QCOMPARE(prlockResolved.type, OCC::FileSystem::FileLockingInfo::Type::Locked);
+
+        // InCopy story: `.idlk` may guard an `.icml` when no `.indd` sibling exists.
+        const auto icmlPath = dirPath + QStringLiteral("story.icml");
+        const auto idlk2Path = dirPath + QStringLiteral("~story~ab12cd(.idlk");
+        QVERIFY(QFile{icmlPath}.open(QIODevice::WriteOnly));
+        QVERIFY(QFile{idlk2Path}.open(QIODevice::WriteOnly));
+        const auto idlk2Resolved = OCC::FileSystem::lockFileTargetFilePath(idlk2Path, QString{});
+        QCOMPARE(idlk2Resolved.path, icmlPath);
+        QCOMPARE(idlk2Resolved.type, OCC::FileSystem::FileLockingInfo::Type::Locked);
+
+        // A non-lock file resolves to nothing.
+        const auto nonLock = OCC::FileSystem::lockFileTargetFilePath(dirPath + QStringLiteral("notes.txt"), QString{});
+        QVERIFY(nonLock.path.isEmpty());
+        QCOMPARE(nonLock.type, OCC::FileSystem::FileLockingInfo::Type::Unset);
+
+        // A lock file with no matching sibling document resolves to nothing.
+        const auto orphanIdlkPath = dirPath + QStringLiteral("~orphan~zz(.idlk");
+        QVERIFY(QFile{orphanIdlkPath}.open(QIODevice::WriteOnly));
+        const auto orphan = OCC::FileSystem::lockFileTargetFilePath(orphanIdlkPath, QString{});
+        QVERIFY(orphan.path.isEmpty());
+
+        // An .idlk file whose name does not match the InDesign `~base~token(.idlk`
+        // pattern resolves to nothing — the regex fails, base name is nullopt.
+        const QStringList malformedIdlkNames = {
+            QStringLiteral("Test.idlk"),        // missing leading ~ and token
+            QStringLiteral("~Test.idlk"),       // missing ~token(
+            QStringLiteral("~Test~token.idlk"), // missing trailing (
+            QStringLiteral("Test~token(.idlk"), // missing leading ~
+        };
+        for (const auto &malformedName : malformedIdlkNames) {
+            const auto malformedPath = dirPath + malformedName;
+            QVERIFY(QFile{malformedPath}.open(QIODevice::WriteOnly));
+            const auto resolved = OCC::FileSystem::lockFileTargetFilePath(malformedPath, QString{});
+            QVERIFY2(resolved.path.isEmpty(), qPrintable(QStringLiteral("Expected empty path for malformed idlk name: %1").arg(malformedName)));
+            QFile::remove(malformedPath);
+        }
+
+        // A non-Adobe, non-Office extension resolves to nothing.
+        const auto unknownExtPath = dirPath + QStringLiteral("file.unknown");
+        QVERIFY(QFile{unknownExtPath}.open(QIODevice::WriteOnly));
+        const auto unknownExt = OCC::FileSystem::lockFileTargetFilePath(unknownExtPath, QString{});
+        QVERIFY(unknownExt.path.isEmpty());
+        QCOMPARE(unknownExt.type, OCC::FileSystem::FileLockingInfo::Type::Unset);
+    }
+
     void testLockFile_verifyE2eeFilesUseCorrectPath()
     {
         const auto e2eeRoot = QStringLiteral("encrypted");