Changeset 14081

Timestamp:

May 23, 2013, 5:43:12 AM (9 years ago)

Author:

jordan

Message:

whitespace/indentation

File:

• trunk/libtransmission/session.c (modified) (153 diffs)

trunk/libtransmission/session.c

@@ -60 +60 @@
 {
 #ifdef TR_LIGHTWEIGHT
-    DEFAULT_CACHE_SIZE_MB = 2,
-    DEFAULT_PREFETCH_ENABLED = false,
+  DEFAULT_CACHE_SIZE_MB = 2,
+  DEFAULT_PREFETCH_ENABLED = false,
 #else
-    DEFAULT_CACHE_SIZE_MB = 4,
-    DEFAULT_PREFETCH_ENABLED = true,
+  DEFAULT_CACHE_SIZE_MB = 4,
+  DEFAULT_PREFETCH_ENABLED = true,
 #endif
-    SAVE_INTERVAL_SECS = 360
+  SAVE_INTERVAL_SECS = 360
 };
 
@@ -81 +81 @@
 getRandomPort (tr_session * s)
 {
-    return tr_cryptoWeakRandInt (s->randomPortHigh - s->randomPortLow + 1) + s->randomPortLow;
+  return tr_cryptoWeakRandInt (s->randomPortHigh - s->randomPortLow + 1) + s->randomPortLow;
 }
 
@@ -91 +91 @@
 tr_peerIdInit (uint8_t * buf)
 {
-    int          i;
-    int          val;
-    int          total = 0;
-    const char * pool = "0123456789abcdefghijklmnopqrstuvwxyz";
-    const int    base = 36;
-
-    memcpy (buf, PEERID_PREFIX, 8);
-
-    tr_cryptoRandBuf (buf+8, 11);
-    for (i=8; i<19; ++i) {
-        val = buf[i] % base;
-        total += val;
-        buf[i] = pool[val];
-    }
-
-    val = total % base ? base - (total % base) : 0;
-    buf[19] = pool[val];
-    buf[20] = '\0';
+  int i;
+  int val;
+  int total = 0;
+  const char * pool = "0123456789abcdefghijklmnopqrstuvwxyz";
+  const int base = 36;
+
+  memcpy (buf, PEERID_PREFIX, 8);
+
+  tr_cryptoRandBuf (buf+8, 11);
+  for (i=8; i<19; ++i)
+    {
+      val = buf[i] % base;
+      total += val;
+      buf[i] = pool[val];
+    }
+
+  val = total % base ? base - (total % base) : 0;
+  buf[19] = pool[val];
+  buf[20] = '\0';
 }
 
@@ -118 +119 @@
 tr_sessionGetEncryption (tr_session * session)
 {
-    assert (session);
-
-    return session->encryptionMode;
-}
-
-void
-tr_sessionSetEncryption (tr_session *       session,
-                         tr_encryption_mode mode)
-{
-    assert (session);
-    assert (mode == TR_ENCRYPTION_PREFERRED
-          || mode == TR_ENCRYPTION_REQUIRED
-          || mode == TR_CLEAR_PREFERRED);
-
-    session->encryptionMode = mode;
+  assert (session);
+
+  return session->encryptionMode;
+}
+
+void
+tr_sessionSetEncryption (tr_session          * session,
+                         tr_encryption_mode    mode)
+{
+  assert (session);
+  assert (mode == TR_ENCRYPTION_PREFERRED
+       || mode == TR_ENCRYPTION_REQUIRED
+       || mode == TR_CLEAR_PREFERRED);
+
+  session->encryptionMode = mode;
 }
 
@@ -141 +142 @@
 struct tr_bindinfo
 {
-    int socket;
-    tr_address addr;
-    struct event * ev;
+  int socket;
+  tr_address addr;
+  struct event * ev;
 };
 
@@ -150 +151 @@
 close_bindinfo (struct tr_bindinfo * b)
 {
-    if ((b != NULL) && (b->socket >=0))
-    {
-        event_free (b->ev);
-        b->ev = NULL;
-        tr_netCloseSocket (b->socket);
+  if ((b != NULL) && (b->socket >=0))
+    {
+      event_free (b->ev);
+      b->ev = NULL;
+      tr_netCloseSocket (b->socket);
     }
 }
@@ -161 +162 @@
 close_incoming_peer_port (tr_session * session)
 {
-    close_bindinfo (session->public_ipv4);
-    close_bindinfo (session->public_ipv6);
+  close_bindinfo (session->public_ipv4);
+  close_bindinfo (session->public_ipv6);
 }
 
@@ -168 +169 @@
 free_incoming_peer_port (tr_session * session)
 {
-    close_bindinfo (session->public_ipv4);
-    tr_free (session->public_ipv4);
-    session->public_ipv4 = NULL;
-
-    close_bindinfo (session->public_ipv6);
-    tr_free (session->public_ipv6);
-    session->public_ipv6 = NULL;
+  close_bindinfo (session->public_ipv4);
+  tr_free (session->public_ipv4);
+  session->public_ipv4 = NULL;
+
+  close_bindinfo (session->public_ipv6);
+  tr_free (session->public_ipv6);
+  session->public_ipv6 = NULL;
 }
 
@@ -180 +181 @@
 accept_incoming_peer (int fd, short what UNUSED, void * vsession)
 {
-    int clientSocket;
-    tr_port clientPort;
-    tr_address clientAddr;
-    tr_session * session = vsession;
-
-    clientSocket = tr_netAccept (session, fd, &clientAddr, &clientPort);
-    if (clientSocket > 0) {
-        tr_logAddDeep (__FILE__, __LINE__, NULL, "new incoming connection %d (%s)",
+  int clientSocket;
+  tr_port clientPort;
+  tr_address clientAddr;
+  tr_session * session = vsession;
+
+  clientSocket = tr_netAccept (session, fd, &clientAddr, &clientPort);
+  if (clientSocket > 0)
+    {
+      tr_logAddDeep (__FILE__, __LINE__, NULL, "new incoming connection %d (%s)",
                        clientSocket, tr_peerIoAddrStr (&clientAddr, clientPort));
-        tr_peerMgrAddIncoming (session->peerMgr, &clientAddr, clientPort,
-                               clientSocket, NULL);
+      tr_peerMgrAddIncoming (session->peerMgr, &clientAddr, clientPort,
+                             clientSocket, NULL);
     }
 }
@@ -197 +199 @@
 open_incoming_peer_port (tr_session * session)
 {
-    struct tr_bindinfo * b;
-
-    /* bind an ipv4 port to listen for incoming peers... */
-    b = session->public_ipv4;
-    b->socket = tr_netBindTCP (&b->addr, session->private_peer_port, false);
-    if (b->socket >= 0) {
-        b->ev = event_new (session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session);
-        event_add (b->ev, NULL);
-    }
-
-    /* and do the exact same thing for ipv6, if it's supported... */
-    if (tr_net_hasIPv6 (session->private_peer_port)) {
-        b = session->public_ipv6;
-        b->socket = tr_netBindTCP (&b->addr, session->private_peer_port, false);
-        if (b->socket >= 0) {
-            b->ev = event_new (session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session);
-            event_add (b->ev, NULL);
+  struct tr_bindinfo * b;
+
+  /* bind an ipv4 port to listen for incoming peers... */
+  b = session->public_ipv4;
+  b->socket = tr_netBindTCP (&b->addr, session->private_peer_port, false);
+  if (b->socket >= 0)
+    {
+      b->ev = event_new (session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session);
+      event_add (b->ev, NULL);
+    }
+
+  /* and do the exact same thing for ipv6, if it's supported... */
+  if (tr_net_hasIPv6 (session->private_peer_port))
+    {
+      b = session->public_ipv6;
+      b->socket = tr_netBindTCP (&b->addr, session->private_peer_port, false);
+      if (b->socket >= 0)
+        {
+          b->ev = event_new (session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session);
+          event_add (b->ev, NULL);
         }
     }
@@ -221 +226 @@
 tr_sessionGetPublicAddress (const tr_session * session, int tr_af_type, bool * is_default_value)
 {
-    const char * default_value;
-    const struct tr_bindinfo * bindinfo;
-
-    switch (tr_af_type)
-    {
-        case TR_AF_INET:
-            bindinfo = session->public_ipv4;
-            default_value = TR_DEFAULT_BIND_ADDRESS_IPV4;
-            break;
-
-        case TR_AF_INET6:
-            bindinfo = session->public_ipv6;
-            default_value = TR_DEFAULT_BIND_ADDRESS_IPV6;
-            break;
-
-        default:
-            bindinfo = NULL;
-            default_value = "";
-            break;
-    }
-
-    if (is_default_value && bindinfo)
-        *is_default_value = !tr_strcmp0 (default_value, tr_address_to_string (&bindinfo->addr));
-
-    return bindinfo ? &bindinfo->addr : NULL;
+  const char * default_value;
+  const struct tr_bindinfo * bindinfo;
+
+  switch (tr_af_type)
+    {
+      case TR_AF_INET:
+        bindinfo = session->public_ipv4;
+        default_value = TR_DEFAULT_BIND_ADDRESS_IPV4;
+        break;
+
+      case TR_AF_INET6:
+        bindinfo = session->public_ipv6;
+        default_value = TR_DEFAULT_BIND_ADDRESS_IPV6;
+        break;
+
+      default:
+        bindinfo = NULL;
+        default_value = "";
+        break;
+    }
+
+  if (is_default_value && bindinfo)
+    *is_default_value = !tr_strcmp0 (default_value, tr_address_to_string (&bindinfo->addr));
+
+  return bindinfo ? &bindinfo->addr : NULL;
 }
 
@@ -261 +266 @@
 parse_tos (const char *str)
 {
-    char *p;
-    int value;
-
-    if (!evutil_ascii_strcasecmp (str, ""))
-        return 0;
-    if (!evutil_ascii_strcasecmp (str, "default"))
-        return 0;
-
-    if (!evutil_ascii_strcasecmp (str, "lowcost"))
-        return 0x10;
-    if (!evutil_ascii_strcasecmp (str, "mincost"))
-        return 0x10;
-
-    if (!evutil_ascii_strcasecmp (str, "throughput"))
-        return 0x08;
-    if (!evutil_ascii_strcasecmp (str, "reliability"))
-        return 0x04;
-    if (!evutil_ascii_strcasecmp (str, "lowdelay"))
-        return 0x02;
-
-    value = strtol (str, &p, 0);
-    if (!p || (p == str))
-        return 0;
-
-    return value;
+  char *p;
+  int value;
+
+  if (!evutil_ascii_strcasecmp (str, ""))
+    return 0;
+  if (!evutil_ascii_strcasecmp (str, "default"))
+    return 0;
+
+  if (!evutil_ascii_strcasecmp (str, "lowcost"))
+    return 0x10;
+  if (!evutil_ascii_strcasecmp (str, "mincost"))
+    return 0x10;
+
+  if (!evutil_ascii_strcasecmp (str, "throughput"))
+    return 0x08;
+  if (!evutil_ascii_strcasecmp (str, "reliability"))
+    return 0x04;
+  if (!evutil_ascii_strcasecmp (str, "lowdelay"))
+    return 0x02;
+
+  value = strtol (str, &p, 0);
+  if (!p || (p == str))
+    return 0;
+
+  return value;
 }
 
@@ -291 +296 @@
 format_tos (int value)
 {
-    static char buf[8];
-    switch (value) {
-    case 0: return "default";
-    case 0x10: return "lowcost";
-    case 0x08: return "throughput";
-    case 0x04: return "reliability";
-    case 0x02: return "lowdelay";
-    default:
+  static char buf[8];
+  switch (value)
+    {
+      case 0: return "default";
+      case 0x10: return "lowcost";
+      case 0x08: return "throughput";
+      case 0x04: return "reliability";
+      case 0x02: return "lowdelay";
+      default:
         tr_snprintf (buf, 8, "%d", value);
         return buf;
@@ -307 +313 @@
 tr_sessionGetDefaultSettings (tr_variant * d)
 {
-    assert (tr_variantIsDict (d));
-
-    tr_variantDictReserve (d, 63);
-    tr_variantDictAddBool (d, TR_KEY_blocklist_enabled,               false);
-    tr_variantDictAddStr  (d, TR_KEY_blocklist_url,                   "http://www.example.com/blocklist");
-    tr_variantDictAddInt  (d, TR_KEY_cache_size_mb,                   DEFAULT_CACHE_SIZE_MB);
-    tr_variantDictAddBool (d, TR_KEY_dht_enabled,                     true);
-    tr_variantDictAddBool (d, TR_KEY_utp_enabled,                     true);
-    tr_variantDictAddBool (d, TR_KEY_lpd_enabled,                     false);
-    tr_variantDictAddStr  (d, TR_KEY_download_dir,                    tr_getDefaultDownloadDir ());
-    tr_variantDictAddInt  (d, TR_KEY_speed_limit_down,                100);
-    tr_variantDictAddBool (d, TR_KEY_speed_limit_down_enabled,        false);
-    tr_variantDictAddInt  (d, TR_KEY_encryption,                      TR_DEFAULT_ENCRYPTION);
-    tr_variantDictAddInt  (d, TR_KEY_idle_seeding_limit,              30);
-    tr_variantDictAddBool (d, TR_KEY_idle_seeding_limit_enabled,      false);
-    tr_variantDictAddStr  (d, TR_KEY_incomplete_dir,                  tr_getDefaultDownloadDir ());
-    tr_variantDictAddBool (d, TR_KEY_incomplete_dir_enabled,          false);
-    tr_variantDictAddInt  (d, TR_KEY_message_level,                   TR_LOG_INFO);
-    tr_variantDictAddInt  (d, TR_KEY_download_queue_size,             5);
-    tr_variantDictAddBool (d, TR_KEY_download_queue_enabled,          true);
-    tr_variantDictAddInt  (d, TR_KEY_peer_limit_global,               atoi (TR_DEFAULT_PEER_LIMIT_GLOBAL_STR));
-    tr_variantDictAddInt  (d, TR_KEY_peer_limit_per_torrent,          atoi (TR_DEFAULT_PEER_LIMIT_TORRENT_STR));
-    tr_variantDictAddInt  (d, TR_KEY_peer_port,                       atoi (TR_DEFAULT_PEER_PORT_STR));
-    tr_variantDictAddBool (d, TR_KEY_peer_port_random_on_start,       false);
-    tr_variantDictAddInt  (d, TR_KEY_peer_port_random_low,            49152);
-    tr_variantDictAddInt  (d, TR_KEY_peer_port_random_high,           65535);
-    tr_variantDictAddStr  (d, TR_KEY_peer_socket_tos,                 TR_DEFAULT_PEER_SOCKET_TOS_STR);
-    tr_variantDictAddBool (d, TR_KEY_pex_enabled,                     true);
-    tr_variantDictAddBool (d, TR_KEY_port_forwarding_enabled,         true);
-    tr_variantDictAddInt  (d, TR_KEY_preallocation,                   TR_PREALLOCATE_SPARSE);
-    tr_variantDictAddBool (d, TR_KEY_prefetch_enabled,                DEFAULT_PREFETCH_ENABLED);
-    tr_variantDictAddInt  (d, TR_KEY_peer_id_ttl_hours,               6);
-    tr_variantDictAddBool (d, TR_KEY_queue_stalled_enabled,           true);
-    tr_variantDictAddInt  (d, TR_KEY_queue_stalled_minutes,           30);
-    tr_variantDictAddReal (d, TR_KEY_ratio_limit,                     2.0);
-    tr_variantDictAddBool (d, TR_KEY_ratio_limit_enabled,             false);
-    tr_variantDictAddBool (d, TR_KEY_rename_partial_files,            true);
-    tr_variantDictAddBool (d, TR_KEY_rpc_authentication_required,     false);
-    tr_variantDictAddStr  (d, TR_KEY_rpc_bind_address,                "0.0.0.0");
-    tr_variantDictAddBool (d, TR_KEY_rpc_enabled,                     false);
-    tr_variantDictAddStr  (d, TR_KEY_rpc_password,                    "");
-    tr_variantDictAddStr  (d, TR_KEY_rpc_username,                    "");
-    tr_variantDictAddStr  (d, TR_KEY_rpc_whitelist,                   TR_DEFAULT_RPC_WHITELIST);
-    tr_variantDictAddBool (d, TR_KEY_rpc_whitelist_enabled,           true);
-    tr_variantDictAddInt  (d, TR_KEY_rpc_port,                        atoi (TR_DEFAULT_RPC_PORT_STR));
-    tr_variantDictAddStr  (d, TR_KEY_rpc_url,                         TR_DEFAULT_RPC_URL_STR);
-    tr_variantDictAddBool (d, TR_KEY_scrape_paused_torrents_enabled,  true);
-    tr_variantDictAddStr  (d, TR_KEY_script_torrent_done_filename,    "");
-    tr_variantDictAddBool (d, TR_KEY_script_torrent_done_enabled,     false);
-    tr_variantDictAddInt  (d, TR_KEY_seed_queue_size,                 10);
-    tr_variantDictAddBool (d, TR_KEY_seed_queue_enabled,              false);
-    tr_variantDictAddBool (d, TR_KEY_alt_speed_enabled,               false);
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_up,                    50); /* half the regular */
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_down,                  50); /* half the regular */
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_begin,            540); /* 9am */
-    tr_variantDictAddBool (d, TR_KEY_alt_speed_time_enabled,          false);
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_end,              1020); /* 5pm */
-    tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_day,              TR_SCHED_ALL);
-    tr_variantDictAddInt  (d, TR_KEY_speed_limit_up,                  100);
-    tr_variantDictAddBool (d, TR_KEY_speed_limit_up_enabled,          false);
-    tr_variantDictAddInt  (d, TR_KEY_umask,                           022);
-    tr_variantDictAddInt  (d, TR_KEY_upload_slots_per_torrent,        14);
-    tr_variantDictAddStr  (d, TR_KEY_bind_address_ipv4,               TR_DEFAULT_BIND_ADDRESS_IPV4);
-    tr_variantDictAddStr  (d, TR_KEY_bind_address_ipv6,               TR_DEFAULT_BIND_ADDRESS_IPV6);
-    tr_variantDictAddBool (d, TR_KEY_start_added_torrents,            true);
-    tr_variantDictAddBool (d, TR_KEY_trash_original_torrent_files,    false);
+  assert (tr_variantIsDict (d));
+
+  tr_variantDictReserve (d, 63);
+  tr_variantDictAddBool (d, TR_KEY_blocklist_enabled,               false);
+  tr_variantDictAddStr  (d, TR_KEY_blocklist_url,                   "http://www.example.com/blocklist");
+  tr_variantDictAddInt  (d, TR_KEY_cache_size_mb,                   DEFAULT_CACHE_SIZE_MB);
+  tr_variantDictAddBool (d, TR_KEY_dht_enabled,                     true);
+  tr_variantDictAddBool (d, TR_KEY_utp_enabled,                     true);
+  tr_variantDictAddBool (d, TR_KEY_lpd_enabled,                     false);
+  tr_variantDictAddStr  (d, TR_KEY_download_dir,                    tr_getDefaultDownloadDir ());
+  tr_variantDictAddInt  (d, TR_KEY_speed_limit_down,                100);
+  tr_variantDictAddBool (d, TR_KEY_speed_limit_down_enabled,        false);
+  tr_variantDictAddInt  (d, TR_KEY_encryption,                      TR_DEFAULT_ENCRYPTION);
+  tr_variantDictAddInt  (d, TR_KEY_idle_seeding_limit,              30);
+  tr_variantDictAddBool (d, TR_KEY_idle_seeding_limit_enabled,      false);
+  tr_variantDictAddStr  (d, TR_KEY_incomplete_dir,                  tr_getDefaultDownloadDir ());
+  tr_variantDictAddBool (d, TR_KEY_incomplete_dir_enabled,          false);
+  tr_variantDictAddInt  (d, TR_KEY_message_level,                   TR_LOG_INFO);
+  tr_variantDictAddInt  (d, TR_KEY_download_queue_size,             5);
+  tr_variantDictAddBool (d, TR_KEY_download_queue_enabled,          true);
+  tr_variantDictAddInt  (d, TR_KEY_peer_limit_global,               atoi (TR_DEFAULT_PEER_LIMIT_GLOBAL_STR));
+  tr_variantDictAddInt  (d, TR_KEY_peer_limit_per_torrent,          atoi (TR_DEFAULT_PEER_LIMIT_TORRENT_STR));
+  tr_variantDictAddInt  (d, TR_KEY_peer_port,                       atoi (TR_DEFAULT_PEER_PORT_STR));
+  tr_variantDictAddBool (d, TR_KEY_peer_port_random_on_start,       false);
+  tr_variantDictAddInt  (d, TR_KEY_peer_port_random_low,            49152);
+  tr_variantDictAddInt  (d, TR_KEY_peer_port_random_high,           65535);
+  tr_variantDictAddStr  (d, TR_KEY_peer_socket_tos,                 TR_DEFAULT_PEER_SOCKET_TOS_STR);
+  tr_variantDictAddBool (d, TR_KEY_pex_enabled,                     true);
+  tr_variantDictAddBool (d, TR_KEY_port_forwarding_enabled,         true);
+  tr_variantDictAddInt  (d, TR_KEY_preallocation,                   TR_PREALLOCATE_SPARSE);
+  tr_variantDictAddBool (d, TR_KEY_prefetch_enabled,                DEFAULT_PREFETCH_ENABLED);
+  tr_variantDictAddInt  (d, TR_KEY_peer_id_ttl_hours,               6);
+  tr_variantDictAddBool (d, TR_KEY_queue_stalled_enabled,           true);
+  tr_variantDictAddInt  (d, TR_KEY_queue_stalled_minutes,           30);
+  tr_variantDictAddReal (d, TR_KEY_ratio_limit,                     2.0);
+  tr_variantDictAddBool (d, TR_KEY_ratio_limit_enabled,             false);
+  tr_variantDictAddBool (d, TR_KEY_rename_partial_files,            true);
+  tr_variantDictAddBool (d, TR_KEY_rpc_authentication_required,     false);
+  tr_variantDictAddStr  (d, TR_KEY_rpc_bind_address,                "0.0.0.0");
+  tr_variantDictAddBool (d, TR_KEY_rpc_enabled,                     false);
+  tr_variantDictAddStr  (d, TR_KEY_rpc_password,                    "");
+  tr_variantDictAddStr  (d, TR_KEY_rpc_username,                    "");
+  tr_variantDictAddStr  (d, TR_KEY_rpc_whitelist,                   TR_DEFAULT_RPC_WHITELIST);
+  tr_variantDictAddBool (d, TR_KEY_rpc_whitelist_enabled,           true);
+  tr_variantDictAddInt  (d, TR_KEY_rpc_port,                        atoi (TR_DEFAULT_RPC_PORT_STR));
+  tr_variantDictAddStr  (d, TR_KEY_rpc_url,                         TR_DEFAULT_RPC_URL_STR);
+  tr_variantDictAddBool (d, TR_KEY_scrape_paused_torrents_enabled,  true);
+  tr_variantDictAddStr  (d, TR_KEY_script_torrent_done_filename,    "");
+  tr_variantDictAddBool (d, TR_KEY_script_torrent_done_enabled,     false);
+  tr_variantDictAddInt  (d, TR_KEY_seed_queue_size,                 10);
+  tr_variantDictAddBool (d, TR_KEY_seed_queue_enabled,              false);
+  tr_variantDictAddBool (d, TR_KEY_alt_speed_enabled,               false);
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_up,                    50); /* half the regular */
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_down,                  50); /* half the regular */
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_begin,            540); /* 9am */
+  tr_variantDictAddBool (d, TR_KEY_alt_speed_time_enabled,          false);
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_end,              1020); /* 5pm */
+  tr_variantDictAddInt  (d, TR_KEY_alt_speed_time_day,              TR_SCHED_ALL);
+  tr_variantDictAddInt  (d, TR_KEY_speed_limit_up,                  100);
+  tr_variantDictAddBool (d, TR_KEY_speed_limit_up_enabled,          false);
+  tr_variantDictAddInt  (d, TR_KEY_umask,                           022);
+  tr_variantDictAddInt  (d, TR_KEY_upload_slots_per_torrent,        14);
+  tr_variantDictAddStr  (d, TR_KEY_bind_address_ipv4,               TR_DEFAULT_BIND_ADDRESS_IPV4);
+  tr_variantDictAddStr  (d, TR_KEY_bind_address_ipv6,               TR_DEFAULT_BIND_ADDRESS_IPV6);
+  tr_variantDictAddBool (d, TR_KEY_start_added_torrents,            true);
+  tr_variantDictAddBool (d, TR_KEY_trash_original_torrent_files,    false);
 }
 
