kdesktopfile.cpp

/*
    This file is part of the KDE libraries
    SPDX-FileCopyrightText: 1999 Pietro Iglio <iglio@kde.org>
    SPDX-FileCopyrightText: 1999 Preston Brown <pbrown@kde.org>
 
    SPDX-License-Identifier: LGPL-2.0-or-later
*/
 
#include "kdesktopfile.h"
 
#include "kauthorized.h"
#include "kconfig_core_log_settings.h"
#include "kconfig_p.h"
#include "kconfiggroup.h"
#include "kconfigini_p.h"
#include "kdesktopfileaction.h"
 
#include <QDir>
#include <QFileInfo>
#include <QStandardPaths>
#include <QUrl>
 
#ifndef Q_OS_WIN
#include <unistd.h>
#endif
 
#include <algorithm>
 
class KDesktopFilePrivate : public KConfigPrivate
{
public:
    KDesktopFilePrivate(QStandardPaths::StandardLocation resourceType, const QString &fileName)
        : KConfigPrivate(KConfig::NoGlobals, resourceType)
    {
        changeFileName(fileName);
 
        // make sure the [Desktop Entry] group is always the first one, as required by the spec
        mBackend.setPrimaryGroup(QStringLiteral("Desktop Entry"));
    }
    KConfigGroup desktopGroup;
};
 
KDesktopFile::KDesktopFile(QStandardPaths::StandardLocation resourceType, const QString &fileName)
    : KConfig(*new KDesktopFilePrivate(resourceType, fileName))
{
    Q_D(KDesktopFile);
    reparseConfiguration();
    d->desktopGroup = KConfigGroup(this, QStringLiteral("Desktop Entry"));
}
 
KDesktopFile::KDesktopFile(const QString &fileName)
    : KDesktopFile(QStandardPaths::ApplicationsLocation, fileName)
{
}
 
KDesktopFile::~KDesktopFile() = default;
 
KConfigGroup KDesktopFile::desktopGroup() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup;
}
 
QString KDesktopFile::locateLocal(const QString &path)
{
    static const QLatin1Char slash('/');
 
    // Relative to config? (e.g. for autostart)
    const QStringList genericConfig = QStandardPaths::standardLocations(QStandardPaths::GenericConfigLocation);
    // Iterate from the last item since some items may be subfolders of others.
    auto it = std::find_if(genericConfig.crbegin(), genericConfig.crend(), [&path](const QString &dir) {
        return path.startsWith(dir + slash);
    });
    if (it != genericConfig.crend()) {
        return QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + slash + QStringView(path).mid(it->size() + 1);
    }
 
    QString relativePath;
    // Relative to xdg data dir? (much more common)
    const QStringList lstGenericDataLocation = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);
    for (const QString &dir : lstGenericDataLocation) {
        if (path.startsWith(dir + slash)) {
            relativePath = path.mid(dir.length() + 1);
        }
    }
    if (relativePath.isEmpty()) {
        // What now? The desktop file doesn't come from XDG_DATA_DIRS. Use filename only and hope for the best.
        relativePath = path.mid(path.lastIndexOf(slash) + 1);
    }
    return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + slash + relativePath;
}
 
bool KDesktopFile::isDesktopFile(const QString &path)
{
    return path.endsWith(QLatin1String(".desktop"));
}
 
bool KDesktopFile::isAuthorizedDesktopFile(const QString &path)
{
    if (path.isEmpty()) {
        return false; // Empty paths are not ok.
    }
 
    if (QDir::isRelativePath(path)) {
        return true; // Relative paths are ok.
    }
 
    const QString realPath = QFileInfo(path).canonicalFilePath();
    if (realPath.isEmpty()) {
        return false; // File doesn't exist.
    }
 
#ifndef Q_OS_WIN
    static constexpr Qt::CaseSensitivity sensitivity = Qt::CaseSensitive;
#else
    static constexpr Qt::CaseSensitivity sensitivity = Qt::CaseInsensitive;
#endif
 
    // Check if the .desktop file is installed as part of KDE or XDG.
    const QStringList appsDirs = QStandardPaths::standardLocations(QStandardPaths::ApplicationsLocation);
    auto it = std::find_if(appsDirs.cbegin(), appsDirs.cend(), [&realPath, &path](const QString &prefix) {
        QFileInfo info(prefix);
        return info.exists() && info.isDir() && (realPath.startsWith(info.canonicalFilePath(), sensitivity) || path.startsWith(info.canonicalFilePath()));
    });
    if (it != appsDirs.cend()) {
        return true;
    }
 
    const QString autostartDir = QStringLiteral("autostart/");
    const QStringList lstConfigPath = QStandardPaths::standardLocations(QStandardPaths::GenericConfigLocation);
    auto configIt = std::find_if(lstConfigPath.cbegin(), lstConfigPath.cend(), [&realPath, &autostartDir](const QString &xdgDataPrefix) {
        QFileInfo info(xdgDataPrefix);
        if (info.exists() && info.isDir()) {
            const QString prefix = info.canonicalFilePath();
            return realPath.startsWith(prefix + QLatin1Char('/') + autostartDir, sensitivity);
        }
        return false;
    });
    if (configIt != lstConfigPath.cend()) {
        return true;
    }
 
    // Forbid desktop files outside of standard locations if kiosk is set so
    if (!KAuthorized::authorize(QStringLiteral("run_desktop_files"))) {
        qCWarning(KCONFIG_CORE_LOG) << "Access to" << path << "denied because of 'run_desktop_files' restriction.";
        return false;
    }
 
    // Not otherwise permitted, so only allow if the file is executable, or if
    // owned by root (uid == 0)
    QFileInfo entryInfo(path);
    if (entryInfo.isExecutable() || entryInfo.ownerId() == 0) {
        return true;
    }
 
    qCInfo(KCONFIG_CORE_LOG) << "Access to" << path << "denied, not owned by root and executable flag not set.";
    return false;
}
 
