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