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_wakeupCheckTimer = new QTimer(this);
1474         connect(m_wakeupCheckTimer, &QTimer::timeout, this, [this]
1475         {
1476             const auto now = QDateTime::currentDateTime();
1477             if (m_wakeupCheckTimestamp.secsTo(now) > 100)
1478             {
1479                 LogMsg(tr("System wake-up event detected. Re-announcing to all the trackers..."));
1480                 reannounceToAllTrackers();
1481             }
1482
1483             m_wakeupCheckTimestamp = QDateTime::currentDateTime();
1484         });
1485         m_wakeupCheckTimestamp = QDateTime::currentDateTime();
1486         m_wakeupCheckTimer->start(30s);
1487
1488         m_isRestored = true;
1489         emit startupProgressUpdated(100);
1490         emit restored();
1491     });
1492 }
1493
1494 void SessionImpl::initializeNativeSession()
1495 {
1496     lt::settings_pack pack = loadLTSettings();
1497
1498     const std::string peerId = lt::generate_fingerprint(PEER_ID, QBT_VERSION_MAJOR, QBT_VERSION_MINOR, QBT_VERSION_BUGFIX, QBT_VERSION_BUILD);
1499     pack.set_str(lt::settings_pack::peer_fingerprint, peerId);
1500
1501     pack.set_bool(lt::settings_pack::listen_system_port_fallback, false);
1502     pack.set_str(lt::settings_pack::user_agent, USER_AGENT.toStdString());
1503     pack.set_bool(lt::settings_pack::use_dht_as_fallback, false);
1504     // Speed up exit
1505     pack.set_int(lt::settings_pack::auto_scrape_interval, 1200); // 20 minutes
1506     pack.set_int(lt::settings_pack::auto_scrape_min_interval, 900); // 15 minutes
1507     // libtorrent 1.1 enables UPnP & NAT-PMP by default
1508     // turn them off before `lt::session` ctor to avoid split second effects
1509     pack.set_bool(lt::settings_pack::enable_upnp, false);
1510     pack.set_bool(lt::settings_pack::enable_natpmp, false);
1511
1512 #ifdef QBT_USES_LIBTORRENT2
1513     // preserve the same behavior as in earlier libtorrent versions
1514     pack.set_bool(lt::settings_pack::enable_set_file_valid_data, true);
1515 #endif
1516
1517     lt::session_params sessionParams {std::move(pack), {}};
1518 #ifdef QBT_USES_LIBTORRENT2
1519     switch (diskIOType())
1520     {
1521     case DiskIOType::Posix:
1522         sessionParams.disk_io_constructor = customPosixDiskIOConstructor;
1523         break;
1524     case DiskIOType::MMap:
1525         sessionParams.disk_io_constructor = customMMapDiskIOConstructor;
1526         break;
1527     default:
1528         sessionParams.disk_io_constructor = customDiskIOConstructor;
1529         break;
1530     }
1531 #endif
1532
1533 #if LIBTORRENT_VERSION_NUM < 20100
1534     m_nativeSession = new lt::session(sessionParams, lt::session::paused);
1535 #else
1536     m_nativeSession = new lt::session(sessionParams);
1537     m_nativeSession->pause();
1538 #endif
1539
1540     LogMsg(tr("Peer ID: \"%1\"").arg(QString::fromStdString(peerId)), Log::INFO);
1541     LogMsg(tr("HTTP User-Agent: \"%1\"").arg(USER_AGENT), Log::INFO);
1542     LogMsg(tr("Distributed Hash Table (DHT) support: %1").arg(isDHTEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1543     LogMsg(tr("Local Peer Discovery support: %1").arg(isLSDEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1544     LogMsg(tr("Peer Exchange (PeX) support: %1").arg(isPeXEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1545     LogMsg(tr("Anonymous mode: %1").arg(isAnonymousModeEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1546     LogMsg(tr("Encryption support: %1").arg((encryption() == 0) ? tr("ON") : ((encryption() == 1) ? tr("FORCED") : tr("OFF"))), Log::INFO);
1547
1548     m_nativeSession->set_alert_notify([this]()
1549     {
1550         QMetaObject::invokeMethod(this, &SessionImpl::readAlerts, Qt::QueuedConnection);
1551     });
1552
1553     // Enabling plugins
1554     m_nativeSession->add_extension(&lt::create_smart_ban_plugin);
1555     m_nativeSession->add_extension(&lt::create_ut_metadata_plugin);
1556     if (isPeXEnabled())
1557         m_nativeSession->add_extension(&lt::create_ut_pex_plugin);
1558
1559     auto nativeSessionExtension = std::make_shared<NativeSessionExtension>();
1560     m_nativeSession->add_extension(nativeSessionExtension);
1561     m_nativeSessionExtension = nativeSessionExtension.get();
1562 }
1563
1564 void SessionImpl::processBannedIPs(lt::ip_filter &filter)
1565 {
1566     // First, import current filter
1567     for (const QString &ip : asConst(m_bannedIPs.get()))
1568     {
1569         lt::error_code ec;
1570         const lt::address addr = lt::make_address(ip.toLatin1().constData(), ec);
1571         Q_ASSERT(!ec);
1572         if (!ec)
1573             filter.add_rule(addr, addr, lt::ip_filter::blocked);
1574     }
1575 }
1576
1577 void SessionImpl::initMetrics()
1578 {
1579     const auto findMetricIndex = [](const char *name) -> int
1580     {
1581         const int index = lt::find_metric_idx(name);
1582         Q_ASSERT(index >= 0);
1583         return index;
1584     };
1585
1586     // TODO: switch to "designated initializers" in C++20
1587     m_metricIndices.net.hasIncomingConnections = findMetricIndex("net.has_incoming_connections");
1588     m_metricIndices.net.sentPayloadBytes = findMetricIndex("net.sent_payload_bytes");
1589     m_metricIndices.net.recvPayloadBytes = findMetricIndex("net.recv_payload_bytes");
1590     m_metricIndices.net.sentBytes = findMetricIndex("net.sent_bytes");
1591     m_metricIndices.net.recvBytes = findMetricIndex("net.recv_bytes");
1592     m_metricIndices.net.sentIPOverheadBytes = findMetricIndex("net.sent_ip_overhead_bytes");
1593     m_metricIndices.net.recvIPOverheadBytes = findMetricIndex("net.recv_ip_overhead_bytes");
1594     m_metricIndices.net.sentTrackerBytes = findMetricIndex("net.sent_tracker_bytes");
1595     m_metricIndices.net.recvTrackerBytes = findMetricIndex("net.recv_tracker_bytes");
1596     m_metricIndices.net.recvRedundantBytes = findMetricIndex("net.recv_redundant_bytes");
1597     m_metricIndices.net.recvFailedBytes = findMetricIndex("net.recv_failed_bytes");
1598
1599     m_metricIndices.peer.numPeersConnected = findMetricIndex("peer.num_peers_connected");
1600     m_metricIndices.peer.numPeersDownDisk = findMetricIndex("peer.num_peers_down_disk");
1601     m_metricIndices.peer.numPeersUpDisk = findMetricIndex("peer.num_peers_up_disk");
1602
1603     m_metricIndices.dht.dhtBytesIn = findMetricIndex("dht.dht_bytes_in");
1604     m_metricIndices.dht.dhtBytesOut = findMetricIndex("dht.dht_bytes_out");
1605     m_metricIndices.dht.dhtNodes = findMetricIndex("dht.dht_nodes");
1606
1607     m_metricIndices.disk.diskBlocksInUse = findMetricIndex("disk.disk_blocks_in_use");
1608     m_metricIndices.disk.numBlocksRead = findMetricIndex("disk.num_blocks_read");
1609 #ifndef QBT_USES_LIBTORRENT2
1610     m_metricIndices.disk.numBlocksCacheHits = findMetricIndex("disk.num_blocks_cache_hits");
1611 #endif
1612     m_metricIndices.disk.writeJobs = findMetricIndex("disk.num_write_ops");
1613     m_metricIndices.disk.readJobs = findMetricIndex("disk.num_read_ops");
1614     m_metricIndices.disk.hashJobs = findMetricIndex("disk.num_blocks_hashed");
1615     m_metricIndices.disk.queuedDiskJobs = findMetricIndex("disk.queued_disk_jobs");
1616     m_metricIndices.disk.diskJobTime = findMetricIndex("disk.disk_job_time");
1617 }
1618
1619 lt::settings_pack SessionImpl::loadLTSettings() const
1620 {
1621     lt::settings_pack settingsPack;
1622
1623     const lt::alert_category_t alertMask = lt::alert::error_notification
1624         | lt::alert::file_progress_notification
1625         | lt::alert::ip_block_notification
1626         | lt::alert::peer_notification
1627         | (isPerformanceWarningEnabled() ? lt::alert::performance_warning : lt::alert_category_t())
1628         | lt::alert::port_mapping_notification
1629         | lt::alert::status_notification
1630         | lt::alert::storage_notification
1631         | lt::alert::tracker_notification;
1632     settingsPack.set_int(lt::settings_pack::alert_mask, alertMask);
1633
1634     settingsPack.set_int(lt::settings_pack::connection_speed, connectionSpeed());
1635
1636     // from libtorrent doc:
1637     // It will not take affect until the listen_interfaces settings is updated
1638     settingsPack.set_int(lt::settings_pack::send_socket_buffer_size, socketSendBufferSize());
1639     settingsPack.set_int(lt::settings_pack::recv_socket_buffer_size, socketReceiveBufferSize());
1640     settingsPack.set_int(lt::settings_pack::listen_queue_size, socketBacklogSize());
1641
1642     applyNetworkInterfacesSettings(settingsPack);
1643
1644     settingsPack.set_int(lt::settings_pack::download_rate_limit, downloadSpeedLimit());
1645     settingsPack.set_int(lt::settings_pack::upload_rate_limit, uploadSpeedLimit());
1646
1647     // The most secure, rc4 only so that all streams are encrypted
1648     settingsPack.set_int(lt::settings_pack::allowed_enc_level, lt::settings_pack::pe_rc4);
1649     settingsPack.set_bool(lt::settings_pack::prefer_rc4, true);
1650     switch (encryption())
1651     {
1652     case 0: // Enabled
1653         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_enabled);
1654         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_enabled);
1655         break;
1656     case 1: // Forced
1657         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_forced);
1658         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_forced);
1659         break;
1660     default: // Disabled
1661         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_disabled);
1662         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_disabled);
1663     }
1664
1665     settingsPack.set_int(lt::settings_pack::active_checking, maxActiveCheckingTorrents());
1666
1667     // I2P
1668     if (isI2PEnabled())
1669     {
1670         settingsPack.set_str(lt::settings_pack::i2p_hostname, I2PAddress().toStdString());
1671         settingsPack.set_int(lt::settings_pack::i2p_port, I2PPort());
1672         settingsPack.set_bool(lt::settings_pack::allow_i2p_mixed, I2PMixedMode());
1673     }
1674     else
1675     {
1676         settingsPack.set_str(lt::settings_pack::i2p_hostname, "");
1677         settingsPack.set_int(lt::settings_pack::i2p_port, 0);
1678         settingsPack.set_bool(lt::settings_pack::allow_i2p_mixed, false);
1679     }
1680
1681     // proxy
1682     settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::none);
1683     if (Preferences::instance()->useProxyForBT())
1684     {
1685         const auto *proxyManager = Net::ProxyConfigurationManager::instance();
1686         const Net::ProxyConfiguration proxyConfig = proxyManager->proxyConfiguration();
1687
1688         switch (proxyConfig.type)
1689         {
1690         case Net::ProxyType::SOCKS4:
1691             settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks4);
1692             break;
1693
1694         case Net::ProxyType::HTTP:
1695             if (proxyConfig.authEnabled)
1696                 settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::http_pw);
1697             else
1698                 settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::http);
1699             break;
1700
1701         case Net::ProxyType::SOCKS5:
1702             if (proxyConfig.authEnabled)
1703                 settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks5_pw);
1704             else
1705                 settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks5);
1706             break;
1707
1708         default:
1709             break;
1710         }
1711
1712         settingsPack.set_str(lt::settings_pack::proxy_hostname, proxyConfig.ip.toStdString());
1713         settingsPack.set_int(lt::settings_pack::proxy_port, proxyConfig.port);
1714
1715         if (proxyConfig.authEnabled)
1716         {
1717             settingsPack.set_str(lt::settings_pack::proxy_username, proxyConfig.username.toStdString());
1718             settingsPack.set_str(lt::settings_pack::proxy_password, proxyConfig.password.toStdString());
1719         }
1720
1721         settingsPack.set_bool(lt::settings_pack::proxy_peer_connections, isProxyPeerConnectionsEnabled());
1722         settingsPack.set_bool(lt::settings_pack::proxy_hostnames, proxyConfig.hostnameLookupEnabled);
1723     }
1724
1725     settingsPack.set_bool(lt::settings_pack::announce_to_all_trackers, announceToAllTrackers());
1726     settingsPack.set_bool(lt::settings_pack::announce_to_all_tiers, announceToAllTiers());
1727
1728     settingsPack.set_int(lt::settings_pack::peer_turnover, peerTurnover());
1729     settingsPack.set_int(lt::settings_pack::peer_turnover_cutoff, peerTurnoverCutoff());
1730     settingsPack.set_int(lt::settings_pack::peer_turnover_interval, peerTurnoverInterval());
1731
1732     settingsPack.set_int(lt::settings_pack::max_out_request_queue, requestQueueSize());
1733
1734     settingsPack.set_int(lt::settings_pack::aio_threads, asyncIOThreads());
1735 #ifdef QBT_USES_LIBTORRENT2
1736     settingsPack.set_int(lt::settings_pack::hashing_threads, hashingThreads());
1737 #endif
1738     settingsPack.set_int(lt::settings_pack::file_pool_size, filePoolSize());
1739
1740     const int checkingMemUsageSize = checkingMemUsage() * 64;
1741     settingsPack.set_int(lt::settings_pack::checking_mem_usage, checkingMemUsageSize);
1742
1743 #ifndef QBT_USES_LIBTORRENT2
1744     const int cacheSize = (diskCacheSize() > -1) ? (diskCacheSize() * 64) : -1;
1745     settingsPack.set_int(lt::settings_pack::cache_size, cacheSize);
1746     settingsPack.set_int(lt::settings_pack::cache_expiry, diskCacheTTL());
1747 #endif
1748
1749     settingsPack.set_int(lt::settings_pack::max_queued_disk_bytes, diskQueueSize());
1750
1751     switch (diskIOReadMode())
1752     {
1753     case DiskIOReadMode::DisableOSCache:
1754         settingsPack.set_int(lt::settings_pack::disk_io_read_mode, lt::settings_pack::disable_os_cache);
1755         break;
1756     case DiskIOReadMode::EnableOSCache:
1757     default:
1758         settingsPack.set_int(lt::settings_pack::disk_io_read_mode, lt::settings_pack::enable_os_cache);
1759         break;
1760     }
1761
1762     switch (diskIOWriteMode())
1763     {
1764     case DiskIOWriteMode::DisableOSCache:
1765         settingsPack.set_int(lt::settings_pack::disk_io_write_mode, lt::settings_pack::disable_os_cache);
1766         break;
1767     case DiskIOWriteMode::EnableOSCache:
1768     default:
1769         settingsPack.set_int(lt::settings_pack::disk_io_write_mode, lt::settings_pack::enable_os_cache);
1770         break;
1771 #ifdef QBT_USES_LIBTORRENT2
1772     case DiskIOWriteMode::WriteThrough:
1773         settingsPack.set_int(lt::settings_pack::disk_io_write_mode, lt::settings_pack::write_through);
1774         break;
1775 #endif
1776     }
1777
1778 #ifndef QBT_USES_LIBTORRENT2
1779     settingsPack.set_bool(lt::settings_pack::coalesce_reads, isCoalesceReadWriteEnabled());
1780     settingsPack.set_bool(lt::settings_pack::coalesce_writes, isCoalesceReadWriteEnabled());
1781 #endif
1782
1783     settingsPack.set_bool(lt::settings_pack::piece_extent_affinity, usePieceExtentAffinity());
1784
1785     settingsPack.set_int(lt::settings_pack::suggest_mode, isSuggestModeEnabled()
1786                          ? lt::settings_pack::suggest_read_cache : lt::settings_pack::no_piece_suggestions);
1787
1788     settingsPack.set_int(lt::settings_pack::send_buffer_watermark, sendBufferWatermark() * 1024);
1789     settingsPack.set_int(lt::settings_pack::send_buffer_low_watermark, sendBufferLowWatermark() * 1024);
1790     settingsPack.set_int(lt::settings_pack::send_buffer_watermark_factor, sendBufferWatermarkFactor());
1791
1792     settingsPack.set_bool(lt::settings_pack::anonymous_mode, isAnonymousModeEnabled());
1793
1794     // Queueing System
1795     if (isQueueingSystemEnabled())
1796     {
1797         settingsPack.set_int(lt::settings_pack::active_downloads, maxActiveDownloads());
1798         settingsPack.set_int(lt::settings_pack::active_limit, maxActiveTorrents());
1799         settingsPack.set_int(lt::settings_pack::active_seeds, maxActiveUploads());
1800         settingsPack.set_bool(lt::settings_pack::dont_count_slow_torrents, ignoreSlowTorrentsForQueueing());
1801         settingsPack.set_int(lt::settings_pack::inactive_down_rate, downloadRateForSlowTorrents() * 1024); // KiB to Bytes
1802         settingsPack.set_int(lt::settings_pack::inactive_up_rate, uploadRateForSlowTorrents() * 1024); // KiB to Bytes
1803         settingsPack.set_int(lt::settings_pack::auto_manage_startup, slowTorrentsInactivityTimer());
1804     }
1805     else
1806     {
1807         settingsPack.set_int(lt::settings_pack::active_downloads, -1);
1808         settingsPack.set_int(lt::settings_pack::active_seeds, -1);
1809         settingsPack.set_int(lt::settings_pack::active_limit, -1);
1810     }
1811     settingsPack.set_int(lt::settings_pack::active_tracker_limit, -1);
1812     settingsPack.set_int(lt::settings_pack::active_dht_limit, -1);
1813     settingsPack.set_int(lt::settings_pack::active_lsd_limit, -1);
1814     settingsPack.set_int(lt::settings_pack::alert_queue_size, std::numeric_limits<int>::max() / 2);
1815
1816     // Outgoing ports
1817     settingsPack.set_int(lt::settings_pack::outgoing_port, outgoingPortsMin());
1818     settingsPack.set_int(lt::settings_pack::num_outgoing_ports, (outgoingPortsMax() - outgoingPortsMin()));
1819     // UPnP lease duration
1820     settingsPack.set_int(lt::settings_pack::upnp_lease_duration, UPnPLeaseDuration());
1821     // Type of service
1822     settingsPack.set_int(lt::settings_pack::peer_tos, peerToS());
1823     // Include overhead in transfer limits
1824     settingsPack.set_bool(lt::settings_pack::rate_limit_ip_overhead, includeOverheadInLimits());
1825     // IP address to announce to trackers
1826     settingsPack.set_str(lt::settings_pack::announce_ip, announceIP().toStdString());
1827     // Max concurrent HTTP announces
1828     settingsPack.set_int(lt::settings_pack::max_concurrent_http_announces, maxConcurrentHTTPAnnounces());
1829     // Stop tracker timeout
1830     settingsPack.set_int(lt::settings_pack::stop_tracker_timeout, stopTrackerTimeout());
1831     // * Max connections limit
1832     settingsPack.set_int(lt::settings_pack::connections_limit, maxConnections());
1833     // * Global max upload slots
1834     settingsPack.set_int(lt::settings_pack::unchoke_slots_limit, maxUploads());
1835     // uTP
1836     switch (btProtocol())
1837     {
1838     case BTProtocol::Both:
1839     default:
1840         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, true);
1841         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, true);
1842         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, true);
1843         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, true);
1844         break;
1845
1846     case BTProtocol::TCP:
1847         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, true);
1848         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, true);
1849         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, false);
1850         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, false);
1851         break;
1852
1853     case BTProtocol::UTP:
1854         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, false);
1855         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, false);
1856         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, true);
1857         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, true);
1858         break;
1859     }
1860
1861     switch (utpMixedMode())
1862     {
1863     case MixedModeAlgorithm::TCP:
1864     default:
1865         settingsPack.set_int(lt::settings_pack::mixed_mode_algorithm, lt::settings_pack::prefer_tcp);
1866         break;
1867     case MixedModeAlgorithm::Proportional:
1868         settingsPack.set_int(lt::settings_pack::mixed_mode_algorithm, lt::settings_pack::peer_proportional);
1869         break;
1870     }
1871
1872     settingsPack.set_bool(lt::settings_pack::allow_idna, isIDNSupportEnabled());
1873
1874     settingsPack.set_bool(lt::settings_pack::allow_multiple_connections_per_ip, multiConnectionsPerIpEnabled());
1875
1876     settingsPack.set_bool(lt::settings_pack::validate_https_trackers, validateHTTPSTrackerCertificate());
1877
1878     settingsPack.set_bool(lt::settings_pack::ssrf_mitigation, isSSRFMitigationEnabled());
1879
1880     settingsPack.set_bool(lt::settings_pack::no_connect_privileged_ports, blockPeersOnPrivilegedPorts());
1881
1882     settingsPack.set_bool(lt::settings_pack::apply_ip_filter_to_trackers, isTrackerFilteringEnabled());
1883
1884     settingsPack.set_bool(lt::settings_pack::enable_dht, isDHTEnabled());
1885     if (isDHTEnabled())
1886         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");
1887     settingsPack.set_bool(lt::settings_pack::enable_lsd, isLSDEnabled());
1888
1889     switch (chokingAlgorithm())
1890     {
1891     case ChokingAlgorithm::FixedSlots:
1892     default:
1893         settingsPack.set_int(lt::settings_pack::choking_algorithm, lt::settings_pack::fixed_slots_choker);
1894         break;
1895     case ChokingAlgorithm::RateBased:
1896         settingsPack.set_int(lt::settings_pack::choking_algorithm, lt::settings_pack::rate_based_choker);
1897         break;
1898     }
1899
1900     switch (seedChokingAlgorithm())
1901     {
1902     case SeedChokingAlgorithm::RoundRobin:
1903         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::round_robin);
1904         break;
1905     case SeedChokingAlgorithm::FastestUpload:
1906     default:
1907         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::fastest_upload);
1908         break;
1909     case SeedChokingAlgorithm::AntiLeech:
1910         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::anti_leech);
1911         break;
1912     }
1913
1914     return settingsPack;
1915 }
1916
1917 void SessionImpl::applyNetworkInterfacesSettings(lt::settings_pack &settingsPack) const
1918 {
1919     if (m_listenInterfaceConfigured)
1920         return;
1921
1922     if (port() > 0)  // user has specified port number
1923         settingsPack.set_int(lt::settings_pack::max_retry_port_bind, 0);
1924
1925     QStringList endpoints;
1926     QStringList outgoingInterfaces;
1927     const QString portString = u':' + QString::number(port());
1928
1929     for (const QString &ip : asConst(getListeningIPs()))
1930     {
1931         const QHostAddress addr {ip};
1932         if (!addr.isNull())
1933         {
1934             const bool isIPv6 = (addr.protocol() == QAbstractSocket::IPv6Protocol);
1935             const QString ip = isIPv6
1936                           ? Utils::Net::canonicalIPv6Addr(addr).toString()
1937                           : addr.toString();
1938
1939             endpoints << ((isIPv6 ? (u'[' + ip + u']') : ip) + portString);
1940
1941             if ((ip != u"0.0.0.0") && (ip != u"::"))
1942                 outgoingInterfaces << ip;
1943         }
1944         else
1945         {
1946             // ip holds an interface name
1947 #ifdef Q_OS_WIN
1948             // On Vista+ versions and after Qt 5.5 QNetworkInterface::name() returns
1949             // the interface's LUID and not the GUID.
1950             // Libtorrent expects GUIDs for the 'listen_interfaces' setting.
1951             const QString guid = convertIfaceNameToGuid(ip);
1952             if (!guid.isEmpty())
1953             {
1954                 endpoints << (guid + portString);
1955                 outgoingInterfaces << guid;
1956             }
1957             else
1958             {
1959                 LogMsg(tr("Could not find GUID of network interface. Interface: \"%1\"").arg(ip), Log::WARNING);
1960                 // Since we can't get the GUID, we'll pass the interface name instead.
1961                 // Otherwise an empty string will be passed to outgoing_interface which will cause IP leak.
1962                 endpoints << (ip + portString);
1963                 outgoingInterfaces << ip;
1964             }
1965 #else
1966             endpoints << (ip + portString);
1967             outgoingInterfaces << ip;
1968 #endif
1969         }
1970     }
1971
1972     const QString finalEndpoints = endpoints.join(u',');
1973     settingsPack.set_str(lt::settings_pack::listen_interfaces, finalEndpoints.toStdString());
1974     LogMsg(tr("Trying to listen on the following list of IP addresses: \"%1\"").arg(finalEndpoints));
1975
1976     settingsPack.set_str(lt::settings_pack::outgoing_interfaces, outgoingInterfaces.join(u',').toStdString());
1977     m_listenInterfaceConfigured = true;
1978 }
1979
1980 void SessionImpl::configurePeerClasses()
1981 {
1982     lt::ip_filter f;
1983     // lt::make_address("255.255.255.255") crashes on some people's systems
1984     // so instead we use address_v4::broadcast()
1985     // Proactively do the same for 0.0.0.0 and address_v4::any()
1986     f.add_rule(lt::address_v4::any()
1987                , lt::address_v4::broadcast()
1988                , 1 << LT::toUnderlyingType(lt::session::global_peer_class_id));
1989
1990     // IPv6 may not be available on OS and the parsing
1991     // would result in an exception -> abnormal program termination
1992     // Affects Windows XP
1993     try
1994     {
1995         f.add_rule(lt::address_v6::any()
1996                    , lt::make_address("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
1997                    , 1 << LT::toUnderlyingType(lt::session::global_peer_class_id));
1998     }
1999     catch (const std::exception &) {}
2000
2001     if (ignoreLimitsOnLAN())
2002     {
2003         // local networks
2004         f.add_rule(lt::make_address("10.0.0.0")
2005                    , lt::make_address("10.255.255.255")
2006                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2007         f.add_rule(lt::make_address("172.16.0.0")
2008                    , lt::make_address("172.31.255.255")
2009                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2010         f.add_rule(lt::make_address("192.168.0.0")
2011                    , lt::make_address("192.168.255.255")
2012                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2013         // link local
2014         f.add_rule(lt::make_address("169.254.0.0")
2015                    , lt::make_address("169.254.255.255")
2016                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2017         // loopback
2018         f.add_rule(lt::make_address("127.0.0.0")
2019                    , lt::make_address("127.255.255.255")
2020                    , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2021
2022         // IPv6 may not be available on OS and the parsing
2023         // would result in an exception -> abnormal program termination
2024         // Affects Windows XP
2025         try
2026         {
2027             // link local
2028             f.add_rule(lt::make_address("fe80::")
2029                        , lt::make_address("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
2030                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2031             // unique local addresses
2032             f.add_rule(lt::make_address("fc00::")
2033                        , lt::make_address("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
2034                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2035             // loopback
2036             f.add_rule(lt::address_v6::loopback()
2037                        , lt::address_v6::loopback()
2038                        , 1 << LT::toUnderlyingType(lt::session::local_peer_class_id));
2039         }
2040         catch (const std::exception &) {}
2041     }
2042     m_nativeSession->set_peer_class_filter(f);
2043
2044     lt::peer_class_type_filter peerClassTypeFilter;
2045     peerClassTypeFilter.add(lt::peer_class_type_filter::tcp_socket, lt::session::tcp_peer_class_id);
2046     peerClassTypeFilter.add(lt::peer_class_type_filter::ssl_tcp_socket, lt::session::tcp_peer_class_id);
2047     peerClassTypeFilter.add(lt::peer_class_type_filter::i2p_socket, lt::session::tcp_peer_class_id);
2048     if (!isUTPRateLimited())
2049     {
2050         peerClassTypeFilter.disallow(lt::peer_class_type_filter::utp_socket
2051             , lt::session::global_peer_class_id);
2052         peerClassTypeFilter.disallow(lt::peer_class_type_filter::ssl_utp_socket
2053             , lt::session::global_peer_class_id);
2054     }
2055     m_nativeSession->set_peer_class_type_filter(peerClassTypeFilter);
2056 }
2057
2058 void SessionImpl::enableTracker(const bool enable)
2059 {
2060     const QString profile = u"embeddedTracker"_qs;
2061     auto *portForwarder = Net::PortForwarder::instance();
2062
2063     if (enable)
2064     {
2065         if (!m_tracker)
2066             m_tracker = new Tracker(this);
2067
2068         m_tracker->start();
2069
2070         const auto *pref = Preferences::instance();
2071         if (pref->isTrackerPortForwardingEnabled())
2072             portForwarder->setPorts(profile, {static_cast<quint16>(pref->getTrackerPort())});
2073         else
2074             portForwarder->removePorts(profile);
2075     }
2076     else
2077     {
2078         delete m_tracker;
2079
2080         portForwarder->removePorts(profile);
2081     }
2082 }
2083
2084 void SessionImpl::enableBandwidthScheduler()
2085 {
2086     if (!m_bwScheduler)
2087     {
2088         m_bwScheduler = new BandwidthScheduler(this);
2089         connect(m_bwScheduler.data(), &BandwidthScheduler::bandwidthLimitRequested
2090                 , this, &SessionImpl::setAltGlobalSpeedLimitEnabled);
2091     }
2092     m_bwScheduler->start();
2093 }
2094
2095 void SessionImpl::populateAdditionalTrackers()
2096 {
2097     m_additionalTrackerList.clear();
2098
2099     const QString trackers = additionalTrackers();
2100     for (QStringView tracker : asConst(QStringView(trackers).split(u'\n')))
2101     {
2102         tracker = tracker.trimmed();
2103         if (!tracker.isEmpty())
2104             m_additionalTrackerList.append({tracker.toString()});
2105     }
2106 }
2107
2108 void SessionImpl::processShareLimits()
2109 {
2110     qDebug("Processing share limits...");
2111
2112     // We shouldn't iterate over `m_torrents` in the loop below
2113     // since `deleteTorrent()` modifies it indirectly
2114     const QHash<TorrentID, TorrentImpl *> torrents {m_torrents};
2115     for (TorrentImpl *const torrent : torrents)
2116     {
2117         if (torrent->isFinished() && !torrent->isForced())
2118         {
2119             if (torrent->ratioLimit() != Torrent::NO_RATIO_LIMIT)
2120             {
2121                 const qreal ratio = torrent->realRatio();
2122                 qreal ratioLimit = torrent->ratioLimit();
2123                 if (ratioLimit == Torrent::USE_GLOBAL_RATIO)
2124                     // If Global Max Ratio is really set...
2125                     ratioLimit = globalMaxRatio();
2126
2127                 if (ratioLimit >= 0)
2128                 {
2129                     qDebug("Ratio: %f (limit: %f)", ratio, ratioLimit);
2130
2131                     if ((ratio <= Torrent::MAX_RATIO) && (ratio >= ratioLimit))
2132                     {
2133                         const QString description = tr("Torrent reached the share ratio limit.");
2134                         const QString torrentName = tr("Torrent: \"%1\".").arg(torrent->name());
2135
2136                         if (m_maxRatioAction == Remove)
2137                         {
2138                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Removed torrent."), torrentName));
2139                             deleteTorrent(torrent->id());
2140                         }
2141                         else if (m_maxRatioAction == DeleteFiles)
2142                         {
2143                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Removed torrent and deleted its content."), torrentName));
2144                             deleteTorrent(torrent->id(), DeleteTorrentAndFiles);
2145                         }
2146                         else if ((m_maxRatioAction == Pause) && !torrent->isPaused())
2147                         {
2148                             torrent->pause();
2149                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Torrent paused."), torrentName));
2150                         }
2151                         else if ((m_maxRatioAction == EnableSuperSeeding) && !torrent->isPaused() && !torrent->superSeeding())
2152                         {
2153                             torrent->setSuperSeeding(true);
2154                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Super seeding enabled."), torrentName));
2155                         }
2156
2157                         continue;
2158                     }
2159                 }
2160             }
2161
2162             if (torrent->seedingTimeLimit() != Torrent::NO_SEEDING_TIME_LIMIT)
2163             {
2164                 const qlonglong seedingTimeInMinutes = torrent->finishedTime() / 60;
2165                 int seedingTimeLimit = torrent->seedingTimeLimit();
2166                 if (seedingTimeLimit == Torrent::USE_GLOBAL_SEEDING_TIME)
2167                 {
2168                      // If Global Seeding Time Limit is really set...
2169                     seedingTimeLimit = globalMaxSeedingMinutes();
2170                 }
2171
2172                 if (seedingTimeLimit >= 0)
2173                 {
2174                     if ((seedingTimeInMinutes <= Torrent::MAX_SEEDING_TIME) && (seedingTimeInMinutes >= seedingTimeLimit))
2175                     {
2176                         const QString description = tr("Torrent reached the seeding time limit.");
2177                         const QString torrentName = tr("Torrent: \"%1\".").arg(torrent->name());
2178
2179                         if (m_maxRatioAction == Remove)
2180                         {
2181                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Removed torrent."), torrentName));
2182                             deleteTorrent(torrent->id());
2183                         }
2184                         else if (m_maxRatioAction == DeleteFiles)
2185                         {
2186                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Removed torrent and deleted its content."), torrentName));
2187                             deleteTorrent(torrent->id(), DeleteTorrentAndFiles);
2188                         }
2189                         else if ((m_maxRatioAction == Pause) && !torrent->isPaused())
2190                         {
2191                             torrent->pause();
2192                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Torrent paused."), torrentName));
2193                         }
2194                         else if ((m_maxRatioAction == EnableSuperSeeding) && !torrent->isPaused() && !torrent->superSeeding())
2195                         {
2196                             torrent->setSuperSeeding(true);
2197                             LogMsg(u"%1 %2 %3"_qs.arg(description, tr("Super seeding enabled."), torrentName));
2198                         }
2199                     }
2200                 }
2201             }
2202         }
2203     }
2204 }
2205
2206 // Add to BitTorrent session the downloaded torrent file
2207 void SessionImpl::handleDownloadFinished(const Net::DownloadResult &result)
2208 {
2209     switch (result.status)
2210     {
2211     case Net::DownloadStatus::Success:
2212         emit downloadFromUrlFinished(result.url);
2213         if (const nonstd::expected<TorrentInfo, QString> loadResult = TorrentInfo::load(result.data); loadResult)
2214             addTorrent(loadResult.value(), m_downloadedTorrents.take(result.url));
2215         else
2216             LogMsg(tr("Failed to load torrent. Reason: \"%1\"").arg(loadResult.error()), Log::WARNING);
2217         break;
2218     case Net::DownloadStatus::RedirectedToMagnet:
2219         emit downloadFromUrlFinished(result.url);
2220         addTorrent(MagnetUri(result.magnet), m_downloadedTorrents.take(result.url));
2221         break;
2222     default:
2223         emit downloadFromUrlFailed(result.url, result.errorString);
2224     }
2225 }
2226
2227 void SessionImpl::fileSearchFinished(const TorrentID &id, const Path &savePath, const PathList &fileNames)
2228 {
2229     TorrentImpl *torrent = m_torrents.value(id);
2230     if (torrent)
2231     {
2232         torrent->fileSearchFinished(savePath, fileNames);
2233         return;
2234     }
2235
2236     const auto loadingTorrentsIter = m_loadingTorrents.find(id);
2237     if (loadingTorrentsIter != m_loadingTorrents.end())
2238     {
2239         LoadTorrentParams &params = loadingTorrentsIter.value();
2240         lt::add_torrent_params &p = params.ltAddTorrentParams;
2241
2242         p.save_path = savePath.toString().toStdString();
2243         const TorrentInfo torrentInfo {*p.ti};
2244         const auto nativeIndexes = torrentInfo.nativeIndexes();
2245         for (int i = 0; i < fileNames.size(); ++i)
2246             p.renamed_files[nativeIndexes[i]] = fileNames[i].toString().toStdString();
2247
2248         m_nativeSession->async_add_torrent(p);
2249     }
2250 }
2251
2252 Torrent *SessionImpl::getTorrent(const TorrentID &id) const
2253 {
2254     return m_torrents.value(id);
2255 }
2256
2257 Torrent *SessionImpl::findTorrent(const InfoHash &infoHash) const
2258 {
2259     const auto id = TorrentID::fromInfoHash(infoHash);
2260     if (Torrent *torrent = m_torrents.value(id); torrent)
2261         return torrent;
2262
2263     if (!infoHash.isHybrid())
2264         return m_hybridTorrentsByAltID.value(id);
2265
2266     // alternative ID can be useful to find existing torrent
2267     // in case if hybrid torrent was added by v1 info hash
2268     const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
2269     return m_torrents.value(altID);
2270 }
2271
2272 void SessionImpl::banIP(const QString &ip)
2273 {
2274     if (m_bannedIPs.get().contains(ip))
2275         return;
2276
2277     lt::error_code ec;
2278     const lt::address addr = lt::make_address(ip.toLatin1().constData(), ec);
2279     Q_ASSERT(!ec);
2280     if (ec)
2281         return;
2282
2283     invokeAsync([session = m_nativeSession, addr]
2284     {
2285         lt::ip_filter filter = session->get_ip_filter();
2286         filter.add_rule(addr, addr, lt::ip_filter::blocked);
2287         session->set_ip_filter(std::move(filter));
2288     });
2289
2290     QStringList bannedIPs = m_bannedIPs;
2291     bannedIPs.append(ip);
2292     bannedIPs.sort();
2293     m_bannedIPs = bannedIPs;
2294 }
2295
2296 // Delete a torrent from the session, given its hash
2297 // and from the disk, if the corresponding deleteOption is chosen
2298 bool SessionImpl::deleteTorrent(const TorrentID &id, const DeleteOption deleteOption)
2299 {
2300     TorrentImpl *const torrent = m_torrents.take(id);
2301     if (!torrent) return false;
2302
2303     qDebug("Deleting torrent with ID: %s", qUtf8Printable(torrent->id().toString()));
2304     emit torrentAboutToBeRemoved(torrent);
2305
2306     if (const InfoHash infoHash = torrent->infoHash(); infoHash.isHybrid())
2307         m_hybridTorrentsByAltID.remove(TorrentID::fromSHA1Hash(infoHash.v1()));
2308
2309     // Remove it from session
2310     if (deleteOption == DeleteTorrent)
2311     {
2312         m_removingTorrents[torrent->id()] = {torrent->name(), {}, deleteOption};
2313
2314         const lt::torrent_handle nativeHandle {torrent->nativeHandle()};
2315         const auto iter = std::find_if(m_moveStorageQueue.begin(), m_moveStorageQueue.end()
2316                                  , [&nativeHandle](const MoveStorageJob &job)
2317         {
2318             return job.torrentHandle == nativeHandle;
2319         });
2320         if (iter != m_moveStorageQueue.end())
2321         {
2322             // We shouldn't actually remove torrent until existing "move storage jobs" are done
2323             torrentQueuePositionBottom(nativeHandle);
2324             nativeHandle.unset_flags(lt::torrent_flags::auto_managed);
2325             nativeHandle.pause();
2326         }
2327         else
2328         {
2329             m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_partfile);
2330         }
2331     }
2332     else
2333     {
2334         m_removingTorrents[torrent->id()] = {torrent->name(), torrent->rootPath(), deleteOption};
2335
2336         if (m_moveStorageQueue.size() > 1)
2337         {
2338             // Delete "move storage job" for the deleted torrent
2339             // (note: we shouldn't delete active job)
2340             const auto iter = std::find_if((m_moveStorageQueue.begin() + 1), m_moveStorageQueue.end()
2341                                      , [torrent](const MoveStorageJob &job)
2342             {
2343                 return job.torrentHandle == torrent->nativeHandle();
2344             });
2345             if (iter != m_moveStorageQueue.end())
2346                 m_moveStorageQueue.erase(iter);
2347         }
2348
2349         m_nativeSession->remove_torrent(torrent->nativeHandle(), lt::session::delete_files);
2350     }
2351
2352     // Remove it from torrent resume directory
2353     m_resumeDataStorage->remove(torrent->id());
2354
2355     delete torrent;
2356     return true;
2357 }
2358
2359 bool SessionImpl::cancelDownloadMetadata(const TorrentID &id)
2360 {
2361     const auto downloadedMetadataIter = m_downloadedMetadata.find(id);
2362     if (downloadedMetadataIter == m_downloadedMetadata.end())
2363         return false;
2364
2365     const lt::torrent_handle nativeHandle = downloadedMetadataIter.value();
2366 #ifdef QBT_USES_LIBTORRENT2
2367     const InfoHash infoHash {nativeHandle.info_hashes()};
2368     if (infoHash.isHybrid())
2369     {
2370         // if magnet link was hybrid initially then it is indexed also by v1 info hash
2371         // so we need to remove both entries
2372         const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
2373         m_downloadedMetadata.remove((altID == downloadedMetadataIter.key()) ? id : altID);
2374     }
2375 #endif
2376     m_downloadedMetadata.erase(downloadedMetadataIter);
2377     m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_files);
2378     return true;
2379 }
2380
2381 void SessionImpl::increaseTorrentsQueuePos(const QVector<TorrentID> &ids)
2382 {
2383     using ElementType = std::pair<int, const TorrentImpl *>;
2384     std::priority_queue<ElementType
2385         , std::vector<ElementType>
2386         , std::greater<ElementType>> torrentQueue;
2387
2388     // Sort torrents by queue position
2389     for (const TorrentID &id : ids)
2390     {
2391         const TorrentImpl *torrent = m_torrents.value(id);
2392         if (!torrent) continue;
2393         if (const int position = torrent->queuePosition(); position >= 0)
2394             torrentQueue.emplace(position, torrent);
2395     }
2396
2397     // Increase torrents queue position (starting with the one in the highest queue position)
2398     while (!torrentQueue.empty())
2399     {
2400         const TorrentImpl *torrent = torrentQueue.top().second;
2401         torrentQueuePositionUp(torrent->nativeHandle());
2402         torrentQueue.pop();
2403     }
2404
2405     m_torrentsQueueChanged = true;
2406 }
2407
2408 void SessionImpl::decreaseTorrentsQueuePos(const QVector<TorrentID> &ids)
2409 {
2410     using ElementType = std::pair<int, const TorrentImpl *>;
2411     std::priority_queue<ElementType> torrentQueue;
2412
2413     // Sort torrents by queue position
2414     for (const TorrentID &id : ids)
2415     {
2416         const TorrentImpl *torrent = m_torrents.value(id);
2417         if (!torrent) continue;
2418         if (const int position = torrent->queuePosition(); position >= 0)
2419             torrentQueue.emplace(position, torrent);
2420     }
2421
2422     // Decrease torrents queue position (starting with the one in the lowest queue position)
2423     while (!torrentQueue.empty())
2424     {
2425         const TorrentImpl *torrent = torrentQueue.top().second;
2426         torrentQueuePositionDown(torrent->nativeHandle());
2427         torrentQueue.pop();
2428     }
2429
2430     for (const lt::torrent_handle &torrentHandle : asConst(m_downloadedMetadata))
2431         torrentQueuePositionBottom(torrentHandle);
2432
2433     m_torrentsQueueChanged = true;
2434 }
2435
2436 void SessionImpl::topTorrentsQueuePos(const QVector<TorrentID> &ids)
2437 {
2438     using ElementType = std::pair<int, const TorrentImpl *>;
2439     std::priority_queue<ElementType> torrentQueue;
2440
2441     // Sort torrents by queue position
2442     for (const TorrentID &id : ids)
2443     {
2444         const TorrentImpl *torrent = m_torrents.value(id);
2445         if (!torrent) continue;
2446         if (const int position = torrent->queuePosition(); position >= 0)
2447             torrentQueue.emplace(position, torrent);
2448     }
2449
2450     // Top torrents queue position (starting with the one in the lowest queue position)
2451     while (!torrentQueue.empty())
2452     {
2453         const TorrentImpl *torrent = torrentQueue.top().second;
2454         torrentQueuePositionTop(torrent->nativeHandle());
2455         torrentQueue.pop();
2456     }
2457
2458     m_torrentsQueueChanged = true;
2459 }
2460
2461 void SessionImpl::bottomTorrentsQueuePos(const QVector<TorrentID> &ids)
2462 {
2463     using ElementType = std::pair<int, const TorrentImpl *>;
2464     std::priority_queue<ElementType
2465         , std::vector<ElementType>
2466         , std::greater<ElementType>> torrentQueue;
2467
2468     // Sort torrents by queue position
2469     for (const TorrentID &id : ids)
2470     {
2471         const TorrentImpl *torrent = m_torrents.value(id);
2472         if (!torrent) continue;
2473         if (const int position = torrent->queuePosition(); position >= 0)
2474             torrentQueue.emplace(position, torrent);
2475     }
2476
2477     // Bottom torrents queue position (starting with the one in the highest queue position)
2478     while (!torrentQueue.empty())
2479     {
2480         const TorrentImpl *torrent = torrentQueue.top().second;
2481         torrentQueuePositionBottom(torrent->nativeHandle());
2482         torrentQueue.pop();
2483     }
2484
2485     for (const lt::torrent_handle &torrentHandle : asConst(m_downloadedMetadata))
2486         torrentQueuePositionBottom(torrentHandle);
2487
2488     m_torrentsQueueChanged = true;
2489 }
2490
2491 void SessionImpl::handleTorrentNeedSaveResumeData(const TorrentImpl *torrent)
2492 {
2493     if (m_needSaveResumeDataTorrents.empty())
2494     {
2495         QMetaObject::invokeMethod(this, [this]()
2496         {
2497             for (const TorrentID &torrentID : asConst(m_needSaveResumeDataTorrents))
2498             {
2499                 TorrentImpl *torrent = m_torrents.value(torrentID);
2500                 if (torrent)
2501                     torrent->saveResumeData();
2502             }
2503             m_needSaveResumeDataTorrents.clear();
2504         }, Qt::QueuedConnection);
2505     }
2506
2507     m_needSaveResumeDataTorrents.insert(torrent->id());
2508 }
2509
2510 void SessionImpl::handleTorrentSaveResumeDataRequested(const TorrentImpl *torrent)
2511 {
2512     qDebug("Saving resume data is requested for torrent '%s'...", qUtf8Printable(torrent->name()));
2513     ++m_numResumeData;
2514 }
2515
2516 void SessionImpl::handleTorrentSaveResumeDataFailed(const TorrentImpl *torrent)
2517 {
2518     Q_UNUSED(torrent);
2519     --m_numResumeData;
2520 }
2521
2522 QVector<Torrent *> SessionImpl::torrents() const
2523 {
2524     QVector<Torrent *> result;
2525     result.reserve(m_torrents.size());
2526     for (TorrentImpl *torrent : asConst(m_torrents))
2527         result << torrent;
2528
2529     return result;
2530 }
2531
2532 qsizetype SessionImpl::torrentsCount() const
2533 {
2534     return m_torrents.size();
2535 }
2536
2537 bool SessionImpl::addTorrent(const QString &source, const AddTorrentParams &params)
2538 {
2539     // `source`: .torrent file path/url or magnet uri
2540
2541     if (!isRestored())
2542         return false;
2543
2544     if (Net::DownloadManager::hasSupportedScheme(source))
2545     {
2546         LogMsg(tr("Downloading torrent, please wait... Source: \"%1\"").arg(source));
2547         // Launch downloader
2548         Net::DownloadManager::instance()->download(Net::DownloadRequest(source).limit(MAX_TORRENT_SIZE)
2549                 , Preferences::instance()->useProxyForGeneralPurposes(), this, &SessionImpl::handleDownloadFinished);
2550         m_downloadedTorrents[source] = params;
2551         return true;
2552     }
2553
2554     const MagnetUri magnetUri {source};
2555     if (magnetUri.isValid())
2556         return addTorrent(magnetUri, params);
2557
2558     const Path path {source};
2559     TorrentFileGuard guard {path};
2560     const nonstd::expected<TorrentInfo, QString> loadResult = TorrentInfo::loadFromFile(path);
2561     if (!loadResult)
2562     {
2563        LogMsg(tr("Failed to load torrent. Source: \"%1\". Reason: \"%2\"").arg(source, loadResult.error()), Log::WARNING);
2564        return false;
2565     }
2566
2567     guard.markAsAddedToSession();
2568     return addTorrent(loadResult.value(), params);
2569 }
2570
2571 bool SessionImpl::addTorrent(const MagnetUri &magnetUri, const AddTorrentParams &params)
2572 {
2573     if (!isRestored())
2574         return false;
2575
2576     if (!magnetUri.isValid())
2577         return false;
2578
2579     return addTorrent_impl(magnetUri, params);
2580 }
2581
2582 bool SessionImpl::addTorrent(const TorrentInfo &torrentInfo, const AddTorrentParams &params)
2583 {
2584     if (!isRestored())
2585         return false;
2586
2587     return addTorrent_impl(torrentInfo, params);
2588 }
2589
2590 LoadTorrentParams SessionImpl::initLoadTorrentParams(const AddTorrentParams &addTorrentParams)
2591 {
2592     LoadTorrentParams loadTorrentParams;
2593
2594     loadTorrentParams.name = addTorrentParams.name;
2595     loadTorrentParams.firstLastPiecePriority = addTorrentParams.firstLastPiecePriority;
2596     loadTorrentParams.hasFinishedStatus = addTorrentParams.skipChecking; // do not react on 'torrent_finished_alert' when skipping
2597     loadTorrentParams.contentLayout = addTorrentParams.contentLayout.value_or(torrentContentLayout());
2598     loadTorrentParams.operatingMode = (addTorrentParams.addForced ? TorrentOperatingMode::Forced : TorrentOperatingMode::AutoManaged);
2599     loadTorrentParams.stopped = addTorrentParams.addPaused.value_or(isAddTorrentPaused());
2600     loadTorrentParams.stopCondition = addTorrentParams.stopCondition.value_or(torrentStopCondition());
2601     loadTorrentParams.addToQueueTop = addTorrentParams.addToQueueTop.value_or(isAddTorrentToQueueTop());
2602     loadTorrentParams.ratioLimit = addTorrentParams.ratioLimit;
2603     loadTorrentParams.seedingTimeLimit = addTorrentParams.seedingTimeLimit;
2604
2605     const QString category = addTorrentParams.category;
2606     if (!category.isEmpty() && !m_categories.contains(category) && !addCategory(category))
2607         loadTorrentParams.category = u""_qs;
2608     else
2609         loadTorrentParams.category = category;
2610
2611     const auto defaultSavePath = suggestedSavePath(loadTorrentParams.category, addTorrentParams.useAutoTMM);
2612     const auto defaultDownloadPath = suggestedDownloadPath(loadTorrentParams.category, addTorrentParams.useAutoTMM);
2613
2614     loadTorrentParams.useAutoTMM = addTorrentParams.useAutoTMM.value_or(!isAutoTMMDisabledByDefault());
2615
2616     if (!addTorrentParams.useAutoTMM.has_value())
2617     {
2618         // Default TMM settings
2619
2620         if (!loadTorrentParams.useAutoTMM)
2621         {
2622             loadTorrentParams.savePath = defaultSavePath;
2623             if (isDownloadPathEnabled())
2624                 loadTorrentParams.downloadPath = (!defaultDownloadPath.isEmpty() ? defaultDownloadPath : downloadPath());
2625         }
2626     }
2627     else
2628     {
2629         // Overridden TMM settings
2630
2631         if (!loadTorrentParams.useAutoTMM)
2632         {
2633             if (addTorrentParams.savePath.isAbsolute())
2634                 loadTorrentParams.savePath = addTorrentParams.savePath;
2635             else
2636                 loadTorrentParams.savePath = defaultSavePath / addTorrentParams.savePath;
2637
2638             if (!addTorrentParams.useDownloadPath.has_value())
2639             {
2640                 // Default "Download path" settings
2641
2642                 if (isDownloadPathEnabled())
2643                     loadTorrentParams.downloadPath = (!defaultDownloadPath.isEmpty() ? defaultDownloadPath : downloadPath());
2644             }
2645             else if (addTorrentParams.useDownloadPath.value())
2646             {
2647                 // Overridden "Download path" settings
2648
2649                 if (addTorrentParams.downloadPath.isAbsolute())
2650                 {
2651                     loadTorrentParams.downloadPath = addTorrentParams.downloadPath;
2652                 }
2653                 else
2654                 {
2655                     const Path basePath = (!defaultDownloadPath.isEmpty() ? defaultDownloadPath : downloadPath());
2656                     loadTorrentParams.downloadPath = basePath / addTorrentParams.downloadPath;
2657                 }
2658             }
2659         }
2660     }
2661
2662     for (const QString &tag : addTorrentParams.tags)
2663     {
2664         if (hasTag(tag) || addTag(tag))
2665             loadTorrentParams.tags.insert(tag);
2666     }
2667
2668     return loadTorrentParams;
2669 }
2670
2671 // Add a torrent to the BitTorrent session
2672 bool SessionImpl::addTorrent_impl(const std::variant<MagnetUri, TorrentInfo> &source, const AddTorrentParams &addTorrentParams)
2673 {
2674     Q_ASSERT(isRestored());
2675
2676     const bool hasMetadata = std::holds_alternative<TorrentInfo>(source);
2677     const auto infoHash = (hasMetadata ? std::get<TorrentInfo>(source).infoHash() : std::get<MagnetUri>(source).infoHash());
2678     const auto id = TorrentID::fromInfoHash(infoHash);
2679
2680     // alternative ID can be useful to find existing torrent in case if hybrid torrent was added by v1 info hash
2681     const auto altID = (infoHash.isHybrid() ? TorrentID::fromSHA1Hash(infoHash.v1()) : TorrentID());
2682
2683     // We should not add the torrent if it is already
2684     // processed or is pending to add to session
2685     if (m_loadingTorrents.contains(id) || (infoHash.isHybrid() && m_loadingTorrents.contains(altID)))
2686         return false;
2687
2688     if (Torrent *torrent = findTorrent(infoHash); torrent)
2689     {
2690         if (hasMetadata)
2691         {
2692             // Trying to set metadata to existing torrent in case if it has none
2693             torrent->setMetadata(std::get<TorrentInfo>(source));
2694         }
2695
2696         return false;
2697     }
2698
2699     // It looks illogical that we don't just use an existing handle,
2700     // but as previous experience has shown, it actually creates unnecessary
2701     // problems and unwanted behavior due to the fact that it was originally
2702     // added with parameters other than those provided by the user.
2703     cancelDownloadMetadata(id);
2704     if (infoHash.isHybrid())
2705         cancelDownloadMetadata(altID);
2706
2707     LoadTorrentParams loadTorrentParams = initLoadTorrentParams(addTorrentParams);
2708     lt::add_torrent_params &p = loadTorrentParams.ltAddTorrentParams;
2709
2710     bool isFindingIncompleteFiles = false;
2711
2712     const bool useAutoTMM = loadTorrentParams.useAutoTMM;
2713     const Path actualSavePath = useAutoTMM ? categorySavePath(loadTorrentParams.category) : loadTorrentParams.savePath;
2714
2715     if (hasMetadata)
2716     {
2717         const TorrentInfo &torrentInfo = std::get<TorrentInfo>(source);
2718
2719         Q_ASSERT(addTorrentParams.filePaths.isEmpty() || (addTorrentParams.filePaths.size() == torrentInfo.filesCount()));
2720
2721         PathList filePaths = addTorrentParams.filePaths;
2722         if (filePaths.isEmpty())
2723         {
2724             filePaths = torrentInfo.filePaths();
2725             if (loadTorrentParams.contentLayout != TorrentContentLayout::Original)
2726             {
2727                 const Path originalRootFolder = Path::findRootFolder(filePaths);
2728                 const auto originalContentLayout = (originalRootFolder.isEmpty()
2729                                                     ? TorrentContentLayout::NoSubfolder
2730                                                     : TorrentContentLayout::Subfolder);
2731                 if (loadTorrentParams.contentLayout != originalContentLayout)
2732                 {
2733                     if (loadTorrentParams.contentLayout == TorrentContentLayout::NoSubfolder)
2734                         Path::stripRootFolder(filePaths);
2735                     else
2736                         Path::addRootFolder(filePaths, filePaths.at(0).removedExtension());
2737                 }
2738             }
2739         }
2740
2741         // if torrent name wasn't explicitly set we handle the case of
2742         // initial renaming of torrent content and rename torrent accordingly
2743         if (loadTorrentParams.name.isEmpty())
2744         {
2745             QString contentName = Path::findRootFolder(filePaths).toString();
2746             if (contentName.isEmpty() && (filePaths.size() == 1))
2747                 contentName = filePaths.at(0).filename();
2748
2749             if (!contentName.isEmpty() && (contentName != torrentInfo.name()))
2750                 loadTorrentParams.name = contentName;
2751         }
2752
2753         if (!loadTorrentParams.hasFinishedStatus)
2754         {
2755             const Path actualDownloadPath = useAutoTMM
2756                     ? categoryDownloadPath(loadTorrentParams.category) : loadTorrentParams.downloadPath;
2757             findIncompleteFiles(torrentInfo, actualSavePath, actualDownloadPath, filePaths);
2758             isFindingIncompleteFiles = true;
2759         }
2760
2761         const auto nativeIndexes = torrentInfo.nativeIndexes();
2762         if (!isFindingIncompleteFiles)
2763         {
2764             for (int index = 0; index < filePaths.size(); ++index)
2765                 p.renamed_files[nativeIndexes[index]] = filePaths.at(index).toString().toStdString();
2766         }
2767
2768         Q_ASSERT(p.file_priorities.empty());
2769         Q_ASSERT(addTorrentParams.filePriorities.isEmpty() || (addTorrentParams.filePriorities.size() == nativeIndexes.size()));
2770
2771         const int internalFilesCount = torrentInfo.nativeInfo()->files().num_files(); // including .pad files
2772         // Use qBittorrent default priority rather than libtorrent's (4)
2773         p.file_priorities = std::vector(internalFilesCount, LT::toNative(DownloadPriority::Normal));
2774
2775         if (addTorrentParams.filePriorities.isEmpty())
2776         {
2777             if (isExcludedFileNamesEnabled())
2778             {
2779                 // Check file name blacklist when priorities are not explicitly set
2780                 for (int i = 0; i < filePaths.size(); ++i)
2781                 {
2782                     if (isFilenameExcluded(filePaths.at(i).filename()))
2783                         p.file_priorities[LT::toUnderlyingType(nativeIndexes[i])] = lt::dont_download;
2784                 }
2785             }
2786         }
2787         else
2788         {
2789             for (int i = 0; i < addTorrentParams.filePriorities.size(); ++i)
2790                 p.file_priorities[LT::toUnderlyingType(nativeIndexes[i])] = LT::toNative(addTorrentParams.filePriorities[i]);
2791         }
2792
2793         p.ti = torrentInfo.nativeInfo();
2794     }
2795     else
2796     {
2797         const MagnetUri &magnetUri = std::get<MagnetUri>(source);
2798         p = magnetUri.addTorrentParams();
2799
2800         if (loadTorrentParams.name.isEmpty() && !p.name.empty())
2801             loadTorrentParams.name = QString::fromStdString(p.name);
2802     }
2803
2804     p.save_path = actualSavePath.toString().toStdString();
2805
2806     if (isAddTrackersEnabled() && !(hasMetadata && p.ti->priv()))
2807     {
2808         p.trackers.reserve(p.trackers.size() + static_cast<std::size_t>(m_additionalTrackerList.size()));
2809         p.tracker_tiers.reserve(p.trackers.size() + static_cast<std::size_t>(m_additionalTrackerList.size()));
2810         p.tracker_tiers.resize(p.trackers.size(), 0);
2811         for (const TrackerEntry &trackerEntry : asConst(m_additionalTrackerList))
2812         {
2813             p.trackers.push_back(trackerEntry.url.toStdString());
2814             p.tracker_tiers.push_back(trackerEntry.tier);
2815         }
2816     }
2817
2818     p.upload_limit = addTorrentParams.uploadLimit;
2819     p.download_limit = addTorrentParams.downloadLimit;
2820
2821     // Preallocation mode
2822     p.storage_mode = isPreallocationEnabled() ? lt::storage_mode_allocate : lt::storage_mode_sparse;
2823
2824     if (addTorrentParams.sequential)
2825         p.flags |= lt::torrent_flags::sequential_download;
2826     else
2827         p.flags &= ~lt::torrent_flags::sequential_download;
2828
2829     // Seeding mode
2830     // Skip checking and directly start seeding
2831     if (addTorrentParams.skipChecking)
2832         p.flags |= lt::torrent_flags::seed_mode;
2833     else
2834         p.flags &= ~lt::torrent_flags::seed_mode;
2835
2836     if (loadTorrentParams.stopped || (loadTorrentParams.operatingMode == TorrentOperatingMode::AutoManaged))
2837         p.flags |= lt::torrent_flags::paused;
2838     else
2839         p.flags &= ~lt::torrent_flags::paused;
2840     if (loadTorrentParams.stopped || (loadTorrentParams.operatingMode == TorrentOperatingMode::Forced))
2841         p.flags &= ~lt::torrent_flags::auto_managed;
2842     else
2843         p.flags |= lt::torrent_flags::auto_managed;
2844
2845     p.flags |= lt::torrent_flags::duplicate_is_error;
2846
2847     p.added_time = std::time(nullptr);
2848
2849     // Limits
2850     p.max_connections = maxConnectionsPerTorrent();
2851     p.max_uploads = maxUploadsPerTorrent();
2852
2853     p.userdata = LTClientData(new ExtensionData);
2854 #ifndef QBT_USES_LIBTORRENT2
2855     p.storage = customStorageConstructor;
2856 #endif
2857
2858     m_loadingTorrents.insert(id, loadTorrentParams);
2859     if (infoHash.isHybrid())
2860         m_hybridTorrentsByAltID.insert(altID, nullptr);
2861     if (!isFindingIncompleteFiles)
2862         m_nativeSession->async_add_torrent(p);
2863
2864     return true;
2865 }
2866
2867 void SessionImpl::findIncompleteFiles(const TorrentInfo &torrentInfo, const Path &savePath
2868                                   , const Path &downloadPath, const PathList &filePaths) const
2869 {
2870     Q_ASSERT(filePaths.isEmpty() || (filePaths.size() == torrentInfo.filesCount()));
2871
2872     const auto searchId = TorrentID::fromInfoHash(torrentInfo.infoHash());
2873     const PathList originalFileNames = (filePaths.isEmpty() ? torrentInfo.filePaths() : filePaths);
2874     QMetaObject::invokeMethod(m_fileSearcher, [=]()
2875     {
2876         m_fileSearcher->search(searchId, originalFileNames, savePath, downloadPath, isAppendExtensionEnabled());
2877     });
2878 }
2879
2880 void SessionImpl::enablePortMapping()
2881 {
2882     invokeAsync([this]
2883     {
2884         if (m_isPortMappingEnabled)
2885             return;
2886
2887         lt::settings_pack settingsPack;
2888         settingsPack.set_bool(lt::settings_pack::enable_upnp, true);
2889         settingsPack.set_bool(lt::settings_pack::enable_natpmp, true);
2890         m_nativeSession->apply_settings(std::move(settingsPack));
2891
2892         m_isPortMappingEnabled = true;
2893
2894         LogMsg(tr("UPnP/NAT-PMP support: ON"), Log::INFO);
2895     });
2896 }
2897
2898 void SessionImpl::disablePortMapping()
2899 {
2900     invokeAsync([this]
2901     {
2902         if (!m_isPortMappingEnabled)
2903             return;
2904
2905         lt::settings_pack settingsPack;
2906         settingsPack.set_bool(lt::settings_pack::enable_upnp, false);
2907         settingsPack.set_bool(lt::settings_pack::enable_natpmp, false);
2908         m_nativeSession->apply_settings(std::move(settingsPack));
2909
2910         m_mappedPorts.clear();
2911         m_isPortMappingEnabled = false;
2912
2913         LogMsg(tr("UPnP/NAT-PMP support: OFF"), Log::INFO);
2914     });
2915 }
2916
2917 void SessionImpl::addMappedPorts(const QSet<quint16> &ports)
2918 {
2919     invokeAsync([this, ports]
2920     {
2921         if (!m_isPortMappingEnabled)
2922             return;
2923
2924         for (const quint16 port : ports)
2925         {
2926             if (!m_mappedPorts.contains(port))
2927                 m_mappedPorts.insert(port, m_nativeSession->add_port_mapping(lt::session::tcp, port, port));
2928         }
2929     });
2930 }
2931
2932 void SessionImpl::removeMappedPorts(const QSet<quint16> &ports)
2933 {
2934     invokeAsync([this, ports]
2935     {
2936         if (!m_isPortMappingEnabled)
2937             return;
2938
2939         Algorithm::removeIf(m_mappedPorts, [this, ports](const quint16 port, const std::vector<lt::port_mapping_t> &handles)
2940         {
2941             if (!ports.contains(port))
2942                 return false;
2943
2944             for (const lt::port_mapping_t &handle : handles)
2945                 m_nativeSession->delete_port_mapping(handle);
2946
2947             return true;
2948         });
2949     });
2950 }
2951
2952 void SessionImpl::invokeAsync(std::function<void ()> func)
2953 {
2954     m_asyncWorker->start(std::move(func));
2955 }
2956
2957 // Add a torrent to libtorrent session in hidden mode
2958 // and force it to download its metadata
2959 bool SessionImpl::downloadMetadata(const MagnetUri &magnetUri)
2960 {
2961     if (!magnetUri.isValid())
2962         return false;
2963
2964     const InfoHash infoHash = magnetUri.infoHash();
2965
2966     // We should not add torrent if it's already
2967     // processed or adding to session
2968     if (isKnownTorrent(infoHash))
2969         return false;
2970
2971     lt::add_torrent_params p = magnetUri.addTorrentParams();
2972
2973     if (isAddTrackersEnabled())
2974     {
2975         // Use "additional trackers" when metadata retrieving (this can help when the DHT nodes are few)
2976         p.trackers.reserve(p.trackers.size() + static_cast<std::size_t>(m_additionalTrackerList.size()));
2977         p.tracker_tiers.reserve(p.trackers.size() + static_cast<std::size_t>(m_additionalTrackerList.size()));
2978         p.tracker_tiers.resize(p.trackers.size(), 0);
2979         for (const TrackerEntry &trackerEntry : asConst(m_additionalTrackerList))
2980         {
2981             p.trackers.push_back(trackerEntry.url.toStdString());
2982             p.tracker_tiers.push_back(trackerEntry.tier);
2983         }
2984     }
2985
2986     // Flags
2987     // Preallocation mode
2988     if (isPreallocationEnabled())
2989         p.storage_mode = lt::storage_mode_allocate;
2990     else
2991         p.storage_mode = lt::storage_mode_sparse;
2992
2993     // Limits
2994     p.max_connections = maxConnectionsPerTorrent();
2995     p.max_uploads = maxUploadsPerTorrent();
2996
2997     const auto id = TorrentID::fromInfoHash(infoHash);
2998     const Path savePath = Utils::Fs::tempPath() / Path(id.toString());
2999     p.save_path = savePath.toString().toStdString();
3000
3001     // Forced start
3002     p.flags &= ~lt::torrent_flags::paused;
3003     p.flags &= ~lt::torrent_flags::auto_managed;
3004
3005     // Solution to avoid accidental file writes
3006     p.flags |= lt::torrent_flags::upload_mode;
3007
3008 #ifndef QBT_USES_LIBTORRENT2
3009     p.storage = customStorageConstructor;
3010 #endif
3011
3012     // Adding torrent to libtorrent session
3013     m_nativeSession->async_add_torrent(p);
3014     m_downloadedMetadata.insert(id, {});
3015
3016     return true;
3017 }
3018
3019 void SessionImpl::exportTorrentFile(const Torrent *torrent, const Path &folderPath)
3020 {
3021     if (!folderPath.exists() && !Utils::Fs::mkpath(folderPath))
3022         return;
3023
3024     const QString validName = Utils::Fs::toValidFileName(torrent->name());
3025     QString torrentExportFilename = u"%1.torrent"_qs.arg(validName);
3026     Path newTorrentPath = folderPath / Path(torrentExportFilename);
3027     int counter = 0;
3028     while (newTorrentPath.exists())
3029     {
3030         // Append number to torrent name to make it unique
3031         torrentExportFilename = u"%1 %2.torrent"_qs.arg(validName).arg(++counter);
3032         newTorrentPath = folderPath / Path(torrentExportFilename);
3033     }
3034
3035     const nonstd::expected<void, QString> result = torrent->exportToFile(newTorrentPath);
3036     if (!result)
3037     {
3038         LogMsg(tr("Failed to export torrent. Torrent: \"%1\". Destination: \"%2\". Reason: \"%3\"")
3039                .arg(torrent->name(), newTorrentPath.toString(), result.error()), Log::WARNING);
3040     }
3041 }
3042
3043 void SessionImpl::generateResumeData()
3044 {
3045     for (TorrentImpl *const torrent : asConst(m_torrents))
3046     {
3047         if (!torrent->isValid()) continue;
3048
3049         if (torrent->needSaveResumeData())
3050         {
3051             torrent->saveResumeData();
3052             m_needSaveResumeDataTorrents.remove(torrent->id());
3053         }
3054     }
3055 }
3056
3057 // Called on exit
3058 void SessionImpl::saveResumeData()
3059 {
3060     for (const TorrentImpl *torrent : asConst(m_torrents))
3061         torrent->nativeHandle().save_resume_data(lt::torrent_handle::only_if_modified);
3062     m_numResumeData += m_torrents.size();
3063
3064     // clear queued storage move jobs except the current ongoing one
3065     if (m_moveStorageQueue.size() > 1)
3066     {
3067 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
3068         m_moveStorageQueue = m_moveStorageQueue.mid(0, 1);
3069 #else
3070         m_moveStorageQueue.resize(1);
3071 #endif
3072     }
3073
3074     QElapsedTimer timer;
3075     timer.start();
3076
3077     while ((m_numResumeData > 0) || !m_moveStorageQueue.isEmpty() || m_needSaveTorrentsQueue)
3078     {
3079         const lt::seconds waitTime {5};
3080         const lt::seconds expireTime {30};
3081
3082         // only terminate when no storage is moving
3083         if (timer.hasExpired(lt::total_milliseconds(expireTime)) && m_moveStorageQueue.isEmpty())
3084         {
3085             LogMsg(tr("Aborted saving resume data. Number of outstanding torrents: %1").arg(QString::number(m_numResumeData))
3086                 , Log::CRITICAL);
3087             break;
3088         }
3089
3090         const std::vector<lt::alert *> alerts = getPendingAlerts(waitTime);
3091
3092         bool hasWantedAlert = false;
3093         for (const lt::alert *a : alerts)
3094         {
3095             if (const int alertType = a->type();
3096                 (alertType == lt::save_resume_data_alert::alert_type) || (alertType == lt::save_resume_data_failed_alert::alert_type)
3097                 || (alertType == lt::storage_moved_alert::alert_type) || (alertType == lt::storage_moved_failed_alert::alert_type)
3098                 || (alertType == lt::state_update_alert::alert_type))
3099             {
3100                 hasWantedAlert = true;
3101             }
3102
3103             handleAlert(a);
3104         }
3105
3106         if (hasWantedAlert)
3107             timer.start();
3108     }
3109 }
3110
3111 void SessionImpl::saveTorrentsQueue()
3112 {
3113     QVector<TorrentID> queue;
3114     for (const TorrentImpl *torrent : asConst(m_torrents))
3115     {
3116         if (const int queuePos = torrent->queuePosition(); queuePos >= 0)
3117         {
3118             if (queuePos >= queue.size())
3119                 queue.resize(queuePos + 1);
3120             queue[queuePos] = torrent->id();
3121         }
3122     }
3123
3124     m_resumeDataStorage->storeQueue(queue);
3125     m_needSaveTorrentsQueue = false;
3126 }
3127
3128 void SessionImpl::removeTorrentsQueue()
3129 {
3130     m_resumeDataStorage->storeQueue({});
3131     m_torrentsQueueChanged = false;
3132     m_needSaveTorrentsQueue = false;
3133 }
3134
3135 void SessionImpl::setSavePath(const Path &path)
3136 {
3137     const auto newPath = (path.isAbsolute() ? path : (specialFolderLocation(SpecialFolder::Downloads) / path));
3138     if (newPath == m_savePath)
3139         return;
3140
3141     if (isDisableAutoTMMWhenDefaultSavePathChanged())
3142     {
3143         QSet<QString> affectedCatogories {{}}; // includes default (unnamed) category
3144         for (auto it = m_categories.cbegin(); it != m_categories.cend(); ++it)
3145         {
3146             const QString &categoryName = it.key();
3147             const CategoryOptions &categoryOptions = it.value();
3148             if (categoryOptions.savePath.isRelative())
3149                 affectedCatogories.insert(categoryName);
3150         }
3151
3152         for (TorrentImpl *const torrent : asConst(m_torrents))
3153         {
3154             if (affectedCatogories.contains(torrent->category()))
3155                 torrent->setAutoTMMEnabled(false);
3156         }
3157     }
3158
3159     m_savePath = newPath;
3160     for (TorrentImpl *const torrent : asConst(m_torrents))
3161         torrent->handleCategoryOptionsChanged();
3162 }
3163
3164 void SessionImpl::setDownloadPath(const Path &path)
3165 {
3166     const Path newPath = (path.isAbsolute() ? path : (savePath() / Path(u"temp"_qs) / path));
3167     if (newPath == m_downloadPath)
3168         return;
3169
3170     if (isDisableAutoTMMWhenDefaultSavePathChanged())
3171     {
3172         QSet<QString> affectedCatogories {{}}; // includes default (unnamed) category
3173         for (auto it = m_categories.cbegin(); it != m_categories.cend(); ++it)
3174         {
3175             const QString &categoryName = it.key();
3176             const CategoryOptions &categoryOptions = it.value();
3177             const CategoryOptions::DownloadPathOption downloadPathOption =
3178                     categoryOptions.downloadPath.value_or(CategoryOptions::DownloadPathOption {isDownloadPathEnabled(), downloadPath()});
3179             if (downloadPathOption.enabled && downloadPathOption.path.isRelative())
3180                 affectedCatogories.insert(categoryName);
3181         }
3182
3183         for (TorrentImpl *const torrent : asConst(m_torrents))
3184         {
3185             if (affectedCatogories.contains(torrent->category()))
3186                 torrent->setAutoTMMEnabled(false);
3187         }
3188     }
3189
3190     m_downloadPath = newPath;
3191     for (TorrentImpl *const torrent : asConst(m_torrents))
3192         torrent->handleCategoryOptionsChanged();
3193 }
3194
3195 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
3196 void SessionImpl::networkOnlineStateChanged(const bool online)
3197 {
3198     LogMsg(tr("System network status changed to %1", "e.g: System network status changed to ONLINE").arg(online ? tr("ONLINE") : tr("OFFLINE")), Log::INFO);
3199 }
3200
3201 void SessionImpl::networkConfigurationChange(const QNetworkConfiguration &cfg)
3202 {
3203     const QString configuredInterfaceName = networkInterface();
3204     // Empty means "Any Interface". In this case libtorrent has binded to 0.0.0.0 so any change to any interface will
3205     // be automatically picked up. Otherwise we would rebinding here to 0.0.0.0 again.
3206     if (configuredInterfaceName.isEmpty()) return;
3207
3208     const QString changedInterface = cfg.name();
3209
3210     if (configuredInterfaceName == changedInterface)
3211     {
3212         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);
3213         configureListeningInterface();
3214     }
3215 }
3216 #endif
3217
3218 QStringList SessionImpl::getListeningIPs() const
3219 {
3220     QStringList IPs;
3221
3222     const QString ifaceName = networkInterface();
3223     const QString ifaceAddr = networkInterfaceAddress();
3224     const QHostAddress configuredAddr(ifaceAddr);
3225     const bool allIPv4 = (ifaceAddr == u"0.0.0.0"); // Means All IPv4 addresses
3226     const bool allIPv6 = (ifaceAddr == u"::"); // Means All IPv6 addresses
3227
3228     if (!ifaceAddr.isEmpty() && !allIPv4 && !allIPv6 && configuredAddr.isNull())
3229     {
3230         LogMsg(tr("The configured network address is invalid. Address: \"%1\"").arg(ifaceAddr), Log::CRITICAL);
3231         // Pass the invalid user configured interface name/address to libtorrent
3232         // in hopes that it will come online later.
3233         // This will not cause IP leak but allow user to reconnect the interface
3234         // and re-establish connection without restarting the client.
3235         IPs.append(ifaceAddr);
3236         return IPs;
3237     }
3238
3239     if (ifaceName.isEmpty())
3240     {
3241         if (ifaceAddr.isEmpty())
3242             return {u"0.0.0.0"_qs, u"::"_qs}; // Indicates all interfaces + all addresses (aka default)
3243
3244         if (allIPv4)
3245             return {u"0.0.0.0"_qs};
3246
3247         if (allIPv6)
3248             return {u"::"_qs};
3249     }
3250
3251     const auto checkAndAddIP = [allIPv4, allIPv6, &IPs](const QHostAddress &addr, const QHostAddress &match)
3252     {
3253         if ((allIPv4 && (addr.protocol() != QAbstractSocket::IPv4Protocol))
3254             || (allIPv6 && (addr.protocol() != QAbstractSocket::IPv6Protocol)))
3255             return;
3256
3257         if ((match == addr) || allIPv4 || allIPv6)
3258             IPs.append(addr.toString());
3259     };
3260
3261     if (ifaceName.isEmpty())
3262     {
3263         const QList<QHostAddress> addresses = QNetworkInterface::allAddresses();
3264         for (const auto &addr : addresses)
3265             checkAndAddIP(addr, configuredAddr);
3266
3267         // At this point ifaceAddr was non-empty
3268         // If IPs.isEmpty() it means the configured Address was not found
3269         if (IPs.isEmpty())
3270         {
3271             LogMsg(tr("Failed to find the configured network address to listen on. Address: \"%1\"")
3272                 .arg(ifaceAddr), Log::CRITICAL);
3273             IPs.append(ifaceAddr);
3274         }
3275
3276         return IPs;
3277     }
3278
3279     // Attempt to listen on provided interface
3280     const QNetworkInterface networkIFace = QNetworkInterface::interfaceFromName(ifaceName);
3281     if (!networkIFace.isValid())
3282     {
3283         qDebug("Invalid network interface: %s", qUtf8Printable(ifaceName));
3284         LogMsg(tr("The configured network interface is invalid. Interface: \"%1\"").arg(ifaceName), Log::CRITICAL);
3285         IPs.append(ifaceName);
3286         return IPs;
3287     }
3288
3289     if (ifaceAddr.isEmpty())
3290     {
3291         IPs.append(ifaceName);
3292         return IPs; // On Windows calling code converts it to GUID
3293     }
3294
3295     const QList<QNetworkAddressEntry> addresses = networkIFace.addressEntries();
3296     qDebug() << "This network interface has " << addresses.size() << " IP addresses";
3297     for (const QNetworkAddressEntry &entry : addresses)
3298         checkAndAddIP(entry.ip(), configuredAddr);
3299
3300     // Make sure there is at least one IP
3301     // At this point there was an explicit interface and an explicit address set
3302     // and the address should have been found
3303     if (IPs.isEmpty())
3304     {
3305         LogMsg(tr("Failed to find the configured network address to listen on. Address: \"%1\"")
3306             .arg(ifaceAddr), Log::CRITICAL);
3307         IPs.append(ifaceAddr);
3308     }
3309
3310     return IPs;
3311 }
3312
3313 // Set the ports range in which is chosen the port
3314 // the BitTorrent session will listen to
3315 void SessionImpl::configureListeningInterface()
3316 {
3317     m_listenInterfaceConfigured = false;
3318     configureDeferred();
3319 }
3320
3321 int SessionImpl::globalDownloadSpeedLimit() const
3322 {
3323     // Unfortunately the value was saved as KiB instead of B.
3324     // But it is better to pass it around internally(+ webui) as Bytes.
3325     return m_globalDownloadSpeedLimit * 1024;
3326 }
3327
3328 void SessionImpl::setGlobalDownloadSpeedLimit(const int limit)
3329 {
3330     // Unfortunately the value was saved as KiB instead of B.
3331     // But it is better to pass it around internally(+ webui) as Bytes.
3332     if (limit == globalDownloadSpeedLimit())
3333         return;
3334
3335     if (limit <= 0)
3336         m_globalDownloadSpeedLimit = 0;
3337     else if (limit <= 1024)
3338         m_globalDownloadSpeedLimit = 1;
3339     else
3340         m_globalDownloadSpeedLimit = (limit / 1024);
3341
3342     if (!isAltGlobalSpeedLimitEnabled())
3343         configureDeferred();
3344 }
3345
3346 int SessionImpl::globalUploadSpeedLimit() const
3347 {
3348     // Unfortunately the value was saved as KiB instead of B.
3349     // But it is better to pass it around internally(+ webui) as Bytes.
3350     return m_globalUploadSpeedLimit * 1024;
3351 }
3352
3353 void SessionImpl::setGlobalUploadSpeedLimit(const int limit)
3354 {
3355     // Unfortunately the value was saved as KiB instead of B.
3356     // But it is better to pass it around internally(+ webui) as Bytes.
3357     if (limit == globalUploadSpeedLimit())
3358         return;
3359
3360     if (limit <= 0)
3361         m_globalUploadSpeedLimit = 0;
3362     else if (limit <= 1024)
3363         m_globalUploadSpeedLimit = 1;
3364     else
3365         m_globalUploadSpeedLimit = (limit / 1024);
3366
3367     if (!isAltGlobalSpeedLimitEnabled())
3368         configureDeferred();
3369 }
3370
3371 int SessionImpl::altGlobalDownloadSpeedLimit() const
3372 {
3373     // Unfortunately the value was saved as KiB instead of B.
3374     // But it is better to pass it around internally(+ webui) as Bytes.
3375     return m_altGlobalDownloadSpeedLimit * 1024;
3376 }
3377
3378 void SessionImpl::setAltGlobalDownloadSpeedLimit(const int limit)
3379 {
3380     // Unfortunately the value was saved as KiB instead of B.
3381     // But it is better to pass it around internally(+ webui) as Bytes.
3382     if (limit == altGlobalDownloadSpeedLimit())
3383         return;
3384
3385     if (limit <= 0)
3386         m_altGlobalDownloadSpeedLimit = 0;
3387     else if (limit <= 1024)
3388         m_altGlobalDownloadSpeedLimit = 1;
3389     else
3390         m_altGlobalDownloadSpeedLimit = (limit / 1024);
3391
3392     if (isAltGlobalSpeedLimitEnabled())
3393         configureDeferred();
3394 }
3395
3396 int SessionImpl::altGlobalUploadSpeedLimit() const
3397 {
3398     // Unfortunately the value was saved as KiB instead of B.
3399     // But it is better to pass it around internally(+ webui) as Bytes.
3400     return m_altGlobalUploadSpeedLimit * 1024;
3401 }
3402
3403 void SessionImpl::setAltGlobalUploadSpeedLimit(const int limit)
3404 {
3405     // Unfortunately the value was saved as KiB instead of B.
3406     // But it is better to pass it around internally(+ webui) as Bytes.
3407     if (limit == altGlobalUploadSpeedLimit())
3408         return;
3409
3410     if (limit <= 0)
3411         m_altGlobalUploadSpeedLimit = 0;
3412     else if (limit <= 1024)
3413         m_altGlobalUploadSpeedLimit = 1;
3414     else
3415         m_altGlobalUploadSpeedLimit = (limit / 1024);
3416
3417     if (isAltGlobalSpeedLimitEnabled())
3418         configureDeferred();
3419 }
3420
3421 int SessionImpl::downloadSpeedLimit() const
3422 {
3423     return isAltGlobalSpeedLimitEnabled()
3424             ? altGlobalDownloadSpeedLimit()
3425             : globalDownloadSpeedLimit();
3426 }
3427
3428 void SessionImpl::setDownloadSpeedLimit(const int limit)
3429 {
3430     if (isAltGlobalSpeedLimitEnabled())
3431         setAltGlobalDownloadSpeedLimit(limit);
3432     else
3433         setGlobalDownloadSpeedLimit(limit);
3434 }
3435
3436 int SessionImpl::uploadSpeedLimit() const
3437 {
3438     return isAltGlobalSpeedLimitEnabled()
3439             ? altGlobalUploadSpeedLimit()
3440             : globalUploadSpeedLimit();
3441 }
3442
3443 void SessionImpl::setUploadSpeedLimit(const int limit)
3444 {
3445     if (isAltGlobalSpeedLimitEnabled())
3446         setAltGlobalUploadSpeedLimit(limit);
3447     else
3448         setGlobalUploadSpeedLimit(limit);
3449 }
3450
3451 bool SessionImpl::isAltGlobalSpeedLimitEnabled() const
3452 {
3453     return m_isAltGlobalSpeedLimitEnabled;
3454 }
3455
3456 void SessionImpl::setAltGlobalSpeedLimitEnabled(const bool enabled)
3457 {
3458     if (enabled == isAltGlobalSpeedLimitEnabled()) return;
3459
3460     // Save new state to remember it on startup
3461     m_isAltGlobalSpeedLimitEnabled = enabled;
3462     applyBandwidthLimits();
3463     // Notify
3464     emit speedLimitModeChanged(m_isAltGlobalSpeedLimitEnabled);
3465 }
3466
3467 bool SessionImpl::isBandwidthSchedulerEnabled() const
3468 {
3469     return m_isBandwidthSchedulerEnabled;
3470 }
3471
3472 void SessionImpl::setBandwidthSchedulerEnabled(const bool enabled)
3473 {
3474     if (enabled != isBandwidthSchedulerEnabled())
3475     {
3476         m_isBandwidthSchedulerEnabled = enabled;
3477         if (enabled)
3478             enableBandwidthScheduler();
3479         else
3480             delete m_bwScheduler;
3481     }
3482 }
3483
3484 bool SessionImpl::isPerformanceWarningEnabled() const
3485 {
3486     return m_isPerformanceWarningEnabled;
3487 }
3488
3489 void SessionImpl::setPerformanceWarningEnabled(const bool enable)
3490 {
3491     if (enable == m_isPerformanceWarningEnabled)
3492         return;
3493
3494     m_isPerformanceWarningEnabled = enable;
3495     configureDeferred();
3496 }
3497
3498 int SessionImpl::saveResumeDataInterval() const
3499 {
3500     return m_saveResumeDataInterval;
3501 }
3502
3503 void SessionImpl::setSaveResumeDataInterval(const int value)
3504 {
3505     if (value == m_saveResumeDataInterval)
3506         return;
3507
3508     m_saveResumeDataInterval = value;
3509
3510     if (value > 0)
3511     {
3512         m_resumeDataTimer->setInterval(std::chrono::minutes(value));
3513         m_resumeDataTimer->start();
3514     }
3515     else
3516     {
3517         m_resumeDataTimer->stop();
3518     }
3519 }
3520
3521 int SessionImpl::port() const
3522 {
3523     return m_port;
3524 }
3525
3526 void SessionImpl::setPort(const int port)
3527 {
3528     if (port != m_port)
3529     {
3530         m_port = port;
3531         configureListeningInterface();
3532
3533         if (isReannounceWhenAddressChangedEnabled())
3534             reannounceToAllTrackers();
3535     }
3536 }
3537
3538 QString SessionImpl::networkInterface() const
3539 {
3540     return m_networkInterface;
3541 }
3542
3543 void SessionImpl::setNetworkInterface(const QString &iface)
3544 {
3545     if (iface != networkInterface())
3546     {
3547         m_networkInterface = iface;
3548         configureListeningInterface();
3549     }
3550 }
3551
3552 QString SessionImpl::networkInterfaceName() const
3553 {
3554     return m_networkInterfaceName;
3555 }
3556
3557 void SessionImpl::setNetworkInterfaceName(const QString &name)
3558 {
3559     m_networkInterfaceName = name;
3560 }
3561
3562 QString SessionImpl::networkInterfaceAddress() const
3563 {
3564     return m_networkInterfaceAddress;
3565 }
3566
3567 void SessionImpl::setNetworkInterfaceAddress(const QString &address)
3568 {
3569     if (address != networkInterfaceAddress())
3570     {
3571         m_networkInterfaceAddress = address;
3572         configureListeningInterface();
3573     }
3574 }
3575
3576 int SessionImpl::encryption() const
3577 {
3578     return m_encryption;
3579 }
3580
3581 void SessionImpl::setEncryption(const int state)
3582 {
3583     if (state != encryption())
3584     {
3585         m_encryption = state;
3586         configureDeferred();
3587         LogMsg(tr("Encryption support: %1").arg(
3588             state == 0 ? tr("ON") : ((state == 1) ? tr("FORCED") : tr("OFF")))
3589             , Log::INFO);
3590     }
3591 }
3592
3593 int SessionImpl::maxActiveCheckingTorrents() const
3594 {
3595     return m_maxActiveCheckingTorrents;
3596 }
3597
3598 void SessionImpl::setMaxActiveCheckingTorrents(const int val)
3599 {
3600     if (val == m_maxActiveCheckingTorrents)
3601         return;
3602
3603     m_maxActiveCheckingTorrents = val;
3604     configureDeferred();
3605 }
3606
3607 bool SessionImpl::isI2PEnabled() const
3608 {
3609     return m_isI2PEnabled;
3610 }
3611
3612 void SessionImpl::setI2PEnabled(const bool enabled)
3613 {
3614     if (m_isI2PEnabled != enabled)
3615     {
3616         m_isI2PEnabled = enabled;
3617         configureDeferred();
3618     }
3619 }
3620
3621 QString SessionImpl::I2PAddress() const
3622 {
3623     return m_I2PAddress;
3624 }
3625
3626 void SessionImpl::setI2PAddress(const QString &address)
3627 {
3628     if (m_I2PAddress != address)
3629     {
3630         m_I2PAddress = address;
3631         configureDeferred();
3632     }
3633 }
3634
3635 int SessionImpl::I2PPort() const
3636 {
3637     return m_I2PPort;
3638 }
3639
3640 void SessionImpl::setI2PPort(int port)
3641 {
3642     if (m_I2PPort != port)
3643     {
3644         m_I2PPort = port;
3645         configureDeferred();
3646     }
3647 }
3648
3649 bool SessionImpl::I2PMixedMode() const
3650 {
3651     return m_I2PMixedMode;
3652 }
3653
3654 void SessionImpl::setI2PMixedMode(const bool enabled)
3655 {
3656     if (m_I2PMixedMode != enabled)
3657     {
3658         m_I2PMixedMode = enabled;
3659         configureDeferred();
3660     }
3661 }
3662
3663 bool SessionImpl::isProxyPeerConnectionsEnabled() const
3664 {
3665     return m_isProxyPeerConnectionsEnabled;
3666 }
3667
3668 void SessionImpl::setProxyPeerConnectionsEnabled(const bool enabled)
3669 {
3670     if (enabled != isProxyPeerConnectionsEnabled())
3671     {
3672         m_isProxyPeerConnectionsEnabled = enabled;
3673         configureDeferred();
3674     }
3675 }
3676
3677 ChokingAlgorithm SessionImpl::chokingAlgorithm() const
3678 {
3679     return m_chokingAlgorithm;
3680 }
3681
3682 void SessionImpl::setChokingAlgorithm(const ChokingAlgorithm mode)
3683 {
3684     if (mode == m_chokingAlgorithm) return;
3685
3686     m_chokingAlgorithm = mode;
3687     configureDeferred();
3688 }
3689
3690 SeedChokingAlgorithm SessionImpl::seedChokingAlgorithm() const
3691 {
3692     return m_seedChokingAlgorithm;
3693 }
3694
3695 void SessionImpl::setSeedChokingAlgorithm(const SeedChokingAlgorithm mode)
3696 {
3697     if (mode == m_seedChokingAlgorithm) return;
3698
3699     m_seedChokingAlgorithm = mode;
3700     configureDeferred();
3701 }
3702
3703 bool SessionImpl::isAddTrackersEnabled() const
3704 {
3705     return m_isAddTrackersEnabled;
3706 }
3707
3708 void SessionImpl::setAddTrackersEnabled(const bool enabled)
3709 {
3710     m_isAddTrackersEnabled = enabled;
3711 }
3712
3713 QString SessionImpl::additionalTrackers() const
3714 {
3715     return m_additionalTrackers;
3716 }
3717
3718 void SessionImpl::setAdditionalTrackers(const QString &trackers)
3719 {
3720     if (trackers != additionalTrackers())
3721     {
3722         m_additionalTrackers = trackers;
3723         populateAdditionalTrackers();
3724     }
3725 }
3726
3727 bool SessionImpl::isIPFilteringEnabled() const
3728 {
3729     return m_isIPFilteringEnabled;
3730 }
3731
3732 void SessionImpl::setIPFilteringEnabled(const bool enabled)
3733 {
3734     if (enabled != m_isIPFilteringEnabled)
3735     {
3736         m_isIPFilteringEnabled = enabled;
3737         m_IPFilteringConfigured = false;
3738         configureDeferred();
3739     }
3740 }
3741
3742 Path SessionImpl::IPFilterFile() const
3743 {
3744     return m_IPFilterFile;
3745 }
3746
3747 void SessionImpl::setIPFilterFile(const Path &path)
3748 {
3749     if (path != IPFilterFile())
3750     {
3751         m_IPFilterFile = path;
3752         m_IPFilteringConfigured = false;
3753         configureDeferred();
3754     }
3755 }
3756
3757 bool SessionImpl::isExcludedFileNamesEnabled() const
3758 {
3759     return m_isExcludedFileNamesEnabled;
3760 }
3761
3762 void SessionImpl::setExcludedFileNamesEnabled(const bool enabled)
3763 {
3764     if (m_isExcludedFileNamesEnabled == enabled)
3765         return;
3766
3767     m_isExcludedFileNamesEnabled = enabled;
3768
3769     if (enabled)
3770         populateExcludedFileNamesRegExpList();
3771     else
3772         m_excludedFileNamesRegExpList.clear();
3773 }
3774
3775 QStringList SessionImpl::excludedFileNames() const
3776 {
3777     return m_excludedFileNames;
3778 }
3779
3780 void SessionImpl::setExcludedFileNames(const QStringList &excludedFileNames)
3781 {
3782     if (excludedFileNames != m_excludedFileNames)
3783     {
3784         m_excludedFileNames = excludedFileNames;
3785         populateExcludedFileNamesRegExpList();
3786     }
3787 }
3788
3789 void SessionImpl::populateExcludedFileNamesRegExpList()
3790 {
3791     const QStringList excludedNames = excludedFileNames();
3792
3793     m_excludedFileNamesRegExpList.clear();
3794     m_excludedFileNamesRegExpList.reserve(excludedNames.size());
3795
3796     for (const QString &str : excludedNames)
3797     {
3798         const QString pattern = QRegularExpression::anchoredPattern(QRegularExpression::wildcardToRegularExpression(str));
3799         const QRegularExpression re {pattern, QRegularExpression::CaseInsensitiveOption};
3800         m_excludedFileNamesRegExpList.append(re);
3801     }
3802 }
3803
3804 bool SessionImpl::isFilenameExcluded(const QString &fileName) const
3805 {
3806     if (!isExcludedFileNamesEnabled())
3807         return false;
3808
3809     return std::any_of(m_excludedFileNamesRegExpList.begin(), m_excludedFileNamesRegExpList.end(), [&fileName](const QRegularExpression &re)
3810     {
3811         return re.match(fileName).hasMatch();
3812     });
3813 }
3814
3815 void SessionImpl::setBannedIPs(const QStringList &newList)
3816 {
3817     if (newList == m_bannedIPs)
3818         return; // do nothing
3819     // here filter out incorrect IP
3820     QStringList filteredList;
3821     for (const QString &ip : newList)
3822     {
3823         if (Utils::Net::isValidIP(ip))
3824         {
3825             // the same IPv6 addresses could be written in different forms;
3826             // QHostAddress::toString() result format follows RFC5952;
3827             // thus we avoid duplicate entries pointing to the same address
3828             filteredList << QHostAddress(ip).toString();
3829         }
3830         else
3831         {
3832             LogMsg(tr("Rejected invalid IP address while applying the list of banned IP addresses. IP: \"%1\"")
3833                    .arg(ip)
3834                 , Log::WARNING);
3835         }
3836     }
3837     // now we have to sort IPs and make them unique
3838     filteredList.sort();
3839     filteredList.removeDuplicates();
3840     // Again ensure that the new list is different from the stored one.
3841     if (filteredList == m_bannedIPs)
3842         return; // do nothing
3843     // store to session settings
3844     // also here we have to recreate filter list including 3rd party ban file
3845     // and install it again into m_session
3846     m_bannedIPs = filteredList;
3847     m_IPFilteringConfigured = false;
3848     configureDeferred();
3849 }
3850
3851 ResumeDataStorageType SessionImpl::resumeDataStorageType() const
3852 {
3853     return m_resumeDataStorageType;
3854 }
3855
3856 void SessionImpl::setResumeDataStorageType(const ResumeDataStorageType type)
3857 {
3858     m_resumeDataStorageType = type;
3859 }
3860
3861 QStringList SessionImpl::bannedIPs() const
3862 {
3863     return m_bannedIPs;
3864 }
3865
3866 bool SessionImpl::isRestored() const
3867 {
3868     return m_isRestored;
3869 }
3870
3871 int SessionImpl::maxConnectionsPerTorrent() const
3872 {
3873     return m_maxConnectionsPerTorrent;
3874 }
3875
3876 void SessionImpl::setMaxConnectionsPerTorrent(int max)
3877 {
3878     max = (max > 0) ? max : -1;
3879     if (max != maxConnectionsPerTorrent())
3880     {
3881         m_maxConnectionsPerTorrent = max;
3882
3883         for (const TorrentImpl *torrent : asConst(m_torrents))
3884         {
3885             try
3886             {
3887                 torrent->nativeHandle().set_max_connections(max);
3888             }
3889             catch (const std::exception &) {}
3890         }
3891     }
3892 }
3893
3894 int SessionImpl::maxUploadsPerTorrent() const
3895 {
3896     return m_maxUploadsPerTorrent;
3897 }
3898
3899 void SessionImpl::setMaxUploadsPerTorrent(int max)
3900 {
3901     max = (max > 0) ? max : -1;
3902     if (max != maxUploadsPerTorrent())
3903     {
3904         m_maxUploadsPerTorrent = max;
3905
3906         for (const TorrentImpl *torrent : asConst(m_torrents))
3907         {
3908             try
3909             {
3910                 torrent->nativeHandle().set_max_uploads(max);
3911             }
3912             catch (const std::exception &) {}
3913         }
3914     }
3915 }
3916
3917 bool SessionImpl::announceToAllTrackers() const
3918 {
3919     return m_announceToAllTrackers;
3920 }
3921
3922 void SessionImpl::setAnnounceToAllTrackers(const bool val)
3923 {
3924     if (val != m_announceToAllTrackers)
3925     {
3926         m_announceToAllTrackers = val;
3927         configureDeferred();
3928     }
3929 }
3930
3931 bool SessionImpl::announceToAllTiers() const
3932 {
3933     return m_announceToAllTiers;
3934 }
3935
3936 void SessionImpl::setAnnounceToAllTiers(const bool val)
3937 {
3938     if (val != m_announceToAllTiers)
3939     {
3940         m_announceToAllTiers = val;
3941         configureDeferred();
3942     }
3943 }
3944
3945 int SessionImpl::peerTurnover() const
3946 {
3947     return m_peerTurnover;
3948 }
3949
3950 void SessionImpl::setPeerTurnover(const int val)
3951 {
3952     if (val == m_peerTurnover)
3953         return;
3954
3955     m_peerTurnover = val;
3956     configureDeferred();
3957 }
3958
3959 int SessionImpl::peerTurnoverCutoff() const
3960 {
3961     return m_peerTurnoverCutoff;
3962 }
3963
3964 void SessionImpl::setPeerTurnoverCutoff(const int val)
3965 {
3966     if (val == m_peerTurnoverCutoff)
3967         return;
3968
3969     m_peerTurnoverCutoff = val;
3970     configureDeferred();
3971 }
3972
3973 int SessionImpl::peerTurnoverInterval() const
3974 {
3975     return m_peerTurnoverInterval;
3976 }
3977
3978 void SessionImpl::setPeerTurnoverInterval(const int val)
3979 {
3980     if (val == m_peerTurnoverInterval)
3981         return;
3982
3983     m_peerTurnoverInterval = val;
3984     configureDeferred();
3985 }
3986
3987 DiskIOType SessionImpl::diskIOType() const
3988 {
3989     return m_diskIOType;
3990 }
3991
3992 void SessionImpl::setDiskIOType(const DiskIOType type)
3993 {
3994     if (type != m_diskIOType)
3995     {
3996         m_diskIOType = type;
3997     }
3998 }
3999
4000 int SessionImpl::requestQueueSize() const
4001 {
4002     return m_requestQueueSize;
4003 }
4004
4005 void SessionImpl::setRequestQueueSize(const int val)
4006 {
4007     if (val == m_requestQueueSize)
4008         return;
4009
4010     m_requestQueueSize = val;
4011     configureDeferred();
4012 }
4013
4014 int SessionImpl::asyncIOThreads() const
4015 {
4016     return std::clamp(m_asyncIOThreads.get(), 1, 1024);
4017 }
4018
4019 void SessionImpl::setAsyncIOThreads(const int num)
4020 {
4021     if (num == m_asyncIOThreads)
4022         return;
4023
4024     m_asyncIOThreads = num;
4025     configureDeferred();
4026 }
4027
4028 int SessionImpl::hashingThreads() const
4029 {
4030     return std::clamp(m_hashingThreads.get(), 1, 1024);
4031 }
4032
4033 void SessionImpl::setHashingThreads(const int num)
4034 {
4035     if (num == m_hashingThreads)
4036         return;
4037
4038     m_hashingThreads = num;
4039     configureDeferred();
4040 }
4041
4042 int SessionImpl::filePoolSize() const
4043 {
4044     return m_filePoolSize;
4045 }
4046
4047 void SessionImpl::setFilePoolSize(const int size)
4048 {
4049     if (size == m_filePoolSize)
4050         return;
4051
4052     m_filePoolSize = size;
4053     configureDeferred();
4054 }
4055
4056 int SessionImpl::checkingMemUsage() const
4057 {
4058     return std::max(1, m_checkingMemUsage.get());
4059 }
4060
4061 void SessionImpl::setCheckingMemUsage(int size)
4062 {
4063     size = std::max(size, 1);
4064
4065     if (size == m_checkingMemUsage)
4066         return;
4067
4068     m_checkingMemUsage = size;
4069     configureDeferred();
4070 }
4071
4072 int SessionImpl::diskCacheSize() const
4073 {
4074 #ifdef QBT_APP_64BIT
4075     return std::min(m_diskCacheSize.get(), 33554431);  // 32768GiB
4076 #else
4077     // When build as 32bit binary, set the maximum at less than 2GB to prevent crashes
4078     // allocate 1536MiB and leave 512MiB to the rest of program data in RAM
4079     return std::min(m_diskCacheSize.get(), 1536);
4080 #endif
4081 }
4082
4083 void SessionImpl::setDiskCacheSize(int size)
4084 {
4085 #ifdef QBT_APP_64BIT
4086     size = std::min(size, 33554431);  // 32768GiB
4087 #else
4088     // allocate 1536MiB and leave 512MiB to the rest of program data in RAM
4089     size = std::min(size, 1536);
4090 #endif
4091     if (size != m_diskCacheSize)
4092     {
4093         m_diskCacheSize = size;
4094         configureDeferred();
4095     }
4096 }
4097
4098 int SessionImpl::diskCacheTTL() const
4099 {
4100     return m_diskCacheTTL;
4101 }
4102
4103 void SessionImpl::setDiskCacheTTL(const int ttl)
4104 {
4105     if (ttl != m_diskCacheTTL)
4106     {
4107         m_diskCacheTTL = ttl;
4108         configureDeferred();
4109     }
4110 }
4111
4112 qint64 SessionImpl::diskQueueSize() const
4113 {
4114     return m_diskQueueSize;
4115 }
4116
4117 void SessionImpl::setDiskQueueSize(const qint64 size)
4118 {
4119     if (size == m_diskQueueSize)
4120         return;
4121
4122     m_diskQueueSize = size;
4123     configureDeferred();
4124 }
4125
4126 DiskIOReadMode SessionImpl::diskIOReadMode() const
4127 {
4128     return m_diskIOReadMode;
4129 }
4130
4131 void SessionImpl::setDiskIOReadMode(const DiskIOReadMode mode)
4132 {
4133     if (mode == m_diskIOReadMode)
4134         return;
4135
4136     m_diskIOReadMode = mode;
4137     configureDeferred();
4138 }
4139
4140 DiskIOWriteMode SessionImpl::diskIOWriteMode() const
4141 {
4142     return m_diskIOWriteMode;
4143 }
4144
4145 void SessionImpl::setDiskIOWriteMode(const DiskIOWriteMode mode)
4146 {
4147     if (mode == m_diskIOWriteMode)
4148         return;
4149
4150     m_diskIOWriteMode = mode;
4151     configureDeferred();
4152 }
4153
4154 bool SessionImpl::isCoalesceReadWriteEnabled() const
4155 {
4156     return m_coalesceReadWriteEnabled;
4157 }
4158
4159 void SessionImpl::setCoalesceReadWriteEnabled(const bool enabled)
4160 {
4161     if (enabled == m_coalesceReadWriteEnabled) return;
4162
4163     m_coalesceReadWriteEnabled = enabled;
4164     configureDeferred();
4165 }
4166
4167 bool SessionImpl::isSuggestModeEnabled() const
4168 {
4169     return m_isSuggestMode;
4170 }
4171
4172 bool SessionImpl::usePieceExtentAffinity() const
4173 {
4174     return m_usePieceExtentAffinity;
4175 }
4176
4177 void SessionImpl::setPieceExtentAffinity(const bool enabled)
4178 {
4179     if (enabled == m_usePieceExtentAffinity) return;
4180
4181     m_usePieceExtentAffinity = enabled;
4182     configureDeferred();
4183 }
4184
4185 void SessionImpl::setSuggestMode(const bool mode)
4186 {
4187     if (mode == m_isSuggestMode) return;
4188
4189     m_isSuggestMode = mode;
4190     configureDeferred();
4191 }
4192
4193 int SessionImpl::sendBufferWatermark() const
4194 {
4195     return m_sendBufferWatermark;
4196 }
4197
4198 void SessionImpl::setSendBufferWatermark(const int value)
4199 {
4200     if (value == m_sendBufferWatermark) return;
4201
4202     m_sendBufferWatermark = value;
4203     configureDeferred();
4204 }
4205
4206 int SessionImpl::sendBufferLowWatermark() const
4207 {
4208     return m_sendBufferLowWatermark;
4209 }
4210
4211 void SessionImpl::setSendBufferLowWatermark(const int value)
4212 {
4213     if (value == m_sendBufferLowWatermark) return;
4214
4215     m_sendBufferLowWatermark = value;
4216     configureDeferred();
4217 }
4218
4219 int SessionImpl::sendBufferWatermarkFactor() const
4220 {
4221     return m_sendBufferWatermarkFactor;
4222 }
4223
4224 void SessionImpl::setSendBufferWatermarkFactor(const int value)
4225 {
4226     if (value == m_sendBufferWatermarkFactor) return;
4227
4228     m_sendBufferWatermarkFactor = value;
4229     configureDeferred();
4230 }
4231
4232 int SessionImpl::connectionSpeed() const
4233 {
4234     return m_connectionSpeed;
4235 }
4236
4237 void SessionImpl::setConnectionSpeed(const int value)
4238 {
4239     if (value == m_connectionSpeed) return;
4240
4241     m_connectionSpeed = value;
4242     configureDeferred();
4243 }
4244
4245 int SessionImpl::socketSendBufferSize() const
4246 {
4247     return m_socketSendBufferSize;
4248 }
4249
4250 void SessionImpl::setSocketSendBufferSize(const int value)
4251 {
4252     if (value == m_socketSendBufferSize)
4253         return;
4254
4255     m_socketSendBufferSize = value;
4256     configureDeferred();
4257 }
4258
4259 int SessionImpl::socketReceiveBufferSize() const
4260 {
4261     return m_socketReceiveBufferSize;
4262 }
4263
4264 void SessionImpl::setSocketReceiveBufferSize(const int value)
4265 {
4266     if (value == m_socketReceiveBufferSize)
4267         return;
4268
4269     m_socketReceiveBufferSize = value;
4270     configureDeferred();
4271 }
4272
4273 int SessionImpl::socketBacklogSize() const
4274 {
4275     return m_socketBacklogSize;
4276 }
4277
4278 void SessionImpl::setSocketBacklogSize(const int value)
4279 {
4280     if (value == m_socketBacklogSize) return;
4281
4282     m_socketBacklogSize = value;
4283     configureDeferred();
4284 }
4285
4286 bool SessionImpl::isAnonymousModeEnabled() const
4287 {
4288     return m_isAnonymousModeEnabled;
4289 }
4290
4291 void SessionImpl::setAnonymousModeEnabled(const bool enabled)
4292 {
4293     if (enabled != m_isAnonymousModeEnabled)
4294     {
4295         m_isAnonymousModeEnabled = enabled;
4296         configureDeferred();
4297         LogMsg(tr("Anonymous mode: %1").arg(isAnonymousModeEnabled() ? tr("ON") : tr("OFF"))
4298             , Log::INFO);
4299     }
4300 }
4301
4302 bool SessionImpl::isQueueingSystemEnabled() const
4303 {
4304     return m_isQueueingEnabled;
4305 }
4306
4307 void SessionImpl::setQueueingSystemEnabled(const bool enabled)
4308 {
4309     if (enabled != m_isQueueingEnabled)
4310     {
4311         m_isQueueingEnabled = enabled;
4312         configureDeferred();
4313
4314         if (enabled)
4315             m_torrentsQueueChanged = true;
4316         else
4317             removeTorrentsQueue();
4318     }
4319 }
4320
4321 int SessionImpl::maxActiveDownloads() const
4322 {
4323     return m_maxActiveDownloads;
4324 }
4325
4326 void SessionImpl::setMaxActiveDownloads(int max)
4327 {
4328     max = std::max(max, -1);
4329     if (max != m_maxActiveDownloads)
4330     {
4331         m_maxActiveDownloads = max;
4332         configureDeferred();
4333     }
4334 }
4335
4336 int SessionImpl::maxActiveUploads() const
4337 {
4338     return m_maxActiveUploads;
4339 }
4340
4341 void SessionImpl::setMaxActiveUploads(int max)
4342 {
4343     max = std::max(max, -1);
4344     if (max != m_maxActiveUploads)
4345     {
4346         m_maxActiveUploads = max;
4347         configureDeferred();
4348     }
4349 }
4350
4351 int SessionImpl::maxActiveTorrents() const
4352 {
4353     return m_maxActiveTorrents;
4354 }
4355
4356 void SessionImpl::setMaxActiveTorrents(int max)
4357 {
4358     max = std::max(max, -1);
4359     if (max != m_maxActiveTorrents)
4360     {
4361         m_maxActiveTorrents = max;
4362         configureDeferred();
4363     }
4364 }
4365
4366 bool SessionImpl::ignoreSlowTorrentsForQueueing() const
4367 {
4368     return m_ignoreSlowTorrentsForQueueing;
4369 }
4370
4371 void SessionImpl::setIgnoreSlowTorrentsForQueueing(const bool ignore)
4372 {
4373     if (ignore != m_ignoreSlowTorrentsForQueueing)
4374     {
4375         m_ignoreSlowTorrentsForQueueing = ignore;
4376         configureDeferred();
4377     }
4378 }
4379
4380 int SessionImpl::downloadRateForSlowTorrents() const
4381 {
4382     return m_downloadRateForSlowTorrents;
4383 }
4384
4385 void SessionImpl::setDownloadRateForSlowTorrents(const int rateInKibiBytes)
4386 {
4387     if (rateInKibiBytes == m_downloadRateForSlowTorrents)
4388         return;
4389
4390     m_downloadRateForSlowTorrents = rateInKibiBytes;
4391     configureDeferred();
4392 }
4393
4394 int SessionImpl::uploadRateForSlowTorrents() const
4395 {
4396     return m_uploadRateForSlowTorrents;
4397 }
4398
4399 void SessionImpl::setUploadRateForSlowTorrents(const int rateInKibiBytes)
4400 {
4401     if (rateInKibiBytes == m_uploadRateForSlowTorrents)
4402         return;
4403
4404     m_uploadRateForSlowTorrents = rateInKibiBytes;
4405     configureDeferred();
4406 }
4407
4408 int SessionImpl::slowTorrentsInactivityTimer() const
4409 {
4410     return m_slowTorrentsInactivityTimer;
4411 }
4412
4413 void SessionImpl::setSlowTorrentsInactivityTimer(const int timeInSeconds)
4414 {
4415     if (timeInSeconds == m_slowTorrentsInactivityTimer)
4416         return;
4417
4418     m_slowTorrentsInactivityTimer = timeInSeconds;
4419     configureDeferred();
4420 }
4421
4422 int SessionImpl::outgoingPortsMin() const
4423 {
4424     return m_outgoingPortsMin;
4425 }
4426
4427 void SessionImpl::setOutgoingPortsMin(const int min)
4428 {
4429     if (min != m_outgoingPortsMin)
4430     {
4431         m_outgoingPortsMin = min;
4432         configureDeferred();
4433     }
4434 }
4435
4436 int SessionImpl::outgoingPortsMax() const
4437 {
4438     return m_outgoingPortsMax;
4439 }
4440
4441 void SessionImpl::setOutgoingPortsMax(const int max)
4442 {
4443     if (max != m_outgoingPortsMax)
4444     {
4445         m_outgoingPortsMax = max;
4446         configureDeferred();
4447     }
4448 }
4449
4450 int SessionImpl::UPnPLeaseDuration() const
4451 {
4452     return m_UPnPLeaseDuration;
4453 }
4454
4455 void SessionImpl::setUPnPLeaseDuration(const int duration)
4456 {
4457     if (duration != m_UPnPLeaseDuration)
4458     {
4459         m_UPnPLeaseDuration = duration;
4460         configureDeferred();
4461     }
4462 }
4463
4464 int SessionImpl::peerToS() const
4465 {
4466     return m_peerToS;
4467 }
4468
4469 void SessionImpl::setPeerToS(const int value)
4470 {
4471     if (value == m_peerToS)
4472         return;
4473
4474     m_peerToS = value;
4475     configureDeferred();
4476 }
4477
4478 bool SessionImpl::ignoreLimitsOnLAN() const
4479 {
4480     return m_ignoreLimitsOnLAN;
4481 }
4482
4483 void SessionImpl::setIgnoreLimitsOnLAN(const bool ignore)
4484 {
4485     if (ignore != m_ignoreLimitsOnLAN)
4486     {
4487         m_ignoreLimitsOnLAN = ignore;
4488         configureDeferred();
4489     }
4490 }
4491
4492 bool SessionImpl::includeOverheadInLimits() const
4493 {
4494     return m_includeOverheadInLimits;
4495 }
4496
4497 void SessionImpl::setIncludeOverheadInLimits(const bool include)
4498 {
4499     if (include != m_includeOverheadInLimits)
4500     {
4501         m_includeOverheadInLimits = include;
4502         configureDeferred();
4503     }
4504 }
4505
4506 QString SessionImpl::announceIP() const
4507 {
4508     return m_announceIP;
4509 }
4510
4511 void SessionImpl::setAnnounceIP(const QString &ip)
4512 {
4513     if (ip != m_announceIP)
4514     {
4515         m_announceIP = ip;
4516         configureDeferred();
4517     }
4518 }
4519
4520 int SessionImpl::maxConcurrentHTTPAnnounces() const
4521 {
4522     return m_maxConcurrentHTTPAnnounces;
4523 }
4524
4525 void SessionImpl::setMaxConcurrentHTTPAnnounces(const int value)
4526 {
4527     if (value == m_maxConcurrentHTTPAnnounces)
4528         return;
4529
4530     m_maxConcurrentHTTPAnnounces = value;
4531     configureDeferred();
4532 }
4533
4534 bool SessionImpl::isReannounceWhenAddressChangedEnabled() const
4535 {
4536     return m_isReannounceWhenAddressChangedEnabled;
4537 }
4538
4539 void SessionImpl::setReannounceWhenAddressChangedEnabled(const bool enabled)
4540 {
4541     if (enabled == m_isReannounceWhenAddressChangedEnabled)
4542         return;
4543
4544     m_isReannounceWhenAddressChangedEnabled = enabled;
4545 }
4546
4547 void SessionImpl::reannounceToAllTrackers() const
4548 {
4549     for (const TorrentImpl *torrent : asConst(m_torrents))
4550     {
4551         try
4552         {
4553             torrent->nativeHandle().force_reannounce(0, -1, lt::torrent_handle::ignore_min_interval);
4554         }
4555         catch (const std::exception &) {}
4556     }
4557 }
4558
4559 int SessionImpl::stopTrackerTimeout() const
4560 {
4561     return m_stopTrackerTimeout;
4562 }
4563
4564 void SessionImpl::setStopTrackerTimeout(const int value)
4565 {
4566     if (value == m_stopTrackerTimeout)
4567         return;
4568
4569     m_stopTrackerTimeout = value;
4570     configureDeferred();
4571 }
4572
4573 int SessionImpl::maxConnections() const
4574 {
4575     return m_maxConnections;
4576 }
4577
4578 void SessionImpl::setMaxConnections(int max)
4579 {
4580     max = (max > 0) ? max : -1;
4581     if (max != m_maxConnections)
4582     {
4583         m_maxConnections = max;
4584         configureDeferred();
4585     }
4586 }
4587
4588 int SessionImpl::maxUploads() const
4589 {
4590     return m_maxUploads;
4591 }
4592
4593 void SessionImpl::setMaxUploads(int max)
4594 {
4595     max = (max > 0) ? max : -1;
4596     if (max != m_maxUploads)
4597     {
4598         m_maxUploads = max;
4599         configureDeferred();
4600     }
4601 }
4602
4603 BTProtocol SessionImpl::btProtocol() const
4604 {
4605     return m_btProtocol;
4606 }
4607
4608 void SessionImpl::setBTProtocol(const BTProtocol protocol)
4609 {
4610     if ((protocol < BTProtocol::Both) || (BTProtocol::UTP < protocol))
4611         return;
4612
4613     if (protocol == m_btProtocol) return;
4614
4615     m_btProtocol = protocol;
4616     configureDeferred();
4617 }
4618
4619 bool SessionImpl::isUTPRateLimited() const
4620 {
4621     return m_isUTPRateLimited;
4622 }
4623
4624 void SessionImpl::setUTPRateLimited(const bool limited)
4625 {
4626     if (limited != m_isUTPRateLimited)
4627     {
4628         m_isUTPRateLimited = limited;
4629         configureDeferred();
4630     }
4631 }
4632
4633 MixedModeAlgorithm SessionImpl::utpMixedMode() const
4634 {
4635     return m_utpMixedMode;
4636 }
4637
4638 void SessionImpl::setUtpMixedMode(const MixedModeAlgorithm mode)
4639 {
4640     if (mode == m_utpMixedMode) return;
4641
4642     m_utpMixedMode = mode;
4643     configureDeferred();
4644 }
4645
4646 bool SessionImpl::isIDNSupportEnabled() const
4647 {
4648     return m_IDNSupportEnabled;
4649 }
4650
4651 void SessionImpl::setIDNSupportEnabled(const bool enabled)
4652 {
4653     if (enabled == m_IDNSupportEnabled) return;
4654
4655     m_IDNSupportEnabled = enabled;
4656     configureDeferred();
4657 }
4658
4659 bool SessionImpl::multiConnectionsPerIpEnabled() const
4660 {
4661     return m_multiConnectionsPerIpEnabled;
4662 }
4663
4664 void SessionImpl::setMultiConnectionsPerIpEnabled(const bool enabled)
4665 {
4666     if (enabled == m_multiConnectionsPerIpEnabled) return;
4667
4668     m_multiConnectionsPerIpEnabled = enabled;
4669     configureDeferred();
4670 }
4671
4672 bool SessionImpl::validateHTTPSTrackerCertificate() const
4673 {
4674     return m_validateHTTPSTrackerCertificate;
4675 }
4676
4677 void SessionImpl::setValidateHTTPSTrackerCertificate(const bool enabled)
4678 {
4679     if (enabled == m_validateHTTPSTrackerCertificate) return;
4680
4681     m_validateHTTPSTrackerCertificate = enabled;
4682     configureDeferred();
4683 }
4684
4685 bool SessionImpl::isSSRFMitigationEnabled() const
4686 {
4687     return m_SSRFMitigationEnabled;
4688 }
4689
4690 void SessionImpl::setSSRFMitigationEnabled(const bool enabled)
4691 {
4692     if (enabled == m_SSRFMitigationEnabled) return;
4693
4694     m_SSRFMitigationEnabled = enabled;
4695     configureDeferred();
4696 }
4697
4698 bool SessionImpl::blockPeersOnPrivilegedPorts() const
4699 {
4700     return m_blockPeersOnPrivilegedPorts;
4701 }
4702
4703 void SessionImpl::setBlockPeersOnPrivilegedPorts(const bool enabled)
4704 {
4705     if (enabled == m_blockPeersOnPrivilegedPorts) return;
4706
4707     m_blockPeersOnPrivilegedPorts = enabled;
4708     configureDeferred();
4709 }
4710
4711 bool SessionImpl::isTrackerFilteringEnabled() const
4712 {
4713     return m_isTrackerFilteringEnabled;
4714 }
4715
4716 void SessionImpl::setTrackerFilteringEnabled(const bool enabled)
4717 {
4718     if (enabled != m_isTrackerFilteringEnabled)
4719     {
4720         m_isTrackerFilteringEnabled = enabled;
4721         configureDeferred();
4722     }
4723 }
4724
4725 bool SessionImpl::isListening() const
4726 {
4727     return m_nativeSessionExtension->isSessionListening();
4728 }
4729
4730 MaxRatioAction SessionImpl::maxRatioAction() const
4731 {
4732     return static_cast<MaxRatioAction>(m_maxRatioAction.get());
4733 }
4734
4735 void SessionImpl::setMaxRatioAction(const MaxRatioAction act)
4736 {
4737     m_maxRatioAction = static_cast<int>(act);
4738 }
4739
4740 bool SessionImpl::isKnownTorrent(const InfoHash &infoHash) const
4741 {
4742     const bool isHybrid = infoHash.isHybrid();
4743     const auto id = TorrentID::fromInfoHash(infoHash);
4744     // alternative ID can be useful to find existing torrent
4745     // in case if hybrid torrent was added by v1 info hash
4746     const auto altID = (isHybrid ? TorrentID::fromSHA1Hash(infoHash.v1()) : TorrentID());
4747
4748     if (m_loadingTorrents.contains(id) || (isHybrid && m_loadingTorrents.contains(altID)))
4749         return true;
4750     if (m_downloadedMetadata.contains(id) || (isHybrid && m_downloadedMetadata.contains(altID)))
4751         return true;
4752     return findTorrent(infoHash);
4753 }
4754
4755 void SessionImpl::updateSeedingLimitTimer()
4756 {
4757     if ((globalMaxRatio() == Torrent::NO_RATIO_LIMIT) && !hasPerTorrentRatioLimit()
4758         && (globalMaxSeedingMinutes() == Torrent::NO_SEEDING_TIME_LIMIT) && !hasPerTorrentSeedingTimeLimit())
4759         {
4760         if (m_seedingLimitTimer->isActive())
4761             m_seedingLimitTimer->stop();
4762     }
4763     else if (!m_seedingLimitTimer->isActive())
4764     {
4765         m_seedingLimitTimer->start();
4766     }
4767 }
4768
4769 void SessionImpl::handleTorrentShareLimitChanged(TorrentImpl *const)
4770 {
4771     updateSeedingLimitTimer();
4772 }
4773
4774 void SessionImpl::handleTorrentNameChanged(TorrentImpl *const)
4775 {
4776 }
4777
4778 void SessionImpl::handleTorrentSavePathChanged(TorrentImpl *const torrent)
4779 {
4780     emit torrentSavePathChanged(torrent);
4781 }
4782
4783 void SessionImpl::handleTorrentCategoryChanged(TorrentImpl *const torrent, const QString &oldCategory)
4784 {
4785     emit torrentCategoryChanged(torrent, oldCategory);
4786 }
4787
4788 void SessionImpl::handleTorrentTagAdded(TorrentImpl *const torrent, const QString &tag)
4789 {
4790     emit torrentTagAdded(torrent, tag);
4791 }
4792
4793 void SessionImpl::handleTorrentTagRemoved(TorrentImpl *const torrent, const QString &tag)
4794 {
4795     emit torrentTagRemoved(torrent, tag);
4796 }
4797
4798 void SessionImpl::handleTorrentSavingModeChanged(TorrentImpl *const torrent)
4799 {
4800     emit torrentSavingModeChanged(torrent);
4801 }
4802
4803 void SessionImpl::handleTorrentTrackersAdded(TorrentImpl *const torrent, const QVector<TrackerEntry> &newTrackers)
4804 {
4805     for (const TrackerEntry &newTracker : newTrackers)
4806         LogMsg(tr("Added tracker to torrent. Torrent: \"%1\". Tracker: \"%2\"").arg(torrent->name(), newTracker.url));
4807     emit trackersAdded(torrent, newTrackers);
4808     if (torrent->trackers().size() == newTrackers.size())
4809         emit trackerlessStateChanged(torrent, false);
4810     emit trackersChanged(torrent);
4811 }
4812
4813 void SessionImpl::handleTorrentTrackersRemoved(TorrentImpl *const torrent, const QStringList &deletedTrackers)
4814 {
4815     for (const QString &deletedTracker : deletedTrackers)
4816         LogMsg(tr("Removed tracker from torrent. Torrent: \"%1\". Tracker: \"%2\"").arg(torrent->name(), deletedTracker));
4817     emit trackersRemoved(torrent, deletedTrackers);
4818     if (torrent->trackers().isEmpty())
4819         emit trackerlessStateChanged(torrent, true);
4820     emit trackersChanged(torrent);
4821 }
4822
4823 void SessionImpl::handleTorrentTrackersChanged(TorrentImpl *const torrent)
4824 {
4825     emit trackersChanged(torrent);
4826 }
4827
4828 void SessionImpl::handleTorrentUrlSeedsAdded(TorrentImpl *const torrent, const QVector<QUrl> &newUrlSeeds)
4829 {
4830     for (const QUrl &newUrlSeed : newUrlSeeds)
4831         LogMsg(tr("Added URL seed to torrent. Torrent: \"%1\". URL: \"%2\"").arg(torrent->name(), newUrlSeed.toString()));
4832 }
4833
4834 void SessionImpl::handleTorrentUrlSeedsRemoved(TorrentImpl *const torrent, const QVector<QUrl> &urlSeeds)
4835 {
4836     for (const QUrl &urlSeed : urlSeeds)
4837         LogMsg(tr("Removed URL seed from torrent. Torrent: \"%1\". URL: \"%2\"").arg(torrent->name(), urlSeed.toString()));
4838 }
4839
4840 void SessionImpl::handleTorrentMetadataReceived(TorrentImpl *const torrent)
4841 {
4842     if (!torrentExportDirectory().isEmpty())
4843         exportTorrentFile(torrent, torrentExportDirectory());
4844
4845     emit torrentMetadataReceived(torrent);
4846 }
4847
4848 void SessionImpl::handleTorrentPaused(TorrentImpl *const torrent)
4849 {
4850     LogMsg(tr("Torrent paused. Torrent: \"%1\"").arg(torrent->name()));
4851     emit torrentPaused(torrent);
4852 }
4853
4854 void SessionImpl::handleTorrentResumed(TorrentImpl *const torrent)
4855 {
4856     LogMsg(tr("Torrent resumed. Torrent: \"%1\"").arg(torrent->name()));
4857     emit torrentResumed(torrent);
4858 }
4859
4860 void SessionImpl::handleTorrentChecked(TorrentImpl *const torrent)
4861 {
4862     emit torrentFinishedChecking(torrent);
4863 }
4864
4865 void SessionImpl::handleTorrentFinished(TorrentImpl *const torrent)
4866 {
4867     LogMsg(tr("Torrent download finished. Torrent: \"%1\"").arg(torrent->name()));
4868     emit torrentFinished(torrent);
4869
4870     if (const Path exportPath = finishedTorrentExportDirectory(); !exportPath.isEmpty())
4871         exportTorrentFile(torrent, exportPath);
4872
4873     // Check whether it contains .torrent files
4874     for (const Path &torrentRelpath : asConst(torrent->filePaths()))
4875     {
4876         if (torrentRelpath.hasExtension(u".torrent"_qs))
4877         {
4878             emit recursiveTorrentDownloadPossible(torrent);
4879             break;
4880         }
4881     }
4882
4883     const bool hasUnfinishedTorrents = std::any_of(m_torrents.cbegin(), m_torrents.cend(), [](const TorrentImpl *torrent)
4884     {
4885         return !(torrent->isFinished() || torrent->isPaused() || torrent->isErrored());
4886     });
4887     if (!hasUnfinishedTorrents)
4888         emit allTorrentsFinished();
4889 }
4890
4891 void SessionImpl::handleTorrentResumeDataReady(TorrentImpl *const torrent, const LoadTorrentParams &data)
4892 {
4893     --m_numResumeData;
4894
4895     m_resumeDataStorage->store(torrent->id(), data);
4896     const auto iter = m_changedTorrentIDs.find(torrent->id());
4897     if (iter != m_changedTorrentIDs.end())
4898     {
4899         m_resumeDataStorage->remove(iter.value());
4900         m_changedTorrentIDs.erase(iter);
4901     }
4902 }
4903
4904 void SessionImpl::handleTorrentInfoHashChanged(TorrentImpl *torrent, const InfoHash &prevInfoHash)
4905 {
4906     Q_ASSERT(torrent->infoHash().isHybrid());
4907
4908     m_hybridTorrentsByAltID.insert(TorrentID::fromSHA1Hash(torrent->infoHash().v1()), torrent);
4909
4910     const auto prevID = TorrentID::fromInfoHash(prevInfoHash);
4911     const TorrentID currentID = torrent->id();
4912     if (currentID != prevID)
4913     {
4914         m_torrents[torrent->id()] = m_torrents.take(prevID);
4915         m_changedTorrentIDs[torrent->id()] = prevID;
4916     }
4917 }
4918
4919 bool SessionImpl::addMoveTorrentStorageJob(TorrentImpl *torrent, const Path &newPath, const MoveStorageMode mode, const MoveStorageContext context)
4920 {
4921     Q_ASSERT(torrent);
4922
4923     const lt::torrent_handle torrentHandle = torrent->nativeHandle();
4924     const Path currentLocation = torrent->actualStorageLocation();
4925     const bool torrentHasActiveJob = !m_moveStorageQueue.isEmpty() && (m_moveStorageQueue.first().torrentHandle == torrentHandle);
4926
4927     if (m_moveStorageQueue.size() > 1)
4928     {
4929         auto iter = std::find_if((m_moveStorageQueue.begin() + 1), m_moveStorageQueue.end()
4930                 , [&torrentHandle](const MoveStorageJob &job)
4931         {
4932             return job.torrentHandle == torrentHandle;
4933         });
4934
4935         if (iter != m_moveStorageQueue.end())
4936         {
4937             // remove existing inactive job
4938             torrent->handleMoveStorageJobFinished(currentLocation, iter->context, torrentHasActiveJob);
4939             LogMsg(tr("Torrent move canceled. Torrent: \"%1\". Source: \"%2\". Destination: \"%3\"").arg(torrent->name(), currentLocation.toString(), iter->path.toString()));
4940             m_moveStorageQueue.erase(iter);
4941         }
4942     }
4943
4944     if (torrentHasActiveJob)
4945     {
4946         // if there is active job for this torrent prevent creating meaningless
4947         // job that will move torrent to the same location as current one
4948         if (m_moveStorageQueue.first().path == newPath)
4949         {
4950             LogMsg(tr("Failed to enqueue torrent move. Torrent: \"%1\". Source: \"%2\". Destination: \"%3\". Reason: torrent is currently moving to the destination")
4951                    .arg(torrent->name(), currentLocation.toString(), newPath.toString()));
4952             return false;
4953         }
4954     }
4955     else
4956     {
4957         if (currentLocation == newPath)
4958         {
4959             LogMsg(tr("Failed to enqueue torrent move. Torrent: \"%1\". Source: \"%2\" Destination: \"%3\". Reason: both paths point to the same location")
4960                    .arg(torrent->name(), currentLocation.toString(), newPath.toString()));
4961             return false;
4962         }
4963     }
4964
4965     const MoveStorageJob moveStorageJob {torrentHandle, newPath, mode, context};
4966     m_moveStorageQueue << moveStorageJob;
4967     LogMsg(tr("Enqueued torrent move. Torrent: \"%1\". Source: \"%2\". Destination: \"%3\"").arg(torrent->name(), currentLocation.toString(), newPath.toString()));
4968
4969     if (m_moveStorageQueue.size() == 1)
4970         moveTorrentStorage(moveStorageJob);
4971
4972     return true;
4973 }
4974
4975 void SessionImpl::moveTorrentStorage(const MoveStorageJob &job) const
4976 {
4977 #ifdef QBT_USES_LIBTORRENT2
4978     const auto id = TorrentID::fromInfoHash(job.torrentHandle.info_hashes());
4979 #else
4980     const auto id = TorrentID::fromInfoHash(job.torrentHandle.info_hash());
4981 #endif
4982     const TorrentImpl *torrent = m_torrents.value(id);
4983     const QString torrentName = (torrent ? torrent->name() : id.toString());
4984     LogMsg(tr("Start moving torrent. Torrent: \"%1\". Destination: \"%2\"").arg(torrentName, job.path.toString()));
4985
4986     job.torrentHandle.move_storage(job.path.toString().toStdString(), toNative(job.mode));
4987 }
4988
4989 void SessionImpl::handleMoveTorrentStorageJobFinished(const Path &newPath)
4990 {
4991     const MoveStorageJob finishedJob = m_moveStorageQueue.takeFirst();
4992     if (!m_moveStorageQueue.isEmpty())
4993         moveTorrentStorage(m_moveStorageQueue.first());
4994
4995     const auto iter = std::find_if(m_moveStorageQueue.cbegin(), m_moveStorageQueue.cend()
4996             , [&finishedJob](const MoveStorageJob &job)
4997     {
4998         return job.torrentHandle == finishedJob.torrentHandle;
4999     });
5000
5001     const bool torrentHasOutstandingJob = (iter != m_moveStorageQueue.cend());
5002
5003     TorrentImpl *torrent = m_torrents.value(finishedJob.torrentHandle.info_hash());
5004     if (torrent)
5005     {
5006         torrent->handleMoveStorageJobFinished(newPath, finishedJob.context, torrentHasOutstandingJob);
5007     }
5008     else if (!torrentHasOutstandingJob)
5009     {
5010         // Last job is completed for torrent that being removing, so actually remove it
5011         const lt::torrent_handle nativeHandle {finishedJob.torrentHandle};
5012         const RemovingTorrentData &removingTorrentData = m_removingTorrents[nativeHandle.info_hash()];
5013         if (removingTorrentData.deleteOption == DeleteTorrent)
5014             m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_partfile);
5015     }
5016 }
5017
5018 void SessionImpl::storeCategories() const
5019 {
5020     QJsonObject jsonObj;
5021     for (auto it = m_categories.cbegin(); it != m_categories.cend(); ++it)
5022     {
5023         const QString &categoryName = it.key();
5024         const CategoryOptions &categoryOptions = it.value();
5025         jsonObj[categoryName] = categoryOptions.toJSON();
5026     }
5027
5028     const Path path = specialFolderLocation(SpecialFolder::Config) / CATEGORIES_FILE_NAME;
5029     const QByteArray data = QJsonDocument(jsonObj).toJson();
5030     const nonstd::expected<void, QString> result = Utils::IO::saveToFile(path, data);
5031     if (!result)
5032     {
5033         LogMsg(tr("Failed to save Categories configuration. File: \"%1\". Error: \"%2\"")
5034                .arg(path.toString(), result.error()), Log::WARNING);
5035     }
5036 }
5037
5038 void SessionImpl::upgradeCategories()
5039 {
5040     const auto legacyCategories = SettingValue<QVariantMap>(u"BitTorrent/Session/Categories"_qs).get();
5041     for (auto it = legacyCategories.cbegin(); it != legacyCategories.cend(); ++it)
5042     {
5043         const QString &categoryName = it.key();
5044         CategoryOptions categoryOptions;
5045         categoryOptions.savePath = Path(it.value().toString());
5046         m_categories[categoryName] = categoryOptions;
5047     }
5048
5049     storeCategories();
5050 }
5051
5052 void SessionImpl::loadCategories()
5053 {
5054     m_categories.clear();
5055
5056     QFile confFile {(specialFolderLocation(SpecialFolder::Config) / CATEGORIES_FILE_NAME).data()};
5057     if (!confFile.exists())
5058     {
5059         // TODO: Remove the following upgrade code in v4.5
5060         // == BEGIN UPGRADE CODE ==
5061         upgradeCategories();
5062         m_needUpgradeDownloadPath = true;
5063         // == END UPGRADE CODE ==
5064
5065 //        return;
5066     }
5067
5068     if (!confFile.open(QFile::ReadOnly))
5069     {
5070         LogMsg(tr("Failed to load Categories. File: \"%1\". Error: \"%2\"")
5071                .arg(confFile.fileName(), confFile.errorString()), Log::CRITICAL);
5072         return;
5073     }
5074
5075     QJsonParseError jsonError;
5076     const QJsonDocument jsonDoc = QJsonDocument::fromJson(confFile.readAll(), &jsonError);
5077     if (jsonError.error != QJsonParseError::NoError)
5078     {
5079         LogMsg(tr("Failed to parse Categories configuration. File: \"%1\". Error: \"%2\"")
5080                .arg(confFile.fileName(), jsonError.errorString()), Log::WARNING);
5081         return;
5082     }
5083
5084     if (!jsonDoc.isObject())
5085     {
5086         LogMsg(tr("Failed to load Categories configuration. File: \"%1\". Reason: invalid data format")
5087                .arg(confFile.fileName()), Log::WARNING);
5088         return;
5089     }
5090
5091     const QJsonObject jsonObj = jsonDoc.object();
5092     for (auto it = jsonObj.constBegin(); it != jsonObj.constEnd(); ++it)
5093     {
5094         const QString &categoryName = it.key();
5095         const auto categoryOptions = CategoryOptions::fromJSON(it.value().toObject());
5096         m_categories[categoryName] = categoryOptions;
5097     }
5098 }
5099
5100 bool SessionImpl::hasPerTorrentRatioLimit() const
5101 {
5102     return std::any_of(m_torrents.cbegin(), m_torrents.cend(), [](const TorrentImpl *torrent)
5103     {
5104         return (torrent->ratioLimit() >= 0);
5105     });
5106 }
5107
5108 bool SessionImpl::hasPerTorrentSeedingTimeLimit() const
5109 {
5110     return std::any_of(m_torrents.cbegin(), m_torrents.cend(), [](const TorrentImpl *torrent)
5111     {
5112         return (torrent->seedingTimeLimit() >= 0);
5113     });
5114 }
5115
5116 void SessionImpl::configureDeferred()
5117 {
5118     if (m_deferredConfigureScheduled)
5119         return;
5120
5121     m_deferredConfigureScheduled = true;
5122     QMetaObject::invokeMethod(this, qOverload<>(&SessionImpl::configure), Qt::QueuedConnection);
5123 }
5124
5125 // Enable IP Filtering
5126 // this method creates ban list from scratch combining user ban list and 3rd party ban list file
5127 void SessionImpl::enableIPFilter()
5128 {
5129     qDebug("Enabling IPFilter");
5130     // 1. Parse the IP filter
5131     // 2. In the slot add the manually banned IPs to the provided lt::ip_filter
5132     // 3. Set the ip_filter in one go so there isn't a time window where there isn't an ip_filter
5133     //    set between clearing the old one and setting the new one.
5134     if (!m_filterParser)
5135     {
5136         m_filterParser = new FilterParserThread(this);
5137         connect(m_filterParser.data(), &FilterParserThread::IPFilterParsed, this, &SessionImpl::handleIPFilterParsed);
5138         connect(m_filterParser.data(), &FilterParserThread::IPFilterError, this, &SessionImpl::handleIPFilterError);
5139     }
5140     m_filterParser->processFilterFile(IPFilterFile());
5141 }
5142
5143 // Disable IP Filtering
5144 void SessionImpl::disableIPFilter()
5145 {
5146     qDebug("Disabling IPFilter");
5147     if (m_filterParser)
5148     {
5149         disconnect(m_filterParser.data(), nullptr, this, nullptr);
5150         delete m_filterParser;
5151     }
5152
5153     // Add the banned IPs after the IPFilter disabling
5154     // which creates an empty filter and overrides all previously
5155     // applied bans.
5156     lt::ip_filter filter;
5157     processBannedIPs(filter);
5158     m_nativeSession->set_ip_filter(filter);
5159 }
5160
5161 void SessionImpl::recursiveTorrentDownload(const TorrentID &id)
5162 {
5163     const TorrentImpl *torrent = m_torrents.value(id);
5164     if (!torrent)
5165         return;
5166
5167     for (const Path &torrentRelpath : asConst(torrent->filePaths()))
5168     {
5169         if (torrentRelpath.hasExtension(u".torrent"_qs))
5170         {
5171             const Path torrentFullpath = torrent->savePath() / torrentRelpath;
5172
5173             LogMsg(tr("Recursive download .torrent file within torrent. Source torrent: \"%1\". File: \"%2\"")
5174                 .arg(torrent->name(), torrentFullpath.toString()));
5175
5176             AddTorrentParams params;
5177             // Passing the save path along to the sub torrent file
5178             params.savePath = torrent->savePath();
5179             const nonstd::expected<TorrentInfo, QString> loadResult = TorrentInfo::loadFromFile(torrentFullpath);
5180             if (loadResult)
5181             {
5182                 addTorrent(loadResult.value(), params);
5183             }
5184             else
5185             {
5186                 LogMsg(tr("Failed to load .torrent file within torrent. Source torrent: \"%1\". File: \"%2\". Error: \"%3\"")
5187                     .arg(torrent->name(), torrentFullpath.toString(), loadResult.error()), Log::WARNING);
5188             }
5189         }
5190     }
5191 }
5192
5193 const SessionStatus &SessionImpl::status() const
5194 {
5195     return m_status;
5196 }
5197
5198 const CacheStatus &SessionImpl::cacheStatus() const
5199 {
5200     return m_cacheStatus;
5201 }
5202
5203 void SessionImpl::enqueueRefresh()
5204 {
5205     Q_ASSERT(!m_refreshEnqueued);
5206
5207     QTimer::singleShot(refreshInterval(), Qt::CoarseTimer, this, [this]
5208     {
5209         m_nativeSession->post_torrent_updates();
5210         m_nativeSession->post_session_stats();
5211
5212         if (m_torrentsQueueChanged)
5213         {
5214             m_torrentsQueueChanged = false;
5215             m_needSaveTorrentsQueue = true;
5216         }
5217     });
5218
5219     m_refreshEnqueued = true;
5220 }
5221
5222 void SessionImpl::handleIPFilterParsed(const int ruleCount)
5223 {
5224     if (m_filterParser)
5225     {
5226         lt::ip_filter filter = m_filterParser->IPfilter();
5227         processBannedIPs(filter);
5228         m_nativeSession->set_ip_filter(filter);
5229     }
5230     LogMsg(tr("Successfully parsed the IP filter file. Number of rules applied: %1").arg(ruleCount));
5231     emit IPFilterParsed(false, ruleCount);
5232 }
5233
5234 void SessionImpl::handleIPFilterError()
5235 {
5236     lt::ip_filter filter;
5237     processBannedIPs(filter);
5238     m_nativeSession->set_ip_filter(filter);
5239
5240     LogMsg(tr("Failed to parse the IP filter file"), Log::WARNING);
5241     emit IPFilterParsed(true, 0);
5242 }
5243
5244 std::vector<lt::alert *> SessionImpl::getPendingAlerts(const lt::time_duration time) const
5245 {
5246     if (time > lt::time_duration::zero())
5247         m_nativeSession->wait_for_alert(time);
5248
5249     std::vector<lt::alert *> alerts;
5250     m_nativeSession->pop_alerts(&alerts);
5251     return alerts;
5252 }
5253
5254 TorrentContentLayout SessionImpl::torrentContentLayout() const
5255 {
5256     return m_torrentContentLayout;
5257 }
5258
5259 void SessionImpl::setTorrentContentLayout(const TorrentContentLayout value)
5260 {
5261     m_torrentContentLayout = value;
5262 }
5263
5264 // Read alerts sent by the BitTorrent session
5265 void SessionImpl::readAlerts()
5266 {
5267     const std::vector<lt::alert *> alerts = getPendingAlerts();
5268     handleAddTorrentAlerts(alerts);
5269     for (const lt::alert *a : alerts)
5270         handleAlert(a);
5271
5272     processTrackerStatuses();
5273 }
5274
5275 void SessionImpl::handleAddTorrentAlerts(const std::vector<lt::alert *> &alerts)
5276 {
5277     QVector<Torrent *> loadedTorrents;
5278     if (!isRestored())
5279         loadedTorrents.reserve(MAX_PROCESSING_RESUMEDATA_COUNT);
5280
5281     for (const lt::alert *a : alerts)
5282     {
5283         if (a->type() != lt::add_torrent_alert::alert_type)
5284             continue;
5285
5286         const auto *alert = static_cast<const lt::add_torrent_alert *>(a);
5287         if (alert->error)
5288         {
5289             const QString msg = QString::fromStdString(alert->message());
5290             LogMsg(tr("Failed to load torrent. Reason: \"%1\"").arg(msg), Log::WARNING);
5291             emit loadTorrentFailed(msg);
5292
5293             const lt::add_torrent_params &params = alert->params;
5294             const bool hasMetadata = (params.ti && params.ti->is_valid());
5295 #ifdef QBT_USES_LIBTORRENT2
5296             const InfoHash infoHash {(hasMetadata ? params.ti->info_hashes() : params.info_hashes)};
5297             if (infoHash.isHybrid())
5298                 m_hybridTorrentsByAltID.remove(TorrentID::fromSHA1Hash(infoHash.v1()));
5299 #else
5300             const InfoHash infoHash {(hasMetadata ? params.ti->info_hash() : params.info_hash)};
5301 #endif
5302             if (const auto loadingTorrentsIter = m_loadingTorrents.find(TorrentID::fromInfoHash(infoHash))
5303                     ; loadingTorrentsIter != m_loadingTorrents.end())
5304             {
5305                 m_loadingTorrents.erase(loadingTorrentsIter);
5306             }
5307             else if (const auto downloadedMetadataIter = m_downloadedMetadata.find(TorrentID::fromInfoHash(infoHash))
5308                      ; downloadedMetadataIter != m_downloadedMetadata.end())
5309             {
5310                 m_downloadedMetadata.erase(downloadedMetadataIter);
5311                 if (infoHash.isHybrid())
5312                 {
5313                     // index hybrid magnet links by both v1 and v2 info hashes
5314                     const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
5315                     m_downloadedMetadata.remove(altID);
5316                 }
5317             }
5318
5319             return;
5320         }
5321
5322
5323 #ifdef QBT_USES_LIBTORRENT2
5324         const InfoHash infoHash {alert->handle.info_hashes()};
5325 #else
5326         const InfoHash infoHash {alert->handle.info_hash()};
5327 #endif
5328         const auto torrentID = TorrentID::fromInfoHash(infoHash);
5329
5330         if (const auto loadingTorrentsIter = m_loadingTorrents.find(torrentID)
5331                 ; loadingTorrentsIter != m_loadingTorrents.end())
5332         {
5333             const LoadTorrentParams params = loadingTorrentsIter.value();
5334             m_loadingTorrents.erase(loadingTorrentsIter);
5335
5336             Torrent *torrent = createTorrent(alert->handle, params);
5337             loadedTorrents.append(torrent);
5338         }
5339         else if (const auto downloadedMetadataIter = m_downloadedMetadata.find(torrentID)
5340                  ; downloadedMetadataIter != m_downloadedMetadata.end())
5341         {
5342             downloadedMetadataIter.value() = alert->handle;
5343             if (infoHash.isHybrid())
5344             {
5345                 // index hybrid magnet links by both v1 and v2 info hashes
5346                 const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
5347                 m_downloadedMetadata[altID] = alert->handle;
5348             }
5349         }
5350     }
5351
5352     if (!loadedTorrents.isEmpty())
5353     {
5354         if (isRestored())
5355             m_torrentsQueueChanged = true;
5356         emit torrentsLoaded(loadedTorrents);
5357     }
5358 }
5359
5360 void SessionImpl::handleAlert(const lt::alert *a)
5361 {
5362     try
5363     {
5364         switch (a->type())
5365         {
5366 #ifdef QBT_USES_LIBTORRENT2
5367         case lt::file_prio_alert::alert_type:
5368 #endif
5369         case lt::file_renamed_alert::alert_type:
5370         case lt::file_rename_failed_alert::alert_type:
5371         case lt::file_completed_alert::alert_type:
5372         case lt::torrent_finished_alert::alert_type:
5373         case lt::save_resume_data_alert::alert_type:
5374         case lt::save_resume_data_failed_alert::alert_type:
5375         case lt::torrent_paused_alert::alert_type:
5376         case lt::torrent_resumed_alert::alert_type:
5377         case lt::fastresume_rejected_alert::alert_type:
5378         case lt::torrent_checked_alert::alert_type:
5379         case lt::metadata_received_alert::alert_type:
5380         case lt::performance_alert::alert_type:
5381             dispatchTorrentAlert(static_cast<const lt::torrent_alert *>(a));
5382             break;
5383         case lt::state_update_alert::alert_type:
5384             handleStateUpdateAlert(static_cast<const lt::state_update_alert*>(a));
5385             break;
5386         case lt::session_stats_alert::alert_type:
5387             handleSessionStatsAlert(static_cast<const lt::session_stats_alert*>(a));
5388             break;
5389         case lt::tracker_announce_alert::alert_type:
5390         case lt::tracker_error_alert::alert_type:
5391         case lt::tracker_reply_alert::alert_type:
5392         case lt::tracker_warning_alert::alert_type:
5393             handleTrackerAlert(static_cast<const lt::tracker_alert *>(a));
5394             break;
5395         case lt::file_error_alert::alert_type:
5396             handleFileErrorAlert(static_cast<const lt::file_error_alert*>(a));
5397             break;
5398         case lt::add_torrent_alert::alert_type:
5399             // handled separately
5400             break;
5401         case lt::torrent_removed_alert::alert_type:
5402             handleTorrentRemovedAlert(static_cast<const lt::torrent_removed_alert*>(a));
5403             break;
5404         case lt::torrent_deleted_alert::alert_type:
5405             handleTorrentDeletedAlert(static_cast<const lt::torrent_deleted_alert*>(a));
5406             break;
5407         case lt::torrent_delete_failed_alert::alert_type:
5408             handleTorrentDeleteFailedAlert(static_cast<const lt::torrent_delete_failed_alert*>(a));
5409             break;
5410         case lt::portmap_error_alert::alert_type:
5411             handlePortmapWarningAlert(static_cast<const lt::portmap_error_alert*>(a));
5412             break;
5413         case lt::portmap_alert::alert_type:
5414             handlePortmapAlert(static_cast<const lt::portmap_alert*>(a));
5415             break;
5416         case lt::peer_blocked_alert::alert_type:
5417             handlePeerBlockedAlert(static_cast<const lt::peer_blocked_alert*>(a));
5418             break;
5419         case lt::peer_ban_alert::alert_type:
5420             handlePeerBanAlert(static_cast<const lt::peer_ban_alert*>(a));
5421             break;
5422         case lt::url_seed_alert::alert_type:
5423             handleUrlSeedAlert(static_cast<const lt::url_seed_alert*>(a));
5424             break;
5425         case lt::listen_succeeded_alert::alert_type:
5426             handleListenSucceededAlert(static_cast<const lt::listen_succeeded_alert*>(a));
5427             break;
5428         case lt::listen_failed_alert::alert_type:
5429             handleListenFailedAlert(static_cast<const lt::listen_failed_alert*>(a));
5430             break;
5431         case lt::external_ip_alert::alert_type:
5432             handleExternalIPAlert(static_cast<const lt::external_ip_alert*>(a));
5433             break;
5434         case lt::alerts_dropped_alert::alert_type:
5435             handleAlertsDroppedAlert(static_cast<const lt::alerts_dropped_alert *>(a));
5436             break;
5437         case lt::storage_moved_alert::alert_type:
5438             handleStorageMovedAlert(static_cast<const lt::storage_moved_alert*>(a));
5439             break;
5440         case lt::storage_moved_failed_alert::alert_type:
5441             handleStorageMovedFailedAlert(static_cast<const lt::storage_moved_failed_alert*>(a));
5442             break;
5443         case lt::socks5_alert::alert_type:
5444             handleSocks5Alert(static_cast<const lt::socks5_alert *>(a));
5445             break;
5446 #ifdef QBT_USES_LIBTORRENT2
5447         case lt::torrent_conflict_alert::alert_type:
5448             handleTorrentConflictAlert(static_cast<const lt::torrent_conflict_alert *>(a));
5449             break;
5450 #endif
5451         }
5452     }
5453     catch (const std::exception &exc)
5454     {
5455         qWarning() << "Caught exception in " << Q_FUNC_INFO << ": " << QString::fromStdString(exc.what());
5456     }
5457 }
5458
5459 void SessionImpl::dispatchTorrentAlert(const lt::torrent_alert *a)
5460 {
5461     const TorrentID torrentID {a->handle.info_hash()};
5462     TorrentImpl *torrent = m_torrents.value(torrentID);
5463 #ifdef QBT_USES_LIBTORRENT2
5464     if (!torrent && (a->type() == lt::metadata_received_alert::alert_type))
5465     {
5466         const InfoHash infoHash {a->handle.info_hashes()};
5467         if (infoHash.isHybrid())
5468             torrent = m_torrents.value(TorrentID::fromSHA1Hash(infoHash.v1()));
5469     }
5470 #endif
5471
5472     if (torrent)
5473     {
5474         torrent->handleAlert(a);
5475         return;
5476     }
5477
5478     switch (a->type())
5479     {
5480     case lt::metadata_received_alert::alert_type:
5481         handleMetadataReceivedAlert(static_cast<const lt::metadata_received_alert *>(a));
5482         break;
5483     }
5484 }
5485
5486 TorrentImpl *SessionImpl::createTorrent(const lt::torrent_handle &nativeHandle, const LoadTorrentParams &params)
5487 {
5488     auto *const torrent = new TorrentImpl(this, m_nativeSession, nativeHandle, params);
5489     m_torrents.insert(torrent->id(), torrent);
5490     if (const InfoHash infoHash = torrent->infoHash(); infoHash.isHybrid())
5491         m_hybridTorrentsByAltID.insert(TorrentID::fromSHA1Hash(infoHash.v1()), torrent);
5492
5493     if (isRestored())
5494     {
5495         if (params.addToQueueTop)
5496             nativeHandle.queue_position_top();
5497
5498         torrent->saveResumeData(lt::torrent_handle::save_info_dict);
5499
5500         // The following is useless for newly added magnet
5501         if (torrent->hasMetadata())
5502         {
5503             if (!torrentExportDirectory().isEmpty())
5504                 exportTorrentFile(torrent, torrentExportDirectory());
5505         }
5506     }
5507
5508     if (((torrent->ratioLimit() >= 0) || (torrent->seedingTimeLimit() >= 0))
5509         && !m_seedingLimitTimer->isActive())
5510     {
5511         m_seedingLimitTimer->start();
5512     }
5513
5514     if (!isRestored())
5515     {
5516         LogMsg(tr("Restored torrent. Torrent: \"%1\"").arg(torrent->name()));
5517     }
5518     else
5519     {
5520         LogMsg(tr("Added new torrent. Torrent: \"%1\"").arg(torrent->name()));
5521         emit torrentAdded(torrent);
5522     }
5523
5524     // Torrent could have error just after adding to libtorrent
5525     if (torrent->hasError())
5526         LogMsg(tr("Torrent errored. Torrent: \"%1\". Error: \"%2\"").arg(torrent->name(), torrent->error()), Log::WARNING);
5527
5528     return torrent;
5529 }
5530
5531 void SessionImpl::handleTorrentRemovedAlert(const lt::torrent_removed_alert *p)
5532 {
5533 #ifdef QBT_USES_LIBTORRENT2
5534     const auto id = TorrentID::fromInfoHash(p->info_hashes);
5535 #else
5536     const auto id = TorrentID::fromInfoHash(p->info_hash);
5537 #endif
5538
5539     const auto removingTorrentDataIter = m_removingTorrents.find(id);
5540     if (removingTorrentDataIter != m_removingTorrents.end())
5541     {
5542         if (removingTorrentDataIter->deleteOption == DeleteTorrent)
5543         {
5544             LogMsg(tr("Removed torrent. Torrent: \"%1\"").arg(removingTorrentDataIter->name));
5545             m_removingTorrents.erase(removingTorrentDataIter);
5546         }
5547     }
5548 }
5549
5550 void SessionImpl::handleTorrentDeletedAlert(const lt::torrent_deleted_alert *p)
5551 {
5552 #ifdef QBT_USES_LIBTORRENT2
5553     const auto id = TorrentID::fromInfoHash(p->info_hashes);
5554 #else
5555     const auto id = TorrentID::fromInfoHash(p->info_hash);
5556 #endif
5557
5558     const auto removingTorrentDataIter = m_removingTorrents.find(id);
5559     if (removingTorrentDataIter == m_removingTorrents.end())
5560         return;
5561
5562     // torrent_deleted_alert can also be posted due to deletion of partfile. Ignore it in such a case.
5563     if (removingTorrentDataIter->deleteOption == DeleteTorrent)
5564         return;
5565
5566     Utils::Fs::smartRemoveEmptyFolderTree(removingTorrentDataIter->pathToRemove);
5567     LogMsg(tr("Removed torrent and deleted its content. Torrent: \"%1\"").arg(removingTorrentDataIter->name));
5568     m_removingTorrents.erase(removingTorrentDataIter);
5569 }
5570
5571 void SessionImpl::handleTorrentDeleteFailedAlert(const lt::torrent_delete_failed_alert *p)
5572 {
5573 #ifdef QBT_USES_LIBTORRENT2
5574     const auto id = TorrentID::fromInfoHash(p->info_hashes);
5575 #else
5576     const auto id = TorrentID::fromInfoHash(p->info_hash);
5577 #endif
5578
5579     const auto removingTorrentDataIter = m_removingTorrents.find(id);
5580     if (removingTorrentDataIter == m_removingTorrents.end())
5581         return;
5582
5583     if (p->error)
5584     {
5585         // libtorrent won't delete the directory if it contains files not listed in the torrent,
5586         // so we remove the directory ourselves
5587         Utils::Fs::smartRemoveEmptyFolderTree(removingTorrentDataIter->pathToRemove);
5588
5589         LogMsg(tr("Removed torrent but failed to delete its content and/or partfile. Torrent: \"%1\". Error: \"%2\"")
5590                 .arg(removingTorrentDataIter->name, QString::fromLocal8Bit(p->error.message().c_str()))
5591             , Log::WARNING);
5592     }
5593     else // torrent without metadata, hence no files on disk
5594     {
5595         LogMsg(tr("Removed torrent. Torrent: \"%1\"").arg(removingTorrentDataIter->name));
5596     }
5597
5598     m_removingTorrents.erase(removingTorrentDataIter);
5599 }
5600
5601 void SessionImpl::handleMetadataReceivedAlert(const lt::metadata_received_alert *p)
5602 {
5603     const TorrentID torrentID {p->handle.info_hash()};
5604
5605     bool found = false;
5606     if (const auto iter = m_downloadedMetadata.find(torrentID); iter != m_downloadedMetadata.end())
5607     {
5608         found = true;
5609         m_downloadedMetadata.erase(iter);
5610     }
5611 #ifdef QBT_USES_LIBTORRENT2
5612     const InfoHash infoHash {p->handle.info_hashes()};
5613     if (infoHash.isHybrid())
5614     {
5615         const auto altID = TorrentID::fromSHA1Hash(infoHash.v1());
5616         if (const auto iter = m_downloadedMetadata.find(altID); iter != m_downloadedMetadata.end())
5617         {
5618             found = true;
5619             m_downloadedMetadata.erase(iter);
5620         }
5621     }
5622 #endif
5623     if (found)
5624     {
5625         const TorrentInfo metadata {*p->handle.torrent_file()};
5626         m_nativeSession->remove_torrent(p->handle, lt::session::delete_files);
5627
5628         emit metadataDownloaded(metadata);
5629     }
5630 }
5631
5632 void SessionImpl::handleFileErrorAlert(const lt::file_error_alert *p)
5633 {
5634     TorrentImpl *const torrent = m_torrents.value(p->handle.info_hash());
5635     if (!torrent)
5636         return;
5637
5638     torrent->handleAlert(p);
5639
5640     const TorrentID id = torrent->id();
5641     if (!m_recentErroredTorrents.contains(id))
5642     {
5643         m_recentErroredTorrents.insert(id);
5644
5645         const QString msg = QString::fromStdString(p->message());
5646         LogMsg(tr("File error alert. Torrent: \"%1\". File: \"%2\". Reason: \"%3\"")
5647                 .arg(torrent->name(), QString::fromLocal8Bit(p->filename()), msg)
5648             , Log::WARNING);
5649         emit fullDiskError(torrent, msg);
5650     }
5651
5652     m_recentErroredTorrentsTimer->start();
5653 }
5654
5655 void SessionImpl::handlePortmapWarningAlert(const lt::portmap_error_alert *p)
5656 {
5657     LogMsg(tr("UPnP/NAT-PMP port mapping failed. Message: \"%1\"").arg(QString::fromStdString(p->message())), Log::WARNING);
5658 }
5659
5660 void SessionImpl::handlePortmapAlert(const lt::portmap_alert *p)
5661 {
5662     qDebug("UPnP Success, msg: %s", p->message().c_str());
5663     LogMsg(tr("UPnP/NAT-PMP port mapping succeeded. Message: \"%1\"").arg(QString::fromStdString(p->message())), Log::INFO);
5664 }
5665
5666 void SessionImpl::handlePeerBlockedAlert(const lt::peer_blocked_alert *p)
5667 {
5668     QString reason;
5669     switch (p->reason)
5670     {
5671     case lt::peer_blocked_alert::ip_filter:
5672         reason = tr("IP filter", "this peer was blocked. Reason: IP filter.");
5673         break;
5674     case lt::peer_blocked_alert::port_filter:
5675         reason = tr("filtered port (%1)", "this peer was blocked. Reason: filtered port (8899).").arg(QString::number(p->endpoint.port()));
5676         break;
5677     case lt::peer_blocked_alert::i2p_mixed:
5678         reason = tr("%1 mixed mode restrictions", "this peer was blocked. Reason: I2P mixed mode restrictions.").arg(u"I2P"_qs); // don't translate I2P
5679         break;
5680     case lt::peer_blocked_alert::privileged_ports:
5681         reason = tr("privileged port (%1)", "this peer was blocked. Reason: privileged port (80).").arg(QString::number(p->endpoint.port()));
5682         break;
5683     case lt::peer_blocked_alert::utp_disabled:
5684         reason = tr("%1 is disabled", "this peer was blocked. Reason: uTP is disabled.").arg(C_UTP); // don't translate μTP
5685         break;
5686     case lt::peer_blocked_alert::tcp_disabled:
5687         reason = tr("%1 is disabled", "this peer was blocked. Reason: TCP is disabled.").arg(u"TCP"_qs); // don't translate TCP
5688         break;
5689     }
5690
5691     const QString ip {toString(p->endpoint.address())};
5692     if (!ip.isEmpty())
5693         Logger::instance()->addPeer(ip, true, reason);
5694 }
5695
5696 void SessionImpl::handlePeerBanAlert(const lt::peer_ban_alert *p)
5697 {
5698     const QString ip {toString(p->endpoint.address())};
5699     if (!ip.isEmpty())
5700         Logger::instance()->addPeer(ip, false);
5701 }
5702
5703 void SessionImpl::handleUrlSeedAlert(const lt::url_seed_alert *p)
5704 {
5705     const TorrentImpl *torrent = m_torrents.value(p->handle.info_hash());
5706     if (!torrent)
5707         return;
5708
5709     if (p->error)
5710     {
5711         LogMsg(tr("URL seed DNS lookup failed. Torrent: \"%1\". URL: \"%2\". Error: \"%3\"")
5712             .arg(torrent->name(), QString::fromUtf8(p->server_url()), QString::fromStdString(p->message()))
5713             , Log::WARNING);
5714     }
5715     else
5716     {
5717         LogMsg(tr("Received error message from URL seed. Torrent: \"%1\". URL: \"%2\". Message: \"%3\"")
5718             .arg(torrent->name(), QString::fromUtf8(p->server_url()), QString::fromUtf8(p->error_message()))
5719             , Log::WARNING);
5720     }
5721 }
5722
5723 void SessionImpl::handleListenSucceededAlert(const lt::listen_succeeded_alert *p)
5724 {
5725     const QString proto {toString(p->socket_type)};
5726     LogMsg(tr("Successfully listening on IP. IP: \"%1\". Port: \"%2/%3\"")
5727             .arg(toString(p->address), proto, QString::number(p->port)), Log::INFO);
5728 }
5729
5730 void SessionImpl::handleListenFailedAlert(const lt::listen_failed_alert *p)
5731 {
5732     const QString proto {toString(p->socket_type)};
5733     LogMsg(tr("Failed to listen on IP. IP: \"%1\". Port: \"%2/%3\". Reason: \"%4\"")
5734         .arg(toString(p->address), proto, QString::number(p->port)
5735             , QString::fromLocal8Bit(p->error.message().c_str())), Log::CRITICAL);
5736 }
5737
5738 void SessionImpl::handleExternalIPAlert(const lt::external_ip_alert *p)
5739 {
5740     const QString externalIP {toString(p->external_address)};
5741     LogMsg(tr("Detected external IP. IP: \"%1\"")
5742         .arg(externalIP), Log::INFO);
5743
5744     if (m_lastExternalIP != externalIP)
5745     {
5746         if (isReannounceWhenAddressChangedEnabled() && !m_lastExternalIP.isEmpty())
5747             reannounceToAllTrackers();
5748         m_lastExternalIP = externalIP;
5749     }
5750 }
5751
5752 void SessionImpl::handleSessionStatsAlert(const lt::session_stats_alert *p)
5753 {
5754     if (m_refreshEnqueued)
5755         m_refreshEnqueued = false;
5756     else
5757         enqueueRefresh();
5758
5759     const int64_t interval = lt::total_microseconds(p->timestamp() - m_statsLastTimestamp);
5760     if (interval <= 0)
5761         return;
5762
5763     m_statsLastTimestamp = p->timestamp();
5764
5765     const auto stats = p->counters();
5766
5767     m_status.hasIncomingConnections = static_cast<bool>(stats[m_metricIndices.net.hasIncomingConnections]);
5768
5769     const int64_t ipOverheadDownload = stats[m_metricIndices.net.recvIPOverheadBytes];
5770     const int64_t ipOverheadUpload = stats[m_metricIndices.net.sentIPOverheadBytes];
5771     const int64_t totalDownload = stats[m_metricIndices.net.recvBytes] + ipOverheadDownload;
5772     const int64_t totalUpload = stats[m_metricIndices.net.sentBytes] + ipOverheadUpload;
5773     const int64_t totalPayloadDownload = stats[m_metricIndices.net.recvPayloadBytes];
5774     const int64_t totalPayloadUpload = stats[m_metricIndices.net.sentPayloadBytes];
5775     const int64_t trackerDownload = stats[m_metricIndices.net.recvTrackerBytes];
5776     const int64_t trackerUpload = stats[m_metricIndices.net.sentTrackerBytes];
5777     const int64_t dhtDownload = stats[m_metricIndices.dht.dhtBytesIn];
5778     const int64_t dhtUpload = stats[m_metricIndices.dht.dhtBytesOut];
5779
5780     const auto calcRate = [interval](const qint64 previous, const qint64 current) -> qint64
5781     {
5782         Q_ASSERT(current >= previous);
5783         Q_ASSERT(interval >= 0);
5784         return (((current - previous) * lt::microseconds(1s).count()) / interval);
5785     };
5786
5787     m_status.payloadDownloadRate = calcRate(m_status.totalPayloadDownload, totalPayloadDownload);
5788     m_status.payloadUploadRate = calcRate(m_status.totalPayloadUpload, totalPayloadUpload);
5789     m_status.downloadRate = calcRate(m_status.totalDownload, totalDownload);
5790     m_status.uploadRate = calcRate(m_status.totalUpload, totalUpload);
5791     m_status.ipOverheadDownloadRate = calcRate(m_status.ipOverheadDownload, ipOverheadDownload);
5792     m_status.ipOverheadUploadRate = calcRate(m_status.ipOverheadUpload, ipOverheadUpload);
5793     m_status.dhtDownloadRate = calcRate(m_status.dhtDownload, dhtDownload);
5794     m_status.dhtUploadRate = calcRate(m_status.dhtUpload, dhtUpload);
5795     m_status.trackerDownloadRate = calcRate(m_status.trackerDownload, trackerDownload);
5796     m_status.trackerUploadRate = calcRate(m_status.trackerUpload, trackerUpload);
5797
5798     m_status.totalPayloadDownload = totalPayloadDownload;
5799     m_status.totalPayloadUpload = totalPayloadUpload;
5800     m_status.ipOverheadDownload = ipOverheadDownload;
5801     m_status.ipOverheadUpload = ipOverheadUpload;
5802     m_status.trackerDownload = trackerDownload;
5803     m_status.trackerUpload = trackerUpload;
5804     m_status.dhtDownload = dhtDownload;
5805     m_status.dhtUpload = dhtUpload;
5806     m_status.totalWasted = stats[m_metricIndices.net.recvRedundantBytes]
5807             + stats[m_metricIndices.net.recvFailedBytes];
5808     m_status.dhtNodes = stats[m_metricIndices.dht.dhtNodes];
5809     m_status.diskReadQueue = stats[m_metricIndices.peer.numPeersUpDisk];
5810     m_status.diskWriteQueue = stats[m_metricIndices.peer.numPeersDownDisk];
5811     m_status.peersCount = stats[m_metricIndices.peer.numPeersConnected];
5812
5813     if (totalDownload > m_status.totalDownload)
5814     {
5815         m_status.totalDownload = totalDownload;
5816         m_isStatisticsDirty = true;
5817     }
5818
5819     if (totalUpload > m_status.totalUpload)
5820     {
5821         m_status.totalUpload = totalUpload;
5822         m_isStatisticsDirty = true;
5823     }
5824
5825     m_status.allTimeDownload = m_previouslyDownloaded + m_status.totalDownload;
5826     m_status.allTimeUpload = m_previouslyUploaded + m_status.totalUpload;
5827
5828     if (m_statisticsLastUpdateTimer.hasExpired(STATISTICS_SAVE_INTERVAL))
5829         saveStatistics();
5830
5831     m_cacheStatus.totalUsedBuffers = stats[m_metricIndices.disk.diskBlocksInUse];
5832     m_cacheStatus.jobQueueLength = stats[m_metricIndices.disk.queuedDiskJobs];
5833
5834 #ifndef QBT_USES_LIBTORRENT2
5835     const int64_t numBlocksRead = stats[m_metricIndices.disk.numBlocksRead];
5836     const int64_t numBlocksCacheHits = stats[m_metricIndices.disk.numBlocksCacheHits];
5837     m_cacheStatus.readRatio = static_cast<qreal>(numBlocksCacheHits) / std::max<int64_t>((numBlocksCacheHits + numBlocksRead), 1);
5838 #endif
5839
5840     const int64_t totalJobs = stats[m_metricIndices.disk.writeJobs] + stats[m_metricIndices.disk.readJobs]
5841                   + stats[m_metricIndices.disk.hashJobs];
5842     m_cacheStatus.averageJobTime = (totalJobs > 0)
5843                                    ? (stats[m_metricIndices.disk.diskJobTime] / totalJobs) : 0;
5844
5845     emit statsUpdated();
5846 }
5847
5848 void SessionImpl::handleAlertsDroppedAlert(const lt::alerts_dropped_alert *p) const
5849 {
5850     LogMsg(tr("Error: Internal alert queue is full and alerts are dropped, you might see degraded performance. Dropped alert type: \"%1\". Message: \"%2\"")
5851         .arg(QString::fromStdString(p->dropped_alerts.to_string()), QString::fromStdString(p->message())), Log::CRITICAL);
5852 }
5853
5854 void SessionImpl::handleStorageMovedAlert(const lt::storage_moved_alert *p)
5855 {
5856     Q_ASSERT(!m_moveStorageQueue.isEmpty());
5857
5858     const MoveStorageJob &currentJob = m_moveStorageQueue.first();
5859     Q_ASSERT(currentJob.torrentHandle == p->handle);
5860
5861     const Path newPath {QString::fromUtf8(p->storage_path())};
5862     Q_ASSERT(newPath == currentJob.path);
5863
5864 #ifdef QBT_USES_LIBTORRENT2
5865     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hashes());
5866 #else
5867     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hash());
5868 #endif
5869
5870     TorrentImpl *torrent = m_torrents.value(id);
5871     const QString torrentName = (torrent ? torrent->name() : id.toString());
5872     LogMsg(tr("Moved torrent successfully. Torrent: \"%1\". Destination: \"%2\"").arg(torrentName, newPath.toString()));
5873
5874     handleMoveTorrentStorageJobFinished(newPath);
5875 }
5876
5877 void SessionImpl::handleStorageMovedFailedAlert(const lt::storage_moved_failed_alert *p)
5878 {
5879     Q_ASSERT(!m_moveStorageQueue.isEmpty());
5880
5881     const MoveStorageJob &currentJob = m_moveStorageQueue.first();
5882     Q_ASSERT(currentJob.torrentHandle == p->handle);
5883
5884 #ifdef QBT_USES_LIBTORRENT2
5885     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hashes());
5886 #else
5887     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hash());
5888 #endif
5889
5890     TorrentImpl *torrent = m_torrents.value(id);
5891     const QString torrentName = (torrent ? torrent->name() : id.toString());
5892     const Path currentLocation = (torrent ? torrent->actualStorageLocation()
5893             : Path(p->handle.status(lt::torrent_handle::query_save_path).save_path));
5894     const QString errorMessage = QString::fromStdString(p->message());
5895     LogMsg(tr("Failed to move torrent. Torrent: \"%1\". Source: \"%2\". Destination: \"%3\". Reason: \"%4\"")
5896            .arg(torrentName, currentLocation.toString(), currentJob.path.toString(), errorMessage), Log::WARNING);
5897
5898     handleMoveTorrentStorageJobFinished(currentLocation);
5899 }
5900
5901 void SessionImpl::handleStateUpdateAlert(const lt::state_update_alert *p)
5902 {
5903     QVector<Torrent *> updatedTorrents;
5904     updatedTorrents.reserve(static_cast<decltype(updatedTorrents)::size_type>(p->status.size()));
5905
5906     for (const lt::torrent_status &status : p->status)
5907     {
5908 #ifdef QBT_USES_LIBTORRENT2
5909         const auto id = TorrentID::fromInfoHash(status.info_hashes);
5910 #else
5911         const auto id = TorrentID::fromInfoHash(status.info_hash);
5912 #endif
5913         TorrentImpl *const torrent = m_torrents.value(id);
5914         if (!torrent)
5915             continue;
5916
5917         torrent->handleStateUpdate(status);
5918         updatedTorrents.push_back(torrent);
5919     }
5920
5921     if (!updatedTorrents.isEmpty())
5922         emit torrentsUpdated(updatedTorrents);
5923
5924     if (m_needSaveTorrentsQueue)
5925         saveTorrentsQueue();
5926
5927     if (m_refreshEnqueued)
5928         m_refreshEnqueued = false;
5929     else
5930         enqueueRefresh();
5931 }
5932
5933 void SessionImpl::handleSocks5Alert(const lt::socks5_alert *p) const
5934 {
5935     if (p->error)
5936     {
5937         const auto addr = p->ip.address();
5938         const QString endpoint = (addr.is_v6() ? u"[%1]:%2"_qs : u"%1:%2"_qs)
5939                 .arg(QString::fromStdString(addr.to_string()), QString::number(p->ip.port()));
5940         LogMsg(tr("SOCKS5 proxy error. Address: %1. Message: \"%2\".")
5941                 .arg(endpoint, QString::fromLocal8Bit(p->error.message().c_str()))
5942                 , Log::WARNING);
5943     }
5944 }
5945
5946 void SessionImpl::handleTrackerAlert(const lt::tracker_alert *a)
5947 {
5948     TorrentImpl *torrent = m_torrents.value(a->handle.info_hash());
5949     if (!torrent)
5950         return;
5951
5952     QMap<TrackerEntry::Endpoint, int> &updateInfo = m_updatedTrackerEntries[torrent->nativeHandle()][std::string(a->tracker_url())];
5953
5954     if (a->type() == lt::tracker_reply_alert::alert_type)
5955     {
5956         const int numPeers = static_cast<const lt::tracker_reply_alert *>(a)->num_peers;
5957         updateInfo.insert(a->local_endpoint, numPeers);
5958     }
5959 }
5960
5961 #ifdef QBT_USES_LIBTORRENT2
5962 void SessionImpl::handleTorrentConflictAlert(const lt::torrent_conflict_alert *a)
5963 {
5964     const auto torrentIDv1 = TorrentID::fromSHA1Hash(a->metadata->info_hashes().v1);
5965     const auto torrentIDv2 = TorrentID::fromSHA256Hash(a->metadata->info_hashes().v2);
5966     TorrentImpl *torrent1 = m_torrents.value(torrentIDv1);
5967     TorrentImpl *torrent2 = m_torrents.value(torrentIDv2);
5968     if (torrent2)
5969     {
5970         if (torrent1)
5971             deleteTorrent(torrentIDv1);
5972         else
5973             cancelDownloadMetadata(torrentIDv1);
5974
5975         invokeAsync([torrentHandle = torrent2->nativeHandle(), metadata = a->metadata]
5976         {
5977             try
5978             {
5979                 torrentHandle.set_metadata(metadata->info_section());
5980             }
5981             catch (const std::exception &) {}
5982         });
5983     }
5984     else if (torrent1)
5985     {
5986         if (!torrent2)
5987             cancelDownloadMetadata(torrentIDv2);
5988
5989         invokeAsync([torrentHandle = torrent1->nativeHandle(), metadata = a->metadata]
5990         {
5991             try
5992             {
5993                 torrentHandle.set_metadata(metadata->info_section());
5994             }
5995             catch (const std::exception &) {}
5996         });
5997     }
5998     else
5999     {
6000         cancelDownloadMetadata(torrentIDv1);
6001         cancelDownloadMetadata(torrentIDv2);
6002     }
6003
6004     if (!torrent1 || !torrent2)
6005         emit metadataDownloaded(TorrentInfo(*a->metadata));
6006 }
6007 #endif
6008
6009 void SessionImpl::processTrackerStatuses()
6010 {
6011     if (m_updatedTrackerEntries.isEmpty())
6012         return;
6013
6014     for (auto it = m_updatedTrackerEntries.cbegin(); it != m_updatedTrackerEntries.cend(); ++it)
6015     {
6016         invokeAsync([this, torrentHandle = it.key(), updatedTrackers = it.value()]() mutable
6017         {
6018             try
6019             {
6020                 std::vector<lt::announce_entry> nativeTrackers = torrentHandle.trackers();
6021                 invoke([this, torrentHandle, nativeTrackers = std::move(nativeTrackers)
6022                         , updatedTrackers = std::move(updatedTrackers)]
6023                 {
6024                     TorrentImpl *torrent = m_torrents.value(torrentHandle.info_hash());
6025                     if (!torrent)
6026                         return;
6027
6028                     QHash<QString, TrackerEntry> updatedTrackerEntries;
6029                     updatedTrackerEntries.reserve(updatedTrackers.size());
6030                     for (const lt::announce_entry &announceEntry : nativeTrackers)
6031                     {
6032                         const auto updatedTrackersIter = updatedTrackers.find(announceEntry.url);
6033                         if (updatedTrackersIter == updatedTrackers.end())
6034                             continue;
6035
6036                         const QMap<TrackerEntry::Endpoint, int> &updateInfo = updatedTrackersIter.value();
6037                         TrackerEntry trackerEntry = torrent->updateTrackerEntry(announceEntry, updateInfo);
6038 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
6039                         updatedTrackerEntries[trackerEntry.url] = std::move(trackerEntry);
6040 #else
6041                         updatedTrackerEntries.emplace(trackerEntry.url, std::move(trackerEntry));
6042 #endif
6043                     }
6044
6045                     emit trackerEntriesUpdated(torrent, updatedTrackerEntries);
6046                 });
6047             }
6048             catch (const std::exception &)
6049             {
6050             }
6051         });
6052     }
6053
6054     m_updatedTrackerEntries.clear();
6055 }
6056
6057 void SessionImpl::saveStatistics() const
6058 {
6059     if (!m_isStatisticsDirty)
6060         return;
6061
6062     const QVariantHash stats {
6063         {u"AlltimeDL"_qs, m_status.allTimeDownload},
6064         {u"AlltimeUL"_qs, m_status.allTimeUpload}};
6065     std::unique_ptr<QSettings> settings = Profile::instance()->applicationSettings(u"qBittorrent-data"_qs);
6066     settings->setValue(u"Stats/AllStats"_qs, stats);
6067
6068     m_statisticsLastUpdateTimer.start();
6069     m_isStatisticsDirty = false;
6070 }
6071
6072 void SessionImpl::loadStatistics()
6073 {
6074     const std::unique_ptr<QSettings> settings = Profile::instance()->applicationSettings(u"qBittorrent-data"_qs);
6075     const QVariantHash value = settings->value(u"Stats/AllStats"_qs).toHash();
6076
6077     m_previouslyDownloaded = value[u"AlltimeDL"_qs].toLongLong();
6078     m_previouslyUploaded = value[u"AlltimeUL"_qs].toLongLong();
6079 }