File indexing completed on 2024-04-28 15:29:51

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 1999-2006 David Faure <faure@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "kservice.h"
 #include "kservicefactory_p.h"
 #include "ksycoca.h"
 #include "ksycocadict_p.h"
 #include "ksycocatype.h"
 #include "servicesdebug.h"
 #include <QDir>
 #include <QFile>
 
 extern int servicesDebugArea();
 
 KServiceFactory::KServiceFactory(KSycoca *db)
     : KSycocaFactory(KST_KServiceFactory, db)
     , m_nameDict(nullptr)
     , m_relNameDict(nullptr)
     , m_menuIdDict(nullptr)
 {
     m_offerListOffset = 0;
     m_nameDictOffset = 0;
     m_relNameDictOffset = 0;
     m_menuIdDictOffset = 0;
     if (!sycoca()->isBuilding()) {
         QDataStream *str = stream();
         Q_ASSERT(str);
         if (!str) {
             return;
         }
         // Read Header
         qint32 i;
         (*str) >> i;
         m_nameDictOffset = i;
         (*str) >> i;
         m_relNameDictOffset = i;
         (*str) >> i;
         m_offerListOffset = i;
         (*str) >> i;
         m_menuIdDictOffset = i;
 
         const qint64 saveOffset = str->device()->pos();
         // Init index tables
         m_nameDict = new KSycocaDict(str, m_nameDictOffset);
         // Init index tables
         m_relNameDict = new KSycocaDict(str, m_relNameDictOffset);
         // Init index tables
         m_menuIdDict = new KSycocaDict(str, m_menuIdDictOffset);
         str->device()->seek(saveOffset);
     }
 }
 
 KServiceFactory::~KServiceFactory()
 {
     delete m_nameDict;
     delete m_relNameDict;
     delete m_menuIdDict;
 }
 
 KService::Ptr KServiceFactory::findServiceByName(const QString &_name)
 {
     if (!sycocaDict()) {
         return KService::Ptr(); // Error!
     }
 
     // Warning : this assumes we're NOT building a database
     // But since findServiceByName isn't called in that case...
     // [ see KServiceTypeFactory for how to do it if needed ]
 
     int offset = sycocaDict()->find_string(_name);
     if (!offset) {
         return KService::Ptr(); // Not found
     }
 
     KService::Ptr newService(createEntry(offset));
 
     // Check whether the dictionary was right.
     if (newService && (newService->name() != _name)) {
         // No it wasn't...
         return KService::Ptr();
     }
     return newService;
 }
 
 KService::Ptr KServiceFactory::findServiceByDesktopName(const QString &_name)
 {
     if (!m_nameDict) {
         return KService::Ptr(); // Error!
     }
 
     // Warning : this assumes we're NOT building a database
     // KBuildServiceFactory reimplements it for the case where we are building one
 
     int offset = m_nameDict->find_string(_name);
     if (!offset) {
         return KService::Ptr(); // Not found
     }
 
     KService::Ptr newService(createEntry(offset));
 
     // Check whether the dictionary was right.
     if (newService && (newService->desktopEntryName() != _name)) {
         // No it wasn't...
         return KService::Ptr();
     }
     return newService;
 }
 
 KService::Ptr KServiceFactory::findServiceByDesktopPath(const QString &_name)
 {
     if (!m_relNameDict) {
         return KService::Ptr(); // Error!
     }
 
     // Warning : this assumes we're NOT building a database
     // KBuildServiceFactory reimplements it for the case where we are building one
 
     int offset = m_relNameDict->find_string(_name);
     if (!offset) {
         // qCDebug(SERVICES) << "findServiceByDesktopPath:" << _name << "not found";
         return KService::Ptr(); // Not found
     }
 
     KService::Ptr newService(createEntry(offset));
     if (!newService) {
         qCDebug(SERVICES) << "createEntry failed!";
     }
     // Check whether the dictionary was right
     // It's ok that it's wrong, for the case where we're looking up an unknown service,
     // and the hash value gave us another one.
     if (newService && (newService->entryPath() != _name)) {
         // No it wasn't...
         return KService::Ptr();
     }
     return newService;
 }
 
 KService::Ptr KServiceFactory::findServiceByMenuId(const QString &_menuId)
 {
     if (!m_menuIdDict) {
         return KService::Ptr(); // Error!
     }
 
     // Warning : this assumes we're NOT building a database
     // KBuildServiceFactory reimplements it for the case where we are building one
 
     int offset = m_menuIdDict->find_string(_menuId);
     if (!offset) {
         return KService::Ptr(); // Not found
     }
 
     KService::Ptr newService(createEntry(offset));
 
     // Check whether the dictionary was right.
     if (newService && (newService->menuId() != _menuId)) {
         // No it wasn't...
         return KService::Ptr();
     }
     return newService;
 }
 
 KService::Ptr KServiceFactory::findServiceByStorageId(const QString &_storageId)
 {
     KService::Ptr service = findServiceByMenuId(_storageId);
     if (service) {
         return service;
     }
 
     service = findServiceByDesktopPath(_storageId);
     if (service) {
         return service;
     }
 
     if (!QDir::isRelativePath(_storageId) && QFile::exists(_storageId)) {
         return KService::Ptr(new KService(_storageId));
     }
 
     QString tmp = _storageId;
     tmp = tmp.mid(tmp.lastIndexOf(QLatin1Char('/')) + 1); // Strip dir
 
     if (tmp.endsWith(QLatin1String(".desktop"))) {
         tmp.chop(8);
     }
 
     if (tmp.endsWith(QLatin1String(".kdelnk"))) {
         tmp.chop(7);
     }
 
     service = findServiceByDesktopName(tmp);
 
     return service;
 }
 
 KService *KServiceFactory::createEntry(int offset) const
 {
     KSycocaType type;
     QDataStream *str = sycoca()->findEntry(offset, type);
     if (type != KST_KService) {
         qCWarning(SERVICES) << "KServiceFactory: unexpected object entry in KSycoca database (type=" << int(type) << ")";
         return nullptr;
     }
     KService *newEntry = new KService(*str, offset);
     if (!newEntry->isValid()) {
         qCWarning(SERVICES) << "KServiceFactory: corrupt object in KSycoca database!";
         delete newEntry;
         newEntry = nullptr;
     }
     return newEntry;
 }
 
 KService::List KServiceFactory::allServices()
 {
     KService::List result;
     const KSycocaEntry::List list = allEntries();
     for (const auto &entryPtr : list) {
         if (entryPtr->isType(KST_KService)) {
             result.append(KService::Ptr(static_cast<KService *>(entryPtr.data())));
         }
     }
     return result;
 }
 
 QStringList KServiceFactory::resourceDirs()
 {
     return KSycocaFactory::allDirectories(QStringLiteral("kservices5")) + KSycocaFactory::allDirectories(QStringLiteral("applications"));
 }
 
 QList<KServiceOffer> KServiceFactory::offers(int serviceTypeOffset, int serviceOffersOffset)
 {
     QList<KServiceOffer> list;
 
     // Jump to the offer list
     QDataStream *str = stream();
     str->device()->seek(m_offerListOffset + serviceOffersOffset);
 
     qint32 aServiceTypeOffset;
     qint32 aServiceOffset;
     qint32 initialPreference;
     qint32 mimeTypeInheritanceLevel;
     while (true) {
         (*str) >> aServiceTypeOffset;
         if (aServiceTypeOffset) {
             (*str) >> aServiceOffset;
             (*str) >> initialPreference;
             (*str) >> mimeTypeInheritanceLevel;
             if (aServiceTypeOffset == serviceTypeOffset) {
                 // Save stream position !
                 const qint64 savedPos = str->device()->pos();
                 // Create Service
                 KService *serv = createEntry(aServiceOffset);
                 if (serv) {
                     KService::Ptr servPtr(serv);
 #if KSERVICE_BUILD_DEPRECATED_SINCE(5, 69)
                     list.append(KServiceOffer(servPtr, initialPreference, mimeTypeInheritanceLevel, servPtr->allowAsDefault()));
 #else
                     list.append(KServiceOffer(servPtr, initialPreference, mimeTypeInheritanceLevel));
 #endif
                 }
                 // Restore position
                 str->device()->seek(savedPos);
             } else {
                 break; // too far
             }
         } else {
             break; // 0 => end of list
         }
     }
     return list;
 }
 
 KService::List KServiceFactory::serviceOffers(const KServiceType::Ptr &serviceType)
 {
     return serviceOffers(serviceType->offset(), serviceType->serviceOffersOffset());
 }
 
 KService::List KServiceFactory::serviceOffers(int serviceTypeOffset, int serviceOffersOffset)
 {
     KService::List list;
 
     // Jump to the offer list
     QDataStream *str = stream();
     str->device()->seek(m_offerListOffset + serviceOffersOffset);
 
     qint32 aServiceTypeOffset;
     qint32 aServiceOffset;
     qint32 initialPreference;
     qint32 mimeTypeInheritanceLevel;
     while (true) {
         (*str) >> aServiceTypeOffset;
         if (aServiceTypeOffset) {
             (*str) >> aServiceOffset;
             (*str) >> initialPreference; // unused (remove once KMimeTypeTrader/KServiceTypeTrader are gone)
             (*str) >> mimeTypeInheritanceLevel; // unused (remove once KMimeTypeTrader/KServiceTypeTrader are gone)
             if (aServiceTypeOffset == serviceTypeOffset) {
                 // Save stream position !
                 const qint64 savedPos = str->device()->pos();
                 // Create service
                 KService *serv = createEntry(aServiceOffset);
                 if (serv) {
                     list.append(KService::Ptr(serv));
                 }
                 // Restore position
                 str->device()->seek(savedPos);
             } else {
                 break; // too far
             }
         } else {
             break; // 0 => end of list
         }
     }
     return list;
 }
 
 bool KServiceFactory::hasOffer(const KServiceType::Ptr &serviceType, const KService::Ptr &testedService)
 {
     return hasOffer(serviceType->offset(), serviceType->serviceOffersOffset(), testedService->offset());
 }
 
 bool KServiceFactory::hasOffer(int serviceTypeOffset, int serviceOffersOffset, int testedServiceOffset)
 {
     // Save stream position
     QDataStream *str = stream();
     const qint64 savedPos = str->device()->pos();
 
     // Jump to the offer list
     str->device()->seek(m_offerListOffset + serviceOffersOffset);
     bool found = false;
     qint32 aServiceTypeOffset;
     qint32 aServiceOffset;
     qint32 initialPreference;
     qint32 mimeTypeInheritanceLevel;
     while (!found) {
         (*str) >> aServiceTypeOffset;
         if (aServiceTypeOffset) {
             (*str) >> aServiceOffset;
             (*str) >> initialPreference;
             (*str) >> mimeTypeInheritanceLevel;
             if (aServiceTypeOffset == serviceTypeOffset) {
                 if (aServiceOffset == testedServiceOffset) {
                     found = true;
                 }
             } else {
                 break; // too far
             }
         } else {
             break; // 0 => end of list
         }
     }
     // Restore position
     str->device()->seek(savedPos);
     return found;
 }
 
 void KServiceFactory::virtual_hook(int id, void *data)
 {
     KSycocaFactory::virtual_hook(id, data);
 }