Changeset 14079

Timestamp:

May 23, 2013, 12:11:09 AM (9 years ago)

Author:

jordan

Message:

whitespace/indentation

Location:

trunk/libtransmission

Files:

• rpcimpl.c (modified) (45 diffs)
• torrent.c (modified) (121 diffs)

trunk/libtransmission/rpcimpl.c

@@ -87 +87 @@
 struct tr_rpc_idle_data
 {
-    tr_session            * session;
-    tr_variant            * response;
-    tr_variant            * args_out;
-    tr_rpc_response_func    callback;
-    void                  * callback_user_data;
+ tr_session            * session;
+ tr_variant            * response;
+ tr_variant            * args_out;
+ tr_rpc_response_func    callback;
+ void                  * callback_user_data;
 };
 
@@ -97 +97 @@
 tr_idle_function_done (struct tr_rpc_idle_data * data, const char * result)
 {
-    struct evbuffer * buf;
-
-    if (result == NULL)
-        result = "success";
-    tr_variantDictAddStr (data->response, TR_KEY_result, result);
-
-    buf = tr_variantToBuf (data->response, TR_VARIANT_FMT_JSON_LEAN);
-  (*data->callback)(data->session, buf, data->callback_user_data);
-    evbuffer_free (buf);
-
-    tr_variantFree (data->response);
-    tr_free (data->response);
-    tr_free (data);
+ struct evbuffer * buf;
+
+ if (result == NULL)
+   result = "success";
+ tr_variantDictAddStr (data->response, TR_KEY_result, result);
+
+ buf = tr_variantToBuf (data->response, TR_VARIANT_FMT_JSON_LEAN);
+ (*data->callback)(data->session, buf, data->callback_user_data);
+ evbuffer_free (buf);
+
+ tr_variantFree (data->response);
+ tr_free (data->response);
+ tr_free (data);
 }
 
@@ -121 +121 @@
              int        * setmeCount)
 {
-    int           torrentCount = 0;
-    int64_t       id;
-    tr_torrent ** torrents = NULL;
-    tr_variant *     ids;
-    const char * str;
-
-    if (tr_variantDictFindList (args, TR_KEY_ids, &ids))
-    {
-        int       i;
-        const int n = tr_variantListSize (ids);
-
-        torrents = tr_new0 (tr_torrent *, n);
-
-        for (i = 0; i < n; ++i)
-        {
-            tr_torrent * tor = NULL;
-            tr_variant *    node = tr_variantListChild (ids, i);
-            const char * str;
-            if (tr_variantGetInt (node, &id))
-                tor = tr_torrentFindFromId (session, id);
-            else if (tr_variantGetStr (node, &str, NULL))
-                tor = tr_torrentFindFromHashString (session, str);
-            if (tor)
-                torrents[torrentCount++] = tor;
-        }
-    }
-    else if (tr_variantDictFindInt (args, TR_KEY_ids, &id)
-           || tr_variantDictFindInt (args, TR_KEY_id, &id))
-    {
-        tr_torrent * tor;
-        torrents = tr_new0 (tr_torrent *, 1);
-        if ((tor = tr_torrentFindFromId (session, id)))
+  int torrentCount = 0;
+  int64_t id;
+  tr_torrent ** torrents = NULL;
+  tr_variant * ids;
+  const char * str;
+
+  if (tr_variantDictFindList (args, TR_KEY_ids, &ids))
+    {
+      int i;
+      const int n = tr_variantListSize (ids);
+
+      torrents = tr_new0 (tr_torrent *, n);
+
+      for (i=0; i<n; ++i)
+        {
+          const char * str;
+          tr_torrent * tor;
+          tr_variant * node = tr_variantListChild (ids, i);
+
+          if (tr_variantGetInt (node, &id))
+            tor = tr_torrentFindFromId (session, id);
+          else if (tr_variantGetStr (node, &str, NULL))
+            tor = tr_torrentFindFromHashString (session, str);
+          else
+            tor = NULL;
+
+          if (tor != NULL)
             torrents[torrentCount++] = tor;
-    }
-    else if (tr_variantDictFindStr (args, TR_KEY_ids, &str, NULL))
-    {
-        if (!strcmp (str, "recently-active"))
-        {
-            tr_torrent * tor = NULL;
-            const time_t now = tr_time ();
-            const time_t window = RECENTLY_ACTIVE_SECONDS;
-            const int n = tr_sessionCountTorrents (session);
-            torrents = tr_new0 (tr_torrent *, n);
-            while ((tor = tr_torrentNext (session, tor)))
-                if (tor->anyDate >= now - window)
-                    torrents[torrentCount++] = tor;
-        }
-        else
-        {
-            tr_torrent * tor;
-            torrents = tr_new0 (tr_torrent *, 1);
-            if ((tor = tr_torrentFindFromHashString (session, str)))
-                torrents[torrentCount++] = tor;
-        }
-    }
-    else /* all of them */
-    {
-        tr_torrent * tor = NULL;
-        const int n = tr_sessionCountTorrents (session);
-        torrents = tr_new0 (tr_torrent *, n);
-        while ((tor = tr_torrentNext (session, tor)))
+        }
+    }
+  else if (tr_variantDictFindInt (args, TR_KEY_ids, &id)
+        || tr_variantDictFindInt (args, TR_KEY_id, &id))
+    {
+      tr_torrent * tor;
+      torrents = tr_new0 (tr_torrent *, 1);
+      if ((tor = tr_torrentFindFromId (session, id)))
+        torrents[torrentCount++] = tor;
+    }
+  else if (tr_variantDictFindStr (args, TR_KEY_ids, &str, NULL))
+    {
+      if (!strcmp (str, "recently-active"))
+        {
+          tr_torrent * tor = NULL;
+          const time_t now = tr_time ();
+          const time_t window = RECENTLY_ACTIVE_SECONDS;
+          const int n = tr_sessionCountTorrents (session);
+          torrents = tr_new0 (tr_torrent *, n);
+          while ((tor = tr_torrentNext (session, tor)))
+            if (tor->anyDate >= now - window)
+              torrents[torrentCount++] = tor;
+        }
+      else
+        {
+          tr_torrent * tor;
+          torrents = tr_new0 (tr_torrent *, 1);
+          if ((tor = tr_torrentFindFromHashString (session, str)))
             torrents[torrentCount++] = tor;
-    }
-
-    *setmeCount = torrentCount;
-    return torrents;
+        }
+    }
+  else /* all of them */
+    {
+      tr_torrent * tor = NULL;
+      const int n = tr_sessionCountTorrents (session);
+      torrents = tr_new0 (tr_torrent *, n);
+      while ((tor = tr_torrentNext (session, tor)))
+        torrents[torrentCount++] = tor;
+    }
+
+  *setmeCount = torrentCount;
+  return torrents;
 }
 
@@ -192 +196 @@
 notifyBatchQueueChange (tr_session * session, tr_torrent ** torrents, int n)
 {
-    int i;
-    for (i=0; i<n; ++i)
-        notify (session, TR_RPC_TORRENT_CHANGED, torrents[i]);
-    notify (session, TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED, NULL);
+  int i;
+  for (i=0; i<n; ++i)
+    notify (session, TR_RPC_TORRENT_CHANGED, torrents[i]);
+  notify (session, TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED, NULL);
 }
 
@@ -204 +208 @@
               struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int n;
-    tr_torrent ** torrents = getTorrents (session, args_in, &n);
-    tr_torrentsQueueMoveTop (torrents, n);
-    notifyBatchQueueChange (session, torrents, n);
-    tr_free (torrents);
-    return NULL;
+  int n;
+  tr_torrent ** torrents = getTorrents (session, args_in, &n);
+  tr_torrentsQueueMoveTop (torrents, n);
+  notifyBatchQueueChange (session, torrents, n);
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -218 +222 @@
              struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int n;
-    tr_torrent ** torrents = getTorrents (session, args_in, &n);
-    tr_torrentsQueueMoveUp (torrents, n);
-    notifyBatchQueueChange (session, torrents, n);
-    tr_free (torrents);
-    return NULL;
+  int n;
+  tr_torrent ** torrents = getTorrents (session, args_in, &n);
+  tr_torrentsQueueMoveUp (torrents, n);
+  notifyBatchQueueChange (session, torrents, n);
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -232 +236 @@
                struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int n;
-    tr_torrent ** torrents = getTorrents (session, args_in, &n);
-    tr_torrentsQueueMoveDown (torrents, n);
-    notifyBatchQueueChange (session, torrents, n);
-    tr_free (torrents);
-    return NULL;
+  int n;
+  tr_torrent ** torrents = getTorrents (session, args_in, &n);
+  tr_torrentsQueueMoveDown (torrents, n);
+  notifyBatchQueueChange (session, torrents, n);
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -246 +250 @@
                  struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int n;
-    tr_torrent ** torrents = getTorrents (session, args_in, &n);
-    tr_torrentsQueueMoveBottom (torrents, n);
-    notifyBatchQueueChange (session, torrents, n);
-    tr_free (torrents);
-    return NULL;
+  int n;
+  tr_torrent ** torrents = getTorrents (session, args_in, &n);
+  tr_torrentsQueueMoveBottom (torrents, n);
+  notifyBatchQueueChange (session, torrents, n);
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -260 +264 @@
               struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
-
-    assert (idle_data == NULL);
-
-    for (i = 0; i < torrentCount; ++i)
-    {
-        tr_torrent * tor = torrents[i];
-        if (!tor->isRunning)
-        {
-            tr_torrentStart (tor);
-            notify (session, TR_RPC_TORRENT_STARTED, tor);
-        }
-    }
-    tr_free (torrents);
-    return NULL;
+  int i;
+  int torrentCount;
+  tr_torrent ** torrents;
+
+  assert (idle_data == NULL);
+
+  torrents = getTorrents (session, args_in, &torrentCount);
+  for (i=0; i<torrentCount; ++i)
+    {
+      tr_torrent * tor = torrents[i];
+      if (!tor->isRunning)
+        {
+          tr_torrentStart (tor);
+          notify (session, TR_RPC_TORRENT_STARTED, tor);
+        }
+    }
+
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -284 +291 @@
                  struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
-
-    assert (idle_data == NULL);
-
-    for (i = 0; i < torrentCount; ++i)
-    {
-        tr_torrent * tor = torrents[i];
-        if (!tor->isRunning)
-        {
-            tr_torrentStartNow (tor);
-            notify (session, TR_RPC_TORRENT_STARTED, tor);
-        }
-    }
-    tr_free (torrents);
-    return NULL;
+  int i;
+  int torrentCount;
+  tr_torrent ** torrents;
+
+  assert (idle_data == NULL);
+
+  torrents = getTorrents (session, args_in, &torrentCount);
+  for (i=0; i<torrentCount; ++i)
+    {
+      tr_torrent * tor = torrents[i];
+
+      if (!tor->isRunning)
+        {
+          tr_torrentStartNow (tor);
+          notify (session, TR_RPC_TORRENT_STARTED, tor);
+        }
+    }
+
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -308 +319 @@
              struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
-
-    assert (idle_data == NULL);
-
-    for (i = 0; i < torrentCount; ++i)
-    {
-        tr_torrent * tor = torrents[i];
-
-        if (tor->isRunning || tr_torrentIsQueued (tor))
-        {
-            tor->isStopping = true;
-            notify (session, TR_RPC_TORRENT_STOPPED, tor);
-        }
-    }
-    tr_free (torrents);
-    return NULL;
+  int i;
+  int torrentCount;
+  tr_torrent ** torrents;
+
+  assert (idle_data == NULL);
+
+  torrents = getTorrents (session, args_in, &torrentCount);
+  for (i=0; i<torrentCount; ++i)
+    {
+      tr_torrent * tor = torrents[i];
+
+      if (tor->isRunning || tr_torrentIsQueued (tor))
+        {
+          tor->isStopping = true;
+          notify (session, TR_RPC_TORRENT_STOPPED, tor);
+        }
+    }
+
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -333 +347 @@
                struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int i;
-    int torrentCount;
-    tr_rpc_callback_type type;
-    bool deleteFlag = false;
-    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
-
-    assert (idle_data == NULL);
-
-    tr_variantDictFindBool (args_in, TR_KEY_delete_local_data, &deleteFlag);
-    type = deleteFlag ? TR_RPC_TORRENT_TRASHING
-                      : TR_RPC_TORRENT_REMOVING;
-
-    for (i=0; i<torrentCount; ++i)
-    {
-        tr_torrent * tor = torrents[i];
-        const tr_rpc_callback_status status = notify (session, type, tor);
-        if (! (status & TR_RPC_NOREMOVE))
-            tr_torrentRemove (tor, deleteFlag, NULL);
-    }
-
-    tr_free (torrents);
-    return NULL;
+  int i;
+  int torrentCount;
+  tr_rpc_callback_type type;
+  bool deleteFlag = false;
+  tr_torrent ** torrents;
+
+  assert (idle_data == NULL);
+
+  tr_variantDictFindBool (args_in, TR_KEY_delete_local_data, &deleteFlag);
+  type = deleteFlag ? TR_RPC_TORRENT_TRASHING
+                    : TR_RPC_TORRENT_REMOVING;
+
+  torrents = getTorrents (session, args_in, &torrentCount);
+  for (i=0; i<torrentCount; ++i)
+    {
+      tr_torrent * tor = torrents[i];
+      const tr_rpc_callback_status status = notify (session, type, tor);
+
+      if (!(status & TR_RPC_NOREMOVE))
+        tr_torrentRemove (tor, deleteFlag, NULL);
+    }
+
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -363 +379 @@
                    struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int i, torrentCount;
-    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
-
-    assert (idle_data == NULL);
-
-    for (i=0; i<torrentCount; ++i)
-    {
-        tr_torrent * tor = torrents[i];
-        if (tr_torrentCanManualUpdate (tor))
-        {
-            tr_torrentManualUpdate (tor);
-            notify (session, TR_RPC_TORRENT_CHANGED, tor);
-        }
-    }
-
-    tr_free (torrents);
-    return NULL;
+  int i;
+  int torrentCount;
+  tr_torrent ** torrents;
+
+  assert (idle_data == NULL);
+
+  torrents = getTorrents (session, args_in, &torrentCount);
+  for (i=0; i<torrentCount; ++i)
+    {
+      tr_torrent * tor = torrents[i];
+
+      if (tr_torrentCanManualUpdate (tor))
+        {
+          tr_torrentManualUpdate (tor);
+          notify (session, TR_RPC_TORRENT_CHANGED, tor);
+        }
+    }
+
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -388 +407 @@
                struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
-
-    assert (idle_data == NULL);
-
-    for (i = 0; i < torrentCount; ++i)
-    {
-        tr_torrent * tor = torrents[i];
-        tr_torrentVerify (tor, NULL, NULL);
-        notify (session, TR_RPC_TORRENT_CHANGED, tor);
-    }
-
-    tr_free (torrents);
-    return NULL;
+  int i;
+  int torrentCount;
+  tr_torrent ** torrents;
+
+  assert (idle_data == NULL);
+
+  torrents = getTorrents (session, args_in, &torrentCount);
+  for (i=0; i<torrentCount; ++i)
+    {
+      tr_torrent * tor = torrents[i];
+      tr_torrentVerify (tor, NULL, NULL);
+      notify (session, TR_RPC_TORRENT_CHANGED, tor);
+    }
+
+  tr_free (torrents);
+  return NULL;
 }
 
@@ -411 +432 @@
 addFileStats (const tr_torrent * tor, tr_variant * list)
 {
-    tr_file_index_t i;
-    tr_file_index_t n;
-    const tr_info * info = tr_torrentInfo (tor);
-    tr_file_stat * files = tr_torrentFiles (tor, &n);
-
-    for (i = 0; i < info->fileCount; ++i)
-    {
-        const tr_file * file = &info->files[i];
-        tr_variant * d = tr_variantListAddDict (list, 3);
-        tr_variantDictAddInt (d, TR_KEY_bytesCompleted, files[i].bytesCompleted);
-        tr_variantDictAddInt (d, TR_KEY_priority, file->priority);
-        tr_variantDictAddBool (d, TR_KEY_wanted, !file->dnd);
-    }
-
-    tr_torrentFilesFree (files, n);
+  tr_file_index_t i;
+  tr_file_index_t n;
+  const tr_info * info = tr_torrentInfo (tor);
+  tr_file_stat * files = tr_torrentFiles (tor, &n);
+
+  for (i=0; i<info->fileCount; ++i)
+    {
+      const tr_file * file = &info->files[i];
+      tr_variant * d = tr_variantListAddDict (list, 3);
+      tr_variantDictAddInt (d, TR_KEY_bytesCompleted, files[i].bytesCompleted);
+      tr_variantDictAddInt (d, TR_KEY_priority, file->priority);
+      tr_variantDictAddBool (d, TR_KEY_wanted, !file->dnd);
+    }
+
+  tr_torrentFilesFree (files, n);
 }
 
@@ -431 +452 @@
 addFiles (const tr_torrent * tor, tr_variant * list)
 {
-    tr_file_index_t i;
-    tr_file_index_t n;
-    const tr_info * info = tr_torrentInfo (tor);
-    tr_file_stat *  files = tr_torrentFiles (tor, &n);
-
-    for (i = 0; i < info->fileCount; ++i)
-    {
-        const tr_file * file = &info->files[i];
-        tr_variant *       d = tr_variantListAddDict (list, 3);
-        tr_variantDictAddInt (d, TR_KEY_bytesCompleted, files[i].bytesCompleted);
-        tr_variantDictAddInt (d, TR_KEY_length, file->length);
-        tr_variantDictAddStr (d, TR_KEY_name, file->name);
-    }
-
-    tr_torrentFilesFree (files, n);
+  tr_file_index_t i;
+  tr_file_index_t n;
+  const tr_info * info = tr_torrentInfo (tor);
+  tr_file_stat *  files = tr_torrentFiles (tor, &n);
+
+  for (i=0; i<info->fileCount; ++i)
+    {
+      const tr_file * file = &info->files[i];
+      tr_variant * d = tr_variantListAddDict (list, 3);
+      tr_variantDictAddInt (d, TR_KEY_bytesCompleted, files[i].bytesCompleted);
+      tr_variantDictAddInt (d, TR_KEY_length, file->length);
+      tr_variantDictAddStr (d, TR_KEY_name, file->name);
+    }
+
+  tr_torrentFilesFree (files, n);
 }
 
@@ -478 +499 @@
 addTrackerStats (const tr_tracker_stat * st, int n, tr_variant * list)
 {
-    int i;
-
-    for (i=0; i<n; ++i)
-    {
-        const tr_tracker_stat * s = &st[i];
-        tr_variant * d = tr_variantListAddDict (list, 26);
-        tr_variantDictAddStr  (d, TR_KEY_announce, s->announce);
-        tr_variantDictAddInt  (d, TR_KEY_announceState, s->announceState);
-        tr_variantDictAddInt  (d, TR_KEY_downloadCount, s->downloadCount);
-        tr_variantDictAddBool (d, TR_KEY_hasAnnounced, s->hasAnnounced);
-        tr_variantDictAddBool (d, TR_KEY_hasScraped, s->hasScraped);
-        tr_variantDictAddStr  (d, TR_KEY_host, s->host);
-        tr_variantDictAddInt  (d, TR_KEY_id, s->id);
-        tr_variantDictAddBool (d, TR_KEY_isBackup, s->isBackup);
-        tr_variantDictAddInt  (d, TR_KEY_lastAnnouncePeerCount, s->lastAnnouncePeerCount);
-        tr_variantDictAddStr  (d, TR_KEY_lastAnnounceResult, s->lastAnnounceResult);
-        tr_variantDictAddInt  (d, TR_KEY_lastAnnounceStartTime, s->lastAnnounceStartTime);
-        tr_variantDictAddBool (d, TR_KEY_lastAnnounceSucceeded, s->lastAnnounceSucceeded);
-        tr_variantDictAddInt  (d, TR_KEY_lastAnnounceTime, s->lastAnnounceTime);
-        tr_variantDictAddBool (d, TR_KEY_lastAnnounceTimedOut, s->lastAnnounceTimedOut);
-        tr_variantDictAddStr  (d, TR_KEY_lastScrapeResult, s->lastScrapeResult);
-        tr_variantDictAddInt  (d, TR_KEY_lastScrapeStartTime, s->lastScrapeStartTime);
-        tr_variantDictAddBool (d, TR_KEY_lastScrapeSucceeded, s->lastScrapeSucceeded);
-        tr_variantDictAddInt  (d, TR_KEY_lastScrapeTime, s->lastScrapeTime);
-        tr_variantDictAddInt  (d, TR_KEY_lastScrapeTimedOut, s->lastScrapeTimedOut);
-        tr_variantDictAddInt  (d, TR_KEY_leecherCount, s->leecherCount);
-        tr_variantDictAddInt  (d, TR_KEY_nextAnnounceTime, s->nextAnnounceTime);
-        tr_variantDictAddInt  (d, TR_KEY_nextScrapeTime, s->nextScrapeTime);
-        tr_variantDictAddStr  (d, TR_KEY_scrape, s->scrape);
-        tr_variantDictAddInt  (d, TR_KEY_scrapeState, s->scrapeState);
-        tr_variantDictAddInt  (d, TR_KEY_seederCount, s->seederCount);
-        tr_variantDictAddInt  (d, TR_KEY_tier, s->tier);
+  int i;
+
+  for (i=0; i<n; ++i)
+    {
+      const tr_tracker_stat * s = &st[i];
+      tr_variant * d = tr_variantListAddDict (list, 26);
+      tr_variantDictAddStr  (d, TR_KEY_announce, s->announce);
+      tr_variantDictAddInt  (d, TR_KEY_announceState, s->announceState);
+      tr_variantDictAddInt  (d, TR_KEY_downloadCount, s->downloadCount);
+      tr_variantDictAddBool (d, TR_KEY_hasAnnounced, s->hasAnnounced);
+      tr_variantDictAddBool (d, TR_KEY_hasScraped, s->hasScraped);
+      tr_variantDictAddStr  (d, TR_KEY_host, s->host);
+      tr_variantDictAddInt  (d, TR_KEY_id, s->id);
+      tr_variantDictAddBool (d, TR_KEY_isBackup, s->isBackup);
+      tr_variantDictAddInt  (d, TR_KEY_lastAnnouncePeerCount, s->lastAnnouncePeerCount);
+      tr_variantDictAddStr  (d, TR_KEY_lastAnnounceResult, s->lastAnnounceResult);
+      tr_variantDictAddInt  (d, TR_KEY_lastAnnounceStartTime, s->lastAnnounceStartTime);
+      tr_variantDictAddBool (d, TR_KEY_lastAnnounceSucceeded, s->lastAnnounceSucceeded);
+      tr_variantDictAddInt  (d, TR_KEY_lastAnnounceTime, s->lastAnnounceTime);
+      tr_variantDictAddBool (d, TR_KEY_lastAnnounceTimedOut, s->lastAnnounceTimedOut);
+      tr_variantDictAddStr  (d, TR_KEY_lastScrapeResult, s->lastScrapeResult);
+      tr_variantDictAddInt  (d, TR_KEY_lastScrapeStartTime, s->lastScrapeStartTime);
+      tr_variantDictAddBool (d, TR_KEY_lastScrapeSucceeded, s->lastScrapeSucceeded);
+      tr_variantDictAddInt  (d, TR_KEY_lastScrapeTime, s->lastScrapeTime);
+      tr_variantDictAddInt  (d, TR_KEY_lastScrapeTimedOut, s->lastScrapeTimedOut);
+      tr_variantDictAddInt  (d, TR_KEY_leecherCount, s->leecherCount);
+      tr_variantDictAddInt  (d, TR_KEY_nextAnnounceTime, s->nextAnnounceTime);
+      tr_variantDictAddInt  (d, TR_KEY_nextScrapeTime, s->nextScrapeTime);
+      tr_variantDictAddStr  (d, TR_KEY_scrape, s->scrape);
+      tr_variantDictAddInt  (d, TR_KEY_scrapeState, s->scrapeState);
+      tr_variantDictAddInt  (d, TR_KEY_seederCount, s->seederCount);
+      tr_variantDictAddInt  (d, TR_KEY_tier, s->tier);
     }
 }
@@ -524 +545 @@
   for (i=0; i<peerCount; ++i)
     {
-        tr_variant * d = tr_variantListAddDict (list, 16);
-        const tr_peer_stat * peer = peers + i;
-        tr_variantDictAddStr  (d, TR_KEY_address, peer->addr);
-        tr_variantDictAddStr  (d, TR_KEY_clientName, peer->client);
-        tr_variantDictAddBool (d, TR_KEY_clientIsChoked, peer->clientIsChoked);
-        tr_variantDictAddBool (d, TR_KEY_clientIsInterested, peer->clientIsInterested);
-        tr_variantDictAddStr  (d, TR_KEY_flagStr, peer->flagStr);
-        tr_variantDictAddBool (d, TR_KEY_isDownloadingFrom, peer->isDownloadingFrom);
-        tr_variantDictAddBool (d, TR_KEY_isEncrypted, peer->isEncrypted);
-        tr_variantDictAddBool (d, TR_KEY_isIncoming, peer->isIncoming);
-        tr_variantDictAddBool (d, TR_KEY_isUploadingTo, peer->isUploadingTo);
-        tr_variantDictAddBool (d, TR_KEY_isUTP, peer->isUTP);
-        tr_variantDictAddBool (d, TR_KEY_peerIsChoked, peer->peerIsChoked);
-        tr_variantDictAddBool (d, TR_KEY_peerIsInterested, peer->peerIsInterested);
-        tr_variantDictAddInt  (d, TR_KEY_port, peer->port);
-        tr_variantDictAddReal (d, TR_KEY_progress, peer->progress);
-        tr_variantDictAddInt  (d, TR_KEY_rateToClient, toSpeedBytes (peer->rateToClient_KBps));
-        tr_variantDictAddInt  (d, TR_KEY_rateToPeer, toSpeedBytes (peer->rateToPeer_KBps));
-    }
-
-    tr_torrentPeersFree (peers, peerCount);
+      tr_variant * d = tr_variantListAddDict (list, 16);
+      const tr_peer_stat * peer = peers + i;
+      tr_variantDictAddStr  (d, TR_KEY_address, peer->addr);
+      tr_variantDictAddStr  (d, TR_KEY_clientName, peer->client);
+      tr_variantDictAddBool (d, TR_KEY_clientIsChoked, peer->clientIsChoked);
+      tr_variantDictAddBool (d, TR_KEY_clientIsInterested, peer->clientIsInterested);
+      tr_variantDictAddStr  (d, TR_KEY_flagStr, peer->flagStr);
+      tr_variantDictAddBool (d, TR_KEY_isDownloadingFrom, peer->isDownloadingFrom);
+      tr_variantDictAddBool (d, TR_KEY_isEncrypted, peer->isEncrypted);
+      tr_variantDictAddBool (d, TR_KEY_isIncoming, peer->isIncoming);
+      tr_variantDictAddBool (d, TR_KEY_isUploadingTo, peer->isUploadingTo);
+      tr_variantDictAddBool (d, TR_KEY_isUTP, peer->isUTP);
+      tr_variantDictAddBool (d, TR_KEY_peerIsChoked, peer->peerIsChoked);
+      tr_variantDictAddBool (d, TR_KEY_peerIsInterested, peer->peerIsInterested);
+      tr_variantDictAddInt  (d, TR_KEY_port, peer->port);
+      tr_variantDictAddReal (d, TR_KEY_progress, peer->progress);
+      tr_variantDictAddInt  (d, TR_KEY_rateToClient, toSpeedBytes (peer->rateToClient_KBps));
+      tr_variantDictAddInt  (d, TR_KEY_rateToPeer, toSpeedBytes (peer->rateToPeer_KBps));
+    }
+
+  tr_torrentPeersFree (peers, peerCount);
 }
 
