qfile.cpp

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// Copyright (C) 2017 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qplatformdefs.h"
#include "qdebug.h"
#include "qfile.h"
#include "qfsfileengine_p.h"
#include "qtemporaryfile.h"
#include "qtemporaryfile_p.h"
#include "qlist.h"
#include "qfileinfo.h"
#include "private/qiodevice_p.h"
#include "private/qfile_p.h"
#include "private/qfilesystemengine_p.h"
#include "private/qsystemerror_p.h"
#include "private/qtemporaryfile_p.h"
#if defined(QT_BUILD_CORE_LIB)
# include "qcoreapplication.h"
#endif
 
#ifdef QT_NO_QOBJECT
#define tr(X) QString::fromLatin1(X)
#endif
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
Q_DECL_COLD_FUNCTION
static bool file_already_open(QFile &file, const char *where = nullptr)
{
    qWarning("QFile::%s: File (%ls) already open", where ? where : "open", qUtf16Printable(file.fileName()));
    return false;
}
 
//************* QFilePrivate
QFilePrivate::QFilePrivate()
{
}
 
QFilePrivate::~QFilePrivate()
{
}
 
bool
QFilePrivate::openExternalFile(QIODevice::OpenMode flags, int fd, QFile::FileHandleFlags handleFlags)
{
#ifdef QT_NO_FSFILEENGINE
    Q_UNUSED(flags);
    Q_UNUSED(fd);
    return false;
#else
    auto fs = std::make_unique<QFSFileEngine>();
    auto fe = fs.get();
    fileEngine = std::move(fs);
    return fe->open(flags, fd, handleFlags);
#endif
}
 
bool
QFilePrivate::openExternalFile(QIODevice::OpenMode flags, FILE *fh, QFile::FileHandleFlags handleFlags)
{
#ifdef QT_NO_FSFILEENGINE
    Q_UNUSED(flags);
    Q_UNUSED(fh);
    return false;
#else
    auto fs = std::make_unique<QFSFileEngine>();
    auto fe = fs.get();
    fileEngine = std::move(fs);
    return fe->open(flags, fh, handleFlags);
#endif
}
 
QAbstractFileEngine *QFilePrivate::engine() const
{
    if (!fileEngine)
        fileEngine.reset(QAbstractFileEngine::create(fileName));
    return fileEngine.get();
}
 
//************* QFile
 
#ifdef QT_NO_QOBJECT
QFile::QFile()
    : QFileDevice(*new QFilePrivate)
{
}
QFile::QFile(const QString &name)
    : QFileDevice(*new QFilePrivate)
{
    d_func()->fileName = name;
}
QFile::QFile(QFilePrivate &dd)
    : QFileDevice(dd)
{
}
#else
QFile::QFile()
    : QFileDevice(*new QFilePrivate, nullptr)
{
}
QFile::QFile(QObject *parent)
    : QFileDevice(*new QFilePrivate, parent)
{
}
 
 
QFile::QFile(const QString &name)
    : QFileDevice(*new QFilePrivate, nullptr)
{
    Q_D(QFile);
    d->fileName = name;
}
QFile::QFile(const QString &name, QObject *parent)
    : QFileDevice(*new QFilePrivate, parent)
{
    Q_D(QFile);
    d->fileName = name;
}
QFile::QFile(QFilePrivate &dd, QObject *parent)
    : QFileDevice(dd, parent)
{
}
#endif
 
QFile::~QFile()
{
}
 
QString QFile::fileName() const
{
    Q_D(const QFile);
    return d->engine()->fileName(QAbstractFileEngine::DefaultName);
}
 
void
QFile::setFileName(const QString &name)
{
    Q_D(QFile);
    if (isOpen()) {
        file_already_open(*this, "setFileName");
        close();
    }
    d->fileEngine.reset(); //get a new file engine later
    d->fileName = name;
}
 
bool
QFile::exists() const
{
    Q_D(const QFile);
    // 0x1000000 = QAbstractFileEngine::Refresh, forcing an update
    return d->engine()->fileFlags(QAbstractFileEngine::FlagsMask
                                    | QAbstractFileEngine::Refresh).testAnyFlag(QAbstractFileEngine::ExistsFlag);
}
 
bool
QFile::exists(const QString &fileName)
{
    return QFileInfo::exists(fileName);
}
 
QString QFile::symLinkTarget() const
{
    Q_D(const QFile);
    return d->engine()->fileName(QAbstractFileEngine::AbsoluteLinkTarget);
}
 
QString QFile::symLinkTarget(const QString &fileName)
{
    return QFileInfo(fileName).symLinkTarget();
}
 
