qsavefile.cpp

Go to the documentation of this file.

// Copyright (C) 2012 David Faure <faure@kde.org>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsavefile.h"
 
#ifndef QT_NO_TEMPORARYFILE
 
#include "qplatformdefs.h"
#include "private/qsavefile_p.h"
#include "qfileinfo.h"
#include "qabstractfileengine_p.h"
#include "qdebug.h"
#include "qtemporaryfile.h"
#include "private/qiodevice_p.h"
#include "private/qtemporaryfile_p.h"
#ifdef Q_OS_UNIX
#include <errno.h>
#endif
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
QSaveFilePrivate::QSaveFilePrivate()
    : writeError(QFileDevice::NoError),
      useTemporaryFile(true),
      directWriteFallback(false)
{
}
 
QSaveFilePrivate::~QSaveFilePrivate()
{
}
 
#ifdef QT_NO_QOBJECT
QSaveFile::QSaveFile(const QString &name)
    : QFileDevice(*new QSaveFilePrivate)
{
    Q_D(QSaveFile);
    d->fileName = name;
}
#else
QSaveFile::QSaveFile(const QString &name)
    : QFileDevice(*new QSaveFilePrivate, nullptr)
{
    Q_D(QSaveFile);
    d->fileName = name;
}
 
QSaveFile::QSaveFile(QObject *parent)
    : QFileDevice(*new QSaveFilePrivate, parent)
{
}
QSaveFile::QSaveFile(const QString &name, QObject *parent)
    : QFileDevice(*new QSaveFilePrivate, parent)
{
    Q_D(QSaveFile);
    d->fileName = name;
}
#endif
 
QSaveFile::~QSaveFile()
{
    Q_D(QSaveFile);
    QFileDevice::close();
    if (d->fileEngine) {
        d->fileEngine->remove();
        d->fileEngine.reset();
    }
}
 
QString QSaveFile::fileName() const
{
    return d_func()->fileName;
}
 
void QSaveFile::setFileName(const QString &name)
{
    d_func()->fileName = name;
}
 
bool QSaveFile::open(OpenMode mode)
{
    Q_D(QSaveFile);
    if (isOpen()) {
        qWarning("QSaveFile::open: File (%ls) already open", qUtf16Printable(fileName()));
        return false;
    }
    unsetError();
    d->writeError = QFileDevice::NoError;
    if ((mode & (ReadOnly | WriteOnly)) == 0) {
        qWarning("QSaveFile::open: Open mode not specified");
        return false;
    }
    // In the future we could implement ReadWrite by copying from the existing file to the temp file...
    // The implications of NewOnly and ExistingOnly when used with QSaveFile need to be considered carefully...
    if (mode & (ReadOnly | Append | NewOnly | ExistingOnly)) {
        qWarning("QSaveFile::open: Unsupported open mode 0x%x", uint(mode.toInt()));
        return false;
    }
 
    // check if existing file is writable
    QFileInfo existingFile(d->fileName);
    if (existingFile.exists() && !existingFile.isWritable()) {
        d->setError(QFileDevice::WriteError, QSaveFile::tr("Existing file %1 is not writable").arg(d->fileName));
        d->writeError = QFileDevice::WriteError;
        return false;
    }
 
    if (existingFile.isDir()) {
        d->setError(QFileDevice::WriteError, QSaveFile::tr("Filename refers to a directory"));
        d->writeError = QFileDevice::WriteError;
        return false;
    }
 
    // Resolve symlinks. Don't use QFileInfo::canonicalFilePath so it still give the expected
    // target even if the file does not exist
    d->finalFileName = d->fileName;
    if (existingFile.isSymLink()) {
        int maxDepth = 128;
        while (--maxDepth && existingFile.isSymLink())
            existingFile.setFile(existingFile.symLinkTarget());
        if (maxDepth > 0)
            d->finalFileName = existingFile.filePath();
    }
 
    auto openDirectly = [&]() {
        d->fileEngine.reset(QAbstractFileEngine::create(d->finalFileName));
        if (d->fileEngine->open(mode | QIODevice::Unbuffered)) {
            d->useTemporaryFile = false;
            QFileDevice::open(mode);
            return true;
        }
        return false;
    };
 
    bool requiresDirectWrite = false;
#ifdef Q_OS_WIN
    // check if it is an Alternate Data Stream
    requiresDirectWrite = d->finalFileName == d->fileName && d->fileName.indexOf(u':', 2) > 1;
#elif defined(Q_OS_ANDROID)
    // check if it is a content:// URL
    requiresDirectWrite  = d->fileName.startsWith("content://"_L1);
#endif
    if (requiresDirectWrite) {
        // yes, we can't rename onto it...
        if (d->directWriteFallback) {
            if (openDirectly())
                return true;
            d->setError(d->fileEngine->error(), d->fileEngine->errorString());
            d->fileEngine.reset();
        } else {
            QString msg =
                    QSaveFile::tr("QSaveFile cannot open '%1' without direct write fallback enabled.")
                     .arg(QDir::toNativeSeparators(d->fileName));
            d->setError(QFileDevice::OpenError, msg);
        }
        return false;
    }
 
    d->fileEngine.reset(new QTemporaryFileEngine(&d->finalFileName, QTemporaryFileEngine::Win32NonShared));
    // if the target file exists, we'll copy its permissions below,
    // but until then, let's ensure the temporary file is not accessible
    // to a third party
    int perm = (existingFile.exists() ? 0600 : 0666);
    static_cast<QTemporaryFileEngine *>(d->fileEngine.get())->initialize(d->finalFileName, perm);
    // Same as in QFile: QIODevice provides the buffering, so there's no need to request it from the file engine.
    if (!d->fileEngine->open(mode | QIODevice::Unbuffered)) {
        QFileDevice::FileError err = d->fileEngine->error();
#ifdef Q_OS_UNIX
        if (d->directWriteFallback && err == QFileDevice::OpenError && errno == EACCES) {
            if (openDirectly())
                return true;
            err = d->fileEngine->error();
        }
#endif
        if (err == QFileDevice::UnspecifiedError)
            err = QFileDevice::OpenError;
        d->setError(err, d->fileEngine->errorString());
        d->fileEngine.reset();
        return false;
    }
 
    d->useTemporaryFile = true;
    QFileDevice::open(mode);
    if (existingFile.exists())
        setPermissions(existingFile.permissions());
    return true;
}
 