@@ -899 +920 @@
 static const char*
 torrentGet (tr_session               * session,
-            tr_variant                  * args_in,
-            tr_variant                  * args_out,
+            tr_variant               * args_in,
+            tr_variant               * args_out,
             struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
-    tr_variant *     list = tr_variantDictAddList (args_out, TR_KEY_torrents, torrentCount);
-    tr_variant *     fields;
-    const char *  msg = NULL;
-    const char *  strVal;
-
-    assert (idle_data == NULL);
-
-    if (tr_variantDictFindStr (args_in, TR_KEY_ids, &strVal, NULL) && !strcmp (strVal, "recently-active")) {
-        int n = 0;
-        tr_variant * d;
-        const time_t now = tr_time ();
-        const int interval = RECENTLY_ACTIVE_SECONDS;
-        tr_variant * removed_out = tr_variantDictAddList (args_out, TR_KEY_removed, 0);
-        while ((d = tr_variantListChild (&session->removedTorrents, n++))) {
-            int64_t intVal;
-            if (tr_variantDictFindInt (d, TR_KEY_date, &intVal) && (intVal >= now - interval)) {
-                tr_variantDictFindInt (d, TR_KEY_id, &intVal);
-                tr_variantListAddInt (removed_out, intVal);
+  int i;
+  int torrentCount;
+  tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
+  tr_variant * list = tr_variantDictAddList (args_out, TR_KEY_torrents, torrentCount);
+  tr_variant * fields;
+  const char * strVal;
+  const char * errmsg = NULL;
+
+  assert (idle_data == NULL);
+
+  if (tr_variantDictFindStr (args_in, TR_KEY_ids, &strVal, NULL) && !strcmp (strVal, "recently-active"))
+    {
+      int n = 0;
+      tr_variant * d;
+      const time_t now = tr_time ();
+      const int interval = RECENTLY_ACTIVE_SECONDS;
+      tr_variant * removed_out = tr_variantDictAddList (args_out, TR_KEY_removed, 0);
+      while ((d = tr_variantListChild (&session->removedTorrents, n++)))
+        {
+          int64_t intVal;
+          if (tr_variantDictFindInt (d, TR_KEY_date, &intVal) && (intVal >= now - interval))
+            {
+              tr_variantDictFindInt (d, TR_KEY_id, &intVal);
+              tr_variantListAddInt (removed_out, intVal);
             }
         }
     }
 
-    if (!tr_variantDictFindList (args_in, TR_KEY_fields, &fields))
-        msg = "no fields specified";
-    else for (i = 0; i < torrentCount; ++i)
-        addInfo (torrents[i], tr_variantListAdd (list), fields);
-
-    tr_free (torrents);
-    return msg;
+  if (!tr_variantDictFindList (args_in, TR_KEY_fields, &fields))
+    errmsg = "no fields specified";
+  else for (i=0; i<torrentCount; ++i)
+    addInfo (torrents[i], tr_variantListAdd (list), fields);
+
+  tr_free (torrents);
+  return errmsg;
 }
 
@@ -943 +968 @@
 setFilePriorities (tr_torrent * tor,
                    int          priority,
-                   tr_variant *    list)
-{
-    int i;
-    int64_t tmp;
-    int fileCount = 0;
-    const int n = tr_variantListSize (list);
-    const char * errmsg = NULL;
-    tr_file_index_t * files = tr_new0 (tr_file_index_t, tor->info.fileCount);
-
-    if (n)
-    {
-        for (i = 0; i < n; ++i) {
-            if (tr_variantGetInt (tr_variantListChild (list, i), &tmp)) {
-                if (0 <= tmp && tmp < tor->info.fileCount) {
-                    files[fileCount++] = tmp;
-                } else {
-                    errmsg = "file index out of range";
-                }
+                   tr_variant * list)
+{
+  int i;
+  int64_t tmp;
+  int fileCount = 0;
+  const int n = tr_variantListSize (list);
+  const char * errmsg = NULL;
+  tr_file_index_t * files = tr_new0 (tr_file_index_t, tor->info.fileCount);
+
+  if (n)
+    {
+      for (i=0; i<n; ++i)
+        {
+          if (tr_variantGetInt (tr_variantListChild (list, i), &tmp))
+            {
+              if (0 <= tmp && tmp < tor->info.fileCount)
+                files[fileCount++] = tmp;
+              else
+                errmsg = "file index out of range";
             }
         }
     }
-    else /* if empty set, apply to all */
-    {
-        tr_file_index_t t;
-        for (t = 0; t < tor->info.fileCount; ++t)
-            files[fileCount++] = t;
-    }
-
-    if (fileCount)
-        tr_torrentSetFilePriorities (tor, files, fileCount, priority);
-
-    tr_free (files);
-    return errmsg;
+  else /* if empty set, apply to all */
+    {
+      tr_file_index_t t;
+      for (t=0; t<tor->info.fileCount; ++t)
+        files[fileCount++] = t;
+    }
+
+  if (fileCount)
+    tr_torrentSetFilePriorities (tor, files, fileCount, priority);
+
+  tr_free (files);
+  return errmsg;
 }
 
@@ -981 +1007 @@
 setFileDLs (tr_torrent * tor,
             int          do_download,
-            tr_variant *    list)
-{
-    int i;
-    int64_t tmp;
-    int fileCount = 0;
-    const int n = tr_variantListSize (list);
-    const char * errmsg = NULL;
-    tr_file_index_t * files = tr_new0 (tr_file_index_t, tor->info.fileCount);
-
-    if (n) /* if argument list, process them */
-    {
-        for (i = 0; i < n; ++i) {
-            if (tr_variantGetInt (tr_variantListChild (list, i), &tmp)) {
-                if (0 <= tmp && tmp < tor->info.fileCount) {
-                    files[fileCount++] = tmp;
-                } else {
-                    errmsg = "file index out of range";
-                }
+            tr_variant * list)
+{
+  int i;
+  int64_t tmp;
+  int fileCount = 0;
+  const int n = tr_variantListSize (list);
+  const char * errmsg = NULL;
+  tr_file_index_t * files = tr_new0 (tr_file_index_t, tor->info.fileCount);
+
+  if (n) /* if argument list, process them */
+    {
+      for (i=0; i<n; ++i)
+        {
+          if (tr_variantGetInt (tr_variantListChild (list, i), &tmp))
+            {
+              if (0 <= tmp && tmp < tor->info.fileCount)
+                files[fileCount++] = tmp;
+              else
+                errmsg = "file index out of range";
             }
         }
     }
-    else /* if empty set, apply to all */
-    {
-        tr_file_index_t t;
-        for (t = 0; t < tor->info.fileCount; ++t)
-            files[fileCount++] = t;
-    }
-
-    if (fileCount)
-        tr_torrentSetFileDLs (tor, files, fileCount, do_download);
-
-    tr_free (files);
-    return errmsg;
+  else /* if empty set, apply to all */
+    {
+      tr_file_index_t t;
+
+      for (t=0; t<tor->info.fileCount; ++t)
+        files[fileCount++] = t;
+    }
+
+  if (fileCount)
+      tr_torrentSetFileDLs (tor, files, fileCount, do_download);
+
+  tr_free (files);
+  return errmsg;
 }
 
@@ -1019 +1047 @@
 findAnnounceUrl (const tr_tracker_info * t, int n, const char * url, int * pos)
 {
-    int i;
-    bool found = false;
-
-    for (i=0; i<n; ++i)
-    {
-        if (!strcmp (t[i].announce, url))
-        {
-            found = true;
-            if (pos) *pos = i;
-            break;
-        }
-    }
-
-    return found;
+  int i;
+  bool found = false;
+
+  for (i=0; i<n; ++i)
+    {
+      if (!strcmp (t[i].announce, url))
+        {
+          found = true;
+
+          if (pos != NULL)
+            *pos = i;
+
+          break;
+        }
+    }
+
+  return found;
 }
 
@@ -1038 +1069 @@
 copyTrackers (tr_tracker_info * tgt, const tr_tracker_info * src, int n)
 {
-    int i;
-    int maxTier = -1;
-
-    for (i=0; i<n; ++i)
-    {
-        tgt[i].tier = src[i].tier;
-        tgt[i].announce = tr_strdup (src[i].announce);
-        maxTier = MAX (maxTier, src[i].tier);
-    }
-
-    return maxTier;
+  int i;
+  int maxTier = -1;
+
+  for (i=0; i<n; ++i)
+    {
+      tgt[i].tier = src[i].tier;
+      tgt[i].announce = tr_strdup (src[i].announce);
+      maxTier = MAX (maxTier, src[i].tier);
+    }
+
+  return maxTier;
 }
 
@@ -1054 +1085 @@
 freeTrackers (tr_tracker_info * trackers, int n)
 {
-    int i;
-
-    for (i=0; i<n; ++i)
-        tr_free (trackers[i].announce);
-
-    tr_free (trackers);
+  int i;
+
+  for (i=0; i<n; ++i)
+    tr_free (trackers[i].announce);
+
+  tr_free (trackers);
 }
 
@@ -1065 +1096 @@
 addTrackerUrls (tr_torrent * tor, tr_variant * urls)
 {
-    int i;
-    int n;
-    int tier;
-    tr_variant * val;
-    tr_tracker_info * trackers;
-    bool changed = false;
-    const tr_info * inf = tr_torrentInfo (tor);
-    const char * errmsg = NULL;
-
-    /* make a working copy of the existing announce list */
-    n = inf->trackerCount;
-    trackers = tr_new0 (tr_tracker_info, n + tr_variantListSize (urls));
-    tier = copyTrackers (trackers, inf->trackers, n);
-
-    /* and add the new ones */
-    i = 0;
-    while ((val = tr_variantListChild (urls, i++)))
-    {
-        const char * announce = NULL;
-
-        if ( tr_variantGetStr (val, &announce, NULL)
-            && tr_urlIsValidTracker (announce)
-            && !findAnnounceUrl (trackers, n, announce, NULL))
-        {
-            trackers[n].tier = ++tier; /* add a new tier */
-            trackers[n].announce = tr_strdup (announce);
-            ++n;
-            changed = true;
-        }
-    }
-
-    if (!changed)
-        errmsg = "invalid argument";
-    else if (!tr_torrentSetAnnounceList (tor, trackers, n))
-        errmsg = "error setting announce list";
-
-    freeTrackers (trackers, n);
-    return errmsg;
+  int i;
+  int n;
+  int tier;
+  tr_variant * val;
+  tr_tracker_info * trackers;
+  bool changed = false;
+  const tr_info * inf = tr_torrentInfo (tor);
+  const char * errmsg = NULL;
+
+  /* make a working copy of the existing announce list */
+  n = inf->trackerCount;
+  trackers = tr_new0 (tr_tracker_info, n + tr_variantListSize (urls));
+  tier = copyTrackers (trackers, inf->trackers, n);
+
+  /* and add the new ones */
+  i = 0;
+  while ((val = tr_variantListChild (urls, i++)))
+    {
+      const char * announce = NULL;
+
+      if ( tr_variantGetStr (val, &announce, NULL)
+          && tr_urlIsValidTracker (announce)
+          && !findAnnounceUrl (trackers, n, announce, NULL))
+        {
+          trackers[n].tier = ++tier; /* add a new tier */
+          trackers[n].announce = tr_strdup (announce);
+          ++n;
+          changed = true;
+        }
+    }
+
+  if (!changed)
+    errmsg = "invalid argument";
+  else if (!tr_torrentSetAnnounceList (tor, trackers, n))
+    errmsg = "error setting announce list";
+
+  freeTrackers (trackers, n);
+  return errmsg;
 }
 
@@ -1108 +1139 @@
 replaceTrackers (tr_torrent * tor, tr_variant * urls)
 {
-    int i;
-    tr_variant * pair[2];
-    tr_tracker_info * trackers;
-    bool changed = false;
-    const tr_info * inf = tr_torrentInfo (tor);
-    const int n = inf->trackerCount;
-    const char * errmsg = NULL;
-
-    /* make a working copy of the existing announce list */
-    trackers = tr_new0 (tr_tracker_info, n);
-    copyTrackers (trackers, inf->trackers, n);
-
-    /* make the substitutions... */
-    i = 0;
-    while (((pair[0] = tr_variantListChild (urls,i))) &&
-        ((pair[1] = tr_variantListChild (urls,i+1))))
-    {
-        size_t len;
-        int64_t pos;
-        const char * newval;
-
-        if ( tr_variantGetInt (pair[0], &pos)
-            && tr_variantGetStr (pair[1], &newval, &len)
-            && tr_urlIsValidTracker (newval)
-            && pos < n
-            && pos >= 0)
-        {
-            tr_free (trackers[pos].announce);
-            trackers[pos].announce = tr_strndup (newval, len);
-            changed = true;
-        }
-
-        i += 2;
-    }
-
-    if (!changed)
-        errmsg = "invalid argument";
-    else if (!tr_torrentSetAnnounceList (tor, trackers, n))
-        errmsg = "error setting announce list";
-
-    freeTrackers (trackers, n);
-    return errmsg;
+  int i;
+  tr_variant * pair[2];
+  tr_tracker_info * trackers;
+  bool changed = false;
+  const tr_info * inf = tr_torrentInfo (tor);
+  const int n = inf->trackerCount;
+  const char * errmsg = NULL;
+
+  /* make a working copy of the existing announce list */
+  trackers = tr_new0 (tr_tracker_info, n);
+  copyTrackers (trackers, inf->trackers, n);
+
+  /* make the substitutions... */
+  i = 0;
+  while (((pair[0] = tr_variantListChild (urls,i))) &&
+         ((pair[1] = tr_variantListChild (urls,i+1))))
+    {
+      size_t len;
+      int64_t pos;
+      const char * newval;
+
+      if (tr_variantGetInt (pair[0], &pos)
+          && tr_variantGetStr (pair[1], &newval, &len)
+          && tr_urlIsValidTracker (newval)
+          && pos < n
+          && pos >= 0)
+        {
+          tr_free (trackers[pos].announce);
+          trackers[pos].announce = tr_strndup (newval, len);
+          changed = true;
+        }
+
+      i += 2;
+    }
+
+  if (!changed)
+    errmsg = "invalid argument";
+  else if (!tr_torrentSetAnnounceList (tor, trackers, n))
+    errmsg = "error setting announce list";
+
+  freeTrackers (trackers, n);
+  return errmsg;
 }
 
@@ -1155 +1186 @@
 removeTrackers (tr_torrent * tor, tr_variant * ids)
 {
-    int i;
-    int n;
-    int t = 0;
-    int dup = -1;
-    int * tids;
-    tr_variant * val;
-    tr_tracker_info * trackers;
-    bool changed = false;
-    const tr_info * inf = tr_torrentInfo (tor);
-    const char * errmsg = NULL;
-
-    /* make a working copy of the existing announce list */
-    n = inf->trackerCount;
-    tids = tr_new0 (int, n);
-    trackers = tr_new0 (tr_tracker_info, n);
-    copyTrackers (trackers, inf->trackers, n);
-
-    /* remove the ones specified in the urls list */
-    i = 0;
-    while ((val = tr_variantListChild (ids, i++)))
-    {
-        int64_t pos;
-
-        if ( tr_variantGetInt (val, &pos)
-            && pos < n
-            && pos >= 0)
-            tids[t++] = pos;
-    }
-
-    /* sort trackerIds and remove from largest to smallest so there is no need to recacluate array indicies */
-    qsort (tids, t, sizeof (int), compareInt);
-    while (t--)
-    {
-        /* check for duplicates */
-        if (tids[t] == dup)
-            continue;
-        tr_removeElementFromArray (trackers, tids[t], sizeof (tr_tracker_info), n--);
-        dup = tids[t];
-        changed = true;
-    }
-
-    if (!changed)
-        errmsg = "invalid argument";
-    else if (!tr_torrentSetAnnounceList (tor, trackers, n))
-        errmsg = "error setting announce list";
-
-    freeTrackers (trackers, n);
-    tr_free (tids);
-    return errmsg;
+  int i;
+  int n;
+  int t = 0;
+  int dup = -1;
+  int * tids;
+  tr_variant * val;
+  tr_tracker_info * trackers;
+  bool changed = false;
+  const tr_info * inf = tr_torrentInfo (tor);
+  const char * errmsg = NULL;
+
+  /* make a working copy of the existing announce list */
+  n = inf->trackerCount;
+  tids = tr_new0 (int, n);
+  trackers = tr_new0 (tr_tracker_info, n);
+  copyTrackers (trackers, inf->trackers, n);
+
+  /* remove the ones specified in the urls list */
+  i = 0;
+  while ((val = tr_variantListChild (ids, i++)))
+    {
+      int64_t pos;
+
+      if (tr_variantGetInt (val, &pos) && (0 <= pos) && (pos < n))
+        tids[t++] = pos;
+    }
+
+  /* sort trackerIds and remove from largest to smallest so there is no need to recacluate array indicies */
+  qsort (tids, t, sizeof (int), compareInt);
+  while (t--)
+    {
+      /* check for duplicates */
+      if (tids[t] == dup)
+        continue;
+      tr_removeElementFromArray (trackers, tids[t], sizeof (tr_tracker_info), n--);
+      dup = tids[t];
+      changed = true;
+    }
+
+  if (!changed)
+    errmsg = "invalid argument";
+  else if (!tr_torrentSetAnnounceList (tor, trackers, n))
+    errmsg = "error setting announce list";
+
+  freeTrackers (trackers, n);
+  tr_free (tids);
+  return errmsg;
 }
 
@@ -1212 +1241 @@
             struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    const char * errmsg = NULL;
-    int i, torrentCount;
-    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
-
-    assert (idle_data == NULL);
-
-    for (i = 0; i < torrentCount; ++i)
-    {
-        int64_t      tmp;
-        double       d;
-        tr_variant *    files;
-        tr_variant *    trackers;
-        bool         boolVal;
-        tr_torrent * tor = torrents[i];
-
-        if (tr_variantDictFindInt (args_in, TR_KEY_bandwidthPriority, &tmp))
-            if (tr_isPriority (tmp))
-                tr_torrentSetPriority (tor, tmp);
-        if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_files_unwanted, &files))
-            errmsg = setFileDLs (tor, false, files);
-        if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_files_wanted, &files))
-            errmsg = setFileDLs (tor, true, files);
-        if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit, &tmp))
-            tr_torrentSetPeerLimit (tor, tmp);
-        if (!errmsg &&  tr_variantDictFindList (args_in, TR_KEY_priority_high, &files))
-            errmsg = setFilePriorities (tor, TR_PRI_HIGH, files);
-        if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_priority_low, &files))
-            errmsg = setFilePriorities (tor, TR_PRI_LOW, files);
-        if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_priority_normal, &files))
-            errmsg = setFilePriorities (tor, TR_PRI_NORMAL, files);
-        if (tr_variantDictFindInt (args_in, TR_KEY_downloadLimit, &tmp))
-            tr_torrentSetSpeedLimit_KBps (tor, TR_DOWN, tmp);
-        if (tr_variantDictFindBool (args_in, TR_KEY_downloadLimited, &boolVal))
-            tr_torrentUseSpeedLimit (tor, TR_DOWN, boolVal);
-        if (tr_variantDictFindBool (args_in, TR_KEY_honorsSessionLimits, &boolVal))
-            tr_torrentUseSessionLimits (tor, boolVal);
-        if (tr_variantDictFindInt (args_in, TR_KEY_uploadLimit, &tmp))
-            tr_torrentSetSpeedLimit_KBps (tor, TR_UP, tmp);
-        if (tr_variantDictFindBool (args_in, TR_KEY_uploadLimited, &boolVal))
-            tr_torrentUseSpeedLimit (tor, TR_UP, boolVal);
-        if (tr_variantDictFindInt (args_in, TR_KEY_seedIdleLimit, &tmp))
-            tr_torrentSetIdleLimit (tor, tmp);
-        if (tr_variantDictFindInt (args_in, TR_KEY_seedIdleMode, &tmp))
-            tr_torrentSetIdleMode (tor, tmp);
-        if (tr_variantDictFindReal (args_in, TR_KEY_seedRatioLimit, &d))
-            tr_torrentSetRatioLimit (tor, d);
-        if (tr_variantDictFindInt (args_in, TR_KEY_seedRatioMode, &tmp))
-            tr_torrentSetRatioMode (tor, tmp);
-        if (tr_variantDictFindInt (args_in, TR_KEY_queuePosition, &tmp))
-            tr_torrentSetQueuePosition (tor, tmp);
-        if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerAdd, &trackers))
-            errmsg = addTrackerUrls (tor, trackers);
-        if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerRemove, &trackers))
-            errmsg = removeTrackers (tor, trackers);
-        if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerReplace, &trackers))
-            errmsg = replaceTrackers (tor, trackers);
-        notify (session, TR_RPC_TORRENT_CHANGED, tor);
-    }
-
-    tr_free (torrents);
-    return errmsg;
+  int i;
+  int torrentCount;
+  tr_torrent ** torrents;
+  const char * errmsg = NULL;
+
+  assert (idle_data == NULL);
+
+  torrents = getTorrents (session, args_in, &torrentCount);
+
+  for (i=0; i<torrentCount; ++i)
+    {
+      int64_t tmp;
+      double d;
+      tr_variant * files;
+      tr_variant * trackers;
+      bool boolVal;
+      tr_torrent * tor;
+
+      tor = torrents[i];
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_bandwidthPriority, &tmp))
+        if (tr_isPriority (tmp))
+          tr_torrentSetPriority (tor, tmp);
+
+      if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_files_unwanted, &files))
+        errmsg = setFileDLs (tor, false, files);
+
+      if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_files_wanted, &files))
+        errmsg = setFileDLs (tor, true, files);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit, &tmp))
+        tr_torrentSetPeerLimit (tor, tmp);
+
+      if (!errmsg &&  tr_variantDictFindList (args_in, TR_KEY_priority_high, &files))
+        errmsg = setFilePriorities (tor, TR_PRI_HIGH, files);
+
+      if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_priority_low, &files))
+        errmsg = setFilePriorities (tor, TR_PRI_LOW, files);
+
+      if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_priority_normal, &files))
+        errmsg = setFilePriorities (tor, TR_PRI_NORMAL, files);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_downloadLimit, &tmp))
+        tr_torrentSetSpeedLimit_KBps (tor, TR_DOWN, tmp);
+
+      if (tr_variantDictFindBool (args_in, TR_KEY_downloadLimited, &boolVal))
+        tr_torrentUseSpeedLimit (tor, TR_DOWN, boolVal);
+
+      if (tr_variantDictFindBool (args_in, TR_KEY_honorsSessionLimits, &boolVal))
+        tr_torrentUseSessionLimits (tor, boolVal);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_uploadLimit, &tmp))
+        tr_torrentSetSpeedLimit_KBps (tor, TR_UP, tmp);
+
+      if (tr_variantDictFindBool (args_in, TR_KEY_uploadLimited, &boolVal))
+        tr_torrentUseSpeedLimit (tor, TR_UP, boolVal);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_seedIdleLimit, &tmp))
+        tr_torrentSetIdleLimit (tor, tmp);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_seedIdleMode, &tmp))
+        tr_torrentSetIdleMode (tor, tmp);
+
+      if (tr_variantDictFindReal (args_in, TR_KEY_seedRatioLimit, &d))
+        tr_torrentSetRatioLimit (tor, d);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_seedRatioMode, &tmp))
+        tr_torrentSetRatioMode (tor, tmp);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_queuePosition, &tmp))
+        tr_torrentSetQueuePosition (tor, tmp);
+
+      if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerAdd, &trackers))
+        errmsg = addTrackerUrls (tor, trackers);
+
+      if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerRemove, &trackers))
+        errmsg = removeTrackers (tor, trackers);
+
+      if (!errmsg && tr_variantDictFindList (args_in, TR_KEY_trackerReplace, &trackers))
+        errmsg = replaceTrackers (tor, trackers);
+
+      notify (session, TR_RPC_TORRENT_CHANGED, tor);
+    }
+
+  tr_free (torrents);
+  return errmsg;
 }
 