bool
QFile::remove()
{
    Q_D(QFile);
    if (d->fileName.isEmpty() &&
            !static_cast<QFSFileEngine *>(d->engine())->isUnnamedFile()) {
        qWarning("QFile::remove: Empty or null file name");
        return false;
    }
    unsetError();
    close();
    if (error() == QFile::NoError) {
        if (d->engine()->remove()) {
            unsetError();
            return true;
        }
        d->setError(QFile::RemoveError, d->fileEngine->errorString());
    }
    return false;
}
 
bool
QFile::remove(const QString &fileName)
{
    return QFile(fileName).remove();
}
 
bool
QFile::moveToTrash()
{
    Q_D(QFile);
    if (d->fileName.isEmpty() &&
        !static_cast<QFSFileEngine *>(d->engine())->isUnnamedFile()) {
        qWarning("QFile::remove: Empty or null file name");
        return false;
    }
    unsetError();
    close();
    if (error() == QFile::NoError) {
        QFileSystemEntry fileEntry(d->fileName);
        QFileSystemEntry trashEntry;
        QSystemError error;
        if (QFileSystemEngine::moveFileToTrash(fileEntry, trashEntry, error)) {
            setFileName(trashEntry.filePath());
            unsetError();
            return true;
        }
        d->setError(QFile::RenameError, error.toString());
    }
    return false;
}
 
bool
QFile::moveToTrash(const QString &fileName, QString *pathInTrash)
{
    QFile file(fileName);
    if (file.moveToTrash()) {
        if (pathInTrash)
            *pathInTrash = file.fileName();
        return true;
    }
    return false;
}
 
bool
QFile::rename(const QString &newName)
{
    Q_D(QFile);
 
    // if this is a QTemporaryFile, the virtual fileName() call here may do something
    if (fileName().isEmpty()) {
        qWarning("QFile::rename: Empty or null file name");
        return false;
    }
    if (d->fileName == newName) {
        d->setError(QFile::RenameError, tr("Destination file is the same file."));
        return false;
    }
    if (!exists()) {
        d->setError(QFile::RenameError, tr("Source file does not exist."));
        return false;
    }
 
    // If the file exists and it is a case-changing rename ("foo" -> "Foo"),
    // compare Ids to make sure it really is a different file.
    // Note: this does not take file engines into account.
    bool changingCase = false;
    QByteArray targetId = QFileSystemEngine::id(QFileSystemEntry(newName));
    if (!targetId.isNull()) {
        QByteArray fileId = d->fileEngine ?
                    d->fileEngine->id() :
                    QFileSystemEngine::id(QFileSystemEntry(d->fileName));
        changingCase = (fileId == targetId && d->fileName.compare(newName, Qt::CaseInsensitive) == 0);
        if (!changingCase) {
            d->setError(QFile::RenameError, tr("Destination file exists"));
            return false;
        }
 
#ifdef Q_OS_LINUX
        // rename() on Linux simply does nothing when renaming "foo" to "Foo" on a case-insensitive
        // FS, such as FAT32. Move the file away and rename in 2 steps to work around.
        QTemporaryFileName tfn(d->fileName);
        QFileSystemEntry src(d->fileName);
        QSystemError error;
        for (int attempt = 0; attempt < 16; ++attempt) {
            QFileSystemEntry tmp(tfn.generateNext(), QFileSystemEntry::FromNativePath());
 
            // rename to temporary name
            if (!QFileSystemEngine::renameFile(src, tmp, error))
                continue;
 
            // rename to final name
            if (QFileSystemEngine::renameFile(tmp, QFileSystemEntry(newName), error)) {
                d->fileEngine->setFileName(newName);
                d->fileName = newName;
                return true;
            }
 
            // We need to restore the original file.
            QSystemError error2;
            if (QFileSystemEngine::renameFile(tmp, src, error2))
                break;      // report the original error, below
 
            // report both errors
            d->setError(QFile::RenameError,
                        tr("Error while renaming: %1").arg(error.toString())
                        + u'\n'
                        + tr("Unable to restore from %1: %2").
                        arg(QDir::toNativeSeparators(tmp.filePath()), error2.toString()));
            return false;
        }
        d->setError(QFile::RenameError,
                    tr("Error while renaming: %1").arg(error.toString()));
        return false;
#endif // Q_OS_LINUX
    }
    unsetError();
    close();
    if (error() == QFile::NoError) {
        if (changingCase ? d->engine()->renameOverwrite(newName) : d->engine()->rename(newName)) {
            unsetError();
            // engine was able to handle the new name so we just reset it
            d->fileEngine->setFileName(newName);
            d->fileName = newName;
            return true;
        }
 
        if (isSequential()) {
            d->setError(QFile::RenameError, tr("Will not rename sequential file using block copy"));
            return false;
        }
 
        QFile out(newName);
        if (open(QIODevice::ReadOnly)) {
            if (out.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
                bool error = false;
                char block[4096];
                qint64 bytes;
                while ((bytes = read(block, sizeof(block))) > 0) {
                    if (bytes != out.write(block, bytes)) {
                        d->setError(QFile::RenameError, out.errorString());
                        error = true;
                        break;
                    }
                }
                if (bytes == -1) {
                    d->setError(QFile::RenameError, errorString());
                    error = true;
                }
                if (!error) {
                    if (!remove()) {
                        d->setError(QFile::RenameError, tr("Cannot remove source file"));
                        error = true;
                    }
                }
                if (error) {
                    out.remove();
                } else {
                    d->fileEngine->setFileName(newName);
                    setPermissions(permissions());
                    unsetError();
                    setFileName(newName);
                }
                close();
                return !error;
            }
            close();
            d->setError(QFile::RenameError,
                        tr("Cannot open destination file: %1").arg(out.errorString()));
        } else {
            d->setError(QFile::RenameError, errorString());
        }
    }
    return false;
}
 
