src/base/bittorrent/torrentimpl.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015-2023  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2006  Christophe Dumez <chris@qbittorrent.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "torrentimpl.h"
  31
  32 #include <algorithm>
  33 #include <memory>
  34
  35 #ifdef Q_OS_WIN
  36 #include <windows.h>
  37 #endif
  38
  39 #include <libtorrent/address.hpp>
  40 #include <libtorrent/alert_types.hpp>
  41 #include <libtorrent/create_torrent.hpp>
  42 #include <libtorrent/session.hpp>
  43 #include <libtorrent/storage_defs.hpp>
  44 #include <libtorrent/time.hpp>
  45
  46 #ifdef QBT_USES_LIBTORRENT2
  47 #include <libtorrent/info_hash.hpp>
  48 #endif
  49
  50 #include <QtSystemDetection>
  51 #include <QByteArray>
  52 #include <QDebug>
  53 #include <QPointer>
  54 #include <QSet>
  55 #include <QStringList>
  56 #include <QUrl>
  57
  58 #include "base/exceptions.h"
  59 #include "base/global.h"
  60 #include "base/logger.h"
  61 #include "base/preferences.h"
  62 #include "base/types.h"
  63 #include "base/utils/fs.h"
  64 #include "base/utils/io.h"
  65 #include "common.h"
  66 #include "downloadpriority.h"
  67 #include "extensiondata.h"
  68 #include "loadtorrentparams.h"
  69 #include "ltqbitarray.h"
  70 #include "lttypecast.h"
  71 #include "peeraddress.h"
  72 #include "peerinfo.h"
  73 #include "sessionimpl.h"
  74
  75 #if defined(Q_OS_MACOS) || defined(Q_OS_WIN)
  76 #include "base/utils/os.h"
  77 #endif // Q_OS_MACOS || Q_OS_WIN
  78
  79 using namespace BitTorrent;
  80
  81 namespace
  82 {
  83     lt::announce_entry makeNativeAnnounceEntry(const QString &url, const int tier)
  84     {
  85         lt::announce_entry entry {url.toStdString()};
  86         entry.tier = tier;
  87         return entry;
  88     }
  89
  90     QDateTime fromLTTimePoint32(const lt::time_point32 &timePoint)
  91     {
  92         const auto ltNow = lt::clock_type::now();
  93         const auto qNow = QDateTime::currentDateTime();
  94         const auto secsSinceNow = lt::duration_cast<lt::seconds>(timePoint - ltNow + lt::milliseconds(500)).count();
  95
  96         return qNow.addSecs(secsSinceNow);
  97     }
  98
  99     QString toString(const lt::tcp::endpoint &ltTCPEndpoint)
 100     {
 101         return QString::fromStdString((std::stringstream() << ltTCPEndpoint).str());
 102     }
 103
 104     void updateTrackerEntry(TrackerEntry &trackerEntry, const lt::announce_entry &nativeEntry
 105             , const QSet<int> &btProtocols, const QHash<lt::tcp::endpoint, QMap<int, int>> &updateInfo)
 106     {
 107         Q_ASSERT(trackerEntry.url == QString::fromStdString(nativeEntry.url));
 108
 109         trackerEntry.tier = nativeEntry.tier;
 110
 111         // remove outdated endpoints
 112         trackerEntry.endpointEntries.removeIf([&nativeEntry](const QHash<std::pair<QString, int>, TrackerEndpointEntry>::iterator &iter)
 113         {
 114             return std::none_of(nativeEntry.endpoints.cbegin(), nativeEntry.endpoints.cend()
 115                     , [&endpointName = std::get<0>(iter.key())](const auto &existingEndpoint)
 116             {
 117                 return (endpointName == toString(existingEndpoint.local_endpoint));
 118             });
 119         });
 120
 121         const auto numEndpoints = static_cast<qsizetype>(nativeEntry.endpoints.size()) * btProtocols.size();
 122
 123         int numUpdating = 0;
 124         int numWorking = 0;
 125         int numNotWorking = 0;
 126         int numTrackerError = 0;
 127         int numUnreachable = 0;
 128
 129         for (const lt::announce_endpoint &ltAnnounceEndpoint : nativeEntry.endpoints)
 130         {
 131             const auto endpointName = toString(ltAnnounceEndpoint.local_endpoint);
 132
 133             for (const auto protocolVersion : btProtocols)
 134             {
 135 #ifdef QBT_USES_LIBTORRENT2
 136                 Q_ASSERT((protocolVersion == 1) || (protocolVersion == 2));
 137                 const auto ltProtocolVersion = (protocolVersion == 1) ? lt::protocol_version::V1 : lt::protocol_version::V2;
 138                 const lt::announce_infohash &ltAnnounceInfo = ltAnnounceEndpoint.info_hashes[ltProtocolVersion];
 139 #else
 140                 Q_ASSERT(protocolVersion == 1);
 141                 const lt::announce_endpoint &ltAnnounceInfo = ltAnnounceEndpoint;
 142 #endif
 143                 const QMap<int, int> &endpointUpdateInfo = updateInfo[ltAnnounceEndpoint.local_endpoint];
 144                 TrackerEndpointEntry &trackerEndpointEntry = trackerEntry.endpointEntries[std::make_pair(endpointName, protocolVersion)];
 145
 146                 trackerEndpointEntry.name = endpointName;
 147                 trackerEndpointEntry.btVersion = protocolVersion;
 148                 trackerEndpointEntry.numPeers = endpointUpdateInfo.value(protocolVersion, trackerEndpointEntry.numPeers);
 149                 trackerEndpointEntry.numSeeds = ltAnnounceInfo.scrape_complete;
 150                 trackerEndpointEntry.numLeeches = ltAnnounceInfo.scrape_incomplete;
 151                 trackerEndpointEntry.numDownloaded = ltAnnounceInfo.scrape_downloaded;
 152                 trackerEndpointEntry.nextAnnounceTime = fromLTTimePoint32(ltAnnounceInfo.next_announce);
 153                 trackerEndpointEntry.minAnnounceTime = fromLTTimePoint32(ltAnnounceInfo.min_announce);
 154
 155                 if (ltAnnounceInfo.updating)
 156                 {
 157                     trackerEndpointEntry.status = TrackerEntryStatus::Updating;
 158                     ++numUpdating;
 159                 }
 160                 else if (ltAnnounceInfo.fails > 0)
 161                 {
 162                     if (ltAnnounceInfo.last_error == lt::errors::tracker_failure)
 163                     {
 164                         trackerEndpointEntry.status = TrackerEntryStatus::TrackerError;
 165                         ++numTrackerError;
 166                     }
 167                     else if (ltAnnounceInfo.last_error == lt::errors::announce_skipped)
 168                     {
 169                         trackerEndpointEntry.status = TrackerEntryStatus::Unreachable;
 170                         ++numUnreachable;
 171                     }
 172                     else
 173                     {
 174                         trackerEndpointEntry.status = TrackerEntryStatus::NotWorking;
 175                         ++numNotWorking;
 176                     }
 177                 }
 178                 else if (nativeEntry.verified)
 179                 {
 180                     trackerEndpointEntry.status = TrackerEntryStatus::Working;
 181                     ++numWorking;
 182                 }
 183                 else
 184                 {
 185                     trackerEndpointEntry.status = TrackerEntryStatus::NotContacted;
 186                 }
 187
 188                 if (!ltAnnounceInfo.message.empty())
 189                 {
 190                     trackerEndpointEntry.message = QString::fromStdString(ltAnnounceInfo.message);
 191                 }
 192                 else if (ltAnnounceInfo.last_error)
 193                 {
 194                     trackerEndpointEntry.message = QString::fromLocal8Bit(ltAnnounceInfo.last_error.message());
 195                 }
 196                 else
 197                 {
 198                     trackerEndpointEntry.message.clear();
 199                 }
 200             }
 201         }
 202
 203         if (numEndpoints > 0)
 204         {
 205             if (numUpdating > 0)
 206             {
 207                 trackerEntry.status = TrackerEntryStatus::Updating;
 208             }
 209             else if (numWorking > 0)
 210             {
 211                 trackerEntry.status = TrackerEntryStatus::Working;
 212             }
 213             else if (numTrackerError > 0)
 214             {
 215                 trackerEntry.status = TrackerEntryStatus::TrackerError;
 216             }
 217             else if (numUnreachable == numEndpoints)
 218             {
 219                 trackerEntry.status = TrackerEntryStatus::Unreachable;
 220             }
 221             else if ((numUnreachable + numNotWorking) == numEndpoints)
 222             {
 223                 trackerEntry.status = TrackerEntryStatus::NotWorking;
 224             }
 225         }
 226
 227         trackerEntry.numPeers = -1;
 228         trackerEntry.numSeeds = -1;
 229         trackerEntry.numLeeches = -1;
 230         trackerEntry.numDownloaded = -1;
 231         trackerEntry.nextAnnounceTime = QDateTime();
 232         trackerEntry.minAnnounceTime = QDateTime();
 233         trackerEntry.message.clear();
 234
 235         for (const TrackerEndpointEntry &endpointEntry : asConst(trackerEntry.endpointEntries))
 236         {
 237             trackerEntry.numPeers = std::max(trackerEntry.numPeers, endpointEntry.numPeers);
 238             trackerEntry.numSeeds = std::max(trackerEntry.numSeeds, endpointEntry.numSeeds);
 239             trackerEntry.numLeeches = std::max(trackerEntry.numLeeches, endpointEntry.numLeeches);
 240             trackerEntry.numDownloaded = std::max(trackerEntry.numDownloaded, endpointEntry.numDownloaded);
 241
 242             if (endpointEntry.status == trackerEntry.status)
 243             {
 244                 if (!trackerEntry.nextAnnounceTime.isValid() || (trackerEntry.nextAnnounceTime > endpointEntry.nextAnnounceTime))
 245                 {
 246                     trackerEntry.nextAnnounceTime = endpointEntry.nextAnnounceTime;
 247                     trackerEntry.minAnnounceTime = endpointEntry.minAnnounceTime;
 248                     if ((endpointEntry.status != TrackerEntryStatus::Working)
 249                             || !endpointEntry.message.isEmpty())
 250                     {
 251                         trackerEntry.message = endpointEntry.message;
 252                     }
 253                 }
 254
 255                 if (endpointEntry.status == TrackerEntryStatus::Working)
 256                 {
 257                     if (trackerEntry.message.isEmpty())
 258                         trackerEntry.message = endpointEntry.message;
 259                 }
 260             }
 261         }
 262     }
 263
 264     template <typename Vector>
 265     Vector resized(const Vector &inVector, const typename Vector::size_type size, const typename Vector::value_type &defaultValue)
 266     {
 267         Vector outVector = inVector;
 268         outVector.resize(size, defaultValue);
 269         return outVector;
 270     }
 271
 272     // This is an imitation of limit normalization performed by libtorrent itself.
 273     // We need perform it to keep cached values in line with the ones used by libtorrent.
 274     int cleanLimitValue(const int value)
 275     {
 276         return ((value < 0) || (value == std::numeric_limits<int>::max())) ? 0 : value;
 277     }
 278 }
 279
 280 // TorrentImpl
 281
 282 TorrentImpl::TorrentImpl(SessionImpl *session, lt::session *nativeSession
 283                                      , const lt::torrent_handle &nativeHandle, const LoadTorrentParams &params)
 284     : Torrent(session)
 285     , m_session(session)
 286     , m_nativeSession(nativeSession)
 287     , m_nativeHandle(nativeHandle)
 288 #ifdef QBT_USES_LIBTORRENT2
 289     , m_infoHash(m_nativeHandle.info_hashes())
 290 #else
 291     , m_infoHash(m_nativeHandle.info_hash())
 292 #endif
 293     , m_name(params.name)
 294     , m_savePath(params.savePath)
 295     , m_downloadPath(params.downloadPath)
 296     , m_category(params.category)
 297     , m_tags(params.tags)
 298     , m_ratioLimit(params.ratioLimit)
 299     , m_seedingTimeLimit(params.seedingTimeLimit)
 300     , m_inactiveSeedingTimeLimit(params.inactiveSeedingTimeLimit)
 301     , m_operatingMode(params.operatingMode)
 302     , m_contentLayout(params.contentLayout)
 303     , m_hasFinishedStatus(params.hasFinishedStatus)
 304     , m_hasFirstLastPiecePriority(params.firstLastPiecePriority)
 305     , m_useAutoTMM(params.useAutoTMM)
 306     , m_isStopped(params.stopped)
 307     , m_ltAddTorrentParams(params.ltAddTorrentParams)
 308     , m_downloadLimit(cleanLimitValue(m_ltAddTorrentParams.download_limit))
 309     , m_uploadLimit(cleanLimitValue(m_ltAddTorrentParams.upload_limit))
 310 {
 311     if (m_ltAddTorrentParams.ti)
 312     {
 313         // Initialize it only if torrent is added with metadata.
 314         // Otherwise it should be initialized in "Metadata received" handler.
 315         m_torrentInfo = TorrentInfo(*m_ltAddTorrentParams.ti);
 316
 317         Q_ASSERT(m_filePaths.isEmpty());
 318         Q_ASSERT(m_indexMap.isEmpty());
 319         const int filesCount = m_torrentInfo.filesCount();
 320         m_filePaths.reserve(filesCount);
 321         m_indexMap.reserve(filesCount);
 322         m_filePriorities.reserve(filesCount);
 323         const std::vector<lt::download_priority_t> filePriorities =
 324                 resized(m_ltAddTorrentParams.file_priorities, m_ltAddTorrentParams.ti->num_files()
 325                         , LT::toNative(m_ltAddTorrentParams.file_priorities.empty() ? DownloadPriority::Normal : DownloadPriority::Ignored));
 326
 327         m_completedFiles.fill(static_cast<bool>(m_ltAddTorrentParams.flags & lt::torrent_flags::seed_mode), filesCount);
 328         m_filesProgress.resize(filesCount);
 329
 330         for (int i = 0; i < filesCount; ++i)
 331         {
 332             const lt::file_index_t nativeIndex = m_torrentInfo.nativeIndexes().at(i);
 333             m_indexMap[nativeIndex] = i;
 334
 335             const auto fileIter = m_ltAddTorrentParams.renamed_files.find(nativeIndex);
 336             const Path filePath = ((fileIter != m_ltAddTorrentParams.renamed_files.end())
 337                     ? makeUserPath(Path(fileIter->second)) : m_torrentInfo.filePath(i));
 338             m_filePaths.append(filePath);
 339
 340             const auto priority = LT::fromNative(filePriorities[LT::toUnderlyingType(nativeIndex)]);
 341             m_filePriorities.append(priority);
 342         }
 343     }
 344
 345     setStopCondition(params.stopCondition);
 346
 347     const auto *extensionData = static_cast<ExtensionData *>(m_ltAddTorrentParams.userdata);
 348     m_trackerEntries.reserve(static_cast<decltype(m_trackerEntries)::size_type>(extensionData->trackers.size()));
 349     for (const lt::announce_entry &announceEntry : extensionData->trackers)
 350         m_trackerEntries.append({QString::fromStdString(announceEntry.url), announceEntry.tier});
 351     m_urlSeeds.reserve(static_cast<decltype(m_urlSeeds)::size_type>(extensionData->urlSeeds.size()));
 352     for (const std::string &urlSeed : extensionData->urlSeeds)
 353         m_urlSeeds.append(QString::fromStdString(urlSeed));
 354     m_nativeStatus = extensionData->status;
 355
 356     if (hasMetadata())
 357         updateProgress();
 358
 359     updateState();
 360
 361     if (hasMetadata())
 362         applyFirstLastPiecePriority(m_hasFirstLastPiecePriority);
 363 }
 364
 365 TorrentImpl::~TorrentImpl() = default;
 366
 367 bool TorrentImpl::isValid() const
 368 {
 369     return m_nativeHandle.is_valid();
 370 }
 371
 372 Session *TorrentImpl::session() const
 373 {
 374     return m_session;
 375 }
 376
 377 InfoHash TorrentImpl::infoHash() const
 378 {
 379     return m_infoHash;
 380 }
 381
 382 QString TorrentImpl::name() const
 383 {
 384     if (!m_name.isEmpty())
 385         return m_name;
 386
 387     if (hasMetadata())
 388         return m_torrentInfo.name();
 389
 390     const QString name = QString::fromStdString(m_nativeStatus.name);
 391     if (!name.isEmpty())
 392         return name;
 393
 394     return id().toString();
 395 }
 396
 397 QDateTime TorrentImpl::creationDate() const
 398 {
 399     return m_torrentInfo.creationDate();
 400 }
 401
 402 QString TorrentImpl::creator() const
 403 {
 404     return m_torrentInfo.creator();
 405 }
 406
 407 QString TorrentImpl::comment() const
 408 {
 409     return m_torrentInfo.comment();
 410 }
 411
 412 bool TorrentImpl::isPrivate() const
 413 {
 414     return m_torrentInfo.isPrivate();
 415 }
 416
 417 qlonglong TorrentImpl::totalSize() const
 418 {
 419     return m_torrentInfo.totalSize();
 420 }
 421
 422 // size without the "don't download" files
 423 qlonglong TorrentImpl::wantedSize() const
 424 {
 425     return m_nativeStatus.total_wanted;
 426 }
 427
 428 qlonglong TorrentImpl::completedSize() const
 429 {
 430     return m_nativeStatus.total_wanted_done;
 431 }
 432
 433 qlonglong TorrentImpl::pieceLength() const
 434 {
 435     return m_torrentInfo.pieceLength();
 436 }
 437
 438 qlonglong TorrentImpl::wastedSize() const
 439 {
 440     return (m_nativeStatus.total_failed_bytes + m_nativeStatus.total_redundant_bytes);
 441 }
 442
 443 QString TorrentImpl::currentTracker() const
 444 {
 445     return QString::fromStdString(m_nativeStatus.current_tracker);
 446 }
 447
 448 Path TorrentImpl::savePath() const
 449 {
 450     return isAutoTMMEnabled() ? m_session->categorySavePath(category()) : m_savePath;
 451 }
 452
 453 void TorrentImpl::setSavePath(const Path &path)
 454 {
 455     Q_ASSERT(!isAutoTMMEnabled());
 456
 457     const Path basePath = m_session->useCategoryPathsInManualMode()
 458             ? m_session->categorySavePath(category()) : m_session->savePath();
 459     const Path resolvedPath = (path.isAbsolute() ? path : (basePath / path));
 460     if (resolvedPath == savePath())
 461         return;
 462
 463     if (isFinished() || m_hasFinishedStatus || downloadPath().isEmpty())
 464     {
 465         moveStorage(resolvedPath, MoveStorageContext::ChangeSavePath);
 466     }
 467     else
 468     {
 469         m_savePath = resolvedPath;
 470         m_session->handleTorrentSavePathChanged(this);
 471         m_session->handleTorrentNeedSaveResumeData(this);
 472     }
 473 }
 474
 475 Path TorrentImpl::downloadPath() const
 476 {
 477     return isAutoTMMEnabled() ? m_session->categoryDownloadPath(category()) : m_downloadPath;
 478 }
 479
 480 void TorrentImpl::setDownloadPath(const Path &path)
 481 {
 482     Q_ASSERT(!isAutoTMMEnabled());
 483
 484     const Path basePath = m_session->useCategoryPathsInManualMode()
 485             ? m_session->categoryDownloadPath(category()) : m_session->downloadPath();
 486     const Path resolvedPath = (path.isEmpty() || path.isAbsolute()) ? path : (basePath / path);
 487     if (resolvedPath == m_downloadPath)
 488         return;
 489
 490     const bool isIncomplete = !(isFinished() || m_hasFinishedStatus);
 491     if (isIncomplete)
 492     {
 493         moveStorage((resolvedPath.isEmpty() ? savePath() : resolvedPath), MoveStorageContext::ChangeDownloadPath);
 494     }
 495     else
 496     {
 497         m_downloadPath = resolvedPath;
 498         m_session->handleTorrentSavePathChanged(this);
 499         m_session->handleTorrentNeedSaveResumeData(this);
 500     }
 501 }
 502
 503 Path TorrentImpl::rootPath() const
 504 {
 505     if (!hasMetadata())
 506         return {};
 507
 508     const Path relativeRootPath = Path::findRootFolder(filePaths());
 509     if (relativeRootPath.isEmpty())
 510         return {};
 511
 512     return (actualStorageLocation() / relativeRootPath);
 513 }
 514
 515 Path TorrentImpl::contentPath() const
 516 {
 517     if (!hasMetadata())
 518         return {};
 519
 520     if (filesCount() == 1)
 521         return (actualStorageLocation() / filePath(0));
 522
 523     const Path rootPath = this->rootPath();
 524     return (rootPath.isEmpty() ? actualStorageLocation() : rootPath);
 525 }
 526
 527 bool TorrentImpl::isAutoTMMEnabled() const
 528 {
 529     return m_useAutoTMM;
 530 }
 531
 532 void TorrentImpl::setAutoTMMEnabled(bool enabled)
 533 {
 534     if (m_useAutoTMM == enabled)
 535         return;
 536
 537     m_useAutoTMM = enabled;
 538     if (!m_useAutoTMM)
 539     {
 540         m_savePath = m_session->categorySavePath(category());
 541         m_downloadPath = m_session->categoryDownloadPath(category());
 542     }
 543
 544     m_session->handleTorrentNeedSaveResumeData(this);
 545     m_session->handleTorrentSavingModeChanged(this);
 546
 547     adjustStorageLocation();
 548 }
 549
 550 Path TorrentImpl::actualStorageLocation() const
 551 {
 552     if (!hasMetadata())
 553         return {};
 554
 555     return Path(m_nativeStatus.save_path);
 556 }
 557
 558 void TorrentImpl::setAutoManaged(const bool enable)
 559 {
 560     if (enable)
 561         m_nativeHandle.set_flags(lt::torrent_flags::auto_managed);
 562     else
 563         m_nativeHandle.unset_flags(lt::torrent_flags::auto_managed);
 564 }
 565
 566 Path TorrentImpl::makeActualPath(int index, const Path &path) const
 567 {
 568     Path actualPath = path;
 569
 570     if (m_session->isAppendExtensionEnabled()
 571             && (fileSize(index) > 0) && !m_completedFiles.at(index))
 572     {
 573         actualPath += QB_EXT;
 574     }
 575
 576     if (m_session->isUnwantedFolderEnabled()
 577             && (m_filePriorities[index] == DownloadPriority::Ignored))
 578     {
 579         const Path parentPath = actualPath.parentPath();
 580         const QString fileName = actualPath.filename();
 581         actualPath = parentPath / Path(UNWANTED_FOLDER_NAME) / Path(fileName);
 582     }
 583
 584     return actualPath;
 585 }
 586
 587 Path TorrentImpl::makeUserPath(const Path &path) const
 588 {
 589     Path userPath = path.removedExtension(QB_EXT);
 590
 591     const Path parentRelPath = userPath.parentPath();
 592     if (parentRelPath.filename() == UNWANTED_FOLDER_NAME)
 593     {
 594         const QString fileName = userPath.filename();
 595         const Path relPath = parentRelPath.parentPath();
 596         userPath = relPath / Path(fileName);
 597     }
 598
 599     return userPath;
 600 }
 601
 602 QVector<TrackerEntry> TorrentImpl::trackers() const
 603 {
 604     return m_trackerEntries;
 605 }
 606
 607 void TorrentImpl::addTrackers(QVector<TrackerEntry> trackers)
 608 {
 609     trackers.removeIf([](const TrackerEntry &entry) { return entry.url.isEmpty(); });
 610
 611     const auto newTrackers = QSet<TrackerEntry>(trackers.cbegin(), trackers.cend())
 612             - QSet<TrackerEntry>(m_trackerEntries.cbegin(), m_trackerEntries.cend());
 613     if (newTrackers.isEmpty())
 614         return;
 615
 616     trackers = QVector<TrackerEntry>(newTrackers.cbegin(), newTrackers.cend());
 617     for (const TrackerEntry &tracker : trackers)
 618         m_nativeHandle.add_tracker(makeNativeAnnounceEntry(tracker.url, tracker.tier));
 619
 620     m_trackerEntries.append(trackers);
 621     std::sort(m_trackerEntries.begin(), m_trackerEntries.end()
 622         , [](const TrackerEntry &lhs, const TrackerEntry &rhs) { return lhs.tier < rhs.tier; });
 623
 624     m_session->handleTorrentNeedSaveResumeData(this);
 625     m_session->handleTorrentTrackersAdded(this, trackers);
 626 }
 627
 628 void TorrentImpl::removeTrackers(const QStringList &trackers)
 629 {
 630     QStringList removedTrackers = trackers;
 631     for (const QString &tracker : trackers)
 632     {
 633         if (!m_trackerEntries.removeOne({tracker}))
 634             removedTrackers.removeOne(tracker);
 635     }
 636
 637     std::vector<lt::announce_entry> nativeTrackers;
 638     nativeTrackers.reserve(m_trackerEntries.size());
 639     for (const TrackerEntry &tracker : asConst(m_trackerEntries))
 640         nativeTrackers.emplace_back(makeNativeAnnounceEntry(tracker.url, tracker.tier));
 641
 642     if (!removedTrackers.isEmpty())
 643     {
 644         m_nativeHandle.replace_trackers(nativeTrackers);
 645
 646         m_session->handleTorrentNeedSaveResumeData(this);
 647         m_session->handleTorrentTrackersRemoved(this, removedTrackers);
 648     }
 649 }
 650
 651 void TorrentImpl::replaceTrackers(QVector<TrackerEntry> trackers)
 652 {
 653     trackers.removeIf([](const TrackerEntry &entry) { return entry.url.isEmpty(); });
 654     // Filter out duplicate trackers
 655     const auto uniqueTrackers = QSet<TrackerEntry>(trackers.cbegin(), trackers.cend());
 656     trackers = QVector<TrackerEntry>(uniqueTrackers.cbegin(), uniqueTrackers.cend());
 657     std::sort(trackers.begin(), trackers.end()
 658         , [](const TrackerEntry &lhs, const TrackerEntry &rhs) { return lhs.tier < rhs.tier; });
 659
 660     std::vector<lt::announce_entry> nativeTrackers;
 661     nativeTrackers.reserve(trackers.size());
 662     for (const TrackerEntry &tracker : trackers)
 663         nativeTrackers.emplace_back(makeNativeAnnounceEntry(tracker.url, tracker.tier));
 664
 665     m_nativeHandle.replace_trackers(nativeTrackers);
 666     m_trackerEntries = trackers;
 667
 668     // Clear the peer list if it's a private torrent since
 669     // we do not want to keep connecting with peers from old tracker.
 670     if (isPrivate())
 671         clearPeers();
 672
 673     m_session->handleTorrentNeedSaveResumeData(this);
 674     m_session->handleTorrentTrackersChanged(this);
 675 }
 676
 677 QVector<QUrl> TorrentImpl::urlSeeds() const
 678 {
 679     return m_urlSeeds;
 680 }
 681
 682 void TorrentImpl::addUrlSeeds(const QVector<QUrl> &urlSeeds)
 683 {
 684     m_session->invokeAsync([urlSeeds, session = m_session
 685                            , nativeHandle = m_nativeHandle
 686                            , thisTorrent = QPointer<TorrentImpl>(this)]
 687     {
 688         try
 689         {
 690             const std::set<std::string> nativeSeeds = nativeHandle.url_seeds();
 691             QVector<QUrl> currentSeeds;
 692             currentSeeds.reserve(static_cast<decltype(currentSeeds)::size_type>(nativeSeeds.size()));
 693             for (const std::string &urlSeed : nativeSeeds)
 694                 currentSeeds.append(QString::fromStdString(urlSeed));
 695
 696             QVector<QUrl> addedUrlSeeds;
 697             addedUrlSeeds.reserve(urlSeeds.size());
 698
 699             for (const QUrl &url : urlSeeds)
 700             {
 701                 if (!currentSeeds.contains(url))
 702                 {
 703                     nativeHandle.add_url_seed(url.toString().toStdString());
 704                     addedUrlSeeds.append(url);
 705                 }
 706             }
 707
 708             currentSeeds.append(addedUrlSeeds);
 709             session->invoke([session, thisTorrent, currentSeeds, addedUrlSeeds]
 710             {
 711                 if (!thisTorrent)
 712                     return;
 713
 714                 thisTorrent->m_urlSeeds = currentSeeds;
 715                 if (!addedUrlSeeds.isEmpty())
 716                 {
 717                     session->handleTorrentNeedSaveResumeData(thisTorrent);
 718                     session->handleTorrentUrlSeedsAdded(thisTorrent, addedUrlSeeds);
 719                 }
 720             });
 721         }
 722         catch (const std::exception &) {}
 723     });
 724 }
 725
 726 void TorrentImpl::removeUrlSeeds(const QVector<QUrl> &urlSeeds)
 727 {
 728     m_session->invokeAsync([urlSeeds, session = m_session
 729                            , nativeHandle = m_nativeHandle
 730                            , thisTorrent = QPointer<TorrentImpl>(this)]
 731     {
 732         try
 733         {
 734             const std::set<std::string> nativeSeeds = nativeHandle.url_seeds();
 735             QVector<QUrl> currentSeeds;
 736             currentSeeds.reserve(static_cast<decltype(currentSeeds)::size_type>(nativeSeeds.size()));
 737             for (const std::string &urlSeed : nativeSeeds)
 738                 currentSeeds.append(QString::fromStdString(urlSeed));
 739
 740             QVector<QUrl> removedUrlSeeds;
 741             removedUrlSeeds.reserve(urlSeeds.size());
 742
 743             for (const QUrl &url : urlSeeds)
 744             {
 745                 if (currentSeeds.removeOne(url))
 746                 {
 747                     nativeHandle.remove_url_seed(url.toString().toStdString());
 748                     removedUrlSeeds.append(url);
 749                 }
 750             }
 751
 752             session->invoke([session, thisTorrent, currentSeeds, removedUrlSeeds]
 753             {
 754                 if (!thisTorrent)
 755                     return;
 756
 757                 thisTorrent->m_urlSeeds = currentSeeds;
 758
 759                 if (!removedUrlSeeds.isEmpty())
 760                 {
 761                     session->handleTorrentNeedSaveResumeData(thisTorrent);
 762                     session->handleTorrentUrlSeedsRemoved(thisTorrent, removedUrlSeeds);
 763                 }
 764             });
 765         }
 766         catch (const std::exception &) {}
 767     });
 768 }
 769
 770 void TorrentImpl::clearPeers()
 771 {
 772     m_nativeHandle.clear_peers();
 773 }
 774
 775 bool TorrentImpl::connectPeer(const PeerAddress &peerAddress)
 776 {
 777     lt::error_code ec;
 778     const lt::address addr = lt::make_address(peerAddress.ip.toString().toStdString(), ec);
 779     if (ec) return false;
 780
 781     const lt::tcp::endpoint endpoint(addr, peerAddress.port);
 782     try
 783     {
 784         m_nativeHandle.connect_peer(endpoint);
 785     }
 786     catch (const lt::system_error &err)
 787     {
 788         LogMsg(tr("Failed to add peer \"%1\" to torrent \"%2\". Reason: %3")
 789             .arg(peerAddress.toString(), name(), QString::fromLocal8Bit(err.what())), Log::WARNING);
 790         return false;
 791     }
 792
 793     LogMsg(tr("Peer \"%1\" is added to torrent \"%2\"").arg(peerAddress.toString(), name()));
 794     return true;
 795 }
 796
 797 bool TorrentImpl::needSaveResumeData() const
 798 {
 799     return m_nativeStatus.need_save_resume;
 800 }
 801
 802 void TorrentImpl::saveResumeData(lt::resume_data_flags_t flags)
 803 {
 804     m_nativeHandle.save_resume_data(flags);
 805     m_session->handleTorrentSaveResumeDataRequested(this);
 806 }
 807
 808 int TorrentImpl::filesCount() const
 809 {
 810     return m_torrentInfo.filesCount();
 811 }
 812
 813 int TorrentImpl::piecesCount() const
 814 {
 815     return m_torrentInfo.piecesCount();
 816 }
 817
 818 int TorrentImpl::piecesHave() const
 819 {
 820     return m_nativeStatus.num_pieces;
 821 }
 822
 823 qreal TorrentImpl::progress() const
 824 {
 825     if (isChecking())
 826         return m_nativeStatus.progress;
 827
 828     if (m_nativeStatus.total_wanted == 0)
 829         return 0.;
 830
 831     if (m_nativeStatus.total_wanted_done == m_nativeStatus.total_wanted)
 832         return 1.;
 833
 834     const qreal progress = static_cast<qreal>(m_nativeStatus.total_wanted_done) / m_nativeStatus.total_wanted;
 835     if ((progress < 0.f) || (progress > 1.f))
 836     {
 837         LogMsg(tr("Unexpected data detected. Torrent: %1. Data: total_wanted=%2 total_wanted_done=%3.")
 838                 .arg(name(), QString::number(m_nativeStatus.total_wanted), QString::number(m_nativeStatus.total_wanted_done))
 839                 , Log::WARNING);
 840     }
 841
 842     return progress;
 843 }
 844
 845 QString TorrentImpl::category() const
 846 {
 847     return m_category;
 848 }
 849
 850 bool TorrentImpl::belongsToCategory(const QString &category) const
 851 {
 852     if (m_category.isEmpty())
 853         return category.isEmpty();
 854
 855     if (m_category == category)
 856         return true;
 857
 858     return (m_session->isSubcategoriesEnabled() && m_category.startsWith(category + u'/'));
 859 }
 860
 861 TagSet TorrentImpl::tags() const
 862 {
 863     return m_tags;
 864 }
 865
 866 bool TorrentImpl::hasTag(const Tag &tag) const
 867 {
 868     return m_tags.contains(tag);
 869 }
 870
 871 bool TorrentImpl::addTag(const Tag &tag)
 872 {
 873     if (!tag.isValid())
 874         return false;
 875     if (hasTag(tag))
 876         return false;
 877
 878     if (!m_session->hasTag(tag))
 879     {
 880         if (!m_session->addTag(tag))
 881             return false;
 882     }
 883     m_tags.insert(tag);
 884     m_session->handleTorrentNeedSaveResumeData(this);
 885     m_session->handleTorrentTagAdded(this, tag);
 886     return true;
 887 }
 888
 889 bool TorrentImpl::removeTag(const Tag &tag)
 890 {
 891     if (m_tags.remove(tag))
 892     {
 893         m_session->handleTorrentNeedSaveResumeData(this);
 894         m_session->handleTorrentTagRemoved(this, tag);
 895         return true;
 896     }
 897     return false;
 898 }
 899
 900 void TorrentImpl::removeAllTags()
 901 {
 902     for (const Tag &tag : asConst(tags()))
 903         removeTag(tag);
 904 }
 905
 906 QDateTime TorrentImpl::addedTime() const
 907 {
 908     return QDateTime::fromSecsSinceEpoch(m_nativeStatus.added_time);
 909 }
 910
 911 qreal TorrentImpl::ratioLimit() const
 912 {
 913     return m_ratioLimit;
 914 }
 915
 916 int TorrentImpl::seedingTimeLimit() const
 917 {
 918     return m_seedingTimeLimit;
 919 }
 920
 921 int TorrentImpl::inactiveSeedingTimeLimit() const
 922 {
 923     return m_inactiveSeedingTimeLimit;
 924 }
 925
 926 Path TorrentImpl::filePath(const int index) const
 927 {
 928     Q_ASSERT(index >= 0);
 929     Q_ASSERT(index < m_filePaths.size());
 930
 931     return m_filePaths.value(index, {});
 932 }
 933
 934 Path TorrentImpl::actualFilePath(const int index) const
 935 {
 936     const QVector<lt::file_index_t> nativeIndexes = m_torrentInfo.nativeIndexes();
 937
 938     Q_ASSERT(index >= 0);
 939     Q_ASSERT(index < nativeIndexes.size());
 940     if ((index < 0) || (index >= nativeIndexes.size()))
 941         return {};
 942
 943     return Path(nativeTorrentInfo()->files().file_path(nativeIndexes[index]));
 944 }
 945
 946 qlonglong TorrentImpl::fileSize(const int index) const
 947 {
 948     return m_torrentInfo.fileSize(index);
 949 }
 950
 951 PathList TorrentImpl::filePaths() const
 952 {
 953     return m_filePaths;
 954 }
 955
 956 QVector<DownloadPriority> TorrentImpl::filePriorities() const
 957 {
 958     return m_filePriorities;
 959 }
 960
 961 TorrentInfo TorrentImpl::info() const
 962 {
 963     return m_torrentInfo;
 964 }
 965
 966 bool TorrentImpl::isPaused() const
 967 {
 968     return m_isStopped;
 969 }
 970
 971 bool TorrentImpl::isQueued() const
 972 {
 973     // Torrent is Queued if it isn't in Paused state but paused internally
 974     return (!isPaused()
 975             && (m_nativeStatus.flags & lt::torrent_flags::auto_managed)
 976             && (m_nativeStatus.flags & lt::torrent_flags::paused));
 977 }
 978
 979 bool TorrentImpl::isChecking() const
 980 {
 981     return ((m_nativeStatus.state == lt::torrent_status::checking_files)
 982             || (m_nativeStatus.state == lt::torrent_status::checking_resume_data));
 983 }
 984
 985 bool TorrentImpl::isDownloading() const
 986 {
 987     switch (m_state)
 988     {
 989     case TorrentState::Downloading:
 990     case TorrentState::DownloadingMetadata:
 991     case TorrentState::ForcedDownloadingMetadata:
 992     case TorrentState::StalledDownloading:
 993     case TorrentState::CheckingDownloading:
 994     case TorrentState::PausedDownloading:
 995     case TorrentState::QueuedDownloading:
 996     case TorrentState::ForcedDownloading:
 997         return true;
 998     default:
 999         break;
1000     };
1001
1002     return false;
1003 }
1004
1005 bool TorrentImpl::isMoving() const
1006 {
1007     return m_state == TorrentState::Moving;
1008 }
1009
1010 bool TorrentImpl::isUploading() const
1011 {
1012     switch (m_state)
1013     {
1014     case TorrentState::Uploading:
1015     case TorrentState::StalledUploading:
1016     case TorrentState::CheckingUploading:
1017     case TorrentState::QueuedUploading:
1018     case TorrentState::ForcedUploading:
1019         return true;
1020     default:
1021         break;
1022     };
1023
1024     return false;
1025 }
1026
1027 bool TorrentImpl::isCompleted() const
1028 {
1029     switch (m_state)
1030     {
1031     case TorrentState::Uploading:
1032     case TorrentState::StalledUploading:
1033     case TorrentState::CheckingUploading:
1034     case TorrentState::PausedUploading:
1035     case TorrentState::QueuedUploading:
1036     case TorrentState::ForcedUploading:
1037         return true;
1038     default:
1039         break;
1040     };
1041
1042     return false;
1043 }
1044
1045 bool TorrentImpl::isActive() const
1046 {
1047     switch (m_state)
1048     {
1049     case TorrentState::StalledDownloading:
1050         return (uploadPayloadRate() > 0);
1051
1052     case TorrentState::DownloadingMetadata:
1053     case TorrentState::ForcedDownloadingMetadata:
1054     case TorrentState::Downloading:
1055     case TorrentState::ForcedDownloading:
1056     case TorrentState::Uploading:
1057     case TorrentState::ForcedUploading:
1058     case TorrentState::Moving:
1059         return true;
1060
1061     default:
1062         break;
1063     };
1064
1065     return false;
1066 }
1067
1068 bool TorrentImpl::isInactive() const
1069 {
1070     return !isActive();
1071 }
1072
1073 bool TorrentImpl::isErrored() const
1074 {
1075     return ((m_state == TorrentState::MissingFiles)
1076             || (m_state == TorrentState::Error));
1077 }
1078
1079 bool TorrentImpl::isFinished() const
1080 {
1081     return ((m_nativeStatus.state == lt::torrent_status::finished)
1082             || (m_nativeStatus.state == lt::torrent_status::seeding));
1083 }
1084
1085 bool TorrentImpl::isForced() const
1086 {
1087     return (!isPaused() && (m_operatingMode == TorrentOperatingMode::Forced));
1088 }
1089
1090 bool TorrentImpl::isSequentialDownload() const
1091 {
1092     return static_cast<bool>(m_nativeStatus.flags & lt::torrent_flags::sequential_download);
1093 }
1094
1095 bool TorrentImpl::hasFirstLastPiecePriority() const
1096 {
1097     return m_hasFirstLastPiecePriority;
1098 }
1099
1100 TorrentState TorrentImpl::state() const
1101 {
1102     return m_state;
1103 }
1104
1105 void TorrentImpl::updateState()
1106 {
1107     if (m_nativeStatus.state == lt::torrent_status::checking_resume_data)
1108     {
1109         m_state = TorrentState::CheckingResumeData;
1110     }
1111     else if (isMoveInProgress())
1112     {
1113         m_state = TorrentState::Moving;
1114     }
1115     else if (hasMissingFiles())
1116     {
1117         m_state = TorrentState::MissingFiles;
1118     }
1119     else if (hasError())
1120     {
1121         m_state = TorrentState::Error;
1122     }
1123     else if (!hasMetadata())
1124     {
1125         if (isPaused())
1126             m_state = TorrentState::PausedDownloading;
1127         else if (m_session->isQueueingSystemEnabled() && isQueued())
1128             m_state = TorrentState::QueuedDownloading;
1129         else
1130             m_state = isForced() ? TorrentState::ForcedDownloadingMetadata : TorrentState::DownloadingMetadata;
1131     }
1132     else if ((m_nativeStatus.state == lt::torrent_status::checking_files) && !isPaused())
1133     {
1134         // If the torrent is not just in the "checking" state, but is being actually checked
1135         m_state = m_hasFinishedStatus ? TorrentState::CheckingUploading : TorrentState::CheckingDownloading;
1136     }
1137     else if (isFinished())
1138     {
1139         if (isPaused())
1140             m_state = TorrentState::PausedUploading;
1141         else if (m_session->isQueueingSystemEnabled() && isQueued())
1142             m_state = TorrentState::QueuedUploading;
1143         else if (isForced())
1144             m_state = TorrentState::ForcedUploading;
1145         else if (m_nativeStatus.upload_payload_rate > 0)
1146             m_state = TorrentState::Uploading;
1147         else
1148             m_state = TorrentState::StalledUploading;
1149     }
1150     else
1151     {
1152         if (isPaused())
1153             m_state = TorrentState::PausedDownloading;
1154         else if (m_session->isQueueingSystemEnabled() && isQueued())
1155             m_state = TorrentState::QueuedDownloading;
1156         else if (isForced())
1157             m_state = TorrentState::ForcedDownloading;
1158         else if (m_nativeStatus.download_payload_rate > 0)
1159             m_state = TorrentState::Downloading;
1160         else
1161             m_state = TorrentState::StalledDownloading;
1162     }
1163 }
1164
1165 bool TorrentImpl::hasMetadata() const
1166 {
1167     return m_torrentInfo.isValid();
1168 }
1169
1170 bool TorrentImpl::hasMissingFiles() const
1171 {
1172     return m_hasMissingFiles;
1173 }
1174
1175 bool TorrentImpl::hasError() const
1176 {
1177     return (m_nativeStatus.errc || (m_nativeStatus.flags & lt::torrent_flags::upload_mode));
1178 }
1179
1180 int TorrentImpl::queuePosition() const
1181 {
1182     return static_cast<int>(m_nativeStatus.queue_position);
1183 }
1184
1185 QString TorrentImpl::error() const
1186 {
1187     if (m_nativeStatus.errc)
1188         return QString::fromLocal8Bit(m_nativeStatus.errc.message().c_str());
1189
1190     if (m_nativeStatus.flags & lt::torrent_flags::upload_mode)
1191     {
1192         return tr("Couldn't write to file. Reason: \"%1\". Torrent is now in \"upload only\" mode.")
1193             .arg(QString::fromLocal8Bit(m_lastFileError.error.message().c_str()));
1194     }
1195
1196     return {};
1197 }
1198
1199 qlonglong TorrentImpl::totalDownload() const
1200 {
1201     return m_nativeStatus.all_time_download;
1202 }
1203
1204 qlonglong TorrentImpl::totalUpload() const
1205 {
1206     return m_nativeStatus.all_time_upload;
1207 }
1208
1209 qlonglong TorrentImpl::activeTime() const
1210 {
1211     return lt::total_seconds(m_nativeStatus.active_duration);
1212 }
1213
1214 qlonglong TorrentImpl::finishedTime() const
1215 {
1216     return lt::total_seconds(m_nativeStatus.finished_duration);
1217 }
1218
1219 qlonglong TorrentImpl::eta() const
1220 {
1221     if (isPaused()) return MAX_ETA;
1222
1223     const SpeedSampleAvg speedAverage = m_payloadRateMonitor.average();
1224
1225     if (isFinished())
1226     {
1227         const qreal maxRatioValue = maxRatio();
1228         const int maxSeedingTimeValue = maxSeedingTime();
1229         const int maxInactiveSeedingTimeValue = maxInactiveSeedingTime();
1230         if ((maxRatioValue < 0) && (maxSeedingTimeValue < 0) && (maxInactiveSeedingTimeValue < 0)) return MAX_ETA;
1231
1232         qlonglong ratioEta = MAX_ETA;
1233
1234         if ((speedAverage.upload > 0) && (maxRatioValue >= 0))
1235         {
1236
1237             qlonglong realDL = totalDownload();
1238             if (realDL <= 0)
1239                 realDL = wantedSize();
1240
1241             ratioEta = ((realDL * maxRatioValue) - totalUpload()) / speedAverage.upload;
1242         }
1243
1244         qlonglong seedingTimeEta = MAX_ETA;
1245
1246         if (maxSeedingTimeValue >= 0)
1247         {
1248             seedingTimeEta = (maxSeedingTimeValue * 60) - finishedTime();
1249             if (seedingTimeEta < 0)
1250                 seedingTimeEta = 0;
1251         }
1252
1253         qlonglong inactiveSeedingTimeEta = MAX_ETA;
1254
1255         if (maxInactiveSeedingTimeValue >= 0)
1256         {
1257             inactiveSeedingTimeEta = (maxInactiveSeedingTimeValue * 60) - timeSinceActivity();
1258             inactiveSeedingTimeEta = std::max<qlonglong>(inactiveSeedingTimeEta, 0);
1259         }
1260
1261         return std::min({ratioEta, seedingTimeEta, inactiveSeedingTimeEta});
1262     }
1263
1264     if (!speedAverage.download) return MAX_ETA;
1265
1266     return (wantedSize() - completedSize()) / speedAverage.download;
1267 }
1268
1269 QVector<qreal> TorrentImpl::filesProgress() const
1270 {
1271     if (!hasMetadata())
1272         return {};
1273
1274     const int count = m_filesProgress.size();
1275     Q_ASSERT(count == filesCount());
1276     if (count != filesCount()) [[unlikely]]
1277         return {};
1278
1279     if (m_completedFiles.count(true) == count)
1280         return QVector<qreal>(count, 1);
1281
1282     QVector<qreal> result;
1283     result.reserve(count);
1284     for (int i = 0; i < count; ++i)
1285     {
1286         const int64_t progress = m_filesProgress.at(i);
1287         const int64_t size = fileSize(i);
1288         if ((size <= 0) || (progress == size))
1289             result << 1;
1290         else
1291             result << (progress / static_cast<qreal>(size));
1292     }
1293
1294     return result;
1295 }
1296
1297 int TorrentImpl::seedsCount() const
1298 {
1299     return m_nativeStatus.num_seeds;
1300 }
1301
1302 int TorrentImpl::peersCount() const
1303 {
1304     return m_nativeStatus.num_peers;
1305 }
1306
1307 int TorrentImpl::leechsCount() const
1308 {
1309     return (m_nativeStatus.num_peers - m_nativeStatus.num_seeds);
1310 }
1311
1312 int TorrentImpl::totalSeedsCount() const
1313 {
1314     return (m_nativeStatus.num_complete > -1) ? m_nativeStatus.num_complete : m_nativeStatus.list_seeds;
1315 }
1316
1317 int TorrentImpl::totalPeersCount() const
1318 {
1319     const int peers = m_nativeStatus.num_complete + m_nativeStatus.num_incomplete;
1320     return (peers > -1) ? peers : m_nativeStatus.list_peers;
1321 }
1322
1323 int TorrentImpl::totalLeechersCount() const
1324 {
1325     return (m_nativeStatus.num_incomplete > -1) ? m_nativeStatus.num_incomplete : (m_nativeStatus.list_peers - m_nativeStatus.list_seeds);
1326 }
1327
1328 QDateTime TorrentImpl::lastSeenComplete() const
1329 {
1330     if (m_nativeStatus.last_seen_complete > 0)
1331         return QDateTime::fromSecsSinceEpoch(m_nativeStatus.last_seen_complete);
1332     else
1333         return {};
1334 }
1335
1336 QDateTime TorrentImpl::completedTime() const
1337 {
1338     if (m_nativeStatus.completed_time > 0)
1339         return QDateTime::fromSecsSinceEpoch(m_nativeStatus.completed_time);
1340     else
1341         return {};
1342 }
1343
1344 qlonglong TorrentImpl::timeSinceUpload() const
1345 {
1346     if (m_nativeStatus.last_upload.time_since_epoch().count() == 0)
1347         return -1;
1348     return lt::total_seconds(lt::clock_type::now() - m_nativeStatus.last_upload);
1349 }
1350
1351 qlonglong TorrentImpl::timeSinceDownload() const
1352 {
1353     if (m_nativeStatus.last_download.time_since_epoch().count() == 0)
1354         return -1;
1355     return lt::total_seconds(lt::clock_type::now() - m_nativeStatus.last_download);
1356 }
1357
1358 qlonglong TorrentImpl::timeSinceActivity() const
1359 {
1360     const qlonglong upTime = timeSinceUpload();
1361     const qlonglong downTime = timeSinceDownload();
1362     return ((upTime < 0) != (downTime < 0))
1363         ? std::max(upTime, downTime)
1364         : std::min(upTime, downTime);
1365 }
1366
1367 int TorrentImpl::downloadLimit() const
1368 {
1369     return m_downloadLimit;;
1370 }
1371
1372 int TorrentImpl::uploadLimit() const
1373 {
1374     return m_uploadLimit;
1375 }
1376
1377 bool TorrentImpl::superSeeding() const
1378 {
1379     return static_cast<bool>(m_nativeStatus.flags & lt::torrent_flags::super_seeding);
1380 }
1381
1382 bool TorrentImpl::isDHTDisabled() const
1383 {
1384     return static_cast<bool>(m_nativeStatus.flags & lt::torrent_flags::disable_dht);
1385 }
1386
1387 bool TorrentImpl::isPEXDisabled() const
1388 {
1389     return static_cast<bool>(m_nativeStatus.flags & lt::torrent_flags::disable_pex);
1390 }
1391
1392 bool TorrentImpl::isLSDDisabled() const
1393 {
1394     return static_cast<bool>(m_nativeStatus.flags & lt::torrent_flags::disable_lsd);
1395 }
1396
1397 QVector<PeerInfo> TorrentImpl::peers() const
1398 {
1399     std::vector<lt::peer_info> nativePeers;
1400     m_nativeHandle.get_peer_info(nativePeers);
1401
1402     QVector<PeerInfo> peers;
1403     peers.reserve(static_cast<decltype(peers)::size_type>(nativePeers.size()));
1404
1405     for (const lt::peer_info &peer : nativePeers)
1406         peers.append(PeerInfo(peer, pieces()));
1407
1408     return peers;
1409 }
1410
1411 QBitArray TorrentImpl::pieces() const
1412 {
1413     return m_pieces;
1414 }
1415
1416 QBitArray TorrentImpl::downloadingPieces() const
1417 {
1418     QBitArray result(piecesCount());
1419
1420     std::vector<lt::partial_piece_info> queue;
1421     m_nativeHandle.get_download_queue(queue);
1422
1423     for (const lt::partial_piece_info &info : queue)
1424         result.setBit(LT::toUnderlyingType(info.piece_index));
1425
1426     return result;
1427 }
1428
1429 QVector<int> TorrentImpl::pieceAvailability() const
1430 {
1431     std::vector<int> avail;
1432     m_nativeHandle.piece_availability(avail);
1433
1434     return {avail.cbegin(), avail.cend()};
1435 }
1436
1437 qreal TorrentImpl::distributedCopies() const
1438 {
1439     return m_nativeStatus.distributed_copies;
1440 }
1441
1442 qreal TorrentImpl::maxRatio() const
1443 {
1444     if (m_ratioLimit == USE_GLOBAL_RATIO)
1445         return m_session->globalMaxRatio();
1446
1447     return m_ratioLimit;
1448 }
1449
1450 int TorrentImpl::maxSeedingTime() const
1451 {
1452     if (m_seedingTimeLimit == USE_GLOBAL_SEEDING_TIME)
1453         return m_session->globalMaxSeedingMinutes();
1454
1455     return m_seedingTimeLimit;
1456 }
1457
1458 int TorrentImpl::maxInactiveSeedingTime() const
1459 {
1460     if (m_inactiveSeedingTimeLimit == USE_GLOBAL_INACTIVE_SEEDING_TIME)
1461         return m_session->globalMaxInactiveSeedingMinutes();
1462
1463     return m_inactiveSeedingTimeLimit;
1464 }
1465
1466 qreal TorrentImpl::realRatio() const
1467 {
1468     const int64_t upload = m_nativeStatus.all_time_upload;
1469     // special case for a seeder who lost its stats, also assume nobody will import a 99% done torrent
1470     const int64_t download = (m_nativeStatus.all_time_download < (m_nativeStatus.total_done * 0.01))
1471         ? m_nativeStatus.total_done
1472         : m_nativeStatus.all_time_download;
1473
1474     if (download == 0)
1475         return (upload == 0) ? 0 : MAX_RATIO;
1476
1477     const qreal ratio = upload / static_cast<qreal>(download);
1478     Q_ASSERT(ratio >= 0);
1479     return (ratio > MAX_RATIO) ? MAX_RATIO : ratio;
1480 }
1481
1482 int TorrentImpl::uploadPayloadRate() const
1483 {
1484     // workaround: suppress the speed for paused state
1485     return isPaused() ? 0 : m_nativeStatus.upload_payload_rate;
1486 }
1487
1488 int TorrentImpl::downloadPayloadRate() const
1489 {
1490     // workaround: suppress the speed for paused state
1491     return isPaused() ? 0 : m_nativeStatus.download_payload_rate;
1492 }
1493
1494 qlonglong TorrentImpl::totalPayloadUpload() const
1495 {
1496     return m_nativeStatus.total_payload_upload;
1497 }
1498
1499 qlonglong TorrentImpl::totalPayloadDownload() const
1500 {
1501     return m_nativeStatus.total_payload_download;
1502 }
1503
1504 int TorrentImpl::connectionsCount() const
1505 {
1506     return m_nativeStatus.num_connections;
1507 }
1508
1509 int TorrentImpl::connectionsLimit() const
1510 {
1511     return m_nativeStatus.connections_limit;
1512 }
1513
1514 qlonglong TorrentImpl::nextAnnounce() const
1515 {
1516     return lt::total_seconds(m_nativeStatus.next_announce);
1517 }
1518
1519 void TorrentImpl::setName(const QString &name)
1520 {
1521     if (m_name != name)
1522     {
1523         m_name = name;
1524         m_session->handleTorrentNeedSaveResumeData(this);
1525         m_session->handleTorrentNameChanged(this);
1526     }
1527 }
1528
1529 bool TorrentImpl::setCategory(const QString &category)
1530 {
1531     if (m_category != category)
1532     {
1533         if (!category.isEmpty() && !m_session->categories().contains(category))
1534             return false;
1535
1536         const QString oldCategory = m_category;
1537         m_category = category;
1538         m_session->handleTorrentNeedSaveResumeData(this);
1539         m_session->handleTorrentCategoryChanged(this, oldCategory);
1540
1541         if (m_useAutoTMM)
1542         {
1543             if (!m_session->isDisableAutoTMMWhenCategoryChanged())
1544                 adjustStorageLocation();
1545             else
1546                 setAutoTMMEnabled(false);
1547         }
1548     }
1549
1550     return true;
1551 }
1552
1553 void TorrentImpl::forceReannounce(const int index)
1554 {
1555     m_nativeHandle.force_reannounce(0, index);
1556 }
1557
1558 void TorrentImpl::forceDHTAnnounce()
1559 {
1560     m_nativeHandle.force_dht_announce();
1561 }
1562
1563 void TorrentImpl::forceRecheck()
1564 {
1565     if (!hasMetadata())
1566         return;
1567
1568     m_nativeHandle.force_recheck();
1569     // We have to force update the cached state, otherwise someone will be able to get
1570     // an incorrect one during the interval until the cached state is updated in a regular way.
1571     m_nativeStatus.state = lt::torrent_status::checking_resume_data;
1572
1573     m_hasMissingFiles = false;
1574     m_unchecked = false;
1575
1576     m_completedFiles.fill(false);
1577     m_filesProgress.fill(0);
1578     m_pieces.fill(false);
1579     m_nativeStatus.pieces.clear_all();
1580     m_nativeStatus.num_pieces = 0;
1581
1582     if (isPaused())
1583     {
1584         // When "force recheck" is applied on paused torrent, we temporarily resume it
1585         resume();
1586         m_stopCondition = StopCondition::FilesChecked;
1587     }
1588 }
1589
1590 void TorrentImpl::setSequentialDownload(const bool enable)
1591 {
1592     if (enable)
1593     {
1594         m_nativeHandle.set_flags(lt::torrent_flags::sequential_download);
1595         m_nativeStatus.flags |= lt::torrent_flags::sequential_download;  // prevent return cached value
1596     }
1597     else
1598     {
1599         m_nativeHandle.unset_flags(lt::torrent_flags::sequential_download);
1600         m_nativeStatus.flags &= ~lt::torrent_flags::sequential_download;  // prevent return cached value
1601     }
1602
1603     m_session->handleTorrentNeedSaveResumeData(this);
1604 }
1605
1606 void TorrentImpl::setFirstLastPiecePriority(const bool enabled)
1607 {
1608     if (m_hasFirstLastPiecePriority == enabled)
1609         return;
1610
1611     m_hasFirstLastPiecePriority = enabled;
1612     if (hasMetadata())
1613         applyFirstLastPiecePriority(enabled);
1614
1615     LogMsg(tr("Download first and last piece first: %1, torrent: '%2'")
1616         .arg((enabled ? tr("On") : tr("Off")), name()));
1617
1618     m_session->handleTorrentNeedSaveResumeData(this);
1619 }
1620
1621 void TorrentImpl::applyFirstLastPiecePriority(const bool enabled)
1622 {
1623     Q_ASSERT(hasMetadata());
1624
1625     // Download first and last pieces first for every file in the torrent
1626
1627     auto piecePriorities = std::vector<lt::download_priority_t>(m_torrentInfo.piecesCount(), LT::toNative(DownloadPriority::Ignored));
1628
1629     // Updating file priorities is an async operation in libtorrent, when we just updated it and immediately query it
1630     // we might get the old/wrong values, so we rely on `updatedFilePrio` in this case.
1631     for (int fileIndex = 0; fileIndex < m_filePriorities.size(); ++fileIndex)
1632     {
1633         const DownloadPriority filePrio = m_filePriorities[fileIndex];
1634         if (filePrio <= DownloadPriority::Ignored)
1635             continue;
1636
1637         // Determine the priority to set
1638         const lt::download_priority_t piecePrio = LT::toNative(enabled ? DownloadPriority::Maximum : filePrio);
1639         const TorrentInfo::PieceRange pieceRange = m_torrentInfo.filePieces(fileIndex);
1640
1641         // worst case: AVI index = 1% of total file size (at the end of the file)
1642         const int numPieces = std::ceil(fileSize(fileIndex) * 0.01 / pieceLength());
1643         for (int i = 0; i < numPieces; ++i)
1644         {
1645             piecePriorities[pieceRange.first() + i] = piecePrio;
1646             piecePriorities[pieceRange.last() - i] = piecePrio;
1647         }
1648
1649         const int firstPiece = pieceRange.first() + numPieces;
1650         const int lastPiece = pieceRange.last() - numPieces;
1651         for (int pieceIndex = firstPiece; pieceIndex <= lastPiece; ++pieceIndex)
1652             piecePriorities[pieceIndex] = LT::toNative(filePrio);
1653     }
1654
1655     m_nativeHandle.prioritize_pieces(piecePriorities);
1656 }
1657
1658 void TorrentImpl::fileSearchFinished(const Path &savePath, const PathList &fileNames)
1659 {
1660     if (m_maintenanceJob == MaintenanceJob::HandleMetadata)
1661         endReceivedMetadataHandling(savePath, fileNames);
1662 }
1663
1664 TrackerEntry TorrentImpl::updateTrackerEntry(const lt::announce_entry &announceEntry, const QHash<lt::tcp::endpoint, QMap<int, int>> &updateInfo)
1665 {
1666     const auto it = std::find_if(m_trackerEntries.begin(), m_trackerEntries.end()
1667             , [&announceEntry](const TrackerEntry &trackerEntry)
1668     {
1669         return (trackerEntry.url == QString::fromStdString(announceEntry.url));
1670     });
1671
1672     Q_ASSERT(it != m_trackerEntries.end());
1673     if (it == m_trackerEntries.end()) [[unlikely]]
1674         return {};
1675
1676 #ifdef QBT_USES_LIBTORRENT2
1677     QSet<int> btProtocols;
1678     const auto &infoHashes = nativeHandle().info_hashes();
1679     if (infoHashes.has(lt::protocol_version::V1))
1680         btProtocols.insert(1);
1681     if (infoHashes.has(lt::protocol_version::V2))
1682         btProtocols.insert(2);
1683 #else
1684     const QSet<int> btProtocols {1};
1685 #endif
1686     ::updateTrackerEntry(*it, announceEntry, btProtocols, updateInfo);
1687     return *it;
1688 }
1689
1690 void TorrentImpl::resetTrackerEntries()
1691 {
1692     for (auto &trackerEntry : m_trackerEntries)
1693         trackerEntry = {trackerEntry.url, trackerEntry.tier};
1694 }
1695
1696 std::shared_ptr<const libtorrent::torrent_info> TorrentImpl::nativeTorrentInfo() const
1697 {
1698     if (m_nativeStatus.torrent_file.expired())
1699         m_nativeStatus.torrent_file = m_nativeHandle.torrent_file();
1700     return m_nativeStatus.torrent_file.lock();
1701 }
1702
1703 void TorrentImpl::endReceivedMetadataHandling(const Path &savePath, const PathList &fileNames)
1704 {
1705     Q_ASSERT(m_maintenanceJob == MaintenanceJob::HandleMetadata);
1706     if (m_maintenanceJob != MaintenanceJob::HandleMetadata) [[unlikely]]
1707         return;
1708
1709     Q_ASSERT(m_filePaths.isEmpty());
1710     if (!m_filePaths.isEmpty()) [[unlikely]]
1711         m_filePaths.clear();
1712
1713     lt::add_torrent_params &p = m_ltAddTorrentParams;
1714
1715     const std::shared_ptr<lt::torrent_info> metadata = std::const_pointer_cast<lt::torrent_info>(nativeTorrentInfo());
1716     m_torrentInfo = TorrentInfo(*metadata);
1717     m_filePriorities.reserve(filesCount());
1718     const auto nativeIndexes = m_torrentInfo.nativeIndexes();
1719     p.file_priorities = resized(p.file_priorities, metadata->files().num_files()
1720             , LT::toNative(p.file_priorities.empty() ? DownloadPriority::Normal : DownloadPriority::Ignored));
1721
1722     m_completedFiles.fill(static_cast<bool>(p.flags & lt::torrent_flags::seed_mode), filesCount());
1723     m_filesProgress.resize(filesCount());
1724     updateProgress();
1725
1726     for (int i = 0; i < fileNames.size(); ++i)
1727     {
1728         const auto nativeIndex = nativeIndexes.at(i);
1729
1730         const Path &actualFilePath = fileNames.at(i);
1731         p.renamed_files[nativeIndex] = actualFilePath.toString().toStdString();
1732
1733         const Path filePath = actualFilePath.removedExtension(QB_EXT);
1734         m_filePaths.append(filePath);
1735
1736         lt::download_priority_t &nativePriority = p.file_priorities[LT::toUnderlyingType(nativeIndex)];
1737         if ((nativePriority != lt::dont_download) && m_session->isFilenameExcluded(filePath.filename()))
1738             nativePriority = lt::dont_download;
1739         const auto priority = LT::fromNative(nativePriority);
1740         m_filePriorities.append(priority);
1741     }
1742     p.save_path = savePath.toString().toStdString();
1743     p.ti = metadata;
1744
1745     if (stopCondition() == StopCondition::MetadataReceived)
1746     {
1747         m_stopCondition = StopCondition::None;
1748
1749         m_isStopped = true;
1750         p.flags |= lt::torrent_flags::paused;
1751         p.flags &= ~lt::torrent_flags::auto_managed;
1752
1753         m_session->handleTorrentPaused(this);
1754     }
1755
1756     reload();
1757
1758     // If first/last piece priority was specified when adding this torrent,
1759     // we should apply it now that we have metadata:
1760     if (m_hasFirstLastPiecePriority)
1761         applyFirstLastPiecePriority(true);
1762
1763     m_maintenanceJob = MaintenanceJob::None;
1764     prepareResumeData(p);
1765
1766     m_session->handleTorrentMetadataReceived(this);
1767 }
1768
1769 void TorrentImpl::reload()
1770 {
1771     try
1772     {
1773         m_completedFiles.fill(false);
1774         m_filesProgress.fill(0);
1775         m_pieces.fill(false);
1776         m_nativeStatus.pieces.clear_all();
1777         m_nativeStatus.num_pieces = 0;
1778
1779         const auto queuePos = m_nativeHandle.queue_position();
1780
1781         m_nativeSession->remove_torrent(m_nativeHandle, lt::session::delete_partfile);
1782
1783         lt::add_torrent_params p = m_ltAddTorrentParams;
1784         p.flags |= lt::torrent_flags::update_subscribe
1785                 | lt::torrent_flags::override_trackers
1786                 | lt::torrent_flags::override_web_seeds;
1787
1788         if (m_isStopped)
1789         {
1790             p.flags |= lt::torrent_flags::paused;
1791             p.flags &= ~lt::torrent_flags::auto_managed;
1792         }
1793         else if (m_operatingMode == TorrentOperatingMode::AutoManaged)
1794         {
1795             p.flags |= (lt::torrent_flags::auto_managed | lt::torrent_flags::paused);
1796         }
1797         else
1798         {
1799             p.flags &= ~(lt::torrent_flags::auto_managed | lt::torrent_flags::paused);
1800         }
1801
1802         auto *const extensionData = new ExtensionData;
1803         p.userdata = LTClientData(extensionData);
1804         m_nativeHandle = m_nativeSession->add_torrent(p);
1805
1806         m_nativeStatus = extensionData->status;
1807
1808         if (queuePos >= lt::queue_position_t {})
1809             m_nativeHandle.queue_position_set(queuePos);
1810         m_nativeStatus.queue_position = queuePos;
1811
1812         updateState();
1813     }
1814     catch (const lt::system_error &err)
1815     {
1816         throw RuntimeError(tr("Failed to reload torrent. Torrent: %1. Reason: %2")
1817                 .arg(id().toString(), QString::fromLocal8Bit(err.what())));
1818     }
1819 }
1820
1821 void TorrentImpl::pause()
1822 {
1823     if (!m_isStopped)
1824     {
1825         m_stopCondition = StopCondition::None;
1826         m_isStopped = true;
1827         m_session->handleTorrentNeedSaveResumeData(this);
1828         m_session->handleTorrentPaused(this);
1829     }
1830
1831     if (m_maintenanceJob == MaintenanceJob::None)
1832     {
1833         setAutoManaged(false);
1834         m_nativeHandle.pause();
1835
1836         m_payloadRateMonitor.reset();
1837     }
1838 }
1839
1840 void TorrentImpl::resume(const TorrentOperatingMode mode)
1841 {
1842     if (hasError())
1843     {
1844         m_nativeHandle.clear_error();
1845         m_nativeHandle.unset_flags(lt::torrent_flags::upload_mode);
1846     }
1847
1848     m_operatingMode = mode;
1849
1850     if (m_hasMissingFiles)
1851     {
1852         m_hasMissingFiles = false;
1853         m_isStopped = false;
1854         m_ltAddTorrentParams.ti = std::const_pointer_cast<lt::torrent_info>(nativeTorrentInfo());
1855         reload();
1856         return;
1857     }
1858
1859     if (m_isStopped)
1860     {
1861         m_isStopped = false;
1862         m_session->handleTorrentNeedSaveResumeData(this);
1863         m_session->handleTorrentResumed(this);
1864     }
1865
1866     if (m_maintenanceJob == MaintenanceJob::None)
1867     {
1868         setAutoManaged(m_operatingMode == TorrentOperatingMode::AutoManaged);
1869         if (m_operatingMode == TorrentOperatingMode::Forced)
1870             m_nativeHandle.resume();
1871     }
1872 }
1873
1874 void TorrentImpl::moveStorage(const Path &newPath, const MoveStorageContext context)
1875 {
1876     if (!hasMetadata())
1877     {
1878         m_savePath = newPath;
1879         m_session->handleTorrentSavePathChanged(this);
1880         return;
1881     }
1882
1883     const auto mode = (context == MoveStorageContext::AdjustCurrentLocation)
1884             ? MoveStorageMode::Overwrite : MoveStorageMode::KeepExistingFiles;
1885     if (m_session->addMoveTorrentStorageJob(this, newPath, mode, context))
1886     {
1887         if (!m_storageIsMoving)
1888         {
1889             m_storageIsMoving = true;
1890             updateState();
1891             m_session->handleTorrentStorageMovingStateChanged(this);
1892         }
1893     }
1894 }
1895
1896 void TorrentImpl::renameFile(const int index, const Path &path)
1897 {
1898     Q_ASSERT((index >= 0) && (index < filesCount()));
1899     if ((index < 0) || (index >= filesCount())) [[unlikely]]
1900         return;
1901
1902     const Path targetActualPath = makeActualPath(index, path);
1903     doRenameFile(index, targetActualPath);
1904 }
1905
1906 void TorrentImpl::handleStateUpdate(const lt::torrent_status &nativeStatus)
1907 {
1908     updateStatus(nativeStatus);
1909 }
1910
1911 void TorrentImpl::handleMoveStorageJobFinished(const Path &path, const MoveStorageContext context, const bool hasOutstandingJob)
1912 {
1913     if (context == MoveStorageContext::ChangeSavePath)
1914         m_savePath = path;
1915     else if (context == MoveStorageContext::ChangeDownloadPath)
1916         m_downloadPath = path;
1917     m_storageIsMoving = hasOutstandingJob;
1918     m_nativeStatus.save_path = path.toString().toStdString();
1919
1920     m_session->handleTorrentSavePathChanged(this);
1921     m_session->handleTorrentNeedSaveResumeData(this);
1922
1923     if (!m_storageIsMoving)
1924     {
1925         updateState();
1926         m_session->handleTorrentStorageMovingStateChanged(this);
1927
1928         if (m_hasMissingFiles)
1929         {
1930             // it can be moved to the proper location
1931             m_hasMissingFiles = false;
1932             m_ltAddTorrentParams.save_path = m_nativeStatus.save_path;
1933             m_ltAddTorrentParams.ti = std::const_pointer_cast<lt::torrent_info>(nativeTorrentInfo());
1934             reload();
1935         }
1936
1937         while ((m_renameCount == 0) && !m_moveFinishedTriggers.isEmpty())
1938             std::invoke(m_moveFinishedTriggers.dequeue());
1939     }
1940 }
1941
1942 void TorrentImpl::handleTorrentCheckedAlert([[maybe_unused]] const lt::torrent_checked_alert *p)
1943 {
1944     if (!hasMetadata())
1945     {
1946         // The torrent is checked due to metadata received, but we should not process
1947         // this event until the torrent is reloaded using the received metadata.
1948         return;
1949     }
1950
1951     if (stopCondition() == StopCondition::FilesChecked)
1952         pause();
1953
1954     m_statusUpdatedTriggers.enqueue([this]()
1955     {
1956         qDebug("\"%s\" have just finished checking.", qUtf8Printable(name()));
1957
1958         if (!m_hasMissingFiles)
1959         {
1960             if ((progress() < 1.0) && (wantedSize() > 0))
1961                 m_hasFinishedStatus = false;
1962             else if (progress() == 1.0)
1963                 m_hasFinishedStatus = true;
1964
1965             adjustStorageLocation();
1966             manageActualFilePaths();
1967
1968             if (!isPaused())
1969             {
1970                 // torrent is internally paused using NativeTorrentExtension after files checked
1971                 // so we need to resume it if there is no corresponding "stop condition" set
1972                 setAutoManaged(m_operatingMode == TorrentOperatingMode::AutoManaged);
1973                 if (m_operatingMode == TorrentOperatingMode::Forced)
1974                     m_nativeHandle.resume();
1975             }
1976         }
1977
1978         if (m_nativeStatus.need_save_resume)
1979             m_session->handleTorrentNeedSaveResumeData(this);
1980
1981         m_session->handleTorrentChecked(this);
1982     });
1983 }
1984
1985 void TorrentImpl::handleTorrentFinishedAlert([[maybe_unused]] const lt::torrent_finished_alert *p)
1986 {
1987     m_hasMissingFiles = false;
1988     if (m_hasFinishedStatus)
1989         return;
1990
1991     m_statusUpdatedTriggers.enqueue([this]()
1992     {
1993         adjustStorageLocation();
1994         manageActualFilePaths();
1995
1996         m_session->handleTorrentNeedSaveResumeData(this);
1997
1998         const bool recheckTorrentsOnCompletion = Preferences::instance()->recheckTorrentsOnCompletion();
1999         if (recheckTorrentsOnCompletion && m_unchecked)
2000         {
2001             forceRecheck();
2002         }
2003         else
2004         {
2005             m_hasFinishedStatus = true;
2006
2007             if (isMoveInProgress() || (m_renameCount > 0))
2008                 m_moveFinishedTriggers.enqueue([this]() { m_session->handleTorrentFinished(this); });
2009             else
2010                 m_session->handleTorrentFinished(this);
2011         }
2012     });
2013 }
2014
2015 void TorrentImpl::handleTorrentPausedAlert([[maybe_unused]] const lt::torrent_paused_alert *p)
2016 {
2017 }
2018
2019 void TorrentImpl::handleTorrentResumedAlert([[maybe_unused]] const lt::torrent_resumed_alert *p)
2020 {
2021 }
2022
2023 void TorrentImpl::handleSaveResumeDataAlert(const lt::save_resume_data_alert *p)
2024 {
2025     if (m_ltAddTorrentParams.url_seeds != p->params.url_seeds)
2026     {
2027         // URL seed list have been changed by libtorrent for some reason, so we need to update cached one.
2028         // Unfortunately, URL seed list containing in "resume data" is generated according to different rules
2029         // than the list we usually cache, so we have to request it from the appropriate source.
2030         fetchURLSeeds([this](const QVector<QUrl> &urlSeeds) { m_urlSeeds = urlSeeds; });
2031     }
2032
2033     if (m_maintenanceJob == MaintenanceJob::HandleMetadata)
2034     {
2035         Q_ASSERT(m_indexMap.isEmpty());
2036
2037         const auto isSeedMode = static_cast<bool>(m_ltAddTorrentParams.flags & lt::torrent_flags::seed_mode);
2038         m_ltAddTorrentParams = p->params;
2039         if (isSeedMode)
2040             m_ltAddTorrentParams.flags |= lt::torrent_flags::seed_mode;
2041
2042         m_ltAddTorrentParams.have_pieces.clear();
2043         m_ltAddTorrentParams.verified_pieces.clear();
2044
2045         TorrentInfo metadata = TorrentInfo(*nativeTorrentInfo());
2046
2047         const auto &renamedFiles = m_ltAddTorrentParams.renamed_files;
2048         PathList filePaths = metadata.filePaths();
2049         if (renamedFiles.empty() && (m_contentLayout != TorrentContentLayout::Original))
2050         {
2051             const Path originalRootFolder = Path::findRootFolder(filePaths);
2052             const auto originalContentLayout = (originalRootFolder.isEmpty()
2053                                                 ? TorrentContentLayout::NoSubfolder
2054                                                 : TorrentContentLayout::Subfolder);
2055             if (m_contentLayout != originalContentLayout)
2056             {
2057                 if (m_contentLayout == TorrentContentLayout::NoSubfolder)
2058                     Path::stripRootFolder(filePaths);
2059                 else
2060                     Path::addRootFolder(filePaths, filePaths.at(0).removedExtension());
2061             }
2062         }
2063
2064         const auto nativeIndexes = metadata.nativeIndexes();
2065         m_indexMap.reserve(filePaths.size());
2066         for (int i = 0; i < filePaths.size(); ++i)
2067         {
2068             const auto nativeIndex = nativeIndexes.at(i);
2069             m_indexMap[nativeIndex] = i;
2070
2071             if (const auto it = renamedFiles.find(nativeIndex); it != renamedFiles.cend())
2072                 filePaths[i] = Path(it->second);
2073         }
2074
2075         m_session->findIncompleteFiles(metadata, savePath(), downloadPath(), filePaths);
2076     }
2077     else
2078     {
2079         prepareResumeData(p->params);
2080     }
2081 }
2082
2083 void TorrentImpl::prepareResumeData(const lt::add_torrent_params &params)
2084 {
2085     if (m_hasMissingFiles)
2086     {
2087         const auto havePieces = m_ltAddTorrentParams.have_pieces;
2088         const auto unfinishedPieces = m_ltAddTorrentParams.unfinished_pieces;
2089         const auto verifiedPieces = m_ltAddTorrentParams.verified_pieces;
2090
2091         // Update recent resume data but preserve existing progress
2092         m_ltAddTorrentParams = params;
2093         m_ltAddTorrentParams.have_pieces = havePieces;
2094         m_ltAddTorrentParams.unfinished_pieces = unfinishedPieces;
2095         m_ltAddTorrentParams.verified_pieces = verifiedPieces;
2096     }
2097     else
2098     {
2099         const bool preserveSeedMode = (!hasMetadata() && (m_ltAddTorrentParams.flags & lt::torrent_flags::seed_mode));
2100         // Update recent resume data
2101         m_ltAddTorrentParams = params;
2102         if (preserveSeedMode)
2103             m_ltAddTorrentParams.flags |= lt::torrent_flags::seed_mode;
2104     }
2105
2106     // We shouldn't save upload_mode flag to allow torrent operate normally on next run
2107     m_ltAddTorrentParams.flags &= ~lt::torrent_flags::upload_mode;
2108
2109     LoadTorrentParams resumeData;
2110     resumeData.name = m_name;
2111     resumeData.category = m_category;
2112     resumeData.tags = m_tags;
2113     resumeData.contentLayout = m_contentLayout;
2114     resumeData.ratioLimit = m_ratioLimit;
2115     resumeData.seedingTimeLimit = m_seedingTimeLimit;
2116     resumeData.inactiveSeedingTimeLimit = m_inactiveSeedingTimeLimit;
2117     resumeData.firstLastPiecePriority = m_hasFirstLastPiecePriority;
2118     resumeData.hasFinishedStatus = m_hasFinishedStatus;
2119     resumeData.stopped = m_isStopped;
2120     resumeData.stopCondition = m_stopCondition;
2121     resumeData.operatingMode = m_operatingMode;
2122     resumeData.ltAddTorrentParams = m_ltAddTorrentParams;
2123     resumeData.useAutoTMM = m_useAutoTMM;
2124     if (!resumeData.useAutoTMM)
2125     {
2126         resumeData.savePath = m_savePath;
2127         resumeData.downloadPath = m_downloadPath;
2128     }
2129
2130     m_session->handleTorrentResumeDataReady(this, resumeData);
2131 }
2132
2133 void TorrentImpl::handleSaveResumeDataFailedAlert(const lt::save_resume_data_failed_alert *p)
2134 {
2135     if (p->error != lt::errors::resume_data_not_modified)
2136     {
2137         LogMsg(tr("Generate resume data failed. Torrent: \"%1\". Reason: \"%2\"")
2138             .arg(name(), QString::fromLocal8Bit(p->error.message().c_str())), Log::CRITICAL);
2139     }
2140
2141     m_session->handleTorrentSaveResumeDataFailed(this);
2142 }
2143
2144 void TorrentImpl::handleFastResumeRejectedAlert(const lt::fastresume_rejected_alert *p)
2145 {
2146     // Files were probably moved or storage isn't accessible
2147     m_hasMissingFiles = true;
2148     LogMsg(tr("Failed to restore torrent. Files were probably moved or storage isn't accessible. Torrent: \"%1\". Reason: \"%2\"")
2149         .arg(name(), QString::fromStdString(p->message())), Log::WARNING);
2150 }
2151
2152 void TorrentImpl::handleFileRenamedAlert(const lt::file_renamed_alert *p)
2153 {
2154     const int fileIndex = m_indexMap.value(p->index, -1);
2155     Q_ASSERT(fileIndex >= 0);
2156
2157     const Path newActualFilePath {QString::fromUtf8(p->new_name())};
2158
2159     const Path oldFilePath = m_filePaths.at(fileIndex);
2160     const Path newFilePath = makeUserPath(newActualFilePath);
2161
2162     // Check if ".!qB" extension or ".unwanted" folder was just added or removed
2163     // We should compare path in a case sensitive manner even on case insensitive
2164     // platforms since it can be renamed by only changing case of some character(s)
2165     if (oldFilePath.data() == newFilePath.data())
2166     {
2167         // Remove empty ".unwanted" folders
2168 #ifdef QBT_USES_LIBTORRENT2
2169         const Path oldActualFilePath {QString::fromUtf8(p->old_name())};
2170 #else
2171         const Path oldActualFilePath;
2172 #endif
2173         const Path oldActualParentPath = oldActualFilePath.parentPath();
2174         const Path newActualParentPath = newActualFilePath.parentPath();
2175         if (newActualParentPath.filename() == UNWANTED_FOLDER_NAME)
2176         {
2177             if (oldActualParentPath.filename() != UNWANTED_FOLDER_NAME)
2178             {
2179 #ifdef Q_OS_WIN
2180                 const std::wstring winPath = (actualStorageLocation() / newActualParentPath).toString().toStdWString();
2181                 const DWORD dwAttrs = ::GetFileAttributesW(winPath.c_str());
2182                 ::SetFileAttributesW(winPath.c_str(), (dwAttrs | FILE_ATTRIBUTE_HIDDEN));
2183 #endif
2184             }
2185         }
2186 #ifdef QBT_USES_LIBTORRENT2
2187         else if (oldActualParentPath.filename() == UNWANTED_FOLDER_NAME)
2188         {
2189             if (newActualParentPath.filename() != UNWANTED_FOLDER_NAME)
2190                 Utils::Fs::rmdir(actualStorageLocation() / oldActualParentPath);
2191         }
2192 #else
2193         else
2194         {
2195             Utils::Fs::rmdir(actualStorageLocation() / newActualParentPath / Path(UNWANTED_FOLDER_NAME));
2196         }
2197 #endif
2198     }
2199     else
2200     {
2201         m_filePaths[fileIndex] = newFilePath;
2202
2203         // Remove empty leftover folders
2204         // For example renaming "a/b/c" to "d/b/c", then folders "a/b" and "a" will
2205         // be removed if they are empty
2206         Path oldParentPath = oldFilePath.parentPath();
2207         const Path commonBasePath = Path::commonPath(oldParentPath, newFilePath.parentPath());
2208         while (oldParentPath != commonBasePath)
2209         {
2210             Utils::Fs::rmdir(actualStorageLocation() / oldParentPath);
2211             oldParentPath = oldParentPath.parentPath();
2212         }
2213     }
2214
2215     --m_renameCount;
2216     while (!isMoveInProgress() && (m_renameCount == 0) && !m_moveFinishedTriggers.isEmpty())
2217         m_moveFinishedTriggers.takeFirst()();
2218
2219     m_session->handleTorrentNeedSaveResumeData(this);
2220 }
2221
2222 void TorrentImpl::handleFileRenameFailedAlert(const lt::file_rename_failed_alert *p)
2223 {
2224     const int fileIndex = m_indexMap.value(p->index, -1);
2225     Q_ASSERT(fileIndex >= 0);
2226
2227     LogMsg(tr("File rename failed. Torrent: \"%1\", file: \"%2\", reason: \"%3\"")
2228         .arg(name(), filePath(fileIndex).toString(), QString::fromLocal8Bit(p->error.message().c_str())), Log::WARNING);
2229
2230     --m_renameCount;
2231     while (!isMoveInProgress() && (m_renameCount == 0) && !m_moveFinishedTriggers.isEmpty())
2232         m_moveFinishedTriggers.takeFirst()();
2233
2234     m_session->handleTorrentNeedSaveResumeData(this);
2235 }
2236
2237 void TorrentImpl::handleFileCompletedAlert(const lt::file_completed_alert *p)
2238 {
2239     if (m_maintenanceJob == MaintenanceJob::HandleMetadata)
2240         return;
2241
2242     const int fileIndex = m_indexMap.value(p->index, -1);
2243     Q_ASSERT(fileIndex >= 0);
2244
2245     m_completedFiles.setBit(fileIndex);
2246
2247     const Path actualPath = actualFilePath(fileIndex);
2248
2249 #if defined(Q_OS_MACOS) || defined(Q_OS_WIN)
2250     // only apply Mark-of-the-Web to new download files
2251     if (Preferences::instance()->isMarkOfTheWebEnabled() && isDownloading())
2252     {
2253         const Path fullpath = actualStorageLocation() / actualPath;
2254         Utils::OS::applyMarkOfTheWeb(fullpath);
2255     }
2256 #endif // Q_OS_MACOS || Q_OS_WIN
2257
2258     if (m_session->isAppendExtensionEnabled())
2259     {
2260         const Path path = filePath(fileIndex);
2261         if (actualPath != path)
2262         {
2263             qDebug("Renaming %s to %s", qUtf8Printable(actualPath.toString()), qUtf8Printable(path.toString()));
2264             doRenameFile(fileIndex, path);
2265         }
2266     }
2267 }
2268
2269 void TorrentImpl::handleFileErrorAlert(const lt::file_error_alert *p)
2270 {
2271     m_lastFileError = {p->error, p->op};
2272 }
2273
2274 #ifdef QBT_USES_LIBTORRENT2
2275 void TorrentImpl::handleFilePrioAlert(const lt::file_prio_alert *)
2276 {
2277     m_session->handleTorrentNeedSaveResumeData(this);
2278 }
2279 #endif
2280
2281 void TorrentImpl::handleMetadataReceivedAlert([[maybe_unused]] const lt::metadata_received_alert *p)
2282 {
2283     qDebug("Metadata received for torrent %s.", qUtf8Printable(name()));
2284
2285 #ifdef QBT_USES_LIBTORRENT2
2286     const InfoHash prevInfoHash = infoHash();
2287     m_infoHash = InfoHash(m_nativeHandle.info_hashes());
2288     if (prevInfoHash != infoHash())
2289         m_session->handleTorrentInfoHashChanged(this, prevInfoHash);
2290 #endif
2291
2292     m_maintenanceJob = MaintenanceJob::HandleMetadata;
2293     m_session->handleTorrentNeedSaveResumeData(this);
2294 }
2295
2296 void TorrentImpl::handlePerformanceAlert(const lt::performance_alert *p) const
2297 {
2298     LogMsg((tr("Performance alert: %1. More info: %2").arg(QString::fromStdString(p->message()), u"https://libtorrent.org/reference-Alerts.html#enum-performance-warning-t"_s))
2299            , Log::INFO);
2300 }
2301
2302 void TorrentImpl::handleCategoryOptionsChanged()
2303 {
2304     if (m_useAutoTMM)
2305         adjustStorageLocation();
2306 }
2307
2308 void TorrentImpl::handleAppendExtensionToggled()
2309 {
2310     if (!hasMetadata())
2311         return;
2312
2313     manageActualFilePaths();
2314 }
2315
2316 void TorrentImpl::handleUnwantedFolderToggled()
2317 {
2318     if (!hasMetadata())
2319         return;
2320
2321     manageActualFilePaths();
2322 }
2323
2324 void TorrentImpl::handleAlert(const lt::alert *a)
2325 {
2326     switch (a->type())
2327     {
2328 #ifdef QBT_USES_LIBTORRENT2
2329     case lt::file_prio_alert::alert_type:
2330         handleFilePrioAlert(static_cast<const lt::file_prio_alert*>(a));
2331         break;
2332 #endif
2333     case lt::file_renamed_alert::alert_type:
2334         handleFileRenamedAlert(static_cast<const lt::file_renamed_alert*>(a));
2335         break;
2336     case lt::file_rename_failed_alert::alert_type:
2337         handleFileRenameFailedAlert(static_cast<const lt::file_rename_failed_alert*>(a));
2338         break;
2339     case lt::file_completed_alert::alert_type:
2340         handleFileCompletedAlert(static_cast<const lt::file_completed_alert*>(a));
2341         break;
2342     case lt::file_error_alert::alert_type:
2343         handleFileErrorAlert(static_cast<const lt::file_error_alert*>(a));
2344         break;
2345     case lt::torrent_finished_alert::alert_type:
2346         handleTorrentFinishedAlert(static_cast<const lt::torrent_finished_alert*>(a));
2347         break;
2348     case lt::save_resume_data_alert::alert_type:
2349         handleSaveResumeDataAlert(static_cast<const lt::save_resume_data_alert*>(a));
2350         break;
2351     case lt::save_resume_data_failed_alert::alert_type:
2352         handleSaveResumeDataFailedAlert(static_cast<const lt::save_resume_data_failed_alert*>(a));
2353         break;
2354     case lt::torrent_paused_alert::alert_type:
2355         handleTorrentPausedAlert(static_cast<const lt::torrent_paused_alert*>(a));
2356         break;
2357     case lt::torrent_resumed_alert::alert_type:
2358         handleTorrentResumedAlert(static_cast<const lt::torrent_resumed_alert*>(a));
2359         break;
2360     case lt::metadata_received_alert::alert_type:
2361         handleMetadataReceivedAlert(static_cast<const lt::metadata_received_alert*>(a));
2362         break;
2363     case lt::fastresume_rejected_alert::alert_type:
2364         handleFastResumeRejectedAlert(static_cast<const lt::fastresume_rejected_alert*>(a));
2365         break;
2366     case lt::torrent_checked_alert::alert_type:
2367         handleTorrentCheckedAlert(static_cast<const lt::torrent_checked_alert*>(a));
2368         break;
2369     case lt::performance_alert::alert_type:
2370         handlePerformanceAlert(static_cast<const lt::performance_alert*>(a));
2371         break;
2372     }
2373 }
2374
2375 void TorrentImpl::manageActualFilePaths()
2376 {
2377     const std::shared_ptr<const lt::torrent_info> nativeInfo = nativeTorrentInfo();
2378     const lt::file_storage &nativeFiles = nativeInfo->files();
2379
2380     for (int i = 0; i < filesCount(); ++i)
2381     {
2382         const Path path = filePath(i);
2383
2384         const auto nativeIndex = m_torrentInfo.nativeIndexes().at(i);
2385         const Path actualPath {nativeFiles.file_path(nativeIndex)};
2386         const Path targetActualPath = makeActualPath(i, path);
2387         if (actualPath != targetActualPath)
2388         {
2389             qDebug() << "Renaming" << actualPath.toString() << "to" << targetActualPath.toString();
2390             doRenameFile(i, targetActualPath);
2391         }
2392     }
2393 }
2394
2395 void TorrentImpl::adjustStorageLocation()
2396 {
2397     const Path downloadPath = this->downloadPath();
2398     const Path targetPath = ((isFinished() || m_hasFinishedStatus || downloadPath.isEmpty()) ? savePath() : downloadPath);
2399
2400     if ((targetPath != actualStorageLocation()) || isMoveInProgress())
2401         moveStorage(targetPath, MoveStorageContext::AdjustCurrentLocation);
2402 }
2403
2404 void TorrentImpl::doRenameFile(const int index, const Path &path)
2405 {
2406     const QVector<lt::file_index_t> nativeIndexes = m_torrentInfo.nativeIndexes();
2407
2408     Q_ASSERT(index >= 0);
2409     Q_ASSERT(index < nativeIndexes.size());
2410     if ((index < 0) || (index >= nativeIndexes.size())) [[unlikely]]
2411         return;
2412
2413     ++m_renameCount;
2414     m_nativeHandle.rename_file(nativeIndexes[index], path.toString().toStdString());
2415 }
2416
2417 lt::torrent_handle TorrentImpl::nativeHandle() const
2418 {
2419     return m_nativeHandle;
2420 }
2421
2422 void TorrentImpl::setMetadata(const TorrentInfo &torrentInfo)
2423 {
2424     if (hasMetadata())
2425         return;
2426
2427     m_session->invokeAsync([nativeHandle = m_nativeHandle, torrentInfo]
2428     {
2429         try
2430         {
2431 #ifdef QBT_USES_LIBTORRENT2
2432             nativeHandle.set_metadata(torrentInfo.nativeInfo()->info_section());
2433 #else
2434             const std::shared_ptr<lt::torrent_info> nativeInfo = torrentInfo.nativeInfo();
2435             nativeHandle.set_metadata(lt::span<const char>(nativeInfo->metadata().get(), nativeInfo->metadata_size()));
2436 #endif
2437         }
2438         catch (const std::exception &) {}
2439     });
2440 }
2441
2442 Torrent::StopCondition TorrentImpl::stopCondition() const
2443 {
2444     return m_stopCondition;
2445 }
2446
2447 void TorrentImpl::setStopCondition(const StopCondition stopCondition)
2448 {
2449     if (stopCondition == m_stopCondition)
2450         return;
2451
2452     if (isPaused())
2453         return;
2454
2455     if ((stopCondition == StopCondition::MetadataReceived) && hasMetadata())
2456         return;
2457
2458     if ((stopCondition == StopCondition::FilesChecked) && hasMetadata() && !isChecking())
2459         return;
2460
2461     m_stopCondition = stopCondition;
2462 }
2463
2464 bool TorrentImpl::isMoveInProgress() const
2465 {
2466     return m_storageIsMoving;
2467 }
2468
2469 void TorrentImpl::updateStatus(const lt::torrent_status &nativeStatus)
2470 {
2471     const lt::torrent_status oldStatus = std::exchange(m_nativeStatus, nativeStatus);
2472
2473     if (m_nativeStatus.num_pieces != oldStatus.num_pieces)
2474         updateProgress();
2475
2476     updateState();
2477
2478     m_payloadRateMonitor.addSample({nativeStatus.download_payload_rate
2479                               , nativeStatus.upload_payload_rate});
2480
2481     if (hasMetadata())
2482     {
2483         // NOTE: Don't change the order of these conditionals!
2484         // Otherwise it will not work properly since torrent can be CheckingDownloading.
2485         if (isChecking())
2486             m_unchecked = false;
2487         else if (isDownloading())
2488             m_unchecked = true;
2489     }
2490
2491     while (!m_statusUpdatedTriggers.isEmpty())
2492         std::invoke(m_statusUpdatedTriggers.dequeue());
2493 }
2494
2495 void TorrentImpl::updateProgress()
2496 {
2497     Q_ASSERT(hasMetadata());
2498     if (!hasMetadata()) [[unlikely]]
2499         return;
2500
2501     Q_ASSERT(!m_filesProgress.isEmpty());
2502     if (m_filesProgress.isEmpty()) [[unlikely]]
2503         m_filesProgress.resize(filesCount());
2504
2505     const QBitArray oldPieces = std::exchange(m_pieces, LT::toQBitArray(m_nativeStatus.pieces));
2506     const QBitArray newPieces = m_pieces ^ oldPieces;
2507
2508     const int64_t pieceSize = m_torrentInfo.pieceLength();
2509     for (qsizetype index = 0; index < newPieces.size(); ++index)
2510     {
2511         if (!newPieces.at(index))
2512             continue;
2513
2514         int64_t size = m_torrentInfo.pieceLength(index);
2515         int64_t pieceOffset = index * pieceSize;
2516
2517         for (const int fileIndex : asConst(m_torrentInfo.fileIndicesForPiece(index)))
2518         {
2519             const int64_t fileOffsetInPiece = pieceOffset - m_torrentInfo.fileOffset(fileIndex);
2520             const int64_t add = std::min<int64_t>((m_torrentInfo.fileSize(fileIndex) - fileOffsetInPiece), size);
2521
2522             m_filesProgress[fileIndex] += add;
2523
2524             size -= add;
2525             if (size <= 0)
2526                 break;
2527
2528             pieceOffset += add;
2529         }
2530     }
2531 }
2532
2533 void TorrentImpl::setRatioLimit(qreal limit)
2534 {
2535     if (limit < USE_GLOBAL_RATIO)
2536         limit = NO_RATIO_LIMIT;
2537     else if (limit > MAX_RATIO)
2538         limit = MAX_RATIO;
2539
2540     if (m_ratioLimit != limit)
2541     {
2542         m_ratioLimit = limit;
2543         m_session->handleTorrentNeedSaveResumeData(this);
2544         m_session->handleTorrentShareLimitChanged(this);
2545     }
2546 }
2547
2548 void TorrentImpl::setSeedingTimeLimit(int limit)
2549 {
2550     if (limit < USE_GLOBAL_SEEDING_TIME)
2551         limit = NO_SEEDING_TIME_LIMIT;
2552     else if (limit > MAX_SEEDING_TIME)
2553         limit = MAX_SEEDING_TIME;
2554
2555     if (m_seedingTimeLimit != limit)
2556     {
2557         m_seedingTimeLimit = limit;
2558         m_session->handleTorrentNeedSaveResumeData(this);
2559         m_session->handleTorrentShareLimitChanged(this);
2560     }
2561 }
2562
2563 void TorrentImpl::setInactiveSeedingTimeLimit(int limit)
2564 {
2565     if (limit < USE_GLOBAL_INACTIVE_SEEDING_TIME)
2566         limit = NO_INACTIVE_SEEDING_TIME_LIMIT;
2567     else if (limit > MAX_INACTIVE_SEEDING_TIME)
2568         limit = MAX_SEEDING_TIME;
2569
2570     if (m_inactiveSeedingTimeLimit != limit)
2571     {
2572         m_inactiveSeedingTimeLimit = limit;
2573         m_session->handleTorrentNeedSaveResumeData(this);
2574         m_session->handleTorrentShareLimitChanged(this);
2575     }
2576 }
2577
2578 void TorrentImpl::setUploadLimit(const int limit)
2579 {
2580     const int cleanValue = cleanLimitValue(limit);
2581     if (cleanValue == uploadLimit())
2582         return;
2583
2584     m_uploadLimit = cleanValue;
2585     m_nativeHandle.set_upload_limit(m_uploadLimit);
2586     m_session->handleTorrentNeedSaveResumeData(this);
2587 }
2588
2589 void TorrentImpl::setDownloadLimit(const int limit)
2590 {
2591     const int cleanValue = cleanLimitValue(limit);
2592     if (cleanValue == downloadLimit())
2593         return;
2594
2595     m_downloadLimit = cleanValue;
2596     m_nativeHandle.set_download_limit(m_downloadLimit);
2597     m_session->handleTorrentNeedSaveResumeData(this);
2598 }
2599
2600 void TorrentImpl::setSuperSeeding(const bool enable)
2601 {
2602     if (enable == superSeeding())
2603         return;
2604
2605     if (enable)
2606         m_nativeHandle.set_flags(lt::torrent_flags::super_seeding);
2607     else
2608         m_nativeHandle.unset_flags(lt::torrent_flags::super_seeding);
2609
2610     m_session->handleTorrentNeedSaveResumeData(this);
2611 }
2612
2613 void TorrentImpl::setDHTDisabled(const bool disable)
2614 {
2615     if (disable == isDHTDisabled())
2616         return;
2617
2618     if (disable)
2619         m_nativeHandle.set_flags(lt::torrent_flags::disable_dht);
2620     else
2621         m_nativeHandle.unset_flags(lt::torrent_flags::disable_dht);
2622
2623     m_session->handleTorrentNeedSaveResumeData(this);
2624 }
2625
2626 void TorrentImpl::setPEXDisabled(const bool disable)
2627 {
2628     if (disable == isPEXDisabled())
2629         return;
2630
2631     if (disable)
2632         m_nativeHandle.set_flags(lt::torrent_flags::disable_pex);
2633     else
2634         m_nativeHandle.unset_flags(lt::torrent_flags::disable_pex);
2635
2636     m_session->handleTorrentNeedSaveResumeData(this);
2637 }
2638
2639 void TorrentImpl::setLSDDisabled(const bool disable)
2640 {
2641     if (disable == isLSDDisabled())
2642         return;
2643
2644     if (disable)
2645         m_nativeHandle.set_flags(lt::torrent_flags::disable_lsd);
2646     else
2647         m_nativeHandle.unset_flags(lt::torrent_flags::disable_lsd);
2648
2649     m_session->handleTorrentNeedSaveResumeData(this);
2650 }
2651
2652 void TorrentImpl::flushCache() const
2653 {
2654     m_nativeHandle.flush_cache();
2655 }
2656
2657 QString TorrentImpl::createMagnetURI() const
2658 {
2659     QString ret = u"magnet:?"_s;
2660
2661     const SHA1Hash infoHash1 = infoHash().v1();
2662     if (infoHash1.isValid())
2663     {
2664         ret += u"xt=urn:btih:" + infoHash1.toString();
2665     }
2666
2667     const SHA256Hash infoHash2 = infoHash().v2();
2668     if (infoHash2.isValid())
2669     {
2670         if (infoHash1.isValid())
2671             ret += u'&';
2672         ret += u"xt=urn:btmh:1220" + infoHash2.toString();
2673     }
2674
2675     const QString displayName = name();
2676     if (displayName != id().toString())
2677     {
2678         ret += u"&dn=" + QString::fromLatin1(QUrl::toPercentEncoding(displayName));
2679     }
2680
2681     for (const TrackerEntry &tracker : asConst(trackers()))
2682     {
2683         ret += u"&tr=" + QString::fromLatin1(QUrl::toPercentEncoding(tracker.url));
2684     }
2685
2686     for (const QUrl &urlSeed : asConst(urlSeeds()))
2687     {
2688         ret += u"&ws=" + QString::fromLatin1(urlSeed.toEncoded());
2689     }
2690
2691     return ret;
2692 }
2693
2694 nonstd::expected<lt::entry, QString> TorrentImpl::exportTorrent() const
2695 {
2696     if (!hasMetadata())
2697         return nonstd::make_unexpected(tr("Missing metadata"));
2698
2699     try
2700     {
2701 #ifdef QBT_USES_LIBTORRENT2
2702         const std::shared_ptr<lt::torrent_info> completeTorrentInfo = m_nativeHandle.torrent_file_with_hashes();
2703         const std::shared_ptr<lt::torrent_info> torrentInfo = (completeTorrentInfo ? completeTorrentInfo : info().nativeInfo());
2704 #else
2705         const std::shared_ptr<lt::torrent_info> torrentInfo = info().nativeInfo();
2706 #endif
2707         lt::create_torrent creator {*torrentInfo};
2708
2709         for (const TrackerEntry &entry : asConst(trackers()))
2710             creator.add_tracker(entry.url.toStdString(), entry.tier);
2711
2712         return creator.generate();
2713     }
2714     catch (const lt::system_error &err)
2715     {
2716         return nonstd::make_unexpected(QString::fromLocal8Bit(err.what()));
2717     }
2718 }
2719
2720 nonstd::expected<QByteArray, QString> TorrentImpl::exportToBuffer() const
2721 {
2722     const nonstd::expected<lt::entry, QString> preparationResult = exportTorrent();
2723     if (!preparationResult)
2724         return preparationResult.get_unexpected();
2725
2726     // usually torrent size should be smaller than 1 MB,
2727     // however there are >100 MB v2/hybrid torrent files out in the wild
2728     QByteArray buffer;
2729     buffer.reserve(1024 * 1024);
2730     lt::bencode(std::back_inserter(buffer), preparationResult.value());
2731     return buffer;
2732 }
2733
2734 nonstd::expected<void, QString> TorrentImpl::exportToFile(const Path &path) const
2735 {
2736     const nonstd::expected<lt::entry, QString> preparationResult = exportTorrent();
2737     if (!preparationResult)
2738         return preparationResult.get_unexpected();
2739
2740     const nonstd::expected<void, QString> saveResult = Utils::IO::saveToFile(path, preparationResult.value());
2741     if (!saveResult)
2742         return saveResult.get_unexpected();
2743
2744     return {};
2745 }
2746
2747 void TorrentImpl::fetchPeerInfo(std::function<void (QVector<PeerInfo>)> resultHandler) const
2748 {
2749     invokeAsync([nativeHandle = m_nativeHandle, allPieces = pieces()]() -> QVector<PeerInfo>
2750     {
2751         try
2752         {
2753             std::vector<lt::peer_info> nativePeers;
2754             nativeHandle.get_peer_info(nativePeers);
2755             QVector<PeerInfo> peers;
2756             peers.reserve(static_cast<decltype(peers)::size_type>(nativePeers.size()));
2757             for (const lt::peer_info &peer : nativePeers)
2758                 peers.append(PeerInfo(peer, allPieces));
2759             return peers;
2760         }
2761         catch (const std::exception &) {}
2762
2763         return {};
2764     }
2765     , std::move(resultHandler));
2766 }
2767
2768 void TorrentImpl::fetchURLSeeds(std::function<void (QVector<QUrl>)> resultHandler) const
2769 {
2770     invokeAsync([nativeHandle = m_nativeHandle]() -> QVector<QUrl>
2771     {
2772         try
2773         {
2774             const std::set<std::string> currentSeeds = nativeHandle.url_seeds();
2775             QVector<QUrl> urlSeeds;
2776             urlSeeds.reserve(static_cast<decltype(urlSeeds)::size_type>(currentSeeds.size()));
2777             for (const std::string &urlSeed : currentSeeds)
2778                 urlSeeds.append(QString::fromStdString(urlSeed));
2779             return urlSeeds;
2780         }
2781         catch (const std::exception &) {}
2782
2783         return {};
2784     }
2785     , std::move(resultHandler));
2786 }
2787
2788 void TorrentImpl::fetchPieceAvailability(std::function<void (QVector<int>)> resultHandler) const
2789 {
2790     invokeAsync([nativeHandle = m_nativeHandle]() -> QVector<int>
2791     {
2792         try
2793         {
2794             std::vector<int> piecesAvailability;
2795             nativeHandle.piece_availability(piecesAvailability);
2796             return QVector<int>(piecesAvailability.cbegin(), piecesAvailability.cend());
2797         }
2798         catch (const std::exception &) {}
2799
2800         return {};
2801     }
2802     , std::move(resultHandler));
2803 }
2804
2805 void TorrentImpl::fetchDownloadingPieces(std::function<void (QBitArray)> resultHandler) const
2806 {
2807     invokeAsync([nativeHandle = m_nativeHandle, torrentInfo = m_torrentInfo]() -> QBitArray
2808     {
2809         try
2810         {
2811 #ifdef QBT_USES_LIBTORRENT2
2812             const std::vector<lt::partial_piece_info> queue = nativeHandle.get_download_queue();
2813 #else
2814             std::vector<lt::partial_piece_info> queue;
2815             nativeHandle.get_download_queue(queue);
2816 #endif
2817             QBitArray result;
2818             result.resize(torrentInfo.piecesCount());
2819             for (const lt::partial_piece_info &info : queue)
2820                 result.setBit(LT::toUnderlyingType(info.piece_index));
2821             return result;
2822         }
2823         catch (const std::exception &) {}
2824
2825         return {};
2826     }
2827     , std::move(resultHandler));
2828 }
2829
2830 void TorrentImpl::fetchAvailableFileFractions(std::function<void (QVector<qreal>)> resultHandler) const
2831 {
2832     invokeAsync([nativeHandle = m_nativeHandle, torrentInfo = m_torrentInfo]() -> QVector<qreal>
2833     {
2834         if (!torrentInfo.isValid() || (torrentInfo.filesCount() <= 0))
2835             return {};
2836
2837         try
2838         {
2839             std::vector<int> piecesAvailability;
2840             nativeHandle.piece_availability(piecesAvailability);
2841             const int filesCount = torrentInfo.filesCount();
2842             // libtorrent returns empty array for seeding only torrents
2843             if (piecesAvailability.empty())
2844                 return QVector<qreal>(filesCount, -1);
2845
2846             QVector<qreal> result;
2847             result.reserve(filesCount);
2848             for (int i = 0; i < filesCount; ++i)
2849             {
2850                 const TorrentInfo::PieceRange filePieces = torrentInfo.filePieces(i);
2851
2852                 int availablePieces = 0;
2853                 for (const int piece : filePieces)
2854                     availablePieces += (piecesAvailability[piece] > 0) ? 1 : 0;
2855
2856                 const qreal availability = filePieces.isEmpty()
2857                         ? 1  // the file has no pieces, so it is available by default
2858                         : static_cast<qreal>(availablePieces) / filePieces.size();
2859                 result.append(availability);
2860             }
2861             return result;
2862         }
2863         catch (const std::exception &) {}
2864
2865         return {};
2866     }
2867     , std::move(resultHandler));
2868 }
2869
2870 void TorrentImpl::prioritizeFiles(const QVector<DownloadPriority> &priorities)
2871 {
2872     if (!hasMetadata())
2873         return;
2874
2875     Q_ASSERT(priorities.size() == filesCount());
2876
2877     // Reset 'm_hasSeedStatus' if needed in order to react again to
2878     // 'torrent_finished_alert' and eg show tray notifications
2879     const QVector<DownloadPriority> oldPriorities = filePriorities();
2880     for (int i = 0; i < oldPriorities.size(); ++i)
2881     {
2882         if ((oldPriorities[i] == DownloadPriority::Ignored)
2883             && (priorities[i] > DownloadPriority::Ignored)
2884             && !m_completedFiles.at(i))
2885         {
2886             m_hasFinishedStatus = false;
2887             break;
2888         }
2889     }
2890
2891     const int internalFilesCount = m_torrentInfo.nativeInfo()->files().num_files(); // including .pad files
2892     auto nativePriorities = std::vector<lt::download_priority_t>(internalFilesCount, LT::toNative(DownloadPriority::Normal));
2893     const auto nativeIndexes = m_torrentInfo.nativeIndexes();
2894     for (int i = 0; i < priorities.size(); ++i)
2895         nativePriorities[LT::toUnderlyingType(nativeIndexes[i])] = LT::toNative(priorities[i]);
2896
2897     qDebug() << Q_FUNC_INFO << "Changing files priorities...";
2898     m_nativeHandle.prioritize_files(nativePriorities);
2899
2900     m_filePriorities = priorities;
2901     // Restore first/last piece first option if necessary
2902     if (m_hasFirstLastPiecePriority)
2903         applyFirstLastPiecePriority(true);
2904     manageActualFilePaths();
2905 }
2906
2907 QVector<qreal> TorrentImpl::availableFileFractions() const
2908 {
2909     Q_ASSERT(hasMetadata());
2910
2911     const int filesCount = this->filesCount();
2912     if (filesCount <= 0) return {};
2913
2914     const QVector<int> piecesAvailability = pieceAvailability();
2915     // libtorrent returns empty array for seeding only torrents
2916     if (piecesAvailability.empty()) return QVector<qreal>(filesCount, -1);
2917
2918     QVector<qreal> res;
2919     res.reserve(filesCount);
2920     for (int i = 0; i < filesCount; ++i)
2921     {
2922         const TorrentInfo::PieceRange filePieces = m_torrentInfo.filePieces(i);
2923
2924         int availablePieces = 0;
2925         for (const int piece : filePieces)
2926             availablePieces += (piecesAvailability[piece] > 0) ? 1 : 0;
2927
2928         const qreal availability = filePieces.isEmpty()
2929             ? 1  // the file has no pieces, so it is available by default
2930             : static_cast<qreal>(availablePieces) / filePieces.size();
2931         res.push_back(availability);
2932     }
2933     return res;
2934 }
2935
2936 template <typename Func, typename Callback>
2937 void TorrentImpl::invokeAsync(Func func, Callback resultHandler) const
2938 {
2939     m_session->invokeAsync([session = m_session
2940                            , func = std::move(func)
2941                            , resultHandler = std::move(resultHandler)
2942                            , thisTorrent = QPointer<const TorrentImpl>(this)]() mutable
2943     {
2944         session->invoke([result = func(), thisTorrent, resultHandler = std::move(resultHandler)]
2945         {
2946             if (thisTorrent)
2947                 resultHandler(result);
2948         });
2949     });
2950 }