@@ -1375 +1429 @@
             void             * user_data)
 {
-    char result[1024];
-    struct tr_rpc_idle_data * data = user_data;
-
-    if (response_code != 200)
-    {
-        tr_snprintf (result, sizeof (result), "portTested: http error %ld: %s",
-                     response_code, tr_webGetResponseStr (response_code));
-    }
-    else /* success */
-    {
-        const bool isOpen = response_byte_count && * (char*)response == '1';
-        tr_variantDictAddBool (data->args_out, TR_KEY_port_is_open, isOpen);
-        tr_snprintf (result, sizeof (result), "success");
+  char result[1024];
+  struct tr_rpc_idle_data * data = user_data;
+
+  if (response_code != 200)
+    {
+      tr_snprintf (result, sizeof (result), "portTested: http error %ld: %s",
+                   response_code, tr_webGetResponseStr (response_code));
+    }
+  else /* success */
+    {
+      const bool isOpen = response_byte_count && * (char*)response == '1';
+      tr_variantDictAddBool (data->args_out, TR_KEY_port_is_open, isOpen);
+      tr_snprintf (result, sizeof (result), "success");
     }
 
@@ -1399 +1453 @@
           struct tr_rpc_idle_data  * idle_data)
 {
-    const int port = tr_sessionGetPeerPort (session);
-    char * url = tr_strdup_printf ("http://portcheck.transmissionbt.com/%d", port);
-    tr_webRun (session, url, portTested, idle_data);
-    tr_free (url);
-    return NULL;
+  const int port = tr_sessionGetPeerPort (session);
+  char * url = tr_strdup_printf ("http://portcheck.transmissionbt.com/%d", port);
+  tr_webRun (session, url, portTested, idle_data);
+  tr_free (url);
+  return NULL;
 }
 
@@ -1419 +1473 @@
                  void             * user_data)
 {
-    char result[1024];
-    struct tr_rpc_idle_data * data = user_data;
-
-    *result = '\0';
-
-    if (response_code != 200)
-    {
-        tr_snprintf (result, sizeof (result), "gotNewBlocklist: http error %ld: %s",
-                     response_code, tr_webGetResponseStr (response_code));
-    }
-    else /* successfully fetched the blocklist... */
-    {
-        int fd;
-        int err;
-        char * filename;
-        z_stream stream;
-        const char * configDir = tr_sessionGetConfigDir (session);
-        const size_t buflen = 1024 * 128; /* 128 KiB buffer */
-        uint8_t * buf = tr_valloc (buflen);
-
-        /* this is an odd Magic Number required by zlib to enable gz support.
-           See zlib's inflateInit2 () documentation for a full description */
-        const int windowBits = 15 + 32;
-
-        stream.zalloc = (alloc_func) Z_NULL;
-        stream.zfree = (free_func) Z_NULL;
-        stream.opaque = (voidpf) Z_NULL;
-        stream.next_in = (void*) response;
-        stream.avail_in = response_byte_count;
-        inflateInit2 (&stream, windowBits);
-
-        filename = tr_buildPath (configDir, "blocklist.tmp", NULL);
-        fd = tr_open_file_for_writing (filename);
-        if (fd < 0)
-            tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
-
-        for (;;)
-        {
-            stream.next_out = (void*) buf;
-            stream.avail_out = buflen;
-            err = inflate (&stream, Z_NO_FLUSH);
-
-            if (stream.avail_out < buflen) {
-                const int e = write (fd, buf, buflen - stream.avail_out);
-                if (e < 0) {
-                    tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
-                    break;
+  char result[1024];
+  struct tr_rpc_idle_data * data = user_data;
+
+  *result = '\0';
+
+  if (response_code != 200)
+    {
+      tr_snprintf (result, sizeof (result), "gotNewBlocklist: http error %ld: %s",
+                   response_code, tr_webGetResponseStr (response_code));
+    }
+  else /* successfully fetched the blocklist... */
+    {
+      int fd;
+      int err;
+      char * filename;
+      z_stream stream;
+      const char * configDir = tr_sessionGetConfigDir (session);
+      const size_t buflen = 1024 * 128; /* 128 KiB buffer */
+      uint8_t * buf = tr_valloc (buflen);
+
+      /* this is an odd Magic Number required by zlib to enable gz support.
+         See zlib's inflateInit2 () documentation for a full description */
+      const int windowBits = 15 + 32;
+
+      stream.zalloc = (alloc_func) Z_NULL;
+      stream.zfree = (free_func) Z_NULL;
+      stream.opaque = (voidpf) Z_NULL;
+      stream.next_in = (void*) response;
+      stream.avail_in = response_byte_count;
+      inflateInit2 (&stream, windowBits);
+
+      filename = tr_buildPath (configDir, "blocklist.tmp", NULL);
+      fd = tr_open_file_for_writing (filename);
+      if (fd < 0)
+        tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
+
+      for (;;)
+        {
+          stream.next_out = (void*) buf;
+          stream.avail_out = buflen;
+          err = inflate (&stream, Z_NO_FLUSH);
+
+          if (stream.avail_out < buflen)
+            {
+              const int e = write (fd, buf, buflen - stream.avail_out);
+              if (e < 0)
+                {
+                  tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
+                  break;
                 }
             }
 
-            if (err != Z_OK) {
-                if ((err != Z_STREAM_END) && (err != Z_DATA_ERROR))
-                    tr_snprintf (result, sizeof (result), _("Error uncompressing blocklist: %s (%d)"), zError (err), err);
-                break;
+          if (err != Z_OK)
+            {
+              if ((err != Z_STREAM_END) && (err != Z_DATA_ERROR))
+                tr_snprintf (result, sizeof (result), _("Error uncompressing blocklist: %s (%d)"), zError (err), err);
+              break;
             }
         }
 
-        inflateEnd (&stream);
-
-        if (err == Z_DATA_ERROR) /* couldn't inflate it... it's probably already uncompressed */
-            if (write (fd, response, response_byte_count) < 0)
-                tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
-
-        if (*result)
-            tr_logAddError ("%s", result);
-        else {
-            /* feed it to the session and give the client a response */
-            const int rule_count = tr_blocklistSetContent (session, filename);
-            tr_variantDictAddInt (data->args_out, TR_KEY_blocklist_size, rule_count);
-            tr_snprintf (result, sizeof (result), "success");
-        }
-
-        tr_remove (filename);
-        tr_free (filename);
-        tr_free (buf);
-    }
-
-    tr_idle_function_done (data, result);
+      inflateEnd (&stream);
+
+      if (err == Z_DATA_ERROR) /* couldn't inflate it... it's probably already uncompressed */
+        if (write (fd, response, response_byte_count) < 0)
+          tr_snprintf (result, sizeof (result), _("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
+
+      if (*result)
+        {
+          tr_logAddError ("%s", result);
+        }
+      else
+        {
+          /* feed it to the session and give the client a response */
+          const int rule_count = tr_blocklistSetContent (session, filename);
+          tr_variantDictAddInt (data->args_out, TR_KEY_blocklist_size, rule_count);
+          tr_snprintf (result, sizeof (result), "success");
+        }
+
+      tr_remove (filename);
+      tr_free (filename);
+      tr_free (buf);
+    }
+
+  tr_idle_function_done (data, result);
 }
 
@@ -1505 +1565 @@
                  struct tr_rpc_idle_data  * idle_data)
 {
-    tr_webRun (session, session->blocklist_url, gotNewBlocklist, idle_data);
-    return NULL;
+  tr_webRun (session, session->blocklist_url, gotNewBlocklist, idle_data);
+  return NULL;
 }
 
@@ -1561 +1621 @@
 struct add_torrent_idle_data
 {
-    struct tr_rpc_idle_data * data;
-    tr_ctor * ctor;
+  struct tr_rpc_idle_data * data;
+  tr_ctor * ctor;
 };
 
@@ -1574 +1634 @@
                     void             * user_data)
 {
-    struct add_torrent_idle_data * data = user_data;
-
-    dbgmsg ("torrentAdd: HTTP response code was %ld (%s); response length was %zu bytes",
-            response_code, tr_webGetResponseStr (response_code), response_byte_count);
-
-    if (response_code==200 || response_code==221) /* http or ftp success.. */
-    {
-        tr_ctorSetMetainfo (data->ctor, response, response_byte_count);
-        addTorrentImpl (data->data, data->ctor);
-    }
-    else
-    {
-        char result[1024];
-        tr_snprintf (result, sizeof (result), "gotMetadataFromURL: http error %ld: %s",
-                     response_code, tr_webGetResponseStr (response_code));
-        tr_idle_function_done (data->data, result);
-    }
-
-    tr_free (data);
+  struct add_torrent_idle_data * data = user_data;
+
+  dbgmsg ("torrentAdd: HTTP response code was %ld (%s); response length was %zu bytes",
+          response_code, tr_webGetResponseStr (response_code), response_byte_count);
+
+  if (response_code==200 || response_code==221) /* http or ftp success.. */
+    {
+      tr_ctorSetMetainfo (data->ctor, response, response_byte_count);
+      addTorrentImpl (data->data, data->ctor);
+    }
+  else
+    {
+      char result[1024];
+      tr_snprintf (result, sizeof (result), "gotMetadataFromURL: http error %ld: %s",
+                   response_code, tr_webGetResponseStr (response_code));
+      tr_idle_function_done (data->data, result);
+    }
+
+  tr_free (data);
 }
 
@@ -1598 +1658 @@
 isCurlURL (const char * filename)
 {
-    if (filename == NULL)
-        return false;
-
-    return !strncmp (filename, "ftp://", 6) ||
-           !strncmp (filename, "http://", 7) ||
-           !strncmp (filename, "https://", 8);
+  if (filename == NULL)
+    return false;
+
+  return !strncmp (filename, "ftp://", 6) ||
+         !strncmp (filename, "http://", 7) ||
+         !strncmp (filename, "https://", 8);
 }
 
@@ -1609 +1669 @@
 fileListFromList (tr_variant * list, tr_file_index_t * setmeCount)
 {
-    size_t i;
-    const size_t childCount = tr_variantListSize (list);
-    tr_file_index_t n = 0;
-    tr_file_index_t * files = tr_new0 (tr_file_index_t, childCount);
-
-    for (i=0; i<childCount; ++i) {
-        int64_t intVal;
-        if (tr_variantGetInt (tr_variantListChild (list, i), &intVal))
-            files[n++] = (tr_file_index_t)intVal;
-    }
-
-    *setmeCount = n;
-    return files;
+  size_t i;
+  const size_t childCount = tr_variantListSize (list);
+  tr_file_index_t n = 0;
+  tr_file_index_t * files = tr_new0 (tr_file_index_t, childCount);
+
+  for (i=0; i<childCount; ++i)
+    {
+      int64_t intVal;
+      if (tr_variantGetInt (tr_variantListChild (list, i), &intVal))
+        files[n++] = (tr_file_index_t)intVal;
+    }
+
+  *setmeCount = n;
+  return files;
 }
 
@@ -1630 +1691 @@
             struct tr_rpc_idle_data  * idle_data)
 {
-    const char * filename = NULL;
-    const char * metainfo_base64 = NULL;
-
-    assert (idle_data != NULL);
-
-    tr_variantDictFindStr (args_in, TR_KEY_filename, &filename, NULL);
-    tr_variantDictFindStr (args_in, TR_KEY_metainfo, &metainfo_base64, NULL);
-    if (!filename && !metainfo_base64)
-        return "no filename or metainfo specified";
-    else
-    {
-        int64_t      i;
-        bool         boolVal;
-        tr_variant    * l;
-        const char * str;
-        const char * cookies = NULL;
-        tr_ctor    * ctor = tr_ctorNew (session);
-
-        /* set the optional arguments */
-
-        tr_variantDictFindStr (args_in, TR_KEY_cookies, &cookies, NULL);
-
-        if (tr_variantDictFindStr (args_in, TR_KEY_download_dir, &str, NULL))
-            tr_ctorSetDownloadDir (ctor, TR_FORCE, str);
-
-        if (tr_variantDictFindBool (args_in, TR_KEY_paused, &boolVal))
-            tr_ctorSetPaused (ctor, TR_FORCE, boolVal);
-
-        if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit, &i))
-            tr_ctorSetPeerLimit (ctor, TR_FORCE, i);
-
-        if (tr_variantDictFindInt (args_in, TR_KEY_bandwidthPriority, &i))
-            tr_ctorSetBandwidthPriority (ctor, i);
-
-        if (tr_variantDictFindList (args_in, TR_KEY_files_unwanted, &l)) {
-            tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList (l, &fileCount);
-            tr_ctorSetFilesWanted (ctor, files, fileCount, false);
-            tr_free (files);
-        }
-        if (tr_variantDictFindList (args_in, TR_KEY_files_wanted, &l)) {
-            tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList (l, &fileCount);
-            tr_ctorSetFilesWanted (ctor, files, fileCount, true);
-            tr_free (files);
-        }
-
-        if (tr_variantDictFindList (args_in, TR_KEY_priority_low, &l)) {
-            tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList (l, &fileCount);
-            tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_LOW);
-            tr_free (files);
-        }
-        if (tr_variantDictFindList (args_in, TR_KEY_priority_normal, &l)) {
-            tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList (l, &fileCount);
-            tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_NORMAL);
-            tr_free (files);
-        }
-        if (tr_variantDictFindList (args_in, TR_KEY_priority_high, &l)) {
-            tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList (l, &fileCount);
-            tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_HIGH);
-            tr_free (files);
-        }
-
-        dbgmsg ("torrentAdd: filename is \"%s\"", filename ? filename : " (null)");
-
-        if (isCurlURL (filename))
-        {
-            struct add_torrent_idle_data * d = tr_new0 (struct add_torrent_idle_data, 1);
-            d->data = idle_data;
-            d->ctor = ctor;
-            tr_webRunWithCookies (session, filename, cookies, gotMetadataFromURL, d);
-        }
-        else
-        {
-            char * fname = tr_strstrip (tr_strdup (filename));
-
-            if (fname == NULL)
+  const char * filename = NULL;
+  const char * metainfo_base64 = NULL;
+
+  assert (idle_data != NULL);
+
+  tr_variantDictFindStr (args_in, TR_KEY_filename, &filename, NULL);
+  tr_variantDictFindStr (args_in, TR_KEY_metainfo, &metainfo_base64, NULL);
+  if (!filename && !metainfo_base64)
+    {
+      return "no filename or metainfo specified";
+    }
+  else
+    {
+      int64_t i;
+      bool boolVal;
+      tr_variant * l;
+      const char * str;
+      const char * cookies = NULL;
+      tr_ctor * ctor = tr_ctorNew (session);
+
+      /* set the optional arguments */
+
+      tr_variantDictFindStr (args_in, TR_KEY_cookies, &cookies, NULL);
+
+      if (tr_variantDictFindStr (args_in, TR_KEY_download_dir, &str, NULL))
+        tr_ctorSetDownloadDir (ctor, TR_FORCE, str);
+
+      if (tr_variantDictFindBool (args_in, TR_KEY_paused, &boolVal))
+        tr_ctorSetPaused (ctor, TR_FORCE, boolVal);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit, &i))
+        tr_ctorSetPeerLimit (ctor, TR_FORCE, i);
+
+      if (tr_variantDictFindInt (args_in, TR_KEY_bandwidthPriority, &i))
+        tr_ctorSetBandwidthPriority (ctor, i);
+
+      if (tr_variantDictFindList (args_in, TR_KEY_files_unwanted, &l))
+        {
+          tr_file_index_t fileCount;
+          tr_file_index_t * files = fileListFromList (l, &fileCount);
+          tr_ctorSetFilesWanted (ctor, files, fileCount, false);
+          tr_free (files);
+        }
+
+      if (tr_variantDictFindList (args_in, TR_KEY_files_wanted, &l))
+        {
+          tr_file_index_t fileCount;
+          tr_file_index_t * files = fileListFromList (l, &fileCount);
+          tr_ctorSetFilesWanted (ctor, files, fileCount, true);
+          tr_free (files);
+        }
+
+      if (tr_variantDictFindList (args_in, TR_KEY_priority_low, &l))
+        {
+          tr_file_index_t fileCount;
+          tr_file_index_t * files = fileListFromList (l, &fileCount);
+          tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_LOW);
+          tr_free (files);
+        }
+
+      if (tr_variantDictFindList (args_in, TR_KEY_priority_normal, &l))
+        {
+          tr_file_index_t fileCount;
+          tr_file_index_t * files = fileListFromList (l, &fileCount);
+          tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_NORMAL);
+          tr_free (files);
+        }
+
+      if (tr_variantDictFindList (args_in, TR_KEY_priority_high, &l))
+        {
+          tr_file_index_t fileCount;
+          tr_file_index_t * files = fileListFromList (l, &fileCount);
+          tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_HIGH);
+          tr_free (files);
+        }
+
+      dbgmsg ("torrentAdd: filename is \"%s\"", filename ? filename : " (null)");
+
+      if (isCurlURL (filename))
+        {
+          struct add_torrent_idle_data * d = tr_new0 (struct add_torrent_idle_data, 1);
+          d->data = idle_data;
+          d->ctor = ctor;
+          tr_webRunWithCookies (session, filename, cookies, gotMetadataFromURL, d);
+        }
+      else
+        {
+          char * fname = tr_strstrip (tr_strdup (filename));
+
+          if (fname == NULL)
             {
-                int len;
-                char * metainfo = tr_base64_decode (metainfo_base64, -1, &len);
-                tr_ctorSetMetainfo (ctor, (uint8_t*)metainfo, len);
-                tr_free (metainfo);
+              int len;
+              char * metainfo = tr_base64_decode (metainfo_base64, -1, &len);
+              tr_ctorSetMetainfo (ctor, (uint8_t*)metainfo, len);
+              tr_free (metainfo);
             }
-            else if (!strncmp (fname, "magnet:?", 8))
+          else if (!strncmp (fname, "magnet:?", 8))
             {
-                tr_ctorSetMetainfoFromMagnetLink (ctor, fname);
+              tr_ctorSetMetainfoFromMagnetLink (ctor, fname);
             }
-            else
+          else
             {
-                tr_ctorSetMetainfoFromFile (ctor, fname);
+              tr_ctorSetMetainfoFromFile (ctor, fname);
             }
 
-            addTorrentImpl (idle_data, ctor);
-
-            tr_free (fname);
-        }
-
-    }
-
-    return NULL;
+          addTorrentImpl (idle_data, ctor);
+
+          tr_free (fname);
+        }
+
+    }
+
+  return NULL;
 }
 
@@ -1745 +1816 @@
             struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int64_t      i;
-    double       d;
-    bool         boolVal;
-    const char * str;
-
-    assert (idle_data == NULL);
-
-    if (tr_variantDictFindInt (args_in, TR_KEY_cache_size_mb, &i))
-        tr_sessionSetCacheLimit_MB (session, i);
-    if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_up, &i))
-        tr_sessionSetAltSpeed_KBps (session, TR_UP, i);
-    if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_down, &i))
-        tr_sessionSetAltSpeed_KBps (session, TR_DOWN, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_alt_speed_enabled, &boolVal))
-        tr_sessionUseAltSpeed (session, boolVal);
-    if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_begin, &i))
-        tr_sessionSetAltSpeedBegin (session, i);
-    if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_end, &i))
-        tr_sessionSetAltSpeedEnd (session, i);
-    if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_day, &i))
-        tr_sessionSetAltSpeedDay (session, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_alt_speed_time_enabled, &boolVal))
-        tr_sessionUseAltSpeedTime (session, boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_blocklist_enabled, &boolVal))
-        tr_blocklistSetEnabled (session, boolVal);
-    if (tr_variantDictFindStr (args_in, TR_KEY_blocklist_url, &str, NULL))
-        tr_blocklistSetURL (session, str);
-    if (tr_variantDictFindStr (args_in, TR_KEY_download_dir, &str, NULL))
-        tr_sessionSetDownloadDir (session, str);
-    if (tr_variantDictFindInt (args_in, TR_KEY_queue_stalled_minutes, &i))
-        tr_sessionSetQueueStalledMinutes (session, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_queue_stalled_enabled, &boolVal))
-        tr_sessionSetQueueStalledEnabled (session, boolVal);
-    if (tr_variantDictFindInt (args_in, TR_KEY_download_queue_size, &i))
-        tr_sessionSetQueueSize (session, TR_DOWN, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_download_queue_enabled, &boolVal))
-        tr_sessionSetQueueEnabled (session, TR_DOWN, boolVal);
-    if (tr_variantDictFindStr (args_in, TR_KEY_incomplete_dir, &str, NULL))
-        tr_sessionSetIncompleteDir (session, str);
-    if (tr_variantDictFindBool (args_in, TR_KEY_incomplete_dir_enabled, &boolVal))
-        tr_sessionSetIncompleteDirEnabled (session, boolVal);
-    if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit_global, &i))
-        tr_sessionSetPeerLimit (session, i);
-    if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit_per_torrent, &i))
-        tr_sessionSetPeerLimitPerTorrent (session, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_pex_enabled, &boolVal))
-        tr_sessionSetPexEnabled (session, boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_dht_enabled, &boolVal))
-        tr_sessionSetDHTEnabled (session, boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_utp_enabled, &boolVal))
-        tr_sessionSetUTPEnabled (session, boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_lpd_enabled, &boolVal))
-        tr_sessionSetLPDEnabled (session, boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_peer_port_random_on_start, &boolVal))
-        tr_sessionSetPeerPortRandomOnStart (session, boolVal);
-    if (tr_variantDictFindInt (args_in, TR_KEY_peer_port, &i))
-        tr_sessionSetPeerPort (session, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_port_forwarding_enabled, &boolVal))
-        tr_sessionSetPortForwardingEnabled (session, boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_rename_partial_files, &boolVal))
-        tr_sessionSetIncompleteFileNamingEnabled (session, boolVal);
-    if (tr_variantDictFindReal (args_in, TR_KEY_seedRatioLimit, &d))
-        tr_sessionSetRatioLimit (session, d);
-    if (tr_variantDictFindBool (args_in, TR_KEY_seedRatioLimited, &boolVal))
-        tr_sessionSetRatioLimited (session, boolVal);
-    if (tr_variantDictFindInt (args_in, TR_KEY_idle_seeding_limit, &i))
-        tr_sessionSetIdleLimit (session, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_idle_seeding_limit_enabled, &boolVal))
-        tr_sessionSetIdleLimited (session, boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_start_added_torrents, &boolVal))
-        tr_sessionSetPaused (session, !boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_seed_queue_enabled, &boolVal))
-        tr_sessionSetQueueEnabled (session, TR_UP, boolVal);
-    if (tr_variantDictFindInt (args_in, TR_KEY_seed_queue_size, &i))
-        tr_sessionSetQueueSize (session, TR_UP, i);
-    if (tr_variantDictFindStr (args_in, TR_KEY_script_torrent_done_filename, &str, NULL))
-        tr_sessionSetTorrentDoneScript (session, str);
-    if (tr_variantDictFindBool (args_in, TR_KEY_script_torrent_done_enabled, &boolVal))
-        tr_sessionSetTorrentDoneScriptEnabled (session, boolVal);
-    if (tr_variantDictFindBool (args_in, TR_KEY_trash_original_torrent_files, &boolVal))
-        tr_sessionSetDeleteSource (session, boolVal);
-    if (tr_variantDictFindInt (args_in, TR_KEY_speed_limit_down, &i))
-        tr_sessionSetSpeedLimit_KBps (session, TR_DOWN, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_speed_limit_down_enabled, &boolVal))
-        tr_sessionLimitSpeed (session, TR_DOWN, boolVal);
-    if (tr_variantDictFindInt (args_in, TR_KEY_speed_limit_up, &i))
-        tr_sessionSetSpeedLimit_KBps (session, TR_UP, i);
-    if (tr_variantDictFindBool (args_in, TR_KEY_speed_limit_up_enabled, &boolVal))
-        tr_sessionLimitSpeed (session, TR_UP, boolVal);
-    if (tr_variantDictFindStr (args_in, TR_KEY_encryption, &str, NULL)) {
-        if (!strcmp (str, "required"))
-            tr_sessionSetEncryption (session, TR_ENCRYPTION_REQUIRED);
-        else if (!strcmp (str, "tolerated"))
-            tr_sessionSetEncryption (session, TR_CLEAR_PREFERRED);
-        else
-            tr_sessionSetEncryption (session, TR_ENCRYPTION_PREFERRED);
-    }
-
-    notify (session, TR_RPC_SESSION_CHANGED, NULL);
-
-    return NULL;
+  int64_t i;
+  double d;
+  bool boolVal;
+  const char * str;
+
+  assert (idle_data == NULL);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_cache_size_mb, &i))
+    tr_sessionSetCacheLimit_MB (session, i);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_up, &i))
+    tr_sessionSetAltSpeed_KBps (session, TR_UP, i);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_down, &i))
+    tr_sessionSetAltSpeed_KBps (session, TR_DOWN, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_alt_speed_enabled, &boolVal))
+    tr_sessionUseAltSpeed (session, boolVal);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_begin, &i))
+    tr_sessionSetAltSpeedBegin (session, i);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_end, &i))
+    tr_sessionSetAltSpeedEnd (session, i);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_alt_speed_time_day, &i))
+    tr_sessionSetAltSpeedDay (session, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_alt_speed_time_enabled, &boolVal))
+    tr_sessionUseAltSpeedTime (session, boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_blocklist_enabled, &boolVal))
+    tr_blocklistSetEnabled (session, boolVal);
+
+  if (tr_variantDictFindStr (args_in, TR_KEY_blocklist_url, &str, NULL))
+    tr_blocklistSetURL (session, str);
+
+  if (tr_variantDictFindStr (args_in, TR_KEY_download_dir, &str, NULL))
+    tr_sessionSetDownloadDir (session, str);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_queue_stalled_minutes, &i))
+    tr_sessionSetQueueStalledMinutes (session, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_queue_stalled_enabled, &boolVal))
+    tr_sessionSetQueueStalledEnabled (session, boolVal);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_download_queue_size, &i))
+    tr_sessionSetQueueSize (session, TR_DOWN, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_download_queue_enabled, &boolVal))
+    tr_sessionSetQueueEnabled (session, TR_DOWN, boolVal);
+
+  if (tr_variantDictFindStr (args_in, TR_KEY_incomplete_dir, &str, NULL))
+    tr_sessionSetIncompleteDir (session, str);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_incomplete_dir_enabled, &boolVal))
+    tr_sessionSetIncompleteDirEnabled (session, boolVal);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit_global, &i))
+    tr_sessionSetPeerLimit (session, i);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_peer_limit_per_torrent, &i))
+    tr_sessionSetPeerLimitPerTorrent (session, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_pex_enabled, &boolVal))
+    tr_sessionSetPexEnabled (session, boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_dht_enabled, &boolVal))
+    tr_sessionSetDHTEnabled (session, boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_utp_enabled, &boolVal))
+    tr_sessionSetUTPEnabled (session, boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_lpd_enabled, &boolVal))
+    tr_sessionSetLPDEnabled (session, boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_peer_port_random_on_start, &boolVal))
+    tr_sessionSetPeerPortRandomOnStart (session, boolVal);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_peer_port, &i))
+    tr_sessionSetPeerPort (session, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_port_forwarding_enabled, &boolVal))
+    tr_sessionSetPortForwardingEnabled (session, boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_rename_partial_files, &boolVal))
+    tr_sessionSetIncompleteFileNamingEnabled (session, boolVal);
+
+  if (tr_variantDictFindReal (args_in, TR_KEY_seedRatioLimit, &d))
+    tr_sessionSetRatioLimit (session, d);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_seedRatioLimited, &boolVal))
+    tr_sessionSetRatioLimited (session, boolVal);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_idle_seeding_limit, &i))
+    tr_sessionSetIdleLimit (session, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_idle_seeding_limit_enabled, &boolVal))
+    tr_sessionSetIdleLimited (session, boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_start_added_torrents, &boolVal))
+    tr_sessionSetPaused (session, !boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_seed_queue_enabled, &boolVal))
+    tr_sessionSetQueueEnabled (session, TR_UP, boolVal);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_seed_queue_size, &i))
+    tr_sessionSetQueueSize (session, TR_UP, i);
+
+  if (tr_variantDictFindStr (args_in, TR_KEY_script_torrent_done_filename, &str, NULL))
+    tr_sessionSetTorrentDoneScript (session, str);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_script_torrent_done_enabled, &boolVal))
+    tr_sessionSetTorrentDoneScriptEnabled (session, boolVal);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_trash_original_torrent_files, &boolVal))
+    tr_sessionSetDeleteSource (session, boolVal);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_speed_limit_down, &i))
+    tr_sessionSetSpeedLimit_KBps (session, TR_DOWN, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_speed_limit_down_enabled, &boolVal))
+    tr_sessionLimitSpeed (session, TR_DOWN, boolVal);
+
+  if (tr_variantDictFindInt (args_in, TR_KEY_speed_limit_up, &i))
+    tr_sessionSetSpeedLimit_KBps (session, TR_UP, i);
+
+  if (tr_variantDictFindBool (args_in, TR_KEY_speed_limit_up_enabled, &boolVal))
+    tr_sessionLimitSpeed (session, TR_UP, boolVal);
+
+  if (tr_variantDictFindStr (args_in, TR_KEY_encryption, &str, NULL))
+    {
+      if (!tr_strcmp0 (str, "required"))
+        tr_sessionSetEncryption (session, TR_ENCRYPTION_REQUIRED);
+      else if (!tr_strcmp0 (str, "tolerated"))
+        tr_sessionSetEncryption (session, TR_CLEAR_PREFERRED);
+      else
+        tr_sessionSetEncryption (session, TR_ENCRYPTION_PREFERRED);
+    }
+
+  notify (session, TR_RPC_SESSION_CHANGED, NULL);
+
+  return NULL;
 }
 
 static const char*
 sessionStats (tr_session               * session,
-              tr_variant                  * args_in UNUSED,
-              tr_variant                  * args_out,
+              tr_variant               * args_in UNUSED,
+              tr_variant               * args_out,
               struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    int running = 0;
-    int total = 0;
-    tr_variant * d;
-    tr_session_stats currentStats = { 0.0f, 0, 0, 0, 0, 0 };
-    tr_session_stats cumulativeStats = { 0.0f, 0, 0, 0, 0, 0 };
-    tr_torrent * tor = NULL;
-
-    assert (idle_data == NULL);
-
-    while ((tor = tr_torrentNext (session, tor))) {
-        ++total;
-        if (tor->isRunning)
-            ++running;
-    }
-
-    tr_sessionGetStats (session, &currentStats);
-    tr_sessionGetCumulativeStats (session, &cumulativeStats);
-
-    tr_variantDictAddInt  (args_out, TR_KEY_activeTorrentCount, running);
-    tr_variantDictAddReal (args_out, TR_KEY_downloadSpeed, tr_sessionGetPieceSpeed_Bps (session, TR_DOWN));
-    tr_variantDictAddInt  (args_out, TR_KEY_pausedTorrentCount, total - running);
-    tr_variantDictAddInt  (args_out, TR_KEY_torrentCount, total);
-    tr_variantDictAddReal (args_out, TR_KEY_uploadSpeed, tr_sessionGetPieceSpeed_Bps (session, TR_UP));
-
-    d = tr_variantDictAddDict (args_out, TR_KEY_cumulative_stats, 5);
-    tr_variantDictAddInt (d, TR_KEY_downloadedBytes, cumulativeStats.downloadedBytes);
-    tr_variantDictAddInt (d, TR_KEY_filesAdded, cumulativeStats.filesAdded);
-    tr_variantDictAddInt (d, TR_KEY_secondsActive, cumulativeStats.secondsActive);
-    tr_variantDictAddInt (d, TR_KEY_sessionCount, cumulativeStats.sessionCount);
-    tr_variantDictAddInt (d, TR_KEY_uploadedBytes, cumulativeStats.uploadedBytes);
-
-    d = tr_variantDictAddDict (args_out, TR_KEY_current_stats, 5);
-    tr_variantDictAddInt (d, TR_KEY_downloadedBytes, currentStats.downloadedBytes);
-    tr_variantDictAddInt (d, TR_KEY_filesAdded, currentStats.filesAdded);
-    tr_variantDictAddInt (d, TR_KEY_secondsActive, currentStats.secondsActive);
-    tr_variantDictAddInt (d, TR_KEY_sessionCount, currentStats.sessionCount);
-    tr_variantDictAddInt (d, TR_KEY_uploadedBytes, currentStats.uploadedBytes);
-
-    return NULL;
+  int running = 0;
+  int total = 0;
+  tr_variant * d;
+  tr_session_stats currentStats = { 0.0f, 0, 0, 0, 0, 0 };
+  tr_session_stats cumulativeStats = { 0.0f, 0, 0, 0, 0, 0 };
+  tr_torrent * tor = NULL;
+
+  assert (idle_data == NULL);
+
+  while ((tor = tr_torrentNext (session, tor)))
+    {
+      ++total;
+
+      if (tor->isRunning)
+        ++running;
+    }
+
+  tr_sessionGetStats (session, &currentStats);
+  tr_sessionGetCumulativeStats (session, &cumulativeStats);
+
+  tr_variantDictAddInt  (args_out, TR_KEY_activeTorrentCount, running);
+  tr_variantDictAddReal (args_out, TR_KEY_downloadSpeed, tr_sessionGetPieceSpeed_Bps (session, TR_DOWN));
+  tr_variantDictAddInt  (args_out, TR_KEY_pausedTorrentCount, total - running);
+  tr_variantDictAddInt  (args_out, TR_KEY_torrentCount, total);
+  tr_variantDictAddReal (args_out, TR_KEY_uploadSpeed, tr_sessionGetPieceSpeed_Bps (session, TR_UP));
+
+  d = tr_variantDictAddDict (args_out, TR_KEY_cumulative_stats, 5);
+  tr_variantDictAddInt (d, TR_KEY_downloadedBytes, cumulativeStats.downloadedBytes);
+  tr_variantDictAddInt (d, TR_KEY_filesAdded, cumulativeStats.filesAdded);
+  tr_variantDictAddInt (d, TR_KEY_secondsActive, cumulativeStats.secondsActive);
+  tr_variantDictAddInt (d, TR_KEY_sessionCount, cumulativeStats.sessionCount);
+  tr_variantDictAddInt (d, TR_KEY_uploadedBytes, cumulativeStats.uploadedBytes);
+
+  d = tr_variantDictAddDict (args_out, TR_KEY_current_stats, 5);
+  tr_variantDictAddInt (d, TR_KEY_downloadedBytes, currentStats.downloadedBytes);
+  tr_variantDictAddInt (d, TR_KEY_filesAdded, currentStats.filesAdded);
+  tr_variantDictAddInt (d, TR_KEY_secondsActive, currentStats.secondsActive);
+  tr_variantDictAddInt (d, TR_KEY_sessionCount, currentStats.sessionCount);
+  tr_variantDictAddInt (d, TR_KEY_uploadedBytes, currentStats.uploadedBytes);
+
+  return NULL;
 }
 
