src/app/application.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2006  Christophe Dumez
   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 "application.h"
  31
  32 #include <algorithm>
  33
  34 #ifdef DISABLE_GUI
  35 #include <cstdio>
  36 #endif
  37
  38 #ifdef Q_OS_WIN
  39 #include <memory>
  40 #include <Windows.h>
  41 #include <Shellapi.h>
  42 #elif defined(Q_OS_UNIX)
  43 #include <sys/resource.h>
  44 #endif
  45
  46 #include <QByteArray>
  47 #include <QDebug>
  48 #include <QLibraryInfo>
  49 #include <QMetaObject>
  50 #include <QProcess>
  51
  52 #ifndef DISABLE_GUI
  53 #include <QMenu>
  54 #include <QMessageBox>
  55 #include <QPixmapCache>
  56 #include <QProgressDialog>
  57 #ifdef Q_OS_WIN
  58 #include <QSessionManager>
  59 #include <QSharedMemory>
  60 #endif // Q_OS_WIN
  61 #ifdef Q_OS_MACOS
  62 #include <QFileOpenEvent>
  63 #endif // Q_OS_MACOS
  64 #endif
  65
  66 #include "base/bittorrent/infohash.h"
  67 #include "base/bittorrent/session.h"
  68 #include "base/bittorrent/torrent.h"
  69 #include "base/exceptions.h"
  70 #include "base/global.h"
  71 #include "base/iconprovider.h"
  72 #include "base/logger.h"
  73 #include "base/net/downloadmanager.h"
  74 #include "base/net/geoipmanager.h"
  75 #include "base/net/proxyconfigurationmanager.h"
  76 #include "base/net/smtp.h"
  77 #include "base/preferences.h"
  78 #include "base/profile.h"
  79 #include "base/rss/rss_autodownloader.h"
  80 #include "base/rss/rss_session.h"
  81 #include "base/search/searchpluginmanager.h"
  82 #include "base/settingsstorage.h"
  83 #include "base/torrentfileswatcher.h"
  84 #include "base/utils/compare.h"
  85 #include "base/utils/fs.h"
  86 #include "base/utils/misc.h"
  87 #include "base/utils/string.h"
  88 #include "base/version.h"
  89 #include "applicationinstancemanager.h"
  90 #include "filelogger.h"
  91 #include "upgrade.h"
  92
  93 #ifndef DISABLE_GUI
  94 #include "gui/addnewtorrentdialog.h"
  95 #include "gui/desktopintegration.h"
  96 #include "gui/mainwindow.h"
  97 #include "gui/shutdownconfirmdialog.h"
  98 #include "gui/uithememanager.h"
  99 #include "gui/utils.h"
 100 #include "gui/windowstate.h"
 101 #endif // DISABLE_GUI
 102
 103 #ifndef DISABLE_WEBUI
 104 #include "webui/webui.h"
 105 #endif
 106
 107 namespace
 108 {
 109 #define SETTINGS_KEY(name) u"Application/" name
 110 #define FILELOGGER_SETTINGS_KEY(name) (SETTINGS_KEY(u"FileLogger/") name)
 111 #define NOTIFICATIONS_SETTINGS_KEY(name) (SETTINGS_KEY(u"GUI/Notifications/"_s) name)
 112
 113     const QString LOG_FOLDER = u"logs"_s;
 114     const QChar PARAMS_SEPARATOR = u'|';
 115
 116     const Path DEFAULT_PORTABLE_MODE_PROFILE_DIR {u"profile"_s};
 117
 118     const int MIN_FILELOG_SIZE = 1024; // 1KiB
 119     const int MAX_FILELOG_SIZE = 1000 * 1024 * 1024; // 1000MiB
 120     const int DEFAULT_FILELOG_SIZE = 65 * 1024; // 65KiB
 121
 122 #ifndef DISABLE_GUI
 123     const int PIXMAP_CACHE_SIZE = 64 * 1024 * 1024;  // 64MiB
 124 #endif
 125
 126     QString serializeParams(const QBtCommandLineParameters &params)
 127     {
 128         QStringList result;
 129         // Because we're passing a string list to the currently running
 130         // qBittorrent process, we need some way of passing along the options
 131         // the user has specified. Here we place special strings that are
 132         // almost certainly not going to collide with a file path or URL
 133         // specified by the user, and placing them at the beginning of the
 134         // string list so that they will be processed before the list of
 135         // torrent paths or URLs.
 136
 137         const BitTorrent::AddTorrentParams &addTorrentParams = params.addTorrentParams;
 138
 139         if (!addTorrentParams.savePath.isEmpty())
 140             result.append(u"@savePath=" + addTorrentParams.savePath.data());
 141
 142         if (addTorrentParams.addPaused.has_value())
 143             result.append(*addTorrentParams.addPaused ? u"@addPaused=1"_s : u"@addPaused=0"_s);
 144
 145         if (addTorrentParams.skipChecking)
 146             result.append(u"@skipChecking"_s);
 147
 148         if (!addTorrentParams.category.isEmpty())
 149             result.append(u"@category=" + addTorrentParams.category);
 150
 151         if (addTorrentParams.sequential)
 152             result.append(u"@sequential"_s);
 153
 154         if (addTorrentParams.firstLastPiecePriority)
 155             result.append(u"@firstLastPiecePriority"_s);
 156
 157         if (params.skipDialog.has_value())
 158             result.append(*params.skipDialog ? u"@skipDialog=1"_s : u"@skipDialog=0"_s);
 159
 160         result += params.torrentSources;
 161
 162         return result.join(PARAMS_SEPARATOR);
 163     }
 164
 165     QBtCommandLineParameters parseParams(const QString &str)
 166     {
 167         QBtCommandLineParameters parsedParams;
 168         BitTorrent::AddTorrentParams &addTorrentParams = parsedParams.addTorrentParams;
 169
 170         for (QString param : asConst(str.split(PARAMS_SEPARATOR, Qt::SkipEmptyParts)))
 171         {
 172             param = param.trimmed();
 173
 174             // Process strings indicating options specified by the user.
 175
 176             if (param.startsWith(u"@savePath="))
 177             {
 178                 addTorrentParams.savePath = Path(param.mid(10));
 179                 continue;
 180             }
 181
 182             if (param.startsWith(u"@addPaused="))
 183             {
 184                 addTorrentParams.addPaused = (QStringView(param).mid(11).toInt() != 0);
 185                 continue;
 186             }
 187
 188             if (param == u"@skipChecking")
 189             {
 190                 addTorrentParams.skipChecking = true;
 191                 continue;
 192             }
 193
 194             if (param.startsWith(u"@category="))
 195             {
 196                 addTorrentParams.category = param.mid(10);
 197                 continue;
 198             }
 199
 200             if (param == u"@sequential")
 201             {
 202                 addTorrentParams.sequential = true;
 203                 continue;
 204             }
 205
 206             if (param == u"@firstLastPiecePriority")
 207             {
 208                 addTorrentParams.firstLastPiecePriority = true;
 209                 continue;
 210             }
 211
 212             if (param.startsWith(u"@skipDialog="))
 213             {
 214                 parsedParams.skipDialog = (QStringView(param).mid(12).toInt() != 0);
 215                 continue;
 216             }
 217
 218             parsedParams.torrentSources.append(param);
 219         }
 220
 221         return parsedParams;
 222     }
 223 }
 224
 225 Application::Application(int &argc, char **argv)
 226     : BaseApplication(argc, argv)
 227     , m_commandLineArgs(parseCommandLine(Application::arguments()))
 228     , m_storeFileLoggerEnabled(FILELOGGER_SETTINGS_KEY(u"Enabled"_s))
 229     , m_storeFileLoggerBackup(FILELOGGER_SETTINGS_KEY(u"Backup"_s))
 230     , m_storeFileLoggerDeleteOld(FILELOGGER_SETTINGS_KEY(u"DeleteOld"_s))
 231     , m_storeFileLoggerMaxSize(FILELOGGER_SETTINGS_KEY(u"MaxSizeBytes"_s))
 232     , m_storeFileLoggerAge(FILELOGGER_SETTINGS_KEY(u"Age"_s))
 233     , m_storeFileLoggerAgeType(FILELOGGER_SETTINGS_KEY(u"AgeType"_s))
 234     , m_storeFileLoggerPath(FILELOGGER_SETTINGS_KEY(u"Path"_s))
 235     , m_storeMemoryWorkingSetLimit(SETTINGS_KEY(u"MemoryWorkingSetLimit"_s))
 236 #ifdef Q_OS_WIN
 237     , m_processMemoryPriority(SETTINGS_KEY(u"ProcessMemoryPriority"_s))
 238 #endif
 239 #ifndef DISABLE_GUI
 240     , m_startUpWindowState(u"GUI/StartUpWindowState"_s)
 241     , m_storeNotificationTorrentAdded(NOTIFICATIONS_SETTINGS_KEY(u"TorrentAdded"_s))
 242 #endif
 243 {
 244     qRegisterMetaType<Log::Msg>("Log::Msg");
 245     qRegisterMetaType<Log::Peer>("Log::Peer");
 246
 247     setApplicationName(u"qBittorrent"_s);
 248     setOrganizationDomain(u"qbittorrent.org"_s);
 249 #if !defined(DISABLE_GUI)
 250     setDesktopFileName(u"org.qbittorrent.qBittorrent"_s);
 251 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 252     setAttribute(Qt::AA_UseHighDpiPixmaps, true);  // opt-in to the high DPI pixmap support
 253 #endif
 254     setQuitOnLastWindowClosed(false);
 255     QPixmapCache::setCacheLimit(PIXMAP_CACHE_SIZE);
 256 #endif
 257
 258     Logger::initInstance();
 259
 260     const auto portableProfilePath = Path(QCoreApplication::applicationDirPath()) / DEFAULT_PORTABLE_MODE_PROFILE_DIR;
 261     const bool portableModeEnabled = m_commandLineArgs.profileDir.isEmpty() && portableProfilePath.exists();
 262
 263     const Path profileDir = portableModeEnabled
 264         ? portableProfilePath
 265         : m_commandLineArgs.profileDir;
 266     Profile::initInstance(profileDir, m_commandLineArgs.configurationName,
 267                         (m_commandLineArgs.relativeFastresumePaths || portableModeEnabled));
 268
 269     m_instanceManager = new ApplicationInstanceManager(Profile::instance()->location(SpecialFolder::Config), this);
 270
 271     SettingsStorage::initInstance();
 272     Preferences::initInstance();
 273
 274     const bool firstTimeUser = !Preferences::instance()->getAcceptedLegal();
 275     if (!firstTimeUser)
 276     {
 277         if (!upgrade())
 278             throw RuntimeError(u"Failed migration of old settings"_s); // Not translatable. Translation isn't configured yet.
 279         handleChangedDefaults(DefaultPreferencesMode::Legacy);
 280     }
 281     else
 282     {
 283         handleChangedDefaults(DefaultPreferencesMode::Current);
 284     }
 285
 286     initializeTranslation();
 287
 288     connect(this, &QCoreApplication::aboutToQuit, this, &Application::cleanup);
 289     connect(m_instanceManager, &ApplicationInstanceManager::messageReceived, this, &Application::processMessage);
 290 #if defined(Q_OS_WIN) && !defined(DISABLE_GUI)
 291     connect(this, &QGuiApplication::commitDataRequest, this, &Application::shutdownCleanup, Qt::DirectConnection);
 292 #endif
 293
 294     LogMsg(tr("qBittorrent %1 started", "qBittorrent v3.2.0alpha started").arg(QStringLiteral(QBT_VERSION)));
 295     if (portableModeEnabled)
 296     {
 297         LogMsg(tr("Running in portable mode. Auto detected profile folder at: %1").arg(profileDir.toString()));
 298         if (m_commandLineArgs.relativeFastresumePaths)
 299             LogMsg(tr("Redundant command line flag detected: \"%1\". Portable mode implies relative fastresume.").arg(u"--relative-fastresume"_s), Log::WARNING); // to avoid translating the `--relative-fastresume` string
 300     }
 301     else
 302     {
 303         LogMsg(tr("Using config directory: %1").arg(Profile::instance()->location(SpecialFolder::Config).toString()));
 304     }
 305
 306     if (isFileLoggerEnabled())
 307         m_fileLogger = new FileLogger(fileLoggerPath(), isFileLoggerBackup(), fileLoggerMaxSize(), isFileLoggerDeleteOld(), fileLoggerAge(), static_cast<FileLogger::FileLogAgeType>(fileLoggerAgeType()));
 308
 309     if (m_commandLineArgs.webUiPort > 0) // it will be -1 when user did not set any value
 310         Preferences::instance()->setWebUiPort(m_commandLineArgs.webUiPort);
 311
 312     if (m_commandLineArgs.torrentingPort > 0) // it will be -1 when user did not set any value
 313     {
 314         SettingValue<int> port {u"BitTorrent/Session/Port"_s};
 315         port = m_commandLineArgs.torrentingPort;
 316     }
 317 }
 318
 319 Application::~Application()
 320 {
 321     // we still need to call cleanup()
 322     // in case the App failed to start
 323     cleanup();
 324 }
 325
 326 #ifndef DISABLE_GUI
 327 DesktopIntegration *Application::desktopIntegration()
 328 {
 329     return m_desktopIntegration;
 330 }
 331
 332 MainWindow *Application::mainWindow()
 333 {
 334     return m_window;
 335 }
 336
 337 WindowState Application::startUpWindowState() const
 338 {
 339     return m_startUpWindowState;
 340 }
 341
 342 void Application::setStartUpWindowState(const WindowState windowState)
 343 {
 344     m_startUpWindowState = windowState;
 345 }
 346
 347 bool Application::isTorrentAddedNotificationsEnabled() const
 348 {
 349     return m_storeNotificationTorrentAdded;
 350 }
 351
 352 void Application::setTorrentAddedNotificationsEnabled(const bool value)
 353 {
 354     m_storeNotificationTorrentAdded = value;
 355 }
 356 #endif
 357
 358 const QBtCommandLineParameters &Application::commandLineArgs() const
 359 {
 360     return m_commandLineArgs;
 361 }
 362
 363 int Application::memoryWorkingSetLimit() const
 364 {
 365     return m_storeMemoryWorkingSetLimit.get(512);
 366 }
 367
 368 void Application::setMemoryWorkingSetLimit(const int size)
 369 {
 370     if (size == memoryWorkingSetLimit())
 371         return;
 372
 373     m_storeMemoryWorkingSetLimit = size;
 374 #ifdef QBT_USES_LIBTORRENT2
 375     applyMemoryWorkingSetLimit();
 376 #endif
 377 }
 378
 379 bool Application::isFileLoggerEnabled() const
 380 {
 381     return m_storeFileLoggerEnabled.get(true);
 382 }
 383
 384 void Application::setFileLoggerEnabled(const bool value)
 385 {
 386     if (value && !m_fileLogger)
 387         m_fileLogger = new FileLogger(fileLoggerPath(), isFileLoggerBackup(), fileLoggerMaxSize(), isFileLoggerDeleteOld(), fileLoggerAge(), static_cast<FileLogger::FileLogAgeType>(fileLoggerAgeType()));
 388     else if (!value)
 389         delete m_fileLogger;
 390     m_storeFileLoggerEnabled = value;
 391 }
 392
 393 Path Application::fileLoggerPath() const
 394 {
 395     return m_storeFileLoggerPath.get(specialFolderLocation(SpecialFolder::Data) / Path(LOG_FOLDER));
 396 }
 397
 398 void Application::setFileLoggerPath(const Path &path)
 399 {
 400     if (m_fileLogger)
 401         m_fileLogger->changePath(path);
 402     m_storeFileLoggerPath = path;
 403 }
 404
 405 bool Application::isFileLoggerBackup() const
 406 {
 407     return m_storeFileLoggerBackup.get(true);
 408 }
 409
 410 void Application::setFileLoggerBackup(const bool value)
 411 {
 412     if (m_fileLogger)
 413         m_fileLogger->setBackup(value);
 414     m_storeFileLoggerBackup = value;
 415 }
 416
 417 bool Application::isFileLoggerDeleteOld() const
 418 {
 419     return m_storeFileLoggerDeleteOld.get(true);
 420 }
 421
 422 void Application::setFileLoggerDeleteOld(const bool value)
 423 {
 424     if (value && m_fileLogger)
 425         m_fileLogger->deleteOld(fileLoggerAge(), static_cast<FileLogger::FileLogAgeType>(fileLoggerAgeType()));
 426     m_storeFileLoggerDeleteOld = value;
 427 }
 428
 429 int Application::fileLoggerMaxSize() const
 430 {
 431     const int val = m_storeFileLoggerMaxSize.get(DEFAULT_FILELOG_SIZE);
 432     return std::min(std::max(val, MIN_FILELOG_SIZE), MAX_FILELOG_SIZE);
 433 }
 434
 435 void Application::setFileLoggerMaxSize(const int bytes)
 436 {
 437     const int clampedValue = std::min(std::max(bytes, MIN_FILELOG_SIZE), MAX_FILELOG_SIZE);
 438     if (m_fileLogger)
 439         m_fileLogger->setMaxSize(clampedValue);
 440     m_storeFileLoggerMaxSize = clampedValue;
 441 }
 442
 443 int Application::fileLoggerAge() const
 444 {
 445     const int val = m_storeFileLoggerAge.get(1);
 446     return std::min(std::max(val, 1), 365);
 447 }
 448
 449 void Application::setFileLoggerAge(const int value)
 450 {
 451     m_storeFileLoggerAge = std::min(std::max(value, 1), 365);
 452 }
 453
 454 int Application::fileLoggerAgeType() const
 455 {
 456     const int val = m_storeFileLoggerAgeType.get(1);
 457     return ((val < 0) || (val > 2)) ? 1 : val;
 458 }
 459
 460 void Application::setFileLoggerAgeType(const int value)
 461 {
 462     m_storeFileLoggerAgeType = ((value < 0) || (value > 2)) ? 1 : value;
 463 }
 464
 465 void Application::processMessage(const QString &message)
 466 {
 467 #ifndef DISABLE_GUI
 468     if (message.isEmpty())
 469     {
 470         // TODO: use [[likely]] in C++20
 471         if (Q_LIKELY(BitTorrent::Session::instance()->isRestored()))
 472         {
 473             m_window->activate(); // show UI
 474         }
 475         else if (m_startupProgressDialog)
 476         {
 477             m_startupProgressDialog->show();
 478             m_startupProgressDialog->activateWindow();
 479             m_startupProgressDialog->raise();
 480         }
 481         else
 482         {
 483             createStartupProgressDialog();
 484         }
 485
 486         return;
 487     }
 488 #endif
 489
 490     const QBtCommandLineParameters params = parseParams(message);
 491     // If Application is not allowed to process params immediately
 492     // (i.e., other components are not ready) store params
 493     if (m_isProcessingParamsAllowed)
 494         processParams(params);
 495     else
 496         m_paramsQueue.append(params);
 497 }
 498
 499 void Application::runExternalProgram(const QString &programTemplate, const BitTorrent::Torrent *torrent) const
 500 {
 501     // Cannot give users shell environment by default, as doing so could
 502     // enable command injection via torrent name and other arguments
 503     // (especially when some automated download mechanism has been setup).
 504     // See: https://github.com/qbittorrent/qBittorrent/issues/10925
 505
 506     const auto replaceVariables = [torrent](QString str) -> QString
 507     {
 508         for (int i = (str.length() - 2); i >= 0; --i)
 509         {
 510             if (str[i] != u'%')
 511                 continue;
 512
 513             const ushort specifier = str[i + 1].unicode();
 514             switch (specifier)
 515             {
 516             case u'C':
 517                 str.replace(i, 2, QString::number(torrent->filesCount()));
 518                 break;
 519             case u'D':
 520                 str.replace(i, 2, torrent->savePath().toString());
 521                 break;
 522             case u'F':
 523                 str.replace(i, 2, torrent->contentPath().toString());
 524                 break;
 525             case u'G':
 526                 str.replace(i, 2, torrent->tags().join(u","_s));
 527                 break;
 528             case u'I':
 529                 str.replace(i, 2, (torrent->infoHash().v1().isValid() ? torrent->infoHash().v1().toString() : u"-"_s));
 530                 break;
 531             case u'J':
 532                 str.replace(i, 2, (torrent->infoHash().v2().isValid() ? torrent->infoHash().v2().toString() : u"-"_s));
 533                 break;
 534             case u'K':
 535                 str.replace(i, 2, torrent->id().toString());
 536                 break;
 537             case u'L':
 538                 str.replace(i, 2, torrent->category());
 539                 break;
 540             case u'N':
 541                 str.replace(i, 2, torrent->name());
 542                 break;
 543             case u'R':
 544                 str.replace(i, 2, torrent->rootPath().toString());
 545                 break;
 546             case u'T':
 547                 str.replace(i, 2, torrent->currentTracker());
 548                 break;
 549             case u'Z':
 550                 str.replace(i, 2, QString::number(torrent->totalSize()));
 551                 break;
 552             default:
 553                 // do nothing
 554                 break;
 555             }
 556
 557             // decrement `i` to avoid unwanted replacement, example pattern: "%%N"
 558             --i;
 559         }
 560
 561         return str;
 562     };
 563
 564     const QString logMsg = tr("Running external program. Torrent: \"%1\". Command: `%2`");
 565     const QString logMsgError = tr("Failed to run external program. Torrent: \"%1\". Command: `%2`");
 566
 567     // The processing sequenece is different for Windows and other OS, this is intentional
 568 #if defined(Q_OS_WIN)
 569     const QString program = replaceVariables(programTemplate);
 570     const std::wstring programWStr = program.toStdWString();
 571
 572     // Need to split arguments manually because QProcess::startDetached(QString)
 573     // will strip off empty parameters.
 574     // E.g. `python.exe "1" "" "3"` will become `python.exe "1" "3"`
 575     int argCount = 0;
 576     std::unique_ptr<LPWSTR[], decltype(&::LocalFree)> args {::CommandLineToArgvW(programWStr.c_str(), &argCount), ::LocalFree};
 577
 578     if (argCount <= 0)
 579         return;
 580
 581     QStringList argList;
 582     for (int i = 1; i < argCount; ++i)
 583         argList += QString::fromWCharArray(args[i]);
 584
 585     QProcess proc;
 586     proc.setProgram(QString::fromWCharArray(args[0]));
 587     proc.setArguments(argList);
 588     proc.setCreateProcessArgumentsModifier([](QProcess::CreateProcessArguments *args)
 589     {
 590         if (Preferences::instance()->isAutoRunConsoleEnabled())
 591         {
 592             args->flags |= CREATE_NEW_CONSOLE;
 593             args->flags &= ~(CREATE_NO_WINDOW | DETACHED_PROCESS);
 594         }
 595         else
 596         {
 597             args->flags |= CREATE_NO_WINDOW;
 598             args->flags &= ~(CREATE_NEW_CONSOLE | DETACHED_PROCESS);
 599         }
 600         args->inheritHandles = false;
 601         args->startupInfo->dwFlags &= ~STARTF_USESTDHANDLES;
 602         ::CloseHandle(args->startupInfo->hStdInput);
 603         ::CloseHandle(args->startupInfo->hStdOutput);
 604         ::CloseHandle(args->startupInfo->hStdError);
 605         args->startupInfo->hStdInput = nullptr;
 606         args->startupInfo->hStdOutput = nullptr;
 607         args->startupInfo->hStdError = nullptr;
 608     });
 609
 610     if (proc.startDetached())
 611         LogMsg(logMsg.arg(torrent->name(), program));
 612     else
 613         LogMsg(logMsgError.arg(torrent->name(), program));
 614 #else // Q_OS_WIN
 615     QStringList args = Utils::String::splitCommand(programTemplate);
 616
 617     if (args.isEmpty())
 618         return;
 619
 620     for (QString &arg : args)
 621     {
 622         // strip redundant quotes
 623         if (arg.startsWith(u'"') && arg.endsWith(u'"'))
 624             arg = arg.mid(1, (arg.size() - 2));
 625
 626         arg = replaceVariables(arg);
 627     }
 628
 629     const QString command = args.takeFirst();
 630     QProcess proc;
 631     proc.setProgram(command);
 632     proc.setArguments(args);
 633
 634     if (proc.startDetached())
 635     {
 636         // show intended command in log
 637         LogMsg(logMsg.arg(torrent->name(), replaceVariables(programTemplate)));
 638     }
 639     else
 640     {
 641         // show intended command in log
 642         LogMsg(logMsgError.arg(torrent->name(), replaceVariables(programTemplate)));
 643     }
 644 #endif
 645 }
 646
 647 void Application::sendNotificationEmail(const BitTorrent::Torrent *torrent)
 648 {
 649     // Prepare mail content
 650     const QString content = tr("Torrent name: %1").arg(torrent->name()) + u'\n'
 651         + tr("Torrent size: %1").arg(Utils::Misc::friendlyUnit(torrent->wantedSize())) + u'\n'
 652         + tr("Save path: %1").arg(torrent->savePath().toString()) + u"\n\n"
 653         + tr("The torrent was downloaded in %1.", "The torrent was downloaded in 1 hour and 20 seconds")
 654             .arg(Utils::Misc::userFriendlyDuration(torrent->activeTime())) + u"\n\n\n"
 655         + tr("Thank you for using qBittorrent.") + u'\n';
 656
 657     // Send the notification email
 658     const Preferences *pref = Preferences::instance();
 659     auto *smtp = new Net::Smtp(this);
 660     smtp->sendMail(pref->getMailNotificationSender(),
 661                      pref->getMailNotificationEmail(),
 662                      tr("Torrent \"%1\" has finished downloading").arg(torrent->name()),
 663                      content);
 664 }
 665
 666 void Application::torrentAdded(const BitTorrent::Torrent *torrent) const
 667 {
 668     const Preferences *pref = Preferences::instance();
 669
 670     // AutoRun program
 671     if (pref->isAutoRunOnTorrentAddedEnabled())
 672         runExternalProgram(pref->getAutoRunOnTorrentAddedProgram().trimmed(), torrent);
 673 }
 674
 675 void Application::torrentFinished(const BitTorrent::Torrent *torrent)
 676 {
 677     const Preferences *pref = Preferences::instance();
 678
 679     // AutoRun program
 680     if (pref->isAutoRunOnTorrentFinishedEnabled())
 681         runExternalProgram(pref->getAutoRunOnTorrentFinishedProgram().trimmed(), torrent);
 682
 683     // Mail notification
 684     if (pref->isMailNotificationEnabled())
 685     {
 686         LogMsg(tr("Torrent: %1, sending mail notification").arg(torrent->name()));
 687         sendNotificationEmail(torrent);
 688     }
 689 }
 690
 691 void Application::allTorrentsFinished()
 692 {
 693     Preferences *const pref = Preferences::instance();
 694     bool isExit = pref->shutdownqBTWhenDownloadsComplete();
 695     bool isShutdown = pref->shutdownWhenDownloadsComplete();
 696     bool isSuspend = pref->suspendWhenDownloadsComplete();
 697     bool isHibernate = pref->hibernateWhenDownloadsComplete();
 698
 699     bool haveAction = isExit || isShutdown || isSuspend || isHibernate;
 700     if (!haveAction) return;
 701
 702     ShutdownDialogAction action = ShutdownDialogAction::Exit;
 703     if (isSuspend)
 704         action = ShutdownDialogAction::Suspend;
 705     else if (isHibernate)
 706         action = ShutdownDialogAction::Hibernate;
 707     else if (isShutdown)
 708         action = ShutdownDialogAction::Shutdown;
 709
 710 #ifndef DISABLE_GUI
 711     // ask confirm
 712     if ((action == ShutdownDialogAction::Exit) && (pref->dontConfirmAutoExit()))
 713     {
 714         // do nothing & skip confirm
 715     }
 716     else
 717     {
 718         if (!ShutdownConfirmDialog::askForConfirmation(m_window, action)) return;
 719     }
 720 #endif // DISABLE_GUI
 721
 722     // Actually shut down
 723     if (action != ShutdownDialogAction::Exit)
 724     {
 725         qDebug("Preparing for auto-shutdown because all downloads are complete!");
 726         // Disabling it for next time
 727         pref->setShutdownWhenDownloadsComplete(false);
 728         pref->setSuspendWhenDownloadsComplete(false);
 729         pref->setHibernateWhenDownloadsComplete(false);
 730         // Make sure preferences are synced before exiting
 731         m_shutdownAct = action;
 732     }
 733
 734     qDebug("Exiting the application");
 735     exit();
 736 }
 737
 738 bool Application::callMainInstance()
 739 {
 740     return m_instanceManager->sendMessage(serializeParams(commandLineArgs()));
 741 }
 742
 743 void Application::processParams(const QBtCommandLineParameters &params)
 744 {
 745 #ifndef DISABLE_GUI
 746     // There are two circumstances in which we want to show the torrent
 747     // dialog. One is when the application settings specify that it should
 748     // be shown and skipTorrentDialog is undefined. The other is when
 749     // skipTorrentDialog is false, meaning that the application setting
 750     // should be overridden.
 751     const bool showDialog = !params.skipDialog.value_or(!AddNewTorrentDialog::isEnabled());
 752     if (showDialog)
 753     {
 754         for (const QString &torrentSource : params.torrentSources)
 755             AddNewTorrentDialog::show(torrentSource, params.addTorrentParams, m_window);
 756     }
 757     else
 758 #endif
 759     {
 760         for (const QString &torrentSource : params.torrentSources)
 761             BitTorrent::Session::instance()->addTorrent(torrentSource, params.addTorrentParams);
 762     }
 763 }
 764
 765 int Application::exec()
 766 try
 767 {
 768 #if !defined(DISABLE_WEBUI) && defined(DISABLE_GUI)
 769     const QString loadingStr = tr("WebUI will be started shortly after internal preparations. Please wait...");
 770     printf("%s\n", qUtf8Printable(loadingStr));
 771 #endif
 772
 773 #ifdef QBT_USES_LIBTORRENT2
 774     applyMemoryWorkingSetLimit();
 775 #endif
 776
 777 #ifdef Q_OS_WIN
 778     applyMemoryPriority();
 779     adjustThreadPriority();
 780 #endif
 781
 782     Net::ProxyConfigurationManager::initInstance();
 783     Net::DownloadManager::initInstance();
 784     IconProvider::initInstance();
 785
 786     BitTorrent::Session::initInstance();
 787 #ifndef DISABLE_GUI
 788     UIThemeManager::initInstance();
 789
 790     m_desktopIntegration = new DesktopIntegration;
 791     m_desktopIntegration->setToolTip(tr("Loading torrents..."));
 792 #ifndef Q_OS_MACOS
 793     auto *desktopIntegrationMenu = new QMenu;
 794     auto *actionExit = new QAction(tr("E&xit"), desktopIntegrationMenu);
 795     actionExit->setIcon(UIThemeManager::instance()->getIcon(u"application-exit"_s));
 796     actionExit->setMenuRole(QAction::QuitRole);
 797     actionExit->setShortcut(Qt::CTRL | Qt::Key_Q);
 798     connect(actionExit, &QAction::triggered, this, []
 799     {
 800         QApplication::exit();
 801     });
 802     desktopIntegrationMenu->addAction(actionExit);
 803
 804     m_desktopIntegration->setMenu(desktopIntegrationMenu);
 805
 806     const bool isHidden = m_desktopIntegration->isActive() && (startUpWindowState() == WindowState::Hidden);
 807 #else
 808     const bool isHidden = false;
 809 #endif
 810
 811     if (!isHidden)
 812     {
 813         createStartupProgressDialog();
 814         // Add a small delay to avoid "flashing" the progress dialog in case there are not many torrents to restore.
 815         m_startupProgressDialog->setMinimumDuration(1000);
 816         if (startUpWindowState() != WindowState::Normal)
 817             m_startupProgressDialog->setWindowState(Qt::WindowMinimized);
 818     }
 819     else
 820     {
 821         connect(m_desktopIntegration, &DesktopIntegration::activationRequested, this, &Application::createStartupProgressDialog);
 822     }
 823 #endif
 824     connect(BitTorrent::Session::instance(), &BitTorrent::Session::restored, this, [this]()
 825     {
 826         connect(BitTorrent::Session::instance(), &BitTorrent::Session::torrentAdded, this, &Application::torrentAdded);
 827         connect(BitTorrent::Session::instance(), &BitTorrent::Session::torrentFinished, this, &Application::torrentFinished);
 828         connect(BitTorrent::Session::instance(), &BitTorrent::Session::allTorrentsFinished, this, &Application::allTorrentsFinished, Qt::QueuedConnection);
 829
 830         Net::GeoIPManager::initInstance();
 831         TorrentFilesWatcher::initInstance();
 832
 833         new RSS::Session; // create RSS::Session singleton
 834         new RSS::AutoDownloader; // create RSS::AutoDownloader singleton
 835
 836 #ifndef DISABLE_GUI
 837         const auto *btSession = BitTorrent::Session::instance();
 838         connect(btSession, &BitTorrent::Session::fullDiskError, this
 839                 , [this](const BitTorrent::Torrent *torrent, const QString &msg)
 840         {
 841             m_desktopIntegration->showNotification(tr("I/O Error", "i.e: Input/Output Error")
 842                                                    , tr("An I/O error occurred for torrent '%1'.\n Reason: %2"
 843                                                         , "e.g: An error occurred for torrent 'xxx.avi'.\n Reason: disk is full.").arg(torrent->name(), msg));
 844         });
 845         connect(btSession, &BitTorrent::Session::loadTorrentFailed, this
 846                 , [this](const QString &error)
 847         {
 848             m_desktopIntegration->showNotification(tr("Error"), tr("Failed to add torrent: %1").arg(error));
 849         });
 850         connect(btSession, &BitTorrent::Session::torrentAdded, this
 851                 , [this](const BitTorrent::Torrent *torrent)
 852         {
 853             if (isTorrentAddedNotificationsEnabled())
 854                 m_desktopIntegration->showNotification(tr("Torrent added"), tr("'%1' was added.", "e.g: xxx.avi was added.").arg(torrent->name()));
 855         });
 856         connect(btSession, &BitTorrent::Session::torrentFinished, this
 857                 , [this](const BitTorrent::Torrent *torrent)
 858         {
 859             m_desktopIntegration->showNotification(tr("Download completed"), tr("'%1' has finished downloading.", "e.g: xxx.avi has finished downloading.").arg(torrent->name()));
 860         });
 861         connect(btSession, &BitTorrent::Session::downloadFromUrlFailed, this
 862                 , [this](const QString &url, const QString &reason)
 863         {
 864             m_desktopIntegration->showNotification(tr("URL download error")
 865                                                    , tr("Couldn't download file at URL '%1', reason: %2.").arg(url, reason));
 866         });
 867
 868         disconnect(m_desktopIntegration, &DesktopIntegration::activationRequested, this, &Application::createStartupProgressDialog);
 869 #ifndef Q_OS_MACOS
 870         const WindowState windowState = !m_startupProgressDialog ? WindowState::Hidden
 871                 : (m_startupProgressDialog->windowState() & Qt::WindowMinimized) ? WindowState::Minimized
 872                         : WindowState::Normal;
 873 #else
 874         const WindowState windowState = (m_startupProgressDialog->windowState() & Qt::WindowMinimized)
 875                 ? WindowState::Minimized : WindowState::Normal;
 876 #endif
 877         m_window = new MainWindow(this, windowState);
 878         delete m_startupProgressDialog;
 879 #ifdef Q_OS_WIN
 880         auto *pref = Preferences::instance();
 881         if (!pref->neverCheckFileAssoc() && (!Preferences::isTorrentFileAssocSet() || !Preferences::isMagnetLinkAssocSet()))
 882         {
 883             if (QMessageBox::question(m_window, tr("Torrent file association")
 884                                       , tr("qBittorrent is not the default application for opening torrent files or Magnet links.\nDo you want to make qBittorrent the default application for these?")
 885                                       , QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes)
 886             {
 887                 pref->setTorrentFileAssoc(true);
 888                 pref->setMagnetLinkAssoc(true);
 889             }
 890             else
 891             {
 892                 pref->setNeverCheckFileAssoc();
 893             }
 894         }
 895 #endif // Q_OS_WIN
 896 #endif // DISABLE_GUI
 897
 898 #ifndef DISABLE_WEBUI
 899         m_webui = new WebUI(this);
 900 #ifdef DISABLE_GUI
 901         if (m_webui->isErrored())
 902             QCoreApplication::exit(EXIT_FAILURE);
 903         connect(m_webui, &WebUI::fatalError, this, []() { QCoreApplication::exit(EXIT_FAILURE); });
 904
 905         const Preferences *pref = Preferences::instance();
 906
 907         const auto scheme = pref->isWebUiHttpsEnabled() ? u"https"_s : u"http"_s;
 908         const auto url = u"%1://localhost:%2\n"_s.arg(scheme, QString::number(pref->getWebUiPort()));
 909         const QString mesg = u"\n******** %1 ********\n"_s.arg(tr("Information"))
 910                 + tr("To control qBittorrent, access the WebUI at: %1").arg(url);
 911         printf("%s\n", qUtf8Printable(mesg));
 912
 913         if (pref->getWebUIPassword() == QByteArrayLiteral("ARQ77eY1NUZaQsuDHbIMCA==:0WMRkYTUWVT9wVvdDtHAjU9b3b7uB8NR1Gur2hmQCvCDpm39Q+PsJRJPaCU51dEiz+dTzh8qbPsL8WkFljQYFQ=="))
 914         {
 915             const QString warning = tr("The Web UI administrator username is: %1").arg(pref->getWebUiUsername()) + u'\n'
 916                     + tr("The Web UI administrator password has not been changed from the default: %1").arg(u"adminadmin"_s) + u'\n'
 917                     + tr("This is a security risk, please change your password in program preferences.") + u'\n';
 918             printf("%s", qUtf8Printable(warning));
 919         }
 920 #endif // DISABLE_GUI
 921 #endif // DISABLE_WEBUI
 922
 923         m_isProcessingParamsAllowed = true;
 924         for (const QBtCommandLineParameters &params : m_paramsQueue)
 925             processParams(params);
 926         m_paramsQueue.clear();
 927     });
 928
 929     const QBtCommandLineParameters params = commandLineArgs();
 930     if (!params.torrentSources.isEmpty())
 931         m_paramsQueue.append(params);
 932
 933     return BaseApplication::exec();
 934 }
 935 catch (const RuntimeError &err)
 936 {
 937 #ifdef DISABLE_GUI
 938     fprintf(stderr, "%s", qPrintable(err.message()));
 939 #else
 940     QMessageBox msgBox;
 941     msgBox.setIcon(QMessageBox::Critical);
 942     msgBox.setText(QCoreApplication::translate("Application", "Application failed to start."));
 943     msgBox.setInformativeText(err.message());
 944     msgBox.show(); // Need to be shown or to moveToCenter does not work
 945     msgBox.move(Utils::Gui::screenCenter(&msgBox));
 946     msgBox.exec();
 947 #endif
 948     return EXIT_FAILURE;
 949 }
 950
 951 bool Application::isRunning()
 952 {
 953     return !m_instanceManager->isFirstInstance();
 954 }
 955
 956 #ifndef DISABLE_GUI
 957 void Application::createStartupProgressDialog()
 958 {
 959     Q_ASSERT(!m_startupProgressDialog);
 960     Q_ASSERT(m_desktopIntegration);
 961
 962     disconnect(m_desktopIntegration, &DesktopIntegration::activationRequested, this, &Application::createStartupProgressDialog);
 963
 964     m_startupProgressDialog = new QProgressDialog(tr("Loading torrents..."), tr("Exit"), 0, 100);
 965     m_startupProgressDialog->setAttribute(Qt::WA_DeleteOnClose);
 966     m_startupProgressDialog->setWindowFlag(Qt::WindowMinimizeButtonHint);
 967     m_startupProgressDialog->setMinimumDuration(0); // Show dialog immediately by default
 968     m_startupProgressDialog->setAutoReset(false);
 969     m_startupProgressDialog->setAutoClose(false);
 970
 971     connect(m_startupProgressDialog, &QProgressDialog::canceled, this, []()
 972     {
 973         QApplication::exit();
 974     });
 975
 976     connect(BitTorrent::Session::instance(), &BitTorrent::Session::startupProgressUpdated, m_startupProgressDialog, &QProgressDialog::setValue);
 977
 978     connect(m_desktopIntegration, &DesktopIntegration::activationRequested, m_startupProgressDialog, [this]()
 979     {
 980 #ifdef Q_OS_MACOS
 981         if (!m_startupProgressDialog->isVisible())
 982         {
 983             m_startupProgressDialog->show();
 984             m_startupProgressDialog->activateWindow();
 985             m_startupProgressDialog->raise();
 986         }
 987 #else
 988         if (m_startupProgressDialog->isHidden())
 989         {
 990             // Make sure the window is not minimized
 991             m_startupProgressDialog->setWindowState((m_startupProgressDialog->windowState() & ~Qt::WindowMinimized) | Qt::WindowActive);
 992
 993             // Then show it
 994             m_startupProgressDialog->show();
 995             m_startupProgressDialog->raise();
 996             m_startupProgressDialog->activateWindow();
 997         }
 998         else
 999         {
1000             m_startupProgressDialog->hide();
1001         }
1002 #endif
1003     });
1004 }
1005
1006 #ifdef Q_OS_MACOS
1007 bool Application::event(QEvent *ev)
1008 {
1009     if (ev->type() == QEvent::FileOpen)
1010     {
1011         QString path = static_cast<QFileOpenEvent *>(ev)->file();
1012         if (path.isEmpty())
1013             // Get the url instead
1014             path = static_cast<QFileOpenEvent *>(ev)->url().toString();
1015         qDebug("Received a mac file open event: %s", qUtf8Printable(path));
1016
1017         QBtCommandLineParameters params;
1018         params.torrentSources.append(path);
1019         // If Application is not allowed to process params immediately
1020         // (i.e., other components are not ready) store params
1021         if (m_isProcessingParamsAllowed)
1022             processParams(params);
1023         else
1024             m_paramsQueue.append(params);
1025
1026         return true;
1027     }
1028
1029     return BaseApplication::event(ev);
1030 }
1031 #endif // Q_OS_MACOS
1032 #endif // DISABLE_GUI
1033
1034 void Application::initializeTranslation()
1035 {
1036     Preferences *const pref = Preferences::instance();
1037     // Load translation
1038     const QString localeStr = pref->getLocale();
1039
1040     if (m_qtTranslator.load((u"qtbase_" + localeStr), QLibraryInfo::location(QLibraryInfo::TranslationsPath)) ||
1041         m_qtTranslator.load((u"qt_" + localeStr), QLibraryInfo::location(QLibraryInfo::TranslationsPath)))
1042             qDebug("Qt %s locale recognized, using translation.", qUtf8Printable(localeStr));
1043     else
1044         qDebug("Qt %s locale unrecognized, using default (en).", qUtf8Printable(localeStr));
1045
1046     installTranslator(&m_qtTranslator);
1047
1048     if (m_translator.load(u":/lang/qbittorrent_" + localeStr))
1049         qDebug("%s locale recognized, using translation.", qUtf8Printable(localeStr));
1050     else
1051         qDebug("%s locale unrecognized, using default (en).", qUtf8Printable(localeStr));
1052     installTranslator(&m_translator);
1053
1054 #ifndef DISABLE_GUI
1055     if (localeStr.startsWith(u"ar") || localeStr.startsWith(u"he"))
1056     {
1057         qDebug("Right to Left mode");
1058         setLayoutDirection(Qt::RightToLeft);
1059     }
1060     else
1061     {
1062         setLayoutDirection(Qt::LeftToRight);
1063     }
1064 #endif
1065 }
1066
1067 #if (!defined(DISABLE_GUI) && defined(Q_OS_WIN))
1068 void Application::shutdownCleanup(QSessionManager &manager)
1069 {
1070     Q_UNUSED(manager);
1071
1072     // This is only needed for a special case on Windows XP.
1073     // (but is called for every Windows version)
1074     // If a process takes too much time to exit during OS
1075     // shutdown, the OS presents a dialog to the user.
1076     // That dialog tells the user that qbt is blocking the
1077     // shutdown, it shows a progress bar and it offers
1078     // a "Terminate Now" button for the user. However,
1079     // after the progress bar has reached 100% another button
1080     // is offered to the user reading "Cancel". With this the
1081     // user can cancel the **OS** shutdown. If we don't do
1082     // the cleanup by handling the commitDataRequest() signal
1083     // and the user clicks "Cancel", it will result in qbt being
1084     // killed and the shutdown proceeding instead. Apparently
1085     // aboutToQuit() is emitted too late in the shutdown process.
1086     cleanup();
1087
1088     // According to the qt docs we shouldn't call quit() inside a slot.
1089     // aboutToQuit() is never emitted if the user hits "Cancel" in
1090     // the above dialog.
1091     QMetaObject::invokeMethod(qApp, &QCoreApplication::quit, Qt::QueuedConnection);
1092 }
1093 #endif
1094
1095 #ifdef QBT_USES_LIBTORRENT2
1096 void Application::applyMemoryWorkingSetLimit() const
1097 {
1098     const size_t MiB = 1024 * 1024;
1099     const QString logMessage = tr("Failed to set physical memory (RAM) usage limit. Error code: %1. Error message: \"%2\"");
1100
1101 #ifdef Q_OS_WIN
1102     const SIZE_T maxSize = memoryWorkingSetLimit() * MiB;
1103     const auto minSize = std::min<SIZE_T>((64 * MiB), (maxSize / 2));
1104     if (!::SetProcessWorkingSetSizeEx(::GetCurrentProcess(), minSize, maxSize, QUOTA_LIMITS_HARDWS_MAX_ENABLE))
1105     {
1106         const DWORD errorCode = ::GetLastError();
1107         QString message;
1108         LPVOID lpMsgBuf = nullptr;
1109         const DWORD msgLength = ::FormatMessageW((FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS)
1110             , nullptr, errorCode, LANG_USER_DEFAULT, reinterpret_cast<LPWSTR>(&lpMsgBuf), 0, nullptr);
1111         if (msgLength > 0)
1112         {
1113             message = QString::fromWCharArray(reinterpret_cast<LPWSTR>(lpMsgBuf)).trimmed();
1114             ::LocalFree(lpMsgBuf);
1115         }
1116         LogMsg(logMessage.arg(QString::number(errorCode), message), Log::WARNING);
1117     }
1118 #elif defined(Q_OS_UNIX)
1119     // has no effect on linux but it might be meaningful for other OS
1120     rlimit limit {};
1121
1122     if (::getrlimit(RLIMIT_RSS, &limit) != 0)
1123         return;
1124
1125     const size_t newSize = memoryWorkingSetLimit() * MiB;
1126     if (newSize > limit.rlim_max)
1127     {
1128         // try to raise the hard limit
1129         rlimit newLimit = limit;
1130         newLimit.rlim_max = newSize;
1131         if (::setrlimit(RLIMIT_RSS, &newLimit) != 0)
1132         {
1133             const auto message = QString::fromLocal8Bit(strerror(errno));
1134             LogMsg(tr("Failed to set physical memory (RAM) usage hard limit. Requested size: %1. System hard limit: %2. Error code: %3. Error message: \"%4\"")
1135                 .arg(QString::number(newSize), QString::number(limit.rlim_max), QString::number(errno), message), Log::WARNING);
1136             return;
1137         }
1138     }
1139
1140     limit.rlim_cur = newSize;
1141     if (::setrlimit(RLIMIT_RSS, &limit) != 0)
1142     {
1143         const auto message = QString::fromLocal8Bit(strerror(errno));
1144         LogMsg(logMessage.arg(QString::number(errno), message), Log::WARNING);
1145     }
1146 #endif
1147 }
1148 #endif
1149
1150 #ifdef Q_OS_WIN
1151 MemoryPriority Application::processMemoryPriority() const
1152 {
1153     return m_processMemoryPriority.get(MemoryPriority::BelowNormal);
1154 }
1155
1156 void Application::setProcessMemoryPriority(const MemoryPriority priority)
1157 {
1158     if (processMemoryPriority() == priority)
1159         return;
1160
1161     m_processMemoryPriority = priority;
1162     applyMemoryPriority();
1163 }
1164
1165 void Application::applyMemoryPriority() const
1166 {
1167     using SETPROCESSINFORMATION = BOOL (WINAPI *)(HANDLE, PROCESS_INFORMATION_CLASS, LPVOID, DWORD);
1168     const auto setProcessInformation = Utils::Misc::loadWinAPI<SETPROCESSINFORMATION>(u"Kernel32.dll"_s, "SetProcessInformation");
1169     if (!setProcessInformation)  // only available on Windows >= 8
1170         return;
1171
1172     using SETTHREADINFORMATION = BOOL (WINAPI *)(HANDLE, THREAD_INFORMATION_CLASS, LPVOID, DWORD);
1173     const auto setThreadInformation = Utils::Misc::loadWinAPI<SETTHREADINFORMATION>(u"Kernel32.dll"_s, "SetThreadInformation");
1174     if (!setThreadInformation)  // only available on Windows >= 8
1175         return;
1176
1177 #if (_WIN32_WINNT < _WIN32_WINNT_WIN8)
1178     // this dummy struct is required to compile successfully when targeting older Windows version
1179     struct MEMORY_PRIORITY_INFORMATION
1180     {
1181         ULONG MemoryPriority;
1182     };
1183
1184 #define MEMORY_PRIORITY_LOWEST 0
1185 #define MEMORY_PRIORITY_VERY_LOW 1
1186 #define MEMORY_PRIORITY_LOW 2
1187 #define MEMORY_PRIORITY_MEDIUM 3
1188 #define MEMORY_PRIORITY_BELOW_NORMAL 4
1189 #define MEMORY_PRIORITY_NORMAL 5
1190 #endif
1191
1192     MEMORY_PRIORITY_INFORMATION prioInfo {};
1193     switch (processMemoryPriority())
1194     {
1195     case MemoryPriority::Normal:
1196     default:
1197         prioInfo.MemoryPriority = MEMORY_PRIORITY_NORMAL;
1198         break;
1199     case MemoryPriority::BelowNormal:
1200         prioInfo.MemoryPriority = MEMORY_PRIORITY_BELOW_NORMAL;
1201         break;
1202     case MemoryPriority::Medium:
1203         prioInfo.MemoryPriority = MEMORY_PRIORITY_MEDIUM;
1204         break;
1205     case MemoryPriority::Low:
1206         prioInfo.MemoryPriority = MEMORY_PRIORITY_LOW;
1207         break;
1208     case MemoryPriority::VeryLow:
1209         prioInfo.MemoryPriority = MEMORY_PRIORITY_VERY_LOW;
1210         break;
1211     }
1212     setProcessInformation(::GetCurrentProcess(), ProcessMemoryPriority, &prioInfo, sizeof(prioInfo));
1213
1214     // To avoid thrashing/sluggishness of the app, set "main event loop" thread to normal memory priority
1215     // which is higher/equal than other threads
1216     prioInfo.MemoryPriority = MEMORY_PRIORITY_NORMAL;
1217     setThreadInformation(::GetCurrentThread(), ThreadMemoryPriority, &prioInfo, sizeof(prioInfo));
1218 }
1219
1220 void Application::adjustThreadPriority() const
1221 {
1222     // Workaround for improving responsiveness of qbt when CPU resources are scarce.
1223     // Raise main event loop thread to be just one level higher than libtorrent threads.
1224     // Also note that on *nix platforms there is no easy way to achieve it,
1225     // so implementation is omitted.
1226
1227     ::SetThreadPriority(::GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
1228 }
1229 #endif
1230
1231 void Application::cleanup()
1232 {
1233     // cleanup() can be called multiple times during shutdown. We only need it once.
1234     if (!m_isCleanupRun.testAndSetAcquire(0, 1))
1235         return;
1236
1237     LogMsg(tr("qBittorrent termination initiated"));
1238
1239 #ifndef DISABLE_GUI
1240     if (m_desktopIntegration)
1241     {
1242         m_desktopIntegration->disconnect();
1243         m_desktopIntegration->setToolTip(tr("qBittorrent is shutting down..."));
1244         if (m_desktopIntegration->menu())
1245             m_desktopIntegration->menu()->setEnabled(false);
1246     }
1247
1248     if (m_window)
1249     {
1250         // Hide the window and don't leave it on screen as
1251         // unresponsive. Also for Windows take the WinId
1252         // after it's hidden, because hide() may cause a
1253         // WinId change.
1254         m_window->hide();
1255
1256 #ifdef Q_OS_WIN
1257         const std::wstring msg = tr("Saving torrent progress...").toStdWString();
1258         ::ShutdownBlockReasonCreate(reinterpret_cast<HWND>(m_window->effectiveWinId())
1259             , msg.c_str());
1260 #endif // Q_OS_WIN
1261
1262         // Do manual cleanup in MainWindow to force widgets
1263         // to save their Preferences, stop all timers and
1264         // delete as many widgets as possible to leave only
1265         // a 'shell' MainWindow.
1266         // We need a valid window handle for Windows Vista+
1267         // otherwise the system shutdown will continue even
1268         // though we created a ShutdownBlockReason
1269         m_window->cleanup();
1270     }
1271 #endif // DISABLE_GUI
1272
1273 #ifndef DISABLE_WEBUI
1274     delete m_webui;
1275 #endif
1276
1277     delete RSS::AutoDownloader::instance();
1278     delete RSS::Session::instance();
1279
1280     TorrentFilesWatcher::freeInstance();
1281     BitTorrent::Session::freeInstance();
1282     Net::GeoIPManager::freeInstance();
1283     Net::DownloadManager::freeInstance();
1284     Net::ProxyConfigurationManager::freeInstance();
1285     Preferences::freeInstance();
1286     SettingsStorage::freeInstance();
1287     IconProvider::freeInstance();
1288     SearchPluginManager::freeInstance();
1289     Utils::Fs::removeDirRecursively(Utils::Fs::tempPath());
1290
1291     LogMsg(tr("qBittorrent is now ready to exit"));
1292     Logger::freeInstance();
1293     delete m_fileLogger;
1294
1295 #ifndef DISABLE_GUI
1296     if (m_window)
1297     {
1298 #ifdef Q_OS_WIN
1299         ::ShutdownBlockReasonDestroy(reinterpret_cast<HWND>(m_window->effectiveWinId()));
1300 #endif // Q_OS_WIN
1301         delete m_window;
1302         delete m_desktopIntegration;
1303         UIThemeManager::freeInstance();
1304     }
1305 #endif // DISABLE_GUI
1306
1307     Profile::freeInstance();
1308
1309     if (m_shutdownAct != ShutdownDialogAction::Exit)
1310     {
1311         qDebug() << "Sending computer shutdown/suspend/hibernate signal...";
1312         Utils::Misc::shutdownComputer(m_shutdownAct);
1313     }
1314 }