QString KDesktopFile::readType() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readEntry("Type", QString());
}
 
QString KDesktopFile::readIcon() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readEntry("Icon", QString());
}
 
QString KDesktopFile::readName() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readEntry("Name", QString());
}
 
QString KDesktopFile::readComment() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readEntry("Comment", QString());
}
 
QString KDesktopFile::readGenericName() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readEntry("GenericName", QString());
}
 
QString KDesktopFile::readPath() const
{
    Q_D(const KDesktopFile);
    // NOT readPathEntry, it is not XDG-compliant: it performs
    // various expansions, like $HOME.  Note that the expansion
    // behaviour still happens if the "e" flag is set, maintaining
    // backwards compatibility.
    return d->desktopGroup.readEntry("Path", QString());
}
 
QString KDesktopFile::readUrl() const
{
    Q_D(const KDesktopFile);
    if (hasDeviceType()) {
        return d->desktopGroup.readEntry("MountPoint", QString());
    } else {
        // NOT readPathEntry (see readPath())
        QString url = d->desktopGroup.readEntry("URL", QString());
        if (!url.isEmpty() && !QDir::isRelativePath(url)) {
            // Handle absolute paths as such (i.e. we need to escape them)
            return QUrl::fromLocalFile(url).toString();
        }
        return url;
    }
}
 
QStringList KDesktopFile::readActions() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readXdgListEntry("Actions");
}
 
QStringList KDesktopFile::readMimeTypes() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readXdgListEntry("MimeType");
}
 
KConfigGroup KDesktopFile::actionGroup(const QString &group)
{
    return KConfigGroup(this, QLatin1String("Desktop Action ") + group);
}
 
KConfigGroup KDesktopFile::actionGroup(const QString &group) const
{
    return const_cast<KDesktopFile *>(this)->actionGroup(group);
}
 
bool KDesktopFile::hasActionGroup(const QString &group) const
{
    return hasGroup(QString(QLatin1String("Desktop Action ") + group));
}
 
bool KDesktopFile::hasLinkType() const
{
    return readType() == QLatin1String("Link");
}
 
bool KDesktopFile::hasApplicationType() const
{
    return readType() == QLatin1String("Application");
}
 
bool KDesktopFile::hasDeviceType() const
{
    return readType() == QLatin1String("FSDevice");
}
 
bool KDesktopFile::tryExec() const
{
    Q_D(const KDesktopFile);
    // Test for TryExec and "X-KDE-AuthorizeAction"
    // NOT readPathEntry (see readPath())
    const QString te = d->desktopGroup.readEntry("TryExec", QString());
    if (!te.isEmpty() && QStandardPaths::findExecutable(te).isEmpty()) {
        return false;
    }
    const QStringList list = d->desktopGroup.readEntry("X-KDE-AuthorizeAction", QStringList());
    const auto isNotAuthorized = std::any_of(list.cbegin(), list.cend(), [](const QString &action) {
        return !KAuthorized::authorize(action.trimmed());
    });
    if (isNotAuthorized) {
        return false;
    }
 
    // See also KService::username()
    if (d->desktopGroup.readEntry("X-KDE-SubstituteUID", false)) {
        QString user = d->desktopGroup.readEntry("X-KDE-Username", QString());
        if (user.isEmpty()) {
            user = qEnvironmentVariable("ADMIN_ACCOUNT"), QStringLiteral("root");
        }
        if (!KAuthorized::authorize(QLatin1String("user/") + user)) {
            return false;
        }
    }
 
    return true;
}
 
QString KDesktopFile::readDocPath() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readPathEntry("X-DocPath", QString());
}
 
KDesktopFile *KDesktopFile::copyTo(const QString &file) const
{
    KDesktopFile *config = new KDesktopFile(QString());
    this->KConfig::copyTo(file, config);
    return config;
}
 
QString KDesktopFile::fileName() const
{
    return name();
}
 
bool KDesktopFile::noDisplay() const
{
    Q_D(const KDesktopFile);
    return d->desktopGroup.readEntry("NoDisplay", false);
}
 
QList<KDesktopFileAction> KDesktopFile::actions() const
{
    QList<KDesktopFileAction> desktopFileActions;
    const QStringList actionKeys = readActions();
    for (const QString &actionKey : actionKeys) {
        const KConfigGroup grp = actionGroup(actionKey);
        desktopFileActions << KDesktopFileAction(actionKey, grp.readEntry("Name"), grp.readEntry("Icon"), grp.readEntry("Exec"), fileName());
    }
    return desktopFileActions;
}