@@ -1901 +2016 @@
             struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    const char * str;
-    tr_variant * d = args_out;
-
-    assert (idle_data == NULL);
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_up, tr_sessionGetAltSpeed_KBps (s,TR_UP));
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_down, tr_sessionGetAltSpeed_KBps (s,TR_DOWN));
-    tr_variantDictAddBool (d, TR_KEY_alt_speed_enabled, tr_sessionUsesAltSpeed (s));
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_begin, tr_sessionGetAltSpeedBegin (s));
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_end,tr_sessionGetAltSpeedEnd (s));
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_day,tr_sessionGetAltSpeedDay (s));
-    tr_variantDictAddBool (d, TR_KEY_alt_speed_time_enabled, tr_sessionUsesAltSpeedTime (s));
-    tr_variantDictAddBool (d, TR_KEY_blocklist_enabled, tr_blocklistIsEnabled (s));
-    tr_variantDictAddStr  (d, TR_KEY_blocklist_url, tr_blocklistGetURL (s));
-    tr_variantDictAddInt  (d, TR_KEY_cache_size_mb, tr_sessionGetCacheLimit_MB (s));
-    tr_variantDictAddInt  (d, TR_KEY_blocklist_size, tr_blocklistGetRuleCount (s));
-    tr_variantDictAddStr  (d, TR_KEY_config_dir, tr_sessionGetConfigDir (s));
-    tr_variantDictAddStr  (d, TR_KEY_download_dir, tr_sessionGetDownloadDir (s));
-    tr_variantDictAddInt  (d, TR_KEY_download_dir_free_space, tr_device_info_get_free_space (s->downloadDir));
-    tr_variantDictAddBool (d, TR_KEY_download_queue_enabled, tr_sessionGetQueueEnabled (s, TR_DOWN));
-    tr_variantDictAddInt  (d, TR_KEY_download_queue_size, tr_sessionGetQueueSize (s, TR_DOWN));
-    tr_variantDictAddInt  (d, TR_KEY_peer_limit_global, tr_sessionGetPeerLimit (s));
-    tr_variantDictAddInt  (d, TR_KEY_peer_limit_per_torrent, tr_sessionGetPeerLimitPerTorrent (s));
-    tr_variantDictAddStr  (d, TR_KEY_incomplete_dir, tr_sessionGetIncompleteDir (s));
-    tr_variantDictAddBool (d, TR_KEY_incomplete_dir_enabled, tr_sessionIsIncompleteDirEnabled (s));
-    tr_variantDictAddBool (d, TR_KEY_pex_enabled, tr_sessionIsPexEnabled (s));
-    tr_variantDictAddBool (d, TR_KEY_utp_enabled, tr_sessionIsUTPEnabled (s));
-    tr_variantDictAddBool (d, TR_KEY_dht_enabled, tr_sessionIsDHTEnabled (s));
-    tr_variantDictAddBool (d, TR_KEY_lpd_enabled, tr_sessionIsLPDEnabled (s));
-    tr_variantDictAddInt  (d, TR_KEY_peer_port, tr_sessionGetPeerPort (s));
-    tr_variantDictAddBool (d, TR_KEY_peer_port_random_on_start, tr_sessionGetPeerPortRandomOnStart (s));
-    tr_variantDictAddBool (d, TR_KEY_port_forwarding_enabled, tr_sessionIsPortForwardingEnabled (s));
-    tr_variantDictAddBool (d, TR_KEY_rename_partial_files, tr_sessionIsIncompleteFileNamingEnabled (s));
-    tr_variantDictAddInt  (d, TR_KEY_rpc_version, RPC_VERSION);
-    tr_variantDictAddInt  (d, TR_KEY_rpc_version_minimum, RPC_VERSION_MIN);
-    tr_variantDictAddReal (d, TR_KEY_seedRatioLimit, tr_sessionGetRatioLimit (s));
-    tr_variantDictAddBool (d, TR_KEY_seedRatioLimited, tr_sessionIsRatioLimited (s));
-    tr_variantDictAddInt  (d, TR_KEY_idle_seeding_limit, tr_sessionGetIdleLimit (s));
-    tr_variantDictAddBool (d, TR_KEY_idle_seeding_limit_enabled, tr_sessionIsIdleLimited (s));
-    tr_variantDictAddBool (d, TR_KEY_seed_queue_enabled, tr_sessionGetQueueEnabled (s, TR_UP));
-    tr_variantDictAddInt  (d, TR_KEY_seed_queue_size, tr_sessionGetQueueSize (s, TR_UP));
-    tr_variantDictAddBool (d, TR_KEY_start_added_torrents, !tr_sessionGetPaused (s));
-    tr_variantDictAddBool (d, TR_KEY_trash_original_torrent_files, tr_sessionGetDeleteSource (s));
-    tr_variantDictAddInt  (d, TR_KEY_speed_limit_up, tr_sessionGetSpeedLimit_KBps (s, TR_UP));
-    tr_variantDictAddBool (d, TR_KEY_speed_limit_up_enabled, tr_sessionIsSpeedLimited (s, TR_UP));
-    tr_variantDictAddInt  (d, TR_KEY_speed_limit_down, tr_sessionGetSpeedLimit_KBps (s, TR_DOWN));
-    tr_variantDictAddBool (d, TR_KEY_speed_limit_down_enabled, tr_sessionIsSpeedLimited (s, TR_DOWN));
-    tr_variantDictAddStr  (d, TR_KEY_script_torrent_done_filename, tr_sessionGetTorrentDoneScript (s));
-    tr_variantDictAddBool (d, TR_KEY_script_torrent_done_enabled, tr_sessionIsTorrentDoneScriptEnabled (s));
-    tr_variantDictAddBool (d, TR_KEY_queue_stalled_enabled, tr_sessionGetQueueStalledEnabled (s));
-    tr_variantDictAddInt  (d, TR_KEY_queue_stalled_minutes, tr_sessionGetQueueStalledMinutes (s));
-    tr_formatter_get_units (tr_variantDictAddDict (d, TR_KEY_units, 0));
-    tr_variantDictAddStr  (d, TR_KEY_version, LONG_VERSION_STRING);
-    switch (tr_sessionGetEncryption (s)) {
-        case TR_CLEAR_PREFERRED: str = "tolerated"; break;
-        case TR_ENCRYPTION_REQUIRED: str = "required"; break;
-        default: str = "preferred"; break;
-    }
-    tr_variantDictAddStr (d, TR_KEY_encryption, str);
-
-    return NULL;
+  const char * str;
+  tr_variant * d = args_out;
+
+  assert (idle_data == NULL);
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_up, tr_sessionGetAltSpeed_KBps (s,TR_UP));
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_down, tr_sessionGetAltSpeed_KBps (s,TR_DOWN));
+  tr_variantDictAddBool (d, TR_KEY_alt_speed_enabled, tr_sessionUsesAltSpeed (s));
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_begin, tr_sessionGetAltSpeedBegin (s));
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_end,tr_sessionGetAltSpeedEnd (s));
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_day,tr_sessionGetAltSpeedDay (s));
+  tr_variantDictAddBool (d, TR_KEY_alt_speed_time_enabled, tr_sessionUsesAltSpeedTime (s));
+  tr_variantDictAddBool (d, TR_KEY_blocklist_enabled, tr_blocklistIsEnabled (s));
+  tr_variantDictAddStr  (d, TR_KEY_blocklist_url, tr_blocklistGetURL (s));
+  tr_variantDictAddInt  (d, TR_KEY_cache_size_mb, tr_sessionGetCacheLimit_MB (s));
+  tr_variantDictAddInt  (d, TR_KEY_blocklist_size, tr_blocklistGetRuleCount (s));
+  tr_variantDictAddStr  (d, TR_KEY_config_dir, tr_sessionGetConfigDir (s));
+  tr_variantDictAddStr  (d, TR_KEY_download_dir, tr_sessionGetDownloadDir (s));
+  tr_variantDictAddInt  (d, TR_KEY_download_dir_free_space, tr_device_info_get_free_space (s->downloadDir));
+  tr_variantDictAddBool (d, TR_KEY_download_queue_enabled, tr_sessionGetQueueEnabled (s, TR_DOWN));
+  tr_variantDictAddInt  (d, TR_KEY_download_queue_size, tr_sessionGetQueueSize (s, TR_DOWN));
+  tr_variantDictAddInt  (d, TR_KEY_peer_limit_global, tr_sessionGetPeerLimit (s));
+  tr_variantDictAddInt  (d, TR_KEY_peer_limit_per_torrent, tr_sessionGetPeerLimitPerTorrent (s));
+  tr_variantDictAddStr  (d, TR_KEY_incomplete_dir, tr_sessionGetIncompleteDir (s));
+  tr_variantDictAddBool (d, TR_KEY_incomplete_dir_enabled, tr_sessionIsIncompleteDirEnabled (s));
+  tr_variantDictAddBool (d, TR_KEY_pex_enabled, tr_sessionIsPexEnabled (s));
+  tr_variantDictAddBool (d, TR_KEY_utp_enabled, tr_sessionIsUTPEnabled (s));
+  tr_variantDictAddBool (d, TR_KEY_dht_enabled, tr_sessionIsDHTEnabled (s));
+  tr_variantDictAddBool (d, TR_KEY_lpd_enabled, tr_sessionIsLPDEnabled (s));
+  tr_variantDictAddInt  (d, TR_KEY_peer_port, tr_sessionGetPeerPort (s));
+  tr_variantDictAddBool (d, TR_KEY_peer_port_random_on_start, tr_sessionGetPeerPortRandomOnStart (s));
+  tr_variantDictAddBool (d, TR_KEY_port_forwarding_enabled, tr_sessionIsPortForwardingEnabled (s));
+  tr_variantDictAddBool (d, TR_KEY_rename_partial_files, tr_sessionIsIncompleteFileNamingEnabled (s));
+  tr_variantDictAddInt  (d, TR_KEY_rpc_version, RPC_VERSION);
+  tr_variantDictAddInt  (d, TR_KEY_rpc_version_minimum, RPC_VERSION_MIN);
+  tr_variantDictAddReal (d, TR_KEY_seedRatioLimit, tr_sessionGetRatioLimit (s));
+  tr_variantDictAddBool (d, TR_KEY_seedRatioLimited, tr_sessionIsRatioLimited (s));
+  tr_variantDictAddInt  (d, TR_KEY_idle_seeding_limit, tr_sessionGetIdleLimit (s));
+  tr_variantDictAddBool (d, TR_KEY_idle_seeding_limit_enabled, tr_sessionIsIdleLimited (s));
+  tr_variantDictAddBool (d, TR_KEY_seed_queue_enabled, tr_sessionGetQueueEnabled (s, TR_UP));
+  tr_variantDictAddInt  (d, TR_KEY_seed_queue_size, tr_sessionGetQueueSize (s, TR_UP));
+  tr_variantDictAddBool (d, TR_KEY_start_added_torrents, !tr_sessionGetPaused (s));
+  tr_variantDictAddBool (d, TR_KEY_trash_original_torrent_files, tr_sessionGetDeleteSource (s));
+  tr_variantDictAddInt  (d, TR_KEY_speed_limit_up, tr_sessionGetSpeedLimit_KBps (s, TR_UP));
+  tr_variantDictAddBool (d, TR_KEY_speed_limit_up_enabled, tr_sessionIsSpeedLimited (s, TR_UP));
+  tr_variantDictAddInt  (d, TR_KEY_speed_limit_down, tr_sessionGetSpeedLimit_KBps (s, TR_DOWN));
+  tr_variantDictAddBool (d, TR_KEY_speed_limit_down_enabled, tr_sessionIsSpeedLimited (s, TR_DOWN));
+  tr_variantDictAddStr  (d, TR_KEY_script_torrent_done_filename, tr_sessionGetTorrentDoneScript (s));
+  tr_variantDictAddBool (d, TR_KEY_script_torrent_done_enabled, tr_sessionIsTorrentDoneScriptEnabled (s));
+  tr_variantDictAddBool (d, TR_KEY_queue_stalled_enabled, tr_sessionGetQueueStalledEnabled (s));
+  tr_variantDictAddInt  (d, TR_KEY_queue_stalled_minutes, tr_sessionGetQueueStalledMinutes (s));
+  tr_formatter_get_units (tr_variantDictAddDict (d, TR_KEY_units, 0));
+  tr_variantDictAddStr  (d, TR_KEY_version, LONG_VERSION_STRING);
+  switch (tr_sessionGetEncryption (s))
+    {
+      case TR_CLEAR_PREFERRED: str = "tolerated"; break;
+      case TR_ENCRYPTION_REQUIRED: str = "required"; break;
+      default: str = "preferred"; break;
+    }
+  tr_variantDictAddStr (d, TR_KEY_encryption, str);
+
+  return NULL;
 }
 
@@ -1996 +2112 @@
 static const char*
 sessionClose (tr_session               * session,
-              tr_variant                  * args_in UNUSED,
-              tr_variant                  * args_out UNUSED,
+              tr_variant               * args_in UNUSED,
+              tr_variant               * args_out UNUSED,
               struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    notify (session, TR_RPC_SESSION_CLOSE, NULL);
-    return NULL;
+  notify (session, TR_RPC_SESSION_CLOSE, NULL);
+  return NULL;
 }
 
@@ -2012 +2128 @@
 static struct method
 {
-    const char *  name;
-    bool          immediate;
-    handler       func;
+  const char *  name;
+  bool          immediate;
+  handler       func;
 }
 methods[] =
 {
-    { "port-test",             false, portTest            },
-    { "blocklist-update",      false, blocklistUpdate     },
-    { "free-space",            true,  freeSpace           },
-    { "session-close",         true,  sessionClose        },
-    { "session-get",           true,  sessionGet          },
-    { "session-set",           true,  sessionSet          },
-    { "session-stats",         true,  sessionStats        },
-    { "torrent-add",           false, torrentAdd          },
-    { "torrent-get",           true,  torrentGet          },
-    { "torrent-remove",        true,  torrentRemove       },
-    { "torrent-rename-path",   false, torrentRenamePath   },
-    { "torrent-set",           true,  torrentSet          },
-    { "torrent-set-location",  true,  torrentSetLocation  },
-    { "torrent-start",         true,  torrentStart        },
-    { "torrent-start-now",     true,  torrentStartNow     },
-    { "torrent-stop",          true,  torrentStop         },
-    { "torrent-verify",        true,  torrentVerify       },
-    { "torrent-reannounce",    true,  torrentReannounce   },
-    { "queue-move-top",        true,  queueMoveTop        },
-    { "queue-move-up",         true,  queueMoveUp         },
-    { "queue-move-down",       true,  queueMoveDown       },
-    { "queue-move-bottom",     true,  queueMoveBottom     }
+  { "port-test",             false, portTest            },
+  { "blocklist-update",      false, blocklistUpdate     },
+  { "free-space",            true,  freeSpace           },
+  { "session-close",         true,  sessionClose        },
+  { "session-get",           true,  sessionGet          },
+  { "session-set",           true,  sessionSet          },
+  { "session-stats",         true,  sessionStats        },
+  { "torrent-add",           false, torrentAdd          },
+  { "torrent-get",           true,  torrentGet          },
+  { "torrent-remove",        true,  torrentRemove       },
+  { "torrent-rename-path",   false, torrentRenamePath   },
+  { "torrent-set",           true,  torrentSet          },
+  { "torrent-set-location",  true,  torrentSetLocation  },
+  { "torrent-start",         true,  torrentStart        },
+  { "torrent-start-now",     true,  torrentStartNow     },
+  { "torrent-stop",          true,  torrentStop         },
+  { "torrent-verify",        true,  torrentVerify       },
+  { "torrent-reannounce",    true,  torrentReannounce   },
+  { "queue-move-top",        true,  queueMoveTop        },
+  { "queue-move-up",         true,  queueMoveUp         },
+  { "queue-move-down",       true,  queueMoveDown       },
+  { "queue-move-bottom",     true,  queueMoveBottom     }
 };
 
@@ -2055 +2171 @@
               void                   * callback_user_data)
 {
-    int i;
-    const char * str;
-    tr_variant * args_in = tr_variantDictFind (request, TR_KEY_arguments);
-    const char * result = NULL;
-
-    if (callback == NULL)
-        callback = noop_response_callback;
-
-    /* parse the request */
-    if (!tr_variantDictFindStr (request, TR_KEY_method, &str, NULL))
-        result = "no method name";
-    else {
-        const int n = TR_N_ELEMENTS (methods);
-        for (i = 0; i < n; ++i)
-            if (!strcmp (str, methods[i].name))
-                break;
-        if (i ==n)
-            result = "method name not recognized";
-    }
-
-    /* if we couldn't figure out which method to use, return an error */
-    if (result != NULL)
-    {
-        int64_t tag;
-        tr_variant response;
-        struct evbuffer * buf;
-
-        tr_variantInitDict (&response, 3);
-        tr_variantDictAddDict (&response, TR_KEY_arguments, 0);
-        tr_variantDictAddStr (&response, TR_KEY_result, result);
-        if (tr_variantDictFindInt (request, TR_KEY_tag, &tag))
-            tr_variantDictAddInt (&response, TR_KEY_tag, tag);
-
-        buf = tr_variantToBuf (&response, TR_VARIANT_FMT_JSON_LEAN);
+  int i;
+  const char * str;
+  tr_variant * args_in = tr_variantDictFind (request, TR_KEY_arguments);
+  const char * result = NULL;
+
+  if (callback == NULL)
+    callback = noop_response_callback;
+
+  /* parse the request */
+  if (!tr_variantDictFindStr (request, TR_KEY_method, &str, NULL))
+    {
+      result = "no method name";
+    }
+  else
+    {
+      const int n = TR_N_ELEMENTS (methods);
+
+      for (i=0; i<n; ++i)
+        if (!strcmp (str, methods[i].name))
+          break;
+
+      if (i ==n)
+        result = "method name not recognized";
+    }
+
+  /* if we couldn't figure out which method to use, return an error */
+  if (result != NULL)
+    {
+      int64_t tag;
+      tr_variant response;
+      struct evbuffer * buf;
+
+      tr_variantInitDict (&response, 3);
+      tr_variantDictAddDict (&response, TR_KEY_arguments, 0);
+      tr_variantDictAddStr (&response, TR_KEY_result, result);
+      if (tr_variantDictFindInt (request, TR_KEY_tag, &tag))
+        tr_variantDictAddInt (&response, TR_KEY_tag, tag);
+
+      buf = tr_variantToBuf (&response, TR_VARIANT_FMT_JSON_LEAN);
       (*callback)(session, buf, callback_user_data);
-        evbuffer_free (buf);
-
-        tr_variantFree (&response);
-    }
-    else if (methods[i].immediate)
-    {
-        int64_t tag;
-        tr_variant response;
-        tr_variant * args_out;
-        struct evbuffer * buf;
-
-        tr_variantInitDict (&response, 3);
-        args_out = tr_variantDictAddDict (&response, TR_KEY_arguments, 0);
-        result = (*methods[i].func)(session, args_in, args_out, NULL);
-        if (result == NULL)
-            result = "success";
-        tr_variantDictAddStr (&response, TR_KEY_result, result);
-        if (tr_variantDictFindInt (request, TR_KEY_tag, &tag))
-            tr_variantDictAddInt (&response, TR_KEY_tag, tag);
-
-        buf = tr_variantToBuf (&response, TR_VARIANT_FMT_JSON_LEAN);
-        (*callback)(session, buf, callback_user_data);
-        evbuffer_free (buf);
-
-        tr_variantFree (&response);
-    }
-    else
-    {
-        int64_t tag;
-        struct tr_rpc_idle_data * data = tr_new0 (struct tr_rpc_idle_data, 1);
-        data->session = session;
-        data->response = tr_new0 (tr_variant, 1);
-        tr_variantInitDict (data->response, 3);
-        if (tr_variantDictFindInt (request, TR_KEY_tag, &tag))
-            tr_variantDictAddInt (data->response, TR_KEY_tag, tag);
-        data->args_out = tr_variantDictAddDict (data->response, TR_KEY_arguments, 0);
-        data->callback = callback;
-        data->callback_user_data = callback_user_data;
-        (*methods[i].func)(session, args_in, data->args_out, data);
+      evbuffer_free (buf);
+
+      tr_variantFree (&response);
+    }
+  else if (methods[i].immediate)
+    {
+      int64_t tag;
+      tr_variant response;
+      tr_variant * args_out;
+      struct evbuffer * buf;
+
+      tr_variantInitDict (&response, 3);
+      args_out = tr_variantDictAddDict (&response, TR_KEY_arguments, 0);
+      result = (*methods[i].func)(session, args_in, args_out, NULL);
+      if (result == NULL)
+        result = "success";
+      tr_variantDictAddStr (&response, TR_KEY_result, result);
+      if (tr_variantDictFindInt (request, TR_KEY_tag, &tag))
+        tr_variantDictAddInt (&response, TR_KEY_tag, tag);
+
+      buf = tr_variantToBuf (&response, TR_VARIANT_FMT_JSON_LEAN);
+      (*callback)(session, buf, callback_user_data);
+      evbuffer_free (buf);
+
+      tr_variantFree (&response);
+    }
+  else
+    {
+      int64_t tag;
+      struct tr_rpc_idle_data * data = tr_new0 (struct tr_rpc_idle_data, 1);
+      data->session = session;
+      data->response = tr_new0 (tr_variant, 1);
+      tr_variantInitDict (data->response, 3);
+      if (tr_variantDictFindInt (request, TR_KEY_tag, &tag))
+        tr_variantDictAddInt (data->response, TR_KEY_tag, tag);
+      data->args_out = tr_variantDictAddDict (data->response, TR_KEY_arguments, 0);
+      data->callback = callback;
+      data->callback_user_data = callback_user_data;
+      (*methods[i].func)(session, args_in, data->args_out, data);
     }
 }
@@ -2139 +2260 @@
                           void                  * callback_user_data)
 {
-    tr_variant top;
-    int have_content;
-
-    if (request_len < 0)
-        request_len = strlen (request_json);
-
-    have_content = !tr_variantFromJson (&top, request_json, request_len);
-    request_exec (session, have_content ? &top : NULL, callback, callback_user_data);
-
-    if (have_content)
-        tr_variantFree (&top);
+  tr_variant top;
+  int have_content;
+
+  if (request_len < 0)
+    request_len = strlen (request_json);
+
+  have_content = !tr_variantFromJson (&top, request_json, request_len);
+  request_exec (session, have_content ? &top : NULL, callback, callback_user_data);
+
+  if (have_content)
+    tr_variantFree (&top);
 }
 
@@ -2167 +2288 @@
 
 {
-    int valueCount;
-    int * values = tr_parseNumberRange (str, len, &valueCount);
-
-    if (valueCount == 0)
-        tr_variantInitStr (setme, str, len);
-    else if (valueCount == 1)
-        tr_variantInitInt (setme, values[0]);
-    else {
-        int i;
-        tr_variantInitList (setme, valueCount);
-        for (i=0; i<valueCount; ++i)
-            tr_variantListAddInt (setme, values[i]);
-    }
-
-    tr_free (values);
+  int valueCount;
+  int * values = tr_parseNumberRange (str, len, &valueCount);
+
+  if (valueCount == 0)
+    {
+      tr_variantInitStr (setme, str, len);
+    }
+  else if (valueCount == 1)
+    {
+      tr_variantInitInt (setme, values[0]);
+    }
+  else
+    {
+      int i;
+
+      tr_variantInitList (setme, valueCount);
+
+      for (i=0; i<valueCount; ++i)
+        tr_variantListAddInt (setme, values[i]);
+    }
+
+  tr_free (values);
 }
 
