src/base/bittorrent/session.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015  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 "session.h"
  31
  32 #include <algorithm>
  33 #include <cstdint>
  34 #include <queue>
  35 #include <string>
  36 #include <utility>
  37
  38 #ifdef Q_OS_WIN
  39 #include <Windows.h>
  40 #include <wincrypt.h>
  41 #include <iphlpapi.h>
  42 #endif
  43
  44 #include <libtorrent/alert_types.hpp>
  45 #include <libtorrent/error_code.hpp>
  46 #include <libtorrent/extensions/smart_ban.hpp>
  47 #include <libtorrent/extensions/ut_metadata.hpp>
  48 #include <libtorrent/extensions/ut_pex.hpp>
  49 #include <libtorrent/ip_filter.hpp>
  50 #include <libtorrent/magnet_uri.hpp>
  51 #include <libtorrent/session.hpp>
  52 #include <libtorrent/session_stats.hpp>
  53 #include <libtorrent/session_status.hpp>
  54 #include <libtorrent/torrent_info.hpp>
  55
  56 #include <QDebug>
  57 #include <QDir>
  58 #include <QFile>
  59 #include <QHostAddress>
  60 #include <QNetworkAddressEntry>
  61 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
  62 #include <QNetworkConfigurationManager>
  63 #endif
  64 #include <QNetworkInterface>
  65 #include <QRegularExpression>
  66 #include <QString>
  67 #include <QThread>
  68 #include <QTimer>
  69 #include <QUuid>
  70
  71 #include "base/algorithm.h"
  72 #include "base/exceptions.h"
  73 #include "base/global.h"
  74 #include "base/logger.h"
  75 #include "base/net/downloadmanager.h"
  76 #include "base/net/proxyconfigurationmanager.h"
  77 #include "base/profile.h"
  78 #include "base/torrentfileguard.h"
  79 #include "base/torrentfilter.h"
  80 #include "base/unicodestrings.h"
  81 #include "base/utils/bytearray.h"
  82 #include "base/utils/fs.h"
  83 #include "base/utils/misc.h"
  84 #include "base/utils/net.h"
  85 #include "base/utils/random.h"
  86 #include "base/version.h"
  87 #include "bandwidthscheduler.h"
  88 #include "bencoderesumedatastorage.h"
  89 #include "common.h"
  90 #include "customstorage.h"
  91 #include "dbresumedatastorage.h"
  92 #include "filesearcher.h"
  93 #include "filterparserthread.h"
  94 #include "loadtorrentparams.h"
  95 #include "ltunderlyingtype.h"
  96 #include "magneturi.h"
  97 #include "nativesessionextension.h"
  98 #include "portforwarderimpl.h"
  99 #include "statistics.h"
 100 #include "torrentimpl.h"
 101 #include "tracker.h"
 102
 103 using namespace BitTorrent;
 104
 105 namespace
 106 {
 107     const char PEER_ID[] = "qB";
 108     const char USER_AGENT[] = "qBittorrent/" QBT_VERSION_2;
 109
 110     void torrentQueuePositionUp(const lt::torrent_handle &handle)
 111     {
 112         try
 113         {
 114             handle.queue_position_up();
 115         }
 116         catch (const std::exception &exc)
 117         {
 118             qDebug() << Q_FUNC_INFO << " fails: " << exc.what();
 119         }
 120     }
 121
 122     void torrentQueuePositionDown(const lt::torrent_handle &handle)
 123     {
 124         try
 125         {
 126             handle.queue_position_down();
 127         }
 128         catch (const std::exception &exc)
 129         {
 130             qDebug() << Q_FUNC_INFO << " fails: " << exc.what();
 131         }
 132     }
 133
 134     void torrentQueuePositionTop(const lt::torrent_handle &handle)
 135     {
 136         try
 137         {
 138             handle.queue_position_top();
 139         }
 140         catch (const std::exception &exc)
 141         {
 142             qDebug() << Q_FUNC_INFO << " fails: " << exc.what();
 143         }
 144     }
 145
 146     void torrentQueuePositionBottom(const lt::torrent_handle &handle)
 147     {
 148         try
 149         {
 150             handle.queue_position_bottom();
 151         }
 152         catch (const std::exception &exc)
 153         {
 154             qDebug() << Q_FUNC_INFO << " fails: " << exc.what();
 155         }
 156     }
 157
 158     QStringMap map_cast(const QVariantMap &map)
 159     {
 160         QStringMap result;
 161         for (auto i = map.cbegin(); i != map.cend(); ++i)
 162             result[i.key()] = i.value().toString();
 163         return result;
 164     }
 165
 166     QVariantMap map_cast(const QStringMap &map)
 167     {
 168         QVariantMap result;
 169         for (auto i = map.cbegin(); i != map.cend(); ++i)
 170             result[i.key()] = i.value();
 171         return result;
 172     }
 173
 174     QString normalizePath(const QString &path)
 175     {
 176         QString tmp = Utils::Fs::toUniformPath(path.trimmed());
 177         if (!tmp.isEmpty() && !tmp.endsWith('/'))
 178             return tmp + '/';
 179         return tmp;
 180     }
 181
 182     QString normalizeSavePath(QString path, const QString &defaultPath = specialFolderLocation(SpecialFolder::Downloads))
 183     {
 184         path = path.trimmed();
 185         if (path.isEmpty())
 186             path = Utils::Fs::toUniformPath(defaultPath.trimmed());
 187
 188         return normalizePath(path);
 189     }
 190
 191     QStringMap expandCategories(const QStringMap &categories)
 192     {
 193         QStringMap expanded = categories;
 194
 195         for (auto i = categories.cbegin(); i != categories.cend(); ++i)
 196         {
 197             const QString &category = i.key();
 198             for (const QString &subcat : asConst(Session::expandCategory(category)))
 199             {
 200                 if (!expanded.contains(subcat))
 201                     expanded[subcat] = "";
 202             }
 203         }
 204
 205         return expanded;
 206     }
 207
 208     QString toString(const lt::socket_type_t socketType)
 209     {
 210         switch (socketType)
 211         {
 212 #if (LIBTORRENT_VERSION_NUM >= 20000)
 213         case lt::socket_type_t::http:
 214             return QLatin1String("HTTP");
 215         case lt::socket_type_t::http_ssl:
 216             return QLatin1String("HTTP_SSL");
 217 #endif
 218         case lt::socket_type_t::i2p:
 219             return QLatin1String("I2P");
 220         case lt::socket_type_t::socks5:
 221             return QLatin1String("SOCKS5");
 222 #if (LIBTORRENT_VERSION_NUM >= 20000)
 223         case lt::socket_type_t::socks5_ssl:
 224             return QLatin1String("SOCKS5_SSL");
 225 #endif
 226         case lt::socket_type_t::tcp:
 227             return QLatin1String("TCP");
 228         case lt::socket_type_t::tcp_ssl:
 229             return QLatin1String("TCP_SSL");
 230 #if (LIBTORRENT_VERSION_NUM >= 20000)
 231         case lt::socket_type_t::utp:
 232             return QLatin1String("UTP");
 233 #else
 234         case lt::socket_type_t::udp:
 235             return QLatin1String("UDP");
 236 #endif
 237         case lt::socket_type_t::utp_ssl:
 238             return QLatin1String("UTP_SSL");
 239         }
 240         return QLatin1String("INVALID");
 241     }
 242
 243     QString toString(const lt::address &address)
 244     {
 245         try
 246         {
 247             return QString::fromLatin1(address.to_string().c_str());
 248         }
 249         catch (const std::exception &)
 250         {
 251             // suppress conversion error
 252         }
 253         return {};
 254     }
 255
 256     template <typename T>
 257     struct LowerLimited
 258     {
 259         LowerLimited(T limit, T ret)
 260             : m_limit(limit)
 261             , m_ret(ret)
 262         {
 263         }
 264
 265         explicit LowerLimited(T limit)
 266             : LowerLimited(limit, limit)
 267         {
 268         }
 269
 270         T operator()(T val) const
 271         {
 272             return val <= m_limit ? m_ret : val;
 273         }
 274
 275     private:
 276         const T m_limit;
 277         const T m_ret;
 278     };
 279
 280     template <typename T>
 281     LowerLimited<T> lowerLimited(T limit) { return LowerLimited<T>(limit); }
 282
 283     template <typename T>
 284     LowerLimited<T> lowerLimited(T limit, T ret) { return LowerLimited<T>(limit, ret); }
 285
 286     template <typename T>
 287     auto clampValue(const T lower, const T upper)
 288     {
 289         return [lower, upper](const T value) -> T
 290         {
 291             if (value < lower)
 292                 return lower;
 293             if (value > upper)
 294                 return upper;
 295             return value;
 296         };
 297     }
 298
 299 #ifdef Q_OS_WIN
 300     QString convertIfaceNameToGuid(const QString &name)
 301     {
 302         // Under Windows XP or on Qt version <= 5.5 'name' will be a GUID already.
 303         const QUuid uuid(name);
 304         if (!uuid.isNull())
 305             return uuid.toString().toUpper(); // Libtorrent expects the GUID in uppercase
 306
 307         NET_LUID luid {};
 308         const LONG res = ::ConvertInterfaceNameToLuidW(name.toStdWString().c_str(), &luid);
 309         if (res == 0)
 310         {
 311             GUID guid;
 312             if (::ConvertInterfaceLuidToGuid(&luid, &guid) == 0)
 313                 return QUuid(guid).toString().toUpper();
 314         }
 315
 316         return {};
 317     }
 318 #endif
 319 }
 320
 321 const int addTorrentParamsId = qRegisterMetaType<AddTorrentParams>();
 322
 323 // Session
 324
 325 Session *Session::m_instance = nullptr;
 326
 327 #define BITTORRENT_KEY(name) "BitTorrent/" name
 328 #define BITTORRENT_SESSION_KEY(name) BITTORRENT_KEY("Session/") name
 329
 330 Session::Session(QObject *parent)
 331     : QObject(parent)
 332     , m_isDHTEnabled(BITTORRENT_SESSION_KEY("DHTEnabled"), true)
 333     , m_isLSDEnabled(BITTORRENT_SESSION_KEY("LSDEnabled"), true)
 334     , m_isPeXEnabled(BITTORRENT_SESSION_KEY("PeXEnabled"), true)
 335     , m_isIPFilteringEnabled(BITTORRENT_SESSION_KEY("IPFilteringEnabled"), false)
 336     , m_isTrackerFilteringEnabled(BITTORRENT_SESSION_KEY("TrackerFilteringEnabled"), false)
 337     , m_IPFilterFile(BITTORRENT_SESSION_KEY("IPFilter"))
 338     , m_announceToAllTrackers(BITTORRENT_SESSION_KEY("AnnounceToAllTrackers"), false)
 339     , m_announceToAllTiers(BITTORRENT_SESSION_KEY("AnnounceToAllTiers"), true)
 340     , m_asyncIOThreads(BITTORRENT_SESSION_KEY("AsyncIOThreadsCount"), 10)
 341     , m_hashingThreads(BITTORRENT_SESSION_KEY("HashingThreadsCount"), 2)
 342     , m_filePoolSize(BITTORRENT_SESSION_KEY("FilePoolSize"), 5000)
 343     , m_checkingMemUsage(BITTORRENT_SESSION_KEY("CheckingMemUsageSize"), 32)
 344     , m_diskCacheSize(BITTORRENT_SESSION_KEY("DiskCacheSize"), -1)
 345     , m_diskCacheTTL(BITTORRENT_SESSION_KEY("DiskCacheTTL"), 60)
 346     , m_useOSCache(BITTORRENT_SESSION_KEY("UseOSCache"), true)
 347 #ifdef Q_OS_WIN
 348     , m_coalesceReadWriteEnabled(BITTORRENT_SESSION_KEY("CoalesceReadWrite"), true)
 349 #else
 350     , m_coalesceReadWriteEnabled(BITTORRENT_SESSION_KEY("CoalesceReadWrite"), false)
 351 #endif
 352     , m_usePieceExtentAffinity(BITTORRENT_SESSION_KEY("PieceExtentAffinity"), false)
 353     , m_isSuggestMode(BITTORRENT_SESSION_KEY("SuggestMode"), false)
 354     , m_sendBufferWatermark(BITTORRENT_SESSION_KEY("SendBufferWatermark"), 500)
 355     , m_sendBufferLowWatermark(BITTORRENT_SESSION_KEY("SendBufferLowWatermark"), 10)
 356     , m_sendBufferWatermarkFactor(BITTORRENT_SESSION_KEY("SendBufferWatermarkFactor"), 50)
 357     , m_connectionSpeed(BITTORRENT_SESSION_KEY("ConnectionSpeed"), 30)
 358     , m_socketBacklogSize(BITTORRENT_SESSION_KEY("SocketBacklogSize"), 30)
 359     , m_isAnonymousModeEnabled(BITTORRENT_SESSION_KEY("AnonymousModeEnabled"), false)
 360     , m_isQueueingEnabled(BITTORRENT_SESSION_KEY("QueueingSystemEnabled"), false)
 361     , m_maxActiveDownloads(BITTORRENT_SESSION_KEY("MaxActiveDownloads"), 3, lowerLimited(-1))
 362     , m_maxActiveUploads(BITTORRENT_SESSION_KEY("MaxActiveUploads"), 3, lowerLimited(-1))
 363     , m_maxActiveTorrents(BITTORRENT_SESSION_KEY("MaxActiveTorrents"), 5, lowerLimited(-1))
 364     , m_ignoreSlowTorrentsForQueueing(BITTORRENT_SESSION_KEY("IgnoreSlowTorrentsForQueueing"), false)
 365     , m_downloadRateForSlowTorrents(BITTORRENT_SESSION_KEY("SlowTorrentsDownloadRate"), 2)
 366     , m_uploadRateForSlowTorrents(BITTORRENT_SESSION_KEY("SlowTorrentsUploadRate"), 2)
 367     , m_slowTorrentsInactivityTimer(BITTORRENT_SESSION_KEY("SlowTorrentsInactivityTimer"), 60)
 368     , m_outgoingPortsMin(BITTORRENT_SESSION_KEY("OutgoingPortsMin"), 0)
 369     , m_outgoingPortsMax(BITTORRENT_SESSION_KEY("OutgoingPortsMax"), 0)
 370     , m_UPnPLeaseDuration(BITTORRENT_SESSION_KEY("UPnPLeaseDuration"), 0)
 371     , m_peerToS(BITTORRENT_SESSION_KEY("PeerToS"), 0x20)
 372     , m_ignoreLimitsOnLAN(BITTORRENT_SESSION_KEY("IgnoreLimitsOnLAN"), false)
 373     , m_includeOverheadInLimits(BITTORRENT_SESSION_KEY("IncludeOverheadInLimits"), false)
 374     , m_announceIP(BITTORRENT_SESSION_KEY("AnnounceIP"))
 375     , m_maxConcurrentHTTPAnnounces(BITTORRENT_SESSION_KEY("MaxConcurrentHTTPAnnounces"), 50)
 376     , m_isReannounceWhenAddressChangedEnabled(BITTORRENT_SESSION_KEY("ReannounceWhenAddressChanged"), false)
 377     , m_stopTrackerTimeout(BITTORRENT_SESSION_KEY("StopTrackerTimeout"), 5)
 378     , m_maxConnections(BITTORRENT_SESSION_KEY("MaxConnections"), 500, lowerLimited(0, -1))
 379     , m_maxUploads(BITTORRENT_SESSION_KEY("MaxUploads"), 20, lowerLimited(0, -1))
 380     , m_maxConnectionsPerTorrent(BITTORRENT_SESSION_KEY("MaxConnectionsPerTorrent"), 100, lowerLimited(0, -1))
 381     , m_maxUploadsPerTorrent(BITTORRENT_SESSION_KEY("MaxUploadsPerTorrent"), 4, lowerLimited(0, -1))
 382     , m_btProtocol(BITTORRENT_SESSION_KEY("BTProtocol"), BTProtocol::Both
 383         , clampValue(BTProtocol::Both, BTProtocol::UTP))
 384     , m_isUTPRateLimited(BITTORRENT_SESSION_KEY("uTPRateLimited"), true)
 385     , m_utpMixedMode(BITTORRENT_SESSION_KEY("uTPMixedMode"), MixedModeAlgorithm::TCP
 386         , clampValue(MixedModeAlgorithm::TCP, MixedModeAlgorithm::Proportional))
 387     , m_IDNSupportEnabled(BITTORRENT_SESSION_KEY("IDNSupportEnabled"), false)
 388     , m_multiConnectionsPerIpEnabled(BITTORRENT_SESSION_KEY("MultiConnectionsPerIp"), false)
 389     , m_validateHTTPSTrackerCertificate(BITTORRENT_SESSION_KEY("ValidateHTTPSTrackerCertificate"), true)
 390     , m_blockPeersOnPrivilegedPorts(BITTORRENT_SESSION_KEY("BlockPeersOnPrivilegedPorts"), false)
 391     , m_isAddTrackersEnabled(BITTORRENT_SESSION_KEY("AddTrackersEnabled"), false)
 392     , m_additionalTrackers(BITTORRENT_SESSION_KEY("AdditionalTrackers"))
 393     , m_globalMaxRatio(BITTORRENT_SESSION_KEY("GlobalMaxRatio"), -1, [](qreal r) { return r < 0 ? -1. : r;})
 394     , m_globalMaxSeedingMinutes(BITTORRENT_SESSION_KEY("GlobalMaxSeedingMinutes"), -1, lowerLimited(-1))
 395     , m_isAddTorrentPaused(BITTORRENT_SESSION_KEY("AddTorrentPaused"), false)
 396     , m_torrentContentLayout(BITTORRENT_SESSION_KEY("TorrentContentLayout"), TorrentContentLayout::Original)
 397     , m_isAppendExtensionEnabled(BITTORRENT_SESSION_KEY("AddExtensionToIncompleteFiles"), false)
 398     , m_refreshInterval(BITTORRENT_SESSION_KEY("RefreshInterval"), 1500)
 399     , m_isPreallocationEnabled(BITTORRENT_SESSION_KEY("Preallocation"), false)
 400     , m_torrentExportDirectory(BITTORRENT_SESSION_KEY("TorrentExportDirectory"))
 401     , m_finishedTorrentExportDirectory(BITTORRENT_SESSION_KEY("FinishedTorrentExportDirectory"))
 402     , m_globalDownloadSpeedLimit(BITTORRENT_SESSION_KEY("GlobalDLSpeedLimit"), 0, lowerLimited(0))
 403     , m_globalUploadSpeedLimit(BITTORRENT_SESSION_KEY("GlobalUPSpeedLimit"), 0, lowerLimited(0))
 404     , m_altGlobalDownloadSpeedLimit(BITTORRENT_SESSION_KEY("AlternativeGlobalDLSpeedLimit"), 10, lowerLimited(0))
 405     , m_altGlobalUploadSpeedLimit(BITTORRENT_SESSION_KEY("AlternativeGlobalUPSpeedLimit"), 10, lowerLimited(0))
 406     , m_isAltGlobalSpeedLimitEnabled(BITTORRENT_SESSION_KEY("UseAlternativeGlobalSpeedLimit"), false)
 407     , m_isBandwidthSchedulerEnabled(BITTORRENT_SESSION_KEY("BandwidthSchedulerEnabled"), false)
 408     , m_saveResumeDataInterval(BITTORRENT_SESSION_KEY("SaveResumeDataInterval"), 60)
 409     , m_port(BITTORRENT_SESSION_KEY("Port"), -1)
 410     , m_useRandomPort(BITTORRENT_SESSION_KEY("UseRandomPort"), false)
 411     , m_networkInterface(BITTORRENT_SESSION_KEY("Interface"))
 412     , m_networkInterfaceName(BITTORRENT_SESSION_KEY("InterfaceName"))
 413     , m_networkInterfaceAddress(BITTORRENT_SESSION_KEY("InterfaceAddress"))
 414     , m_encryption(BITTORRENT_SESSION_KEY("Encryption"), 0)
 415     , m_isProxyPeerConnectionsEnabled(BITTORRENT_SESSION_KEY("ProxyPeerConnections"), false)
 416     , m_chokingAlgorithm(BITTORRENT_SESSION_KEY("ChokingAlgorithm"), ChokingAlgorithm::FixedSlots
 417         , clampValue(ChokingAlgorithm::FixedSlots, ChokingAlgorithm::RateBased))
 418     , m_seedChokingAlgorithm(BITTORRENT_SESSION_KEY("SeedChokingAlgorithm"), SeedChokingAlgorithm::FastestUpload
 419         , clampValue(SeedChokingAlgorithm::RoundRobin, SeedChokingAlgorithm::AntiLeech))
 420     , m_storedCategories(BITTORRENT_SESSION_KEY("Categories"))
 421     , m_storedTags(BITTORRENT_SESSION_KEY("Tags"))
 422     , m_maxRatioAction(BITTORRENT_SESSION_KEY("MaxRatioAction"), Pause)
 423     , m_defaultSavePath(BITTORRENT_SESSION_KEY("DefaultSavePath"), specialFolderLocation(SpecialFolder::Downloads), normalizePath)
 424     , m_tempPath(BITTORRENT_SESSION_KEY("TempPath"), defaultSavePath() + "temp/", normalizePath)
 425     , m_isSubcategoriesEnabled(BITTORRENT_SESSION_KEY("SubcategoriesEnabled"), false)
 426     , m_isTempPathEnabled(BITTORRENT_SESSION_KEY("TempPathEnabled"), false)
 427     , m_isAutoTMMDisabledByDefault(BITTORRENT_SESSION_KEY("DisableAutoTMMByDefault"), true)
 428     , m_isDisableAutoTMMWhenCategoryChanged(BITTORRENT_SESSION_KEY("DisableAutoTMMTriggers/CategoryChanged"), false)
 429     , m_isDisableAutoTMMWhenDefaultSavePathChanged(BITTORRENT_SESSION_KEY("DisableAutoTMMTriggers/DefaultSavePathChanged"), true)
 430     , m_isDisableAutoTMMWhenCategorySavePathChanged(BITTORRENT_SESSION_KEY("DisableAutoTMMTriggers/CategorySavePathChanged"), true)
 431     , m_isTrackerEnabled(BITTORRENT_KEY("TrackerEnabled"), false)
 432     , m_peerTurnover(BITTORRENT_SESSION_KEY("PeerTurnover"), 4)
 433     , m_peerTurnoverCutoff(BITTORRENT_SESSION_KEY("PeerTurnoverCutOff"), 90)
 434     , m_peerTurnoverInterval(BITTORRENT_SESSION_KEY("PeerTurnoverInterval"), 300)
 435     , m_bannedIPs("State/BannedIPs"
 436                   , QStringList()
 437                   , [](const QStringList &value)
 438                         {
 439                             QStringList tmp = value;
 440                             tmp.sort();
 441                             return tmp;
 442                         }
 443                  )
 444     , m_resumeDataStorageType(BITTORRENT_SESSION_KEY("ResumeDataStorageType"), ResumeDataStorageType::Legacy)
 445 #if defined(Q_OS_WIN)
 446     , m_OSMemoryPriority(BITTORRENT_KEY("OSMemoryPriority"), OSMemoryPriority::BelowNormal)
 447 #endif
 448     , m_seedingLimitTimer {new QTimer {this}}
 449     , m_resumeDataTimer {new QTimer {this}}
 450     , m_statistics {new Statistics {this}}
 451     , m_ioThread {new QThread {this}}
 452     , m_recentErroredTorrentsTimer {new QTimer {this}}
 453 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 454     , m_networkManager {new QNetworkConfigurationManager {this}}
 455 #endif
 456 {
 457     if (port() < 0)
 458         m_port = Utils::Random::rand(1024, 65535);
 459
 460     m_recentErroredTorrentsTimer->setSingleShot(true);
 461     m_recentErroredTorrentsTimer->setInterval(1000);
 462     connect(m_recentErroredTorrentsTimer, &QTimer::timeout
 463         , this, [this]() { m_recentErroredTorrents.clear(); });
 464
 465     m_seedingLimitTimer->setInterval(10000);
 466     connect(m_seedingLimitTimer, &QTimer::timeout, this, &Session::processShareLimits);
 467
 468     initializeNativeSession();
 469     configureComponents();
 470
 471     if (isBandwidthSchedulerEnabled())
 472         enableBandwidthScheduler();
 473
 474     m_categories = map_cast(m_storedCategories);
 475     if (isSubcategoriesEnabled())
 476     {
 477         // if subcategories support changed manually
 478         m_categories = expandCategories(m_categories);
 479         m_storedCategories = map_cast(m_categories);
 480     }
 481
 482     const QStringList storedTags = m_storedTags.get();
 483     m_tags = {storedTags.cbegin(), storedTags.cend()};
 484
 485     enqueueRefresh();
 486     updateSeedingLimitTimer();
 487     populateAdditionalTrackers();
 488
 489     enableTracker(isTrackerEnabled());
 490
 491     connect(Net::ProxyConfigurationManager::instance()
 492         , &Net::ProxyConfigurationManager::proxyConfigurationChanged
 493         , this, &Session::configureDeferred);
 494
 495 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 496     // Network configuration monitor
 497     connect(m_networkManager, &QNetworkConfigurationManager::onlineStateChanged, this, &Session::networkOnlineStateChanged);
 498     connect(m_networkManager, &QNetworkConfigurationManager::configurationAdded, this, &Session::networkConfigurationChange);
 499     connect(m_networkManager, &QNetworkConfigurationManager::configurationRemoved, this, &Session::networkConfigurationChange);
 500     connect(m_networkManager, &QNetworkConfigurationManager::configurationChanged, this, &Session::networkConfigurationChange);
 501 #endif
 502
 503     m_fileSearcher = new FileSearcher;
 504     m_fileSearcher->moveToThread(m_ioThread);
 505     connect(m_ioThread, &QThread::finished, m_fileSearcher, &QObject::deleteLater);
 506     connect(m_fileSearcher, &FileSearcher::searchFinished, this, &Session::fileSearchFinished);
 507
 508     m_ioThread->start();
 509
 510     // Regular saving of fastresume data
 511     connect(m_resumeDataTimer, &QTimer::timeout, this, [this]() { generateResumeData(); });
 512     const int saveInterval = saveResumeDataInterval();
 513     if (saveInterval > 0)
 514     {
 515         m_resumeDataTimer->setInterval(saveInterval * 60 * 1000);
 516         m_resumeDataTimer->start();
 517     }
 518
 519     // initialize PortForwarder instance
 520     new PortForwarderImpl {m_nativeSession};
 521
 522     initMetrics();
 523 }
 524
 525 bool Session::isDHTEnabled() const
 526 {
 527     return m_isDHTEnabled;
 528 }
 529
 530 void Session::setDHTEnabled(bool enabled)
 531 {
 532     if (enabled != m_isDHTEnabled)
 533     {
 534         m_isDHTEnabled = enabled;
 535         configureDeferred();
 536         LogMsg(tr("DHT support [%1]").arg(enabled ? tr("ON") : tr("OFF")), Log::INFO);
 537     }
 538 }
 539
 540 bool Session::isLSDEnabled() const
 541 {
 542     return m_isLSDEnabled;
 543 }
 544
 545 void Session::setLSDEnabled(const bool enabled)
 546 {
 547     if (enabled != m_isLSDEnabled)
 548     {
 549         m_isLSDEnabled = enabled;
 550         configureDeferred();
 551         LogMsg(tr("Local Peer Discovery support [%1]").arg(enabled ? tr("ON") : tr("OFF"))
 552             , Log::INFO);
 553     }
 554 }
 555
 556 bool Session::isPeXEnabled() const
 557 {
 558     return m_isPeXEnabled;
 559 }
 560
 561 void Session::setPeXEnabled(const bool enabled)
 562 {
 563     m_isPeXEnabled = enabled;
 564     if (m_wasPexEnabled != enabled)
 565         LogMsg(tr("Restart is required to toggle PeX support"), Log::WARNING);
 566 }
 567
 568 bool Session::isTempPathEnabled() const
 569 {
 570     return m_isTempPathEnabled;
 571 }
 572
 573 void Session::setTempPathEnabled(const bool enabled)
 574 {
 575     if (enabled != isTempPathEnabled())
 576     {
 577         m_isTempPathEnabled = enabled;
 578         for (TorrentImpl *const torrent : asConst(m_torrents))
 579             torrent->handleTempPathChanged();
 580     }
 581 }
 582
 583 bool Session::isAppendExtensionEnabled() const
 584 {
 585     return m_isAppendExtensionEnabled;
 586 }
 587
 588 void Session::setAppendExtensionEnabled(const bool enabled)
 589 {
 590     if (isAppendExtensionEnabled() != enabled)
 591     {
 592         m_isAppendExtensionEnabled = enabled;
 593
 594         // append or remove .!qB extension for incomplete files
 595         for (TorrentImpl *const torrent : asConst(m_torrents))
 596             torrent->handleAppendExtensionToggled();
 597     }
 598 }
 599
 600 int Session::refreshInterval() const
 601 {
 602     return m_refreshInterval;
 603 }
 604
 605 void Session::setRefreshInterval(const int value)
 606 {
 607     if (value != refreshInterval())
 608     {
 609         m_refreshInterval = value;
 610     }
 611 }
 612
 613 bool Session::isPreallocationEnabled() const
 614 {
 615     return m_isPreallocationEnabled;
 616 }
 617
 618 void Session::setPreallocationEnabled(const bool enabled)
 619 {
 620     m_isPreallocationEnabled = enabled;
 621 }
 622
 623 QString Session::torrentExportDirectory() const
 624 {
 625     return Utils::Fs::toUniformPath(m_torrentExportDirectory);
 626 }
 627
 628 void Session::setTorrentExportDirectory(QString path)
 629 {
 630     path = Utils::Fs::toUniformPath(path);
 631     if (path != torrentExportDirectory())
 632         m_torrentExportDirectory = path;
 633 }
 634
 635 QString Session::finishedTorrentExportDirectory() const
 636 {
 637     return Utils::Fs::toUniformPath(m_finishedTorrentExportDirectory);
 638 }
 639
 640 void Session::setFinishedTorrentExportDirectory(QString path)
 641 {
 642     path = Utils::Fs::toUniformPath(path);
 643     if (path != finishedTorrentExportDirectory())
 644         m_finishedTorrentExportDirectory = path;
 645 }
 646
 647 QString Session::defaultSavePath() const
 648 {
 649     return Utils::Fs::toUniformPath(m_defaultSavePath);
 650 }
 651
 652 QString Session::tempPath() const
 653 {
 654     return Utils::Fs::toUniformPath(m_tempPath);
 655 }
 656
 657 QString Session::torrentTempPath(const TorrentInfo &torrentInfo) const
 658 {
 659     if ((torrentInfo.filesCount() > 1) && !torrentInfo.hasRootFolder())
 660         return tempPath() + torrentInfo.name() + '/';
 661
 662     return tempPath();
 663 }
 664
 665 bool Session::isValidCategoryName(const QString &name)
 666 {
 667     static const QRegularExpression re(R"(^([^\\\/]|[^\\\/]([^\\\/]|\/(?=[^\/]))*[^\\\/])$)");
 668     if (!name.isEmpty() && (name.indexOf(re) != 0))
 669     {
 670         qDebug() << "Incorrect category name:" << name;
 671         return false;
 672     }
 673
 674     return true;
 675 }
 676
 677 QStringList Session::expandCategory(const QString &category)
 678 {
 679     QStringList result;
 680     if (!isValidCategoryName(category))
 681         return result;
 682
 683     int index = 0;
 684     while ((index = category.indexOf('/', index)) >= 0)
 685     {
 686         result << category.left(index);
 687         ++index;
 688     }
 689     result << category;
 690
 691     return result;
 692 }
 693
 694 QStringMap Session::categories() const
 695 {
 696     return m_categories;
 697 }
 698
 699 QString Session::categorySavePath(const QString &categoryName) const
 700 {
 701     const QString basePath = m_defaultSavePath;
 702     if (categoryName.isEmpty()) return basePath;
 703
 704     QString path = m_categories.value(categoryName);
 705     if (path.isEmpty()) // use implicit save path
 706         path = Utils::Fs::toValidFileSystemName(categoryName, true);
 707
 708     if (!QDir::isAbsolutePath(path))
 709         path.prepend(basePath);
 710
 711     return normalizeSavePath(path);
 712 }
 713
 714 bool Session::addCategory(const QString &name, const QString &savePath)
 715 {
 716     if (name.isEmpty()) return false;
 717     if (!isValidCategoryName(name) || m_categories.contains(name))
 718         return false;
 719
 720     if (isSubcategoriesEnabled())
 721     {
 722         for (const QString &parent : asConst(expandCategory(name)))
 723         {
 724             if ((parent != name) && !m_categories.contains(parent))
 725             {
 726                 m_categories[parent] = "";
 727                 emit categoryAdded(parent);
 728             }
 729         }
 730     }
 731
 732     m_categories[name] = savePath;
 733     m_storedCategories = map_cast(m_categories);
 734     emit categoryAdded(name);
 735
 736     return true;
 737 }
 738
 739 bool Session::editCategory(const QString &name, const QString &savePath)
 740 {
 741     if (!m_categories.contains(name)) return false;
 742     if (categorySavePath(name) == savePath) return false;
 743
 744     m_categories[name] = savePath;
 745     m_storedCategories = map_cast(m_categories);
 746     if (isDisableAutoTMMWhenCategorySavePathChanged())
 747     {
 748         for (TorrentImpl *const torrent : asConst(m_torrents))
 749             if (torrent->category() == name)
 750                 torrent->setAutoTMMEnabled(false);
 751     }
 752     else
 753     {
 754         for (TorrentImpl *const torrent : asConst(m_torrents))
 755             if (torrent->category() == name)
 756                 torrent->handleCategorySavePathChanged();
 757     }
 758
 759     return true;
 760 }
 761
 762 bool Session::removeCategory(const QString &name)
 763 {
 764     for (TorrentImpl *const torrent : asConst(m_torrents))
 765         if (torrent->belongsToCategory(name))
 766             torrent->setCategory("");
 767
 768     // remove stored category and its subcategories if exist
 769     bool result = false;
 770     if (isSubcategoriesEnabled())
 771     {
 772         // remove subcategories
 773         const QString test = name + '/';
 774         Algorithm::removeIf(m_categories, [this, &test, &result](const QString &category, const QString &)
 775         {
 776             if (category.startsWith(test))
 777             {
 778                 result = true;
 779                 emit categoryRemoved(category);
 780                 return true;
 781             }
 782             return false;
 783         });
 784     }
 785
 786     result = (m_categories.remove(name) > 0) || result;
 787
 788     if (result)
 789     {
 790         // update stored categories
 791         m_storedCategories = map_cast(m_categories);
 792         emit categoryRemoved(name);
 793     }
 794
 795     return result;
 796 }
 797
 798 bool Session::isSubcategoriesEnabled() const
 799 {
 800     return m_isSubcategoriesEnabled;
 801 }
 802
 803 void Session::setSubcategoriesEnabled(const bool value)
 804 {
 805     if (isSubcategoriesEnabled() == value) return;
 806
 807     if (value)
 808     {
 809         // expand categories to include all parent categories
 810         m_categories = expandCategories(m_categories);
 811         // update stored categories
 812         m_storedCategories = map_cast(m_categories);
 813     }
 814     else
 815     {
 816         // reload categories
 817         m_categories = map_cast(m_storedCategories);
 818     }
 819
 820     m_isSubcategoriesEnabled = value;
 821     emit subcategoriesSupportChanged();
 822 }
 823
 824 QSet<QString> Session::tags() const
 825 {
 826     return m_tags;
 827 }
 828
 829 bool Session::isValidTag(const QString &tag)
 830 {
 831     return (!tag.trimmed().isEmpty() && !tag.contains(','));
 832 }
 833
 834 bool Session::hasTag(const QString &tag) const
 835 {
 836     return m_tags.contains(tag);
 837 }
 838
 839 bool Session::addTag(const QString &tag)
 840 {
 841     if (!isValidTag(tag) || hasTag(tag))
 842         return false;
 843
 844     m_tags.insert(tag);
 845     m_storedTags = m_tags.values();
 846     emit tagAdded(tag);
 847     return true;
 848 }
 849
 850 bool Session::removeTag(const QString &tag)
 851 {
 852     if (m_tags.remove(tag))
 853     {
 854         for (TorrentImpl *const torrent : asConst(m_torrents))
 855             torrent->removeTag(tag);
 856         m_storedTags = m_tags.values();
 857         emit tagRemoved(tag);
 858         return true;
 859     }
 860     return false;
 861 }
 862
 863 bool Session::isAutoTMMDisabledByDefault() const
 864 {
 865     return m_isAutoTMMDisabledByDefault;
 866 }
 867
 868 void Session::setAutoTMMDisabledByDefault(const bool value)
 869 {
 870     m_isAutoTMMDisabledByDefault = value;
 871 }
 872
 873 bool Session::isDisableAutoTMMWhenCategoryChanged() const
 874 {
 875     return m_isDisableAutoTMMWhenCategoryChanged;
 876 }
 877
 878 void Session::setDisableAutoTMMWhenCategoryChanged(const bool value)
 879 {
 880     m_isDisableAutoTMMWhenCategoryChanged = value;
 881 }
 882
 883 bool Session::isDisableAutoTMMWhenDefaultSavePathChanged() const
 884 {
 885     return m_isDisableAutoTMMWhenDefaultSavePathChanged;
 886 }
 887
 888 void Session::setDisableAutoTMMWhenDefaultSavePathChanged(const bool value)
 889 {
 890     m_isDisableAutoTMMWhenDefaultSavePathChanged = value;
 891 }
 892
 893 bool Session::isDisableAutoTMMWhenCategorySavePathChanged() const
 894 {
 895     return m_isDisableAutoTMMWhenCategorySavePathChanged;
 896 }
 897
 898 void Session::setDisableAutoTMMWhenCategorySavePathChanged(const bool value)
 899 {
 900     m_isDisableAutoTMMWhenCategorySavePathChanged = value;
 901 }
 902
 903 bool Session::isAddTorrentPaused() const
 904 {
 905     return m_isAddTorrentPaused;
 906 }
 907
 908 void Session::setAddTorrentPaused(const bool value)
 909 {
 910     m_isAddTorrentPaused = value;
 911 }
 912
 913 bool Session::isTrackerEnabled() const
 914 {
 915     return m_isTrackerEnabled;
 916 }
 917
 918 void Session::setTrackerEnabled(const bool enabled)
 919 {
 920     if (m_isTrackerEnabled != enabled)
 921         m_isTrackerEnabled = enabled;
 922
 923     // call enableTracker() unconditionally, otherwise port change won't trigger
 924     // tracker restart
 925     enableTracker(enabled);
 926 }
 927
 928 qreal Session::globalMaxRatio() const
 929 {
 930     return m_globalMaxRatio;
 931 }
 932
 933 // Torrents with a ratio superior to the given value will
 934 // be automatically deleted
 935 void Session::setGlobalMaxRatio(qreal ratio)
 936 {
 937     if (ratio < 0)
 938         ratio = -1.;
 939
 940     if (ratio != globalMaxRatio())
 941     {
 942         m_globalMaxRatio = ratio;
 943         updateSeedingLimitTimer();
 944     }
 945 }
 946
 947 int Session::globalMaxSeedingMinutes() const
 948 {
 949     return m_globalMaxSeedingMinutes;
 950 }
 951
 952 void Session::setGlobalMaxSeedingMinutes(int minutes)
 953 {
 954     if (minutes < 0)
 955         minutes = -1;
 956
 957     if (minutes != globalMaxSeedingMinutes())
 958     {
 959         m_globalMaxSeedingMinutes = minutes;
 960         updateSeedingLimitTimer();
 961     }
 962 }
 963
 964 // Main destructor
 965 Session::~Session()
 966 {
 967     // Do some BT related saving
 968     saveResumeData();
 969
 970     // We must delete FilterParserThread
 971     // before we delete lt::session
 972     delete m_filterParser;
 973
 974     // We must delete PortForwarderImpl before
 975     // we delete lt::session
 976     delete Net::PortForwarder::instance();
 977
 978     qDebug("Deleting the session");
 979     delete m_nativeSession;
 980
 981     m_ioThread->quit();
 982     m_ioThread->wait();
 983 }
 984
 985 void Session::initInstance()
 986 {
 987     if (!m_instance)
 988         m_instance = new Session;
 989 }
 990
 991 void Session::freeInstance()
 992 {
 993     delete m_instance;
 994     m_instance = nullptr;
 995 }
 996
 997 Session *Session::instance()
 998 {
 999     return m_instance;
1000 }
1001
1002 void Session::adjustLimits()
1003 {
1004     if (isQueueingSystemEnabled())
1005     {
1006         lt::settings_pack settingsPack = m_nativeSession->get_settings();
1007         adjustLimits(settingsPack);
1008         m_nativeSession->apply_settings(settingsPack);
1009     }
1010 }
1011
1012 void Session::applyBandwidthLimits()
1013 {
1014     lt::settings_pack settingsPack = m_nativeSession->get_settings();
1015     applyBandwidthLimits(settingsPack);
1016     m_nativeSession->apply_settings(settingsPack);
1017 }
1018
1019 void Session::configure()
1020 {
1021     lt::settings_pack settingsPack = m_nativeSession->get_settings();
1022     loadLTSettings(settingsPack);
1023     m_nativeSession->apply_settings(settingsPack);
1024
1025     configureComponents();
1026
1027     m_deferredConfigureScheduled = false;
1028 }
1029
1030 void Session::configureComponents()
1031 {
1032     // This function contains components/actions that:
1033     // 1. Need to be setup at start up
1034     // 2. When deferred configure is called
1035
1036     configurePeerClasses();
1037
1038     if (!m_IPFilteringConfigured)
1039     {
1040         if (isIPFilteringEnabled())
1041             enableIPFilter();
1042         else
1043             disableIPFilter();
1044         m_IPFilteringConfigured = true;
1045     }
1046
1047 #if defined(Q_OS_WIN)
1048     applyOSMemoryPriority();
1049 #endif
1050 }
1051
1052 void Session::initializeNativeSession()
1053 {
1054     const lt::alert_category_t alertMask = lt::alert::error_notification
1055         | lt::alert::file_progress_notification
1056         | lt::alert::ip_block_notification
1057         | lt::alert::peer_notification
1058         | lt::alert::performance_warning
1059         | lt::alert::port_mapping_notification
1060         | lt::alert::status_notification
1061         | lt::alert::storage_notification
1062         | lt::alert::tracker_notification;
1063     const std::string peerId = lt::generate_fingerprint(PEER_ID, QBT_VERSION_MAJOR, QBT_VERSION_MINOR, QBT_VERSION_BUGFIX, QBT_VERSION_BUILD);
1064
1065     lt::settings_pack pack;
1066     pack.set_int(lt::settings_pack::alert_mask, alertMask);
1067     pack.set_str(lt::settings_pack::peer_fingerprint, peerId);
1068     pack.set_bool(lt::settings_pack::listen_system_port_fallback, false);
1069     pack.set_str(lt::settings_pack::user_agent, USER_AGENT);
1070     pack.set_bool(lt::settings_pack::use_dht_as_fallback, false);
1071     // Speed up exit
1072     pack.set_int(lt::settings_pack::auto_scrape_interval, 1200); // 20 minutes
1073     pack.set_int(lt::settings_pack::auto_scrape_min_interval, 900); // 15 minutes
1074     // libtorrent 1.1 enables UPnP & NAT-PMP by default
1075     // turn them off before `lt::session` ctor to avoid split second effects
1076     pack.set_bool(lt::settings_pack::enable_upnp, false);
1077     pack.set_bool(lt::settings_pack::enable_natpmp, false);
1078
1079 #if (LIBTORRENT_VERSION_NUM > 20000)
1080     // preserve the same behavior as in earlier libtorrent versions
1081     pack.set_bool(lt::settings_pack::enable_set_file_valid_data, true);
1082 #endif
1083
1084     loadLTSettings(pack);
1085     lt::session_params sessionParams {pack, {}};
1086 #if (LIBTORRENT_VERSION_NUM >= 20000)
1087     sessionParams.disk_io_constructor = customDiskIOConstructor;
1088 #endif
1089     m_nativeSession = new lt::session {sessionParams};
1090
1091     LogMsg(tr("Peer ID: ") + QString::fromStdString(peerId));
1092     LogMsg(tr("HTTP User-Agent is '%1'").arg(USER_AGENT));
1093     LogMsg(tr("DHT support [%1]").arg(isDHTEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1094     LogMsg(tr("Local Peer Discovery support [%1]").arg(isLSDEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1095     LogMsg(tr("PeX support [%1]").arg(isPeXEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1096     LogMsg(tr("Anonymous mode [%1]").arg(isAnonymousModeEnabled() ? tr("ON") : tr("OFF")), Log::INFO);
1097     LogMsg(tr("Encryption support [%1]").arg((encryption() == 0) ? tr("ON") :
1098         ((encryption() == 1) ? tr("FORCED") : tr("OFF"))), Log::INFO);
1099
1100     m_nativeSession->set_alert_notify([this]()
1101     {
1102         QMetaObject::invokeMethod(this, &Session::readAlerts, Qt::QueuedConnection);
1103     });
1104
1105     // Enabling plugins
1106     m_nativeSession->add_extension(&lt::create_smart_ban_plugin);
1107     m_nativeSession->add_extension(&lt::create_ut_metadata_plugin);
1108     if (isPeXEnabled())
1109         m_nativeSession->add_extension(&lt::create_ut_pex_plugin);
1110
1111     m_nativeSession->add_extension(std::make_shared<NativeSessionExtension>());
1112 }
1113
1114 void Session::processBannedIPs(lt::ip_filter &filter)
1115 {
1116     // First, import current filter
1117     for (const QString &ip : asConst(m_bannedIPs.get()))
1118     {
1119         lt::error_code ec;
1120         const lt::address addr = lt::make_address(ip.toLatin1().constData(), ec);
1121         Q_ASSERT(!ec);
1122         if (!ec)
1123             filter.add_rule(addr, addr, lt::ip_filter::blocked);
1124     }
1125 }
1126
1127 void Session::adjustLimits(lt::settings_pack &settingsPack) const
1128 {
1129     // Internally increase the queue limits to ensure that the magnet is started
1130     const int maxDownloads = maxActiveDownloads();
1131     const int maxActive = maxActiveTorrents();
1132
1133     settingsPack.set_int(lt::settings_pack::active_downloads
1134                          , maxDownloads > -1 ? maxDownloads + m_extraLimit : maxDownloads);
1135     settingsPack.set_int(lt::settings_pack::active_limit
1136                          , maxActive > -1 ? maxActive + m_extraLimit : maxActive);
1137 }
1138
1139 void Session::applyBandwidthLimits(lt::settings_pack &settingsPack) const
1140 {
1141     const bool altSpeedLimitEnabled = isAltGlobalSpeedLimitEnabled();
1142     settingsPack.set_int(lt::settings_pack::download_rate_limit, altSpeedLimitEnabled ? altGlobalDownloadSpeedLimit() : globalDownloadSpeedLimit());
1143     settingsPack.set_int(lt::settings_pack::upload_rate_limit, altSpeedLimitEnabled ? altGlobalUploadSpeedLimit() : globalUploadSpeedLimit());
1144 }
1145
1146 void Session::initMetrics()
1147 {
1148     const auto findMetricIndex = [](const char *name) -> int
1149     {
1150         const int index = lt::find_metric_idx(name);
1151         Q_ASSERT(index >= 0);
1152         return index;
1153     };
1154
1155     // TODO: switch to "designated initializers" in C++20
1156     m_metricIndices.net.hasIncomingConnections = findMetricIndex("net.has_incoming_connections");
1157     m_metricIndices.net.sentPayloadBytes = findMetricIndex("net.sent_payload_bytes");
1158     m_metricIndices.net.recvPayloadBytes = findMetricIndex("net.recv_payload_bytes");
1159     m_metricIndices.net.sentBytes = findMetricIndex("net.sent_bytes");
1160     m_metricIndices.net.recvBytes = findMetricIndex("net.recv_bytes");
1161     m_metricIndices.net.sentIPOverheadBytes = findMetricIndex("net.sent_ip_overhead_bytes");
1162     m_metricIndices.net.recvIPOverheadBytes = findMetricIndex("net.recv_ip_overhead_bytes");
1163     m_metricIndices.net.sentTrackerBytes = findMetricIndex("net.sent_tracker_bytes");
1164     m_metricIndices.net.recvTrackerBytes = findMetricIndex("net.recv_tracker_bytes");
1165     m_metricIndices.net.recvRedundantBytes = findMetricIndex("net.recv_redundant_bytes");
1166     m_metricIndices.net.recvFailedBytes = findMetricIndex("net.recv_failed_bytes");
1167
1168     m_metricIndices.peer.numPeersConnected = findMetricIndex("peer.num_peers_connected");
1169     m_metricIndices.peer.numPeersDownDisk = findMetricIndex("peer.num_peers_down_disk");
1170     m_metricIndices.peer.numPeersUpDisk = findMetricIndex("peer.num_peers_up_disk");
1171
1172     m_metricIndices.dht.dhtBytesIn = findMetricIndex("dht.dht_bytes_in");
1173     m_metricIndices.dht.dhtBytesOut = findMetricIndex("dht.dht_bytes_out");
1174     m_metricIndices.dht.dhtNodes = findMetricIndex("dht.dht_nodes");
1175
1176     m_metricIndices.disk.diskBlocksInUse = findMetricIndex("disk.disk_blocks_in_use");
1177     m_metricIndices.disk.numBlocksRead = findMetricIndex("disk.num_blocks_read");
1178 #if (LIBTORRENT_VERSION_NUM < 20000)
1179     m_metricIndices.disk.numBlocksCacheHits = findMetricIndex("disk.num_blocks_cache_hits");
1180 #endif
1181     m_metricIndices.disk.writeJobs = findMetricIndex("disk.num_write_ops");
1182     m_metricIndices.disk.readJobs = findMetricIndex("disk.num_read_ops");
1183     m_metricIndices.disk.hashJobs = findMetricIndex("disk.num_blocks_hashed");
1184     m_metricIndices.disk.queuedDiskJobs = findMetricIndex("disk.queued_disk_jobs");
1185     m_metricIndices.disk.diskJobTime = findMetricIndex("disk.disk_job_time");
1186 }
1187
1188 void Session::loadLTSettings(lt::settings_pack &settingsPack)
1189 {
1190     settingsPack.set_int(lt::settings_pack::connection_speed, connectionSpeed());
1191
1192     // from libtorrent doc:
1193     // It will not take affect until the listen_interfaces settings is updated
1194     settingsPack.set_int(lt::settings_pack::listen_queue_size, socketBacklogSize());
1195
1196     configureNetworkInterfaces(settingsPack);
1197     applyBandwidthLimits(settingsPack);
1198
1199     // The most secure, rc4 only so that all streams are encrypted
1200     settingsPack.set_int(lt::settings_pack::allowed_enc_level, lt::settings_pack::pe_rc4);
1201     settingsPack.set_bool(lt::settings_pack::prefer_rc4, true);
1202     switch (encryption())
1203     {
1204     case 0: // Enabled
1205         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_enabled);
1206         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_enabled);
1207         break;
1208     case 1: // Forced
1209         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_forced);
1210         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_forced);
1211         break;
1212     default: // Disabled
1213         settingsPack.set_int(lt::settings_pack::out_enc_policy, lt::settings_pack::pe_disabled);
1214         settingsPack.set_int(lt::settings_pack::in_enc_policy, lt::settings_pack::pe_disabled);
1215     }
1216
1217     // proxy
1218     const auto proxyManager = Net::ProxyConfigurationManager::instance();
1219     const Net::ProxyConfiguration proxyConfig = proxyManager->proxyConfiguration();
1220
1221     switch (proxyConfig.type)
1222     {
1223     case Net::ProxyType::HTTP:
1224         settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::http);
1225         break;
1226     case Net::ProxyType::HTTP_PW:
1227         settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::http_pw);
1228         break;
1229     case Net::ProxyType::SOCKS4:
1230         settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks4);
1231         break;
1232     case Net::ProxyType::SOCKS5:
1233         settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks5);
1234         break;
1235     case Net::ProxyType::SOCKS5_PW:
1236         settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::socks5_pw);
1237         break;
1238     case Net::ProxyType::None:
1239     default:
1240         settingsPack.set_int(lt::settings_pack::proxy_type, lt::settings_pack::none);
1241     }
1242
1243     if (proxyConfig.type != Net::ProxyType::None)
1244     {
1245         settingsPack.set_str(lt::settings_pack::proxy_hostname, proxyConfig.ip.toStdString());
1246         settingsPack.set_int(lt::settings_pack::proxy_port, proxyConfig.port);
1247
1248         if (proxyManager->isAuthenticationRequired())
1249         {
1250             settingsPack.set_str(lt::settings_pack::proxy_username, proxyConfig.username.toStdString());
1251             settingsPack.set_str(lt::settings_pack::proxy_password, proxyConfig.password.toStdString());
1252         }
1253
1254         settingsPack.set_bool(lt::settings_pack::proxy_peer_connections, isProxyPeerConnectionsEnabled());
1255     }
1256
1257     settingsPack.set_bool(lt::settings_pack::announce_to_all_trackers, announceToAllTrackers());
1258     settingsPack.set_bool(lt::settings_pack::announce_to_all_tiers, announceToAllTiers());
1259
1260     settingsPack.set_int(lt::settings_pack::peer_turnover, peerTurnover());
1261     settingsPack.set_int(lt::settings_pack::peer_turnover_cutoff, peerTurnoverCutoff());
1262     settingsPack.set_int(lt::settings_pack::peer_turnover_interval, peerTurnoverInterval());
1263
1264     settingsPack.set_int(lt::settings_pack::aio_threads, asyncIOThreads());
1265 #if (LIBTORRENT_VERSION_NUM >= 20000)
1266     settingsPack.set_int(lt::settings_pack::hashing_threads, hashingThreads());
1267 #endif
1268     settingsPack.set_int(lt::settings_pack::file_pool_size, filePoolSize());
1269
1270     const int checkingMemUsageSize = checkingMemUsage() * 64;
1271     settingsPack.set_int(lt::settings_pack::checking_mem_usage, checkingMemUsageSize);
1272
1273 #if (LIBTORRENT_VERSION_NUM < 20000)
1274     const int cacheSize = (diskCacheSize() > -1) ? (diskCacheSize() * 64) : -1;
1275     settingsPack.set_int(lt::settings_pack::cache_size, cacheSize);
1276     settingsPack.set_int(lt::settings_pack::cache_expiry, diskCacheTTL());
1277 #endif
1278
1279     lt::settings_pack::io_buffer_mode_t mode = useOSCache() ? lt::settings_pack::enable_os_cache
1280                                                               : lt::settings_pack::disable_os_cache;
1281     settingsPack.set_int(lt::settings_pack::disk_io_read_mode, mode);
1282     settingsPack.set_int(lt::settings_pack::disk_io_write_mode, mode);
1283
1284 #if (LIBTORRENT_VERSION_NUM < 20000)
1285     settingsPack.set_bool(lt::settings_pack::coalesce_reads, isCoalesceReadWriteEnabled());
1286     settingsPack.set_bool(lt::settings_pack::coalesce_writes, isCoalesceReadWriteEnabled());
1287 #endif
1288
1289     settingsPack.set_bool(lt::settings_pack::piece_extent_affinity, usePieceExtentAffinity());
1290
1291     settingsPack.set_int(lt::settings_pack::suggest_mode, isSuggestModeEnabled()
1292                          ? lt::settings_pack::suggest_read_cache : lt::settings_pack::no_piece_suggestions);
1293
1294     settingsPack.set_int(lt::settings_pack::send_buffer_watermark, sendBufferWatermark() * 1024);
1295     settingsPack.set_int(lt::settings_pack::send_buffer_low_watermark, sendBufferLowWatermark() * 1024);
1296     settingsPack.set_int(lt::settings_pack::send_buffer_watermark_factor, sendBufferWatermarkFactor());
1297
1298     settingsPack.set_bool(lt::settings_pack::anonymous_mode, isAnonymousModeEnabled());
1299
1300     // Queueing System
1301     if (isQueueingSystemEnabled())
1302     {
1303         adjustLimits(settingsPack);
1304
1305         settingsPack.set_int(lt::settings_pack::active_seeds, maxActiveUploads());
1306         settingsPack.set_bool(lt::settings_pack::dont_count_slow_torrents, ignoreSlowTorrentsForQueueing());
1307         settingsPack.set_int(lt::settings_pack::inactive_down_rate, downloadRateForSlowTorrents() * 1024); // KiB to Bytes
1308         settingsPack.set_int(lt::settings_pack::inactive_up_rate, uploadRateForSlowTorrents() * 1024); // KiB to Bytes
1309         settingsPack.set_int(lt::settings_pack::auto_manage_startup, slowTorrentsInactivityTimer());
1310     }
1311     else
1312     {
1313         settingsPack.set_int(lt::settings_pack::active_downloads, -1);
1314         settingsPack.set_int(lt::settings_pack::active_seeds, -1);
1315         settingsPack.set_int(lt::settings_pack::active_limit, -1);
1316     }
1317     settingsPack.set_int(lt::settings_pack::active_tracker_limit, -1);
1318     settingsPack.set_int(lt::settings_pack::active_dht_limit, -1);
1319     settingsPack.set_int(lt::settings_pack::active_lsd_limit, -1);
1320     settingsPack.set_int(lt::settings_pack::alert_queue_size, std::numeric_limits<int>::max() / 2);
1321
1322     // Outgoing ports
1323     settingsPack.set_int(lt::settings_pack::outgoing_port, outgoingPortsMin());
1324     settingsPack.set_int(lt::settings_pack::num_outgoing_ports, outgoingPortsMax() - outgoingPortsMin() + 1);
1325     // UPnP lease duration
1326     settingsPack.set_int(lt::settings_pack::upnp_lease_duration, UPnPLeaseDuration());
1327     // Type of service
1328     settingsPack.set_int(lt::settings_pack::peer_tos, peerToS());
1329     // Include overhead in transfer limits
1330     settingsPack.set_bool(lt::settings_pack::rate_limit_ip_overhead, includeOverheadInLimits());
1331     // IP address to announce to trackers
1332     settingsPack.set_str(lt::settings_pack::announce_ip, announceIP().toStdString());
1333     // Max concurrent HTTP announces
1334     settingsPack.set_int(lt::settings_pack::max_concurrent_http_announces, maxConcurrentHTTPAnnounces());
1335     // Stop tracker timeout
1336     settingsPack.set_int(lt::settings_pack::stop_tracker_timeout, stopTrackerTimeout());
1337     // * Max connections limit
1338     settingsPack.set_int(lt::settings_pack::connections_limit, maxConnections());
1339     // * Global max upload slots
1340     settingsPack.set_int(lt::settings_pack::unchoke_slots_limit, maxUploads());
1341     // uTP
1342     switch (btProtocol())
1343     {
1344     case BTProtocol::Both:
1345     default:
1346         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, true);
1347         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, true);
1348         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, true);
1349         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, true);
1350         break;
1351
1352     case BTProtocol::TCP:
1353         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, true);
1354         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, true);
1355         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, false);
1356         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, false);
1357         break;
1358
1359     case BTProtocol::UTP:
1360         settingsPack.set_bool(lt::settings_pack::enable_incoming_tcp, false);
1361         settingsPack.set_bool(lt::settings_pack::enable_outgoing_tcp, false);
1362         settingsPack.set_bool(lt::settings_pack::enable_incoming_utp, true);
1363         settingsPack.set_bool(lt::settings_pack::enable_outgoing_utp, true);
1364         break;
1365     }
1366
1367     switch (utpMixedMode())
1368     {
1369     case MixedModeAlgorithm::TCP:
1370     default:
1371         settingsPack.set_int(lt::settings_pack::mixed_mode_algorithm, lt::settings_pack::prefer_tcp);
1372         break;
1373     case MixedModeAlgorithm::Proportional:
1374         settingsPack.set_int(lt::settings_pack::mixed_mode_algorithm, lt::settings_pack::peer_proportional);
1375         break;
1376     }
1377
1378     settingsPack.set_bool(lt::settings_pack::allow_idna, isIDNSupportEnabled());
1379
1380     settingsPack.set_bool(lt::settings_pack::allow_multiple_connections_per_ip, multiConnectionsPerIpEnabled());
1381
1382     settingsPack.set_bool(lt::settings_pack::validate_https_trackers, validateHTTPSTrackerCertificate());
1383
1384     settingsPack.set_bool(lt::settings_pack::no_connect_privileged_ports, blockPeersOnPrivilegedPorts());
1385
1386     settingsPack.set_bool(lt::settings_pack::apply_ip_filter_to_trackers, isTrackerFilteringEnabled());
1387
1388     settingsPack.set_bool(lt::settings_pack::enable_dht, isDHTEnabled());
1389     if (isDHTEnabled())
1390         settingsPack.set_str(lt::settings_pack::dht_bootstrap_nodes, "dht.libtorrent.org:25401,router.bittorrent.com:6881,router.utorrent.com:6881,dht.transmissionbt.com:6881,dht.aelitis.com:6881");
1391     settingsPack.set_bool(lt::settings_pack::enable_lsd, isLSDEnabled());
1392
1393     switch (chokingAlgorithm())
1394     {
1395     case ChokingAlgorithm::FixedSlots:
1396     default:
1397         settingsPack.set_int(lt::settings_pack::choking_algorithm, lt::settings_pack::fixed_slots_choker);
1398         break;
1399     case ChokingAlgorithm::RateBased:
1400         settingsPack.set_int(lt::settings_pack::choking_algorithm, lt::settings_pack::rate_based_choker);
1401         break;
1402     }
1403
1404     switch (seedChokingAlgorithm())
1405     {
1406     case SeedChokingAlgorithm::RoundRobin:
1407         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::round_robin);
1408         break;
1409     case SeedChokingAlgorithm::FastestUpload:
1410     default:
1411         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::fastest_upload);
1412         break;
1413     case SeedChokingAlgorithm::AntiLeech:
1414         settingsPack.set_int(lt::settings_pack::seed_choking_algorithm, lt::settings_pack::anti_leech);
1415         break;
1416     }
1417 }
1418
1419 void Session::configureNetworkInterfaces(lt::settings_pack &settingsPack)
1420 {
1421     if (m_listenInterfaceConfigured)
1422         return;
1423
1424     const int port = useRandomPort() ? 0 : this->port();
1425     if (port > 0)  // user specified port
1426         settingsPack.set_int(lt::settings_pack::max_retry_port_bind, 0);
1427
1428     QStringList endpoints;
1429     QStringList outgoingInterfaces;
1430     const QString portString = ':' + QString::number(port);
1431
1432     for (const QString &ip : asConst(getListeningIPs()))
1433     {
1434         const QHostAddress addr {ip};
1435         if (!addr.isNull())
1436         {
1437             const bool isIPv6 = (addr.protocol() == QAbstractSocket::IPv6Protocol);
1438             const QString ip = isIPv6
1439                           ? Utils::Net::canonicalIPv6Addr(addr).toString()
1440                           : addr.toString();
1441
1442             endpoints << ((isIPv6 ? ('[' + ip + ']') : ip) + portString);
1443
1444             if ((ip != QLatin1String("0.0.0.0")) && (ip != QLatin1String("::")))
1445                 outgoingInterfaces << ip;
1446         }
1447         else
1448         {
1449             // ip holds an interface name
1450 #ifdef Q_OS_WIN
1451             // On Vista+ versions and after Qt 5.5 QNetworkInterface::name() returns
1452             // the interface's LUID and not the GUID.
1453             // Libtorrent expects GUIDs for the 'listen_interfaces' setting.
1454             const QString guid = convertIfaceNameToGuid(ip);
1455             if (!guid.isEmpty())
1456             {
1457                 endpoints << (guid + portString);
1458                 outgoingInterfaces << guid;
1459             }
1460             else
1461             {
1462                 LogMsg(tr("Could not get GUID of network interface: %1").arg(ip) , Log::WARNING);
1463                 // Since we can't get the GUID, we'll pass the interface name instead.
1464                 // Otherwise an empty string will be passed to outgoing_interface which will cause IP leak.
1465                 endpoints << (ip + portString);
1466                 outgoingInterfaces << ip;
1467             }
1468 #else
1469             endpoints << (ip + portString);
1470             outgoingInterfaces << ip;
1471 #endif
1472         }
1473     }
1474
1475     const QString finalEndpoints = endpoints.join(',');
1476     settingsPack.set_str(lt::settings_pack::listen_interfaces, finalEndpoints.toStdString());
1477     LogMsg(tr("Trying to listen on: %1", "e.g: Trying to listen on: 192.168.0.1:6881")
1478            .arg(finalEndpoints), Log::INFO);
1479
1480     settingsPack.set_str(lt::settings_pack::outgoing_interfaces, outgoingInterfaces.join(',').toStdString());
1481     m_listenInterfaceConfigured = true;
1482 }
1483
1484 void Session::configurePeerClasses()
1485 {
1486     lt::ip_filter f;
1487     // lt::make_address("255.255.255.255") crashes on some people's systems
1488     // so instead we use address_v4::broadcast()
1489     // Proactively do the same for 0.0.0.0 and address_v4::any()
1490     f.add_rule(lt::address_v4::any()
1491                , lt::address_v4::broadcast()
1492                , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::global_peer_class_id));
1493
1494     // IPv6 may not be available on OS and the parsing
1495     // would result in an exception -> abnormal program termination
1496     // Affects Windows XP
1497     try
1498     {
1499         f.add_rule(lt::address_v6::any()
1500                    , lt::make_address("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
1501                    , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::global_peer_class_id));
1502     }
1503     catch (const std::exception &) {}
1504
1505     if (ignoreLimitsOnLAN())
1506     {
1507         // local networks
1508         f.add_rule(lt::make_address("10.0.0.0")
1509                    , lt::make_address("10.255.255.255")
1510                    , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::local_peer_class_id));
1511         f.add_rule(lt::make_address("172.16.0.0")
1512                    , lt::make_address("172.31.255.255")
1513                    , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::local_peer_class_id));
1514         f.add_rule(lt::make_address("192.168.0.0")
1515                    , lt::make_address("192.168.255.255")
1516                    , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::local_peer_class_id));
1517         // link local
1518         f.add_rule(lt::make_address("169.254.0.0")
1519                    , lt::make_address("169.254.255.255")
1520                    , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::local_peer_class_id));
1521         // loopback
1522         f.add_rule(lt::make_address("127.0.0.0")
1523                    , lt::make_address("127.255.255.255")
1524                    , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::local_peer_class_id));
1525
1526         // IPv6 may not be available on OS and the parsing
1527         // would result in an exception -> abnormal program termination
1528         // Affects Windows XP
1529         try
1530         {
1531             // link local
1532             f.add_rule(lt::make_address("fe80::")
1533                        , lt::make_address("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
1534                        , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::local_peer_class_id));
1535             // unique local addresses
1536             f.add_rule(lt::make_address("fc00::")
1537                        , lt::make_address("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
1538                        , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::local_peer_class_id));
1539             // loopback
1540             f.add_rule(lt::address_v6::loopback()
1541                        , lt::address_v6::loopback()
1542                        , 1 << static_cast<LTUnderlyingType<lt::peer_class_t>>(lt::session::local_peer_class_id));
1543         }
1544         catch (const std::exception &) {}
1545     }
1546     m_nativeSession->set_peer_class_filter(f);
1547
1548     lt::peer_class_type_filter peerClassTypeFilter;
1549     peerClassTypeFilter.add(lt::peer_class_type_filter::tcp_socket, lt::session::tcp_peer_class_id);
1550     peerClassTypeFilter.add(lt::peer_class_type_filter::ssl_tcp_socket, lt::session::tcp_peer_class_id);
1551     peerClassTypeFilter.add(lt::peer_class_type_filter::i2p_socket, lt::session::tcp_peer_class_id);
1552     if (!isUTPRateLimited())
1553     {
1554         peerClassTypeFilter.disallow(lt::peer_class_type_filter::utp_socket
1555             , lt::session::global_peer_class_id);
1556         peerClassTypeFilter.disallow(lt::peer_class_type_filter::ssl_utp_socket
1557             , lt::session::global_peer_class_id);
1558     }
1559     m_nativeSession->set_peer_class_type_filter(peerClassTypeFilter);
1560 }
1561
1562 void Session::enableTracker(const bool enable)
1563 {
1564     if (enable)
1565     {
1566         if (!m_tracker)
1567             m_tracker = new Tracker(this);
1568
1569         m_tracker->start();
1570     }
1571     else
1572     {
1573         delete m_tracker;
1574     }
1575 }
1576
1577 void Session::enableBandwidthScheduler()
1578 {
1579     if (!m_bwScheduler)
1580     {
1581         m_bwScheduler = new BandwidthScheduler(this);
1582         connect(m_bwScheduler.data(), &BandwidthScheduler::bandwidthLimitRequested
1583                 , this, &Session::setAltGlobalSpeedLimitEnabled);
1584     }
1585     m_bwScheduler->start();
1586 }
1587
1588 void Session::populateAdditionalTrackers()
1589 {
1590     m_additionalTrackerList.clear();
1591
1592     const QString trackers = additionalTrackers();
1593     for (QStringRef tracker : asConst(trackers.splitRef('\n')))
1594     {
1595         tracker = tracker.trimmed();
1596         if (!tracker.isEmpty())
1597             m_additionalTrackerList.append({tracker.toString()});
1598     }
1599 }
1600
1601 void Session::processShareLimits()
1602 {
1603     qDebug("Processing share limits...");
1604
1605     // We shouldn't iterate over `m_torrents` in the loop below
1606     // since `deleteTorrent()` modifies it indirectly
1607     const QHash<TorrentID, TorrentImpl *> torrents {m_torrents};
1608     for (TorrentImpl *const torrent : torrents)
1609     {
1610         if (torrent->isSeed() && !torrent->isForced())
1611         {
1612             if (torrent->ratioLimit() != Torrent::NO_RATIO_LIMIT)
1613             {
1614                 const qreal ratio = torrent->realRatio();
1615                 qreal ratioLimit = torrent->ratioLimit();
1616                 if (ratioLimit == Torrent::USE_GLOBAL_RATIO)
1617                     // If Global Max Ratio is really set...
1618                     ratioLimit = globalMaxRatio();
1619
1620                 if (ratioLimit >= 0)
1621                 {
1622                     qDebug("Ratio: %f (limit: %f)", ratio, ratioLimit);
1623
1624                     if ((ratio <= Torrent::MAX_RATIO) && (ratio >= ratioLimit))
1625                     {
1626                         if (m_maxRatioAction == Remove)
1627                         {
1628                             LogMsg(tr("'%1' reached the maximum ratio you set. Removed.").arg(torrent->name()));
1629                             deleteTorrent(torrent->id());
1630                         }
1631                         else if (m_maxRatioAction == DeleteFiles)
1632                         {
1633                             LogMsg(tr("'%1' reached the maximum ratio you set. Removed torrent and its files.").arg(torrent->name()));
1634                             deleteTorrent(torrent->id(), DeleteTorrentAndFiles);
1635                         }
1636                         else if ((m_maxRatioAction == Pause) && !torrent->isPaused())
1637                         {
1638                             torrent->pause();
1639                             LogMsg(tr("'%1' reached the maximum ratio you set. Paused.").arg(torrent->name()));
1640                         }
1641                         else if ((m_maxRatioAction == EnableSuperSeeding) && !torrent->isPaused() && !torrent->superSeeding())
1642                         {
1643                             torrent->setSuperSeeding(true);
1644                             LogMsg(tr("'%1' reached the maximum ratio you set. Enabled super seeding for it.").arg(torrent->name()));
1645                         }
1646                         continue;
1647                     }
1648                 }
1649             }
1650
1651             if (torrent->seedingTimeLimit() != Torrent::NO_SEEDING_TIME_LIMIT)
1652             {
1653                 const qlonglong seedingTimeInMinutes = torrent->seedingTime() / 60;
1654                 int seedingTimeLimit = torrent->seedingTimeLimit();
1655                 if (seedingTimeLimit == Torrent::USE_GLOBAL_SEEDING_TIME)
1656                 {
1657                      // If Global Seeding Time Limit is really set...
1658                     seedingTimeLimit = globalMaxSeedingMinutes();
1659                 }
1660
1661                 if (seedingTimeLimit >= 0)
1662                 {
1663                     if ((seedingTimeInMinutes <= Torrent::MAX_SEEDING_TIME) && (seedingTimeInMinutes >= seedingTimeLimit))
1664                     {
1665                         if (m_maxRatioAction == Remove)
1666                         {
1667                             LogMsg(tr("'%1' reached the maximum seeding time you set. Removed.").arg(torrent->name()));
1668                             deleteTorrent(torrent->id());
1669                         }
1670                         else if (m_maxRatioAction == DeleteFiles)
1671                         {
1672                             LogMsg(tr("'%1' reached the maximum seeding time you set. Removed torrent and its files.").arg(torrent->name()));
1673                             deleteTorrent(torrent->id(), DeleteTorrentAndFiles);
1674                         }
1675                         else if ((m_maxRatioAction == Pause) && !torrent->isPaused())
1676                         {
1677                             torrent->pause();
1678                             LogMsg(tr("'%1' reached the maximum seeding time you set. Paused.").arg(torrent->name()));
1679                         }
1680                         else if ((m_maxRatioAction == EnableSuperSeeding) && !torrent->isPaused() && !torrent->superSeeding())
1681                         {
1682                             torrent->setSuperSeeding(true);
1683                             LogMsg(tr("'%1' reached the maximum seeding time you set. Enabled super seeding for it.").arg(torrent->name()));
1684                         }
1685                     }
1686                 }
1687             }
1688         }
1689     }
1690 }
1691
1692 // Add to BitTorrent session the downloaded torrent file
1693 void Session::handleDownloadFinished(const Net::DownloadResult &result)
1694 {
1695     switch (result.status)
1696     {
1697     case Net::DownloadStatus::Success:
1698         emit downloadFromUrlFinished(result.url);
1699         addTorrent(TorrentInfo::load(result.data), m_downloadedTorrents.take(result.url));
1700         break;
1701     case Net::DownloadStatus::RedirectedToMagnet:
1702         emit downloadFromUrlFinished(result.url);
1703         addTorrent(MagnetUri {result.magnet}, m_downloadedTorrents.take(result.url));
1704         break;
1705     default:
1706         emit downloadFromUrlFailed(result.url, result.errorString);
1707     }
1708 }
1709
1710 void Session::fileSearchFinished(const TorrentID &id, const QString &savePath, const QStringList &fileNames)
1711 {
1712     TorrentImpl *torrent = m_torrents.value(id);
1713     if (torrent)
1714     {
1715         torrent->fileSearchFinished(savePath, fileNames);
1716         return;
1717     }
1718
1719     const auto loadingTorrentsIter = m_loadingTorrents.find(id);
1720     if (loadingTorrentsIter != m_loadingTorrents.end())
1721     {
1722         LoadTorrentParams params = loadingTorrentsIter.value();
1723         m_loadingTorrents.erase(loadingTorrentsIter);
1724
1725         lt::add_torrent_params &p = params.ltAddTorrentParams;
1726
1727         p.save_path = Utils::Fs::toNativePath(savePath).toStdString();
1728         for (int i = 0; i < fileNames.size(); ++i)
1729             p.renamed_files[lt::file_index_t {i}] = fileNames[i].toStdString();
1730
1731         loadTorrent(params);
1732     }
1733 }
1734
1735 // Return the torrent handle, given its hash
1736 Torrent *Session::findTorrent(const TorrentID &id) const
1737 {
1738     return m_torrents.value(id);
1739 }
1740
1741 bool Session::hasActiveTorrents() const
1742 {
1743     return std::any_of(m_torrents.begin(), m_torrents.end(), [](TorrentImpl *torrent)
1744     {
1745         return TorrentFilter::ActiveTorrent.match(torrent);
1746     });
1747 }
1748
1749 bool Session::hasUnfinishedTorrents() const
1750 {
1751     return std::any_of(m_torrents.begin(), m_torrents.end(), [](const TorrentImpl *torrent)
1752     {
1753         return (!torrent->isSeed() && !torrent->isPaused() && !torrent->isErrored());
1754     });
1755 }
1756
1757 bool Session::hasRunningSeed() const
1758 {
1759     return std::any_of(m_torrents.begin(), m_torrents.end(), [](const TorrentImpl *torrent)
1760     {
1761         return (torrent->isSeed() && !torrent->isPaused());
1762     });
1763 }
1764
1765 void Session::banIP(const QString &ip)
1766 {
1767     QStringList bannedIPs = m_bannedIPs;
1768     if (!bannedIPs.contains(ip))
1769     {
1770         lt::ip_filter filter = m_nativeSession->get_ip_filter();
1771         lt::error_code ec;
1772         const lt::address addr = lt::make_address(ip.toLatin1().constData(), ec);
1773         Q_ASSERT(!ec);
1774         if (ec) return;
1775         filter.add_rule(addr, addr, lt::ip_filter::blocked);
1776         m_nativeSession->set_ip_filter(filter);
1777
1778         bannedIPs << ip;
1779         bannedIPs.sort();
1780         m_bannedIPs = bannedIPs;
1781     }
1782 }
1783
1784 // Delete a torrent from the session, given its hash
1785 // and from the disk, if the corresponding deleteOption is chosen
1786 bool Session::deleteTorrent(const TorrentID &id, const DeleteOption deleteOption)
1787 {
1788     TorrentImpl *const torrent = m_torrents.take(id);
1789     if (!torrent) return false;
1790
1791     qDebug("Deleting torrent with ID: %s", qUtf8Printable(torrent->id().toString()));
1792     emit torrentAboutToBeRemoved(torrent);
1793
1794     // Remove it from session
1795     if (deleteOption == DeleteTorrent)
1796     {
1797         m_removingTorrents[torrent->id()] = {torrent->name(), "", deleteOption};
1798
1799         const lt::torrent_handle nativeHandle {torrent->nativeHandle()};
1800         const auto iter = std::find_if(m_moveStorageQueue.begin(), m_moveStorageQueue.end()
1801                                  , [&nativeHandle](const MoveStorageJob &job)
1802         {
1803             return job.torrentHandle == nativeHandle;
1804         });
1805         if (iter != m_moveStorageQueue.end())
1806         {
1807             // We shouldn't actually remove torrent until existing "move storage jobs" are done
1808             torrentQueuePositionBottom(nativeHandle);
1809             nativeHandle.unset_flags(lt::torrent_flags::auto_managed);
1810             nativeHandle.pause();
1811         }
1812         else
1813         {
1814             m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_partfile);
1815         }
1816     }
1817     else
1818     {
1819         QString rootPath = torrent->rootPath(true);
1820         if (!rootPath.isEmpty() && torrent->useTempPath())
1821         {
1822             // torrent without root folder still has it in its temporary save path
1823             rootPath = torrent->actualStorageLocation();
1824         }
1825
1826         m_removingTorrents[torrent->id()] = {torrent->name(), rootPath, deleteOption};
1827
1828         if (m_moveStorageQueue.size() > 1)
1829         {
1830             // Delete "move storage job" for the deleted torrent
1831             // (note: we shouldn't delete active job)
1832             const auto iter = std::find_if(m_moveStorageQueue.begin() + 1, m_moveStorageQueue.end()
1833                                      , [torrent](const MoveStorageJob &job)
1834             {
1835                 return job.torrentHandle == torrent->nativeHandle();
1836             });
1837             if (iter != m_moveStorageQueue.end())
1838                 m_moveStorageQueue.erase(iter);
1839         }
1840
1841         m_nativeSession->remove_torrent(torrent->nativeHandle(), lt::session::delete_files);
1842     }
1843
1844     // Remove it from torrent resume directory
1845     m_resumeDataStorage->remove(torrent->id());
1846
1847     delete torrent;
1848     return true;
1849 }
1850
1851 bool Session::cancelDownloadMetadata(const TorrentID &id)
1852 {
1853     const auto downloadedMetadataIter = m_downloadedMetadata.find(id);
1854     if (downloadedMetadataIter == m_downloadedMetadata.end()) return false;
1855
1856     m_downloadedMetadata.erase(downloadedMetadataIter);
1857     --m_extraLimit;
1858     adjustLimits();
1859     m_nativeSession->remove_torrent(m_nativeSession->find_torrent(id), lt::session::delete_files);
1860     return true;
1861 }
1862
1863 void Session::increaseTorrentsQueuePos(const QVector<TorrentID> &ids)
1864 {
1865     using ElementType = std::pair<int, const TorrentImpl *>;
1866     std::priority_queue<ElementType
1867         , std::vector<ElementType>
1868         , std::greater<ElementType>> torrentQueue;
1869
1870     // Sort torrents by queue position
1871     for (const TorrentID &id : ids)
1872     {
1873         const TorrentImpl *torrent = m_torrents.value(id);
1874         if (!torrent) continue;
1875         if (const int position = torrent->queuePosition(); position >= 0)
1876             torrentQueue.emplace(position, torrent);
1877     }
1878
1879     // Increase torrents queue position (starting with the one in the highest queue position)
1880     while (!torrentQueue.empty())
1881     {
1882         const TorrentImpl *torrent = torrentQueue.top().second;
1883         torrentQueuePositionUp(torrent->nativeHandle());
1884         torrentQueue.pop();
1885     }
1886
1887     saveTorrentsQueue();
1888 }
1889
1890 void Session::decreaseTorrentsQueuePos(const QVector<TorrentID> &ids)
1891 {
1892     using ElementType = std::pair<int, const TorrentImpl *>;
1893     std::priority_queue<ElementType> torrentQueue;
1894
1895     // Sort torrents by queue position
1896     for (const TorrentID &id : ids)
1897     {
1898         const TorrentImpl *torrent = m_torrents.value(id);
1899         if (!torrent) continue;
1900         if (const int position = torrent->queuePosition(); position >= 0)
1901             torrentQueue.emplace(position, torrent);
1902     }
1903
1904     // Decrease torrents queue position (starting with the one in the lowest queue position)
1905     while (!torrentQueue.empty())
1906     {
1907         const TorrentImpl *torrent = torrentQueue.top().second;
1908         torrentQueuePositionDown(torrent->nativeHandle());
1909         torrentQueue.pop();
1910     }
1911
1912     for (auto i = m_downloadedMetadata.cbegin(); i != m_downloadedMetadata.cend(); ++i)
1913         torrentQueuePositionBottom(m_nativeSession->find_torrent(*i));
1914
1915     saveTorrentsQueue();
1916 }
1917
1918 void Session::topTorrentsQueuePos(const QVector<TorrentID> &ids)
1919 {
1920     using ElementType = std::pair<int, const TorrentImpl *>;
1921     std::priority_queue<ElementType> torrentQueue;
1922
1923     // Sort torrents by queue position
1924     for (const TorrentID &id : ids)
1925     {
1926         const TorrentImpl *torrent = m_torrents.value(id);
1927         if (!torrent) continue;
1928         if (const int position = torrent->queuePosition(); position >= 0)
1929             torrentQueue.emplace(position, torrent);
1930     }
1931
1932     // Top torrents queue position (starting with the one in the lowest queue position)
1933     while (!torrentQueue.empty())
1934     {
1935         const TorrentImpl *torrent = torrentQueue.top().second;
1936         torrentQueuePositionTop(torrent->nativeHandle());
1937         torrentQueue.pop();
1938     }
1939
1940     saveTorrentsQueue();
1941 }
1942
1943 void Session::bottomTorrentsQueuePos(const QVector<TorrentID> &ids)
1944 {
1945     using ElementType = std::pair<int, const TorrentImpl *>;
1946     std::priority_queue<ElementType
1947         , std::vector<ElementType>
1948         , std::greater<ElementType>> torrentQueue;
1949
1950     // Sort torrents by queue position
1951     for (const TorrentID &id : ids)
1952     {
1953         const TorrentImpl *torrent = m_torrents.value(id);
1954         if (!torrent) continue;
1955         if (const int position = torrent->queuePosition(); position >= 0)
1956             torrentQueue.emplace(position, torrent);
1957     }
1958
1959     // Bottom torrents queue position (starting with the one in the highest queue position)
1960     while (!torrentQueue.empty())
1961     {
1962         const TorrentImpl *torrent = torrentQueue.top().second;
1963         torrentQueuePositionBottom(torrent->nativeHandle());
1964         torrentQueue.pop();
1965     }
1966
1967     for (auto i = m_downloadedMetadata.cbegin(); i != m_downloadedMetadata.cend(); ++i)
1968         torrentQueuePositionBottom(m_nativeSession->find_torrent(*i));
1969
1970     saveTorrentsQueue();
1971 }
1972
1973 void Session::handleTorrentNeedSaveResumeData(const TorrentImpl *torrent)
1974 {
1975     if (m_needSaveResumeDataTorrents.empty())
1976     {
1977         QMetaObject::invokeMethod(this, [this]()
1978         {
1979             for (const TorrentID &torrentID : asConst(m_needSaveResumeDataTorrents))
1980             {
1981                 TorrentImpl *torrent = m_torrents.value(torrentID);
1982                 if (torrent)
1983                     torrent->saveResumeData();
1984             }
1985             m_needSaveResumeDataTorrents.clear();
1986         }, Qt::QueuedConnection);
1987     }
1988
1989     m_needSaveResumeDataTorrents.insert(torrent->id());
1990 }
1991
1992 void Session::handleTorrentSaveResumeDataRequested(const TorrentImpl *torrent)
1993 {
1994     qDebug("Saving resume data is requested for torrent '%s'...", qUtf8Printable(torrent->name()));
1995     ++m_numResumeData;
1996 }
1997
1998 QVector<Torrent *> Session::torrents() const
1999 {
2000     QVector<Torrent *> result;
2001     result.reserve(m_torrents.size());
2002     for (TorrentImpl *torrent : asConst(m_torrents))
2003         result << torrent;
2004
2005     return result;
2006 }
2007
2008 bool Session::addTorrent(const QString &source, const AddTorrentParams &params)
2009 {
2010     // `source`: .torrent file path/url or magnet uri
2011
2012     if (Net::DownloadManager::hasSupportedScheme(source))
2013     {
2014         LogMsg(tr("Downloading '%1', please wait...", "e.g: Downloading 'xxx.torrent', please wait...").arg(source));
2015         // Launch downloader
2016         Net::DownloadManager::instance()->download(Net::DownloadRequest(source).limit(MAX_TORRENT_SIZE)
2017                                                    , this, &Session::handleDownloadFinished);
2018         m_downloadedTorrents[source] = params;
2019         return true;
2020     }
2021
2022     const MagnetUri magnetUri {source};
2023     if (magnetUri.isValid())
2024         return addTorrent(magnetUri, params);
2025
2026     TorrentFileGuard guard {source};
2027     if (addTorrent(TorrentInfo::loadFromFile(source), params))
2028     {
2029         guard.markAsAddedToSession();
2030         return true;
2031     }
2032
2033     return false;
2034 }
2035
2036 bool Session::addTorrent(const MagnetUri &magnetUri, const AddTorrentParams &params)
2037 {
2038     if (!magnetUri.isValid()) return false;
2039
2040     return addTorrent_impl(magnetUri, params);
2041 }
2042
2043 bool Session::addTorrent(const TorrentInfo &torrentInfo, const AddTorrentParams &params)
2044 {
2045     if (!torrentInfo.isValid()) return false;
2046
2047     return addTorrent_impl(torrentInfo, params);
2048 }
2049
2050 LoadTorrentParams Session::initLoadTorrentParams(const AddTorrentParams &addTorrentParams)
2051 {
2052     LoadTorrentParams loadTorrentParams;
2053
2054     loadTorrentParams.name = addTorrentParams.name;
2055     loadTorrentParams.firstLastPiecePriority = addTorrentParams.firstLastPiecePriority;
2056     loadTorrentParams.hasSeedStatus = addTorrentParams.skipChecking; // do not react on 'torrent_finished_alert' when skipping
2057     loadTorrentParams.contentLayout = addTorrentParams.contentLayout.value_or(torrentContentLayout());
2058     loadTorrentParams.operatingMode = (addTorrentParams.addForced ? TorrentOperatingMode::Forced : TorrentOperatingMode::AutoManaged);
2059     loadTorrentParams.stopped = addTorrentParams.addPaused.value_or(isAddTorrentPaused());
2060     loadTorrentParams.ratioLimit = addTorrentParams.ratioLimit;
2061     loadTorrentParams.seedingTimeLimit = addTorrentParams.seedingTimeLimit;
2062
2063     const bool useAutoTMM = addTorrentParams.useAutoTMM.value_or(!isAutoTMMDisabledByDefault());
2064     if (useAutoTMM)
2065         loadTorrentParams.savePath = "";
2066     else if (addTorrentParams.savePath.isEmpty())
2067         loadTorrentParams.savePath = defaultSavePath();
2068     else if (QDir(addTorrentParams.savePath).isRelative())
2069         loadTorrentParams.savePath = QDir(defaultSavePath()).absoluteFilePath(addTorrentParams.savePath);
2070     else
2071         loadTorrentParams.savePath = normalizePath(addTorrentParams.savePath);
2072
2073     const QString category = addTorrentParams.category;
2074     if (!category.isEmpty() && !m_categories.contains(category) && !addCategory(category))
2075         loadTorrentParams.category = "";
2076     else
2077         loadTorrentParams.category = addTorrentParams.category;
2078
2079     for (const QString &tag : addTorrentParams.tags)
2080     {
2081         if (hasTag(tag) || addTag(tag))
2082             loadTorrentParams.tags.insert(tag);
2083     }
2084
2085     return loadTorrentParams;
2086 }
2087
2088 // Add a torrent to the BitTorrent session
2089 bool Session::addTorrent_impl(const std::variant<MagnetUri, TorrentInfo> &source, const AddTorrentParams &addTorrentParams)
2090 {
2091     const bool hasMetadata = std::holds_alternative<TorrentInfo>(source);
2092     TorrentInfo metadata = (hasMetadata ? std::get<TorrentInfo>(source) : TorrentInfo {});
2093     const MagnetUri &magnetUri = (hasMetadata ? MagnetUri {} : std::get<MagnetUri>(source));
2094     const auto id = TorrentID::fromInfoHash(hasMetadata ? metadata.infoHash() : magnetUri.infoHash());
2095
2096     // It looks illogical that we don't just use an existing handle,
2097     // but as previous experience has shown, it actually creates unnecessary
2098     // problems and unwanted behavior due to the fact that it was originally
2099     // added with parameters other than those provided by the user.
2100     cancelDownloadMetadata(id);
2101
2102     // We should not add the torrent if it is already
2103     // processed or is pending to add to session
2104     if (m_loadingTorrents.contains(id))
2105         return false;
2106
2107     TorrentImpl *const torrent = m_torrents.value(id);
2108     if (torrent)
2109     {  // a duplicate torrent is added
2110         if (torrent->isPrivate() || (hasMetadata && metadata.isPrivate()))
2111             return false;
2112
2113         // merge trackers and web seeds
2114         torrent->addTrackers(hasMetadata ? metadata.trackers() : magnetUri.trackers());
2115         torrent->addUrlSeeds(hasMetadata ? metadata.urlSeeds() : magnetUri.urlSeeds());
2116         return true;
2117     }
2118
2119     LoadTorrentParams loadTorrentParams = initLoadTorrentParams(addTorrentParams);
2120     lt::add_torrent_params &p = loadTorrentParams.ltAddTorrentParams;
2121
2122     bool isFindingIncompleteFiles = false;
2123
2124     // If empty then Automatic mode, otherwise Manual mode
2125     const QString actualSavePath = loadTorrentParams.savePath.isEmpty() ? categorySavePath(loadTorrentParams.category) : loadTorrentParams.savePath;
2126     if (hasMetadata)
2127     {
2128         metadata.setContentLayout(loadTorrentParams.contentLayout);
2129
2130         if (!loadTorrentParams.hasSeedStatus)
2131         {
2132             findIncompleteFiles(metadata, actualSavePath);
2133             isFindingIncompleteFiles = true;
2134         }
2135
2136         // if torrent name wasn't explicitly set we handle the case of
2137         // initial renaming of torrent content and rename torrent accordingly
2138         if (loadTorrentParams.name.isEmpty())
2139         {
2140             QString contentName = metadata.rootFolder();
2141             if (contentName.isEmpty() && (metadata.filesCount() == 1))
2142                 contentName = metadata.fileName(0);
2143
2144             if (!contentName.isEmpty() && (contentName != metadata.name()))
2145                 loadTorrentParams.name = contentName;
2146         }
2147
2148         Q_ASSERT(p.file_priorities.empty());
2149         std::transform(addTorrentParams.filePriorities.cbegin(), addTorrentParams.filePriorities.cend()
2150                        , std::back_inserter(p.file_priorities), [](const DownloadPriority priority)
2151         {
2152             return static_cast<lt::download_priority_t>(
2153                         static_cast<lt::download_priority_t::underlying_type>(priority));
2154         });
2155
2156         p.ti = metadata.nativeInfo();
2157     }
2158     else
2159     {
2160         p = magnetUri.addTorrentParams();
2161
2162         if (loadTorrentParams.name.isEmpty() && !p.name.empty())
2163             loadTorrentParams.name = QString::fromStdString(p.name);
2164     }
2165
2166     p.save_path = Utils::Fs::toNativePath(actualSavePath).toStdString();
2167
2168     p.upload_limit = addTorrentParams.uploadLimit;
2169     p.download_limit = addTorrentParams.downloadLimit;
2170
2171     // Preallocation mode
2172     p.storage_mode = isPreallocationEnabled() ? lt::storage_mode_allocate : lt::storage_mode_sparse;
2173
2174     if (addTorrentParams.sequential)
2175         p.flags |= lt::torrent_flags::sequential_download;
2176     else
2177         p.flags &= ~lt::torrent_flags::sequential_download;
2178
2179     // Seeding mode
2180     // Skip checking and directly start seeding
2181     if (addTorrentParams.skipChecking)
2182         p.flags |= lt::torrent_flags::seed_mode;
2183     else
2184         p.flags &= ~lt::torrent_flags::seed_mode;
2185
2186     if (loadTorrentParams.stopped || (loadTorrentParams.operatingMode == TorrentOperatingMode::AutoManaged))
2187         p.flags |= lt::torrent_flags::paused;
2188     else
2189         p.flags &= ~lt::torrent_flags::paused;
2190     if (loadTorrentParams.stopped || (loadTorrentParams.operatingMode == TorrentOperatingMode::Forced))
2191         p.flags &= ~lt::torrent_flags::auto_managed;
2192     else
2193         p.flags |= lt::torrent_flags::auto_managed;
2194
2195     if (!isFindingIncompleteFiles)
2196         return loadTorrent(loadTorrentParams);
2197
2198     m_loadingTorrents.insert(id, loadTorrentParams);
2199     return true;
2200 }
2201
2202 // Add a torrent to the BitTorrent session
2203 bool Session::loadTorrent(LoadTorrentParams params)
2204 {
2205     lt::add_torrent_params &p = params.ltAddTorrentParams;
2206
2207 #if (LIBTORRENT_VERSION_NUM < 20000)
2208     p.storage = customStorageConstructor;
2209 #endif
2210     // Limits
2211     p.max_connections = maxConnectionsPerTorrent();
2212     p.max_uploads = maxUploadsPerTorrent();
2213
2214     const bool hasMetadata = (p.ti && p.ti->is_valid());
2215 #if (LIBTORRENT_VERSION_NUM >= 20000)
2216     const auto id = TorrentID::fromInfoHash(hasMetadata ? p.ti->info_hashes() : p.info_hashes);
2217 #else
2218     const auto id = TorrentID::fromInfoHash(hasMetadata ? p.ti->info_hash() : p.info_hash);
2219 #endif
2220     m_loadingTorrents.insert(id, params);
2221
2222     // Adding torrent to BitTorrent session
2223     m_nativeSession->async_add_torrent(p);
2224
2225     return true;
2226 }
2227
2228 void Session::findIncompleteFiles(const TorrentInfo &torrentInfo, const QString &savePath) const
2229 {
2230     const auto searchId = TorrentID::fromInfoHash(torrentInfo.infoHash());
2231     const QStringList originalFileNames = torrentInfo.filePaths();
2232     const QString completeSavePath = savePath;
2233     const QString incompleteSavePath = (isTempPathEnabled() ? torrentTempPath(torrentInfo) : QString {});
2234     QMetaObject::invokeMethod(m_fileSearcher, [=]()
2235     {
2236         m_fileSearcher->search(searchId, originalFileNames, completeSavePath, incompleteSavePath);
2237     });
2238 }
2239
2240 // Add a torrent to libtorrent session in hidden mode
2241 // and force it to download its metadata
2242 bool Session::downloadMetadata(const MagnetUri &magnetUri)
2243 {
2244     if (!magnetUri.isValid()) return false;
2245
2246     const auto id = TorrentID::fromInfoHash(magnetUri.infoHash());
2247     const QString name = magnetUri.name();
2248
2249     // We should not add torrent if it's already
2250     // processed or adding to session
2251     if (m_torrents.contains(id)) return false;
2252     if (m_loadingTorrents.contains(id)) return false;
2253     if (m_downloadedMetadata.contains(id)) return false;
2254
2255     qDebug("Adding torrent to preload metadata...");
2256     qDebug(" -> Torrent ID: %s", qUtf8Printable(id.toString()));
2257     qDebug(" -> Name: %s", qUtf8Printable(name));
2258
2259     lt::add_torrent_params p = magnetUri.addTorrentParams();
2260
2261     // Flags
2262     // Preallocation mode
2263     if (isPreallocationEnabled())
2264         p.storage_mode = lt::storage_mode_allocate;
2265     else
2266         p.storage_mode = lt::storage_mode_sparse;
2267
2268     // Limits
2269     p.max_connections = maxConnectionsPerTorrent();
2270     p.max_uploads = maxUploadsPerTorrent();
2271
2272     const QString savePath = Utils::Fs::tempPath() + id.toString();
2273     p.save_path = Utils::Fs::toNativePath(savePath).toStdString();
2274
2275     // Forced start
2276     p.flags &= ~lt::torrent_flags::paused;
2277     p.flags &= ~lt::torrent_flags::auto_managed;
2278
2279     // Solution to avoid accidental file writes
2280     p.flags |= lt::torrent_flags::upload_mode;
2281
2282 #if (LIBTORRENT_VERSION_NUM < 20000)
2283     p.storage = customStorageConstructor;
2284 #endif
2285
2286     // Adding torrent to libtorrent session
2287     lt::error_code ec;
2288     lt::torrent_handle h = m_nativeSession->add_torrent(p, ec);
2289     if (ec) return false;
2290
2291     // waiting for metadata...
2292     m_downloadedMetadata.insert(h.info_hash());
2293     ++m_extraLimit;
2294     adjustLimits();
2295
2296     return true;
2297 }
2298
2299 void Session::exportTorrentFile(const TorrentInfo &torrentInfo, const QString &folderPath, const QString &baseName)
2300 {
2301     const QString validName = Utils::Fs::toValidFileSystemName(baseName);
2302     QString torrentExportFilename = QString::fromLatin1("%1.torrent").arg(validName);
2303     const QDir exportDir {folderPath};
2304     if (exportDir.exists() || exportDir.mkpath(exportDir.absolutePath()))
2305     {
2306         QString newTorrentPath = exportDir.absoluteFilePath(torrentExportFilename);
2307         int counter = 0;
2308         while (QFile::exists(newTorrentPath))
2309         {
2310             // Append number to torrent name to make it unique
2311             torrentExportFilename = QString::fromLatin1("%1 %2.torrent").arg(validName).arg(++counter);
2312             newTorrentPath = exportDir.absoluteFilePath(torrentExportFilename);
2313         }
2314
2315         try
2316         {
2317             torrentInfo.saveToFile(newTorrentPath);
2318         }
2319         catch (const RuntimeError &err)
2320         {
2321             LogMsg(tr("Couldn't export torrent metadata file '%1'. Reason: %2.")
2322                    .arg(newTorrentPath, err.message()), Log::WARNING);
2323         }
2324     }
2325 }
2326
2327 void Session::generateResumeData()
2328 {
2329     for (TorrentImpl *const torrent : asConst(m_torrents))
2330     {
2331         if (!torrent->isValid()) continue;
2332
2333         if (torrent->needSaveResumeData())
2334         {
2335             torrent->saveResumeData();
2336             m_needSaveResumeDataTorrents.remove(torrent->id());
2337         }
2338     }
2339 }
2340
2341 // Called on exit
2342 void Session::saveResumeData()
2343 {
2344     // Pause session
2345     m_nativeSession->pause();
2346
2347     if (isQueueingSystemEnabled())
2348         saveTorrentsQueue();
2349     generateResumeData();
2350
2351     while (m_numResumeData > 0)
2352     {
2353         const std::vector<lt::alert *> alerts = getPendingAlerts(lt::seconds {30});
2354         if (alerts.empty())
2355         {
2356             LogMsg(tr("Error: Aborted saving resume data for %1 outstanding torrents.").arg(QString::number(m_numResumeData))
2357                 , Log::CRITICAL);
2358             break;
2359         }
2360
2361         for (const lt::alert *a : alerts)
2362         {
2363             switch (a->type())
2364             {
2365             case lt::save_resume_data_failed_alert::alert_type:
2366             case lt::save_resume_data_alert::alert_type:
2367                 dispatchTorrentAlert(a);
2368                 break;
2369             }
2370         }
2371     }
2372 }
2373
2374 void Session::saveTorrentsQueue() const
2375 {
2376     QVector<TorrentID> queue;
2377     for (const TorrentImpl *torrent : asConst(m_torrents))
2378     {
2379         // We require actual (non-cached) queue position here!
2380         const int queuePos = static_cast<LTUnderlyingType<lt::queue_position_t>>(torrent->nativeHandle().queue_position());
2381         if (queuePos >= 0)
2382         {
2383             if (queuePos >= queue.size())
2384                 queue.resize(queuePos + 1);
2385             queue[queuePos] = torrent->id();
2386         }
2387     }
2388
2389     m_resumeDataStorage->storeQueue(queue);
2390 }
2391
2392 void Session::removeTorrentsQueue() const
2393 {
2394     m_resumeDataStorage->storeQueue({});
2395 }
2396
2397 void Session::setDefaultSavePath(QString path)
2398 {
2399     path = normalizeSavePath(path);
2400     if (path == m_defaultSavePath) return;
2401
2402     m_defaultSavePath = path;
2403
2404     if (isDisableAutoTMMWhenDefaultSavePathChanged())
2405         for (TorrentImpl *const torrent : asConst(m_torrents))
2406             torrent->setAutoTMMEnabled(false);
2407     else
2408         for (TorrentImpl *const torrent : asConst(m_torrents))
2409             torrent->handleCategorySavePathChanged();
2410 }
2411
2412 void Session::setTempPath(QString path)
2413 {
2414     path = normalizeSavePath(path, defaultSavePath() + "temp/");
2415     if (path == m_tempPath) return;
2416
2417     m_tempPath = path;
2418
2419     for (TorrentImpl *const torrent : asConst(m_torrents))
2420         torrent->handleTempPathChanged();
2421 }
2422
2423 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
2424 void Session::networkOnlineStateChanged(const bool online)
2425 {
2426     LogMsg(tr("System network status changed to %1", "e.g: System network status changed to ONLINE").arg(online ? tr("ONLINE") : tr("OFFLINE")), Log::INFO);
2427 }
2428
2429 void Session::networkConfigurationChange(const QNetworkConfiguration &cfg)
2430 {
2431     const QString configuredInterfaceName = networkInterface();
2432     // Empty means "Any Interface". In this case libtorrent has binded to 0.0.0.0 so any change to any interface will
2433     // be automatically picked up. Otherwise we would rebinding here to 0.0.0.0 again.
2434     if (configuredInterfaceName.isEmpty()) return;
2435
2436     const QString changedInterface = cfg.name();
2437
2438     if (configuredInterfaceName == changedInterface)
2439     {
2440         LogMsg(tr("Network configuration of %1 has changed, refreshing session binding", "e.g: Network configuration of tun0 has changed, refreshing session binding").arg(changedInterface), Log::INFO);
2441         configureListeningInterface();
2442     }
2443 }
2444 #endif
2445
2446 QStringList Session::getListeningIPs() const
2447 {
2448     QStringList IPs;
2449
2450     const QString ifaceName = networkInterface();
2451     const QString ifaceAddr = networkInterfaceAddress();
2452     const QHostAddress configuredAddr(ifaceAddr);
2453     const bool allIPv4 = (ifaceAddr == QLatin1String("0.0.0.0")); // Means All IPv4 addresses
2454     const bool allIPv6 = (ifaceAddr == QLatin1String("::")); // Means All IPv6 addresses
2455
2456     if (!ifaceAddr.isEmpty() && !allIPv4 && !allIPv6 && configuredAddr.isNull())
2457     {
2458         LogMsg(tr("Configured network interface address %1 isn't valid.", "Configured network interface address 124.5.158.1 isn't valid.").arg(ifaceAddr), Log::CRITICAL);
2459         // Pass the invalid user configured interface name/address to libtorrent
2460         // in hopes that it will come online later.
2461         // This will not cause IP leak but allow user to reconnect the interface
2462         // and re-establish connection without restarting the client.
2463         IPs.append(ifaceAddr);
2464         return IPs;
2465     }
2466
2467     if (ifaceName.isEmpty())
2468     {
2469         if (ifaceAddr.isEmpty())
2470             return {QLatin1String("0.0.0.0"), QLatin1String("::")}; // Indicates all interfaces + all addresses (aka default)
2471
2472         if (allIPv4)
2473             return {QLatin1String("0.0.0.0")};
2474
2475         if (allIPv6)
2476             return {QLatin1String("::")};
2477     }
2478
2479     const auto checkAndAddIP = [allIPv4, allIPv6, &IPs](const QHostAddress &addr, const QHostAddress &match)
2480     {
2481         if ((allIPv4 && (addr.protocol() != QAbstractSocket::IPv4Protocol))
2482             || (allIPv6 && (addr.protocol() != QAbstractSocket::IPv6Protocol)))
2483             return;
2484
2485         if ((match == addr) || allIPv4 || allIPv6)
2486             IPs.append(addr.toString());
2487     };
2488
2489     if (ifaceName.isEmpty())
2490     {
2491         const QList<QHostAddress> addresses = QNetworkInterface::allAddresses();
2492         for (const auto &addr : addresses)
2493             checkAndAddIP(addr, configuredAddr);
2494
2495         // At this point ifaceAddr was non-empty
2496         // If IPs.isEmpty() it means the configured Address was not found
2497         if (IPs.isEmpty())
2498         {
2499             LogMsg(tr("Can't find the configured address '%1' to listen on"
2500                     , "Can't find the configured address '192.168.1.3' to listen on")
2501                 .arg(ifaceAddr), Log::CRITICAL);
2502             IPs.append(ifaceAddr);
2503         }
2504
2505         return IPs;
2506     }
2507
2508     // Attempt to listen on provided interface
2509     const QNetworkInterface networkIFace = QNetworkInterface::interfaceFromName(ifaceName);
2510     if (!networkIFace.isValid())
2511     {
2512         qDebug("Invalid network interface: %s", qUtf8Printable(ifaceName));
2513         LogMsg(tr("The network interface defined is invalid: %1").arg(ifaceName), Log::CRITICAL);
2514         IPs.append(ifaceName);
2515         return IPs;
2516     }
2517
2518     if (ifaceAddr.isEmpty())
2519     {
2520         IPs.append(ifaceName);
2521         return IPs; // On Windows calling code converts it to GUID
2522     }
2523
2524     const QList<QNetworkAddressEntry> addresses = networkIFace.addressEntries();
2525     qDebug("This network interface has %d IP addresses", addresses.size());
2526     for (const QNetworkAddressEntry &entry : addresses)
2527         checkAndAddIP(entry.ip(), configuredAddr);
2528
2529     // Make sure there is at least one IP
2530     // At this point there was an explicit interface and an explicit address set
2531     // and the address should have been found
2532     if (IPs.isEmpty())
2533     {
2534         LogMsg(tr("Can't find the configured address '%1' to listen on"
2535                   , "Can't find the configured address '192.168.1.3' to listen on")
2536             .arg(ifaceAddr), Log::CRITICAL);
2537         IPs.append(ifaceAddr);
2538     }
2539
2540     return IPs;
2541 }
2542
2543 // Set the ports range in which is chosen the port
2544 // the BitTorrent session will listen to
2545 void Session::configureListeningInterface()
2546 {
2547     m_listenInterfaceConfigured = false;
2548     configureDeferred();
2549 }
2550
2551 int Session::globalDownloadSpeedLimit() const
2552 {
2553     // Unfortunately the value was saved as KiB instead of B.
2554     // But it is better to pass it around internally(+ webui) as Bytes.
2555     return m_globalDownloadSpeedLimit * 1024;
2556 }
2557
2558 void Session::setGlobalDownloadSpeedLimit(const int limit)
2559 {
2560     // Unfortunately the value was saved as KiB instead of B.
2561     // But it is better to pass it around internally(+ webui) as Bytes.
2562     if (limit == globalDownloadSpeedLimit())
2563         return;
2564
2565     if (limit <= 0)
2566         m_globalDownloadSpeedLimit = 0;
2567     else if (limit <= 1024)
2568         m_globalDownloadSpeedLimit = 1;
2569     else
2570         m_globalDownloadSpeedLimit = (limit / 1024);
2571
2572     if (!isAltGlobalSpeedLimitEnabled())
2573         configureDeferred();
2574 }
2575
2576 int Session::globalUploadSpeedLimit() const
2577 {
2578     // Unfortunately the value was saved as KiB instead of B.
2579     // But it is better to pass it around internally(+ webui) as Bytes.
2580     return m_globalUploadSpeedLimit * 1024;
2581 }
2582
2583 void Session::setGlobalUploadSpeedLimit(const int limit)
2584 {
2585     // Unfortunately the value was saved as KiB instead of B.
2586     // But it is better to pass it around internally(+ webui) as Bytes.
2587     if (limit == globalUploadSpeedLimit())
2588         return;
2589
2590     if (limit <= 0)
2591         m_globalUploadSpeedLimit = 0;
2592     else if (limit <= 1024)
2593         m_globalUploadSpeedLimit = 1;
2594     else
2595         m_globalUploadSpeedLimit = (limit / 1024);
2596
2597     if (!isAltGlobalSpeedLimitEnabled())
2598         configureDeferred();
2599 }
2600
2601 int Session::altGlobalDownloadSpeedLimit() const
2602 {
2603     // Unfortunately the value was saved as KiB instead of B.
2604     // But it is better to pass it around internally(+ webui) as Bytes.
2605     return m_altGlobalDownloadSpeedLimit * 1024;
2606 }
2607
2608 void Session::setAltGlobalDownloadSpeedLimit(const int limit)
2609 {
2610     // Unfortunately the value was saved as KiB instead of B.
2611     // But it is better to pass it around internally(+ webui) as Bytes.
2612     if (limit == altGlobalDownloadSpeedLimit())
2613         return;
2614
2615     if (limit <= 0)
2616         m_altGlobalDownloadSpeedLimit = 0;
2617     else if (limit <= 1024)
2618         m_altGlobalDownloadSpeedLimit = 1;
2619     else
2620         m_altGlobalDownloadSpeedLimit = (limit / 1024);
2621
2622     if (isAltGlobalSpeedLimitEnabled())
2623         configureDeferred();
2624 }
2625
2626 int Session::altGlobalUploadSpeedLimit() const
2627 {
2628     // Unfortunately the value was saved as KiB instead of B.
2629     // But it is better to pass it around internally(+ webui) as Bytes.
2630     return m_altGlobalUploadSpeedLimit * 1024;
2631 }
2632
2633 void Session::setAltGlobalUploadSpeedLimit(const int limit)
2634 {
2635     // Unfortunately the value was saved as KiB instead of B.
2636     // But it is better to pass it around internally(+ webui) as Bytes.
2637     if (limit == altGlobalUploadSpeedLimit())
2638         return;
2639
2640     if (limit <= 0)
2641         m_altGlobalUploadSpeedLimit = 0;
2642     else if (limit <= 1024)
2643         m_altGlobalUploadSpeedLimit = 1;
2644     else
2645         m_altGlobalUploadSpeedLimit = (limit / 1024);
2646
2647     if (isAltGlobalSpeedLimitEnabled())
2648         configureDeferred();
2649 }
2650
2651 int Session::downloadSpeedLimit() const
2652 {
2653     return isAltGlobalSpeedLimitEnabled()
2654             ? altGlobalDownloadSpeedLimit()
2655             : globalDownloadSpeedLimit();
2656 }
2657
2658 void Session::setDownloadSpeedLimit(const int limit)
2659 {
2660     if (isAltGlobalSpeedLimitEnabled())
2661         setAltGlobalDownloadSpeedLimit(limit);
2662     else
2663         setGlobalDownloadSpeedLimit(limit);
2664 }
2665
2666 int Session::uploadSpeedLimit() const
2667 {
2668     return isAltGlobalSpeedLimitEnabled()
2669             ? altGlobalUploadSpeedLimit()
2670             : globalUploadSpeedLimit();
2671 }
2672
2673 void Session::setUploadSpeedLimit(const int limit)
2674 {
2675     if (isAltGlobalSpeedLimitEnabled())
2676         setAltGlobalUploadSpeedLimit(limit);
2677     else
2678         setGlobalUploadSpeedLimit(limit);
2679 }
2680
2681 bool Session::isAltGlobalSpeedLimitEnabled() const
2682 {
2683     return m_isAltGlobalSpeedLimitEnabled;
2684 }
2685
2686 void Session::setAltGlobalSpeedLimitEnabled(const bool enabled)
2687 {
2688     if (enabled == isAltGlobalSpeedLimitEnabled()) return;
2689
2690     // Save new state to remember it on startup
2691     m_isAltGlobalSpeedLimitEnabled = enabled;
2692     applyBandwidthLimits();
2693     // Notify
2694     emit speedLimitModeChanged(m_isAltGlobalSpeedLimitEnabled);
2695 }
2696
2697 bool Session::isBandwidthSchedulerEnabled() const
2698 {
2699     return m_isBandwidthSchedulerEnabled;
2700 }
2701
2702 void Session::setBandwidthSchedulerEnabled(const bool enabled)
2703 {
2704     if (enabled != isBandwidthSchedulerEnabled())
2705     {
2706         m_isBandwidthSchedulerEnabled = enabled;
2707         if (enabled)
2708             enableBandwidthScheduler();
2709         else
2710             delete m_bwScheduler;
2711     }
2712 }
2713
2714 int Session::saveResumeDataInterval() const
2715 {
2716     return m_saveResumeDataInterval;
2717 }
2718
2719 void Session::setSaveResumeDataInterval(const int value)
2720 {
2721     if (value == m_saveResumeDataInterval)
2722         return;
2723
2724     m_saveResumeDataInterval = value;
2725
2726     if (value > 0)
2727     {
2728         m_resumeDataTimer->setInterval(value * 60 * 1000);
2729         m_resumeDataTimer->start();
2730     }
2731     else
2732     {
2733         m_resumeDataTimer->stop();
2734     }
2735 }
2736
2737 int Session::port() const
2738 {
2739     return m_port;
2740 }
2741
2742 void Session::setPort(const int port)
2743 {
2744     if (port != m_port)
2745     {
2746         m_port = port;
2747         configureListeningInterface();
2748
2749         if (isReannounceWhenAddressChangedEnabled())
2750             reannounceToAllTrackers();
2751     }
2752 }
2753
2754 bool Session::useRandomPort() const
2755 {
2756     return m_useRandomPort;
2757 }
2758
2759 void Session::setUseRandomPort(const bool value)
2760 {
2761     m_useRandomPort = value;
2762 }
2763
2764 QString Session::networkInterface() const
2765 {
2766     return m_networkInterface;
2767 }
2768
2769 void Session::setNetworkInterface(const QString &iface)
2770 {
2771     if (iface != networkInterface())
2772     {
2773         m_networkInterface = iface;
2774         configureListeningInterface();
2775     }
2776 }
2777
2778 QString Session::networkInterfaceName() const
2779 {
2780     return m_networkInterfaceName;
2781 }
2782
2783 void Session::setNetworkInterfaceName(const QString &name)
2784 {
2785     m_networkInterfaceName = name;
2786 }
2787
2788 QString Session::networkInterfaceAddress() const
2789 {
2790     return m_networkInterfaceAddress;
2791 }
2792
2793 void Session::setNetworkInterfaceAddress(const QString &address)
2794 {
2795     if (address != networkInterfaceAddress())
2796     {
2797         m_networkInterfaceAddress = address;
2798         configureListeningInterface();
2799     }
2800 }
2801
2802 int Session::encryption() const
2803 {
2804     return m_encryption;
2805 }
2806
2807 void Session::setEncryption(const int state)
2808 {
2809     if (state != encryption())
2810     {
2811         m_encryption = state;
2812         configureDeferred();
2813         LogMsg(tr("Encryption support [%1]").arg(
2814             state == 0 ? tr("ON") : ((state == 1) ? tr("FORCED") : tr("OFF")))
2815             , Log::INFO);
2816     }
2817 }
2818
2819 bool Session::isProxyPeerConnectionsEnabled() const
2820 {
2821     return m_isProxyPeerConnectionsEnabled;
2822 }
2823
2824 void Session::setProxyPeerConnectionsEnabled(const bool enabled)
2825 {
2826     if (enabled != isProxyPeerConnectionsEnabled())
2827     {
2828         m_isProxyPeerConnectionsEnabled = enabled;
2829         configureDeferred();
2830     }
2831 }
2832
2833 ChokingAlgorithm Session::chokingAlgorithm() const
2834 {
2835     return m_chokingAlgorithm;
2836 }
2837
2838 void Session::setChokingAlgorithm(const ChokingAlgorithm mode)
2839 {
2840     if (mode == m_chokingAlgorithm) return;
2841
2842     m_chokingAlgorithm = mode;
2843     configureDeferred();
2844 }
2845
2846 SeedChokingAlgorithm Session::seedChokingAlgorithm() const
2847 {
2848     return m_seedChokingAlgorithm;
2849 }
2850
2851 void Session::setSeedChokingAlgorithm(const SeedChokingAlgorithm mode)
2852 {
2853     if (mode == m_seedChokingAlgorithm) return;
2854
2855     m_seedChokingAlgorithm = mode;
2856     configureDeferred();
2857 }
2858
2859 bool Session::isAddTrackersEnabled() const
2860 {
2861     return m_isAddTrackersEnabled;
2862 }
2863
2864 void Session::setAddTrackersEnabled(const bool enabled)
2865 {
2866     m_isAddTrackersEnabled = enabled;
2867 }
2868
2869 QString Session::additionalTrackers() const
2870 {
2871     return m_additionalTrackers;
2872 }
2873
2874 void Session::setAdditionalTrackers(const QString &trackers)
2875 {
2876     if (trackers != additionalTrackers())
2877     {
2878         m_additionalTrackers = trackers;
2879         populateAdditionalTrackers();
2880     }
2881 }
2882
2883 bool Session::isIPFilteringEnabled() const
2884 {
2885     return m_isIPFilteringEnabled;
2886 }
2887
2888 void Session::setIPFilteringEnabled(const bool enabled)
2889 {
2890     if (enabled != m_isIPFilteringEnabled)
2891     {
2892         m_isIPFilteringEnabled = enabled;
2893         m_IPFilteringConfigured = false;
2894         configureDeferred();
2895     }
2896 }
2897
2898 QString Session::IPFilterFile() const
2899 {
2900     return Utils::Fs::toUniformPath(m_IPFilterFile);
2901 }
2902
2903 void Session::setIPFilterFile(QString path)
2904 {
2905     path = Utils::Fs::toUniformPath(path);
2906     if (path != IPFilterFile())
2907     {
2908         m_IPFilterFile = path;
2909         m_IPFilteringConfigured = false;
2910         configureDeferred();
2911     }
2912 }
2913
2914 void Session::setBannedIPs(const QStringList &newList)
2915 {
2916     if (newList == m_bannedIPs)
2917         return; // do nothing
2918     // here filter out incorrect IP
2919     QStringList filteredList;
2920     for (const QString &ip : newList)
2921     {
2922         if (Utils::Net::isValidIP(ip))
2923         {
2924             // the same IPv6 addresses could be written in different forms;
2925             // QHostAddress::toString() result format follows RFC5952;
2926             // thus we avoid duplicate entries pointing to the same address
2927             filteredList << QHostAddress(ip).toString();
2928         }
2929         else
2930         {
2931             LogMsg(tr("%1 is not a valid IP address and was rejected while applying the list of banned addresses.")
2932                    .arg(ip)
2933                 , Log::WARNING);
2934         }
2935     }
2936     // now we have to sort IPs and make them unique
2937     filteredList.sort();
2938     filteredList.removeDuplicates();
2939     // Again ensure that the new list is different from the stored one.
2940     if (filteredList == m_bannedIPs)
2941         return; // do nothing
2942     // store to session settings
2943     // also here we have to recreate filter list including 3rd party ban file
2944     // and install it again into m_session
2945     m_bannedIPs = filteredList;
2946     m_IPFilteringConfigured = false;
2947     configureDeferred();
2948 }
2949
2950 ResumeDataStorageType Session::resumeDataStorageType() const
2951 {
2952     return m_resumeDataStorageType;
2953 }
2954
2955 void Session::setResumeDataStorageType(const ResumeDataStorageType type)
2956 {
2957     m_resumeDataStorageType = type;
2958 }
2959
2960 QStringList Session::bannedIPs() const
2961 {
2962     return m_bannedIPs;
2963 }
2964
2965 #if defined(Q_OS_WIN)
2966 OSMemoryPriority Session::getOSMemoryPriority() const
2967 {
2968     return m_OSMemoryPriority;
2969 }
2970
2971 void Session::setOSMemoryPriority(const OSMemoryPriority priority)
2972 {
2973     if (m_OSMemoryPriority == priority)
2974         return;
2975
2976     m_OSMemoryPriority = priority;
2977     configureDeferred();
2978 }
2979
2980 void Session::applyOSMemoryPriority() const
2981 {
2982     using SETPROCESSINFORMATION = BOOL (WINAPI *)(HANDLE, PROCESS_INFORMATION_CLASS, LPVOID, DWORD);
2983     const auto setProcessInformation = Utils::Misc::loadWinAPI<SETPROCESSINFORMATION>("Kernel32.dll", "SetProcessInformation");
2984     if (!setProcessInformation)  // only available on Windows >= 8
2985         return;
2986
2987 #if (_WIN32_WINNT < _WIN32_WINNT_WIN8)
2988     // this dummy struct is required to compile successfully when targeting older Windows version
2989     struct MEMORY_PRIORITY_INFORMATION
2990     {
2991         ULONG MemoryPriority;
2992     };
2993
2994 #define MEMORY_PRIORITY_LOWEST 0
2995 #define MEMORY_PRIORITY_VERY_LOW 1
2996 #define MEMORY_PRIORITY_LOW 2
2997 #define MEMORY_PRIORITY_MEDIUM 3
2998 #define MEMORY_PRIORITY_BELOW_NORMAL 4
2999 #define MEMORY_PRIORITY_NORMAL 5
3000 #endif
3001
3002     MEMORY_PRIORITY_INFORMATION prioInfo {};
3003     switch (getOSMemoryPriority())
3004     {
3005     case OSMemoryPriority::Normal:
3006     default:
3007         prioInfo.MemoryPriority = MEMORY_PRIORITY_NORMAL;
3008         break;
3009     case OSMemoryPriority::BelowNormal:
3010         prioInfo.MemoryPriority = MEMORY_PRIORITY_BELOW_NORMAL;
3011         break;
3012     case OSMemoryPriority::Medium:
3013         prioInfo.MemoryPriority = MEMORY_PRIORITY_MEDIUM;
3014         break;
3015     case OSMemoryPriority::Low:
3016         prioInfo.MemoryPriority = MEMORY_PRIORITY_LOW;
3017         break;
3018     case OSMemoryPriority::VeryLow:
3019         prioInfo.MemoryPriority = MEMORY_PRIORITY_VERY_LOW;
3020         break;
3021     }
3022     setProcessInformation(::GetCurrentProcess(), ProcessMemoryPriority, &prioInfo, sizeof(prioInfo));
3023 }
3024 #endif
3025
3026 int Session::maxConnectionsPerTorrent() const
3027 {
3028     return m_maxConnectionsPerTorrent;
3029 }
3030
3031 void Session::setMaxConnectionsPerTorrent(int max)
3032 {
3033     max = (max > 0) ? max : -1;
3034     if (max != maxConnectionsPerTorrent())
3035     {
3036         m_maxConnectionsPerTorrent = max;
3037
3038         // Apply this to all session torrents
3039         for (const lt::torrent_handle &handle : m_nativeSession->get_torrents())
3040         {
3041             try
3042             {
3043                 handle.set_max_connections(max);
3044             }
3045             catch (const std::exception &) {}
3046         }
3047     }
3048 }
3049
3050 int Session::maxUploadsPerTorrent() const
3051 {
3052     return m_maxUploadsPerTorrent;
3053 }
3054
3055 void Session::setMaxUploadsPerTorrent(int max)
3056 {
3057     max = (max > 0) ? max : -1;
3058     if (max != maxUploadsPerTorrent())
3059     {
3060         m_maxUploadsPerTorrent = max;
3061
3062         // Apply this to all session torrents
3063         for (const lt::torrent_handle &handle : m_nativeSession->get_torrents())
3064         {
3065             try
3066             {
3067                 handle.set_max_uploads(max);
3068             }
3069             catch (const std::exception &) {}
3070         }
3071     }
3072 }
3073
3074 bool Session::announceToAllTrackers() const
3075 {
3076     return m_announceToAllTrackers;
3077 }
3078
3079 void Session::setAnnounceToAllTrackers(const bool val)
3080 {
3081     if (val != m_announceToAllTrackers)
3082     {
3083         m_announceToAllTrackers = val;
3084         configureDeferred();
3085     }
3086 }
3087
3088 bool Session::announceToAllTiers() const
3089 {
3090     return m_announceToAllTiers;
3091 }
3092
3093 void Session::setAnnounceToAllTiers(const bool val)
3094 {
3095     if (val != m_announceToAllTiers)
3096     {
3097         m_announceToAllTiers = val;
3098         configureDeferred();
3099     }
3100 }
3101
3102 int Session::peerTurnover() const
3103 {
3104     return m_peerTurnover;
3105 }
3106
3107 void Session::setPeerTurnover(const int val)
3108 {
3109     if (val == m_peerTurnover)
3110         return;
3111
3112     m_peerTurnover = val;
3113     configureDeferred();
3114 }
3115
3116 int Session::peerTurnoverCutoff() const
3117 {
3118     return m_peerTurnoverCutoff;
3119 }
3120
3121 void Session::setPeerTurnoverCutoff(const int val)
3122 {
3123     if (val == m_peerTurnoverCutoff)
3124         return;
3125
3126     m_peerTurnoverCutoff = val;
3127     configureDeferred();
3128 }
3129
3130 int Session::peerTurnoverInterval() const
3131 {
3132     return m_peerTurnoverInterval;
3133 }
3134
3135 void Session::setPeerTurnoverInterval(const int val)
3136 {
3137     if (val == m_peerTurnoverInterval)
3138         return;
3139
3140     m_peerTurnoverInterval = val;
3141     configureDeferred();
3142 }
3143
3144 int Session::asyncIOThreads() const
3145 {
3146     return qBound(1, m_asyncIOThreads.get(), 1024);
3147 }
3148
3149 void Session::setAsyncIOThreads(const int num)
3150 {
3151     if (num == m_asyncIOThreads)
3152         return;
3153
3154     m_asyncIOThreads = num;
3155     configureDeferred();
3156 }
3157
3158 int Session::hashingThreads() const
3159 {
3160     return qBound(1, m_hashingThreads.get(), 1024);
3161 }
3162
3163 void Session::setHashingThreads(const int num)
3164 {
3165     if (num == m_hashingThreads)
3166         return;
3167
3168     m_hashingThreads = num;
3169     configureDeferred();
3170 }
3171
3172 int Session::filePoolSize() const
3173 {
3174     return m_filePoolSize;
3175 }
3176
3177 void Session::setFilePoolSize(const int size)
3178 {
3179     if (size == m_filePoolSize)
3180         return;
3181
3182     m_filePoolSize = size;
3183     configureDeferred();
3184 }
3185
3186 int Session::checkingMemUsage() const
3187 {
3188     return qMax(1, m_checkingMemUsage.get());
3189 }
3190
3191 void Session::setCheckingMemUsage(int size)
3192 {
3193     size = qMax(size, 1);
3194
3195     if (size == m_checkingMemUsage)
3196         return;
3197
3198     m_checkingMemUsage = size;
3199     configureDeferred();
3200 }
3201
3202 int Session::diskCacheSize() const
3203 {
3204 #ifdef QBT_APP_64BIT
3205     return qMin(m_diskCacheSize.get(), 33554431);  // 32768GiB
3206 #else
3207     // When build as 32bit binary, set the maximum at less than 2GB to prevent crashes
3208     // allocate 1536MiB and leave 512MiB to the rest of program data in RAM
3209     return qMin(m_diskCacheSize.get(), 1536);
3210 #endif
3211 }
3212
3213 void Session::setDiskCacheSize(int size)
3214 {
3215 #ifdef QBT_APP_64BIT
3216     size = qMin(size, 33554431);  // 32768GiB
3217 #else
3218     // allocate 1536MiB and leave 512MiB to the rest of program data in RAM
3219     size = qMin(size, 1536);
3220 #endif
3221     if (size != m_diskCacheSize)
3222     {
3223         m_diskCacheSize = size;
3224         configureDeferred();
3225     }
3226 }
3227
3228 int Session::diskCacheTTL() const
3229 {
3230     return m_diskCacheTTL;
3231 }
3232
3233 void Session::setDiskCacheTTL(const int ttl)
3234 {
3235     if (ttl != m_diskCacheTTL)
3236     {
3237         m_diskCacheTTL = ttl;
3238         configureDeferred();
3239     }
3240 }
3241
3242 bool Session::useOSCache() const
3243 {
3244     return m_useOSCache;
3245 }
3246
3247 void Session::setUseOSCache(const bool use)
3248 {
3249     if (use != m_useOSCache)
3250     {
3251         m_useOSCache = use;
3252         configureDeferred();
3253     }
3254 }
3255
3256 bool Session::isCoalesceReadWriteEnabled() const
3257 {
3258     return m_coalesceReadWriteEnabled;
3259 }
3260
3261 void Session::setCoalesceReadWriteEnabled(const bool enabled)
3262 {
3263     if (enabled == m_coalesceReadWriteEnabled) return;
3264
3265     m_coalesceReadWriteEnabled = enabled;
3266     configureDeferred();
3267 }
3268
3269 bool Session::isSuggestModeEnabled() const
3270 {
3271     return m_isSuggestMode;
3272 }
3273
3274 bool Session::usePieceExtentAffinity() const
3275 {
3276     return m_usePieceExtentAffinity;
3277 }
3278
3279 void Session::setPieceExtentAffinity(const bool enabled)
3280 {
3281     if (enabled == m_usePieceExtentAffinity) return;
3282
3283     m_usePieceExtentAffinity = enabled;
3284     configureDeferred();
3285 }
3286
3287 void Session::setSuggestMode(const bool mode)
3288 {
3289     if (mode == m_isSuggestMode) return;
3290
3291     m_isSuggestMode = mode;
3292     configureDeferred();
3293 }
3294
3295 int Session::sendBufferWatermark() const
3296 {
3297     return m_sendBufferWatermark;
3298 }
3299
3300 void Session::setSendBufferWatermark(const int value)
3301 {
3302     if (value == m_sendBufferWatermark) return;
3303
3304     m_sendBufferWatermark = value;
3305     configureDeferred();
3306 }
3307
3308 int Session::sendBufferLowWatermark() const
3309 {
3310     return m_sendBufferLowWatermark;
3311 }
3312
3313 void Session::setSendBufferLowWatermark(const int value)
3314 {
3315     if (value == m_sendBufferLowWatermark) return;
3316
3317     m_sendBufferLowWatermark = value;
3318     configureDeferred();
3319 }
3320
3321 int Session::sendBufferWatermarkFactor() const
3322 {
3323     return m_sendBufferWatermarkFactor;
3324 }
3325
3326 void Session::setSendBufferWatermarkFactor(const int value)
3327 {
3328     if (value == m_sendBufferWatermarkFactor) return;
3329
3330     m_sendBufferWatermarkFactor = value;
3331     configureDeferred();
3332 }
3333
3334 int Session::connectionSpeed() const
3335 {
3336     return m_connectionSpeed;
3337 }
3338
3339 void Session::setConnectionSpeed(const int value)
3340 {
3341     if (value == m_connectionSpeed) return;
3342
3343     m_connectionSpeed = value;
3344     configureDeferred();
3345 }
3346
3347 int Session::socketBacklogSize() const
3348 {
3349     return m_socketBacklogSize;
3350 }
3351
3352 void Session::setSocketBacklogSize(const int value)
3353 {
3354     if (value == m_socketBacklogSize) return;
3355
3356     m_socketBacklogSize = value;
3357     configureDeferred();
3358 }
3359
3360 bool Session::isAnonymousModeEnabled() const
3361 {
3362     return m_isAnonymousModeEnabled;
3363 }
3364
3365 void Session::setAnonymousModeEnabled(const bool enabled)
3366 {
3367     if (enabled != m_isAnonymousModeEnabled)
3368     {
3369         m_isAnonymousModeEnabled = enabled;
3370         configureDeferred();
3371         LogMsg(tr("Anonymous mode [%1]").arg(isAnonymousModeEnabled() ? tr("ON") : tr("OFF"))
3372             , Log::INFO);
3373     }
3374 }
3375
3376 bool Session::isQueueingSystemEnabled() const
3377 {
3378     return m_isQueueingEnabled;
3379 }
3380
3381 void Session::setQueueingSystemEnabled(const bool enabled)
3382 {
3383     if (enabled != m_isQueueingEnabled)
3384     {
3385         m_isQueueingEnabled = enabled;
3386         configureDeferred();
3387
3388         if (enabled)
3389             saveTorrentsQueue();
3390         else
3391             removeTorrentsQueue();
3392     }
3393 }
3394
3395 int Session::maxActiveDownloads() const
3396 {
3397     return m_maxActiveDownloads;
3398 }
3399
3400 void Session::setMaxActiveDownloads(int max)
3401 {
3402     max = std::max(max, -1);
3403     if (max != m_maxActiveDownloads)
3404     {
3405         m_maxActiveDownloads = max;
3406         configureDeferred();
3407     }
3408 }
3409
3410 int Session::maxActiveUploads() const
3411 {
3412     return m_maxActiveUploads;
3413 }
3414
3415 void Session::setMaxActiveUploads(int max)
3416 {
3417     max = std::max(max, -1);
3418     if (max != m_maxActiveUploads)
3419     {
3420         m_maxActiveUploads = max;
3421         configureDeferred();
3422     }
3423 }
3424
3425 int Session::maxActiveTorrents() const
3426 {
3427     return m_maxActiveTorrents;
3428 }
3429
3430 void Session::setMaxActiveTorrents(int max)
3431 {
3432     max = std::max(max, -1);
3433     if (max != m_maxActiveTorrents)
3434     {
3435         m_maxActiveTorrents = max;
3436         configureDeferred();
3437     }
3438 }
3439
3440 bool Session::ignoreSlowTorrentsForQueueing() const
3441 {
3442     return m_ignoreSlowTorrentsForQueueing;
3443 }
3444
3445 void Session::setIgnoreSlowTorrentsForQueueing(const bool ignore)
3446 {
3447     if (ignore != m_ignoreSlowTorrentsForQueueing)
3448     {
3449         m_ignoreSlowTorrentsForQueueing = ignore;
3450         configureDeferred();
3451     }
3452 }
3453
3454 int Session::downloadRateForSlowTorrents() const
3455 {
3456     return m_downloadRateForSlowTorrents;
3457 }
3458
3459 void Session::setDownloadRateForSlowTorrents(const int rateInKibiBytes)
3460 {
3461     if (rateInKibiBytes == m_downloadRateForSlowTorrents)
3462         return;
3463
3464     m_downloadRateForSlowTorrents = rateInKibiBytes;
3465     configureDeferred();
3466 }
3467
3468 int Session::uploadRateForSlowTorrents() const
3469 {
3470     return m_uploadRateForSlowTorrents;
3471 }
3472
3473 void Session::setUploadRateForSlowTorrents(const int rateInKibiBytes)
3474 {
3475     if (rateInKibiBytes == m_uploadRateForSlowTorrents)
3476         return;
3477
3478     m_uploadRateForSlowTorrents = rateInKibiBytes;
3479     configureDeferred();
3480 }
3481
3482 int Session::slowTorrentsInactivityTimer() const
3483 {
3484     return m_slowTorrentsInactivityTimer;
3485 }
3486
3487 void Session::setSlowTorrentsInactivityTimer(const int timeInSeconds)
3488 {
3489     if (timeInSeconds == m_slowTorrentsInactivityTimer)
3490         return;
3491
3492     m_slowTorrentsInactivityTimer = timeInSeconds;
3493     configureDeferred();
3494 }
3495
3496 int Session::outgoingPortsMin() const
3497 {
3498     return m_outgoingPortsMin;
3499 }
3500
3501 void Session::setOutgoingPortsMin(const int min)
3502 {
3503     if (min != m_outgoingPortsMin)
3504     {
3505         m_outgoingPortsMin = min;
3506         configureDeferred();
3507     }
3508 }
3509
3510 int Session::outgoingPortsMax() const
3511 {
3512     return m_outgoingPortsMax;
3513 }
3514
3515 void Session::setOutgoingPortsMax(const int max)
3516 {
3517     if (max != m_outgoingPortsMax)
3518     {
3519         m_outgoingPortsMax = max;
3520         configureDeferred();
3521     }
3522 }
3523
3524 int Session::UPnPLeaseDuration() const
3525 {
3526     return m_UPnPLeaseDuration;
3527 }
3528
3529 void Session::setUPnPLeaseDuration(const int duration)
3530 {
3531     if (duration != m_UPnPLeaseDuration)
3532     {
3533         m_UPnPLeaseDuration = duration;
3534         configureDeferred();
3535     }
3536 }
3537
3538 int Session::peerToS() const
3539 {
3540     return m_peerToS;
3541 }
3542
3543 void Session::setPeerToS(const int value)
3544 {
3545     if (value == m_peerToS)
3546         return;
3547
3548     m_peerToS = value;
3549     configureDeferred();
3550 }
3551
3552 bool Session::ignoreLimitsOnLAN() const
3553 {
3554     return m_ignoreLimitsOnLAN;
3555 }
3556
3557 void Session::setIgnoreLimitsOnLAN(const bool ignore)
3558 {
3559     if (ignore != m_ignoreLimitsOnLAN)
3560     {
3561         m_ignoreLimitsOnLAN = ignore;
3562         configureDeferred();
3563     }
3564 }
3565
3566 bool Session::includeOverheadInLimits() const
3567 {
3568     return m_includeOverheadInLimits;
3569 }
3570
3571 void Session::setIncludeOverheadInLimits(const bool include)
3572 {
3573     if (include != m_includeOverheadInLimits)
3574     {
3575         m_includeOverheadInLimits = include;
3576         configureDeferred();
3577     }
3578 }
3579
3580 QString Session::announceIP() const
3581 {
3582     return m_announceIP;
3583 }
3584
3585 void Session::setAnnounceIP(const QString &ip)
3586 {
3587     if (ip != m_announceIP)
3588     {
3589         m_announceIP = ip;
3590         configureDeferred();
3591     }
3592 }
3593
3594 int Session::maxConcurrentHTTPAnnounces() const
3595 {
3596     return m_maxConcurrentHTTPAnnounces;
3597 }
3598
3599 void Session::setMaxConcurrentHTTPAnnounces(const int value)
3600 {
3601     if (value == m_maxConcurrentHTTPAnnounces)
3602         return;
3603
3604     m_maxConcurrentHTTPAnnounces = value;
3605     configureDeferred();
3606 }
3607
3608 bool Session::isReannounceWhenAddressChangedEnabled() const
3609 {
3610     return m_isReannounceWhenAddressChangedEnabled;
3611 }
3612
3613 void Session::setReannounceWhenAddressChangedEnabled(const bool enabled)
3614 {
3615     if (enabled == m_isReannounceWhenAddressChangedEnabled)
3616         return;
3617
3618     m_isReannounceWhenAddressChangedEnabled = enabled;
3619 }
3620
3621 void Session::reannounceToAllTrackers() const
3622 {
3623     for (const lt::torrent_handle &torrent : m_nativeSession->get_torrents())
3624         torrent.force_reannounce(0, -1, lt::torrent_handle::ignore_min_interval);
3625 }
3626
3627 int Session::stopTrackerTimeout() const
3628 {
3629     return m_stopTrackerTimeout;
3630 }
3631
3632 void Session::setStopTrackerTimeout(const int value)
3633 {
3634     if (value == m_stopTrackerTimeout)
3635         return;
3636
3637     m_stopTrackerTimeout = value;
3638     configureDeferred();
3639 }
3640
3641 int Session::maxConnections() const
3642 {
3643     return m_maxConnections;
3644 }
3645
3646 void Session::setMaxConnections(int max)
3647 {
3648     max = (max > 0) ? max : -1;
3649     if (max != m_maxConnections)
3650     {
3651         m_maxConnections = max;
3652         configureDeferred();
3653     }
3654 }
3655
3656 int Session::maxUploads() const
3657 {
3658     return m_maxUploads;
3659 }
3660
3661 void Session::setMaxUploads(int max)
3662 {
3663     max = (max > 0) ? max : -1;
3664     if (max != m_maxUploads)
3665     {
3666         m_maxUploads = max;
3667         configureDeferred();
3668     }
3669 }
3670
3671 BTProtocol Session::btProtocol() const
3672 {
3673     return m_btProtocol;
3674 }
3675
3676 void Session::setBTProtocol(const BTProtocol protocol)
3677 {
3678     if ((protocol < BTProtocol::Both) || (BTProtocol::UTP < protocol))
3679         return;
3680
3681     if (protocol == m_btProtocol) return;
3682
3683     m_btProtocol = protocol;
3684     configureDeferred();
3685 }
3686
3687 bool Session::isUTPRateLimited() const
3688 {
3689     return m_isUTPRateLimited;
3690 }
3691
3692 void Session::setUTPRateLimited(const bool limited)
3693 {
3694     if (limited != m_isUTPRateLimited)
3695     {
3696         m_isUTPRateLimited = limited;
3697         configureDeferred();
3698     }
3699 }
3700
3701 MixedModeAlgorithm Session::utpMixedMode() const
3702 {
3703     return m_utpMixedMode;
3704 }
3705
3706 void Session::setUtpMixedMode(const MixedModeAlgorithm mode)
3707 {
3708     if (mode == m_utpMixedMode) return;
3709
3710     m_utpMixedMode = mode;
3711     configureDeferred();
3712 }
3713
3714 bool Session::isIDNSupportEnabled() const
3715 {
3716     return m_IDNSupportEnabled;
3717 }
3718
3719 void Session::setIDNSupportEnabled(const bool enabled)
3720 {
3721     if (enabled == m_IDNSupportEnabled) return;
3722
3723     m_IDNSupportEnabled = enabled;
3724     configureDeferred();
3725 }
3726
3727 bool Session::multiConnectionsPerIpEnabled() const
3728 {
3729     return m_multiConnectionsPerIpEnabled;
3730 }
3731
3732 void Session::setMultiConnectionsPerIpEnabled(const bool enabled)
3733 {
3734     if (enabled == m_multiConnectionsPerIpEnabled) return;
3735
3736     m_multiConnectionsPerIpEnabled = enabled;
3737     configureDeferred();
3738 }
3739
3740 bool Session::validateHTTPSTrackerCertificate() const
3741 {
3742     return m_validateHTTPSTrackerCertificate;
3743 }
3744
3745 void Session::setValidateHTTPSTrackerCertificate(const bool enabled)
3746 {
3747     if (enabled == m_validateHTTPSTrackerCertificate) return;
3748
3749     m_validateHTTPSTrackerCertificate = enabled;
3750     configureDeferred();
3751 }
3752
3753 bool Session::blockPeersOnPrivilegedPorts() const
3754 {
3755     return m_blockPeersOnPrivilegedPorts;
3756 }
3757
3758 void Session::setBlockPeersOnPrivilegedPorts(const bool enabled)
3759 {
3760     if (enabled == m_blockPeersOnPrivilegedPorts) return;
3761
3762     m_blockPeersOnPrivilegedPorts = enabled;
3763     configureDeferred();
3764 }
3765
3766 bool Session::isTrackerFilteringEnabled() const
3767 {
3768     return m_isTrackerFilteringEnabled;
3769 }
3770
3771 void Session::setTrackerFilteringEnabled(const bool enabled)
3772 {
3773     if (enabled != m_isTrackerFilteringEnabled)
3774     {
3775         m_isTrackerFilteringEnabled = enabled;
3776         configureDeferred();
3777     }
3778 }
3779
3780 bool Session::isListening() const
3781 {
3782     return m_nativeSession->is_listening();
3783 }
3784
3785 MaxRatioAction Session::maxRatioAction() const
3786 {
3787     return static_cast<MaxRatioAction>(m_maxRatioAction.get());
3788 }
3789
3790 void Session::setMaxRatioAction(const MaxRatioAction act)
3791 {
3792     m_maxRatioAction = static_cast<int>(act);
3793 }
3794
3795 // If this functions returns true, we cannot add torrent to session,
3796 // but it is still possible to merge trackers in some cases
3797 bool Session::isKnownTorrent(const TorrentID &id) const
3798 {
3799     return (m_torrents.contains(id)
3800             || m_loadingTorrents.contains(id)
3801             || m_downloadedMetadata.contains(id));
3802 }
3803
3804 void Session::updateSeedingLimitTimer()
3805 {
3806     if ((globalMaxRatio() == Torrent::NO_RATIO_LIMIT) && !hasPerTorrentRatioLimit()
3807         && (globalMaxSeedingMinutes() == Torrent::NO_SEEDING_TIME_LIMIT) && !hasPerTorrentSeedingTimeLimit())
3808         {
3809         if (m_seedingLimitTimer->isActive())
3810             m_seedingLimitTimer->stop();
3811     }
3812     else if (!m_seedingLimitTimer->isActive())
3813     {
3814         m_seedingLimitTimer->start();
3815     }
3816 }
3817
3818 void Session::handleTorrentShareLimitChanged(TorrentImpl *const)
3819 {
3820     updateSeedingLimitTimer();
3821 }
3822
3823 void Session::handleTorrentNameChanged(TorrentImpl *const)
3824 {
3825 }
3826
3827 void Session::handleTorrentSavePathChanged(TorrentImpl *const torrent)
3828 {
3829     emit torrentSavePathChanged(torrent);
3830 }
3831
3832 void Session::handleTorrentCategoryChanged(TorrentImpl *const torrent, const QString &oldCategory)
3833 {
3834     emit torrentCategoryChanged(torrent, oldCategory);
3835 }
3836
3837 void Session::handleTorrentTagAdded(TorrentImpl *const torrent, const QString &tag)
3838 {
3839     emit torrentTagAdded(torrent, tag);
3840 }
3841
3842 void Session::handleTorrentTagRemoved(TorrentImpl *const torrent, const QString &tag)
3843 {
3844     emit torrentTagRemoved(torrent, tag);
3845 }
3846
3847 void Session::handleTorrentSavingModeChanged(TorrentImpl *const torrent)
3848 {
3849     emit torrentSavingModeChanged(torrent);
3850 }
3851
3852 void Session::handleTorrentTrackersAdded(TorrentImpl *const torrent, const QVector<TrackerEntry> &newTrackers)
3853 {
3854     for (const TrackerEntry &newTracker : newTrackers)
3855         LogMsg(tr("Tracker '%1' was added to torrent '%2'").arg(newTracker.url, torrent->name()));
3856     emit trackersAdded(torrent, newTrackers);
3857     if (torrent->trackers().size() == newTrackers.size())
3858         emit trackerlessStateChanged(torrent, false);
3859     emit trackersChanged(torrent);
3860 }
3861
3862 void Session::handleTorrentTrackersRemoved(TorrentImpl *const torrent, const QVector<TrackerEntry> &deletedTrackers)
3863 {
3864     for (const TrackerEntry &deletedTracker : deletedTrackers)
3865         LogMsg(tr("Tracker '%1' was deleted from torrent '%2'").arg(deletedTracker.url, torrent->name()));
3866     emit trackersRemoved(torrent, deletedTrackers);
3867     if (torrent->trackers().empty())
3868         emit trackerlessStateChanged(torrent, true);
3869     emit trackersChanged(torrent);
3870 }
3871
3872 void Session::handleTorrentTrackersChanged(TorrentImpl *const torrent)
3873 {
3874     emit trackersChanged(torrent);
3875 }
3876
3877 void Session::handleTorrentUrlSeedsAdded(TorrentImpl *const torrent, const QVector<QUrl> &newUrlSeeds)
3878 {
3879     for (const QUrl &newUrlSeed : newUrlSeeds)
3880         LogMsg(tr("URL seed '%1' was added to torrent '%2'").arg(newUrlSeed.toString(), torrent->name()));
3881 }
3882
3883 void Session::handleTorrentUrlSeedsRemoved(TorrentImpl *const torrent, const QVector<QUrl> &urlSeeds)
3884 {
3885     for (const QUrl &urlSeed : urlSeeds)
3886         LogMsg(tr("URL seed '%1' was removed from torrent '%2'").arg(urlSeed.toString(), torrent->name()));
3887 }
3888
3889 void Session::handleTorrentMetadataReceived(TorrentImpl *const torrent)
3890 {
3891     // Copy the torrent file to the export folder
3892     if (!torrentExportDirectory().isEmpty())
3893     {
3894 #if (LIBTORRENT_VERSION_NUM >= 20000)
3895         const TorrentInfo torrentInfo {torrent->nativeHandle().torrent_file_with_hashes()};
3896 #else
3897         const TorrentInfo torrentInfo {torrent->nativeHandle().torrent_file()};
3898 #endif
3899         exportTorrentFile(torrentInfo, torrentExportDirectory(), torrent->name());
3900     }
3901
3902     emit torrentMetadataReceived(torrent);
3903 }
3904
3905 void Session::handleTorrentPaused(TorrentImpl *const torrent)
3906 {
3907     emit torrentPaused(torrent);
3908 }
3909
3910 void Session::handleTorrentResumed(TorrentImpl *const torrent)
3911 {
3912     emit torrentResumed(torrent);
3913 }
3914
3915 void Session::handleTorrentChecked(TorrentImpl *const torrent)
3916 {
3917     emit torrentFinishedChecking(torrent);
3918 }
3919
3920 void Session::handleTorrentFinished(TorrentImpl *const torrent)
3921 {
3922     emit torrentFinished(torrent);
3923
3924     qDebug("Checking if the torrent contains torrent files to download");
3925     // Check if there are torrent files inside
3926     for (int i = 0; i < torrent->filesCount(); ++i)
3927     {
3928         const QString torrentRelpath = torrent->filePath(i);
3929         if (torrentRelpath.endsWith(".torrent", Qt::CaseInsensitive))
3930         {
3931             qDebug("Found possible recursive torrent download.");
3932             const QString torrentFullpath = torrent->savePath(true) + '/' + torrentRelpath;
3933             qDebug("Full subtorrent path is %s", qUtf8Printable(torrentFullpath));
3934             TorrentInfo torrentInfo = TorrentInfo::loadFromFile(torrentFullpath);
3935             if (torrentInfo.isValid())
3936             {
3937                 qDebug("emitting recursiveTorrentDownloadPossible()");
3938                 emit recursiveTorrentDownloadPossible(torrent);
3939                 break;
3940             }
3941             else
3942             {
3943                 qDebug("Caught error loading torrent");
3944                 LogMsg(tr("Unable to decode '%1' torrent file.").arg(Utils::Fs::toNativePath(torrentFullpath)), Log::CRITICAL);
3945             }
3946         }
3947     }
3948
3949     // Move .torrent file to another folder
3950     if (!finishedTorrentExportDirectory().isEmpty())
3951     {
3952 #if (LIBTORRENT_VERSION_NUM >= 20000)
3953         const TorrentInfo torrentInfo {torrent->nativeHandle().torrent_file_with_hashes()};
3954 #else
3955         const TorrentInfo torrentInfo {torrent->nativeHandle().torrent_file()};
3956 #endif
3957         exportTorrentFile(torrentInfo, finishedTorrentExportDirectory(), torrent->name());
3958     }
3959
3960     if (!hasUnfinishedTorrents())
3961         emit allTorrentsFinished();
3962 }
3963
3964 void Session::handleTorrentResumeDataReady(TorrentImpl *const torrent, const LoadTorrentParams &data)
3965 {
3966     --m_numResumeData;
3967
3968     m_resumeDataStorage->store(torrent->id(), data);
3969 }
3970
3971 void Session::handleTorrentTrackerReply(TorrentImpl *const torrent, const QString &trackerUrl)
3972 {
3973     emit trackerSuccess(torrent, trackerUrl);
3974 }
3975
3976 void Session::handleTorrentTrackerError(TorrentImpl *const torrent, const QString &trackerUrl)
3977 {
3978     emit trackerError(torrent, trackerUrl);
3979 }
3980
3981 bool Session::addMoveTorrentStorageJob(TorrentImpl *torrent, const QString &newPath, const MoveStorageMode mode)
3982 {
3983     Q_ASSERT(torrent);
3984
3985     const lt::torrent_handle torrentHandle = torrent->nativeHandle();
3986     const QString currentLocation = torrent->actualStorageLocation();
3987
3988     if (m_moveStorageQueue.size() > 1)
3989     {
3990         const auto iter = std::find_if(m_moveStorageQueue.begin() + 1, m_moveStorageQueue.end()
3991                                  , [&torrentHandle](const MoveStorageJob &job)
3992         {
3993             return job.torrentHandle == torrentHandle;
3994         });
3995
3996         if (iter != m_moveStorageQueue.end())
3997         {
3998             // remove existing inactive job
3999             m_moveStorageQueue.erase(iter);
4000             LogMsg(tr("Cancelled moving \"%1\" from \"%2\" to \"%3\".").arg(torrent->name(), currentLocation, iter->path));
4001         }
4002     }
4003
4004     if (!m_moveStorageQueue.isEmpty() && (m_moveStorageQueue.first().torrentHandle == torrentHandle))
4005     {
4006         // if there is active job for this torrent prevent creating meaningless
4007         // job that will move torrent to the same location as current one
4008         if (QDir {m_moveStorageQueue.first().path} == QDir {newPath})
4009         {
4010             LogMsg(tr("Couldn't enqueue move of \"%1\" to \"%2\". Torrent is currently moving to the same destination location.")
4011                    .arg(torrent->name(), newPath));
4012             return false;
4013         }
4014     }
4015     else
4016     {
4017         if (QDir {currentLocation} == QDir {newPath})
4018         {
4019             LogMsg(tr("Couldn't enqueue move of \"%1\" from \"%2\" to \"%3\". Both paths point to the same location.")
4020                    .arg(torrent->name(), currentLocation, newPath));
4021             return false;
4022         }
4023     }
4024
4025     const MoveStorageJob moveStorageJob {torrentHandle, newPath, mode};
4026     m_moveStorageQueue << moveStorageJob;
4027     LogMsg(tr("Enqueued to move \"%1\" from \"%2\" to \"%3\".").arg(torrent->name(), currentLocation, newPath));
4028
4029     if (m_moveStorageQueue.size() == 1)
4030         moveTorrentStorage(moveStorageJob);
4031
4032     return true;
4033 }
4034
4035 void Session::moveTorrentStorage(const MoveStorageJob &job) const
4036 {
4037 #if (LIBTORRENT_VERSION_NUM >= 20000)
4038     const auto id = TorrentID::fromInfoHash(job.torrentHandle.info_hashes());
4039 #else
4040     const auto id = TorrentID::fromInfoHash(job.torrentHandle.info_hash());
4041 #endif
4042     const TorrentImpl *torrent = m_torrents.value(id);
4043     const QString torrentName = (torrent ? torrent->name() : id.toString());
4044     LogMsg(tr("Moving \"%1\" to \"%2\"...").arg(torrentName, job.path));
4045
4046     job.torrentHandle.move_storage(job.path.toUtf8().constData()
4047                             , ((job.mode == MoveStorageMode::Overwrite)
4048                             ? lt::move_flags_t::always_replace_files : lt::move_flags_t::dont_replace));
4049 }
4050
4051 void Session::handleMoveTorrentStorageJobFinished()
4052 {
4053     const MoveStorageJob finishedJob = m_moveStorageQueue.takeFirst();
4054     if (!m_moveStorageQueue.isEmpty())
4055         moveTorrentStorage(m_moveStorageQueue.first());
4056
4057     const auto iter = std::find_if(m_moveStorageQueue.cbegin(), m_moveStorageQueue.cend()
4058                                    , [&finishedJob](const MoveStorageJob &job)
4059     {
4060         return job.torrentHandle == finishedJob.torrentHandle;
4061     });
4062
4063     const bool torrentHasOutstandingJob = (iter != m_moveStorageQueue.cend());
4064
4065     TorrentImpl *torrent = m_torrents.value(finishedJob.torrentHandle.info_hash());
4066     if (torrent)
4067     {
4068         torrent->handleMoveStorageJobFinished(torrentHasOutstandingJob);
4069     }
4070     else if (!torrentHasOutstandingJob)
4071     {
4072         // Last job is completed for torrent that being removing, so actually remove it
4073         const lt::torrent_handle nativeHandle {finishedJob.torrentHandle};
4074         const RemovingTorrentData &removingTorrentData = m_removingTorrents[nativeHandle.info_hash()];
4075         if (removingTorrentData.deleteOption == DeleteTorrent)
4076             m_nativeSession->remove_torrent(nativeHandle, lt::session::delete_partfile);
4077     }
4078 }
4079
4080 void Session::handleTorrentTrackerWarning(TorrentImpl *const torrent, const QString &trackerUrl)
4081 {
4082     emit trackerWarning(torrent, trackerUrl);
4083 }
4084
4085 bool Session::hasPerTorrentRatioLimit() const
4086 {
4087     return std::any_of(m_torrents.cbegin(), m_torrents.cend(), [](const TorrentImpl *torrent)
4088     {
4089         return (torrent->ratioLimit() >= 0);
4090     });
4091 }
4092
4093 bool Session::hasPerTorrentSeedingTimeLimit() const
4094 {
4095     return std::any_of(m_torrents.cbegin(), m_torrents.cend(), [](const TorrentImpl *torrent)
4096     {
4097         return (torrent->seedingTimeLimit() >= 0);
4098     });
4099 }
4100
4101 void Session::configureDeferred()
4102 {
4103     if (m_deferredConfigureScheduled)
4104         return;
4105
4106     m_deferredConfigureScheduled = true;
4107     QMetaObject::invokeMethod(this, qOverload<>(&Session::configure), Qt::QueuedConnection);
4108 }
4109
4110 // Enable IP Filtering
4111 // this method creates ban list from scratch combining user ban list and 3rd party ban list file
4112 void Session::enableIPFilter()
4113 {
4114     qDebug("Enabling IPFilter");
4115     // 1. Parse the IP filter
4116     // 2. In the slot add the manually banned IPs to the provided lt::ip_filter
4117     // 3. Set the ip_filter in one go so there isn't a time window where there isn't an ip_filter
4118     //    set between clearing the old one and setting the new one.
4119     if (!m_filterParser)
4120     {
4121         m_filterParser = new FilterParserThread(this);
4122         connect(m_filterParser.data(), &FilterParserThread::IPFilterParsed, this, &Session::handleIPFilterParsed);
4123         connect(m_filterParser.data(), &FilterParserThread::IPFilterError, this, &Session::handleIPFilterError);
4124     }
4125     m_filterParser->processFilterFile(IPFilterFile());
4126 }
4127
4128 // Disable IP Filtering
4129 void Session::disableIPFilter()
4130 {
4131     qDebug("Disabling IPFilter");
4132     if (m_filterParser)
4133     {
4134         disconnect(m_filterParser.data(), nullptr, this, nullptr);
4135         delete m_filterParser;
4136     }
4137
4138     // Add the banned IPs after the IPFilter disabling
4139     // which creates an empty filter and overrides all previously
4140     // applied bans.
4141     lt::ip_filter filter;
4142     processBannedIPs(filter);
4143     m_nativeSession->set_ip_filter(filter);
4144 }
4145
4146 void Session::recursiveTorrentDownload(const TorrentID &id)
4147 {
4148     TorrentImpl *const torrent = m_torrents.value(id);
4149     if (!torrent) return;
4150
4151     for (int i = 0; i < torrent->filesCount(); ++i)
4152     {
4153         const QString torrentRelpath = torrent->filePath(i);
4154         if (torrentRelpath.endsWith(".torrent"))
4155         {
4156             LogMsg(tr("Recursive download of file '%1' embedded in torrent '%2'"
4157                     , "Recursive download of 'test.torrent' embedded in torrent 'test2'")
4158                 .arg(Utils::Fs::toNativePath(torrentRelpath), torrent->name()));
4159             const QString torrentFullpath = torrent->savePath() + '/' + torrentRelpath;
4160
4161             AddTorrentParams params;
4162             // Passing the save path along to the sub torrent file
4163             params.savePath = torrent->savePath();
4164             addTorrent(TorrentInfo::loadFromFile(torrentFullpath), params);
4165         }
4166     }
4167 }
4168
4169 const SessionStatus &Session::status() const
4170 {
4171     return m_status;
4172 }
4173
4174 const CacheStatus &Session::cacheStatus() const
4175 {
4176     return m_cacheStatus;
4177 }
4178
4179 void Session::startUpTorrents()
4180 {
4181     qDebug("Initializing torrents resume data storage...");
4182
4183     const QString dbPath = Utils::Fs::expandPathAbs(
4184                 specialFolderLocation(SpecialFolder::Data) + QLatin1String("torrents.db"));
4185     const bool dbStorageExists = QFile::exists(dbPath);
4186
4187     ResumeDataStorage *startupStorage = nullptr;
4188     if (resumeDataStorageType() == ResumeDataStorageType::SQLite)
4189     {
4190         m_resumeDataStorage = new DBResumeDataStorage(dbPath, this);
4191
4192         if (!dbStorageExists)
4193         {
4194             const QString dataPath = Utils::Fs::expandPathAbs(
4195                         specialFolderLocation(SpecialFolder::Data) + QLatin1String("BT_backup"));
4196             startupStorage = new BencodeResumeDataStorage(dataPath, this);
4197         }
4198     }
4199     else
4200     {
4201         const QString dataPath = Utils::Fs::expandPathAbs(
4202                     specialFolderLocation(SpecialFolder::Data) + QLatin1String("BT_backup"));
4203         m_resumeDataStorage = new BencodeResumeDataStorage(dataPath, this);
4204
4205         if (dbStorageExists)
4206             startupStorage = new DBResumeDataStorage(dbPath, this);
4207     }
4208
4209     if (!startupStorage)
4210         startupStorage = m_resumeDataStorage;
4211
4212     qDebug("Starting up torrents...");
4213
4214     const QVector<TorrentID> torrents = startupStorage->registeredTorrents();
4215     int resumedTorrentsCount = 0;
4216     QVector<TorrentID> queue;
4217     for (const TorrentID &torrentID : torrents)
4218     {
4219         const std::optional<LoadTorrentParams> resumeData = startupStorage->load(torrentID);
4220         if (resumeData)
4221         {
4222             if (m_resumeDataStorage != startupStorage)
4223             {
4224                 m_resumeDataStorage->store(torrentID, *resumeData);
4225                 if (isQueueingSystemEnabled() && !resumeData->hasSeedStatus)
4226                     queue.append(torrentID);
4227             }
4228
4229             qDebug() << "Starting up torrent" << torrentID.toString() << "...";
4230             if (!loadTorrent(*resumeData))
4231                 LogMsg(tr("Unable to resume torrent '%1'.", "e.g: Unable to resume torrent 'hash'.")
4232                            .arg(torrentID.toString()), Log::CRITICAL);
4233
4234             // process add torrent messages before message queue overflow
4235             if ((resumedTorrentsCount % 100) == 0) readAlerts();
4236
4237             ++resumedTorrentsCount;
4238         }
4239         else
4240         {
4241             LogMsg(tr("Unable to resume torrent '%1'.", "e.g: Unable to resume torrent 'hash'.")
4242                        .arg(torrentID.toString()), Log::CRITICAL);
4243         }
4244     }
4245
4246     if (m_resumeDataStorage != startupStorage)
4247     {
4248         delete startupStorage;
4249         if (resumeDataStorageType() == ResumeDataStorageType::Legacy)
4250             Utils::Fs::forceRemove(dbPath);
4251
4252         if (isQueueingSystemEnabled())
4253             m_resumeDataStorage->storeQueue(queue);
4254     }
4255 }
4256
4257 quint64 Session::getAlltimeDL() const
4258 {
4259     return m_statistics->getAlltimeDL();
4260 }
4261
4262 quint64 Session::getAlltimeUL() const
4263 {
4264     return m_statistics->getAlltimeUL();
4265 }
4266
4267 void Session::enqueueRefresh()
4268 {
4269     Q_ASSERT(!m_refreshEnqueued);
4270
4271     QTimer::singleShot(refreshInterval(), this, [this] ()
4272     {
4273         m_nativeSession->post_torrent_updates();
4274         m_nativeSession->post_session_stats();
4275     });
4276
4277     m_refreshEnqueued = true;
4278 }
4279
4280 void Session::handleIPFilterParsed(const int ruleCount)
4281 {
4282     if (m_filterParser)
4283     {
4284         lt::ip_filter filter = m_filterParser->IPfilter();
4285         processBannedIPs(filter);
4286         m_nativeSession->set_ip_filter(filter);
4287     }
4288     LogMsg(tr("Successfully parsed the provided IP filter: %1 rules were applied.", "%1 is a number").arg(ruleCount));
4289     emit IPFilterParsed(false, ruleCount);
4290 }
4291
4292 void Session::handleIPFilterError()
4293 {
4294     lt::ip_filter filter;
4295     processBannedIPs(filter);
4296     m_nativeSession->set_ip_filter(filter);
4297
4298     LogMsg(tr("Error: Failed to parse the provided IP filter."), Log::CRITICAL);
4299     emit IPFilterParsed(true, 0);
4300 }
4301
4302 std::vector<lt::alert *> Session::getPendingAlerts(const lt::time_duration time) const
4303 {
4304     if (time > lt::time_duration::zero())
4305         m_nativeSession->wait_for_alert(time);
4306
4307     std::vector<lt::alert *> alerts;
4308     m_nativeSession->pop_alerts(&alerts);
4309     return alerts;
4310 }
4311
4312 TorrentContentLayout Session::torrentContentLayout() const
4313 {
4314     return m_torrentContentLayout;
4315 }
4316
4317 void Session::setTorrentContentLayout(const TorrentContentLayout value)
4318 {
4319     m_torrentContentLayout = value;
4320 }
4321
4322 // Read alerts sent by the BitTorrent session
4323 void Session::readAlerts()
4324 {
4325     const std::vector<lt::alert *> alerts = getPendingAlerts();
4326     for (const lt::alert *a : alerts)
4327         handleAlert(a);
4328 }
4329
4330 void Session::handleAlert(const lt::alert *a)
4331 {
4332     try
4333     {
4334         switch (a->type())
4335         {
4336 #if (LIBTORRENT_VERSION_NUM >= 20003)
4337         case lt::file_prio_alert::alert_type:
4338 #endif
4339         case lt::file_renamed_alert::alert_type:
4340         case lt::file_completed_alert::alert_type:
4341         case lt::torrent_finished_alert::alert_type:
4342         case lt::save_resume_data_alert::alert_type:
4343         case lt::save_resume_data_failed_alert::alert_type:
4344         case lt::torrent_paused_alert::alert_type:
4345         case lt::torrent_resumed_alert::alert_type:
4346         case lt::tracker_error_alert::alert_type:
4347         case lt::tracker_reply_alert::alert_type:
4348         case lt::tracker_warning_alert::alert_type:
4349         case lt::fastresume_rejected_alert::alert_type:
4350         case lt::torrent_checked_alert::alert_type:
4351         case lt::metadata_received_alert::alert_type:
4352             dispatchTorrentAlert(a);
4353             break;
4354         case lt::state_update_alert::alert_type:
4355             handleStateUpdateAlert(static_cast<const lt::state_update_alert*>(a));
4356             break;
4357         case lt::session_stats_alert::alert_type:
4358             handleSessionStatsAlert(static_cast<const lt::session_stats_alert*>(a));
4359             break;
4360         case lt::file_error_alert::alert_type:
4361             handleFileErrorAlert(static_cast<const lt::file_error_alert*>(a));
4362             break;
4363         case lt::add_torrent_alert::alert_type:
4364             handleAddTorrentAlert(static_cast<const lt::add_torrent_alert*>(a));
4365             break;
4366         case lt::torrent_removed_alert::alert_type:
4367             handleTorrentRemovedAlert(static_cast<const lt::torrent_removed_alert*>(a));
4368             break;
4369         case lt::torrent_deleted_alert::alert_type:
4370             handleTorrentDeletedAlert(static_cast<const lt::torrent_deleted_alert*>(a));
4371             break;
4372         case lt::torrent_delete_failed_alert::alert_type:
4373             handleTorrentDeleteFailedAlert(static_cast<const lt::torrent_delete_failed_alert*>(a));
4374             break;
4375         case lt::portmap_error_alert::alert_type:
4376             handlePortmapWarningAlert(static_cast<const lt::portmap_error_alert*>(a));
4377             break;
4378         case lt::portmap_alert::alert_type:
4379             handlePortmapAlert(static_cast<const lt::portmap_alert*>(a));
4380             break;
4381         case lt::peer_blocked_alert::alert_type:
4382             handlePeerBlockedAlert(static_cast<const lt::peer_blocked_alert*>(a));
4383             break;
4384         case lt::peer_ban_alert::alert_type:
4385             handlePeerBanAlert(static_cast<const lt::peer_ban_alert*>(a));
4386             break;
4387         case lt::url_seed_alert::alert_type:
4388             handleUrlSeedAlert(static_cast<const lt::url_seed_alert*>(a));
4389             break;
4390         case lt::listen_succeeded_alert::alert_type:
4391             handleListenSucceededAlert(static_cast<const lt::listen_succeeded_alert*>(a));
4392             break;
4393         case lt::listen_failed_alert::alert_type:
4394             handleListenFailedAlert(static_cast<const lt::listen_failed_alert*>(a));
4395             break;
4396         case lt::external_ip_alert::alert_type:
4397             handleExternalIPAlert(static_cast<const lt::external_ip_alert*>(a));
4398             break;
4399         case lt::alerts_dropped_alert::alert_type:
4400             handleAlertsDroppedAlert(static_cast<const lt::alerts_dropped_alert *>(a));
4401             break;
4402         case lt::storage_moved_alert::alert_type:
4403             handleStorageMovedAlert(static_cast<const lt::storage_moved_alert*>(a));
4404             break;
4405         case lt::storage_moved_failed_alert::alert_type:
4406             handleStorageMovedFailedAlert(static_cast<const lt::storage_moved_failed_alert*>(a));
4407             break;
4408         case lt::socks5_alert::alert_type:
4409             handleSocks5Alert(static_cast<const lt::socks5_alert *>(a));
4410             break;
4411         }
4412     }
4413     catch (const std::exception &exc)
4414     {
4415         qWarning() << "Caught exception in " << Q_FUNC_INFO << ": " << QString::fromStdString(exc.what());
4416     }
4417 }
4418
4419 void Session::dispatchTorrentAlert(const lt::alert *a)
4420 {
4421     TorrentImpl *const torrent = m_torrents.value(static_cast<const lt::torrent_alert*>(a)->handle.info_hash());
4422     if (torrent)
4423     {
4424         torrent->handleAlert(a);
4425         return;
4426     }
4427
4428     switch (a->type())
4429     {
4430     case lt::metadata_received_alert::alert_type:
4431         handleMetadataReceivedAlert(static_cast<const lt::metadata_received_alert*>(a));
4432         break;
4433     }
4434 }
4435
4436 void Session::createTorrent(const lt::torrent_handle &nativeHandle)
4437 {
4438 #if (LIBTORRENT_VERSION_NUM >= 20000)
4439     const auto torrentID = TorrentID::fromInfoHash(nativeHandle.info_hashes());
4440 #else
4441     const auto torrentID = TorrentID::fromInfoHash(nativeHandle.info_hash());
4442 #endif
4443
4444     Q_ASSERT(m_loadingTorrents.contains(torrentID));
4445
4446     const LoadTorrentParams params = m_loadingTorrents.take(torrentID);
4447
4448     auto *const torrent = new TorrentImpl {this, m_nativeSession, nativeHandle, params};
4449     m_torrents.insert(torrent->id(), torrent);
4450
4451     const bool hasMetadata = torrent->hasMetadata();
4452
4453     if (params.restored)
4454     {
4455         LogMsg(tr("'%1' restored.", "'torrent name' restored.").arg(torrent->name()));
4456     }
4457     else
4458     {
4459         m_resumeDataStorage->store(torrent->id(), params);
4460
4461         // The following is useless for newly added magnet
4462         if (hasMetadata)
4463         {
4464             // Copy the torrent file to the export folder
4465             if (!torrentExportDirectory().isEmpty())
4466             {
4467                 const TorrentInfo torrentInfo {params.ltAddTorrentParams.ti};
4468                 exportTorrentFile(torrentInfo, torrentExportDirectory(), torrent->name());
4469             }
4470         }
4471
4472         if (isAddTrackersEnabled() && !torrent->isPrivate())
4473             torrent->addTrackers(m_additionalTrackerList);
4474
4475         LogMsg(tr("'%1' added to download list.", "'torrent name' was added to download list.")
4476             .arg(torrent->name()));
4477     }
4478
4479     if (((torrent->ratioLimit() >= 0) || (torrent->seedingTimeLimit() >= 0))
4480         && !m_seedingLimitTimer->isActive())
4481         m_seedingLimitTimer->start();
4482
4483     // Send torrent addition signal
4484     emit torrentLoaded(torrent);
4485     // Send new torrent signal
4486     if (!params.restored)
4487         emit torrentAdded(torrent);
4488
4489     // Torrent could have error just after adding to libtorrent
4490     if (torrent->hasError())
4491         LogMsg(tr("Torrent errored. Torrent: \"%1\". Error: %2.").arg(torrent->name(), torrent->error()), Log::WARNING);
4492 }
4493
4494 void Session::handleAddTorrentAlert(const lt::add_torrent_alert *p)
4495 {
4496     if (p->error)
4497     {
4498         const QString msg = QString::fromStdString(p->message());
4499         LogMsg(tr("Couldn't load torrent. Reason: %1.").arg(msg), Log::WARNING);
4500         emit loadTorrentFailed(msg);
4501
4502         const lt::add_torrent_params &params = p->params;
4503         const bool hasMetadata = (params.ti && params.ti->is_valid());
4504 #if (LIBTORRENT_VERSION_NUM >= 20000)
4505         const auto id = TorrentID::fromInfoHash(hasMetadata ? params.ti->info_hashes() : params.info_hashes);
4506 #else
4507         const auto id = TorrentID::fromInfoHash(hasMetadata ? params.ti->info_hash() : params.info_hash);
4508 #endif
4509         m_loadingTorrents.remove(id);
4510     }
4511     else if (m_loadingTorrents.contains(p->handle.info_hash()))
4512     {
4513         createTorrent(p->handle);
4514     }
4515 }
4516
4517 void Session::handleTorrentRemovedAlert(const lt::torrent_removed_alert *p)
4518 {
4519 #if (LIBTORRENT_VERSION_NUM >= 20000)
4520     const auto id = TorrentID::fromInfoHash(p->info_hashes);
4521 #else
4522     const auto id = TorrentID::fromInfoHash(p->info_hash);
4523 #endif
4524
4525     const auto removingTorrentDataIter = m_removingTorrents.find(id);
4526     if (removingTorrentDataIter != m_removingTorrents.end())
4527     {
4528         if (removingTorrentDataIter->deleteOption == DeleteTorrent)
4529         {
4530             LogMsg(tr("'%1' was removed from the transfer list.", "'xxx.avi' was removed...").arg(removingTorrentDataIter->name));
4531             m_removingTorrents.erase(removingTorrentDataIter);
4532         }
4533     }
4534 }
4535
4536 void Session::handleTorrentDeletedAlert(const lt::torrent_deleted_alert *p)
4537 {
4538 #if (LIBTORRENT_VERSION_NUM >= 20000)
4539     const auto id = TorrentID::fromInfoHash(p->info_hashes);
4540 #else
4541     const auto id = TorrentID::fromInfoHash(p->info_hash);
4542 #endif
4543
4544     const auto removingTorrentDataIter = m_removingTorrents.find(id);
4545
4546     if (removingTorrentDataIter == m_removingTorrents.end())
4547         return;
4548
4549     Utils::Fs::smartRemoveEmptyFolderTree(removingTorrentDataIter->pathToRemove);
4550     LogMsg(tr("'%1' was removed from the transfer list and hard disk.", "'xxx.avi' was removed...").arg(removingTorrentDataIter->name));
4551     m_removingTorrents.erase(removingTorrentDataIter);
4552 }
4553
4554 void Session::handleTorrentDeleteFailedAlert(const lt::torrent_delete_failed_alert *p)
4555 {
4556 #if (LIBTORRENT_VERSION_NUM >= 20000)
4557     const auto id = TorrentID::fromInfoHash(p->info_hashes);
4558 #else
4559     const auto id = TorrentID::fromInfoHash(p->info_hash);
4560 #endif
4561
4562     const auto removingTorrentDataIter = m_removingTorrents.find(id);
4563
4564     if (removingTorrentDataIter == m_removingTorrents.end())
4565         return;
4566
4567     if (p->error)
4568     {
4569         // libtorrent won't delete the directory if it contains files not listed in the torrent,
4570         // so we remove the directory ourselves
4571         Utils::Fs::smartRemoveEmptyFolderTree(removingTorrentDataIter->pathToRemove);
4572
4573         LogMsg(tr("'%1' was removed from the transfer list but the files couldn't be deleted. Error: %2", "'xxx.avi' was removed...")
4574                 .arg(removingTorrentDataIter->name, QString::fromLocal8Bit(p->error.message().c_str()))
4575             , Log::WARNING);
4576     }
4577     else // torrent without metadata, hence no files on disk
4578     {
4579         LogMsg(tr("'%1' was removed from the transfer list.", "'xxx.avi' was removed...").arg(removingTorrentDataIter->name));
4580     }
4581     m_removingTorrents.erase(removingTorrentDataIter);
4582 }
4583
4584 void Session::handleMetadataReceivedAlert(const lt::metadata_received_alert *p)
4585 {
4586 #if (LIBTORRENT_VERSION_NUM >= 20000)
4587     const auto id = TorrentID::fromInfoHash(p->handle.info_hashes());
4588 #else
4589     const auto id = TorrentID::fromInfoHash(p->handle.info_hash());
4590 #endif
4591
4592     const auto downloadedMetadataIter = m_downloadedMetadata.find(id);
4593
4594     if (downloadedMetadataIter != m_downloadedMetadata.end())
4595     {
4596         const TorrentInfo metadata {p->handle.torrent_file()};
4597
4598         m_downloadedMetadata.erase(downloadedMetadataIter);
4599         --m_extraLimit;
4600         adjustLimits();
4601         m_nativeSession->remove_torrent(p->handle, lt::session::delete_files);
4602
4603         emit metadataDownloaded(metadata);
4604     }
4605 }
4606
4607 void Session::handleFileErrorAlert(const lt::file_error_alert *p)
4608 {
4609     TorrentImpl *const torrent = m_torrents.value(p->handle.info_hash());
4610     if (!torrent)
4611         return;
4612
4613     torrent->handleAlert(p);
4614
4615     const TorrentID id = torrent->id();
4616     if (!m_recentErroredTorrents.contains(id))
4617     {
4618         m_recentErroredTorrents.insert(id);
4619
4620         const QString msg = QString::fromStdString(p->message());
4621         LogMsg(tr("File error alert. Torrent: \"%1\". File: \"%2\". Reason: %3")
4622                 .arg(torrent->name(), p->filename(), msg)
4623             , Log::WARNING);
4624         emit fullDiskError(torrent, msg);
4625     }
4626
4627     m_recentErroredTorrentsTimer->start();
4628 }
4629
4630 void Session::handlePortmapWarningAlert(const lt::portmap_error_alert *p)
4631 {
4632     LogMsg(tr("UPnP/NAT-PMP: Port mapping failure, message: %1").arg(QString::fromStdString(p->message())), Log::CRITICAL);
4633 }
4634
4635 void Session::handlePortmapAlert(const lt::portmap_alert *p)
4636 {
4637     qDebug("UPnP Success, msg: %s", p->message().c_str());
4638     LogMsg(tr("UPnP/NAT-PMP: Port mapping successful, message: %1").arg(QString::fromStdString(p->message())), Log::INFO);
4639 }
4640
4641 void Session::handlePeerBlockedAlert(const lt::peer_blocked_alert *p)
4642 {
4643     QString reason;
4644     switch (p->reason)
4645     {
4646     case lt::peer_blocked_alert::ip_filter:
4647         reason = tr("IP filter", "this peer was blocked. Reason: IP filter.");
4648         break;
4649     case lt::peer_blocked_alert::port_filter:
4650         reason = tr("port filter", "this peer was blocked. Reason: port filter.");
4651         break;
4652     case lt::peer_blocked_alert::i2p_mixed:
4653         reason = tr("%1 mixed mode restrictions", "this peer was blocked. Reason: I2P mixed mode restrictions.").arg("I2P"); // don't translate I2P
4654         break;
4655     case lt::peer_blocked_alert::privileged_ports:
4656         reason = tr("use of privileged port", "this peer was blocked. Reason: use of privileged port.");
4657         break;
4658     case lt::peer_blocked_alert::utp_disabled:
4659         reason = tr("%1 is disabled", "this peer was blocked. Reason: uTP is disabled.").arg(QString::fromUtf8(C_UTP)); // don't translate μTP
4660         break;
4661     case lt::peer_blocked_alert::tcp_disabled:
4662         reason = tr("%1 is disabled", "this peer was blocked. Reason: TCP is disabled.").arg("TCP"); // don't translate TCP
4663         break;
4664     }
4665
4666     const QString ip {toString(p->endpoint.address())};
4667     if (!ip.isEmpty())
4668         Logger::instance()->addPeer(ip, true, reason);
4669 }
4670
4671 void Session::handlePeerBanAlert(const lt::peer_ban_alert *p)
4672 {
4673     const QString ip {toString(p->endpoint.address())};
4674     if (!ip.isEmpty())
4675         Logger::instance()->addPeer(ip, false);
4676 }
4677
4678 void Session::handleUrlSeedAlert(const lt::url_seed_alert *p)
4679 {
4680     const TorrentImpl *torrent = m_torrents.value(p->handle.info_hash());
4681     if (!torrent)
4682         return;
4683
4684     if (p->error)
4685     {
4686         LogMsg(tr("URL seed name lookup failed. Torrent: \"%1\". URL: \"%2\". Error: \"%3\"")
4687             .arg(torrent->name(), p->server_url(), QString::fromStdString(p->message()))
4688             , Log::WARNING);
4689     }
4690     else
4691     {
4692         LogMsg(tr("Received error message from a URL seed. Torrent: \"%1\". URL: \"%2\". Message: \"%3\"")
4693             .arg(torrent->name(), p->server_url(), p->error_message())
4694             , Log::WARNING);
4695     }
4696 }
4697
4698 void Session::handleListenSucceededAlert(const lt::listen_succeeded_alert *p)
4699 {
4700     const QString proto {toString(p->socket_type)};
4701     LogMsg(tr("Successfully listening on IP: %1, port: %2/%3"
4702               , "e.g: Successfully listening on IP: 192.168.0.1, port: TCP/6881")
4703             .arg(toString(p->address), proto, QString::number(p->port)), Log::INFO);
4704
4705     // Force reannounce on all torrents because some trackers blacklist some ports
4706     reannounceToAllTrackers();
4707 }
4708
4709 void Session::handleListenFailedAlert(const lt::listen_failed_alert *p)
4710 {
4711     const QString proto {toString(p->socket_type)};
4712     LogMsg(tr("Failed to listen on IP: %1, port: %2/%3. Reason: %4"
4713               , "e.g: Failed to listen on IP: 192.168.0.1, port: TCP/6881. Reason: already in use")
4714         .arg(toString(p->address), proto, QString::number(p->port)
4715             , QString::fromLocal8Bit(p->error.message().c_str())), Log::CRITICAL);
4716 }
4717
4718 void Session::handleExternalIPAlert(const lt::external_ip_alert *p)
4719 {
4720     const QString externalIP {toString(p->external_address)};
4721     LogMsg(tr("Detected external IP: %1", "e.g. Detected external IP: 1.1.1.1")
4722         .arg(externalIP), Log::INFO);
4723
4724     if (m_lastExternalIP != externalIP)
4725     {
4726         if (isReannounceWhenAddressChangedEnabled() && !m_lastExternalIP.isEmpty())
4727             reannounceToAllTrackers();
4728         m_lastExternalIP = externalIP;
4729     }
4730 }
4731
4732 void Session::handleSessionStatsAlert(const lt::session_stats_alert *p)
4733 {
4734     const qreal interval = lt::total_milliseconds(p->timestamp() - m_statsLastTimestamp) / 1000.;
4735     m_statsLastTimestamp = p->timestamp();
4736
4737     const auto stats = p->counters();
4738
4739     m_status.hasIncomingConnections = static_cast<bool>(stats[m_metricIndices.net.hasIncomingConnections]);
4740
4741     const int64_t ipOverheadDownload = stats[m_metricIndices.net.recvIPOverheadBytes];
4742     const int64_t ipOverheadUpload = stats[m_metricIndices.net.sentIPOverheadBytes];
4743     const int64_t totalDownload = stats[m_metricIndices.net.recvBytes] + ipOverheadDownload;
4744     const int64_t totalUpload = stats[m_metricIndices.net.sentBytes] + ipOverheadUpload;
4745     const int64_t totalPayloadDownload = stats[m_metricIndices.net.recvPayloadBytes];
4746     const int64_t totalPayloadUpload = stats[m_metricIndices.net.sentPayloadBytes];
4747     const int64_t trackerDownload = stats[m_metricIndices.net.recvTrackerBytes];
4748     const int64_t trackerUpload = stats[m_metricIndices.net.sentTrackerBytes];
4749     const int64_t dhtDownload = stats[m_metricIndices.dht.dhtBytesIn];
4750     const int64_t dhtUpload = stats[m_metricIndices.dht.dhtBytesOut];
4751
4752     auto calcRate = [interval](const quint64 previous, const quint64 current)
4753     {
4754         Q_ASSERT(current >= previous);
4755         return static_cast<quint64>((current - previous) / interval);
4756     };
4757
4758     m_status.payloadDownloadRate = calcRate(m_status.totalPayloadDownload, totalPayloadDownload);
4759     m_status.payloadUploadRate = calcRate(m_status.totalPayloadUpload, totalPayloadUpload);
4760     m_status.downloadRate = calcRate(m_status.totalDownload, totalDownload);
4761     m_status.uploadRate = calcRate(m_status.totalUpload, totalUpload);
4762     m_status.ipOverheadDownloadRate = calcRate(m_status.ipOverheadDownload, ipOverheadDownload);
4763     m_status.ipOverheadUploadRate = calcRate(m_status.ipOverheadUpload, ipOverheadUpload);
4764     m_status.dhtDownloadRate = calcRate(m_status.dhtDownload, dhtDownload);
4765     m_status.dhtUploadRate = calcRate(m_status.dhtUpload, dhtUpload);
4766     m_status.trackerDownloadRate = calcRate(m_status.trackerDownload, trackerDownload);
4767     m_status.trackerUploadRate = calcRate(m_status.trackerUpload, trackerUpload);
4768
4769     m_status.totalDownload = totalDownload;
4770     m_status.totalUpload = totalUpload;
4771     m_status.totalPayloadDownload = totalPayloadDownload;
4772     m_status.totalPayloadUpload = totalPayloadUpload;
4773     m_status.ipOverheadDownload = ipOverheadDownload;
4774     m_status.ipOverheadUpload = ipOverheadUpload;
4775     m_status.trackerDownload = trackerDownload;
4776     m_status.trackerUpload = trackerUpload;
4777     m_status.dhtDownload = dhtDownload;
4778     m_status.dhtUpload = dhtUpload;
4779     m_status.totalWasted = stats[m_metricIndices.net.recvRedundantBytes]
4780             + stats[m_metricIndices.net.recvFailedBytes];
4781     m_status.dhtNodes = stats[m_metricIndices.dht.dhtNodes];
4782     m_status.diskReadQueue = stats[m_metricIndices.peer.numPeersUpDisk];
4783     m_status.diskWriteQueue = stats[m_metricIndices.peer.numPeersDownDisk];
4784     m_status.peersCount = stats[m_metricIndices.peer.numPeersConnected];
4785
4786     m_cacheStatus.totalUsedBuffers = stats[m_metricIndices.disk.diskBlocksInUse];
4787     m_cacheStatus.jobQueueLength = stats[m_metricIndices.disk.queuedDiskJobs];
4788
4789 #if (LIBTORRENT_VERSION_NUM < 20000)
4790     const int64_t numBlocksRead = stats[m_metricIndices.disk.numBlocksRead];
4791     const int64_t numBlocksCacheHits = stats[m_metricIndices.disk.numBlocksCacheHits];
4792     m_cacheStatus.readRatio = static_cast<qreal>(numBlocksCacheHits) / std::max<int64_t>((numBlocksCacheHits + numBlocksRead), 1);
4793 #endif
4794
4795     const int64_t totalJobs = stats[m_metricIndices.disk.writeJobs] + stats[m_metricIndices.disk.readJobs]
4796                   + stats[m_metricIndices.disk.hashJobs];
4797     m_cacheStatus.averageJobTime = (totalJobs > 0)
4798                                    ? (stats[m_metricIndices.disk.diskJobTime] / totalJobs) : 0;
4799
4800     emit statsUpdated();
4801
4802     if (m_refreshEnqueued)
4803         m_refreshEnqueued = false;
4804     else
4805         enqueueRefresh();
4806 }
4807
4808 void Session::handleAlertsDroppedAlert(const lt::alerts_dropped_alert *p) const
4809 {
4810     LogMsg(tr("Error: Internal alert queue full and alerts were dropped, you might see degraded performance. Dropped alert types: %1. Message: %2")
4811         .arg(QString::fromStdString(p->dropped_alerts.to_string()), QString::fromStdString(p->message())), Log::CRITICAL);
4812 }
4813
4814 void Session::handleStorageMovedAlert(const lt::storage_moved_alert *p)
4815 {
4816     Q_ASSERT(!m_moveStorageQueue.isEmpty());
4817
4818     const MoveStorageJob &currentJob = m_moveStorageQueue.first();
4819     Q_ASSERT(currentJob.torrentHandle == p->handle);
4820
4821     const QString newPath {p->storage_path()};
4822     Q_ASSERT(newPath == currentJob.path);
4823
4824 #if (LIBTORRENT_VERSION_NUM >= 20000)
4825     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hashes());
4826 #else
4827     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hash());
4828 #endif
4829
4830     TorrentImpl *torrent = m_torrents.value(id);
4831     const QString torrentName = (torrent ? torrent->name() : id.toString());
4832     LogMsg(tr("\"%1\" is successfully moved to \"%2\".").arg(torrentName, newPath));
4833
4834     handleMoveTorrentStorageJobFinished();
4835 }
4836
4837 void Session::handleStorageMovedFailedAlert(const lt::storage_moved_failed_alert *p)
4838 {
4839     Q_ASSERT(!m_moveStorageQueue.isEmpty());
4840
4841     const MoveStorageJob &currentJob = m_moveStorageQueue.first();
4842     Q_ASSERT(currentJob.torrentHandle == p->handle);
4843
4844 #if (LIBTORRENT_VERSION_NUM >= 20000)
4845     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hashes());
4846 #else
4847     const auto id = TorrentID::fromInfoHash(currentJob.torrentHandle.info_hash());
4848 #endif
4849
4850     TorrentImpl *torrent = m_torrents.value(id);
4851     const QString torrentName = (torrent ? torrent->name() : id.toString());
4852     const QString currentLocation = QString::fromStdString(p->handle.status(lt::torrent_handle::query_save_path).save_path);
4853     const QString errorMessage = QString::fromStdString(p->message());
4854     LogMsg(tr("Failed to move \"%1\" from \"%2\" to \"%3\". Reason: %4.")
4855            .arg(torrentName, currentLocation, currentJob.path, errorMessage), Log::CRITICAL);
4856
4857     handleMoveTorrentStorageJobFinished();
4858 }
4859
4860 void Session::handleStateUpdateAlert(const lt::state_update_alert *p)
4861 {
4862     QVector<Torrent *> updatedTorrents;
4863     updatedTorrents.reserve(static_cast<decltype(updatedTorrents)::size_type>(p->status.size()));
4864
4865     for (const lt::torrent_status &status : p->status)
4866     {
4867 #if (LIBTORRENT_VERSION_NUM >= 20000)
4868         const auto id = TorrentID::fromInfoHash(status.info_hashes);
4869 #else
4870         const auto id = TorrentID::fromInfoHash(status.info_hash);
4871 #endif
4872         TorrentImpl *const torrent = m_torrents.value(id);
4873         if (!torrent)
4874             continue;
4875
4876         torrent->handleStateUpdate(status);
4877         updatedTorrents.push_back(torrent);
4878     }
4879
4880     if (!updatedTorrents.isEmpty())
4881         emit torrentsUpdated(updatedTorrents);
4882
4883     if (m_refreshEnqueued)
4884         m_refreshEnqueued = false;
4885     else
4886         enqueueRefresh();
4887 }
4888
4889 void Session::handleSocks5Alert(const lt::socks5_alert *p) const
4890 {
4891     if (p->error)
4892     {
4893         LogMsg(tr("SOCKS5 proxy error. Message: %1").arg(QString::fromStdString(p->message()))
4894             , Log::WARNING);
4895     }
4896 }