@@ -543 +549 @@
 onSaveTimer (int foo UNUSED, short bar UNUSED, void * vsession)
 {
-    tr_torrent * tor = NULL;
-    tr_session * session = vsession;
-
-    if (tr_cacheFlushDone (session->cache))
-        tr_logAddError ("Error while flushing completed pieces from cache");
-
-    while ((tor = tr_torrentNext (session, tor)))
-        tr_torrentSave (tor);
-
-    tr_statsSaveDirty (session);
-
-    tr_timerAdd (session->saveTimer, SAVE_INTERVAL_SECS, 0);
+  tr_torrent * tor = NULL;
+  tr_session * session = vsession;
+
+  if (tr_cacheFlushDone (session->cache))
+    tr_logAddError ("Error while flushing completed pieces from cache");
+
+  while ((tor = tr_torrentNext (session, tor)))
+    tr_torrentSave (tor);
+
+  tr_statsSaveDirty (session);
+
+  tr_timerAdd (session->saveTimer, SAVE_INTERVAL_SECS, 0);
 }
 
@@ -565 +571 @@
 struct init_data
 {
-    tr_session  * session;
-    const char  * configDir;
-    bool          done;
-    bool          messageQueuingEnabled;
-    tr_variant  * clientSettings;
+  bool done;
+  bool messageQueuingEnabled;
+  tr_session * session;
+  const char * configDir;
+  tr_variant * clientSettings;
 };
 
@@ -578 +584 @@
                 tr_variant     * clientSettings)
 {
-    int64_t i;
-    tr_session * session;
-    struct init_data data;
-
-    assert (tr_variantIsDict (clientSettings));
-
-    tr_timeUpdate (time (NULL));
-
-    /* initialize the bare skeleton of the session object */
-    session = tr_new0 (tr_session, 1);
-    session->udp_socket = -1;
-    session->udp6_socket = -1;
-    session->lock = tr_lockNew ();
-    session->cache = tr_cacheNew (1024*1024*2);
-    session->tag = tr_strdup (tag);
-    session->magicNumber = SESSION_MAGIC_NUMBER;
-    tr_bandwidthConstruct (&session->bandwidth, session, NULL);
-    tr_variantInitList (&session->removedTorrents, 0);
-
-    /* nice to start logging at the very beginning */
-    if (tr_variantDictFindInt (clientSettings, TR_KEY_message_level, &i))
-        tr_logSetLevel (i);
-
-    /* start the libtransmission thread */
-    tr_netInit (); /* must go before tr_eventInit */
-    tr_eventInit (session);
-    assert (session->events != NULL);
-
-    /* run the rest in the libtransmission thread */
-    data.done = false;
-    data.session = session;
-    data.configDir = configDir;
-    data.messageQueuingEnabled = messageQueuingEnabled;
-    data.clientSettings = clientSettings;
-    tr_runInEventThread (session, tr_sessionInitImpl, &data);
-    while (!data.done)
-        tr_wait_msec (50);
-
-    return session;
+  int64_t i;
+  tr_session * session;
+  struct init_data data;
+
+  assert (tr_variantIsDict (clientSettings));
+
+  tr_timeUpdate (time (NULL));
+
+  /* initialize the bare skeleton of the session object */
+  session = tr_new0 (tr_session, 1);
+  session->udp_socket = -1;
+  session->udp6_socket = -1;
+  session->lock = tr_lockNew ();
+  session->cache = tr_cacheNew (1024*1024*2);
+  session->tag = tr_strdup (tag);
+  session->magicNumber = SESSION_MAGIC_NUMBER;
+  tr_bandwidthConstruct (&session->bandwidth, session, NULL);
+  tr_variantInitList (&session->removedTorrents, 0);
+
+  /* nice to start logging at the very beginning */
+  if (tr_variantDictFindInt (clientSettings, TR_KEY_message_level, &i))
+    tr_logSetLevel (i);
+
+  /* start the libtransmission thread */
+  tr_netInit (); /* must go before tr_eventInit */
+  tr_eventInit (session);
+  assert (session->events != NULL);
+
+  /* run the rest in the libtransmission thread */
+  data.done = false;
+  data.session = session;
+  data.configDir = configDir;
+  data.messageQueuingEnabled = messageQueuingEnabled;
+  data.clientSettings = clientSettings;
+  tr_runInEventThread (session, tr_sessionInitImpl, &data);
+  while (!data.done)
+    tr_wait_msec (50);
+
+  return session;
 }
 