@@ -2191 +2319 @@
                          void                 * callback_user_data)
 {
-    tr_variant      top, * args;
-    char *       request = tr_strndup (request_uri, request_len);
-    const char * pch;
-
-    tr_variantInitDict (&top, 3);
-    args = tr_variantDictAddDict (&top, TR_KEY_arguments, 0);
-
-    pch = strchr (request, '?');
-    if (!pch) pch = request;
-    while (pch)
-    {
-        const char * delim = strchr (pch, '=');
-        const char * next = strchr (pch, '&');
-        if (delim)
-        {
-            char *    key = tr_strndup (pch, delim - pch);
-            int       isArg = strcmp (key, "method") && strcmp (key, "tag");
-            tr_variant * parent = isArg ? args : &top;
-            tr_rpc_parse_list_str (tr_variantDictAdd (parent, tr_quark_new (key, delim-pch)),
-                                  delim + 1,
-                                  next ? (size_t)(
-                                       next -
-                                    (delim + 1)) : strlen (delim + 1));
-            tr_free (key);
-        }
-        pch = next ? next + 1 : NULL;
-    }
-
-    request_exec (session, &top, callback, callback_user_data);
-
-    /* cleanup */
-    tr_variantFree (&top);
-    tr_free (request);
-}
+  const char * pch;
+  tr_variant top;
+  tr_variant * args;
+  char * request = tr_strndup (request_uri, request_len);
+
+  tr_variantInitDict (&top, 3);
+  args = tr_variantDictAddDict (&top, TR_KEY_arguments, 0);
+
+  pch = strchr (request, '?');
+  if (!pch) pch = request;
+  while (pch)
+    {
+      const char * delim = strchr (pch, '=');
+      const char * next = strchr (pch, '&');
+      if (delim)
+        {
+          char * key = tr_strndup (pch, delim - pch);
+          int isArg = strcmp (key, "method") && strcmp (key, "tag");
+          tr_variant * parent = isArg ? args : &top;
+
+          tr_rpc_parse_list_str (tr_variantDictAdd (parent, tr_quark_new (key, delim-pch)),
+                                 delim + 1,
+                                 next ? (size_t)(next - (delim + 1)) : strlen (delim + 1));
+          tr_free (key);
+        }
+
+      pch = next ? next + 1 : NULL;
+    }
+
+  request_exec (session, &top, callback, callback_user_data);
+
+  /* cleanup */
+  tr_variantFree (&top);
+  tr_free (request);
+}

trunk/libtransmission/torrent.c

@@ -75 +75 @@
 tr_torrentName (const tr_torrent * tor)
 {
-    return tor ? tor->info.name : "";
+  return tor ? tor->info.name : "";
 }
 
@@ -81 +81 @@
 tr_torrentId (const tr_torrent * tor)
 {
-    return tor ? tor->uniqueId : -1;
+  return tor ? tor->uniqueId : -1;
 }
 
@@ -87 +87 @@
 tr_torrentFindFromId (tr_session * session, int id)
 {
-    tr_torrent * tor = NULL;
-
-    while ((tor = tr_torrentNext (session, tor)))
-        if (tor->uniqueId == id)
-            return tor;
-
-    return NULL;
+  tr_torrent * tor = NULL;
+
+  while ((tor = tr_torrentNext (session, tor)))
+    if (tor->uniqueId == id)
+      return tor;
+
+  return NULL;
 }
 
@@ -99 +99 @@
 tr_torrentFindFromHashString (tr_session *  session, const char * str)
 {
-    tr_torrent * tor = NULL;
-
-    while ((tor = tr_torrentNext (session, tor)))
-        if (!evutil_ascii_strcasecmp (str, tor->info.hashString))
-            return tor;
-
-    return NULL;
+  tr_torrent * tor = NULL;
+
+  while ((tor = tr_torrentNext (session, tor)))
+    if (!evutil_ascii_strcasecmp (str, tor->info.hashString))
+      return tor;
+
+  return NULL;
 }
 
@@ -111 +111 @@
 tr_torrentFindFromHash (tr_session * session, const uint8_t * torrentHash)
 {
-    tr_torrent * tor = NULL;
-
-    while ((tor = tr_torrentNext (session, tor)))
-        if (*tor->info.hash == *torrentHash)
-            if (!memcmp (tor->info.hash, torrentHash, SHA_DIGEST_LENGTH))
-                return tor;
-
-    return NULL;
+  tr_torrent * tor = NULL;
+
+  while ((tor = tr_torrentNext (session, tor)))
+    if (*tor->info.hash == *torrentHash)
+      if (!memcmp (tor->info.hash, torrentHash, SHA_DIGEST_LENGTH))
+        return tor;
+
+  return NULL;
 }
 
@@ -124 +124 @@
 tr_torrentFindFromMagnetLink (tr_session * session, const char * magnet)
 {
-    tr_magnet_info * info;
-    tr_torrent * tor = NULL;
-
-    if ((info = tr_magnetParse (magnet)))
-    {
-        tor = tr_torrentFindFromHash (session, info->hash);
-        tr_magnetFree (info);
-    }
-
-    return tor;
+  tr_magnet_info * info;
+  tr_torrent * tor = NULL;
+
+  if ((info = tr_magnetParse (magnet)))
+    {
+      tor = tr_torrentFindFromHash (session, info->hash);
+      tr_magnetFree (info);
+    }
+
+  return tor;
 }
 
@@ -140 +140 @@
                                   const uint8_t * obfuscatedTorrentHash)
 {
-    tr_torrent * tor = NULL;
-
-    while ((tor = tr_torrentNext (session, tor)))
-        if (!memcmp (tor->obfuscatedHash, obfuscatedTorrentHash,
-                     SHA_DIGEST_LENGTH))
-            return tor;
-
-    return NULL;
+  tr_torrent * tor = NULL;
+
+  while ((tor = tr_torrentNext (session, tor)))
+    if (!memcmp (tor->obfuscatedHash, obfuscatedTorrentHash, SHA_DIGEST_LENGTH))
+      return tor;
+
+  return NULL;
 }
 
@@ -224 +223 @@
 tr_torrentSetSpeedLimit_Bps (tr_torrent * tor, tr_direction dir, unsigned int Bps)
 {
-    assert (tr_isTorrent (tor));
-    assert (tr_isDirection (dir));
-
-    if (tr_bandwidthSetDesiredSpeed_Bps (&tor->bandwidth, dir, Bps))
-        tr_torrentSetDirty (tor);
+  assert (tr_isTorrent (tor));
+  assert (tr_isDirection (dir));
+
+  if (tr_bandwidthSetDesiredSpeed_Bps (&tor->bandwidth, dir, Bps))
+    tr_torrentSetDirty (tor);
 }
 void
 tr_torrentSetSpeedLimit_KBps (tr_torrent * tor, tr_direction dir, unsigned int KBps)
 {
-    tr_torrentSetSpeedLimit_Bps (tor, dir, toSpeedBytes (KBps));
+  tr_torrentSetSpeedLimit_Bps (tor, dir, toSpeedBytes (KBps));
 }
 
@@ -239 +238 @@
 tr_torrentGetSpeedLimit_Bps (const tr_torrent * tor, tr_direction dir)
 {
-    assert (tr_isTorrent (tor));
-    assert (tr_isDirection (dir));
-
-    return tr_bandwidthGetDesiredSpeed_Bps (&tor->bandwidth, dir);
+  assert (tr_isTorrent (tor));
+  assert (tr_isDirection (dir));
+
+  return tr_bandwidthGetDesiredSpeed_Bps (&tor->bandwidth, dir);
 }
 unsigned int
@@ -398 +397 @@
 tr_torrentIsSeedRatioDone (const tr_torrent * tor)
 {
-    uint64_t bytesLeft;
-    return tr_torrentGetSeedRatioBytes (tor, &bytesLeft, NULL) && !bytesLeft;
+  uint64_t bytesLeft;
+  return tr_torrentGetSeedRatioBytes (tor, &bytesLeft, NULL) && !bytesLeft;
 }
 
@@ -409 +408 @@
 tr_torrentSetIdleMode (tr_torrent *  tor, tr_idlelimit mode)
 {
-    assert (tr_isTorrent (tor));
-    assert (mode==TR_IDLELIMIT_GLOBAL || mode==TR_IDLELIMIT_SINGLE || mode==TR_IDLELIMIT_UNLIMITED);
-
-    if (mode != tor->idleLimitMode)
-    {
-        tor->idleLimitMode = mode;
-
-        tr_torrentSetDirty (tor);
+  assert (tr_isTorrent (tor));
+  assert (mode==TR_IDLELIMIT_GLOBAL || mode==TR_IDLELIMIT_SINGLE || mode==TR_IDLELIMIT_UNLIMITED);
+
+  if (mode != tor->idleLimitMode)
+    {
+      tor->idleLimitMode = mode;
+
+      tr_torrentSetDirty (tor);
     }
 }
@@ -423 +422 @@
 tr_torrentGetIdleMode (const tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    return tor->idleLimitMode;
+  assert (tr_isTorrent (tor));
+
+  return tor->idleLimitMode;
 }
 
@@ -431 +430 @@
 tr_torrentSetIdleLimit (tr_torrent * tor, uint16_t idleMinutes)
 {
-    assert (tr_isTorrent (tor));
-
-    if (idleMinutes > 0)
-    {
-        tor->idleLimitMinutes = idleMinutes;
-
-        tr_torrentSetDirty (tor);
+  assert (tr_isTorrent (tor));
+
+  if (idleMinutes > 0)
+    {
+      tor->idleLimitMinutes = idleMinutes;
+
+      tr_torrentSetDirty (tor);
     }
 }
@@ -444 +443 @@
 tr_torrentGetIdleLimit (const tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    return tor->idleLimitMinutes;
+  assert (tr_isTorrent (tor));
+
+  return tor->idleLimitMinutes;
 }
 
@@ -452 +451 @@
 tr_torrentGetSeedIdle (const tr_torrent * tor, uint16_t * idleMinutes)
 {
-    bool isLimited;
-
-    switch (tr_torrentGetIdleMode (tor))
-    {
-        case TR_IDLELIMIT_SINGLE:
-            isLimited = true;
-            if (idleMinutes)
-                *idleMinutes = tr_torrentGetIdleLimit (tor);
-            break;
-
-        case TR_IDLELIMIT_GLOBAL:
-            isLimited = tr_sessionIsIdleLimited (tor->session);
-            if (isLimited && idleMinutes)
-                *idleMinutes = tr_sessionGetIdleLimit (tor->session);
-            break;
-
-        default: /* TR_IDLELIMIT_UNLIMITED */
-            isLimited = false;
-            break;
-    }
-
-    return isLimited;
+  bool isLimited;
+
+  switch (tr_torrentGetIdleMode (tor))
+    {
+      case TR_IDLELIMIT_SINGLE:
+        isLimited = true;
+        if (idleMinutes != NULL)
+          *idleMinutes = tr_torrentGetIdleLimit (tor);
+        break;
+
+      case TR_IDLELIMIT_GLOBAL:
+        isLimited = tr_sessionIsIdleLimited (tor->session);
+        if (isLimited && idleMinutes)
+          *idleMinutes = tr_sessionGetIdleLimit (tor->session);
+        break;
+
+      default: /* TR_IDLELIMIT_UNLIMITED */
+        isLimited = false;
+        break;
+    }
+
+  return isLimited;
 }
 
@@ -479 +478 @@
 tr_torrentIsSeedIdleLimitDone (tr_torrent * tor)
 {
-    uint16_t idleMinutes;
-    return tr_torrentGetSeedIdle (tor, &idleMinutes)
-        && difftime (tr_time (), MAX (tor->startDate, tor->activityDate)) >= idleMinutes * 60u;
+  uint16_t idleMinutes;
+  return tr_torrentGetSeedIdle (tor, &idleMinutes)
+    && difftime (tr_time (), MAX (tor->startDate, tor->activityDate)) >= idleMinutes * 60u;
 }
 
@@ -491 +490 @@
 tr_torrentCheckSeedLimit (tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    if (!tor->isRunning || tor->isStopping || !tr_torrentIsSeed (tor))
-        return;
-
-    /* if we're seeding and reach our seed ratio limit, stop the torrent */
-    if (tr_torrentIsSeedRatioDone (tor))
-    {
-        tr_logAddTorInfo (tor, "%s", "Seed ratio reached; pausing torrent");
-
-        tor->isStopping = true;
-
-        /* maybe notify the client */
-        if (tor->ratio_limit_hit_func != NULL)
-            tor->ratio_limit_hit_func (tor, tor->ratio_limit_hit_func_user_data);
-    }
-    /* if we're seeding and reach our inactiviy limit, stop the torrent */
-    else if (tr_torrentIsSeedIdleLimitDone (tor))
-    {
-        tr_logAddTorInfo (tor, "%s", "Seeding idle limit reached; pausing torrent");
-
-        tor->isStopping = true;
-        tor->finishedSeedingByIdle = true;
-
-        /* maybe notify the client */
-        if (tor->idle_limit_hit_func != NULL)
-            tor->idle_limit_hit_func (tor, tor->idle_limit_hit_func_user_data);
+  assert (tr_isTorrent (tor));
+
+  if (!tor->isRunning || tor->isStopping || !tr_torrentIsSeed (tor))
+    return;
+
+  /* if we're seeding and reach our seed ratio limit, stop the torrent */
+  if (tr_torrentIsSeedRatioDone (tor))
+    {
+      tr_logAddTorInfo (tor, "%s", "Seed ratio reached; pausing torrent");
+
+      tor->isStopping = true;
+
+      /* maybe notify the client */
+      if (tor->ratio_limit_hit_func != NULL)
+        tor->ratio_limit_hit_func (tor, tor->ratio_limit_hit_func_user_data);
+    }
+  /* if we're seeding and reach our inactiviy limit, stop the torrent */
+  else if (tr_torrentIsSeedIdleLimitDone (tor))
+    {
+      tr_logAddTorInfo (tor, "%s", "Seeding idle limit reached; pausing torrent");
+
+      tor->isStopping = true;
+      tor->finishedSeedingByIdle = true;
+
+      /* maybe notify the client */
+      if (tor->idle_limit_hit_func != NULL)
+        tor->idle_limit_hit_func (tor, tor->idle_limit_hit_func_user_data);
     }
 }
@@ -528 +527 @@
 tr_torrentSetLocalError (tr_torrent * tor, const char * fmt, ...)
 {
-    va_list ap;
-
-    assert (tr_isTorrent (tor));
-
-    va_start (ap, fmt);
-    tor->error = TR_STAT_LOCAL_ERROR;
-    tor->errorTracker[0] = '\0';
-    evutil_vsnprintf (tor->errorString, sizeof (tor->errorString), fmt, ap);
-    va_end (ap);
-
-    tr_logAddTorErr (tor, "%s", tor->errorString);
-
-    if (tor->isRunning)
-        tor->isStopping = true;
+  va_list ap;
+
+  assert (tr_isTorrent (tor));
+
+  va_start (ap, fmt);
+  tor->error = TR_STAT_LOCAL_ERROR;
+  tor->errorTracker[0] = '\0';
+  evutil_vsnprintf (tor->errorString, sizeof (tor->errorString), fmt, ap);
+  va_end (ap);
+
+  tr_logAddTorErr (tor, "%s", tor->errorString);
+
+  if (tor->isRunning)
+    tor->isStopping = true;
 }
 
@@ -547 +546 @@
 tr_torrentClearError (tr_torrent * tor)
 {
-    tor->error = TR_STAT_OK;
-    tor->errorString[0] = '\0';
-    tor->errorTracker[0] = '\0';
+  tor->error = TR_STAT_OK;
+  tor->errorString[0] = '\0';
+  tor->errorTracker[0] = '\0';
 }
 
@@ -555 +554 @@
 onTrackerResponse (tr_torrent * tor, const tr_tracker_event * event, void * unused UNUSED)
 {
-    switch (event->messageType)
-    {
-        case TR_TRACKER_PEERS:
+  switch (event->messageType)
+    {
+      case TR_TRACKER_PEERS:
         {
-            size_t i;
-            const int8_t seedProbability = event->seedProbability;
-            const bool allAreSeeds = seedProbability == 100;
-
-             if (allAreSeeds)
-                tr_logAddTorDbg (tor, "Got %zu seeds from tracker", event->pexCount);
-            else
-                tr_logAddTorDbg (tor, "Got %zu peers from tracker", event->pexCount);
-
-            for (i = 0; i < event->pexCount; ++i)
-                tr_peerMgrAddPex (tor, TR_PEER_FROM_TRACKER, &event->pex[i], seedProbability);
-
-            break;
+          size_t i;
+          const int8_t seedProbability = event->seedProbability;
+          const bool allAreSeeds = seedProbability == 100;
+
+          if (allAreSeeds)
+            tr_logAddTorDbg (tor, "Got %zu seeds from tracker", event->pexCount);
+          else
+            tr_logAddTorDbg (tor, "Got %zu peers from tracker", event->pexCount);
+
+          for (i = 0; i < event->pexCount; ++i)
+            tr_peerMgrAddPex (tor, TR_PEER_FROM_TRACKER, &event->pex[i], seedProbability);
+
+          break;
         }
 
-        case TR_TRACKER_WARNING:
-            tr_logAddTorErr (tor, _("Tracker warning: \"%s\""), event->text);
-            tor->error = TR_STAT_TRACKER_WARNING;
-            tr_strlcpy (tor->errorTracker, event->tracker, sizeof (tor->errorTracker));
-            tr_strlcpy (tor->errorString, event->text, sizeof (tor->errorString));
-            break;
-
-        case TR_TRACKER_ERROR:
-            tr_logAddTorErr (tor, _("Tracker error: \"%s\""), event->text);
-            tor->error = TR_STAT_TRACKER_ERROR;
-            tr_strlcpy (tor->errorTracker, event->tracker, sizeof (tor->errorTracker));
-            tr_strlcpy (tor->errorString, event->text, sizeof (tor->errorString));
-            break;
-
-        case TR_TRACKER_ERROR_CLEAR:
-            if (tor->error != TR_STAT_LOCAL_ERROR)
-                tr_torrentClearError (tor);
-            break;
+      case TR_TRACKER_WARNING:
+        tr_logAddTorErr (tor, _("Tracker warning: \"%s\""), event->text);
+        tor->error = TR_STAT_TRACKER_WARNING;
+        tr_strlcpy (tor->errorTracker, event->tracker, sizeof (tor->errorTracker));
+        tr_strlcpy (tor->errorString, event->text, sizeof (tor->errorString));
+        break;
+
+      case TR_TRACKER_ERROR:
+        tr_logAddTorErr (tor, _("Tracker error: \"%s\""), event->text);
+        tor->error = TR_STAT_TRACKER_ERROR;
+        tr_strlcpy (tor->errorTracker, event->tracker, sizeof (tor->errorTracker));
+        tr_strlcpy (tor->errorString, event->text, sizeof (tor->errorString));
+        break;
+
+      case TR_TRACKER_ERROR_CLEAR:
+        if (tor->error != TR_STAT_LOCAL_ERROR)
+          tr_torrentClearError (tor);
+        break;
     }
 }
@@ -604 +603 @@
 getBytePiece (const tr_info * info, uint64_t byteOffset)
 {
-    tr_piece_index_t piece;
-
-    assert (info);
-    assert (info->pieceSize != 0);
-
-    piece = byteOffset / info->pieceSize;
-
-    /* handle 0-byte files at the end of a torrent */
-    if (byteOffset == info->totalSize)
-      piece = info->pieceCount - 1;
-
-    return piece;
+  tr_piece_index_t piece;
+
+  assert (info);
+  assert (info->pieceSize != 0);
+
+  piece = byteOffset / info->pieceSize;
+
+  /* handle 0-byte files at the end of a torrent */
+  if (byteOffset == info->totalSize)
+    piece = info->pieceCount - 1;
+
+  return piece;
 }
 
@@ -622 +621 @@
                 tr_file_index_t fileIndex)
 {
-    tr_file * file;
-    uint64_t  firstByte, lastByte;
-
-    assert (info);
-    assert (fileIndex < info->fileCount);
-
-    file = &info->files[fileIndex];
-    firstByte = file->offset;
-    lastByte = firstByte + (file->length ? file->length - 1 : 0);
-    file->firstPiece = getBytePiece (info, firstByte);
-    file->lastPiece = getBytePiece (info, lastByte);
+  tr_file * file;
+  uint64_t  firstByte, lastByte;
+
+  assert (info);
+  assert (fileIndex < info->fileCount);
+
+  file = &info->files[fileIndex];
+  firstByte = file->offset;
+  lastByte = firstByte + (file->length ? file->length - 1 : 0);
+  file->firstPiece = getBytePiece (info, firstByte);
+  file->lastPiece = getBytePiece (info, lastByte);
 }
 
@@ -639 +638 @@
               const tr_file *  file)
 {
-    return (file->firstPiece <= piece) && (piece <= file->lastPiece);
+  return (file->firstPiece <= piece) && (piece <= file->lastPiece);
 }
 
@@ -647 +646 @@
                         int                fileHint)
 {
-    tr_file_index_t i;
-    tr_priority_t priority = TR_PRI_LOW;
-
-    /* find the first file that has data in this piece */
-    if (fileHint >= 0) {
-        i = fileHint;
-        while (i > 0 && pieceHasFile (piece, &tor->info.files[i - 1]))
-            --i;
-    } else {
-        for (i = 0; i < tor->info.fileCount; ++i)
-            if (pieceHasFile (piece, &tor->info.files[i]))
-                break;
-    }
-
-    /* the piece's priority is the max of the priorities
-     * of all the files in that piece */
-    for (; i < tor->info.fileCount; ++i)
-    {
-        const tr_file * file = &tor->info.files[i];
-
-        if (!pieceHasFile (piece, file))
-            break;
-
-        priority = MAX (priority, file->priority);
-
-        /* when dealing with multimedia files, getting the first and
-           last pieces can sometimes allow you to preview it a bit
-           before it's fully downloaded... */
-        if (file->priority >= TR_PRI_NORMAL)
-            if (file->firstPiece == piece || file->lastPiece == piece)
-                priority = TR_PRI_HIGH;
-    }
-
-    return priority;
+  tr_file_index_t i;
+  tr_priority_t priority = TR_PRI_LOW;
+
+  /* find the first file that has data in this piece */
+  if (fileHint >= 0)
+    {
+      i = fileHint;
+      while (i > 0 && pieceHasFile (piece, &tor->info.files[i - 1]))
+        --i;
+    }
+  else
+    {
+      for (i=0; i<tor->info.fileCount; ++i)
+        if (pieceHasFile (piece, &tor->info.files[i]))
+          break;
+    }
+
+  /* the piece's priority is the max of the priorities
+   * of all the files in that piece */
+  for (; i<tor->info.fileCount; ++i)
+    {
+      const tr_file * file = &tor->info.files[i];
+
+      if (!pieceHasFile (piece, file))
+        break;
+
+      priority = MAX (priority, file->priority);
+
+      /* when dealing with multimedia files, getting the first and
+         last pieces can sometimes allow you to preview it a bit
+         before it's fully downloaded... */
+      if (file->priority >= TR_PRI_NORMAL)
+        if (file->firstPiece == piece || file->lastPiece == piece)
+          priority = TR_PRI_HIGH;
+    }
+
+  return priority;
 }
 
@@ -686 +688 @@
 tr_torrentInitFilePieces (tr_torrent * tor)
 {
-    int * firstFiles;
-    tr_file_index_t f;
-    tr_piece_index_t p;
-    uint64_t offset = 0;
-    tr_info * inf = &tor->info;
-
-    /* assign the file offsets */
-    for (f=0; f<inf->fileCount; ++f) {
-        inf->files[f].offset = offset;
-        offset += inf->files[f].length;
-        initFilePieces (inf, f);
-    }
-
-    /* build the array of first-file hints to give calculatePiecePriority */
-    firstFiles = tr_new (int, inf->pieceCount);
-    for (p=f=0; p<inf->pieceCount; ++p) {
-        while (inf->files[f].lastPiece < p)
-            ++f;
-        firstFiles[p] = f;
+  int * firstFiles;
+  tr_file_index_t f;
+  tr_piece_index_t p;
+  uint64_t offset = 0;
+  tr_info * inf = &tor->info;
+
+  /* assign the file offsets */
+  for (f=0; f<inf->fileCount; ++f)
+    {
+      inf->files[f].offset = offset;
+      offset += inf->files[f].length;
+      initFilePieces (inf, f);
+    }
+
+  /* build the array of first-file hints to give calculatePiecePriority */
+  firstFiles = tr_new (int, inf->pieceCount);
+  for (p=f=0; p<inf->pieceCount; ++p)
+    {
+      while (inf->files[f].lastPiece < p)
+        ++f;
+      firstFiles[p] = f;
     }
 
 #if 0
-    /* test to confirm the first-file hints are correct */
-    for (p=0; p<inf->pieceCount; ++p) {
-        f = firstFiles[p];
-        assert (inf->files[f].firstPiece <= p);
-        assert (inf->files[f].lastPiece >= p);
-        if (f > 0)
-            assert (inf->files[f-1].lastPiece < p);
-        for (f=0; f<inf->fileCount; ++f)
-            if (pieceHasFile (p, &inf->files[f]))
-                break;
-        assert ((int)f == firstFiles[p]);
+  /* test to confirm the first-file hints are correct */
+  for (p=0; p<inf->pieceCount; ++p)
+    {
+      f = firstFiles[p];
+      assert (inf->files[f].firstPiece <= p);
+      assert (inf->files[f].lastPiece >= p);
+      if (f > 0)
+        assert (inf->files[f-1].lastPiece < p);
+
+      for (f=0; f<inf->fileCount; ++f)
+        if (pieceHasFile (p, &inf->files[f]))
+          break;
+
+      assert ((int)f == firstFiles[p]);
     }
 #endif
 
-    for (p=0; p<inf->pieceCount; ++p)
-        inf->pieces[p].priority = calculatePiecePriority (tor, p, firstFiles[p]);
-
-    tr_free (firstFiles);
+  for (p=0; p<inf->pieceCount; ++p)
+    inf->pieces[p].priority = calculatePiecePriority (tor, p, firstFiles[p]);
+
+  tr_free (firstFiles);
 }
 
@@ -738 +745 @@
 tr_getBlockSize (uint32_t pieceSize)
 {
-    uint32_t b = pieceSize;
-
-    while (b > MAX_BLOCK_SIZE)
-        b /= 2u;
-
-    if (!b || (pieceSize % b)) /* not cleanly divisible */
-        return 0;
-    return b;
+  uint32_t b = pieceSize;
+
+  while (b > MAX_BLOCK_SIZE)
+    b /= 2u;
+
+  if (!b || (pieceSize % b)) /* not cleanly divisible */
+    return 0;
+
+  return b;
 }
 
@@ -753 +761 @@
 torrentInitFromInfo (tr_torrent * tor)
 {
-    uint64_t t;
-    tr_info * info = &tor->info;
-
-    tor->blockSize = tr_getBlockSize (info->pieceSize);
-
-    if (info->pieceSize)
-        tor->lastPieceSize = (uint32_t)(info->totalSize % info->pieceSize);
-
-    if (!tor->lastPieceSize)
-        tor->lastPieceSize = info->pieceSize;
-
-    if (tor->blockSize)
-        tor->lastBlockSize = info->totalSize % tor->blockSize;
-
-    if (!tor->lastBlockSize)
-        tor->lastBlockSize = tor->blockSize;
-
-    tor->blockCount = tor->blockSize
-        ? (info->totalSize + tor->blockSize - 1) / tor->blockSize
-        : 0;
-
-    tor->blockCountInPiece = tor->blockSize
-        ? info->pieceSize / tor->blockSize
-        : 0;
-
-    tor->blockCountInLastPiece = tor->blockSize
-        ? (tor->lastPieceSize + tor->blockSize - 1) / tor->blockSize
-        : 0;
-
-    /* check our work */
-    if (tor->blockSize != 0)
-        assert ((info->pieceSize % tor->blockSize) == 0);
-    t = info->pieceCount - 1;
-    t *= info->pieceSize;
-    t += tor->lastPieceSize;
-    assert (t == info->totalSize);
-    t = tor->blockCount - 1;
-    t *= tor->blockSize;
-    t += tor->lastBlockSize;
-    assert (t == info->totalSize);
-    t = info->pieceCount - 1;
-    t *= tor->blockCountInPiece;
-    t += tor->blockCountInLastPiece;
-    assert (t == (uint64_t)tor->blockCount);
-
-    tr_cpConstruct (&tor->completion, tor);
-
-    tr_torrentInitFilePieces (tor);
-
-    tor->completeness = tr_cpGetStatus (&tor->completion);
+  uint64_t t;
+  tr_info * info = &tor->info;
+
+  tor->blockSize = tr_getBlockSize (info->pieceSize);
+
+  if (info->pieceSize)
+    tor->lastPieceSize = (uint32_t)(info->totalSize % info->pieceSize);
+
+  if (!tor->lastPieceSize)
+    tor->lastPieceSize = info->pieceSize;
+
+  if (tor->blockSize)
+    tor->lastBlockSize = info->totalSize % tor->blockSize;
+
+  if (!tor->lastBlockSize)
+    tor->lastBlockSize = tor->blockSize;
+
+  tor->blockCount = tor->blockSize
+    ? (info->totalSize + tor->blockSize - 1) / tor->blockSize
+    : 0;
+
+  tor->blockCountInPiece = tor->blockSize
+    ? info->pieceSize / tor->blockSize
+    : 0;
+
+  tor->blockCountInLastPiece = tor->blockSize
+    ? (tor->lastPieceSize + tor->blockSize - 1) / tor->blockSize
+    : 0;
+
+  /* check our work */
+  if (tor->blockSize != 0)
+    assert ((info->pieceSize % tor->blockSize) == 0);
+  t = info->pieceCount - 1;
+  t *= info->pieceSize;
+  t += tor->lastPieceSize;
+  assert (t == info->totalSize);
+  t = tor->blockCount - 1;
+  t *= tor->blockSize;
+  t += tor->lastBlockSize;
+  assert (t == info->totalSize);
+  t = info->pieceCount - 1;
+  t *= tor->blockCountInPiece;
+  t += tor->blockCountInLastPiece;
+  assert (t == (uint64_t)tor->blockCount);
+
+  tr_cpConstruct (&tor->completion, tor);
+
+  tr_torrentInitFilePieces (tor);
+
+  tor->completeness = tr_cpGetStatus (&tor->completion);
 }
 
@@ -810 +818 @@
 tr_torrentGotNewInfoDict (tr_torrent * tor)
 {
-    torrentInitFromInfo (tor);
-
-    tr_peerMgrOnTorrentGotMetainfo (tor);
-
-    tr_torrentFireMetadataCompleted (tor);
+  torrentInitFromInfo (tor);
+
+  tr_peerMgrOnTorrentGotMetainfo (tor);
+
+  tr_torrentFireMetadataCompleted (tor);
 }
 
@@ -820 +828 @@
 hasAnyLocalData (const tr_torrent * tor)
 {
-    tr_file_index_t i;
-
-    for (i=0; i<tor->info.fileCount; ++i)
-        if (tr_torrentFindFile2 (tor, i, NULL, NULL, NULL))
-            return true;
-
-    return false;
+  tr_file_index_t i;
+
+  for (i=0; i<tor->info.fileCount; ++i)
+    if (tr_torrentFindFile2 (tor, i, NULL, NULL, NULL))
+      return true;
+
+  return false;
 }
 
@@ -832 +840 @@
 setLocalErrorIfFilesDisappeared (tr_torrent * tor)
 {
-    const bool disappeared = (tr_cpHaveTotal (&tor->completion) > 0) && !hasAnyLocalData (tor);
-
-    if (disappeared)
-    {
-        tr_deeplog_tor (tor, "%s", "[LAZY] uh oh, the files disappeared");
-        tr_torrentSetLocalError (tor, "%s", _("No data found! Ensure your drives are connected or use \"Set Location\". To re-download, remove the torrent and re-add it."));
-    }
-
-    return disappeared;
+  const bool disappeared = (tr_cpHaveTotal (&tor->completion) > 0) && !hasAnyLocalData (tor);
+
+  if (disappeared)
+    {
+      tr_deeplog_tor (tor, "%s", "[LAZY] uh oh, the files disappeared");
+      tr_torrentSetLocalError (tor, "%s", _("No data found! Ensure your drives are connected or use \"Set Location\". To re-download, remove the torrent and re-add it."));
+    }
+
+  return disappeared;
 }
 
@@ -846 +854 @@
 torrentInit (tr_torrent * tor, const tr_ctor * ctor)
 {
-    int doStart;
-    uint64_t loaded;
-    const char * dir;
-    bool isNewTorrent;
-    struct stat st;
-    static int nextUniqueId = 1;
-    tr_session * session = tr_ctorGetSession (ctor);
-
-    assert (session != NULL);
-
-    tr_sessionLock (session);
-
-    tor->session   = session;
-    tor->uniqueId = nextUniqueId++;
-    tor->magicNumber = TORRENT_MAGIC_NUMBER;
-    tor->queuePosition = session->torrentCount;
-
-    tr_sha1 (tor->obfuscatedHash, "req2", 4,
-             tor->info.hash, SHA_DIGEST_LENGTH,
-             NULL);
-
-    if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &dir) ||
-        !tr_ctorGetDownloadDir (ctor, TR_FALLBACK, &dir))
-            tor->downloadDir = tr_strdup (dir);
-
-    if (tr_ctorGetIncompleteDir (ctor, &dir))
-        dir = tr_sessionGetIncompleteDir (session);
-    if (tr_sessionIsIncompleteDirEnabled (session))
-        tor->incompleteDir = tr_strdup (dir);
-
-    tr_bandwidthConstruct (&tor->bandwidth, session, &session->bandwidth);
-
-    tor->bandwidth.priority = tr_ctorGetBandwidthPriority (ctor);
-
-    tor->error = TR_STAT_OK;
-
-    tor->finishedSeedingByIdle = false;
-
-    tr_peerMgrAddTorrent (session->peerMgr, tor);
-
-    assert (!tor->downloadedCur);
-    assert (!tor->uploadedCur);
-
-    tr_torrentSetAddedDate (tor, tr_time ()); /* this is a default value to be
-                                                  overwritten by the resume file */
-
-    torrentInitFromInfo (tor);
-    loaded = tr_torrentLoadResume (tor, ~0, ctor);
-    tor->completeness = tr_cpGetStatus (&tor->completion);
-    setLocalErrorIfFilesDisappeared (tor);
-
-    tr_ctorInitTorrentPriorities (ctor, tor);
-    tr_ctorInitTorrentWanted (ctor, tor);
-
-    refreshCurrentDir (tor);
-
-    doStart = tor->isRunning;
-    tor->isRunning = 0;
-
-    if (! (loaded & TR_FR_SPEEDLIMIT))
-    {
-        tr_torrentUseSpeedLimit (tor, TR_UP, false);
-        tr_torrentSetSpeedLimit_Bps (tor, TR_UP, tr_sessionGetSpeedLimit_Bps (tor->session, TR_UP));
-        tr_torrentUseSpeedLimit (tor, TR_DOWN, false);
-        tr_torrentSetSpeedLimit_Bps (tor, TR_DOWN, tr_sessionGetSpeedLimit_Bps (tor->session, TR_DOWN));
-        tr_torrentUseSessionLimits (tor, true);
-    }
-
-    if (! (loaded & TR_FR_RATIOLIMIT))
-    {
-        tr_torrentSetRatioMode (tor, TR_RATIOLIMIT_GLOBAL);
-        tr_torrentSetRatioLimit (tor, tr_sessionGetRatioLimit (tor->session));
-    }
-
-    if (! (loaded & TR_FR_IDLELIMIT))
-    {
-        tr_torrentSetIdleMode (tor, TR_IDLELIMIT_GLOBAL);
-        tr_torrentSetIdleLimit (tor, tr_sessionGetIdleLimit (tor->session));
-    }
-
-    /* add the torrent to tr_session.torrentList */
-    session->torrentCount++;
-    if (session->torrentList == NULL)
-        session->torrentList = tor;
-    else {
-        tr_torrent * it = session->torrentList;
-        while (it->next != NULL)
-            it = it->next;
-        it->next = tor;
-    }
-
-    /* if we don't have a local .torrent file already, assume the torrent is new */
-    isNewTorrent = stat (tor->info.torrent, &st);
-
-    /* maybe save our own copy of the metainfo */
-    if (tr_ctorGetSave (ctor))
-    {
-        const tr_variant * val;
-        if (!tr_ctorGetMetainfo (ctor, &val))
+  int doStart;
+  uint64_t loaded;
+  const char * dir;
+  bool isNewTorrent;
+  struct stat st;
+  tr_session * session = tr_ctorGetSession (ctor);
+  static int nextUniqueId = 1;
+
+  assert (session != NULL);
+
+  tr_sessionLock (session);
+
+  tor->session   = session;
+  tor->uniqueId = nextUniqueId++;
+  tor->magicNumber = TORRENT_MAGIC_NUMBER;
+  tor->queuePosition = session->torrentCount;
+
+  tr_sha1 (tor->obfuscatedHash, "req2", 4,
+           tor->info.hash, SHA_DIGEST_LENGTH,
+           NULL);
+
+  if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &dir) ||
+    !tr_ctorGetDownloadDir (ctor, TR_FALLBACK, &dir))
+      tor->downloadDir = tr_strdup (dir);
+
+  if (tr_ctorGetIncompleteDir (ctor, &dir))
+    dir = tr_sessionGetIncompleteDir (session);
+  if (tr_sessionIsIncompleteDirEnabled (session))
+    tor->incompleteDir = tr_strdup (dir);
+
+  tr_bandwidthConstruct (&tor->bandwidth, session, &session->bandwidth);
+
+  tor->bandwidth.priority = tr_ctorGetBandwidthPriority (ctor);
+
+  tor->error = TR_STAT_OK;
+
+  tor->finishedSeedingByIdle = false;
+
+  tr_peerMgrAddTorrent (session->peerMgr, tor);
+
+  assert (!tor->downloadedCur);
+  assert (!tor->uploadedCur);
+
+  tr_torrentSetAddedDate (tor, tr_time ()); /* this is a default value to be
+                                               overwritten by the resume file */
+
+  torrentInitFromInfo (tor);
+  loaded = tr_torrentLoadResume (tor, ~0, ctor);
+  tor->completeness = tr_cpGetStatus (&tor->completion);
+  setLocalErrorIfFilesDisappeared (tor);
+
+  tr_ctorInitTorrentPriorities (ctor, tor);
+  tr_ctorInitTorrentWanted (ctor, tor);
+
+  refreshCurrentDir (tor);
+
+  doStart = tor->isRunning;
+  tor->isRunning = 0;
+
+  if (!(loaded & TR_FR_SPEEDLIMIT))
+    {
+      tr_torrentUseSpeedLimit (tor, TR_UP, false);
+      tr_torrentSetSpeedLimit_Bps (tor, TR_UP, tr_sessionGetSpeedLimit_Bps (tor->session, TR_UP));
+      tr_torrentUseSpeedLimit (tor, TR_DOWN, false);
+      tr_torrentSetSpeedLimit_Bps (tor, TR_DOWN, tr_sessionGetSpeedLimit_Bps (tor->session, TR_DOWN));
+      tr_torrentUseSessionLimits (tor, true);
+    }
+
+  if (!(loaded & TR_FR_RATIOLIMIT))
+    {
+      tr_torrentSetRatioMode (tor, TR_RATIOLIMIT_GLOBAL);
+      tr_torrentSetRatioLimit (tor, tr_sessionGetRatioLimit (tor->session));
+    }
+
+  if (!(loaded & TR_FR_IDLELIMIT))
+    {
+      tr_torrentSetIdleMode (tor, TR_IDLELIMIT_GLOBAL);
+      tr_torrentSetIdleLimit (tor, tr_sessionGetIdleLimit (tor->session));
+    }
+
+  /* add the torrent to tr_session.torrentList */
+  session->torrentCount++;
+  if (session->torrentList == NULL)
+    {
+      session->torrentList = tor;
+    }
+  else
+    {
+      tr_torrent * it = session->torrentList;
+      while (it->next != NULL)
+        it = it->next;
+      it->next = tor;
+    }
+
+  /* if we don't have a local .torrent file already, assume the torrent is new */
+  isNewTorrent = stat (tor->info.torrent, &st);
+
+  /* maybe save our own copy of the metainfo */
+  if (tr_ctorGetSave (ctor))
+    {
+      const tr_variant * val;
+      if (!tr_ctorGetMetainfo (ctor, &val))
         {
-            const char * path = tor->info.torrent;
-            const int err = tr_variantToFile (val, TR_VARIANT_FMT_BENC, path);
-            if (err)
-                tr_torrentSetLocalError (tor, "Unable to save torrent file: %s", tr_strerror (err));
-            tr_sessionSetTorrentFile (tor->session, tor->info.hashString, path);
+          const char * path = tor->info.torrent;
+          const int err = tr_variantToFile (val, TR_VARIANT_FMT_BENC, path);
+          if (err)
+            tr_torrentSetLocalError (tor, "Unable to save torrent file: %s", tr_strerror (err));
+          tr_sessionSetTorrentFile (tor->session, tor->info.hashString, path);
         }
     }
 
-    tor->tiers = tr_announcerAddTorrent (tor, onTrackerResponse, NULL);
-
-    if (isNewTorrent)
-    {
-        tor->startAfterVerify = doStart;
-        tr_torrentVerify (tor, NULL, NULL);
-    }
-    else if (doStart)
-    {
-        tr_torrentStart (tor);
-    }
-
-    tr_sessionUnlock (session);
+  tor->tiers = tr_announcerAddTorrent (tor, onTrackerResponse, NULL);
+
+  if (isNewTorrent)
+    {
+      tor->startAfterVerify = doStart;
+      tr_torrentVerify (tor, NULL, NULL);
+    }
+  else if (doStart)
+    {
+      tr_torrentStart (tor);
+    }
+
+  tr_sessionUnlock (session);
 }
 