void QSaveFile::close()
{
    qFatal("QSaveFile::close called");
}
 
bool QSaveFile::commit()
{
    Q_D(QSaveFile);
    if (!d->fileEngine)
        return false;
 
    if (!isOpen()) {
        qWarning("QSaveFile::commit: File (%ls) is not open", qUtf16Printable(fileName()));
        return false;
    }
    QFileDevice::close(); // calls flush()
 
    const auto fe = std::move(d->fileEngine);
 
    // Sync to disk if possible. Ignore errors (e.g. not supported).
    fe->syncToDisk();
 
    if (d->useTemporaryFile) {
        if (d->writeError != QFileDevice::NoError) {
            fe->remove();
            d->writeError = QFileDevice::NoError;
            return false;
        }
        // atomically replace old file with new file
        // Can't use QFile::rename for that, must use the file engine directly
        Q_ASSERT(fe);
        if (!fe->renameOverwrite(d->finalFileName)) {
            d->setError(fe->error(), fe->errorString());
            fe->remove();
            return false;
        }
    }
    return true;
}
 
void QSaveFile::cancelWriting()
{
    Q_D(QSaveFile);
    if (!isOpen())
        return;
    d->setError(QFileDevice::WriteError, QSaveFile::tr("Writing canceled by application"));
    d->writeError = QFileDevice::WriteError;
}
 
qint64 QSaveFile::writeData(const char *data, qint64 len)
{
    Q_D(QSaveFile);
    if (d->writeError != QFileDevice::NoError)
        return -1;
 
    const qint64 ret = QFileDevice::writeData(data, len);
 
    if (d->error != QFileDevice::NoError)
        d->writeError = d->error;
    return ret;
}
 
void QSaveFile::setDirectWriteFallback(bool enabled)
{
    Q_D(QSaveFile);
    d->directWriteFallback = enabled;
}
 
bool QSaveFile::directWriteFallback() const
{
    Q_D(const QSaveFile);
    return d->directWriteFallback;
}
 
QT_END_NAMESPACE
 
#ifndef QT_NO_QOBJECT
#include "moc_qsavefile.cpp"
#endif
 
#endif // QT_NO_TEMPORARYFILE