- Rewrited torrent resume code to make it cleaner and more generic

* magnet URI support should be easy to implement now
Warning: Since a lot of code was rewrited, some bugs may have been introduced

Changelog

@@ -1,3 +1,6 @@
+* Unknown - Christophe Dumez <chris@qbittorrent.org> - v1.5.0
+    - BUGFIX: torrent resume code rewrited
+
 * Thu Aug 13 2009 - Christophe Dumez <chris@qbittorrent.org> - v1.4.0
     - FEATURE: Display swarm information in lists
     - FEATURE: Allow to define temporary download folder

src/GUI.cpp

@@ -67,6 +67,7 @@
 #include <stdlib.h>
 #include "console_imp.h"
 #include "httpserver.h"
+#include "torrentPersistentData.h"
 
 using namespace libtorrent;
 
@@ -171,7 +172,7 @@ GUI::GUI(QWidget *parent, QStringList torrentCmdLine) : QMainWindow(parent), dis
   // Configure BT session according to options
   configureSession(true);
   // Resume unfinished torrents
-  BTSession->resumeUnfinishedTorrents();
+  BTSession->startUpTorrents();
   downloadingTorrentTab->loadLastSortedColumn();
   finishedTorrentTab->loadLastSortedColumn();
   // Add torrent given on command line