@@ -976 +987 @@
                   int            * setme_duplicate_id)
 {
-    bool doFree;
-    bool didParse;
-    bool hasInfo = false;
-    tr_info tmp;
-    const tr_variant * metainfo;
-    tr_session * session = tr_ctorGetSession (ctor);
-    tr_parse_result result = TR_PARSE_OK;
-
-    if (setmeInfo == NULL)
-        setmeInfo = &tmp;
-    memset (setmeInfo, 0, sizeof (tr_info));
-
-    if (tr_ctorGetMetainfo (ctor, &metainfo))
-        return TR_PARSE_ERR;
-
-    didParse = tr_metainfoParse (session, metainfo, setmeInfo,
-                                 &hasInfo, dictLength);
-    doFree = didParse && (setmeInfo == &tmp);
-
-    if (!didParse)
-        result = TR_PARSE_ERR;
-
-    if (didParse && hasInfo && !tr_getBlockSize (setmeInfo->pieceSize))
-        result = TR_PARSE_ERR;
-
-    if (didParse && session && (result == TR_PARSE_OK))
-      {
-        const tr_torrent * const tor = tr_torrentFindFromHash (session, setmeInfo->hash);
-
-        if (tor != NULL)
-          {
-            result = TR_PARSE_DUPLICATE;
-
-            if (setme_duplicate_id != NULL)
-              *setme_duplicate_id = tr_torrentId (tor);
-          }
-      }
-
-    if (doFree)
-        tr_metainfoFree (setmeInfo);
-
-    if (setmeHasInfo != NULL)
-        *setmeHasInfo = hasInfo;
-
-    return result;
+  bool doFree;
+  bool didParse;
+  bool hasInfo = false;
+  tr_info tmp;
+  const tr_variant * metainfo;
+  tr_session * session = tr_ctorGetSession (ctor);
+  tr_parse_result result = TR_PARSE_OK;
+
+  if (setmeInfo == NULL)
+    setmeInfo = &tmp;
+  memset (setmeInfo, 0, sizeof (tr_info));
+
+  if (tr_ctorGetMetainfo (ctor, &metainfo))
+    return TR_PARSE_ERR;
+
+  didParse = tr_metainfoParse (session, metainfo, setmeInfo,
+                               &hasInfo, dictLength);
+  doFree = didParse && (setmeInfo == &tmp);
+
+  if (!didParse)
+    result = TR_PARSE_ERR;
+
+  if (didParse && hasInfo && !tr_getBlockSize (setmeInfo->pieceSize))
+    result = TR_PARSE_ERR;
+
+  if (didParse && session && (result == TR_PARSE_OK))
+    {
+      const tr_torrent * const tor = tr_torrentFindFromHash (session, setmeInfo->hash);
+
+      if (tor != NULL)
+        {
+          result = TR_PARSE_DUPLICATE;
+
+          if (setme_duplicate_id != NULL)
+            *setme_duplicate_id = tr_torrentId (tor);
+        }
+    }
+
+  if (doFree)
+    tr_metainfoFree (setmeInfo);
+
+  if (setmeHasInfo != NULL)
+    *setmeHasInfo = hasInfo;
+
+  return result;
 }
 
@@ -1026 +1037 @@
 tr_torrentParse (const tr_ctor * ctor, tr_info * setmeInfo)
 {
-    return torrentParseImpl (ctor, setmeInfo, NULL, NULL, NULL);
+  return torrentParseImpl (ctor, setmeInfo, NULL, NULL, NULL);
 }
 
@@ -1052 +1063 @@
       torrentInit (tor, ctor);
     }