@@ -624 +630 @@
 onNowTimer (int foo UNUSED, short bar UNUSED, void * vsession)
 {
-    int usec;
-    const int min = 100;
-    const int max = 999999;
-    struct timeval tv;
-    tr_torrent * tor = NULL;
-    tr_session * session = vsession;
-    const time_t now = time (NULL);
-
-    assert (tr_isSession (session));
-    assert (session->nowTimer != NULL);
-
-    /**
-    ***  tr_session things to do once per second
-    **/
-
-    tr_timeUpdate (now);
-
-    tr_dhtUpkeep (session);
-
-    if (session->turtle.isClockEnabled)
-        turtleCheckClock (session, &session->turtle);
-
-    while ((tor = tr_torrentNext (session, tor))) {
-        if (tor->isRunning) {
-            if (tr_torrentIsSeed (tor))
-                ++tor->secondsSeeding;
-            else
-                ++tor->secondsDownloading;
+  int usec;
+  const int min = 100;
+  const int max = 999999;
+  struct timeval tv;
+  tr_torrent * tor = NULL;
+  tr_session * session = vsession;
+  const time_t now = time (NULL);
+
+  assert (tr_isSession (session));
+  assert (session->nowTimer != NULL);
+
+  /**
+  ***  tr_session things to do once per second
+  **/
+
+  tr_timeUpdate (now);
+
+  tr_dhtUpkeep (session);
+
+  if (session->turtle.isClockEnabled)
+    turtleCheckClock (session, &session->turtle);
+
+  while ((tor = tr_torrentNext (session, tor)))
+    {
+      if (tor->isRunning)
+        {
+          if (tr_torrentIsSeed (tor))
+            ++tor->secondsSeeding;
+          else
+            ++tor->secondsDownloading;
         }
     }
 
-    /**
-    ***  Set the timer
-    **/
-
-    /* schedule the next timer for right after the next second begins */
-    gettimeofday (&tv, NULL);
-    usec = 1000000 - tv.tv_usec;
-    if (usec > max) usec = max;
-    if (usec < min) usec = min;
-    tr_timerAdd (session->nowTimer, 0, usec);
-    /* fprintf (stderr, "time %zu sec, %zu microsec\n", (size_t)tr_time (), (size_t)tv.tv_usec); */
+  /**
+  ***  Set the timer
+  **/
+
+  /* schedule the next timer for right after the next second begins */
+  gettimeofday (&tv, NULL);
+  usec = 1000000 - tv.tv_usec;
+  if (usec > max)
+    usec = max;
+  if (usec < min)
+    usec = min;
+  tr_timerAdd (session->nowTimer, 0, usec);
+  /* fprintf (stderr, "time %zu sec, %zu microsec\n", (size_t)tr_time (), (size_t)tv.tv_usec); */
 }
 
@@ -673 +683 @@
 tr_sessionInitImpl (void * vdata)
 {
-    tr_variant settings;
-    struct init_data * data = vdata;
-    tr_variant * clientSettings = data->clientSettings;
-    tr_session * session = data->session;
-
-    assert (tr_amInEventThread (session));
-    assert (tr_variantIsDict (clientSettings));
-
-    dbgmsg ("tr_sessionInit: the session's top-level bandwidth object is %p",
-            &session->bandwidth);
-
-    tr_variantInitDict (&settings, 0);
-    tr_sessionGetDefaultSettings (&settings);
-    tr_variantMergeDicts (&settings, clientSettings);
-
-    assert (session->event_base != NULL);
-    session->nowTimer = evtimer_new (session->event_base, onNowTimer, session);
-    onNowTimer (0, 0, session);
+  tr_variant settings;
+  struct init_data * data = vdata;
+  tr_variant * clientSettings = data->clientSettings;
+  tr_session * session = data->session;
+
+  assert (tr_amInEventThread (session));
+  assert (tr_variantIsDict (clientSettings));
+
+  dbgmsg ("tr_sessionInit: the session's top-level bandwidth object is %p",
+          &session->bandwidth);
+
+  tr_variantInitDict (&settings, 0);
+  tr_sessionGetDefaultSettings (&settings);
+  tr_variantMergeDicts (&settings, clientSettings);
+
+  assert (session->event_base != NULL);
+  session->nowTimer = evtimer_new (session->event_base, onNowTimer, session);
+  onNowTimer (0, 0, session);
 
 #ifndef WIN32
-    /* Don't exit when writing on a broken socket */
-    signal (SIGPIPE, SIG_IGN);
+  /* Don't exit when writing on a broken socket */
+  signal (SIGPIPE, SIG_IGN);
 #endif
 
-    tr_logSetQueueEnabled (data->messageQueuingEnabled);
-
-    tr_setConfigDir (session, data->configDir);
-
-    session->peerMgr = tr_peerMgrNew (session);
-
-    session->shared = tr_sharedInit (session);
-
-    /**
-    ***  Blocklist
-    **/
-
-    {
-        char * filename = tr_buildPath (session->configDir, "blocklists", NULL);
-        tr_mkdirp (filename, 0777);
-        tr_free (filename);
-        loadBlocklists (session);
-    }
-
-    assert (tr_isSession (session));
-
-    session->saveTimer = evtimer_new (session->event_base, onSaveTimer, session);
-    tr_timerAdd (session->saveTimer, SAVE_INTERVAL_SECS, 0);
-
-    tr_announcerInit (session);
-
-    /* first %s is the application name
-       second %s is the version number */
-    tr_logAddInfo (_("%s %s started"), TR_NAME, LONG_VERSION_STRING);
-
-    tr_statsInit (session);
-
-    tr_sessionSet (session, &settings);
-
-    tr_udpInit (session);
-
-    if (session->isLPDEnabled)
-        tr_lpdInit (session, &session->public_ipv4->addr);
-
-    /* cleanup */
-    tr_variantFree (&settings);
-    data->done = true;
+  tr_logSetQueueEnabled (data->messageQueuingEnabled);
+
+  tr_setConfigDir (session, data->configDir);
+
+  session->peerMgr = tr_peerMgrNew (session);
+
+  session->shared = tr_sharedInit (session);
+
+  /**
+  ***  Blocklist
+  **/
+
+  {
+    char * filename = tr_buildPath (session->configDir, "blocklists", NULL);
+    tr_mkdirp (filename, 0777);
+    tr_free (filename);
+    loadBlocklists (session);
+  }
+
+  assert (tr_isSession (session));
+
+  session->saveTimer = evtimer_new (session->event_base, onSaveTimer, session);
+  tr_timerAdd (session->saveTimer, SAVE_INTERVAL_SECS, 0);
+
+  tr_announcerInit (session);
+
+  /* first %s is the application name
+     second %s is the version number */
+  tr_logAddInfo (_("%s %s started"), TR_NAME, LONG_VERSION_STRING);
+
+  tr_statsInit (session);
+
+  tr_sessionSet (session, &settings);
+
+  tr_udpInit (session);
+
+  if (session->isLPDEnabled)
+    tr_lpdInit (session, &session->public_ipv4->addr);
+
+  /* cleanup */
+  tr_variantFree (&settings);
+  data->done = true;
 }
 
@@ -747 +757 @@
 sessionSetImpl (void * vdata)
 {
-    int64_t i;
-    double  d;
-    bool boolVal;
-    const char * str;
-    struct tr_bindinfo b;
-    struct init_data * data = vdata;
-    tr_session * session = data->session;
-    tr_variant * settings = data->clientSettings;
-    struct tr_turtle_info * turtle = &session->turtle;
-
-    assert (tr_isSession (session));
-    assert (tr_variantIsDict (settings));
-    assert (tr_amInEventThread (session));
-
-    if (tr_variantDictFindInt (settings, TR_KEY_message_level, &i))
-        tr_logSetLevel (i);
-
-    if (tr_variantDictFindInt (settings, TR_KEY_umask, &i)) {
-        session->umask = (mode_t)i;
-        umask (session->umask);
-    }
-
-    /* misc features */
-    if (tr_variantDictFindInt (settings, TR_KEY_cache_size_mb, &i))
-        tr_sessionSetCacheLimit_MB (session, i);
-    if (tr_variantDictFindInt (settings, TR_KEY_peer_limit_per_torrent, &i))
-        tr_sessionSetPeerLimitPerTorrent (session, i);
-    if (tr_variantDictFindBool (settings, TR_KEY_pex_enabled, &boolVal))
-        tr_sessionSetPexEnabled (session, boolVal);
-    if (tr_variantDictFindBool (settings, TR_KEY_dht_enabled, &boolVal))
-        tr_sessionSetDHTEnabled (session, boolVal);
-    if (tr_variantDictFindBool (settings, TR_KEY_utp_enabled, &boolVal))
-        tr_sessionSetUTPEnabled (session, boolVal);
-    if (tr_variantDictFindBool (settings, TR_KEY_lpd_enabled, &boolVal))
-        tr_sessionSetLPDEnabled (session, boolVal);
-    if (tr_variantDictFindInt (settings, TR_KEY_encryption, &i))
-        tr_sessionSetEncryption (session, i);
-    if (tr_variantDictFindStr (settings, TR_KEY_peer_socket_tos, &str, NULL))
-        session->peerSocketTOS = parse_tos (str);
-    if (tr_variantDictFindStr (settings, TR_KEY_peer_congestion_algorithm, &str, NULL))
-        session->peer_congestion_algorithm = tr_strdup (str);
-    else
-        session->peer_congestion_algorithm = tr_strdup ("");
-    if (tr_variantDictFindBool (settings, TR_KEY_blocklist_enabled, &boolVal))
-        tr_blocklistSetEnabled (session, boolVal);
-    if (tr_variantDictFindStr (settings, TR_KEY_blocklist_url, &str, NULL))
-        tr_blocklistSetURL (session, str);
-    if (tr_variantDictFindBool (settings, TR_KEY_start_added_torrents, &boolVal))
-        tr_sessionSetPaused (session, !boolVal);
-    if (tr_variantDictFindBool (settings, TR_KEY_trash_original_torrent_files, &boolVal))
-        tr_sessionSetDeleteSource (session, boolVal);
-    if (tr_variantDictFindInt (settings, TR_KEY_peer_id_ttl_hours, &i))
-        session->peer_id_ttl_hours = i;
-
-    /* torrent queues */
-    if (tr_variantDictFindInt (settings, TR_KEY_queue_stalled_minutes, &i))
-        tr_sessionSetQueueStalledMinutes (session, i);
-    if (tr_variantDictFindBool (settings, TR_KEY_queue_stalled_enabled, &boolVal))
-        tr_sessionSetQueueStalledEnabled (session, boolVal);
-    if (tr_variantDictFindInt (settings, TR_KEY_download_queue_size, &i))
-        tr_sessionSetQueueSize (session, TR_DOWN, i);
-    if (tr_variantDictFindBool (settings, TR_KEY_download_queue_enabled, &boolVal))
-        tr_sessionSetQueueEnabled (session, TR_DOWN, boolVal);
-    if (tr_variantDictFindInt (settings, TR_KEY_seed_queue_size, &i))
-        tr_sessionSetQueueSize (session, TR_UP, i);
-    if (tr_variantDictFindBool (settings, TR_KEY_seed_queue_enabled, &boolVal))
-        tr_sessionSetQueueEnabled (session, TR_UP, boolVal);
-
-    /* files and directories */
-    if (tr_variantDictFindBool (settings, TR_KEY_prefetch_enabled, &boolVal))
-        session->isPrefetchEnabled = boolVal;
-    if (tr_variantDictFindInt (settings, TR_KEY_preallocation, &i))
-        session->preallocationMode = i;
-    if (tr_variantDictFindStr (settings, TR_KEY_download_dir, &str, NULL))
-        tr_sessionSetDownloadDir (session, str);
-    if (tr_variantDictFindStr (settings, TR_KEY_incomplete_dir, &str, NULL))
-        tr_sessionSetIncompleteDir (session, str);
-    if (tr_variantDictFindBool (settings, TR_KEY_incomplete_dir_enabled, &boolVal))
-        tr_sessionSetIncompleteDirEnabled (session, boolVal);
-    if (tr_variantDictFindBool (settings, TR_KEY_rename_partial_files, &boolVal))
-        tr_sessionSetIncompleteFileNamingEnabled (session, boolVal);
-
-    /* rpc server */
-    if (session->rpcServer != NULL) /* close the old one */
-        tr_rpcClose (&session->rpcServer);
-    session->rpcServer = tr_rpcInit (session, settings);
-
-    /* public addresses */
-
-    free_incoming_peer_port (session);
-
-    tr_variantDictFindStr (settings, TR_KEY_bind_address_ipv4, &str, NULL);
-    if (!tr_address_from_string (&b.addr, str) || (b.addr.type != TR_AF_INET))
-        b.addr = tr_inaddr_any;
-    b.socket = -1;
-    session->public_ipv4 = tr_memdup (&b, sizeof (struct tr_bindinfo));
-
-    tr_variantDictFindStr (settings, TR_KEY_bind_address_ipv6, &str, NULL);
-    if (!tr_address_from_string (&b.addr, str) || (b.addr.type != TR_AF_INET6))
-        b.addr = tr_in6addr_any;
-    b.socket = -1;
-    session->public_ipv6 = tr_memdup (&b, sizeof (struct tr_bindinfo));
-
-    /* incoming peer port */
-    if (tr_variantDictFindInt (settings, TR_KEY_peer_port_random_low, &i))
-        session->randomPortLow = i;
-    if (tr_variantDictFindInt (settings, TR_KEY_peer_port_random_high, &i))
-        session->randomPortHigh = i;
-    if (tr_variantDictFindBool (settings, TR_KEY_peer_port_random_on_start, &boolVal))
-        tr_sessionSetPeerPortRandomOnStart (session, boolVal);
-    if (!tr_variantDictFindInt (settings, TR_KEY_peer_port, &i))
-        i = session->private_peer_port;
-    setPeerPort (session, boolVal ? getRandomPort (session) : i);
-    if (tr_variantDictFindBool (settings, TR_KEY_port_forwarding_enabled, &boolVal))
-        tr_sessionSetPortForwardingEnabled (session, boolVal);
-
-    if (tr_variantDictFindInt (settings, TR_KEY_peer_limit_global, &i))
-        session->peerLimit = i;
-
-    /**
-    **/
-
-    if (tr_variantDictFindInt (settings, TR_KEY_upload_slots_per_torrent, &i))
-        session->uploadSlotsPerTorrent = i;
-
-    if (tr_variantDictFindInt (settings, TR_KEY_speed_limit_up, &i))
-        tr_sessionSetSpeedLimit_KBps (session, TR_UP, i);
-    if (tr_variantDictFindBool (settings, TR_KEY_speed_limit_up_enabled, &boolVal))
-        tr_sessionLimitSpeed (session, TR_UP, boolVal);
-
-    if (tr_variantDictFindInt (settings, TR_KEY_speed_limit_down, &i))
-        tr_sessionSetSpeedLimit_KBps (session, TR_DOWN, i);
-    if (tr_variantDictFindBool (settings, TR_KEY_speed_limit_down_enabled, &boolVal))
-        tr_sessionLimitSpeed (session, TR_DOWN, boolVal);
-
-    if (tr_variantDictFindReal (settings, TR_KEY_ratio_limit, &d))
-        tr_sessionSetRatioLimit (session, d);
-    if (tr_variantDictFindBool (settings, TR_KEY_ratio_limit_enabled, &boolVal))
-        tr_sessionSetRatioLimited (session, boolVal);
-
-    if (tr_variantDictFindInt (settings, TR_KEY_idle_seeding_limit, &i))
-        tr_sessionSetIdleLimit (session, i);
-    if (tr_variantDictFindBool (settings, TR_KEY_idle_seeding_limit_enabled, &boolVal))
-        tr_sessionSetIdleLimited (session, boolVal);
-
-    /**
-    ***  Turtle Mode
-    **/
-
-    /* update the turtle mode's fields */
-    if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_up, &i))
-        turtle->speedLimit_Bps[TR_UP] = toSpeedBytes (i);
-    if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_down, &i))
-        turtle->speedLimit_Bps[TR_DOWN] = toSpeedBytes (i);
-    if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_time_begin, &i))
-        turtle->beginMinute = i;
-    if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_time_end, &i))
-        turtle->endMinute = i;
-    if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_time_day, &i))
-        turtle->days = i;
-    if (tr_variantDictFindBool (settings, TR_KEY_alt_speed_time_enabled, &boolVal))
-        turtle->isClockEnabled = boolVal;
-    if (tr_variantDictFindBool (settings, TR_KEY_alt_speed_enabled, &boolVal))
-        turtle->isEnabled = boolVal;
-    turtleBootstrap (session, turtle);
-
-    /**
-    ***  Scripts
-    **/
-
-    if (tr_variantDictFindBool (settings, TR_KEY_script_torrent_done_enabled, &boolVal))
-        tr_sessionSetTorrentDoneScriptEnabled (session, boolVal);
-    if (tr_variantDictFindStr (settings, TR_KEY_script_torrent_done_filename, &str, NULL))
-        tr_sessionSetTorrentDoneScript (session, str);
-
-
-    if (tr_variantDictFindBool (settings, TR_KEY_scrape_paused_torrents_enabled, &boolVal))
-        session->scrapePausedTorrents = boolVal;
-
-    data->done = true;
+  int64_t i;
+  double  d;
+  bool boolVal;
+  const char * str;
+  struct tr_bindinfo b;
+  struct init_data * data = vdata;
+  tr_session * session = data->session;
+  tr_variant * settings = data->clientSettings;
+  struct tr_turtle_info * turtle = &session->turtle;
+
+  assert (tr_isSession (session));
+  assert (tr_variantIsDict (settings));
+  assert (tr_amInEventThread (session));
+
+  if (tr_variantDictFindInt (settings, TR_KEY_message_level, &i))
+    tr_logSetLevel (i);
+
+  if (tr_variantDictFindInt (settings, TR_KEY_umask, &i))
+    {
+      session->umask = (mode_t)i;
+      umask (session->umask);
+    }
+
+  /* misc features */
+  if (tr_variantDictFindInt (settings, TR_KEY_cache_size_mb, &i))
+    tr_sessionSetCacheLimit_MB (session, i);
+  if (tr_variantDictFindInt (settings, TR_KEY_peer_limit_per_torrent, &i))
+    tr_sessionSetPeerLimitPerTorrent (session, i);
+  if (tr_variantDictFindBool (settings, TR_KEY_pex_enabled, &boolVal))
+    tr_sessionSetPexEnabled (session, boolVal);
+  if (tr_variantDictFindBool (settings, TR_KEY_dht_enabled, &boolVal))
+    tr_sessionSetDHTEnabled (session, boolVal);
+  if (tr_variantDictFindBool (settings, TR_KEY_utp_enabled, &boolVal))
+    tr_sessionSetUTPEnabled (session, boolVal);
+  if (tr_variantDictFindBool (settings, TR_KEY_lpd_enabled, &boolVal))
+    tr_sessionSetLPDEnabled (session, boolVal);
+  if (tr_variantDictFindInt (settings, TR_KEY_encryption, &i))
+    tr_sessionSetEncryption (session, i);
+  if (tr_variantDictFindStr (settings, TR_KEY_peer_socket_tos, &str, NULL))
+    session->peerSocketTOS = parse_tos (str);
+  if (tr_variantDictFindStr (settings, TR_KEY_peer_congestion_algorithm, &str, NULL))
+    session->peer_congestion_algorithm = tr_strdup (str);
+  else
+    session->peer_congestion_algorithm = tr_strdup ("");
+  if (tr_variantDictFindBool (settings, TR_KEY_blocklist_enabled, &boolVal))
+    tr_blocklistSetEnabled (session, boolVal);
+  if (tr_variantDictFindStr (settings, TR_KEY_blocklist_url, &str, NULL))
+    tr_blocklistSetURL (session, str);
+  if (tr_variantDictFindBool (settings, TR_KEY_start_added_torrents, &boolVal))
+    tr_sessionSetPaused (session, !boolVal);
+  if (tr_variantDictFindBool (settings, TR_KEY_trash_original_torrent_files, &boolVal))
+    tr_sessionSetDeleteSource (session, boolVal);
+  if (tr_variantDictFindInt (settings, TR_KEY_peer_id_ttl_hours, &i))
+    session->peer_id_ttl_hours = i;
+
+  /* torrent queues */
+  if (tr_variantDictFindInt (settings, TR_KEY_queue_stalled_minutes, &i))
+    tr_sessionSetQueueStalledMinutes (session, i);
+  if (tr_variantDictFindBool (settings, TR_KEY_queue_stalled_enabled, &boolVal))
+    tr_sessionSetQueueStalledEnabled (session, boolVal);
+  if (tr_variantDictFindInt (settings, TR_KEY_download_queue_size, &i))
+    tr_sessionSetQueueSize (session, TR_DOWN, i);
+  if (tr_variantDictFindBool (settings, TR_KEY_download_queue_enabled, &boolVal))
+    tr_sessionSetQueueEnabled (session, TR_DOWN, boolVal);
+  if (tr_variantDictFindInt (settings, TR_KEY_seed_queue_size, &i))
+    tr_sessionSetQueueSize (session, TR_UP, i);
+  if (tr_variantDictFindBool (settings, TR_KEY_seed_queue_enabled, &boolVal))
+    tr_sessionSetQueueEnabled (session, TR_UP, boolVal);
+
+  /* files and directories */
+  if (tr_variantDictFindBool (settings, TR_KEY_prefetch_enabled, &boolVal))
+    session->isPrefetchEnabled = boolVal;
+  if (tr_variantDictFindInt (settings, TR_KEY_preallocation, &i))
+    session->preallocationMode = i;
+  if (tr_variantDictFindStr (settings, TR_KEY_download_dir, &str, NULL))
+    tr_sessionSetDownloadDir (session, str);
+  if (tr_variantDictFindStr (settings, TR_KEY_incomplete_dir, &str, NULL))
+    tr_sessionSetIncompleteDir (session, str);
+  if (tr_variantDictFindBool (settings, TR_KEY_incomplete_dir_enabled, &boolVal))
+    tr_sessionSetIncompleteDirEnabled (session, boolVal);
+  if (tr_variantDictFindBool (settings, TR_KEY_rename_partial_files, &boolVal))
+    tr_sessionSetIncompleteFileNamingEnabled (session, boolVal);
+
+  /* rpc server */
+  if (session->rpcServer != NULL) /* close the old one */
+    tr_rpcClose (&session->rpcServer);
+  session->rpcServer = tr_rpcInit (session, settings);
+
+  /* public addresses */
+
+  free_incoming_peer_port (session);
+
+  tr_variantDictFindStr (settings, TR_KEY_bind_address_ipv4, &str, NULL);
+  if (!tr_address_from_string (&b.addr, str) || (b.addr.type != TR_AF_INET))
+    b.addr = tr_inaddr_any;
+  b.socket = -1;
+  session->public_ipv4 = tr_memdup (&b, sizeof (struct tr_bindinfo));
+
+  tr_variantDictFindStr (settings, TR_KEY_bind_address_ipv6, &str, NULL);
+  if (!tr_address_from_string (&b.addr, str) || (b.addr.type != TR_AF_INET6))
+    b.addr = tr_in6addr_any;
+  b.socket = -1;
+  session->public_ipv6 = tr_memdup (&b, sizeof (struct tr_bindinfo));
+
+  /* incoming peer port */
+  if (tr_variantDictFindInt (settings, TR_KEY_peer_port_random_low, &i))
+    session->randomPortLow = i;
+  if (tr_variantDictFindInt (settings, TR_KEY_peer_port_random_high, &i))
+    session->randomPortHigh = i;
+  if (tr_variantDictFindBool (settings, TR_KEY_peer_port_random_on_start, &boolVal))
+    tr_sessionSetPeerPortRandomOnStart (session, boolVal);
+  if (!tr_variantDictFindInt (settings, TR_KEY_peer_port, &i))
+    i = session->private_peer_port;
+  setPeerPort (session, boolVal ? getRandomPort (session) : i);
+  if (tr_variantDictFindBool (settings, TR_KEY_port_forwarding_enabled, &boolVal))
+    tr_sessionSetPortForwardingEnabled (session, boolVal);
+
+  if (tr_variantDictFindInt (settings, TR_KEY_peer_limit_global, &i))
+    session->peerLimit = i;
+
+  /**
+  **/
+
+  if (tr_variantDictFindInt (settings, TR_KEY_upload_slots_per_torrent, &i))
+    session->uploadSlotsPerTorrent = i;
+
+  if (tr_variantDictFindInt (settings, TR_KEY_speed_limit_up, &i))
+    tr_sessionSetSpeedLimit_KBps (session, TR_UP, i);
+  if (tr_variantDictFindBool (settings, TR_KEY_speed_limit_up_enabled, &boolVal))
+    tr_sessionLimitSpeed (session, TR_UP, boolVal);
+
+  if (tr_variantDictFindInt (settings, TR_KEY_speed_limit_down, &i))
+    tr_sessionSetSpeedLimit_KBps (session, TR_DOWN, i);
+  if (tr_variantDictFindBool (settings, TR_KEY_speed_limit_down_enabled, &boolVal))
+    tr_sessionLimitSpeed (session, TR_DOWN, boolVal);
+
+  if (tr_variantDictFindReal (settings, TR_KEY_ratio_limit, &d))
+    tr_sessionSetRatioLimit (session, d);
+  if (tr_variantDictFindBool (settings, TR_KEY_ratio_limit_enabled, &boolVal))
+    tr_sessionSetRatioLimited (session, boolVal);
+
+  if (tr_variantDictFindInt (settings, TR_KEY_idle_seeding_limit, &i))
+    tr_sessionSetIdleLimit (session, i);
+  if (tr_variantDictFindBool (settings, TR_KEY_idle_seeding_limit_enabled, &boolVal))
+    tr_sessionSetIdleLimited (session, boolVal);
+
+  /**
+  ***  Turtle Mode
+  **/
+
+  /* update the turtle mode's fields */
+  if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_up, &i))
+    turtle->speedLimit_Bps[TR_UP] = toSpeedBytes (i);
+  if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_down, &i))
+    turtle->speedLimit_Bps[TR_DOWN] = toSpeedBytes (i);
+  if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_time_begin, &i))
+    turtle->beginMinute = i;
+  if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_time_end, &i))
+    turtle->endMinute = i;
+  if (tr_variantDictFindInt (settings, TR_KEY_alt_speed_time_day, &i))
+    turtle->days = i;
+  if (tr_variantDictFindBool (settings, TR_KEY_alt_speed_time_enabled, &boolVal))
+    turtle->isClockEnabled = boolVal;
+  if (tr_variantDictFindBool (settings, TR_KEY_alt_speed_enabled, &boolVal))
+    turtle->isEnabled = boolVal;
+  turtleBootstrap (session, turtle);
+
+  /**
+  ***  Scripts
+  **/
+
+  if (tr_variantDictFindBool (settings, TR_KEY_script_torrent_done_enabled, &boolVal))
+    tr_sessionSetTorrentDoneScriptEnabled (session, boolVal);
+  if (tr_variantDictFindStr (settings, TR_KEY_script_torrent_done_filename, &str, NULL))
+    tr_sessionSetTorrentDoneScript (session, str);
+
+
+  if (tr_variantDictFindBool (settings, TR_KEY_scrape_paused_torrents_enabled, &boolVal))
+    session->scrapePausedTorrents = boolVal;
+
+  data->done = true;
 }
 
