File indexing completed on 2024-04-28 05:27:04

 /* This file is part of the KDE project
    SPDX-FileCopyrightText: 2003 Waldo Bastian <bastian@kde.org>
    SPDX-FileCopyrightText: 2003, 2007 David Faure <faure@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only
 */
 
 #include "mimetypedata.h"
 #include "mimetypewriter.h"
 #include <KApplicationTrader>
 #include <KConfigGroup>
 #include <KParts/PartLoader>
 #include <KProtocolManager>
 #include <KService>
 #include <KSharedConfig>
 #include <QDebug>
 #include <QFileInfo>
 #include <QMimeDatabase>
 #include <QStandardPaths>
 #include <QXmlStreamReader>
 
 MimeTypeData::MimeTypeData(const QString &major)
     : m_askSave(AskSaveDefault)
     , m_bNewItem(false)
     , m_bFullInit(true)
     , m_isGroup(true)
     , m_appServicesModified(false)
     , m_embedServicesModified(false)
     , m_userSpecifiedIconModified(false)
     , m_major(major)
 {
     m_autoEmbed = readAutoEmbed();
 }
 
 MimeTypeData::MimeTypeData(const QMimeType &mime)
     : m_mimetype(mime)
     , m_askSave(AskSaveDefault)
     , // TODO: the code for initializing this is missing. FileTypeDetails initializes the checkbox instead...
     m_bNewItem(false)
     , m_bFullInit(false)
     , m_isGroup(false)
     , m_appServicesModified(false)
     , m_embedServicesModified(false)
     , m_userSpecifiedIconModified(false)
 {
     const QString mimeName = m_mimetype.name();
     Q_ASSERT(!mimeName.isEmpty());
     const int index = mimeName.indexOf(QLatin1Char('/'));
     if (index != -1) {
         m_major = mimeName.left(index);
         m_minor = mimeName.mid(index + 1);
     } else {
         m_major = mimeName;
     }
     initFromQMimeType();
 }
 
 MimeTypeData::MimeTypeData(const QString &mimeName, bool)
     : m_askSave(AskSaveDefault)
     , m_bNewItem(true)
     , m_bFullInit(false)
     , m_isGroup(false)
     , m_appServicesModified(false)
     , m_embedServicesModified(false)
     , m_userSpecifiedIconModified(false)
 {
     const int index = mimeName.indexOf(QLatin1Char('/'));
     if (index != -1) {
         m_major = mimeName.left(index);
         m_minor = mimeName.mid(index + 1);
     } else {
         m_major = mimeName;
     }
     m_autoEmbed = UseGroupSetting;
     // all the rest is empty by default
 }
 
 void MimeTypeData::initFromQMimeType()
 {
     m_comment = m_mimetype.comment();
     setPatterns(m_mimetype.globPatterns());
     m_autoEmbed = readAutoEmbed();
 
     // Parse XML file to find out if the user specified a custom icon name
     QString file = name().toLower() + QLatin1String(".xml");
     QStringList mimeFiles = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("mime/") + file);
     if (mimeFiles.isEmpty()) {
         // This is for shared-mime-info < 1.3 that did not lowecase mime names
         file = name() + QLatin1String(".xml");
         mimeFiles = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("mime/") + file);
         if (mimeFiles.isEmpty()) {
             qWarning() << "No file found for" << file << ", even though the file appeared in a directory listing.";
             qWarning() << "Either it was just removed, or the directory doesn't have executable permission...";
             qWarning() << QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("mime"), QStandardPaths::LocateDirectory);
             return;
         }
     }
 
     // Reverse iterator to get global first, then local.
     for (auto rIt = mimeFiles.crbegin(); rIt != mimeFiles.crend(); ++rIt) {
         const QString fullPath = *rIt;
         QFile qfile(fullPath);
         if (!qfile.open(QFile::ReadOnly)) {
             continue;
         }
 
         QXmlStreamReader xml(&qfile);
         if (xml.readNextStartElement()) {
             if (xml.name() != QLatin1String("mime-type")) {
                 continue;
             }
             const QString mimeName = xml.attributes().value(QLatin1String("type")).toString();
             if (mimeName.isEmpty()) {
                 continue;
             }
             if (QString::compare(mimeName, name(), Qt::CaseInsensitive) != 0) {
                 qWarning() << "Got name" << mimeName << "in file" << file << "expected" << name();
             }
 
             while (xml.readNextStartElement()) {
                 const auto tag = xml.name();
                 if (tag == QLatin1String("icon")) {
                     m_userSpecifiedIcon = xml.attributes().value(QLatin1String("name")).toString();
                 }
                 xml.skipCurrentElement();
             }
         }
     }
 }
 
 MimeTypeData::AutoEmbed MimeTypeData::readAutoEmbed() const
 {
     const KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("filetypesrc"), KConfig::NoGlobals);
     const QString key = QStringLiteral("embed-") + name();
     const KConfigGroup group(config, "EmbedSettings");
     if (m_isGroup) {
         // embedding is false by default except for image/*, multipart/* and inode/* (hardcoded in konq)
         const bool defaultValue = (m_major == QLatin1String("image") || m_major == QLatin1String("multipart") || m_major == QLatin1String("inode"));
         return group.readEntry(key, defaultValue) ? Yes : No;
     } else {
         if (group.hasKey(key)) {
             return group.readEntry(key, false) ? Yes : No;
         }
         // TODO if ( !mimetype.property( "X-KDE-LocalProtocol" ).toString().isEmpty() )
         // TODO    return MimeTypeData::Yes; // embed by default for zip, tar etc.
         return MimeTypeData::UseGroupSetting;
     }
 }
 
 void MimeTypeData::writeAutoEmbed()
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("filetypesrc"), KConfig::NoGlobals);
     if (!config->isConfigWritable(true)) {
         return;
     }
 
     const QString key = QStringLiteral("embed-") + name();
     KConfigGroup group(config, "EmbedSettings");
     if (m_isGroup) {
         group.writeEntry(key, m_autoEmbed == Yes);
     } else {
         if (m_autoEmbed == UseGroupSetting) {
             group.deleteEntry(key);
         } else {
             group.writeEntry(key, m_autoEmbed == Yes);
         }
     }
 }
 
 bool MimeTypeData::isEssential() const
 {
     // Keep in sync with KMimeType::checkEssentialMimeTypes
     const QString n = name();
     if (n == QLatin1String("application/octet-stream")) {
         return true;
     }
     if (n == QLatin1String("inode/directory")) {
         return true;
     }
     if (n == QLatin1String("inode/blockdevice")) {
         return true;
     }
     if (n == QLatin1String("inode/chardevice")) {
         return true;
     }
     if (n == QLatin1String("inode/socket")) {
         return true;
     }
     if (n == QLatin1String("inode/fifo")) {
         return true;
     }
     if (n == QLatin1String("application/x-shellscript")) {
         return true;
     }
     if (n == QLatin1String("application/x-executable")) {
         return true;
     }
     if (n == QLatin1String("application/x-desktop")) {
         return true;
     }
     return false;
 }
 
 void MimeTypeData::setUserSpecifiedIcon(const QString &icon)
 {
     if (icon == m_userSpecifiedIcon) {
         return;
     }
     m_userSpecifiedIcon = icon;
     m_userSpecifiedIconModified = true;
 }
 
 QStringList MimeTypeData::getAppOffers() const
 {
     QStringList serviceIds;
     const KService::List offerList = KApplicationTrader::queryByMimeType(name());
     for (const auto &servicePtr : offerList) {
         serviceIds.append(servicePtr->storageId());
     }
     return serviceIds;
 }
 
 QStringList MimeTypeData::getPartOffers() const
 {
     QStringList servicesIds;
     // We do not do any sorting, because KParts uses the order in which the entries are saved
     const auto partOfferList = KParts::PartLoader::partsForMimeType(name());
     for (const auto &metaData : partOfferList) {
         servicesIds.append(metaData.pluginId());
     }
     return servicesIds;
 }
 
 void MimeTypeData::getMyServiceOffers() const
 {
     m_appServices = getAppOffers();
     m_embedParts = getPartOffers();
     m_bFullInit = true;
 }
 
 QStringList MimeTypeData::appServices() const
 {
     if (!m_bFullInit) {
         getMyServiceOffers();
     }
     return m_appServices;
 }
 
 QStringList MimeTypeData::embedParts() const
 {
     if (!m_bFullInit) {
         getMyServiceOffers();
     }
     return m_embedParts;
 }
 
 bool MimeTypeData::isMimeTypeDirty() const
 {
     Q_ASSERT(!m_isGroup);
     if (m_bNewItem) {
         return true;
     }
 
     if (!m_mimetype.isValid()) {
         qWarning() << "MimeTypeData for" << name() << "says 'not new' but is without a mimetype? Should not happen.";
         return true;
     }
 
     if (m_mimetype.comment() != m_comment) {
         qDebug() << "Mimetype Comment Dirty: old=" << m_mimetype.comment() << "m_comment=" << m_comment;
         return true;
     }
     if (m_userSpecifiedIconModified) {
         qDebug() << "m_userSpecifiedIcon has changed. Now set to" << m_userSpecifiedIcon;
         return true;
     }
 
     QStringList storedPatterns = m_mimetype.globPatterns();
     storedPatterns.sort(); // see ctor
     if (storedPatterns != m_patterns) {
         qDebug() << "Mimetype Patterns Dirty: old=" << storedPatterns << "m_patterns=" << m_patterns;
         return true;
     }
 
     if (readAutoEmbed() != m_autoEmbed) {
         return true;
     }
     return false;
 }
 
 bool MimeTypeData::isServiceListDirty() const
 {
     return !m_isGroup && (m_appServicesModified || m_embedServicesModified);
 }
 
 bool MimeTypeData::isDirty() const
 {
     if (m_bNewItem) {
         qDebug() << "New item, need to save it";
         return true;
     }
 
     if (!m_isGroup) {
         if (isServiceListDirty()) {
             return true;
         }
         if (isMimeTypeDirty()) {
             return true;
         }
     } else { // is a group
         if (readAutoEmbed() != m_autoEmbed) {
             return true;
         }
     }
 
     if (m_askSave != AskSaveDefault) {
         return true;
     }
 
     // nothing seems to have changed, it's not dirty.
     return false;
 }
 
 bool MimeTypeData::sync()
 {
     if (m_isGroup) {
         writeAutoEmbed();
         return false;
     }
 
     if (m_askSave != AskSaveDefault) {
         KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("filetypesrc"), KConfig::NoGlobals);
         if (!config->isConfigWritable(true)) {
             return false;
         }
         KConfigGroup cg = config->group("Notification Messages");
         if (m_askSave == AskSaveYes) {
             // Ask
             cg.deleteEntry(QStringLiteral("askSave") + name());
             cg.deleteEntry(QStringLiteral("askEmbedOrSave") + name());
         } else {
             // Do not ask, open
             cg.writeEntry(QStringLiteral("askSave") + name(), QStringLiteral("no"));
             cg.writeEntry(QStringLiteral("askEmbedOrSave") + name(), QStringLiteral("no"));
         }
     }
 
     writeAutoEmbed();
 
     bool needUpdateMimeDb = false;
     if (isMimeTypeDirty()) {
         MimeTypeWriter mimeTypeWriter(name());
         mimeTypeWriter.setComment(m_comment);
         if (!m_userSpecifiedIcon.isEmpty()) {
             mimeTypeWriter.setIconName(m_userSpecifiedIcon);
         }
         mimeTypeWriter.setPatterns(m_patterns);
         if (!mimeTypeWriter.write()) {
             return false;
         }
         m_userSpecifiedIconModified = false;
         needUpdateMimeDb = true;
     }
 
     syncServices();
 
     return needUpdateMimeDb;
 }
 
 static const char s_DefaultApplications[] = "Default Applications";
 static const char s_AddedAssociations[] = "Added Associations";
 static const char s_RemovedAssociations[] = "Removed Associations";
 
 void MimeTypeData::syncServices()
 {
     if (!m_bFullInit) {
         return;
     }
 
     KSharedConfig::Ptr profile = KSharedConfig::openConfig(QStringLiteral("mimeapps.list"), KConfig::NoGlobals, QStandardPaths::GenericConfigLocation);
 
     if (!profile->isConfigWritable(true)) { // warn user if mimeapps.list is root-owned (#155126/#94504)
         return;
     }
 
     const QStringList oldAppServices = getAppOffers();
     if (oldAppServices != m_appServices) {
         // Save the default application according to mime-apps-spec 1.0
         KConfigGroup defaultApp(profile, s_DefaultApplications);
         saveDefaultApplication(defaultApp, m_appServices);
         // Save preferred services
         KConfigGroup addedApps(profile, s_AddedAssociations);
         saveServices(addedApps, m_appServices);
         KConfigGroup removedApps(profile, s_RemovedAssociations);
         saveRemovedServices(removedApps, m_appServices, oldAppServices);
     }
 
     KSharedConfig::Ptr kpartsProfile = KSharedConfig::openConfig(QStringLiteral("kpartsrc"), KConfig::NoGlobals);
     const QStringList oldPartServices = getPartOffers();
     if (oldPartServices != m_embedParts) {
         KConfigGroup addedParts(kpartsProfile, "Added KDE Part Associations");
         if (m_embedParts.isEmpty()) {
             addedParts.deleteEntry(name());
         } else {
             addedParts.writeXdgListEntry(name(), m_embedParts);
         }
         KConfigGroup removedParts(kpartsProfile, "Removed KDE Part Associations");
         saveRemovedServices(removedParts, m_embedParts, oldPartServices);
     }
 
     // Clean out any kde-mimeapps.list which would take precedence any cancel our changes.
     const QString desktops = QString::fromLocal8Bit(qgetenv("XDG_CURRENT_DESKTOP"));
     const auto desktopsSplit = desktops.split(QLatin1Char(':'), Qt::SkipEmptyParts);
     for (const QString &desktop : desktopsSplit) {
         const QString file =
             QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + QLatin1Char('/') + desktop.toLower() + QLatin1String("-mimeapps.list");
         if (QFileInfo::exists(file)) {
             qDebug() << "Cleaning up" << file;
             KConfig conf(file, KConfig::NoGlobals);
             KConfigGroup(&conf, s_DefaultApplications).deleteEntry(name());
             KConfigGroup(&conf, s_AddedAssociations).deleteEntry(name());
             KConfigGroup(&conf, s_RemovedAssociations).deleteEntry(name());
         }
     }
 
     m_appServicesModified = false;
     m_embedServicesModified = false;
 }
 
 static QStringList collectStorageIds(const QStringList &services)
 {
     QStringList storageIds;
 
     for (const QString &service : services) {
         KService::Ptr pService = KService::serviceByStorageId(service);
         if (!pService) {
             qWarning() << "service with storage id" << service << "not found";
             continue; // Where did that one go?
         }
 
         storageIds.append(pService->storageId());
     }
 
     return storageIds;
 }
 
 void MimeTypeData::saveRemovedServices(KConfigGroup &config, const QStringList &services, const QStringList &oldServices)
 {
     QStringList removedServiceList = config.readXdgListEntry(name());
 
     for (const QString &service : services) {
         // If removedServiceList.contains(service), then it was previously removed but has been added back
         removedServiceList.removeAll(service);
     }
     for (const QString &oldService : oldServices) {
         if (!services.contains(oldService)) {
             // The service was in m_appServices (or m_embedServices) but has been removed
             removedServiceList.append(oldService);
         }
     }
     if (removedServiceList.isEmpty()) {
         config.deleteEntry(name());
     } else {
         config.writeXdgListEntry(name(), removedServiceList);
     }
 }
 
 void MimeTypeData::saveServices(KConfigGroup &config, const QStringList &services)
 {
     if (services.isEmpty()) {
         config.deleteEntry(name());
     } else {
         config.writeXdgListEntry(name(), collectStorageIds(services));
     }
 }
 
 void MimeTypeData::saveDefaultApplication(KConfigGroup &config, const QStringList &services)
 {
     if (services.isEmpty()) {
         config.deleteEntry(name());
         return;
     }
 
     const QStringList storageIds = collectStorageIds(services);
     if (!storageIds.isEmpty()) {
         const QString firstStorageId = storageIds.at(0);
         config.writeXdgListEntry(name(), {firstStorageId});
     }
 }
 
 void MimeTypeData::refresh()
 {
     if (m_isGroup) {
         return;
     }
     QMimeDatabase db;
     m_mimetype = db.mimeTypeForName(name());
     if (m_mimetype.isValid()) {
         if (m_bNewItem) {
             qDebug() << "OK, created" << name();
             m_bNewItem = false; // if this was a new mimetype, we just created it
         }
         if (!isMimeTypeDirty()) {
             // Update from the xml, in case something was changed from out of this kcm
             // (e.g. using KOpenWithDialog, or keditfiletype + kcmshell filetypes)
             initFromQMimeType();
         }
         if (!m_appServicesModified && !m_embedServicesModified) {
             m_bFullInit = false; // refresh services too
         }
     }
 }
 
 void MimeTypeData::getAskSave(bool &_askSave)
 {
     if (m_askSave == AskSaveYes) {
         _askSave = true;
     }
     if (m_askSave == AskSaveNo) {
         _askSave = false;
     }
 }
 
 void MimeTypeData::setAskSave(bool _askSave)
 {
     m_askSave = _askSave ? AskSaveYes : AskSaveNo;
 }
 
 bool MimeTypeData::canUseGroupSetting() const
 {
     // "Use group settings" isn't available for zip, tar etc.; those have a builtin default...
     if (!m_mimetype.isValid()) { // e.g. new mimetype
         return true;
     }
     const bool hasLocalProtocolRedirect = !KProtocolManager::protocolForArchiveMimetype(name()).isEmpty();
     return !hasLocalProtocolRedirect;
 }
 
 void MimeTypeData::setPatterns(const QStringList &p)
 {
     m_patterns = p;
     // Sort them, since update-mime-database doesn't respect order (order of globs file != order of xml),
     // and this code says things like if (m_mimetype.patterns() == m_patterns).
     // We could also sort in KMimeType::setPatterns but this would just slow down the
     // normal use case (anything else than this KCM) for no good reason.
     m_patterns.sort();
 }
 
 bool MimeTypeData::matchesFilter(const QString &filter) const
 {
     if (name().contains(filter, Qt::CaseInsensitive)) {
         return true;
     }
 
     if (m_comment.contains(filter, Qt::CaseInsensitive)) {
         return true;
     }
 
     if (!m_patterns.filter(filter, Qt::CaseInsensitive).isEmpty()) {
         return true;
     }
 
     return false;
 }
 
 void MimeTypeData::setAppServices(const QStringList &dsl)
 {
     if (!m_bFullInit) {
         getMyServiceOffers(); // so that m_bFullInit is true
     }
     m_appServices = dsl;
     m_appServicesModified = true;
 }
 
 void MimeTypeData::setEmbedParts(const QStringList &dsl)
 {
     if (!m_bFullInit) {
         getMyServiceOffers(); // so that m_bFullInit is true
     }
     m_embedParts = dsl;
     m_embedServicesModified = true;
 }
 
 QString MimeTypeData::icon() const
 {
     if (!m_userSpecifiedIcon.isEmpty()) {
         return m_userSpecifiedIcon;
     }
     if (m_mimetype.isValid()) {
         return m_mimetype.iconName();
     }
     return QString();
 }