-    else
+  else
     {
       if (r == TR_PARSE_DUPLICATE)
@@ -1071 +1082 @@
 tr_torrentSetDownloadDir (tr_torrent * tor, const char * path)
 {
-    assert (tr_isTorrent (tor));
-
-    if (!path || !tor->downloadDir || strcmp (path, tor->downloadDir))
-    {
-        tr_free (tor->downloadDir);
-        tor->downloadDir = tr_strdup (path);
-        tr_torrentSetDirty (tor);
-    }
-
-    refreshCurrentDir (tor);
+  assert (tr_isTorrent (tor));
+
+  if (!path || !tor->downloadDir || strcmp (path, tor->downloadDir))
+    {
+      tr_free (tor->downloadDir);
+      tor->downloadDir = tr_strdup (path);
+      tr_torrentSetDirty (tor);
+    }
+
+  refreshCurrentDir (tor);
 }
 
@@ -1086 +1097 @@
 tr_torrentGetDownloadDir (const tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    return tor->downloadDir;
+  assert (tr_isTorrent (tor));
+
+  return tor->downloadDir;
 }
 
@@ -1094 +1105 @@
 tr_torrentGetCurrentDir (const tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    return tor->currentDir;
+  assert (tr_isTorrent (tor));
+
+  return tor->currentDir;
 }
 
@@ -1103 +1114 @@
 tr_torrentChangeMyPort (tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    if (tor->isRunning)
-        tr_announcerChangeMyPort (tor);
+  assert (tr_isTorrent (tor));
+
+  if (tor->isRunning)
+    tr_announcerChangeMyPort (tor);
 }
 
@@ -1112 +1123 @@
 tr_torrentManualUpdateImpl (void * vtor)
 {
-    tr_torrent * tor = vtor;
-
-    assert (tr_isTorrent (tor));
-
-    if (tor->isRunning)
-        tr_announcerManualAnnounce (tor);
+  tr_torrent * tor = vtor;
+
+  assert (tr_isTorrent (tor));
+
+  if (tor->isRunning)
+    tr_announcerManualAnnounce (tor);
 }
 
@@ -1123 +1134 @@
 tr_torrentManualUpdate (tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    tr_runInEventThread (tor->session, tr_torrentManualUpdateImpl, tor);
+  assert (tr_isTorrent (tor));
+
+  tr_runInEventThread (tor->session, tr_torrentManualUpdateImpl, tor);
 }
 
@@ -1131 +1142 @@
 tr_torrentCanManualUpdate (const tr_torrent * tor)
 {
-    return (tr_isTorrent (tor))
-        && (tor->isRunning)
-        && (tr_announcerCanManualAnnounce (tor));
+  return (tr_isTorrent (tor))
+      && (tor->isRunning)
+      && (tr_announcerCanManualAnnounce (tor));
 }
 
@@ -1139 +1150 @@
 tr_torrentInfo (const tr_torrent * tor)
 {
-    return tr_isTorrent (tor) ? &tor->info : NULL;
+  return tr_isTorrent (tor) ? &tor->info : NULL;
 }
 
@@ -1145 +1156 @@
 tr_torrentStatCached (tr_torrent * tor)
 {
-    const time_t now = tr_time ();
-
-    return tr_isTorrent (tor) && (now == tor->lastStatTime)
-         ? &tor->stats
-         : tr_torrentStat (tor);
+  const time_t now = tr_time ();
+
+  return tr_isTorrent (tor) && (now == tor->lastStatTime)
+       ? &tor->stats
+       : tr_torrentStat (tor);
 }
 
@@ -1155 +1166 @@
 tr_torrentSetVerifyState (tr_torrent * tor, tr_verify_state state)
 {
-    assert (tr_isTorrent (tor));
-    assert (state==TR_VERIFY_NONE || state==TR_VERIFY_WAIT || state==TR_VERIFY_NOW);
-
-    tor->verifyState = state;
-    tor->anyDate = tr_time ();
+  assert (tr_isTorrent (tor));
+  assert (state==TR_VERIFY_NONE || state==TR_VERIFY_WAIT || state==TR_VERIFY_NOW);
+
+  tor->verifyState = state;
+  tor->anyDate = tr_time ();
 }
 
@@ -1195 +1206 @@
 torrentGetIdleSecs (const tr_torrent * tor)
 {
-    int idle_secs;
-    const tr_torrent_activity activity = tr_torrentGetActivity (tor);
-
-    if ((activity == TR_STATUS_DOWNLOAD || activity == TR_STATUS_SEED) && tor->startDate != 0)
-        idle_secs = difftime (tr_time (), MAX (tor->startDate, tor->activityDate));
-    else
-        idle_secs = -1;
-
-    return idle_secs;
+  int idle_secs;
+  const tr_torrent_activity activity = tr_torrentGetActivity (tor);
+
+  if ((activity == TR_STATUS_DOWNLOAD || activity == TR_STATUS_SEED) && tor->startDate != 0)
+    idle_secs = difftime (tr_time (), MAX (tor->startDate, tor->activityDate));
+  else
+    idle_secs = -1;
+
+  return idle_secs;
 }
 
@@ -1209 +1220 @@
 tr_torrentIsStalled (const tr_torrent * tor)
 {
-    return tr_sessionGetQueueStalledEnabled (tor->session)
-        && (torrentGetIdleSecs (tor) > (tr_sessionGetQueueStalledMinutes (tor->session) * 60));
+  return tr_sessionGetQueueStalledEnabled (tor->session)
+      && (torrentGetIdleSecs (tor) > (tr_sessionGetQueueStalledMinutes (tor->session) * 60));
 }
 
@@ -1386 +1397 @@
 countFileBytesCompleted (const tr_torrent * tor, tr_file_index_t index)
 {
-    uint64_t total = 0;
-    const tr_file * f = &tor->info.files[index];
-
-    if (f->length)
-    {
-        tr_block_index_t first;
-        tr_block_index_t last;
-        tr_torGetFileBlockRange (tor, index, &first, &last);
-
-        if (first == last)
+  uint64_t total = 0;
+  const tr_file * f = &tor->info.files[index];
+
+  if (f->length)
+    {
+      tr_block_index_t first;
+      tr_block_index_t last;
+      tr_torGetFileBlockRange (tor, index, &first, &last);
+
+      if (first == last)
         {
-            if (tr_cpBlockIsComplete (&tor->completion, first))
-                total = f->length;
+          if (tr_cpBlockIsComplete (&tor->completion, first))
+            total = f->length;
         }
-        else
+      else
         {
-            /* the first block */
-            if (tr_cpBlockIsComplete (&tor->completion, first))
-                total += tor->blockSize - (f->offset % tor->blockSize);
-
-            /* the middle blocks */
-            if (first + 1 < last) {
-                uint64_t u = tr_bitfieldCountRange (&tor->completion.blockBitfield, first+1, last);
-                u *= tor->blockSize;
-                total += u;
+          /* the first block */
+          if (tr_cpBlockIsComplete (&tor->completion, first))
+            total += tor->blockSize - (f->offset % tor->blockSize);
+
+          /* the middle blocks */
+          if (first + 1 < last)
+            {
+              uint64_t u = tr_bitfieldCountRange (&tor->completion.blockBitfield, first+1, last);
+              u *= tor->blockSize;
+              total += u;
             }
 
-            /* the last block */
-            if (tr_cpBlockIsComplete (&tor->completion, last))
-                total += (f->offset + f->length) - ((uint64_t)tor->blockSize * last);
+          /* the last block */
+          if (tr_cpBlockIsComplete (&tor->completion, last))
+            total += (f->offset + f->length) - ((uint64_t)tor->blockSize * last);
         }
     }
 
-    return total;
+  return total;
 }
 
 tr_file_stat *
 tr_torrentFiles (const tr_torrent * tor,
-                 tr_file_index_t *  fileCount)
-{
-    tr_file_index_t       i;
-    const tr_file_index_t n = tor->info.fileCount;
-    tr_file_stat *        files = tr_new0 (tr_file_stat, n);
-    tr_file_stat *        walk = files;
-    const bool            isSeed = tor->completeness == TR_SEED;
-
-    assert (tr_isTorrent (tor));
-
-    for (i=0; i<n; ++i, ++walk) {
-        const uint64_t b = isSeed ? tor->info.files[i].length : countFileBytesCompleted (tor, i);
-        walk->bytesCompleted = b;
-        walk->progress = tor->info.files[i].length > 0 ? ((float)b / tor->info.files[i].length) : 1.0f;
-    }
-
-    if (fileCount)
-        *fileCount = n;
-
-    return files;
-}
-
-void
-tr_torrentFilesFree (tr_file_stat *            files,
-                     tr_file_index_t fileCount UNUSED)
-{
-    tr_free (files);
+                 tr_file_index_t  * fileCount)
+{
+  tr_file_index_t i;
+  const tr_file_index_t n = tor->info.fileCount;
+  tr_file_stat * files = tr_new0 (tr_file_stat, n);
+  tr_file_stat * walk = files;
+  const bool isSeed = tor->completeness == TR_SEED;
+
+  assert (tr_isTorrent (tor));
+
+  for (i=0; i<n; ++i, ++walk)
+    {
+      const uint64_t b = isSeed ? tor->info.files[i].length : countFileBytesCompleted (tor, i);
+      walk->bytesCompleted = b;
+      walk->progress = tor->info.files[i].length > 0 ? ((float)b / tor->info.files[i].length) : 1.0f;
+    }
+
+  if (fileCount != NULL)
+    *fileCount = n;
+
+  return files;
+}
+
+void
+tr_torrentFilesFree (tr_file_stat     * files,
+                     tr_file_index_t    fileCount UNUSED)
+{
+  tr_free (files);
 }
 
@@ -1511 +1524 @@
 tr_torrentResetTransferStats (tr_torrent * tor)
 {
-    tr_torrentLock (tor);
-
-    tor->downloadedPrev += tor->downloadedCur;
-    tor->downloadedCur   = 0;
-    tor->uploadedPrev   += tor->uploadedCur;
-    tor->uploadedCur     = 0;
-    tor->corruptPrev    += tor->corruptCur;
-    tor->corruptCur      = 0;
-
-    tr_torrentSetDirty (tor);
-
-    tr_torrentUnlock (tor);
+  tr_torrentLock (tor);
+
+  tor->downloadedPrev += tor->downloadedCur;
+  tor->downloadedCur   = 0;
+  tor->uploadedPrev   += tor->uploadedCur;
+  tor->uploadedCur     = 0;
+  tor->corruptPrev    += tor->corruptCur;
+  tor->corruptCur      = 0;
+
+  tr_torrentSetDirty (tor);
+
+  tr_torrentUnlock (tor);
 }
 
@@ -1530 +1543 @@
                        bool             has)
 {
-    assert (tr_isTorrent (tor));
-    assert (pieceIndex < tor->info.pieceCount);
-
-    if (has)
-        tr_cpPieceAdd (&tor->completion, pieceIndex);
-    else
-        tr_cpPieceRem (&tor->completion, pieceIndex);
+  assert (tr_isTorrent (tor));
+  assert (pieceIndex < tor->info.pieceCount);
+
+  if (has)
+    tr_cpPieceAdd (&tor->completion, pieceIndex);
+  else
+    tr_cpPieceRem (&tor->completion, pieceIndex);
 }
 
@@ -1550 +1563 @@
 freeTorrent (tr_torrent * tor)
 {
-    tr_torrent * t;
-    tr_session *  session = tor->session;
-    tr_info *    inf = &tor->info;
-    const time_t now = tr_time ();
-
-    assert (!tor->isRunning);
-
-    tr_sessionLock (session);
-
-    tr_peerMgrRemoveTorrent (tor);
-
-    tr_announcerRemoveTorrent (session->announcer, tor);
-
-    tr_cpDestruct (&tor->completion);
-
-    tr_free (tor->downloadDir);
-    tr_free (tor->incompleteDir);
-
-    if (tor == session->torrentList)
-        session->torrentList = tor->next;
-    else for (t = session->torrentList; t != NULL; t = t->next) {
-        if (t->next == tor) {
-            t->next = tor->next;
-            break;
+  tr_torrent * t;
+  tr_session * session = tor->session;
+  tr_info * inf = &tor->info;
+  const time_t now = tr_time ();
+
+  assert (!tor->isRunning);
+
+  tr_sessionLock (session);
+
+  tr_peerMgrRemoveTorrent (tor);
+
+  tr_announcerRemoveTorrent (session->announcer, tor);
+
+  tr_cpDestruct (&tor->completion);
+
+  tr_free (tor->downloadDir);
+  tr_free (tor->incompleteDir);
+
+  if (tor == session->torrentList)
+    {
+      session->torrentList = tor->next;
+    }
+  else for (t = session->torrentList; t != NULL; t = t->next)
+    {
+      if (t->next == tor)
+        {
+          t->next = tor->next;
+          break;
         }
     }
 
-    /* decrement the torrent count */
-    assert (session->torrentCount >= 1);
-    session->torrentCount--;
-
-    /* resequence the queue positions */
-    t = NULL;
-    while ((t = tr_torrentNext (session, t))) {
-        if (t->queuePosition > tor->queuePosition) {
-            t->queuePosition--;
-            t->anyDate = now;
+  /* decrement the torrent count */
+  assert (session->torrentCount >= 1);
+  session->torrentCount--;
+
+  /* resequence the queue positions */
+  t = NULL;
+  while ((t = tr_torrentNext (session, t)))
+    {
+      if (t->queuePosition > tor->queuePosition)
+        {
+          t->queuePosition--;
+          t->anyDate = now;
         }
     }
-    assert (queueIsSequenced (session));
-
-    tr_bandwidthDestruct (&tor->bandwidth);
-
-    tr_metainfoFree (inf);
-    memset (tor, ~0, sizeof (tr_torrent));
-    tr_free (tor);
-
-    tr_sessionUnlock (session);
+  assert (queueIsSequenced (session));
+
+  tr_bandwidthDestruct (&tor->bandwidth);
+
+  tr_metainfoFree (inf);
+  memset (tor, ~0, sizeof (tr_torrent));
+  tr_free (tor);
+
+  tr_sessionUnlock (session);
 }
 
@@ -1609 +1628 @@
 torrentStartImpl (void * vtor)
 {
-    time_t now;
-    tr_torrent * tor = vtor;
-
-    assert (tr_isTorrent (tor));
-
-    tr_sessionLock (tor->session);
-
-    tr_torrentRecheckCompleteness (tor);
-    torrentSetQueued (tor, false);
-
-    now = tr_time ();
-    tor->isRunning = true;
-    tor->completeness = tr_cpGetStatus (&tor->completion);
-    tor->startDate = tor->anyDate = now;
-    tr_torrentClearError (tor);
-    tor->finishedSeedingByIdle = false;
-
-    tr_torrentResetTransferStats (tor);
-    tr_announcerTorrentStarted (tor);
-    tor->dhtAnnounceAt = now + tr_cryptoWeakRandInt (20);
-    tor->dhtAnnounce6At = now + tr_cryptoWeakRandInt (20);
-    tor->lpdAnnounceAt = now;
-    tr_peerMgrStartTorrent (tor);
-
-    tr_sessionUnlock (tor->session);
+  time_t now;
+  tr_torrent * tor = vtor;
+
+  assert (tr_isTorrent (tor));
+
+  tr_sessionLock (tor->session);
+
+  tr_torrentRecheckCompleteness (tor);
+  torrentSetQueued (tor, false);
+
+  now = tr_time ();
+  tor->isRunning = true;
+  tor->completeness = tr_cpGetStatus (&tor->completion);
+  tor->startDate = tor->anyDate = now;
+  tr_torrentClearError (tor);
+  tor->finishedSeedingByIdle = false;
+
+  tr_torrentResetTransferStats (tor);
+  tr_announcerTorrentStarted (tor);
+  tor->dhtAnnounceAt = now + tr_cryptoWeakRandInt (20);
+  tor->dhtAnnounce6At = now + tr_cryptoWeakRandInt (20);
+  tor->lpdAnnounceAt = now;
+  tr_peerMgrStartTorrent (tor);
+
+  tr_sessionUnlock (tor->session);
 }
 
@@ -1639 +1658 @@
 tr_torrentGetCurrentSizeOnDisk (const tr_torrent * tor)
 {
-    tr_file_index_t i;
-    uint64_t byte_count = 0;
-    const tr_file_index_t n = tor->info.fileCount;
-
-    for (i=0; i<n; ++i)
-    {
-        struct stat sb;
-        char * filename = tr_torrentFindFile (tor, i);
-
-        sb.st_size = 0;
-        if (filename && !stat (filename, &sb))
-            byte_count += sb.st_size;
-
-        tr_free (filename);
-    }
-
-    return byte_count;
+  tr_file_index_t i;
+  uint64_t byte_count = 0;
+  const tr_file_index_t n = tor->info.fileCount;
+
+  for (i=0; i<n; ++i)
+    {
+      struct stat sb;
+      char * filename = tr_torrentFindFile (tor, i);
+
+      sb.st_size = 0;
+      if (filename && !stat (filename, &sb))
+        byte_count += sb.st_size;
+
+      tr_free (filename);
+    }
+
+  return byte_count;
 }
 
@@ -1661 +1680 @@
 torrentShouldQueue (const tr_torrent * tor)
 {
-    const tr_direction dir = tr_torrentGetQueueDirection (tor);
-
-    return tr_sessionCountQueueFreeSlots (tor->session, dir) == 0;
+  const tr_direction dir = tr_torrentGetQueueDirection (tor);
+
+  return tr_sessionCountQueueFreeSlots (tor->session, dir) == 0;
 }
 
@@ -1669 +1688 @@
 torrentStart (tr_torrent * tor, bool bypass_queue)
 {
-    switch (tr_torrentGetActivity (tor))
-    {
-        case TR_STATUS_SEED:
-        case TR_STATUS_DOWNLOAD:
-            return; /* already started */
-            break;
-
-        case TR_STATUS_SEED_WAIT:
-        case TR_STATUS_DOWNLOAD_WAIT:
-            if (!bypass_queue)
-                return; /* already queued */
-            break;
-
-        case TR_STATUS_CHECK:
-        case TR_STATUS_CHECK_WAIT:
-            /* verifying right now... wait until that's done so
-             * we'll know what completeness to use/announce */
-            tor->startAfterVerify = true;
+  switch (tr_torrentGetActivity (tor))
+    {
+      case TR_STATUS_SEED:
+      case TR_STATUS_DOWNLOAD:
+        return; /* already started */
+        break;
+
+      case TR_STATUS_SEED_WAIT:
+      case TR_STATUS_DOWNLOAD_WAIT:
+        if (!bypass_queue)
+          return; /* already queued */
+        break;
+
+      case TR_STATUS_CHECK:
+      case TR_STATUS_CHECK_WAIT:
+        /* verifying right now... wait until that's done so
+         * we'll know what completeness to use/announce */
+        tor->startAfterVerify = true;
+        return;
+        break;
+
+      case TR_STATUS_STOPPED:
+        if (!bypass_queue && torrentShouldQueue (tor))
+          {
+            torrentSetQueued (tor, true);
             return;
-            break;
-
-        case TR_STATUS_STOPPED:
-            if (!bypass_queue && torrentShouldQueue (tor)) {
-                torrentSetQueued (tor, true);
-                return;
-            }
-            break;
-    }
-
-    /* don't allow the torrent to be started if the files disappeared */
-    if (setLocalErrorIfFilesDisappeared (tor))
-        return;
-
-    /* otherwise, start it now... */
-    tr_sessionLock (tor->session);
-
-    /* allow finished torrents to be resumed */
-    if (tr_torrentIsSeedRatioDone (tor)) {
-        tr_logAddTorInfo (tor, "%s", _("Restarted manually -- disabling its seed ratio"));
-        tr_torrentSetRatioMode (tor, TR_RATIOLIMIT_UNLIMITED);
-    }
-
-    /* corresponds to the peer_id sent as a tracker request parameter.
-     * one tracker admin says: "When the same torrent is opened and
-     * closed and opened again without quitting Transmission ...
-     * change the peerid. It would help sometimes if a stopped event
-     * was missed to ensure that we didn't think someone was cheating. */
-    tr_torrentUnsetPeerId (tor);
-    tor->isRunning = true;
-    tr_torrentSetDirty (tor);
-    tr_runInEventThread (tor->session, torrentStartImpl, tor);
-
-    tr_sessionUnlock (tor->session);
+          }
+        break;
+    }
+
+  /* don't allow the torrent to be started if the files disappeared */
+  if (setLocalErrorIfFilesDisappeared (tor))
+    return;
+
+  /* otherwise, start it now... */
+  tr_sessionLock (tor->session);
+
+  /* allow finished torrents to be resumed */
+  if (tr_torrentIsSeedRatioDone (tor))
+    {
+      tr_logAddTorInfo (tor, "%s", _("Restarted manually -- disabling its seed ratio"));
+      tr_torrentSetRatioMode (tor, TR_RATIOLIMIT_UNLIMITED);
+    }
+
+  /* corresponds to the peer_id sent as a tracker request parameter.
+   * one tracker admin says: "When the same torrent is opened and
+   * closed and opened again without quitting Transmission ...
+   * change the peerid. It would help sometimes if a stopped event
+   * was missed to ensure that we didn't think someone was cheating. */
+  tr_torrentUnsetPeerId (tor);
+  tor->isRunning = true;
+  tr_torrentSetDirty (tor);
+  tr_runInEventThread (tor->session, torrentStartImpl, tor);
+
+  tr_sessionUnlock (tor->session);
 }
 
@@ -1727 +1748 @@
 tr_torrentStart (tr_torrent * tor)
 {
-    if (tr_isTorrent (tor))
-        torrentStart (tor, false);
+  if (tr_isTorrent (tor))
+    torrentStart (tor, false);
 }
 
@@ -1734 +1755 @@
 tr_torrentStartNow (tr_torrent * tor)
 {
-    if (tr_isTorrent (tor))
-        torrentStart (tor, true);
+  if (tr_isTorrent (tor))
+    torrentStart (tor, true);
 }
 
@@ -1818 +1839 @@
 tr_torrentSave (tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    if (tor->isDirty)
-    {
-        tor->isDirty = false;
-        tr_torrentSaveResume (tor);
+  assert (tr_isTorrent (tor));
+
+  if (tor->isDirty)
+    {
+      tor->isDirty = false;
+      tr_torrentSaveResume (tor);
     }
 }
@@ -1854 +1875 @@
 tr_torrentStop (tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    if (tr_isTorrent (tor))
-    {
-        tr_sessionLock (tor->session);
-
-        tor->isRunning = 0;
-        tor->isStopping = 0;
-        tr_torrentSetDirty (tor);
-        tr_runInEventThread (tor->session, stopTorrent, tor);
-
-        tr_sessionUnlock (tor->session);
+  assert (tr_isTorrent (tor));
+
+  if (tr_isTorrent (tor))
+    {
+      tr_sessionLock (tor->session);
+
+      tor->isRunning = 0;
+      tor->isStopping = 0;
+      tr_torrentSetDirty (tor);
+      tr_runInEventThread (tor->session, stopTorrent, tor);
+
+      tr_sessionUnlock (tor->session);
     }
 }
@@ -1872 +1893 @@
 closeTorrent (void * vtor)
 {
-    tr_variant * d;
-    tr_torrent * tor = vtor;
-
-    assert (tr_isTorrent (tor));
-
-    d = tr_variantListAddDict (&tor->session->removedTorrents, 2);
-    tr_variantDictAddInt (d, TR_KEY_id, tor->uniqueId);
-    tr_variantDictAddInt (d, TR_KEY_date, tr_time ());
-
-    tr_logAddTorInfo (tor, "%s", _("Removing torrent"));
-
-    stopTorrent (tor);
-
-    if (tor->isDeleting)
-    {
-        tr_metainfoRemoveSaved (tor->session, &tor->info);
-        tr_torrentRemoveResume (tor);
-    }
-
-    tor->isRunning = 0;
-    freeTorrent (tor);
+  tr_variant * d;
+  tr_torrent * tor = vtor;
+
+  assert (tr_isTorrent (tor));
+
+  d = tr_variantListAddDict (&tor->session->removedTorrents, 2);
+  tr_variantDictAddInt (d, TR_KEY_id, tor->uniqueId);
+  tr_variantDictAddInt (d, TR_KEY_date, tr_time ());
+
+  tr_logAddTorInfo (tor, "%s", _("Removing torrent"));
+
+  stopTorrent (tor);
+
+  if (tor->isDeleting)
+    {
+      tr_metainfoRemoveSaved (tor->session, &tor->info);
+      tr_torrentRemoveResume (tor);
+    }
+
+  tor->isRunning = 0;
+  freeTorrent (tor);
 }
 
@@ -1942 +1963 @@
                   tr_fileFunc    deleteFunc)
 {
-    struct remove_data * data;
-
-    assert (tr_isTorrent (tor));
-    tor->isDeleting = 1;
-
-    data = tr_new0 (struct remove_data, 1);
-    data->tor = tor;
-    data->deleteFlag = deleteFlag;
-    data->deleteFunc = deleteFunc;
-    tr_runInEventThread (tor->session, removeTorrent, data);
+  struct remove_data * data;
+
+  assert (tr_isTorrent (tor));
+  tor->isDeleting = 1;
+
+  data = tr_new0 (struct remove_data, 1);
+  data->tor = tor;
+  data->deleteFlag = deleteFlag;
+  data->deleteFunc = deleteFunc;
+  tr_runInEventThread (tor->session, removeTorrent, data);
 }
 
@@ -1961 +1982 @@
 getCompletionString (int type)
 {
-    switch (type)
-    {
-        /* Translators: this is a minor point that's safe to skip over, but FYI:
-           "Complete" and "Done" are specific, different terms in Transmission:
-           "Complete" means we've downloaded every file in the torrent.
-           "Done" means we're done downloading the files we wanted, but NOT all
-           that exist */
-        case TR_PARTIAL_SEED:
-            return _("Done");
-
-        case TR_SEED:
-            return _("Complete");
-
-        default:
-            return _("Incomplete");
+  switch (type)
+    {
+      /* Translators: this is a minor point that's safe to skip over, but FYI:
+         "Complete" and "Done" are specific, different terms in Transmission:
+         "Complete" means we've downloaded every file in the torrent.
+         "Done" means we're done downloading the files we wanted, but NOT all
+         that exist */
+      case TR_PARTIAL_SEED:
+        return _("Done");
+
+      case TR_SEED:
+        return _("Complete");
+
+      default:
+        return _("Incomplete");
     }
 }
@@ -1984 +2005 @@
                         bool               wasRunning)
 {
-    assert ((status == TR_LEECH)
-         || (status == TR_SEED)
-         || (status == TR_PARTIAL_SEED));
-
-    if (tor->completeness_func)
-        tor->completeness_func (tor, status, wasRunning,
-                                tor->completeness_func_user_data);
+  assert ((status == TR_LEECH)
+       || (status == TR_SEED)
+       || (status == TR_PARTIAL_SEED));
+
+  if (tor->completeness_func)
+    tor->completeness_func (tor, status, wasRunning,
+                            tor->completeness_func_user_data);
 }
 
@@ -1998 +2019 @@
                                    void                          * user_data)
 {
-    assert (tr_isTorrent (tor));
-
-    tor->completeness_func = func;
-    tor->completeness_func_user_data = user_data;
+  assert (tr_isTorrent (tor));
+
+  tor->completeness_func = func;
+  tor->completeness_func_user_data = user_data;
 }
 
@@ -2007 +2028 @@
 tr_torrentClearCompletenessCallback (tr_torrent * torrent)
 {
-    tr_torrentSetCompletenessCallback (torrent, NULL, NULL);
+  tr_torrentSetCompletenessCallback (torrent, NULL, NULL);
 }
 
@@ -2015 +2036 @@
                                     void                           * user_data)
 {
-    assert (tr_isTorrent (tor));
-
-    tor->ratio_limit_hit_func = func;
-    tor->ratio_limit_hit_func_user_data = user_data;
+  assert (tr_isTorrent (tor));
+
+  tor->ratio_limit_hit_func = func;
+  tor->ratio_limit_hit_func_user_data = user_data;
 }
 
@@ -2024 +2045 @@
 tr_torrentClearRatioLimitHitCallback (tr_torrent * torrent)
 {
-    tr_torrentSetRatioLimitHitCallback (torrent, NULL, NULL);
+  tr_torrentSetRatioLimitHitCallback (torrent, NULL, NULL);
 }
 
@@ -2032 +2053 @@
                                    void                          * user_data)
 {
-    assert (tr_isTorrent (tor));
-
-    tor->idle_limit_hit_func = func;
-    tor->idle_limit_hit_func_user_data = user_data;
+  assert (tr_isTorrent (tor));
+
+  tor->idle_limit_hit_func = func;
+  tor->idle_limit_hit_func_user_data = user_data;
 }
 
@@ -2041 +2062 @@
 tr_torrentClearIdleLimitHitCallback (tr_torrent * torrent)
 {
-    tr_torrentSetIdleLimitHitCallback (torrent, NULL, NULL);
+  tr_torrentSetIdleLimitHitCallback (torrent, NULL, NULL);
 }
 
@@ -2047 +2068 @@
 onSigCHLD (int i UNUSED)
 {
-    waitpid (-1, NULL, WNOHANG);
+  waitpid (-1, NULL, WNOHANG);
 }
 
@@ -2053 +2074 @@
 torrentCallScript (const tr_torrent * tor, const char * script)
 {
-    char timeStr[128];
-    const time_t now = tr_time ();
-
-    tr_strlcpy (timeStr, ctime (&now), sizeof (timeStr));
-    *strchr (timeStr,'\n') = '\0';
-
-    if (script && *script)
-    {
-        int i;
-        char * cmd[] = { tr_strdup (script), NULL };
-        char * env[] = {
-            tr_strdup_printf ("TR_APP_VERSION=%s", SHORT_VERSION_STRING),
-            tr_strdup_printf ("TR_TIME_LOCALTIME=%s", timeStr),
-            tr_strdup_printf ("TR_TORRENT_DIR=%s", tor->currentDir),
-            tr_strdup_printf ("TR_TORRENT_ID=%d", tr_torrentId (tor)),
-            tr_strdup_printf ("TR_TORRENT_HASH=%s", tor->info.hashString),
-            tr_strdup_printf ("TR_TORRENT_NAME=%s", tr_torrentName (tor)),
-            NULL };
-
-        tr_logAddTorInfo (tor, "Calling script \"%s\"", script);
+  char timeStr[128];
+  const time_t now = tr_time ();
+
+  tr_strlcpy (timeStr, ctime (&now), sizeof (timeStr));
+  *strchr (timeStr,'\n') = '\0';
+
+  if (script && *script)
+    {
+      int i;
+      char * cmd[] = { tr_strdup (script), NULL };
+      char * env[] = {
+        tr_strdup_printf ("TR_APP_VERSION=%s", SHORT_VERSION_STRING),
+        tr_strdup_printf ("TR_TIME_LOCALTIME=%s", timeStr),
+        tr_strdup_printf ("TR_TORRENT_DIR=%s", tor->currentDir),
+        tr_strdup_printf ("TR_TORRENT_ID=%d", tr_torrentId (tor)),
+        tr_strdup_printf ("TR_TORRENT_HASH=%s", tor->info.hashString),
+        tr_strdup_printf ("TR_TORRENT_NAME=%s", tr_torrentName (tor)),
+        NULL };
+
+      tr_logAddTorInfo (tor, "Calling script \"%s\"", script);
 
 #ifdef WIN32
-        if (_spawnvpe (_P_NOWAIT, script, (const char*)cmd, env) == -1)
-          tr_logAddTorErr (tor, "error executing script \"%s\": %s", cmd[0], tr_strerror (errno));
+      if (_spawnvpe (_P_NOWAIT, script, (const char*)cmd, env) == -1)
+        tr_logAddTorErr (tor, "error executing script \"%s\": %s", cmd[0], tr_strerror (errno));
 #else
-        signal (SIGCHLD, onSigCHLD);
-
-        if (!fork ())
+      signal (SIGCHLD, onSigCHLD);
+
+      if (!fork ())
         {
-            for (i=0; env[i]; ++i)
-                putenv (env[i]);
-
-            if (execvp (script, cmd) == -1)
-              tr_logAddTorErr (tor, "error executing script \"%s\": %s", cmd[0], tr_strerror (errno));
-
-            _exit (0);
+          for (i=0; env[i]; ++i)
+            putenv (env[i]);
+
+          if (execvp (script, cmd) == -1)
+            tr_logAddTorErr (tor, "error executing script \"%s\": %s", cmd[0], tr_strerror (errno));
+
+          _exit (0);
         }
 #endif
 
-        for (i=0; cmd[i]; ++i) tr_free (cmd[i]);
-        for (i=0; env[i]; ++i) tr_free (env[i]);
+      for (i=0; cmd[i]; ++i) tr_free (cmd[i]);
+      for (i=0; env[i]; ++i) tr_free (env[i]);
     }
 }
@@ -2159 +2180 @@
 tr_torrentFireMetadataCompleted (tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    if (tor->metadata_func)
-        tor->metadata_func (tor, tor->metadata_func_user_data);
+  assert (tr_isTorrent (tor));
+
+  if (tor->metadata_func != NULL)
+    tor->metadata_func (tor, tor->metadata_func_user_data);
 }
 
@@ -2170 +2191 @@
                                void                      * user_data)
 {
-    assert (tr_isTorrent (tor));
-
-    tor->metadata_func = func;
-    tor->metadata_func_user_data = user_data;
+  assert (tr_isTorrent (tor));
+
+  tor->metadata_func = func;
+  tor->metadata_func_user_data = user_data;
 }
 
@@ -2186 +2207 @@
                             tr_priority_t   priority)
 {
-    tr_piece_index_t i;
-    tr_file *        file;
-
-    assert (tr_isTorrent (tor));
-    assert (fileIndex < tor->info.fileCount);
-    assert (tr_isPriority (priority));
-
-    file = &tor->info.files[fileIndex];
-    file->priority = priority;
-    for (i = file->firstPiece; i <= file->lastPiece; ++i)
-        tor->info.pieces[i].priority = calculatePiecePriority (tor, i, fileIndex);
+  tr_file * file;
+  tr_piece_index_t i;
+
+  assert (tr_isTorrent (tor));
+  assert (fileIndex < tor->info.fileCount);
+  assert (tr_isPriority (priority));
+
+  file = &tor->info.files[fileIndex];
+  file->priority = priority;
+  for (i=file->firstPiece; i<=file->lastPiece; ++i)
+    tor->info.pieces[i].priority = calculatePiecePriority (tor, i, fileIndex);
 }
 
@@ -2205 +2226 @@
                              tr_priority_t            priority)
 {
-    tr_file_index_t i;
-    assert (tr_isTorrent (tor));
-    tr_torrentLock (tor);
-
-    for (i = 0; i < fileCount; ++i)
-        if (files[i] < tor->info.fileCount)
-            tr_torrentInitFilePriority (tor, files[i], priority);
-    tr_torrentSetDirty (tor);
-    tr_peerMgrRebuildRequests (tor);
-
-    tr_torrentUnlock (tor);
+  tr_file_index_t i;
+  assert (tr_isTorrent (tor));
+  tr_torrentLock (tor);
+
+  for (i=0; i<fileCount; ++i)
+    if (files[i] < tor->info.fileCount)
+      tr_torrentInitFilePriority (tor, files[i], priority);
+  tr_torrentSetDirty (tor);
+  tr_peerMgrRebuildRequests (tor);
+
+  tr_torrentUnlock (tor);
 }
 
@@ -2241 +2262 @@
 setFileDND (tr_torrent * tor, tr_file_index_t fileIndex, int doDownload)
 {
-    const int8_t     dnd = !doDownload;
-    tr_piece_index_t firstPiece;
-    int8_t           firstPieceDND;
-    tr_piece_index_t lastPiece;
-    int8_t           lastPieceDND;
-    tr_file_index_t  i;
-    tr_file *        file = &tor->info.files[fileIndex];
-
-    file->dnd = dnd;
-    firstPiece = file->firstPiece;
-    lastPiece = file->lastPiece;
-
-    /* can't set the first piece to DND unless
-       every file using that piece is DND */
-    firstPieceDND = dnd;
-    if (fileIndex > 0)
-    {
-        for (i = fileIndex - 1; firstPieceDND; --i)
+  const int8_t dnd = !doDownload;
+  tr_piece_index_t firstPiece;
+  int8_t firstPieceDND;
+  tr_piece_index_t lastPiece;
+  int8_t lastPieceDND;
+  tr_file_index_t  i;
+  tr_file * file = &tor->info.files[fileIndex];
+
+  file->dnd = dnd;
+  firstPiece = file->firstPiece;
+  lastPiece = file->lastPiece;
+
+  /* can't set the first piece to DND unless
+     every file using that piece is DND */
+  firstPieceDND = dnd;
+  if (fileIndex > 0)
+    {
+      for (i=fileIndex-1; firstPieceDND; --i)
         {
-            if (tor->info.files[i].lastPiece != firstPiece)
-                break;
-            firstPieceDND = tor->info.files[i].dnd;
-            if (!i)
-                break;
+          if (tor->info.files[i].lastPiece != firstPiece)
+            break;
+
+          firstPieceDND = tor->info.files[i].dnd;
+          if (!i)
+            break;
         }
     }
 
-    /* can't set the last piece to DND unless
-       every file using that piece is DND */
-    lastPieceDND = dnd;
-    for (i = fileIndex + 1; lastPieceDND && i < tor->info.fileCount; ++i)
-    {
-        if (tor->info.files[i].firstPiece != lastPiece)
-            break;
-        lastPieceDND = tor->info.files[i].dnd;
-    }
-
-    if (firstPiece == lastPiece)
-    {
-        tor->info.pieces[firstPiece].dnd = firstPieceDND && lastPieceDND;
-    }
-    else
-    {
-        tr_piece_index_t pp;
-        tor->info.pieces[firstPiece].dnd = firstPieceDND;
-        tor->info.pieces[lastPiece].dnd = lastPieceDND;
-        for (pp = firstPiece + 1; pp < lastPiece; ++pp)
-            tor->info.pieces[pp].dnd = dnd;
+  /* can't set the last piece to DND unless
+     every file using that piece is DND */
+  lastPieceDND = dnd;
+  for (i=fileIndex+1; lastPieceDND && i<tor->info.fileCount; ++i)
+    {
+      if (tor->info.files[i].firstPiece != lastPiece)
+        break;
+      lastPieceDND = tor->info.files[i].dnd;
+    }
+
+  if (firstPiece == lastPiece)
+    {
+      tor->info.pieces[firstPiece].dnd = firstPieceDND && lastPieceDND;
+    }
+  else
+    {
+      tr_piece_index_t pp;
+      tor->info.pieces[firstPiece].dnd = firstPieceDND;
+      tor->info.pieces[lastPiece].dnd = lastPieceDND;
+      for (pp=firstPiece+1; pp<lastPiece; ++pp)
+        tor->info.pieces[pp].dnd = dnd;
     }
 }
@@ -2298 +2320 @@
                        bool                     doDownload)
 {
-    tr_file_index_t i;
-
-    assert (tr_isTorrent (tor));
-
-    tr_torrentLock (tor);
-
-    for (i=0; i<fileCount; ++i)
-        if (files[i] < tor->info.fileCount)
-            setFileDND (tor, files[i], doDownload);
-
-    tr_cpInvalidateDND (&tor->completion);
-
-    tr_torrentUnlock (tor);
+  tr_file_index_t i;
+
+  assert (tr_isTorrent (tor));
+
+  tr_torrentLock (tor);
+
+  for (i=0; i<fileCount; ++i)
+    if (files[i] < tor->info.fileCount)
+      setFileDND (tor, files[i], doDownload);
+
+  tr_cpInvalidateDND (&tor->completion);
+
+  tr_torrentUnlock (tor);
 }
 
@@ -2319 +2341 @@
                       bool                     doDownload)
 {
-    assert (tr_isTorrent (tor));
-    tr_torrentLock (tor);
-
-    tr_torrentInitFileDLs (tor, files, fileCount, doDownload);
-    tr_torrentSetDirty (tor);
-    tr_torrentRecheckCompleteness (tor);
-    tr_peerMgrRebuildRequests (tor);
-
-    tr_torrentUnlock (tor);
+  assert (tr_isTorrent (tor));
+  tr_torrentLock (tor);
+
+  tr_torrentInitFileDLs (tor, files, fileCount, doDownload);
+  tr_torrentSetDirty (tor);
+  tr_torrentRecheckCompleteness (tor);
+  tr_peerMgrRebuildRequests (tor);
+
+  tr_torrentUnlock (tor);
 }
 
@@ -2337 +2359 @@
 tr_torrentGetPriority (const tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    return tor->bandwidth.priority;
+  assert (tr_isTorrent (tor));
+
+  return tor->bandwidth.priority;
 }
 
@@ -2345 +2367 @@
 tr_torrentSetPriority (tr_torrent * tor, tr_priority_t priority)
 {
-    assert (tr_isTorrent (tor));
-    assert (tr_isPriority (priority));
-
-    if (tor->bandwidth.priority != priority)
-    {
-        tor->bandwidth.priority = priority;
-
-        tr_torrentSetDirty (tor);
+  assert (tr_isTorrent (tor));
+  assert (tr_isPriority (priority));
+
+  if (tor->bandwidth.priority != priority)
+    {
+      tor->bandwidth.priority = priority;
+
+      tr_torrentSetDirty (tor);
     }
 }
@@ -2364 +2386 @@
                         uint16_t     maxConnectedPeers)
 {
-    assert (tr_isTorrent (tor));
-
-    if (tor->maxConnectedPeers != maxConnectedPeers)
-    {
-        tor->maxConnectedPeers = maxConnectedPeers;
-
-        tr_torrentSetDirty (tor);
+  assert (tr_isTorrent (tor));
+
+  if (tor->maxConnectedPeers != maxConnectedPeers)
+    {
+      tor->maxConnectedPeers = maxConnectedPeers;
+
+      tr_torrentSetDirty (tor);
     }
 }
@@ -2377 +2399 @@
 tr_torrentGetPeerLimit (const tr_torrent * tor)
 {
-    assert (tr_isTorrent (tor));
-
-    return tor->maxConnectedPeers;
+  assert (tr_isTorrent (tor));
+
+  return tor->maxConnectedPeers;
 }
 
@@ -2393 +2415 @@
                             uint32_t         * length)
 {
-    uint64_t pos = block;
-    pos *= tor->blockSize;
-    *piece = pos / tor->info.pieceSize;
-    *offset = pos - (*piece * tor->info.pieceSize);
-    *length = tr_torBlockCountBytes (tor, block);
+  uint64_t pos = block;
+  pos *= tor->blockSize;
+  *piece = pos / tor->info.pieceSize;
+  *offset = pos - (*piece * tor->info.pieceSize);
+  *length = tr_torBlockCountBytes (tor, block);
 }
 
@@ -2406 +2428 @@
            uint32_t           offset)
 {
-    tr_block_index_t ret;
-
-    assert (tr_isTorrent (tor));
-
-    ret = index;
-    ret *= (tor->info.pieceSize / tor->blockSize);
-    ret += offset / tor->blockSize;
-    return ret;
+  tr_block_index_t ret;
+
+  assert (tr_isTorrent (tor));
+
+  ret = index;
+  ret *= (tor->info.pieceSize / tor->blockSize);
+  ret += offset / tor->blockSize;
+  return ret;
 }
 
@@ -2422 +2444 @@
                       uint32_t           length)
 {
-    int err = 0;
-
-    assert (tr_isTorrent (tor));
-
-    if (index >= tor->info.pieceCount)
-        err = 1;
-    else if (length < 1)
-        err = 2;
-    else if ((offset + length) > tr_torPieceCountBytes (tor, index))
-        err = 3;
-    else if (length > MAX_BLOCK_SIZE)
-        err = 4;
-    else if (tr_pieceOffset (tor, index, offset, length) > tor->info.totalSize)
-        err = 5;
-
-    if (err) tr_logAddTorDbg (tor, "index %lu offset %lu length %lu err %d\n",
-                            (unsigned long)index,
-                            (unsigned long)offset,
-                            (unsigned long)length,
-                              err);
-
-    return !err;
+  int err = 0;
+
+  assert (tr_isTorrent (tor));
+
+  if (index >= tor->info.pieceCount)
+    err = 1;
+  else if (length < 1)
+    err = 2;
+  else if ((offset + length) > tr_torPieceCountBytes (tor, index))
+    err = 3;
+  else if (length > MAX_BLOCK_SIZE)
+    err = 4;
+  else if (tr_pieceOffset (tor, index, offset, length) > tor->info.totalSize)
+    err = 5;
+
+  if (err)
+    tr_logAddTorDbg (tor, "index %lu offset %lu length %lu err %d\n",
+                     (unsigned long)index,
+                     (unsigned long)offset,
+                     (unsigned long)length,
+                     err);
+
+  return !err;
 }
 