@@ -993 +1004 @@
 tr_sessionSetIncompleteFileNamingEnabled (tr_session * session, bool b)
 {
-    assert (tr_isSession (session));
-    assert (tr_isBool (b));
-
-    session->isIncompleteFileNamingEnabled = b;
+  assert (tr_isSession (session));
+  assert (tr_isBool (b));
+
+  session->isIncompleteFileNamingEnabled = b;
 }
 
@@ -1002 +1013 @@
 tr_sessionIsIncompleteFileNamingEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isIncompleteFileNamingEnabled;
+  assert (tr_isSession (session));
+
+  return session->isIncompleteFileNamingEnabled;
 }
 
@@ -1015 +1026 @@
 tr_sessionSetIncompleteDir (tr_session * session, const char * dir)
 {
-    assert (tr_isSession (session));
-
-    if (session->incompleteDir != dir)
-    {
-        tr_free (session->incompleteDir);
-
-        session->incompleteDir = tr_strdup (dir);
+  assert (tr_isSession (session));
+
+  if (session->incompleteDir != dir)
+    {
+      tr_free (session->incompleteDir);
+
+      session->incompleteDir = tr_strdup (dir);
     }
 }
@@ -1028 +1039 @@
 tr_sessionGetIncompleteDir (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->incompleteDir;
+  assert (tr_isSession (session));
+
+  return session->incompleteDir;
 }
 
@@ -1036 +1047 @@
 tr_sessionSetIncompleteDirEnabled (tr_session * session, bool b)
 {
-    assert (tr_isSession (session));
-    assert (tr_isBool (b));
-
-    session->isIncompleteDirEnabled = b;
+  assert (tr_isSession (session));
+  assert (tr_isBool (b));
+
+  session->isIncompleteDirEnabled = b;
 }
 
@@ -1045 +1056 @@
 tr_sessionIsIncompleteDirEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isIncompleteDirEnabled;
+  assert (tr_isSession (session));
+
+  return session->isIncompleteDirEnabled;
 }
 
@@ -1057 +1068 @@
 tr_sessionLock (tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    tr_lockLock (session->lock);
+  assert (tr_isSession (session));
+
+  tr_lockLock (session->lock);
 }
 
@@ -1065 +1076 @@
 tr_sessionUnlock (tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    tr_lockUnlock (session->lock);
+  assert (tr_isSession (session));
+
+  tr_lockUnlock (session->lock);
 }
 
@@ -1073 +1084 @@
 tr_sessionIsLocked (const tr_session * session)
 {
-    return tr_isSession (session) && tr_lockHave (session->lock);
-}
-
-/***********************************************************************
- * tr_setBindPort
- ***********************************************************************
- *
- **********************************************************************/
+  return tr_isSession (session) && tr_lockHave (session->lock);
+}
+
+/***
+****  Peer Port
+***/
 
 static void
 peerPortChanged (void * session)
 {
-    tr_torrent * tor = NULL;
-
-    assert (tr_isSession (session));
-
-    close_incoming_peer_port (session);
-    open_incoming_peer_port (session);
-    tr_sharedPortChanged (session);
-
-    while ((tor = tr_torrentNext (session, tor)))
-        tr_torrentChangeMyPort (tor);
+  tr_torrent * tor = NULL;
+
+  assert (tr_isSession (session));
+
+  close_incoming_peer_port (session);
+  open_incoming_peer_port (session);
+  tr_sharedPortChanged (session);
+
+  while ((tor = tr_torrentNext (session, tor)))
+    tr_torrentChangeMyPort (tor);
 }
 
@@ -1100 +1109 @@
 setPeerPort (tr_session * session, tr_port port)
 {
-    session->private_peer_port = port;
-    session->public_peer_port = port;
-
-    tr_runInEventThread (session, peerPortChanged, session);
+  session->private_peer_port = port;
+  session->public_peer_port = port;
+
+  tr_runInEventThread (session, peerPortChanged, session);
 }
 
@@ -1109 +1118 @@
 tr_sessionSetPeerPort (tr_session * session, tr_port port)
 {
-    if (tr_isSession (session) && (session->private_peer_port != port))
-    {
-        setPeerPort (session, port);
+  if (tr_isSession (session) && (session->private_peer_port != port))
+    {
+      setPeerPort (session, port);
     }
 }
@@ -1118 +1127 @@
 tr_sessionGetPeerPort (const tr_session * session)
 {
-    return tr_isSession (session) ? session->private_peer_port : 0;
+  return tr_isSession (session) ? session->private_peer_port : 0;
 }
 
@@ -1124 +1133 @@
 tr_sessionSetPeerPortRandom (tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    tr_sessionSetPeerPort (session, getRandomPort (session));
-    return session->private_peer_port;
+  assert (tr_isSession (session));
+
+  tr_sessionSetPeerPort (session, getRandomPort (session));
+  return session->private_peer_port;
 }
 
@@ -1134 +1143 @@
                                     bool random)
 {
-    assert (tr_isSession (session));
-
-    session->isPortRandom = random;
+  assert (tr_isSession (session));
+
+  session->isPortRandom = random;
 }
 
@@ -1142 +1151 @@
 tr_sessionGetPeerPortRandomOnStart (tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isPortRandom;
+  assert (tr_isSession (session));
+
+  return session->isPortRandom;
 }
 
@@ -1150 +1159 @@
 tr_sessionGetPortForwarding (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_sharedTraversalStatus (session->shared);
+  assert (tr_isSession (session));
+
+  return tr_sharedTraversalStatus (session->shared);
 }
 
@@ -1162 +1171 @@
 tr_sessionSetRatioLimited (tr_session * session, bool isLimited)
 {
-    assert (tr_isSession (session));
-
-    session->isRatioLimited = isLimited;
+  assert (tr_isSession (session));
+
+  session->isRatioLimited = isLimited;
 }
 
@@ -1170 +1179 @@
 tr_sessionSetRatioLimit (tr_session * session, double desiredRatio)
 {
-    assert (tr_isSession (session));
-
-    session->desiredRatio = desiredRatio;
+  assert (tr_isSession (session));
+
+  session->desiredRatio = desiredRatio;
 }
 
@@ -1178 +1187 @@
 tr_sessionIsRatioLimited (const tr_session  * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isRatioLimited;
+  assert (tr_isSession (session));
+
+  return session->isRatioLimited;
 }
 
@@ -1186 +1195 @@
 tr_sessionGetRatioLimit (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->desiredRatio;
+  assert (tr_isSession (session));
+
+  return session->desiredRatio;
 }
 
@@ -1198 +1207 @@
 tr_sessionSetIdleLimited (tr_session * session, bool isLimited)
 {
-    assert (tr_isSession (session));
-
-    session->isIdleLimited = isLimited;
+  assert (tr_isSession (session));
+
+  session->isIdleLimited = isLimited;
 }
 
@@ -1206 +1215 @@
 tr_sessionSetIdleLimit (tr_session * session, uint16_t idleMinutes)
 {
-    assert (tr_isSession (session));
-
-    session->idleLimitMinutes = idleMinutes;
+  assert (tr_isSession (session));
+
+  session->idleLimitMinutes = idleMinutes;
 }
 
@@ -1214 +1223 @@
 tr_sessionIsIdleLimited (const tr_session  * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isIdleLimited;
+  assert (tr_isSession (session));
+
+  return session->isIdleLimited;
 }
 
@@ -1222 +1231 @@
 tr_sessionGetIdleLimit (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->idleLimitMinutes;
+  assert (tr_isSession (session));
+
+  return session->idleLimitMinutes;
 }
 
