${CMAKE_CURRENT_LIST_DIR}/syncjournaldb.cpp
${CMAKE_CURRENT_LIST_DIR}/syncjournalfilerecord.cpp
${CMAKE_CURRENT_LIST_DIR}/utility.cpp
+ ${CMAKE_CURRENT_LIST_DIR}/remotepermissions.cpp
)
--- /dev/null
+/*
+ * Copyright (C) by Olivier Goffart <ogoffart@woboq.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "remotepermissions.h"
+#include <cstring>
+
+namespace OCC {
+
+static const char letters[] = " WDNVCKRSMm";
+
+
+template <typename Char>
+void RemotePermissions::fromArray(const Char *p)
+{
+ _value = p ? notNullMask : 0;
+ if (!p)
+ return;
+ while (*p) {
+ if (auto res = std::strchr(letters, static_cast<char>(*p)))
+ _value |= (1 << (res - letters));
+ ++p;
+ }
+}
+
+RemotePermissions::RemotePermissions(const char *p)
+{
+ fromArray(p);
+}
+
+RemotePermissions::RemotePermissions(const QString &s)
+{
+ fromArray(s.isEmpty() ? nullptr : s.utf16());
+}
+
+QByteArray RemotePermissions::toString() const
+{
+ QByteArray result;
+ if (isNull())
+ return result;
+ result.reserve(PermissionsCount);
+ for (uint i = 1; i <= PermissionsCount; ++i) {
+ if (_value & (1 << i))
+ result.append(letters[i]);
+ }
+ if (result.isEmpty()) {
+ // Make sure it is not empty so we can differentiate null and empty permissions
+ result.append(' ');
+ }
+ return result;
+}
+
+} // namespace OCC
--- /dev/null
+/*
+ * Copyright (C) by Olivier Goffart <ogoffart@woboq.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#pragma once
+
+#include <QString>
+#include <QMetaType>
+#include "ocsynclib.h"
+
+namespace OCC {
+
+/**
+ * Class that store in a memory efficient way the remote permission
+ */
+class OCSYNC_EXPORT RemotePermissions
+{
+private:
+ // The first bit tells if the value is set or not
+ // The remaining bits correspond to know if the value is set
+ quint16 _value = 0;
+ static constexpr int notNullMask = 0x1;
+
+ template <typename Char> // can be 'char' or 'ushort' if conversion from QString
+ void fromArray(const Char *p);
+
+public:
+ enum Permissions {
+ CanWrite = 1, // W
+ CanDelete = 2, // D
+ CanRename = 3, // N
+ CanMove = 4, // V
+ CanAddFile = 5, // C
+ CanAddSubDirectories = 6, // K
+ CanReshare = 7, // R
+ // Note: on the server, this means SharedWithMe, but in discoveryphase.cpp we also set
+ // this permission when the server reports the any "share-types"
+ IsShared = 8, // S
+ IsMounted = 9, // M
+ IsMountedSub = 10, // m (internal: set if the parent dir has IsMounted)
+
+ // Note: when adding support for more permissions, we need to invalid the cache in the database.
+ // (by setting forceRemoteDiscovery in SyncJournalDb::checkConnect)
+ PermissionsCount = IsMountedSub
+ };
+ RemotePermissions() = default;
+ explicit RemotePermissions(const char *);
+ explicit RemotePermissions(const QString &);
+
+ QByteArray toString() const;
+ bool hasPermission(Permissions p) const
+ {
+ return _value & (1 << static_cast<int>(p));
+ }
+ void setPermission(Permissions p)
+ {
+ _value |= (1 << static_cast<int>(p)) | notNullMask;
+ }
+ void unsetPermission(Permissions p)
+ {
+ _value &= ~(1 << static_cast<int>(p));
+ }
+
+ bool isNull() const { return !(_value & notNullMask); }
+ friend bool operator==(RemotePermissions a, RemotePermissions b)
+ {
+ return a._value == b._value;
+ }
+ friend bool operator!=(RemotePermissions a, RemotePermissions b)
+ {
+ return !(a == b);
+ }
+};
+
+
+} // namespace OCC
+
+Q_DECLARE_METATYPE(OCC::RemotePermissions)
qCInfo(lcDb) << "Updating file record for path:" << record._path << "inode:" << record._inode
<< "modtime:" << record._modtime << "type:" << record._type
- << "etag:" << record._etag << "fileId:" << record._fileId << "remotePerm:" << record._remotePerm
+ << "etag:" << record._etag << "fileId:" << record._fileId << "remotePerm:" << record._remotePerm.toString()
<< "fileSize:" << record._fileSize << "checksum:" << record._checksumHeader;
qlonglong phash = getPHash(record._path);
QString fileId(record._fileId);
if (fileId.isEmpty())
fileId = "";
- QString remotePerm(record._remotePerm);
- if (remotePerm.isEmpty())
- remotePerm = QString(); // have NULL in DB (vs empty)
+ QByteArray remotePerm = record._remotePerm.toString();
QByteArray checksumType, checksum;
parseChecksumHeader(record._checksumHeader, &checksumType, &checksum);
int contentChecksumTypeId = mapChecksumType(checksumType);
rec._type = _getFileRecordQuery->intValue(6);
rec._etag = _getFileRecordQuery->baValue(7);
rec._fileId = _getFileRecordQuery->baValue(8);
- rec._remotePerm = _getFileRecordQuery->baValue(9);
+ rec._remotePerm = RemotePermissions(_getFileRecordQuery->baValue(9).constData());
rec._fileSize = _getFileRecordQuery->int64Value(10);
rec._serverHasIgnoredFiles = (_getFileRecordQuery->intValue(11) > 0);
rec._checksumHeader = _getFileRecordQuery->baValue(12);
#include <QDateTime>
#include "ocsynclib.h"
+#include "remotepermissions.h"
namespace OCC {
QByteArray _etag;
QByteArray _fileId;
qint64 _fileSize;
- QByteArray _remotePerm;
+ RemotePermissions _remotePerm;
bool _serverHasIgnoredFiles;
QByteArray _checksumHeader;
};
#include <config_csync.h>
#include <memory>
#include <QByteArray>
+#include "common/remotepermissions.h"
#if defined(Q_CC_GNU) && !defined(Q_CC_INTEL) && !defined(Q_CC_CLANG) && (__GNUC__ * 100 + __GNUC_MINOR__ < 408)
// openSuse 12.3 didn't like enum bitfields.
time_t modtime;
int64_t size;
uint64_t inode;
+
+ OCC::RemotePermissions remotePerm;
enum csync_ftw_type_e type BITFIELD(4);
bool child_modified BITFIELD(1);
bool has_ignored_files BITFIELD(1); // Specify that a directory, or child directory contains ignored files.
QByteArray file_id;
QByteArray directDownloadUrl;
QByteArray directDownloadCookies;
- QByteArray remotePerm;
QByteArray original_path; // only set if locale conversion fails
// In the local tree, this can hold a checksum and its type if it is
/* hooks for checking the white list (uses the update_callback_userdata) */
int (*checkSelectiveSyncBlackListHook)(void*, const QByteArray &) = nullptr;
- int (*checkSelectiveSyncNewFolderHook)(void*, const QByteArray &/* path */, const QByteArray &/* remotePerm */) = nullptr;
+ int (*checkSelectiveSyncNewFolderHook)(void *, const QByteArray & /* path */, OCC::RemotePermissions) = nullptr;
csync_vio_opendir_hook remote_opendir_hook = nullptr;
struct {
FileMap files;
bool read_from_db = false;
- QByteArray root_perms; /* Permission of the root folder. (Since the root folder is not in the db tree, we need to keep a separate entry.) */
+ OCC::RemotePermissions root_perms; /* Permission of the root folder. (Since the root folder is not in the db tree, we need to keep a separate entry.) */
} remote;
/* replica we are currently walking */
st->type = static_cast<enum csync_ftw_type_e>(sqlite3_column_int(stmt, 3));
st->etag = (char*)sqlite3_column_text(stmt, 4);
st->file_id = (char*)sqlite3_column_text(stmt, 5);
- st->remotePerm = (char*)sqlite3_column_text(stmt, 6);
+ const char *permStr = (char *)sqlite3_column_text(stmt, 6);
+ // If permStr is empty, construct a null RemotePermissions. We make sure that non-null
+ // permissions are never empty in RemotePermissions.toString()
+ st->remotePerm = permStr && *permStr ? OCC::RemotePermissions(permStr) : OCC::RemotePermissions();
st->size = sqlite3_column_int64(stmt, 7);
st->has_ignored_files = sqlite3_column_int(stmt, 8);
st->checksumHeader = (char *)sqlite3_column_text(stmt, 9);
/* we have an update! */
CSYNC_LOG(CSYNC_LOG_PRIORITY_INFO, "Database entry found, compare: %" PRId64 " <-> %" PRId64
", etag: %s <-> %s, inode: %" PRId64 " <-> %" PRId64
- ", size: %" PRId64 " <-> %" PRId64 ", perms: %s <-> %s, ignore: %d",
+ ", size: %" PRId64 " <-> %" PRId64 ", perms: %x <-> %x, ignore: %d",
((int64_t) fs->modtime), ((int64_t) tmp->modtime),
fs->etag.constData(), tmp->etag.constData(), (uint64_t) fs->inode, (uint64_t) tmp->inode,
- (uint64_t) fs->size, (uint64_t) tmp->size, fs->remotePerm.constData(), tmp->remotePerm.constData(), tmp->has_ignored_files );
+ (uint64_t) fs->size, (uint64_t) tmp->size, *reinterpret_cast<short*>(&fs->remotePerm), *reinterpret_cast<short*>(&tmp->remotePerm), tmp->has_ignored_files );
if (ctx->current == REMOTE_REPLICA && fs->etag != tmp->etag) {
fs->instruction = CSYNC_INSTRUCTION_EVAL;
bool resharingAllowed = true; // lets assume the good
if (fileRecord.isValid()) {
// check the permission: Is resharing allowed?
- if (!fileRecord._remotePerm.contains('R')) {
+ if (!fileRecord._remotePerm.isNull() && !fileRecord._remotePerm.hasPermission(RemotePermissions::CanReshare)) {
resharingAllowed = false;
}
}
return static_cast<DiscoveryJob *>(data)->isInSelectiveSyncBlackList(path);
}
-bool DiscoveryJob::checkSelectiveSyncNewFolder(const QString &path, const QByteArray &remotePerm)
+bool DiscoveryJob::checkSelectiveSyncNewFolder(const QString &path, RemotePermissions remotePerm)
{
- if (_syncOptions._confirmExternalStorage && remotePerm.contains('M')) {
- // 'M' in the permission means external storage.
+ if (_syncOptions._confirmExternalStorage
+ && remotePerm.hasPermission(RemotePermissions::IsMounted)) {
+ // external storage.
/* Note: DiscoverySingleDirectoryJob::directoryListingIteratedSlot make sure that only the
* root of a mounted storage has 'M', all sub entries have 'm' */
}
}
-int DiscoveryJob::checkSelectiveSyncNewFolderCallback(void *data, const QByteArray &path, const QByteArray &remotePerm)
+int DiscoveryJob::checkSelectiveSyncNewFolderCallback(void *data, const QByteArray &path, RemotePermissions remotePerm)
{
return static_cast<DiscoveryJob *>(data)->checkSelectiveSyncNewFolder(QString::fromUtf8(path), remotePerm);
}
} else if (property == "dDC") {
file_stat->directDownloadCookies = value.toUtf8();
} else if (property == "permissions") {
- file_stat->remotePerm = value.toUtf8();
+ file_stat->remotePerm = RemotePermissions(value);
} else if (property == "checksums") {
file_stat->checksumHeader = findBestChecksum(value.toUtf8());
} else if (property == "share-types" && !value.isEmpty()) {
- // Since QMap is sorted, "share-types" is always "permissions".
- if (file_stat->remotePerm.isEmpty()) {
+ // Since QMap is sorted, "share-types" is always after "permissions".
+ if (file_stat->remotePerm.isNull()) {
qWarning() << "Server returned a share type, but no permissions?";
} else {
// S means shared with me.
// But for our purpose, we want to know if the file is shared. It does not matter
// if we are the owner or not.
- // Piggy back on the persmission field 'S'
- if (!file_stat->remotePerm.contains('S'))
- file_stat->remotePerm.append('S');
+ // Piggy back on the persmission field
+ file_stat->remotePerm.setPermission(RemotePermissions::IsShared);
}
}
}
// The first entry is for the folder itself, we should process it differently.
_ignoredFirst = true;
if (map.contains("permissions")) {
- auto perm = map.value("permissions");
+ RemotePermissions perm(map.value("permissions"));
emit firstDirectoryPermissions(perm);
- _isExternalStorage = perm.contains(QLatin1Char('M'));
+ _isExternalStorage = perm.hasPermission(RemotePermissions::IsMounted);
}
if (map.contains("data-fingerprint")) {
_dataFingerprint = map.value("data-fingerprint").toUtf8();
if (file_stat->etag.isEmpty()) {
qCCritical(lcDiscovery) << "etag of" << file_stat->path << "is" << file_stat->etag << "This must not happen.";
}
- if (_isExternalStorage) {
+ if (_isExternalStorage && file_stat->remotePerm.hasPermission(RemotePermissions::IsMounted)) {
/* All the entries in a external storage have 'M' in their permission. However, for all
purposes in the desktop client, we only need to know about the mount points.
So replace the 'M' by a 'm' for every sub entries in an external storage */
- file_stat->remotePerm.replace('M', 'm');
+ file_stat->remotePerm.unsetPermission(RemotePermissions::IsMounted);
+ file_stat->remotePerm.setPermission(RemotePermissions::IsMountedSub);
}
QStringRef fileRef(&file);
_discoveryJob->_vioMutex.unlock();
}
-void DiscoveryMainThread::singleDirectoryJobFirstDirectoryPermissionsSlot(const QString &p)
+void DiscoveryMainThread::singleDirectoryJobFirstDirectoryPermissionsSlot(RemotePermissions p)
{
// Should be thread safe since the sync thread is blocked
- if (_discoveryJob->_csync_ctx->remote.root_perms.isEmpty()) {
- qCDebug(lcDiscovery) << "Permissions for root dir:" << p;
- _discoveryJob->_csync_ctx->remote.root_perms = p.toUtf8();
+ if (_discoveryJob->_csync_ctx->remote.root_perms.isNull()) {
+ qCDebug(lcDiscovery) << "Permissions for root dir:" << p.toString();
+ _discoveryJob->_csync_ctx->remote.root_perms = p;
}
}
// This is not actually a network job, it is just a job
signals:
- void firstDirectoryPermissions(const QString &);
+ void firstDirectoryPermissions(RemotePermissions);
void etagConcatenation(const QString &);
void etag(const QString &);
void finishedWithResult();
// From Job:
void singleDirectoryJobResultSlot();
void singleDirectoryJobFinishedWithErrorSlot(int csyncErrnoCode, const QString &msg);
- void singleDirectoryJobFirstDirectoryPermissionsSlot(const QString &);
+ void singleDirectoryJobFirstDirectoryPermissionsSlot(RemotePermissions);
void slotGetSizeFinishedWithError();
void slotGetSizeResult(const QVariantMap &);
*/
bool isInSelectiveSyncBlackList(const QByteArray &path) const;
static int isInSelectiveSyncBlackListCallback(void *, const QByteArray &);
- bool checkSelectiveSyncNewFolder(const QString &path, const QByteArray &remotePerm);
- static int checkSelectiveSyncNewFolderCallback(void *data, const QByteArray &path, const QByteArray &remotePerm);
+ bool checkSelectiveSyncNewFolder(const QString &path, RemotePermissions rp);
+ static int checkSelectiveSyncNewFolderCallback(void *data, const QByteArray &path, RemotePermissions rm);
// Just for progress
static void update_job_update_callback(bool local,
}
// Apply the remote permissions
- // Older server versions sometimes provide empty remote permissions
- // see #4450 - don't adjust the write permissions there.
- const int serverVersionGoodRemotePerm = Account::makeServerVersion(7, 0, 0);
- if (propagator()->account()->serverVersionInt() >= serverVersionGoodRemotePerm) {
- FileSystem::setFileReadOnlyWeak(_tmpFile.fileName(),
- !_item->_remotePerm.contains('W'));
- }
+ FileSystem::setFileReadOnlyWeak(_tmpFile.fileName(), !_item->_remotePerm.isNull() && !_item->_remotePerm.hasPermission(RemotePermissions::CanWrite));
QString error;
emit propagator()->touchedFile(fn);
done(isConflict ? SyncFileItem::Conflict : SyncFileItem::Success);
// handle the special recall file
- if (!_item->_remotePerm.contains("S")
+ if (!_item->_remotePerm.hasPermission(RemotePermissions::IsShared)
&& (_item->_file == QLatin1String(".sys.admin#recall#")
|| _item->_file.endsWith("/.sys.admin#recall#"))) {
handleRecallFile(fn, propagator()->_localDir, *propagator()->_journal);
if (!file->directDownloadCookies.isEmpty()) {
item->_directDownloadCookies = QString::fromUtf8(file->directDownloadCookies);
}
- if (!file->remotePerm.isEmpty()) {
+ if (!file->remotePerm.isNull()) {
item->_remotePerm = file->remotePerm;
}
// If the 'W' remote permission changed, update the local filesystem
SyncJournalFileRecord prev = _journal->getFileRecord(item->_file);
- if (prev.isValid() && prev._remotePerm.contains('W') != item->_remotePerm.contains('W')) {
- const bool isReadOnly = !item->_remotePerm.contains('W');
+ if (prev.isValid() && prev._remotePerm.hasPermission(RemotePermissions::CanWrite) != item->_remotePerm.hasPermission(RemotePermissions::CanWrite)) {
+ const bool isReadOnly = !item->_remotePerm.isNull() && !item->_remotePerm.hasPermission(RemotePermissions::CanWrite);
FileSystem::setFileReadOnlyWeak(filePath, isReadOnly);
}
qCWarning(lcEngine) << "Error in remote treewalk.";
}
- qCInfo(lcEngine) << "Permissions of the root folder: " << _csync_ctx->remote.root_perms;
+ qCInfo(lcEngine) << "Permissions of the root folder: " << _csync_ctx->remote.root_perms.toString();
// The map was used for merging trees, convert it to a list:
SyncFileItemVector syncItems = _syncItemMap.values().toVector();
case CSYNC_INSTRUCTION_NEW: {
int slashPos = (*it)->_file.lastIndexOf('/');
QString parentDir = slashPos <= 0 ? "" : (*it)->_file.mid(0, slashPos);
- const QByteArray perms = getPermissions(parentDir);
+ const auto perms = getPermissions(parentDir);
if (perms.isNull()) {
// No permissions set
break;
- } else if ((*it)->isDirectory() && !perms.contains("K")) {
+ } else if ((*it)->isDirectory() && !perms.hasPermission(RemotePermissions::CanAddSubDirectories)) {
qCWarning(lcEngine) << "checkForPermission: ERROR" << (*it)->_file;
(*it)->_instruction = CSYNC_INSTRUCTION_ERROR;
(*it)->_status = SyncFileItem::NormalError;
(*it)->_errorString = tr("Not allowed because you don't have permission to add parent folder");
}
- } else if (!(*it)->isDirectory() && !perms.contains("C")) {
+ } else if (!(*it)->isDirectory() && !perms.hasPermission(RemotePermissions::CanAddFile)) {
qCWarning(lcEngine) << "checkForPermission: ERROR" << (*it)->_file;
(*it)->_instruction = CSYNC_INSTRUCTION_ERROR;
(*it)->_status = SyncFileItem::NormalError;
break;
}
case CSYNC_INSTRUCTION_SYNC: {
- const QByteArray perms = getPermissions((*it)->_file);
+ const auto perms = getPermissions((*it)->_file);
if (perms.isNull()) {
// No permissions set
break;
}
- if (!perms.contains("W")) {
+ if (!perms.hasPermission(RemotePermissions::CanWrite)) {
qCWarning(lcEngine) << "checkForPermission: RESTORING" << (*it)->_file;
(*it)->_instruction = CSYNC_INSTRUCTION_CONFLICT;
(*it)->_direction = SyncFileItem::Down;
break;
}
case CSYNC_INSTRUCTION_REMOVE: {
- const QByteArray perms = getPermissions((*it)->_file);
+ const auto perms = getPermissions((*it)->_file);
if (perms.isNull()) {
// No permissions set
break;
}
- if (!perms.contains("D")) {
+ if (!perms.hasPermission(RemotePermissions::CanDelete)) {
qCWarning(lcEngine) << "checkForPermission: RESTORING" << (*it)->_file;
(*it)->_instruction = CSYNC_INSTRUCTION_NEW;
(*it)->_direction = SyncFileItem::Down;
(*it)->_errorString = tr("Not allowed to remove, restoring");
}
}
- } else if (perms.contains("S") && perms.contains("D")) {
+ } else if (perms.hasPermission(RemotePermissions::IsShared)
+ && perms.hasPermission(RemotePermissions::CanDelete)) {
// this is a top level shared dir which can be removed to unshare it,
// regardless if it is a read only share or not.
// To avoid that we try to restore files underneath this dir which have
case CSYNC_INSTRUCTION_RENAME: {
int slashPos = (*it)->_renameTarget.lastIndexOf('/');
const QString parentDir = slashPos <= 0 ? "" : (*it)->_renameTarget.mid(0, slashPos);
- const QByteArray destPerms = getPermissions(parentDir);
- const QByteArray filePerms = getPermissions((*it)->_file);
+ const auto destPerms = getPermissions(parentDir);
+ const auto filePerms = getPermissions((*it)->_file);
//true when it is just a rename in the same directory. (not a move)
bool isRename = (*it)->_file.startsWith(parentDir) && (*it)->_file.lastIndexOf('/') == slashPos;
if (isRename || destPerms.isNull()) {
// no need to check for the destination dir permission
destinationOK = true;
- } else if ((*it)->isDirectory() && !destPerms.contains("K")) {
+ } else if ((*it)->isDirectory() && !destPerms.hasPermission(RemotePermissions::CanAddSubDirectories)) {
destinationOK = false;
- } else if (!(*it)->isDirectory() && !destPerms.contains("C")) {
+ } else if (!(*it)->isDirectory() && !destPerms.hasPermission(RemotePermissions::CanAddFile)) {
destinationOK = false;
}
// check if we are allowed to move from the source
bool sourceOK = true;
if (!filePerms.isNull()
- && ((isRename && !filePerms.contains("N"))
- || (!isRename && !filePerms.contains("V")))) {
+ && ((isRename && !filePerms.hasPermission(RemotePermissions::CanRename))
+ || (!isRename && !filePerms.hasPermission(RemotePermissions::CanMove)))) {
// We are not allowed to move or rename this file
sourceOK = false;
- if (filePerms.contains("D") && destinationOK) {
+ if (filePerms.hasPermission(RemotePermissions::CanDelete) && destinationOK) {
// but we are allowed to delete it
// TODO! simulate delete & upload
}
}
}
-QByteArray SyncEngine::getPermissions(const QString &file) const
+RemotePermissions SyncEngine::getPermissions(const QString &file) const
{
static bool isTest = qgetenv("OWNCLOUD_TEST_PERMISSIONS").toInt();
if (isTest) {
QRegExp rx("_PERM_([^_]*)_[^/]*$");
if (rx.indexIn(file) != -1) {
- return rx.cap(1).toLatin1();
+ return RemotePermissions(rx.cap(1));
}
}
if (it != _csync_ctx->remote.files.end()) {
return it->second->remotePerm;
}
- return QByteArray();
+ return RemotePermissions();
}
void SyncEngine::restoreOldFiles(SyncFileItemVector &syncItems)
* to recover
*/
void checkForPermission(SyncFileItemVector &syncItems);
- QByteArray getPermissions(const QString &file) const;
+ RemotePermissions getPermissions(const QString &file) const;
/**
* Instead of downloading files from the server, upload the files to the server
Status _status BITFIELD(4);
bool _isRestoration BITFIELD(1); // The original operation was forbidden, and this is a restoration
quint16 _httpErrorCode;
+ RemotePermissions _remotePerm;
QString _errorString; // Contains a string only in case of error
QByteArray _responseTimeStamp;
quint32 _affectedItems; // the number of affected items by the operation on this item.
quint64 _size;
quint64 _inode;
QByteArray _fileId;
- QByteArray _remotePerm;
// This is the value for the 'new' side, matching with _size and _modtime.
//
// First look it up in the database to know if it's shared
SyncJournalFileRecord rec = _syncEngine->journal()->getFileRecord(relativePath);
if (rec.isValid()) {
- return resolveSyncAndErrorStatus(relativePath, rec._remotePerm.contains("S") ? Shared : NotShared);
+ return resolveSyncAndErrorStatus(relativePath, rec._remotePerm.hasPermission(RemotePermissions::IsShared) ? Shared : NotShared);
}
// Must be a new file not yet in the database, check if it's syncing or has an error.
_syncProblems[item->_file] = SyncFileStatus::StatusWarning;
}
- SharedFlag sharedFlag = item->_remotePerm.contains("S") ? Shared : NotShared;
+ SharedFlag sharedFlag = item->_remotePerm.hasPermission(RemotePermissions::IsShared) ? Shared : NotShared;
if (item->_instruction != CSYNC_INSTRUCTION_NONE
&& item->_instruction != CSYNC_INSTRUCTION_UPDATE_METADATA
&& item->_instruction != CSYNC_INSTRUCTION_IGNORE
_syncProblems.erase(item->_file);
}
- SharedFlag sharedFlag = item->_remotePerm.contains("S") ? Shared : NotShared;
+ SharedFlag sharedFlag = item->_remotePerm.hasPermission(RemotePermissions::IsShared) ? Shared : NotShared;
if (item->_instruction != CSYNC_INSTRUCTION_NONE
&& item->_instruction != CSYNC_INSTRUCTION_UPDATE_METADATA
&& item->_instruction != CSYNC_INSTRUCTION_IGNORE
record._type = 5;
record._etag = "789789";
record._fileId = "abcd";
- record._remotePerm = "744";
+ record._remotePerm = RemotePermissions("RW");
record._fileSize = 213089055;
record._checksumHeader = "MD5:mychecksum";
QVERIFY(_db.setFileRecord(record));
record._type = 7;
record._etag = "789FFF";
record._fileId = "efg";
- record._remotePerm = "777";
+ record._remotePerm = RemotePermissions("NV");
record._fileSize = 289055;
_db.setFileRecordMetadata(record);
storedRecord = _db.getFileRecord("foo");
{
SyncJournalFileRecord record;
record._path = "foo-checksum";
- record._remotePerm = "744";
+ record._remotePerm = RemotePermissions("RW");
record._checksumHeader = "MD5:mychecksum";
record._modtime = QDateTime::currentDateTimeUtc();
QVERIFY(_db.setFileRecord(record));
{
SyncJournalFileRecord record;
record._path = "foo-nochecksum";
- record._remotePerm = "744";
+ record._remotePerm = RemotePermissions("RWN");
record._modtime = QDateTime::currentDateTimeUtc();
QVERIFY(_db.setFileRecord(record));
projects / nextcloud-desktop.git / commitdiff