@@ -2452 +2475 @@
                 uint32_t           length)
 {
-    uint64_t ret;
-
-    assert (tr_isTorrent (tor));
-
-    ret = tor->info.pieceSize;
-    ret *= index;
-    ret += offset;
-    ret += length;
-    return ret;
+  uint64_t ret;
+
+  assert (tr_isTorrent (tor));
+
+  ret = tor->info.pieceSize;
+  ret *= index;
+  ret += offset;
+  ret += length;
+  return ret;
 }
 
@@ -2469 +2492 @@
                          tr_block_index_t        * last)
 {
-    const tr_file * f = &tor->info.files[file];
-    uint64_t offset = f->offset;
-    *first = offset / tor->blockSize;
-    if (!f->length)
-        *last = *first;
-    else {
-        offset += f->length - 1;
-        *last = offset / tor->blockSize;
+  const tr_file * f = &tor->info.files[file];
+  uint64_t offset = f->offset;
+
+  *first = offset / tor->blockSize;
+
+  if (!f->length)
+    {
+      *last = *first;
+    }
+  else
+    {
+      offset += f->length - 1;
+      *last = offset / tor->blockSize;
     }
 }
@@ -2486 +2514 @@
                           tr_block_index_t        * last)
 {
-    uint64_t offset = tor->info.pieceSize;
-    offset *= piece;
-    *first = offset / tor->blockSize;
-    offset += (tr_torPieceCountBytes (tor, piece) - 1);
-    *last = offset / tor->blockSize;
+  uint64_t offset = tor->info.pieceSize;
+  offset *= piece;
+  *first = offset / tor->blockSize;
+  offset += (tr_torPieceCountBytes (tor, piece) - 1);
+  *last = offset / tor->blockSize;
 }
 
@@ -2501 +2529 @@
 tr_torrentSetPieceChecked (tr_torrent * tor, tr_piece_index_t pieceIndex)
 {
-    assert (tr_isTorrent (tor));
-    assert (pieceIndex < tor->info.pieceCount);
-
-    tor->info.pieces[pieceIndex].timeChecked = tr_time ();
+  assert (tr_isTorrent (tor));
+  assert (pieceIndex < tor->info.pieceCount);
+
+  tor->info.pieces[pieceIndex].timeChecked = tr_time ();
 }
 
@@ -2510 +2538 @@
 tr_torrentSetChecked (tr_torrent * tor, time_t when)
 {
-    tr_piece_index_t i, n;
-
-    assert (tr_isTorrent (tor));
-
-    for (i=0, n=tor->info.pieceCount; i!=n; ++i)
-        tor->info.pieces[i].timeChecked = when;
+  tr_piece_index_t i, n;
+
+  assert (tr_isTorrent (tor));
+
+  for (i=0, n=tor->info.pieceCount; i!=n; ++i)
+    tor->info.pieces[i].timeChecked = when;
 }
 
@@ -2521 +2549 @@
 tr_torrentCheckPiece (tr_torrent * tor, tr_piece_index_t pieceIndex)
 {
-    const bool pass = tr_ioTestPiece (tor, pieceIndex);
-
-    tr_deeplog_tor (tor, "[LAZY] tr_torrentCheckPiece tested piece %zu, pass==%d", (size_t)pieceIndex, (int)pass);
-    tr_torrentSetHasPiece (tor, pieceIndex, pass);
-    tr_torrentSetPieceChecked (tor, pieceIndex);
-    tor->anyDate = tr_time ();
-    tr_torrentSetDirty (tor);
-
-    return pass;
+  const bool pass = tr_ioTestPiece (tor, pieceIndex);
+
+  tr_deeplog_tor (tor, "[LAZY] tr_torrentCheckPiece tested piece %zu, pass==%d", (size_t)pieceIndex, (int)pass);
+  tr_torrentSetHasPiece (tor, pieceIndex, pass);
+  tr_torrentSetPieceChecked (tor, pieceIndex);
+  tor->anyDate = tr_time ();
+  tr_torrentSetDirty (tor);
+
+  return pass;
 }
 
@@ -2535 +2563 @@
 tr_torrentGetFileMTime (const tr_torrent * tor, tr_file_index_t i)
 {
-    time_t mtime = 0;
-    if (!tr_fdFileGetCachedMTime (tor->session, tor->uniqueId, i, &mtime))
-        tr_torrentFindFile2 (tor, i, NULL, NULL, &mtime);
-    return mtime;
+  time_t mtime = 0;
+
+  if (!tr_fdFileGetCachedMTime (tor->session, tor->uniqueId, i, &mtime))
+    tr_torrentFindFile2 (tor, i, NULL, NULL, &mtime);
+
+  return mtime;
 }
 
@@ -2544 +2574 @@
 tr_torrentPieceNeedsCheck (const tr_torrent * tor, tr_piece_index_t p)
 {
-    uint64_t unused;
-    tr_file_index_t f;
-    const tr_info * inf = tr_torrentInfo (tor);
-
-    /* if we've never checked this piece, then it needs to be checked */
-    if (!inf->pieces[p].timeChecked)
+  uint64_t unused;
+  tr_file_index_t f;
+  const tr_info * inf = tr_torrentInfo (tor);
+
+  /* if we've never checked this piece, then it needs to be checked */
+  if (!inf->pieces[p].timeChecked)
+    return true;
+
+  /* If we think we've completed one of the files in this piece,
+   * but it's been modified since we last checked it,
+   * then it needs to be rechecked */
+  tr_ioFindFileLocation (tor, p, 0, &f, &unused);
+  for (; f < inf->fileCount && pieceHasFile (p, &inf->files[f]); ++f)
+    if (tr_cpFileIsComplete (&tor->completion, f))
+      if (tr_torrentGetFileMTime (tor, f) > inf->pieces[p].timeChecked)
         return true;
 
-    /* If we think we've completed one of the files in this piece,
-     * but it's been modified since we last checked it,
-     * then it needs to be rechecked */
-    tr_ioFindFileLocation (tor, p, 0, &f, &unused);
-    for (; f < inf->fileCount && pieceHasFile (p, &inf->files[f]); ++f)
-        if (tr_cpFileIsComplete (&tor->completion, f))
-            if (tr_torrentGetFileMTime (tor, f) > inf->pieces[p].timeChecked)
-                return true;
-
-    return false;
+  return false;
 }
 
@@ -2571 +2601 @@
 compareTrackerByTier (const void * va, const void * vb)
 {
-    const tr_tracker_info * a = va;
-    const tr_tracker_info * b = vb;
-
-    /* sort by tier */
-    if (a->tier != b->tier)
-        return a->tier - b->tier;
-
-    /* get the effects of a stable sort by comparing the two elements' addresses */
-    return a - b;
+  const tr_tracker_info * a = va;
+  const tr_tracker_info * b = vb;
+
+  /* sort by tier */
+  if (a->tier != b->tier)
+    return a->tier - b->tier;
+
+  /* get the effects of a stable sort by comparing the two elements' addresses */
+  return a - b;
 }
 
@@ -2587 +2617 @@
                            int                      trackerCount)
 {
-    int i;
-    tr_variant metainfo;
-    bool ok = true;
-    tr_tracker_info * trackers;
-
-    tr_torrentLock (tor);
-
-    assert (tr_isTorrent (tor));
-
-    /* ensure the trackers' tiers are in ascending order */
-    trackers = tr_memdup (trackers_in, sizeof (tr_tracker_info) * trackerCount);
-    qsort (trackers, trackerCount, sizeof (tr_tracker_info), compareTrackerByTier);
-
-    /* look for bad URLs */
-    for (i=0; ok && i<trackerCount; ++i)
-        if (!tr_urlIsValidTracker (trackers[i].announce))
-            ok = false;
-
-    /* save to the .torrent file */
-    if (ok && !tr_variantFromFile (&metainfo, TR_VARIANT_FMT_BENC, tor->info.torrent))
-    {
-        bool hasInfo;
-        tr_info tmpInfo;
-
-        /* remove the old fields */
-        tr_variantDictRemove (&metainfo, TR_KEY_announce);
-        tr_variantDictRemove (&metainfo, TR_KEY_announce_list);
-
-        /* add the new fields */
-        if (trackerCount > 0)
+  int i;
+  tr_variant metainfo;
+  bool ok = true;
+  tr_tracker_info * trackers;
+
+  tr_torrentLock (tor);
+
+  assert (tr_isTorrent (tor));
+
+  /* ensure the trackers' tiers are in ascending order */
+  trackers = tr_memdup (trackers_in, sizeof (tr_tracker_info) * trackerCount);
+  qsort (trackers, trackerCount, sizeof (tr_tracker_info), compareTrackerByTier);
+
+  /* look for bad URLs */
+  for (i=0; ok && i<trackerCount; ++i)
+    if (!tr_urlIsValidTracker (trackers[i].announce))
+      ok = false;
+
+  /* save to the .torrent file */
+  if (ok && !tr_variantFromFile (&metainfo, TR_VARIANT_FMT_BENC, tor->info.torrent))
+    {
+      bool hasInfo;
+      tr_info tmpInfo;
+
+      /* remove the old fields */
+      tr_variantDictRemove (&metainfo, TR_KEY_announce);
+      tr_variantDictRemove (&metainfo, TR_KEY_announce_list);
+
+      /* add the new fields */
+      if (trackerCount > 0)
         {
-            tr_variantDictAddStr (&metainfo, TR_KEY_announce, trackers[0].announce);
+          tr_variantDictAddStr (&metainfo, TR_KEY_announce, trackers[0].announce);
         }
-        if (trackerCount > 1)
+      if (trackerCount > 1)
         {
-            int i;
-            int prevTier = -1;
-            tr_variant * tier = NULL;
-            tr_variant * announceList = tr_variantDictAddList (&metainfo, TR_KEY_announce_list, 0);
-
-            for (i=0; i<trackerCount; ++i) {
-                if (prevTier != trackers[i].tier) {
-                    prevTier = trackers[i].tier;
-                    tier = tr_variantListAddList (announceList, 0);
+          int i;
+          int prevTier = -1;
+          tr_variant * tier = NULL;
+          tr_variant * announceList = tr_variantDictAddList (&metainfo, TR_KEY_announce_list, 0);
+
+          for (i=0; i<trackerCount; ++i)
+            {
+              if (prevTier != trackers[i].tier)
+                {
+                  prevTier = trackers[i].tier;
+                  tier = tr_variantListAddList (announceList, 0);
                 }
-                tr_variantListAddStr (tier, trackers[i].announce);
+
+              tr_variantListAddStr (tier, trackers[i].announce);
             }
         }
 
-        /* try to parse it back again, to make sure it's good */
-        memset (&tmpInfo, 0, sizeof (tr_info));
-        if (tr_metainfoParse (tor->session, &metainfo, &tmpInfo,
-                              &hasInfo, &tor->infoDictLength))
+      /* try to parse it back again, to make sure it's good */
+      memset (&tmpInfo, 0, sizeof (tr_info));
+      if (tr_metainfoParse (tor->session, &metainfo, &tmpInfo,
+                            &hasInfo, &tor->infoDictLength))
         {
-            /* it's good, so keep these new trackers and free the old ones */
-
-            tr_info swap;
-            swap.trackers = tor->info.trackers;
-            swap.trackerCount = tor->info.trackerCount;
-            tor->info.trackers = tmpInfo.trackers;
-            tor->info.trackerCount = tmpInfo.trackerCount;
-            tmpInfo.trackers = swap.trackers;
-            tmpInfo.trackerCount = swap.trackerCount;
-
-            tr_metainfoFree (&tmpInfo);
-            tr_variantToFile (&metainfo, TR_VARIANT_FMT_BENC, tor->info.torrent);
+          /* it's good, so keep these new trackers and free the old ones */
+
+          tr_info swap;
+          swap.trackers = tor->info.trackers;
+          swap.trackerCount = tor->info.trackerCount;
+          tor->info.trackers = tmpInfo.trackers;
+          tor->info.trackerCount = tmpInfo.trackerCount;
+          tmpInfo.trackers = swap.trackers;
+          tmpInfo.trackerCount = swap.trackerCount;
+
+          tr_metainfoFree (&tmpInfo);
+          tr_variantToFile (&metainfo, TR_VARIANT_FMT_BENC, tor->info.torrent);
         }
 
-        /* cleanup */
-        tr_variantFree (&metainfo);
-
-        /* if we had a tracker-related error on this torrent,
-         * and that tracker's been removed,
-         * then clear the error */
-        if ((tor->error == TR_STAT_TRACKER_WARNING)
-            || (tor->error == TR_STAT_TRACKER_ERROR))
+      /* cleanup */
+      tr_variantFree (&metainfo);
+
+      /* if we had a tracker-related error on this torrent,
+       * and that tracker's been removed,
+       * then clear the error */
+      if ((tor->error == TR_STAT_TRACKER_WARNING)
+          || (tor->error == TR_STAT_TRACKER_ERROR))
         {
-            bool clear = true;
-
-            for (i=0; clear && i<trackerCount; ++i)
-                if (!strcmp (trackers[i].announce, tor->errorTracker))
-                    clear = false;
-
-            if (clear)
-                tr_torrentClearError (tor);
+          bool clear = true;
+
+          for (i=0; clear && i<trackerCount; ++i)
+            if (!strcmp (trackers[i].announce, tor->errorTracker))
+              clear = false;
+
+          if (clear)
+            tr_torrentClearError (tor);
         }
 
-        /* tell the announcer to reload this torrent's tracker list */
-        tr_announcerResetTorrent (tor->session->announcer, tor);
-    }
-
-    tr_torrentUnlock (tor);
-
-    tr_free (trackers);
-    return ok;
+      /* tell the announcer to reload this torrent's tracker list */
+      tr_announcerResetTorrent (tor->session->announcer, tor);
+    }
+
+  tr_torrentUnlock (tor);
+
+  tr_free (trackers);
+  return ok;
 }
 
@@ -2692 +2725 @@
                         time_t       t)
 {
-    assert (tr_isTorrent (tor));
-
-    tor->addedDate = t;
-    tor->anyDate = MAX (tor->anyDate, tor->addedDate);
+  assert (tr_isTorrent (tor));
+
+  tor->addedDate = t;
+  tor->anyDate = MAX (tor->anyDate, tor->addedDate);
 }
 
@@ -2701 +2734 @@
 tr_torrentSetActivityDate (tr_torrent * tor, time_t t)
 {
-    assert (tr_isTorrent (tor));
-
-    tor->activityDate = t;
-    tor->anyDate = MAX (tor->anyDate, tor->activityDate);
+  assert (tr_isTorrent (tor));
+
+  tor->activityDate = t;
+  tor->anyDate = MAX (tor->anyDate, tor->activityDate);
 }
 
@@ -2711 +2744 @@
                        time_t       t)
 {
-    assert (tr_isTorrent (tor));
-
-    tor->doneDate = t;
-    tor->anyDate = MAX (tor->anyDate, tor->doneDate);
+  assert (tr_isTorrent (tor));
+
+  tor->doneDate = t;
+  tor->anyDate = MAX (tor->anyDate, tor->doneDate);
 }
 
@@ -2724 +2757 @@
 tr_torrentGetBytesLeftToAllocate (const tr_torrent * tor)
 {
-    tr_file_index_t i;
-    uint64_t bytesLeft = 0;
-
-    assert (tr_isTorrent (tor));
-
-    for (i=0; i<tor->info.fileCount; ++i)
-    {
-        if (!tor->info.files[i].dnd)
+  tr_file_index_t i;
+  uint64_t bytesLeft = 0;
+
+  assert (tr_isTorrent (tor));
+
+  for (i=0; i<tor->info.fileCount; ++i)
+    {
+      if (!tor->info.files[i].dnd)
         {
-            struct stat sb;
-            const uint64_t length = tor->info.files[i].length;
-            char * path = tr_torrentFindFile (tor, i);
-
-            bytesLeft += length;
-
-            if ((path != NULL) && !stat (path, &sb)
-                                 && S_ISREG (sb.st_mode)
-                                 && ((uint64_t)sb.st_size <= length))
-                bytesLeft -= sb.st_size;
-
-            tr_free (path);
+          struct stat sb;
+          const uint64_t length = tor->info.files[i].length;
+          char * path = tr_torrentFindFile (tor, i);
+
+          bytesLeft += length;
+
+          if ((path != NULL) && !stat (path, &sb)
+                             && S_ISREG (sb.st_mode)
+                             && ((uint64_t)sb.st_size <= length))
+            bytesLeft -= sb.st_size;
+
+          tr_free (path);
         }
     }
 
-    return bytesLeft;
+  return bytesLeft;
 }
 
@@ -2758 +2791 @@
 isJunkFile (const char * base)
 {
-    int i;
-    static const char * files[] = { ".DS_Store", "desktop.ini", "Thumbs.db" };
-    static const int file_count = sizeof (files) / sizeof (files[0]);
-
-    for (i=0; i<file_count; ++i)
-        if (!strcmp (base, files[i]))
-            return true;
+  int i;
+  static const char * files[] = { ".DS_Store", "desktop.ini", "Thumbs.db" };
+  static const int file_count = sizeof (files) / sizeof (files[0]);
+
+  for (i=0; i<file_count; ++i)
+    if (!strcmp (base, files[i]))
+      return true;
 
 #ifdef SYS_DARWIN
-    /* check for resource forks. <http://support.apple.com/kb/TA20578> */
-    if (!memcmp (base, "._", 2))
-        return true;
+  /* check for resource forks. <http://support.apple.com/kb/TA20578> */
+  if (!memcmp (base, "._", 2))
+    return true;
 #endif
 
-    return false;
+  return false;
 }
 
@@ -2778 +2811 @@
 removeEmptyFoldersAndJunkFiles (const char * folder)
 {
-    DIR * odir;
-    if ((odir = opendir (folder))) {
-        struct dirent * d;
-        while ((d = readdir (odir))) {
-            if (strcmp (d->d_name, ".") && strcmp (d->d_name, "..")) {
-                struct stat sb;
-                char * filename = tr_buildPath (folder, d->d_name, NULL);
-                if (!stat (filename, &sb) && S_ISDIR (sb.st_mode))
-                    removeEmptyFoldersAndJunkFiles (filename);
-                else if (isJunkFile (d->d_name))
-                    tr_remove (filename);
-                tr_free (filename);
+  DIR * odir;
+
+  if ((odir = opendir (folder)))
+    {
+      struct dirent * d;
+      while ((d = readdir (odir)))
+        {
+          if (strcmp (d->d_name, ".") && strcmp (d->d_name, ".."))
+            {
+              struct stat sb;
+              char * filename = tr_buildPath (folder, d->d_name, NULL);
+
+              if (!stat (filename, &sb) && S_ISDIR (sb.st_mode))
+                removeEmptyFoldersAndJunkFiles (filename);
+              else if (isJunkFile (d->d_name))
+                tr_remove (filename);
+
+              tr_free (filename);
             }
         }
-        tr_remove (folder);
-        closedir (odir);
+
+      tr_remove (folder);
+      closedir (odir);
     }
 }
@@ -2809 +2849 @@
 deleteLocalData (tr_torrent * tor, tr_fileFunc func)
 {
-    int i, n;
-    tr_file_index_t f;
-    char * base;
-    DIR * odir;
-    char * tmpdir = NULL;
-    tr_ptrArray files = TR_PTR_ARRAY_INIT;
-    tr_ptrArray folders = TR_PTR_ARRAY_INIT;
-    const void * const vstrcmp = strcmp;
-    const char * const top = tor->currentDir;
-
-    /* if it's a magnet link, there's nothing to move... */
-    if (!tr_torrentHasMetadata (tor))
-        return;
-
-    /***
-    ****  Move the local data to a new tmpdir
-    ***/
-
-    base = tr_strdup_printf ("%s__XXXXXX", tr_torrentName (tor));
-    tmpdir = tr_buildPath (top, base, NULL);
-    tr_mkdtemp (tmpdir);
-    tr_free (base);
-
-    for (f=0; f<tor->info.fileCount; ++f)
-    {
-        char * filename = tr_buildPath (top, tor->info.files[f].name, NULL);
-        if (!tr_fileExists (filename, NULL)) {
-                char * partial = tr_torrentBuildPartial (tor, f);
-                tr_free (filename);
-                filename = tr_buildPath (top, partial, NULL);
-                tr_free (partial);
-                if (!tr_fileExists (filename, NULL)) {
-                        tr_free (filename);
-                        filename = NULL;
-                }
-        }
-
-        if (filename != NULL)
+  int i, n;
+  tr_file_index_t f;
+  char * base;
+  DIR * odir;
+  char * tmpdir = NULL;
+  tr_ptrArray files = TR_PTR_ARRAY_INIT;
+  tr_ptrArray folders = TR_PTR_ARRAY_INIT;
+  const void * const vstrcmp = strcmp;
+  const char * const top = tor->currentDir;
+
+  /* if it's a magnet link, there's nothing to move... */
+  if (!tr_torrentHasMetadata (tor))
+    return;
+
+  /***
+  ****  Move the local data to a new tmpdir
+  ***/
+
+  base = tr_strdup_printf ("%s__XXXXXX", tr_torrentName (tor));
+  tmpdir = tr_buildPath (top, base, NULL);
+  tr_mkdtemp (tmpdir);
+  tr_free (base);
+
+  for (f=0; f<tor->info.fileCount; ++f)
+    {
+      char * filename;
+
+      /* try to find the file, looking in the partial and download dirs */
+      filename = tr_buildPath (top, tor->info.files[f].name, NULL);
+      if (!tr_fileExists (filename, NULL))
         {
-            char * target = tr_buildPath (tmpdir, tor->info.files[f].name, NULL);
-            tr_moveFile (filename, target, NULL);
-            tr_ptrArrayAppend (&files, target);
-            tr_free (filename);
-        }
-    }