src/base/torrentfileswatcher.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2021  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2010  Christian Kandeler, 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 "torrentfileswatcher.h"
  31
  32 #include <chrono>
  33
  34 #include <QtGlobal>
  35 #include <QDir>
  36 #include <QDirIterator>
  37 #include <QFile>
  38 #include <QFileSystemWatcher>
  39 #include <QJsonArray>
  40 #include <QJsonDocument>
  41 #include <QJsonObject>
  42 #include <QJsonValue>
  43 #include <QSaveFile>
  44 #include <QSet>
  45 #include <QTextStream>
  46 #include <QThread>
  47 #include <QTimer>
  48 #include <QVariant>
  49
  50 #include "base/algorithm.h"
  51 #include "base/bittorrent/magneturi.h"
  52 #include "base/bittorrent/torrentcontentlayout.h"
  53 #include "base/bittorrent/session.h"
  54 #include "base/bittorrent/torrent.h"
  55 #include "base/bittorrent/torrentinfo.h"
  56 #include "base/exceptions.h"
  57 #include "base/global.h"
  58 #include "base/logger.h"
  59 #include "base/profile.h"
  60 #include "base/settingsstorage.h"
  61 #include "base/tagset.h"
  62 #include "base/utils/fs.h"
  63 #include "base/utils/string.h"
  64
  65 using namespace std::chrono_literals;
  66
  67 const std::chrono::duration WATCH_INTERVAL = 10s;
  68 const int MAX_FAILED_RETRIES = 5;
  69 const QString CONF_FILE_NAME {QStringLiteral("watched_folders.json")};
  70
  71 const QString OPTION_ADDTORRENTPARAMS {QStringLiteral("add_torrent_params")};
  72 const QString OPTION_RECURSIVE {QStringLiteral("recursive")};
  73
  74 const QString PARAM_CATEGORY {QStringLiteral("category")};
  75 const QString PARAM_TAGS {QStringLiteral("tags")};
  76 const QString PARAM_SAVEPATH {QStringLiteral("save_path")};
  77 const QString PARAM_OPERATINGMODE {QStringLiteral("operating_mode")};
  78 const QString PARAM_STOPPED {QStringLiteral("stopped")};
  79 const QString PARAM_CONTENTLAYOUT {QStringLiteral("content_layout")};
  80 const QString PARAM_AUTOTMM {QStringLiteral("use_auto_tmm")};
  81 const QString PARAM_UPLOADLIMIT {QStringLiteral("upload_limit")};
  82 const QString PARAM_DOWNLOADLIMIT {QStringLiteral("download_limit")};
  83 const QString PARAM_SEEDINGTIMELIMIT {QStringLiteral("seeding_time_limit")};
  84 const QString PARAM_RATIOLIMIT {QStringLiteral("ratio_limit")};
  85
  86 namespace
  87 {
  88     TagSet parseTagSet(const QJsonArray &jsonArr)
  89     {
  90         TagSet tags;
  91         for (const QJsonValue &jsonVal : jsonArr)
  92             tags.insert(jsonVal.toString());
  93
  94         return tags;
  95     }
  96
  97     QJsonArray serializeTagSet(const TagSet &tags)
  98     {
  99         QJsonArray arr;
 100         for (const QString &tag : tags)
 101             arr.append(tag);
 102
 103         return arr;
 104     }
 105
 106     std::optional<bool> getOptionalBool(const QJsonObject &jsonObj, const QString &key)
 107     {
 108         const QJsonValue jsonVal = jsonObj.value(key);
 109         if (jsonVal.isUndefined() || jsonVal.isNull())
 110             return std::nullopt;
 111
 112         return jsonVal.toBool();
 113     }
 114
 115     template <typename Enum>
 116     std::optional<Enum> getOptionalEnum(const QJsonObject &jsonObj, const QString &key)
 117     {
 118         const QJsonValue jsonVal = jsonObj.value(key);
 119         if (jsonVal.isUndefined() || jsonVal.isNull())
 120             return std::nullopt;
 121
 122         return Utils::String::toEnum<Enum>(jsonVal.toString(), {});
 123     }
 124
 125     template <typename Enum>
 126     Enum getEnum(const QJsonObject &jsonObj, const QString &key)
 127     {
 128         const QJsonValue jsonVal = jsonObj.value(key);
 129         return Utils::String::toEnum<Enum>(jsonVal.toString(), {});
 130     }
 131
 132     BitTorrent::AddTorrentParams parseAddTorrentParams(const QJsonObject &jsonObj)
 133     {
 134         BitTorrent::AddTorrentParams params;
 135         params.category = jsonObj.value(PARAM_CATEGORY).toString();
 136         params.tags = parseTagSet(jsonObj.value(PARAM_TAGS).toArray());
 137         params.savePath = jsonObj.value(PARAM_SAVEPATH).toString();
 138         params.addForced = (getEnum<BitTorrent::TorrentOperatingMode>(jsonObj, PARAM_OPERATINGMODE) == BitTorrent::TorrentOperatingMode::Forced);
 139         params.addPaused = getOptionalBool(jsonObj, PARAM_STOPPED);
 140         params.contentLayout = getOptionalEnum<BitTorrent::TorrentContentLayout>(jsonObj, PARAM_CONTENTLAYOUT);
 141         params.useAutoTMM = getOptionalBool(jsonObj, PARAM_AUTOTMM);
 142         params.uploadLimit = jsonObj.value(PARAM_UPLOADLIMIT).toInt(-1);
 143         params.downloadLimit = jsonObj.value(PARAM_DOWNLOADLIMIT).toInt(-1);
 144         params.seedingTimeLimit = jsonObj.value(PARAM_SEEDINGTIMELIMIT).toInt(BitTorrent::Torrent::USE_GLOBAL_SEEDING_TIME);
 145         params.ratioLimit = jsonObj.value(PARAM_RATIOLIMIT).toDouble(BitTorrent::Torrent::USE_GLOBAL_RATIO);
 146
 147         return params;
 148     }
 149
 150     QJsonObject serializeAddTorrentParams(const BitTorrent::AddTorrentParams &params)
 151     {
 152         QJsonObject jsonObj {
 153             {PARAM_CATEGORY, params.category},
 154             {PARAM_TAGS, serializeTagSet(params.tags)},
 155             {PARAM_SAVEPATH, params.savePath},
 156             {PARAM_OPERATINGMODE, Utils::String::fromEnum(params.addForced
 157                 ? BitTorrent::TorrentOperatingMode::Forced : BitTorrent::TorrentOperatingMode::AutoManaged)},
 158             {PARAM_UPLOADLIMIT, params.uploadLimit},
 159             {PARAM_DOWNLOADLIMIT, params.downloadLimit},
 160             {PARAM_SEEDINGTIMELIMIT, params.seedingTimeLimit},
 161             {PARAM_RATIOLIMIT, params.ratioLimit}
 162         };
 163
 164         if (params.addPaused)
 165             jsonObj[PARAM_STOPPED] = *params.addPaused;
 166         if (params.contentLayout)
 167             jsonObj[PARAM_CONTENTLAYOUT] = Utils::String::fromEnum(*params.contentLayout);
 168         if (params.useAutoTMM)
 169             jsonObj[PARAM_AUTOTMM] = *params.useAutoTMM;
 170
 171         return jsonObj;
 172     }
 173
 174     TorrentFilesWatcher::WatchedFolderOptions parseWatchedFolderOptions(const QJsonObject &jsonObj)
 175     {
 176         TorrentFilesWatcher::WatchedFolderOptions options;
 177         options.addTorrentParams = parseAddTorrentParams(jsonObj.value(OPTION_ADDTORRENTPARAMS).toObject());
 178         options.recursive = jsonObj.value(OPTION_RECURSIVE).toBool();
 179
 180         return options;
 181     }
 182
 183     QJsonObject serializeWatchedFolderOptions(const TorrentFilesWatcher::WatchedFolderOptions &options)
 184     {
 185         return {
 186             {OPTION_ADDTORRENTPARAMS, serializeAddTorrentParams(options.addTorrentParams)},
 187             {OPTION_RECURSIVE, options.recursive}
 188         };
 189     }
 190 }
 191
 192 class TorrentFilesWatcher::Worker final : public QObject
 193 {
 194     Q_OBJECT
 195     Q_DISABLE_COPY_MOVE(Worker)
 196
 197 public:
 198     Worker();
 199
 200 public slots:
 201     void setWatchedFolder(const QString &path, const TorrentFilesWatcher::WatchedFolderOptions &options);
 202     void removeWatchedFolder(const QString &path);
 203
 204 signals:
 205     void magnetFound(const BitTorrent::MagnetUri &magnetURI, const BitTorrent::AddTorrentParams &addTorrentParams);
 206     void torrentFound(const BitTorrent::TorrentInfo &torrentInfo, const BitTorrent::AddTorrentParams &addTorrentParams);
 207
 208 private:
 209     void onTimeout();
 210     void scheduleWatchedFolderProcessing(const QString &path);
 211     void processWatchedFolder(const QString &path);
 212     void processFolder(const QString &path, const QString &watchedFolderPath, const TorrentFilesWatcher::WatchedFolderOptions &options);
 213     void processFailedTorrents();
 214     void addWatchedFolder(const QString &watchedFolderID, const TorrentFilesWatcher::WatchedFolderOptions &options);
 215     void updateWatchedFolder(const QString &watchedFolderID, const TorrentFilesWatcher::WatchedFolderOptions &options);
 216
 217     QFileSystemWatcher *m_watcher = nullptr;
 218     QTimer *m_watchTimer = nullptr;
 219     QHash<QString, TorrentFilesWatcher::WatchedFolderOptions> m_watchedFolders;
 220     QSet<QString> m_watchedByTimeoutFolders;
 221
 222     // Failed torrents
 223     QTimer *m_retryTorrentTimer = nullptr;
 224     QHash<QString, QHash<QString, int>> m_failedTorrents;
 225 };
 226
 227 TorrentFilesWatcher *TorrentFilesWatcher::m_instance = nullptr;
 228
 229 void TorrentFilesWatcher::initInstance()
 230 {
 231     if (!m_instance)
 232         m_instance = new TorrentFilesWatcher;
 233 }
 234
 235 void TorrentFilesWatcher::freeInstance()
 236 {
 237     delete m_instance;
 238     m_instance = nullptr;
 239 }
 240
 241 TorrentFilesWatcher *TorrentFilesWatcher::instance()
 242 {
 243     return m_instance;
 244 }
 245
 246 TorrentFilesWatcher::TorrentFilesWatcher(QObject *parent)
 247     : QObject {parent}
 248     , m_ioThread {new QThread(this)}
 249     , m_asyncWorker {new TorrentFilesWatcher::Worker}
 250 {
 251     connect(m_asyncWorker, &TorrentFilesWatcher::Worker::magnetFound, this, &TorrentFilesWatcher::onMagnetFound);
 252     connect(m_asyncWorker, &TorrentFilesWatcher::Worker::torrentFound, this, &TorrentFilesWatcher::onTorrentFound);
 253
 254     m_asyncWorker->moveToThread(m_ioThread);
 255     m_ioThread->start();
 256
 257     load();
 258 }
 259
 260 TorrentFilesWatcher::~TorrentFilesWatcher()
 261 {
 262     m_ioThread->quit();
 263     m_ioThread->wait();
 264     delete m_asyncWorker;
 265 }
 266
 267 QString TorrentFilesWatcher::makeCleanPath(const QString &path)
 268 {
 269     if (path.isEmpty())
 270         throw InvalidArgument(tr("Watched folder path cannot be empty."));
 271
 272     if (QDir::isRelativePath(path))
 273         throw InvalidArgument(tr("Watched folder path cannot be relative."));
 274
 275     return QDir::cleanPath(path);
 276 }
 277
 278 void TorrentFilesWatcher::load()
 279 {
 280     QFile confFile {QDir(specialFolderLocation(SpecialFolder::Config)).absoluteFilePath(CONF_FILE_NAME)};
 281     if (!confFile.exists())
 282     {
 283         loadLegacy();
 284         return;
 285     }
 286
 287     if (!confFile.open(QFile::ReadOnly))
 288     {
 289         LogMsg(tr("Couldn't load Watched Folders configuration from %1. Error: %2")
 290             .arg(confFile.fileName(), confFile.errorString()), Log::WARNING);
 291         return;
 292     }
 293
 294     QJsonParseError jsonError;
 295     const QJsonDocument jsonDoc = QJsonDocument::fromJson(confFile.readAll(), &jsonError);
 296     if (jsonError.error != QJsonParseError::NoError)
 297     {
 298         LogMsg(tr("Couldn't parse Watched Folders configuration from %1. Error: %2")
 299             .arg(confFile.fileName(), jsonError.errorString()), Log::WARNING);
 300         return;
 301     }
 302
 303     if (!jsonDoc.isObject())
 304     {
 305         LogMsg(tr("Couldn't load Watched Folders configuration from %1. Invalid data format.")
 306             .arg(confFile.fileName()), Log::WARNING);
 307         return;
 308     }
 309
 310     const QJsonObject jsonObj = jsonDoc.object();
 311     for (auto it = jsonObj.constBegin(); it != jsonObj.constEnd(); ++it)
 312     {
 313         const QString &watchedFolder = it.key();
 314         const WatchedFolderOptions options = parseWatchedFolderOptions(it.value().toObject());
 315         try
 316         {
 317             doSetWatchedFolder(watchedFolder, options);
 318         }
 319         catch (const InvalidArgument &err)
 320         {
 321             LogMsg(err.message(), Log::WARNING);
 322         }
 323     }
 324 }
 325
 326 void TorrentFilesWatcher::loadLegacy()
 327 {
 328     const auto dirs = SettingsStorage::instance()->loadValue<QVariantHash>("Preferences/Downloads/ScanDirsV2");
 329
 330     for (auto i = dirs.cbegin(); i != dirs.cend(); ++i)
 331     {
 332         const QString watchedFolder = i.key();
 333         BitTorrent::AddTorrentParams params;
 334         if (i.value().type() == QVariant::Int)
 335         {
 336             if (i.value().toInt() == 0)
 337             {
 338                 params.savePath = watchedFolder;
 339                 params.useAutoTMM = false;
 340             }
 341         }
 342         else
 343         {
 344             const QString customSavePath = i.value().toString();
 345             params.savePath = customSavePath;
 346             params.useAutoTMM = false;
 347         }
 348
 349         try
 350         {
 351             doSetWatchedFolder(watchedFolder, {params, false});
 352         }
 353         catch (const InvalidArgument &err)
 354         {
 355             LogMsg(err.message(), Log::WARNING);
 356         }
 357     }
 358
 359     store();
 360     SettingsStorage::instance()->removeValue("Preferences/Downloads/ScanDirsV2");
 361 }
 362
 363 void TorrentFilesWatcher::store() const
 364 {
 365     QJsonObject jsonObj;
 366     for (auto it = m_watchedFolders.cbegin(); it != m_watchedFolders.cend(); ++it)
 367     {
 368         const QString &watchedFolder = it.key();
 369         const WatchedFolderOptions &options = it.value();
 370         jsonObj[watchedFolder] = serializeWatchedFolderOptions(options);
 371     }
 372
 373     const QByteArray data = QJsonDocument(jsonObj).toJson();
 374
 375     QSaveFile confFile {QDir(specialFolderLocation(SpecialFolder::Config)).absoluteFilePath(CONF_FILE_NAME)};
 376     if (!confFile.open(QIODevice::WriteOnly) || (confFile.write(data) != data.size()) || !confFile.commit())
 377     {
 378         LogMsg(tr("Couldn't store Watched Folders configuration to %1. Error: %2")
 379             .arg(confFile.fileName(), confFile.errorString()), Log::WARNING);
 380     }
 381 }
 382
 383 QHash<QString, TorrentFilesWatcher::WatchedFolderOptions> TorrentFilesWatcher::folders() const
 384 {
 385     return m_watchedFolders;
 386 }
 387
 388 void TorrentFilesWatcher::setWatchedFolder(const QString &path, const WatchedFolderOptions &options)
 389 {
 390     doSetWatchedFolder(path, options);
 391     store();
 392 }
 393
 394 void TorrentFilesWatcher::doSetWatchedFolder(const QString &path, const WatchedFolderOptions &options)
 395 {
 396     const QString cleanPath = makeCleanPath(path);
 397     m_watchedFolders[cleanPath] = options;
 398
 399     QMetaObject::invokeMethod(m_asyncWorker, [this, path, options]()
 400     {
 401         m_asyncWorker->setWatchedFolder(path, options);
 402     });
 403
 404     emit watchedFolderSet(cleanPath, options);
 405 }
 406
 407 void TorrentFilesWatcher::removeWatchedFolder(const QString &path)
 408 {
 409     const QString cleanPath = makeCleanPath(path);
 410     if (m_watchedFolders.remove(cleanPath))
 411     {
 412         QMetaObject::invokeMethod(m_asyncWorker, [this, cleanPath]()
 413         {
 414             m_asyncWorker->removeWatchedFolder(cleanPath);
 415         });
 416
 417         emit watchedFolderRemoved(cleanPath);
 418
 419         store();
 420     }
 421 }
 422
 423 void TorrentFilesWatcher::onMagnetFound(const BitTorrent::MagnetUri &magnetURI
 424                                          , const BitTorrent::AddTorrentParams &addTorrentParams)
 425 {
 426     BitTorrent::Session::instance()->addTorrent(magnetURI, addTorrentParams);
 427 }
 428
 429 void TorrentFilesWatcher::onTorrentFound(const BitTorrent::TorrentInfo &torrentInfo
 430                                          , const BitTorrent::AddTorrentParams &addTorrentParams)
 431 {
 432     BitTorrent::Session::instance()->addTorrent(torrentInfo, addTorrentParams);
 433 }
 434
 435 TorrentFilesWatcher::Worker::Worker()
 436     : m_watcher {new QFileSystemWatcher(this)}
 437     , m_watchTimer {new QTimer(this)}
 438     , m_retryTorrentTimer {new QTimer(this)}
 439 {
 440     connect(m_watcher, &QFileSystemWatcher::directoryChanged, this, &Worker::scheduleWatchedFolderProcessing);
 441     connect(m_watchTimer, &QTimer::timeout, this, &Worker::onTimeout);
 442
 443     connect(m_retryTorrentTimer, &QTimer::timeout, this, &Worker::processFailedTorrents);
 444 }
 445
 446 void TorrentFilesWatcher::Worker::onTimeout()
 447 {
 448     for (const QString &path : asConst(m_watchedByTimeoutFolders))
 449         processWatchedFolder(path);
 450 }
 451
 452 void TorrentFilesWatcher::Worker::setWatchedFolder(const QString &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 453 {
 454     if (m_watchedFolders.contains(path))
 455         updateWatchedFolder(path, options);
 456     else
 457         addWatchedFolder(path, options);
 458 }
 459
 460 void TorrentFilesWatcher::Worker::removeWatchedFolder(const QString &path)
 461 {
 462     m_watchedFolders.remove(path);
 463
 464     m_watcher->removePath(path);
 465     m_watchedByTimeoutFolders.remove(path);
 466     if (m_watchedByTimeoutFolders.isEmpty())
 467         m_watchTimer->stop();
 468
 469     m_failedTorrents.remove(path);
 470     if (m_failedTorrents.isEmpty())
 471         m_retryTorrentTimer->stop();
 472 }
 473
 474 void TorrentFilesWatcher::Worker::scheduleWatchedFolderProcessing(const QString &path)
 475 {
 476     QTimer::singleShot(2000, this, [this, path]()
 477     {
 478         processWatchedFolder(path);
 479     });
 480 }
 481
 482 void TorrentFilesWatcher::Worker::processWatchedFolder(const QString &path)
 483 {
 484     const TorrentFilesWatcher::WatchedFolderOptions options = m_watchedFolders.value(path);
 485     processFolder(path, path, options);
 486
 487     if (!m_failedTorrents.empty() && !m_retryTorrentTimer->isActive())
 488         m_retryTorrentTimer->start(WATCH_INTERVAL);
 489 }
 490
 491 void TorrentFilesWatcher::Worker::processFolder(const QString &path, const QString &watchedFolderPath
 492                                               , const TorrentFilesWatcher::WatchedFolderOptions &options)
 493 {
 494     const QDir watchedDir {watchedFolderPath};
 495
 496     QDirIterator dirIter {path, {"*.torrent", "*.magnet"}, QDir::Files};
 497     while (dirIter.hasNext())
 498     {
 499         const QString filePath = dirIter.next();
 500         BitTorrent::AddTorrentParams addTorrentParams = options.addTorrentParams;
 501         if (path != watchedFolderPath)
 502         {
 503             const QString subdirPath = watchedDir.relativeFilePath(path);
 504             addTorrentParams.savePath = QDir::cleanPath(QDir(addTorrentParams.savePath).filePath(subdirPath));
 505         }
 506
 507         if (filePath.endsWith(QLatin1String(".magnet"), Qt::CaseInsensitive))
 508         {
 509             QFile file {filePath};
 510             if (file.open(QIODevice::ReadOnly | QIODevice::Text))
 511             {
 512                 QTextStream str {&file};
 513                 while (!str.atEnd())
 514                     emit magnetFound(BitTorrent::MagnetUri(str.readLine()), addTorrentParams);
 515
 516                 file.close();
 517                 Utils::Fs::forceRemove(filePath);
 518             }
 519             else
 520             {
 521                 LogMsg(tr("Failed to open magnet file: %1").arg(file.errorString()));
 522             }
 523         }
 524         else
 525         {
 526             const auto torrentInfo = BitTorrent::TorrentInfo::loadFromFile(filePath);
 527             if (torrentInfo.isValid())
 528             {
 529                 emit torrentFound(torrentInfo, addTorrentParams);
 530                 Utils::Fs::forceRemove(filePath);
 531             }
 532             else
 533             {
 534                 if (!m_failedTorrents.value(path).contains(filePath))
 535                 {
 536                     m_failedTorrents[path][filePath] = 0;
 537                 }
 538             }
 539         }
 540     }
 541
 542     if (options.recursive)
 543     {
 544         QDirIterator dirIter {path, (QDir::Dirs | QDir::NoDot | QDir::NoDotDot)};
 545         while (dirIter.hasNext())
 546         {
 547             const QString folderPath = dirIter.next();
 548             // Skip processing of subdirectory that is explicitly set as watched folder
 549             if (!m_watchedFolders.contains(folderPath))
 550                 processFolder(folderPath, watchedFolderPath, options);
 551         }
 552     }
 553 }
 554
 555 void TorrentFilesWatcher::Worker::processFailedTorrents()
 556 {
 557     // Check which torrents are still partial
 558     Algorithm::removeIf(m_failedTorrents, [this](const QString &watchedFolderPath, QHash<QString, int> &partialTorrents)
 559     {
 560         const QDir dir {watchedFolderPath};
 561         const TorrentFilesWatcher::WatchedFolderOptions options = m_watchedFolders.value(watchedFolderPath);
 562         Algorithm::removeIf(partialTorrents, [this, &dir, &options](const QString &torrentPath, int &value)
 563         {
 564             if (!QFile::exists(torrentPath))
 565                 return true;
 566
 567             const auto torrentInfo = BitTorrent::TorrentInfo::loadFromFile(torrentPath);
 568             if (torrentInfo.isValid())
 569             {
 570                 BitTorrent::AddTorrentParams addTorrentParams = options.addTorrentParams;
 571                 const QString exactDirPath = QFileInfo(torrentPath).canonicalPath();
 572                 if (exactDirPath != dir.path())
 573                 {
 574                     const QString subdirPath = dir.relativeFilePath(exactDirPath);
 575                     addTorrentParams.savePath = QDir(addTorrentParams.savePath).filePath(subdirPath);
 576                 }
 577
 578                 emit torrentFound(torrentInfo, addTorrentParams);
 579                 Utils::Fs::forceRemove(torrentPath);
 580
 581                 return true;
 582             }
 583
 584             if (value >= MAX_FAILED_RETRIES)
 585             {
 586                 LogMsg(tr("Rejecting failed torrent file: %1").arg(torrentPath));
 587                 QFile::rename(torrentPath, torrentPath + ".qbt_rejected");
 588                 return true;
 589             }
 590
 591             ++value;
 592             return false;
 593         });
 594
 595         if (partialTorrents.isEmpty())
 596             return true;
 597
 598         return false;
 599     });
 600
 601     // Stop the partial timer if necessary
 602     if (m_failedTorrents.empty())
 603         m_retryTorrentTimer->stop();
 604     else
 605         m_retryTorrentTimer->start(WATCH_INTERVAL);
 606 }
 607
 608 void TorrentFilesWatcher::Worker::addWatchedFolder(const QString &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 609 {
 610 #if !defined Q_OS_HAIKU
 611     // Check if the path points to a network file system or not
 612     if (Utils::Fs::isNetworkFileSystem(path) || options.recursive)
 613 #else
 614     if (options.recursive)
 615 #endif
 616     {
 617         m_watchedByTimeoutFolders.insert(path);
 618         if (!m_watchTimer->isActive())
 619             m_watchTimer->start(WATCH_INTERVAL);
 620     }
 621     else
 622     {
 623         m_watcher->addPath(path);
 624         scheduleWatchedFolderProcessing(path);
 625     }
 626
 627     m_watchedFolders[path] = options;
 628
 629     LogMsg(tr("Watching folder: \"%1\"").arg(Utils::Fs::toNativePath(path)));
 630 }
 631
 632 void TorrentFilesWatcher::Worker::updateWatchedFolder(const QString &path, const TorrentFilesWatcher::WatchedFolderOptions &options)
 633 {
 634     const bool recursiveModeChanged = (m_watchedFolders[path].recursive != options.recursive);
 635 #if !defined Q_OS_HAIKU
 636     if (recursiveModeChanged && !Utils::Fs::isNetworkFileSystem(path))
 637 #else
 638     if (recursiveModeChanged)
 639 #endif
 640     {
 641         if (options.recursive)
 642         {
 643             m_watcher->removePath(path);
 644
 645             m_watchedByTimeoutFolders.insert(path);
 646             if (!m_watchTimer->isActive())
 647                 m_watchTimer->start(WATCH_INTERVAL);
 648         }
 649         else
 650         {
 651             m_watchedByTimeoutFolders.remove(path);
 652             if (m_watchedByTimeoutFolders.isEmpty())
 653                 m_watchTimer->stop();
 654
 655             m_watcher->addPath(path);
 656             scheduleWatchedFolderProcessing(path);
 657         }
 658     }
 659
 660     m_watchedFolders[path] = options;
 661 }
 662
 663 #include "torrentfileswatcher.moc"