@@ -1236 +1245 @@
 tr_sessionGetActiveSpeedLimit_Bps (const tr_session * session, tr_direction dir, unsigned int * setme_Bps)
 {
-    int isLimited = true;
-
-    if (!tr_isSession (session))
-        return false;
-
-    if (tr_sessionUsesAltSpeed (session))
-        *setme_Bps = tr_sessionGetAltSpeed_Bps (session, dir);
-    else if (tr_sessionIsSpeedLimited (session, dir))
-        *setme_Bps = tr_sessionGetSpeedLimit_Bps (session, dir);
-    else
-        isLimited = false;
-
-    return isLimited;
+  int isLimited = true;
+
+  if (!tr_isSession (session))
+    return false;
+
+  if (tr_sessionUsesAltSpeed (session))
+    *setme_Bps = tr_sessionGetAltSpeed_Bps (session, dir);
+  else if (tr_sessionIsSpeedLimited (session, dir))
+    *setme_Bps = tr_sessionGetSpeedLimit_Bps (session, dir);
+  else
+    isLimited = false;
+
+  return isLimited;
 }
 bool
@@ -1255 +1264 @@
                                     double            * setme_KBps)
 {
-    unsigned int Bps = 0;
-    const bool is_active = tr_sessionGetActiveSpeedLimit_Bps (session, dir, &Bps);
-    *setme_KBps = toSpeedKBps (Bps);
-    return is_active;
+  unsigned int Bps = 0;
+  const bool is_active = tr_sessionGetActiveSpeedLimit_Bps (session, dir, &Bps);
+  *setme_KBps = toSpeedKBps (Bps);
+  return is_active;
 }
 
@@ -1264 +1273 @@
 updateBandwidth (tr_session * session, tr_direction dir)
 {
-    unsigned int limit_Bps = 0;
-    const bool isLimited = tr_sessionGetActiveSpeedLimit_Bps (session, dir, &limit_Bps);
-    const bool zeroCase = isLimited && !limit_Bps;
-
-    tr_bandwidthSetLimited (&session->bandwidth, dir, isLimited && !zeroCase);
-
-    tr_bandwidthSetDesiredSpeed_Bps (&session->bandwidth, dir, limit_Bps);
+  unsigned int limit_Bps = 0;
+  const bool isLimited = tr_sessionGetActiveSpeedLimit_Bps (session, dir, &limit_Bps);
+  const bool zeroCase = isLimited && !limit_Bps;
+
+  tr_bandwidthSetLimited (&session->bandwidth, dir, isLimited && !zeroCase);
+
+  tr_bandwidthSetDesiredSpeed_Bps (&session->bandwidth, dir, limit_Bps);
 }
 
 enum
 {
-    MINUTES_PER_HOUR = 60,
-    MINUTES_PER_DAY = MINUTES_PER_HOUR * 24,
-    MINUTES_PER_WEEK = MINUTES_PER_DAY * 7
+  MINUTES_PER_HOUR = 60,
+  MINUTES_PER_DAY = MINUTES_PER_HOUR * 24,
+  MINUTES_PER_WEEK = MINUTES_PER_DAY * 7
 };
 
