src/base/bittorrent/sessionimpl.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015-2023  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 "sessionimpl.h"
  31
  32 #include <algorithm>
  33 #include <chrono>
  34 #include <cstdint>
  35 #include <ctime>
  36 #include <queue>
  37 #include <string>
  38
  39 #ifdef Q_OS_WIN
  40 #include <Windows.h>
  41 #include <wincrypt.h>
  42 #include <iphlpapi.h>
  43 #endif
  44
  45 #include <boost/asio/ip/tcp.hpp>
  46
  47 #include <libtorrent/add_torrent_params.hpp>
  48 #include <libtorrent/address.hpp>
  49 #include <libtorrent/alert_types.hpp>
  50 #include <libtorrent/error_code.hpp>
  51 #include <libtorrent/extensions/smart_ban.hpp>
  52 #include <libtorrent/extensions/ut_metadata.hpp>
  53 #include <libtorrent/extensions/ut_pex.hpp>
  54 #include <libtorrent/ip_filter.hpp>
  55 #include <libtorrent/magnet_uri.hpp>
  56 #include <libtorrent/session.hpp>
  57 #include <libtorrent/session_stats.hpp>
  58 #include <libtorrent/session_status.hpp>
  59 #include <libtorrent/torrent_info.hpp>
  60
  61 #include <QDebug>
  62 #include <QDir>
  63 #include <QFile>
  64 #include <QHostAddress>
  65 #include <QJsonArray>
  66 #include <QJsonDocument>
  67 #include <QJsonObject>
  68 #include <QJsonValue>
  69 #include <QNetworkAddressEntry>
  70 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
  71 #include <QNetworkConfigurationManager>
  72 #endif
  73 #include <QNetworkInterface>
  74 #include <QRegularExpression>
  75 #include <QString>
  76 #include <QThread>
  77 #include <QThreadPool>
  78 #include <QTimer>
  79 #include <QUuid>
  80
  81 #include "base/algorithm.h"
  82 #include "base/global.h"
  83 #include "base/logger.h"
  84 #include "base/net/downloadmanager.h"
  85 #include "base/net/proxyconfigurationmanager.h"
  86 #include "base/preferences.h"
  87 #include "base/profile.h"
  88 #include "base/torrentfileguard.h"
  89 #include "base/torrentfilter.h"
  90 #include "base/unicodestrings.h"
  91 #include "base/utils/bytearray.h"
  92 #include "base/utils/fs.h"
  93 #include "base/utils/io.h"
  94 #include "base/utils/misc.h"
  95 #include "base/utils/net.h"
  96 #include "base/utils/random.h"
  97 #include "base/version.h"
  98 #include "bandwidthscheduler.h"
  99 #include "bencoderesumedatastorage.h"
 100 #include "common.h"
 101 #include "customstorage.h"
 102 #include "dbresumedatastorage.h"
 103 #include "downloadpriority.h"
 104 #include "extensiondata.h"
 105 #include "filesearcher.h"
 106 #include "filterparserthread.h"
 107 #include "loadtorrentparams.h"
 108 #include "lttypecast.h"
 109 #include "magneturi.h"
 110 #include "nativesessionextension.h"
 111 #include "portforwarderimpl.h"
 112 #include "resumedatastorage.h"
 113 #include "torrentimpl.h"
 114 #include "tracker.h"
 115
 116 using namespace std::chrono_literals;
 117 using namespace BitTorrent;
 118
 119 const Path CATEGORIES_FILE_NAME {u"categories.json"_qs};
 120 const int MAX_PROCESSING_RESUMEDATA_COUNT = 50;
 121 const int STATISTICS_SAVE_INTERVAL = std::chrono::milliseconds(15min).count();
 122
 123 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 124 namespace std
 125 {
 126     uint qHash(const std::string &key, uint seed = 0)
 127     {
 128         return ::qHash(std::hash<std::string> {}(key), seed);
 129     }
 130 }
 131
 132 namespace libtorrent
 133 {
 134     uint qHash(const libtorrent::torrent_handle &key)
 135     {
 136         return static_cast<uint>(libtorrent::hash_value(key));
 137     }
 138 }
 139 #endif
 140
 141 namespace
 142 {
 143     const char PEER_ID[] = "qB";
 144     const auto USER_AGENT = QStringLiteral("qBittorrent/" QBT_VERSION_2);
 145
 146     void torrentQueuePositionUp(const lt::torrent_handle &handle)
 147     {
 148         try
 149         {
 150             handle.queue_position_up();
 151         }
 152         catch (const std::exception &exc)
 153         {
 154             qDebug() << Q_FUNC_INFO << " fails: " << exc.what();
 155         }
 156     }
 157
 158     void torrentQueuePositionDown(const lt::torrent_handle &handle)
 159     {
 160         try
 161         {
 162             handle.queue_position_down();
 163         }
 164         catch (const std::exception &exc)
 165         {
 166             qDebug() << Q_FUNC_INFO << " fails: " << exc.what();
 167         }
 168     }
 169
 170     void torrentQueuePositionTop(const lt::torrent_handle &handle)
 171     {
 172         try
 173         {
 174             handle.queue_position_top();
 175         }
 176         catch (const std::exception &exc)
 177         {
 178             qDebug() << Q_FUNC_INFO << " fails: " << exc.what();
 179         }
 180     }
 181
 182     void torrentQueuePositionBottom(const lt::torrent_handle &handle)
 183     {
 184         try
 185         {
 186             handle.queue_position_bottom();
 187         }
 188         catch (const std::exception &exc)
 189         {
 190             qDebug() << Q_FUNC_INFO << " fails: " << exc.what();
 191         }
 192     }
 193
 194     QMap<QString, CategoryOptions> expandCategories(const QMap<QString, CategoryOptions> &categories)
 195     {
 196         QMap<QString, CategoryOptions> expanded = categories;
 197
 198         for (auto i = categories.cbegin(); i != categories.cend(); ++i)
 199         {
 200             const QString &category = i.key();
 201             for (const QString &subcat : asConst(Session::expandCategory(category)))
 202             {
 203                 if (!expanded.contains(subcat))
 204                     expanded[subcat] = {};
 205             }
 206         }
 207
 208         return expanded;
 209     }
 210
 211     QString toString(const lt::socket_type_t socketType)
 212     {
 213         switch (socketType)
 214         {
 215 #ifdef QBT_USES_LIBTORRENT2
 216         case lt::socket_type_t::http:
 217             return u"HTTP"_qs;
 218         case lt::socket_type_t::http_ssl:
 219             return u"HTTP_SSL"_qs;
 220 #endif
 221         case lt::socket_type_t::i2p:
 222             return u"I2P"_qs;
 223         case lt::socket_type_t::socks5:
 224             return u"SOCKS5"_qs;
 225 #ifdef QBT_USES_LIBTORRENT2
 226         case lt::socket_type_t::socks5_ssl:
 227             return u"SOCKS5_SSL"_qs;
 228 #endif
 229         case lt::socket_type_t::tcp:
 230             return u"TCP"_qs;
 231         case lt::socket_type_t::tcp_ssl:
 232             return u"TCP_SSL"_qs;
 233 #ifdef QBT_USES_LIBTORRENT2
 234         case lt::socket_type_t::utp:
 235             return u"UTP"_qs;
 236 #else
 237         case lt::socket_type_t::udp:
 238             return u"UDP"_qs;
 239 #endif
 240         case lt::socket_type_t::utp_ssl:
 241             return u"UTP_SSL"_qs;
 242         }
 243         return u"INVALID"_qs;
 244     }
 245
 246     QString toString(const lt::address &address)
 247     {
 248         try
 249         {
 250             return QString::fromLatin1(address.to_string().c_str());
 251         }
 252         catch (const std::exception &)
 253         {
 254             // suppress conversion error
 255         }
 256         return {};
 257     }
 258
 259     template <typename T>
 260     struct LowerLimited
 261     {
 262         LowerLimited(T limit, T ret)
 263             : m_limit(limit)
 264             , m_ret(ret)
 265         {
 266         }
 267
 268         explicit LowerLimited(T limit)
 269             : LowerLimited(limit, limit)
 270         {
 271         }
 272
 273         T operator()(T val) const
 274         {
 275             return val <= m_limit ? m_ret : val;
 276         }
 277
 278     private:
 279         const T m_limit;
 280         const T m_ret;
 281     };
 282
 283     template <typename T>
 284     LowerLimited<T> lowerLimited(T limit) { return LowerLimited<T>(limit); }
 285
 286     template <typename T>
 287     LowerLimited<T> lowerLimited(T limit, T ret) { return LowerLimited<T>(limit, ret); }
 288
 289     template <typename T>
 290     auto clampValue(const T lower, const T upper)
 291     {
 292         return [lower, upper](const T value) -> T
 293         {
 294             if (value < lower)
 295                 return lower;
 296             if (value > upper)
 297                 return upper;
 298             return value;
 299         };
 300     }
 301
 302 #ifdef Q_OS_WIN
 303     QString convertIfaceNameToGuid(const QString &name)
 304     {
 305         // Under Windows XP or on Qt version <= 5.5 'name' will be a GUID already.
 306         const QUuid uuid(name);
 307         if (!uuid.isNull())
 308             return uuid.toString().toUpper(); // Libtorrent expects the GUID in uppercase
 309
 310         const std::wstring nameWStr = name.toStdWString();
 311         NET_LUID luid {};
 312         const LONG res = ::ConvertInterfaceNameToLuidW(nameWStr.c_str(), &luid);
 313         if (res == 0)
 314         {
 315             GUID guid;
 316             if (::ConvertInterfaceLuidToGuid(&luid, &guid) == 0)
 317                 return QUuid(guid).toString().toUpper();
 318         }
 319
 320         return {};
 321     }
 322 #endif
 323
 324     constexpr lt::move_flags_t toNative(const MoveStorageMode mode)
 325     {
 326         switch (mode)
 327         {
 328         default:
 329             Q_ASSERT(false);
 330         case MoveStorageMode::FailIfExist:
 331             return lt::move_flags_t::fail_if_exist;
 332         case MoveStorageMode::KeepExistingFiles:
 333             return lt::move_flags_t::dont_replace;
 334         case MoveStorageMode::Overwrite:
 335             return lt::move_flags_t::always_replace_files;
 336         }
 337     }
 338 }
 339
 340 struct BitTorrent::SessionImpl::ResumeSessionContext final : public QObject
 341 {
 342     using QObject::QObject;
 343
 344     ResumeDataStorage *startupStorage = nullptr;
 345     ResumeDataStorageType currentStorageType = ResumeDataStorageType::Legacy;
 346     QList<LoadedResumeData> loadedResumeData;
 347     int processingResumeDataCount = 0;
 348     int64_t totalResumeDataCount = 0;
 349     int64_t finishedResumeDataCount = 0;
 350     bool isLoadFinished = false;
 351     bool isLoadedResumeDataHandlingEnqueued = false;
 352     QSet<QString> recoveredCategories;
 353 #ifdef QBT_USES_LIBTORRENT2
 354     QSet<TorrentID> indexedTorrents;
 355     QSet<TorrentID> skippedIDs;
 356 #endif
 357 };
 358
 359 const int addTorrentParamsId = qRegisterMetaType<AddTorrentParams>();
 360
 361 Session *SessionImpl::m_instance = nullptr;
 362
 363 void Session::initInstance()
 364 {
 365     if (!SessionImpl::m_instance)
 366         SessionImpl::m_instance = new SessionImpl;
 367 }
 368
 369 void Session::freeInstance()
 370 {
 371     delete SessionImpl::m_instance;
 372     SessionImpl::m_instance = nullptr;
 373 }
 374
 375 Session *Session::instance()
 376 {
 377     return SessionImpl::m_instance;
 378 }
 379
 380 bool Session::isValidCategoryName(const QString &name)
 381 {
 382     const QRegularExpression re {uR"(^([^\\\/]|[^\\\/]([^\\\/]|\/(?=[^\/]))*[^\\\/])$)"_qs};
 383     return (name.isEmpty() || (name.indexOf(re) == 0));
 384 }
 385
 386 bool Session::isValidTag(const QString &tag)
 387 {
 388     return (!tag.trimmed().isEmpty() && !tag.contains(u','));
 389 }
 390
 391 QStringList Session::expandCategory(const QString &category)
 392 {
 393     QStringList result;
 394     int index = 0;
 395     while ((index = category.indexOf(u'/', index)) >= 0)
 396     {
 397         result << category.left(index);
 398         ++index;
 399     }
 400     result << category;
 401
 402     return result;
 403 }
 404
 405 #define BITTORRENT_KEY(name) u"BitTorrent/" name
 406 #define BITTORRENT_SESSION_KEY(name) BITTORRENT_KEY(u"Session/") name
 407
 408 SessionImpl::SessionImpl(QObject *parent)
 409     : Session(parent)
 410     , m_isDHTEnabled(BITTORRENT_SESSION_KEY(u"DHTEnabled"_qs), true)
 411     , m_isLSDEnabled(BITTORRENT_SESSION_KEY(u"LSDEnabled"_qs), true)
 412     , m_isPeXEnabled(BITTORRENT_SESSION_KEY(u"PeXEnabled"_qs), true)
 413     , m_isIPFilteringEnabled(BITTORRENT_SESSION_KEY(u"IPFilteringEnabled"_qs), false)
 414     , m_isTrackerFilteringEnabled(BITTORRENT_SESSION_KEY(u"TrackerFilteringEnabled"_qs), false)
 415     , m_IPFilterFile(BITTORRENT_SESSION_KEY(u"IPFilter"_qs))
 416     , m_announceToAllTrackers(BITTORRENT_SESSION_KEY(u"AnnounceToAllTrackers"_qs), false)
 417     , m_announceToAllTiers(BITTORRENT_SESSION_KEY(u"AnnounceToAllTiers"_qs), true)
 418     , m_asyncIOThreads(BITTORRENT_SESSION_KEY(u"AsyncIOThreadsCount"_qs), 10)
 419     , m_hashingThreads(BITTORRENT_SESSION_KEY(u"HashingThreadsCount"_qs), 1)
 420     , m_filePoolSize(BITTORRENT_SESSION_KEY(u"FilePoolSize"_qs), 500)
 421     , m_checkingMemUsage(BITTORRENT_SESSION_KEY(u"CheckingMemUsageSize"_qs), 32)
 422     , m_diskCacheSize(BITTORRENT_SESSION_KEY(u"DiskCacheSize"_qs), -1)
 423     , m_diskCacheTTL(BITTORRENT_SESSION_KEY(u"DiskCacheTTL"_qs), 60)
 424     , m_diskQueueSize(BITTORRENT_SESSION_KEY(u"DiskQueueSize"_qs), (1024 * 1024))
 425     , m_diskIOType(BITTORRENT_SESSION_KEY(u"DiskIOType"_qs), DiskIOType::Default)
 426     , m_diskIOReadMode(BITTORRENT_SESSION_KEY(u"DiskIOReadMode"_qs), DiskIOReadMode::EnableOSCache)
 427     , m_diskIOWriteMode(BITTORRENT_SESSION_KEY(u"DiskIOWriteMode"_qs), DiskIOWriteMode::EnableOSCache)
 428 #ifdef Q_OS_WIN
 429     , m_coalesceReadWriteEnabled(BITTORRENT_SESSION_KEY(u"CoalesceReadWrite"_qs), true)
 430 #else
 431     , m_coalesceReadWriteEnabled(BITTORRENT_SESSION_KEY(u"CoalesceReadWrite"_qs), false)
 432 #endif
 433     , m_usePieceExtentAffinity(BITTORRENT_SESSION_KEY(u"PieceExtentAffinity"_qs), false)
 434     , m_isSuggestMode(BITTORRENT_SESSION_KEY(u"SuggestMode"_qs), false)
 435     , m_sendBufferWatermark(BITTORRENT_SESSION_KEY(u"SendBufferWatermark"_qs), 500)
 436     , m_sendBufferLowWatermark(BITTORRENT_SESSION_KEY(u"SendBufferLowWatermark"_qs), 10)
 437     , m_sendBufferWatermarkFactor(BITTORRENT_SESSION_KEY(u"SendBufferWatermarkFactor"_qs), 50)
 438     , m_connectionSpeed(BITTORRENT_SESSION_KEY(u"ConnectionSpeed"_qs), 30)
 439     , m_socketSendBufferSize(BITTORRENT_SESSION_KEY(u"SocketSendBufferSize"_qs), 0)
 440     , m_socketReceiveBufferSize(BITTORRENT_SESSION_KEY(u"SocketReceiveBufferSize"_qs), 0)
 441     , m_socketBacklogSize(BITTORRENT_SESSION_KEY(u"SocketBacklogSize"_qs), 30)
 442     , m_isAnonymousModeEnabled(BITTORRENT_SESSION_KEY(u"AnonymousModeEnabled"_qs), false)
 443     , m_isQueueingEnabled(BITTORRENT_SESSION_KEY(u"QueueingSystemEnabled"_qs), false)
 444     , m_maxActiveDownloads(BITTORRENT_SESSION_KEY(u"MaxActiveDownloads"_qs), 3, lowerLimited(-1))
 445     , m_maxActiveUploads(BITTORRENT_SESSION_KEY(u"MaxActiveUploads"_qs), 3, lowerLimited(-1))
 446     , m_maxActiveTorrents(BITTORRENT_SESSION_KEY(u"MaxActiveTorrents"_qs), 5, lowerLimited(-1))
 447     , m_ignoreSlowTorrentsForQueueing(BITTORRENT_SESSION_KEY(u"IgnoreSlowTorrentsForQueueing"_qs), false)
 448     , m_downloadRateForSlowTorrents(BITTORRENT_SESSION_KEY(u"SlowTorrentsDownloadRate"_qs), 2)
 449     , m_uploadRateForSlowTorrents(BITTORRENT_SESSION_KEY(u"SlowTorrentsUploadRate"_qs), 2)
 450     , m_slowTorrentsInactivityTimer(BITTORRENT_SESSION_KEY(u"SlowTorrentsInactivityTimer"_qs), 60)
 451     , m_outgoingPortsMin(BITTORRENT_SESSION_KEY(u"OutgoingPortsMin"_qs), 0)
 452     , m_outgoingPortsMax(BITTORRENT_SESSION_KEY(u"OutgoingPortsMax"_qs), 0)
 453     , m_UPnPLeaseDuration(BITTORRENT_SESSION_KEY(u"UPnPLeaseDuration"_qs), 0)
 454     , m_peerToS(BITTORRENT_SESSION_KEY(u"PeerToS"_qs), 0x04)
 455     , m_ignoreLimitsOnLAN(BITTORRENT_SESSION_KEY(u"IgnoreLimitsOnLAN"_qs), false)
 456     , m_includeOverheadInLimits(BITTORRENT_SESSION_KEY(u"IncludeOverheadInLimits"_qs), false)
 457     , m_announceIP(BITTORRENT_SESSION_KEY(u"AnnounceIP"_qs))
 458     , m_maxConcurrentHTTPAnnounces(BITTORRENT_SESSION_KEY(u"MaxConcurrentHTTPAnnounces"_qs), 50)
 459     , m_isReannounceWhenAddressChangedEnabled(BITTORRENT_SESSION_KEY(u"ReannounceWhenAddressChanged"_qs), false)
 460     , m_stopTrackerTimeout(BITTORRENT_SESSION_KEY(u"StopTrackerTimeout"_qs), 5)
 461     , m_maxConnections(BITTORRENT_SESSION_KEY(u"MaxConnections"_qs), 500, lowerLimited(0, -1))
 462     , m_maxUploads(BITTORRENT_SESSION_KEY(u"MaxUploads"_qs), 20, lowerLimited(0, -1))
 463     , m_maxConnectionsPerTorrent(BITTORRENT_SESSION_KEY(u"MaxConnectionsPerTorrent"_qs), 100, lowerLimited(0, -1))
 464     , m_maxUploadsPerTorrent(BITTORRENT_SESSION_KEY(u"MaxUploadsPerTorrent"_qs), 4, lowerLimited(0, -1))
 465     , m_btProtocol(BITTORRENT_SESSION_KEY(u"BTProtocol"_qs), BTProtocol::Both
 466         , clampValue(BTProtocol::Both, BTProtocol::UTP))
 467     , m_isUTPRateLimited(BITTORRENT_SESSION_KEY(u"uTPRateLimited"_qs), true)
 468     , m_utpMixedMode(BITTORRENT_SESSION_KEY(u"uTPMixedMode"_qs), MixedModeAlgorithm::TCP
 469         , clampValue(MixedModeAlgorithm::TCP, MixedModeAlgorithm::Proportional))
 470     , m_IDNSupportEnabled(BITTORRENT_SESSION_KEY(u"IDNSupportEnabled"_qs), false)
 471     , m_multiConnectionsPerIpEnabled(BITTORRENT_SESSION_KEY(u"MultiConnectionsPerIp"_qs), false)
 472     , m_validateHTTPSTrackerCertificate(BITTORRENT_SESSION_KEY(u"ValidateHTTPSTrackerCertificate"_qs), true)
 473     , m_SSRFMitigationEnabled(BITTORRENT_SESSION_KEY(u"SSRFMitigation"_qs), true)
 474     , m_blockPeersOnPrivilegedPorts(BITTORRENT_SESSION_KEY(u"BlockPeersOnPrivilegedPorts"_qs), false)
 475     , m_isAddTrackersEnabled(BITTORRENT_SESSION_KEY(u"AddTrackersEnabled"_qs), false)
 476     , m_additionalTrackers(BITTORRENT_SESSION_KEY(u"AdditionalTrackers"_qs))
 477     , m_globalMaxRatio(BITTORRENT_SESSION_KEY(u"GlobalMaxRatio"_qs), -1, [](qreal r) { return r < 0 ? -1. : r;})
 478     , m_globalMaxSeedingMinutes(BITTORRENT_SESSION_KEY(u"GlobalMaxSeedingMinutes"_qs), -1, lowerLimited(-1))
 479     , m_isAddTorrentToQueueTop(BITTORRENT_SESSION_KEY(u"AddTorrentToTopOfQueue"_qs), false)
 480     , m_isAddTorrentPaused(BITTORRENT_SESSION_KEY(u"AddTorrentPaused"_qs), false)
 481     , m_torrentStopCondition(BITTORRENT_SESSION_KEY(u"TorrentStopCondition"_qs), Torrent::StopCondition::None)
 482     , m_torrentContentLayout(BITTORRENT_SESSION_KEY(u"TorrentContentLayout"_qs), TorrentContentLayout::Original)
 483     , m_isAppendExtensionEnabled(BITTORRENT_SESSION_KEY(u"AddExtensionToIncompleteFiles"_qs), false)
 484     , m_refreshInterval(BITTORRENT_SESSION_KEY(u"RefreshInterval"_qs), 1500)
 485     , m_isPreallocationEnabled(BITTORRENT_SESSION_KEY(u"Preallocation"_qs), false)
 486     , m_torrentExportDirectory(BITTORRENT_SESSION_KEY(u"TorrentExportDirectory"_qs))
 487     , m_finishedTorrentExportDirectory(BITTORRENT_SESSION_KEY(u"FinishedTorrentExportDirectory"_qs))
 488     , m_globalDownloadSpeedLimit(BITTORRENT_SESSION_KEY(u"GlobalDLSpeedLimit"_qs), 0, lowerLimited(0))
 489     , m_globalUploadSpeedLimit(BITTORRENT_SESSION_KEY(u"GlobalUPSpeedLimit"_qs), 0, lowerLimited(0))
 490     , m_altGlobalDownloadSpeedLimit(BITTORRENT_SESSION_KEY(u"AlternativeGlobalDLSpeedLimit"_qs), 10, lowerLimited(0))
 491     , m_altGlobalUploadSpeedLimit(BITTORRENT_SESSION_KEY(u"AlternativeGlobalUPSpeedLimit"_qs), 10, lowerLimited(0))
 492     , m_isAltGlobalSpeedLimitEnabled(BITTORRENT_SESSION_KEY(u"UseAlternativeGlobalSpeedLimit"_qs), false)
 493     , m_isBandwidthSchedulerEnabled(BITTORRENT_SESSION_KEY(u"BandwidthSchedulerEnabled"_qs), false)
 494     , m_isPerformanceWarningEnabled(BITTORRENT_SESSION_KEY(u"PerformanceWarning"_qs), false)
 495     , m_saveResumeDataInterval(BITTORRENT_SESSION_KEY(u"SaveResumeDataInterval"_qs), 60)
 496     , m_port(BITTORRENT_SESSION_KEY(u"Port"_qs), -1)
 497     , m_networkInterface(BITTORRENT_SESSION_KEY(u"Interface"_qs))
 498     , m_networkInterfaceName(BITTORRENT_SESSION_KEY(u"InterfaceName"_qs))
 499     , m_networkInterfaceAddress(BITTORRENT_SESSION_KEY(u"InterfaceAddress"_qs))
 500     , m_encryption(BITTORRENT_SESSION_KEY(u"Encryption"_qs), 0)
 501     , m_maxActiveCheckingTorrents(BITTORRENT_SESSION_KEY(u"MaxActiveCheckingTorrents"_qs), 1)
 502     , m_isProxyPeerConnectionsEnabled(BITTORRENT_SESSION_KEY(u"ProxyPeerConnections"_qs), false)
 503     , m_chokingAlgorithm(BITTORRENT_SESSION_KEY(u"ChokingAlgorithm"_qs), ChokingAlgorithm::FixedSlots
 504         , clampValue(ChokingAlgorithm::FixedSlots, ChokingAlgorithm::RateBased))
 505     , m_seedChokingAlgorithm(BITTORRENT_SESSION_KEY(u"SeedChokingAlgorithm"_qs), SeedChokingAlgorithm::FastestUpload
 506         , clampValue(SeedChokingAlgorithm::RoundRobin, SeedChokingAlgorithm::AntiLeech))
 507     , m_storedTags(BITTORRENT_SESSION_KEY(u"Tags"_qs))
 508     , m_maxRatioAction(BITTORRENT_SESSION_KEY(u"MaxRatioAction"_qs), Pause)
 509     , m_savePath(BITTORRENT_SESSION_KEY(u"DefaultSavePath"_qs), specialFolderLocation(SpecialFolder::Downloads))
 510     , m_downloadPath(BITTORRENT_SESSION_KEY(u"TempPath"_qs), (savePath() / Path(u"temp"_qs)))
 511     , m_isDownloadPathEnabled(BITTORRENT_SESSION_KEY(u"TempPathEnabled"_qs), false)
 512     , m_isSubcategoriesEnabled(BITTORRENT_SESSION_KEY(u"SubcategoriesEnabled"_qs), false)
 513     , m_useCategoryPathsInManualMode(BITTORRENT_SESSION_KEY(u"UseCategoryPathsInManualMode"_qs), false)
 514     , m_isAutoTMMDisabledByDefault(BITTORRENT_SESSION_KEY(u"DisableAutoTMMByDefault"_qs), true)
 515     , m_isDisableAutoTMMWhenCategoryChanged(BITTORRENT_SESSION_KEY(u"DisableAutoTMMTriggers/CategoryChanged"_qs), false)
 516     , m_isDisableAutoTMMWhenDefaultSavePathChanged(BITTORRENT_SESSION_KEY(u"DisableAutoTMMTriggers/DefaultSavePathChanged"_qs), true)
 517     , m_isDisableAutoTMMWhenCategorySavePathChanged(BITTORRENT_SESSION_KEY(u"DisableAutoTMMTriggers/CategorySavePathChanged"_qs), true)
 518     , m_isTrackerEnabled(BITTORRENT_KEY(u"TrackerEnabled"_qs), false)
 519     , m_peerTurnover(BITTORRENT_SESSION_KEY(u"PeerTurnover"_qs), 4)
 520     , m_peerTurnoverCutoff(BITTORRENT_SESSION_KEY(u"PeerTurnoverCutOff"_qs), 90)
 521     , m_peerTurnoverInterval(BITTORRENT_SESSION_KEY(u"PeerTurnoverInterval"_qs), 300)
 522     , m_requestQueueSize(BITTORRENT_SESSION_KEY(u"RequestQueueSize"_qs), 500)
 523     , m_isExcludedFileNamesEnabled(BITTORRENT_KEY(u"ExcludedFileNamesEnabled"_qs), false)
 524     , m_excludedFileNames(BITTORRENT_SESSION_KEY(u"ExcludedFileNames"_qs))
 525     , m_bannedIPs(u"State/BannedIPs"_qs, QStringList(), Algorithm::sorted<QStringList>)
 526     , m_resumeDataStorageType(BITTORRENT_SESSION_KEY(u"ResumeDataStorageType"_qs), ResumeDataStorageType::Legacy)
 527     , m_isI2PEnabled {BITTORRENT_SESSION_KEY(u"I2P/Enabled"_qs), false}
 528     , m_I2PAddress {BITTORRENT_SESSION_KEY(u"I2P/Address"_qs), u"127.0.0.1"_qs}
 529     , m_I2PPort {BITTORRENT_SESSION_KEY(u"I2P/Port"_qs), 7656}
 530     , m_I2PMixedMode {BITTORRENT_SESSION_KEY(u"I2P/MixedMode"_qs), false}
 531     , m_seedingLimitTimer {new QTimer(this)}
 532     , m_resumeDataTimer {new QTimer(this)}
 533     , m_ioThread {new QThread}
 534     , m_asyncWorker {new QThreadPool(this)}
 535     , m_recentErroredTorrentsTimer {new QTimer(this)}
 536 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 537     , m_networkManager {new QNetworkConfigurationManager(this)}
 538 #endif
 539 {
 540     // It is required to perform async access to libtorrent sequentially
 541     m_asyncWorker->setMaxThreadCount(1);
 542
 543     if (port() < 0)
 544         m_port = Utils::Random::rand(1024, 65535);
 545
 546     m_recentErroredTorrentsTimer->setSingleShot(true);
 547     m_recentErroredTorrentsTimer->setInterval(1s);
 548     connect(m_recentErroredTorrentsTimer, &QTimer::timeout
 549         , this, [this]() { m_recentErroredTorrents.clear(); });
 550
 551     m_seedingLimitTimer->setInterval(10s);
 552     connect(m_seedingLimitTimer, &QTimer::timeout, this, &SessionImpl::processShareLimits);
 553
 554     initializeNativeSession();
 555     configureComponents();
 556
 557     if (isBandwidthSchedulerEnabled())
 558         enableBandwidthScheduler();
 559
 560     loadCategories();
 561     if (isSubcategoriesEnabled())
 562     {
 563         // if subcategories support changed manually
 564         m_categories = expandCategories(m_categories);
 565     }
 566
 567     const QStringList storedTags = m_storedTags.get();
 568     m_tags = {storedTags.cbegin(), storedTags.cend()};
 569
 570     updateSeedingLimitTimer();
 571     populateAdditionalTrackers();
 572     if (isExcludedFileNamesEnabled())
 573         populateExcludedFileNamesRegExpList();
 574
 575     connect(Net::ProxyConfigurationManager::instance()
 576         , &Net::ProxyConfigurationManager::proxyConfigurationChanged
 577         , this, &SessionImpl::configureDeferred);
 578
 579 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 580     // Network configuration monitor
 581     connect(m_networkManager, &QNetworkConfigurationManager::onlineStateChanged, this, &SessionImpl::networkOnlineStateChanged);
 582     connect(m_networkManager, &QNetworkConfigurationManager::configurationAdded, this, &SessionImpl::networkConfigurationChange);
 583     connect(m_networkManager, &QNetworkConfigurationManager::configurationRemoved, this, &SessionImpl::networkConfigurationChange);
 584     connect(m_networkManager, &QNetworkConfigurationManager::configurationChanged, this, &SessionImpl::networkConfigurationChange);
 585 #endif
 586
 587     m_fileSearcher = new FileSearcher;
 588     m_fileSearcher->moveToThread(m_ioThread.get());
 589     connect(m_ioThread.get(), &QThread::finished, m_fileSearcher, &QObject::deleteLater);
 590     connect(m_fileSearcher, &FileSearcher::searchFinished, this, &SessionImpl::fileSearchFinished);
 591
 592     m_ioThread->start();
 593
 594     initMetrics();
 595     loadStatistics();
 596
 597     // initialize PortForwarder instance
 598     new PortForwarderImpl(this);
 599
 600     // start embedded tracker
 601     enableTracker(isTrackerEnabled());
 602
 603     prepareStartup();
 604 }
 605
 606 SessionImpl::~SessionImpl()
 607 {
 608     m_nativeSession->pause();
 609
 610     if (m_torrentsQueueChanged)
 611     {
 612         m_nativeSession->post_torrent_updates({});
 613         m_torrentsQueueChanged = false;
 614         m_needSaveTorrentsQueue = true;
 615     }
 616
 617     // Do some bittorrent related saving
 618     // After this, (ideally) no more important alerts will be generated/handled
 619     saveResumeData();
 620
 621     saveStatistics();
 622
 623     // We must delete FilterParserThread
 624     // before we delete lt::session
 625     delete m_filterParser;
 626
 627     // We must delete PortForwarderImpl before
 628     // we delete lt::session
 629     delete Net::PortForwarder::instance();
 630
 631     // We must stop "async worker" only after deletion
 632     // of all the components that could potentially use it
 633     m_asyncWorker->clear();
 634     m_asyncWorker->waitForDone();
 635
 636     qDebug("Deleting libtorrent session...");
 637     delete m_nativeSession;
 638 }
 639
 640 bool SessionImpl::isDHTEnabled() const
 641 {
 642     return m_isDHTEnabled;
 643 }
 644
 645 void SessionImpl::setDHTEnabled(bool enabled)
 646 {
 647     if (enabled != m_isDHTEnabled)
 648     {
 649         m_isDHTEnabled = enabled;
 650         configureDeferred();
 651         LogMsg(tr("Distributed Hash Table (DHT) support: %1").arg(enabled ? tr("ON") : tr("OFF")), Log::INFO);
 652     }
 653 }
 654
 655 bool SessionImpl::isLSDEnabled() const
 656 {
 657     return m_isLSDEnabled;
 658 }
 659
 660 void SessionImpl::setLSDEnabled(const bool enabled)
 661 {
 662     if (enabled != m_isLSDEnabled)
 663     {
 664         m_isLSDEnabled = enabled;
 665         configureDeferred();
 666         LogMsg(tr("Local Peer Discovery support: %1").arg(enabled ? tr("ON") : tr("OFF"))
 667             , Log::INFO);
 668     }
 669 }
 670
 671 bool SessionImpl::isPeXEnabled() const
 672 {
 673     return m_isPeXEnabled;
 674 }
 675
 676 void SessionImpl::setPeXEnabled(const bool enabled)
 677 {
 678     m_isPeXEnabled = enabled;
 679     if (m_wasPexEnabled != enabled)
 680         LogMsg(tr("Restart is required to toggle Peer Exchange (PeX) support"), Log::WARNING);
 681 }
 682
 683 bool SessionImpl::isDownloadPathEnabled() const
 684 {
 685     return m_isDownloadPathEnabled;
 686 }
 687
 688 void SessionImpl::setDownloadPathEnabled(const bool enabled)
 689 {
 690     if (enabled != isDownloadPathEnabled())
 691     {
 692         m_isDownloadPathEnabled = enabled;
 693         for (TorrentImpl *const torrent : asConst(m_torrents))
 694             torrent->handleCategoryOptionsChanged();
 695     }
 696 }
 697
 698 bool SessionImpl::isAppendExtensionEnabled() const
 699 {
 700     return m_isAppendExtensionEnabled;
 701 }
 702
 703 void SessionImpl::setAppendExtensionEnabled(const bool enabled)
 704 {
 705     if (isAppendExtensionEnabled() != enabled)
 706     {
 707         m_isAppendExtensionEnabled = enabled;
 708
 709         // append or remove .!qB extension for incomplete files
 710         for (TorrentImpl *const torrent : asConst(m_torrents))
 711             torrent->handleAppendExtensionToggled();
 712     }
 713 }
 714
 715 int SessionImpl::refreshInterval() const
 716 {
 717     return m_refreshInterval;
 718 }
 719
 720 void SessionImpl::setRefreshInterval(const int value)
 721 {
 722     if (value != refreshInterval())
 723     {
 724         m_refreshInterval = value;
 725     }
 726 }
 727
 728 bool SessionImpl::isPreallocationEnabled() const
 729 {
 730     return m_isPreallocationEnabled;
 731 }
 732
 733 void SessionImpl::setPreallocationEnabled(const bool enabled)
 734 {
 735     m_isPreallocationEnabled = enabled;
 736 }
 737
 738 Path SessionImpl::torrentExportDirectory() const
 739 {
 740     return m_torrentExportDirectory;
 741 }
 742
 743 void SessionImpl::setTorrentExportDirectory(const Path &path)
 744 {
 745     if (path != torrentExportDirectory())
 746         m_torrentExportDirectory = path;
 747 }
 748
 749 Path SessionImpl::finishedTorrentExportDirectory() const
 750 {
 751     return m_finishedTorrentExportDirectory;
 752 }
 753
 754 void SessionImpl::setFinishedTorrentExportDirectory(const Path &path)
 755 {
 756     if (path != finishedTorrentExportDirectory())
 757         m_finishedTorrentExportDirectory = path;
 758 }
 759
 760 Path SessionImpl::savePath() const
 761 {
 762     // TODO: Make sure it is always non-empty
 763     return m_savePath;
 764 }
 765
 766 Path SessionImpl::downloadPath() const
 767 {
 768     // TODO: Make sure it is always non-empty
 769     return m_downloadPath;
 770 }
 771
 772 QStringList SessionImpl::categories() const
 773 {
 774     return m_categories.keys();
 775 }
 776
 777 CategoryOptions SessionImpl::categoryOptions(const QString &categoryName) const
 778 {
 779     return m_categories.value(categoryName);
 780 }
 781
 782 Path SessionImpl::categorySavePath(const QString &categoryName) const
 783 {
 784     const Path basePath = savePath();
 785     if (categoryName.isEmpty())
 786         return basePath;
 787
 788     Path path = m_categories.value(categoryName).savePath;
 789     if (path.isEmpty()) // use implicit save path
 790         path = Utils::Fs::toValidPath(categoryName);
 791
 792     return (path.isAbsolute() ? path : (basePath / path));
 793 }
 794
 795 Path SessionImpl::categoryDownloadPath(const QString &categoryName) const
 796 {
 797     const CategoryOptions categoryOptions = m_categories.value(categoryName);
 798     const CategoryOptions::DownloadPathOption downloadPathOption =
 799             categoryOptions.downloadPath.value_or(CategoryOptions::DownloadPathOption {isDownloadPathEnabled(), downloadPath()});
 800     if (!downloadPathOption.enabled)
 801         return {};
 802
 803     const Path basePath = downloadPath();
 804     if (categoryName.isEmpty())
 805         return basePath;
 806
 807     const Path path = (!downloadPathOption.path.isEmpty()
 808                           ? downloadPathOption.path
 809                           : Utils::Fs::toValidPath(categoryName)); // use implicit download path
 810
 811     return (path.isAbsolute() ? path : (basePath / path));
 812 }
 813
 814 bool SessionImpl::addCategory(const QString &name, const CategoryOptions &options)
 815 {
 816     if (name.isEmpty())
 817         return false;
 818
 819     if (!isValidCategoryName(name) || m_categories.contains(name))
 820         return false;
 821
 822     if (isSubcategoriesEnabled())
 823     {
 824         for (const QString &parent : asConst(expandCategory(name)))
 825         {
 826             if ((parent != name) && !m_categories.contains(parent))
 827             {
 828                 m_categories[parent] = {};
 829                 emit categoryAdded(parent);
 830             }
 831         }
 832     }
 833
 834     m_categories[name] = options;
 835     storeCategories();
 836     emit categoryAdded(name);
 837
 838     return true;
 839 }
 840
 841 bool SessionImpl::editCategory(const QString &name, const CategoryOptions &options)
 842 {
 843     const auto it = m_categories.find(name);
 844     if (it == m_categories.end())
 845         return false;
 846
 847     CategoryOptions &currentOptions = it.value();
 848     if (options == currentOptions)
 849         return false;
 850
 851     currentOptions = options;
 852     storeCategories();
 853     if (isDisableAutoTMMWhenCategorySavePathChanged())
 854     {
 855         for (TorrentImpl *const torrent : asConst(m_torrents))
 856         {
 857             if (torrent->category() == name)
 858                 torrent->setAutoTMMEnabled(false);
 859         }
 860     }
 861     else
 862     {
 863         for (TorrentImpl *const torrent : asConst(m_torrents))
 864         {
 865             if (torrent->category() == name)
 866                 torrent->handleCategoryOptionsChanged();
 867         }
 868     }
 869
 870     emit categoryOptionsChanged(name);
 871     return true;
 872 }
 873
 874 bool SessionImpl::removeCategory(const QString &name)
 875 {
 876     for (TorrentImpl *const torrent : asConst(m_torrents))
 877     {
 878         if (torrent->belongsToCategory(name))
 879             torrent->setCategory(u""_qs);
 880     }
 881
 882     // remove stored category and its subcategories if exist
 883     bool result = false;
 884     if (isSubcategoriesEnabled())
 885     {
 886         // remove subcategories
 887         const QString test = name + u'/';
 888         Algorithm::removeIf(m_categories, [this, &test, &result](const QString &category, const CategoryOptions &)
 889         {
 890             if (category.startsWith(test))
 891             {
 892                 result = true;
 893                 emit categoryRemoved(category);
 894                 return true;
 895             }
 896             return false;
 897         });
 898     }
 899
 900     result = (m_categories.remove(name) > 0) || result;
 901
 902     if (result)
 903     {
 904         // update stored categories
 905         storeCategories();
 906         emit categoryRemoved(name);
 907     }
 908
 909     return result;
 910 }
 911
 912 bool SessionImpl::isSubcategoriesEnabled() const
 913 {
 914     return m_isSubcategoriesEnabled;
 915 }
 916
 917 void SessionImpl::setSubcategoriesEnabled(const bool value)
 918 {
 919     if (isSubcategoriesEnabled() == value) return;
 920
 921     if (value)
 922     {
 923         // expand categories to include all parent categories
 924         m_categories = expandCategories(m_categories);
 925         // update stored categories
 926         storeCategories();
 927     }
 928     else
 929     {
 930         // reload categories
 931         loadCategories();
 932     }
 933
 934     m_isSubcategoriesEnabled = value;
 935     emit subcategoriesSupportChanged();
 936 }
 937
 938 bool SessionImpl::useCategoryPathsInManualMode() const
 939 {
 940     return m_useCategoryPathsInManualMode;
 941 }
 942
 943 void SessionImpl::setUseCategoryPathsInManualMode(const bool value)
 944 {
 945     m_useCategoryPathsInManualMode = value;
 946 }
 947
 948 Path SessionImpl::suggestedSavePath(const QString &categoryName, std::optional<bool> useAutoTMM) const
 949 {
 950     const bool useCategoryPaths = useAutoTMM.value_or(!isAutoTMMDisabledByDefault()) || useCategoryPathsInManualMode();
 951     const auto path = (useCategoryPaths ? categorySavePath(categoryName) : savePath());
 952     return path;
 953 }
 954
 955 Path SessionImpl::suggestedDownloadPath(const QString &categoryName, std::optional<bool> useAutoTMM) const
 956 {
 957     const bool useCategoryPaths = useAutoTMM.value_or(!isAutoTMMDisabledByDefault()) || useCategoryPathsInManualMode();
 958     const auto categoryDownloadPath = this->categoryDownloadPath(categoryName);
 959     const auto path = ((useCategoryPaths && !categoryDownloadPath.isEmpty()) ? categoryDownloadPath : downloadPath());
 960     return path;
 961 }
 962
 963 QSet<QString> SessionImpl::tags() const
 964 {
 965     return m_tags;
 966 }
 967
 968 bool SessionImpl::hasTag(const QString &tag) const
 969 {
 970     return m_tags.contains(tag);
 971 }
 972
 973 bool SessionImpl::addTag(const QString &tag)
 974 {
 975     if (!isValidTag(tag) || hasTag(tag))
 976         return false;
 977
 978     m_tags.insert(tag);
 979     m_storedTags = m_tags.values();
 980     emit tagAdded(tag);
 981     return true;
 982 }
 983
 984 bool SessionImpl::removeTag(const QString &tag)
 985 {
 986     if (m_tags.remove(tag))
 987     {
 988         for (TorrentImpl *const torrent : asConst(m_torrents))
 989             torrent->removeTag(tag);
 990         m_storedTags = m_tags.values();
 991         emit tagRemoved(tag);
 992         return true;
 993     }
 994     return false;
 995 }
 996
 997 bool SessionImpl::isAutoTMMDisabledByDefault() const
 998 {
 999     return m_isAutoTMMDisabledByDefault;
1000 }
1001
1002 void SessionImpl::setAutoTMMDisabledByDefault(const bool value)
1003 {
1004     m_isAutoTMMDisabledByDefault = value;
1005 }
1006
1007 bool SessionImpl::isDisableAutoTMMWhenCategoryChanged() const
1008 {
1009     return m_isDisableAutoTMMWhenCategoryChanged;
1010 }
1011
1012 void SessionImpl::setDisableAutoTMMWhenCategoryChanged(const bool value)
1013 {
1014     m_isDisableAutoTMMWhenCategoryChanged = value;
1015 }
1016
1017 bool SessionImpl::isDisableAutoTMMWhenDefaultSavePathChanged() const
1018 {
1019     return m_isDisableAutoTMMWhenDefaultSavePathChanged;
1020 }
1021
1022 void SessionImpl::setDisableAutoTMMWhenDefaultSavePathChanged(const bool value)
1023 {
1024     m_isDisableAutoTMMWhenDefaultSavePathChanged = value;
1025 }
1026
1027 bool SessionImpl::isDisableAutoTMMWhenCategorySavePathChanged() const
1028 {
1029     return m_isDisableAutoTMMWhenCategorySavePathChanged;
1030 }
1031
1032 void SessionImpl::setDisableAutoTMMWhenCategorySavePathChanged(const bool value)
1033 {
1034     m_isDisableAutoTMMWhenCategorySavePathChanged = value;
1035 }
1036
1037 bool SessionImpl::isAddTorrentToQueueTop() const
1038 {
1039     return m_isAddTorrentToQueueTop;
1040 }
1041
1042 void SessionImpl::setAddTorrentToQueueTop(bool value)
1043 {
1044     m_isAddTorrentToQueueTop = value;
1045 }
1046
1047 bool SessionImpl::isAddTorrentPaused() const
1048 {
1049     return m_isAddTorrentPaused;
1050 }
1051
1052 void SessionImpl::setAddTorrentPaused(const bool value)
1053 {
1054     m_isAddTorrentPaused = value;
1055 }
1056
1057 Torrent::StopCondition SessionImpl::torrentStopCondition() const
1058 {
1059     return m_torrentStopCondition;
1060 }
1061
1062 void SessionImpl::setTorrentStopCondition(const Torrent::StopCondition stopCondition)
1063 {
1064     m_torrentStopCondition = stopCondition;
1065 }
1066
1067 bool SessionImpl::isTrackerEnabled() const
1068 {
1069     return m_isTrackerEnabled;
1070 }
1071
1072 void SessionImpl::setTrackerEnabled(const bool enabled)
1073 {
1074     if (m_isTrackerEnabled != enabled)
1075         m_isTrackerEnabled = enabled;
1076
1077     // call enableTracker() unconditionally, otherwise port change won't trigger
1078     // tracker restart
1079     enableTracker(enabled);
1080 }
1081
1082 qreal SessionImpl::globalMaxRatio() const
1083 {
1084     return m_globalMaxRatio;
1085 }
1086
1087 // Torrents with a ratio superior to the given value will
1088 // be automatically deleted
1089 void SessionImpl::setGlobalMaxRatio(qreal ratio)
1090 {
1091     if (ratio < 0)
1092         ratio = -1.;
1093
1094     if (ratio != globalMaxRatio())
1095     {
1096         m_globalMaxRatio = ratio;
1097         updateSeedingLimitTimer();
1098     }
1099 }
1100
1101 int SessionImpl::globalMaxSeedingMinutes() const
1102 {
1103     return m_globalMaxSeedingMinutes;
1104 }
1105
1106 void SessionImpl::setGlobalMaxSeedingMinutes(int minutes)
1107 {
1108     if (minutes < 0)
1109         minutes = -1;
1110
1111     if (minutes != globalMaxSeedingMinutes())
1112     {
1113         m_globalMaxSeedingMinutes = minutes;
1114         updateSeedingLimitTimer();
1115     }
1116 }
1117
1118 void SessionImpl::applyBandwidthLimits()
1119 {
1120     lt::settings_pack settingsPack;
1121     settingsPack.set_int(lt::settings_pack::download_rate_limit, downloadSpeedLimit());
1122     settingsPack.set_int(lt::settings_pack::upload_rate_limit, uploadSpeedLimit());
1123     m_nativeSession->apply_settings(std::move(settingsPack));
1124 }
1125
1126 void SessionImpl::configure()
1127 {
1128     m_nativeSession->apply_settings(loadLTSettings());
1129     configureComponents();
1130
1131     m_deferredConfigureScheduled = false;
1132 }
1133
1134 void SessionImpl::configureComponents()
1135 {
1136     // This function contains components/actions that:
1137     // 1. Need to be setup at start up
1138     // 2. When deferred configure is called
1139
1140     configurePeerClasses();
1141
1142     if (!m_IPFilteringConfigured)
1143     {
1144         if (isIPFilteringEnabled())
1145             enableIPFilter();
1146         else
1147             disableIPFilter();
1148         m_IPFilteringConfigured = true;
1149     }
1150 }
1151
1152 void SessionImpl::prepareStartup()
1153 {
1154     qDebug("Initializing torrents resume data storage...");
1155
1156     const Path dbPath = specialFolderLocation(SpecialFolder::Data) / Path(u"torrents.db"_qs);
1157     const bool dbStorageExists = dbPath.exists();
1158
1159     auto *context = new ResumeSessionContext(this);
1160     context->currentStorageType = resumeDataStorageType();
1161
1162     if (context->currentStorageType == ResumeDataStorageType::SQLite)
1163     {
1164         m_resumeDataStorage = new DBResumeDataStorage(dbPath, this);
1165
1166         if (!dbStorageExists)
1167         {
1168             const Path dataPath = specialFolderLocation(SpecialFolder::Data) / Path(u"BT_backup"_qs);
1169             context->startupStorage = new BencodeResumeDataStorage(dataPath, this);
1170         }
1171     }
1172     else
1173     {
1174         const Path dataPath = specialFolderLocation(SpecialFolder::Data) / Path(u"BT_backup"_qs);
1175         m_resumeDataStorage = new BencodeResumeDataStorage(dataPath, this);
1176
1177         if (dbStorageExists)
1178             context->startupStorage = new DBResumeDataStorage(dbPath, this);
1179     }
1180
1181     if (!context->startupStorage)
1182         context->startupStorage = m_resumeDataStorage;
1183
1184     connect(context->startupStorage, &ResumeDataStorage::loadStarted, context
1185             , [this, context](const QVector<TorrentID> &torrents)
1186     {
1187         context->totalResumeDataCount = torrents.size();
1188 #ifdef QBT_USES_LIBTORRENT2
1189         context->indexedTorrents = QSet<TorrentID>(torrents.cbegin(), torrents.cend());
1190 #endif
1191
1192         handleLoadedResumeData(context);
1193     });
1194
1195     connect(context->startupStorage, &ResumeDataStorage::loadFinished, context, [context]()
1196     {
1197         context->isLoadFinished = true;
1198     });
1199
1200     connect(this, &SessionImpl::torrentsLoaded, context, [this, context](const QVector<Torrent *> &torrents)
1201     {
1202         context->processingResumeDataCount -= torrents.count();
1203         context->finishedResumeDataCount += torrents.count();
1204         if (!context->isLoadedResumeDataHandlingEnqueued)
1205         {
1206             QMetaObject::invokeMethod(this, [this, context]() { handleLoadedResumeData(context); }, Qt::QueuedConnection);
1207             context->isLoadedResumeDataHandlingEnqueued = true;
1208         }
1209
1210         if (!m_refreshEnqueued)
1211         {
1212             m_nativeSession->post_torrent_updates();
1213             m_refreshEnqueued = true;
1214         }
1215
1216         emit startupProgressUpdated((context->finishedResumeDataCount * 100.) / context->totalResumeDataCount);
1217     });
1218
1219     context->startupStorage->loadAll();
1220 }
1221
1222 void SessionImpl::handleLoadedResumeData(ResumeSessionContext *context)
1223 {
1224     context->isLoadedResumeDataHandlingEnqueued = false;
1225
1226     int count = context->processingResumeDataCount;
1227     while (context->processingResumeDataCount < MAX_PROCESSING_RESUMEDATA_COUNT)
1228     {
1229         if (context->loadedResumeData.isEmpty())
1230             context->loadedResumeData = context->startupStorage->fetchLoadedResumeData();
1231
1232         if (context->loadedResumeData.isEmpty())
1233         {
1234             if (context->processingResumeDataCount == 0)
1235             {
1236                 if (context->isLoadFinished)
1237                 {
1238                     endStartup(context);
1239                 }
1240                 else if (!context->isLoadedResumeDataHandlingEnqueued)
1241                 {
1242                     QMetaObject::invokeMethod(this, [this, context]() { handleLoadedResumeData(context); }, Qt::QueuedConnection);
1243                     context->isLoadedResumeDataHandlingEnqueued = true;
1244                 }
1245             }
1246
1247             break;
1248         }
1249
1250         processNextResumeData(context);
1251         ++count;
1252     }
1253
1254     context->finishedResumeDataCount += (count - context->processingResumeDataCount);
1255 }
1256
1257 void SessionImpl::processNextResumeData(ResumeSessionContext *context)
1258 {
1259     const LoadedResumeData loadedResumeDataItem = context->loadedResumeData.takeFirst();
1260
1261     TorrentID torrentID = loadedResumeDataItem.torrentID;
1262 #ifdef QBT_USES_LIBTORRENT2
1263     if (context->skippedIDs.contains(torrentID))
1264         return;
1265 #endif
1266
1267     const nonstd::expected<LoadTorrentParams, QString> &loadResumeDataResult = loadedResumeDataItem.result;
1268     if (!loadResumeDataResult)
1269     {
1270         LogMsg(tr("Failed to resume torrent. Torrent: \"%1\". Reason: \"%2\"")
1271                .arg(torrentID.toString(), loadResumeDataResult.error()), Log::CRITICAL);
1272         return;
1273     }
1274
1275     LoadTorrentParams resumeData = *loadResumeDataResult;
1276     bool needStore = false;
1277
1278 #ifdef QBT_USES_LIBTORRENT2
1279     const InfoHash infoHash {(resumeData.ltAddTorrentParams.ti
1280                 ? resumeData.ltAddTorrentParams.ti->info_hashes()
1281                 : resumeData.ltAddTorrentParams.info_hashes)};
1282     const bool isHybrid = infoHash.isHybrid();
1283     const auto torrentIDv2 = TorrentID::fromInfoHash(infoHash);
1284     const auto torrentIDv1 = TorrentID::fromSHA1Hash(infoHash.v1());
1285     if (torrentID == torrentIDv2)
1286     {
1287         if (isHybrid && context->indexedTorrents.contains(torrentIDv1))
1288         {
1289             // if we don't have metadata, try to find it in alternative "resume data"
1290             if (!resumeData.ltAddTorrentParams.ti)
1291             {
1292                 const nonstd::expected<LoadTorrentParams, QString> loadAltResumeDataResult = context->startupStorage->load(torrentIDv1);
1293                 if (loadAltResumeDataResult)
1294                     resumeData.ltAddTorrentParams.ti = loadAltResumeDataResult->ltAddTorrentParams.ti;
1295             }
1296
1297             // remove alternative "resume data" and skip the attempt to load it
1298             m_resumeDataStorage->remove(torrentIDv1);
1299             context->skippedIDs.insert(torrentIDv1);
1300         }
1301     }
1302     else if (torrentID == torrentIDv1)
1303     {
1304         torrentID = torrentIDv2;
1305         needStore = true;
1306         m_resumeDataStorage->remove(torrentIDv1);
1307
1308         if (context->indexedTorrents.contains(torrentID))
1309         {
1310             context->skippedIDs.insert(torrentID);
1311
1312             const nonstd::expected<LoadTorrentParams, QString> loadPreferredResumeDataResult = context->startupStorage->load(torrentID);
1313             if (loadPreferredResumeDataResult)
1314             {
1315                 std::shared_ptr<lt::torrent_info> ti = resumeData.ltAddTorrentParams.ti;
1316                 resumeData = *loadPreferredResumeDataResult;
1317                 if (!resumeData.ltAddTorrentParams.ti)
1318                     resumeData.ltAddTorrentParams.ti = ti;
1319             }
1320         }
1321     }
1322     else
1323     {
1324         LogMsg(tr("Failed to resume torrent: inconsistent torrent ID is detected. Torrent: \"%1\"")
1325                .arg(torrentID.toString()), Log::WARNING);
1326         return;
1327     }
1328 #else
1329     const lt::sha1_hash infoHash = (resumeData.ltAddTorrentParams.ti
1330                                       ? resumeData.ltAddTorrentParams.ti->info_hash()
1331                                       : resumeData.ltAddTorrentParams.info_hash);
1332     if (torrentID != TorrentID::fromInfoHash(infoHash))
1333     {
1334         LogMsg(tr("Failed to resume torrent: inconsistent torrent ID is detected. Torrent: \"%1\"")
1335                .arg(torrentID.toString()), Log::WARNING);
1336         return;
1337     }
1338 #endif
1339
1340     if (m_resumeDataStorage != context->startupStorage)
1341        needStore = true;
1342
1343     // TODO: Remove the following upgrade code in v4.6
1344     // == BEGIN UPGRADE CODE ==
1345     if (!needStore)
1346     {
1347         if (m_needUpgradeDownloadPath && isDownloadPathEnabled() && !resumeData.useAutoTMM)
1348         {
1349             resumeData.downloadPath = downloadPath();
1350             needStore = true;
1351         }
1352     }
1353     // == END UPGRADE CODE ==
1354
1355     if (needStore)
1356          m_resumeDataStorage->store(torrentID, resumeData);
1357
1358     const QString category = resumeData.category;
1359     bool isCategoryRecovered = context->recoveredCategories.contains(category);
1360     if (!category.isEmpty() && (isCategoryRecovered || !m_categories.contains(category)))
1361     {
1362         if (!isCategoryRecovered)
1363         {
1364             if (addCategory(category))
1365             {
1366                 context->recoveredCategories.insert(category);
1367                 isCategoryRecovered = true;
1368                 LogMsg(tr("Detected inconsistent data: category is missing from the configuration file."
1369                           " Category will be recovered but its settings will be reset to default."
1370                           " Torrent: \"%1\". Category: \"%2\"").arg(torrentID.toString(), category), Log::WARNING);
1371             }
1372             else
1373             {
1374                 resumeData.category.clear();
1375                 LogMsg(tr("Detected inconsistent data: invalid category. Torrent: \"%1\". Category: \"%2\"")
1376                        .arg(torrentID.toString(), category), Log::WARNING);
1377             }
1378         }
1379
1380         // We should check isCategoryRecovered again since the category
1381         // can be just recovered by the code above
1382         if (isCategoryRecovered && resumeData.useAutoTMM)
1383         {
1384             const Path storageLocation {resumeData.ltAddTorrentParams.save_path};
1385             if ((storageLocation != categorySavePath(resumeData.category)) && (storageLocation != categoryDownloadPath(resumeData.category)))
1386             {
1387                 resumeData.useAutoTMM = false;
1388                 resumeData.savePath = storageLocation;
1389                 resumeData.downloadPath = {};
1390                 LogMsg(tr("Detected mismatch between the save paths of the recovered category and the current save path of the torrent."
1391                           " Torrent is now switched to Manual mode."
1392                           " Torrent: \"%1\". Category: \"%2\"").arg(torrentID.toString(), category), Log::WARNING);
1393             }
1394         }
1395     }
1396
1397     Algorithm::removeIf(resumeData.tags, [this, &torrentID](const QString &tag)
1398     {
1399         if (hasTag(tag))
1400             return false;
1401
1402         if (addTag(tag))
1403         {
1404             LogMsg(tr("Detected inconsistent data: tag is missing from the configuration file."
1405                       " Tag will be recovered."
1406                       " Torrent: \"%1\". Tag: \"%2\"").arg(torrentID.toString(), tag), Log::WARNING);
1407             return false;
1408         }
1409
1410         LogMsg(tr("Detected inconsistent data: invalid tag. Torrent: \"%1\". Tag: \"%2\"")
1411                .arg(torrentID.toString(), tag), Log::WARNING);
1412         return true;
1413     });
1414
1415     resumeData.ltAddTorrentParams.userdata = LTClientData(new ExtensionData);
1416 #ifndef QBT_USES_LIBTORRENT2
1417     resumeData.ltAddTorrentParams.storage = customStorageConstructor;
1418 #endif
1419
1420     qDebug() << "Starting up torrent" << torrentID.toString() << "...";
1421     m_loadingTorrents.insert(torrentID, resumeData);
1422 #ifdef QBT_USES_LIBTORRENT2
1423     if (infoHash.isHybrid())
1424     {
1425         // this allows to know the being added hybrid torrent by its v1 info hash
1426         // without having yet another mapping table
1427         m_hybridTorrentsByAltID.insert(torrentIDv1, nullptr);
1428     }
1429 #endif
1430     m_nativeSession->async_add_torrent(resumeData.ltAddTorrentParams);
1431     ++context->processingResumeDataCount;
1432 }
1433
1434 void SessionImpl::endStartup(ResumeSessionContext *context)
1435 {
1436     if (m_resumeDataStorage != context->startupStorage)
1437     {
1438         if (isQueueingSystemEnabled())
1439             saveTorrentsQueue();
1440
1441         const Path dbPath = context->startupStorage->path();
1442         context->startupStorage->deleteLater();
1443
1444         if (context->currentStorageType == ResumeDataStorageType::Legacy)
1445         {
1446             connect(context->startupStorage, &QObject::destroyed, [dbPath]
1447             {
1448                 Utils::Fs::removeFile(dbPath);
1449             });
1450         }
1451     }
1452
1453     context->deleteLater();
1454     connect(context, &QObject::destroyed, this, [this]
1455     {
1456         m_nativeSession->resume();
1457         if (m_refreshEnqueued)
1458             m_refreshEnqueued = false;
1459         else
1460             enqueueRefresh();
1461
1462         m_statisticsLastUpdateTimer.start();
1463
1464         // Regular saving of fastresume data
1465         connect(m_resumeDataTimer, &QTimer::timeout, this, &SessionImpl::generateResumeData);
1466         const int saveInterval = saveResumeDataInterval();
1467         if (saveInterval > 0)
1468         {
1469             m_resumeDataTimer->setInterval(std::chrono::minutes(saveInterval));
1470             m_resumeDataTimer->start();
1471         }
1472
1473         m_isRestored = true;
1474         emit startupProgressUpdated(100);
1475         emit restored();
1476     });
1477 }
1478
1479 void SessionImpl::initializeNativeSession()
1480 {
1481     lt::settings_pack pack = loadLTSettings();
1482
1483     const std::string peerId = lt::generate_fingerprint(PEER_ID, QBT_VERSION_MAJOR, QBT_VERSION_MINOR, QBT_VERSION_BUGFIX, QBT_VERSION_BUILD);
1484     pack.set_str(lt::settings_pack::peer_fingerprint, peerId);
1485
1486     pack.set_bool(lt::settings_pack::listen_system_port_fallback, false);
1487     pack.set_str(lt::settings_pack::user_agent, USER_AGENT.toStdString());
1488     pack.set_bool(lt::settings_pack::use_dht_as_fallback, false);
1489     // Speed up exit
1490     pack.set_int(lt::settings_pack::auto_scrape_interval, 1200); // 20 minutes
1491     pack.set_int(lt::settings_pack::auto_scrape_min_interval, 900); // 15 minutes
1492     // libtorrent 1.1 enables UPnP & NAT-PMP by default
1493     // turn them off before `lt::session` ctor to avoid split second effects
1494     pack.set_bool(lt::settings_pack::enable_upnp, false);
1495     pack.set_bool(lt::settings_pack::enable_natpmp, false);
1496
1497 #ifdef QBT_USES_LIBTORRENT2
1498     // preserve the same behavior as in earlier libtorrent versions
1499     pack.set_bool(lt::settings_pack::enable_set_file_valid_data, true);
1500 #endif
1501
1502     lt::session_params sessionParams {std::move(pack), {}};
1503 #ifdef QBT_USES_LIBTORRENT2
1504     switch (diskIOType())
1505     {
1506     case DiskIOType::Posix:
1507         sessionParams.disk_io_constructor = customPosixDiskIOConstructor;
1508         break;
1509     case DiskIOType::MMap:
1510         sessionParams.disk_io_constructor = customMMapDiskIOConstructor;
1511         break;
1512     default:
1513         sessionParams.disk_io_constructor = customDiskIOConstructor;
1514         break;
1515     }
1516 #endif
1517
1518 #if LIBTORRENT_VERSION_NUM < 20100
1519     m_nativeSession = new lt::session(sessionParams, lt::session::paused);
1520 #else
1521     m_nativeSession = new lt::session(sessionParams);
1522     m_nativeSession->pause();
1523 #endif
1524
1525     LogMsg(tr("Peer ID: \"%1\"").arg(QString::fromStdString(peerId)), Log::INFO);
1526     LogMsg(tr("HTTP User-Agent: \"%1\"").arg(USER_AGENT), Log::INFO);
1527     LogMsg(tr("Distributed Hash Table (DHT) support: %1").arg(isDHTEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1528     LogMsg(tr("Local Peer Discovery support: %1").arg(isLSDEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1529     LogMsg(tr("Peer Exchange (PeX) support: %1").arg(isPeXEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1530     LogMsg(tr("Anonymous mode: %1").arg(isAnonymousModeEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1531     LogMsg(tr("Encryption support: %1").arg((encryption() == 0) ? tr("ON") : ((encryption() == 1) ? tr("FORCED") : tr("OFF"))), Log::INFO);
1532
1533     m_nativeSession->set_alert_notify([this]()
1534     {
1535         QMetaObject::invokeMethod(this, &SessionImpl::readAlerts, Qt::QueuedConnection);
1536     });
1537
1538     // Enabling plugins
1539     m_nativeSession->add_extension(&lt::create_smart_ban_plugin);
1540     m_nativeSession->add_extension(&lt::create_ut_metadata_plugin);
1541     if (isPeXEnabled())
1542         m_nativeSession->add_extension(&lt::create_ut_pex_plugin);
1543
1544     auto nativeSessionExtension = std::make_shared<NativeSessionExtension>();
1545     m_nativeSession->add_extension(nativeSessionExtension);
1546     m_nativeSessionExtension = nativeSessionExtension.get();
1547 }
1548
1549 void SessionImpl::processBannedIPs(lt::ip_filter &filter)
1550 {
1551     // First, import current filter
1552     for (const QString &ip : asConst(m_bannedIPs.get()))
1553     {
1554         lt::error_code ec;
1555         const lt::address addr = lt::make_address(ip.toLatin1().constData(), ec);
1556         Q_ASSERT(!ec);
1557         if (!ec)
1558             filter.add_rule(addr, addr, lt::ip_filter::blocked);
1559     }
1560 }
1561
1562 void SessionImpl::initMetrics()
1563 {
1564     const auto findMetricIndex = [](const char *name) -> int
1565     {
1566         const int index = lt::find_metric_idx(name);
1567         Q_ASSERT(index >= 0);
1568         return index;
1569     };
1570
1571     // TODO: switch to "designated initializers" in C++20
1572     m_metricIndices.net.hasIncomingConnections = findMetricIndex("net.has_incoming_connections");
1573     m_metricIndices.net.sentPayloadBytes = findMetricIndex("net.sent_payload_bytes");
1574     m_metricIndices.net.recvPayloadBytes = findMetricIndex("net.recv_payload_bytes");
1575     m_metricIndices.net.sentBytes = findMetricIndex("net.sent_bytes");
1576     m_metricIndices.net.recvBytes = findMetricIndex("net.recv_bytes");
1577     m_metricIndices.net.sentIPOverheadBytes = findMetricIndex("net.sent_ip_overhead_bytes");
1578     m_metricIndices.net.recvIPOverheadBytes = findMetricIndex("net.recv_ip_overhead_bytes");
1579     m_metricIndices.net.sentTrackerBytes = findMetricIndex("net.sent_tracker_bytes");
1580     m_metricIndices.net.recvTrackerBytes = findMetricIndex("net.recv_tracker_bytes");
1581     m_metricIndices.net.recvRedundantBytes = findMetricIndex("net.recv_redundant_bytes");
1582     m_metricIndices.net.recvFailedBytes = findMetricIndex("net.recv_failed_bytes");
1583
1584     m_metricIndices.peer.numPeersConnected = findMetricIndex("peer.num_peers_connected");
1585     m_metricIndices.peer.numPeersDownDisk = findMetricIndex("peer.num_peers_down_disk");
1586     m_metricIndices.peer.numPeersUpDisk = findMetricIndex("peer.num_peers_up_disk");
1587
1588     m_metricIndices.dht.dhtBytesIn = findMetricIndex("dht.dht_bytes_in");
1589     m_metricIndices.dht.dhtBytesOut = findMetricIndex("dht.dht_bytes_out");
1590     m_metricIndices.dht.dhtNodes = findMetricIndex("dht.dht_nodes");
1591
1592     m_metricIndices.disk.diskBlocksInUse = findMetricIndex("disk.disk_blocks_in_use");
1593     m_metricIndices.disk.numBlocksRead = findMetricIndex("disk.num_blocks_read");
1594 #ifndef QBT_USES_LIBTORRENT2
1595     m_metricIndices.disk.numBlocksCacheHits = findMetricIndex("disk.num_blocks_cache_hits");
1596 #endif
1597     m_metricIndices.disk.writeJobs = findMetricIndex("disk.num_write_ops");
1598     m_metricIndices.disk.readJobs = findMetricIndex("disk.num_read_ops");
1599     m_metricIndices.disk.hashJobs = findMetricIndex("disk.num_blocks_hashed");
1600     m_metricIndices.disk.queuedDiskJobs = findMetricIndex("disk.queued_disk_jobs");
1601     m_metricIndices.disk.diskJobTime = findMetricIndex("disk.disk_job_time");
1602 }
1603
1604 lt::settings_pack SessionImpl::loadLTSettings() const
1605 {
1606     lt::settings_pack settingsPack;
1607
1608     const lt::alert_category_t alertMask = lt::alert::error_notification
1609         | lt::alert::file_progress_notification
1610         | lt::alert::ip_block_notification
1611         | lt::alert::peer_notification
1612         | (isPerformanceWarningEnabled() ? lt::alert::performance_warning : lt::alert_category_t())
1613         | lt::alert::port_mapping_notification
1614         | lt::alert::status_notification
1615         | lt::alert::storage_notification
1616         | lt::alert::tracker_notification;
1617     settingsPack.set_int(lt::settings_pack::alert_mask, alertMask);
1618
1619     settingsPack.set_int(lt::settings_pack::connection_speed, connectionSpeed());
1620
1621     // from libtorrent doc:
1622     // It will not take affect until the listen_interfaces settings is updated
1623     settingsPack.set_int(lt::settings_pack::send_socket_buffer_size, socketSendBufferSize());
1624     settingsPack.set_int(lt::settings_pack::recv_socket_buffer_size, socketReceiveBufferSize());
1625     settingsPack.set_int(lt::settings_pack::listen_queue_size, socketBacklogSize());
1626
1627     applyNetworkInterfacesSettings(settingsPack);
1628
1629     settingsPack.set_int(lt::settings_pack::download_rate_limit, downloadSpeedLimit());
1630     settingsPack.set_int(lt::settings_pack::upload_rate_limit, uploadSpeedLimit());
1631
1632     // The most secure, rc4 only so that all streams are encrypted
1633     settingsPack.set_int(lt::settings_pack::allowed_enc_level, lt::settings_pack::pe_rc4);
1634     settingsPack.set_bool(lt::settings_pack::prefer_rc4, true);
1635     switch (encryption())
1636     {
1637     case 0: // Enabled
1638         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_enabled);
1639         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_enabled);
1640         break;
1641     case 1: // Forced
1642         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_forced);
1643         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_forced);
1644         break;
1645     default: // Disabled
1646         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_disabled);
1647         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_disabled);
1648     }
1649
1650     settingsPack.set_int(lt::settings_pack::active_checking, maxActiveCheckingTorrents());
1651
1652     // I2P
1653     if (isI2PEnabled())
1654     {
1655         settingsPack.set_str(lt::settings_pack::i2p_hostname, I2PAddress().toStdString());
1656         settingsPack.set_int(lt::settings_pack::i2p_port, I2PPort());
1657         settingsPack.set_bool(lt::settings_pack::allow_i2p_mixed, I2PMixedMode());
1658     }
1659     else
1660     {
1661         settingsPack.set_str(lt::settings_pack::i2p_hostname, "");
1662         settingsPack.set_int(lt::settings_pack::i2p_port, 0);
1663         settingsPack.set_bool(lt::settings_pack::allow_i2p_mixed, false);
1664     }
1665
1666     // proxy
1667     settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::none);
1668     if (Preferences::instance()->useProxyForBT())
1669     {
1670         const auto *proxyManager = Net::ProxyConfigurationManager::instance();
1671         const Net::ProxyConfiguration proxyConfig = proxyManager->proxyConfiguration();
1672
1673         switch (proxyConfig.type)
1674         {
1675         case Net::ProxyType::SOCKS4:
1676             settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks4);
1677             break;
1678
1679         case Net::ProxyType::HTTP:
1680             if (proxyConfig.authEnabled)
1681                 settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::http_pw);
1682             else
1683                 settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::http);
1684             break;
1685
1686         case Net::ProxyType::SOCKS5:
1687             if (proxyConfig.authEnabled)
1688                 settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks5_pw);
1689             else
1690                 settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks5);
1691             break;
1692
1693         default:
1694             break;
1695         }
1696
1697         settingsPack.set_str(lt::settings_pack::proxy_hostname, proxyConfig.ip.toStdString());
1698         settingsPack.set_int(lt::settings_pack::proxy_port, proxyConfig.port);
1699
1700         if (proxyConfig.authEnabled)
1701         {
1702             settingsPack.set_str(lt::settings_pack::proxy_username, proxyConfig.username.toStdString());
1703             settingsPack.set_str(lt::settings_pack::proxy_password, proxyConfig.password.toStdString());
1704         }
1705
1706         settingsPack.set_bool(lt::settings_pack::proxy_peer_connections, isProxyPeerConnectionsEnabled());
1707         settingsPack.set_bool(lt::settings_pack::proxy_hostnames, proxyConfig.hostnameLookupEnabled);
1708     }
1709
1710     settingsPack.set_bool(lt::settings_pack::announce_to_all_trackers, announceToAllTrackers());
1711     settingsPack.set_bool(lt::settings_pack::announce_to_all_tiers, announceToAllTiers());
1712
1713     settingsPack.set_int(lt::settings_pack::peer_turnover, peerTurnover());
1714     settingsPack.set_int(lt::settings_pack::peer_turnover_cutoff, peerTurnoverCutoff());
1715     settingsPack.set_int(lt::settings_pack::peer_turnover_interval, peerTurnoverInterval());
1716
1717     settingsPack.set_int(lt::settings_pack::max_out_request_queue, requestQueueSize());
1718
1719     settingsPack.set_int(lt::settings_pack::aio_threads, asyncIOThreads());
1720 #ifdef QBT_USES_LIBTORRENT2
1721     settingsPack.set_int(lt::settings_pack::hashing_threads, hashingThreads());
1722 #endif
1723     settingsPack.set_int(lt::settings_pack::file_pool_size, filePoolSize());
1724
1725     const int checkingMemUsageSize = checkingMemUsage() * 64;
1726     settingsPack.set_int(lt::settings_pack::checking_mem_usage, checkingMemUsageSize);
1727
1728 #ifndef QBT_USES_LIBTORRENT2
1729     const int cacheSize = (diskCacheSize() > -1) ? (diskCacheSize() * 64) : -1;
1730     settingsPack.set_int(lt::settings_pack::cache_size, cacheSize);
1731     settingsPack.set_int(lt::settings_pack::cache_expiry, diskCacheTTL());
1732 #endif
1733
1734     settingsPack.set_int(lt::settings_pack::max_queued_disk_bytes, diskQueueSize());
1735
1736     switch (diskIOReadMode())
1737     {
1738     case DiskIOReadMode::DisableOSCache:
1739         settingsPack.set_int(lt::settings_pack::disk_io_read_mode, lt::settings_pack::disable_os_cache);
1740         break;
1741     case DiskIOReadMode::EnableOSCache:
1742     default:
1743         settingsPack.set_int(lt::settings_pack::disk_io_read_mode, lt::settings_pack::enable_os_cache);
1744         break;
1745     }
1746
1747     switch (diskIOWriteMode())
1748     {
1749     case DiskIOWriteMode::DisableOSCache:
1750         settingsPack.set_int(lt::settings_pack::disk_io_write_mode, lt::settings_pack::disable_os_cache);
1751         break;
1752     case DiskIOWriteMode::EnableOSCache:
1753     default:
1754         settingsPack.set_int(lt::settings_pack::disk_io_write_mode, lt::settings_pack::enable_os_cache);
1755         break;
1756 #ifdef QBT_USES_LIBTORRENT2
1757     case DiskIOWriteMode::WriteThrough:
1758         settingsPack.set_int(lt::settings_pack::disk_io_write_mode, lt::settings_pack::write_through);
1759         break;
1760 #endif
1761     }
1762
1763 #ifndef QBT_USES_LIBTORRENT2
1764     settingsPack.set_bool(lt::settings_pack::coalesce_reads, isCoalesceReadWriteEnabled());
1765     settingsPack.set_bool(lt::settings_pack::coalesce_writes, isCoalesceReadWriteEnabled());
1766 #endif
1767
1768     settingsPack.set_bool(lt::settings_pack::piece_extent_affinity, usePieceExtentAffinity());
1769
1770     settingsPack.set_int(lt::settings_pack::suggest_mode, isSuggestModeEnabled()
1771                          ? lt::settings_pack::suggest_read_cache : lt::settings_pack::no_piece_suggestions);
1772
1773     settingsPack.set_int(lt::settings_pack::send_buffer_watermark, sendBufferWatermark() * 1024);
1774     settingsPack.set_int(lt::settings_pack::send_buffer_low_watermark, sendBufferLowWatermark() * 1024);
1775     settingsPack.set_int(lt::settings_pack::send_buffer_watermark_factor, sendBufferWatermarkFactor());
1776
1777     settingsPack.set_bool(lt::settings_pack::anonymous_mode, isAnonymousModeEnabled());
1778
1779     // Queueing System
1780     if (isQueueingSystemEnabled())
1781     {
1782         settingsPack.set_int(lt::settings_pack::active_downloads, maxActiveDownloads());
1783         settingsPack.set_int(lt::settings_pack::active_limit, maxActiveTorrents());
1784         settingsPack.set_int(lt::settings_pack::active_seeds, maxActiveUploads());
1785         settingsPack.set_bool(lt::settings_pack::dont_count_slow_torrents, ignoreSlowTorrentsForQueueing());
1786         settingsPack.set_int(lt::settings_pack::inactive_down_rate, downloadRateForSlowTorrents() * 1024); // KiB to Bytes
1787         settingsPack.set_int(lt::settings_pack::inactive_up_rate, uploadRateForSlowTorrents() * 1024); // KiB to Bytes
1788         settingsPack.set_int(lt::settings_pack::auto_manage_startup, slowTorrentsInactivityTimer());
1789     }
1790     else
1791     {
1792         settingsPack.set_int(lt::settings_pack::active_downloads, -1);
1793         settingsPack.set_int(lt::settings_pack::active_seeds, -1);
1794         settingsPack.set_int(lt::settings_pack::active_limit, -1);
1795     }
1796     settingsPack.set_int(lt::settings_pack::active_tracker_limit, -1);
1797     settingsPack.set_int(lt::settings_pack::active_dht_limit, -1);
1798     settingsPack.set_int(lt::settings_pack::active_lsd_limit, -1);
1799     settingsPack.set_int(lt::settings_pack::alert_queue_size, std::numeric_limits<int>::max() / 2);
1800
1801     // Outgoing ports
1802     settingsPack.set_int(lt::settings_pack::outgoing_port, outgoingPortsMin());
1803     settingsPack.set_int(lt::settings_pack::num_outgoing_ports, (outgoingPortsMax() - outgoingPortsMin()));
1804     // UPnP lease duration
1805     settingsPack.set_int(lt::settings_pack::upnp_lease_duration, UPnPLeaseDuration());
1806     // Type of service
1807     settingsPack.set_int(lt::settings_pack::peer_tos, peerToS());
1808     // Include overhead in transfer limits
1809     settingsPack.set_bool(lt::settings_pack::rate_limit_ip_overhead, includeOverheadInLimits());
1810     // IP address to announce to trackers
1811     settingsPack.set_str(lt::settings_pack::announce_ip, announceIP().toStdString());
1812     // Max concurrent HTTP announces
1813     settingsPack.set_int(lt::settings_pack::max_concurrent_http_announces, maxConcurrentHTTPAnnounces());
1814     // Stop tracker timeout
1815     settingsPack.set_int(lt::settings_pack::stop_tracker_timeout, stopTrackerTimeout());
1816     // * Max connections limit
1817     settingsPack.set_int(lt::settings_pack::connections_limit, maxConnections());
1818     // * Global max upload slots
1819     settingsPack.set_int(lt::settings_pack::unchoke_slots_limit, maxUploads());
1820     // uTP
1821     switch (btProtocol())
1822     {
1823     case BTProtocol::Both:
1824     default:
1825         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, true);
1826         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, true);
1827         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, true);
1828         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, true);
1829         break;
1830
1831     case BTProtocol::TCP:
1832         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, true);
1833         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, true);
1834         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, false);
1835         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, false);
1836         break;
1837
1838     case BTProtocol::UTP:
1839         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, false);
1840         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, false);
1841         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, true);
1842         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, true);
1843         break;
1844     }
1845
1846     switch (utpMixedMode())
1847     {
1848     case MixedModeAlgorithm::TCP:
1849     default:
1850         settingsPack.set_int(lt::settings_pack::mixed_mode_algorithm, lt::settings_pack::prefer_tcp);
1851         break;
1852     case MixedModeAlgorithm::Proportional:
1853         settingsPack.set_int(lt::settings_pack::mixed_mode_algorithm, lt::settings_pack::peer_proportional);
1854         break;
1855     }
1856
1857     settingsPack.set_bool(lt::settings_pack::allow_idna, isIDNSupportEnabled());
1858
1859     settingsPack.set_bool(lt::settings_pack::allow_multiple_connections_per_ip, multiConnectionsPerIpEnabled());
1860
1861     settingsPack.set_bool(lt::settings_pack::validate_https_trackers, validateHTTPSTrackerCertificate());
1862
1863     settingsPack.set_bool(lt::settings_pack::ssrf_mitigation, isSSRFMitigationEnabled());
1864
1865     settingsPack.set_bool(lt::settings_pack::no_connect_privileged_ports, blockPeersOnPrivilegedPorts());
1866
1867     settingsPack.set_bool(lt::settings_pack::apply_ip_filter_to_trackers, isTrackerFilteringEnabled());
1868
1869     settingsPack.set_bool(lt::settings_pack::enable_dht, isDHTEnabled());
1870     if (isDHTEnabled())
1871         settingsPack.set_str(lt::settings_pack::dht_bootstrap_nodes, "dht.libtorrent.org:25401,router.bittorrent.com:6881,router.utorrent.com:6881,dht.transmissionbt.com:6881,dht.aelitis.com:6881");
1872     settingsPack.set_bool(lt::settings_pack::enable_lsd, isLSDEnabled());
1873
1874     switch (chokingAlgorithm())
1875     {
1876     case ChokingAlgorithm::FixedSlots:
1877     default:
1878         settingsPack.set_int(lt::settings_pack::choking_algorithm, lt::settings_pack::fixed_slots_choker);
1879         break;
1880     case ChokingAlgorithm::RateBased:
1881         settingsPack.set_int(lt::settings_pack::choking_algorithm, lt::settings_pack::rate_based_choker);
1882         break;
1883     }
1884
1885     switch (seedChokingAlgorithm())
1886     {
1887     case SeedChokingAlgorithm::RoundRobin:
1888         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::round_robin);
1889         break;
1890     case SeedChokingAlgorithm::FastestUpload:
1891     default:
1892         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::fastest_upload);
1893         break;
1894     case SeedChokingAlgorithm::AntiLeech:
1895         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::anti_leech);
1896         break;
1897     }
1898
1899     return settingsPack;
1900 }
1901
1902 void SessionImpl::applyNetworkInterfacesSettings(lt::settings_pack &settingsPack) const
1903 {
1904     if (m_listenInterfaceConfigured)
1905         return;
1906
1907     if (port() > 0)  // user has specified port number
1908         settingsPack.set_int(lt::settings_pack::max_retry_port_bind, 0);
1909
1910     QStringList endpoints;
1911     QStringList outgoingInterfaces;
1912     const QString portString = u':' + QString::number(port());
1913
1914     for (const QString &ip : asConst(getListeningIPs()))
1915     {
1916         const QHostAddress addr {ip};
1917         if (!addr.isNull())
1918         {
1919             const bool isIPv6 = (addr.protocol() == QAbstractSocket::IPv6Protocol);
1920             const QString ip = isIPv6
1921                           ? Utils::Net::canonicalIPv6Addr(addr).toString()
1922                           : addr.toString();
1923
1924             endpoints << ((isIPv6 ? (u'[' + ip + u']') : ip) + portString);
1925
1926             if ((ip != u"0.0.0.0") && (ip != u"::"))
1927                 outgoingInterfaces << ip;
1928         }
1929         else
1930         {
1931             // ip holds an interface name
1932 #ifdef Q_OS_WIN
1933             // On Vista+ versions and after Qt 5.5 QNetworkInterface::name() returns
1934             // the interface's LUID and not the GUID.
1935             // Libtorrent expects GUIDs for the 'listen_interfaces' setting.
1936             const QString guid = convertIfaceNameToGuid(ip);
1937             if (!guid.isEmpty())
1938             {
1939                 endpoints << (guid + portString);
1940                 outgoingInterfaces << guid;
1941             }
1942             else
1943             {
1944                 LogMsg(tr("Could not find GUID of network interface. Interface: \"%1\"").arg(ip), Log::WARNING);
1945                 // Since we can't get the GUID, we'll pass the interface name instead.
1946                 // Otherwise an empty string will be passed to outgoing_interface which will cause IP leak.
1947                 endpoints << (ip + portString);
1948                 outgoingInterfaces << ip;
1949             }
1950 #else
1951             endpoints << (ip + portString);
1952             outgoingInterfaces << ip;
1953 #endif
1954         }
1955     }
1956
1957     const QString finalEndpoints = endpoints.join(u',');
1958     settingsPack.set_str(lt::settings_pack::listen_interfaces, finalEndpoints.toStdString());
1959     LogMsg(tr("Trying to listen on the following list of IP addresses: \"%1\"").arg(finalEndpoints));
1960
1961     settingsPack.set_str(lt::settings_pack::outgoing_interfaces, outgoingInterfaces.join(u',').toStdString());
1962     m_listenInterfaceConfigured = true;
1963 }
1964
1965 void SessionImpl::configurePeerClasses()
1966 {
1967     lt::ip_filter f;
1968     // lt::make_address("255.255.255.255") crashes on some people's systems
1969     // so instead we use address_v4::broadcast()
1970     // Proactively do the same for 0.0.0.0 and address_v4::any()
1971     f.add_rule(lt::address_v4::any()
1972                , lt::address_v4::broadcast()
1973                , 1 << LT::toUnderlyingType(lt::session::global_peer_class_id));
1974
1975     // IPv6 may not be available on OS and the parsing
1976     // would result in an exception -> abnormal program termination
1977     // Affects Windows XP
1978     try
1979     {
1980         f.add_rule(lt::address_v6::any()
1981                    , lt::make_address("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
1982                    , 1 << LT::toUnderlyingType(lt::session::global_peer_class_id));
1983     }
1984     catch (const std::exception &) {}
1985
1986     if (ignoreLimitsOnLAN())
1987     {
1988         // local networks
1989         f.add_rule(lt::make_address("10.0.0.0")
1990                    , lt::make_address("10.255.255.255")
1991                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
1992         f.add_rule(lt::make_address("172.16.0.0")
1993                    , lt::make_address("172.31.255.255")
1994                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
1995         f.add_rule(lt::make_address("192.168.0.0")
1996                    , lt::make_address("192.168.255.255")
1997                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
1998         // link local
1999         f.add_rule(lt::make_address("169.254.0.0")
2000                    , lt::make_address("169.254.255.255")
2001                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2002         // loopback
2003         f.add_rule(lt::make_address("127.0.0.0")
2004                    , lt::make_address("127.255.255.255")
2005                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2006
2007         // IPv6 may not be available on OS and the parsing
2008         // would result in an exception -> abnormal program termination
2009         // Affects Windows XP
2010         try
2011         {
2012             // link local
2013             f.add_rule(lt::make_address("fe80::")
2014                        , lt::make_address("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
2015                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2016             // unique local addresses
2017             f.add_rule(lt::make_address("fc00::")
2018                        , lt::make_address("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
2019                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2020             // loopback
2021             f.add_rule(lt::address_v6::loopback()
2022                        , lt::address_v6::loopback()
2023                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2024         }
2025         catch (const std::exception &) {}
2026     }
2027     m_nativeSession->set_peer_class_filter(f);
2028
2029     lt::peer_class_type_filter peerClassTypeFilter;
2030     peerClassTypeFilter.add(lt::peer_class_type_filter::tcp_socket, lt::session::tcp_peer_class_id);
2031     peerClassTypeFilter.add(lt::peer_class_type_filter::ssl_tcp_socket, lt::session::tcp_peer_class_id);
2032     peerClassTypeFilter.add(lt::peer_class_type_filter::i2p_socket, lt::session::tcp_peer_class_id);
2033     if (!isUTPRateLimited())
2034     {
2035         peerClassTypeFilter.disallow(lt::peer_class_type_filter::utp_socket
2036             , lt::session::global_peer_class_id);
2037         peerClassTypeFilter.disallow(lt::peer_class_type_filter::ssl_utp_socket
2038             , lt::session::global_peer_class_id);
2039     }
2040     m_nativeSession->set_peer_class_type_filter(peerClassTypeFilter);
2041 }
2042
2043 void SessionImpl::enableTracker(const bool enable)
2044 {
2045     const QString profile = u"embeddedTracker"_qs;
2046     auto *portForwarder = Net::PortForwarder::instance();
2047
2048     if (enable)
2049     {
2050         if (!m_tracker)
2051             m_tracker = new Tracker(this);
2052
2053         m_tracker->start();
2054
2055         const auto *pref = Preferences::instance();
2056         if (pref->isTrackerPortForwardingEnabled())
2057             portForwarder->setPorts(profile, {static_cast<quint16>(pref->getTrackerPort())});
2058         else
2059             portForwarder->removePorts(profile);
2060     }
2061     else
2062     {
2063         delete m_tracker;
2064
2065         portForwarder->removePorts(profile);
2066     }
2067 }
2068
2069 void SessionImpl::enableBandwidthScheduler()
2070 {
2071     if (!m_bwScheduler)
2072     {
2073         m_bwScheduler = new BandwidthScheduler(this);
2074         connect(m_bwScheduler.data(), &BandwidthScheduler::bandwidthLimitRequested
2075                 , this, &SessionImpl::setAltGlobalSpeedLimitEnabled);
2076     }
2077     m_bwScheduler->start();
2078 }
2079
2080 void SessionImpl::populateAdditionalTrackers()
2081 {
2082     m_additionalTrackerList.clear();
2083
2084     const QString trackers = additionalTrackers();
2085     for (QStringView tracker : asConst(QStringView(trackers).split(u'\n')))
2086     {
2087         tracker = tracker.trimmed();
2088         if (!tracker.isEmpty())
2089             m_additionalTrackerList.append({tracker.toString()});
2090     }
2091 }
2092
2093 void SessionImpl::processShareLimits()
2094 {
2095     qDebug("Processing share limits...");
2096
2097     // We shouldn't iterate over `m_torrents` in the loop below
2098     // since `deleteTorrent()` modifies it indirectly
2099     const QHash<TorrentID, TorrentImpl *> torrents {m_torrents};
2100     for (TorrentImpl *const torrent : torrents)
2101     {
2102         if (torrent->isFinished() && !torrent->isForced())
2103         {
2104             if (torrent->ratioLimit() != Torrent::NO_RATIO_LIMIT)
2105             {
2106                 const qreal ratio = torrent->realRatio();
2107                 qreal ratioLimit = torrent->ratioLimit();
2108                 if (ratioLimit == Torrent::USE_GLOBAL_RATIO)
2109                     // If Global Max Ratio is really set...
2110                     ratioLimit = globalMaxRatio();
2111
2112                 if (ratioLimit >= 0)
2113                 {
2114                     qDebug("Ratio: %f (limit: %f)", ratio, ratioLimit);
2115
2116                     if ((ratio <= Torrent::MAX_RATIO) && (ratio >= ratioLimit))
2117                     {
2118                         const QString description = tr("Torrent reached the share ratio limit.");
2119                         const QString torrentName = tr("Torrent: \"%1\".").arg(torrent->name());
2120
2121                         if (m_maxRatioAction == Remove)
2122                         {
2123                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Removed torrent."), torrentName));
2124                             deleteTorrent(torrent->id());
2125                         }
2126                         else if (m_maxRatioAction == DeleteFiles)
2127                         {
2128                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Removed torrent and deleted its content."), torrentName));
2129                             deleteTorrent(torrent->id(), DeleteTorrentAndFiles);
2130                         }
2131                         else if ((m_maxRatioAction == Pause) && !torrent->isPaused())
2132                         {
2133                             torrent->pause();
2134                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Torrent paused."), torrentName));
2135                         }
2136                         else if ((m_maxRatioAction == EnableSuperSeeding) && !torrent->isPaused() && !torrent->superSeeding())
2137                         {
2138                             torrent->setSuperSeeding(true);
2139                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Super seeding enabled."), torrentName));
2140                         }
2141
2142                         continue;
2143                     }
2144                 }
2145             }
2146
2147             if (torrent->seedingTimeLimit() != Torrent::NO_SEEDING_TIME_LIMIT)
2148             {
2149                 const qlonglong seedingTimeInMinutes = torrent->finishedTime() / 60;
2150                 int seedingTimeLimit = torrent->seedingTimeLimit();
2151                 if (seedingTimeLimit == Torrent::USE_GLOBAL_SEEDING_TIME)
2152                 {
2153                      // If Global Seeding Time Limit is really set...
2154                     seedingTimeLimit = globalMaxSeedingMinutes();
2155                 }
2156
2157                 if (seedingTimeLimit >= 0)
2158                 {
2159                     if ((seedingTimeInMinutes <= Torrent::MAX_SEEDING_TIME) && (seedingTimeInMinutes >= seedingTimeLimit))
2160                     {
2161                         const QString description = tr("Torrent reached the seeding time limit.");
2162                         const QString torrentName = tr("Torrent: \"%1\".").arg(torrent->name());
2163
2164                         if (m_maxRatioAction == Remove)
2165                         {
2166                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Removed torrent."), torrentName));
2167                             deleteTorrent(torrent->id());
2168                         }
2169                         else if (m_maxRatioAction == DeleteFiles)
2170                         {
2171                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Removed torrent and deleted its content."), torrentName));
2172                             deleteTorrent(torrent->id(), DeleteTorrentAndFiles);
2173                         }
2174                         else if ((m_maxRatioAction == Pause) && !torrent->isPaused())
2175                         {
2176                             torrent->pause();
2177                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Torrent paused."), torrentName));
2178                         }
2179                         else if ((m_maxRatioAction == EnableSuperSeeding) && !torrent->isPaused() && !torrent->superSeeding())
2180                         {
2181                             torrent->setSuperSeeding(true);
2182                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Super seeding enabled."), torrentName));
2183                         }
2184                     }
2185                 }
2186             }
2187         }
2188     }
2189 }
2190
2191 // Add to BitTorrent session the downloaded torrent file
2192 void SessionImpl::handleDownloadFinished(const Net::DownloadResult &result)
2193 {
2194     switch (result.status)
2195     {
2196     case Net::DownloadStatus::Success:
2197         emit downloadFromUrlFinished(result.url);
2198         if (const nonstd::expected<TorrentInfo, QString> loadResult = TorrentInfo::load(result.data); loadResult)
2199             addTorrent(loadResult.value(), m_downloadedTorrents.take(result.url));
2200         else
2201             LogMsg(tr("Failed to load torrent. Reason: \"%1\"").arg(loadResult.error()), Log::WARNING);
2202         break;
2203     case Net::DownloadStatus::RedirectedToMagnet:
2204         emit downloadFromUrlFinished(result.url);
2205         addTorrent(MagnetUri(result.magnet), m_downloadedTorrents.take(result.url));
2206         break;
2207     default:
2208         emit downloadFromUrlFailed(result.url, result.errorString);
2209     }
2210 }
2211
2212 void SessionImpl::fileSearchFinished(const TorrentID &id, const Path &savePath, const PathList &fileNames)
2213 {
2214     TorrentImpl *torrent = m_torrents.value(id);
2215     if (torrent)
2216     {
2217         torrent->fileSearchFinished(savePath, fileNames);
2218         return;
2219     }
2220
2221     const auto loadingTorrentsIter = m_loadingTorrents.find(id);
2222     if (loadingTorrentsIter != m_loadingTorrents.end())
2223     {
2224         LoadTorrentParams &params = loadingTorrentsIter.value();
2225         lt::add_torrent_params &p = params.ltAddTorrentParams;
2226
2227         p.save_path = savePath.toString().toStdString();
2228         const TorrentInfo torrentInfo {*p.ti};
2229         const auto nativeIndexes = torrentInfo.nativeIndexes();
2230         for (int i = 0; i < fileNames.size(); ++i)
2231             p.renamed_files[nativeIndexes[i]] = fileNames[i].toString().toStdString();
2232
2233         m_nativeSession->async_add_torrent(p);
2234     }
2235 }
2236
2237 Torrent *SessionImpl::getTorrent(const TorrentID &id) const
2238 {
2239     return m_torrents.value(id);
2240 }
2241
2242 Torrent *SessionImpl::findTorrent(const InfoHash &infoHash) const
2243 {
2244     const auto id = TorrentID::fromInfoHash(infoHash);
2245     if (Torrent *torrent = m_torrents.value(id); torrent)
2246         return torrent;
2247
2248     if (!infoHash.isHybrid())
2249         return m_hybridTorrentsByAltID.value(id);
2250
2251     // alternative ID can be useful to find existing torrent
2252     // in case if hybrid torrent was added by v1 info hash
2253     const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
2254     return m_torrents.value(altID);
2255 }
2256
2257 void SessionImpl::banIP(const QString &ip)
2258 {
2259     if (m_bannedIPs.get().contains(ip))
2260         return;
2261
2262     lt::error_code ec;
2263     const lt::address addr = lt::make_address(ip.toLatin1().constData(), ec);
2264     Q_ASSERT(!ec);
2265     if (ec)
2266         return;
2267
2268     invokeAsync([session = m_nativeSession, addr]
2269     {
2270         lt::ip_filter filter = session->get_ip_filter();
2271         filter.add_rule(addr, addr, lt::ip_filter::blocked);
2272         session->set_ip_filter(std::move(filter));
2273     });
2274
2275     QStringList bannedIPs = m_bannedIPs;
2276     bannedIPs.append(ip);
2277     bannedIPs.sort();
2278     m_bannedIPs = bannedIPs;
2279 }
2280
2281 // Delete a torrent from the session, given its hash
2282 // and from the disk, if the corresponding deleteOption is chosen
2283 bool SessionImpl::deleteTorrent(const TorrentID &id, const DeleteOption deleteOption)
2284 {
2285     TorrentImpl *const torrent = m_torrents.take(id);
2286     if (!torrent) return false;
2287
2288     qDebug("Deleting torrent with ID: %s", qUtf8Printable(torrent->id().toString()));
2289     emit torrentAboutToBeRemoved(torrent);
2290
2291     if (const InfoHash infoHash = torrent->infoHash(); infoHash.isHybrid())
2292         m_hybridTorrentsByAltID.remove(TorrentID::fromSHA1Hash(infoHash.v1()));
2293
2294     // Remove it from session
2295     if (deleteOption == DeleteTorrent)
2296     {
2297         m_removingTorrents[torrent->id()] = {torrent->name(), {}, deleteOption};
2298
2299         const lt::torrent_handle nativeHandle {torrent->nativeHandle()};
2300         const auto iter = std::find_if(m_moveStorageQueue.begin(), m_moveStorageQueue.end()
2301                                  , [&nativeHandle](const MoveStorageJob &job)
2302         {
2303             return job.torrentHandle == nativeHandle;
2304         });
2305         if (iter != m_moveStorageQueue.end())
2306         {
2307             // We shouldn't actually remove torrent until existing "move storage jobs" are done
2308             torrentQueuePositionBottom(nativeHandle);
2309             nativeHandle.unset_flags(lt::torrent_flags::auto_managed);
2310             nativeHandle.pause();
2311         }
2312         else
2313         {
2314             m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_partfile);
2315         }
2316     }
2317     else
2318     {
2319         m_removingTorrents[torrent->id()] = {torrent->name(), torrent->rootPath(), deleteOption};
2320
2321         if (m_moveStorageQueue.size() > 1)
2322         {
2323             // Delete "move storage job" for the deleted torrent
2324             // (note: we shouldn't delete active job)
2325             const auto iter = std::find_if((m_moveStorageQueue.begin() + 1), m_moveStorageQueue.end()
2326                                      , [torrent](const MoveStorageJob &job)
2327             {
2328                 return job.torrentHandle == torrent->nativeHandle();
2329             });
2330             if (iter != m_moveStorageQueue.end())
2331                 m_moveStorageQueue.erase(iter);
2332         }
2333
2334         m_nativeSession->remove_torrent(torrent->nativeHandle(), lt::session::delete_files);
2335     }
2336
2337     // Remove it from torrent resume directory
2338     m_resumeDataStorage->remove(torrent->id());
2339
2340     delete torrent;
2341     return true;
2342 }
2343
2344 bool SessionImpl::cancelDownloadMetadata(const TorrentID &id)
2345 {
2346     const auto downloadedMetadataIter = m_downloadedMetadata.find(id);
2347     if (downloadedMetadataIter == m_downloadedMetadata.end())
2348         return false;
2349
2350     const lt::torrent_handle nativeHandle = downloadedMetadataIter.value();
2351 #ifdef QBT_USES_LIBTORRENT2
2352     const InfoHash infoHash {nativeHandle.info_hashes()};
2353     if (infoHash.isHybrid())
2354     {
2355         // if magnet link was hybrid initially then it is indexed also by v1 info hash
2356         // so we need to remove both entries
2357         const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
2358         m_downloadedMetadata.remove((altID == downloadedMetadataIter.key()) ? id : altID);
2359     }
2360 #endif
2361     m_downloadedMetadata.erase(downloadedMetadataIter);
2362     m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_files);
2363     return true;
2364 }
2365
2366 void SessionImpl::increaseTorrentsQueuePos(const QVector<TorrentID> &ids)
2367 {
2368     using ElementType = std::pair<int, const TorrentImpl *>;
2369     std::priority_queue<ElementType
2370         , std::vector<ElementType>
2371         , std::greater<ElementType>> torrentQueue;
2372
2373     // Sort torrents by queue position
2374     for (const TorrentID &id : ids)
2375     {
2376         const TorrentImpl *torrent = m_torrents.value(id);
2377         if (!torrent) continue;
2378         if (const int position = torrent->queuePosition(); position >= 0)
2379             torrentQueue.emplace(position, torrent);
2380     }
2381
2382     // Increase torrents queue position (starting with the one in the highest queue position)
2383     while (!torrentQueue.empty())
2384     {
2385         const TorrentImpl *torrent = torrentQueue.top().second;
2386         torrentQueuePositionUp(torrent->nativeHandle());
2387         torrentQueue.pop();
2388     }
2389
2390     m_torrentsQueueChanged = true;
2391 }
2392
2393 void SessionImpl::decreaseTorrentsQueuePos(const QVector<TorrentID> &ids)
2394 {
2395     using ElementType = std::pair<int, const TorrentImpl *>;
2396     std::priority_queue<ElementType> torrentQueue;
2397
2398     // Sort torrents by queue position
2399     for (const TorrentID &id : ids)
2400     {
2401         const TorrentImpl *torrent = m_torrents.value(id);
2402         if (!torrent) continue;
2403         if (const int position = torrent->queuePosition(); position >= 0)
2404             torrentQueue.emplace(position, torrent);
2405     }
2406
2407     // Decrease torrents queue position (starting with the one in the lowest queue position)
2408     while (!torrentQueue.empty())
2409     {
2410         const TorrentImpl *torrent = torrentQueue.top().second;
2411         torrentQueuePositionDown(torrent->nativeHandle());
2412         torrentQueue.pop();
2413     }
2414
2415     for (const lt::torrent_handle &torrentHandle : asConst(m_downloadedMetadata))
2416         torrentQueuePositionBottom(torrentHandle);
2417
2418     m_torrentsQueueChanged = true;
2419 }
2420
2421 void SessionImpl::topTorrentsQueuePos(const QVector<TorrentID> &ids)
2422 {
2423     using ElementType = std::pair<int, const TorrentImpl *>;
2424     std::priority_queue<ElementType> torrentQueue;
2425
2426     // Sort torrents by queue position
2427     for (const TorrentID &id : ids)
2428     {
2429         const TorrentImpl *torrent = m_torrents.value(id);
2430         if (!torrent) continue;
2431         if (const int position = torrent->queuePosition(); position >= 0)
2432             torrentQueue.emplace(position, torrent);
2433     }
2434
2435     // Top torrents queue position (starting with the one in the lowest queue position)
2436     while (!torrentQueue.empty())
2437     {
2438         const TorrentImpl *torrent = torrentQueue.top().second;
2439         torrentQueuePositionTop(torrent->nativeHandle());
2440         torrentQueue.pop();
2441     }
2442
2443     m_torrentsQueueChanged = true;
2444 }
2445
2446 void SessionImpl::bottomTorrentsQueuePos(const QVector<TorrentID> &ids)
2447 {
2448     using ElementType = std::pair<int, const TorrentImpl *>;
2449     std::priority_queue<ElementType
2450         , std::vector<ElementType>
2451         , std::greater<ElementType>> torrentQueue;
2452
2453     // Sort torrents by queue position
2454     for (const TorrentID &id : ids)
2455     {
2456         const TorrentImpl *torrent = m_torrents.value(id);
2457         if (!torrent) continue;
2458         if (const int position = torrent->queuePosition(); position >= 0)
2459             torrentQueue.emplace(position, torrent);
2460     }
2461
2462     // Bottom torrents queue position (starting with the one in the highest queue position)
2463     while (!torrentQueue.empty())
2464     {
2465         const TorrentImpl *torrent = torrentQueue.top().second;
2466         torrentQueuePositionBottom(torrent->nativeHandle());
2467         torrentQueue.pop();
2468     }
2469
2470     for (const lt::torrent_handle &torrentHandle : asConst(m_downloadedMetadata))
2471         torrentQueuePositionBottom(torrentHandle);
2472
2473     m_torrentsQueueChanged = true;
2474 }
2475
2476 void SessionImpl::handleTorrentNeedSaveResumeData(const TorrentImpl *torrent)
2477 {
2478     if (m_needSaveResumeDataTorrents.empty())
2479     {
2480         QMetaObject::invokeMethod(this, [this]()
2481         {
2482             for (const TorrentID &torrentID : asConst(m_needSaveResumeDataTorrents))
2483             {
2484                 TorrentImpl *torrent = m_torrents.value(torrentID);
2485                 if (torrent)
2486                     torrent->saveResumeData();
2487             }
2488             m_needSaveResumeDataTorrents.clear();
2489         }, Qt::QueuedConnection);
2490     }
2491
2492     m_needSaveResumeDataTorrents.insert(torrent->id());
2493 }
2494
2495 void SessionImpl::handleTorrentSaveResumeDataRequested(const TorrentImpl *torrent)
2496 {
2497     qDebug("Saving resume data is requested for torrent '%s'...", qUtf8Printable(torrent->name()));
2498     ++m_numResumeData;
2499 }
2500
2501 void SessionImpl::handleTorrentSaveResumeDataFailed(const TorrentImpl *torrent)
2502 {
2503     Q_UNUSED(torrent);
2504     --m_numResumeData;
2505 }
2506
2507 QVector<Torrent *> SessionImpl::torrents() const
2508 {
2509     QVector<Torrent *> result;
2510     result.reserve(m_torrents.size());
2511     for (TorrentImpl *torrent : asConst(m_torrents))
2512         result << torrent;
2513
2514     return result;
2515 }
2516
2517 qsizetype SessionImpl::torrentsCount() const
2518 {
2519     return m_torrents.size();
2520 }
2521
2522 bool SessionImpl::addTorrent(const QString &source, const AddTorrentParams &params)
2523 {
2524     // `source`: .torrent file path/url or magnet uri
2525
2526     if (!isRestored())
2527         return false;
2528
2529     if (Net::DownloadManager::hasSupportedScheme(source))
2530     {
2531         LogMsg(tr("Downloading torrent, please wait... Source: \"%1\"").arg(source));
2532         // Launch downloader
2533         Net::DownloadManager::instance()->download(Net::DownloadRequest(source).limit(MAX_TORRENT_SIZE)
2534                 , Preferences::instance()->useProxyForGeneralPurposes(), this, &SessionImpl::handleDownloadFinished);
2535         m_downloadedTorrents[source] = params;
2536         return true;
2537     }
2538
2539     const MagnetUri magnetUri {source};
2540     if (magnetUri.isValid())
2541         return addTorrent(magnetUri, params);
2542
2543     const Path path {source};
2544     TorrentFileGuard guard {path};
2545     const nonstd::expected<TorrentInfo, QString> loadResult = TorrentInfo::loadFromFile(path);
2546     if (!loadResult)
2547     {
2548        LogMsg(tr("Failed to load torrent. Source: \"%1\". Reason: \"%2\"").arg(source, loadResult.error()), Log::WARNING);
2549        return false;
2550     }
2551
2552     guard.markAsAddedToSession();
2553     return addTorrent(loadResult.value(), params);
2554 }
2555
2556 bool SessionImpl::addTorrent(const MagnetUri &magnetUri, const AddTorrentParams &params)
2557 {
2558     if (!isRestored())
2559         return false;
2560
2561     if (!magnetUri.isValid())
2562         return false;
2563
2564     return addTorrent_impl(magnetUri, params);
2565 }
2566
2567 bool SessionImpl::addTorrent(const TorrentInfo &torrentInfo, const AddTorrentParams &params)
2568 {
2569     if (!isRestored())
2570         return false;
2571
2572     return addTorrent_impl(torrentInfo, params);
2573 }
2574
2575 LoadTorrentParams SessionImpl::initLoadTorrentParams(const AddTorrentParams &addTorrentParams)
2576 {
2577     LoadTorrentParams loadTorrentParams;
2578
2579     loadTorrentParams.name = addTorrentParams.name;
2580     loadTorrentParams.firstLastPiecePriority = addTorrentParams.firstLastPiecePriority;
2581     loadTorrentParams.hasFinishedStatus = addTorrentParams.skipChecking; // do not react on 'torrent_finished_alert' when skipping
2582     loadTorrentParams.contentLayout = addTorrentParams.contentLayout.value_or(torrentContentLayout());
2583     loadTorrentParams.operatingMode = (addTorrentParams.addForced ? TorrentOperatingMode::Forced : TorrentOperatingMode::AutoManaged);
2584     loadTorrentParams.stopped = addTorrentParams.addPaused.value_or(isAddTorrentPaused());
2585     loadTorrentParams.stopCondition = addTorrentParams.stopCondition.value_or(torrentStopCondition());
2586     loadTorrentParams.addToQueueTop = addTorrentParams.addToQueueTop.value_or(isAddTorrentToQueueTop());
2587     loadTorrentParams.ratioLimit = addTorrentParams.ratioLimit;
2588     loadTorrentParams.seedingTimeLimit = addTorrentParams.seedingTimeLimit;
2589
2590     const QString category = addTorrentParams.category;
2591     if (!category.isEmpty() && !m_categories.contains(category) && !addCategory(category))
2592         loadTorrentParams.category = u""_qs;
2593     else
2594         loadTorrentParams.category = category;
2595
2596     const auto defaultSavePath = suggestedSavePath(loadTorrentParams.category, addTorrentParams.useAutoTMM);
2597     const auto defaultDownloadPath = suggestedDownloadPath(loadTorrentParams.category, addTorrentParams.useAutoTMM);
2598
2599     loadTorrentParams.useAutoTMM = addTorrentParams.useAutoTMM.value_or(!isAutoTMMDisabledByDefault());
2600
2601     if (!addTorrentParams.useAutoTMM.has_value())
2602     {
2603         // Default TMM settings
2604
2605         if (!loadTorrentParams.useAutoTMM)
2606         {
2607             loadTorrentParams.savePath = defaultSavePath;
2608             if (isDownloadPathEnabled())
2609                 loadTorrentParams.downloadPath = (!defaultDownloadPath.isEmpty() ? defaultDownloadPath : downloadPath());
2610         }
2611     }
2612     else
2613     {
2614         // Overridden TMM settings
2615
2616         if (!loadTorrentParams.useAutoTMM)
2617         {
2618             if (addTorrentParams.savePath.isAbsolute())
2619                 loadTorrentParams.savePath = addTorrentParams.savePath;
2620             else
2621                 loadTorrentParams.savePath = defaultSavePath / addTorrentParams.savePath;
2622
2623             if (!addTorrentParams.useDownloadPath.has_value())
2624             {
2625                 // Default "Download path" settings
2626
2627                 if (isDownloadPathEnabled())
2628                     loadTorrentParams.downloadPath = (!defaultDownloadPath.isEmpty() ? defaultDownloadPath : downloadPath());
2629             }
2630             else if (addTorrentParams.useDownloadPath.value())
2631             {
2632                 // Overridden "Download path" settings
2633
2634                 if (addTorrentParams.downloadPath.isAbsolute())
2635                 {
2636                     loadTorrentParams.downloadPath = addTorrentParams.downloadPath;
2637                 }
2638                 else
2639                 {
2640                     const Path basePath = (!defaultDownloadPath.isEmpty() ? defaultDownloadPath : downloadPath());
2641                     loadTorrentParams.downloadPath = basePath / addTorrentParams.downloadPath;
2642                 }
2643             }
2644         }
2645     }
2646
2647     for (const QString &tag : addTorrentParams.tags)
2648     {
2649         if (hasTag(tag) || addTag(tag))
2650             loadTorrentParams.tags.insert(tag);
2651     }
2652
2653     return loadTorrentParams;
2654 }
2655
2656 // Add a torrent to the BitTorrent session
2657 bool SessionImpl::addTorrent_impl(const std::variant<MagnetUri, TorrentInfo> &source, const AddTorrentParams &addTorrentParams)
2658 {
2659     Q_ASSERT(isRestored());
2660
2661     const bool hasMetadata = std::holds_alternative<TorrentInfo>(source);
2662     const auto infoHash = (hasMetadata ? std::get<TorrentInfo>(source).infoHash() : std::get<MagnetUri>(source).infoHash());
2663     const auto id = TorrentID::fromInfoHash(infoHash);
2664
2665     // alternative ID can be useful to find existing torrent in case if hybrid torrent was added by v1 info hash
2666     const auto altID = (infoHash.isHybrid() ? TorrentID::fromSHA1Hash(infoHash.v1()) : TorrentID());
2667
2668     // We should not add the torrent if it is already
2669     // processed or is pending to add to session
2670     if (m_loadingTorrents.contains(id) || (infoHash.isHybrid() && m_loadingTorrents.contains(altID)))
2671         return false;
2672
2673     if (Torrent *torrent = findTorrent(infoHash); torrent)
2674     {
2675         if (hasMetadata)
2676         {
2677             // Trying to set metadata to existing torrent in case if it has none
2678             torrent->setMetadata(std::get<TorrentInfo>(source));
2679         }
2680
2681         return false;
2682     }
2683
2684     // It looks illogical that we don't just use an existing handle,
2685     // but as previous experience has shown, it actually creates unnecessary
2686     // problems and unwanted behavior due to the fact that it was originally
2687     // added with parameters other than those provided by the user.
2688     cancelDownloadMetadata(id);
2689     if (infoHash.isHybrid())
2690         cancelDownloadMetadata(altID);
2691
2692     LoadTorrentParams loadTorrentParams = initLoadTorrentParams(addTorrentParams);
2693     lt::add_torrent_params &p = loadTorrentParams.ltAddTorrentParams;
2694
2695     bool isFindingIncompleteFiles = false;
2696
2697     const bool useAutoTMM = loadTorrentParams.useAutoTMM;
2698     const Path actualSavePath = useAutoTMM ? categorySavePath(loadTorrentParams.category) : loadTorrentParams.savePath;
2699
2700     if (hasMetadata)
2701     {
2702         const TorrentInfo &torrentInfo = std::get<TorrentInfo>(source);
2703
2704         Q_ASSERT(addTorrentParams.filePaths.isEmpty() || (addTorrentParams.filePaths.size() == torrentInfo.filesCount()));
2705
2706         PathList filePaths = addTorrentParams.filePaths;
2707         if (filePaths.isEmpty())
2708         {
2709             filePaths = torrentInfo.filePaths();
2710             if (loadTorrentParams.contentLayout != TorrentContentLayout::Original)
2711             {
2712                 const Path originalRootFolder = Path::findRootFolder(filePaths);
2713                 const auto originalContentLayout = (originalRootFolder.isEmpty()
2714                                                     ? TorrentContentLayout::NoSubfolder
2715                                                     : TorrentContentLayout::Subfolder);
2716                 if (loadTorrentParams.contentLayout != originalContentLayout)
2717                 {
2718                     if (loadTorrentParams.contentLayout == TorrentContentLayout::NoSubfolder)
2719                         Path::stripRootFolder(filePaths);
2720                     else
2721                         Path::addRootFolder(filePaths, filePaths.at(0).removedExtension());
2722                 }
2723             }
2724         }
2725
2726         // if torrent name wasn't explicitly set we handle the case of
2727         // initial renaming of torrent content and rename torrent accordingly
2728         if (loadTorrentParams.name.isEmpty())
2729         {
2730             QString contentName = Path::findRootFolder(filePaths).toString();
2731             if (contentName.isEmpty() && (filePaths.size() == 1))
2732                 contentName = filePaths.at(0).filename();
2733
2734             if (!contentName.isEmpty() && (contentName != torrentInfo.name()))
2735                 loadTorrentParams.name = contentName;
2736         }
2737
2738         if (!loadTorrentParams.hasFinishedStatus)
2739         {
2740             const Path actualDownloadPath = useAutoTMM
2741                     ? categoryDownloadPath(loadTorrentParams.category) : loadTorrentParams.downloadPath;
2742             findIncompleteFiles(torrentInfo, actualSavePath, actualDownloadPath, filePaths);
2743             isFindingIncompleteFiles = true;
2744         }
2745
2746         const auto nativeIndexes = torrentInfo.nativeIndexes();
2747         if (!isFindingIncompleteFiles)
2748         {
2749             for (int index = 0; index < filePaths.size(); ++index)
2750                 p.renamed_files[nativeIndexes[index]] = filePaths.at(index).toString().toStdString();
2751         }
2752
2753         Q_ASSERT(p.file_priorities.empty());
2754         Q_ASSERT(addTorrentParams.filePriorities.isEmpty() || (addTorrentParams.filePriorities.size() == nativeIndexes.size()));
2755
2756         const int internalFilesCount = torrentInfo.nativeInfo()->files().num_files(); // including .pad files
2757         // Use qBittorrent default priority rather than libtorrent's (4)
2758         p.file_priorities = std::vector(internalFilesCount, LT::toNative(DownloadPriority::Normal));
2759
2760         if (addTorrentParams.filePriorities.isEmpty())
2761         {
2762             if (isExcludedFileNamesEnabled())
2763             {
2764                 // Check file name blacklist when priorities are not explicitly set
2765                 for (int i = 0; i < filePaths.size(); ++i)
2766                 {
2767                     if (isFilenameExcluded(filePaths.at(i).filename()))
2768                         p.file_priorities[LT::toUnderlyingType(nativeIndexes[i])] = lt::dont_download;
2769                 }
2770             }
2771         }
2772         else
2773         {
2774             for (int i = 0; i < addTorrentParams.filePriorities.size(); ++i)
2775                 p.file_priorities[LT::toUnderlyingType(nativeIndexes[i])] = LT::toNative(addTorrentParams.filePriorities[i]);
2776         }
2777
2778         p.ti = torrentInfo.nativeInfo();
2779     }
2780     else
2781     {
2782         const MagnetUri &magnetUri = std::get<MagnetUri>(source);
2783         p = magnetUri.addTorrentParams();
2784
2785         if (loadTorrentParams.name.isEmpty() && !p.name.empty())
2786             loadTorrentParams.name = QString::fromStdString(p.name);
2787     }
2788
2789     p.save_path = actualSavePath.toString().toStdString();
2790
2791     if (isAddTrackersEnabled() && !(hasMetadata && p.ti->priv()))
2792     {
2793         p.trackers.reserve(p.trackers.size() + static_cast<std::size_t>(m_additionalTrackerList.size()));
2794         p.tracker_tiers.reserve(p.trackers.size() + static_cast<std::size_t>(m_additionalTrackerList.size()));
2795         p.tracker_tiers.resize(p.trackers.size(), 0);
2796         for (const TrackerEntry &trackerEntry : asConst(m_additionalTrackerList))
2797         {
2798             p.trackers.push_back(trackerEntry.url.toStdString());
2799             p.tracker_tiers.push_back(trackerEntry.tier);
2800         }
2801     }
2802
2803     p.upload_limit = addTorrentParams.uploadLimit;
2804     p.download_limit = addTorrentParams.downloadLimit;
2805
2806     // Preallocation mode
2807     p.storage_mode = isPreallocationEnabled() ? lt::storage_mode_allocate : lt::storage_mode_sparse;
2808
2809     if (addTorrentParams.sequential)
2810         p.flags |= lt::torrent_flags::sequential_download;
2811     else
2812         p.flags &= ~lt::torrent_flags::sequential_download;
2813
2814     // Seeding mode
2815     // Skip checking and directly start seeding
2816     if (addTorrentParams.skipChecking)
2817         p.flags |= lt::torrent_flags::seed_mode;
2818     else
2819         p.flags &= ~lt::torrent_flags::seed_mode;
2820
2821     if (loadTorrentParams.stopped || (loadTorrentParams.operatingMode == TorrentOperatingMode::AutoManaged))
2822         p.flags |= lt::torrent_flags::paused;
2823     else
2824         p.flags &= ~lt::torrent_flags::paused;
2825     if (loadTorrentParams.stopped || (loadTorrentParams.operatingMode == TorrentOperatingMode::Forced))
2826         p.flags &= ~lt::torrent_flags::auto_managed;
2827     else
2828         p.flags |= lt::torrent_flags::auto_managed;
2829
2830     p.flags |= lt::torrent_flags::duplicate_is_error;
2831
2832     p.added_time = std::time(nullptr);
2833
2834     // Limits
2835     p.max_connections = maxConnectionsPerTorrent();
2836     p.max_uploads = maxUploadsPerTorrent();
2837
2838     p.userdata = LTClientData(new ExtensionData);
2839 #ifndef QBT_USES_LIBTORRENT2
2840     p.storage = customStorageConstructor;
2841 #endif
2842
2843     m_loadingTorrents.insert(id, loadTorrentParams);
2844     if (infoHash.isHybrid())
2845         m_hybridTorrentsByAltID.insert(altID, nullptr);
2846     if (!isFindingIncompleteFiles)
2847         m_nativeSession->async_add_torrent(p);
2848
2849     return true;
2850 }
2851
2852 void SessionImpl::findIncompleteFiles(const TorrentInfo &torrentInfo, const Path &savePath
2853                                   , const Path &downloadPath, const PathList &filePaths) const
2854 {
2855     Q_ASSERT(filePaths.isEmpty() || (filePaths.size() == torrentInfo.filesCount()));
2856
2857     const auto searchId = TorrentID::fromInfoHash(torrentInfo.infoHash());
2858     const PathList originalFileNames = (filePaths.isEmpty() ? torrentInfo.filePaths() : filePaths);
2859     QMetaObject::invokeMethod(m_fileSearcher, [=]()
2860     {
2861         m_fileSearcher->search(searchId, originalFileNames, savePath, downloadPath, isAppendExtensionEnabled());
2862     });
2863 }
2864
2865 void SessionImpl::enablePortMapping()
2866 {
2867     invokeAsync([this]
2868     {
2869         if (m_isPortMappingEnabled)
2870             return;
2871
2872         lt::settings_pack settingsPack;
2873         settingsPack.set_bool(lt::settings_pack::enable_upnp, true);
2874         settingsPack.set_bool(lt::settings_pack::enable_natpmp, true);
2875         m_nativeSession->apply_settings(std::move(settingsPack));
2876
2877         m_isPortMappingEnabled = true;
2878
2879         LogMsg(tr("UPnP/NAT-PMP support: ON"), Log::INFO);
2880     });
2881 }
2882
2883 void SessionImpl::disablePortMapping()
2884 {
2885     invokeAsync([this]
2886     {
2887         if (!m_isPortMappingEnabled)
2888             return;
2889
2890         lt::settings_pack settingsPack;
2891         settingsPack.set_bool(lt::settings_pack::enable_upnp, false);
2892         settingsPack.set_bool(lt::settings_pack::enable_natpmp, false);
2893         m_nativeSession->apply_settings(std::move(settingsPack));
2894
2895         m_mappedPorts.clear();
2896         m_isPortMappingEnabled = false;
2897
2898         LogMsg(tr("UPnP/NAT-PMP support: OFF"), Log::INFO);
2899     });
2900 }
2901
2902 void SessionImpl::addMappedPorts(const QSet<quint16> &ports)
2903 {
2904     invokeAsync([this, ports]
2905     {
2906         if (!m_isPortMappingEnabled)
2907             return;
2908
2909         for (const quint16 port : ports)
2910         {
2911             if (!m_mappedPorts.contains(port))
2912                 m_mappedPorts.insert(port, m_nativeSession->add_port_mapping(lt::session::tcp, port, port));
2913         }
2914     });
2915 }
2916
2917 void SessionImpl::removeMappedPorts(const QSet<quint16> &ports)
2918 {
2919     invokeAsync([this, ports]
2920     {
2921         if (!m_isPortMappingEnabled)
2922             return;
2923
2924         Algorithm::removeIf(m_mappedPorts, [this, ports](const quint16 port, const std::vector<lt::port_mapping_t> &handles)
2925         {
2926             if (!ports.contains(port))
2927                 return false;
2928
2929             for (const lt::port_mapping_t &handle : handles)
2930                 m_nativeSession->delete_port_mapping(handle);
2931
2932             return true;
2933         });
2934     });
2935 }
2936
2937 void SessionImpl::invokeAsync(std::function<void ()> func)
2938 {
2939     m_asyncWorker->start(std::move(func));
2940 }
2941
2942 // Add a torrent to libtorrent session in hidden mode
2943 // and force it to download its metadata
2944 bool SessionImpl::downloadMetadata(const MagnetUri &magnetUri)
2945 {
2946     if (!magnetUri.isValid())
2947         return false;
2948
2949     const InfoHash infoHash = magnetUri.infoHash();
2950
2951     // We should not add torrent if it's already
2952     // processed or adding to session
2953     if (isKnownTorrent(infoHash))
2954         return false;
2955
2956     lt::add_torrent_params p = magnetUri.addTorrentParams();
2957
2958     if (isAddTrackersEnabled())
2959     {
2960         // Use "additional trackers" when metadata retrieving (this can help when the DHT nodes are few)
2961         p.trackers.reserve(p.trackers.size() + static_cast<std::size_t>(m_additionalTrackerList.size()));
2962         p.tracker_tiers.reserve(p.trackers.size() + static_cast<std::size_t>(m_additionalTrackerList.size()));
2963         p.tracker_tiers.resize(p.trackers.size(), 0);
2964         for (const TrackerEntry &trackerEntry : asConst(m_additionalTrackerList))
2965         {
2966             p.trackers.push_back(trackerEntry.url.toStdString());
2967             p.tracker_tiers.push_back(trackerEntry.tier);
2968         }
2969     }
2970
2971     // Flags
2972     // Preallocation mode
2973     if (isPreallocationEnabled())
2974         p.storage_mode = lt::storage_mode_allocate;
2975     else
2976         p.storage_mode = lt::storage_mode_sparse;
2977
2978     // Limits
2979     p.max_connections = maxConnectionsPerTorrent();
2980     p.max_uploads = maxUploadsPerTorrent();
2981
2982     const auto id = TorrentID::fromInfoHash(infoHash);
2983     const Path savePath = Utils::Fs::tempPath() / Path(id.toString());
2984     p.save_path = savePath.toString().toStdString();
2985
2986     // Forced start
2987     p.flags &= ~lt::torrent_flags::paused;
2988     p.flags &= ~lt::torrent_flags::auto_managed;
2989
2990     // Solution to avoid accidental file writes
2991     p.flags |= lt::torrent_flags::upload_mode;
2992
2993 #ifndef QBT_USES_LIBTORRENT2
2994     p.storage = customStorageConstructor;
2995 #endif
2996
2997     // Adding torrent to libtorrent session
2998     m_nativeSession->async_add_torrent(p);
2999     m_downloadedMetadata.insert(id, {});
3000
3001     return true;
3002 }
3003
3004 void SessionImpl::exportTorrentFile(const Torrent *torrent, const Path &folderPath)
3005 {
3006     if (!folderPath.exists() && !Utils::Fs::mkpath(folderPath))
3007         return;
3008
3009     const QString validName = Utils::Fs::toValidFileName(torrent->name());
3010     QString torrentExportFilename = u"%1.torrent"_qs.arg(validName);
3011     Path newTorrentPath = folderPath / Path(torrentExportFilename);
3012     int counter = 0;
3013     while (newTorrentPath.exists())
3014     {
3015         // Append number to torrent name to make it unique
3016         torrentExportFilename = u"%1 %2.torrent"_qs.arg(validName).arg(++counter);
3017         newTorrentPath = folderPath / Path(torrentExportFilename);
3018     }
3019
3020     const nonstd::expected<void, QString> result = torrent->exportToFile(newTorrentPath);
3021     if (!result)
3022     {
3023         LogMsg(tr("Failed to export torrent. Torrent: \"%1\". Destination: \"%2\". Reason: \"%3\"")
3024                .arg(torrent->name(), newTorrentPath.toString(), result.error()), Log::WARNING);
3025     }
3026 }
3027
3028 void SessionImpl::generateResumeData()
3029 {
3030     for (TorrentImpl *const torrent : asConst(m_torrents))
3031     {
3032         if (!torrent->isValid()) continue;
3033
3034         if (torrent->needSaveResumeData())
3035         {
3036             torrent->saveResumeData();
3037             m_needSaveResumeDataTorrents.remove(torrent->id());
3038         }
3039     }
3040 }
3041
3042 // Called on exit
3043 void SessionImpl::saveResumeData()
3044 {
3045     for (const TorrentImpl *torrent : asConst(m_torrents))
3046         torrent->nativeHandle().save_resume_data(lt::torrent_handle::only_if_modified);
3047     m_numResumeData += m_torrents.size();
3048
3049     // clear queued storage move jobs except the current ongoing one
3050     if (m_moveStorageQueue.size() > 1)
3051     {
3052 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
3053         m_moveStorageQueue = m_moveStorageQueue.mid(0, 1);
3054 #else
3055         m_moveStorageQueue.resize(1);
3056 #endif
3057     }
3058
3059     QElapsedTimer timer;
3060     timer.start();
3061
3062     while ((m_numResumeData > 0) || !m_moveStorageQueue.isEmpty() || m_needSaveTorrentsQueue)
3063     {
3064         const lt::seconds waitTime {5};
3065         const lt::seconds expireTime {30};
3066
3067         // only terminate when no storage is moving
3068         if (timer.hasExpired(lt::total_milliseconds(expireTime)) && m_moveStorageQueue.isEmpty())
3069         {
3070             LogMsg(tr("Aborted saving resume data. Number of outstanding torrents: %1").arg(QString::number(m_numResumeData))
3071                 , Log::CRITICAL);
3072             break;
3073         }
3074
3075         const std::vector<lt::alert *> alerts = getPendingAlerts(waitTime);
3076
3077         bool hasWantedAlert = false;
3078         for (const lt::alert *a : alerts)
3079         {
3080             if (const int alertType = a->type();
3081                 (alertType == lt::save_resume_data_alert::alert_type) || (alertType == lt::save_resume_data_failed_alert::alert_type)
3082                 || (alertType == lt::storage_moved_alert::alert_type) || (alertType == lt::storage_moved_failed_alert::alert_type)
3083                 || (alertType == lt::state_update_alert::alert_type))
3084             {
3085                 hasWantedAlert = true;
3086             }
3087
3088             handleAlert(a);
3089         }
3090
3091         if (hasWantedAlert)
3092             timer.start();
3093     }
3094 }
3095
3096 void SessionImpl::saveTorrentsQueue()
3097 {
3098     QVector<TorrentID> queue;
3099     for (const TorrentImpl *torrent : asConst(m_torrents))
3100     {
3101         if (const int queuePos = torrent->queuePosition(); queuePos >= 0)
3102         {
3103             if (queuePos >= queue.size())
3104                 queue.resize(queuePos + 1);
3105             queue[queuePos] = torrent->id();
3106         }
3107     }
3108
3109     m_resumeDataStorage->storeQueue(queue);
3110     m_needSaveTorrentsQueue = false;
3111 }
3112
3113 void SessionImpl::removeTorrentsQueue()
3114 {
3115     m_resumeDataStorage->storeQueue({});
3116     m_torrentsQueueChanged = false;
3117     m_needSaveTorrentsQueue = false;
3118 }
3119
3120 void SessionImpl::setSavePath(const Path &path)
3121 {
3122     const auto newPath = (path.isAbsolute() ? path : (specialFolderLocation(SpecialFolder::Downloads) / path));
3123     if (newPath == m_savePath)
3124         return;
3125
3126     if (isDisableAutoTMMWhenDefaultSavePathChanged())
3127     {
3128         QSet<QString> affectedCatogories {{}}; // includes default (unnamed) category
3129         for (auto it = m_categories.cbegin(); it != m_categories.cend(); ++it)
3130         {
3131             const QString &categoryName = it.key();
3132             const CategoryOptions &categoryOptions = it.value();
3133             if (categoryOptions.savePath.isRelative())
3134                 affectedCatogories.insert(categoryName);
3135         }
3136
3137         for (TorrentImpl *const torrent : asConst(m_torrents))
3138         {
3139             if (affectedCatogories.contains(torrent->category()))
3140                 torrent->setAutoTMMEnabled(false);
3141         }
3142     }
3143
3144     m_savePath = newPath;
3145     for (TorrentImpl *const torrent : asConst(m_torrents))
3146         torrent->handleCategoryOptionsChanged();
3147 }
3148
3149 void SessionImpl::setDownloadPath(const Path &path)
3150 {
3151     const Path newPath = (path.isAbsolute() ? path : (savePath() / Path(u"temp"_qs) / path));
3152     if (newPath == m_downloadPath)
3153         return;
3154
3155     if (isDisableAutoTMMWhenDefaultSavePathChanged())
3156     {
3157         QSet<QString> affectedCatogories {{}}; // includes default (unnamed) category
3158         for (auto it = m_categories.cbegin(); it != m_categories.cend(); ++it)
3159         {
3160             const QString &categoryName = it.key();
3161             const CategoryOptions &categoryOptions = it.value();
3162             const CategoryOptions::DownloadPathOption downloadPathOption =
3163                     categoryOptions.downloadPath.value_or(CategoryOptions::DownloadPathOption {isDownloadPathEnabled(), downloadPath()});
3164             if (downloadPathOption.enabled && downloadPathOption.path.isRelative())
3165                 affectedCatogories.insert(categoryName);
3166         }
3167
3168         for (TorrentImpl *const torrent : asConst(m_torrents))
3169         {
3170             if (affectedCatogories.contains(torrent->category()))
3171                 torrent->setAutoTMMEnabled(false);
3172         }
3173     }
3174
3175     m_downloadPath = newPath;
3176     for (TorrentImpl *const torrent : asConst(m_torrents))
3177         torrent->handleCategoryOptionsChanged();
3178 }
3179
3180 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
3181 void SessionImpl::networkOnlineStateChanged(const bool online)
3182 {
3183     LogMsg(tr("System network status changed to %1", "e.g: System network status changed to ONLINE").arg(online ? tr("ONLINE") : tr("OFFLINE")), Log::INFO);
3184 }
3185
3186 void SessionImpl::networkConfigurationChange(const QNetworkConfiguration &cfg)
3187 {
3188     const QString configuredInterfaceName = networkInterface();
3189     // Empty means "Any Interface". In this case libtorrent has binded to 0.0.0.0 so any change to any interface will
3190     // be automatically picked up. Otherwise we would rebinding here to 0.0.0.0 again.
3191     if (configuredInterfaceName.isEmpty()) return;
3192
3193     const QString changedInterface = cfg.name();
3194
3195     if (configuredInterfaceName == changedInterface)
3196     {
3197         LogMsg(tr("Network configuration of %1 has changed, refreshing session binding", "e.g: Network configuration of tun0 has changed, refreshing session binding").arg(changedInterface), Log::INFO);
3198         configureListeningInterface();
3199     }
3200 }
3201 #endif
3202
3203 QStringList SessionImpl::getListeningIPs() const
3204 {
3205     QStringList IPs;
3206
3207     const QString ifaceName = networkInterface();
3208     const QString ifaceAddr = networkInterfaceAddress();
3209     const QHostAddress configuredAddr(ifaceAddr);
3210     const bool allIPv4 = (ifaceAddr == u"0.0.0.0"); // Means All IPv4 addresses
3211     const bool allIPv6 = (ifaceAddr == u"::"); // Means All IPv6 addresses
3212
3213     if (!ifaceAddr.isEmpty() && !allIPv4 && !allIPv6 && configuredAddr.isNull())
3214     {
3215         LogMsg(tr("The configured network address is invalid. Address: \"%1\"").arg(ifaceAddr), Log::CRITICAL);
3216         // Pass the invalid user configured interface name/address to libtorrent
3217         // in hopes that it will come online later.
3218         // This will not cause IP leak but allow user to reconnect the interface
3219         // and re-establish connection without restarting the client.
3220         IPs.append(ifaceAddr);
3221         return IPs;
3222     }
3223
3224     if (ifaceName.isEmpty())
3225     {
3226         if (ifaceAddr.isEmpty())
3227             return {u"0.0.0.0"_qs, u"::"_qs}; // Indicates all interfaces + all addresses (aka default)
3228
3229         if (allIPv4)
3230             return {u"0.0.0.0"_qs};
3231
3232         if (allIPv6)
3233             return {u"::"_qs};
3234     }
3235
3236     const auto checkAndAddIP = [allIPv4, allIPv6, &IPs](const QHostAddress &addr, const QHostAddress &match)
3237     {
3238         if ((allIPv4 && (addr.protocol() != QAbstractSocket::IPv4Protocol))
3239             || (allIPv6 && (addr.protocol() != QAbstractSocket::IPv6Protocol)))
3240             return;
3241
3242         if ((match == addr) || allIPv4 || allIPv6)
3243             IPs.append(addr.toString());
3244     };
3245
3246     if (ifaceName.isEmpty())
3247     {
3248         const QList<QHostAddress> addresses = QNetworkInterface::allAddresses();
3249         for (const auto &addr : addresses)
3250             checkAndAddIP(addr, configuredAddr);
3251
3252         // At this point ifaceAddr was non-empty
3253         // If IPs.isEmpty() it means the configured Address was not found
3254         if (IPs.isEmpty())
3255         {
3256             LogMsg(tr("Failed to find the configured network address to listen on. Address: \"%1\"")
3257                 .arg(ifaceAddr), Log::CRITICAL);
3258             IPs.append(ifaceAddr);
3259         }
3260
3261         return IPs;
3262     }
3263
3264     // Attempt to listen on provided interface
3265     const QNetworkInterface networkIFace = QNetworkInterface::interfaceFromName(ifaceName);
3266     if (!networkIFace.isValid())
3267     {
3268         qDebug("Invalid network interface: %s", qUtf8Printable(ifaceName));
3269         LogMsg(tr("The configured network interface is invalid. Interface: \"%1\"").arg(ifaceName), Log::CRITICAL);
3270         IPs.append(ifaceName);
3271         return IPs;
3272     }
3273
3274     if (ifaceAddr.isEmpty())
3275     {
3276         IPs.append(ifaceName);
3277         return IPs; // On Windows calling code converts it to GUID
3278     }
3279
3280     const QList<QNetworkAddressEntry> addresses = networkIFace.addressEntries();
3281     qDebug() << "This network interface has " << addresses.size() << " IP addresses";
3282     for (const QNetworkAddressEntry &entry : addresses)
3283         checkAndAddIP(entry.ip(), configuredAddr);
3284
3285     // Make sure there is at least one IP
3286     // At this point there was an explicit interface and an explicit address set
3287     // and the address should have been found
3288     if (IPs.isEmpty())
3289     {
3290         LogMsg(tr("Failed to find the configured network address to listen on. Address: \"%1\"")
3291             .arg(ifaceAddr), Log::CRITICAL);
3292         IPs.append(ifaceAddr);
3293     }
3294
3295     return IPs;
3296 }
3297
3298 // Set the ports range in which is chosen the port
3299 // the BitTorrent session will listen to
3300 void SessionImpl::configureListeningInterface()
3301 {
3302     m_listenInterfaceConfigured = false;
3303     configureDeferred();
3304 }
3305
3306 int SessionImpl::globalDownloadSpeedLimit() const
3307 {
3308     // Unfortunately the value was saved as KiB instead of B.
3309     // But it is better to pass it around internally(+ webui) as Bytes.
3310     return m_globalDownloadSpeedLimit * 1024;
3311 }
3312
3313 void SessionImpl::setGlobalDownloadSpeedLimit(const int limit)
3314 {
3315     // Unfortunately the value was saved as KiB instead of B.
3316     // But it is better to pass it around internally(+ webui) as Bytes.
3317     if (limit == globalDownloadSpeedLimit())
3318         return;
3319
3320     if (limit <= 0)
3321         m_globalDownloadSpeedLimit = 0;
3322     else if (limit <= 1024)
3323         m_globalDownloadSpeedLimit = 1;
3324     else
3325         m_globalDownloadSpeedLimit = (limit / 1024);
3326
3327     if (!isAltGlobalSpeedLimitEnabled())
3328         configureDeferred();
3329 }
3330
3331 int SessionImpl::globalUploadSpeedLimit() const
3332 {
3333     // Unfortunately the value was saved as KiB instead of B.
3334     // But it is better to pass it around internally(+ webui) as Bytes.
3335     return m_globalUploadSpeedLimit * 1024;
3336 }
3337
3338 void SessionImpl::setGlobalUploadSpeedLimit(const int limit)
3339 {
3340     // Unfortunately the value was saved as KiB instead of B.
3341     // But it is better to pass it around internally(+ webui) as Bytes.
3342     if (limit == globalUploadSpeedLimit())
3343         return;
3344
3345     if (limit <= 0)
3346         m_globalUploadSpeedLimit = 0;
3347     else if (limit <= 1024)
3348         m_globalUploadSpeedLimit = 1;
3349     else
3350         m_globalUploadSpeedLimit = (limit / 1024);
3351
3352     if (!isAltGlobalSpeedLimitEnabled())
3353         configureDeferred();
3354 }
3355
3356 int SessionImpl::altGlobalDownloadSpeedLimit() const
3357 {
3358     // Unfortunately the value was saved as KiB instead of B.
3359     // But it is better to pass it around internally(+ webui) as Bytes.
3360     return m_altGlobalDownloadSpeedLimit * 1024;
3361 }
3362
3363 void SessionImpl::setAltGlobalDownloadSpeedLimit(const int limit)
3364 {
3365     // Unfortunately the value was saved as KiB instead of B.
3366     // But it is better to pass it around internally(+ webui) as Bytes.
3367     if (limit == altGlobalDownloadSpeedLimit())
3368         return;
3369
3370     if (limit <= 0)
3371         m_altGlobalDownloadSpeedLimit = 0;
3372     else if (limit <= 1024)
3373         m_altGlobalDownloadSpeedLimit = 1;
3374     else
3375         m_altGlobalDownloadSpeedLimit = (limit / 1024);
3376
3377     if (isAltGlobalSpeedLimitEnabled())
3378         configureDeferred();
3379 }
3380
3381 int SessionImpl::altGlobalUploadSpeedLimit() const
3382 {
3383     // Unfortunately the value was saved as KiB instead of B.
3384     // But it is better to pass it around internally(+ webui) as Bytes.
3385     return m_altGlobalUploadSpeedLimit * 1024;
3386 }
3387
3388 void SessionImpl::setAltGlobalUploadSpeedLimit(const int limit)
3389 {
3390     // Unfortunately the value was saved as KiB instead of B.
3391     // But it is better to pass it around internally(+ webui) as Bytes.
3392     if (limit == altGlobalUploadSpeedLimit())
3393         return;
3394
3395     if (limit <= 0)
3396         m_altGlobalUploadSpeedLimit = 0;
3397     else if (limit <= 1024)
3398         m_altGlobalUploadSpeedLimit = 1;
3399     else
3400         m_altGlobalUploadSpeedLimit = (limit / 1024);
3401
3402     if (isAltGlobalSpeedLimitEnabled())
3403         configureDeferred();
3404 }
3405
3406 int SessionImpl::downloadSpeedLimit() const
3407 {
3408     return isAltGlobalSpeedLimitEnabled()
3409             ? altGlobalDownloadSpeedLimit()
3410             : globalDownloadSpeedLimit();
3411 }
3412
3413 void SessionImpl::setDownloadSpeedLimit(const int limit)
3414 {
3415     if (isAltGlobalSpeedLimitEnabled())
3416         setAltGlobalDownloadSpeedLimit(limit);
3417     else
3418         setGlobalDownloadSpeedLimit(limit);
3419 }
3420
3421 int SessionImpl::uploadSpeedLimit() const
3422 {
3423     return isAltGlobalSpeedLimitEnabled()
3424             ? altGlobalUploadSpeedLimit()
3425             : globalUploadSpeedLimit();
3426 }
3427
3428 void SessionImpl::setUploadSpeedLimit(const int limit)
3429 {
3430     if (isAltGlobalSpeedLimitEnabled())
3431         setAltGlobalUploadSpeedLimit(limit);
3432     else
3433         setGlobalUploadSpeedLimit(limit);
3434 }
3435
3436 bool SessionImpl::isAltGlobalSpeedLimitEnabled() const
3437 {
3438     return m_isAltGlobalSpeedLimitEnabled;
3439 }
3440
3441 void SessionImpl::setAltGlobalSpeedLimitEnabled(const bool enabled)
3442 {
3443     if (enabled == isAltGlobalSpeedLimitEnabled()) return;
3444
3445     // Save new state to remember it on startup
3446     m_isAltGlobalSpeedLimitEnabled = enabled;
3447     applyBandwidthLimits();
3448     // Notify
3449     emit speedLimitModeChanged(m_isAltGlobalSpeedLimitEnabled);
3450 }
3451
3452 bool SessionImpl::isBandwidthSchedulerEnabled() const
3453 {
3454     return m_isBandwidthSchedulerEnabled;
3455 }
3456
3457 void SessionImpl::setBandwidthSchedulerEnabled(const bool enabled)
3458 {
3459     if (enabled != isBandwidthSchedulerEnabled())
3460     {
3461         m_isBandwidthSchedulerEnabled = enabled;
3462         if (enabled)
3463             enableBandwidthScheduler();
3464         else
3465             delete m_bwScheduler;
3466     }
3467 }
3468
3469 bool SessionImpl::isPerformanceWarningEnabled() const
3470 {
3471     return m_isPerformanceWarningEnabled;
3472 }
3473
3474 void SessionImpl::setPerformanceWarningEnabled(const bool enable)
3475 {
3476     if (enable == m_isPerformanceWarningEnabled)
3477         return;
3478
3479     m_isPerformanceWarningEnabled = enable;
3480     configureDeferred();
3481 }
3482
3483 int SessionImpl::saveResumeDataInterval() const
3484 {
3485     return m_saveResumeDataInterval;
3486 }
3487
3488 void SessionImpl::setSaveResumeDataInterval(const int value)
3489 {
3490     if (value == m_saveResumeDataInterval)
3491         return;
3492
3493     m_saveResumeDataInterval = value;
3494
3495     if (value > 0)
3496     {
3497         m_resumeDataTimer->setInterval(std::chrono::minutes(value));
3498         m_resumeDataTimer->start();
3499     }
3500     else
3501     {
3502         m_resumeDataTimer->stop();
3503     }
3504 }
3505
3506 int SessionImpl::port() const
3507 {
3508     return m_port;
3509 }
3510
3511 void SessionImpl::setPort(const int port)
3512 {
3513     if (port != m_port)
3514     {
3515         m_port = port;
3516         configureListeningInterface();
3517
3518         if (isReannounceWhenAddressChangedEnabled())
3519             reannounceToAllTrackers();
3520     }
3521 }
3522
3523 QString SessionImpl::networkInterface() const
3524 {
3525     return m_networkInterface;
3526 }
3527
3528 void SessionImpl::setNetworkInterface(const QString &iface)
3529 {
3530     if (iface != networkInterface())
3531     {
3532         m_networkInterface = iface;
3533         configureListeningInterface();
3534     }
3535 }
3536
3537 QString SessionImpl::networkInterfaceName() const
3538 {
3539     return m_networkInterfaceName;
3540 }
3541
3542 void SessionImpl::setNetworkInterfaceName(const QString &name)
3543 {
3544     m_networkInterfaceName = name;
3545 }
3546
3547 QString SessionImpl::networkInterfaceAddress() const
3548 {
3549     return m_networkInterfaceAddress;
3550 }
3551
3552 void SessionImpl::setNetworkInterfaceAddress(const QString &address)
3553 {
3554     if (address != networkInterfaceAddress())
3555     {
3556         m_networkInterfaceAddress = address;
3557         configureListeningInterface();
3558     }
3559 }
3560
3561 int SessionImpl::encryption() const
3562 {
3563     return m_encryption;
3564 }
3565
3566 void SessionImpl::setEncryption(const int state)
3567 {
3568     if (state != encryption())
3569     {
3570         m_encryption = state;
3571         configureDeferred();
3572         LogMsg(tr("Encryption support: %1").arg(
3573             state == 0 ? tr("ON") : ((state == 1) ? tr("FORCED") : tr("OFF")))
3574             , Log::INFO);
3575     }
3576 }
3577
3578 int SessionImpl::maxActiveCheckingTorrents() const
3579 {
3580     return m_maxActiveCheckingTorrents;
3581 }
3582
3583 void SessionImpl::setMaxActiveCheckingTorrents(const int val)
3584 {
3585     if (val == m_maxActiveCheckingTorrents)
3586         return;
3587
3588     m_maxActiveCheckingTorrents = val;
3589     configureDeferred();
3590 }
3591
3592 bool SessionImpl::isI2PEnabled() const
3593 {
3594     return m_isI2PEnabled;
3595 }
3596
3597 void SessionImpl::setI2PEnabled(const bool enabled)
3598 {
3599     if (m_isI2PEnabled != enabled)
3600     {
3601         m_isI2PEnabled = enabled;
3602         configureDeferred();
3603     }
3604 }
3605
3606 QString SessionImpl::I2PAddress() const
3607 {
3608     return m_I2PAddress;
3609 }
3610
3611 void SessionImpl::setI2PAddress(const QString &address)
3612 {
3613     if (m_I2PAddress != address)
3614     {
3615         m_I2PAddress = address;
3616         configureDeferred();
3617     }
3618 }
3619
3620 int SessionImpl::I2PPort() const
3621 {
3622     return m_I2PPort;
3623 }
3624
3625 void SessionImpl::setI2PPort(int port)
3626 {
3627     if (m_I2PPort != port)
3628     {
3629         m_I2PPort = port;
3630         configureDeferred();
3631     }
3632 }
3633
3634 bool SessionImpl::I2PMixedMode() const
3635 {
3636     return m_I2PMixedMode;
3637 }
3638
3639 void SessionImpl::setI2PMixedMode(const bool enabled)
3640 {
3641     if (m_I2PMixedMode != enabled)
3642     {
3643         m_I2PMixedMode = enabled;
3644         configureDeferred();
3645     }
3646 }
3647
3648 bool SessionImpl::isProxyPeerConnectionsEnabled() const
3649 {
3650     return m_isProxyPeerConnectionsEnabled;
3651 }
3652
3653 void SessionImpl::setProxyPeerConnectionsEnabled(const bool enabled)
3654 {
3655     if (enabled != isProxyPeerConnectionsEnabled())
3656     {
3657         m_isProxyPeerConnectionsEnabled = enabled;
3658         configureDeferred();
3659     }
3660 }
3661
3662 ChokingAlgorithm SessionImpl::chokingAlgorithm() const
3663 {
3664     return m_chokingAlgorithm;
3665 }
3666
3667 void SessionImpl::setChokingAlgorithm(const ChokingAlgorithm mode)
3668 {
3669     if (mode == m_chokingAlgorithm) return;
3670
3671     m_chokingAlgorithm = mode;
3672     configureDeferred();
3673 }
3674
3675 SeedChokingAlgorithm SessionImpl::seedChokingAlgorithm() const
3676 {
3677     return m_seedChokingAlgorithm;
3678 }
3679
3680 void SessionImpl::setSeedChokingAlgorithm(const SeedChokingAlgorithm mode)
3681 {
3682     if (mode == m_seedChokingAlgorithm) return;
3683
3684     m_seedChokingAlgorithm = mode;
3685     configureDeferred();
3686 }
3687
3688 bool SessionImpl::isAddTrackersEnabled() const
3689 {
3690     return m_isAddTrackersEnabled;
3691 }
3692
3693 void SessionImpl::setAddTrackersEnabled(const bool enabled)
3694 {
3695     m_isAddTrackersEnabled = enabled;
3696 }
3697
3698 QString SessionImpl::additionalTrackers() const
3699 {
3700     return m_additionalTrackers;
3701 }
3702
3703 void SessionImpl::setAdditionalTrackers(const QString &trackers)
3704 {
3705     if (trackers != additionalTrackers())
3706     {
3707         m_additionalTrackers = trackers;
3708         populateAdditionalTrackers();
3709     }
3710 }
3711
3712 bool SessionImpl::isIPFilteringEnabled() const
3713 {
3714     return m_isIPFilteringEnabled;
3715 }
3716
3717 void SessionImpl::setIPFilteringEnabled(const bool enabled)
3718 {
3719     if (enabled != m_isIPFilteringEnabled)
3720     {
3721         m_isIPFilteringEnabled = enabled;
3722         m_IPFilteringConfigured = false;
3723         configureDeferred();
3724     }
3725 }
3726
3727 Path SessionImpl::IPFilterFile() const
3728 {
3729     return m_IPFilterFile;
3730 }
3731
3732 void SessionImpl::setIPFilterFile(const Path &path)
3733 {
3734     if (path != IPFilterFile())
3735     {
3736         m_IPFilterFile = path;
3737         m_IPFilteringConfigured = false;
3738         configureDeferred();
3739     }
3740 }
3741
3742 bool SessionImpl::isExcludedFileNamesEnabled() const
3743 {
3744     return m_isExcludedFileNamesEnabled;
3745 }
3746
3747 void SessionImpl::setExcludedFileNamesEnabled(const bool enabled)
3748 {
3749     if (m_isExcludedFileNamesEnabled == enabled)
3750         return;
3751
3752     m_isExcludedFileNamesEnabled = enabled;
3753
3754     if (enabled)
3755         populateExcludedFileNamesRegExpList();
3756     else
3757         m_excludedFileNamesRegExpList.clear();
3758 }
3759
3760 QStringList SessionImpl::excludedFileNames() const
3761 {
3762     return m_excludedFileNames;
3763 }
3764
3765 void SessionImpl::setExcludedFileNames(const QStringList &excludedFileNames)
3766 {
3767     if (excludedFileNames != m_excludedFileNames)
3768     {
3769         m_excludedFileNames = excludedFileNames;
3770         populateExcludedFileNamesRegExpList();
3771     }
3772 }
3773
3774 void SessionImpl::populateExcludedFileNamesRegExpList()
3775 {
3776     const QStringList excludedNames = excludedFileNames();
3777
3778     m_excludedFileNamesRegExpList.clear();
3779     m_excludedFileNamesRegExpList.reserve(excludedNames.size());
3780
3781     for (const QString &str : excludedNames)
3782     {
3783         const QString pattern = QRegularExpression::anchoredPattern(QRegularExpression::wildcardToRegularExpression(str));
3784         const QRegularExpression re {pattern, QRegularExpression::CaseInsensitiveOption};
3785         m_excludedFileNamesRegExpList.append(re);
3786     }
3787 }
3788
3789 bool SessionImpl::isFilenameExcluded(const QString &fileName) const
3790 {
3791     if (!isExcludedFileNamesEnabled())
3792         return false;
3793
3794     return std::any_of(m_excludedFileNamesRegExpList.begin(), m_excludedFileNamesRegExpList.end(), [&fileName](const QRegularExpression &re)
3795     {
3796         return re.match(fileName).hasMatch();
3797     });
3798 }
3799
3800 void SessionImpl::setBannedIPs(const QStringList &newList)
3801 {
3802     if (newList == m_bannedIPs)
3803         return; // do nothing
3804     // here filter out incorrect IP
3805     QStringList filteredList;
3806     for (const QString &ip : newList)
3807     {
3808         if (Utils::Net::isValidIP(ip))
3809         {
3810             // the same IPv6 addresses could be written in different forms;
3811             // QHostAddress::toString() result format follows RFC5952;
3812             // thus we avoid duplicate entries pointing to the same address
3813             filteredList << QHostAddress(ip).toString();
3814         }
3815         else
3816         {
3817             LogMsg(tr("Rejected invalid IP address while applying the list of banned IP addresses. IP: \"%1\"")
3818                    .arg(ip)
3819                 , Log::WARNING);
3820         }
3821     }
3822     // now we have to sort IPs and make them unique
3823     filteredList.sort();
3824     filteredList.removeDuplicates();
3825     // Again ensure that the new list is different from the stored one.
3826     if (filteredList == m_bannedIPs)
3827         return; // do nothing
3828     // store to session settings
3829     // also here we have to recreate filter list including 3rd party ban file
3830     // and install it again into m_session
3831     m_bannedIPs = filteredList;
3832     m_IPFilteringConfigured = false;
3833     configureDeferred();
3834 }
3835
3836 ResumeDataStorageType SessionImpl::resumeDataStorageType() const
3837 {
3838     return m_resumeDataStorageType;
3839 }
3840
3841 void SessionImpl::setResumeDataStorageType(const ResumeDataStorageType type)
3842 {
3843     m_resumeDataStorageType = type;
3844 }
3845
3846 QStringList SessionImpl::bannedIPs() const
3847 {
3848     return m_bannedIPs;
3849 }
3850
3851 bool SessionImpl::isRestored() const
3852 {
3853     return m_isRestored;
3854 }
3855
3856 int SessionImpl::maxConnectionsPerTorrent() const
3857 {
3858     return m_maxConnectionsPerTorrent;
3859 }
3860
3861 void SessionImpl::setMaxConnectionsPerTorrent(int max)
3862 {
3863     max = (max > 0) ? max : -1;
3864     if (max != maxConnectionsPerTorrent())
3865     {
3866         m_maxConnectionsPerTorrent = max;
3867
3868         for (const TorrentImpl *torrent : asConst(m_torrents))
3869         {
3870             try
3871             {
3872                 torrent->nativeHandle().set_max_connections(max);
3873             }
3874             catch (const std::exception &) {}
3875         }
3876     }
3877 }
3878
3879 int SessionImpl::maxUploadsPerTorrent() const
3880 {
3881     return m_maxUploadsPerTorrent;
3882 }
3883
3884 void SessionImpl::setMaxUploadsPerTorrent(int max)
3885 {
3886     max = (max > 0) ? max : -1;
3887     if (max != maxUploadsPerTorrent())
3888     {
3889         m_maxUploadsPerTorrent = max;
3890
3891         for (const TorrentImpl *torrent : asConst(m_torrents))
3892         {
3893             try
3894             {
3895                 torrent->nativeHandle().set_max_uploads(max);
3896             }
3897             catch (const std::exception &) {}
3898         }
3899     }
3900 }
3901
3902 bool SessionImpl::announceToAllTrackers() const
3903 {
3904     return m_announceToAllTrackers;
3905 }
3906
3907 void SessionImpl::setAnnounceToAllTrackers(const bool val)
3908 {
3909     if (val != m_announceToAllTrackers)
3910     {
3911         m_announceToAllTrackers = val;
3912         configureDeferred();
3913     }
3914 }
3915
3916 bool SessionImpl::announceToAllTiers() const
3917 {
3918     return m_announceToAllTiers;
3919 }
3920
3921 void SessionImpl::setAnnounceToAllTiers(const bool val)
3922 {
3923     if (val != m_announceToAllTiers)
3924     {
3925         m_announceToAllTiers = val;
3926         configureDeferred();
3927     }
3928 }
3929
3930 int SessionImpl::peerTurnover() const
3931 {
3932     return m_peerTurnover;
3933 }
3934
3935 void SessionImpl::setPeerTurnover(const int val)
3936 {
3937     if (val == m_peerTurnover)
3938         return;
3939
3940     m_peerTurnover = val;
3941     configureDeferred();
3942 }
3943
3944 int SessionImpl::peerTurnoverCutoff() const
3945 {
3946     return m_peerTurnoverCutoff;
3947 }
3948
3949 void SessionImpl::setPeerTurnoverCutoff(const int val)
3950 {
3951     if (val == m_peerTurnoverCutoff)
3952         return;
3953
3954     m_peerTurnoverCutoff = val;
3955     configureDeferred();
3956 }
3957
3958 int SessionImpl::peerTurnoverInterval() const
3959 {
3960     return m_peerTurnoverInterval;
3961 }
3962
3963 void SessionImpl::setPeerTurnoverInterval(const int val)
3964 {
3965     if (val == m_peerTurnoverInterval)
3966         return;
3967
3968     m_peerTurnoverInterval = val;
3969     configureDeferred();
3970 }
3971
3972 DiskIOType SessionImpl::diskIOType() const
3973 {
3974     return m_diskIOType;
3975 }
3976
3977 void SessionImpl::setDiskIOType(const DiskIOType type)
3978 {
3979     if (type != m_diskIOType)
3980     {
3981         m_diskIOType = type;
3982     }
3983 }
3984
3985 int SessionImpl::requestQueueSize() const
3986 {
3987     return m_requestQueueSize;
3988 }
3989
3990 void SessionImpl::setRequestQueueSize(const int val)
3991 {
3992     if (val == m_requestQueueSize)
3993         return;
3994
3995     m_requestQueueSize = val;
3996     configureDeferred();
3997 }
3998
3999 int SessionImpl::asyncIOThreads() const
4000 {
4001     return std::clamp(m_asyncIOThreads.get(), 1, 1024);
4002 }
4003
4004 void SessionImpl::setAsyncIOThreads(const int num)
4005 {
4006     if (num == m_asyncIOThreads)
4007         return;
4008
4009     m_asyncIOThreads = num;
4010     configureDeferred();
4011 }
4012
4013 int SessionImpl::hashingThreads() const
4014 {
4015     return std::clamp(m_hashingThreads.get(), 1, 1024);
4016 }
4017
4018 void SessionImpl::setHashingThreads(const int num)
4019 {
4020     if (num == m_hashingThreads)
4021         return;
4022
4023     m_hashingThreads = num;
4024     configureDeferred();
4025 }
4026
4027 int SessionImpl::filePoolSize() const
4028 {
4029     return m_filePoolSize;
4030 }
4031
4032 void SessionImpl::setFilePoolSize(const int size)
4033 {
4034     if (size == m_filePoolSize)
4035         return;
4036
4037     m_filePoolSize = size;
4038     configureDeferred();
4039 }
4040
4041 int SessionImpl::checkingMemUsage() const
4042 {
4043     return std::max(1, m_checkingMemUsage.get());
4044 }
4045
4046 void SessionImpl::setCheckingMemUsage(int size)
4047 {
4048     size = std::max(size, 1);
4049
4050     if (size == m_checkingMemUsage)
4051         return;
4052
4053     m_checkingMemUsage = size;
4054     configureDeferred();
4055 }
4056
4057 int SessionImpl::diskCacheSize() const
4058 {
4059 #ifdef QBT_APP_64BIT
4060     return std::min(m_diskCacheSize.get(), 33554431);  // 32768GiB
4061 #else
4062     // When build as 32bit binary, set the maximum at less than 2GB to prevent crashes
4063     // allocate 1536MiB and leave 512MiB to the rest of program data in RAM
4064     return std::min(m_diskCacheSize.get(), 1536);
4065 #endif
4066 }
4067
4068 void SessionImpl::setDiskCacheSize(int size)
4069 {
4070 #ifdef QBT_APP_64BIT
4071     size = std::min(size, 33554431);  // 32768GiB
4072 #else
4073     // allocate 1536MiB and leave 512MiB to the rest of program data in RAM
4074     size = std::min(size, 1536);
4075 #endif
4076     if (size != m_diskCacheSize)
4077     {
4078         m_diskCacheSize = size;
4079         configureDeferred();
4080     }
4081 }
4082
4083 int SessionImpl::diskCacheTTL() const
4084 {
4085     return m_diskCacheTTL;
4086 }
4087
4088 void SessionImpl::setDiskCacheTTL(const int ttl)
4089 {
4090     if (ttl != m_diskCacheTTL)
4091     {
4092         m_diskCacheTTL = ttl;
4093         configureDeferred();
4094     }
4095 }
4096
4097 qint64 SessionImpl::diskQueueSize() const
4098 {
4099     return m_diskQueueSize;
4100 }
4101
4102 void SessionImpl::setDiskQueueSize(const qint64 size)
4103 {
4104     if (size == m_diskQueueSize)
4105         return;
4106
4107     m_diskQueueSize = size;
4108     configureDeferred();
4109 }
4110
4111 DiskIOReadMode SessionImpl::diskIOReadMode() const
4112 {
4113     return m_diskIOReadMode;
4114 }
4115
4116 void SessionImpl::setDiskIOReadMode(const DiskIOReadMode mode)
4117 {
4118     if (mode == m_diskIOReadMode)
4119         return;
4120
4121     m_diskIOReadMode = mode;
4122     configureDeferred();
4123 }
4124
4125 DiskIOWriteMode SessionImpl::diskIOWriteMode() const
4126 {
4127     return m_diskIOWriteMode;
4128 }
4129
4130 void SessionImpl::setDiskIOWriteMode(const DiskIOWriteMode mode)
4131 {
4132     if (mode == m_diskIOWriteMode)
4133         return;
4134
4135     m_diskIOWriteMode = mode;
4136     configureDeferred();
4137 }
4138
4139 bool SessionImpl::isCoalesceReadWriteEnabled() const
4140 {
4141     return m_coalesceReadWriteEnabled;
4142 }
4143
4144 void SessionImpl::setCoalesceReadWriteEnabled(const bool enabled)
4145 {
4146     if (enabled == m_coalesceReadWriteEnabled) return;
4147
4148     m_coalesceReadWriteEnabled = enabled;
4149     configureDeferred();
4150 }
4151
4152 bool SessionImpl::isSuggestModeEnabled() const
4153 {
4154     return m_isSuggestMode;
4155 }
4156
4157 bool SessionImpl::usePieceExtentAffinity() const
4158 {
4159     return m_usePieceExtentAffinity;
4160 }
4161
4162 void SessionImpl::setPieceExtentAffinity(const bool enabled)
4163 {
4164     if (enabled == m_usePieceExtentAffinity) return;
4165
4166     m_usePieceExtentAffinity = enabled;
4167     configureDeferred();
4168 }
4169
4170 void SessionImpl::setSuggestMode(const bool mode)
4171 {
4172     if (mode == m_isSuggestMode) return;
4173
4174     m_isSuggestMode = mode;
4175     configureDeferred();
4176 }
4177
4178 int SessionImpl::sendBufferWatermark() const
4179 {
4180     return m_sendBufferWatermark;
4181 }
4182
4183 void SessionImpl::setSendBufferWatermark(const int value)
4184 {
4185     if (value == m_sendBufferWatermark) return;
4186
4187     m_sendBufferWatermark = value;
4188     configureDeferred();
4189 }
4190
4191 int SessionImpl::sendBufferLowWatermark() const
4192 {
4193     return m_sendBufferLowWatermark;
4194 }
4195
4196 void SessionImpl::setSendBufferLowWatermark(const int value)
4197 {
4198     if (value == m_sendBufferLowWatermark) return;
4199
4200     m_sendBufferLowWatermark = value;
4201     configureDeferred();
4202 }
4203
4204 int SessionImpl::sendBufferWatermarkFactor() const
4205 {
4206     return m_sendBufferWatermarkFactor;
4207 }
4208
4209 void SessionImpl::setSendBufferWatermarkFactor(const int value)
4210 {
4211     if (value == m_sendBufferWatermarkFactor) return;
4212
4213     m_sendBufferWatermarkFactor = value;
4214     configureDeferred();
4215 }
4216
4217 int SessionImpl::connectionSpeed() const
4218 {
4219     return m_connectionSpeed;
4220 }
4221
4222 void SessionImpl::setConnectionSpeed(const int value)
4223 {
4224     if (value == m_connectionSpeed) return;
4225
4226     m_connectionSpeed = value;
4227     configureDeferred();
4228 }
4229
4230 int SessionImpl::socketSendBufferSize() const
4231 {
4232     return m_socketSendBufferSize;
4233 }
4234
4235 void SessionImpl::setSocketSendBufferSize(const int value)
4236 {
4237     if (value == m_socketSendBufferSize)
4238         return;
4239
4240     m_socketSendBufferSize = value;
4241     configureDeferred();
4242 }
4243
4244 int SessionImpl::socketReceiveBufferSize() const
4245 {
4246     return m_socketReceiveBufferSize;
4247 }
4248
4249 void SessionImpl::setSocketReceiveBufferSize(const int value)
4250 {
4251     if (value == m_socketReceiveBufferSize)
4252         return;
4253
4254     m_socketReceiveBufferSize = value;
4255     configureDeferred();
4256 }
4257
4258 int SessionImpl::socketBacklogSize() const
4259 {
4260     return m_socketBacklogSize;
4261 }
4262
4263 void SessionImpl::setSocketBacklogSize(const int value)
4264 {
4265     if (value == m_socketBacklogSize) return;
4266
4267     m_socketBacklogSize = value;
4268     configureDeferred();
4269 }
4270
4271 bool SessionImpl::isAnonymousModeEnabled() const
4272 {
4273     return m_isAnonymousModeEnabled;
4274 }
4275
4276 void SessionImpl::setAnonymousModeEnabled(const bool enabled)
4277 {
4278     if (enabled != m_isAnonymousModeEnabled)
4279     {
4280         m_isAnonymousModeEnabled = enabled;
4281         configureDeferred();
4282         LogMsg(tr("Anonymous mode: %1").arg(isAnonymousModeEnabled() ? tr("ON") : tr("OFF"))
4283             , Log::INFO);
4284     }
4285 }
4286
4287 bool SessionImpl::isQueueingSystemEnabled() const
4288 {
4289     return m_isQueueingEnabled;
4290 }
4291
4292 void SessionImpl::setQueueingSystemEnabled(const bool enabled)
4293 {
4294     if (enabled != m_isQueueingEnabled)
4295     {
4296         m_isQueueingEnabled = enabled;
4297         configureDeferred();
4298
4299         if (enabled)
4300             m_torrentsQueueChanged = true;
4301         else
4302             removeTorrentsQueue();
4303     }
4304 }
4305
4306 int SessionImpl::maxActiveDownloads() const
4307 {
4308     return m_maxActiveDownloads;
4309 }
4310
4311 void SessionImpl::setMaxActiveDownloads(int max)
4312 {
4313     max = std::max(max, -1);
4314     if (max != m_maxActiveDownloads)
4315     {
4316         m_maxActiveDownloads = max;
4317         configureDeferred();
4318     }
4319 }
4320
4321 int SessionImpl::maxActiveUploads() const
4322 {
4323     return m_maxActiveUploads;
4324 }
4325
4326 void SessionImpl::setMaxActiveUploads(int max)
4327 {
4328     max = std::max(max, -1);
4329     if (max != m_maxActiveUploads)
4330     {
4331         m_maxActiveUploads = max;
4332         configureDeferred();
4333     }
4334 }
4335
4336 int SessionImpl::maxActiveTorrents() const
4337 {
4338     return m_maxActiveTorrents;
4339 }
4340
4341 void SessionImpl::setMaxActiveTorrents(int max)
4342 {
4343     max = std::max(max, -1);
4344     if (max != m_maxActiveTorrents)
4345     {
4346         m_maxActiveTorrents = max;
4347         configureDeferred();
4348     }
4349 }
4350
4351 bool SessionImpl::ignoreSlowTorrentsForQueueing() const
4352 {
4353     return m_ignoreSlowTorrentsForQueueing;
4354 }
4355
4356 void SessionImpl::setIgnoreSlowTorrentsForQueueing(const bool ignore)
4357 {
4358     if (ignore != m_ignoreSlowTorrentsForQueueing)
4359     {
4360         m_ignoreSlowTorrentsForQueueing = ignore;
4361         configureDeferred();
4362     }
4363 }
4364
4365 int SessionImpl::downloadRateForSlowTorrents() const
4366 {
4367     return m_downloadRateForSlowTorrents;
4368 }
4369
4370 void SessionImpl::setDownloadRateForSlowTorrents(const int rateInKibiBytes)
4371 {
4372     if (rateInKibiBytes == m_downloadRateForSlowTorrents)
4373         return;
4374
4375     m_downloadRateForSlowTorrents = rateInKibiBytes;
4376     configureDeferred();
4377 }
4378
4379 int SessionImpl::uploadRateForSlowTorrents() const
4380 {
4381     return m_uploadRateForSlowTorrents;
4382 }
4383
4384 void SessionImpl::setUploadRateForSlowTorrents(const int rateInKibiBytes)
4385 {
4386     if (rateInKibiBytes == m_uploadRateForSlowTorrents)
4387         return;
4388
4389     m_uploadRateForSlowTorrents = rateInKibiBytes;
4390     configureDeferred();
4391 }
4392
4393 int SessionImpl::slowTorrentsInactivityTimer() const
4394 {
4395     return m_slowTorrentsInactivityTimer;
4396 }
4397
4398 void SessionImpl::setSlowTorrentsInactivityTimer(const int timeInSeconds)
4399 {
4400     if (timeInSeconds == m_slowTorrentsInactivityTimer)
4401         return;
4402
4403     m_slowTorrentsInactivityTimer = timeInSeconds;
4404     configureDeferred();
4405 }
4406
4407 int SessionImpl::outgoingPortsMin() const
4408 {
4409     return m_outgoingPortsMin;
4410 }
4411
4412 void SessionImpl::setOutgoingPortsMin(const int min)
4413 {
4414     if (min != m_outgoingPortsMin)
4415     {
4416         m_outgoingPortsMin = min;
4417         configureDeferred();
4418     }
4419 }
4420
4421 int SessionImpl::outgoingPortsMax() const
4422 {
4423     return m_outgoingPortsMax;
4424 }
4425
4426 void SessionImpl::setOutgoingPortsMax(const int max)
4427 {
4428     if (max != m_outgoingPortsMax)
4429     {
4430         m_outgoingPortsMax = max;
4431         configureDeferred();
4432     }
4433 }
4434
4435 int SessionImpl::UPnPLeaseDuration() const
4436 {
4437     return m_UPnPLeaseDuration;
4438 }
4439
4440 void SessionImpl::setUPnPLeaseDuration(const int duration)
4441 {
4442     if (duration != m_UPnPLeaseDuration)
4443     {
4444         m_UPnPLeaseDuration = duration;
4445         configureDeferred();
4446     }
4447 }
4448
4449 int SessionImpl::peerToS() const
4450 {
4451     return m_peerToS;
4452 }
4453
4454 void SessionImpl::setPeerToS(const int value)
4455 {
4456     if (value == m_peerToS)
4457         return;
4458
4459     m_peerToS = value;
4460     configureDeferred();
4461 }
4462
4463 bool SessionImpl::ignoreLimitsOnLAN() const
4464 {
4465     return m_ignoreLimitsOnLAN;
4466 }
4467
4468 void SessionImpl::setIgnoreLimitsOnLAN(const bool ignore)
4469 {
4470     if (ignore != m_ignoreLimitsOnLAN)
4471     {
4472         m_ignoreLimitsOnLAN = ignore;
4473         configureDeferred();
4474     }
4475 }
4476
4477 bool SessionImpl::includeOverheadInLimits() const
4478 {
4479     return m_includeOverheadInLimits;
4480 }
4481
4482 void SessionImpl::setIncludeOverheadInLimits(const bool include)
4483 {
4484     if (include != m_includeOverheadInLimits)
4485     {
4486         m_includeOverheadInLimits = include;
4487         configureDeferred();
4488     }
4489 }
4490
4491 QString SessionImpl::announceIP() const
4492 {
4493     return m_announceIP;
4494 }
4495
4496 void SessionImpl::setAnnounceIP(const QString &ip)
4497 {
4498     if (ip != m_announceIP)
4499     {
4500         m_announceIP = ip;
4501         configureDeferred();
4502     }
4503 }
4504
4505 int SessionImpl::maxConcurrentHTTPAnnounces() const
4506 {
4507     return m_maxConcurrentHTTPAnnounces;
4508 }
4509
4510 void SessionImpl::setMaxConcurrentHTTPAnnounces(const int value)
4511 {
4512     if (value == m_maxConcurrentHTTPAnnounces)
4513         return;
4514
4515     m_maxConcurrentHTTPAnnounces = value;
4516     configureDeferred();
4517 }
4518
4519 bool SessionImpl::isReannounceWhenAddressChangedEnabled() const
4520 {
4521     return m_isReannounceWhenAddressChangedEnabled;
4522 }
4523
4524 void SessionImpl::setReannounceWhenAddressChangedEnabled(const bool enabled)
4525 {
4526     if (enabled == m_isReannounceWhenAddressChangedEnabled)
4527         return;
4528
4529     m_isReannounceWhenAddressChangedEnabled = enabled;
4530 }
4531
4532 void SessionImpl::reannounceToAllTrackers() const
4533 {
4534     for (const TorrentImpl *torrent : asConst(m_torrents))
4535     {
4536         try
4537         {
4538             torrent->nativeHandle().force_reannounce(0, -1, lt::torrent_handle::ignore_min_interval);
4539         }
4540         catch (const std::exception &) {}
4541     }
4542 }
4543
4544 int SessionImpl::stopTrackerTimeout() const
4545 {
4546     return m_stopTrackerTimeout;
4547 }
4548
4549 void SessionImpl::setStopTrackerTimeout(const int value)
4550 {
4551     if (value == m_stopTrackerTimeout)
4552         return;
4553
4554     m_stopTrackerTimeout = value;
4555     configureDeferred();
4556 }
4557
4558 int SessionImpl::maxConnections() const
4559 {
4560     return m_maxConnections;
4561 }
4562
4563 void SessionImpl::setMaxConnections(int max)
4564 {
4565     max = (max > 0) ? max : -1;
4566     if (max != m_maxConnections)
4567     {
4568         m_maxConnections = max;
4569         configureDeferred();
4570     }
4571 }
4572
4573 int SessionImpl::maxUploads() const
4574 {
4575     return m_maxUploads;
4576 }
4577
4578 void SessionImpl::setMaxUploads(int max)
4579 {
4580     max = (max > 0) ? max : -1;
4581     if (max != m_maxUploads)
4582     {
4583         m_maxUploads = max;
4584         configureDeferred();
4585     }
4586 }
4587
4588 BTProtocol SessionImpl::btProtocol() const
4589 {
4590     return m_btProtocol;
4591 }
4592
4593 void SessionImpl::setBTProtocol(const BTProtocol protocol)
4594 {
4595     if ((protocol < BTProtocol::Both) || (BTProtocol::UTP < protocol))
4596         return;
4597
4598     if (protocol == m_btProtocol) return;
4599
4600     m_btProtocol = protocol;
4601     configureDeferred();
4602 }
4603
4604 bool SessionImpl::isUTPRateLimited() const
4605 {
4606     return m_isUTPRateLimited;
4607 }
4608
4609 void SessionImpl::setUTPRateLimited(const bool limited)
4610 {
4611     if (limited != m_isUTPRateLimited)
4612     {
4613         m_isUTPRateLimited = limited;
4614         configureDeferred();
4615     }
4616 }
4617
4618 MixedModeAlgorithm SessionImpl::utpMixedMode() const
4619 {
4620     return m_utpMixedMode;
4621 }
4622
4623 void SessionImpl::setUtpMixedMode(const MixedModeAlgorithm mode)
4624 {
4625     if (mode == m_utpMixedMode) return;
4626
4627     m_utpMixedMode = mode;
4628     configureDeferred();
4629 }
4630
4631 bool SessionImpl::isIDNSupportEnabled() const
4632 {
4633     return m_IDNSupportEnabled;
4634 }
4635
4636 void SessionImpl::setIDNSupportEnabled(const bool enabled)
4637 {
4638     if (enabled == m_IDNSupportEnabled) return;
4639
4640     m_IDNSupportEnabled = enabled;
4641     configureDeferred();
4642 }
4643
4644 bool SessionImpl::multiConnectionsPerIpEnabled() const
4645 {
4646     return m_multiConnectionsPerIpEnabled;
4647 }
4648
4649 void SessionImpl::setMultiConnectionsPerIpEnabled(const bool enabled)
4650 {
4651     if (enabled == m_multiConnectionsPerIpEnabled) return;
4652
4653     m_multiConnectionsPerIpEnabled = enabled;
4654     configureDeferred();
4655 }
4656
4657 bool SessionImpl::validateHTTPSTrackerCertificate() const
4658 {
4659     return m_validateHTTPSTrackerCertificate;
4660 }
4661
4662 void SessionImpl::setValidateHTTPSTrackerCertificate(const bool enabled)
4663 {
4664     if (enabled == m_validateHTTPSTrackerCertificate) return;
4665
4666     m_validateHTTPSTrackerCertificate = enabled;
4667     configureDeferred();
4668 }
4669
4670 bool SessionImpl::isSSRFMitigationEnabled() const
4671 {
4672     return m_SSRFMitigationEnabled;
4673 }
4674
4675 void SessionImpl::setSSRFMitigationEnabled(const bool enabled)
4676 {
4677     if (enabled == m_SSRFMitigationEnabled) return;
4678
4679     m_SSRFMitigationEnabled = enabled;
4680     configureDeferred();
4681 }
4682
4683 bool SessionImpl::blockPeersOnPrivilegedPorts() const
4684 {
4685     return m_blockPeersOnPrivilegedPorts;
4686 }
4687
4688 void SessionImpl::setBlockPeersOnPrivilegedPorts(const bool enabled)
4689 {
4690     if (enabled == m_blockPeersOnPrivilegedPorts) return;
4691
4692     m_blockPeersOnPrivilegedPorts = enabled;
4693     configureDeferred();
4694 }
4695
4696 bool SessionImpl::isTrackerFilteringEnabled() const
4697 {
4698     return m_isTrackerFilteringEnabled;
4699 }
4700
4701 void SessionImpl::setTrackerFilteringEnabled(const bool enabled)
4702 {
4703     if (enabled != m_isTrackerFilteringEnabled)
4704     {
4705         m_isTrackerFilteringEnabled = enabled;
4706         configureDeferred();
4707     }
4708 }
4709
4710 bool SessionImpl::isListening() const
4711 {
4712     return m_nativeSessionExtension->isSessionListening();
4713 }
4714
4715 MaxRatioAction SessionImpl::maxRatioAction() const
4716 {
4717     return static_cast<MaxRatioAction>(m_maxRatioAction.get());
4718 }
4719
4720 void SessionImpl::setMaxRatioAction(const MaxRatioAction act)
4721 {
4722     m_maxRatioAction = static_cast<int>(act);
4723 }
4724
4725 bool SessionImpl::isKnownTorrent(const InfoHash &infoHash) const
4726 {
4727     const bool isHybrid = infoHash.isHybrid();
4728     const auto id = TorrentID::fromInfoHash(infoHash);
4729     // alternative ID can be useful to find existing torrent
4730     // in case if hybrid torrent was added by v1 info hash
4731     const auto altID = (isHybrid ? TorrentID::fromSHA1Hash(infoHash.v1()) : TorrentID());
4732
4733     if (m_loadingTorrents.contains(id) || (isHybrid && m_loadingTorrents.contains(altID)))
4734         return true;
4735     if (m_downloadedMetadata.contains(id) || (isHybrid && m_downloadedMetadata.contains(altID)))
4736         return true;
4737     return findTorrent(infoHash);
4738 }
4739
4740 void SessionImpl::updateSeedingLimitTimer()
4741 {
4742     if ((globalMaxRatio() == Torrent::NO_RATIO_LIMIT) && !hasPerTorrentRatioLimit()
4743         && (globalMaxSeedingMinutes() == Torrent::NO_SEEDING_TIME_LIMIT) && !hasPerTorrentSeedingTimeLimit())
4744         {
4745         if (m_seedingLimitTimer->isActive())
4746             m_seedingLimitTimer->stop();
4747     }
4748     else if (!m_seedingLimitTimer->isActive())
4749     {
4750         m_seedingLimitTimer->start();
4751     }
4752 }
4753
4754 void SessionImpl::handleTorrentShareLimitChanged(TorrentImpl *const)
4755 {
4756     updateSeedingLimitTimer();
4757 }
4758
4759 void SessionImpl::handleTorrentNameChanged(TorrentImpl *const)
4760 {
4761 }
4762
4763 void SessionImpl::handleTorrentSavePathChanged(TorrentImpl *const torrent)
4764 {
4765     emit torrentSavePathChanged(torrent);
4766 }
4767
4768 void SessionImpl::handleTorrentCategoryChanged(TorrentImpl *const torrent, const QString &oldCategory)
4769 {
4770     emit torrentCategoryChanged(torrent, oldCategory);
4771 }
4772
4773 void SessionImpl::handleTorrentTagAdded(TorrentImpl *const torrent, const QString &tag)
4774 {
4775     emit torrentTagAdded(torrent, tag);
4776 }
4777
4778 void SessionImpl::handleTorrentTagRemoved(TorrentImpl *const torrent, const QString &tag)
4779 {
4780     emit torrentTagRemoved(torrent, tag);
4781 }
4782
4783 void SessionImpl::handleTorrentSavingModeChanged(TorrentImpl *const torrent)
4784 {
4785     emit torrentSavingModeChanged(torrent);
4786 }
4787
4788 void SessionImpl::handleTorrentTrackersAdded(TorrentImpl *const torrent, const QVector<TrackerEntry> &newTrackers)
4789 {
4790     for (const TrackerEntry &newTracker : newTrackers)
4791         LogMsg(tr("Added tracker to torrent. Torrent: \"%1\". Tracker: \"%2\"").arg(torrent->name(), newTracker.url));
4792     emit trackersAdded(torrent, newTrackers);
4793     if (torrent->trackers().size() == newTrackers.size())
4794         emit trackerlessStateChanged(torrent, false);
4795     emit trackersChanged(torrent);
4796 }
4797
4798 void SessionImpl::handleTorrentTrackersRemoved(TorrentImpl *const torrent, const QStringList &deletedTrackers)
4799 {
4800     for (const QString &deletedTracker : deletedTrackers)
4801         LogMsg(tr("Removed tracker from torrent. Torrent: \"%1\". Tracker: \"%2\"").arg(torrent->name(), deletedTracker));
4802     emit trackersRemoved(torrent, deletedTrackers);
4803     if (torrent->trackers().isEmpty())
4804         emit trackerlessStateChanged(torrent, true);
4805     emit trackersChanged(torrent);
4806 }
4807
4808 void SessionImpl::handleTorrentTrackersChanged(TorrentImpl *const torrent)
4809 {
4810     emit trackersChanged(torrent);
4811 }
4812
4813 void SessionImpl::handleTorrentUrlSeedsAdded(TorrentImpl *const torrent, const QVector<QUrl> &newUrlSeeds)
4814 {
4815     for (const QUrl &newUrlSeed : newUrlSeeds)
4816         LogMsg(tr("Added URL seed to torrent. Torrent: \"%1\". URL: \"%2\"").arg(torrent->name(), newUrlSeed.toString()));
4817 }
4818
4819 void SessionImpl::handleTorrentUrlSeedsRemoved(TorrentImpl *const torrent, const QVector<QUrl> &urlSeeds)
4820 {
4821     for (const QUrl &urlSeed : urlSeeds)
4822         LogMsg(tr("Removed URL seed from torrent. Torrent: \"%1\". URL: \"%2\"").arg(torrent->name(), urlSeed.toString()));
4823 }
4824
4825 void SessionImpl::handleTorrentMetadataReceived(TorrentImpl *const torrent)
4826 {
4827     if (!torrentExportDirectory().isEmpty())
4828         exportTorrentFile(torrent, torrentExportDirectory());
4829
4830     emit torrentMetadataReceived(torrent);
4831 }
4832
4833 void SessionImpl::handleTorrentPaused(TorrentImpl *const torrent)
4834 {
4835     LogMsg(tr("Torrent paused. Torrent: \"%1\"").arg(torrent->name()));
4836     emit torrentPaused(torrent);
4837 }
4838
4839 void SessionImpl::handleTorrentResumed(TorrentImpl *const torrent)
4840 {
4841     LogMsg(tr("Torrent resumed. Torrent: \"%1\"").arg(torrent->name()));
4842     emit torrentResumed(torrent);
4843 }
4844
4845 void SessionImpl::handleTorrentChecked(TorrentImpl *const torrent)
4846 {
4847     emit torrentFinishedChecking(torrent);
4848 }
4849
4850 void SessionImpl::handleTorrentFinished(TorrentImpl *const torrent)
4851 {
4852     LogMsg(tr("Torrent download finished. Torrent: \"%1\"").arg(torrent->name()));
4853     emit torrentFinished(torrent);
4854
4855     if (const Path exportPath = finishedTorrentExportDirectory(); !exportPath.isEmpty())
4856         exportTorrentFile(torrent, exportPath);
4857
4858     // Check whether it contains .torrent files
4859     for (const Path &torrentRelpath : asConst(torrent->filePaths()))
4860     {
4861         if (torrentRelpath.hasExtension(u".torrent"_qs))
4862         {
4863             emit recursiveTorrentDownloadPossible(torrent);
4864             break;
4865         }
4866     }
4867
4868     const bool hasUnfinishedTorrents = std::any_of(m_torrents.cbegin(), m_torrents.cend(), [](const TorrentImpl *torrent)
4869     {
4870         return !(torrent->isFinished() || torrent->isPaused() || torrent->isErrored());
4871     });
4872     if (!hasUnfinishedTorrents)
4873         emit allTorrentsFinished();
4874 }
4875
4876 void SessionImpl::handleTorrentResumeDataReady(TorrentImpl *const torrent, const LoadTorrentParams &data)
4877 {
4878     --m_numResumeData;
4879
4880     m_resumeDataStorage->store(torrent->id(), data);
4881     const auto iter = m_changedTorrentIDs.find(torrent->id());
4882     if (iter != m_changedTorrentIDs.end())
4883     {
4884         m_resumeDataStorage->remove(iter.value());
4885         m_changedTorrentIDs.erase(iter);
4886     }
4887 }
4888
4889 void SessionImpl::handleTorrentInfoHashChanged(TorrentImpl *torrent, const InfoHash &prevInfoHash)
4890 {
4891     Q_ASSERT(torrent->infoHash().isHybrid());
4892
4893     m_hybridTorrentsByAltID.insert(TorrentID::fromSHA1Hash(torrent->infoHash().v1()), torrent);
4894
4895     const auto prevID = TorrentID::fromInfoHash(prevInfoHash);
4896     const TorrentID currentID = torrent->id();
4897     if (currentID != prevID)
4898     {
4899         m_torrents[torrent->id()] = m_torrents.take(prevID);
4900         m_changedTorrentIDs[torrent->id()] = prevID;
4901     }
4902 }
4903
4904 bool SessionImpl::addMoveTorrentStorageJob(TorrentImpl *torrent, const Path &newPath, const MoveStorageMode mode, const MoveStorageContext context)
4905 {
4906     Q_ASSERT(torrent);
4907
4908     const lt::torrent_handle torrentHandle = torrent->nativeHandle();
4909     const Path currentLocation = torrent->actualStorageLocation();
4910     const bool torrentHasActiveJob = !m_moveStorageQueue.isEmpty() && (m_moveStorageQueue.first().torrentHandle == torrentHandle);
4911
4912     if (m_moveStorageQueue.size() > 1)
4913     {
4914         auto iter = std::find_if((m_moveStorageQueue.begin() + 1), m_moveStorageQueue.end()
4915                 , [&torrentHandle](const MoveStorageJob &job)
4916         {
4917             return job.torrentHandle == torrentHandle;
4918         });
4919
4920         if (iter != m_moveStorageQueue.end())
4921         {
4922             // remove existing inactive job
4923             torrent->handleMoveStorageJobFinished(currentLocation, iter->context, torrentHasActiveJob);
4924             LogMsg(tr("Torrent move canceled. Torrent: \"%1\". Source: \"%2\". Destination: \"%3\"").arg(torrent->name(), currentLocation.toString(), iter->path.toString()));
4925             m_moveStorageQueue.erase(iter);
4926         }
4927     }
4928
4929     if (torrentHasActiveJob)
4930     {
4931         // if there is active job for this torrent prevent creating meaningless
4932         // job that will move torrent to the same location as current one
4933         if (m_moveStorageQueue.first().path == newPath)
4934         {
4935             LogMsg(tr("Failed to enqueue torrent move. Torrent: \"%1\". Source: \"%2\". Destination: \"%3\". Reason: torrent is currently moving to the destination")
4936                    .arg(torrent->name(), currentLocation.toString(), newPath.toString()));
4937             return false;
4938         }
4939     }
4940     else
4941     {
4942         if (currentLocation == newPath)
4943         {
4944             LogMsg(tr("Failed to enqueue torrent move. Torrent: \"%1\". Source: \"%2\" Destination: \"%3\". Reason: both paths point to the same location")
4945                    .arg(torrent->name(), currentLocation.toString(), newPath.toString()));
4946             return false;
4947         }
4948     }
4949
4950     const MoveStorageJob moveStorageJob {torrentHandle, newPath, mode, context};
4951     m_moveStorageQueue << moveStorageJob;
4952     LogMsg(tr("Enqueued torrent move. Torrent: \"%1\". Source: \"%2\". Destination: \"%3\"").arg(torrent->name(), currentLocation.toString(), newPath.toString()));
4953
4954     if (m_moveStorageQueue.size() == 1)
4955         moveTorrentStorage(moveStorageJob);
4956
4957     return true;
4958 }
4959
4960 void SessionImpl::moveTorrentStorage(const MoveStorageJob &job) const
4961 {
4962 #ifdef QBT_USES_LIBTORRENT2
4963     const auto id = TorrentID::fromInfoHash(job.torrentHandle.info_hashes());
4964 #else
4965     const auto id = TorrentID::fromInfoHash(job.torrentHandle.info_hash());
4966 #endif
4967     const TorrentImpl *torrent = m_torrents.value(id);
4968     const QString torrentName = (torrent ? torrent->name() : id.toString());
4969     LogMsg(tr("Start moving torrent. Torrent: \"%1\". Destination: \"%2\"").arg(torrentName, job.path.toString()));
4970
4971     job.torrentHandle.move_storage(job.path.toString().toStdString(), toNative(job.mode));
4972 }
4973
4974 void SessionImpl::handleMoveTorrentStorageJobFinished(const Path &newPath)
4975 {
4976     const MoveStorageJob finishedJob = m_moveStorageQueue.takeFirst();
4977     if (!m_moveStorageQueue.isEmpty())
4978         moveTorrentStorage(m_moveStorageQueue.first());
4979
4980     const auto iter = std::find_if(m_moveStorageQueue.cbegin(), m_moveStorageQueue.cend()
4981             , [&finishedJob](const MoveStorageJob &job)
4982     {
4983         return job.torrentHandle == finishedJob.torrentHandle;
4984     });
4985
4986     const bool torrentHasOutstandingJob = (iter != m_moveStorageQueue.cend());
4987
4988     TorrentImpl *torrent = m_torrents.value(finishedJob.torrentHandle.info_hash());
4989     if (torrent)
4990     {
4991         torrent->handleMoveStorageJobFinished(newPath, finishedJob.context, torrentHasOutstandingJob);
4992     }
4993     else if (!torrentHasOutstandingJob)
4994     {
4995         // Last job is completed for torrent that being removing, so actually remove it
4996         const lt::torrent_handle nativeHandle {finishedJob.torrentHandle};
4997         const RemovingTorrentData &removingTorrentData = m_removingTorrents[nativeHandle.info_hash()];
4998         if (removingTorrentData.deleteOption == DeleteTorrent)
4999             m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_partfile);
5000     }
5001 }
5002
5003 void SessionImpl::storeCategories() const
5004 {
5005     QJsonObject jsonObj;
5006     for (auto it = m_categories.cbegin(); it != m_categories.cend(); ++it)
5007     {
5008         const QString &categoryName = it.key();
5009         const CategoryOptions &categoryOptions = it.value();
5010         jsonObj[categoryName] = categoryOptions.toJSON();
5011     }
5012
5013     const Path path = specialFolderLocation(SpecialFolder::Config) / CATEGORIES_FILE_NAME;
5014     const QByteArray data = QJsonDocument(jsonObj).toJson();
5015     const nonstd::expected<void, QString> result = Utils::IO::saveToFile(path, data);
5016     if (!result)
5017     {
5018         LogMsg(tr("Failed to save Categories configuration. File: \"%1\". Error: \"%2\"")
5019                .arg(path.toString(), result.error()), Log::WARNING);
5020     }
5021 }
5022
5023 void SessionImpl::upgradeCategories()
5024 {
5025     const auto legacyCategories = SettingValue<QVariantMap>(u"BitTorrent/Session/Categories"_qs).get();
5026     for (auto it = legacyCategories.cbegin(); it != legacyCategories.cend(); ++it)
5027     {
5028         const QString &categoryName = it.key();
5029         CategoryOptions categoryOptions;
5030         categoryOptions.savePath = Path(it.value().toString());
5031         m_categories[categoryName] = categoryOptions;
5032     }
5033
5034     storeCategories();
5035 }
5036
5037 void SessionImpl::loadCategories()
5038 {
5039     m_categories.clear();
5040
5041     QFile confFile {(specialFolderLocation(SpecialFolder::Config) / CATEGORIES_FILE_NAME).data()};
5042     if (!confFile.exists())
5043     {
5044         // TODO: Remove the following upgrade code in v4.5
5045         // == BEGIN UPGRADE CODE ==
5046         upgradeCategories();
5047         m_needUpgradeDownloadPath = true;
5048         // == END UPGRADE CODE ==
5049
5050 //        return;
5051     }
5052
5053     if (!confFile.open(QFile::ReadOnly))
5054     {
5055         LogMsg(tr("Failed to load Categories. File: \"%1\". Error: \"%2\"")
5056                .arg(confFile.fileName(), confFile.errorString()), Log::CRITICAL);
5057         return;
5058     }
5059
5060     QJsonParseError jsonError;
5061     const QJsonDocument jsonDoc = QJsonDocument::fromJson(confFile.readAll(), &jsonError);
5062     if (jsonError.error != QJsonParseError::NoError)
5063     {
5064         LogMsg(tr("Failed to parse Categories configuration. File: \"%1\". Error: \"%2\"")
5065                .arg(confFile.fileName(), jsonError.errorString()), Log::WARNING);
5066         return;
5067     }
5068
5069     if (!jsonDoc.isObject())
5070     {
5071         LogMsg(tr("Failed to load Categories configuration. File: \"%1\". Reason: invalid data format")
5072                .arg(confFile.fileName()), Log::WARNING);
5073         return;
5074     }
5075
5076     const QJsonObject jsonObj = jsonDoc.object();
5077     for (auto it = jsonObj.constBegin(); it != jsonObj.constEnd(); ++it)
5078     {
5079         const QString &categoryName = it.key();
5080         const auto categoryOptions = CategoryOptions::fromJSON(it.value().toObject());
5081         m_categories[categoryName] = categoryOptions;
5082     }
5083 }
5084
5085 bool SessionImpl::hasPerTorrentRatioLimit() const
5086 {
5087     return std::any_of(m_torrents.cbegin(), m_torrents.cend(), [](const TorrentImpl *torrent)
5088     {
5089         return (torrent->ratioLimit() >= 0);
5090     });
5091 }
5092
5093 bool SessionImpl::hasPerTorrentSeedingTimeLimit() const
5094 {
5095     return std::any_of(m_torrents.cbegin(), m_torrents.cend(), [](const TorrentImpl *torrent)
5096     {
5097         return (torrent->seedingTimeLimit() >= 0);
5098     });
5099 }
5100
5101 void SessionImpl::configureDeferred()
5102 {
5103     if (m_deferredConfigureScheduled)
5104         return;
5105
5106     m_deferredConfigureScheduled = true;
5107     QMetaObject::invokeMethod(this, qOverload<>(&SessionImpl::configure), Qt::QueuedConnection);
5108 }
5109
5110 // Enable IP Filtering
5111 // this method creates ban list from scratch combining user ban list and 3rd party ban list file
5112 void SessionImpl::enableIPFilter()
5113 {
5114     qDebug("Enabling IPFilter");
5115     // 1. Parse the IP filter
5116     // 2. In the slot add the manually banned IPs to the provided lt::ip_filter
5117     // 3. Set the ip_filter in one go so there isn't a time window where there isn't an ip_filter
5118     //    set between clearing the old one and setting the new one.
5119     if (!m_filterParser)
5120     {
5121         m_filterParser = new FilterParserThread(this);
5122         connect(m_filterParser.data(), &FilterParserThread::IPFilterParsed, this, &SessionImpl::handleIPFilterParsed);
5123         connect(m_filterParser.data(), &FilterParserThread::IPFilterError, this, &SessionImpl::handleIPFilterError);
5124     }
5125     m_filterParser->processFilterFile(IPFilterFile());
5126 }
5127
5128 // Disable IP Filtering
5129 void SessionImpl::disableIPFilter()
5130 {
5131     qDebug("Disabling IPFilter");
5132     if (m_filterParser)
5133     {
5134         disconnect(m_filterParser.data(), nullptr, this, nullptr);
5135         delete m_filterParser;
5136     }
5137
5138     // Add the banned IPs after the IPFilter disabling
5139     // which creates an empty filter and overrides all previously
5140     // applied bans.
5141     lt::ip_filter filter;
5142     processBannedIPs(filter);
5143     m_nativeSession->set_ip_filter(filter);
5144 }
5145
5146 void SessionImpl::recursiveTorrentDownload(const TorrentID &id)
5147 {
5148     const TorrentImpl *torrent = m_torrents.value(id);
5149     if (!torrent)
5150         return;
5151
5152     for (const Path &torrentRelpath : asConst(torrent->filePaths()))
5153     {
5154         if (torrentRelpath.hasExtension(u".torrent"_qs))
5155         {
5156             const Path torrentFullpath = torrent->savePath() / torrentRelpath;
5157
5158             LogMsg(tr("Recursive download .torrent file within torrent. Source torrent: \"%1\". File: \"%2\"")
5159                 .arg(torrent->name(), torrentFullpath.toString()));
5160
5161             AddTorrentParams params;
5162             // Passing the save path along to the sub torrent file
5163             params.savePath = torrent->savePath();
5164             const nonstd::expected<TorrentInfo, QString> loadResult = TorrentInfo::loadFromFile(torrentFullpath);
5165             if (loadResult)
5166             {
5167                 addTorrent(loadResult.value(), params);
5168             }
5169             else
5170             {
5171                 LogMsg(tr("Failed to load .torrent file within torrent. Source torrent: \"%1\". File: \"%2\". Error: \"%3\"")
5172                     .arg(torrent->name(), torrentFullpath.toString(), loadResult.error()), Log::WARNING);
5173             }
5174         }
5175     }
5176 }
5177
5178 const SessionStatus &SessionImpl::status() const
5179 {
5180     return m_status;
5181 }
5182
5183 const CacheStatus &SessionImpl::cacheStatus() const
5184 {
5185     return m_cacheStatus;
5186 }
5187
5188 void SessionImpl::enqueueRefresh()
5189 {
5190     Q_ASSERT(!m_refreshEnqueued);
5191
5192     QTimer::singleShot(refreshInterval(), Qt::CoarseTimer, this, [this]
5193     {
5194         m_nativeSession->post_torrent_updates();
5195         m_nativeSession->post_session_stats();
5196
5197         if (m_torrentsQueueChanged)
5198         {
5199             m_torrentsQueueChanged = false;
5200             m_needSaveTorrentsQueue = true;
5201         }
5202     });
5203
5204     m_refreshEnqueued = true;
5205 }
5206
5207 void SessionImpl::handleIPFilterParsed(const int ruleCount)
5208 {
5209     if (m_filterParser)
5210     {
5211         lt::ip_filter filter = m_filterParser->IPfilter();
5212         processBannedIPs(filter);
5213         m_nativeSession->set_ip_filter(filter);
5214     }
5215     LogMsg(tr("Successfully parsed the IP filter file. Number of rules applied: %1").arg(ruleCount));
5216     emit IPFilterParsed(false, ruleCount);
5217 }
5218
5219 void SessionImpl::handleIPFilterError()
5220 {
5221     lt::ip_filter filter;
5222     processBannedIPs(filter);
5223     m_nativeSession->set_ip_filter(filter);
5224
5225     LogMsg(tr("Failed to parse the IP filter file"), Log::WARNING);
5226     emit IPFilterParsed(true, 0);
5227 }
5228
5229 std::vector<lt::alert *> SessionImpl::getPendingAlerts(const lt::time_duration time) const
5230 {
5231     if (time > lt::time_duration::zero())
5232         m_nativeSession->wait_for_alert(time);
5233
5234     std::vector<lt::alert *> alerts;
5235     m_nativeSession->pop_alerts(&alerts);
5236     return alerts;
5237 }
5238
5239 TorrentContentLayout SessionImpl::torrentContentLayout() const
5240 {
5241     return m_torrentContentLayout;
5242 }
5243
5244 void SessionImpl::setTorrentContentLayout(const TorrentContentLayout value)
5245 {
5246     m_torrentContentLayout = value;
5247 }
5248
5249 // Read alerts sent by the BitTorrent session
5250 void SessionImpl::readAlerts()
5251 {
5252     const std::vector<lt::alert *> alerts = getPendingAlerts();
5253     handleAddTorrentAlerts(alerts);
5254     for (const lt::alert *a : alerts)
5255         handleAlert(a);
5256
5257     processTrackerStatuses();
5258 }
5259
5260 void SessionImpl::handleAddTorrentAlerts(const std::vector<lt::alert *> &alerts)
5261 {
5262     QVector<Torrent *> loadedTorrents;
5263     if (!isRestored())
5264         loadedTorrents.reserve(MAX_PROCESSING_RESUMEDATA_COUNT);
5265
5266     for (const lt::alert *a : alerts)
5267     {
5268         if (a->type() != lt::add_torrent_alert::alert_type)
5269             continue;
5270
5271         const auto *alert = static_cast<const lt::add_torrent_alert *>(a);
5272         if (alert->error)
5273         {
5274             const QString msg = QString::fromStdString(alert->message());
5275             LogMsg(tr("Failed to load torrent. Reason: \"%1\"").arg(msg), Log::WARNING);
5276             emit loadTorrentFailed(msg);
5277
5278             const lt::add_torrent_params &params = alert->params;
5279             const bool hasMetadata = (params.ti && params.ti->is_valid());
5280 #ifdef QBT_USES_LIBTORRENT2
5281             const InfoHash infoHash {(hasMetadata ? params.ti->info_hashes() : params.info_hashes)};
5282             if (infoHash.isHybrid())
5283                 m_hybridTorrentsByAltID.remove(TorrentID::fromSHA1Hash(infoHash.v1()));
5284 #else
5285             const InfoHash infoHash {(hasMetadata ? params.ti->info_hash() : params.info_hash)};
5286 #endif
5287             if (const auto loadingTorrentsIter = m_loadingTorrents.find(TorrentID::fromInfoHash(infoHash))
5288                     ; loadingTorrentsIter != m_loadingTorrents.end())
5289             {
5290                 m_loadingTorrents.erase(loadingTorrentsIter);
5291             }
5292             else if (const auto downloadedMetadataIter = m_downloadedMetadata.find(TorrentID::fromInfoHash(infoHash))
5293                      ; downloadedMetadataIter != m_downloadedMetadata.end())
5294             {
5295                 m_downloadedMetadata.erase(downloadedMetadataIter);
5296                 if (infoHash.isHybrid())
5297                 {
5298                     // index hybrid magnet links by both v1 and v2 info hashes
5299                     const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
5300                     m_downloadedMetadata.remove(altID);
5301                 }
5302             }
5303
5304             return;
5305         }
5306
5307
5308 #ifdef QBT_USES_LIBTORRENT2
5309         const InfoHash infoHash {alert->handle.info_hashes()};
5310 #else
5311         const InfoHash infoHash {alert->handle.info_hash()};
5312 #endif
5313         const auto torrentID = TorrentID::fromInfoHash(infoHash);
5314
5315         if (const auto loadingTorrentsIter = m_loadingTorrents.find(torrentID)
5316                 ; loadingTorrentsIter != m_loadingTorrents.end())
5317         {
5318             const LoadTorrentParams params = loadingTorrentsIter.value();
5319             m_loadingTorrents.erase(loadingTorrentsIter);
5320
5321             Torrent *torrent = createTorrent(alert->handle, params);
5322             loadedTorrents.append(torrent);
5323         }
5324         else if (const auto downloadedMetadataIter = m_downloadedMetadata.find(torrentID)
5325                  ; downloadedMetadataIter != m_downloadedMetadata.end())
5326         {
5327             downloadedMetadataIter.value() = alert->handle;
5328             if (infoHash.isHybrid())
5329             {
5330                 // index hybrid magnet links by both v1 and v2 info hashes
5331                 const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
5332                 m_downloadedMetadata[altID] = alert->handle;
5333             }
5334         }
5335     }
5336
5337     if (!loadedTorrents.isEmpty())
5338     {
5339         if (isRestored())
5340             m_torrentsQueueChanged = true;
5341         emit torrentsLoaded(loadedTorrents);
5342     }
5343 }
5344
5345 void SessionImpl::handleAlert(const lt::alert *a)
5346 {
5347     try
5348     {
5349         switch (a->type())
5350         {
5351 #ifdef QBT_USES_LIBTORRENT2
5352         case lt::file_prio_alert::alert_type:
5353 #endif
5354         case lt::file_renamed_alert::alert_type:
5355         case lt::file_rename_failed_alert::alert_type:
5356         case lt::file_completed_alert::alert_type:
5357         case lt::torrent_finished_alert::alert_type:
5358         case lt::save_resume_data_alert::alert_type:
5359         case lt::save_resume_data_failed_alert::alert_type:
5360         case lt::torrent_paused_alert::alert_type:
5361         case lt::torrent_resumed_alert::alert_type:
5362         case lt::fastresume_rejected_alert::alert_type:
5363         case lt::torrent_checked_alert::alert_type:
5364         case lt::metadata_received_alert::alert_type:
5365         case lt::performance_alert::alert_type:
5366             dispatchTorrentAlert(static_cast<const lt::torrent_alert *>(a));
5367             break;
5368         case lt::state_update_alert::alert_type:
5369             handleStateUpdateAlert(static_cast<const lt::state_update_alert*>(a));
5370             break;
5371         case lt::session_stats_alert::alert_type:
5372             handleSessionStatsAlert(static_cast<const lt::session_stats_alert*>(a));
5373             break;
5374         case lt::tracker_announce_alert::alert_type:
5375         case lt::tracker_error_alert::alert_type:
5376         case lt::tracker_reply_alert::alert_type:
5377         case lt::tracker_warning_alert::alert_type:
5378             handleTrackerAlert(static_cast<const lt::tracker_alert *>(a));
5379             break;
5380         case lt::file_error_alert::alert_type:
5381             handleFileErrorAlert(static_cast<const lt::file_error_alert*>(a));
5382             break;
5383         case lt::add_torrent_alert::alert_type:
5384             // handled separately
5385             break;
5386         case lt::torrent_removed_alert::alert_type:
5387             handleTorrentRemovedAlert(static_cast<const lt::torrent_removed_alert*>(a));
5388             break;
5389         case lt::torrent_deleted_alert::alert_type:
5390             handleTorrentDeletedAlert(static_cast<const lt::torrent_deleted_alert*>(a));
5391             break;
5392         case lt::torrent_delete_failed_alert::alert_type:
5393             handleTorrentDeleteFailedAlert(static_cast<const lt::torrent_delete_failed_alert*>(a));
5394             break;
5395         case lt::portmap_error_alert::alert_type:
5396             handlePortmapWarningAlert(static_cast<const lt::portmap_error_alert*>(a));
5397             break;
5398         case lt::portmap_alert::alert_type:
5399             handlePortmapAlert(static_cast<const lt::portmap_alert*>(a));
5400             break;
5401         case lt::peer_blocked_alert::alert_type:
5402             handlePeerBlockedAlert(static_cast<const lt::peer_blocked_alert*>(a));
5403             break;
5404         case lt::peer_ban_alert::alert_type:
5405             handlePeerBanAlert(static_cast<const lt::peer_ban_alert*>(a));
5406             break;
5407         case lt::url_seed_alert::alert_type:
5408             handleUrlSeedAlert(static_cast<const lt::url_seed_alert*>(a));
5409             break;
5410         case lt::listen_succeeded_alert::alert_type:
5411             handleListenSucceededAlert(static_cast<const lt::listen_succeeded_alert*>(a));
5412             break;
5413         case lt::listen_failed_alert::alert_type:
5414             handleListenFailedAlert(static_cast<const lt::listen_failed_alert*>(a));
5415             break;
5416         case lt::external_ip_alert::alert_type:
5417             handleExternalIPAlert(static_cast<const lt::external_ip_alert*>(a));
5418             break;
5419         case lt::alerts_dropped_alert::alert_type:
5420             handleAlertsDroppedAlert(static_cast<const lt::alerts_dropped_alert *>(a));
5421             break;
5422         case lt::storage_moved_alert::alert_type:
5423             handleStorageMovedAlert(static_cast<const lt::storage_moved_alert*>(a));
5424             break;
5425         case lt::storage_moved_failed_alert::alert_type:
5426             handleStorageMovedFailedAlert(static_cast<const lt::storage_moved_failed_alert*>(a));
5427             break;
5428         case lt::socks5_alert::alert_type:
5429             handleSocks5Alert(static_cast<const lt::socks5_alert *>(a));
5430             break;
5431 #ifdef QBT_USES_LIBTORRENT2
5432         case lt::torrent_conflict_alert::alert_type:
5433             handleTorrentConflictAlert(static_cast<const lt::torrent_conflict_alert *>(a));
5434             break;
5435 #endif
5436         }
5437     }
5438     catch (const std::exception &exc)
5439     {
5440         qWarning() << "Caught exception in " << Q_FUNC_INFO << ": " << QString::fromStdString(exc.what());
5441     }
5442 }
5443
5444 void SessionImpl::dispatchTorrentAlert(const lt::torrent_alert *a)
5445 {
5446     const TorrentID torrentID {a->handle.info_hash()};
5447     TorrentImpl *torrent = m_torrents.value(torrentID);
5448 #ifdef QBT_USES_LIBTORRENT2
5449     if (!torrent && (a->type() == lt::metadata_received_alert::alert_type))
5450     {
5451         const InfoHash infoHash {a->handle.info_hashes()};
5452         if (infoHash.isHybrid())
5453             torrent = m_torrents.value(TorrentID::fromSHA1Hash(infoHash.v1()));
5454     }
5455 #endif
5456
5457     if (torrent)
5458     {
5459         torrent->handleAlert(a);
5460         return;
5461     }
5462
5463     switch (a->type())
5464     {
5465     case lt::metadata_received_alert::alert_type:
5466         handleMetadataReceivedAlert(static_cast<const lt::metadata_received_alert *>(a));
5467         break;
5468     }
5469 }
5470
5471 TorrentImpl *SessionImpl::createTorrent(const lt::torrent_handle &nativeHandle, const LoadTorrentParams &params)
5472 {
5473     auto *const torrent = new TorrentImpl(this, m_nativeSession, nativeHandle, params);
5474     m_torrents.insert(torrent->id(), torrent);
5475     if (const InfoHash infoHash = torrent->infoHash(); infoHash.isHybrid())
5476         m_hybridTorrentsByAltID.insert(TorrentID::fromSHA1Hash(infoHash.v1()), torrent);
5477
5478     if (isRestored())
5479     {
5480         if (params.addToQueueTop)
5481             nativeHandle.queue_position_top();
5482
5483         torrent->saveResumeData(lt::torrent_handle::save_info_dict);
5484
5485         // The following is useless for newly added magnet
5486         if (torrent->hasMetadata())
5487         {
5488             if (!torrentExportDirectory().isEmpty())
5489                 exportTorrentFile(torrent, torrentExportDirectory());
5490         }
5491     }
5492
5493     if (((torrent->ratioLimit() >= 0) || (torrent->seedingTimeLimit() >= 0))
5494         && !m_seedingLimitTimer->isActive())
5495     {
5496         m_seedingLimitTimer->start();
5497     }
5498
5499     if (!isRestored())
5500     {
5501         LogMsg(tr("Restored torrent. Torrent: \"%1\"").arg(torrent->name()));
5502     }
5503     else
5504     {
5505         LogMsg(tr("Added new torrent. Torrent: \"%1\"").arg(torrent->name()));
5506         emit torrentAdded(torrent);
5507     }
5508
5509     // Torrent could have error just after adding to libtorrent
5510     if (torrent->hasError())
5511         LogMsg(tr("Torrent errored. Torrent: \"%1\". Error: \"%2\"").arg(torrent->name(), torrent->error()), Log::WARNING);
5512
5513     return torrent;
5514 }
5515
5516 void SessionImpl::handleTorrentRemovedAlert(const lt::torrent_removed_alert *p)
5517 {
5518 #ifdef QBT_USES_LIBTORRENT2
5519     const auto id = TorrentID::fromInfoHash(p->info_hashes);
5520 #else
5521     const auto id = TorrentID::fromInfoHash(p->info_hash);
5522 #endif
5523
5524     const auto removingTorrentDataIter = m_removingTorrents.find(id);
5525     if (removingTorrentDataIter != m_removingTorrents.end())
5526     {
5527         if (removingTorrentDataIter->deleteOption == DeleteTorrent)
5528         {
5529             LogMsg(tr("Removed torrent. Torrent: \"%1\"").arg(removingTorrentDataIter->name));
5530             m_removingTorrents.erase(removingTorrentDataIter);
5531         }
5532     }
5533 }
5534
5535 void SessionImpl::handleTorrentDeletedAlert(const lt::torrent_deleted_alert *p)
5536 {
5537 #ifdef QBT_USES_LIBTORRENT2
5538     const auto id = TorrentID::fromInfoHash(p->info_hashes);
5539 #else
5540     const auto id = TorrentID::fromInfoHash(p->info_hash);
5541 #endif
5542
5543     const auto removingTorrentDataIter = m_removingTorrents.find(id);
5544     if (removingTorrentDataIter == m_removingTorrents.end())
5545         return;
5546
5547     // torrent_deleted_alert can also be posted due to deletion of partfile. Ignore it in such a case.
5548     if (removingTorrentDataIter->deleteOption == DeleteTorrent)
5549         return;
5550
5551     Utils::Fs::smartRemoveEmptyFolderTree(removingTorrentDataIter->pathToRemove);
5552     LogMsg(tr("Removed torrent and deleted its content. Torrent: \"%1\"").arg(removingTorrentDataIter->name));
5553     m_removingTorrents.erase(removingTorrentDataIter);
5554 }
5555
5556 void SessionImpl::handleTorrentDeleteFailedAlert(const lt::torrent_delete_failed_alert *p)
5557 {
5558 #ifdef QBT_USES_LIBTORRENT2
5559     const auto id = TorrentID::fromInfoHash(p->info_hashes);
5560 #else
5561     const auto id = TorrentID::fromInfoHash(p->info_hash);
5562 #endif
5563
5564     const auto removingTorrentDataIter = m_removingTorrents.find(id);
5565     if (removingTorrentDataIter == m_removingTorrents.end())
5566         return;
5567
5568     if (p->error)
5569     {
5570         // libtorrent won't delete the directory if it contains files not listed in the torrent,
5571         // so we remove the directory ourselves
5572         Utils::Fs::smartRemoveEmptyFolderTree(removingTorrentDataIter->pathToRemove);
5573
5574         LogMsg(tr("Removed torrent but failed to delete its content and/or partfile. Torrent: \"%1\". Error: \"%2\"")
5575                 .arg(removingTorrentDataIter->name, QString::fromLocal8Bit(p->error.message().c_str()))
5576             , Log::WARNING);
5577     }
5578     else // torrent without metadata, hence no files on disk
5579     {
5580         LogMsg(tr("Removed torrent. Torrent: \"%1\"").arg(removingTorrentDataIter->name));
5581     }
5582
5583     m_removingTorrents.erase(removingTorrentDataIter);
5584 }
5585
5586 void SessionImpl::handleMetadataReceivedAlert(const lt::metadata_received_alert *p)
5587 {
5588     const TorrentID torrentID {p->handle.info_hash()};
5589
5590     bool found = false;
5591     if (const auto iter = m_downloadedMetadata.find(torrentID); iter != m_downloadedMetadata.end())
5592     {
5593         found = true;
5594         m_downloadedMetadata.erase(iter);
5595     }
5596 #ifdef QBT_USES_LIBTORRENT2
5597     const InfoHash infoHash {p->handle.info_hashes()};
5598     if (infoHash.isHybrid())
5599     {
5600         const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
5601         if (const auto iter = m_downloadedMetadata.find(altID); iter != m_downloadedMetadata.end())
5602         {
5603             found = true;
5604             m_downloadedMetadata.erase(iter);
5605         }
5606     }
5607 #endif
5608     if (found)
5609     {
5610         const TorrentInfo metadata {*p->handle.torrent_file()};
5611         m_nativeSession->remove_torrent(p->handle, lt::session::delete_files);
5612
5613         emit metadataDownloaded(metadata);
5614     }
5615 }
5616
5617 void SessionImpl::handleFileErrorAlert(const lt::file_error_alert *p)
5618 {
5619     TorrentImpl *const torrent = m_torrents.value(p->handle.info_hash());
5620     if (!torrent)
5621         return;
5622
5623     torrent->handleAlert(p);
5624
5625     const TorrentID id = torrent->id();
5626     if (!m_recentErroredTorrents.contains(id))
5627     {
5628         m_recentErroredTorrents.insert(id);
5629
5630         const QString msg = QString::fromStdString(p->message());
5631         LogMsg(tr("File error alert. Torrent: \"%1\". File: \"%2\". Reason: \"%3\"")
5632                 .arg(torrent->name(), QString::fromLocal8Bit(p->filename()), msg)
5633             , Log::WARNING);
5634         emit fullDiskError(torrent, msg);
5635     }
5636
5637     m_recentErroredTorrentsTimer->start();
5638 }
5639
5640 void SessionImpl::handlePortmapWarningAlert(const lt::portmap_error_alert *p)
5641 {
5642     LogMsg(tr("UPnP/NAT-PMP port mapping failed. Message: \"%1\"").arg(QString::fromStdString(p->message())), Log::WARNING);
5643 }
5644
5645 void SessionImpl::handlePortmapAlert(const lt::portmap_alert *p)
5646 {
5647     qDebug("UPnP Success, msg: %s", p->message().c_str());
5648     LogMsg(tr("UPnP/NAT-PMP port mapping succeeded. Message: \"%1\"").arg(QString::fromStdString(p->message())), Log::INFO);
5649 }
5650
5651 void SessionImpl::handlePeerBlockedAlert(const lt::peer_blocked_alert *p)
5652 {
5653     QString reason;
5654     switch (p->reason)
5655     {
5656     case lt::peer_blocked_alert::ip_filter:
5657         reason = tr("IP filter", "this peer was blocked. Reason: IP filter.");
5658         break;
5659     case lt::peer_blocked_alert::port_filter:
5660         reason = tr("filtered port (%1)", "this peer was blocked. Reason: filtered port (8899).").arg(QString::number(p->endpoint.port()));
5661         break;
5662     case lt::peer_blocked_alert::i2p_mixed:
5663         reason = tr("%1 mixed mode restrictions", "this peer was blocked. Reason: I2P mixed mode restrictions.").arg(u"I2P"_qs); // don't translate I2P
5664         break;
5665     case lt::peer_blocked_alert::privileged_ports:
5666         reason = tr("privileged port (%1)", "this peer was blocked. Reason: privileged port (80).").arg(QString::number(p->endpoint.port()));
5667         break;
5668     case lt::peer_blocked_alert::utp_disabled:
5669         reason = tr("%1 is disabled", "this peer was blocked. Reason: uTP is disabled.").arg(C_UTP); // don't translate μTP
5670         break;
5671     case lt::peer_blocked_alert::tcp_disabled:
5672         reason = tr("%1 is disabled", "this peer was blocked. Reason: TCP is disabled.").arg(u"TCP"_qs); // don't translate TCP
5673         break;
5674     }
5675
5676     const QString ip {toString(p->endpoint.address())};
5677     if (!ip.isEmpty())
5678         Logger::instance()->addPeer(ip, true, reason);
5679 }
5680
5681 void SessionImpl::handlePeerBanAlert(const lt::peer_ban_alert *p)
5682 {
5683     const QString ip {toString(p->endpoint.address())};
5684     if (!ip.isEmpty())
5685         Logger::instance()->addPeer(ip, false);
5686 }
5687
5688 void SessionImpl::handleUrlSeedAlert(const lt::url_seed_alert *p)
5689 {
5690     const TorrentImpl *torrent = m_torrents.value(p->handle.info_hash());
5691     if (!torrent)
5692         return;
5693
5694     if (p->error)
5695     {
5696         LogMsg(tr("URL seed DNS lookup failed. Torrent: \"%1\". URL: \"%2\". Error: \"%3\"")
5697             .arg(torrent->name(), QString::fromUtf8(p->server_url()), QString::fromStdString(p->message()))
5698             , Log::WARNING);
5699     }
5700     else
5701     {
5702         LogMsg(tr("Received error message from URL seed. Torrent: \"%1\". URL: \"%2\". Message: \"%3\"")
5703             .arg(torrent->name(), QString::fromUtf8(p->server_url()), QString::fromUtf8(p->error_message()))
5704             , Log::WARNING);
5705     }
5706 }
5707
5708 void SessionImpl::handleListenSucceededAlert(const lt::listen_succeeded_alert *p)
5709 {
5710     const QString proto {toString(p->socket_type)};
5711     LogMsg(tr("Successfully listening on IP. IP: \"%1\". Port: \"%2/%3\"")
5712             .arg(toString(p->address), proto, QString::number(p->port)), Log::INFO);
5713 }
5714
5715 void SessionImpl::handleListenFailedAlert(const lt::listen_failed_alert *p)
5716 {
5717     const QString proto {toString(p->socket_type)};
5718     LogMsg(tr("Failed to listen on IP. IP: \"%1\". Port: \"%2/%3\". Reason: \"%4\"")
5719         .arg(toString(p->address), proto, QString::number(p->port)
5720             , QString::fromLocal8Bit(p->error.message().c_str())), Log::CRITICAL);
5721 }
5722
5723 void SessionImpl::handleExternalIPAlert(const lt::external_ip_alert *p)
5724 {
5725     const QString externalIP {toString(p->external_address)};
5726     LogMsg(tr("Detected external IP. IP: \"%1\"")
5727         .arg(externalIP), Log::INFO);
5728
5729     if (m_lastExternalIP != externalIP)
5730     {
5731         if (isReannounceWhenAddressChangedEnabled() && !m_lastExternalIP.isEmpty())
5732             reannounceToAllTrackers();
5733         m_lastExternalIP = externalIP;
5734     }
5735 }
5736
5737 void SessionImpl::handleSessionStatsAlert(const lt::session_stats_alert *p)
5738 {
5739     if (m_refreshEnqueued)
5740         m_refreshEnqueued = false;
5741     else
5742         enqueueRefresh();
5743
5744     const int64_t interval = lt::total_microseconds(p->timestamp() - m_statsLastTimestamp);
5745     if (interval <= 0)
5746         return;
5747
5748     m_statsLastTimestamp = p->timestamp();
5749
5750     const auto stats = p->counters();
5751
5752     m_status.hasIncomingConnections = static_cast<bool>(stats[m_metricIndices.net.hasIncomingConnections]);
5753
5754     const int64_t ipOverheadDownload = stats[m_metricIndices.net.recvIPOverheadBytes];
5755     const int64_t ipOverheadUpload = stats[m_metricIndices.net.sentIPOverheadBytes];
5756     const int64_t totalDownload = stats[m_metricIndices.net.recvBytes] + ipOverheadDownload;
5757     const int64_t totalUpload = stats[m_metricIndices.net.sentBytes] + ipOverheadUpload;
5758     const int64_t totalPayloadDownload = stats[m_metricIndices.net.recvPayloadBytes];
5759     const int64_t totalPayloadUpload = stats[m_metricIndices.net.sentPayloadBytes];
5760     const int64_t trackerDownload = stats[m_metricIndices.net.recvTrackerBytes];
5761     const int64_t trackerUpload = stats[m_metricIndices.net.sentTrackerBytes];
5762     const int64_t dhtDownload = stats[m_metricIndices.dht.dhtBytesIn];
5763     const int64_t dhtUpload = stats[m_metricIndices.dht.dhtBytesOut];
5764
5765     const auto calcRate = [interval](const qint64 previous, const qint64 current) -> qint64
5766     {
5767         Q_ASSERT(current >= previous);
5768         Q_ASSERT(interval >= 0);
5769         return (((current - previous) * lt::microseconds(1s).count()) / interval);
5770     };
5771
5772     m_status.payloadDownloadRate = calcRate(m_status.totalPayloadDownload, totalPayloadDownload);
5773     m_status.payloadUploadRate = calcRate(m_status.totalPayloadUpload, totalPayloadUpload);
5774     m_status.downloadRate = calcRate(m_status.totalDownload, totalDownload);
5775     m_status.uploadRate = calcRate(m_status.totalUpload, totalUpload);
5776     m_status.ipOverheadDownloadRate = calcRate(m_status.ipOverheadDownload, ipOverheadDownload);
5777     m_status.ipOverheadUploadRate = calcRate(m_status.ipOverheadUpload, ipOverheadUpload);
5778     m_status.dhtDownloadRate = calcRate(m_status.dhtDownload, dhtDownload);
5779     m_status.dhtUploadRate = calcRate(m_status.dhtUpload, dhtUpload);
5780     m_status.trackerDownloadRate = calcRate(m_status.trackerDownload, trackerDownload);
5781     m_status.trackerUploadRate = calcRate(m_status.trackerUpload, trackerUpload);
5782
5783     m_status.totalPayloadDownload = totalPayloadDownload;
5784     m_status.totalPayloadUpload = totalPayloadUpload;
5785     m_status.ipOverheadDownload = ipOverheadDownload;
5786     m_status.ipOverheadUpload = ipOverheadUpload;
5787     m_status.trackerDownload = trackerDownload;
5788     m_status.trackerUpload = trackerUpload;
5789     m_status.dhtDownload = dhtDownload;
5790     m_status.dhtUpload = dhtUpload;
5791     m_status.totalWasted = stats[m_metricIndices.net.recvRedundantBytes]
5792             + stats[m_metricIndices.net.recvFailedBytes];
5793     m_status.dhtNodes = stats[m_metricIndices.dht.dhtNodes];
5794     m_status.diskReadQueue = stats[m_metricIndices.peer.numPeersUpDisk];
5795     m_status.diskWriteQueue = stats[m_metricIndices.peer.numPeersDownDisk];
5796     m_status.peersCount = stats[m_metricIndices.peer.numPeersConnected];
5797
5798     if (totalDownload > m_status.totalDownload)
5799     {
5800         m_status.totalDownload = totalDownload;
5801         m_isStatisticsDirty = true;
5802     }
5803
5804     if (totalUpload > m_status.totalUpload)
5805     {
5806         m_status.totalUpload = totalUpload;
5807         m_isStatisticsDirty = true;
5808     }
5809
5810     m_status.allTimeDownload = m_previouslyDownloaded + m_status.totalDownload;
5811     m_status.allTimeUpload = m_previouslyUploaded + m_status.totalUpload;
5812
5813     if (m_statisticsLastUpdateTimer.hasExpired(STATISTICS_SAVE_INTERVAL))
5814         saveStatistics();
5815
5816     m_cacheStatus.totalUsedBuffers = stats[m_metricIndices.disk.diskBlocksInUse];
5817     m_cacheStatus.jobQueueLength = stats[m_metricIndices.disk.queuedDiskJobs];
5818
5819 #ifndef QBT_USES_LIBTORRENT2
5820     const int64_t numBlocksRead = stats[m_metricIndices.disk.numBlocksRead];
5821     const int64_t numBlocksCacheHits = stats[m_metricIndices.disk.numBlocksCacheHits];
5822     m_cacheStatus.readRatio = static_cast<qreal>(numBlocksCacheHits) / std::max<int64_t>((numBlocksCacheHits + numBlocksRead), 1);
5823 #endif
5824
5825     const int64_t totalJobs = stats[m_metricIndices.disk.writeJobs] + stats[m_metricIndices.disk.readJobs]
5826                   + stats[m_metricIndices.disk.hashJobs];
5827     m_cacheStatus.averageJobTime = (totalJobs > 0)
5828                                    ? (stats[m_metricIndices.disk.diskJobTime] / totalJobs) : 0;
5829
5830     emit statsUpdated();
5831 }
5832
5833 void SessionImpl::handleAlertsDroppedAlert(const lt::alerts_dropped_alert *p) const
5834 {
5835     LogMsg(tr("Error: Internal alert queue is full and alerts are dropped, you might see degraded performance. Dropped alert type: \"%1\". Message: \"%2\"")
5836         .arg(QString::fromStdString(p->dropped_alerts.to_string()), QString::fromStdString(p->message())), Log::CRITICAL);
5837 }
5838
5839 void SessionImpl::handleStorageMovedAlert(const lt::storage_moved_alert *p)
5840 {
5841     Q_ASSERT(!m_moveStorageQueue.isEmpty());
5842
5843     const MoveStorageJob &currentJob = m_moveStorageQueue.first();
5844     Q_ASSERT(currentJob.torrentHandle == p->handle);
5845
5846     const Path newPath {QString::fromUtf8(p->storage_path())};
5847     Q_ASSERT(newPath == currentJob.path);
5848
5849 #ifdef QBT_USES_LIBTORRENT2
5850     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hashes());
5851 #else
5852     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hash());
5853 #endif
5854
5855     TorrentImpl *torrent = m_torrents.value(id);
5856     const QString torrentName = (torrent ? torrent->name() : id.toString());
5857     LogMsg(tr("Moved torrent successfully. Torrent: \"%1\". Destination: \"%2\"").arg(torrentName, newPath.toString()));
5858
5859     handleMoveTorrentStorageJobFinished(newPath);
5860 }
5861
5862 void SessionImpl::handleStorageMovedFailedAlert(const lt::storage_moved_failed_alert *p)
5863 {
5864     Q_ASSERT(!m_moveStorageQueue.isEmpty());
5865
5866     const MoveStorageJob &currentJob = m_moveStorageQueue.first();
5867     Q_ASSERT(currentJob.torrentHandle == p->handle);
5868
5869 #ifdef QBT_USES_LIBTORRENT2
5870     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hashes());
5871 #else
5872     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hash());
5873 #endif
5874
5875     TorrentImpl *torrent = m_torrents.value(id);
5876     const QString torrentName = (torrent ? torrent->name() : id.toString());
5877     const Path currentLocation = (torrent ? torrent->actualStorageLocation()
5878             : Path(p->handle.status(lt::torrent_handle::query_save_path).save_path));
5879     const QString errorMessage = QString::fromStdString(p->message());
5880     LogMsg(tr("Failed to move torrent. Torrent: \"%1\". Source: \"%2\". Destination: \"%3\". Reason: \"%4\"")
5881            .arg(torrentName, currentLocation.toString(), currentJob.path.toString(), errorMessage), Log::WARNING);
5882
5883     handleMoveTorrentStorageJobFinished(currentLocation);
5884 }
5885
5886 void SessionImpl::handleStateUpdateAlert(const lt::state_update_alert *p)
5887 {
5888     QVector<Torrent *> updatedTorrents;
5889     updatedTorrents.reserve(static_cast<decltype(updatedTorrents)::size_type>(p->status.size()));
5890
5891     for (const lt::torrent_status &status : p->status)
5892     {
5893 #ifdef QBT_USES_LIBTORRENT2
5894         const auto id = TorrentID::fromInfoHash(status.info_hashes);
5895 #else
5896         const auto id = TorrentID::fromInfoHash(status.info_hash);
5897 #endif
5898         TorrentImpl *const torrent = m_torrents.value(id);
5899         if (!torrent)
5900             continue;
5901
5902         torrent->handleStateUpdate(status);
5903         updatedTorrents.push_back(torrent);
5904     }
5905
5906     if (!updatedTorrents.isEmpty())
5907         emit torrentsUpdated(updatedTorrents);
5908
5909     if (m_needSaveTorrentsQueue)
5910         saveTorrentsQueue();
5911
5912     if (m_refreshEnqueued)
5913         m_refreshEnqueued = false;
5914     else
5915         enqueueRefresh();
5916 }
5917
5918 void SessionImpl::handleSocks5Alert(const lt::socks5_alert *p) const
5919 {
5920     if (p->error)
5921     {
5922         const auto addr = p->ip.address();
5923         const QString endpoint = (addr.is_v6() ? u"[%1]:%2"_qs : u"%1:%2"_qs)
5924                 .arg(QString::fromStdString(addr.to_string()), QString::number(p->ip.port()));
5925         LogMsg(tr("SOCKS5 proxy error. Address: %1. Message: \"%2\".")
5926                 .arg(endpoint, QString::fromLocal8Bit(p->error.message().c_str()))
5927                 , Log::WARNING);
5928     }
5929 }
5930
5931 void SessionImpl::handleTrackerAlert(const lt::tracker_alert *a)
5932 {
5933     TorrentImpl *torrent = m_torrents.value(a->handle.info_hash());
5934     if (!torrent)
5935         return;
5936
5937     QMap<TrackerEntry::Endpoint, int> &updateInfo = m_updatedTrackerEntries[torrent->nativeHandle()][std::string(a->tracker_url())];
5938
5939     if (a->type() == lt::tracker_reply_alert::alert_type)
5940     {
5941         const int numPeers = static_cast<const lt::tracker_reply_alert *>(a)->num_peers;
5942         updateInfo.insert(a->local_endpoint, numPeers);
5943     }
5944 }
5945
5946 #ifdef QBT_USES_LIBTORRENT2
5947 void SessionImpl::handleTorrentConflictAlert(const lt::torrent_conflict_alert *a)
5948 {
5949     const auto torrentIDv1 = TorrentID::fromSHA1Hash(a->metadata->info_hashes().v1);
5950     const auto torrentIDv2 = TorrentID::fromSHA256Hash(a->metadata->info_hashes().v2);
5951     TorrentImpl *torrent1 = m_torrents.value(torrentIDv1);
5952     TorrentImpl *torrent2 = m_torrents.value(torrentIDv2);
5953     if (torrent2)
5954     {
5955         if (torrent1)
5956             deleteTorrent(torrentIDv1);
5957         else
5958             cancelDownloadMetadata(torrentIDv1);
5959
5960         invokeAsync([torrentHandle = torrent2->nativeHandle(), metadata = a->metadata]
5961         {
5962             try
5963             {
5964                 torrentHandle.set_metadata(metadata->info_section());
5965             }
5966             catch (const std::exception &) {}
5967         });
5968     }
5969     else if (torrent1)
5970     {
5971         if (!torrent2)
5972             cancelDownloadMetadata(torrentIDv2);
5973
5974         invokeAsync([torrentHandle = torrent1->nativeHandle(), metadata = a->metadata]
5975         {
5976             try
5977             {
5978                 torrentHandle.set_metadata(metadata->info_section());
5979             }
5980             catch (const std::exception &) {}
5981         });
5982     }
5983     else
5984     {
5985         cancelDownloadMetadata(torrentIDv1);
5986         cancelDownloadMetadata(torrentIDv2);
5987     }
5988
5989     if (!torrent1 || !torrent2)
5990         emit metadataDownloaded(TorrentInfo(*a->metadata));
5991 }
5992 #endif
5993
5994 void SessionImpl::processTrackerStatuses()
5995 {
5996     if (m_updatedTrackerEntries.isEmpty())
5997         return;
5998
5999     for (auto it = m_updatedTrackerEntries.cbegin(); it != m_updatedTrackerEntries.cend(); ++it)
6000     {
6001         invokeAsync([this, torrentHandle = it.key(), updatedTrackers = it.value()]() mutable
6002         {
6003             try
6004             {
6005                 std::vector<lt::announce_entry> nativeTrackers = torrentHandle.trackers();
6006                 invoke([this, torrentHandle, nativeTrackers = std::move(nativeTrackers)
6007                         , updatedTrackers = std::move(updatedTrackers)]
6008                 {
6009                     TorrentImpl *torrent = m_torrents.value(torrentHandle.info_hash());
6010                     if (!torrent)
6011                         return;
6012
6013                     QHash<QString, TrackerEntry> updatedTrackerEntries;
6014                     updatedTrackerEntries.reserve(updatedTrackers.size());
6015                     for (const lt::announce_entry &announceEntry : nativeTrackers)
6016                     {
6017                         const auto updatedTrackersIter = updatedTrackers.find(announceEntry.url);
6018                         if (updatedTrackersIter == updatedTrackers.end())
6019                             continue;
6020
6021                         const QMap<TrackerEntry::Endpoint, int> &updateInfo = updatedTrackersIter.value();
6022                         TrackerEntry trackerEntry = torrent->updateTrackerEntry(announceEntry, updateInfo);
6023 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
6024                         updatedTrackerEntries[trackerEntry.url] = std::move(trackerEntry);
6025 #else
6026                         updatedTrackerEntries.emplace(trackerEntry.url, std::move(trackerEntry));
6027 #endif
6028                     }
6029
6030                     emit trackerEntriesUpdated(torrent, updatedTrackerEntries);
6031                 });
6032             }
6033             catch (const std::exception &)
6034             {
6035             }
6036         });
6037     }
6038
6039     m_updatedTrackerEntries.clear();
6040 }
6041
6042 void SessionImpl::saveStatistics() const
6043 {
6044     if (!m_isStatisticsDirty)
6045         return;
6046
6047     const QVariantHash stats {
6048         {u"AlltimeDL"_qs, m_status.allTimeDownload},
6049         {u"AlltimeUL"_qs, m_status.allTimeUpload}};
6050     std::unique_ptr<QSettings> settings = Profile::instance()->applicationSettings(u"qBittorrent-data"_qs);
6051     settings->setValue(u"Stats/AllStats"_qs, stats);
6052
6053     m_statisticsLastUpdateTimer.start();
6054     m_isStatisticsDirty = false;
6055 }
6056
6057 void SessionImpl::loadStatistics()
6058 {
6059     const std::unique_ptr<QSettings> settings = Profile::instance()->applicationSettings(u"qBittorrent-data"_qs);
6060     const QVariantHash value = settings->value(u"Stats/AllStats"_qs).toHash();
6061
6062     m_previouslyDownloaded = value[u"AlltimeDL"_qs].toLongLong();
6063     m_previouslyUploaded = value[u"AlltimeUL"_qs].toLongLong();
6064 }