File indexing completed on 2024-05-19 16:41:36

 /*
     SPDX-FileCopyrightText: 2007 Glenn Ergeerts <glenn.ergeerts@telenet.be>
     SPDX-FileCopyrightText: 2012 Marco Gulino <marco.gulino@xpeppers.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "firefox.h"
 #include "bookmarkmatch.h"
 #include "bookmarks_debug.h"
 #include "favicon.h"
 #include "faviconfromblob.h"
 #include "fetchsqlite.h"
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <QFile>
 #include <QRegularExpression>
 
 Firefox::Firefox(const QString &firefoxConfigDir, QObject *parent)
     : QObject(parent)
     , m_dbCacheFile(QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation)
                     + QStringLiteral("/bookmarksrunner/bookmarkrunnerfirefoxdbfile.sqlite"))
     , m_dbCacheFile_fav(QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation)
                         + QStringLiteral("/bookmarksrunner/bookmarkrunnerfirefoxfavdbfile.sqlite"))
     , m_favicon(new FallbackFavicon(this))
     , m_fetchsqlite(nullptr)
     , m_fetchsqlite_fav(nullptr)
 {
     if (!QSqlDatabase::isDriverAvailable(QStringLiteral("QSQLITE"))) {
         qCWarning(RUNNER_BOOKMARKS) << "SQLITE driver isn't available";
         return;
     }
 
     KConfigGroup grp(KSharedConfig::openConfig(QStringLiteral("kdeglobals")), QStringLiteral("General"));
     /* This allows the user to specify a profile database */
     m_dbFile = grp.readEntry("dbfile", QString());
     if (m_dbFile.isEmpty() || !QFile::exists(m_dbFile)) {
         // Try to get the right database file, the default profile is used
         KConfig firefoxProfile(firefoxConfigDir + "/profiles.ini", KConfig::SimpleConfig);
         QStringList profilesList = firefoxProfile.groupList();
         profilesList = profilesList.filter(QRegularExpression(QStringLiteral("^Profile\\d+$")));
 
         QString profilePath;
         if (profilesList.size() == 1) {
             // There is only 1 profile so we select it
             KConfigGroup fGrp = firefoxProfile.group(profilesList.first());
             profilePath = fGrp.readEntry("Path");
         } else {
             const QStringList installConfig = firefoxProfile.groupList().filter(QRegularExpression("^Install.*"));
             // The profile with Default=1 is not always the default profile, see BUG: 418526
             // If there is only one Install* group it contains the default profile
             if (installConfig.size() == 1) {
                 profilePath = firefoxProfile.group(installConfig.first()).readEntry("Default");
             } else {
                 // There are multiple profiles, find the default one
                 for (const QString &profileName : qAsConst(profilesList)) {
                     KConfigGroup fGrp = firefoxProfile.group(profileName);
                     if (fGrp.readEntry<int>("Default", 0)) {
                         profilePath = fGrp.readEntry("Path");
                         break;
                     }
                 }
             }
         }
 
         if (profilePath.isEmpty()) {
             qCWarning(RUNNER_BOOKMARKS) << "No default firefox profile found";
             return;
         }
         profilePath.prepend(firefoxConfigDir + "/");
         m_dbFile = profilePath + "/places.sqlite";
         m_dbFile_fav = profilePath + "/favicons.sqlite";
     } else {
         auto dir = QDir(m_dbFile);
         if (dir.cdUp()) {
             QString profilePath = dir.absolutePath();
             m_dbFile_fav = profilePath + "/favicons.sqlite";
         }
     }
     // We can reuse the favicon instance over the lifetime of the plugin consequently the
     // icons that are already written to disk can be reused in multiple match sessions
     updateCacheFile(m_dbFile_fav, m_dbCacheFile_fav);
     m_fetchsqlite_fav = new FetchSqlite(m_dbCacheFile_fav, this);
     delete m_favicon;
     m_favicon = FaviconFromBlob::firefox(m_fetchsqlite_fav, this);
 }
 
 Firefox::~Firefox()
 {
     // Delete the cached databases
     if (!m_dbFile.isEmpty()) {
         QFile db_CacheFile(m_dbCacheFile);
         if (db_CacheFile.exists()) {
             db_CacheFile.remove();
         }
     }
     if (!m_dbFile_fav.isEmpty()) {
         QFile db_CacheFileFav(m_dbCacheFile_fav);
         if (db_CacheFileFav.exists()) {
             db_CacheFileFav.remove();
         }
     }
 }
 
 void Firefox::prepare()
 {
     if (updateCacheFile(m_dbFile, m_dbCacheFile) != Error) {
         m_fetchsqlite = new FetchSqlite(m_dbCacheFile);
         m_fetchsqlite->prepare();
     }
     updateCacheFile(m_dbFile_fav, m_dbCacheFile_fav);
     m_favicon->prepare();
 }
 
 QList<BookmarkMatch> Firefox::match(const QString &term, bool addEverything)
 {
     QList<BookmarkMatch> matches;
     if (!m_fetchsqlite) {
         return matches;
     }
 
     QString query;
     if (addEverything) {
         query = QStringLiteral(
             "SELECT moz_bookmarks.fk, moz_bookmarks.title, moz_places.url "
             "FROM moz_bookmarks, moz_places WHERE "
             "moz_bookmarks.type = 1 AND moz_bookmarks.fk = moz_places.id");
     } else {
         query = QStringLiteral(
             "SELECT moz_bookmarks.fk, moz_bookmarks.title, moz_places.url "
             "FROM moz_bookmarks, moz_places WHERE "
             "moz_bookmarks.type = 1 AND moz_bookmarks.fk = moz_places.id AND "
             "(moz_bookmarks.title LIKE :term OR moz_places.url LIKE :term)");
     }
     const QMap<QString, QVariant> bindVariables{
         {QStringLiteral(":term"), QStringLiteral("%%%1%%").arg(term)},
     };
     const QList<QVariantMap> results = m_fetchsqlite->query(query, bindVariables);
     QMultiMap<QString, QString> uniqueResults;
     for (const QVariantMap &result : results) {
         const QString title = result.value(QStringLiteral("title")).toString();
         const QUrl url = result.value(QStringLiteral("url")).toUrl();
         if (url.isEmpty() || url.scheme() == QLatin1String("place")) {
             // Don't use bookmarks with empty url or Firefox's "place:" scheme,
             // e.g. used for "Most Visited" or "Recent Tags"
             // qDebug() << "element " << url << " was not added";
             continue;
         }
 
         auto urlString = url.toString();
         // After joining we may have multiple results for each URL:
         // 1) one for each bookmark folder (same or different titles)
         // 2) one for each tag (no title for all but the first entry)
         auto keyRange = uniqueResults.equal_range(urlString);
         auto it = keyRange.first;
         if (!title.isEmpty()) {
             while (it != keyRange.second) {
                 if (*it == title) {
                     // same URL and title in multiple bookmark folders
                     break;
                 }
                 if (it->isEmpty()) {
                     // add a title if there was none for the URL
                     *it = title;
                     break;
                 }
                 ++it;
             }
         }
         if (it == keyRange.second) {
             // first or unique entry
             uniqueResults.insert(urlString, title);
         }
     }
 
     for (auto result = uniqueResults.constKeyValueBegin(); result != uniqueResults.constKeyValueEnd(); ++result) {
         const QString url = (*result).first;
         BookmarkMatch bookmarkMatch(m_favicon->iconFor(url), term, (*result).second, url);
         bookmarkMatch.addTo(matches, addEverything);
     }
 
     return matches;
 }
 
 void Firefox::teardown()
 {
     if (m_fetchsqlite) {
         m_fetchsqlite->teardown();
         delete m_fetchsqlite;
         m_fetchsqlite = nullptr;
     }
     m_favicon->teardown();
 }