@@ -1283 +1292 @@
 turtleUpdateTable (struct tr_turtle_info * t)
 {
-    int day;
-    tr_bitfield * b = &t->minutes;
-
-    tr_bitfieldSetHasNone (b);
-
-    for (day=0; day<7; ++day)
-    {
-        if (t->days & (1<<day))
+  int day;
+  tr_bitfield * b = &t->minutes;
+
+  tr_bitfieldSetHasNone (b);
+
+  for (day=0; day<7; ++day)
+    {
+      if (t->days & (1<<day))
         {
-            int i;
-            const time_t begin = t->beginMinute;
-            time_t end = t->endMinute;
-
-            if (end <= begin)
-                end += MINUTES_PER_DAY;
-
-            for (i=begin; i<end; ++i)
-                tr_bitfieldAdd (b, (i+day*MINUTES_PER_DAY) % MINUTES_PER_WEEK);
+          int i;
+          const time_t begin = t->beginMinute;
+          time_t end = t->endMinute;
+
+          if (end <= begin)
+            end += MINUTES_PER_DAY;
+
+          for (i=begin; i<end; ++i)
+            tr_bitfieldAdd (b, (i+day*MINUTES_PER_DAY) % MINUTES_PER_WEEK);
         }
     }
@@ -1308 +1317 @@
 altSpeedToggled (void * vsession)
 {
-    tr_session * session = vsession;
-    struct tr_turtle_info * t = &session->turtle;
-
-    assert (tr_isSession (session));
-
-    updateBandwidth (session, TR_UP);
-    updateBandwidth (session, TR_DOWN);
-
-    if (t->callback != NULL)
-      (*t->callback)(session, t->isEnabled, t->changedByUser, t->callbackUserData);
+  tr_session * session = vsession;
+  struct tr_turtle_info * t = &session->turtle;
+
+  assert (tr_isSession (session));
+
+  updateBandwidth (session, TR_UP);
+  updateBandwidth (session, TR_DOWN);
+
+  if (t->callback != NULL)
+    (*t->callback)(session, t->isEnabled, t->changedByUser, t->callbackUserData);
 }
 
@@ -1324 +1333 @@
              bool enabled, bool byUser)
 {
-    assert (tr_isSession (s));
-    assert (t != NULL);
-    assert (tr_isBool (enabled));
-    assert (tr_isBool (byUser));
-
-    if (t->isEnabled != enabled)
-    {
-        t->isEnabled = enabled;
-        t->changedByUser = byUser;
-        tr_runInEventThread (s, altSpeedToggled, s);
+  assert (tr_isSession (s));
+  assert (t != NULL);
+  assert (tr_isBool (enabled));
+  assert (tr_isBool (byUser));
+
+  if (t->isEnabled != enabled)
+    {
+      t->isEnabled = enabled;
+      t->changedByUser = byUser;
+      tr_runInEventThread (s, altSpeedToggled, s);
     }
 }
@@ -1343 +1352 @@
 getInTurtleTime (const struct tr_turtle_info * t)
 {
-    struct tm tm;
-    size_t minute_of_the_week;
-    const time_t now = tr_time ();
-
-    tr_localtime_r (&now, &tm);
-
-    minute_of_the_week = tm.tm_wday * MINUTES_PER_DAY
-                       + tm.tm_hour * MINUTES_PER_HOUR
-                       + tm.tm_min;
-    if (minute_of_the_week >= MINUTES_PER_WEEK) /* leap minutes? */
-        minute_of_the_week = MINUTES_PER_WEEK - 1;
-
-    return tr_bitfieldHas (&t->minutes, minute_of_the_week);
+  struct tm tm;
+  size_t minute_of_the_week;
+  const time_t now = tr_time ();
+
+  tr_localtime_r (&now, &tm);
+
+  minute_of_the_week = tm.tm_wday * MINUTES_PER_DAY
+                     + tm.tm_hour * MINUTES_PER_HOUR
+                     + tm.tm_min;
+  if (minute_of_the_week >= MINUTES_PER_WEEK) /* leap minutes? */
+    minute_of_the_week = MINUTES_PER_WEEK - 1;
+
+  return tr_bitfieldHas (&t->minutes, minute_of_the_week);
 }
 
@@ -1367 +1376 @@
 turtleCheckClock (tr_session * s, struct tr_turtle_info * t)
 {
-    bool enabled;
-    bool alreadySwitched;
-    tr_auto_switch_state_t newAutoTurtleState;
-
-    assert (t->isClockEnabled);
-
-    enabled = getInTurtleTime (t);
-    newAutoTurtleState = autoSwitchState (enabled);
-    alreadySwitched = (t->autoTurtleState == newAutoTurtleState);
-
-    if (!alreadySwitched)
-    {
-        tr_logAddInfo ("Time to turn %s turtle mode!", (enabled?"on":"off"));
-        t->autoTurtleState = newAutoTurtleState;
-        useAltSpeed (s, t, enabled, false);
+  bool enabled;
+  bool alreadySwitched;
+  tr_auto_switch_state_t newAutoTurtleState;
+
+  assert (t->isClockEnabled);
+
+  enabled = getInTurtleTime (t);
+  newAutoTurtleState = autoSwitchState (enabled);
+  alreadySwitched = (t->autoTurtleState == newAutoTurtleState);
+
+  if (!alreadySwitched)
+    {
+      tr_logAddInfo ("Time to turn %s turtle mode!", (enabled?"on":"off"));
+      t->autoTurtleState = newAutoTurtleState;
+      useAltSpeed (s, t, enabled, false);
     }
 }
@@ -1391 +1400 @@
 turtleBootstrap (tr_session * session, struct tr_turtle_info * turtle)
 {
-    turtle->changedByUser = false;
-    turtle->autoTurtleState = TR_AUTO_SWITCH_UNUSED;
-
-    tr_bitfieldConstruct (&turtle->minutes, MINUTES_PER_WEEK);
-
-    turtleUpdateTable (turtle);
-
-    if (turtle->isClockEnabled)
-    {
-        turtle->isEnabled = getInTurtleTime (turtle);
-        turtle->autoTurtleState = autoSwitchState (turtle->isEnabled);
-    }
-
-    altSpeedToggled (session);
+  turtle->changedByUser = false;
+  turtle->autoTurtleState = TR_AUTO_SWITCH_UNUSED;
+
+  tr_bitfieldConstruct (&turtle->minutes, MINUTES_PER_WEEK);
+
+  turtleUpdateTable (turtle);
+
+  if (turtle->isClockEnabled)
+    {
+      turtle->isEnabled = getInTurtleTime (turtle);
+      turtle->autoTurtleState = autoSwitchState (turtle->isEnabled);
+    }
+
+  altSpeedToggled (session);
 
 }
@@ -1415 +1424 @@
 tr_sessionSetSpeedLimit_Bps (tr_session * s, tr_direction d, unsigned int Bps)
 {
-    assert (tr_isSession (s));
-    assert (tr_isDirection (d));
-
-    s->speedLimit_Bps[d] = Bps;
-
-    updateBandwidth (s, d);
+  assert (tr_isSession (s));
+  assert (tr_isDirection (d));
+
+  s->speedLimit_Bps[d] = Bps;
+
+  updateBandwidth (s, d);
 }
 void
 tr_sessionSetSpeedLimit_KBps (tr_session * s, tr_direction d, unsigned int KBps)
 {
-    tr_sessionSetSpeedLimit_Bps (s, d, toSpeedBytes (KBps));
+  tr_sessionSetSpeedLimit_Bps (s, d, toSpeedBytes (KBps));
 }
 
@@ -1431 +1440 @@
 tr_sessionGetSpeedLimit_Bps (const tr_session * s, tr_direction d)
 {
-    assert (tr_isSession (s));
-    assert (tr_isDirection (d));
-
-    return s->speedLimit_Bps[d];
+  assert (tr_isSession (s));
+  assert (tr_isDirection (d));
+
+  return s->speedLimit_Bps[d];
 }
 unsigned int
@@ -1445 +1454 @@
 tr_sessionLimitSpeed (tr_session * s, tr_direction d, bool b)
 {
-    assert (tr_isSession (s));
-    assert (tr_isDirection (d));
-    assert (tr_isBool (b));
-
-    s->speedLimitEnabled[d] = b;
-
-    updateBandwidth (s, d);
+  assert (tr_isSession (s));
+  assert (tr_isDirection (d));
+  assert (tr_isBool (b));
+
+  s->speedLimitEnabled[d] = b;
+
+  updateBandwidth (s, d);
 }
 
@@ -1457 +1466 @@
 tr_sessionIsSpeedLimited (const tr_session * s, tr_direction d)
 {
-    assert (tr_isSession (s));
-    assert (tr_isDirection (d));
-
-    return s->speedLimitEnabled[d];
+  assert (tr_isSession (s));
+  assert (tr_isDirection (d));
+
+  return s->speedLimitEnabled[d];
 }
 
@@ -1470 +1479 @@
 tr_sessionSetAltSpeed_Bps (tr_session * s, tr_direction d, unsigned int Bps)
 {
-    assert (tr_isSession (s));
-    assert (tr_isDirection (d));
-
-    s->turtle.speedLimit_Bps[d] = Bps;
-
-    updateBandwidth (s, d);
+  assert (tr_isSession (s));
+  assert (tr_isDirection (d));
+
+  s->turtle.speedLimit_Bps[d] = Bps;
+
+  updateBandwidth (s, d);
 }
 
@@ -1481 +1490 @@
 tr_sessionSetAltSpeed_KBps (tr_session * s, tr_direction d, unsigned int KBps)
 {
-    tr_sessionSetAltSpeed_Bps (s, d, toSpeedBytes (KBps));
+  tr_sessionSetAltSpeed_Bps (s, d, toSpeedBytes (KBps));
 }
 
@@ -1487 +1496 @@
 tr_sessionGetAltSpeed_Bps (const tr_session * s, tr_direction d)
 {
-    assert (tr_isSession (s));
-    assert (tr_isDirection (d));
-
-    return s->turtle.speedLimit_Bps[d];
+  assert (tr_isSession (s));
+  assert (tr_isDirection (d));
+
+  return s->turtle.speedLimit_Bps[d];
 }
 unsigned int
 tr_sessionGetAltSpeed_KBps (const tr_session * s, tr_direction d)
 {
-    return toSpeedKBps (tr_sessionGetAltSpeed_Bps (s, d));
+  return toSpeedKBps (tr_sessionGetAltSpeed_Bps (s, d));
 }
 
@@ -1501 +1510 @@
 userPokedTheClock (tr_session * s, struct tr_turtle_info * t)
 {
-    tr_logAddDebug ("Refreshing the turtle mode clock due to user changes");
-
-    t->autoTurtleState = TR_AUTO_SWITCH_UNUSED;
-
-    turtleUpdateTable (t);
-
-    if (t->isClockEnabled)
-    {
-        const bool enabled = getInTurtleTime (t);
-        useAltSpeed (s, t, enabled, true);
-        t->autoTurtleState = autoSwitchState (enabled);
+  tr_logAddDebug ("Refreshing the turtle mode clock due to user changes");
+
+  t->autoTurtleState = TR_AUTO_SWITCH_UNUSED;
+
+  turtleUpdateTable (t);
+
+  if (t->isClockEnabled)
+    {
+      const bool enabled = getInTurtleTime (t);
+      useAltSpeed (s, t, enabled, true);
+      t->autoTurtleState = autoSwitchState (enabled);
     }
 }
@@ -1518 +1527 @@
 tr_sessionUseAltSpeedTime (tr_session * s, bool b)
 {
-    struct tr_turtle_info * t = &s->turtle;
-
-    assert (tr_isSession (s));
-    assert (tr_isBool (b));
-
-    if (t->isClockEnabled != b) {
-        t->isClockEnabled = b;
-        userPokedTheClock (s, t);
+  struct tr_turtle_info * t = &s->turtle;
+
+  assert (tr_isSession (s));
+  assert (tr_isBool (b));
+
+  if (t->isClockEnabled != b)
+    {
+      t->isClockEnabled = b;
+      userPokedTheClock (s, t);
     }
 }
@@ -1532 +1542 @@
 tr_sessionUsesAltSpeedTime (const tr_session * s)
 {
-    assert (tr_isSession (s));
-
-    return s->turtle.isClockEnabled;
+  assert (tr_isSession (s));
+
+  return s->turtle.isClockEnabled;
 }
 
@@ -1540 +1550 @@
 tr_sessionSetAltSpeedBegin (tr_session * s, int minute)
 {
-    assert (tr_isSession (s));
-    assert (0<=minute && minute< (60*24));
-
-    if (s->turtle.beginMinute != minute) {
-        s->turtle.beginMinute = minute;
-        userPokedTheClock (s, &s->turtle);
+  assert (tr_isSession (s));
+  assert (0<=minute && minute< (60*24));
+
+  if (s->turtle.beginMinute != minute)
+    {
+      s->turtle.beginMinute = minute;
+      userPokedTheClock (s, &s->turtle);
     }
 }
@@ -1552 +1563 @@
 tr_sessionGetAltSpeedBegin (const tr_session * s)
 {
-    assert (tr_isSession (s));
-
-    return s->turtle.beginMinute;
+  assert (tr_isSession (s));
+
+  return s->turtle.beginMinute;
 }
 
@@ -1560 +1571 @@
 tr_sessionSetAltSpeedEnd (tr_session * s, int minute)
 {
-    assert (tr_isSession (s));
-    assert (0<=minute && minute< (60*24));
-
-    if (s->turtle.endMinute != minute) {
-        s->turtle.endMinute = minute;
-        userPokedTheClock (s, &s->turtle);
+  assert (tr_isSession (s));
+  assert (0<=minute && minute< (60*24));
+
+  if (s->turtle.endMinute != minute)
+    {
+      s->turtle.endMinute = minute;
+      userPokedTheClock (s, &s->turtle);
     }
 }
@@ -1572 +1584 @@
 tr_sessionGetAltSpeedEnd (const tr_session * s)
 {
-    assert (tr_isSession (s));
-
-    return s->turtle.endMinute;
+  assert (tr_isSession (s));
+
+  return s->turtle.endMinute;
 }
 
@@ -1580 +1592 @@
 tr_sessionSetAltSpeedDay (tr_session * s, tr_sched_day days)
 {
-    assert (tr_isSession (s));
-
-    if (s->turtle.days != days) {
-        s->turtle.days = days;
-        userPokedTheClock (s, &s->turtle);
+  assert (tr_isSession (s));
+
+  if (s->turtle.days != days)
+    {
+      s->turtle.days = days;
+      userPokedTheClock (s, &s->turtle);
     }
 }
@@ -1591 +1604 @@
 tr_sessionGetAltSpeedDay (const tr_session * s)
 {
-    assert (tr_isSession (s));
-
-    return s->turtle.days;
+  assert (tr_isSession (s));
+
+  return s->turtle.days;
 }
 
@@ -1599 +1612 @@
 tr_sessionUseAltSpeed (tr_session * session, bool enabled)
 {
-    useAltSpeed (session, &session->turtle, enabled, true);
+  useAltSpeed (session, &session->turtle, enabled, true);
 }
 
@@ -1605 +1618 @@
 tr_sessionUsesAltSpeed (const tr_session * s)
 {
-    assert (tr_isSession (s));
-
-    return s->turtle.isEnabled;
+  assert (tr_isSession (s));
+
+  return s->turtle.isEnabled;
 }
 
@@ -1615 +1628 @@
                            void             * userData)
 {
-    assert (tr_isSession (session));
-
-    session->turtle.callback = func;
-    session->turtle.callbackUserData = userData;
+  assert (tr_isSession (session));
+
+  session->turtle.callback = func;
+  session->turtle.callbackUserData = userData;
 }
 
@@ -1624 +1637 @@
 tr_sessionClearAltSpeedFunc (tr_session * session)
 {
-    tr_sessionSetAltSpeedFunc (session, NULL, NULL);
+  tr_sessionSetAltSpeedFunc (session, NULL, NULL);
 }
 
@@ -1634 +1647 @@
 tr_sessionSetPeerLimit (tr_session * session, uint16_t n)
 {
-    assert (tr_isSession (session));
-
-    session->peerLimit = n;
+  assert (tr_isSession (session));
+
+  session->peerLimit = n;
 }
 
@@ -1642 +1655 @@
 tr_sessionGetPeerLimit (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->peerLimit;
+  assert (tr_isSession (session));
+
+  return session->peerLimit;
 }
 
@@ -1658 +1671 @@
 tr_sessionGetPeerLimitPerTorrent (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->peerLimitPerTorrent;
+  assert (tr_isSession (session));
+
+  return session->peerLimitPerTorrent;
 }
 
@@ -1670 +1683 @@
 tr_sessionSetPaused (tr_session * session, bool isPaused)
 {
-    assert (tr_isSession (session));
-
-    session->pauseAddedTorrent = isPaused;
+  assert (tr_isSession (session));
+
+  session->pauseAddedTorrent = isPaused;
 }
 
@@ -1678 +1691 @@
 tr_sessionGetPaused (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->pauseAddedTorrent;
+  assert (tr_isSession (session));
+
+  return session->pauseAddedTorrent;
 }
 
@@ -1686 +1699 @@
 tr_sessionSetDeleteSource (tr_session * session, bool deleteSource)
 {
-    assert (tr_isSession (session));
-
-    session->deleteSourceTorrent = deleteSource;
+  assert (tr_isSession (session));
+
+  session->deleteSourceTorrent = deleteSource;
 }
 
@@ -1694 +1707 @@
 tr_sessionGetDeleteSource (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->deleteSourceTorrent;
+  assert (tr_isSession (session));
+
+  return session->deleteSourceTorrent;
 }
 
@@ -1706 +1719 @@
 tr_sessionGetPieceSpeed_Bps (const tr_session * session, tr_direction dir)
 {
-    return tr_isSession (session) ? tr_bandwidthGetPieceSpeed_Bps (&session->bandwidth, 0, dir) : 0;
+  return tr_isSession (session) ? tr_bandwidthGetPieceSpeed_Bps (&session->bandwidth, 0, dir) : 0;
 }
 
@@ -1712 +1725 @@
 tr_sessionGetRawSpeed_Bps (const tr_session * session, tr_direction dir)
 {
-    return tr_isSession (session) ? tr_bandwidthGetRawSpeed_Bps (&session->bandwidth, 0, dir) : 0;
+  return tr_isSession (session) ? tr_bandwidthGetRawSpeed_Bps (&session->bandwidth, 0, dir) : 0;
 }
 double
 tr_sessionGetRawSpeed_KBps (const tr_session * session, tr_direction dir)
 {
-    return toSpeedKBps (tr_sessionGetRawSpeed_Bps (session, dir));
+  return toSpeedKBps (tr_sessionGetRawSpeed_Bps (session, dir));
 }
 
@@ -1724 +1737 @@
 tr_sessionCountTorrents (const tr_session * session)
 {
-    return tr_isSession (session) ? session->torrentCount : 0;
+  return tr_isSession (session) ? session->torrentCount : 0;
 }
 
@@ -1730 +1743 @@
 compareTorrentByCur (const void * va, const void * vb)
 {
-    const tr_torrent * a = * (const tr_torrent**)va;
-    const tr_torrent * b = * (const tr_torrent**)vb;
-    const uint64_t     aCur = a->downloadedCur + a->uploadedCur;
-    const uint64_t     bCur = b->downloadedCur + b->uploadedCur;
-
-    if (aCur != bCur)
-        return aCur > bCur ? -1 : 1; /* close the biggest torrents first */
-
-    return 0;
+  const tr_torrent * a = * (const tr_torrent**)va;
+  const tr_torrent * b = * (const tr_torrent**)vb;
+  const uint64_t aCur = a->downloadedCur + a->uploadedCur;
+  const uint64_t bCur = b->downloadedCur + b->uploadedCur;
+
+  if (aCur != bCur)
+    return aCur > bCur ? -1 : 1; /* close the biggest torrents first */
+
+  return 0;
 }
 
@@ -1746 +1759 @@
 sessionCloseImpl (void * vsession)
 {
-    tr_session *  session = vsession;
-    tr_torrent *  tor;
-    int           i, n;
-    tr_torrent ** torrents;
-
-    assert (tr_isSession (session));
-
-    session->isClosing = true;
-
-    free_incoming_peer_port (session);
-
-    if (session->isLPDEnabled)
-        tr_lpdUninit (session);
-
-    tr_utpClose (session);
-    tr_dhtUninit (session);
-
-    event_free (session->saveTimer);
-    session->saveTimer = NULL;
-
-    event_free (session->nowTimer);
-    session->nowTimer = NULL;
-
-    tr_verifyClose (session);
-    tr_sharedClose (session);
-    tr_rpcClose (&session->rpcServer);
-
-    /* Close the torrents. Get the most active ones first so that
-     * if we can't get them all closed in a reasonable amount of time,
-     * at least we get the most important ones first. */
-    tor = NULL;
-    n = session->torrentCount;
-    torrents = tr_new (tr_torrent *, session->torrentCount);
-    for (i = 0; i < n; ++i)
-        torrents[i] = tor = tr_torrentNext (session, tor);
-    qsort (torrents, n, sizeof (tr_torrent*), compareTorrentByCur);
-    for (i = 0; i < n; ++i)
-        tr_torrentFree (torrents[i]);
-    tr_free (torrents);
-
-    /* Close the announcer *after* closing the torrents
-       so that all the &event=stopped messages will be
-       queued to be sent by tr_announcerClose () */
-    tr_announcerClose (session);
-
-    /* and this goes *after* announcer close so that
-       it won't be idle until the announce events are sent... */
-    tr_webClose (session, TR_WEB_CLOSE_WHEN_IDLE);
-
-    tr_cacheFree (session->cache);
-    session->cache = NULL;
-
-    /* gotta keep udp running long enough to send out all
-       the &event=stopped UDP tracker messages */
-    while (!tr_tracker_udp_is_idle (session)) {
-        tr_tracker_udp_upkeep (session);
-        tr_wait_msec (100);
-    }
-
-    /* we had to wait until UDP trackers were closed before closing these: */
-    evdns_base_free (session->evdns_base, 0);
-    session->evdns_base = NULL;
-    tr_tracker_udp_close (session);
-    tr_udpUninit (session);
-
-    tr_statsClose (session);
-    tr_peerMgrFree (session->peerMgr);
-
-    closeBlocklists (session);
-
-    tr_fdClose (session);
-
-    session->isClosed = true;
+  int i, n;
+  tr_torrent * tor;
+  tr_torrent ** torrents;
+  tr_session * session = vsession;
+
+  assert (tr_isSession (session));
+
+  session->isClosing = true;
+
+  free_incoming_peer_port (session);
+
+  if (session->isLPDEnabled)
+    tr_lpdUninit (session);
+
+  tr_utpClose (session);
+  tr_dhtUninit (session);
+
+  event_free (session->saveTimer);
+  session->saveTimer = NULL;
+
+  event_free (session->nowTimer);
+  session->nowTimer = NULL;
+
+  tr_verifyClose (session);
+  tr_sharedClose (session);
+  tr_rpcClose (&session->rpcServer);
+
+  /* Close the torrents. Get the most active ones first so that
+   * if we can't get them all closed in a reasonable amount of time,
+   * at least we get the most important ones first. */
+  tor = NULL;
+  n = session->torrentCount;
+  torrents = tr_new (tr_torrent *, session->torrentCount);
+  for (i=0; i<n; ++i)
+    torrents[i] = tor = tr_torrentNext (session, tor);
+  qsort (torrents, n, sizeof (tr_torrent*), compareTorrentByCur);
+  for (i=0; i<n; ++i)
+    tr_torrentFree (torrents[i]);
+  tr_free (torrents);
+
+  /* Close the announcer *after* closing the torrents
+     so that all the &event=stopped messages will be
+     queued to be sent by tr_announcerClose () */
+  tr_announcerClose (session);
+
+  /* and this goes *after* announcer close so that
+     it won't be idle until the announce events are sent... */
+  tr_webClose (session, TR_WEB_CLOSE_WHEN_IDLE);
+
+  tr_cacheFree (session->cache);
+  session->cache = NULL;
+
+  /* gotta keep udp running long enough to send out all
+     the &event=stopped UDP tracker messages */
+  while (!tr_tracker_udp_is_idle (session))
+    {
+      tr_tracker_udp_upkeep (session);
+      tr_wait_msec (100);
+    }
+
+  /* we had to wait until UDP trackers were closed before closing these: */
+  evdns_base_free (session->evdns_base, 0);
+  session->evdns_base = NULL;
+  tr_tracker_udp_close (session);
+  tr_udpUninit (session);
+
+  tr_statsClose (session);
+  tr_peerMgrFree (session->peerMgr);
+
+  closeBlocklists (session);
+
+  tr_fdClose (session);
+
+  session->isClosed = true;
 }
 
@@ -1824 +1838 @@
 deadlineReached (const time_t deadline)
 {
-    return time (NULL) >= deadline;
+  return time (NULL) >= deadline;
 }
 
@@ -1832 +1846 @@
 tr_sessionClose (tr_session * session)
 {
-    const time_t deadline = time (NULL) + SHUTDOWN_MAX_SECONDS;
-
-    assert (tr_isSession (session));
-
-    dbgmsg ("shutting down transmission session %p... now is %zu, deadline is %zu", session, (size_t)time (NULL), (size_t)deadline);
-
-    /* close the session */
-    tr_runInEventThread (session, sessionCloseImpl, session);
-    while (!session->isClosed && !deadlineReached (deadline))
-    {
-        dbgmsg ("waiting for the libtransmission thread to finish");
-        tr_wait_msec (100);
-    }
-
-    /* "shared" and "tracker" have live sockets,
-     * so we need to keep the transmission thread alive
-     * for a bit while they tell the router & tracker
-     * that we're closing now */
-    while ((session->shared || session->web || session->announcer || session->announcer_udp)
+  const time_t deadline = time (NULL) + SHUTDOWN_MAX_SECONDS;
+
+  assert (tr_isSession (session));
+
+  dbgmsg ("shutting down transmission session %p... now is %zu, deadline is %zu", session, (size_t)time (NULL), (size_t)deadline);
+
+  /* close the session */
+  tr_runInEventThread (session, sessionCloseImpl, session);
+  while (!session->isClosed && !deadlineReached (deadline))
+    {
+      dbgmsg ("waiting for the libtransmission thread to finish");
+      tr_wait_msec (100);
+    }
+
+  /* "shared" and "tracker" have live sockets,
+   * so we need to keep the transmission thread alive
+   * for a bit while they tell the router & tracker
+   * that we're closing now */
+  while ((session->shared || session->web || session->announcer || session->announcer_udp)
            && !deadlineReached (deadline))
     {
-        dbgmsg ("waiting on port unmap (%p) or announcer (%p)... now %zu deadline %zu",
-                session->shared, session->announcer, (size_t)time (NULL), (size_t)deadline);
-        tr_wait_msec (50);
-    }
-
-    tr_webClose (session, TR_WEB_CLOSE_NOW);
-
-    /* close the libtransmission thread */
-    tr_eventClose (session);
-    while (session->events != NULL)
-    {
-        static bool forced = false;
-        dbgmsg ("waiting for libtransmission thread to finish... now %zu deadline %zu", (size_t)time (NULL), (size_t)deadline);
-        tr_wait_msec (100);
-        if (deadlineReached (deadline) && !forced)
+      dbgmsg ("waiting on port unmap (%p) or announcer (%p)... now %zu deadline %zu",
+              session->shared, session->announcer, (size_t)time (NULL), (size_t)deadline);
+      tr_wait_msec (50);
+    }
+
+  tr_webClose (session, TR_WEB_CLOSE_NOW);
+
+  /* close the libtransmission thread */
+  tr_eventClose (session);
+  while (session->events != NULL)
+    {
+      static bool forced = false;
+      dbgmsg ("waiting for libtransmission thread to finish... now %zu deadline %zu", (size_t)time (NULL), (size_t)deadline);
+      tr_wait_msec (100);
+
+      if (deadlineReached (deadline) && !forced)
         {
-            dbgmsg ("calling event_loopbreak ()");
-            forced = true;
-            event_base_loopbreak (session->event_base);
+          dbgmsg ("calling event_loopbreak ()");
+          forced = true;
+          event_base_loopbreak (session->event_base);
         }
-        if (deadlineReached (deadline+3))
+
+      if (deadlineReached (deadline+3))
         {
-            dbgmsg ("deadline+3 reached... calling break...\n");
-            break;
+          dbgmsg ("deadline+3 reached... calling break...\n");
+          break;
         }
     }
 
-    /* free the session memory */
-    tr_variantFree (&session->removedTorrents);
-    tr_bandwidthDestruct (&session->bandwidth);
-    tr_bitfieldDestruct (&session->turtle.minutes);
-    tr_lockFree (session->lock);
-    if (session->metainfoLookup) {
-        tr_variantFree (session->metainfoLookup);
-        tr_free (session->metainfoLookup);
-    }
-    tr_device_info_free (session->downloadDir);
-    tr_free (session->torrentDoneScript);
-    tr_free (session->tag);
-    tr_free (session->configDir);
-    tr_free (session->resumeDir);
-    tr_free (session->torrentDir);
-    tr_free (session->incompleteDir);
-    tr_free (session->blocklist_url);
-    tr_free (session->peer_congestion_algorithm);
-    tr_free (session);
+  /* free the session memory */
+  tr_variantFree (&session->removedTorrents);
+  tr_bandwidthDestruct (&session->bandwidth);
+  tr_bitfieldDestruct (&session->turtle.minutes);
+  tr_lockFree (session->lock);
+  if (session->metainfoLookup)
+    {
+      tr_variantFree (session->metainfoLookup);
+      tr_free (session->metainfoLookup);
+    }
+  tr_device_info_free (session->downloadDir);
+  tr_free (session->torrentDoneScript);
+  tr_free (session->tag);
+  tr_free (session->configDir);
+  tr_free (session->resumeDir);
+  tr_free (session->torrentDir);
+  tr_free (session->incompleteDir);
+  tr_free (session->blocklist_url);
+  tr_free (session->peer_congestion_algorithm);
+  tr_free (session);
 }
 
 struct sessionLoadTorrentsData
 {
-    tr_session * session;
-    tr_ctor * ctor;
-    int * setmeCount;
-    tr_torrent ** torrents;
-    bool done;
+  tr_session * session;
+  tr_ctor * ctor;
+  int * setmeCount;
+  tr_torrent ** torrents;
+  bool done;
 };
 
@@ -1913 +1930 @@
 sessionLoadTorrents (void * vdata)
 {
-    int i;
-    int n = 0;
-    struct stat sb;
-    DIR * odir = NULL;
-    tr_list * l = NULL;
-    tr_list * list = NULL;
-    struct sessionLoadTorrentsData * data = vdata;
-    const char * dirname = tr_getTorrentDir (data->session);
-
-    assert (tr_isSession (data->session));
-
-    tr_ctorSetSave (data->ctor, false); /* since we already have them */
-
-    if (!stat (dirname, &sb)
+  int i;
+  int n = 0;
+  struct stat sb;
+  DIR * odir = NULL;
+  tr_list * l = NULL;
+  tr_list * list = NULL;
+  struct sessionLoadTorrentsData * data = vdata;
+  const char * dirname = tr_getTorrentDir (data->session);
+
+  assert (tr_isSession (data->session));
+
+  tr_ctorSetSave (data->ctor, false); /* since we already have them */
+
+  if (!stat (dirname, &sb)
       && S_ISDIR (sb.st_mode)
       && ((odir = opendir (dirname))))
     {
-        struct dirent *d;
-        for (d = readdir (odir); d != NULL; d = readdir (odir))
+      struct dirent *d;
+      for (d = readdir (odir); d != NULL; d = readdir (odir))
         {
-            if (tr_str_has_suffix (d->d_name, ".torrent"))
+          if (tr_str_has_suffix (d->d_name, ".torrent"))
             {
-                tr_torrent * tor;
-                char * path = tr_buildPath (dirname, d->d_name, NULL);
-                tr_ctorSetMetainfoFromFile (data->ctor, path);
-                if ((tor = tr_torrentNew (data->ctor, NULL, NULL)))
+              tr_torrent * tor;
+              char * path = tr_buildPath (dirname, d->d_name, NULL);
+              tr_ctorSetMetainfoFromFile (data->ctor, path);
+              if ((tor = tr_torrentNew (data->ctor, NULL, NULL)))
                 {
-                    tr_list_prepend (&list, tor);
-                    ++n;
+                  tr_list_prepend (&list, tor);
+                  ++n;
                 }
-                tr_free (path);
+              tr_free (path);
             }
         }
-        closedir (odir);
-    }
-
-    data->torrents = tr_new (tr_torrent *, n);
-    for (i = 0, l = list; l != NULL; l = l->next)
-        data->torrents[i++] = (tr_torrent*) l->data;
-    assert (i == n);
+      closedir (odir);
+    }
+
+  data->torrents = tr_new (tr_torrent *, n);
+  for (i=0, l=list; l!=NULL; l=l->next)
+    data->torrents[i++] = (tr_torrent*) l->data;
+  assert (i == n);
 
     tr_list_free (&list, NULL);
 
-    if (n)
-        tr_logAddInfo (_("Loaded %d torrents"), n);
-
-    if (data->setmeCount)
-        *data->setmeCount = n;
-
-    data->done = true;
+  if (n)
+    tr_logAddInfo (_("Loaded %d torrents"), n);
+
+  if (data->setmeCount)
+    *data->setmeCount = n;
+
+  data->done = true;
 }
 
@@ -1970 +1987 @@
                         int        * setmeCount)
 {
-    struct sessionLoadTorrentsData data;
-
-    data.session = session;
-    data.ctor = ctor;
-    data.setmeCount = setmeCount;
-    data.torrents = NULL;
-    data.done = false;
-
-    tr_runInEventThread (session, sessionLoadTorrents, &data);
-    while (!data.done)
-        tr_wait_msec (100);
-
-    return data.torrents;
+  struct sessionLoadTorrentsData data;
+
+  data.session = session;
+  data.ctor = ctor;
+  data.setmeCount = setmeCount;
+  data.torrents = NULL;
+  data.done = false;
+
+  tr_runInEventThread (session, sessionLoadTorrents, &data);
+  while (!data.done)
+    tr_wait_msec (100);
+
+  return data.torrents;
 }
 
@@ -1992 +2009 @@
 tr_sessionSetPexEnabled (tr_session * session, bool enabled)
 {
-    assert (tr_isSession (session));
-
-    session->isPexEnabled = enabled != 0;
+  assert (tr_isSession (session));
+
+  session->isPexEnabled = enabled != 0;
 }
 
@@ -2000 +2017 @@
 tr_sessionIsPexEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isPexEnabled;
+  assert (tr_isSession (session));
+
+  return session->isPexEnabled;
 }
 
@@ -2008 +2025 @@
 tr_sessionAllowsDHT (const tr_session * session)
 {
-    return tr_sessionIsDHTEnabled (session);
+  return tr_sessionIsDHTEnabled (session);
 }
 
@@ -2014 +2031 @@
 tr_sessionIsDHTEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isDHTEnabled;
+  assert (tr_isSession (session));
+
+  return session->isDHTEnabled;
 }
 
@@ -2022 +2039 @@
 toggleDHTImpl (void * data)
 {
-    tr_session * session = data;
-    assert (tr_isSession (session));
-
-    tr_udpUninit (session);
-    session->isDHTEnabled = !session->isDHTEnabled;
-    tr_udpInit (session);
+  tr_session * session = data;
+  assert (tr_isSession (session));
+
+  tr_udpUninit (session);
+  session->isDHTEnabled = !session->isDHTEnabled;
+  tr_udpInit (session);
 }
 
@@ -2033 +2050 @@
 tr_sessionSetDHTEnabled (tr_session * session, bool enabled)
 {
-    assert (tr_isSession (session));
-    assert (tr_isBool (enabled));
-
-    if ((enabled != 0) != (session->isDHTEnabled != 0))
-        tr_runInEventThread (session, toggleDHTImpl, session);
+  assert (tr_isSession (session));
+  assert (tr_isBool (enabled));
+
+  if ((enabled != 0) != (session->isDHTEnabled != 0))
+    tr_runInEventThread (session, toggleDHTImpl, session);
 }
 
@@ -2047 +2064 @@
 tr_sessionIsUTPEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
+  assert (tr_isSession (session));
 
 #ifdef WITH_UTP
-    return session->isUTPEnabled;
+  return session->isUTPEnabled;
 #else
-    return false;
+  return false;
 #endif
 }
@@ -2059 +2076 @@
 toggle_utp (void * data)
 {
-    tr_session * session = data;
-    assert (tr_isSession (session));
-
-    session->isUTPEnabled = !session->isUTPEnabled;
-
-    tr_udpSetSocketBuffers (session);
-
-    /* But don't call tr_utpClose -- see reset_timer in tr-utp.c for an
-       explanation. */
+  tr_session * session = data;
+
+  assert (tr_isSession (session));
+
+  session->isUTPEnabled = !session->isUTPEnabled;
+
+  tr_udpSetSocketBuffers (session);
+
+  /* But don't call tr_utpClose -- see reset_timer in tr-utp.c for an
+     explanation. */
 }
 
@@ -2073 +2091 @@
 tr_sessionSetUTPEnabled (tr_session * session, bool enabled)
 {
-    assert (tr_isSession (session));
-    assert (tr_isBool (enabled));
-
-    if ((enabled != 0) != (session->isUTPEnabled != 0))
-        tr_runInEventThread (session, toggle_utp, session);
+  assert (tr_isSession (session));
+  assert (tr_isBool (enabled));
+
+  if ((enabled != 0) != (session->isUTPEnabled != 0))
+    tr_runInEventThread (session, toggle_utp, session);
 }
 
@@ -2087 +2105 @@
 toggleLPDImpl (void * data)
 {
-    tr_session * session = data;
-    assert (tr_isSession (session));
-
-    if (session->isLPDEnabled)
-        tr_lpdUninit (session);
-
-    session->isLPDEnabled = !session->isLPDEnabled;
-
-    if (session->isLPDEnabled)
-        tr_lpdInit (session, &session->public_ipv4->addr);
+  tr_session * session = data;
+  assert (tr_isSession (session));
+
+  if (session->isLPDEnabled)
+    tr_lpdUninit (session);
+
+  session->isLPDEnabled = !session->isLPDEnabled;
+
+  if (session->isLPDEnabled)
+    tr_lpdInit (session, &session->public_ipv4->addr);
 }
 
@@ -2102 +2120 @@
 tr_sessionSetLPDEnabled (tr_session * session, bool enabled)
 {
-    assert (tr_isSession (session));
-    assert (tr_isBool (enabled));
-
-    if ((enabled != 0) != (session->isLPDEnabled != 0))
-        tr_runInEventThread (session, toggleLPDImpl, session);
+  assert (tr_isSession (session));
+  assert (tr_isBool (enabled));
+
+  if ((enabled != 0) != (session->isLPDEnabled != 0))
+    tr_runInEventThread (session, toggleLPDImpl, session);
 }
 
@@ -2112 +2130 @@
 tr_sessionIsLPDEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isLPDEnabled;
+  assert (tr_isSession (session));
+
+  return session->isLPDEnabled;
 }
 
@@ -2120 +2138 @@
 tr_sessionAllowsLPD (const tr_session * session)
 {
-    return tr_sessionIsLPDEnabled (session);
+  return tr_sessionIsLPDEnabled (session);
 }
 
@@ -2130 +2148 @@
 tr_sessionSetCacheLimit_MB (tr_session * session, int max_bytes)
 {
-    assert (tr_isSession (session));
-
-    tr_cacheSetLimit (session->cache, toMemBytes (max_bytes));
+  assert (tr_isSession (session));
+
+  tr_cacheSetLimit (session->cache, toMemBytes (max_bytes));
 }
 
@@ -2138 +2156 @@
 tr_sessionGetCacheLimit_MB (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return toMemMB (tr_cacheGetLimit (session->cache));
+  assert (tr_isSession (session));
+
+  return toMemMB (tr_cacheGetLimit (session->cache));
 }
 
@@ -2149 +2167 @@
 struct port_forwarding_data
 {
-    bool enabled;
-    struct tr_shared * shared;
+  bool enabled;
+  struct tr_shared * shared;
 };
 
@@ -2156 +2174 @@
 setPortForwardingEnabled (void * vdata)
 {
-    struct port_forwarding_data * data = vdata;
-    tr_sharedTraversalEnable (data->shared, data->enabled);
-    tr_free (data);
+  struct port_forwarding_data * data = vdata;
+  tr_sharedTraversalEnable (data->shared, data->enabled);
+  tr_free (data);
 }
 
@@ -2164 +2182 @@
 tr_sessionSetPortForwardingEnabled (tr_session  * session, bool enabled)
 {
-    struct port_forwarding_data * d;
-    d = tr_new0 (struct port_forwarding_data, 1);
-    d->shared = session->shared;
-    d->enabled = enabled;
-    tr_runInEventThread (session, setPortForwardingEnabled, d);
+  struct port_forwarding_data * d;
+  d = tr_new0 (struct port_forwarding_data, 1);
+  d->shared = session->shared;
+  d->enabled = enabled;
+  tr_runInEventThread (session, setPortForwardingEnabled, d);
 }
 
@@ -2174 +2192 @@
 tr_sessionIsPortForwardingEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_sharedTraversalIsEnabled (session->shared);
+  assert (tr_isSession (session));
+
+  return tr_sharedTraversalIsEnabled (session->shared);
 }
 
@@ -2186 +2204 @@
 tr_stringEndsWith (const char * str, const char * end)
 {
-    const size_t slen = strlen (str);
-    const size_t elen = strlen (end);
-
-    return slen >= elen && !memcmp (&str[slen - elen], end, elen);
+  const size_t slen = strlen (str);
+  const size_t elen = strlen (end);
+
+  return slen >= elen && !memcmp (&str[slen - elen], end, elen);
 }
 
@@ -2296 +2314 @@
 closeBlocklists (tr_session * session)
 {
-    tr_list_free (&session->blocklists,
-                (TrListForeachFunc)tr_blocklistFileFree);
+  tr_list_free (&session->blocklists, (TrListForeachFunc)tr_blocklistFileFree);
 }
 
@@ -2303 +2320 @@
 tr_sessionReloadBlocklists (tr_session * session)
 {
-    closeBlocklists (session);
-    loadBlocklists (session);
-
-    tr_peerMgrOnBlocklistChanged (session->peerMgr);
+  closeBlocklists (session);
+  loadBlocklists (session);
+
+  tr_peerMgrOnBlocklistChanged (session->peerMgr);
 }
 
@@ -2312 +2329 @@
 tr_blocklistGetRuleCount (const tr_session * session)
 {
-    int       n = 0;
-    tr_list * l;
-
-    assert (tr_isSession (session));
-
-    for (l = session->blocklists; l; l = l->next)
-        n += tr_blocklistFileGetRuleCount (l->data);
-    return n;
+  tr_list * l;
+  int n = 0;
+
+  assert (tr_isSession (session));
+
+  for (l = session->blocklists; l; l = l->next)
+    n += tr_blocklistFileGetRuleCount (l->data);
+
+  return n;
 }
 
@@ -2325 +2343 @@
 tr_blocklistIsEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isBlocklistEnabled;
+  assert (tr_isSession (session));
+
+  return session->isBlocklistEnabled;
 }
 
@@ -2333 +2351 @@
 tr_blocklistSetEnabled (tr_session * session, bool isEnabled)
 {
-    tr_list * l;
-
-    assert (tr_isSession (session));
-
-    session->isBlocklistEnabled = isEnabled != 0;
-
-    for (l=session->blocklists; l!=NULL; l=l->next)
-        tr_blocklistFileSetEnabled (l->data, isEnabled);
+  tr_list * l;
+
+  assert (tr_isSession (session));
+
+  session->isBlocklistEnabled = isEnabled != 0;
+
+  for (l=session->blocklists; l!=NULL; l=l->next)
+    tr_blocklistFileSetEnabled (l->data, isEnabled);
 }
 
@@ -2346 +2364 @@
 tr_blocklistExists (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->blocklists != NULL;
+  assert (tr_isSession (session));
+
+  return session->blocklists != NULL;
 }
 
@@ -2354 +2372 @@
 tr_blocklistSetContent (tr_session * session, const char * contentFilename)
 {
-    tr_list * l;
-    int ruleCount;
-    tr_blocklistFile * b;
-    const char * defaultName = DEFAULT_BLOCKLIST_FILENAME;
-    tr_sessionLock (session);
-
-    for (b = NULL, l = session->blocklists; !b && l; l = l->next)
-        if (tr_stringEndsWith (tr_blocklistFileGetFilename (l->data),
-                               defaultName))
-            b = l->data;
-
-    if (!b)
-    {
-        char * path = tr_buildPath (session->configDir, "blocklists", defaultName, NULL);
-        b = tr_blocklistFileNew (path, session->isBlocklistEnabled);
-        tr_list_append (&session->blocklists, b);
-        tr_free (path);
-    }
-
-    ruleCount = tr_blocklistFileSetContent (b, contentFilename);
-    tr_sessionUnlock (session);
-    return ruleCount;
+  tr_list * l;
+  int ruleCount;
+  tr_blocklistFile * b;
+  const char * defaultName = DEFAULT_BLOCKLIST_FILENAME;
+  tr_sessionLock (session);
+
+  for (b=NULL, l=session->blocklists; !b && l; l=l->next)
+    if (tr_stringEndsWith (tr_blocklistFileGetFilename (l->data), defaultName))
+      b = l->data;
+
+  if (!b)
+    {
+      char * path = tr_buildPath (session->configDir, "blocklists", defaultName, NULL);
+      b = tr_blocklistFileNew (path, session->isBlocklistEnabled);
+      tr_list_append (&session->blocklists, b);
+      tr_free (path);
+    }
+
+  ruleCount = tr_blocklistFileSetContent (b, contentFilename);
+  tr_sessionUnlock (session);
+  return ruleCount;
 }
 
@@ -2382 +2399 @@
                             const tr_address * addr)
 {
-    tr_list * l;
-
-    assert (tr_isSession (session));
-
-    for (l = session->blocklists; l; l = l->next)
-        if (tr_blocklistFileHasAddress (l->data, addr))
-            return true;
-    return false;
+  tr_list * l;
+
+  assert (tr_isSession (session));
+
+  for (l = session->blocklists; l; l = l->next)
+    if (tr_blocklistFileHasAddress (l->data, addr))
+      return true;
+
+  return false;
 }
 