@@ -378,7 +379,7 @@ void GUI::finishedTorrent(QTorrentHandle& h) const {
     qDebug("In GUI, a torrent has finished");
     QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent"));
     bool show_msg = true;
-  if(QFile::exists(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+h.hash()+".finished"))
+    if(TorrentPersistentData::isSeed(h.hash()))
       show_msg = false;
     QString fileName = h.name();
     bool useNotificationBalloons = settings.value(QString::fromUtf8("Preferences/General/NotificationBaloons"), true).toBool();
@@ -424,8 +425,8 @@ void GUI::checkedTorrent(QTorrentHandle& h) const {
       finishedTorrentTab->addTorrent(h.hash());
     } else {
       // Move torrent back to download list (if necessary)
-        if(QFile::exists(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+h.hash()+".finished")) {
+      if(TorrentPersistentData::isSeed(h.hash())) {
-            QFile::remove(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+h.hash()+".finished");
+        TorrentPersistentData::saveSeedStatus(h);
         finishedTorrentTab->deleteTorrent(h.hash());
         downloadingTorrentTab->addTorrent(h.hash());
       }
@@ -1428,7 +1429,7 @@ void GUI::updateLists(bool force) {
           if(downloadingTorrentTab->updateTorrent(h)) {
             // Torrent was added, we may need to remove it from finished tab
             finishedTorrentTab->deleteTorrent(h.hash());
-                    QFile::remove(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+h.hash()+".finished");
+            TorrentPersistentData::saveSeedStatus(h);
           }
         }
       }

src/arborescence.h

@@ -199,7 +199,7 @@ class arborescence {
       Q_ASSERT(root->getSize() == t->total_size());
     }
 
-    arborescence(torrent_info const& t, std::vector<size_type> fp, int *prioritiesTab) {
+    arborescence(torrent_info const& t, std::vector<size_type> fp, std::vector<int> files_priority) {
       torrent_info::file_iterator fi = t.begin_files();
       if(t.num_files() > 1) {
         qDebug("More than one file in the torrent, setting a folder as root");
@@ -207,13 +207,13 @@ class arborescence {
       } else {
         // XXX: Will crash if there is no file in torrent
         qDebug("one file in the torrent, setting it as root with index 0");
-        root = new torrent_file(0, misc::toQString(t.name()), false, fi->size, 0, ((double)fp[0])/t.file_at(0).size, prioritiesTab[0]);
+        root = new torrent_file(0, misc::toQString(t.name()), false, fi->size, 0, ((double)fp[0])/t.file_at(0).size, files_priority.at(0));
         return;
       }
       int i = 0;
       while(fi != t.end_files()) {
         QString path = QDir::cleanPath(misc::toQString(fi->path.string()));
-        addFile(path, fi->size, i, ((double)fp[i])/t.file_at(i).size, prioritiesTab[i]);
+        addFile(path, fi->size, i, ((double)fp[i])/t.file_at(i).size, files_priority.at(i));
         fi++;
         ++i;
       }

src/bittorrent.cpp

@@ -40,6 +40,7 @@
 #include "misc.h"
 #include "downloadThread.h"
 #include "filterParserThread.h"
+#include "torrentPersistentData.h"
 #include <libtorrent/extensions/ut_metadata.hpp>
 #include <libtorrent/extensions/ut_pex.hpp>
 #include <libtorrent/extensions/smart_ban.hpp>
@@ -281,6 +282,7 @@ void bittorrent::deleteTorrent(QString hash, bool permanent) {
   foreach(const QString &file, files) {
     torrentBackup.remove(file);
   }
+  TorrentPersistentData::deletePersistentData(hash);
   // Remove tracker errors
   trackersErrors.remove(hash);
   if(permanent)
@@ -333,11 +335,7 @@ void bittorrent::resumeTorrent(QString hash) {
 }
 
 void bittorrent::loadWebSeeds(QString hash) {
-  QFile urlseeds_file(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".urlseeds");
+  QVariantList url_seeds = TorrentPersistentData::getUrlSeeds(hash);
-  if(!urlseeds_file.open(QIODevice::ReadOnly | QIODevice::Text)) return;
-  QByteArray urlseeds_lines = urlseeds_file.readAll();
-  urlseeds_file.close();
-  QList<QByteArray> url_seeds = urlseeds_lines.split('\n');
   QTorrentHandle h = getTorrentHandle(hash);
   // First remove from the torrent the url seeds that were deleted
   // in a previous session
@@ -352,7 +350,8 @@ void bittorrent::loadWebSeeds(QString hash) {
     h.remove_url_seed(existing_seed);
   }
   // Add the ones that were added in a previous session
-  foreach(const QByteArray &url_seed, url_seeds) {
+  foreach(const QVariant &var_url_seed, url_seeds) {
+    QString url_seed = var_url_seed.toString();
     if(!url_seed.isEmpty()) {
       // XXX: Should we check if it is already in the list before adding it
       // or is libtorrent clever enough to know
@@ -362,11 +361,12 @@ void bittorrent::loadWebSeeds(QString hash) {
 }
 
 // Add a torrent to the bittorrent session
-QTorrentHandle bittorrent::addTorrent(QString path, bool fromScanDir, QString from_url, bool) {
+QTorrentHandle bittorrent::addTorrent(QString path, bool fromScanDir, QString from_url, bool resumed) {
   QTorrentHandle h;
   bool fastResume=false;
   QDir torrentBackup(misc::qBittorrentPath() + "BT_backup");
-  QString file, dest_file;
+  QString file, dest_file, hash;
+  boost::intrusive_ptr<torrent_info> t;
 
   // Checking if BT_backup Dir exists
   // create it if it is not
@@ -382,8 +382,8 @@ QTorrentHandle bittorrent::addTorrent(QString path, bool fromScanDir, QString fr
     return h;
   }
   Q_ASSERT(!file.startsWith("http://", Qt::CaseInsensitive) && !file.startsWith("https://", Qt::CaseInsensitive) && !file.startsWith("ftp://", Qt::CaseInsensitive));
+
   qDebug("Adding %s to download list", file.toLocal8Bit().data());
-  boost::intrusive_ptr<torrent_info> t;
   try {
     // Getting torrent file informations
     t = new torrent_info(file.toLocal8Bit().data());
@@ -405,7 +405,7 @@ QTorrentHandle bittorrent::addTorrent(QString path, bool fromScanDir, QString fr
   }
   qDebug(" -> Hash: %s", misc::toString(t->info_hash()).c_str());
   qDebug(" -> Name: %s", t->name().c_str());
-  QString hash = misc::toQString(t->info_hash());
+  hash = misc::toQString(t->info_hash());
   if(file.startsWith(torrentBackup.path())) {
     QFileInfo fi(file);
     QString old_hash = fi.baseName();
@@ -436,21 +436,17 @@ QTorrentHandle bittorrent::addTorrent(QString path, bool fromScanDir, QString fr
   add_torrent_params p;
   //Getting fast resume data if existing
   std::vector<char> buf;
+  if(resumed) {
     qDebug("Trying to load fastresume data: %s", (torrentBackup.path()+QDir::separator()+hash+QString(".fastresume")).toLocal8Bit().data());
     if (load_file((torrentBackup.path()+QDir::separator()+hash+QString(".fastresume")).toLocal8Bit().data(), buf) == 0) {
       fastResume = true;
       p.resume_data = &buf;
       qDebug("Successfuly loaded");
     }
-  QString savePath = getSavePath(hash);
-  // Save save_path to hard drive
-  QFile savepath_file(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".savepath"));
-  if(!savepath_file.exists()) {
-      savepath_file.open(QIODevice::WriteOnly | QIODevice::Text);
-      savepath_file.write(savePath.toLocal8Bit());
-      savepath_file.close();
   }
-  if(defaultTempPath.isEmpty() || QFile::exists(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".finished"))) {
+  QString savePath = getSavePath(hash);
+  qDebug("addTorrent: using save_path: %s", savePath.toUtf8().data());
+  if(defaultTempPath.isEmpty() || (resumed && TorrentPersistentData::isSeed(hash))) {
     p.save_path = savePath.toLocal8Bit().data();
   } else {
     p.save_path = defaultTempPath.toLocal8Bit().data();
@@ -485,16 +481,26 @@ QTorrentHandle bittorrent::addTorrent(QString path, bool fromScanDir, QString fr
   h.set_max_uploads(maxUploadsPerTorrent);
   // Load filtered files
   loadFilesPriorities(h);
+  if(resumed) {
     // Load custom url seeds
     loadWebSeeds(hash);
     // Load speed limit from hard drive
     loadTorrentSpeedLimits(hash);
     // Load trackers
-  bool loaded_trackers = loadTrackerFile(hash);
-  // Doing this to order trackers well
-  if(!loaded_trackers) {
-      saveTrackerFile(hash);
     loadTrackerFile(hash);
+  } else {
+    // Sequential download
+    if(TorrentTempData::hasTempData(hash)) {
+      qDebug("addTorrent: Setting download as sequential (from tmp data)");
+      h.set_sequential_download(TorrentTempData::isSequential(hash));
+    }
+    // Save persistent data for new torrent
+    TorrentPersistentData::saveTorrentPersistentData(h);
+    // Save save_path
+    if(!defaultTempPath.isEmpty()) {
+      qDebug("addTorrent: Saving save_path in persistent data: %s", savePath.toUtf8().data());
+      TorrentPersistentData::saveSavePath(hash, savePath);
+    }
   }
   QString newFile = torrentBackup.path() + QDir::separator() + hash + ".torrent";
   if(file != newFile) {
@@ -504,11 +510,6 @@ QTorrentHandle bittorrent::addTorrent(QString path, bool fromScanDir, QString fr
     // Copy it to torrentBackup directory
     QFile::copy(file, newFile);
   }
-  // Incremental download
-  if(QFile::exists(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".incremental")) {
-      qDebug("Incremental download enabled for %s", t->name().c_str());
-      h.set_sequential_download(true);
-  }
   if(!addInPause && !fastResume) {
     // Start torrent because it was added in paused state
     h.resume();
@@ -535,27 +536,17 @@ QTorrentHandle bittorrent::addTorrent(QString path, bool fromScanDir, QString fr
   return h;
 }
 
-// Check in .priorities file if the user filtered files
+// Check if the user filtered files in this torrent.
-// in this torrent.
 bool bittorrent::has_filtered_files(QString hash) const{
-  QFile pieces_file(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".priorities");
+  QVariantList files_priority = TorrentPersistentData::getFilesPriority(hash);
-  // Read saved file
+  foreach(QVariant var_prio, files_priority) {
-  if(!pieces_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+    int priority = var_prio.toInt();
-    return false;
-  }
-  QByteArray pieces_text = pieces_file.readAll();
-  pieces_file.close();
-  QList<QByteArray> pieces_priorities_list = pieces_text.split('\n');
-  unsigned int listSize = pieces_priorities_list.size();
-  for(unsigned int i=0; i<listSize-1; ++i) {
-    int priority = pieces_priorities_list.at(i).toInt();
     if( priority < 0 || priority > 7) {
       priority = 1;
     }
-    if(!priority) {
+    if(!priority)
       return true;
   }
-  }
   return false;
 }
 
@@ -732,7 +723,7 @@ void bittorrent::loadTorrentSpeedLimits(QString hash) {
   h.set_upload_limit(speeds.at(1).toInt());
 }
 
-// Read pieces priorities from .priorities file
+// Read pieces priorities from hard disk
 // and ask QTorrentHandle to consider them
 void bittorrent::loadFilesPriorities(QTorrentHandle &h) {
   qDebug("Applying pieces priorities");
@@ -740,31 +731,19 @@ void bittorrent::loadFilesPriorities(QTorrentHandle &h) {
     qDebug("/!\\ Error: Invalid handle");
     return;
   }
-  unsigned int nbFiles = h.num_files();
-  QString hash = h.hash();
-  QFile pieces_file(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".priorities");
-  if(!pieces_file.exists()){
-    return;
-  }
-  // Read saved file
-  if(!pieces_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-    qDebug("* Error: Couldn't open priorities file: %s", hash.toLocal8Bit().data());
-    return;
-  }
-  QByteArray pieces_priorities = pieces_file.readAll();
-  pieces_file.close();
-  QList<QByteArray> pieces_priorities_list = pieces_priorities.split('\n');
-  if((unsigned int)pieces_priorities_list.size() != nbFiles+1) {
-    std::cerr << "* Error: Corrupted priorities file\n";
-    return;
-  }
   std::vector<int> v;
-  for(unsigned int i=0; i<nbFiles; ++i) {
+  QVariantList files_priority;
-    int priority = pieces_priorities_list.at(i).toInt();
+  if(TorrentTempData::hasTempData(h.hash())) {
+    files_priority = TorrentTempData::getFilesPriority(h.hash());
+  } else {
+    files_priority = TorrentPersistentData::getFilesPriority(h.hash());
+  }
+  foreach(const QVariant &var_prio, files_priority) {
+    int priority = var_prio.toInt();
     if( priority < 0 || priority > 7) {
       priority = 1;
     }
-    qDebug("Setting piece piority to %d", priority);
+    qDebug("Setting file piority to %d", priority);
     v.push_back(priority);
   }
   h.prioritize_files(v);
@@ -800,7 +779,7 @@ void bittorrent::saveFastResumeData() {
     QTorrentHandle h = QTorrentHandle(*torrentIT);
     if(!h.is_valid() || !h.has_metadata()) continue;
     if(isQueueingEnabled())
-        saveTorrentPriority(h.hash(), h.queue_position());
+      TorrentPersistentData::savePriority(h);
     if(h.is_paused()) continue;
     if(h.state() == torrent_status::checking_files || h.state() == torrent_status::queued_for_checking) continue;
     h.save_resume_data();
@@ -912,6 +891,10 @@ void bittorrent::setDefaultSavePath(QString savepath) {
   defaultSavePath = savepath;
 }
 
+bool bittorrent::useTemporaryFolder() const {
+  return !defaultTempPath.isEmpty();
+}
+
 void bittorrent::setDefaultTempPath(QString temppath) {
   if(defaultTempPath == temppath)
     return;
@@ -938,6 +921,11 @@ void bittorrent::setDefaultTempPath(QString temppath) {
   defaultTempPath = temppath;
 }
 
+void bittorrent::saveTrackerFile(QString hash) {
+  QTorrentHandle h = getTorrentHandle(hash);
+  TorrentPersistentData::saveTrackers(h);
+}
+
 // Enable directory scanning
 void bittorrent::enableDirectoryScanning(QString scan_dir) {
   if(!scan_dir.isEmpty()) {
@@ -1032,46 +1020,21 @@ void bittorrent::setDeleteRatio(float ratio) {
   }
 }
 
-bool bittorrent::loadTrackerFile(QString hash) {
+void bittorrent::loadTrackerFile(QString hash) {
-  QDir torrentBackup(misc::qBittorrentPath() + "BT_backup");
+  QHash<QString, QVariant> tiers = TorrentPersistentData::getTrackers(hash);
-  QFile tracker_file(torrentBackup.path()+QDir::separator()+ hash + ".trackers");
-  if(!tracker_file.exists()) return false;
-  tracker_file.open(QIODevice::ReadOnly | QIODevice::Text);
-  QStringList lines = QString::fromUtf8(tracker_file.readAll().data()).split("\n");
   std::vector<announce_entry> trackers;
-  foreach(const QString &line, lines) {
+  foreach(const QString tracker_url, tiers.keys()) {
-    QStringList parts = line.split("|");
+    announce_entry t(tracker_url.toStdString());
-    if(parts.size() != 2) continue;
+    t.tier = tiers[tracker_url].toInt();
-    announce_entry t(parts[0].toStdString());
-    t.tier = parts[1].toInt();
     trackers.push_back(t);
   }
   if(!trackers.empty()) {
     QTorrentHandle h = getTorrentHandle(hash);
     h.replace_trackers(trackers);
     h.force_reannounce();
-    return true;
-  }else{
-    return false;
   }
 }
 
-void bittorrent::saveTrackerFile(QString hash) {
-  qDebug("Saving tracker file for %s", hash.toLocal8Bit().data());
-  QDir torrentBackup(misc::qBittorrentPath() + "BT_backup");
-  QFile tracker_file(torrentBackup.path()+QDir::separator()+ hash + ".trackers");
-  if(tracker_file.exists()) {
-    tracker_file.remove();
-  }
-  tracker_file.open(QIODevice::WriteOnly | QIODevice::Text);
-  QTorrentHandle h = getTorrentHandle(hash);
-  std::vector<announce_entry> trackers = h.trackers();
-  for(unsigned int i=0; i<trackers.size(); ++i) {
-    tracker_file.write(QByteArray(trackers[i].url.c_str())+QByteArray("|")+QByteArray(misc::toString(i).c_str())+QByteArray("\n"));
-  }
-  tracker_file.close();
-}
-
 // Set DHT port (>= 1000 or 0 if same as BT)
 void bittorrent::setDHTPort(int dht_port) {
   if(dht_port == 0 or dht_port >= 1000) {
@@ -1149,10 +1112,8 @@ void bittorrent::readAlerts() {
       if(h.is_valid()){
         emit finishedTorrent(h);
         QString hash = h.hash();
-        // Create .finished file if necessary
+        // Remember finished state
-        QFile finished_file(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".finished");
+        TorrentPersistentData::saveSeedStatus(h);
-        finished_file.open(QIODevice::WriteOnly | QIODevice::Text);
-        finished_file.close();
         // Move to download directory if necessary
         if(!defaultTempPath.isEmpty()) {
           // Check if directory is different
@@ -1284,17 +1245,17 @@ session_status bittorrent::getSessionStatus() const{
 }
 
 QString bittorrent::getSavePath(QString hash) {
-  QFile savepath_file(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".savepath");
-  QByteArray line;
   QString savePath;
-  if(savepath_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+  if(TorrentTempData::hasTempData(hash)) {
-    line = savepath_file.readAll();
+    savePath = TorrentTempData::getSavePath(hash);
-    savepath_file.close();
+    qDebug("getSavePath, got save_path from temp data: %s", savePath.toUtf8().data());
-    qDebug(" -> Save path: %s", line.data());
-    savePath = QString::fromUtf8(line.data());
   } else {
-    // use default save path
+    savePath = TorrentPersistentData::getSavePath(hash);
-    qDebug("Using default save path because none was set");
+    qDebug("getSavePath, got save_path from persistent data: %s", savePath.toUtf8().data());
+  }
+  if(savePath.isEmpty()) {
+    // use default save path if no other can be found
+    qDebug("Using default save path because none was set: %s", defaultSavePath.toUtf8().data());
     savePath = defaultSavePath;
   }
   // Checking if savePath Dir exists
@@ -1383,42 +1344,23 @@ void bittorrent::applyEncryptionSettings(pe_settings se) {
   s->set_pe_settings(se);
 }
 
-void bittorrent::saveTorrentPriority(QString hash, int prio) {
-  // Write .queued file
-  QFile prio_file(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".prio");
-  prio_file.open(QIODevice::WriteOnly | QIODevice::Text);
-  prio_file.write(QByteArray::number(prio));
-  prio_file.close();
-}
-
 // Will fast resume torrents in
 // backup directory
-void bittorrent::resumeUnfinishedTorrents() {
+void bittorrent::startUpTorrents() {
   qDebug("Resuming unfinished torrents");
   QDir torrentBackup(misc::qBittorrentPath() + "BT_backup");
   QStringList fileNames;
-  // Scan torrentBackup directory
+  QStringList known_torrents = TorrentPersistentData::knownTorrents();
-  QStringList filters;
-  filters << "*.torrent";
-  fileNames = torrentBackup.entryList(filters, QDir::Files, QDir::Unsorted);
   if(isQueueingEnabled()) {
     QList<QPair<int, QString> > filePaths;
-      foreach(const QString &fileName, fileNames) {
+    foreach(const QString &hash, known_torrents) {
-        QString filePath = torrentBackup.path()+QDir::separator()+fileName;
+      QString filePath;
-        int prio = 99999;
+      if(TorrentPersistentData::isMagnet(hash)) {
-        // Get priority
+        filePath = TorrentPersistentData::getMagnetUri(hash);
-        QString prioPath = filePath;
+      } else {
-        prioPath.replace(".torrent", ".prio");
+        filePath = torrentBackup.path()+QDir::separator()+hash+".torrent";
-        if(QFile::exists(prioPath)) {
-            QFile prio_file(prioPath);
-            if(prio_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-                bool ok = false;
-                prio = prio_file.readAll().toInt(&ok);
-                if(!ok)
-                    prio = 99999;
-                prio_file.close();
-            }
       }
+      int prio = TorrentPersistentData::getPriority(hash);
       misc::insertSort2<QString>(filePaths, qMakePair(prio, filePath));
     }
     // Resume downloads

src/bittorrent.h

@@ -107,6 +107,7 @@ class bittorrent : public QObject {
     QStringList getConsoleMessages() const;
     QStringList getPeerBanMessages() const;
     qlonglong getETA(QString hash) const;
+    bool useTemporaryFolder() const;
 
   public slots:
     QTorrentHandle addTorrent(QString path, bool fromScanDir = false, QString from_url = QString(), bool resumed = false);
@@ -115,11 +116,12 @@ class bittorrent : public QObject {
     void downloadFromUrl(QString url);
     void downloadFromURLList(const QStringList& url_list);
     void deleteTorrent(QString hash, bool permanent = false);
+    void startUpTorrents();
     /* Needed by Web UI */
     void pauseAllTorrents();
-    void resumeAllTorrents();
     void pauseTorrent(QString hash);
     void resumeTorrent(QString hash);
+    void resumeAllTorrents();
     /* End Web UI */
     void saveDHTEntry();
     void preAllocateAllFiles(bool b);
@@ -129,8 +131,6 @@ class bittorrent : public QObject {
     void enableIPFilter(QString filter);
     void disableIPFilter();
     void setQueueingEnabled(bool enable);
-    void resumeUnfinishedTorrents();
-    void saveTorrentPriority(QString hash, int prio);
     void saveTorrentSpeedLimits(QString hash);
     void loadTorrentSpeedLimits(QString hash);
     void handleDownloadFailure(QString url, QString reason);
@@ -164,12 +164,12 @@ class bittorrent : public QObject {
     void addConsoleMessage(QString msg, QColor color=QApplication::palette().color(QPalette::WindowText));
     void addPeerBanMessage(QString msg, bool from_ipfilter);
     void processDownloadedFile(QString, QString);
+    void saveTrackerFile(QString hash);
 
   protected slots:
     void scanDirectory(QString);
     void readAlerts();
-    bool loadTrackerFile(QString hash);
+    void loadTrackerFile(QString hash);
-    void saveTrackerFile(QString hash);
     void deleteBigRatios();
 
   signals:

src/properties_imp.cpp

@@ -36,6 +36,7 @@
 #include "realprogressbar.h"
 #include "realprogressbarthread.h"
 #include "TrackersAdditionDlg.h"
+#include "torrentPersistentData.h"
 
 #include <QInputDialog>
 #include <QMessageBox>
@@ -86,7 +87,7 @@ properties::properties(QWidget *parent, bittorrent *BTSession, QTorrentHandle &h
   // get Infos from torrent handle
   fileName->setText(h.name());
   // Torrent Infos
-  save_path->setText(h.save_path());
+  save_path->setText(TorrentPersistentData::getSavePath(hash));
   QString author = h.creator().trimmed();
   if(author.isEmpty())
     author = tr("Unknown");
@@ -115,23 +116,18 @@ properties::properties(QWidget *parent, bittorrent *BTSession, QTorrentHandle &h
   shareRatio->setText(QString(QByteArray::number(ratio, 'f', 1)));
   std::vector<size_type> fp;
   h.file_progress(fp);
-  int *prioritiesTab = loadPiecesPriorities();
+  std::vector<int> files_priority = loadFilesPriorities();
   // List files in torrent
-  arborescence *arb = new arborescence(h.get_torrent_info(), fp, prioritiesTab);
+  arborescence *arb = new arborescence(h.get_torrent_info(), fp, files_priority);
   addFilesToTree(arb->getRoot(), PropListModel->invisibleRootItem());
   delete arb;
-  delete prioritiesTab;
   connect(PropListModel, SIGNAL(itemChanged(QStandardItem*)), this, SLOT(updatePriorities(QStandardItem*)));
   filesList->expandAll();
   // List web seeds
   loadWebSeedsFromFile();
   loadWebSeeds();
   // Incremental download
-  if(QFile::exists(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".incremental")){
+  incrementalDownload->setChecked(TorrentPersistentData::isSequentialDownload(hash));
-    incrementalDownload->setChecked(true);
-  }else{
-    incrementalDownload->setChecked(false);
-  }
   updateInfosTimer = new QTimer(this);
   connect(updateInfosTimer, SIGNAL(timeout()), this, SLOT(updateInfos()));
   updateInfosTimer->start(3000);
@@ -314,41 +310,19 @@ void properties::loadWebSeeds(){
   }
 }
 
-int* properties::loadPiecesPriorities(){
+std::vector<int> properties::loadFilesPriorities(){
-  unsigned int nbFiles = h.num_files();
+  std::vector<int> fp;
-  int *prioritiesTab = new int[nbFiles];
+  QVariantList files_priority = TorrentPersistentData::getFilesPriority(hash);
-  QString fileName = h.name();
+  foreach(const QVariant &var_prio, files_priority) {
-  QFile pieces_file(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".priorities");
+    int priority = var_prio.toInt();
-  has_filtered_files = false;
-  qDebug("Loading pieces priorities");
-  // Read saved file
-  if(!pieces_file.open(QIODevice::ReadOnly | QIODevice::Text)){
-    qDebug("Could not find pieces file");
-    for(unsigned int i=0; i<nbFiles; ++i)
-      prioritiesTab[i] = NORMAL;
-    return prioritiesTab;
-  }
-  QByteArray pieces_text = pieces_file.readAll();
-  pieces_file.close();
-  QList<QByteArray> pieces_priority_list = pieces_text.split('\n');
-  if((unsigned int)pieces_priority_list.size() != nbFiles+1){
-    std::cerr << "Error: Corrupted pieces file\n";
-    for(unsigned int i=0; i<nbFiles; ++i)
-      prioritiesTab[i] = NORMAL;
-    return prioritiesTab;
-  }
-  for(unsigned int i=0; i<nbFiles; ++i){
-    int priority = pieces_priority_list.at(i).toInt();
     if( priority < 0 || priority > 7){
       // Normal priority as default
       priority = 1;
     }
-    if(!priority){
+    fp.push_back(priority);
-      has_filtered_files = true;
   }
-    prioritiesTab[i] = priority;
+
-  }
+  return fp;
-  return prioritiesTab;
 }
 
 bool properties::allFiltered() const {
@@ -494,7 +468,7 @@ void properties::askWebSeed(){
   }
   urlSeeds << url_seed;
   h.add_url_seed(url_seed);
-  saveWebSeeds();
+  TorrentPersistentData::saveUrlSeeds(h);
   // Refresh the seeds list
   loadWebSeeds();
 }
@@ -536,7 +510,7 @@ void properties::deleteSelectedUrlSeeds(){
   }
   if(change){
     // Save them to disk
-    saveWebSeeds();
+    TorrentPersistentData::saveUrlSeeds(h);
     // Refresh list
     loadWebSeeds();
   }
@@ -672,19 +646,16 @@ void properties::setAllPiecesState(unsigned short priority){
   }
 }
 
-void properties::on_incrementalDownload_stateChanged(int){
+void properties::on_incrementalDownload_stateChanged(int state){
   qDebug("Incremental download toggled");
-  if(incrementalDownload->isChecked()){
+  if(state == Qt::Checked){
-    if(!QFile::exists(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".incremental"))) {
+    if(!TorrentPersistentData::isSequentialDownload(hash)) {
-      // Create .incremental file
-      QFile incremental_file(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".incremental"));
-      incremental_file.open(QIODevice::WriteOnly | QIODevice::Text);
-      incremental_file.close();
       h.set_sequential_download(true);
+      TorrentPersistentData::saveSequentialStatus(h);
     }
   }else{
-    QFile::remove(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".incremental");
     h.set_sequential_download(false);
+    TorrentPersistentData::saveSequentialStatus(h);
   }
 }
 
@@ -706,11 +677,9 @@ void properties::on_changeSavePathButton_clicked() {
             }
         }
         // Save savepath
-        QFile savepath_file(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".savepath"));
+        TorrentPersistentData::saveSavePath(hash, savePath.path());
-        savepath_file.open(QIODevice::WriteOnly | QIODevice::Text);
-        savepath_file.write(savePath.path().toLocal8Bit());
-        savepath_file.close();
         // Actually move storage
+        if(!BTSession->useTemporaryFolder() || h.is_seed())
           h.move_storage(savePath.path());
         // Update save_path in dialog
         save_path->setText(savePath.path());
@@ -723,13 +692,10 @@ void properties::on_okButton_clicked(){
 }
 
 void properties::loadWebSeedsFromFile(){
-  QFile urlseeds_file(misc::qBittorrentPath()+"BT_backup"+QDir::separator()+hash+".urlseeds");
-  if(!urlseeds_file.open(QIODevice::ReadOnly | QIODevice::Text)) return;
-  QByteArray urlseeds_lines = urlseeds_file.readAll();
-  urlseeds_file.close();
-  QList<QByteArray> url_seeds = urlseeds_lines.split('\n');
   urlSeeds.clear();
-  foreach(const QByteArray &url_seed, url_seeds){
+  QVariantList url_seeds = TorrentPersistentData::getUrlSeeds(hash);
+  foreach(const QVariant &var_url_seed, url_seeds){
+    QString url_seed = var_url_seed.toString();
     if(!url_seed.isEmpty())
       urlSeeds << url_seed;
   }
@@ -743,19 +709,6 @@ void properties::loadWebSeedsFromFile(){
   }
 }
 
-void properties::saveWebSeeds(){
-  QFile urlseeds_file(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".urlseeds"));
-  if(!urlseeds_file.open(QIODevice::WriteOnly | QIODevice::Text)){
-    std::cerr << "Error: Could not save url seeds\n";
-    return;
-  }
-  foreach(const QString &url_seed, urlSeeds){
-    urlseeds_file.write((url_seed+"\n").toLocal8Bit());
-  }
-  urlseeds_file.close();
-  qDebug("url seeds were saved");
-}
-
 bool properties::savePiecesPriorities() {
   if(!changedFilteredfiles) return true;
   if(allFiltered()) {
@@ -763,30 +716,15 @@ bool properties::savePiecesPriorities() {
     return false;
   }
   qDebug("Saving pieces priorities");
-  bool hasFilteredFiles = false;
-  QString fileName = h.name();
-  QFile pieces_file(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".priorities"));
-  // First, remove old file
-  pieces_file.remove();
   int *priorities = new int[h.get_torrent_info().num_files()];
   getPriorities(PropListModel->invisibleRootItem(), priorities);
-      // Ok, we have priorities, save them
-  if(!pieces_file.open(QIODevice::WriteOnly | QIODevice::Text)){
-    std::cerr << "Error: Could not save pieces priorities\n";
-    return true;
-  }
   unsigned int nbFiles = h.get_torrent_info().num_files();
   for(unsigned int i=0; i<nbFiles; ++i) {
-    if(!priorities[i]) {
+    h.file_priority(i, priorities[i]);
-      hasFilteredFiles = true;
   }
-    pieces_file.write(misc::toQByteArray(priorities[i])+misc::toQByteArray("\n"));
-  }
-  pieces_file.close();
   delete[] priorities;
-  BTSession->loadFilesPriorities(h);
+  TorrentPersistentData::saveFilesPriority(h);
   // Emit a signal so that the GUI updates the size
   emit filteredFilesChanged(hash);
-  has_filtered_files = hasFilteredFiles;
   return true;
 }

src/properties_imp.h

@@ -55,7 +55,6 @@ class properties : public QDialog, private Ui::properties{
     PropListDelegate *PropDelegate;
     QStandardItemModel *PropListModel;
     QTimer *updateInfosTimer;
-    bool has_filtered_files;
     QStringList urlSeeds;
     RealProgressBar *progressBar;
     RealProgressBarThread *progressBarUpdater;
@@ -79,7 +78,6 @@ class properties : public QDialog, private Ui::properties{
     void maximumSelection();
     void loadWebSeeds();
     void askWebSeed();
-    void saveWebSeeds();
     void loadWebSeedsFromFile();
     void deleteSelectedUrlSeeds();
     void addFilesToTree(const torrent_file *root, QStandardItem *parent);
@@ -103,7 +101,7 @@ class properties : public QDialog, private Ui::properties{
     ~properties();
     bool allFiltered() const;
     bool savePiecesPriorities();
-    int* loadPiecesPriorities();
+    std::vector<int> loadFilesPriorities();
 
   protected:
     QPoint screenCenter() const;

src/qtorrenthandle.cpp

@@ -241,6 +241,11 @@ torrent_status::state_t QTorrentHandle::state() const {
   return h.status().state;
 }
 
+std::vector<int> QTorrentHandle::file_priorities() const {
+  Q_ASSERT(h.is_valid());
+  return h.file_priorities();
+}
+
 QString QTorrentHandle::creator() const {
   Q_ASSERT(h.is_valid());
   return misc::toQString(h.get_torrent_info().creator());
@@ -325,6 +330,11 @@ int QTorrentHandle::active_time() const {
     return h.status().active_time;
 }
 
+bool QTorrentHandle::is_sequential_download() const {
+  Q_ASSERT(h.is_valid());
+  return h.is_sequential_download();
+}
+
 //
 // Setters
 //
@@ -428,6 +438,11 @@ void QTorrentHandle::move_storage(QString new_path) const {
    h.move_storage(new_path.toLocal8Bit().data());
 }
 
+void QTorrentHandle::file_priority(int index, int priority) const {
+  Q_ASSERT(h.is_valid());
+   h.file_priority(index, priority);
+}
+
 //
 // Operators
 //

src/qtorrenthandle.h

@@ -108,6 +108,8 @@ class QTorrentHandle {
     bool is_seed() const;
     bool is_auto_managed() const;
     int active_time() const;
+    std::vector<int> file_priorities() const;
+    bool is_sequential_download() const;
 
     //
     // Setters
@@ -122,6 +124,7 @@ class QTorrentHandle {
     void set_max_uploads(int val);
     void set_max_connections(int val);
     void prioritize_files(std::vector<int> v);
+    void file_priority(int index, int priority) const;
     void set_ratio(float ratio) const;
     void replace_trackers(std::vector<announce_entry> const&) const;
     void force_reannounce();

src/torrentAddition.h

@@ -48,6 +48,7 @@
 #include "PropListDelegate.h"
 #include "ui_addTorrentDialog.h"
 #include "arborescence.h"
+#include "torrentPersistentData.h"
 
 using namespace libtorrent;
 
@@ -371,22 +372,14 @@ class torrentAdditionDialog : public QDialog, private Ui_addTorrentDialog{
 
     void savePiecesPriorities(){
       qDebug("Saving pieces priorities");
-      QFile pieces_file(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".priorities"));
-      // First, remove old file
-      pieces_file.remove();
       int *priorities = new int[nbFiles];
       getPriorities(PropListModel->invisibleRootItem(), priorities);
-      // Ok, we have priorities, save them
+      std::vector<int> vect_prio;
-      if(!pieces_file.open(QIODevice::WriteOnly | QIODevice::Text)){
-        std::cerr << "Error: Could not save pieces priorities\n";
-        return;
-      }
       for(unsigned int i=0; i<nbFiles; ++i) {
-        qDebug("%d ", priorities[i]);
+        vect_prio.push_back(priorities[i]);
-        pieces_file.write(misc::toQByteArray(priorities[i])+misc::toQByteArray("\n"));
       }
-      pieces_file.close();
       delete[] priorities;
+      TorrentTempData::setFilesPriority(hash, vect_prio);
     }
 
     void on_OkButton_clicked(){
@@ -403,21 +396,12 @@ class torrentAdditionDialog : public QDialog, private Ui_addTorrentDialog{
         }
       }
       // Save savepath
-      QFile savepath_file(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".savepath"));
+      TorrentTempData::setSavePath(hash, savePath.path());
-      savepath_file.open(QIODevice::WriteOnly | QIODevice::Text);
-      savepath_file.write(savePath.path().toLocal8Bit());
-      savepath_file.close();
       // Save last dir to remember it
       QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent"));
       settings.setValue(QString::fromUtf8("LastDirTorrentAdd"), savePathTxt->text());
       // Create .incremental file if necessary
-      if(checkIncrementalDL->isChecked()){
+      TorrentTempData::setSequential(hash, checkIncrementalDL->isChecked());
-        QFile incremental_file(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".incremental"));
-        incremental_file.open(QIODevice::WriteOnly | QIODevice::Text);
-        incremental_file.close();
-      }else{
-        QFile::remove(misc::qBittorrentPath()+QString::fromUtf8("BT_backup")+QDir::separator()+hash+QString::fromUtf8(".incremental"));
-      }
       // Check if there is at least one selected file
       if(allFiltered()){
           QMessageBox::warning(0, tr("Invalid file selection"), tr("You must select at least one file in the torrent"));

src/torrentPersistentData.h

@@ -0,0 +1,339 @@
+/*
+ * Bittorrent Client using Qt4 and libtorrent.
+ * Copyright (C) 2006  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#ifndef TORRENTPERSISTENTDATA_H
+#define TORRENTPERSISTENTDATA_H
+
+#include <QSettings>
+#include <QHash>
+#include <QVariant>
+#include <libtorrent/magnet_uri.hpp>
+
+#include "qtorrenthandle.h"
+#include "misc.h"
+
+class TorrentTempData {
+public:
+  static bool hasTempData(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents-tmp", QHash<QString, QVariant>()).toHash();
+    return all_data.contains(hash);
+  }
+
+  static void deleteTempData(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents-tmp", QHash<QString, QVariant>()).toHash();
+    if(all_data.contains(hash)) {
+      all_data.remove(hash);
+      settings.setValue("torrents-tmp", all_data);
+    }
+  }
+
+  static void setFilesPriority(QString hash,  std::vector<int> pp) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents-tmp", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    std::vector<int>::iterator pp_it = pp.begin();
+    QVariantList pieces_priority;
+    while(pp_it != pp.end()) {
+      pieces_priority << *pp_it;
+      pp_it++;
+    }
+    data["files_priority"] = pieces_priority;
+    all_data[hash] = data;
+    settings.setValue("torrents-tmp", all_data);
+  }
+
+  static void setSavePath(QString hash, QString save_path) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents-tmp", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    data["save_path"] = save_path;
+    all_data[hash] = data;
+    settings.setValue("torrents-tmp", all_data);
+  }
+
+  static void setSequential(QString hash, bool sequential) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents-tmp", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    data["sequential"] = sequential;
+    all_data[hash] = data;
+    settings.setValue("torrents-tmp", all_data);
+  }
+
+  static bool isSequential(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents-tmp", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    if(data.contains("sequential"))
+      return data["sequential"].toBool();
+    return false;
+
+  }
+
+  static QString getSavePath(QString hash) {
+  QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents-tmp", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    if(data.contains("save_path"))
+      return data["save_path"].toString();
+    qDebug("Warning Temp::getSavePath returns null string!");
+    return QString::null;
+  }
+
+  static QVariantList getFilesPriority(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents-tmp", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    if(data.contains("files_priority"))
+      return data["files_priority"].toList();
+    return QVariantList();
+  }
+};
+
+class TorrentPersistentData {
+public:
+
+  static bool isKnownTorrent(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    return all_data.contains(hash);
+  }
+
+  static QStringList knownTorrents() {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    return all_data.keys();
+  }
+
+  static void deletePersistentData(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    if(all_data.contains(hash)) {
+      all_data.remove(hash);
+      settings.setValue("torrents", all_data);
+    }
+  }
+
+  static void saveTorrentPersistentData(QTorrentHandle h, bool is_magnet = false) {
+    // First, remove temp data
+    TorrentTempData::deleteTempData(h.hash());
+    Q_ASSERT(!TorrentTempData::hasTempData(h.hash()));
+    // Save persistent data
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data;
+    data["hash"] = h.hash();
+    data["is_magnet"] = is_magnet;
+    if(is_magnet) {
+      data["magnet_uri"] = misc::toQString(make_magnet_uri(h.get_torrent_handle()));
+    }
+    data["seed"] = h.is_seed();
+    data["priority"] = h.queue_position();
+    QVariantList files_priority;
+    std::vector<int> fp = h.file_priorities();
+    std::vector<int>::iterator fp_it = fp.begin();
+    while(fp_it != fp.end()) {
+      files_priority << *fp_it;
+      fp_it++;
+    }
+    data["files_priority"] = files_priority;
+    data["save_path"] = h.save_path();
+    QHash<QString, QVariant> trackers;
+    std::vector<announce_entry> tr = h.trackers();
+    std::vector<announce_entry>::iterator tr_it = tr.begin();
+    while(tr_it != tr.end()) {
+      trackers[misc::toQString((*tr_it).url)] = (*tr_it).tier;
+      tr_it++;
+    }
+    data["trackers"] = trackers;
+    QVariantList url_seeds;
+    foreach(QString url_seed, h.url_seeds()) {
+      url_seeds << url_seed;
+    }
+    data["url_seeds"] = url_seeds;
+    data["sequential"] = h.is_sequential_download();
+    // Save data
+    all_data[h.hash()] = data;
+    settings.setValue("torrents", all_data);
+  }
+
+  static void saveTrackers(QTorrentHandle h) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
+    QVariantList trackers;
+    std::vector<announce_entry> tr = h.trackers();
+    std::vector<announce_entry>::iterator tr_it = tr.begin();
+    while(tr_it != tr.end()) {
+      trackers << misc::toQString((*tr_it).url);
+      tr_it++;
+    }
+    data["trackers"] = trackers;
+    // Save data
+    all_data[h.hash()] = data;
+    settings.setValue("torrents", all_data);
+  }
+
+  // Setters
+
+  static void saveFilesPriority(QTorrentHandle h) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
+    std::vector<int> fp = h.file_priorities();
+    std::vector<int>::iterator fp_it = fp.begin();
+    QVariantList files_priority;
+    while(fp_it != fp.end()) {
+      files_priority << *fp_it;
+      fp_it++;
+    }
+    data["files_priority"] = files_priority;
+    all_data[h.hash()] = data;
+    settings.setValue("torrents", all_data);
+  }
+
+  static void saveSavePath(QString hash, QString save_path) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    data["save_path"] = save_path;
+    all_data[hash] = data;
+    settings.setValue("torrents", all_data);
+  }
+
+  static void saveUrlSeeds(QTorrentHandle h) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
+    QVariantList url_seeds;
+    foreach(QString url_seed, h.url_seeds()) {
+      url_seeds << url_seed;
+    }
+    data["url_seeds"] = url_seeds;
+    all_data[h.hash()] = data;
+    settings.setValue("torrents", all_data);
+  }
+
+  static void savePriority(QTorrentHandle h) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
+    data["priority"] = h.queue_position();
+    all_data[h.hash()] = data;
+    settings.setValue("torrents", all_data);
+  }
+
+  static void saveSeedStatus(QTorrentHandle h) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
+    data["seed"] = h.is_seed();
+    all_data[h.hash()] = data;
+    settings.setValue("torrents", all_data);
+  }
+
+  static void saveSequentialStatus(QTorrentHandle h) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
+    data["sequential"] = h.is_sequential_download();
+    all_data[h.hash()] = data;
+    settings.setValue("torrents", all_data);
+  }
+
+  // Getters
+  static QHash<QString, QVariant> getTrackers(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    return data["trackers"].toHash();
+  }
+
+  static QVariantList getFilesPriority(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    return data["files_priority"].toList();
+  }
+
+  static QString getSavePath(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    return data["save_path"].toString();
+  }
+
+  static int getPriority(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    return data["priority"].toInt();
+  }
+
+  static QVariantList getUrlSeeds(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    return data["url_seeds"].toList();
+  }
+
+  static bool isSeed(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    return data["seed"].toBool();
+  }
+
+  static bool isMagnet(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    return data["is_magnet"].toBool();
+  }
+
+  static QString getMagnetUri(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    Q_ASSERT(data["is_magnet"].toBool());
+    return data["magnet_uri"].toString();
+  }
+
+  static bool isSequentialDownload(QString hash) {
+    QSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    QHash<QString, QVariant> all_data = settings.value("torrents", QHash<QString, QVariant>()).toHash();
+    QHash<QString, QVariant> data = all_data[hash].toHash();
+    return data["sequential"].toBool();
+  }
+
+};
+#endif // TORRENTPERSISTENTDATA_H