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 #include <QAtomicInt>
  35 #include <QDebug>
  36 #include <QLibraryInfo>
  37 #include <QLocale>
  38 #include <QProcess>
  39 #include <QSysInfo>
  40
  41 #ifdef Q_OS_WIN
  42 #include <memory>
  43 #include <Shellapi.h>
  44 #endif
  45
  46 #ifndef DISABLE_GUI
  47 #include <QMessageBox>
  48 #ifdef Q_OS_WIN
  49 #include <QSessionManager>
  50 #include <QSharedMemory>
  51 #endif // Q_OS_WIN
  52 #ifdef Q_OS_MAC
  53 #include <QFileOpenEvent>
  54 #endif // Q_OS_MAC
  55 #include "addnewtorrentdialog.h"
  56 #include "gui/guiiconprovider.h"
  57 #include "mainwindow.h"
  58 #include "shutdownconfirmdialog.h"
  59 #else // DISABLE_GUI
  60 #include <cstdio>
  61 #endif // DISABLE_GUI
  62
  63 #include "base/bittorrent/session.h"
  64 #include "base/bittorrent/torrenthandle.h"
  65 #include "base/exceptions.h"
  66 #include "base/iconprovider.h"
  67 #include "base/logger.h"
  68 #include "base/net/downloadmanager.h"
  69 #include "base/net/geoipmanager.h"
  70 #include "base/net/proxyconfigurationmanager.h"
  71 #include "base/net/smtp.h"
  72 #include "base/preferences.h"
  73 #include "base/profile.h"
  74 #include "base/rss/rss_autodownloader.h"
  75 #include "base/rss/rss_session.h"
  76 #include "base/scanfoldersmodel.h"
  77 #include "base/search/searchpluginmanager.h"
  78 #include "base/settingsstorage.h"
  79 #include "base/utils/fs.h"
  80 #include "base/utils/misc.h"
  81 #include "base/utils/string.h"
  82 #include "filelogger.h"
  83
  84 #ifndef DISABLE_WEBUI
  85 #include "webui/webui.h"
  86 #endif
  87
  88 namespace
  89 {
  90 #define SETTINGS_KEY(name) "Application/" name
  91
  92     // FileLogger properties keys
  93 #define FILELOGGER_SETTINGS_KEY(name) QStringLiteral(SETTINGS_KEY("FileLogger/") name)
  94     const QString KEY_FILELOGGER_ENABLED = FILELOGGER_SETTINGS_KEY("Enabled");
  95     const QString KEY_FILELOGGER_PATH = FILELOGGER_SETTINGS_KEY("Path");
  96     const QString KEY_FILELOGGER_BACKUP = FILELOGGER_SETTINGS_KEY("Backup");
  97     const QString KEY_FILELOGGER_DELETEOLD = FILELOGGER_SETTINGS_KEY("DeleteOld");
  98     const QString KEY_FILELOGGER_MAXSIZEBYTES = FILELOGGER_SETTINGS_KEY("MaxSizeBytes");
  99     const QString KEY_FILELOGGER_AGE = FILELOGGER_SETTINGS_KEY("Age");
 100     const QString KEY_FILELOGGER_AGETYPE = FILELOGGER_SETTINGS_KEY("AgeType");
 101
 102     // just a shortcut
 103     inline SettingsStorage *settings() { return  SettingsStorage::instance(); }
 104
 105     const QString LOG_FOLDER = QStringLiteral("logs");
 106     const QChar PARAMS_SEPARATOR = '|';
 107
 108     const QString DEFAULT_PORTABLE_MODE_PROFILE_DIR = QStringLiteral("profile");
 109
 110     const int MIN_FILELOG_SIZE = 1024; // 1KiB
 111     const int MAX_FILELOG_SIZE = 1000 * 1024 * 1024; // 1000MiB
 112     const int DEFAULT_FILELOG_SIZE = 65 * 1024; // 65KiB
 113 }
 114
 115 Application::Application(const QString &id, int &argc, char **argv)
 116     : BaseApplication(id, argc, argv)
 117     , m_running(false)
 118     , m_shutdownAct(ShutdownDialogAction::Exit)
 119     , m_commandLineArgs(parseCommandLine(this->arguments()))
 120 #ifndef DISABLE_WEBUI
 121     , m_webui(nullptr)
 122 #endif
 123 {
 124     qRegisterMetaType<Log::Msg>("Log::Msg");
 125
 126     setApplicationName("qBittorrent");
 127     validateCommandLineParameters();
 128
 129     QString profileDir = m_commandLineArgs.portableMode
 130         ? QDir(QCoreApplication::applicationDirPath()).absoluteFilePath(DEFAULT_PORTABLE_MODE_PROFILE_DIR)
 131         : m_commandLineArgs.profileDir;
 132
 133     Profile::initialize(profileDir, m_commandLineArgs.configurationName,
 134                         m_commandLineArgs.relativeFastresumePaths || m_commandLineArgs.portableMode);
 135
 136     Logger::initInstance();
 137     SettingsStorage::initInstance();
 138     Preferences::initInstance();
 139
 140     if (m_commandLineArgs.webUiPort > 0) // it will be -1 when user did not set any value
 141         Preferences::instance()->setWebUiPort(m_commandLineArgs.webUiPort);
 142
 143     initializeTranslation();
 144
 145 #if !defined(DISABLE_GUI)
 146     setAttribute(Qt::AA_UseHighDpiPixmaps, true);  // opt-in to the high DPI pixmap support
 147     setQuitOnLastWindowClosed(false);
 148 #endif
 149
 150 #if defined(Q_OS_WIN) && !defined(DISABLE_GUI)
 151     connect(this, &QGuiApplication::commitDataRequest, this, &Application::shutdownCleanup, Qt::DirectConnection);
 152 #endif
 153
 154     connect(this, &Application::messageReceived, this, &Application::processMessage);
 155     connect(this, &QCoreApplication::aboutToQuit, this, &Application::cleanup);
 156
 157     if (isFileLoggerEnabled())
 158         m_fileLogger = new FileLogger(fileLoggerPath(), isFileLoggerBackup(), fileLoggerMaxSize(), isFileLoggerDeleteOld(), fileLoggerAge(), static_cast<FileLogger::FileLogAgeType>(fileLoggerAgeType()));
 159
 160     Logger::instance()->addMessage(tr("qBittorrent %1 started", "qBittorrent v3.2.0alpha started").arg(QBT_VERSION));
 161 }
 162
 163 Application::~Application()
 164 {
 165     // we still need to call cleanup()
 166     // in case the App failed to start
 167     cleanup();
 168 }
 169
 170 #ifndef DISABLE_GUI
 171 QPointer<MainWindow> Application::mainWindow()
 172 {
 173     return m_window;
 174 }
 175 #endif
 176
 177 const QBtCommandLineParameters &Application::commandLineArgs() const
 178 {
 179     return m_commandLineArgs;
 180 }
 181
 182 bool Application::isFileLoggerEnabled() const
 183 {
 184     return settings()->loadValue(KEY_FILELOGGER_ENABLED, true).toBool();
 185 }
 186
 187 void Application::setFileLoggerEnabled(bool value)
 188 {
 189     if (value && !m_fileLogger)
 190         m_fileLogger = new FileLogger(fileLoggerPath(), isFileLoggerBackup(), fileLoggerMaxSize(), isFileLoggerDeleteOld(), fileLoggerAge(), static_cast<FileLogger::FileLogAgeType>(fileLoggerAgeType()));
 191     else if (!value)
 192         delete m_fileLogger;
 193     settings()->storeValue(KEY_FILELOGGER_ENABLED, value);
 194 }
 195
 196 QString Application::fileLoggerPath() const
 197 {
 198     return settings()->loadValue(KEY_FILELOGGER_PATH,
 199             QVariant(specialFolderLocation(SpecialFolder::Data) + LOG_FOLDER)).toString();
 200 }
 201
 202 void Application::setFileLoggerPath(const QString &path)
 203 {
 204     if (m_fileLogger)
 205         m_fileLogger->changePath(path);
 206     settings()->storeValue(KEY_FILELOGGER_PATH, path);
 207 }
 208
 209 bool Application::isFileLoggerBackup() const
 210 {
 211     return settings()->loadValue(KEY_FILELOGGER_BACKUP, true).toBool();
 212 }
 213
 214 void Application::setFileLoggerBackup(bool value)
 215 {
 216     if (m_fileLogger)
 217         m_fileLogger->setBackup(value);
 218     settings()->storeValue(KEY_FILELOGGER_BACKUP, value);
 219 }
 220
 221 bool Application::isFileLoggerDeleteOld() const
 222 {
 223     return settings()->loadValue(KEY_FILELOGGER_DELETEOLD, true).toBool();
 224 }
 225
 226 void Application::setFileLoggerDeleteOld(bool value)
 227 {
 228     if (value && m_fileLogger)
 229         m_fileLogger->deleteOld(fileLoggerAge(), static_cast<FileLogger::FileLogAgeType>(fileLoggerAgeType()));
 230     settings()->storeValue(KEY_FILELOGGER_DELETEOLD, value);
 231 }
 232
 233 int Application::fileLoggerMaxSize() const
 234 {
 235     int val = settings()->loadValue(KEY_FILELOGGER_MAXSIZEBYTES, DEFAULT_FILELOG_SIZE).toInt();
 236     return std::min(std::max(val, MIN_FILELOG_SIZE), MAX_FILELOG_SIZE);
 237 }
 238
 239 void Application::setFileLoggerMaxSize(const int bytes)
 240 {
 241     int clampedValue = std::min(std::max(bytes, MIN_FILELOG_SIZE), MAX_FILELOG_SIZE);
 242     if (m_fileLogger)
 243         m_fileLogger->setMaxSize(clampedValue);
 244     settings()->storeValue(KEY_FILELOGGER_MAXSIZEBYTES, clampedValue);
 245 }
 246
 247 int Application::fileLoggerAge() const
 248 {
 249     int val = settings()->loadValue(KEY_FILELOGGER_AGE, 1).toInt();
 250     return std::min(std::max(val, 1), 365);
 251 }
 252
 253 void Application::setFileLoggerAge(const int value)
 254 {
 255     settings()->storeValue(KEY_FILELOGGER_AGE, std::min(std::max(value, 1), 365));
 256 }
 257
 258 int Application::fileLoggerAgeType() const
 259 {
 260     int val = settings()->loadValue(KEY_FILELOGGER_AGETYPE, 1).toInt();
 261     return ((val < 0) || (val > 2)) ? 1 : val;
 262 }
 263
 264 void Application::setFileLoggerAgeType(const int value)
 265 {
 266     settings()->storeValue(KEY_FILELOGGER_AGETYPE, ((value < 0) || (value > 2)) ? 1 : value);
 267 }
 268
 269 void Application::processMessage(const QString &message)
 270 {
 271     QStringList params = message.split(PARAMS_SEPARATOR, QString::SkipEmptyParts);
 272     // If Application is not running (i.e., other
 273     // components are not ready) store params
 274     if (m_running)
 275         processParams(params);
 276     else
 277         m_paramsQueue.append(params);
 278 }
 279
 280 void Application::runExternalProgram(const BitTorrent::TorrentHandle *torrent) const
 281 {
 282     QString program = Preferences::instance()->getAutoRunProgram().trimmed();
 283     program.replace("%N", torrent->name());
 284     program.replace("%L", torrent->category());
 285
 286     QStringList tags = torrent->tags().toList();
 287     std::sort(tags.begin(), tags.end(), Utils::String::naturalLessThan<Qt::CaseInsensitive>);
 288     program.replace("%G", tags.join(','));
 289
 290 #if defined(Q_OS_WIN)
 291     const auto chopPathSep = [](const QString &str) -> QString
 292     {
 293         if (str.endsWith('\\'))
 294             return str.mid(0, (str.length() -1));
 295         return str;
 296     };
 297     program.replace("%F", chopPathSep(Utils::Fs::toNativePath(torrent->contentPath())));
 298     program.replace("%R", chopPathSep(Utils::Fs::toNativePath(torrent->rootPath())));
 299     program.replace("%D", chopPathSep(Utils::Fs::toNativePath(torrent->savePath())));
 300 #else
 301     program.replace("%F", Utils::Fs::toNativePath(torrent->contentPath()));
 302     program.replace("%R", Utils::Fs::toNativePath(torrent->rootPath()));
 303     program.replace("%D", Utils::Fs::toNativePath(torrent->savePath()));
 304 #endif
 305     program.replace("%C", QString::number(torrent->filesCount()));
 306     program.replace("%Z", QString::number(torrent->totalSize()));
 307     program.replace("%T", torrent->currentTracker());
 308     program.replace("%I", torrent->hash());
 309
 310     Logger *logger = Logger::instance();
 311     logger->addMessage(tr("Torrent: %1, running external program, command: %2").arg(torrent->name(), program));
 312
 313 #if defined(Q_OS_WIN)
 314     std::unique_ptr<wchar_t[]> programWchar(new wchar_t[program.length() + 1] {});
 315     program.toWCharArray(programWchar.get());
 316
 317     // Need to split arguments manually because QProcess::startDetached(QString)
 318     // will strip off empty parameters.
 319     // E.g. `python.exe "1" "" "3"` will become `python.exe "1" "3"`
 320     int argCount = 0;
 321     LPWSTR *args = ::CommandLineToArgvW(programWchar.get(), &argCount);
 322
 323     QStringList argList;
 324     for (int i = 1; i < argCount; ++i)
 325         argList += QString::fromWCharArray(args[i]);
 326
 327     QProcess::startDetached(QString::fromWCharArray(args[0]), argList);
 328
 329     ::LocalFree(args);
 330 #else
 331     QProcess::startDetached(QLatin1String("/bin/sh"), {QLatin1String("-c"), program});
 332 #endif
 333 }
 334
 335 void Application::sendNotificationEmail(const BitTorrent::TorrentHandle *torrent)
 336 {
 337     // Prepare mail content
 338     const QString content = tr("Torrent name: %1").arg(torrent->name()) + '\n'
 339         + tr("Torrent size: %1").arg(Utils::Misc::friendlyUnit(torrent->wantedSize())) + '\n'
 340         + tr("Save path: %1").arg(torrent->savePath()) + "\n\n"
 341         + tr("The torrent was downloaded in %1.", "The torrent was downloaded in 1 hour and 20 seconds")
 342             .arg(Utils::Misc::userFriendlyDuration(torrent->activeTime())) + "\n\n\n"
 343         + tr("Thank you for using qBittorrent.") + '\n';
 344
 345     // Send the notification email
 346     const Preferences *pref = Preferences::instance();
 347     Net::Smtp *smtp = new Net::Smtp(this);
 348     smtp->sendMail(pref->getMailNotificationSender(),
 349                      pref->getMailNotificationEmail(),
 350                      tr("[qBittorrent] '%1' has finished downloading").arg(torrent->name()),
 351                      content);
 352 }
 353
 354 void Application::torrentFinished(BitTorrent::TorrentHandle *const torrent)
 355 {
 356     Preferences *const pref = Preferences::instance();
 357
 358     // AutoRun program
 359     if (pref->isAutoRunEnabled())
 360         runExternalProgram(torrent);
 361
 362     // Mail notification
 363     if (pref->isMailNotificationEnabled()) {
 364         Logger::instance()->addMessage(tr("Torrent: %1, sending mail notification").arg(torrent->name()));
 365         sendNotificationEmail(torrent);
 366     }
 367 }
 368
 369 void Application::allTorrentsFinished()
 370 {
 371     Preferences *const pref = Preferences::instance();
 372     bool isExit = pref->shutdownqBTWhenDownloadsComplete();
 373     bool isShutdown = pref->shutdownWhenDownloadsComplete();
 374     bool isSuspend = pref->suspendWhenDownloadsComplete();
 375     bool isHibernate = pref->hibernateWhenDownloadsComplete();
 376
 377     bool haveAction = isExit || isShutdown || isSuspend || isHibernate;
 378     if (!haveAction) return;
 379
 380     ShutdownDialogAction action = ShutdownDialogAction::Exit;
 381     if (isSuspend)
 382         action = ShutdownDialogAction::Suspend;
 383     else if (isHibernate)
 384         action = ShutdownDialogAction::Hibernate;
 385     else if (isShutdown)
 386         action = ShutdownDialogAction::Shutdown;
 387
 388 #ifndef DISABLE_GUI
 389     // ask confirm
 390     if ((action == ShutdownDialogAction::Exit) && (pref->dontConfirmAutoExit())) {
 391         // do nothing & skip confirm
 392     }
 393     else {
 394         if (!ShutdownConfirmDialog::askForConfirmation(m_window, action)) return;
 395     }
 396 #endif // DISABLE_GUI
 397
 398     // Actually shut down
 399     if (action != ShutdownDialogAction::Exit) {
 400         qDebug("Preparing for auto-shutdown because all downloads are complete!");
 401         // Disabling it for next time
 402         pref->setShutdownWhenDownloadsComplete(false);
 403         pref->setSuspendWhenDownloadsComplete(false);
 404         pref->setHibernateWhenDownloadsComplete(false);
 405         // Make sure preferences are synced before exiting
 406         m_shutdownAct = action;
 407     }
 408
 409     qDebug("Exiting the application");
 410     exit();
 411 }
 412
 413 bool Application::sendParams(const QStringList &params)
 414 {
 415     return sendMessage(params.join(PARAMS_SEPARATOR));
 416 }
 417
 418 // As program parameters, we can get paths or urls.
 419 // This function parse the parameters and call
 420 // the right addTorrent function, considering
 421 // the parameter type.
 422 void Application::processParams(const QStringList &params)
 423 {
 424 #ifndef DISABLE_GUI
 425     if (params.isEmpty()) {
 426         m_window->activate(); // show UI
 427         return;
 428     }
 429 #endif
 430     BitTorrent::AddTorrentParams torrentParams;
 431     TriStateBool skipTorrentDialog;
 432
 433     for (QString param : params) {
 434         param = param.trimmed();
 435
 436         // Process strings indicating options specified by the user.
 437
 438         if (param.startsWith(QLatin1String("@savePath="))) {
 439             torrentParams.savePath = param.mid(10);
 440             continue;
 441         }
 442
 443         if (param.startsWith(QLatin1String("@addPaused="))) {
 444             torrentParams.addPaused = param.midRef(11).toInt() ? TriStateBool::True : TriStateBool::False;
 445             continue;
 446         }
 447
 448         if (param == QLatin1String("@skipChecking")) {
 449             torrentParams.skipChecking = true;
 450             continue;
 451         }
 452
 453         if (param.startsWith(QLatin1String("@category="))) {
 454             torrentParams.category = param.mid(10);
 455             continue;
 456         }
 457
 458         if (param == QLatin1String("@sequential")) {
 459             torrentParams.sequential = true;
 460             continue;
 461         }
 462
 463         if (param == QLatin1String("@firstLastPiecePriority")) {
 464             torrentParams.firstLastPiecePriority = true;
 465             continue;
 466         }
 467
 468         if (param.startsWith(QLatin1String("@skipDialog="))) {
 469             skipTorrentDialog = param.midRef(12).toInt() ? TriStateBool::True : TriStateBool::False;
 470             continue;
 471         }
 472
 473 #ifndef DISABLE_GUI
 474         // There are two circumstances in which we want to show the torrent
 475         // dialog. One is when the application settings specify that it should
 476         // be shown and skipTorrentDialog is undefined. The other is when
 477         // skipTorrentDialog is false, meaning that the application setting
 478         // should be overridden.
 479         const bool showDialogForThisTorrent =
 480             ((AddNewTorrentDialog::isEnabled() && skipTorrentDialog == TriStateBool::Undefined)
 481              || skipTorrentDialog == TriStateBool::False);
 482         if (showDialogForThisTorrent)
 483             AddNewTorrentDialog::show(param, torrentParams, m_window);
 484         else
 485 #endif
 486             BitTorrent::Session::instance()->addTorrent(param, torrentParams);
 487     }
 488 }
 489
 490 int Application::exec(const QStringList &params)
 491 {
 492     Net::ProxyConfigurationManager::initInstance();
 493     Net::DownloadManager::initInstance();
 494 #ifdef DISABLE_GUI
 495     IconProvider::initInstance();
 496 #else
 497     GuiIconProvider::initInstance();
 498 #endif
 499
 500     try {
 501         BitTorrent::Session::initInstance();
 502         connect(BitTorrent::Session::instance(), &BitTorrent::Session::torrentFinished, this, &Application::torrentFinished);
 503         connect(BitTorrent::Session::instance(), &BitTorrent::Session::allTorrentsFinished, this, &Application::allTorrentsFinished, Qt::QueuedConnection);
 504
 505 #ifndef DISABLE_COUNTRIES_RESOLUTION
 506         Net::GeoIPManager::initInstance();
 507 #endif
 508         ScanFoldersModel::initInstance(this);
 509
 510 #ifndef DISABLE_WEBUI
 511         m_webui = new WebUI;
 512 #ifdef DISABLE_GUI
 513         if (m_webui->isErrored())
 514             return 1;
 515         connect(m_webui, &WebUI::fatalError, this, []() { QCoreApplication::exit(1); });
 516 #endif // DISABLE_GUI
 517 #endif // DISABLE_WEBUI
 518
 519         new RSS::Session; // create RSS::Session singleton
 520         new RSS::AutoDownloader; // create RSS::AutoDownloader singleton
 521     }
 522     catch (const RuntimeError &err) {
 523 #ifdef DISABLE_GUI
 524         fprintf(stderr, "%s", err.what());
 525 #else
 526         QMessageBox msgBox;
 527         msgBox.setIcon(QMessageBox::Critical);
 528         msgBox.setText(tr("Application failed to start."));
 529         msgBox.setInformativeText(err.message());
 530         msgBox.show(); // Need to be shown or to moveToCenter does not work
 531         msgBox.move(Utils::Misc::screenCenter(&msgBox));
 532         msgBox.exec();
 533 #endif
 534         return 1;
 535     }
 536
 537 #ifdef DISABLE_GUI
 538 #ifndef DISABLE_WEBUI
 539     Preferences *const pref = Preferences::instance();
 540     // Display some information to the user
 541     const QString mesg = QString("\n******** %1 ********\n").arg(tr("Information"))
 542         + tr("To control qBittorrent, access the Web UI at %1")
 543             .arg(QString("http://localhost:") + QString::number(pref->getWebUiPort())) + '\n';
 544     printf("%s", qUtf8Printable(mesg));
 545
 546     if (pref->getWebUIPassword() == "ARQ77eY1NUZaQsuDHbIMCA==:0WMRkYTUWVT9wVvdDtHAjU9b3b7uB8NR1Gur2hmQCvCDpm39Q+PsJRJPaCU51dEiz+dTzh8qbPsL8WkFljQYFQ==") {
 547         const QString warning = tr("The Web UI administrator username is: %1").arg(pref->getWebUiUsername()) + '\n'
 548             + tr("The Web UI administrator password is still the default one: %1").arg("adminadmin") + '\n'
 549             + tr("This is a security risk, please consider changing your password from program preferences.") + '\n';
 550         printf("%s", qUtf8Printable(warning));
 551     }
 552 #endif // DISABLE_WEBUI
 553 #else
 554     m_window = new MainWindow;
 555 #endif // DISABLE_GUI
 556
 557     m_running = true;
 558
 559     // Now UI is ready to process signals from Session
 560     BitTorrent::Session::instance()->startUpTorrents();
 561
 562     m_paramsQueue = params + m_paramsQueue;
 563     if (!m_paramsQueue.isEmpty()) {
 564         processParams(m_paramsQueue);
 565         m_paramsQueue.clear();
 566     }
 567     return BaseApplication::exec();
 568 }
 569
 570 #ifndef DISABLE_GUI
 571 #ifdef Q_OS_WIN
 572 bool Application::isRunning()
 573 {
 574     bool running = BaseApplication::isRunning();
 575     QSharedMemory *sharedMem = new QSharedMemory(id() + QLatin1String("-shared-memory-key"), this);
 576     if (!running) {
 577         // First instance creates shared memory and store PID
 578         if (sharedMem->create(sizeof(DWORD)) && sharedMem->lock()) {
 579             *(static_cast<DWORD*>(sharedMem->data())) = ::GetCurrentProcessId();
 580             sharedMem->unlock();
 581         }
 582     }
 583     else {
 584         // Later instances attach to shared memory and retrieve PID
 585         if (sharedMem->attach() && sharedMem->lock()) {
 586             ::AllowSetForegroundWindow(*(static_cast<DWORD*>(sharedMem->data())));
 587             sharedMem->unlock();
 588         }
 589     }
 590
 591     if (!sharedMem->isAttached())
 592         qWarning() << "Failed to initialize shared memory: " << sharedMem->errorString();
 593
 594     return running;
 595 }
 596 #endif // Q_OS_WIN
 597
 598 #ifdef Q_OS_MAC
 599 bool Application::event(QEvent *ev)
 600 {
 601     if (ev->type() == QEvent::FileOpen) {
 602         QString path = static_cast<QFileOpenEvent *>(ev)->file();
 603         if (path.isEmpty())
 604             // Get the url instead
 605             path = static_cast<QFileOpenEvent *>(ev)->url().toString();
 606         qDebug("Received a mac file open event: %s", qUtf8Printable(path));
 607         if (m_running)
 608             processParams(QStringList(path));
 609         else
 610             m_paramsQueue.append(path);
 611         return true;
 612     }
 613     else {
 614         return BaseApplication::event(ev);
 615     }
 616 }
 617 #endif // Q_OS_MAC
 618
 619 bool Application::notify(QObject *receiver, QEvent *event)
 620 {
 621     try {
 622         return QApplication::notify(receiver, event);
 623     }
 624     catch (const std::exception &e) {
 625         qCritical() << "Exception thrown:" << e.what() << ", receiver: " << receiver->objectName();
 626         receiver->dumpObjectInfo();
 627     }
 628
 629     return false;
 630 }
 631 #endif // DISABLE_GUI
 632
 633 void Application::initializeTranslation()
 634 {
 635     Preferences *const pref = Preferences::instance();
 636     // Load translation
 637     QString localeStr = pref->getLocale();
 638
 639     if (m_qtTranslator.load(QLatin1String("qtbase_") + localeStr, QLibraryInfo::location(QLibraryInfo::TranslationsPath)) ||
 640         m_qtTranslator.load(QLatin1String("qt_") + localeStr, QLibraryInfo::location(QLibraryInfo::TranslationsPath)))
 641             qDebug("Qt %s locale recognized, using translation.", qUtf8Printable(localeStr));
 642     else
 643         qDebug("Qt %s locale unrecognized, using default (en).", qUtf8Printable(localeStr));
 644
 645     installTranslator(&m_qtTranslator);
 646
 647     if (m_translator.load(QLatin1String(":/lang/qbittorrent_") + localeStr))
 648         qDebug("%s locale recognized, using translation.", qUtf8Printable(localeStr));
 649     else
 650         qDebug("%s locale unrecognized, using default (en).", qUtf8Printable(localeStr));
 651     installTranslator(&m_translator);
 652
 653 #ifndef DISABLE_GUI
 654     if (localeStr.startsWith("ar") || localeStr.startsWith("he")) {
 655         qDebug("Right to Left mode");
 656         setLayoutDirection(Qt::RightToLeft);
 657     }
 658     else {
 659         setLayoutDirection(Qt::LeftToRight);
 660     }
 661 #endif
 662 }
 663
 664 #if (!defined(DISABLE_GUI) && defined(Q_OS_WIN))
 665 void Application::shutdownCleanup(QSessionManager &manager)
 666 {
 667     Q_UNUSED(manager);
 668
 669     // This is only needed for a special case on Windows XP.
 670     // (but is called for every Windows version)
 671     // If a process takes too much time to exit during OS
 672     // shutdown, the OS presents a dialog to the user.
 673     // That dialog tells the user that qbt is blocking the
 674     // shutdown, it shows a progress bar and it offers
 675     // a "Terminate Now" button for the user. However,
 676     // after the progress bar has reached 100% another button
 677     // is offered to the user reading "Cancel". With this the
 678     // user can cancel the **OS** shutdown. If we don't do
 679     // the cleanup by handling the commitDataRequest() signal
 680     // and the user clicks "Cancel", it will result in qbt being
 681     // killed and the shutdown proceeding instead. Apparently
 682     // aboutToQuit() is emitted too late in the shutdown process.
 683     cleanup();
 684
 685     // According to the qt docs we shouldn't call quit() inside a slot.
 686     // aboutToQuit() is never emitted if the user hits "Cancel" in
 687     // the above dialog.
 688     QTimer::singleShot(0, qApp, &QCoreApplication::quit);
 689 }
 690 #endif
 691
 692 void Application::cleanup()
 693 {
 694     // cleanup() can be called multiple times during shutdown. We only need it once.
 695     static QAtomicInt alreadyDone;
 696     if (!alreadyDone.testAndSetAcquire(0, 1))
 697         return;
 698
 699 #ifndef DISABLE_GUI
 700     if (m_window) {
 701         // Hide the window and don't leave it on screen as
 702         // unresponsive. Also for Windows take the WinId
 703         // after it's hidden, because hide() may cause a
 704         // WinId change.
 705         m_window->hide();
 706
 707 #ifdef Q_OS_WIN
 708         typedef BOOL (WINAPI *PSHUTDOWNBRCREATE)(HWND, LPCWSTR);
 709         const auto shutdownBRCreate = Utils::Misc::loadWinAPI<PSHUTDOWNBRCREATE>("User32.dll", "ShutdownBlockReasonCreate");
 710         // Only available on Vista+
 711         if (shutdownBRCreate)
 712             shutdownBRCreate((HWND)m_window->effectiveWinId(), tr("Saving torrent progress...").toStdWString().c_str());
 713 #endif // Q_OS_WIN
 714
 715         // Do manual cleanup in MainWindow to force widgets
 716         // to save their Preferences, stop all timers and
 717         // delete as many widgets as possible to leave only
 718         // a 'shell' MainWindow.
 719         // We need a valid window handle for Windows Vista+
 720         // otherwise the system shutdown will continue even
 721         // though we created a ShutdownBlockReason
 722         m_window->cleanup();
 723     }
 724 #endif // DISABLE_GUI
 725
 726 #ifndef DISABLE_WEBUI
 727     delete m_webui;
 728 #endif
 729
 730     delete RSS::AutoDownloader::instance();
 731     delete RSS::Session::instance();
 732
 733     ScanFoldersModel::freeInstance();
 734     BitTorrent::Session::freeInstance();
 735 #ifndef DISABLE_COUNTRIES_RESOLUTION
 736     Net::GeoIPManager::freeInstance();
 737 #endif
 738     Net::DownloadManager::freeInstance();
 739     Net::ProxyConfigurationManager::freeInstance();
 740     Preferences::freeInstance();
 741     SettingsStorage::freeInstance();
 742     delete m_fileLogger;
 743     Logger::freeInstance();
 744     IconProvider::freeInstance();
 745     SearchPluginManager::freeInstance();
 746     Utils::Fs::removeDirRecursive(Utils::Fs::tempPath());
 747
 748 #ifndef DISABLE_GUI
 749     if (m_window) {
 750 #ifdef Q_OS_WIN
 751         typedef BOOL (WINAPI *PSHUTDOWNBRDESTROY)(HWND);
 752         const auto shutdownBRDestroy = Utils::Misc::loadWinAPI<PSHUTDOWNBRDESTROY>("User32.dll", "ShutdownBlockReasonDestroy");
 753         // Only available on Vista+
 754         if (shutdownBRDestroy)
 755             shutdownBRDestroy((HWND)m_window->effectiveWinId());
 756 #endif // Q_OS_WIN
 757         delete m_window;
 758     }
 759 #endif // DISABLE_GUI
 760
 761     if (m_shutdownAct != ShutdownDialogAction::Exit) {
 762         qDebug() << "Sending computer shutdown/suspend/hibernate signal...";
 763         Utils::Misc::shutdownComputer(m_shutdownAct);
 764     }
 765 }
 766
 767 void Application::validateCommandLineParameters()
 768 {
 769     if (m_commandLineArgs.portableMode && !m_commandLineArgs.profileDir.isEmpty())
 770         throw CommandLineParameterError(tr("Portable mode and explicit profile directory options are mutually exclusive"));
 771
 772     if (m_commandLineArgs.portableMode && m_commandLineArgs.relativeFastresumePaths)
 773         Logger::instance()->addMessage(tr("Portable mode implies relative fastresume"), Log::WARNING);
 774 }