@@ -2395 +2413 @@
 tr_blocklistSetURL (tr_session * session, const char * url)
 {
-    if (session->blocklist_url != url)
-    {
-        tr_free (session->blocklist_url);
-        session->blocklist_url = tr_strdup (url);
+  if (session->blocklist_url != url)
+    {
+      tr_free (session->blocklist_url);
+      session->blocklist_url = tr_strdup (url);
     }
 }
@@ -2405 +2423 @@
 tr_blocklistGetURL (const tr_session * session)
 {
-    return session->blocklist_url;
+  return session->blocklist_url;
 }
 
@@ -2416 +2434 @@
 metainfoLookupInit (tr_session * session)
 {
-    struct stat  sb;
-    const char * dirname = tr_getTorrentDir (session);
-    DIR *        odir = NULL;
-    tr_ctor *    ctor = NULL;
-    tr_variant * lookup;
-    int n = 0;
-
-    assert (tr_isSession (session));
-
-    /* walk through the directory and find the mappings */
-    lookup = tr_new0 (tr_variant, 1);
-    tr_variantInitDict (lookup, 0);
-    ctor = tr_ctorNew (session);
-    tr_ctorSetSave (ctor, false); /* since we already have them */
-    if (!stat (dirname, &sb) && S_ISDIR (sb.st_mode) && ((odir = opendir (dirname))))
-    {
-        struct dirent *d;
-        while ((d = readdir (odir)))
+  struct stat sb;
+  const char * dirname = tr_getTorrentDir (session);
+  DIR * odir = NULL;
+  tr_ctor * ctor = NULL;
+  tr_variant * lookup;
+  int n = 0;
+
+  assert (tr_isSession (session));
+
+  /* walk through the directory and find the mappings */
+  lookup = tr_new0 (tr_variant, 1);
+  tr_variantInitDict (lookup, 0);
+  ctor = tr_ctorNew (session);
+  tr_ctorSetSave (ctor, false); /* since we already have them */
+  if (!stat (dirname, &sb) && S_ISDIR (sb.st_mode) && ((odir = opendir (dirname))))
+    {
+      struct dirent *d;
+      while ((d = readdir (odir)))
         {
-            if (tr_str_has_suffix (d->d_name, ".torrent"))
+          if (tr_str_has_suffix (d->d_name, ".torrent"))
             {
-                tr_info inf;
-                char * path = tr_buildPath (dirname, d->d_name, NULL);
-                tr_ctorSetMetainfoFromFile (ctor, path);
-                if (!tr_torrentParse (ctor, &inf))
+              tr_info inf;
+              char * path = tr_buildPath (dirname, d->d_name, NULL);
+              tr_ctorSetMetainfoFromFile (ctor, path);
+              if (!tr_torrentParse (ctor, &inf))
                 {
-                    ++n;
-                    tr_variantDictAddStr (lookup, tr_quark_new(inf.hashString,-1), path);
+                  ++n;
+                  tr_variantDictAddStr (lookup, tr_quark_new(inf.hashString,-1), path);
                 }
-                tr_free (path);
+              tr_free (path);
             }
         }
-        closedir (odir);
-    }
-    tr_ctorFree (ctor);
-
-    session->metainfoLookup = lookup;
-    tr_logAddDebug ("Found %d torrents in \"%s\"", n, dirname);
+      closedir (odir);
+    }
+  tr_ctorFree (ctor);
+
+  session->metainfoLookup = lookup;
+  tr_logAddDebug ("Found %d torrents in \"%s\"", n, dirname);
 }
 
@@ -2460 +2478 @@
                            const char       * hashString)
 {
-    const char * filename = NULL;
-    if (!session->metainfoLookup)
-        metainfoLookupInit ((tr_session*)session);
-    tr_variantDictFindStr (session->metainfoLookup, tr_quark_new(hashString,-1), &filename, NULL);
-    return filename;
+  const char * filename = NULL;
+
+  if (!session->metainfoLookup)
+    metainfoLookupInit ((tr_session*)session);
+  tr_variantDictFindStr (session->metainfoLookup, tr_quark_new(hashString,-1), &filename, NULL);
+
+  return filename;
 }
 
