Revision control
++ // 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 "qqmlpreviewfileloader.h"
++ #include "qqmlpreviewservice.h"
++
++ #include <QtQml/qqmlfile.h>
++
++ #include <QtCore/qlibraryinfo.h>
++ #include <QtCore/qstandardpaths.h>
++
++ QT_BEGIN_NAMESPACE
++
++ QQmlPreviewFileLoader::QQmlPreviewFileLoader(QQmlPreviewServiceImpl *service)
++ {
++ // This is created from stateChanged() on the debug server thread, but that's not where we
++ // want it to live. It logically belongs to the service. Mind that the service does not live
++ // on the debug server thread, but does process messageReceived() on the debug server thread.
++ moveToThread(service->thread());
++
++ // Exclude some resource paths used by Qt itself. There is no point in loading those from the
++ // client as the client will not have the files (or even worse, it may have different ones).
++ m_blacklist.blacklist(":/qt-project.org");
++ m_blacklist.blacklist(":/QtQuick/Controls/Styles");
++ m_blacklist.blacklist(":/ExtrasImports/QtQuick/Controls/Styles");
++
++ // Target specific configuration should not replaced with files from the host.
++ m_blacklist.blacklist("/etc");
++
++ for (int loc = QLibraryInfo::PrefixPath; loc < QLibraryInfo::TestsPath; ++loc) {
++ m_blacklist.blacklist(QLibraryInfo::paths(
++ static_cast<QLibraryInfo::LibraryPath>(loc)));
++ }
++ m_blacklist.blacklist(QLibraryInfo::paths(QLibraryInfo::SettingsPath));
++
++ static const QStandardPaths::StandardLocation blackListLocations[] = {
++ QStandardPaths::CacheLocation,
++ QStandardPaths::GenericDataLocation,
++ QStandardPaths::ConfigLocation,
++ QStandardPaths::GenericCacheLocation,
++ QStandardPaths::GenericConfigLocation,
++ QStandardPaths::AppDataLocation,
++ QStandardPaths::AppConfigLocation
++ };
++
++ for (auto locationType : blackListLocations) {
++ const QStringList locations = QStandardPaths::standardLocations(locationType);
++ for (const QString &location : locations)
++ m_blacklist.blacklist(location);
++ }
++
++ m_blacklist.whitelist(QLibraryInfo::paths(QLibraryInfo::TestsPath));
++
++ // On Windows, GenericDataLocation (AppData/Local) is a parent of the temp directory
++ // (AppData/Local/Temp). Whitelist the temp path since we commonly want to preview
++ // files in the temp location.
++ const QStringList tempLocations
++ = QStandardPaths::standardLocations(QStandardPaths::TempLocation);
++ for (const QString &tempLocation : tempLocations)
++ m_blacklist.whitelist(tempLocation);
++
++ // We absolutely want those signals to be connected directly. The service's (directly connected)
++ // load() signal should not be able to sneak in between a file() signal submission and its
++ // arrival. All the file loader's methods are protected by the contentMutex. So we can connect
++ // directly.
++ connect(this, &QQmlPreviewFileLoader::request, service, &QQmlPreviewServiceImpl::forwardRequest,
++ Qt::DirectConnection);
++ connect(service, &QQmlPreviewServiceImpl::directory, this, &QQmlPreviewFileLoader::directory,
++ Qt::DirectConnection);
++ connect(service, &QQmlPreviewServiceImpl::file, this, &QQmlPreviewFileLoader::file,
++ Qt::DirectConnection);
++ connect(service, &QQmlPreviewServiceImpl::error, this, &QQmlPreviewFileLoader::error,
++ Qt::DirectConnection);
++ connect(service, &QQmlPreviewServiceImpl::clearCache, this, &QQmlPreviewFileLoader::clearCache,
++ Qt::DirectConnection);
++ }
++
++ QQmlPreviewFileLoader::Result QQmlPreviewFileLoader::load(const QString &path)
++ {
++ QMutexLocker locker(&m_contentMutex);
++ m_path = path;
++
++ auto fileIterator = m_fileCache.constFind(path);
++ if (fileIterator != m_fileCache.constEnd()) {
++ m_result = File;
++ m_contents = *fileIterator;
++ m_entries.clear();
++ return m_result;
++ }
++
++ auto dirIterator = m_directoryCache.constFind(path);
++ if (dirIterator != m_directoryCache.constEnd()) {
++ m_result = Directory;
++ m_contents.clear();
++ m_entries = *dirIterator;
++ return m_result;
++ }
++
++ m_result = Unknown;
++ m_entries.clear();
++ m_contents.clear();
++ emit request(path);
++ m_waitCondition.wait(&m_contentMutex);
++ return m_result;
++ }
++
++ QByteArray QQmlPreviewFileLoader::contents()
++ {
++ QMutexLocker locker(&m_contentMutex);
++ return m_contents;
++ }
++
++ QStringList QQmlPreviewFileLoader::entries()
++ {
++ QMutexLocker locker(&m_contentMutex);
++ return m_entries;
++ }
++
++ void QQmlPreviewFileLoader::whitelist(const QUrl &url)
++ {
++ const QString path = QQmlFile::urlToLocalFileOrQrc(url);
++ if (!path.isEmpty()) {
++ QMutexLocker locker(&m_contentMutex);
++ m_blacklist.whitelist(path);
++ }
++ }
++
++ bool QQmlPreviewFileLoader::isBlacklisted(const QString &path)
++ {
++ QMutexLocker locker(&m_contentMutex);
++ return m_blacklist.isBlacklisted(path);
++ }
++
++ void QQmlPreviewFileLoader::file(const QString &path, const QByteArray &contents)
++ {
++ QMutexLocker locker(&m_contentMutex);
++ m_blacklist.whitelist(path);
++ m_fileCache[path] = contents;
++ if (path == m_path) {
++ m_contents = contents;
++ m_result = File;
++ m_waitCondition.wakeOne();
++ }
++ }
++
++ void QQmlPreviewFileLoader::directory(const QString &path, const QStringList &entries)
++ {
++ QMutexLocker locker(&m_contentMutex);
++ m_blacklist.whitelist(path);
++ m_directoryCache[path] = entries;
++ if (path == m_path) {
++ m_entries = entries;
++ m_result = Directory;
++ m_waitCondition.wakeOne();
++ }
++ }
++
++ void QQmlPreviewFileLoader::error(const QString &path)
++ {
++ QMutexLocker locker(&m_contentMutex);
++ m_blacklist.blacklist(path);
++ if (path == m_path) {
++ m_result = Fallback;
++ m_waitCondition.wakeOne();
++ }
++ }
++
++ void QQmlPreviewFileLoader::clearCache()
++ {
++ QMutexLocker locker(&m_contentMutex);
++ m_fileCache.clear();
++ m_directoryCache.clear();
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qqmlpreviewfileloader.cpp"