bool
QFile::rename(const QString &oldName, const QString &newName)
{
    return QFile(oldName).rename(newName);
}
 
bool
QFile::link(const QString &linkName)
{
    Q_D(QFile);
    if (fileName().isEmpty()) {
        qWarning("QFile::link: Empty or null file name");
        return false;
    }
    QFileInfo fi(linkName);
    if (d->engine()->link(fi.absoluteFilePath())) {
        unsetError();
        return true;
    }
    d->setError(QFile::RenameError, d->fileEngine->errorString());
    return false;
}
 
bool
QFile::link(const QString &fileName, const QString &linkName)
{
    return QFile(fileName).link(linkName);
}
 
bool
QFile::copy(const QString &newName)
{
    Q_D(QFile);
    if (fileName().isEmpty()) {
        qWarning("QFile::copy: Empty or null file name");
        return false;
    }
    if (QFile::exists(newName)) {
        // ### Race condition. If a file is moved in after this, it /will/ be
        // overwritten. On Unix, the proper solution is to use hardlinks:
        // return ::link(old, new) && ::remove(old); See also rename().
        d->setError(QFile::CopyError, tr("Destination file exists"));
        return false;
    }
    unsetError();
    close();
    if (error() == QFile::NoError) {
        if (d->engine()->copy(newName)) {
            unsetError();
            return true;
        } else {
            bool error = false;
            if (!open(QFile::ReadOnly)) {
                error = true;
                d->setError(QFile::CopyError, tr("Cannot open %1 for input").arg(d->fileName));
            } else {
                const auto fileTemplate = "%1/qt_temp.XXXXXX"_L1;
#ifdef QT_NO_TEMPORARYFILE
                QFile out(fileTemplate.arg(QFileInfo(newName).path()));
                if (!out.open(QIODevice::ReadWrite))
                    error = true;
#else
                QTemporaryFile out(fileTemplate.arg(QFileInfo(newName).path()));
                if (!out.open()) {
                    out.setFileTemplate(fileTemplate.arg(QDir::tempPath()));
                    if (!out.open())
                        error = true;
                }
#endif
                if (error) {
                    out.close();
                    close();
                    d->setError(QFile::CopyError, tr("Cannot open for output: %1").arg(out.errorString()));
                } else {
                    if (!d->engine()->cloneTo(out.d_func()->engine())) {
                        char block[4096];
                        qint64 totalRead = 0;
                        while (!atEnd()) {
                            qint64 in = read(block, sizeof(block));
                            if (in <= 0)
                                break;
                            totalRead += in;
                            if (in != out.write(block, in)) {
                                close();
                                d->setError(QFile::CopyError, tr("Failure to write block: %1")
                                            .arg(out.errorString()));
                                error = true;
                                break;
                            }
                        }
 
                        if (totalRead != size()) {
                            // Unable to read from the source. The error string is
                            // already set from read().
                            error = true;
                        }
                    }
 
                    if (!error) {
                        // Sync to disk if possible. Ignore errors (e.g. not supported).
                        out.d_func()->fileEngine->syncToDisk();
 
                        if (!out.rename(newName)) {
                            error = true;
                            close();
                            d->setError(QFile::CopyError, tr("Cannot create %1 for output: %2")
                                        .arg(newName, out.errorString()));
                        }
                    }
#ifdef QT_NO_TEMPORARYFILE
                    if (error)
                        out.remove();
#else
                    if (!error)
                        out.setAutoRemove(false);
#endif
                }
            }
            if (!error) {
                QFile::setPermissions(newName, permissions());
                close();
                unsetError();
                return true;
            }
        }
    }
    return false;
}
 
