Source code
Revision control
Copy as Markdown
// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
#include "qqmlpreviewfileengine.h"
#include "qqmlpreviewservice.h"
#include <QtCore/qlibraryinfo.h>
#include <QtCore/qthread.h>
#include <QtCore/qwaitcondition.h>
#include <cstring>
QT_BEGIN_NAMESPACE
static bool isRelative(const QString &path)
{
if (path.isEmpty())
return true;
if (path.at(0) == '/')
return false;
if (path.at(0) == ':' && path.size() >= 2 && path.at(1) == '/')
return false;
#ifdef Q_OS_WIN
if (path.length() >= 2 && path.at(1) == ':')
return false;
#endif
return true;
}
static QString absolutePath(const QString &path)
{
return QDir::cleanPath(isRelative(path) ? (QDir::currentPath() + '/' + path) : path);
}
bool isRootPath(const QString &path)
{
return QFileSystemEntry::isRootPath(path);
}
class QQmlPreviewFileEngineIterator : public QAbstractFileEngineIterator
{
public:
QQmlPreviewFileEngineIterator(const QString &path, QDirListing::IteratorFlags filters,
const QStringList &filterNames, const QStringList &m_entries);
~QQmlPreviewFileEngineIterator();
bool advance() override;
QString currentFileName() const override;
private:
const QStringList m_entries;
int m_index;
};
QQmlPreviewFileEngineIterator::QQmlPreviewFileEngineIterator(const QString &path,
QDirListing::IteratorFlags filters,
const QStringList &filterNames,
const QStringList &entries)
: QAbstractFileEngineIterator(path, filters, filterNames), m_entries(entries), m_index(0)
{
}
QQmlPreviewFileEngineIterator::~QQmlPreviewFileEngineIterator()
{
}
bool QQmlPreviewFileEngineIterator::advance()
{
if (m_index >= m_entries.size())
return false;
++m_index;
return true;
}
QString QQmlPreviewFileEngineIterator::currentFileName() const
{
if (m_index == 0 || m_index > m_entries.size())
return QString();
return m_entries.at(m_index - 1);
}
QQmlPreviewFileEngine::QQmlPreviewFileEngine(const QString &file, const QString &absolute,
QQmlPreviewFileLoader *loader) :
m_name(file), m_absolute(absolute), m_loader(loader)
{
load();
}
void QQmlPreviewFileEngine::setFileName(const QString &file)
{
m_name = file;
m_absolute = absolutePath(file);
m_fallback.reset();
m_contents.close();
m_contents.setData(QByteArray());
m_entries.clear();
load();
}
bool QQmlPreviewFileEngine::open(QIODevice::OpenMode flags,
std::optional<QFile::Permissions> permissions)
{
switch (m_result) {
case QQmlPreviewFileLoader::File:
return m_contents.open(flags);
case QQmlPreviewFileLoader::Directory:
return false;
case QQmlPreviewFileLoader::Fallback:
return m_fallback->open(flags, permissions);
default:
Q_UNREACHABLE_RETURN(false);
}
}
bool QQmlPreviewFileEngine::close()
{
switch (m_result) {
case QQmlPreviewFileLoader::Fallback:
return m_fallback->close();
case QQmlPreviewFileLoader::File:
m_contents.close();
return true;
case QQmlPreviewFileLoader::Directory:
return false;
default:
Q_UNREACHABLE_RETURN(false);
}
}
qint64 QQmlPreviewFileEngine::size() const
{
return m_fallback ? m_fallback->size() : m_contents.size();
}
qint64 QQmlPreviewFileEngine::pos() const
{
return m_fallback ? m_fallback->pos() : m_contents.pos();
}
bool QQmlPreviewFileEngine::seek(qint64 newPos)
{
return m_fallback? m_fallback->seek(newPos) : m_contents.seek(newPos);
}
qint64 QQmlPreviewFileEngine::read(char *data, qint64 maxlen)
{
return m_fallback ? m_fallback->read(data, maxlen) : m_contents.read(data, maxlen);
}
QAbstractFileEngine::FileFlags QQmlPreviewFileEngine::fileFlags(
QAbstractFileEngine::FileFlags type) const
{
if (m_fallback)
return m_fallback->fileFlags(type);
QAbstractFileEngine::FileFlags ret;
if (type & PermsMask) {
ret |= QAbstractFileEngine::FileFlags(
ReadOwnerPerm | ReadUserPerm | ReadGroupPerm | ReadOtherPerm);
}
if (type & TypesMask) {
if (m_result == QQmlPreviewFileLoader::Directory)
ret |= DirectoryType;
else
ret |= FileType;
}
if (type & FlagsMask) {
ret |= ExistsFlag;
if (isRootPath(m_name))
ret |= RootFlag;
}
return ret;
}
QString QQmlPreviewFileEngine::fileName(QAbstractFileEngine::FileName file) const
{
if (m_fallback)
return m_fallback->fileName(file);
if (file == BaseName) {
int slashPos = m_name.lastIndexOf('/');
if (slashPos == -1)
return m_name;
return m_name.mid(slashPos + 1);
} else if (file == PathName || file == AbsolutePathName) {
const QString path = (file == AbsolutePathName) ? m_absolute : m_name;
const int slashPos = path.lastIndexOf('/');
if (slashPos == -1)
return QString();
else if (slashPos == 0)
return "/";
return path.left(slashPos);
} else if (file == CanonicalName || file == CanonicalPathName) {
if (file == CanonicalPathName) {
const int slashPos = m_absolute.lastIndexOf('/');
if (slashPos != -1)
return m_absolute.left(slashPos);
}
return m_absolute;
}
return m_name;
}
uint QQmlPreviewFileEngine::ownerId(QAbstractFileEngine::FileOwner owner) const
{
return m_fallback ? m_fallback->ownerId(owner) : static_cast<uint>(-2);
}
QAbstractFileEngine::IteratorUniquePtr QQmlPreviewFileEngine::beginEntryList(
const QString &path, QDirListing::IteratorFlags filters, const QStringList &filterNames)
{
return m_fallback ? m_fallback->beginEntryList(path, filters, filterNames)
: std::make_unique<QQmlPreviewFileEngineIterator>(
path, filters, filterNames, m_entries);
}
QAbstractFileEngine::IteratorUniquePtr QQmlPreviewFileEngine::endEntryList()
{
return m_fallback ? m_fallback->endEntryList() : nullptr;
}
bool QQmlPreviewFileEngine::flush()
{
return m_fallback ? m_fallback->flush() : true;
}
bool QQmlPreviewFileEngine::syncToDisk()
{
return m_fallback ? m_fallback->syncToDisk() : false;
}
bool QQmlPreviewFileEngine::isSequential() const
{
return m_fallback ? m_fallback->isSequential() : m_contents.isSequential();
}
bool QQmlPreviewFileEngine::remove()
{
return m_fallback ? m_fallback->remove() : false;
}
bool QQmlPreviewFileEngine::copy(const QString &newName)
{
return m_fallback ? m_fallback->copy(newName) : false;
}
bool QQmlPreviewFileEngine::rename(const QString &newName)
{
return m_fallback ? m_fallback->rename(newName) : false;
}
bool QQmlPreviewFileEngine::renameOverwrite(const QString &newName)
{
return m_fallback ? m_fallback->renameOverwrite(newName) : false;
}
bool QQmlPreviewFileEngine::link(const QString &newName)
{
return m_fallback ? m_fallback->link(newName) : false;
}
bool QQmlPreviewFileEngine::mkdir(const QString &dirName, bool createParentDirectories,
std::optional<QFile::Permissions> permissions) const
{
if (m_fallback)
return m_fallback->mkdir(dirName, createParentDirectories, permissions);
if (isRelative(dirName))
return false;
// If we're creating a directory from an absolute path, it can be anywhere.
// The result is unrelated to the currently running preview.
return QAbstractFileEngine::create(QDir::rootPath())
->mkdir(dirName, createParentDirectories, permissions);
}
bool QQmlPreviewFileEngine::rmdir(const QString &dirName, bool recurseParentDirectories) const
{
if (m_fallback)
m_fallback->rmdir(dirName, recurseParentDirectories);
if (isRelative(dirName))
return false;
// If we're removing a directory at an absolute path, it can be anywhere.
// The result is unrelated to the currently running preview.
return QAbstractFileEngine::create(QDir::rootPath())
->rmdir(dirName, recurseParentDirectories);
}
bool QQmlPreviewFileEngine::setSize(qint64 size)
{
switch (m_result) {
case QQmlPreviewFileLoader::Fallback:
return m_fallback->setSize(size);
case QQmlPreviewFileLoader::File:
if (size < 0 || size > std::numeric_limits<int>::max())
return false;
m_contents.buffer().resize(static_cast<int>(size));
return true;
case QQmlPreviewFileLoader::Directory:
return false;
default:
Q_UNREACHABLE_RETURN(false);
}
}
bool QQmlPreviewFileEngine::caseSensitive() const
{
return m_fallback ? m_fallback->caseSensitive() : true;
}
bool QQmlPreviewFileEngine::isRelativePath() const
{
return m_fallback ? m_fallback->isRelativePath() : isRelative(m_name);
}
bool QQmlPreviewFileEngine::setPermissions(uint perms)
{
return m_fallback ? m_fallback->setPermissions(perms) : false;
}
QByteArray QQmlPreviewFileEngine::id() const
{
return m_fallback ? m_fallback->id() : QByteArray();
}
QString QQmlPreviewFileEngine::owner(FileOwner owner) const
{
return m_fallback ? m_fallback->owner(owner) : QString();
}
QDateTime QQmlPreviewFileEngine::fileTime(QFile::FileTime time) const
{
// Files we replace are always newer than the ones we had before. This makes the QML engine
// actually recompile them, rather than pick them from the cache.
return m_fallback ? m_fallback->fileTime(time) : QDateTime::currentDateTime();
}
int QQmlPreviewFileEngine::handle() const
{
return m_fallback ? m_fallback->handle() : -1;
}
qint64 QQmlPreviewFileEngine::readLine(char *data, qint64 maxlen)
{
return m_fallback ? m_fallback->readLine(data, maxlen) : m_contents.readLine(data, maxlen);
}
qint64 QQmlPreviewFileEngine::write(const char *data, qint64 len)
{
return m_fallback ? m_fallback->write(data, len) : m_contents.write(data, len);
}
bool QQmlPreviewFileEngine::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output)
{
return m_fallback ? m_fallback->extension(extension, option, output) : false;
}
bool QQmlPreviewFileEngine::supportsExtension(Extension extension) const
{
return m_fallback ? m_fallback->supportsExtension(extension) : false;
}
void QQmlPreviewFileEngine::load() const
{
// We can get here from different threads on different instances of QQmlPreviewFileEngine.
// However, there is only one loader per QQmlPreviewFileEngineHandler and it is not thread-safe.
// Its content mutex doesn't help us here because we explicitly wait on it in load(), which
// causes it to be released. Therefore, lock the load mutex first.
// This doesn't cause any deadlocks because the only thread that wakes the loader on the content
// mutex never calls load(). It's the QML debug server thread that handles the debug protocol.
QMutexLocker loadLocker(m_loader->loadMutex());
m_result = m_loader->load(m_absolute);
switch (m_result) {
case QQmlPreviewFileLoader::File:
m_contents.setData(m_loader->contents());
break;
case QQmlPreviewFileLoader::Directory:
m_entries = m_loader->entries();
break;
case QQmlPreviewFileLoader::Fallback:
m_fallback = QAbstractFileEngine::create(m_name);
break;
case QQmlPreviewFileLoader::Unknown:
Q_UNREACHABLE();
break;
}
}
QQmlPreviewFileEngineHandler::QQmlPreviewFileEngineHandler(QQmlPreviewFileLoader *loader)
: m_loader(loader)
{
}
std::unique_ptr<QAbstractFileEngine> QQmlPreviewFileEngineHandler::create(
const QString &fileName) const
{
using namespace Qt::StringLiterals;
static QList<QLatin1StringView> prohibitedSuffixes {
// Don't load compiled QML/JS over the network
".qmlc"_L1, ".jsc"_L1, ".mjsc"_L1,
// Don't load plugins over the network
".dll"_L1, ".so"_L1, ".dylib"_L1
};
for (QLatin1StringView suffix : prohibitedSuffixes) {
if (fileName.endsWith(suffix))
return nullptr;
}
if (isRootPath(fileName))
return nullptr;
QString relative = fileName;
while (relative.endsWith('/'))
relative.chop(1);
if (relative.isEmpty() || relative == ":")
return nullptr;
const QString absolute = relative.startsWith(':') ? relative : absolutePath(relative);
if (m_loader->isBlacklisted(absolute))
return {};
return std::make_unique<QQmlPreviewFileEngine>(relative, absolute, m_loader.data());
}
QT_END_NAMESPACE