src/base/search/searchpluginmanager.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015-2024  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "searchpluginmanager.h"
  31
  32 #include <memory>
  33
  34 #include <QDir>
  35 #include <QDirIterator>
  36 #include <QDomDocument>
  37 #include <QDomElement>
  38 #include <QDomNode>
  39 #include <QFile>
  40 #include <QPointer>
  41 #include <QProcess>
  42 #include <QUrl>
  43
  44 #include "base/global.h"
  45 #include "base/logger.h"
  46 #include "base/net/downloadmanager.h"
  47 #include "base/net/proxyconfigurationmanager.h"
  48 #include "base/preferences.h"
  49 #include "base/profile.h"
  50 #include "base/utils/bytearray.h"
  51 #include "base/utils/foreignapps.h"
  52 #include "base/utils/fs.h"
  53 #include "searchdownloadhandler.h"
  54 #include "searchhandler.h"
  55
  56 namespace
  57 {
  58     void clearPythonCache(const Path &path)
  59     {
  60         // remove python cache artifacts in `path` and subdirs
  61
  62         PathList dirs = {path};
  63         QDirIterator iter {path.data(), (QDir::AllDirs | QDir::NoDotAndDotDot), QDirIterator::Subdirectories};
  64         while (iter.hasNext())
  65             dirs += Path(iter.next());
  66
  67         for (const Path &dir : asConst(dirs))
  68         {
  69             // python 3: remove "__pycache__" folders
  70             if (dir.filename() == u"__pycache__")
  71             {
  72                 Utils::Fs::removeDirRecursively(dir);
  73                 continue;
  74             }
  75
  76             // python 2: remove "*.pyc" files
  77             QDirIterator it {dir.data(), {u"*.pyc"_s}, QDir::Files};
  78             while (it.hasNext())
  79             {
  80                 const QString filePath = it.next();
  81                 Utils::Fs::removeFile(Path(filePath));
  82             }
  83         }
  84     }
  85 }
  86
  87 QPointer<SearchPluginManager> SearchPluginManager::m_instance = nullptr;
  88
  89 SearchPluginManager::SearchPluginManager()
  90     : m_updateUrl(u"https://searchplugins.qbittorrent.org/nova3/engines/"_s)
  91 {
  92     Q_ASSERT(!m_instance); // only one instance is allowed
  93     m_instance = this;
  94
  95     connect(Net::ProxyConfigurationManager::instance(), &Net::ProxyConfigurationManager::proxyConfigurationChanged
  96             , this, &SearchPluginManager::applyProxySettings);
  97     connect(Preferences::instance(), &Preferences::changed
  98             , this, &SearchPluginManager::applyProxySettings);
  99     applyProxySettings();
 100
 101     updateNova();
 102     update();
 103 }
 104
 105 SearchPluginManager::~SearchPluginManager()
 106 {
 107     qDeleteAll(m_plugins);
 108 }
 109
 110 SearchPluginManager *SearchPluginManager::instance()
 111 {
 112     if (!m_instance)
 113         m_instance = new SearchPluginManager;
 114     return m_instance;
 115 }
 116
 117 void SearchPluginManager::freeInstance()
 118 {
 119     delete m_instance;
 120 }
 121
 122 QStringList SearchPluginManager::allPlugins() const
 123 {
 124     return m_plugins.keys();
 125 }
 126
 127 QStringList SearchPluginManager::enabledPlugins() const
 128 {
 129     QStringList plugins;
 130     for (const PluginInfo *plugin : asConst(m_plugins))
 131     {
 132         if (plugin->enabled)
 133             plugins << plugin->name;
 134     }
 135
 136     return plugins;
 137 }
 138
 139 QStringList SearchPluginManager::supportedCategories() const
 140 {
 141     QStringList result;
 142     for (const PluginInfo *plugin : asConst(m_plugins))
 143     {
 144         if (plugin->enabled)
 145         {
 146             for (const QString &cat : plugin->supportedCategories)
 147             {
 148                 if (!result.contains(cat))
 149                     result << cat;
 150             }
 151         }
 152     }
 153
 154     return result;
 155 }
 156
 157 QStringList SearchPluginManager::getPluginCategories(const QString &pluginName) const
 158 {
 159     QStringList plugins;
 160     if (pluginName == u"all")
 161         plugins = allPlugins();
 162     else if ((pluginName == u"enabled") || (pluginName == u"multi"))
 163         plugins = enabledPlugins();
 164     else
 165         plugins << pluginName.trimmed();
 166
 167     QSet<QString> categories;
 168     for (const QString &name : asConst(plugins))
 169     {
 170         const PluginInfo *plugin = pluginInfo(name);
 171         if (!plugin) continue; // plugin wasn't found
 172         for (const QString &category : plugin->supportedCategories)
 173             categories << category;
 174     }
 175
 176     return categories.values();
 177 }
 178
 179 PluginInfo *SearchPluginManager::pluginInfo(const QString &name) const
 180 {
 181     return m_plugins.value(name);
 182 }
 183
 184 QString SearchPluginManager::pluginNameBySiteURL(const QString &siteURL) const
 185 {
 186     for (const PluginInfo *plugin : asConst(m_plugins))
 187     {
 188         if (plugin->url == siteURL)
 189             return plugin->name;
 190     }
 191
 192     return {};
 193 }
 194
 195 void SearchPluginManager::enablePlugin(const QString &name, const bool enabled)
 196 {
 197     PluginInfo *plugin = m_plugins.value(name, nullptr);
 198     if (plugin)
 199     {
 200         plugin->enabled = enabled;
 201         // Save to Hard disk
 202         Preferences *const pref = Preferences::instance();
 203         QStringList disabledPlugins = pref->getSearchEngDisabled();
 204         if (enabled)
 205             disabledPlugins.removeAll(name);
 206         else if (!disabledPlugins.contains(name))
 207             disabledPlugins.append(name);
 208         pref->setSearchEngDisabled(disabledPlugins);
 209
 210         emit pluginEnabled(name, enabled);
 211     }
 212 }
 213
 214 // Updates shipped plugin
 215 void SearchPluginManager::updatePlugin(const QString &name)
 216 {
 217     installPlugin(u"%1%2.py"_s.arg(m_updateUrl, name));
 218 }
 219
 220 // Install or update plugin from file or url
 221 void SearchPluginManager::installPlugin(const QString &source)
 222 {
 223     clearPythonCache(engineLocation());
 224
 225     if (Net::DownloadManager::hasSupportedScheme(source))
 226     {
 227         using namespace Net;
 228         DownloadManager::instance()->download(DownloadRequest(source).saveToFile(true)
 229                 , Preferences::instance()->useProxyForGeneralPurposes()
 230                 , this, &SearchPluginManager::pluginDownloadFinished);
 231     }
 232     else
 233     {
 234         const Path path {source.startsWith(u"file:", Qt::CaseInsensitive) ? QUrl(source).toLocalFile() : source};
 235
 236         QString pluginName = path.filename();
 237         if (pluginName.endsWith(u".py", Qt::CaseInsensitive))
 238         {
 239             pluginName.chop(pluginName.size() - pluginName.lastIndexOf(u'.'));
 240             installPlugin_impl(pluginName, path);
 241         }
 242         else
 243         {
 244             emit pluginInstallationFailed(pluginName, tr("Unknown search engine plugin file format."));
 245         }
 246     }
 247 }
 248
 249 void SearchPluginManager::installPlugin_impl(const QString &name, const Path &path)
 250 {
 251     const PluginVersion newVersion = getPluginVersion(path);
 252     const PluginInfo *plugin = pluginInfo(name);
 253     if (plugin && !(plugin->version < newVersion))
 254     {
 255         LogMsg(tr("Plugin already at version %1, which is greater than %2").arg(plugin->version.toString(), newVersion.toString()), Log::INFO);
 256         emit pluginUpdateFailed(name, tr("A more recent version of this plugin is already installed."));
 257         return;
 258     }
 259
 260     // Process with install
 261     const Path destPath = pluginPath(name);
 262     const Path backupPath = destPath + u".bak";
 263     bool updated = false;
 264     if (destPath.exists())
 265     {
 266         // Backup in case install fails
 267         Utils::Fs::copyFile(destPath, backupPath);
 268         Utils::Fs::removeFile(destPath);
 269         updated = true;
 270     }
 271     // Copy the plugin
 272     Utils::Fs::copyFile(path, destPath);
 273     // Update supported plugins
 274     update();
 275     // Check if this was correctly installed
 276     if (!m_plugins.contains(name))
 277     {
 278         // Remove broken file
 279         Utils::Fs::removeFile(destPath);
 280         LogMsg(tr("Plugin %1 is not supported.").arg(name), Log::INFO);
 281         if (updated)
 282         {
 283             // restore backup
 284             Utils::Fs::copyFile(backupPath, destPath);
 285             Utils::Fs::removeFile(backupPath);
 286             // Update supported plugins
 287             update();
 288             emit pluginUpdateFailed(name, tr("Plugin is not supported."));
 289         }
 290         else
 291         {
 292             emit pluginInstallationFailed(name, tr("Plugin is not supported."));
 293         }
 294     }
 295     else
 296     {
 297         // Install was successful, remove backup
 298         if (updated)
 299         {
 300             LogMsg(tr("Plugin %1 has been successfully updated.").arg(name), Log::INFO);
 301             Utils::Fs::removeFile(backupPath);
 302         }
 303     }
 304 }
 305
 306 bool SearchPluginManager::uninstallPlugin(const QString &name)
 307 {
 308     clearPythonCache(engineLocation());
 309
 310     // remove it from hard drive
 311     QDirIterator iter {pluginsLocation().data(), {name + u".*"}, QDir::Files};
 312     while (iter.hasNext())
 313     {
 314         const QString filePath = iter.next();
 315         Utils::Fs::removeFile(Path(filePath));
 316     }
 317
 318     // Remove it from supported engines
 319     delete m_plugins.take(name);
 320
 321     emit pluginUninstalled(name);
 322     return true;
 323 }
 324
 325 void SearchPluginManager::updateIconPath(PluginInfo *const plugin)
 326 {
 327     if (!plugin) return;
 328
 329     const Path pluginsPath = pluginsLocation();
 330     Path iconPath = pluginsPath / Path(plugin->name + u".png");
 331     if (iconPath.exists())
 332     {
 333         plugin->iconPath = iconPath;
 334     }
 335     else
 336     {
 337         iconPath = pluginsPath / Path(plugin->name + u".ico");
 338         if (iconPath.exists())
 339             plugin->iconPath = iconPath;
 340     }
 341 }
 342
 343 void SearchPluginManager::checkForUpdates()
 344 {
 345     // Download version file from update server
 346     using namespace Net;
 347     DownloadManager::instance()->download({m_updateUrl + u"versions.txt"}
 348             , Preferences::instance()->useProxyForGeneralPurposes()
 349             , this, &SearchPluginManager::versionInfoDownloadFinished);
 350 }
 351
 352 SearchDownloadHandler *SearchPluginManager::downloadTorrent(const QString &pluginName, const QString &url)
 353 {
 354     return new SearchDownloadHandler(pluginName, url, this);
 355 }
 356
 357 SearchHandler *SearchPluginManager::startSearch(const QString &pattern, const QString &category, const QStringList &usedPlugins)
 358 {
 359     // No search pattern entered
 360     Q_ASSERT(!pattern.isEmpty());
 361
 362     return new SearchHandler {pattern, category, usedPlugins, this};
 363 }
 364
 365 QString SearchPluginManager::categoryFullName(const QString &categoryName)
 366 {
 367     const QHash<QString, QString> categoryTable
 368     {
 369         {u"all"_s, tr("All categories")},
 370         {u"anime"_s, tr("Anime")},
 371         {u"books"_s, tr("Books")},
 372         {u"games"_s, tr("Games")},
 373         {u"movies"_s, tr("Movies")},
 374         {u"music"_s, tr("Music")},
 375         {u"pictures"_s, tr("Pictures")},
 376         {u"software"_s, tr("Software")},
 377         {u"tv"_s, tr("TV shows")}
 378     };
 379     return categoryTable.value(categoryName);
 380 }
 381
 382 QString SearchPluginManager::pluginFullName(const QString &pluginName) const
 383 {
 384     return pluginInfo(pluginName) ? pluginInfo(pluginName)->fullName : QString();
 385 }
 386
 387 Path SearchPluginManager::pluginsLocation()
 388 {
 389     return (engineLocation() / Path(u"engines"_s));
 390 }
 391
 392 Path SearchPluginManager::engineLocation()
 393 {
 394     static Path location;
 395     if (location.isEmpty())
 396     {
 397         location = specialFolderLocation(SpecialFolder::Data) / Path(u"nova3"_s);
 398         Utils::Fs::mkpath(location);
 399     }
 400
 401     return location;
 402 }
 403
 404 void SearchPluginManager::applyProxySettings()
 405 {
 406     const auto *proxyManager = Net::ProxyConfigurationManager::instance();
 407     const Net::ProxyConfiguration proxyConfig = proxyManager->proxyConfiguration();
 408
 409     // Define environment variables for urllib in search engine plugins
 410     QString proxyStrHTTP, proxyStrSOCK;
 411     if ((proxyConfig.type != Net::ProxyType::None) && Preferences::instance()->useProxyForGeneralPurposes())
 412     {
 413         switch (proxyConfig.type)
 414         {
 415         case Net::ProxyType::HTTP:
 416             if (proxyConfig.authEnabled)
 417             {
 418                 proxyStrHTTP = u"http://%1:%2@%3:%4"_s.arg(proxyConfig.username
 419                         , proxyConfig.password, proxyConfig.ip, QString::number(proxyConfig.port));
 420             }
 421             else
 422             {
 423                 proxyStrHTTP = u"http://%1:%2"_s.arg(proxyConfig.ip, QString::number(proxyConfig.port));
 424             }
 425             break;
 426
 427         case Net::ProxyType::SOCKS5:
 428             if (proxyConfig.authEnabled)
 429             {
 430                 proxyStrSOCK = u"%1:%2@%3:%4"_s.arg(proxyConfig.username
 431                     , proxyConfig.password, proxyConfig.ip, QString::number(proxyConfig.port));
 432             }
 433             else
 434             {
 435                 proxyStrSOCK = u"%1:%2"_s.arg(proxyConfig.ip, QString::number(proxyConfig.port));
 436             }
 437             break;
 438
 439         default:
 440             qDebug("Disabling HTTP communications proxy");
 441         }
 442
 443         qDebug("HTTP communications proxy string: %s"
 444                , qUtf8Printable((proxyConfig.type == Net::ProxyType::SOCKS5) ? proxyStrSOCK : proxyStrHTTP));
 445     }
 446
 447     qputenv("http_proxy", proxyStrHTTP.toLocal8Bit());
 448     qputenv("https_proxy", proxyStrHTTP.toLocal8Bit());
 449     qputenv("sock_proxy", proxyStrSOCK.toLocal8Bit());
 450 }
 451
 452 void SearchPluginManager::versionInfoDownloadFinished(const Net::DownloadResult &result)
 453 {
 454     if (result.status == Net::DownloadStatus::Success)
 455         parseVersionInfo(result.data);
 456     else
 457         emit checkForUpdatesFailed(tr("Update server is temporarily unavailable. %1").arg(result.errorString));
 458 }
 459
 460 void SearchPluginManager::pluginDownloadFinished(const Net::DownloadResult &result)
 461 {
 462     if (result.status == Net::DownloadStatus::Success)
 463     {
 464         const Path filePath = result.filePath;
 465
 466         const auto pluginPath = Path(QUrl(result.url).path()).removedExtension();
 467         installPlugin_impl(pluginPath.filename(), filePath);
 468         Utils::Fs::removeFile(filePath);
 469     }
 470     else
 471     {
 472         const QString url = result.url;
 473         QString pluginName = url.mid(url.lastIndexOf(u'/') + 1);
 474         pluginName.replace(u".py"_s, u""_s, Qt::CaseInsensitive);
 475
 476         if (pluginInfo(pluginName))
 477             emit pluginUpdateFailed(pluginName, tr("Failed to download the plugin file. %1").arg(result.errorString));
 478         else
 479             emit pluginInstallationFailed(pluginName, tr("Failed to download the plugin file. %1").arg(result.errorString));
 480     }
 481 }
 482
 483 // Update nova.py search plugin if necessary
 484 void SearchPluginManager::updateNova()
 485 {
 486     // create nova directory if necessary
 487     const Path enginePath = engineLocation();
 488
 489     QFile packageFile {(enginePath / Path(u"__init__.py"_s)).data()};
 490     packageFile.open(QIODevice::WriteOnly);
 491     packageFile.close();
 492
 493     Utils::Fs::mkdir(enginePath / Path(u"engines"_s));
 494
 495     QFile packageFile2 {(enginePath / Path(u"engines/__init__.py"_s)).data()};
 496     packageFile2.open(QIODevice::WriteOnly);
 497     packageFile2.close();
 498
 499     // Copy search plugin files (if necessary)
 500     const auto updateFile = [&enginePath](const Path &filename, const bool compareVersion)
 501     {
 502         const Path filePathBundled = Path(u":/searchengine/nova3"_s) / filename;
 503         const Path filePathDisk = enginePath / filename;
 504
 505         if (compareVersion && (getPluginVersion(filePathBundled) <= getPluginVersion(filePathDisk)))
 506             return;
 507
 508         Utils::Fs::removeFile(filePathDisk);
 509         Utils::Fs::copyFile(filePathBundled, filePathDisk);
 510     };
 511
 512     updateFile(Path(u"helpers.py"_s), true);
 513     updateFile(Path(u"nova2.py"_s), true);
 514     updateFile(Path(u"nova2dl.py"_s), true);
 515     updateFile(Path(u"novaprinter.py"_s), true);
 516     updateFile(Path(u"socks.py"_s), false);
 517 }
 518
 519 void SearchPluginManager::update()
 520 {
 521     QProcess nova;
 522     nova.setProcessEnvironment(QProcessEnvironment::systemEnvironment());
 523
 524     const QStringList params
 525     {
 526         Utils::ForeignApps::PYTHON_ISOLATE_MODE_FLAG,
 527         (engineLocation() / Path(u"/nova2.py"_s)).toString(),
 528         u"--capabilities"_s
 529     };
 530     nova.start(Utils::ForeignApps::pythonInfo().executableName, params, QIODevice::ReadOnly);
 531     nova.waitForFinished();
 532
 533     const auto capabilities = QString::fromUtf8(nova.readAllStandardOutput());
 534     QDomDocument xmlDoc;
 535     if (!xmlDoc.setContent(capabilities))
 536     {
 537         qWarning() << "Could not parse Nova search engine capabilities, msg: " << capabilities.toLocal8Bit().data();
 538         qWarning() << "Error: " << nova.readAllStandardError().constData();
 539         return;
 540     }
 541
 542     const QDomElement root = xmlDoc.documentElement();
 543     if (root.tagName() != u"capabilities")
 544     {
 545         qWarning() << "Invalid XML file for Nova search engine capabilities, msg: " << capabilities.toLocal8Bit().data();
 546         return;
 547     }
 548
 549     for (QDomNode engineNode = root.firstChild(); !engineNode.isNull(); engineNode = engineNode.nextSibling())
 550     {
 551         const QDomElement engineElem = engineNode.toElement();
 552         if (!engineElem.isNull())
 553         {
 554             const QString pluginName = engineElem.tagName();
 555
 556             auto plugin = std::make_unique<PluginInfo>();
 557             plugin->name = pluginName;
 558             plugin->version = getPluginVersion(pluginPath(pluginName));
 559             plugin->fullName = engineElem.elementsByTagName(u"name"_s).at(0).toElement().text();
 560             plugin->url = engineElem.elementsByTagName(u"url"_s).at(0).toElement().text();
 561
 562             const QStringList categories = engineElem.elementsByTagName(u"categories"_s).at(0).toElement().text().split(u' ');
 563             for (QString cat : categories)
 564             {
 565                 cat = cat.trimmed();
 566                 if (!cat.isEmpty())
 567                     plugin->supportedCategories << cat;
 568             }
 569
 570             const QStringList disabledEngines = Preferences::instance()->getSearchEngDisabled();
 571             plugin->enabled = !disabledEngines.contains(pluginName);
 572
 573             updateIconPath(plugin.get());
 574
 575             if (!m_plugins.contains(pluginName))
 576             {
 577                 m_plugins[pluginName] = plugin.release();
 578                 emit pluginInstalled(pluginName);
 579             }
 580             else if (m_plugins[pluginName]->version != plugin->version)
 581             {
 582                 delete m_plugins.take(pluginName);
 583                 m_plugins[pluginName] = plugin.release();
 584                 emit pluginUpdated(pluginName);
 585             }
 586         }
 587     }
 588 }
 589
 590 void SearchPluginManager::parseVersionInfo(const QByteArray &info)
 591 {
 592     QHash<QString, PluginVersion> updateInfo;
 593     int numCorrectData = 0;
 594
 595     const QList<QByteArrayView> lines = Utils::ByteArray::splitToViews(info, "\n", Qt::SkipEmptyParts);
 596     for (QByteArrayView line : lines)
 597     {
 598         line = line.trimmed();
 599         if (line.isEmpty()) continue;
 600         if (line.startsWith('#')) continue;
 601
 602         const QList<QByteArrayView> list = Utils::ByteArray::splitToViews(line, ":", Qt::SkipEmptyParts);
 603         if (list.size() != 2) continue;
 604
 605         const auto pluginName = QString::fromUtf8(list.first().trimmed());
 606         const auto version = PluginVersion::fromString(QString::fromLatin1(list.last().trimmed()));
 607
 608         if (!version.isValid()) continue;
 609
 610         ++numCorrectData;
 611         if (isUpdateNeeded(pluginName, version))
 612         {
 613             LogMsg(tr("Plugin \"%1\" is outdated, updating to version %2").arg(pluginName, version.toString()), Log::INFO);
 614             updateInfo[pluginName] = version;
 615         }
 616     }
 617
 618     if (numCorrectData < lines.size())
 619     {
 620         emit checkForUpdatesFailed(tr("Incorrect update info received for %1 out of %2 plugins.")
 621             .arg(QString::number(lines.size() - numCorrectData), QString::number(lines.size())));
 622     }
 623     else
 624     {
 625         emit checkForUpdatesFinished(updateInfo);
 626     }
 627 }
 628
 629 bool SearchPluginManager::isUpdateNeeded(const QString &pluginName, const PluginVersion &newVersion) const
 630 {
 631     const PluginInfo *plugin = pluginInfo(pluginName);
 632     if (!plugin) return true;
 633
 634     PluginVersion oldVersion = plugin->version;
 635     return (newVersion > oldVersion);
 636 }
 637
 638 Path SearchPluginManager::pluginPath(const QString &name)
 639 {
 640     return (pluginsLocation() / Path(name + u".py"));
 641 }
 642
 643 PluginVersion SearchPluginManager::getPluginVersion(const Path &filePath)
 644 {
 645     const int lineMaxLength = 16;
 646
 647     QFile pluginFile {filePath.data()};
 648     if (!pluginFile.open(QIODevice::ReadOnly | QIODevice::Text))
 649         return {};
 650
 651     while (!pluginFile.atEnd())
 652     {
 653         const auto line = QString::fromUtf8(pluginFile.readLine(lineMaxLength)).remove(u' ');
 654         if (!line.startsWith(u"#VERSION:", Qt::CaseInsensitive)) continue;
 655
 656         const QString versionStr = line.mid(9);
 657         const auto version = PluginVersion::fromString(versionStr);
 658         if (version.isValid())
 659             return version;
 660
 661         LogMsg(tr("Search plugin '%1' contains invalid version string ('%2')")
 662             .arg(filePath.filename(), versionStr), Log::MsgType::WARNING);
 663         break;
 664     }
 665
 666     return {};
 667 }