bool
QFile::copy(const QString &fileName, const QString &newName)
{
    return QFile(fileName).copy(newName);
}
 
bool QFile::open(OpenMode mode)
{
    Q_D(QFile);
    if (isOpen())
        return file_already_open(*this);
    // Either Append or NewOnly implies WriteOnly
    if (mode & (Append | NewOnly))
        mode |= WriteOnly;
    unsetError();
    if ((mode & (ReadOnly | WriteOnly)) == 0) {
        qWarning("QIODevice::open: File access not specified");
        return false;
    }
 
    // QIODevice provides the buffering, so there's no need to request it from the file engine.
    if (d->engine()->open(mode | QIODevice::Unbuffered)) {
        QIODevice::open(mode);
        if (mode & Append)
            seek(size());
        return true;
    }
    QFile::FileError err = d->fileEngine->error();
    if (err == QFile::UnspecifiedError)
        err = QFile::OpenError;
    d->setError(err, d->fileEngine->errorString());
    return false;
}
 
bool QFile::open(OpenMode mode, QFile::Permissions permissions)
{
    Q_D(QFile);
    if (isOpen())
        return file_already_open(*this);
    // Either Append or NewOnly implies WriteOnly
    if (mode & (Append | NewOnly))
        mode |= WriteOnly;
    unsetError();
    if ((mode & (ReadOnly | WriteOnly)) == 0) {
        qWarning("QIODevice::open: File access not specified");
        return false;
    }
 
    // QIODevice provides the buffering, so there's no need to request it from the file engine.
    if (d->engine()->open(mode | QIODevice::Unbuffered, permissions)) {
        QIODevice::open(mode);
        if (mode & Append)
            seek(size());
        return true;
    }
    QFile::FileError err = d->fileEngine->error();
    if (err == QFile::UnspecifiedError)
        err = QFile::OpenError;
    d->setError(err, d->fileEngine->errorString());
    return false;
}
 
bool QFile::open(FILE *fh, OpenMode mode, FileHandleFlags handleFlags)
{
    Q_D(QFile);
    if (isOpen())
        return file_already_open(*this);
    // Either Append or NewOnly implies WriteOnly
    if (mode & (Append | NewOnly))
        mode |= WriteOnly;
    unsetError();
    if ((mode & (ReadOnly | WriteOnly)) == 0) {
        qWarning("QFile::open: File access not specified");
        return false;
    }
 
    // QIODevice provides the buffering, so request unbuffered file engines
    if (d->openExternalFile(mode | Unbuffered, fh, handleFlags)) {
        QIODevice::open(mode);
        if (!(mode & Append) && !isSequential()) {
            qint64 pos = (qint64)QT_FTELL(fh);
            if (pos != -1) {
                // Skip redundant checks in QFileDevice::seek().
                QIODevice::seek(pos);
            }
        }
        return true;
    }
    return false;
}
 
bool QFile::open(int fd, OpenMode mode, FileHandleFlags handleFlags)
{
    Q_D(QFile);
    if (isOpen())
        return file_already_open(*this);
    // Either Append or NewOnly implies WriteOnly
    if (mode & (Append | NewOnly))
        mode |= WriteOnly;
    unsetError();
    if ((mode & (ReadOnly | WriteOnly)) == 0) {
        qWarning("QFile::open: File access not specified");
        return false;
    }
 
    // QIODevice provides the buffering, so request unbuffered file engines
    if (d->openExternalFile(mode | Unbuffered, fd, handleFlags)) {
        QIODevice::open(mode);
        if (!(mode & Append) && !isSequential()) {
            qint64 pos = (qint64)QT_LSEEK(fd, QT_OFF_T(0), SEEK_CUR);
            if (pos != -1) {
                // Skip redundant checks in QFileDevice::seek().
                QIODevice::seek(pos);
            }
        }
        return true;
    }
    return false;
}
 
bool QFile::resize(qint64 sz)
{
    return QFileDevice::resize(sz); // for now
}
 
bool
QFile::resize(const QString &fileName, qint64 sz)
{
    return QFile(fileName).resize(sz);
}
 
QFile::Permissions QFile::permissions() const
{
    return QFileDevice::permissions(); // for now
}
 
QFile::Permissions
QFile::permissions(const QString &fileName)
{
    return QFile(fileName).permissions();
}
 
bool QFile::setPermissions(Permissions permissions)
{
    return QFileDevice::setPermissions(permissions); // for now
}
 
bool
QFile::setPermissions(const QString &fileName, Permissions permissions)
{
    return QFile(fileName).setPermissions(permissions);
}
 
qint64 QFile::size() const
{
    return QFileDevice::size(); // for now
}
 
QT_END_NAMESPACE
 
#ifndef QT_NO_QOBJECT
#include "moc_qfile.cpp"
#endif