@@ -2472 +2492 @@
                           const char * filename)
 {
-    /* since we walk session->configDir/torrents/ to build the lookup table,
-     * and tr_sessionSetTorrentFile () is just to tell us there's a new file
-     * in that same directory, we don't need to do anything here if the
-     * lookup table hasn't been built yet */
-    if (session->metainfoLookup)
-        tr_variantDictAddStr (session->metainfoLookup, tr_quark_new(hashString,-1), filename);
+  /* since we walk session->configDir/torrents/ to build the lookup table,
+   * and tr_sessionSetTorrentFile () is just to tell us there's a new file
+   * in that same directory, we don't need to do anything here if the
+   * lookup table hasn't been built yet */
+  if (session->metainfoLookup)
+    tr_variantDictAddStr (session->metainfoLookup, tr_quark_new(hashString,-1), filename);
 }
 
@@ -2487 +2507 @@
 tr_sessionSetRPCEnabled (tr_session * session, bool isEnabled)
 {
-    assert (tr_isSession (session));
-
-    tr_rpcSetEnabled (session->rpcServer, isEnabled);
+  assert (tr_isSession (session));
+
+  tr_rpcSetEnabled (session->rpcServer, isEnabled);
 }
 
@@ -2495 +2515 @@
 tr_sessionIsRPCEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcIsEnabled (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcIsEnabled (session->rpcServer);
 }
 
@@ -2504 +2524 @@
                       tr_port      port)
 {
-    assert (tr_isSession (session));
-
-    tr_rpcSetPort (session->rpcServer, port);
+  assert (tr_isSession (session));
+
+  tr_rpcSetPort (session->rpcServer, port);
 }
 
@@ -2512 +2532 @@
 tr_sessionGetRPCPort (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcGetPort (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcGetPort (session->rpcServer);
 }
 
@@ -2521 +2541 @@
                      const char * url)
 {
-    assert (tr_isSession (session));
-
-    tr_rpcSetUrl (session->rpcServer, url);
+  assert (tr_isSession (session));
+
+  tr_rpcSetUrl (session->rpcServer, url);
 }
 
@@ -2529 +2549 @@
 tr_sessionGetRPCUrl (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcGetUrl (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcGetUrl (session->rpcServer);
 }
 
@@ -2539 +2559 @@
                           void *       user_data)
 {
-    assert (tr_isSession (session));
-
-    session->rpc_func = func;
-    session->rpc_func_user_data = user_data;
+  assert (tr_isSession (session));
+
+  session->rpc_func = func;
+  session->rpc_func_user_data = user_data;
 }
 
@@ -2549 +2569 @@
                            const char * whitelist)
 {
-    assert (tr_isSession (session));
-
-    tr_rpcSetWhitelist (session->rpcServer, whitelist);
+  assert (tr_isSession (session));
+
+  tr_rpcSetWhitelist (session->rpcServer, whitelist);
 }
 
@@ -2557 +2577 @@
 tr_sessionGetRPCWhitelist (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcGetWhitelist (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcGetWhitelist (session->rpcServer);
 }
 
@@ -2565 +2585 @@
 tr_sessionSetRPCWhitelistEnabled (tr_session * session, bool isEnabled)
 {
-    assert (tr_isSession (session));
-
-    tr_rpcSetWhitelistEnabled (session->rpcServer, isEnabled);
+  assert (tr_isSession (session));
+
+  tr_rpcSetWhitelistEnabled (session->rpcServer, isEnabled);
 }
 
@@ -2573 +2593 @@
 tr_sessionGetRPCWhitelistEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcGetWhitelistEnabled (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcGetWhitelistEnabled (session->rpcServer);
 }
 
@@ -2583 +2603 @@
                           const char * password)
 {
-    assert (tr_isSession (session));
-
-    tr_rpcSetPassword (session->rpcServer, password);
+  assert (tr_isSession (session));
+
+  tr_rpcSetPassword (session->rpcServer, password);
 }
 
@@ -2591 +2611 @@
 tr_sessionGetRPCPassword (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcGetPassword (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcGetPassword (session->rpcServer);
 }
 
@@ -2600 +2620 @@
                           const char * username)
 {
-    assert (tr_isSession (session));
-
-    tr_rpcSetUsername (session->rpcServer, username);
+  assert (tr_isSession (session));
+
+  tr_rpcSetUsername (session->rpcServer, username);
 }
 
@@ -2608 +2628 @@
 tr_sessionGetRPCUsername (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcGetUsername (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcGetUsername (session->rpcServer);
 }
 
@@ -2616 +2636 @@
 tr_sessionSetRPCPasswordEnabled (tr_session * session, bool isEnabled)
 {
-    assert (tr_isSession (session));
-
-    tr_rpcSetPasswordEnabled (session->rpcServer, isEnabled);
+  assert (tr_isSession (session));
+
+  tr_rpcSetPasswordEnabled (session->rpcServer, isEnabled);
 }
 
@@ -2624 +2644 @@
 tr_sessionIsRPCPasswordEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcIsPasswordEnabled (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcIsPasswordEnabled (session->rpcServer);
 }
 
@@ -2632 +2652 @@
 tr_sessionGetRPCBindAddress (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return tr_rpcGetBindAddress (session->rpcServer);
+  assert (tr_isSession (session));
+
+  return tr_rpcGetBindAddress (session->rpcServer);
 }
 
@@ -2644 +2664 @@
 tr_sessionIsTorrentDoneScriptEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->isTorrentDoneScriptEnabled;
+  assert (tr_isSession (session));
+
+  return session->isTorrentDoneScriptEnabled;
 }
 
@@ -2652 +2672 @@
 tr_sessionSetTorrentDoneScriptEnabled (tr_session * session, bool isEnabled)
 {
-    assert (tr_isSession (session));
-    assert (tr_isBool (isEnabled));
-
-    session->isTorrentDoneScriptEnabled = isEnabled;
+  assert (tr_isSession (session));
+  assert (tr_isBool (isEnabled));
+
+  session->isTorrentDoneScriptEnabled = isEnabled;
 }
 
@@ -2661 +2681 @@
 tr_sessionGetTorrentDoneScript (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->torrentDoneScript;
+  assert (tr_isSession (session));
+
+  return session->torrentDoneScript;
 }
 
@@ -2669 +2689 @@
 tr_sessionSetTorrentDoneScript (tr_session * session, const char * scriptFilename)
 {
-    assert (tr_isSession (session));
-
-    if (session->torrentDoneScript != scriptFilename)
-    {
-        tr_free (session->torrentDoneScript);
-        session->torrentDoneScript = tr_strdup (scriptFilename);
+  assert (tr_isSession (session));
+
+  if (session->torrentDoneScript != scriptFilename)
+    {
+      tr_free (session->torrentDoneScript);
+      session->torrentDoneScript = tr_strdup (scriptFilename);
     }
 }
@@ -2685 +2705 @@
 tr_sessionSetQueueSize (tr_session * session, tr_direction dir, int n)
 {
-    assert (tr_isSession (session));
-    assert (tr_isDirection (dir));
-
-    session->queueSize[dir] = n;
+  assert (tr_isSession (session));
+  assert (tr_isDirection (dir));
+
+  session->queueSize[dir] = n;
 }
 
@@ -2694 +2714 @@
 tr_sessionGetQueueSize (const tr_session * session, tr_direction dir)
 {
-    assert (tr_isSession (session));
-    assert (tr_isDirection (dir));
-
-    return session->queueSize[dir];
+  assert (tr_isSession (session));
+  assert (tr_isDirection (dir));
+
+  return session->queueSize[dir];
 }
 
@@ -2703 +2723 @@
 tr_sessionSetQueueEnabled (tr_session * session, tr_direction dir, bool is_enabled)
 {
-    assert (tr_isSession (session));
-    assert (tr_isDirection (dir));
-    assert (tr_isBool (is_enabled));
-
-    session->queueEnabled[dir] = is_enabled;
+  assert (tr_isSession (session));
+  assert (tr_isDirection (dir));
+  assert (tr_isBool (is_enabled));
+
+  session->queueEnabled[dir] = is_enabled;
 }
 
@@ -2713 +2733 @@
 tr_sessionGetQueueEnabled (const tr_session * session, tr_direction dir)
 {
-    assert (tr_isSession (session));
-    assert (tr_isDirection (dir));
-
-    return session->queueEnabled[dir];
+  assert (tr_isSession (session));
+  assert (tr_isDirection (dir));
+
+  return session->queueEnabled[dir];
 }
 
@@ -2722 +2742 @@
 tr_sessionSetQueueStalledMinutes (tr_session * session, int minutes)
 {
-    assert (tr_isSession (session));
-    assert (minutes > 0);
-
-    session->queueStalledMinutes = minutes;
+  assert (tr_isSession (session));
+  assert (minutes > 0);
+
+  session->queueStalledMinutes = minutes;
 }
 
@@ -2731 +2751 @@
 tr_sessionSetQueueStalledEnabled (tr_session * session, bool is_enabled)
 {
-    assert (tr_isSession (session));
-    assert (tr_isBool (is_enabled));
-
-    session->stalledEnabled = is_enabled;
+  assert (tr_isSession (session));
+  assert (tr_isBool (is_enabled));
+
+  session->stalledEnabled = is_enabled;
 }
 
@@ -2740 +2760 @@
 tr_sessionGetQueueStalledEnabled (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->stalledEnabled;
+  assert (tr_isSession (session));
+
+  return session->stalledEnabled;
 }
 
@@ -2748 +2768 @@
 tr_sessionGetQueueStalledMinutes (const tr_session * session)
 {
-    assert (tr_isSession (session));
-
-    return session->queueStalledMinutes;
+  assert (tr_isSession (session));
+
+  return session->queueStalledMinutes;
 }
 
@@ -2827 +2847 @@
 tr_sessionCountQueueFreeSlots (tr_session * session, tr_direction dir)
 {
-    tr_torrent * tor;
-    int active_count;
-    const int max = tr_sessionGetQueueSize (session, dir);
-    const tr_torrent_activity activity = dir == TR_UP ? TR_STATUS_SEED : TR_STATUS_DOWNLOAD;
-
-    if (!tr_sessionGetQueueEnabled (session, dir))
-        return INT_MAX;
+  tr_torrent * tor;
+  int active_count;
+  const int max = tr_sessionGetQueueSize (session, dir);
+  const tr_torrent_activity activity = dir == TR_UP ? TR_STATUS_SEED : TR_STATUS_DOWNLOAD;
+
+  if (!tr_sessionGetQueueEnabled (session, dir))
+    return INT_MAX;
 
     tor = NULL;