From 3d38723ad92540e7f5e968d22d68edcc132db744 Mon Sep 17 00:00:00 2001
From: Jordan Lee <jordan@transmissionbt.com>
Date: Wed, 5 Dec 2012 17:29:46 +0000
Subject: [PATCH] Follow more common whitespace style conventions in the C code
 (libtransmission, daemon, utils, cli, gtk).

---
 cli/cli.c                              |  587 +++---
 daemon/daemon.c                        |  396 ++--
 daemon/remote.c                        | 1974 +++++++++---------
 daemon/watch.c                         |  156 +-
 daemon/watch.h                         |   10 +-
 gtk/actions.c                          |  284 +--
 gtk/actions.h                          |   18 +-
 gtk/conf.c                             |  334 +--
 gtk/conf.h                             |   22 +-
 gtk/details.c                          | 2308 ++++++++++-----------
 gtk/details.h                          |   10 +-
 gtk/dialogs.c                          |  118 +-
 gtk/dialogs.h                          |    4 +-
 gtk/favicon.c                          |  114 +-
 gtk/favicon.h                          |   10 +-
 gtk/file-list.c                        |  630 +++---
 gtk/file-list.h                        |    8 +-
 gtk/filter.c                           |  778 +++----
 gtk/filter.h                           |    6 +-
 gtk/hig.c                              |  146 +-
 gtk/hig.h                              |   44 +-
 gtk/icon-lock.h                        |    2 +-
 gtk/icon-logo-24.h                     |    2 +-
 gtk/icon-logo-48.h                     |    6 +-
 gtk/icons.c                            |  150 +-
 gtk/icons.h                            |    6 +-
 gtk/main.c                             | 1990 +++++++++---------
 gtk/makemeta-ui.c                      |  466 ++---
 gtk/makemeta-ui.h                      |    4 +-
 gtk/msgwin.c                           |  712 +++----
 gtk/msgwin.h                           |    4 +-
 gtk/notify.c                           |  196 +-
 gtk/notify.h                           |    8 +-
 gtk/open-dialog.c                      |  448 ++---
 gtk/open-dialog.h                      |    8 +-
 gtk/relocate.c                         |  136 +-
 gtk/relocate.h                         |    6 +-
 gtk/stats.c                            |  176 +-
 gtk/stats.h                            |    4 +-
 gtk/torrent-cell-renderer.c            |  650 +++---
 gtk/torrent-cell-renderer.h            |   14 +-
 gtk/tr-core.c                          | 2170 ++++++++++----------
 gtk/tr-core.h                          |   74 +-
 gtk/tr-icon.c                          |  100 +-
 gtk/tr-icon.h                          |    6 +-
 gtk/tr-prefs.c                         | 1454 +++++++-------
 gtk/tr-prefs.h                         |    6 +-
 gtk/tr-window.c                        |  804 ++++----
 gtk/tr-window.h                        |    8 +-
 gtk/util.c                             |  462 ++---
 gtk/util.h                             |   66 +-
 libtransmission/ConvertUTF.c           |   54 +-
 libtransmission/ConvertUTF.h           |    8 +-
 libtransmission/announcer-common.h     |   30 +-
 libtransmission/announcer-http.c       |  338 ++--
 libtransmission/announcer-udp.c        |  690 +++----
 libtransmission/announcer.c            | 1000 ++++-----
 libtransmission/announcer.h            |   52 +-
 libtransmission/bandwidth.c            |  270 +--
 libtransmission/bandwidth.h            |   76 +-
 libtransmission/bencode-test.c         |  482 ++---
 libtransmission/bencode.c              | 1114 +++++-----
 libtransmission/bencode.h              |  134 +-
 libtransmission/bitfield.c             |  492 ++---
 libtransmission/bitfield.h             |   72 +-
 libtransmission/blocklist-test.c       |   82 +-
 libtransmission/blocklist.c            |  236 +--
 libtransmission/blocklist.h            |   28 +-
 libtransmission/cache.c                |  501 ++---
 libtransmission/cache.h                |   33 +-
 libtransmission/clients-test.c         |   32 +-
 libtransmission/clients.c              |  480 ++---
 libtransmission/clients.h              |    4 +-
 libtransmission/completion.c           |  194 +-
 libtransmission/completion.h           |   66 +-
 libtransmission/crypto.c               |  250 +--
 libtransmission/crypto.h               |   50 +-
 libtransmission/fdlimit.c              |  428 ++--
 libtransmission/fdlimit.h              |   48 +-
 libtransmission/handshake.c            |  861 ++++----
 libtransmission/handshake.h            |   20 +-
 libtransmission/history-test.c         |   26 +-
 libtransmission/history.c              |   47 +-
 libtransmission/history.h              |   26 +-
 libtransmission/inout.c                |  335 ++--
 libtransmission/inout.h                |   22 +-
 libtransmission/json-test.c            |  148 +-
 libtransmission/json.c                 |   14 +-
 libtransmission/json.h                 |    6 +-
 libtransmission/libtransmission-test.h |   26 +-
 libtransmission/list.c                 |  221 +-
 libtransmission/list.h                 |   30 +-
 libtransmission/magnet-test.c          |   48 +-
 libtransmission/magnet.c               |  303 +--
 libtransmission/magnet.h               |   20 +-
 libtransmission/makemeta.c             |  382 ++--
 libtransmission/makemeta.h             |   24 +-
 libtransmission/metainfo-test.c        |    4 +-
 libtransmission/metainfo.c             |  810 ++++----
 libtransmission/metainfo.h             |   16 +-
 libtransmission/natpmp.c               |  130 +-
 libtransmission/natpmp_local.h         |    8 +-
 libtransmission/net.c                  |  368 ++--
 libtransmission/net.h                  |   62 +-
 libtransmission/peer-common.h          |   10 +-
 libtransmission/peer-io.c              |  934 ++++-----
 libtransmission/peer-io.h              |  210 +-
 libtransmission/peer-mgr.c             | 2568 ++++++++++++------------
 libtransmission/peer-mgr.h             |  102 +-
 libtransmission/peer-msgs-test.c       |   22 +-
 libtransmission/peer-msgs.c            | 1714 ++++++++--------
 libtransmission/peer-msgs.h            |   28 +-
 libtransmission/platform.c             |  821 ++++----
 libtransmission/platform.h             |   38 +-
 libtransmission/port-forwarding.c      |  128 +-
 libtransmission/port-forwarding.h      |   16 +-
 libtransmission/ptrarray.c             |  140 +-
 libtransmission/ptrarray.h             |   70 +-
 libtransmission/resume.c               |  592 +++---
 libtransmission/resume.h               |   50 +-
 libtransmission/rpc-server.c           |  710 +++----
 libtransmission/rpc-server.h           |   54 +-
 libtransmission/rpc-test.c             |   82 +-
 libtransmission/rpcimpl.c              | 1864 ++++++++---------
 libtransmission/rpcimpl.h              |   20 +-
 libtransmission/session.c              | 2064 +++++++++----------
 libtransmission/session.h              |  100 +-
 libtransmission/stats.c                |  252 ++-
 libtransmission/stats.h                |   23 +-
 libtransmission/test-peer-id.c         |   18 +-
 libtransmission/torrent-ctor.c         |  256 +--
 libtransmission/torrent-magnet.c       |  238 +--
 libtransmission/torrent-magnet.h       |   14 +-
 libtransmission/torrent.c              | 2206 ++++++++++----------
 libtransmission/torrent.h              |  190 +-
 libtransmission/tr-dht.c               |  502 ++---
 libtransmission/tr-dht.h               |   18 +-
 libtransmission/tr-getopt.c            |  140 +-
 libtransmission/tr-getopt.h            |   18 +-
 libtransmission/tr-lpd.c               |  272 +--
 libtransmission/tr-lpd.h               |   14 +-
 libtransmission/tr-udp.c               |  250 +--
 libtransmission/tr-udp.h               |   10 +-
 libtransmission/tr-utp.c               |  104 +-
 libtransmission/tr-utp.h               |    6 +-
 libtransmission/transmission.h         |  784 ++++----
 libtransmission/trevent.c              |  200 +-
 libtransmission/trevent.h              |   10 +-
 libtransmission/upnp.c                 |  164 +-
 libtransmission/upnp.h                 |   10 +-
 libtransmission/utils-test.c           |  384 ++--
 libtransmission/utils.c                | 1116 +++++-----
 libtransmission/utils.h                |  370 ++--
 libtransmission/verify.c               |  395 ++--
 libtransmission/verify.h               |   12 +-
 libtransmission/web.c                  |  388 ++--
 libtransmission/web.h                  |   28 +-
 libtransmission/webseed.c              |  358 ++--
 libtransmission/webseed.h              |   14 +-
 libtransmission/wildmat.c              |   12 +-
 utils/create.c                         |  193 +-
 utils/edit.c                           |  375 ++--
 utils/show.c                           |  398 ++--
 163 files changed, 25889 insertions(+), 25486 deletions(-)

diff --git a/cli/cli.c b/cli/cli.c
index 806aa59ce..c8b0d168d 100644
--- a/cli/cli.c
+++ b/cli/cli.c
@@ -22,9 +22,9 @@
  * DEALINGS IN THE SOFTWARE.
  *****************************************************************************/
 
-#include <stdio.h> /* fprintf() */
-#include <stdlib.h> /* atoi() */
-#include <string.h> /* memcmp() */
+#include <stdio.h> /* fprintf () */
+#include <stdlib.h> /* atoi () */
+#include <string.h> /* memcmp () */
 #include <signal.h>
 
 #include <libtransmission/transmission.h>
@@ -67,384 +67,439 @@
 #define MY_READABLE_NAME "transmission-cli"
 
 static bool showVersion              = false;
-static bool verify                   = 0;
-static sig_atomic_t gotsig           = 0;
-static sig_atomic_t manualUpdate     = 0;
+static bool verify                   = false;
+static sig_atomic_t gotsig           = false;
+static sig_atomic_t manualUpdate     = false;
 
 static const char * torrentPath  = NULL;
 
 static const struct tr_option options[] =
 {
-    { 'b', "blocklist",            "Enable peer blocklists", "b",  0, NULL },
-    { 'B', "no-blocklist",         "Disable peer blocklists", "B",  0, NULL },
-    { 'd', "downlimit",            "Set max download speed in "SPEED_K_STR, "d",  1, "<speed>" },
-    { 'D', "no-downlimit",         "Don't limit the download speed", "D",  0, NULL },
-    { 910, "encryption-required",  "Encrypt all peer connections", "er", 0, NULL },
-    { 911, "encryption-preferred", "Prefer encrypted peer connections", "ep", 0, NULL },
-    { 912, "encryption-tolerated", "Prefer unencrypted peer connections", "et", 0, NULL },
-    { 'f', "finish",               "Run a script when the torrent finishes", "f", 1, "<script>" },
-    { 'g', "config-dir",           "Where to find configuration files", "g", 1, "<path>" },
-    { 'm', "portmap",              "Enable portmapping via NAT-PMP or UPnP", "m",  0, NULL },
-    { 'M', "no-portmap",           "Disable portmapping", "M",  0, NULL },
-    { 'p', "port", "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")", "p", 1, "<port>" },
-    { 't', "tos", "Peer socket TOS (0 to 255, default=" TR_DEFAULT_PEER_SOCKET_TOS_STR ")", "t", 1, "<tos>" },
-    { 'u', "uplimit",              "Set max upload speed in "SPEED_K_STR, "u",  1, "<speed>"   },
-    { 'U', "no-uplimit",           "Don't limit the upload speed", "U",  0, NULL        },
-    { 'v', "verify",               "Verify the specified torrent", "v",  0, NULL        },
-    { 'V', "version",              "Show version number and exit", "V", 0, NULL },
-    { 'w', "download-dir",         "Where to save downloaded data", "w",  1, "<path>"    },
-    { 0, NULL, NULL, NULL, 0, NULL }
+  { 'b', "blocklist",            "Enable peer blocklists", "b",  0, NULL },
+  { 'B', "no-blocklist",         "Disable peer blocklists", "B",  0, NULL },
+  { 'd', "downlimit",            "Set max download speed in "SPEED_K_STR, "d",  1, "<speed>" },
+  { 'D', "no-downlimit",         "Don't limit the download speed", "D",  0, NULL },
+  { 910, "encryption-required",  "Encrypt all peer connections", "er", 0, NULL },
+  { 911, "encryption-preferred", "Prefer encrypted peer connections", "ep", 0, NULL },
+  { 912, "encryption-tolerated", "Prefer unencrypted peer connections", "et", 0, NULL },
+  { 'f', "finish",               "Run a script when the torrent finishes", "f", 1, "<script>" },
+  { 'g', "config-dir",           "Where to find configuration files", "g", 1, "<path>" },
+  { 'm', "portmap",              "Enable portmapping via NAT-PMP or UPnP", "m",  0, NULL },
+  { 'M', "no-portmap",           "Disable portmapping", "M",  0, NULL },
+  { 'p', "port", "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")", "p", 1, "<port>" },
+  { 't', "tos", "Peer socket TOS (0 to 255, default=" TR_DEFAULT_PEER_SOCKET_TOS_STR ")", "t", 1, "<tos>" },
+  { 'u', "uplimit",              "Set max upload speed in "SPEED_K_STR, "u",  1, "<speed>"   },
+  { 'U', "no-uplimit",           "Don't limit the upload speed", "U",  0, NULL        },
+  { 'v', "verify",               "Verify the specified torrent", "v",  0, NULL        },
+  { 'V', "version",              "Show version number and exit", "V", 0, NULL },
+  { 'w', "download-dir",         "Where to save downloaded data", "w",  1, "<path>"    },
+  { 0, NULL, NULL, NULL, 0, NULL }
 };
 
 static const char *
-getUsage( void )
+getUsage (void)
 {
-    return "A fast and easy BitTorrent client\n"
-           "\n"
-           "Usage: " MY_READABLE_NAME " [options] <file|url|magnet>";
+  return "A fast and easy BitTorrent client\n"
+         "\n"
+         "Usage: " MY_READABLE_NAME " [options] <file|url|magnet>";
 }
 
-static int parseCommandLine( tr_benc*, int argc, const char ** argv );
+static int parseCommandLine (tr_benc*, int argc, const char ** argv);
 
-static void         sigHandler( int signal );
+static void sigHandler (int signal);
 
 static char*
-tr_strlratio( char * buf,
-              double ratio,
-              size_t buflen )
+tr_strlratio (char * buf, double ratio, size_t buflen)
 {
-    if( (int)ratio == TR_RATIO_NA )
-        tr_strlcpy( buf, _( "None" ), buflen );
-    else if( (int)ratio == TR_RATIO_INF )
-        tr_strlcpy( buf, "Inf", buflen );
-    else if( ratio < 10.0 )
-        tr_snprintf( buf, buflen, "%.2f", ratio );
-    else if( ratio < 100.0 )
-        tr_snprintf( buf, buflen, "%.1f", ratio );
-    else
-        tr_snprintf( buf, buflen, "%.0f", ratio );
-    return buf;
+  if ((int)ratio == TR_RATIO_NA)
+    tr_strlcpy (buf, _ ("None"), buflen);
+  else if ((int)ratio == TR_RATIO_INF)
+    tr_strlcpy (buf, "Inf", buflen);
+  else if (ratio < 10.0)
+    tr_snprintf (buf, buflen, "%.2f", ratio);
+  else if (ratio < 100.0)
+    tr_snprintf (buf, buflen, "%.1f", ratio);
+  else
+    tr_snprintf (buf, buflen, "%.0f", ratio);
+
+  return buf;
 }
 
 static bool waitingOnWeb;
 
 static void
-onTorrentFileDownloaded( tr_session   * session UNUSED,
+onTorrentFileDownloaded (tr_session   * session UNUSED,
                          bool           did_connect UNUSED,
                          bool           did_timeout UNUSED,
                          long           response_code UNUSED,
                          const void   * response,
                          size_t         response_byte_count,
-                         void         * ctor )
+                         void         * ctor)
 {
-    tr_ctorSetMetainfo( ctor, response, response_byte_count );
-    waitingOnWeb = false;
+  tr_ctorSetMetainfo (ctor, response, response_byte_count);
+  waitingOnWeb = false;
 }
 
 static void
-getStatusStr( const tr_stat * st,
+getStatusStr (const tr_stat * st,
               char *          buf,
-              size_t          buflen )
+              size_t          buflen)
 {
-    if( st->activity == TR_STATUS_CHECK_WAIT )
+  if (st->activity == TR_STATUS_CHECK_WAIT)
     {
-        tr_snprintf( buf, buflen, "Waiting to verify local files" );
+      tr_snprintf (buf, buflen, "Waiting to verify local files");
     }
-    else if( st->activity == TR_STATUS_CHECK )
+  else if (st->activity == TR_STATUS_CHECK)
     {
-        tr_snprintf( buf, buflen,
-                     "Verifying local files (%.2f%%, %.2f%% valid)",
-                     tr_truncd( 100 * st->recheckProgress, 2 ),
-                     tr_truncd( 100 * st->percentDone, 2 ) );
+      tr_snprintf (buf, buflen,
+                   "Verifying local files (%.2f%%, %.2f%% valid)",
+                   tr_truncd (100 * st->recheckProgress, 2),
+                   tr_truncd (100 * st->percentDone, 2));
     }
-    else if( st->activity == TR_STATUS_DOWNLOAD )
+  else if (st->activity == TR_STATUS_DOWNLOAD)
     {
-        char upStr[80];
-        char dnStr[80];
-        char ratioStr[80];
-
-        tr_formatter_speed_KBps( upStr, st->pieceUploadSpeed_KBps, sizeof( upStr ) );
-        tr_formatter_speed_KBps( dnStr, st->pieceDownloadSpeed_KBps, sizeof( dnStr ) );
-        tr_strlratio( ratioStr, st->ratio, sizeof( ratioStr ) );
-
-        tr_snprintf( buf, buflen,
-            "Progress: %.1f%%, "
-            "dl from %d of %d peers (%s), "
-            "ul to %d (%s) "
-            "[%s]",
-            tr_truncd( 100 * st->percentDone, 1 ),
-            st->peersSendingToUs, st->peersConnected, dnStr,
-            st->peersGettingFromUs, upStr,
-            ratioStr );
+      char upStr[80];
+      char dnStr[80];
+      char ratioStr[80];
+
+      tr_formatter_speed_KBps (upStr, st->pieceUploadSpeed_KBps, sizeof (upStr));
+      tr_formatter_speed_KBps (dnStr, st->pieceDownloadSpeed_KBps, sizeof (dnStr));
+      tr_strlratio (ratioStr, st->ratio, sizeof (ratioStr));
+
+      tr_snprintf (buf, buflen,
+                   "Progress: %.1f%%, "
+                   "dl from %d of %d peers (%s), "
+                   "ul to %d (%s) "
+                   "[%s]",
+                   tr_truncd (100 * st->percentDone, 1),
+                   st->peersSendingToUs, st->peersConnected, dnStr,
+                   st->peersGettingFromUs, upStr,
+                   ratioStr);
     }
-    else if( st->activity == TR_STATUS_SEED )
+  else if (st->activity == TR_STATUS_SEED)
     {
-        char upStr[80];
-        char ratioStr[80];
+      char upStr[80];
+      char ratioStr[80];
 
-        tr_formatter_speed_KBps( upStr, st->pieceUploadSpeed_KBps, sizeof( upStr ) );
-        tr_strlratio( ratioStr, st->ratio, sizeof( ratioStr ) );
+      tr_formatter_speed_KBps (upStr, st->pieceUploadSpeed_KBps, sizeof (upStr));
+      tr_strlratio (ratioStr, st->ratio, sizeof (ratioStr));
 
-        tr_snprintf( buf, buflen,
-                     "Seeding, uploading to %d of %d peer(s), %s [%s]",
-                     st->peersGettingFromUs, st->peersConnected, upStr, ratioStr );
+      tr_snprintf (buf, buflen,
+                   "Seeding, uploading to %d of %d peer (s), %s [%s]",
+                   st->peersGettingFromUs, st->peersConnected, upStr, ratioStr);
+    }
+  else
+    {
+      *buf = '\0';
     }
-    else *buf = '\0';
 }
 
 static const char*
-getConfigDir( int argc, const char ** argv )
+getConfigDir (int argc, const char ** argv)
 {
-    int c;
-    const char * configDir = NULL;
-    const char * optarg;
-    const int ind = tr_optind;
-
-    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg ))) {
-        if( c == 'g' ) {
-            configDir = optarg;
-            break;
+  int c;
+  const char * configDir = NULL;
+  const char * optarg;
+  const int ind = tr_optind;
+
+  while ((c = tr_getopt (getUsage (), argc, argv, options, &optarg)))
+    {
+      if (c == 'g')
+        {
+          configDir = optarg;
+          break;
         }
     }
 
-    tr_optind = ind;
+  tr_optind = ind;
 
-    if( configDir == NULL )
-        configDir = tr_getDefaultConfigDir( MY_CONFIG_NAME );
+  if (configDir == NULL)
+    configDir = tr_getDefaultConfigDir (MY_CONFIG_NAME);
 
-    return configDir;
+  return configDir;
 }
 
 int
-main( int argc, char ** argv )
+main (int argc, char ** argv)
 {
-    int           error;
-    tr_session  * h;
-    tr_ctor     * ctor;
-    tr_torrent  * tor = NULL;
-    tr_benc       settings;
-    const char  * configDir;
-    uint8_t     * fileContents;
-    size_t        fileLength;
-    const char  * str;
-    char          buf[TR_PATH_MAX];
-
-    tr_formatter_mem_init( MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR );
-    tr_formatter_size_init( DISK_K,DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR );
-    tr_formatter_speed_init( SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR );
-
-    printf( "%s %s\n", MY_READABLE_NAME, LONG_VERSION_STRING );
-
-    /* user needs to pass in at least one argument */
-    if( argc < 2 ) {
-        tr_getopt_usage( MY_READABLE_NAME, getUsage( ), options );
-        return EXIT_FAILURE;
+  int           error;
+  tr_session  * h;
+  tr_ctor     * ctor;
+  tr_torrent  * tor = NULL;
+  tr_benc       settings;
+  const char  * configDir;
+  uint8_t     * fileContents;
+  size_t        fileLength;
+  const char  * str;
+  char          buf[TR_PATH_MAX];
+
+  tr_formatter_mem_init (MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR);
+  tr_formatter_size_init (DISK_K,DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR);
+  tr_formatter_speed_init (SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR);
+
+  printf ("%s %s\n", MY_READABLE_NAME, LONG_VERSION_STRING);
+
+  /* user needs to pass in at least one argument */
+  if (argc < 2)
+    {
+      tr_getopt_usage (MY_READABLE_NAME, getUsage (), options);
+      return EXIT_FAILURE;
     }
 
-    /* load the defaults from config file + libtransmission defaults */
-    tr_bencInitDict( &settings, 0 );
-    configDir = getConfigDir( argc, (const char**)argv );
-    tr_sessionLoadSettings( &settings, configDir, MY_CONFIG_NAME );
+  /* load the defaults from config file + libtransmission defaults */
+  tr_bencInitDict (&settings, 0);
+  configDir = getConfigDir (argc, (const char**)argv);
+  tr_sessionLoadSettings (&settings, configDir, MY_CONFIG_NAME);
 
-    /* the command line overrides defaults */
-    if( parseCommandLine( &settings, argc, (const char**)argv ) )
-        return EXIT_FAILURE;
+  /* the command line overrides defaults */
+  if (parseCommandLine (&settings, argc, (const char**)argv))
+    return EXIT_FAILURE;
 
-    if( showVersion )
-        return 0;
+  if (showVersion)
+    return EXIT_SUCCESS;
 
-    /* Check the options for validity */
-    if( !torrentPath ) {
-        fprintf( stderr, "No torrent specified!\n" );
-        return EXIT_FAILURE;
+  /* Check the options for validity */
+  if (!torrentPath)
+    {
+      fprintf (stderr, "No torrent specified!\n");
+      return EXIT_FAILURE;
     }
 
-    if( tr_bencDictFindStr( &settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) ) {
-        str = tr_realpath( str, buf );
-        if( str != NULL ) {
-            tr_bencDictAddStr( &settings, TR_PREFS_KEY_DOWNLOAD_DIR, str );
-        } else {
-            fprintf( stderr, "Download directory does not exist!\n" );
-            return EXIT_FAILURE;
+  if (tr_bencDictFindStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str))
+    {
+      str = tr_realpath (str, buf);
+
+      if (str != NULL)
+        {
+          tr_bencDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, str);
+        }
+      else
+        {
+          fprintf (stderr, "Download directory does not exist!\n");
+          return EXIT_FAILURE;
         }
     }
 
-    h = tr_sessionInit( "cli", configDir, false, &settings );
-
-    ctor = tr_ctorNew( h );
-
-    fileContents = tr_loadFile( torrentPath, &fileLength );
-    tr_ctorSetPaused( ctor, TR_FORCE, false );
-    if( fileContents != NULL ) {
-        tr_ctorSetMetainfo( ctor, fileContents, fileLength );
-    } else if( !memcmp( torrentPath, "magnet:?", 8 ) ) {
-        tr_ctorSetMetainfoFromMagnetLink( ctor, torrentPath );
-    } else if( !memcmp( torrentPath, "http", 4 ) ) {
-        tr_webRun( h, torrentPath, NULL, NULL, onTorrentFileDownloaded, ctor );
-        waitingOnWeb = true;
-        while( waitingOnWeb ) tr_wait_msec( 1000 );
-    } else {
-        fprintf( stderr, "ERROR: Unrecognized torrent \"%s\".\n", torrentPath );
-        fprintf( stderr, " * If you're trying to create a torrent, use transmission-create.\n" );
-        fprintf( stderr, " * If you're trying to see a torrent's info, use transmission-show.\n" );
-        tr_sessionClose( h );
-        return EXIT_FAILURE;
+  h = tr_sessionInit ("cli", configDir, false, &settings);
+
+  ctor = tr_ctorNew (h);
+
+  fileContents = tr_loadFile (torrentPath, &fileLength);
+  tr_ctorSetPaused (ctor, TR_FORCE, false);
+  if (fileContents != NULL)
+    {
+      tr_ctorSetMetainfo (ctor, fileContents, fileLength);
     }
-    tr_free( fileContents );
+  else if (!memcmp (torrentPath, "magnet:?", 8))
+    {
+      tr_ctorSetMetainfoFromMagnetLink (ctor, torrentPath);
+    }
+  else if (!memcmp (torrentPath, "http", 4))
+    {
+      tr_webRun (h, torrentPath, NULL, NULL, onTorrentFileDownloaded, ctor);
+      waitingOnWeb = true;
+      while (waitingOnWeb)
+        tr_wait_msec (1000);
+    }
+  else
+    {
+      fprintf (stderr, "ERROR: Unrecognized torrent \"%s\".\n", torrentPath);
+      fprintf (stderr, " * If you're trying to create a torrent, use transmission-create.\n");
+      fprintf (stderr, " * If you're trying to see a torrent's info, use transmission-show.\n");
+      tr_sessionClose (h);
+      return EXIT_FAILURE;
+    }
+
+  tr_free (fileContents);
 
-    tor = tr_torrentNew( ctor, &error );
-    tr_ctorFree( ctor );
-    if( !tor )
+  tor = tr_torrentNew (ctor, &error);
+  tr_ctorFree (ctor);
+  if (!tor)
     {
-        fprintf( stderr, "Failed opening torrent file `%s'\n", torrentPath );
-        tr_sessionClose( h );
-        return EXIT_FAILURE;
+      fprintf (stderr, "Failed opening torrent file `%s'\n", torrentPath);
+      tr_sessionClose (h);
+      return EXIT_FAILURE;
     }
 
-    signal( SIGINT, sigHandler );
+  signal (SIGINT, sigHandler);
 #ifndef WIN32
-    signal( SIGHUP, sigHandler );
+  signal (SIGHUP, sigHandler);
 #endif
-    tr_torrentStart( tor );
+  tr_torrentStart (tor);
 
-    if( verify )
+  if (verify)
     {
-        verify = 0;
-        tr_torrentVerify( tor );
+      verify = false;
+      tr_torrentVerify (tor);
     }
 
-    for( ; ; )
+  for (;;)
     {
-        char            line[LINEWIDTH];
-        const tr_stat * st;
-        const char * messageName[] = { NULL, "Tracker gave a warning:",
-                                             "Tracker gave an error:",
-                                             "Error:" };
+      char  line[LINEWIDTH];
+      const tr_stat * st;
+      const char * messageName[] = { NULL, "Tracker gave a warning:",
+                                           "Tracker gave an error:",
+                                           "Error:" };
 
-        tr_wait_msec( 200 );
+      tr_wait_msec (200);
 
-        if( gotsig )
+      if (gotsig)
         {
-            gotsig = 0;
-            printf( "\nStopping torrent...\n" );
-            tr_torrentStop( tor );
+          gotsig = false;
+          printf ("\nStopping torrent...\n");
+          tr_torrentStop (tor);
         }
 
-        if( manualUpdate )
+      if (manualUpdate)
         {
-            manualUpdate = 0;
-            if( !tr_torrentCanManualUpdate( tor ) )
-                fprintf(
-                    stderr,
-                    "\nReceived SIGHUP, but can't send a manual update now\n" );
-            else
+          manualUpdate = false;
+          if (!tr_torrentCanManualUpdate (tor))
+            {
+              fprintf (stderr, "\nReceived SIGHUP, but can't send a manual update now\n");
+            }
+          else
             {
-                fprintf( stderr,
-                         "\nReceived SIGHUP: manual update scheduled\n" );
-                tr_torrentManualUpdate( tor );
+              fprintf (stderr, "\nReceived SIGHUP: manual update scheduled\n");
+              tr_torrentManualUpdate (tor);
             }
         }
 
-        st = tr_torrentStat( tor );
-        if( st->activity == TR_STATUS_STOPPED )
-            break;
+      st = tr_torrentStat (tor);
+      if (st->activity == TR_STATUS_STOPPED)
+        break;
 
-        getStatusStr( st, line, sizeof( line ) );
-        printf( "\r%-*s", LINEWIDTH, line );
+      getStatusStr (st, line, sizeof (line));
+      printf ("\r%-*s", LINEWIDTH, line);
 
-        if( messageName[st->error] )
-            fprintf( stderr, "\n%s: %s\n", messageName[st->error], st->errorString );
+      if (messageName[st->error])
+        fprintf (stderr, "\n%s: %s\n", messageName[st->error], st->errorString);
     }
 
-    tr_sessionSaveSettings( h, configDir, &settings );
+  tr_sessionSaveSettings (h, configDir, &settings);
 
-    printf( "\n" );
-    tr_bencFree( &settings );
-    tr_sessionClose( h );
-    return EXIT_SUCCESS;
+  printf ("\n");
+  tr_bencFree (&settings);
+  tr_sessionClose (h);
+  return EXIT_SUCCESS;
 }
 
 /***
 ****
 ****
-****
 ***/
 
 static int
-parseCommandLine( tr_benc * d, int argc, const char ** argv )
+parseCommandLine (tr_benc * d, int argc, const char ** argv)
 {
-    int          c;
-    const char * optarg;
+  int c;
+  const char * optarg;
 
-    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
+  while ((c = tr_getopt (getUsage (), argc, argv, options, &optarg)))
     {
-        switch( c )
+      switch (c)
         {
-            case 'b': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, true );
-                      break;
-            case 'B': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, false );
-                      break;
-            case 'd': tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_KBps, atoi( optarg ) );
-                      tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, true );
-                      break;
-            case 'D': tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, false );
-                      break;
-            case 'f': tr_bencDictAddStr( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg );
-                      tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true );
-                      break;
-            case 'g': /* handled above */
-                      break;
-            case 'm': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, true );
-                      break;
-            case 'M': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, false );
-                      break;
-            case 'p': tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, atoi( optarg ) );
-                      break;
-            case 't': tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi( optarg ) );
-                      break;
-            case 'u': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_KBps, atoi( optarg ) );
-                      tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, true );
-                      break;
-            case 'U': tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, false );
-                      break;
-            case 'v': verify = true;
-                      break;
-            case 'V': showVersion = true;
-                      break;
-            case 'w': tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg );
-                      break;
-            case 910: tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED );
-                      break;
-            case 911: tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED );
-                      break;
-            case 912: tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED );
-                      break;
-            case TR_OPT_UNK:
-                      if( torrentPath == NULL )
-                          torrentPath = optarg;
-                      break;
-            default: return 1;
+          case 'b':
+            tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, true);
+            break;
+
+          case 'B': tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, false);
+            break;
+
+          case 'd':
+            tr_bencDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps, atoi (optarg));
+            tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, true);
+            break;
+
+          case 'D': tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, false);
+            break;
+
+          case 'f':
+            tr_bencDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg);
+            tr_bencDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true);
+            break;
+
+          case 'g': /* handled above */
+            break;
+
+          case 'm':
+            tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, true);
+            break;
+
+          case 'M':
+            tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, false);
+            break;
+
+          case 'p':
+            tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT, atoi (optarg));
+            break;
+
+          case 't':
+            tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi (optarg));
+            break;
+
+          case 'u':
+            tr_bencDictAddInt (d, TR_PREFS_KEY_USPEED_KBps, atoi (optarg));
+            tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, true);
+            break;
+
+          case 'U':
+            tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, false);
+            break;
+
+          case 'v':
+            verify = true;
+            break;
+
+          case 'V':
+            showVersion = true;
+            break;
+
+          case 'w':
+            tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);
+            break;
+
+          case 910:
+            tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);
+            break;
+
+          case 911:
+            tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);
+            break;
+
+          case 912:
+            tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);
+            break;
+
+          case TR_OPT_UNK:
+            if (torrentPath == NULL)
+              torrentPath = optarg;
+            break;
+
+          default:
+            return 1;
         }
     }
 
-    return 0;
+  return 0;
 }
 
 static void
-sigHandler( int signal )
+sigHandler (int signal)
 {
-    switch( signal )
+  switch (signal)
     {
-        case SIGINT:
-            gotsig = 1; break;
+      case SIGINT:
+        gotsig = true;
+        break;
 
 #ifndef WIN32
-        case SIGHUP:
-            manualUpdate = 1; break;
+      case SIGHUP:
+        manualUpdate = true;
+        break;
 
 #endif
-        default:
-            break;
+      default:
+        break;
     }
 }
 
diff --git a/daemon/daemon.c b/daemon/daemon.c
index d7a3c63b2..5504e048e 100644
--- a/daemon/daemon.c
+++ b/daemon/daemon.c
@@ -71,7 +71,7 @@ static tr_session * mySession = NULL;
 ***/
 
 static const char *
-getUsage( void )
+getUsage (void)
 {
     return "Transmission " LONG_VERSION_STRING
            "  http://www.transmissionbt.com/\n"
@@ -133,22 +133,22 @@ static const struct tr_option options[] =
 };
 
 static void
-showUsage( void )
+showUsage (void)
 {
-    tr_getopt_usage( MY_NAME, getUsage( ), options );
-    exit( 0 );
+    tr_getopt_usage (MY_NAME, getUsage (), options);
+    exit (0);
 }
 
 static void
-gotsig( int sig )
+gotsig (int sig)
 {
-    switch( sig )
+    switch (sig)
     {
         case SIGHUP:
         {
-            if( !mySession )
+            if (!mySession)
             {
-                tr_inf( "Deferring reload until session is fully started." );
+                tr_inf ("Deferring reload until session is fully started.");
                 seenHUP = true;
             }
             else
@@ -157,26 +157,26 @@ gotsig( int sig )
                 const char * configDir;
 
                 /* reopen the logfile to allow for log rotation */
-                if( logfileName ) {
-                    logfile = freopen( logfileName, LOGFILE_MODE_STR, logfile );
-                    if( !logfile )
-                        fprintf( stderr, "Couldn't reopen \"%s\": %s\n", logfileName, tr_strerror( errno ) );
+                if (logfileName) {
+                    logfile = freopen (logfileName, LOGFILE_MODE_STR, logfile);
+                    if (!logfile)
+                        fprintf (stderr, "Couldn't reopen \"%s\": %s\n", logfileName, tr_strerror (errno));
                 }
 
-                configDir = tr_sessionGetConfigDir( mySession );
-                tr_inf( "Reloading settings from \"%s\"", configDir );
-                tr_bencInitDict( &settings, 0 );
-                tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, true );
-                tr_sessionLoadSettings( &settings, configDir, MY_NAME );
-                tr_sessionSet( mySession, &settings );
-                tr_bencFree( &settings );
-                tr_sessionReloadBlocklists( mySession );
+                configDir = tr_sessionGetConfigDir (mySession);
+                tr_inf ("Reloading settings from \"%s\"", configDir);
+                tr_bencInitDict (&settings, 0);
+                tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_ENABLED, true);
+                tr_sessionLoadSettings (&settings, configDir, MY_NAME);
+                tr_sessionSet (mySession, &settings);
+                tr_bencFree (&settings);
+                tr_sessionReloadBlocklists (mySession);
             }
             break;
         }
 
         default:
-            tr_err( "Unexpected signal(%d) in daemon, closing.", sig);
+            tr_err ("Unexpected signal (%d) in daemon, closing.", sig);
             /* no break */
 
         case SIGINT:
@@ -186,44 +186,44 @@ gotsig( int sig )
     }
 }
 
-#if defined(WIN32)
+#if defined (WIN32)
  #define USE_NO_DAEMON
-#elif !defined(HAVE_DAEMON) || defined(__UCLIBC__)
+#elif !defined (HAVE_DAEMON) || defined (__UCLIBC__)
  #define USE_TR_DAEMON
 #else
  #define USE_OS_DAEMON
 #endif
 
 static int
-tr_daemon( int nochdir, int noclose )
+tr_daemon (int nochdir, int noclose)
 {
-#if defined(USE_OS_DAEMON)
+#if defined (USE_OS_DAEMON)
 
-    return daemon( nochdir, noclose );
+    return daemon (nochdir, noclose);
 
-#elif defined(USE_TR_DAEMON)
+#elif defined (USE_TR_DAEMON)
 
-    /* this is loosely based off of glibc's daemon() implementation
+    /* this is loosely based off of glibc's daemon () implementation
      * http://sourceware.org/git/?p=glibc.git;a=blob_plain;f=misc/daemon.c */
 
-    switch( fork( ) ) {
+    switch (fork ()) {
         case -1: return -1;
         case 0: break;
-        default: _exit(0);
+        default: _exit (0);
     }
 
-    if( setsid( ) == -1 )
+    if (setsid () == -1)
         return -1;
 
-    if( !nochdir )
-        chdir( "/" );
+    if (!nochdir)
+        chdir ("/");
 
-    if( !noclose ) {
-        int fd = open( "/dev/null", O_RDWR, 0 );
-        dup2( fd, STDIN_FILENO );
-        dup2( fd, STDOUT_FILENO );
-        dup2( fd, STDERR_FILENO );
-        close( fd );
+    if (!noclose) {
+        int fd = open ("/dev/null", O_RDWR, 0);
+        dup2 (fd, STDIN_FILENO);
+        dup2 (fd, STDOUT_FILENO);
+        dup2 (fd, STDERR_FILENO);
+        close (fd);
     }
 
     return 0;
@@ -234,15 +234,15 @@ tr_daemon( int nochdir, int noclose )
 }
 
 static const char*
-getConfigDir( int argc, const char ** argv )
+getConfigDir (int argc, const char ** argv)
 {
     int c;
     const char * configDir = NULL;
     const char * optarg;
     const int ind = tr_optind;
 
-    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg ))) {
-        if( c == 'g' ) {
+    while ((c = tr_getopt (getUsage (), argc, argv, options, &optarg))) {
+        if (c == 'g') {
             configDir = optarg;
             break;
         }
@@ -250,62 +250,62 @@ getConfigDir( int argc, const char ** argv )
 
     tr_optind = ind;
 
-    if( configDir == NULL )
-        configDir = tr_getDefaultConfigDir( MY_NAME );
+    if (configDir == NULL)
+        configDir = tr_getDefaultConfigDir (MY_NAME);
 
     return configDir;
 }
 
 static void
-onFileAdded( tr_session * session, const char * dir, const char * file )
+onFileAdded (tr_session * session, const char * dir, const char * file)
 {
-    char * filename = tr_buildPath( dir, file, NULL );
-    tr_ctor * ctor = tr_ctorNew( session );
-    int err = tr_ctorSetMetainfoFromFile( ctor, filename );
+    char * filename = tr_buildPath (dir, file, NULL);
+    tr_ctor * ctor = tr_ctorNew (session);
+    int err = tr_ctorSetMetainfoFromFile (ctor, filename);
 
-    if( !err )
+    if (!err)
     {
-        tr_torrentNew( ctor, &err );
+        tr_torrentNew (ctor, &err);
 
-        if( err == TR_PARSE_ERR )
-            tr_err( "Error parsing .torrent file \"%s\"", file );
+        if (err == TR_PARSE_ERR)
+            tr_err ("Error parsing .torrent file \"%s\"", file);
         else
         {
             bool trash = false;
-            int test = tr_ctorGetDeleteSource( ctor, &trash );
+            int test = tr_ctorGetDeleteSource (ctor, &trash);
 
-            tr_inf( "Parsing .torrent file successful \"%s\"", file );
+            tr_inf ("Parsing .torrent file successful \"%s\"", file);
 
-            if( !test && trash )
+            if (!test && trash)
             {
-                tr_inf( "Deleting input .torrent file \"%s\"", file );
-                if( remove( filename ) )
-                    tr_err( "Error deleting .torrent file: %s", tr_strerror( errno ) );
+                tr_inf ("Deleting input .torrent file \"%s\"", file);
+                if (remove (filename))
+                    tr_err ("Error deleting .torrent file: %s", tr_strerror (errno));
             }
             else
             {
-                char * new_filename = tr_strdup_printf( "%s.added", filename );
-                rename( filename, new_filename );
-                tr_free( new_filename );
+                char * new_filename = tr_strdup_printf ("%s.added", filename);
+                rename (filename, new_filename);
+                tr_free (new_filename);
             }
         }
     }
 
-    tr_ctorFree( ctor );
-    tr_free( filename );
+    tr_ctorFree (ctor);
+    tr_free (filename);
 }
 
 static void
-printMessage( FILE * logfile, int level, const char * name, const char * message, const char * file, int line )
+printMessage (FILE * logfile, int level, const char * name, const char * message, const char * file, int line)
 {
-    if( logfile != NULL )
+    if (logfile != NULL)
     {
         char timestr[64];
-        tr_getLogTimeStr( timestr, sizeof( timestr ) );
-        if( name )
-            fprintf( logfile, "[%s] %s %s (%s:%d)\n", timestr, name, message, file, line );
+        tr_getLogTimeStr (timestr, sizeof (timestr));
+        if (name)
+            fprintf (logfile, "[%s] %s %s (%s:%d)\n", timestr, name, message, file, line);
         else
-            fprintf( logfile, "[%s] %s (%s:%d)\n", timestr, message, file, line );
+            fprintf (logfile, "[%s] %s (%s:%d)\n", timestr, message, file, line);
     }
 #ifdef HAVE_SYSLOG
     else /* daemon... write to syslog */
@@ -313,48 +313,48 @@ printMessage( FILE * logfile, int level, const char * name, const char * message
         int priority;
 
         /* figure out the syslog priority */
-        switch( level ) {
+        switch (level) {
             case TR_MSG_ERR: priority = LOG_ERR; break;
             case TR_MSG_DBG: priority = LOG_DEBUG; break;
             default: priority = LOG_INFO; break;
         }
 
-        if( name )
-            syslog( priority, "%s %s (%s:%d)", name, message, file, line );
+        if (name)
+            syslog (priority, "%s %s (%s:%d)", name, message, file, line);
         else
-            syslog( priority, "%s (%s:%d)", message, file, line );
+            syslog (priority, "%s (%s:%d)", message, file, line);
     }
 #endif
 }
 
 static void
-pumpLogMessages( FILE * logfile )
+pumpLogMessages (FILE * logfile)
 {
     const tr_msg_list * l;
-    tr_msg_list * list = tr_getQueuedMessages( );
+    tr_msg_list * list = tr_getQueuedMessages ();
 
-    for( l=list; l!=NULL; l=l->next )
-        printMessage( logfile, l->level, l->name, l->message, l->file, l->line );
+    for (l=list; l!=NULL; l=l->next)
+        printMessage (logfile, l->level, l->name, l->message, l->file, l->line);
 
-    if( logfile != NULL )
-        fflush( logfile );
+    if (logfile != NULL)
+        fflush (logfile);
 
-    tr_freeMessageList( list );
+    tr_freeMessageList (list);
 }
 
 static tr_rpc_callback_status
-on_rpc_callback( tr_session            * session UNUSED,
+on_rpc_callback (tr_session            * session UNUSED,
                  tr_rpc_callback_type    type,
                  struct tr_torrent     * tor UNUSED,
-                 void                  * user_data UNUSED )
+                 void                  * user_data UNUSED)
 {
-    if( type == TR_RPC_SESSION_CLOSE )
+    if (type == TR_RPC_SESSION_CLOSE)
         closing = true;
     return TR_RPC_OK;
 }
 
 int
-main( int argc, char ** argv )
+main (int argc, char ** argv)
 {
     int c;
     const char * optarg;
@@ -369,235 +369,235 @@ main( int argc, char ** argv )
     bool pidfile_created = false;
     tr_session * session = NULL;
 
-    signal( SIGINT, gotsig );
-    signal( SIGTERM, gotsig );
+    signal (SIGINT, gotsig);
+    signal (SIGTERM, gotsig);
 #ifndef WIN32
-    signal( SIGHUP, gotsig );
+    signal (SIGHUP, gotsig);
 #endif
 
     /* load settings from defaults + config file */
-    tr_bencInitDict( &settings, 0 );
-    tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, true );
-    configDir = getConfigDir( argc, (const char**)argv );
-    loaded = tr_sessionLoadSettings( &settings, configDir, MY_NAME );
+    tr_bencInitDict (&settings, 0);
+    tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_ENABLED, true);
+    configDir = getConfigDir (argc, (const char**)argv);
+    loaded = tr_sessionLoadSettings (&settings, configDir, MY_NAME);
 
     /* overwrite settings from the comamndline */
     tr_optind = 1;
-    while(( c = tr_getopt( getUsage(), argc, (const char**)argv, options, &optarg ))) {
-        switch( c ) {
-            case 'a': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_WHITELIST, optarg );
-                      tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, true );
+    while ((c = tr_getopt (getUsage (), argc, (const char**)argv, options, &optarg))) {
+        switch (c) {
+            case 'a': tr_bencDictAddStr (&settings, TR_PREFS_KEY_RPC_WHITELIST, optarg);
+                      tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, true);
                       break;
-            case 'b': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, true );
+            case 'b': tr_bencDictAddBool (&settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, true);
                       break;
-            case 'B': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, false );
+            case 'B': tr_bencDictAddBool (&settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, false);
                       break;
-            case 'c': tr_bencDictAddStr( &settings, PREF_KEY_DIR_WATCH, optarg );
-                      tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, true );
+            case 'c': tr_bencDictAddStr (&settings, PREF_KEY_DIR_WATCH, optarg);
+                      tr_bencDictAddBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, true);
                       break;
-            case 'C': tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, false );
+            case 'C': tr_bencDictAddBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, false);
                       break;
-            case 941: tr_bencDictAddStr( &settings, TR_PREFS_KEY_INCOMPLETE_DIR, optarg );
-                      tr_bencDictAddBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true );
+            case 941: tr_bencDictAddStr (&settings, TR_PREFS_KEY_INCOMPLETE_DIR, optarg);
+                      tr_bencDictAddBool (&settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true);
                       break;
-            case 942: tr_bencDictAddBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false );
+            case 942: tr_bencDictAddBool (&settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false);
                       break;
             case 'd': dumpSettings = true;
                       break;
-            case 'e': logfile = fopen( optarg, LOGFILE_MODE_STR );
-                      if( logfile )
+            case 'e': logfile = fopen (optarg, LOGFILE_MODE_STR);
+                      if (logfile)
                           logfileName = optarg;
                       else
-                          fprintf( stderr, "Couldn't open \"%s\": %s\n", optarg, tr_strerror( errno ) );
+                          fprintf (stderr, "Couldn't open \"%s\": %s\n", optarg, tr_strerror (errno));
                       break;
             case 'f': foreground = true;
                       break;
             case 'g': /* handled above */
                       break;
             case 'V': /* version */
-                      fprintf(stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING);
-                      exit( 0 );
-            case 'o': tr_bencDictAddBool( &settings, TR_PREFS_KEY_DHT_ENABLED, true );
+                      fprintf (stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING);
+                      exit (0);
+            case 'o': tr_bencDictAddBool (&settings, TR_PREFS_KEY_DHT_ENABLED, true);
                       break;
-            case 'O': tr_bencDictAddBool( &settings, TR_PREFS_KEY_DHT_ENABLED, false );
+            case 'O': tr_bencDictAddBool (&settings, TR_PREFS_KEY_DHT_ENABLED, false);
                       break;
-            case 'p': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_PORT, atoi( optarg ) );
+            case 'p': tr_bencDictAddInt (&settings, TR_PREFS_KEY_RPC_PORT, atoi (optarg));
                       break;
-            case 't': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, true );
+            case 't': tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, true);
                       break;
-            case 'T': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, false );
+            case 'T': tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, false);
                       break;
-            case 'u': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_USERNAME, optarg );
+            case 'u': tr_bencDictAddStr (&settings, TR_PREFS_KEY_RPC_USERNAME, optarg);
                       break;
-            case 'v': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_PASSWORD, optarg );
+            case 'v': tr_bencDictAddStr (&settings, TR_PREFS_KEY_RPC_PASSWORD, optarg);
                       break;
-            case 'w': tr_bencDictAddStr( &settings, TR_PREFS_KEY_DOWNLOAD_DIR, optarg );
+            case 'w': tr_bencDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);
                       break;
-            case 'P': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_PORT, atoi( optarg ) );
+            case 'P': tr_bencDictAddInt (&settings, TR_PREFS_KEY_PEER_PORT, atoi (optarg));
                       break;
-            case 'm': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, true );
+            case 'm': tr_bencDictAddBool (&settings, TR_PREFS_KEY_PORT_FORWARDING, true);
                       break;
-            case 'M': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, false );
+            case 'M': tr_bencDictAddBool (&settings, TR_PREFS_KEY_PORT_FORWARDING, false);
                       break;
-            case 'L': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi( optarg ) );
+            case 'L': tr_bencDictAddInt (&settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi (optarg));
                       break;
-            case 'l': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi( optarg ) );
+            case 'l': tr_bencDictAddInt (&settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi (optarg));
                       break;
             case 800: paused = true;
                       break;
-            case 910: tr_bencDictAddInt( &settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED );
+            case 910: tr_bencDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);
                       break;
-            case 911: tr_bencDictAddInt( &settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED );
+            case 911: tr_bencDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);
                       break;
-            case 912: tr_bencDictAddInt( &settings, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED );
+            case 912: tr_bencDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);
                       break;
-            case 'i': tr_bencDictAddStr( &settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, optarg );
+            case 'i': tr_bencDictAddStr (&settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, optarg);
                       break;
-            case 'I': tr_bencDictAddStr( &settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, optarg );
+            case 'I': tr_bencDictAddStr (&settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, optarg);
                       break;
-            case 'r': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_BIND_ADDRESS, optarg );
+            case 'r': tr_bencDictAddStr (&settings, TR_PREFS_KEY_RPC_BIND_ADDRESS, optarg);
                       break;
-            case 953: tr_bencDictAddReal( &settings, TR_PREFS_KEY_RATIO, atof(optarg) );
-                      tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, true );
+            case 953: tr_bencDictAddReal (&settings, TR_PREFS_KEY_RATIO, atof (optarg));
+                      tr_bencDictAddBool (&settings, TR_PREFS_KEY_RATIO_ENABLED, true);
                       break;
-            case 954: tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, false );
+            case 954: tr_bencDictAddBool (&settings, TR_PREFS_KEY_RATIO_ENABLED, false);
                       break;
-            case 'x': tr_bencDictAddStr( &settings, PREF_KEY_PIDFILE, optarg );
+            case 'x': tr_bencDictAddStr (&settings, PREF_KEY_PIDFILE, optarg);
                       break;
-            case 'y': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, true );
+            case 'y': tr_bencDictAddBool (&settings, TR_PREFS_KEY_LPD_ENABLED, true);
                       break;
-            case 'Y': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, false );
+            case 'Y': tr_bencDictAddBool (&settings, TR_PREFS_KEY_LPD_ENABLED, false);
                       break;
-            case 810: tr_bencDictAddInt( &settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_ERR );
+            case 810: tr_bencDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_ERR);
                       break;
-            case 811: tr_bencDictAddInt( &settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF );
+            case 811: tr_bencDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF);
                       break;
-            case 812: tr_bencDictAddInt( &settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_DBG );
+            case 812: tr_bencDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_DBG);
                       break;
-            case 830: tr_bencDictAddBool( &settings, TR_PREFS_KEY_UTP_ENABLED, true );
+            case 830: tr_bencDictAddBool (&settings, TR_PREFS_KEY_UTP_ENABLED, true);
                       break;
-            case 831: tr_bencDictAddBool( &settings, TR_PREFS_KEY_UTP_ENABLED, false );
+            case 831: tr_bencDictAddBool (&settings, TR_PREFS_KEY_UTP_ENABLED, false);
                       break;
-            default:  showUsage( );
+            default:  showUsage ();
                       break;
         }
     }
 
-    if( foreground && !logfile )
+    if (foreground && !logfile)
         logfile = stderr;
 
-    if( !loaded )
+    if (!loaded)
     {
-        printMessage( logfile, TR_MSG_ERR, MY_NAME, "Error loading config file -- exiting.", __FILE__, __LINE__ );
+        printMessage (logfile, TR_MSG_ERR, MY_NAME, "Error loading config file -- exiting.", __FILE__, __LINE__);
         return -1;
     }
 
-    if( dumpSettings )
+    if (dumpSettings)
     {
-        char * str = tr_bencToStr( &settings, TR_FMT_JSON, NULL );
-        fprintf( stderr, "%s", str );
-        tr_free( str );
+        char * str = tr_bencToStr (&settings, TR_FMT_JSON, NULL);
+        fprintf (stderr, "%s", str);
+        tr_free (str);
         return 0;
     }
 
-    if( !foreground && tr_daemon( true, false ) < 0 )
+    if (!foreground && tr_daemon (true, false) < 0)
     {
         char buf[256];
-        tr_snprintf( buf, sizeof( buf ), "Failed to daemonize: %s", tr_strerror( errno ) );
-        printMessage( logfile, TR_MSG_ERR, MY_NAME, buf, __FILE__, __LINE__ );
-        exit( 1 );
+        tr_snprintf (buf, sizeof (buf), "Failed to daemonize: %s", tr_strerror (errno));
+        printMessage (logfile, TR_MSG_ERR, MY_NAME, buf, __FILE__, __LINE__);
+        exit (1);
     }
 
     /* start the session */
-    tr_formatter_mem_init( MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR );
-    tr_formatter_size_init( DISK_K, DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR );
-    tr_formatter_speed_init( SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR );
-    session = tr_sessionInit( "daemon", configDir, true, &settings );
-    tr_sessionSetRPCCallback( session, on_rpc_callback, NULL );
-    tr_ninf( NULL, "Using settings from \"%s\"", configDir );
-    tr_sessionSaveSettings( session, configDir, &settings );
+    tr_formatter_mem_init (MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR);
+    tr_formatter_size_init (DISK_K, DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR);
+    tr_formatter_speed_init (SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR);
+    session = tr_sessionInit ("daemon", configDir, true, &settings);
+    tr_sessionSetRPCCallback (session, on_rpc_callback, NULL);
+    tr_ninf (NULL, "Using settings from \"%s\"", configDir);
+    tr_sessionSaveSettings (session, configDir, &settings);
 
     pid_filename = NULL;
-    tr_bencDictFindStr( &settings, PREF_KEY_PIDFILE, &pid_filename );
-    if( pid_filename && *pid_filename )
+    tr_bencDictFindStr (&settings, PREF_KEY_PIDFILE, &pid_filename);
+    if (pid_filename && *pid_filename)
     {
-        FILE * fp = fopen( pid_filename, "w+" );
-        if( fp != NULL )
+        FILE * fp = fopen (pid_filename, "w+");
+        if (fp != NULL)
         {
-            fprintf( fp, "%d", (int)getpid() );
-            fclose( fp );
-            tr_inf( "Saved pidfile \"%s\"", pid_filename );
+            fprintf (fp, "%d", (int)getpid ());
+            fclose (fp);
+            tr_inf ("Saved pidfile \"%s\"", pid_filename);
             pidfile_created = true;
         }
         else
-            tr_err( "Unable to save pidfile \"%s\": %s", pid_filename, tr_strerror( errno ) );
+            tr_err ("Unable to save pidfile \"%s\": %s", pid_filename, tr_strerror (errno));
     }
 
-    if( tr_bencDictFindBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal ) && boolVal )
-        tr_ninf( MY_NAME, "requiring authentication" );
+    if (tr_bencDictFindBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal) && boolVal)
+        tr_ninf (MY_NAME, "requiring authentication");
 
     mySession = session;
 
     /* If we got a SIGHUP during startup, process that now. */
-    if( seenHUP )
-        gotsig( SIGHUP );
+    if (seenHUP)
+        gotsig (SIGHUP);
 
     /* maybe add a watchdir */
     {
         const char * dir;
 
-        if( tr_bencDictFindBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal )
+        if (tr_bencDictFindBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal)
             && boolVal
-            && tr_bencDictFindStr( &settings, PREF_KEY_DIR_WATCH, &dir )
+            && tr_bencDictFindStr (&settings, PREF_KEY_DIR_WATCH, &dir)
             && dir
-            && *dir )
+            && *dir)
         {
-            tr_inf( "Watching \"%s\" for new .torrent files", dir );
-            watchdir = dtr_watchdir_new( mySession, dir, onFileAdded );
+            tr_inf ("Watching \"%s\" for new .torrent files", dir);
+            watchdir = dtr_watchdir_new (mySession, dir, onFileAdded);
         }
     }
 
     /* load the torrents */
     {
         tr_torrent ** torrents;
-        tr_ctor * ctor = tr_ctorNew( mySession );
-        if( paused )
-            tr_ctorSetPaused( ctor, TR_FORCE, true );
-        torrents = tr_sessionLoadTorrents( mySession, ctor, NULL );
-        tr_free( torrents );
-        tr_ctorFree( ctor );
+        tr_ctor * ctor = tr_ctorNew (mySession);
+        if (paused)
+            tr_ctorSetPaused (ctor, TR_FORCE, true);
+        torrents = tr_sessionLoadTorrents (mySession, ctor, NULL);
+        tr_free (torrents);
+        tr_ctorFree (ctor);
     }
 
 #ifdef HAVE_SYSLOG
-    if( !foreground )
-        openlog( MY_NAME, LOG_CONS|LOG_PID, LOG_DAEMON );
+    if (!foreground)
+        openlog (MY_NAME, LOG_CONS|LOG_PID, LOG_DAEMON);
 #endif
 
-    while( !closing ) {
-        tr_wait_msec( 1000 ); /* sleep one second */
-        dtr_watchdir_update( watchdir );
-        pumpLogMessages( logfile );
+    while (!closing) {
+        tr_wait_msec (1000); /* sleep one second */
+        dtr_watchdir_update (watchdir);
+        pumpLogMessages (logfile);
     }
 
-    printf( "Closing transmission session..." );
-    tr_sessionSaveSettings( mySession, configDir, &settings );
-    dtr_watchdir_free( watchdir );
-    tr_sessionClose( mySession );
-    pumpLogMessages( logfile );
-    printf( " done.\n" );
+    printf ("Closing transmission session...");
+    tr_sessionSaveSettings (mySession, configDir, &settings);
+    dtr_watchdir_free (watchdir);
+    tr_sessionClose (mySession);
+    pumpLogMessages (logfile);
+    printf (" done.\n");
 
     /* shutdown */
 #if HAVE_SYSLOG
-    if( !foreground )
+    if (!foreground)
     {
-        syslog( LOG_INFO, "%s", "Closing session" );
-        closelog( );
+        syslog (LOG_INFO, "%s", "Closing session");
+        closelog ();
     }
 #endif
 
     /* cleanup */
-    if( pidfile_created )
-        remove( pid_filename );
-    tr_bencFree( &settings );
+    if (pidfile_created)
+        remove (pid_filename);
+    tr_bencFree (&settings);
     return 0;
 }
diff --git a/daemon/remote.c b/daemon/remote.c
index fbc0e1586..ce8d5cc35 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -39,7 +39,7 @@
 
 #define MY_NAME "transmission-remote"
 #define DEFAULT_HOST "localhost"
-#define DEFAULT_PORT atoi(TR_DEFAULT_RPC_PORT_STR)
+#define DEFAULT_PORT atoi (TR_DEFAULT_RPC_PORT_STR)
 #define DEFAULT_URL TR_DEFAULT_RPC_URL_STR "rpc/"
 
 #define ARGUMENTS "arguments"
@@ -72,115 +72,115 @@
 ***/
 
 static void
-etaToString( char *  buf, size_t  buflen, int64_t eta )
+etaToString (char *  buf, size_t  buflen, int64_t eta)
 {
-    if( eta < 0 )
-        tr_snprintf( buf, buflen, "Unknown" );
-    else if( eta < 60 )
-        tr_snprintf( buf, buflen, "%" PRId64 " sec", eta );
-    else if( eta < ( 60 * 60 ) )
-        tr_snprintf( buf, buflen, "%" PRId64 " min", eta / 60 );
-    else if( eta < ( 60 * 60 * 24 ) )
-        tr_snprintf( buf, buflen, "%" PRId64 " hrs", eta / ( 60 * 60 ) );
+    if (eta < 0)
+        tr_snprintf (buf, buflen, "Unknown");
+    else if (eta < 60)
+        tr_snprintf (buf, buflen, "%" PRId64 " sec", eta);
+    else if (eta < (60 * 60))
+        tr_snprintf (buf, buflen, "%" PRId64 " min", eta / 60);
+    else if (eta < (60 * 60 * 24))
+        tr_snprintf (buf, buflen, "%" PRId64 " hrs", eta / (60 * 60));
     else
-        tr_snprintf( buf, buflen, "%" PRId64 " days", eta / ( 60 * 60 * 24 ) );
+        tr_snprintf (buf, buflen, "%" PRId64 " days", eta / (60 * 60 * 24));
 }
 
 static char*
-tr_strltime( char * buf, int seconds, size_t buflen )
+tr_strltime (char * buf, int seconds, size_t buflen)
 {
     int  days, hours, minutes, total_seconds;
     char b[128], d[128], h[128], m[128], s[128], t[128];
 
-    if( seconds < 0 )
+    if (seconds < 0)
         seconds = 0;
 
     total_seconds = seconds;
     days = seconds / 86400;
-    hours = ( seconds % 86400 ) / 3600;
-    minutes = ( seconds % 3600 ) / 60;
-    seconds = ( seconds % 3600 ) % 60;
+    hours = (seconds % 86400) / 3600;
+    minutes = (seconds % 3600) / 60;
+    seconds = (seconds % 3600) % 60;
 
-    tr_snprintf( d, sizeof( d ), "%d %s", days, days==1?"day":"days" );
-    tr_snprintf( h, sizeof( h ), "%d %s", hours, hours==1?"hour":"hours" );
-    tr_snprintf( m, sizeof( m ), "%d %s", minutes, minutes==1?"minute":"minutes" );
-    tr_snprintf( s, sizeof( s ), "%d %s", seconds, seconds==1?"second":"seconds" );
-    tr_snprintf( t, sizeof( t ), "%d %s", total_seconds, total_seconds==1?"second":"seconds" );
+    tr_snprintf (d, sizeof (d), "%d %s", days, days==1?"day":"days");
+    tr_snprintf (h, sizeof (h), "%d %s", hours, hours==1?"hour":"hours");
+    tr_snprintf (m, sizeof (m), "%d %s", minutes, minutes==1?"minute":"minutes");
+    tr_snprintf (s, sizeof (s), "%d %s", seconds, seconds==1?"second":"seconds");
+    tr_snprintf (t, sizeof (t), "%d %s", total_seconds, total_seconds==1?"second":"seconds");
 
-    if( days )
+    if (days)
     {
-        if( days >= 4 || !hours )
-            tr_strlcpy( b, d, sizeof( b ) );
+        if (days >= 4 || !hours)
+            tr_strlcpy (b, d, sizeof (b));
         else
-            tr_snprintf( b, sizeof( b ), "%s, %s", d, h );
+            tr_snprintf (b, sizeof (b), "%s, %s", d, h);
     }
-    else if( hours )
+    else if (hours)
     {
-        if( hours >= 4 || !minutes )
-            tr_strlcpy( b, h, sizeof( b ) );
+        if (hours >= 4 || !minutes)
+            tr_strlcpy (b, h, sizeof (b));
         else
-            tr_snprintf( b, sizeof( b ), "%s, %s", h, m );
+            tr_snprintf (b, sizeof (b), "%s, %s", h, m);
     }
-    else if( minutes )
+    else if (minutes)
     {
-        if( minutes >= 4 || !seconds )
-            tr_strlcpy( b, m, sizeof( b ) );
+        if (minutes >= 4 || !seconds)
+            tr_strlcpy (b, m, sizeof (b));
         else
-            tr_snprintf( b, sizeof( b ), "%s, %s", m, s );
+            tr_snprintf (b, sizeof (b), "%s, %s", m, s);
     }
-    else tr_strlcpy( b, s, sizeof( b ) );
+    else tr_strlcpy (b, s, sizeof (b));
 
-    tr_snprintf( buf, buflen, "%s (%s)", b, t );
+    tr_snprintf (buf, buflen, "%s (%s)", b, t);
     return buf;
 }
 
 static char*
-strlpercent( char * buf, double x, size_t buflen )
+strlpercent (char * buf, double x, size_t buflen)
 {
-    return tr_strpercent( buf, x, buflen );
+    return tr_strpercent (buf, x, buflen);
 }
 
 static char*
-strlratio2( char * buf, double ratio, size_t buflen )
+strlratio2 (char * buf, double ratio, size_t buflen)
 {
-    return tr_strratio( buf, buflen, ratio, "Inf" );
+    return tr_strratio (buf, buflen, ratio, "Inf");
 }
 
 static char*
-strlratio( char * buf, int64_t numerator, int64_t denominator, size_t buflen )
+strlratio (char * buf, int64_t numerator, int64_t denominator, size_t buflen)
 {
     double ratio;
 
-    if( denominator != 0 )
+    if (denominator != 0)
         ratio = numerator / (double)denominator;
-    else if( numerator != 0 )
+    else if (numerator != 0)
         ratio = TR_RATIO_INF;
     else
         ratio = TR_RATIO_NA;
 
-    return strlratio2( buf, ratio, buflen );
+    return strlratio2 (buf, ratio, buflen);
 }
 
 static char*
-strlmem( char * buf, int64_t bytes, size_t buflen )
+strlmem (char * buf, int64_t bytes, size_t buflen)
 {
-    if( !bytes )
-        tr_strlcpy( buf, "None", buflen );
+    if (!bytes)
+        tr_strlcpy (buf, "None", buflen);
     else
-        tr_formatter_mem_B( buf, bytes, buflen );
+        tr_formatter_mem_B (buf, bytes, buflen);
 
     return buf;
 }
 
 static char*
-strlsize( char * buf, int64_t bytes, size_t buflen )
+strlsize (char * buf, int64_t bytes, size_t buflen)
 {
-    if( bytes < 0 )
-        tr_strlcpy( buf, "Unknown", buflen );
-    else if( bytes == 0 )
-        tr_strlcpy( buf, "None", buflen );
+    if (bytes < 0)
+        tr_strlcpy (buf, "Unknown", buflen);
+    else if (bytes == 0)
+        tr_strlcpy (buf, "None", buflen);
     else
-        tr_formatter_size_B( buf, bytes, buflen );
+        tr_formatter_size_B (buf, bytes, buflen);
 
     return buf;
 }
@@ -200,7 +200,7 @@ enum
 };
 
 static const char*
-getUsage( void )
+getUsage (void)
 {
     return
         MY_NAME" "LONG_VERSION_STRING"\n"
@@ -214,7 +214,7 @@ getUsage( void )
                 "       "
         MY_NAME " [host:port] [options]\n"
                 "       "
-        MY_NAME " [http(s?)://host:port/transmission/] [options]\n"
+        MY_NAME " [http (s?)://host:port/transmission/] [options]\n"
                 "\n"
                 "See the man page for detailed explanations and many examples.";
 }
@@ -241,21 +241,21 @@ static tr_option opts[] =
     { 'c', "incomplete-dir",         "Where to store new torrents until they're complete", "c", 1, "<dir>" },
     { 'C', "no-incomplete-dir",      "Don't store incomplete torrents in a different location", "C", 0, NULL },
     { 'b', "debug",                  "Print debugging information", "b",  0, NULL },
-    { 'd', "downlimit",              "Set the max download speed in "SPEED_K_STR" for the current torrent(s) or globally", "d", 1, "<speed>" },
-    { 'D', "no-downlimit",           "Disable max download speed for the current torrent(s) or globally", "D", 0, NULL },
+    { 'd', "downlimit",              "Set the max download speed in "SPEED_K_STR" for the current torrent (s) or globally", "d", 1, "<speed>" },
+    { 'D', "no-downlimit",           "Disable max download speed for the current torrent (s) or globally", "D", 0, NULL },
     { 'e', "cache",                  "Set the maximum size of the session's memory cache (in " MEM_M_STR ")", "e", 1, "<size>" },
     { 910, "encryption-required",    "Encrypt all peer connections", "er", 0, NULL },
     { 911, "encryption-preferred",   "Prefer encrypted peer connections", "ep", 0, NULL },
     { 912, "encryption-tolerated",   "Prefer unencrypted peer connections", "et", 0, NULL },
     { 850, "exit",                   "Tell the transmission session to shut down", NULL, 0, NULL },
-    { 940, "files",                  "List the current torrent(s)' files", "f",  0, NULL },
+    { 940, "files",                  "List the current torrent (s)' files", "f",  0, NULL },
     { 'g', "get",                    "Mark files for download", "g",  1, "<files>" },
     { 'G', "no-get",                 "Mark files for not downloading", "G",  1, "<files>" },
-    { 'i', "info",                   "Show the current torrent(s)' details", "i",  0, NULL },
-    { 940, "info-files",             "List the current torrent(s)' files", "if",  0, NULL },
-    { 941, "info-peers",             "List the current torrent(s)' peers", "ip",  0, NULL },
-    { 942, "info-pieces",            "List the current torrent(s)' pieces", "ic",  0, NULL },
-    { 943, "info-trackers",          "List the current torrent(s)' trackers", "it",  0, NULL },
+    { 'i', "info",                   "Show the current torrent (s)' details", "i",  0, NULL },
+    { 940, "info-files",             "List the current torrent (s)' files", "if",  0, NULL },
+    { 941, "info-peers",             "List the current torrent (s)' peers", "ip",  0, NULL },
+    { 942, "info-pieces",            "List the current torrent (s)' pieces", "ic",  0, NULL },
+    { 943, "info-trackers",          "List the current torrent (s)' trackers", "it",  0, NULL },
     { 920, "session-info",           "Show the session's details", "si", 0, NULL },
     { 921, "session-stats",          "Show the session's statistics", "st", 0, NULL },
     { 'l', "list",                   "List all torrents", "l",  0, NULL },
@@ -272,66 +272,66 @@ static tr_option opts[] =
     { 'p', "port",                   "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")", "p", 1, "<port>" },
     { 962, "port-test",              "Port testing", "pt", 0, NULL },
     { 'P', "random-port",            "Random port for incomping peers", "P", 0, NULL },
-    { 900, "priority-high",          "Try to download these file(s) first", "ph", 1, "<files>" },
-    { 901, "priority-normal",        "Try to download these file(s) normally", "pn", 1, "<files>" },
-    { 902, "priority-low",           "Try to download these file(s) last", "pl", 1, "<files>" },
+    { 900, "priority-high",          "Try to download these file (s) first", "ph", 1, "<files>" },
+    { 901, "priority-normal",        "Try to download these file (s) normally", "pn", 1, "<files>" },
+    { 902, "priority-low",           "Try to download these file (s) last", "pl", 1, "<files>" },
     { 700, "bandwidth-high",         "Give this torrent first chance at available bandwidth", "Bh", 0, NULL },
     { 701, "bandwidth-normal",       "Give this torrent bandwidth left over by high priority torrents", "Bn", 0, NULL },
     { 702, "bandwidth-low",          "Give this torrent bandwidth left over by high and normal priority torrents", "Bl", 0, NULL },
-    { 600, "reannounce",             "Reannounce the current torrent(s)", NULL,  0, NULL },
-    { 'r', "remove",                 "Remove the current torrent(s)", "r",  0, NULL },
-    { 930, "peers",                  "Set the maximum number of peers for the current torrent(s) or globally", "pr", 1, "<max>" },
-    { 'R', "remove-and-delete",      "Remove the current torrent(s) and delete local data", NULL, 0, NULL },
+    { 600, "reannounce",             "Reannounce the current torrent (s)", NULL,  0, NULL },
+    { 'r', "remove",                 "Remove the current torrent (s)", "r",  0, NULL },
+    { 930, "peers",                  "Set the maximum number of peers for the current torrent (s) or globally", "pr", 1, "<max>" },
+    { 'R', "remove-and-delete",      "Remove the current torrent (s) and delete local data", NULL, 0, NULL },
     { 800, "torrent-done-script",    "Specify a script to run when a torrent finishes", NULL, 1, "<file>" },
     { 801, "no-torrent-done-script", "Don't run a script when torrents finish", NULL, 0, NULL },
-    { 950, "seedratio",              "Let the current torrent(s) seed until a specific ratio", "sr", 1, "ratio" },
-    { 951, "seedratio-default",      "Let the current torrent(s) use the global seedratio settings", "srd", 0, NULL },
-    { 952, "no-seedratio",           "Let the current torrent(s) seed regardless of ratio", "SR", 0, NULL },
+    { 950, "seedratio",              "Let the current torrent (s) seed until a specific ratio", "sr", 1, "ratio" },
+    { 951, "seedratio-default",      "Let the current torrent (s) use the global seedratio settings", "srd", 0, NULL },
+    { 952, "no-seedratio",           "Let the current torrent (s) seed regardless of ratio", "SR", 0, NULL },
     { 953, "global-seedratio",       "All torrents, unless overridden by a per-torrent setting, should seed until a specific ratio", "gsr", 1, "ratio" },
     { 954, "no-global-seedratio",    "All torrents, unless overridden by a per-torrent setting, should seed regardless of ratio", "GSR", 0, NULL },
     { 710, "tracker-add",            "Add a tracker to a torrent", "td", 1, "<tracker>" },
     { 712, "tracker-remove",         "Remove a tracker from a torrent", "tr", 1, "<trackerId>" },
-    { 's', "start",                  "Start the current torrent(s)", "s",  0, NULL },
-    { 'S', "stop",                   "Stop the current torrent(s)", "S",  0, NULL },
-    { 't', "torrent",                "Set the current torrent(s)", "t",  1, "<torrent>" },
+    { 's', "start",                  "Start the current torrent (s)", "s",  0, NULL },
+    { 'S', "stop",                   "Stop the current torrent (s)", "S",  0, NULL },
+    { 't', "torrent",                "Set the current torrent (s)", "t",  1, "<torrent>" },
     { 990, "start-paused",           "Start added torrents paused", NULL, 0, NULL },
     { 991, "no-start-paused",        "Start added torrents unpaused", NULL, 0, NULL },
     { 992, "trash-torrent",          "Delete torrents after adding", NULL, 0, NULL },
     { 993, "no-trash-torrent",       "Do not delete torrents after adding", NULL, 0, NULL },
-    { 984, "honor-session",          "Make the current torrent(s) honor the session limits", "hl",  0, NULL },
-    { 985, "no-honor-session",       "Make the current torrent(s) not honor the session limits", "HL",  0, NULL },
-    { 'u', "uplimit",                "Set the max upload speed in "SPEED_K_STR" for the current torrent(s) or globally", "u", 1, "<speed>" },
-    { 'U', "no-uplimit",             "Disable max upload speed for the current torrent(s) or globally", "U", 0, NULL },
+    { 984, "honor-session",          "Make the current torrent (s) honor the session limits", "hl",  0, NULL },
+    { 985, "no-honor-session",       "Make the current torrent (s) not honor the session limits", "HL",  0, NULL },
+    { 'u', "uplimit",                "Set the max upload speed in "SPEED_K_STR" for the current torrent (s) or globally", "u", 1, "<speed>" },
+    { 'U', "no-uplimit",             "Disable max upload speed for the current torrent (s) or globally", "U", 0, NULL },
     { 830, "utp",                    "Enable uTP for peer connections", NULL, 0, NULL },
     { 831, "no-utp",                 "Disable uTP for peer connections", NULL, 0, NULL },
-    { 'v', "verify",                 "Verify the current torrent(s)", "v",  0, NULL },
+    { 'v', "verify",                 "Verify the current torrent (s)", "v",  0, NULL },
     { 'V', "version",                "Show version number and exit", "V", 0, NULL },
     { 'w', "download-dir",           "When adding a new torrent, set its download folder. Otherwise, set the default download folder", "w",  1, "<path>" },
     { 'x', "pex",                    "Enable peer exchange (PEX)", "x",  0, NULL },
     { 'X', "no-pex",                 "Disable peer exchange (PEX)", "X",  0, NULL },
     { 'y', "lpd",                    "Enable local peer discovery (LPD)", "y",  0, NULL },
     { 'Y', "no-lpd",                 "Disable local peer discovery (LPD)", "Y",  0, NULL },
-    { 941, "peer-info",              "List the current torrent(s)' peers", "pi",  0, NULL },
+    { 941, "peer-info",              "List the current torrent (s)' peers", "pi",  0, NULL },
     {   0, NULL,                     NULL, NULL, 0, NULL }
 };
 
 static void
-showUsage( void )
+showUsage (void)
 {
-    tr_getopt_usage( MY_NAME, getUsage( ), opts );
+    tr_getopt_usage (MY_NAME, getUsage (), opts);
 }
 
 static int
-numarg( const char * arg )
+numarg (const char * arg)
 {
     char *     end = NULL;
-    const long num = strtol( arg, &end, 10 );
+    const long num = strtol (arg, &end, 10);
 
-    if( *end )
+    if (*end)
     {
-        fprintf( stderr, "Not a number: \"%s\"\n", arg );
-        showUsage( );
-        exit( EXIT_FAILURE );
+        fprintf (stderr, "Not a number: \"%s\"\n", arg);
+        showUsage ();
+        exit (EXIT_FAILURE);
     }
     return num;
 }
@@ -356,9 +356,9 @@ enum
 };
 
 static int
-getOptMode( int val )
+getOptMode (int val)
 {
-    switch( val )
+    switch (val)
     {
         case TR_OPT_ERR:
         case TR_OPT_UNK:
@@ -484,8 +484,8 @@ getOptMode( int val )
             return MODE_TORRENT_SET_LOCATION;
 
         default:
-            fprintf( stderr, "unrecognized argument %d\n", val );
-            assert( "unrecognized argument" && 0 );
+            fprintf (stderr, "unrecognized argument %d\n", val);
+            assert ("unrecognized argument" && 0);
             return 0;
     }
 }
@@ -497,155 +497,155 @@ static char * sessionId = NULL;
 static bool UseSSL = false;
 
 static char*
-tr_getcwd( void )
+tr_getcwd (void)
 {
     char * result;
     char buf[2048];
 #ifdef WIN32
-    result = _getcwd( buf, sizeof( buf ) );
+    result = _getcwd (buf, sizeof (buf));
 #else
-    result = getcwd( buf, sizeof( buf ) );
+    result = getcwd (buf, sizeof (buf));
 #endif
-    if( result == NULL )
+    if (result == NULL)
     {
-        fprintf( stderr, "getcwd error: \"%s\"", tr_strerror( errno ) );
+        fprintf (stderr, "getcwd error: \"%s\"", tr_strerror (errno));
         *buf = '\0';
     }
-    return tr_strdup( buf );
+    return tr_strdup (buf);
 }
 
 static char*
-absolutify( const char * path )
+absolutify (const char * path)
 {
     char * buf;
 
-    if( *path == '/' )
-        buf = tr_strdup( path );
+    if (*path == '/')
+        buf = tr_strdup (path);
     else {
-        char * cwd = tr_getcwd( );
-        buf = tr_buildPath( cwd, path, NULL );
-        tr_free( cwd );
+        char * cwd = tr_getcwd ();
+        buf = tr_buildPath (cwd, path, NULL);
+        tr_free (cwd);
     }
 
     return buf;
 }
 
 static char*
-getEncodedMetainfo( const char * filename )
+getEncodedMetainfo (const char * filename)
 {
     size_t    len = 0;
     char *    b64 = NULL;
-    uint8_t * buf = tr_loadFile( filename, &len );
+    uint8_t * buf = tr_loadFile (filename, &len);
 
-    if( buf )
+    if (buf)
     {
-        b64 = tr_base64_encode( buf, len, NULL );
-        tr_free( buf );
+        b64 = tr_base64_encode (buf, len, NULL);
+        tr_free (buf);
     }
     return b64;
 }
 
 static void
-addIdArg( tr_benc * args, const char * id )
+addIdArg (tr_benc * args, const char * id)
 {
-    if( !*id )
+    if (!*id)
     {
-        fprintf(
+        fprintf (
             stderr,
-            "No torrent specified!  Please use the -t option first.\n" );
+            "No torrent specified!  Please use the -t option first.\n");
         id = "-1"; /* no torrent will have this ID, so should be a no-op */
     }
-    if( strcmp( id, "all" ) )
+    if (strcmp (id, "all"))
     {
         const char * pch;
-        bool isList = strchr(id,',') || strchr(id,'-');
+        bool isList = strchr (id,',') || strchr (id,'-');
         bool isNum = true;
-        for( pch=id; isNum && *pch; ++pch )
-            if( !isdigit( *pch ) )
+        for (pch=id; isNum && *pch; ++pch)
+            if (!isdigit (*pch))
                 isNum = false;
-        if( isNum || isList )
-            tr_rpc_parse_list_str( tr_bencDictAdd( args, "ids" ), id, strlen( id ) );
+        if (isNum || isList)
+            tr_rpc_parse_list_str (tr_bencDictAdd (args, "ids"), id, strlen (id));
         else
-            tr_bencDictAddStr( args, "ids", id ); /* it's a torrent sha hash */
+            tr_bencDictAddStr (args, "ids", id); /* it's a torrent sha hash */
     }
 }
 
 static void
-addTime( tr_benc * args, const char * key, const char * arg )
+addTime (tr_benc * args, const char * key, const char * arg)
 {
     int time;
     bool success = false;
 
-    if( arg && ( strlen( arg ) == 4 ) )
+    if (arg && (strlen (arg) == 4))
     {
         const char hh[3] = { arg[0], arg[1], '\0' };
         const char mm[3] = { arg[2], arg[3], '\0' };
-        const int hour = atoi( hh );
-        const int min = atoi( mm );
+        const int hour = atoi (hh);
+        const int min = atoi (mm);
 
-        if( 0<=hour && hour<24 && 0<=min && min<60 )
+        if (0<=hour && hour<24 && 0<=min && min<60)
         {
-            time = min + ( hour * 60 );
+            time = min + (hour * 60);
             success = true;
         }
     }
 
-    if( success )
-        tr_bencDictAddInt( args, key, time );
+    if (success)
+        tr_bencDictAddInt (args, key, time);
     else
-        fprintf( stderr, "Please specify the time of day in 'hhmm' format.\n" );
+        fprintf (stderr, "Please specify the time of day in 'hhmm' format.\n");
 }
 
 static void
-addDays( tr_benc * args, const char * key, const char * arg )
+addDays (tr_benc * args, const char * key, const char * arg)
 {
     int days = 0;
 
-    if( arg )
+    if (arg)
     {
         int i;
         int valueCount;
-        int * values = tr_parseNumberRange( arg, -1, &valueCount );
-        for( i=0; i<valueCount; ++i )
+        int * values = tr_parseNumberRange (arg, -1, &valueCount);
+        for (i=0; i<valueCount; ++i)
         {
-            if ( values[i] < 0 || values[i] > 7 ) continue;
-            if ( values[i] == 7 ) values[i] = 0;
+            if (values[i] < 0 || values[i] > 7) continue;
+            if (values[i] == 7) values[i] = 0;
 
             days |= 1 << values[i];
         }
-        tr_free( values );
+        tr_free (values);
     }
 
-    if ( days )
-        tr_bencDictAddInt( args, key, days );
+    if (days)
+        tr_bencDictAddInt (args, key, days);
     else
-        fprintf( stderr, "Please specify the days of the week in '1-3,4,7' format.\n" );
+        fprintf (stderr, "Please specify the days of the week in '1-3,4,7' format.\n");
 }
 
 static void
-addFiles( tr_benc *    args,
+addFiles (tr_benc *    args,
           const char * key,
-          const char * arg )
+          const char * arg)
 {
-    tr_benc * files = tr_bencDictAddList( args, key, 100 );
+    tr_benc * files = tr_bencDictAddList (args, key, 100);
 
-    if( !*arg )
+    if (!*arg)
     {
-        fprintf( stderr, "No files specified!\n" );
+        fprintf (stderr, "No files specified!\n");
         arg = "-1"; /* no file will have this index, so should be a no-op */
     }
-    if( strcmp( arg, "all" ) )
+    if (strcmp (arg, "all"))
     {
         int i;
         int valueCount;
-        int * values = tr_parseNumberRange( arg, -1, &valueCount );
-        for( i=0; i<valueCount; ++i )
-            tr_bencListAddInt( files, values[i] );
-        tr_free( values );
+        int * values = tr_parseNumberRange (arg, -1, &valueCount);
+        for (i=0; i<valueCount; ++i)
+            tr_bencListAddInt (files, values[i]);
+        tr_free (values);
     }
 }
 
-#define TR_N_ELEMENTS( ary ) ( sizeof( ary ) / sizeof( *ary ) )
+#define TR_N_ELEMENTS(ary) (sizeof (ary) / sizeof (*ary))
 
 static const char * files_keys[] = {
     "files",
@@ -723,66 +723,66 @@ static const char * list_keys[] = {
 };
 
 static size_t
-writeFunc( void * ptr, size_t size, size_t nmemb, void * buf )
+writeFunc (void * ptr, size_t size, size_t nmemb, void * buf)
 {
     const size_t byteCount = size * nmemb;
-    evbuffer_add( buf, ptr, byteCount );
+    evbuffer_add (buf, ptr, byteCount);
     return byteCount;
 }
 
 /* look for a session id in the header in case the server gives back a 409 */
 static size_t
-parseResponseHeader( void *ptr, size_t size, size_t nmemb, void * stream UNUSED )
+parseResponseHeader (void *ptr, size_t size, size_t nmemb, void * stream UNUSED)
 {
     const char * line = ptr;
     const size_t line_len = size * nmemb;
     const char * key = TR_RPC_SESSION_ID_HEADER ": ";
-    const size_t key_len = strlen( key );
+    const size_t key_len = strlen (key);
 
-    if( ( line_len >= key_len ) && !memcmp( line, key, key_len ) )
+    if ((line_len >= key_len) && !memcmp (line, key, key_len))
     {
         const char * begin = line + key_len;
         const char * end = begin;
-        while( !isspace( *end ) )
+        while (!isspace (*end))
             ++end;
-        tr_free( sessionId );
-        sessionId = tr_strndup( begin, end-begin );
+        tr_free (sessionId);
+        sessionId = tr_strndup (begin, end-begin);
     }
 
     return line_len;
 }
 
 static long
-getTimeoutSecs( const char * req )
+getTimeoutSecs (const char * req)
 {
-  if( strstr( req, "\"method\":\"blocklist-update\"" ) != NULL )
+  if (strstr (req, "\"method\":\"blocklist-update\"") != NULL)
     return 300L;
 
   return 60L; /* default value */
 }
 
 static char*
-getStatusString( tr_benc * t, char * buf, size_t buflen )
+getStatusString (tr_benc * t, char * buf, size_t buflen)
 {
     int64_t status;
     bool boolVal;
 
-    if( !tr_bencDictFindInt( t, "status", &status ) )
+    if (!tr_bencDictFindInt (t, "status", &status))
     {
         *buf = '\0';
     }
-    else switch( status )
+    else switch (status)
     {
         case TR_STATUS_DOWNLOAD_WAIT:
         case TR_STATUS_SEED_WAIT:
-            tr_strlcpy( buf, "Queued", buflen );
+            tr_strlcpy (buf, "Queued", buflen);
             break;
 
         case TR_STATUS_STOPPED:
-            if( tr_bencDictFindBool( t, "isFinished", &boolVal ) && boolVal )
-                tr_strlcpy( buf, "Finished", buflen );
+            if (tr_bencDictFindBool (t, "isFinished", &boolVal) && boolVal)
+                tr_strlcpy (buf, "Finished", buflen);
             else
-                tr_strlcpy( buf, "Stopped", buflen );
+                tr_strlcpy (buf, "Stopped", buflen);
             break;
 
         case TR_STATUS_CHECK_WAIT:
@@ -791,10 +791,10 @@ getStatusString( tr_benc * t, char * buf, size_t buflen )
                              ? "Will Verify"
                              : "Verifying";
             double percent;
-            if( tr_bencDictFindReal( t, "recheckProgress", &percent ) )
-                tr_snprintf( buf, buflen, "%s (%.0f%%)", str, floor(percent*100.0) );
+            if (tr_bencDictFindReal (t, "recheckProgress", &percent))
+                tr_snprintf (buf, buflen, "%s (%.0f%%)", str, floor (percent*100.0));
             else
-                tr_strlcpy( buf, str, buflen );
+                tr_strlcpy (buf, str, buflen);
 
             break;
         }
@@ -803,27 +803,27 @@ getStatusString( tr_benc * t, char * buf, size_t buflen )
         case TR_STATUS_SEED: {
             int64_t fromUs = 0;
             int64_t toUs = 0;
-            tr_bencDictFindInt( t, "peersGettingFromUs", &fromUs );
-            tr_bencDictFindInt( t, "peersSendingToUs", &toUs );
-            if( fromUs && toUs )
-                tr_strlcpy( buf, "Up & Down", buflen );
-            else if( toUs )
-                tr_strlcpy( buf, "Downloading", buflen );
-            else if( fromUs ) {
+            tr_bencDictFindInt (t, "peersGettingFromUs", &fromUs);
+            tr_bencDictFindInt (t, "peersSendingToUs", &toUs);
+            if (fromUs && toUs)
+                tr_strlcpy (buf, "Up & Down", buflen);
+            else if (toUs)
+                tr_strlcpy (buf, "Downloading", buflen);
+            else if (fromUs) {
                 int64_t leftUntilDone = 0;
-                tr_bencDictFindInt( t, "leftUntilDone", &leftUntilDone );
-                if( leftUntilDone > 0 )
-                    tr_strlcpy( buf, "Uploading", buflen );
+                tr_bencDictFindInt (t, "leftUntilDone", &leftUntilDone);
+                if (leftUntilDone > 0)
+                    tr_strlcpy (buf, "Uploading", buflen);
                 else
-                    tr_strlcpy( buf, "Seeding", buflen );
+                    tr_strlcpy (buf, "Seeding", buflen);
             } else {
-                tr_strlcpy( buf, "Idle", buflen );
+                tr_strlcpy (buf, "Idle", buflen);
             }
             break;
         }
 
         default:
-            tr_strlcpy( buf, "Unknown", buflen );
+            tr_strlcpy (buf, "Unknown", buflen);
             break;
     }
 
@@ -834,18 +834,18 @@ static const char *bandwidthPriorityNames[] =
     { "Low", "Normal", "High", "Invalid" };
 
 static void
-printDetails( tr_benc * top )
+printDetails (tr_benc * top)
 {
     tr_benc *args, *torrents;
 
-    if( ( tr_bencDictFindDict( top, "arguments", &args ) )
-      && ( tr_bencDictFindList( args, "torrents", &torrents ) ) )
+    if ((tr_bencDictFindDict (top, "arguments", &args))
+      && (tr_bencDictFindList (args, "torrents", &torrents)))
     {
         int ti, tCount;
-        for( ti = 0, tCount = tr_bencListSize( torrents ); ti < tCount;
-             ++ti )
+        for (ti = 0, tCount = tr_bencListSize (torrents); ti < tCount;
+             ++ti)
         {
-            tr_benc *    t = tr_bencListChild( torrents, ti );
+            tr_benc *    t = tr_bencListChild (torrents, ti);
             tr_benc *    l;
             const char * str;
             char         buf[512];
@@ -854,252 +854,252 @@ printDetails( tr_benc * top )
             bool      boolVal;
             double       d;
 
-            printf( "NAME\n" );
-            if( tr_bencDictFindInt( t, "id", &i ) )
-                printf( "  Id: %" PRId64 "\n", i );
-            if( tr_bencDictFindStr( t, "name", &str ) )
-                printf( "  Name: %s\n", str );
-            if( tr_bencDictFindStr( t, "hashString", &str ) )
-                printf( "  Hash: %s\n", str );
-            if( tr_bencDictFindStr( t, "magnetLink", &str ) )
-                printf( "  Magnet: %s\n", str );
-            printf( "\n" );
-
-            printf( "TRANSFER\n" );
-            getStatusString( t, buf, sizeof( buf ) );
-            printf( "  State: %s\n", buf );
-
-            if( tr_bencDictFindStr( t, "downloadDir", &str ) )
-                printf( "  Location: %s\n", str );
-
-            if( tr_bencDictFindInt( t, "sizeWhenDone", &i )
-              && tr_bencDictFindInt( t, "leftUntilDone", &j ) )
+            printf ("NAME\n");
+            if (tr_bencDictFindInt (t, "id", &i))
+                printf ("  Id: %" PRId64 "\n", i);
+            if (tr_bencDictFindStr (t, "name", &str))
+                printf ("  Name: %s\n", str);
+            if (tr_bencDictFindStr (t, "hashString", &str))
+                printf ("  Hash: %s\n", str);
+            if (tr_bencDictFindStr (t, "magnetLink", &str))
+                printf ("  Magnet: %s\n", str);
+            printf ("\n");
+
+            printf ("TRANSFER\n");
+            getStatusString (t, buf, sizeof (buf));
+            printf ("  State: %s\n", buf);
+
+            if (tr_bencDictFindStr (t, "downloadDir", &str))
+                printf ("  Location: %s\n", str);
+
+            if (tr_bencDictFindInt (t, "sizeWhenDone", &i)
+              && tr_bencDictFindInt (t, "leftUntilDone", &j))
             {
-                strlpercent( buf, 100.0 * ( i - j ) / i, sizeof( buf ) );
-                printf( "  Percent Done: %s%%\n", buf );
+                strlpercent (buf, 100.0 * (i - j) / i, sizeof (buf));
+                printf ("  Percent Done: %s%%\n", buf);
             }
 
-            if( tr_bencDictFindInt( t, "eta", &i ) )
-                printf( "  ETA: %s\n", tr_strltime( buf, i, sizeof( buf ) ) );
-            if( tr_bencDictFindInt( t, "rateDownload", &i ) )
-                printf( "  Download Speed: %s\n", tr_formatter_speed_KBps( buf, i/(double)tr_speed_K, sizeof( buf ) ) );
-            if( tr_bencDictFindInt( t, "rateUpload", &i ) )
-                printf( "  Upload Speed: %s\n", tr_formatter_speed_KBps( buf, i/(double)tr_speed_K, sizeof( buf ) ) );
-            if( tr_bencDictFindInt( t, "haveUnchecked", &i )
-              && tr_bencDictFindInt( t, "haveValid", &j ) )
+            if (tr_bencDictFindInt (t, "eta", &i))
+                printf ("  ETA: %s\n", tr_strltime (buf, i, sizeof (buf)));
+            if (tr_bencDictFindInt (t, "rateDownload", &i))
+                printf ("  Download Speed: %s\n", tr_formatter_speed_KBps (buf, i/ (double)tr_speed_K, sizeof (buf)));
+            if (tr_bencDictFindInt (t, "rateUpload", &i))
+                printf ("  Upload Speed: %s\n", tr_formatter_speed_KBps (buf, i/ (double)tr_speed_K, sizeof (buf)));
+            if (tr_bencDictFindInt (t, "haveUnchecked", &i)
+              && tr_bencDictFindInt (t, "haveValid", &j))
             {
-                strlsize( buf, i + j, sizeof( buf ) );
-                strlsize( buf2, j, sizeof( buf2 ) );
-                printf( "  Have: %s (%s verified)\n", buf, buf2 );
+                strlsize (buf, i + j, sizeof (buf));
+                strlsize (buf2, j, sizeof (buf2));
+                printf ("  Have: %s (%s verified)\n", buf, buf2);
             }
 
-            if( tr_bencDictFindInt( t, "sizeWhenDone", &i ) )
+            if (tr_bencDictFindInt (t, "sizeWhenDone", &i))
             {
-                if( i < 1 )
-                    printf( "  Availability: None\n" );
-                if( tr_bencDictFindInt( t, "desiredAvailable", &j)
-                    && tr_bencDictFindInt( t, "leftUntilDone", &k) )
+                if (i < 1)
+                    printf ("  Availability: None\n");
+                if (tr_bencDictFindInt (t, "desiredAvailable", &j)
+                    && tr_bencDictFindInt (t, "leftUntilDone", &k))
                 {
                     j += i - k;
-                    strlpercent( buf, 100.0 * j / i, sizeof( buf ) );
-                    printf( "  Availability: %s%%\n", buf );
+                    strlpercent (buf, 100.0 * j / i, sizeof (buf));
+                    printf ("  Availability: %s%%\n", buf);
                 }
-                if( tr_bencDictFindInt( t, "totalSize", &j ) )
+                if (tr_bencDictFindInt (t, "totalSize", &j))
                 {
-                    strlsize( buf2, i, sizeof( buf2 ) );
-                    strlsize( buf, j, sizeof( buf ) );
-                    printf( "  Total size: %s (%s wanted)\n", buf, buf2 );
+                    strlsize (buf2, i, sizeof (buf2));
+                    strlsize (buf, j, sizeof (buf));
+                    printf ("  Total size: %s (%s wanted)\n", buf, buf2);
                 }
             }
-            if( tr_bencDictFindInt( t, "downloadedEver", &i )
-              && tr_bencDictFindInt( t, "uploadedEver", &j ) )
+            if (tr_bencDictFindInt (t, "downloadedEver", &i)
+              && tr_bencDictFindInt (t, "uploadedEver", &j))
             {
-                strlsize( buf, i, sizeof( buf ) );
-                printf( "  Downloaded: %s\n", buf );
-                strlsize( buf, j, sizeof( buf ) );
-                printf( "  Uploaded: %s\n", buf );
-                strlratio( buf, j, i, sizeof( buf ) );
-                printf( "  Ratio: %s\n", buf );
+                strlsize (buf, i, sizeof (buf));
+                printf ("  Downloaded: %s\n", buf);
+                strlsize (buf, j, sizeof (buf));
+                printf ("  Uploaded: %s\n", buf);
+                strlratio (buf, j, i, sizeof (buf));
+                printf ("  Ratio: %s\n", buf);
             }
-            if( tr_bencDictFindInt( t, "corruptEver", &i ) )
+            if (tr_bencDictFindInt (t, "corruptEver", &i))
             {
-                strlsize( buf, i, sizeof( buf ) );
-                printf( "  Corrupt DL: %s\n", buf );
+                strlsize (buf, i, sizeof (buf));
+                printf ("  Corrupt DL: %s\n", buf);
             }
-            if( tr_bencDictFindStr( t, "errorString", &str ) && str && *str &&
-                tr_bencDictFindInt( t, "error", &i ) && i )
+            if (tr_bencDictFindStr (t, "errorString", &str) && str && *str &&
+                tr_bencDictFindInt (t, "error", &i) && i)
             {
-                switch( i ) {
-                    case TR_STAT_TRACKER_WARNING: printf( "  Tracker gave a warning: %s\n", str ); break;
-                    case TR_STAT_TRACKER_ERROR:   printf( "  Tracker gave an error: %s\n", str ); break;
-                    case TR_STAT_LOCAL_ERROR:     printf( "  Error: %s\n", str ); break;
+                switch (i) {
+                    case TR_STAT_TRACKER_WARNING: printf ("  Tracker gave a warning: %s\n", str); break;
+                    case TR_STAT_TRACKER_ERROR:   printf ("  Tracker gave an error: %s\n", str); break;
+                    case TR_STAT_LOCAL_ERROR:     printf ("  Error: %s\n", str); break;
                     default: break; /* no error */
                 }
             }
-            if( tr_bencDictFindInt( t, "peersConnected", &i )
-              && tr_bencDictFindInt( t, "peersGettingFromUs", &j )
-              && tr_bencDictFindInt( t, "peersSendingToUs", &k ) )
+            if (tr_bencDictFindInt (t, "peersConnected", &i)
+              && tr_bencDictFindInt (t, "peersGettingFromUs", &j)
+              && tr_bencDictFindInt (t, "peersSendingToUs", &k))
             {
-                printf(
+                printf (
                     "  Peers: "
                     "connected to %" PRId64 ", "
                                             "uploading to %" PRId64
                     ", "
                     "downloading from %"
                     PRId64 "\n",
-                    i, j, k );
+                    i, j, k);
             }
 
-            if( tr_bencDictFindList( t, "webseeds", &l )
-              && tr_bencDictFindInt( t, "webseedsSendingToUs", &i ) )
+            if (tr_bencDictFindList (t, "webseeds", &l)
+              && tr_bencDictFindInt (t, "webseedsSendingToUs", &i))
             {
-                const int64_t n = tr_bencListSize( l );
-                if( n > 0 )
-                    printf(
+                const int64_t n = tr_bencListSize (l);
+                if (n > 0)
+                    printf (
                         "  Web Seeds: downloading from %" PRId64 " of %"
                         PRId64
-                        " web seeds\n", i, n );
+                        " web seeds\n", i, n);
             }
-            printf( "\n" );
+            printf ("\n");
 
-            printf( "HISTORY\n" );
-            if( tr_bencDictFindInt( t, "addedDate", &i ) && i )
+            printf ("HISTORY\n");
+            if (tr_bencDictFindInt (t, "addedDate", &i) && i)
             {
                 const time_t tt = i;
-                printf( "  Date added:       %s", ctime( &tt ) );
+                printf ("  Date added:       %s", ctime (&tt));
             }
-            if( tr_bencDictFindInt( t, "doneDate", &i ) && i )
+            if (tr_bencDictFindInt (t, "doneDate", &i) && i)
             {
                 const time_t tt = i;
-                printf( "  Date finished:    %s", ctime( &tt ) );
+                printf ("  Date finished:    %s", ctime (&tt));
             }
-            if( tr_bencDictFindInt( t, "startDate", &i ) && i )
+            if (tr_bencDictFindInt (t, "startDate", &i) && i)
             {
                 const time_t tt = i;
-                printf( "  Date started:     %s", ctime( &tt ) );
+                printf ("  Date started:     %s", ctime (&tt));
             }
-            if( tr_bencDictFindInt( t, "activityDate", &i ) && i )
+            if (tr_bencDictFindInt (t, "activityDate", &i) && i)
             {
                 const time_t tt = i;
-                printf( "  Latest activity:  %s", ctime( &tt ) );
+                printf ("  Latest activity:  %s", ctime (&tt));
             }
-            if( tr_bencDictFindInt( t, "secondsDownloading", &i ) && ( i > 0 ) )
-                printf( "  Downloading Time: %s\n", tr_strltime( buf, i, sizeof( buf ) ) );
-            if( tr_bencDictFindInt( t, "secondsSeeding", &i ) && ( i > 0 ) )
-                printf( "  Seeding Time:     %s\n", tr_strltime( buf, i, sizeof( buf ) ) );
-            printf( "\n" );
-
-            printf( "ORIGINS\n" );
-            if( tr_bencDictFindInt( t, "dateCreated", &i ) && i )
+            if (tr_bencDictFindInt (t, "secondsDownloading", &i) && (i > 0))
+                printf ("  Downloading Time: %s\n", tr_strltime (buf, i, sizeof (buf)));
+            if (tr_bencDictFindInt (t, "secondsSeeding", &i) && (i > 0))
+                printf ("  Seeding Time:     %s\n", tr_strltime (buf, i, sizeof (buf)));
+            printf ("\n");
+
+            printf ("ORIGINS\n");
+            if (tr_bencDictFindInt (t, "dateCreated", &i) && i)
             {
                 const time_t tt = i;
-                printf( "  Date created: %s", ctime( &tt ) );
+                printf ("  Date created: %s", ctime (&tt));
             }
-            if( tr_bencDictFindBool( t, "isPrivate", &boolVal ) )
-                printf( "  Public torrent: %s\n", ( boolVal ? "No" : "Yes" ) );
-            if( tr_bencDictFindStr( t, "comment", &str ) && str && *str )
-                printf( "  Comment: %s\n", str );
-            if( tr_bencDictFindStr( t, "creator", &str ) && str && *str )
-                printf( "  Creator: %s\n", str );
-            if( tr_bencDictFindInt( t, "pieceCount", &i ) )
-                printf( "  Piece Count: %" PRId64 "\n", i );
-            if( tr_bencDictFindInt( t, "pieceSize", &i ) )
-                printf( "  Piece Size: %s\n", strlmem( buf, i, sizeof( buf ) ) );
-            printf( "\n" );
-
-            printf( "LIMITS & BANDWIDTH\n" );
-            if( tr_bencDictFindBool( t, "downloadLimited", &boolVal )
-                && tr_bencDictFindInt( t, "downloadLimit", &i ) )
+            if (tr_bencDictFindBool (t, "isPrivate", &boolVal))
+                printf ("  Public torrent: %s\n", (boolVal ? "No" : "Yes"));
+            if (tr_bencDictFindStr (t, "comment", &str) && str && *str)
+                printf ("  Comment: %s\n", str);
+            if (tr_bencDictFindStr (t, "creator", &str) && str && *str)
+                printf ("  Creator: %s\n", str);
+            if (tr_bencDictFindInt (t, "pieceCount", &i))
+                printf ("  Piece Count: %" PRId64 "\n", i);
+            if (tr_bencDictFindInt (t, "pieceSize", &i))
+                printf ("  Piece Size: %s\n", strlmem (buf, i, sizeof (buf)));
+            printf ("\n");
+
+            printf ("LIMITS & BANDWIDTH\n");
+            if (tr_bencDictFindBool (t, "downloadLimited", &boolVal)
+                && tr_bencDictFindInt (t, "downloadLimit", &i))
             {
-                printf( "  Download Limit: " );
-                if( boolVal )
-                    printf( "%s\n", tr_formatter_speed_KBps( buf, i, sizeof( buf ) ) );
+                printf ("  Download Limit: ");
+                if (boolVal)
+                    printf ("%s\n", tr_formatter_speed_KBps (buf, i, sizeof (buf)));
                 else
-                    printf( "Unlimited\n" );
+                    printf ("Unlimited\n");
             }
-            if( tr_bencDictFindBool( t, "uploadLimited", &boolVal )
-                && tr_bencDictFindInt( t, "uploadLimit", &i ) )
+            if (tr_bencDictFindBool (t, "uploadLimited", &boolVal)
+                && tr_bencDictFindInt (t, "uploadLimit", &i))
             {
-                printf( "  Upload Limit: " );
-                if( boolVal )
-                    printf( "%s\n", tr_formatter_speed_KBps( buf, i, sizeof( buf ) ) );
+                printf ("  Upload Limit: ");
+                if (boolVal)
+                    printf ("%s\n", tr_formatter_speed_KBps (buf, i, sizeof (buf)));
                 else
-                    printf( "Unlimited\n" );
+                    printf ("Unlimited\n");
             }
-            if( tr_bencDictFindInt( t, "seedRatioMode", &i))
+            if (tr_bencDictFindInt (t, "seedRatioMode", &i))
             {
-                switch( i ) {
+                switch (i) {
                     case TR_RATIOLIMIT_GLOBAL:
-                        printf( "  Ratio Limit: Default\n" );
+                        printf ("  Ratio Limit: Default\n");
                         break;
                     case TR_RATIOLIMIT_SINGLE:
-                        if( tr_bencDictFindReal( t, "seedRatioLimit", &d))
-                            printf( "  Ratio Limit: %.2f\n", d );
+                        if (tr_bencDictFindReal (t, "seedRatioLimit", &d))
+                            printf ("  Ratio Limit: %.2f\n", d);
                         break;
                     case TR_RATIOLIMIT_UNLIMITED:
-                        printf( "  Ratio Limit: Unlimited\n" );
+                        printf ("  Ratio Limit: Unlimited\n");
                         break;
                     default: break;
                 }
             }
-            if( tr_bencDictFindBool( t, "honorsSessionLimits", &boolVal ) )
-                printf( "  Honors Session Limits: %s\n", ( boolVal ? "Yes" : "No" ) );
-            if( tr_bencDictFindInt ( t, "peer-limit", &i ) )
-                printf( "  Peer limit: %" PRId64 "\n", i );
+            if (tr_bencDictFindBool (t, "honorsSessionLimits", &boolVal))
+                printf ("  Honors Session Limits: %s\n", (boolVal ? "Yes" : "No"));
+            if (tr_bencDictFindInt (t, "peer-limit", &i))
+                printf ("  Peer limit: %" PRId64 "\n", i);
             if (tr_bencDictFindInt (t, "bandwidthPriority", &i))
                 printf ("  Bandwidth Priority: %s\n",
-                        bandwidthPriorityNames[(i + 1) & 3]);
+                        bandwidthPriorityNames[ (i + 1) & 3]);
 
-            printf( "\n" );
+            printf ("\n");
         }
     }
 }
 
 static void
-printFileList( tr_benc * top )
+printFileList (tr_benc * top)
 {
     tr_benc *args, *torrents;
 
-    if( ( tr_bencDictFindDict( top, "arguments", &args ) )
-      && ( tr_bencDictFindList( args, "torrents", &torrents ) ) )
+    if ((tr_bencDictFindDict (top, "arguments", &args))
+      && (tr_bencDictFindList (args, "torrents", &torrents)))
     {
         int i, in;
-        for( i = 0, in = tr_bencListSize( torrents ); i < in; ++i )
+        for (i = 0, in = tr_bencListSize (torrents); i < in; ++i)
         {
-            tr_benc *    d = tr_bencListChild( torrents, i );
+            tr_benc *    d = tr_bencListChild (torrents, i);
             tr_benc *    files, *priorities, *wanteds;
             const char * name;
-            if( tr_bencDictFindStr( d, "name", &name )
-              && tr_bencDictFindList( d, "files", &files )
-              && tr_bencDictFindList( d, "priorities", &priorities )
-              && tr_bencDictFindList( d, "wanted", &wanteds ) )
+            if (tr_bencDictFindStr (d, "name", &name)
+              && tr_bencDictFindList (d, "files", &files)
+              && tr_bencDictFindList (d, "priorities", &priorities)
+              && tr_bencDictFindList (d, "wanted", &wanteds))
             {
-                int j = 0, jn = tr_bencListSize( files );
-                printf( "%s (%d files):\n", name, jn );
-                printf( "%3s  %4s %8s %3s %9s  %s\n", "#", "Done",
+                int j = 0, jn = tr_bencListSize (files);
+                printf ("%s (%d files):\n", name, jn);
+                printf ("%3s  %4s %8s %3s %9s  %s\n", "#", "Done",
                         "Priority", "Get", "Size",
-                        "Name" );
-                for( j = 0, jn = tr_bencListSize( files ); j < jn; ++j )
+                        "Name");
+                for (j = 0, jn = tr_bencListSize (files); j < jn; ++j)
                 {
                     int64_t      have;
                     int64_t      length;
                     int64_t      priority;
                     int64_t      wanted;
                     const char * filename;
-                    tr_benc *    file = tr_bencListChild( files, j );
-                    if( tr_bencDictFindInt( file, "length", &length )
-                      && tr_bencDictFindStr( file, "name", &filename )
-                      && tr_bencDictFindInt( file, "bytesCompleted", &have )
-                      && tr_bencGetInt( tr_bencListChild( priorities,
-                                                          j ), &priority )
-                      && tr_bencGetInt( tr_bencListChild( wanteds,
-                                                          j ), &wanted ) )
+                    tr_benc *    file = tr_bencListChild (files, j);
+                    if (tr_bencDictFindInt (file, "length", &length)
+                      && tr_bencDictFindStr (file, "name", &filename)
+                      && tr_bencDictFindInt (file, "bytesCompleted", &have)
+                      && tr_bencGetInt (tr_bencListChild (priorities,
+                                                          j), &priority)
+                      && tr_bencGetInt (tr_bencListChild (wanteds,
+                                                          j), &wanted))
                     {
                         char         sizestr[64];
                         double       percent = (double)have / length;
                         const char * pristr;
-                        strlsize( sizestr, length, sizeof( sizestr ) );
-                        switch( priority )
+                        strlsize (sizestr, length, sizeof (sizestr));
+                        switch (priority)
                         {
                             case TR_PRI_LOW:
                                 pristr = "Low"; break;
@@ -1110,13 +1110,13 @@ printFileList( tr_benc * top )
                             default:
                                 pristr = "Normal"; break;
                         }
-                        printf( "%3d: %3.0f%% %-8s %-3s %9s  %s\n",
+                        printf ("%3d: %3.0f%% %-8s %-3s %9s  %s\n",
                                 j,
-                                floor( 100.0 * percent ),
+                                floor (100.0 * percent),
                                 pristr,
-                                ( wanted ? "Yes" : "No" ),
+                              (wanted ? "Yes" : "No"),
                                 sizestr,
-                                filename );
+                                filename);
                     }
                 }
             }
@@ -1125,145 +1125,145 @@ printFileList( tr_benc * top )
 }
 
 static void
-printPeersImpl( tr_benc * peers )
+printPeersImpl (tr_benc * peers)
 {
     int i, n;
-    printf( "%-20s  %-12s  %-5s %-6s  %-6s  %s\n",
-            "Address", "Flags", "Done", "Down", "Up", "Client" );
-    for( i = 0, n = tr_bencListSize( peers ); i < n; ++i )
+    printf ("%-20s  %-12s  %-5s %-6s  %-6s  %s\n",
+            "Address", "Flags", "Done", "Down", "Up", "Client");
+    for (i = 0, n = tr_bencListSize (peers); i < n; ++i)
     {
         double progress;
         const char * address, * client, * flagstr;
         int64_t rateToClient, rateToPeer;
-        tr_benc * d = tr_bencListChild( peers, i );
-
-        if( tr_bencDictFindStr( d, "address", &address )
-          && tr_bencDictFindStr( d, "clientName", &client )
-          && tr_bencDictFindReal( d, "progress", &progress )
-          && tr_bencDictFindStr( d, "flagStr", &flagstr )
-          && tr_bencDictFindInt( d, "rateToClient", &rateToClient )
-          && tr_bencDictFindInt( d, "rateToPeer", &rateToPeer ) )
+        tr_benc * d = tr_bencListChild (peers, i);
+
+        if (tr_bencDictFindStr (d, "address", &address)
+          && tr_bencDictFindStr (d, "clientName", &client)
+          && tr_bencDictFindReal (d, "progress", &progress)
+          && tr_bencDictFindStr (d, "flagStr", &flagstr)
+          && tr_bencDictFindInt (d, "rateToClient", &rateToClient)
+          && tr_bencDictFindInt (d, "rateToPeer", &rateToPeer))
         {
-            printf( "%-20s  %-12s  %-5.1f %6.1f  %6.1f  %s\n",
+            printf ("%-20s  %-12s  %-5.1f %6.1f  %6.1f  %s\n",
                     address, flagstr, (progress*100.0),
                     rateToClient / (double)tr_speed_K,
                     rateToPeer / (double)tr_speed_K,
-                    client );
+                    client);
         }
     }
 }
 
 static void
-printPeers( tr_benc * top )
+printPeers (tr_benc * top)
 {
     tr_benc *args, *torrents;
 
-    if( tr_bencDictFindDict( top, "arguments", &args )
-      && tr_bencDictFindList( args, "torrents", &torrents ) )
+    if (tr_bencDictFindDict (top, "arguments", &args)
+      && tr_bencDictFindList (args, "torrents", &torrents))
     {
         int i, n;
-        for( i=0, n=tr_bencListSize( torrents ); i<n; ++i )
+        for (i=0, n=tr_bencListSize (torrents); i<n; ++i)
         {
             tr_benc * peers;
-            tr_benc * torrent = tr_bencListChild( torrents, i );
-            if( tr_bencDictFindList( torrent, "peers", &peers ) ) {
-                printPeersImpl( peers );
-                if( i+1<n )
-                    printf( "\n" );
+            tr_benc * torrent = tr_bencListChild (torrents, i);
+            if (tr_bencDictFindList (torrent, "peers", &peers)) {
+                printPeersImpl (peers);
+                if (i+1<n)
+                    printf ("\n");
             }
         }
     }
 }
 
 static void
-printPiecesImpl( const uint8_t * raw, size_t rawlen, int64_t j )
+printPiecesImpl (const uint8_t * raw, size_t rawlen, int64_t j)
 {
     int i, k, len;
-    char * str = tr_base64_decode( raw, rawlen, &len );
-    printf( "  " );
-    for( i=k=0; k<len; ++k ) {
+    char * str = tr_base64_decode (raw, rawlen, &len);
+    printf ("  ");
+    for (i=k=0; k<len; ++k) {
         int e;
-        for( e=0; i<j && e<8; ++e, ++i )
-            printf( "%c", str[k] & (1<<(7-e)) ? '1' : '0' );
-        printf( " " );
-        if( !(i%64) )
-            printf( "\n  " );
+        for (e=0; i<j && e<8; ++e, ++i)
+            printf ("%c", str[k] & (1<< (7-e)) ? '1' : '0');
+        printf (" ");
+        if (! (i%64))
+            printf ("\n  ");
     }
-    printf( "\n" );
-    tr_free( str );
+    printf ("\n");
+    tr_free (str);
 }
 
 static void
-printPieces( tr_benc * top )
+printPieces (tr_benc * top)
 {
     tr_benc *args, *torrents;
 
-    if( tr_bencDictFindDict( top, "arguments", &args )
-      && tr_bencDictFindList( args, "torrents", &torrents ) )
+    if (tr_bencDictFindDict (top, "arguments", &args)
+      && tr_bencDictFindList (args, "torrents", &torrents))
     {
         int i, n;
-        for( i=0, n=tr_bencListSize( torrents ); i<n; ++i )
+        for (i=0, n=tr_bencListSize (torrents); i<n; ++i)
         {
             int64_t j;
             const uint8_t * raw;
             size_t       rawlen;
-            tr_benc * torrent = tr_bencListChild( torrents, i );
-            if( tr_bencDictFindRaw( torrent, "pieces", &raw, &rawlen ) &&
-                tr_bencDictFindInt( torrent, "pieceCount", &j ) ) {
-                printPiecesImpl( raw, rawlen, j );
-                if( i+1<n )
-                    printf( "\n" );
+            tr_benc * torrent = tr_bencListChild (torrents, i);
+            if (tr_bencDictFindRaw (torrent, "pieces", &raw, &rawlen) &&
+                tr_bencDictFindInt (torrent, "pieceCount", &j)) {
+                printPiecesImpl (raw, rawlen, j);
+                if (i+1<n)
+                    printf ("\n");
             }
         }
     }
 }
 
 static void
-printPortTest( tr_benc * top )
+printPortTest (tr_benc * top)
 {
     tr_benc *args;
-    if( ( tr_bencDictFindDict( top, "arguments", &args ) ) )
+    if ((tr_bencDictFindDict (top, "arguments", &args)))
     {
         bool      boolVal;
 
-        if( tr_bencDictFindBool( args, "port-is-open", &boolVal ) )
-            printf( "Port is open: %s\n", ( boolVal ? "Yes" : "No" ) );
+        if (tr_bencDictFindBool (args, "port-is-open", &boolVal))
+            printf ("Port is open: %s\n", (boolVal ? "Yes" : "No"));
     }
 }
 
 static void
-printTorrentList( tr_benc * top )
+printTorrentList (tr_benc * top)
 {
     tr_benc *args, *list;
 
-    if( ( tr_bencDictFindDict( top, "arguments", &args ) )
-      && ( tr_bencDictFindList( args, "torrents", &list ) ) )
+    if ((tr_bencDictFindDict (top, "arguments", &args))
+      && (tr_bencDictFindList (args, "torrents", &list)))
     {
         int i, n;
         int64_t total_size=0;
         double total_up=0, total_down=0;
         char haveStr[32];
 
-        printf( "%-4s   %-4s  %9s  %-8s  %6s  %6s  %-5s  %-11s  %s\n",
+        printf ("%-4s   %-4s  %9s  %-8s  %6s  %6s  %-5s  %-11s  %s\n",
                 "ID", "Done", "Have", "ETA", "Up", "Down", "Ratio", "Status",
-                "Name" );
+                "Name");
 
-        for( i = 0, n = tr_bencListSize( list ); i < n; ++i )
+        for (i = 0, n = tr_bencListSize (list); i < n; ++i)
         {
             int64_t      id, eta, status, up, down;
             int64_t      sizeWhenDone, leftUntilDone;
             double       ratio;
             const char * name;
-            tr_benc *   d = tr_bencListChild( list, i );
-            if( tr_bencDictFindInt( d, "eta", &eta )
-              && tr_bencDictFindInt( d, "id", &id )
-              && tr_bencDictFindInt( d, "leftUntilDone", &leftUntilDone )
-              && tr_bencDictFindStr( d, "name", &name )
-              && tr_bencDictFindInt( d, "rateDownload", &down )
-              && tr_bencDictFindInt( d, "rateUpload", &up )
-              && tr_bencDictFindInt( d, "sizeWhenDone", &sizeWhenDone )
-              && tr_bencDictFindInt( d, "status", &status )
-              && tr_bencDictFindReal( d, "uploadRatio", &ratio ) )
+            tr_benc *   d = tr_bencListChild (list, i);
+            if (tr_bencDictFindInt (d, "eta", &eta)
+              && tr_bencDictFindInt (d, "id", &id)
+              && tr_bencDictFindInt (d, "leftUntilDone", &leftUntilDone)
+              && tr_bencDictFindStr (d, "name", &name)
+              && tr_bencDictFindInt (d, "rateDownload", &down)
+              && tr_bencDictFindInt (d, "rateUpload", &up)
+              && tr_bencDictFindInt (d, "sizeWhenDone", &sizeWhenDone)
+              && tr_bencDictFindInt (d, "status", &status)
+              && tr_bencDictFindReal (d, "uploadRatio", &ratio))
             {
                 char etaStr[16];
                 char statusStr[64];
@@ -1272,32 +1272,32 @@ printTorrentList( tr_benc * top )
                 int64_t error;
                 char errorMark;
 
-                if( sizeWhenDone )
-                    tr_snprintf( doneStr, sizeof( doneStr ), "%d%%", (int)( 100.0 * ( sizeWhenDone - leftUntilDone ) / sizeWhenDone ) );
+                if (sizeWhenDone)
+                    tr_snprintf (doneStr, sizeof (doneStr), "%d%%", (int)(100.0 * (sizeWhenDone - leftUntilDone) / sizeWhenDone));
                 else
-                    tr_strlcpy( doneStr, "n/a", sizeof( doneStr ) );
+                    tr_strlcpy (doneStr, "n/a", sizeof (doneStr));
 
-                strlsize( haveStr, sizeWhenDone - leftUntilDone, sizeof( haveStr ) );
+                strlsize (haveStr, sizeWhenDone - leftUntilDone, sizeof (haveStr));
 
-                if( leftUntilDone || eta != -1 )
-                    etaToString( etaStr, sizeof( etaStr ), eta );
+                if (leftUntilDone || eta != -1)
+                    etaToString (etaStr, sizeof (etaStr), eta);
                 else
-                    tr_snprintf( etaStr, sizeof( etaStr ), "Done" );
-                if( tr_bencDictFindInt( d, "error", &error ) && error )
+                    tr_snprintf (etaStr, sizeof (etaStr), "Done");
+                if (tr_bencDictFindInt (d, "error", &error) && error)
                     errorMark = '*';
                 else
                     errorMark = ' ';
-                printf(
+                printf (
                     "%4d%c  %4s  %9s  %-8s  %6.1f  %6.1f  %5s  %-11s  %s\n",
-                    (int)id, errorMark,
+                  (int)id, errorMark,
                     doneStr,
                     haveStr,
                     etaStr,
-                    up/(double)tr_speed_K,
-                    down/(double)tr_speed_K,
-                    strlratio2( ratioStr, ratio, sizeof( ratioStr ) ),
-                    getStatusString( d, statusStr, sizeof( statusStr ) ),
-                    name );
+                    up/ (double)tr_speed_K,
+                    down/ (double)tr_speed_K,
+                    strlratio2 (ratioStr, ratio, sizeof (ratioStr)),
+                    getStatusString (d, statusStr, sizeof (statusStr)),
+                    name);
 
                 total_up += up;
                 total_down += down;
@@ -1305,21 +1305,21 @@ printTorrentList( tr_benc * top )
             }
         }
 
-        printf( "Sum:         %9s            %6.1f  %6.1f\n",
-                strlsize( haveStr, total_size, sizeof( haveStr ) ),
-                total_up/(double)tr_speed_K,
-                total_down/(double)tr_speed_K );
+        printf ("Sum:         %9s            %6.1f  %6.1f\n",
+                strlsize (haveStr, total_size, sizeof (haveStr)),
+                total_up/ (double)tr_speed_K,
+                total_down/ (double)tr_speed_K);
     }
 }
 
 static void
-printTrackersImpl( tr_benc * trackerStats )
+printTrackersImpl (tr_benc * trackerStats)
 {
     int i;
     char         buf[512];
     tr_benc * t;
 
-    for( i=0; (( t = tr_bencListChild( trackerStats, i ))); ++i )
+    for (i=0; ((t = tr_bencListChild (trackerStats, i))); ++i)
     {
         int64_t downloadCount;
         bool hasAnnounced;
@@ -1346,100 +1346,100 @@ printTrackersImpl( tr_benc * trackerStats )
         int64_t announceState;
         int64_t scrapeState;
 
-        if( tr_bencDictFindInt ( t, "downloadCount", &downloadCount ) &&
-            tr_bencDictFindBool( t, "hasAnnounced", &hasAnnounced ) &&
-            tr_bencDictFindBool( t, "hasScraped", &hasScraped ) &&
-            tr_bencDictFindStr ( t, "host", &host ) &&
-            tr_bencDictFindInt ( t, "id", &id ) &&
-            tr_bencDictFindBool( t, "isBackup", &isBackup ) &&
-            tr_bencDictFindInt ( t, "announceState", &announceState ) &&
-            tr_bencDictFindInt ( t, "scrapeState", &scrapeState ) &&
-            tr_bencDictFindInt ( t, "lastAnnouncePeerCount", &lastAnnouncePeerCount ) &&
-            tr_bencDictFindStr ( t, "lastAnnounceResult", &lastAnnounceResult ) &&
-            tr_bencDictFindInt ( t, "lastAnnounceStartTime", &lastAnnounceStartTime ) &&
-            tr_bencDictFindBool( t, "lastAnnounceSucceeded", &lastAnnounceSucceeded ) &&
-            tr_bencDictFindInt ( t, "lastAnnounceTime", &lastAnnounceTime ) &&
-            tr_bencDictFindBool( t, "lastAnnounceTimedOut", &lastAnnounceTimedOut ) &&
-            tr_bencDictFindStr ( t, "lastScrapeResult", &lastScrapeResult ) &&
-            tr_bencDictFindInt ( t, "lastScrapeStartTime", &lastScrapeStartTime ) &&
-            tr_bencDictFindBool( t, "lastScrapeSucceeded", &lastScrapeSucceeded ) &&
-            tr_bencDictFindInt ( t, "lastScrapeTime", &lastScrapeTime ) &&
-            tr_bencDictFindBool( t, "lastScrapeTimedOut", &lastScrapeTimedOut ) &&
-            tr_bencDictFindInt ( t, "leecherCount", &leecherCount ) &&
-            tr_bencDictFindInt ( t, "nextAnnounceTime", &nextAnnounceTime ) &&
-            tr_bencDictFindInt ( t, "nextScrapeTime", &nextScrapeTime ) &&
-            tr_bencDictFindInt ( t, "seederCount", &seederCount ) &&
-            tr_bencDictFindInt ( t, "tier", &tier ) )
+        if (tr_bencDictFindInt (t, "downloadCount", &downloadCount) &&
+            tr_bencDictFindBool (t, "hasAnnounced", &hasAnnounced) &&
+            tr_bencDictFindBool (t, "hasScraped", &hasScraped) &&
+            tr_bencDictFindStr (t, "host", &host) &&
+            tr_bencDictFindInt (t, "id", &id) &&
+            tr_bencDictFindBool (t, "isBackup", &isBackup) &&
+            tr_bencDictFindInt (t, "announceState", &announceState) &&
+            tr_bencDictFindInt (t, "scrapeState", &scrapeState) &&
+            tr_bencDictFindInt (t, "lastAnnouncePeerCount", &lastAnnouncePeerCount) &&
+            tr_bencDictFindStr (t, "lastAnnounceResult", &lastAnnounceResult) &&
+            tr_bencDictFindInt (t, "lastAnnounceStartTime", &lastAnnounceStartTime) &&
+            tr_bencDictFindBool (t, "lastAnnounceSucceeded", &lastAnnounceSucceeded) &&
+            tr_bencDictFindInt (t, "lastAnnounceTime", &lastAnnounceTime) &&
+            tr_bencDictFindBool (t, "lastAnnounceTimedOut", &lastAnnounceTimedOut) &&
+            tr_bencDictFindStr (t, "lastScrapeResult", &lastScrapeResult) &&
+            tr_bencDictFindInt (t, "lastScrapeStartTime", &lastScrapeStartTime) &&
+            tr_bencDictFindBool (t, "lastScrapeSucceeded", &lastScrapeSucceeded) &&
+            tr_bencDictFindInt (t, "lastScrapeTime", &lastScrapeTime) &&
+            tr_bencDictFindBool (t, "lastScrapeTimedOut", &lastScrapeTimedOut) &&
+            tr_bencDictFindInt (t, "leecherCount", &leecherCount) &&
+            tr_bencDictFindInt (t, "nextAnnounceTime", &nextAnnounceTime) &&
+            tr_bencDictFindInt (t, "nextScrapeTime", &nextScrapeTime) &&
+            tr_bencDictFindInt (t, "seederCount", &seederCount) &&
+            tr_bencDictFindInt (t, "tier", &tier))
         {
-            const time_t now = time( NULL );
+            const time_t now = time (NULL);
 
-            printf( "\n" );
-            printf( "  Tracker %d: %s\n", (int)(id), host );
-            if( isBackup )
-                printf( "  Backup on tier %d\n", (int)tier );
+            printf ("\n");
+            printf ("  Tracker %d: %s\n", (int)(id), host);
+            if (isBackup)
+                printf ("  Backup on tier %d\n", (int)tier);
             else
-                printf( "  Active in tier %d\n", (int)tier );
+                printf ("  Active in tier %d\n", (int)tier);
 
-            if( !isBackup )
+            if (!isBackup)
             {
-                if( hasAnnounced && announceState != TR_TRACKER_INACTIVE )
+                if (hasAnnounced && announceState != TR_TRACKER_INACTIVE)
                 {
-                    tr_strltime( buf, now - lastAnnounceTime, sizeof( buf ) );
-                    if( lastAnnounceSucceeded )
-                        printf( "  Got a list of %d peers %s ago\n",
-                                (int)lastAnnouncePeerCount, buf );
-                    else if( lastAnnounceTimedOut )
-                        printf( "  Peer list request timed out; will retry\n" );
+                    tr_strltime (buf, now - lastAnnounceTime, sizeof (buf));
+                    if (lastAnnounceSucceeded)
+                        printf ("  Got a list of %d peers %s ago\n",
+                              (int)lastAnnouncePeerCount, buf);
+                    else if (lastAnnounceTimedOut)
+                        printf ("  Peer list request timed out; will retry\n");
                     else
-                        printf( "  Got an error \"%s\" %s ago\n",
-                                lastAnnounceResult, buf );
+                        printf ("  Got an error \"%s\" %s ago\n",
+                                lastAnnounceResult, buf);
                 }
 
-                switch( announceState )
+                switch (announceState)
                 {
                     case TR_TRACKER_INACTIVE:
-                        printf( "  No updates scheduled\n" );
+                        printf ("  No updates scheduled\n");
                         break;
                     case TR_TRACKER_WAITING:
-                        tr_strltime( buf, nextAnnounceTime - now, sizeof( buf ) );
-                        printf( "  Asking for more peers in %s\n", buf );
+                        tr_strltime (buf, nextAnnounceTime - now, sizeof (buf));
+                        printf ("  Asking for more peers in %s\n", buf);
                         break;
                     case TR_TRACKER_QUEUED:
-                        printf( "  Queued to ask for more peers\n" );
+                        printf ("  Queued to ask for more peers\n");
                         break;
                     case TR_TRACKER_ACTIVE:
-                        tr_strltime( buf, now - lastAnnounceStartTime, sizeof( buf ) );
-                        printf( "  Asking for more peers now... %s\n", buf );
+                        tr_strltime (buf, now - lastAnnounceStartTime, sizeof (buf));
+                        printf ("  Asking for more peers now... %s\n", buf);
                         break;
                 }
 
-                if( hasScraped )
+                if (hasScraped)
                 {
-                    tr_strltime( buf, now - lastScrapeTime, sizeof( buf ) );
-                    if( lastScrapeSucceeded )
-                        printf( "  Tracker had %d seeders and %d leechers %s ago\n",
-                                (int)seederCount, (int)leecherCount, buf );
-                    else if( lastScrapeTimedOut )
-                        printf( "  Tracker scrape timed out; will retry\n" );
+                    tr_strltime (buf, now - lastScrapeTime, sizeof (buf));
+                    if (lastScrapeSucceeded)
+                        printf ("  Tracker had %d seeders and %d leechers %s ago\n",
+                              (int)seederCount, (int)leecherCount, buf);
+                    else if (lastScrapeTimedOut)
+                        printf ("  Tracker scrape timed out; will retry\n");
                     else
-                        printf( "  Got a scrape error \"%s\" %s ago\n",
-                                lastScrapeResult, buf );
+                        printf ("  Got a scrape error \"%s\" %s ago\n",
+                                lastScrapeResult, buf);
                 }
 
-                switch( scrapeState )
+                switch (scrapeState)
                 {
                     case TR_TRACKER_INACTIVE:
                         break;
                     case TR_TRACKER_WAITING:
-                        tr_strltime( buf, nextScrapeTime - now, sizeof( buf ) );
-                        printf( "  Asking for peer counts in %s\n", buf );
+                        tr_strltime (buf, nextScrapeTime - now, sizeof (buf));
+                        printf ("  Asking for peer counts in %s\n", buf);
                         break;
                     case TR_TRACKER_QUEUED:
-                        printf( "  Queued to ask for peer counts\n" );
+                        printf ("  Queued to ask for peer counts\n");
                         break;
                     case TR_TRACKER_ACTIVE:
-                        tr_strltime( buf, now - lastScrapeStartTime, sizeof( buf ) );
-                        printf( "  Asking for peer counts now... %s\n", buf );
+                        tr_strltime (buf, now - lastScrapeStartTime, sizeof (buf));
+                        printf ("  Asking for peer counts now... %s\n", buf);
                         break;
                 }
             }
@@ -1448,189 +1448,189 @@ printTrackersImpl( tr_benc * trackerStats )
 }
 
 static void
-printTrackers( tr_benc * top )
+printTrackers (tr_benc * top)
 {
     tr_benc *args, *torrents;
 
-    if( tr_bencDictFindDict( top, "arguments", &args )
-      && tr_bencDictFindList( args, "torrents", &torrents ) )
+    if (tr_bencDictFindDict (top, "arguments", &args)
+      && tr_bencDictFindList (args, "torrents", &torrents))
     {
         int i, n;
-        for( i=0, n=tr_bencListSize( torrents ); i<n; ++i )
+        for (i=0, n=tr_bencListSize (torrents); i<n; ++i)
         {
             tr_benc * trackerStats;
-            tr_benc * torrent = tr_bencListChild( torrents, i );
-            if( tr_bencDictFindList( torrent, "trackerStats", &trackerStats ) ) {
-                printTrackersImpl( trackerStats );
-                if( i+1<n )
-                    printf( "\n" );
+            tr_benc * torrent = tr_bencListChild (torrents, i);
+            if (tr_bencDictFindList (torrent, "trackerStats", &trackerStats)) {
+                printTrackersImpl (trackerStats);
+                if (i+1<n)
+                    printf ("\n");
             }
         }
     }
 }
 
 static void
-printSession( tr_benc * top )
+printSession (tr_benc * top)
 {
     tr_benc *args;
-    if( ( tr_bencDictFindDict( top, "arguments", &args ) ) )
+    if ((tr_bencDictFindDict (top, "arguments", &args)))
     {
         int64_t i;
         char buf[64];
         bool boolVal;
         const char * str;
 
-        printf( "VERSION\n" );
-        if( tr_bencDictFindStr( args,  "version", &str ) )
-            printf( "  Daemon version: %s\n", str );
-        if( tr_bencDictFindInt( args, "rpc-version", &i ) )
-            printf( "  RPC version: %" PRId64 "\n", i );
-        if( tr_bencDictFindInt( args, "rpc-version-minimum", &i ) )
-            printf( "  RPC minimum version: %" PRId64 "\n", i );
-        printf( "\n" );
-
-        printf( "CONFIG\n" );
-        if( tr_bencDictFindStr( args, "config-dir", &str ) )
-            printf( "  Configuration directory: %s\n", str );
-        if( tr_bencDictFindStr( args,  TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
-            printf( "  Download directory: %s\n", str );
-        if( tr_bencDictFindInt( args,  "download-dir-free-space", &i ) )
-            printf( "  Download directory free space: %s\n",  strlsize( buf, i, sizeof buf ) );
-        if( tr_bencDictFindInt( args, TR_PREFS_KEY_PEER_PORT, &i ) )
-            printf( "  Listenport: %" PRId64 "\n", i );
-        if( tr_bencDictFindBool( args, TR_PREFS_KEY_PORT_FORWARDING, &boolVal ) )
-            printf( "  Portforwarding enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
-        if( tr_bencDictFindBool( args, TR_PREFS_KEY_UTP_ENABLED, &boolVal ) )
-            printf( "  uTP enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
-        if( tr_bencDictFindBool( args, TR_PREFS_KEY_DHT_ENABLED, &boolVal ) )
-            printf( "  Distributed hash table enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
-        if( tr_bencDictFindBool( args, TR_PREFS_KEY_LPD_ENABLED, &boolVal ) )
-            printf( "  Local peer discovery enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
-        if( tr_bencDictFindBool( args, TR_PREFS_KEY_PEX_ENABLED, &boolVal ) )
-            printf( "  Peer exchange allowed: %s\n", ( boolVal ? "Yes" : "No" ) );
-        if( tr_bencDictFindStr( args,  TR_PREFS_KEY_ENCRYPTION, &str ) )
-            printf( "  Encryption: %s\n", str );
-        if( tr_bencDictFindInt( args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i ) )
-            printf( "  Maximum memory cache size: %s\n", tr_formatter_mem_MB( buf, i, sizeof( buf ) ) );
-        printf( "\n" );
+        printf ("VERSION\n");
+        if (tr_bencDictFindStr (args,  "version", &str))
+            printf ("  Daemon version: %s\n", str);
+        if (tr_bencDictFindInt (args, "rpc-version", &i))
+            printf ("  RPC version: %" PRId64 "\n", i);
+        if (tr_bencDictFindInt (args, "rpc-version-minimum", &i))
+            printf ("  RPC minimum version: %" PRId64 "\n", i);
+        printf ("\n");
+
+        printf ("CONFIG\n");
+        if (tr_bencDictFindStr (args, "config-dir", &str))
+            printf ("  Configuration directory: %s\n", str);
+        if (tr_bencDictFindStr (args,  TR_PREFS_KEY_DOWNLOAD_DIR, &str))
+            printf ("  Download directory: %s\n", str);
+        if (tr_bencDictFindInt (args,  "download-dir-free-space", &i))
+            printf ("  Download directory free space: %s\n",  strlsize (buf, i, sizeof buf));
+        if (tr_bencDictFindInt (args, TR_PREFS_KEY_PEER_PORT, &i))
+            printf ("  Listenport: %" PRId64 "\n", i);
+        if (tr_bencDictFindBool (args, TR_PREFS_KEY_PORT_FORWARDING, &boolVal))
+            printf ("  Portforwarding enabled: %s\n", (boolVal ? "Yes" : "No"));
+        if (tr_bencDictFindBool (args, TR_PREFS_KEY_UTP_ENABLED, &boolVal))
+            printf ("  uTP enabled: %s\n", (boolVal ? "Yes" : "No"));
+        if (tr_bencDictFindBool (args, TR_PREFS_KEY_DHT_ENABLED, &boolVal))
+            printf ("  Distributed hash table enabled: %s\n", (boolVal ? "Yes" : "No"));
+        if (tr_bencDictFindBool (args, TR_PREFS_KEY_LPD_ENABLED, &boolVal))
+            printf ("  Local peer discovery enabled: %s\n", (boolVal ? "Yes" : "No"));
+        if (tr_bencDictFindBool (args, TR_PREFS_KEY_PEX_ENABLED, &boolVal))
+            printf ("  Peer exchange allowed: %s\n", (boolVal ? "Yes" : "No"));
+        if (tr_bencDictFindStr (args,  TR_PREFS_KEY_ENCRYPTION, &str))
+            printf ("  Encryption: %s\n", str);
+        if (tr_bencDictFindInt (args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i))
+            printf ("  Maximum memory cache size: %s\n", tr_formatter_mem_MB (buf, i, sizeof (buf)));
+        printf ("\n");
 
         {
             bool altEnabled, altTimeEnabled, upEnabled, downEnabled, seedRatioLimited;
             int64_t altDown, altUp, altBegin, altEnd, altDay, upLimit, downLimit, peerLimit;
             double seedRatioLimit;
 
-            if( tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &altDown ) &&
-                tr_bencDictFindBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, &altEnabled ) &&
-                tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &altBegin ) &&
-                tr_bencDictFindBool( args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &altTimeEnabled ) &&
-                tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_TIME_END, &altEnd ) &&
-                tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &altDay ) &&
-                tr_bencDictFindInt ( args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &altUp ) &&
-                tr_bencDictFindInt ( args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &peerLimit ) &&
-                tr_bencDictFindInt ( args, TR_PREFS_KEY_DSPEED_KBps, &downLimit ) &&
-                tr_bencDictFindBool( args, TR_PREFS_KEY_DSPEED_ENABLED, &downEnabled ) &&
-                tr_bencDictFindInt ( args, TR_PREFS_KEY_USPEED_KBps, &upLimit ) &&
-                tr_bencDictFindBool( args, TR_PREFS_KEY_USPEED_ENABLED, &upEnabled ) &&
-                tr_bencDictFindReal( args, "seedRatioLimit", &seedRatioLimit ) &&
-                tr_bencDictFindBool( args, "seedRatioLimited", &seedRatioLimited) )
+            if (tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &altDown) &&
+                tr_bencDictFindBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, &altEnabled) &&
+                tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &altBegin) &&
+                tr_bencDictFindBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &altTimeEnabled) &&
+                tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_END, &altEnd) &&
+                tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &altDay) &&
+                tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &altUp) &&
+                tr_bencDictFindInt (args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &peerLimit) &&
+                tr_bencDictFindInt (args, TR_PREFS_KEY_DSPEED_KBps, &downLimit) &&
+                tr_bencDictFindBool (args, TR_PREFS_KEY_DSPEED_ENABLED, &downEnabled) &&
+                tr_bencDictFindInt (args, TR_PREFS_KEY_USPEED_KBps, &upLimit) &&
+                tr_bencDictFindBool (args, TR_PREFS_KEY_USPEED_ENABLED, &upEnabled) &&
+                tr_bencDictFindReal (args, "seedRatioLimit", &seedRatioLimit) &&
+                tr_bencDictFindBool (args, "seedRatioLimited", &seedRatioLimited))
             {
                 char buf[128];
                 char buf2[128];
                 char buf3[128];
 
-                printf( "LIMITS\n" );
-                printf( "  Peer limit: %" PRId64 "\n", peerLimit );
+                printf ("LIMITS\n");
+                printf ("  Peer limit: %" PRId64 "\n", peerLimit);
 
-                if( seedRatioLimited )
-                    tr_snprintf( buf, sizeof( buf ), "%.2f", seedRatioLimit );
+                if (seedRatioLimited)
+                    tr_snprintf (buf, sizeof (buf), "%.2f", seedRatioLimit);
                 else
-                    tr_strlcpy( buf, "Unlimited", sizeof( buf ) );
-                printf( "  Default seed ratio limit: %s\n", buf );
+                    tr_strlcpy (buf, "Unlimited", sizeof (buf));
+                printf ("  Default seed ratio limit: %s\n", buf);
 
-                if( altEnabled )
-                    tr_formatter_speed_KBps( buf, altUp, sizeof( buf ) );
-                else if( upEnabled )
-                    tr_formatter_speed_KBps( buf, upLimit, sizeof( buf ) );
+                if (altEnabled)
+                    tr_formatter_speed_KBps (buf, altUp, sizeof (buf));
+                else if (upEnabled)
+                    tr_formatter_speed_KBps (buf, upLimit, sizeof (buf));
                 else
-                    tr_strlcpy( buf, "Unlimited", sizeof( buf ) );
-                printf( "  Upload speed limit: %s  (%s limit: %s; %s turtle limit: %s)\n",
+                    tr_strlcpy (buf, "Unlimited", sizeof (buf));
+                printf ("  Upload speed limit: %s (%s limit: %s; %s turtle limit: %s)\n",
                         buf,
                         upEnabled ? "Enabled" : "Disabled",
-                        tr_formatter_speed_KBps( buf2, upLimit, sizeof( buf2 ) ),
+                        tr_formatter_speed_KBps (buf2, upLimit, sizeof (buf2)),
                         altEnabled ? "Enabled" : "Disabled",
-                        tr_formatter_speed_KBps( buf3, altUp, sizeof( buf3 ) ) );
+                        tr_formatter_speed_KBps (buf3, altUp, sizeof (buf3)));
 
-                if( altEnabled )
-                    tr_formatter_speed_KBps( buf, altDown, sizeof( buf ) );
-                else if( downEnabled )
-                    tr_formatter_speed_KBps( buf, downLimit, sizeof( buf ) );
+                if (altEnabled)
+                    tr_formatter_speed_KBps (buf, altDown, sizeof (buf));
+                else if (downEnabled)
+                    tr_formatter_speed_KBps (buf, downLimit, sizeof (buf));
                 else
-                    tr_strlcpy( buf, "Unlimited", sizeof( buf ) );
-                printf( "  Download speed limit: %s  (%s limit: %s; %s turtle limit: %s)\n",
+                    tr_strlcpy (buf, "Unlimited", sizeof (buf));
+                printf ("  Download speed limit: %s (%s limit: %s; %s turtle limit: %s)\n",
                         buf,
                         downEnabled ? "Enabled" : "Disabled",
-                        tr_formatter_speed_KBps( buf2, downLimit, sizeof( buf2 ) ),
+                        tr_formatter_speed_KBps (buf2, downLimit, sizeof (buf2)),
                         altEnabled ? "Enabled" : "Disabled",
-                        tr_formatter_speed_KBps( buf3, altDown, sizeof( buf3 ) ) );
-
-                if( altTimeEnabled ) {
-                    printf( "  Turtle schedule: %02d:%02d - %02d:%02d  ",
-                            (int)(altBegin/60), (int)(altBegin%60),
-                            (int)(altEnd/60), (int)(altEnd%60) );
-                    if( altDay & TR_SCHED_SUN )   printf( "Sun " );
-                    if( altDay & TR_SCHED_MON )   printf( "Mon " );
-                    if( altDay & TR_SCHED_TUES )  printf( "Tue " );
-                    if( altDay & TR_SCHED_WED )   printf( "Wed " );
-                    if( altDay & TR_SCHED_THURS ) printf( "Thu " );
-                    if( altDay & TR_SCHED_FRI )   printf( "Fri " );
-                    if( altDay & TR_SCHED_SAT )   printf( "Sat " );
-                    printf( "\n" );
+                        tr_formatter_speed_KBps (buf3, altDown, sizeof (buf3)));
+
+                if (altTimeEnabled) {
+                    printf ("  Turtle schedule: %02d:%02d - %02d:%02d  ",
+                          (int)(altBegin/60), (int)(altBegin%60),
+                          (int)(altEnd/60), (int)(altEnd%60));
+                    if (altDay & TR_SCHED_SUN)   printf ("Sun ");
+                    if (altDay & TR_SCHED_MON)   printf ("Mon ");
+                    if (altDay & TR_SCHED_TUES)  printf ("Tue ");
+                    if (altDay & TR_SCHED_WED)   printf ("Wed ");
+                    if (altDay & TR_SCHED_THURS) printf ("Thu ");
+                    if (altDay & TR_SCHED_FRI)   printf ("Fri ");
+                    if (altDay & TR_SCHED_SAT)   printf ("Sat ");
+                    printf ("\n");
                 }
             }
         }
-        printf( "\n" );
+        printf ("\n");
 
-        printf( "MISC\n" );
-        if( tr_bencDictFindBool( args, TR_PREFS_KEY_START, &boolVal ) )
-            printf( "  Autostart added torrents: %s\n", ( boolVal ? "Yes" : "No" ) );
-        if( tr_bencDictFindBool( args, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal ) )
-            printf( "  Delete automatically added torrents: %s\n", ( boolVal ? "Yes" : "No" ) );
+        printf ("MISC\n");
+        if (tr_bencDictFindBool (args, TR_PREFS_KEY_START, &boolVal))
+            printf ("  Autostart added torrents: %s\n", (boolVal ? "Yes" : "No"));
+        if (tr_bencDictFindBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal))
+            printf ("  Delete automatically added torrents: %s\n", (boolVal ? "Yes" : "No"));
     }
 }
 
 static void
-printSessionStats( tr_benc * top )
+printSessionStats (tr_benc * top)
 {
     tr_benc *args, *d;
-    if( ( tr_bencDictFindDict( top, "arguments", &args ) ) )
+    if ((tr_bencDictFindDict (top, "arguments", &args)))
     {
         char buf[512];
         int64_t up, down, secs, sessions;
 
-        if( tr_bencDictFindDict( args, "current-stats", &d )
-            && tr_bencDictFindInt( d, "uploadedBytes", &up )
-            && tr_bencDictFindInt( d, "downloadedBytes", &down )
-            && tr_bencDictFindInt( d, "secondsActive", &secs ) )
+        if (tr_bencDictFindDict (args, "current-stats", &d)
+            && tr_bencDictFindInt (d, "uploadedBytes", &up)
+            && tr_bencDictFindInt (d, "downloadedBytes", &down)
+            && tr_bencDictFindInt (d, "secondsActive", &secs))
         {
-            printf( "\nCURRENT SESSION\n" );
-            printf( "  Uploaded:   %s\n", strlsize( buf, up, sizeof( buf ) ) );
-            printf( "  Downloaded: %s\n", strlsize( buf, down, sizeof( buf ) ) );
-            printf( "  Ratio:      %s\n", strlratio( buf, up, down, sizeof( buf ) ) );
-            printf( "  Duration:   %s\n", tr_strltime( buf, secs, sizeof( buf ) ) );
+            printf ("\nCURRENT SESSION\n");
+            printf ("  Uploaded:   %s\n", strlsize (buf, up, sizeof (buf)));
+            printf ("  Downloaded: %s\n", strlsize (buf, down, sizeof (buf)));
+            printf ("  Ratio:      %s\n", strlratio (buf, up, down, sizeof (buf)));
+            printf ("  Duration:   %s\n", tr_strltime (buf, secs, sizeof (buf)));
         }
 
-        if( tr_bencDictFindDict( args, "cumulative-stats", &d )
-            && tr_bencDictFindInt( d, "sessionCount", &sessions )
-            && tr_bencDictFindInt( d, "uploadedBytes", &up )
-            && tr_bencDictFindInt( d, "downloadedBytes", &down )
-            && tr_bencDictFindInt( d, "secondsActive", &secs ) )
+        if (tr_bencDictFindDict (args, "cumulative-stats", &d)
+            && tr_bencDictFindInt (d, "sessionCount", &sessions)
+            && tr_bencDictFindInt (d, "uploadedBytes", &up)
+            && tr_bencDictFindInt (d, "downloadedBytes", &down)
+            && tr_bencDictFindInt (d, "secondsActive", &secs))
         {
-            printf( "\nTOTAL\n" );
-            printf( "  Started %lu times\n", (unsigned long)sessions );
-            printf( "  Uploaded:   %s\n", strlsize( buf, up, sizeof( buf ) ) );
-            printf( "  Downloaded: %s\n", strlsize( buf, down, sizeof( buf ) ) );
-            printf( "  Ratio:      %s\n", strlratio( buf, up, down, sizeof( buf ) ) );
-            printf( "  Duration:   %s\n", tr_strltime( buf, secs, sizeof( buf ) ) );
+            printf ("\nTOTAL\n");
+            printf ("  Started %lu times\n", (unsigned long)sessions);
+            printf ("  Uploaded:   %s\n", strlsize (buf, up, sizeof (buf)));
+            printf ("  Downloaded: %s\n", strlsize (buf, down, sizeof (buf)));
+            printf ("  Ratio:      %s\n", strlratio (buf, up, down, sizeof (buf)));
+            printf ("  Duration:   %s\n", tr_strltime (buf, secs, sizeof (buf)));
         }
     }
 }
@@ -1638,19 +1638,19 @@ printSessionStats( tr_benc * top )
 static char id[4096];
 
 static int
-processResponse( const char * rpcurl, const void * response, size_t len )
+processResponse (const char * rpcurl, const void * response, size_t len)
 {
     tr_benc top;
     int status = EXIT_SUCCESS;
 
-    if( debug )
-        fprintf( stderr, "got response (len %d):\n--------\n%*.*s\n--------\n",
-                 (int)len, (int)len, (int)len, (const char*) response );
+    if (debug)
+        fprintf (stderr, "got response (len %d):\n--------\n%*.*s\n--------\n",
+               (int)len, (int)len, (int)len, (const char*) response);
 
-    if( tr_jsonParse( NULL, response, len, &top, NULL ) )
+    if (tr_jsonParse (NULL, response, len, &top, NULL))
     {
-        tr_nerr( MY_NAME, "Unable to parse response \"%*.*s\"", (int)len,
-                 (int)len, (char*)response );
+        tr_nerr (MY_NAME, "Unable to parse response \"%*.*s\"", (int)len,
+               (int)len, (char*)response);
         status |= EXIT_FAILURE;
     }
     else
@@ -1658,66 +1658,66 @@ processResponse( const char * rpcurl, const void * response, size_t len )
         int64_t      tag = -1;
         const char * str;
 
-        if(tr_bencDictFindStr(&top, "result", &str))
+        if (tr_bencDictFindStr (&top, "result", &str))
         {
-            if( strcmp( str, "success") )
+            if (strcmp (str, "success"))
             {
-                printf( "Error: %s\n", str );
+                printf ("Error: %s\n", str);
                 status |= EXIT_FAILURE;
             }
             else
             {
-        tr_bencDictFindInt( &top, "tag", &tag );
+        tr_bencDictFindInt (&top, "tag", &tag);
 
-        switch( tag )
+        switch (tag)
         {
             case TAG_SESSION:
-                printSession( &top ); break;
+                printSession (&top); break;
 
             case TAG_STATS:
-                printSessionStats( &top ); break;
+                printSessionStats (&top); break;
 
             case TAG_DETAILS:
-                printDetails( &top ); break;
+                printDetails (&top); break;
 
             case TAG_FILES:
-                printFileList( &top ); break;
+                printFileList (&top); break;
 
             case TAG_LIST:
-                printTorrentList( &top ); break;
+                printTorrentList (&top); break;
 
             case TAG_PEERS:
-                printPeers( &top ); break;
+                printPeers (&top); break;
 
             case TAG_PIECES:
-                printPieces( &top ); break;
+                printPieces (&top); break;
 
             case TAG_PORTTEST:
-                printPortTest( &top ); break;
+                printPortTest (&top); break;
 
             case TAG_TRACKERS:
-                printTrackers( &top ); break;
+                printTrackers (&top); break;
 
             case TAG_TORRENT_ADD: {
                 int64_t i;
                 tr_benc * b = &top;
-                if( tr_bencDictFindDict( &top, ARGUMENTS, &b )
-                        && tr_bencDictFindDict( b, "torrent-added", &b )
-                        && tr_bencDictFindInt( b, "id", &i ) )
-                    tr_snprintf( id, sizeof(id), "%"PRId64, i );
+                if (tr_bencDictFindDict (&top, ARGUMENTS, &b)
+                        && tr_bencDictFindDict (b, "torrent-added", &b)
+                        && tr_bencDictFindInt (b, "id", &i))
+                    tr_snprintf (id, sizeof (id), "%"PRId64, i);
                 /* fall-through to default: to give success or failure msg */
             }
             default:
-                if( !tr_bencDictFindStr( &top, "result", &str ) )
+                if (!tr_bencDictFindStr (&top, "result", &str))
                     status |= EXIT_FAILURE;
                 else {
-                    printf( "%s responded: \"%s\"\n", rpcurl, str );
-                    if( strcmp( str, "success") )
+                    printf ("%s responded: \"%s\"\n", rpcurl, str);
+                    if (strcmp (str, "success"))
                         status |= EXIT_FAILURE;
                 }
         }
 
-        tr_bencFree( &top );
+        tr_bencFree (&top);
     }
         }
         else
@@ -1728,129 +1728,129 @@ processResponse( const char * rpcurl, const void * response, size_t len )
 }
 
 static CURL*
-tr_curl_easy_init( struct evbuffer * writebuf )
+tr_curl_easy_init (struct evbuffer * writebuf)
 {
-    CURL * curl = curl_easy_init( );
-    curl_easy_setopt( curl, CURLOPT_USERAGENT, MY_NAME "/" LONG_VERSION_STRING );
-    curl_easy_setopt( curl, CURLOPT_WRITEFUNCTION, writeFunc );
-    curl_easy_setopt( curl, CURLOPT_WRITEDATA, writebuf );
-    curl_easy_setopt( curl, CURLOPT_HEADERFUNCTION, parseResponseHeader );
-    curl_easy_setopt( curl, CURLOPT_POST, 1 );
-    curl_easy_setopt( curl, CURLOPT_NETRC, CURL_NETRC_OPTIONAL );
-    curl_easy_setopt( curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY );
-    curl_easy_setopt( curl, CURLOPT_VERBOSE, debug );
-    curl_easy_setopt( curl, CURLOPT_ENCODING, "" ); /* "" tells curl to fill in the blanks with what it was compiled to support */
-    if( netrc )
-        curl_easy_setopt( curl, CURLOPT_NETRC_FILE, netrc );
-    if( auth )
-        curl_easy_setopt( curl, CURLOPT_USERPWD, auth );
-    if( UseSSL )
-        curl_easy_setopt( curl, CURLOPT_SSL_VERIFYPEER, 0 ); /* since most certs will be self-signed, do not verify against CA */		
-    if( sessionId ) {
-        char * h = tr_strdup_printf( "%s: %s", TR_RPC_SESSION_ID_HEADER, sessionId );
-        struct curl_slist * custom_headers = curl_slist_append( NULL, h );
-        curl_easy_setopt( curl, CURLOPT_HTTPHEADER, custom_headers );
+    CURL * curl = curl_easy_init ();
+    curl_easy_setopt (curl, CURLOPT_USERAGENT, MY_NAME "/" LONG_VERSION_STRING);
+    curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, writeFunc);
+    curl_easy_setopt (curl, CURLOPT_WRITEDATA, writebuf);
+    curl_easy_setopt (curl, CURLOPT_HEADERFUNCTION, parseResponseHeader);
+    curl_easy_setopt (curl, CURLOPT_POST, 1);
+    curl_easy_setopt (curl, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
+    curl_easy_setopt (curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
+    curl_easy_setopt (curl, CURLOPT_VERBOSE, debug);
+    curl_easy_setopt (curl, CURLOPT_ENCODING, ""); /* "" tells curl to fill in the blanks with what it was compiled to support */
+    if (netrc)
+        curl_easy_setopt (curl, CURLOPT_NETRC_FILE, netrc);
+    if (auth)
+        curl_easy_setopt (curl, CURLOPT_USERPWD, auth);
+    if (UseSSL)
+        curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, 0); /* since most certs will be self-signed, do not verify against CA */		
+    if (sessionId) {
+        char * h = tr_strdup_printf ("%s: %s", TR_RPC_SESSION_ID_HEADER, sessionId);
+        struct curl_slist * custom_headers = curl_slist_append (NULL, h);
+        curl_easy_setopt (curl, CURLOPT_HTTPHEADER, custom_headers);
         /* fixme: leaks */
     }
     return curl;
 }
 
 static int
-flush( const char * rpcurl, tr_benc ** benc )
+flush (const char * rpcurl, tr_benc ** benc)
 {
     CURLcode res;
     CURL * curl;
     int status = EXIT_SUCCESS;
-    struct evbuffer * buf = evbuffer_new( );
-    char * json = tr_bencToStr( *benc, TR_FMT_JSON_LEAN, NULL );
-    char *rpcurl_http =  tr_strdup_printf( UseSSL? "https://%s" : "http://%s", rpcurl );
+    struct evbuffer * buf = evbuffer_new ();
+    char * json = tr_bencToStr (*benc, TR_FMT_JSON_LEAN, NULL);
+    char *rpcurl_http =  tr_strdup_printf (UseSSL? "https://%s" : "http://%s", rpcurl);
 
-    curl = tr_curl_easy_init( buf );
-    curl_easy_setopt( curl, CURLOPT_URL, rpcurl_http );
-    curl_easy_setopt( curl, CURLOPT_POSTFIELDS, json );
-    curl_easy_setopt( curl, CURLOPT_TIMEOUT, getTimeoutSecs( json ) );
+    curl = tr_curl_easy_init (buf);
+    curl_easy_setopt (curl, CURLOPT_URL, rpcurl_http);
+    curl_easy_setopt (curl, CURLOPT_POSTFIELDS, json);
+    curl_easy_setopt (curl, CURLOPT_TIMEOUT, getTimeoutSecs (json));
 
-    if( debug )
-        fprintf( stderr, "posting:\n--------\n%s\n--------\n", json );
+    if (debug)
+        fprintf (stderr, "posting:\n--------\n%s\n--------\n", json);
 
-    if(( res = curl_easy_perform( curl )))
+    if ((res = curl_easy_perform (curl)))
     {
-        tr_nerr( MY_NAME, "(%s) %s", rpcurl_http, curl_easy_strerror( res ) );
+        tr_nerr (MY_NAME, " (%s) %s", rpcurl_http, curl_easy_strerror (res));
         status |= EXIT_FAILURE;
     }
     else
     {
         long response;
-        curl_easy_getinfo( curl, CURLINFO_RESPONSE_CODE, &response );
-        switch( response ) {
+        curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &response);
+        switch (response) {
             case 200:
-                status |= processResponse( rpcurl, (const char*) evbuffer_pullup( buf, -1 ), evbuffer_get_length( buf ) );
+                status |= processResponse (rpcurl, (const char*) evbuffer_pullup (buf, -1), evbuffer_get_length (buf));
                 break;
             case 409:
                 /* Session id failed. Our curl header func has already
                  * pulled the new session id from this response's headers,
                  * build a new CURL* and try again */
-                curl_easy_cleanup( curl );
+                curl_easy_cleanup (curl);
                 curl = NULL;
-                status |= flush( rpcurl, benc );
+                status |= flush (rpcurl, benc);
                 benc = NULL;
                 break;
             default:
-                fprintf( stderr, "Unexpected response: %s\n", evbuffer_pullup( buf, -1 ) );
+                fprintf (stderr, "Unexpected response: %s\n", evbuffer_pullup (buf, -1));
                 status |= EXIT_FAILURE;
                 break;
         }
     }
 
     /* cleanup */
-    tr_free( rpcurl_http );
-    tr_free( json );
-    evbuffer_free( buf );
-    if( curl != 0 )
-        curl_easy_cleanup( curl );
-    if( benc != NULL ) {
-        tr_bencFree( *benc );
+    tr_free (rpcurl_http);
+    tr_free (json);
+    evbuffer_free (buf);
+    if (curl != 0)
+        curl_easy_cleanup (curl);
+    if (benc != NULL) {
+        tr_bencFree (*benc);
         *benc = 0;
     }
     return status;
 }
 
 static tr_benc*
-ensure_sset( tr_benc ** sset )
+ensure_sset (tr_benc ** sset)
 {
     tr_benc * args;
 
-    if( *sset )
-        args = tr_bencDictFind( *sset, ARGUMENTS );
+    if (*sset)
+        args = tr_bencDictFind (*sset, ARGUMENTS);
     else {
-        *sset = tr_new0( tr_benc, 1 );
-        tr_bencInitDict( *sset, 3 );
-        tr_bencDictAddStr( *sset, "method", "session-set" );
-        args = tr_bencDictAddDict( *sset, ARGUMENTS, 0 );
+        *sset = tr_new0 (tr_benc, 1);
+        tr_bencInitDict (*sset, 3);
+        tr_bencDictAddStr (*sset, "method", "session-set");
+        args = tr_bencDictAddDict (*sset, ARGUMENTS, 0);
     }
 
     return args;
 }
 
 static tr_benc*
-ensure_tset( tr_benc ** tset )
+ensure_tset (tr_benc ** tset)
 {
     tr_benc * args;
 
-    if( *tset )
-        args = tr_bencDictFind( *tset, ARGUMENTS );
+    if (*tset)
+        args = tr_bencDictFind (*tset, ARGUMENTS);
     else {
-        *tset = tr_new0( tr_benc, 1 );
-        tr_bencInitDict( *tset, 3 );
-        tr_bencDictAddStr( *tset, "method", "torrent-set" );
-        args = tr_bencDictAddDict( *tset, ARGUMENTS, 1 );
+        *tset = tr_new0 (tr_benc, 1);
+        tr_bencInitDict (*tset, 3);
+        tr_bencDictAddStr (*tset, "method", "torrent-set");
+        args = tr_bencDictAddDict (*tset, ARGUMENTS, 1);
     }
 
     return args;
 }
 
 static int
-processArgs( const char * rpcurl, int argc, const char ** argv )
+processArgs (const char * rpcurl, int argc, const char ** argv)
 {
     int c;
     int status = EXIT_SUCCESS;
@@ -1861,23 +1861,23 @@ processArgs( const char * rpcurl, int argc, const char ** argv )
 
     *id = '\0';
 
-    while(( c = tr_getopt( getUsage( ), argc, argv, opts, &optarg )))
+    while ((c = tr_getopt (getUsage (), argc, argv, opts, &optarg)))
     {
-        const int stepMode = getOptMode( c );
+        const int stepMode = getOptMode (c);
 
-        if( !stepMode ) /* meta commands */
+        if (!stepMode) /* meta commands */
         {
-            switch( c )
+            switch (c)
             {
                 case 'a': /* add torrent */
-                    if( sset != 0 ) status |= flush( rpcurl, &sset );
-                    if( tadd != 0 ) status |= flush( rpcurl, &tadd );
-                    if( tset != 0 ) { addIdArg( tr_bencDictFind( tset, ARGUMENTS ), id ); status |= flush( rpcurl, &tset ); }
-                    tadd = tr_new0( tr_benc, 1 );
-                    tr_bencInitDict( tadd, 3 );
-                    tr_bencDictAddStr( tadd, "method", "torrent-add" );
-                    tr_bencDictAddInt( tadd, "tag", TAG_TORRENT_ADD );
-                    tr_bencDictAddDict( tadd, ARGUMENTS, 0 );
+                    if (sset != 0) status |= flush (rpcurl, &sset);
+                    if (tadd != 0) status |= flush (rpcurl, &tadd);
+                    if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
+                    tadd = tr_new0 (tr_benc, 1);
+                    tr_bencInitDict (tadd, 3);
+                    tr_bencDictAddStr (tadd, "method", "torrent-add");
+                    tr_bencDictAddInt (tadd, "tag", TAG_TORRENT_ADD);
+                    tr_bencDictAddDict (tadd, ARGUMENTS, 0);
                     break;
 
                 case 'b': /* debug */
@@ -1885,22 +1885,22 @@ processArgs( const char * rpcurl, int argc, const char ** argv )
                     break;
 
                 case 'n': /* auth */
-                    auth = tr_strdup( optarg );
+                    auth = tr_strdup (optarg);
                     break;
 
                 case 810: /* authenv */
                     {
-                        char *authenv = getenv("TR_AUTH");
-                        if( !authenv ) {
-                            fprintf( stderr, "The TR_AUTH environment variable is not set\n" );
-                            exit( 0 );
+                        char *authenv = getenv ("TR_AUTH");
+                        if (!authenv) {
+                            fprintf (stderr, "The TR_AUTH environment variable is not set\n");
+                            exit (0);
                         }
-                        auth = tr_strdup( authenv );
+                        auth = tr_strdup (authenv);
                     }
                     break;
 
                 case 'N': /* netrc */
-                    netrc = tr_strdup( optarg );
+                    netrc = tr_strdup (optarg);
                     break;
 
                 case 820: /* UseSSL */
@@ -1908,504 +1908,504 @@ processArgs( const char * rpcurl, int argc, const char ** argv )
                     break;
 
                 case 't': /* set current torrent */
-                    if( tadd != 0 ) status |= flush( rpcurl, &tadd );
-                    if( tset != 0 ) { addIdArg( tr_bencDictFind( tset, ARGUMENTS ), id ); status |= flush( rpcurl, &tset ); }
-                    tr_strlcpy( id, optarg, sizeof( id ) );
+                    if (tadd != 0) status |= flush (rpcurl, &tadd);
+                    if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
+                    tr_strlcpy (id, optarg, sizeof (id));
                     break;
 
                 case 'V': /* show version number */
-                    fprintf( stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING );
-                    exit( 0 );
+                    fprintf (stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING);
+                    exit (0);
                     break;
 
                 case TR_OPT_ERR:
-                    fprintf( stderr, "invalid option\n" );
-                    showUsage( );
+                    fprintf (stderr, "invalid option\n");
+                    showUsage ();
                     status |= EXIT_FAILURE;
                     break;
 
                 case TR_OPT_UNK:
-                    if( tadd ) {
-                        tr_benc * args = tr_bencDictFind( tadd, ARGUMENTS );
-                        char * tmp = getEncodedMetainfo( optarg );
-                        if( tmp )
-                            tr_bencDictAddStr( args, "metainfo", tmp );
+                    if (tadd) {
+                        tr_benc * args = tr_bencDictFind (tadd, ARGUMENTS);
+                        char * tmp = getEncodedMetainfo (optarg);
+                        if (tmp)
+                            tr_bencDictAddStr (args, "metainfo", tmp);
                         else
-                            tr_bencDictAddStr( args, "filename", optarg );
-                        tr_free( tmp );
+                            tr_bencDictAddStr (args, "filename", optarg);
+                        tr_free (tmp);
                     } else {
-                        fprintf( stderr, "Unknown option: %s\n", optarg );
+                        fprintf (stderr, "Unknown option: %s\n", optarg);
                         status |= EXIT_FAILURE;
                     }
                     break;
             }
         }
-        else if( stepMode == MODE_TORRENT_GET )
+        else if (stepMode == MODE_TORRENT_GET)
         {
             size_t i, n;
-            tr_benc * top = tr_new0( tr_benc, 1 );
+            tr_benc * top = tr_new0 (tr_benc, 1);
             tr_benc * args;
             tr_benc * fields;
-            tr_bencInitDict( top, 3 );
-            tr_bencDictAddStr( top, "method", "torrent-get" );
-            args = tr_bencDictAddDict( top, ARGUMENTS, 0 );
-            fields = tr_bencDictAddList( args, "fields", 0 );
+            tr_bencInitDict (top, 3);
+            tr_bencDictAddStr (top, "method", "torrent-get");
+            args = tr_bencDictAddDict (top, ARGUMENTS, 0);
+            fields = tr_bencDictAddList (args, "fields", 0);
 
-            if( tset != 0 ) { addIdArg( tr_bencDictFind( tset, ARGUMENTS ), id ); status |= flush( rpcurl, &tset ); }
+            if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
 
-            switch( c )
+            switch (c)
             {
-                case 'i': tr_bencDictAddInt( top, "tag", TAG_DETAILS );
-                          n = TR_N_ELEMENTS( details_keys );
-                          for( i=0; i<n; ++i ) tr_bencListAddStr( fields, details_keys[i] );
-                          addIdArg( args, id );
-                          break;
-                case 'l': tr_bencDictAddInt( top, "tag", TAG_LIST );
-                          n = TR_N_ELEMENTS( list_keys );
-                          for( i=0; i<n; ++i ) tr_bencListAddStr( fields, list_keys[i] );
-                          break;
-                case 940: tr_bencDictAddInt( top, "tag", TAG_FILES );
-                          n = TR_N_ELEMENTS( files_keys );
-                          for( i=0; i<n; ++i ) tr_bencListAddStr( fields, files_keys[i] );
-                          addIdArg( args, id );
-                          break;
-                case 941: tr_bencDictAddInt( top, "tag", TAG_PEERS );
-                          tr_bencListAddStr( fields, "peers" );
-                          addIdArg( args, id );
-                          break;
-                case 942: tr_bencDictAddInt( top, "tag", TAG_PIECES );
-                          tr_bencListAddStr( fields, "pieces" );
-                          tr_bencListAddStr( fields, "pieceCount" );
-                          addIdArg( args, id );
-                          break;
-                case 943: tr_bencDictAddInt( top, "tag", TAG_TRACKERS );
-                          tr_bencListAddStr( fields, "trackerStats" );
-                          addIdArg( args, id );
-                          break;
-                default:  assert( "unhandled value" && 0 );
+                case 'i': tr_bencDictAddInt (top, "tag", TAG_DETAILS);
+                          n = TR_N_ELEMENTS (details_keys);
+                          for (i=0; i<n; ++i) tr_bencListAddStr (fields, details_keys[i]);
+                          addIdArg (args, id);
+                          break;
+                case 'l': tr_bencDictAddInt (top, "tag", TAG_LIST);
+                          n = TR_N_ELEMENTS (list_keys);
+                          for (i=0; i<n; ++i) tr_bencListAddStr (fields, list_keys[i]);
+                          break;
+                case 940: tr_bencDictAddInt (top, "tag", TAG_FILES);
+                          n = TR_N_ELEMENTS (files_keys);
+                          for (i=0; i<n; ++i) tr_bencListAddStr (fields, files_keys[i]);
+                          addIdArg (args, id);
+                          break;
+                case 941: tr_bencDictAddInt (top, "tag", TAG_PEERS);
+                          tr_bencListAddStr (fields, "peers");
+                          addIdArg (args, id);
+                          break;
+                case 942: tr_bencDictAddInt (top, "tag", TAG_PIECES);
+                          tr_bencListAddStr (fields, "pieces");
+                          tr_bencListAddStr (fields, "pieceCount");
+                          addIdArg (args, id);
+                          break;
+                case 943: tr_bencDictAddInt (top, "tag", TAG_TRACKERS);
+                          tr_bencListAddStr (fields, "trackerStats");
+                          addIdArg (args, id);
+                          break;
+                default:  assert ("unhandled value" && 0);
             }
 
-            status |= flush( rpcurl, &top );
+            status |= flush (rpcurl, &top);
         }
-        else if( stepMode == MODE_SESSION_SET )
+        else if (stepMode == MODE_SESSION_SET)
         {
-            tr_benc * args = ensure_sset( &sset );
+            tr_benc * args = ensure_sset (&sset);
 
-            switch( c )
+            switch (c)
             {
-                case 800: tr_bencDictAddStr( args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg );
-                          tr_bencDictAddBool( args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true );
+                case 800: tr_bencDictAddStr (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg);
+                          tr_bencDictAddBool (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true);
                           break;
-                case 801: tr_bencDictAddBool( args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, false );
+                case 801: tr_bencDictAddBool (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, false);
                           break;
-                case 970: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, true );
+                case 970: tr_bencDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, true);
                           break;
-                case 971: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, false );
+                case 971: tr_bencDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, false);
                           break;
-                case 972: tr_bencDictAddInt( args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, numarg( optarg ) );
+                case 972: tr_bencDictAddInt (args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, numarg (optarg));
                           break;
-                case 973: tr_bencDictAddInt( args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, numarg( optarg ) );
+                case 973: tr_bencDictAddInt (args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, numarg (optarg));
                           break;
-                case 974: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, true );
+                case 974: tr_bencDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, true);
                           break;
-                case 975: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, false );
+                case 975: tr_bencDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, false);
                           break;
-                case 976: addTime( args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, optarg );
+                case 976: addTime (args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, optarg);
                           break;
-                case 977: addTime( args, TR_PREFS_KEY_ALT_SPEED_TIME_END, optarg );
+                case 977: addTime (args, TR_PREFS_KEY_ALT_SPEED_TIME_END, optarg);
                           break;
-                case 978: addDays( args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, optarg );
+                case 978: addDays (args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, optarg);
                           break;
-                case 'c': tr_bencDictAddStr( args, TR_PREFS_KEY_INCOMPLETE_DIR, optarg );
-                          tr_bencDictAddBool( args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true );
+                case 'c': tr_bencDictAddStr (args, TR_PREFS_KEY_INCOMPLETE_DIR, optarg);
+                          tr_bencDictAddBool (args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true);
                           break;
-                case 'C': tr_bencDictAddBool( args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false );
+                case 'C': tr_bencDictAddBool (args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false);
                           break;
-                case 'e': tr_bencDictAddInt( args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, atoi(optarg) );
+                case 'e': tr_bencDictAddInt (args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, atoi (optarg));
                           break;
-                case 910: tr_bencDictAddStr( args, TR_PREFS_KEY_ENCRYPTION, "required" );
+                case 910: tr_bencDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "required");
                           break;
-                case 911: tr_bencDictAddStr( args, TR_PREFS_KEY_ENCRYPTION, "preferred" );
+                case 911: tr_bencDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "preferred");
                           break;
-                case 912: tr_bencDictAddStr( args, TR_PREFS_KEY_ENCRYPTION, "tolerated" );
+                case 912: tr_bencDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "tolerated");
                           break;
-                case 'm': tr_bencDictAddBool( args, TR_PREFS_KEY_PORT_FORWARDING, true );
+                case 'm': tr_bencDictAddBool (args, TR_PREFS_KEY_PORT_FORWARDING, true);
                           break;
-                case 'M': tr_bencDictAddBool( args, TR_PREFS_KEY_PORT_FORWARDING, false );
+                case 'M': tr_bencDictAddBool (args, TR_PREFS_KEY_PORT_FORWARDING, false);
                           break;
-                case 'o': tr_bencDictAddBool( args, TR_PREFS_KEY_DHT_ENABLED, true );
+                case 'o': tr_bencDictAddBool (args, TR_PREFS_KEY_DHT_ENABLED, true);
                           break;
-                case 'O': tr_bencDictAddBool( args, TR_PREFS_KEY_DHT_ENABLED, false );
+                case 'O': tr_bencDictAddBool (args, TR_PREFS_KEY_DHT_ENABLED, false);
                           break;
-                case 830: tr_bencDictAddBool( args, TR_PREFS_KEY_UTP_ENABLED, true );
+                case 830: tr_bencDictAddBool (args, TR_PREFS_KEY_UTP_ENABLED, true);
                           break;
-                case 831: tr_bencDictAddBool( args, TR_PREFS_KEY_UTP_ENABLED, false );
+                case 831: tr_bencDictAddBool (args, TR_PREFS_KEY_UTP_ENABLED, false);
                           break;
-                case 'p': tr_bencDictAddInt( args, TR_PREFS_KEY_PEER_PORT, numarg( optarg ) );
+                case 'p': tr_bencDictAddInt (args, TR_PREFS_KEY_PEER_PORT, numarg (optarg));
                           break;
-                case 'P': tr_bencDictAddBool( args, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, true);
+                case 'P': tr_bencDictAddBool (args, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, true);
                           break;
-                case 'x': tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, true );
+                case 'x': tr_bencDictAddBool (args, TR_PREFS_KEY_PEX_ENABLED, true);
                           break;
-                case 'X': tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, false );
+                case 'X': tr_bencDictAddBool (args, TR_PREFS_KEY_PEX_ENABLED, false);
                           break;
-                case 'y': tr_bencDictAddBool( args, TR_PREFS_KEY_LPD_ENABLED, true );
+                case 'y': tr_bencDictAddBool (args, TR_PREFS_KEY_LPD_ENABLED, true);
                           break;
-                case 'Y': tr_bencDictAddBool( args, TR_PREFS_KEY_LPD_ENABLED, false );
+                case 'Y': tr_bencDictAddBool (args, TR_PREFS_KEY_LPD_ENABLED, false);
                           break;
-                case 953: tr_bencDictAddReal( args, "seedRatioLimit", atof(optarg) );
-                          tr_bencDictAddBool( args, "seedRatioLimited", true );
+                case 953: tr_bencDictAddReal (args, "seedRatioLimit", atof (optarg));
+                          tr_bencDictAddBool (args, "seedRatioLimited", true);
                           break;
-                case 954: tr_bencDictAddBool( args, "seedRatioLimited", false );
+                case 954: tr_bencDictAddBool (args, "seedRatioLimited", false);
                           break;
-                case 990: tr_bencDictAddBool( args, TR_PREFS_KEY_START, false );
+                case 990: tr_bencDictAddBool (args, TR_PREFS_KEY_START, false);
                           break;
-                case 991: tr_bencDictAddBool( args, TR_PREFS_KEY_START, true );
+                case 991: tr_bencDictAddBool (args, TR_PREFS_KEY_START, true);
                           break;
-                case 992: tr_bencDictAddBool( args, TR_PREFS_KEY_TRASH_ORIGINAL, true );
+                case 992: tr_bencDictAddBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, true);
                           break;
-                case 993: tr_bencDictAddBool( args, TR_PREFS_KEY_TRASH_ORIGINAL, false );
+                case 993: tr_bencDictAddBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, false);
                           break;
-                default:  assert( "unhandled value" && 0 );
+                default:  assert ("unhandled value" && 0);
                           break;
             }
         }
-        else if( stepMode == ( MODE_SESSION_SET | MODE_TORRENT_SET ) )
+        else if (stepMode == (MODE_SESSION_SET | MODE_TORRENT_SET))
         {
             tr_benc * targs = 0;
             tr_benc * sargs = 0;
 
-            if( *id )
-                targs = ensure_tset( &tset );
+            if (*id)
+                targs = ensure_tset (&tset);
             else
-                sargs = ensure_sset( &sset );
+                sargs = ensure_sset (&sset);
 
-            switch( c )
+            switch (c)
             {
-                case 'd': if( targs ) {
-                              tr_bencDictAddInt( targs, "downloadLimit", numarg( optarg ) );
-                              tr_bencDictAddBool( targs, "downloadLimited", true );
+                case 'd': if (targs) {
+                              tr_bencDictAddInt (targs, "downloadLimit", numarg (optarg));
+                              tr_bencDictAddBool (targs, "downloadLimited", true);
                           } else {
-                              tr_bencDictAddInt( sargs, TR_PREFS_KEY_DSPEED_KBps, numarg( optarg ) );
-                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_DSPEED_ENABLED, true );
+                              tr_bencDictAddInt (sargs, TR_PREFS_KEY_DSPEED_KBps, numarg (optarg));
+                              tr_bencDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, true);
                           }
                           break;
-                case 'D': if( targs )
-                              tr_bencDictAddBool( targs, "downloadLimited", false );
+                case 'D': if (targs)
+                              tr_bencDictAddBool (targs, "downloadLimited", false);
                           else
-                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_DSPEED_ENABLED, false );
+                              tr_bencDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, false);
                           break;
-                case 'u': if( targs ) {
-                              tr_bencDictAddInt( targs, "uploadLimit", numarg( optarg ) );
-                              tr_bencDictAddBool( targs, "uploadLimited", true );
+                case 'u': if (targs) {
+                              tr_bencDictAddInt (targs, "uploadLimit", numarg (optarg));
+                              tr_bencDictAddBool (targs, "uploadLimited", true);
                           } else {
-                              tr_bencDictAddInt( sargs, TR_PREFS_KEY_USPEED_KBps, numarg( optarg ) );
-                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_USPEED_ENABLED, true );
+                              tr_bencDictAddInt (sargs, TR_PREFS_KEY_USPEED_KBps, numarg (optarg));
+                              tr_bencDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, true);
                           }
                           break;
-                case 'U': if( targs )
-                              tr_bencDictAddBool( targs, "uploadLimited", false );
+                case 'U': if (targs)
+                              tr_bencDictAddBool (targs, "uploadLimited", false);
                           else
-                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_USPEED_ENABLED, false );
+                              tr_bencDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, false);
                           break;
-                case 930: if( targs )
-                              tr_bencDictAddInt( targs, "peer-limit", atoi(optarg) );
+                case 930: if (targs)
+                              tr_bencDictAddInt (targs, "peer-limit", atoi (optarg));
                           else
-                              tr_bencDictAddInt( sargs, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi(optarg) );
+                              tr_bencDictAddInt (sargs, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi (optarg));
                           break;
-                default:  assert( "unhandled value" && 0 );
+                default:  assert ("unhandled value" && 0);
                           break;
             }
         }
-        else if( stepMode == MODE_TORRENT_SET )
+        else if (stepMode == MODE_TORRENT_SET)
         {
-            tr_benc * args = ensure_tset( &tset );
+            tr_benc * args = ensure_tset (&tset);
 
-            switch( c )
+            switch (c)
             {
-                case 712: tr_bencListAddInt( tr_bencDictAddList( args, "trackerRemove", 1 ), atoi( optarg ) );
+                case 712: tr_bencListAddInt (tr_bencDictAddList (args, "trackerRemove", 1), atoi (optarg));
                           break;
-                case 950: tr_bencDictAddReal( args, "seedRatioLimit", atof(optarg) );
-                          tr_bencDictAddInt( args, "seedRatioMode", TR_RATIOLIMIT_SINGLE );
+                case 950: tr_bencDictAddReal (args, "seedRatioLimit", atof (optarg));
+                          tr_bencDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_SINGLE);
                           break;
-                case 951: tr_bencDictAddInt( args, "seedRatioMode", TR_RATIOLIMIT_GLOBAL );
+                case 951: tr_bencDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_GLOBAL);
                           break;
-                case 952: tr_bencDictAddInt( args, "seedRatioMode", TR_RATIOLIMIT_UNLIMITED );
+                case 952: tr_bencDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_UNLIMITED);
                           break;
-                case 984: tr_bencDictAddBool( args, "honorsSessionLimits", true );
+                case 984: tr_bencDictAddBool (args, "honorsSessionLimits", true);
                           break;
-                case 985: tr_bencDictAddBool( args, "honorsSessionLimits", false );
+                case 985: tr_bencDictAddBool (args, "honorsSessionLimits", false);
                           break;
-                default:  assert( "unhandled value" && 0 );
+                default:  assert ("unhandled value" && 0);
                           break;
             }
         }
-        else if( stepMode == ( MODE_TORRENT_SET | MODE_TORRENT_ADD ) )
+        else if (stepMode == (MODE_TORRENT_SET | MODE_TORRENT_ADD))
         {
             tr_benc * args;
 
-            if( tadd )
-                args = tr_bencDictFind( tadd, ARGUMENTS );
+            if (tadd)
+                args = tr_bencDictFind (tadd, ARGUMENTS);
             else
-                args = ensure_tset( &tset );
+                args = ensure_tset (&tset);
 
-            switch( c )
+            switch (c)
             {
-                case 'g': addFiles( args, "files-wanted", optarg );
+                case 'g': addFiles (args, "files-wanted", optarg);
                           break;
-                case 'G': addFiles( args, "files-unwanted", optarg );
+                case 'G': addFiles (args, "files-unwanted", optarg);
                           break;
-                case 900: addFiles( args, "priority-high", optarg );
+                case 900: addFiles (args, "priority-high", optarg);
                           break;
-                case 901: addFiles( args, "priority-normal", optarg );
+                case 901: addFiles (args, "priority-normal", optarg);
                           break;
-                case 902: addFiles( args, "priority-low", optarg );
+                case 902: addFiles (args, "priority-low", optarg);
                           break;
-                case 700: tr_bencDictAddInt( args, "bandwidthPriority",  1 );
+                case 700: tr_bencDictAddInt (args, "bandwidthPriority",  1);
                           break;
-                case 701: tr_bencDictAddInt( args, "bandwidthPriority",  0 );
+                case 701: tr_bencDictAddInt (args, "bandwidthPriority",  0);
                           break;
-                case 702: tr_bencDictAddInt( args, "bandwidthPriority", -1 );
+                case 702: tr_bencDictAddInt (args, "bandwidthPriority", -1);
                           break;
-                case 710: tr_bencListAddStr( tr_bencDictAddList( args, "trackerAdd", 1 ), optarg );
+                case 710: tr_bencListAddStr (tr_bencDictAddList (args, "trackerAdd", 1), optarg);
                           break;
-                default:  assert( "unhandled value" && 0 );
+                default:  assert ("unhandled value" && 0);
                           break;
             }
         }
-        else if( c == 961 ) /* set location */
+        else if (c == 961) /* set location */
         {
-            if( tadd )
+            if (tadd)
             {
-                tr_benc * args = tr_bencDictFind( tadd, ARGUMENTS );
-                tr_bencDictAddStr( args, "download-dir", optarg );
+                tr_benc * args = tr_bencDictFind (tadd, ARGUMENTS);
+                tr_bencDictAddStr (args, "download-dir", optarg);
             }
             else
             {
                 tr_benc * args;
-                tr_benc * top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 2 );
-                tr_bencDictAddStr( top, "method", "torrent-set-location" );
-                args = tr_bencDictAddDict( top, ARGUMENTS, 3 );
-                tr_bencDictAddStr( args, "location", optarg );
-                tr_bencDictAddBool( args, "move", false );
-                addIdArg( args, id );
-                status |= flush( rpcurl, &top );
+                tr_benc * top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 2);
+                tr_bencDictAddStr (top, "method", "torrent-set-location");
+                args = tr_bencDictAddDict (top, ARGUMENTS, 3);
+                tr_bencDictAddStr (args, "location", optarg);
+                tr_bencDictAddBool (args, "move", false);
+                addIdArg (args, id);
+                status |= flush (rpcurl, &top);
                 break;
             }
         }
-        else switch( c )
+        else switch (c)
         {
             case 920: /* session-info */
             {
-                tr_benc * top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 2 );
-                tr_bencDictAddStr( top, "method", "session-get" );
-                tr_bencDictAddInt( top, "tag", TAG_SESSION );
-                status |= flush( rpcurl, &top );
+                tr_benc * top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 2);
+                tr_bencDictAddStr (top, "method", "session-get");
+                tr_bencDictAddInt (top, "tag", TAG_SESSION);
+                status |= flush (rpcurl, &top);
                 break;
             }
             case 's': /* start */
             {
-                if( tadd )
-                    tr_bencDictAddBool( tr_bencDictFind( tadd, "arguments" ), "paused", false );
+                if (tadd)
+                    tr_bencDictAddBool (tr_bencDictFind (tadd, "arguments"), "paused", false);
                 else {
-                    tr_benc * top = tr_new0( tr_benc, 1 );
-                    tr_bencInitDict( top, 2 );
-                    tr_bencDictAddStr( top, "method", "torrent-start" );
-                    addIdArg( tr_bencDictAddDict( top, ARGUMENTS, 1 ), id );
-                    status |= flush( rpcurl, &top );
+                    tr_benc * top = tr_new0 (tr_benc, 1);
+                    tr_bencInitDict (top, 2);
+                    tr_bencDictAddStr (top, "method", "torrent-start");
+                    addIdArg (tr_bencDictAddDict (top, ARGUMENTS, 1), id);
+                    status |= flush (rpcurl, &top);
                 }
                 break;
             }
             case 'S': /* stop */
             {
-                if( tadd )
-                    tr_bencDictAddBool( tr_bencDictFind( tadd, "arguments" ), "paused", true );
+                if (tadd)
+                    tr_bencDictAddBool (tr_bencDictFind (tadd, "arguments"), "paused", true);
                 else {
-                    tr_benc * top = tr_new0( tr_benc, 1 );
-                    tr_bencInitDict( top, 2 );
-                    tr_bencDictAddStr( top, "method", "torrent-stop" );
-                    addIdArg( tr_bencDictAddDict( top, ARGUMENTS, 1 ), id );
-                    status |= flush( rpcurl, &top );
+                    tr_benc * top = tr_new0 (tr_benc, 1);
+                    tr_bencInitDict (top, 2);
+                    tr_bencDictAddStr (top, "method", "torrent-stop");
+                    addIdArg (tr_bencDictAddDict (top, ARGUMENTS, 1), id);
+                    status |= flush (rpcurl, &top);
                 }
                 break;
             }
             case 'w':
             {
-                char * path = absolutify( optarg );
-                if( tadd )
-                    tr_bencDictAddStr( tr_bencDictFind( tadd, "arguments" ), "download-dir", path );
+                char * path = absolutify (optarg);
+                if (tadd)
+                    tr_bencDictAddStr (tr_bencDictFind (tadd, "arguments"), "download-dir", path);
                 else {
-                    tr_benc * args = ensure_sset( &sset );
-                    tr_bencDictAddStr( args, "download-dir", path );
+                    tr_benc * args = ensure_sset (&sset);
+                    tr_bencDictAddStr (args, "download-dir", path);
                 }
-                tr_free( path );
+                tr_free (path);
                 break;
             }
             case 850:
             {
-                tr_benc * top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 1 );
-                tr_bencDictAddStr( top, "method", "session-close" );
-                status |= flush( rpcurl, &top );
+                tr_benc * top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 1);
+                tr_bencDictAddStr (top, "method", "session-close");
+                status |= flush (rpcurl, &top);
                 break;
             }
             case 963:
             {
-                tr_benc * top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 1 );
-                tr_bencDictAddStr( top, "method", "blocklist-update" );
-                status |= flush( rpcurl, &top );
+                tr_benc * top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 1);
+                tr_bencDictAddStr (top, "method", "blocklist-update");
+                status |= flush (rpcurl, &top);
                 break;
             }
             case 921:
             {
-                tr_benc * top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 2 );
-                tr_bencDictAddStr( top, "method", "session-stats" );
-                tr_bencDictAddInt( top, "tag", TAG_STATS );
-                status |= flush( rpcurl, &top );
+                tr_benc * top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 2);
+                tr_bencDictAddStr (top, "method", "session-stats");
+                tr_bencDictAddInt (top, "tag", TAG_STATS);
+                status |= flush (rpcurl, &top);
                 break;
             }
             case 962:
             {
-                tr_benc * top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 2 );
-                tr_bencDictAddStr( top, "method", "port-test" );
-                tr_bencDictAddInt( top, "tag", TAG_PORTTEST );
-                status |= flush( rpcurl, &top );
+                tr_benc * top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 2);
+                tr_bencDictAddStr (top, "method", "port-test");
+                tr_bencDictAddInt (top, "tag", TAG_PORTTEST);
+                status |= flush (rpcurl, &top);
                 break;
             }
             case 600:
             {
                 tr_benc * top;
-                if( tset != 0 ) { addIdArg( tr_bencDictFind( tset, ARGUMENTS ), id ); status |= flush( rpcurl, &tset ); }
-                top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 2 );
-                tr_bencDictAddStr( top, "method", "torrent-reannounce" );
-                addIdArg( tr_bencDictAddDict( top, ARGUMENTS, 1 ), id );
-                status |= flush( rpcurl, &top );
+                if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
+                top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 2);
+                tr_bencDictAddStr (top, "method", "torrent-reannounce");
+                addIdArg (tr_bencDictAddDict (top, ARGUMENTS, 1), id);
+                status |= flush (rpcurl, &top);
                 break;
             }
             case 'v':
             {
                 tr_benc * top;
-                if( tset != 0 ) { addIdArg( tr_bencDictFind( tset, ARGUMENTS ), id ); status |= flush( rpcurl, &tset ); }
-                top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 2 );
-                tr_bencDictAddStr( top, "method", "torrent-verify" );
-                addIdArg( tr_bencDictAddDict( top, ARGUMENTS, 1 ), id );
-                status |= flush( rpcurl, &top );
+                if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
+                top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 2);
+                tr_bencDictAddStr (top, "method", "torrent-verify");
+                addIdArg (tr_bencDictAddDict (top, ARGUMENTS, 1), id);
+                status |= flush (rpcurl, &top);
                 break;
             }
             case 'r':
             case 'R':
             {
                 tr_benc * args;
-                tr_benc * top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 2 );
-                tr_bencDictAddStr( top, "method", "torrent-remove" );
-                args = tr_bencDictAddDict( top, ARGUMENTS, 2 );
-                tr_bencDictAddBool( args, "delete-local-data", c=='R' );
-                addIdArg( args, id );
-                status |= flush( rpcurl, &top );
+                tr_benc * top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 2);
+                tr_bencDictAddStr (top, "method", "torrent-remove");
+                args = tr_bencDictAddDict (top, ARGUMENTS, 2);
+                tr_bencDictAddBool (args, "delete-local-data", c=='R');
+                addIdArg (args, id);
+                status |= flush (rpcurl, &top);
                 break;
             }
             case 960:
             {
                 tr_benc * args;
-                tr_benc * top = tr_new0( tr_benc, 1 );
-                tr_bencInitDict( top, 2 );
-                tr_bencDictAddStr( top, "method", "torrent-set-location" );
-                args = tr_bencDictAddDict( top, ARGUMENTS, 3 );
-                tr_bencDictAddStr( args, "location", optarg );
-                tr_bencDictAddBool( args, "move", true );
-                addIdArg( args, id );
-                status |= flush( rpcurl, &top );
+                tr_benc * top = tr_new0 (tr_benc, 1);
+                tr_bencInitDict (top, 2);
+                tr_bencDictAddStr (top, "method", "torrent-set-location");
+                args = tr_bencDictAddDict (top, ARGUMENTS, 3);
+                tr_bencDictAddStr (args, "location", optarg);
+                tr_bencDictAddBool (args, "move", true);
+                addIdArg (args, id);
+                status |= flush (rpcurl, &top);
                 break;
             }
             default:
             {
-                fprintf( stderr, "got opt [%d]\n", c );
-                showUsage( );
+                fprintf (stderr, "got opt [%d]\n", c);
+                showUsage ();
                 break;
             }
         }
     }
 
-    if( tadd != 0 ) status |= flush( rpcurl, &tadd );
-    if( tset != 0 ) { addIdArg( tr_bencDictFind( tset, ARGUMENTS ), id ); status |= flush( rpcurl, &tset ); }
-    if( sset != 0 ) status |= flush( rpcurl, &sset );
+    if (tadd != 0) status |= flush (rpcurl, &tadd);
+    if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
+    if (sset != 0) status |= flush (rpcurl, &sset);
     return status;
 }
 
-/* [host:port] or [host] or [port] or [http(s?)://host:port/transmission/] */
+/* [host:port] or [host] or [port] or [http (s?)://host:port/transmission/] */
 static void
-getHostAndPortAndRpcUrl( int * argc, char ** argv,
-                         char ** host, int * port, char ** rpcurl )
+getHostAndPortAndRpcUrl (int * argc, char ** argv,
+                         char ** host, int * port, char ** rpcurl)
 {
-    if( *argv[1] != '-' )
+    if (*argv[1] != '-')
     {
         int          i;
         const char * s = argv[1];
-        const char * delim = strchr( s, ':' );
-        if( !strncmp(s, "http://", 7 ) )   /* user passed in http rpc url */
+        const char * delim = strchr (s, ':');
+        if (!strncmp (s, "http://", 7))   /* user passed in http rpc url */
         {
-            *rpcurl = tr_strdup_printf( "%s/rpc/", s + 7 );
+            *rpcurl = tr_strdup_printf ("%s/rpc/", s + 7);
         }
-        else if( !strncmp(s, "https://", 8) ) /* user passed in https rpc url */
+        else if (!strncmp (s, "https://", 8)) /* user passed in https rpc url */
         {
             UseSSL = true;
-            *rpcurl = tr_strdup_printf( "%s/rpc/", s + 8 );
+            *rpcurl = tr_strdup_printf ("%s/rpc/", s + 8);
         }
-        else if( delim )   /* user passed in both host and port */
+        else if (delim)   /* user passed in both host and port */
         {
-            *host = tr_strndup( s, delim - s );
-            *port = atoi( delim + 1 );
+            *host = tr_strndup (s, delim - s);
+            *port = atoi (delim + 1);
         }
         else
         {
             char *    end;
-            const int i = strtol( s, &end, 10 );
-            if( !*end ) /* user passed in a port */
+            const int i = strtol (s, &end, 10);
+            if (!*end) /* user passed in a port */
                 *port = i;
             else /* user passed in a host */
-                *host = tr_strdup( s );
+                *host = tr_strdup (s);
         }
 
         *argc -= 1;
-        for( i = 1; i < *argc; ++i )
+        for (i = 1; i < *argc; ++i)
             argv[i] = argv[i + 1];
     }
 }
 
 int
-main( int argc, char ** argv )
+main (int argc, char ** argv)
 {
     int port = DEFAULT_PORT;
     char * host = NULL;
     char * rpcurl = NULL;
     int exit_status = EXIT_SUCCESS;
 
-    if( argc < 2 ) {
-        showUsage( );
+    if (argc < 2) {
+        showUsage ();
         return EXIT_FAILURE;
     }
 
-    tr_formatter_mem_init( MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR );
-    tr_formatter_size_init( DISK_K,DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR );
-    tr_formatter_speed_init( SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR );
+    tr_formatter_mem_init (MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR);
+    tr_formatter_size_init (DISK_K,DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR);
+    tr_formatter_speed_init (SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR);
 
-    getHostAndPortAndRpcUrl( &argc, argv, &host, &port, &rpcurl );
-    if( host == NULL )
-        host = tr_strdup( DEFAULT_HOST );
-    if( rpcurl == NULL )
-        rpcurl = tr_strdup_printf( "%s:%d%s", host, port, DEFAULT_URL );
+    getHostAndPortAndRpcUrl (&argc, argv, &host, &port, &rpcurl);
+    if (host == NULL)
+        host = tr_strdup (DEFAULT_HOST);
+    if (rpcurl == NULL)
+        rpcurl = tr_strdup_printf ("%s:%d%s", host, port, DEFAULT_URL);
 
-    exit_status = processArgs( rpcurl, argc, (const char**)argv );
+    exit_status = processArgs (rpcurl, argc, (const char**)argv);
 
-    tr_free( host );
-    tr_free( rpcurl );
+    tr_free (host);
+    tr_free (rpcurl);
     return exit_status;
 }
diff --git a/daemon/watch.c b/daemon/watch.c
index a7971a31a..8976fca57 100644
--- a/daemon/watch.c
+++ b/daemon/watch.c
@@ -20,13 +20,13 @@
 #endif
 
 #include <errno.h>
-#include <string.h> /* strlen() */
-#include <stdio.h> /* perror() */
+#include <string.h> /* strlen () */
+#include <stdio.h> /* perror () */
 
 #include <dirent.h> /* readdir */
 
 #include <libtransmission/transmission.h>
-#include <libtransmission/utils.h> /* tr_buildPath(), tr_inf() */
+#include <libtransmission/utils.h> /* tr_buildPath (), tr_inf () */
 #include "watch.h"
 
 struct dtr_watchdir
@@ -46,69 +46,69 @@ struct dtr_watchdir
 ****  INOTIFY IMPLEMENTATION
 ***/
 
-#if defined(WITH_INOTIFY)
+#if defined (WITH_INOTIFY)
 
 /* how many inotify events to try to batch into a single read */
 #define EVENT_BATCH_COUNT 50
 /* size of the event structure, not counting name */
-#define EVENT_SIZE  (sizeof (struct inotify_event))
+#define EVENT_SIZE (sizeof (struct inotify_event))
 /* reasonable guess as to size of 50 events */
 #define BUF_LEN (EVENT_BATCH_COUNT * (EVENT_SIZE + 16) + 2048)
 
 #define DTR_INOTIFY_MASK (IN_CLOSE_WRITE|IN_MOVED_TO|IN_ONLYDIR)
 
 static void
-watchdir_new_impl( dtr_watchdir * w )
+watchdir_new_impl (dtr_watchdir * w)
 {
     int i;
     DIR * odir;
-    w->inotify_fd = inotify_init( );
+    w->inotify_fd = inotify_init ();
 
-    if( w->inotify_fd < 0 )
+    if (w->inotify_fd < 0)
     {
         i = -1;
     }
     else
     {
-        tr_inf( "Using inotify to watch directory \"%s\"", w->dir );
-        i = inotify_add_watch( w->inotify_fd, w->dir, DTR_INOTIFY_MASK );
+        tr_inf ("Using inotify to watch directory \"%s\"", w->dir);
+        i = inotify_add_watch (w->inotify_fd, w->dir, DTR_INOTIFY_MASK);
     }
 
-    if( i < 0 )
+    if (i < 0)
     {
-        tr_err( "Unable to watch \"%s\": %s", w->dir, tr_strerror( errno ) );
+        tr_err ("Unable to watch \"%s\": %s", w->dir, tr_strerror (errno));
     }
-    else if(( odir = opendir( w->dir )))
+    else if ((odir = opendir (w->dir)))
     {
         struct dirent * d;
 
-        while(( d = readdir( odir )))
+        while ((d = readdir (odir)))
         {
             const char * name = d->d_name;
 
-            if( !tr_str_has_suffix( name, ".torrent" ) ) /* skip non-torrents */
+            if (!tr_str_has_suffix (name, ".torrent")) /* skip non-torrents */
                 continue;
 
-            tr_inf( "Found new .torrent file \"%s\" in watchdir \"%s\"", name, w->dir );
-            w->callback( w->session, w->dir, name );
+            tr_inf ("Found new .torrent file \"%s\" in watchdir \"%s\"", name, w->dir);
+            w->callback (w->session, w->dir, name);
         }
 
-        closedir( odir );
+        closedir (odir);
     }
 
 }
 static void
-watchdir_free_impl( dtr_watchdir * w )
+watchdir_free_impl (dtr_watchdir * w)
 {
-    if( w->inotify_fd >= 0 )
+    if (w->inotify_fd >= 0)
     {
-        inotify_rm_watch( w->inotify_fd, DTR_INOTIFY_MASK );
+        inotify_rm_watch (w->inotify_fd, DTR_INOTIFY_MASK);
 
-        close( w->inotify_fd );
+        close (w->inotify_fd);
     }
 }
 static void
-watchdir_update_impl( dtr_watchdir * w )
+watchdir_update_impl (dtr_watchdir * w)
 {
     int ret;
     fd_set rfds;
@@ -120,26 +120,26 @@ watchdir_update_impl( dtr_watchdir * w )
     time.tv_usec = 0;
 
     /* make the fd_set hold the inotify fd */
-    FD_ZERO( &rfds );
-    FD_SET( fd, &rfds );
+    FD_ZERO (&rfds);
+    FD_SET (fd, &rfds);
 
     /* check for added files */
-    ret = select( fd+1, &rfds, NULL, NULL, &time );
-    if( ret < 0 ) {
-        perror( "select" );
-    } else if( !ret ) {
+    ret = select (fd+1, &rfds, NULL, NULL, &time);
+    if (ret < 0) {
+        perror ("select");
+    } else if (!ret) {
         /* timed out! */
-    } else if( FD_ISSET( fd, &rfds ) ) {
+    } else if (FD_ISSET (fd, &rfds)) {
         int i = 0;
         char buf[BUF_LEN];
-        int len = read( fd, buf, sizeof( buf ) );
+        int len = read (fd, buf, sizeof (buf));
         while (i < len) {
             struct inotify_event * event = (struct inotify_event *) &buf[i];
             const char * name = event->name;
-            if( tr_str_has_suffix( name, ".torrent" ) )
+            if (tr_str_has_suffix (name, ".torrent"))
             {
-                tr_inf( "Found new .torrent file \"%s\" in watchdir \"%s\"", name, w->dir );
-                w->callback( w->session, w->dir, name );
+                tr_inf ("Found new .torrent file \"%s\" in watchdir \"%s\"", name, w->dir);
+                w->callback (w->session, w->dir, name);
             }
             i += EVENT_SIZE +  event->len;
         }
@@ -157,82 +157,82 @@ watchdir_update_impl( dtr_watchdir * w )
 #define FILE_DELIMITER '\t'
 
 static void
-watchdir_new_impl( dtr_watchdir * w UNUSED )
+watchdir_new_impl (dtr_watchdir * w UNUSED)
 {
-    tr_inf( "Using readdir to watch directory \"%s\"", w->dir );
-    w->lastFiles = evbuffer_new( );
+    tr_inf ("Using readdir to watch directory \"%s\"", w->dir);
+    w->lastFiles = evbuffer_new ();
 }
 static void
-watchdir_free_impl( dtr_watchdir * w )
+watchdir_free_impl (dtr_watchdir * w)
 {
-    evbuffer_free( w->lastFiles );
+    evbuffer_free (w->lastFiles);
 }
 
 static char*
-get_key_from_file( const char * filename, const size_t len )
+get_key_from_file (const char * filename, const size_t len)
 {
-    return tr_strdup_printf( "%c%*.*s%d", FILE_DELIMITER, (int)len, (int)len, filename, FILE_DELIMITER );
+    return tr_strdup_printf ("%c%*.*s%d", FILE_DELIMITER, (int)len, (int)len, filename, FILE_DELIMITER);
 }
 
 static void
-add_file_to_list( struct evbuffer * buf, const char * filename, size_t len )
+add_file_to_list (struct evbuffer * buf, const char * filename, size_t len)
 {
-    char * key = get_key_from_file( filename, len );
-    evbuffer_add( buf, key, strlen( key ) );
-    tr_free( key );
+    char * key = get_key_from_file (filename, len);
+    evbuffer_add (buf, key, strlen (key));
+    tr_free (key);
 }
 static bool
-is_file_in_list( struct evbuffer * buf, const char * filename, size_t len )
+is_file_in_list (struct evbuffer * buf, const char * filename, size_t len)
 {
     bool in_list;
     struct evbuffer_ptr ptr;
-    char * key = get_key_from_file( filename, len );
+    char * key = get_key_from_file (filename, len);
 
-    ptr = evbuffer_search( buf, key, strlen( key ), NULL );
+    ptr = evbuffer_search (buf, key, strlen (key), NULL);
     in_list = ptr.pos != -1;
 
-    tr_free( key );
+    tr_free (key);
     return in_list;
 }
 static void
-watchdir_update_impl( dtr_watchdir * w )
+watchdir_update_impl (dtr_watchdir * w)
 {
     struct stat sb;
     DIR * odir;
     const time_t oldTime = w->lastTimeChecked;
     const char * dirname = w->dir;
-    struct evbuffer * curFiles = evbuffer_new( );
+    struct evbuffer * curFiles = evbuffer_new ();
 
-    if ( ( oldTime + WATCHDIR_POLL_INTERVAL_SECS < time( NULL ) )
-         && !stat( dirname, &sb )
-         && S_ISDIR( sb.st_mode )
-         && (( odir = opendir( dirname ))) )
+    if ((oldTime + WATCHDIR_POLL_INTERVAL_SECS < time (NULL))
+         && !stat (dirname, &sb)
+         && S_ISDIR (sb.st_mode)
+         && ((odir = opendir (dirname))))
     {
         struct dirent * d;
 
-        for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
+        for (d = readdir (odir); d != NULL; d = readdir (odir))
         {
             size_t len;
             const char * name = d->d_name;
 
-            if( !name || *name=='.' ) /* skip dotfiles */
+            if (!name || *name=='.') /* skip dotfiles */
                 continue;
-            if( !tr_str_has_suffix( name, ".torrent" ) ) /* skip non-torrents */
+            if (!tr_str_has_suffix (name, ".torrent")) /* skip non-torrents */
                 continue;
 
-            len = strlen( name );
-            add_file_to_list( curFiles, name, len );
+            len = strlen (name);
+            add_file_to_list (curFiles, name, len);
 
             /* if this file wasn't here last time, try adding it */
-            if( !is_file_in_list( w->lastFiles, name, len ) ) {
-                tr_inf( "Found new .torrent file \"%s\" in watchdir \"%s\"", name, w->dir );
-                w->callback( w->session, w->dir, name );
+            if (!is_file_in_list (w->lastFiles, name, len)) {
+                tr_inf ("Found new .torrent file \"%s\" in watchdir \"%s\"", name, w->dir);
+                w->callback (w->session, w->dir, name);
             }
         }
 
-        closedir( odir );
-        w->lastTimeChecked = time( NULL );
-        evbuffer_free( w->lastFiles );
+        closedir (odir);
+        w->lastTimeChecked = time (NULL);
+        evbuffer_free (w->lastFiles);
         w->lastFiles = curFiles;
     }
 }
@@ -244,33 +244,33 @@ watchdir_update_impl( dtr_watchdir * w )
 ***/
 
 dtr_watchdir*
-dtr_watchdir_new( tr_session * session, const char * dir, dtr_watchdir_callback * callback )
+dtr_watchdir_new (tr_session * session, const char * dir, dtr_watchdir_callback * callback)
 {
-    dtr_watchdir * w = tr_new0( dtr_watchdir, 1 );
+    dtr_watchdir * w = tr_new0 (dtr_watchdir, 1);
 
     w->session = session;
-    w->dir = tr_strdup( dir );
+    w->dir = tr_strdup (dir);
     w->callback = callback;
 
-    watchdir_new_impl( w );
+    watchdir_new_impl (w);
 
     return w;
 }
 
 void
-dtr_watchdir_update( dtr_watchdir * w )
+dtr_watchdir_update (dtr_watchdir * w)
 {
-    if( w != NULL )
-        watchdir_update_impl( w );
+    if (w != NULL)
+        watchdir_update_impl (w);
 }
 
 void
-dtr_watchdir_free( dtr_watchdir * w )
+dtr_watchdir_free (dtr_watchdir * w)
 {
-    if( w != NULL )
+    if (w != NULL)
     {
-        watchdir_free_impl( w );
-        tr_free( w->dir );
-        tr_free( w );
+        watchdir_free_impl (w);
+        tr_free (w->dir);
+        tr_free (w);
     }
 }
diff --git a/daemon/watch.h b/daemon/watch.h
index a99ffdeba..df45a9359 100644
--- a/daemon/watch.h
+++ b/daemon/watch.h
@@ -5,7 +5,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -15,12 +15,12 @@
 
 typedef struct dtr_watchdir dtr_watchdir;
 
-typedef void( dtr_watchdir_callback )( tr_session * session, const char * dir, const char * file );
+typedef void (dtr_watchdir_callback)(tr_session * session, const char * dir, const char * file);
 
-dtr_watchdir* dtr_watchdir_new( tr_session * session, const char * dir, dtr_watchdir_callback cb );
+dtr_watchdir* dtr_watchdir_new (tr_session * session, const char * dir, dtr_watchdir_callback cb);
 
-void dtr_watchdir_update( dtr_watchdir * w );
+void dtr_watchdir_update (dtr_watchdir * w);
 
-void dtr_watchdir_free( dtr_watchdir * w );
+void dtr_watchdir_free (dtr_watchdir * w);
 
 #endif
diff --git a/gtk/actions.c b/gtk/actions.c
index 3d63444c6..88836184d 100644
--- a/gtk/actions.c
+++ b/gtk/actions.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -35,101 +35,101 @@ static TrCore * myCore = NULL;
 static GtkActionGroup * myGroup = NULL;
 
 static void
-action_cb( GtkAction * a, gpointer user_data )
+action_cb (GtkAction * a, gpointer user_data)
 {
-    gtr_actions_handler( gtk_action_get_name( a ), user_data );
+    gtr_actions_handler (gtk_action_get_name (a), user_data);
 }
 
 static GtkRadioActionEntry sort_radio_entries[] =
 {
-    { "sort-by-activity",  NULL, N_( "Sort by _Activity" ),  NULL, NULL, 0 },
-    { "sort-by-name",      NULL, N_( "Sort by _Name" ),      NULL, NULL, 1 },
-    { "sort-by-progress",  NULL, N_( "Sort by _Progress" ),  NULL, NULL, 2 },
-    { "sort-by-queue",     NULL, N_( "Sort by _Queue" ),     NULL, NULL, 3 },
-    { "sort-by-ratio",     NULL, N_( "Sort by Rati_o" ),     NULL, NULL, 4 },
-    { "sort-by-state",     NULL, N_( "Sort by Stat_e" ),     NULL, NULL, 5 },
-    { "sort-by-age",       NULL, N_( "Sort by A_ge" ),       NULL, NULL, 6 },
-    { "sort-by-time-left", NULL, N_( "Sort by Time _Left" ), NULL, NULL, 7 },
-    { "sort-by-size",      NULL, N_( "Sort by Si_ze" ),      NULL, NULL, 8 }
+    { "sort-by-activity",  NULL, N_("Sort by _Activity"),  NULL, NULL, 0 },
+    { "sort-by-name",      NULL, N_("Sort by _Name"),      NULL, NULL, 1 },
+    { "sort-by-progress",  NULL, N_("Sort by _Progress"),  NULL, NULL, 2 },
+    { "sort-by-queue",     NULL, N_("Sort by _Queue"),     NULL, NULL, 3 },
+    { "sort-by-ratio",     NULL, N_("Sort by Rati_o"),     NULL, NULL, 4 },
+    { "sort-by-state",     NULL, N_("Sort by Stat_e"),     NULL, NULL, 5 },
+    { "sort-by-age",       NULL, N_("Sort by A_ge"),       NULL, NULL, 6 },
+    { "sort-by-time-left", NULL, N_("Sort by Time _Left"), NULL, NULL, 7 },
+    { "sort-by-size",      NULL, N_("Sort by Si_ze"),      NULL, NULL, 8 }
 };
 
 static void
-sort_changed_cb( GtkAction            * action UNUSED,
+sort_changed_cb (GtkAction            * action UNUSED,
                  GtkRadioAction *              current,
-                 gpointer user_data            UNUSED )
+                 gpointer user_data            UNUSED)
 {
     const char * key = PREF_KEY_SORT_MODE;
-    const int    i = gtk_radio_action_get_current_value( current );
+    const int    i = gtk_radio_action_get_current_value (current);
     const char * val = sort_radio_entries[i].name;
 
-    gtr_core_set_pref( myCore, key, val );
+    gtr_core_set_pref (myCore, key, val);
 }
 
 static GtkToggleActionEntry show_toggle_entries[] =
 {
-    { "toggle-main-window", NULL, N_( "_Show Transmission" ), NULL, NULL, G_CALLBACK( action_cb ), TRUE },
-    { "toggle-message-log", NULL, N_( "Message _Log" ), NULL, NULL, G_CALLBACK( action_cb ), FALSE }
+    { "toggle-main-window", NULL, N_("_Show Transmission"), NULL, NULL, G_CALLBACK (action_cb), TRUE },
+    { "toggle-message-log", NULL, N_("Message _Log"), NULL, NULL, G_CALLBACK (action_cb), FALSE }
 };
 
 static void
-toggle_pref_cb( GtkToggleAction *  action,
-                gpointer user_data UNUSED )
+toggle_pref_cb (GtkToggleAction *  action,
+                gpointer user_data UNUSED)
 {
-    const char *   key = gtk_action_get_name( GTK_ACTION( action ) );
-    const gboolean val = gtk_toggle_action_get_active( action );
+    const char *   key = gtk_action_get_name (GTK_ACTION (action));
+    const gboolean val = gtk_toggle_action_get_active (action);
 
-    gtr_core_set_pref_bool( myCore, key, val );
+    gtr_core_set_pref_bool (myCore, key, val);
 }
 
 static GtkToggleActionEntry  pref_toggle_entries[] =
 {
-    { "alt-speed-enabled", NULL, N_( "Enable Alternative Speed _Limits" ), NULL, NULL, G_CALLBACK( toggle_pref_cb ), FALSE },
-    { "compact-view",      NULL, N_( "_Compact View" ), "<alt>C", NULL, G_CALLBACK( toggle_pref_cb ), FALSE },
-    { "sort-reversed",     NULL, N_( "Re_verse Sort Order" ), NULL, NULL, G_CALLBACK( toggle_pref_cb ), FALSE },
-    { "show-filterbar",    NULL, N_( "_Filterbar" ), NULL, NULL, G_CALLBACK( toggle_pref_cb ), FALSE },
-    { "show-statusbar",    NULL, N_( "_Statusbar" ), NULL, NULL, G_CALLBACK( toggle_pref_cb ), FALSE },
-    { "show-toolbar",      NULL, N_( "_Toolbar" ), NULL, NULL, G_CALLBACK( toggle_pref_cb ), FALSE }
+    { "alt-speed-enabled", NULL, N_("Enable Alternative Speed _Limits"), NULL, NULL, G_CALLBACK (toggle_pref_cb), FALSE },
+    { "compact-view",      NULL, N_("_Compact View"), "<alt>C", NULL, G_CALLBACK (toggle_pref_cb), FALSE },
+    { "sort-reversed",     NULL, N_("Re_verse Sort Order"), NULL, NULL, G_CALLBACK (toggle_pref_cb), FALSE },
+    { "show-filterbar",    NULL, N_("_Filterbar"), NULL, NULL, G_CALLBACK (toggle_pref_cb), FALSE },
+    { "show-statusbar",    NULL, N_("_Statusbar"), NULL, NULL, G_CALLBACK (toggle_pref_cb), FALSE },
+    { "show-toolbar",      NULL, N_("_Toolbar"), NULL, NULL, G_CALLBACK (toggle_pref_cb), FALSE }
 };
 
 static GtkActionEntry entries[] =
 {
-    { "file-menu", NULL, N_( "_File" ), NULL, NULL, NULL  },
-    { "torrent-menu", NULL, N_( "_Torrent" ), NULL, NULL, NULL  },
-    { "view-menu", NULL, N_( "_View" ), NULL, NULL, NULL  },
-    { "sort-menu", NULL, N_( "_Sort Torrents By" ), NULL, NULL, NULL },
-    { "queue-menu", NULL, N_( "_Queue" ), NULL, NULL, NULL },
-    { "edit-menu", NULL, N_( "_Edit" ), NULL, NULL, NULL },
-    { "help-menu", NULL, N_( "_Help" ), NULL, NULL, NULL },
-    { "copy-magnet-link-to-clipboard",  GTK_STOCK_COPY, N_("Copy _Magnet Link to Clipboard" ), "", NULL,  G_CALLBACK( action_cb ) },
-    { "open-torrent-from-url",  GTK_STOCK_OPEN, N_("Open _URL…" ), "<control>U", N_( "Open URL…" ),  G_CALLBACK( action_cb ) },
-    { "open-torrent-toolbar",  GTK_STOCK_OPEN, NULL, NULL, N_( "Open a torrent" ),  G_CALLBACK( action_cb ) },
-    { "open-torrent-menu", GTK_STOCK_OPEN, NULL, NULL, N_( "Open a torrent" ), G_CALLBACK( action_cb ) },
-    { "torrent-start", GTK_STOCK_MEDIA_PLAY, N_( "_Start" ), "<control>S", N_( "Start torrent" ), G_CALLBACK( action_cb ) },
-    { "torrent-start-now", GTK_STOCK_MEDIA_PLAY, N_( "Start _Now" ), "<shift><control>S", N_( "Start torrent now" ), G_CALLBACK( action_cb ) },
-    { "show-stats", NULL, N_( "_Statistics" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "donate", NULL, N_( "_Donate" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "torrent-verify", NULL, N_( "_Verify Local Data" ), "<control>V", NULL, G_CALLBACK( action_cb ) },
-    { "torrent-stop", GTK_STOCK_MEDIA_PAUSE, N_( "_Pause" ), "<control>P", N_( "Pause torrent" ), G_CALLBACK( action_cb ) },
-    { "pause-all-torrents", GTK_STOCK_MEDIA_PAUSE, N_( "_Pause All" ), NULL, N_( "Pause all torrents" ), G_CALLBACK( action_cb ) },
-    { "start-all-torrents", GTK_STOCK_MEDIA_PLAY, N_( "_Start All" ), NULL, N_( "Start all torrents" ), G_CALLBACK( action_cb ) },
-    { "relocate-torrent", NULL, N_("Set _Location…" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "remove-torrent", GTK_STOCK_REMOVE, NULL, "Delete", N_( "Remove torrent" ), G_CALLBACK( action_cb ) },
-    { "delete-torrent", GTK_STOCK_DELETE, N_( "_Delete Files and Remove" ), "<shift>Delete", NULL, G_CALLBACK( action_cb ) },
-    { "new-torrent", GTK_STOCK_NEW, N_( "_New…" ), NULL, N_( "Create a torrent" ), G_CALLBACK( action_cb ) },
-    { "quit", GTK_STOCK_QUIT, N_( "_Quit" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "select-all", GTK_STOCK_SELECT_ALL, N_( "Select _All" ), "<control>A", NULL, G_CALLBACK( action_cb ) },
-    { "deselect-all", NULL, N_( "Dese_lect All" ), "<shift><control>A", NULL, G_CALLBACK( action_cb ) },
-    { "edit-preferences", GTK_STOCK_PREFERENCES, NULL, NULL, NULL, G_CALLBACK( action_cb ) },
-    { "show-torrent-properties", GTK_STOCK_PROPERTIES, NULL, "<alt>Return", N_( "Torrent properties" ), G_CALLBACK( action_cb ) },
-    { "open-torrent-folder",  GTK_STOCK_OPEN, N_( "Open Fold_er" ), "<control>E", NULL, G_CALLBACK( action_cb ) },
-    { "show-about-dialog", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK( action_cb ) },
-    { "help", GTK_STOCK_HELP, N_( "_Contents" ), "F1", NULL, G_CALLBACK( action_cb ) },
-    { "torrent-reannounce", GTK_STOCK_NETWORK, N_( "Ask Tracker for _More Peers" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "queue-move-top", GTK_STOCK_GOTO_TOP, N_( "Move to _Top" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "queue-move-up", GTK_STOCK_GO_UP, N_( "Move _Up" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "queue-move-down", GTK_STOCK_GO_DOWN, N_( "Move _Down" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "queue-move-bottom", GTK_STOCK_GOTO_BOTTOM, N_( "Move to _Bottom" ), NULL, NULL, G_CALLBACK( action_cb ) },
-    { "present-main-window", NULL, N_( "Present Main Window" ), NULL, NULL, G_CALLBACK( action_cb ) }
+    { "file-menu", NULL, N_("_File"), NULL, NULL, NULL  },
+    { "torrent-menu", NULL, N_("_Torrent"), NULL, NULL, NULL  },
+    { "view-menu", NULL, N_("_View"), NULL, NULL, NULL  },
+    { "sort-menu", NULL, N_("_Sort Torrents By"), NULL, NULL, NULL },
+    { "queue-menu", NULL, N_("_Queue"), NULL, NULL, NULL },
+    { "edit-menu", NULL, N_("_Edit"), NULL, NULL, NULL },
+    { "help-menu", NULL, N_("_Help"), NULL, NULL, NULL },
+    { "copy-magnet-link-to-clipboard",  GTK_STOCK_COPY, N_("Copy _Magnet Link to Clipboard"), "", NULL,  G_CALLBACK (action_cb) },
+    { "open-torrent-from-url",  GTK_STOCK_OPEN, N_("Open _URL…"), "<control>U", N_("Open URL…"),  G_CALLBACK (action_cb) },
+    { "open-torrent-toolbar",  GTK_STOCK_OPEN, NULL, NULL, N_("Open a torrent"),  G_CALLBACK (action_cb) },
+    { "open-torrent-menu", GTK_STOCK_OPEN, NULL, NULL, N_("Open a torrent"), G_CALLBACK (action_cb) },
+    { "torrent-start", GTK_STOCK_MEDIA_PLAY, N_("_Start"), "<control>S", N_("Start torrent"), G_CALLBACK (action_cb) },
+    { "torrent-start-now", GTK_STOCK_MEDIA_PLAY, N_("Start _Now"), "<shift><control>S", N_("Start torrent now"), G_CALLBACK (action_cb) },
+    { "show-stats", NULL, N_("_Statistics"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "donate", NULL, N_("_Donate"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "torrent-verify", NULL, N_("_Verify Local Data"), "<control>V", NULL, G_CALLBACK (action_cb) },
+    { "torrent-stop", GTK_STOCK_MEDIA_PAUSE, N_("_Pause"), "<control>P", N_("Pause torrent"), G_CALLBACK (action_cb) },
+    { "pause-all-torrents", GTK_STOCK_MEDIA_PAUSE, N_("_Pause All"), NULL, N_("Pause all torrents"), G_CALLBACK (action_cb) },
+    { "start-all-torrents", GTK_STOCK_MEDIA_PLAY, N_("_Start All"), NULL, N_("Start all torrents"), G_CALLBACK (action_cb) },
+    { "relocate-torrent", NULL, N_("Set _Location…"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "remove-torrent", GTK_STOCK_REMOVE, NULL, "Delete", N_("Remove torrent"), G_CALLBACK (action_cb) },
+    { "delete-torrent", GTK_STOCK_DELETE, N_("_Delete Files and Remove"), "<shift>Delete", NULL, G_CALLBACK (action_cb) },
+    { "new-torrent", GTK_STOCK_NEW, N_("_New…"), NULL, N_("Create a torrent"), G_CALLBACK (action_cb) },
+    { "quit", GTK_STOCK_QUIT, N_("_Quit"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "select-all", GTK_STOCK_SELECT_ALL, N_("Select _All"), "<control>A", NULL, G_CALLBACK (action_cb) },
+    { "deselect-all", NULL, N_("Dese_lect All"), "<shift><control>A", NULL, G_CALLBACK (action_cb) },
+    { "edit-preferences", GTK_STOCK_PREFERENCES, NULL, NULL, NULL, G_CALLBACK (action_cb) },
+    { "show-torrent-properties", GTK_STOCK_PROPERTIES, NULL, "<alt>Return", N_("Torrent properties"), G_CALLBACK (action_cb) },
+    { "open-torrent-folder",  GTK_STOCK_OPEN, N_("Open Fold_er"), "<control>E", NULL, G_CALLBACK (action_cb) },
+    { "show-about-dialog", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK (action_cb) },
+    { "help", GTK_STOCK_HELP, N_("_Contents"), "F1", NULL, G_CALLBACK (action_cb) },
+    { "torrent-reannounce", GTK_STOCK_NETWORK, N_("Ask Tracker for _More Peers"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "queue-move-top", GTK_STOCK_GOTO_TOP, N_("Move to _Top"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "queue-move-up", GTK_STOCK_GO_UP, N_("Move _Up"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "queue-move-down", GTK_STOCK_GO_DOWN, N_("Move _Down"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "queue-move-bottom", GTK_STOCK_GOTO_BOTTOM, N_("Move to _Bottom"), NULL, NULL, G_CALLBACK (action_cb) },
+    { "present-main-window", NULL, N_("Present Main Window"), NULL, NULL, G_CALLBACK (action_cb) }
 };
 
 typedef struct
@@ -152,100 +152,100 @@ static const BuiltinIconInfo my_fallback_icons[] =
 };
 
 static void
-register_my_icons( void )
+register_my_icons (void)
 {
     int              i;
-    const int        n = G_N_ELEMENTS( my_fallback_icons );
-    GtkIconFactory * factory = gtk_icon_factory_new( );
-    GtkIconTheme *   theme = gtk_icon_theme_get_default( );
+    const int        n = G_N_ELEMENTS (my_fallback_icons);
+    GtkIconFactory * factory = gtk_icon_factory_new ();
+    GtkIconTheme *   theme = gtk_icon_theme_get_default ();
 
-    gtk_icon_factory_add_default( factory );
+    gtk_icon_factory_add_default (factory);
 
-    for( i = 0; i < n; ++i )
+    for (i = 0; i < n; ++i)
     {
         const char * name = my_fallback_icons[i].name;
 
-        if( !gtk_icon_theme_has_icon( theme, name ) )
+        if (!gtk_icon_theme_has_icon (theme, name))
         {
             int          width;
             GdkPixbuf *  p;
             GtkIconSet * icon_set;
 
             p =
-                gdk_pixbuf_new_from_inline( -1, my_fallback_icons[i].raw,
+                gdk_pixbuf_new_from_inline (-1, my_fallback_icons[i].raw,
                                             FALSE,
-                                            NULL );
-            width = gdk_pixbuf_get_width( p );
-            icon_set = gtk_icon_set_new_from_pixbuf( p );
-            gtk_icon_theme_add_builtin_icon( name, width, p );
-            gtk_icon_factory_add( factory, name, icon_set );
-
-            g_object_unref( p );
-            gtk_icon_set_unref( icon_set );
+                                            NULL);
+            width = gdk_pixbuf_get_width (p);
+            icon_set = gtk_icon_set_new_from_pixbuf (p);
+            gtk_icon_theme_add_builtin_icon (name, width, p);
+            gtk_icon_factory_add (factory, name, icon_set);
+
+            g_object_unref (p);
+            gtk_icon_set_unref (icon_set);
         }
     }
 
-    g_object_unref ( G_OBJECT ( factory ) );
+    g_object_unref (G_OBJECT (factory));
 }
 
 static GtkUIManager * myUIManager = NULL;
 
 void
-gtr_actions_set_core( TrCore * core )
+gtr_actions_set_core (TrCore * core)
 {
     myCore = core;
 }
 
 void
-gtr_actions_init( GtkUIManager * ui_manager, gpointer callback_user_data )
+gtr_actions_init (GtkUIManager * ui_manager, gpointer callback_user_data)
 {
     int              i, n;
     int              active;
     const char *     match;
-    const int        n_entries = G_N_ELEMENTS( entries );
+    const int        n_entries = G_N_ELEMENTS (entries);
     GtkActionGroup * action_group;
 
     myUIManager = ui_manager;
 
-    register_my_icons( );
+    register_my_icons ();
 
-    action_group = myGroup = gtk_action_group_new( "Actions" );
-    gtk_action_group_set_translation_domain( action_group, NULL );
+    action_group = myGroup = gtk_action_group_new ("Actions");
+    gtk_action_group_set_translation_domain (action_group, NULL);
 
 
-    match = gtr_pref_string_get( PREF_KEY_SORT_MODE );
-    for( i = 0, n = G_N_ELEMENTS( sort_radio_entries ), active = -1;
-         active == -1 && i < n; ++i )
-        if( !strcmp( sort_radio_entries[i].name, match ) )
+    match = gtr_pref_string_get (PREF_KEY_SORT_MODE);
+    for (i = 0, n = G_N_ELEMENTS (sort_radio_entries), active = -1;
+         active == -1 && i < n; ++i)
+        if (!strcmp (sort_radio_entries[i].name, match))
             active = i;
 
-    gtk_action_group_add_radio_actions( action_group,
+    gtk_action_group_add_radio_actions (action_group,
                                         sort_radio_entries,
-                                        G_N_ELEMENTS( sort_radio_entries ),
+                                        G_N_ELEMENTS (sort_radio_entries),
                                         active,
-                                        G_CALLBACK( sort_changed_cb ),
-                                        NULL );
+                                        G_CALLBACK (sort_changed_cb),
+                                        NULL);
 
-    gtk_action_group_add_toggle_actions( action_group,
+    gtk_action_group_add_toggle_actions (action_group,
                                          show_toggle_entries,
-                                         G_N_ELEMENTS( show_toggle_entries ),
-                                         callback_user_data );
+                                         G_N_ELEMENTS (show_toggle_entries),
+                                         callback_user_data);
 
-    for( i = 0, n = G_N_ELEMENTS( pref_toggle_entries ); i < n; ++i )
+    for (i = 0, n = G_N_ELEMENTS (pref_toggle_entries); i < n; ++i)
         pref_toggle_entries[i].is_active =
-            gtr_pref_flag_get( pref_toggle_entries[i].name );
+            gtr_pref_flag_get (pref_toggle_entries[i].name);
 
-    gtk_action_group_add_toggle_actions( action_group,
+    gtk_action_group_add_toggle_actions (action_group,
                                          pref_toggle_entries,
-                                         G_N_ELEMENTS( pref_toggle_entries ),
-                                         callback_user_data );
+                                         G_N_ELEMENTS (pref_toggle_entries),
+                                         callback_user_data);
 
-    gtk_action_group_add_actions( action_group,
+    gtk_action_group_add_actions (action_group,
                                   entries, n_entries,
-                                  callback_user_data );
+                                  callback_user_data);
 
-    gtk_ui_manager_insert_action_group( ui_manager, action_group, 0 );
-    g_object_unref ( G_OBJECT( action_group ) );
+    gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+    g_object_unref (G_OBJECT (action_group));
 }
 
 /****
@@ -255,77 +255,77 @@ gtr_actions_init( GtkUIManager * ui_manager, gpointer callback_user_data )
 static GHashTable * key_to_action = NULL;
 
 static void
-ensure_action_map_loaded( GtkUIManager * uim )
+ensure_action_map_loaded (GtkUIManager * uim)
 {
     GList * l;
 
-    if( key_to_action != NULL )
+    if (key_to_action != NULL)
         return;
 
     key_to_action =
-        g_hash_table_new_full( g_str_hash, g_str_equal, g_free, NULL );
+        g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 
-    for( l = gtk_ui_manager_get_action_groups( uim ); l != NULL;
-         l = l->next )
+    for (l = gtk_ui_manager_get_action_groups (uim); l != NULL;
+         l = l->next)
     {
-        GtkActionGroup * action_group = GTK_ACTION_GROUP( l->data );
-        GList *          ait, *actions = gtk_action_group_list_actions(
-            action_group );
-        for( ait = actions; ait != NULL; ait = ait->next )
+        GtkActionGroup * action_group = GTK_ACTION_GROUP (l->data);
+        GList *          ait, *actions = gtk_action_group_list_actions (
+            action_group);
+        for (ait = actions; ait != NULL; ait = ait->next)
         {
-            GtkAction *  action = GTK_ACTION( ait->data );
-            const char * name = gtk_action_get_name( action );
-            g_hash_table_insert( key_to_action, g_strdup( name ), action );
+            GtkAction *  action = GTK_ACTION (ait->data);
+            const char * name = gtk_action_get_name (action);
+            g_hash_table_insert (key_to_action, g_strdup (name), action);
         }
-        g_list_free( actions );
+        g_list_free (actions);
     }
 }
 
 static GtkAction*
-get_action( const char* name )
+get_action (const char* name)
 {
-    ensure_action_map_loaded( myUIManager );
-    return ( GtkAction* ) g_hash_table_lookup( key_to_action, name );
+    ensure_action_map_loaded (myUIManager);
+    return (GtkAction*) g_hash_table_lookup (key_to_action, name);
 }
 
 void
-gtr_action_activate( const char * name )
+gtr_action_activate (const char * name)
 {
-    GtkAction * action = get_action( name );
+    GtkAction * action = get_action (name);
 
-    g_assert( action != NULL );
-    gtk_action_activate( action );
+    g_assert (action != NULL);
+    gtk_action_activate (action);
 }
 
 void
-gtr_action_set_sensitive( const char * name, gboolean b )
+gtr_action_set_sensitive (const char * name, gboolean b)
 {
-    GtkAction * action = get_action( name );
+    GtkAction * action = get_action (name);
 
-    g_assert( action != NULL );
-    g_object_set( action, "sensitive", b, NULL );
+    g_assert (action != NULL);
+    g_object_set (action, "sensitive", b, NULL);
 }
 
 void
-gtr_action_set_important( const char * name, gboolean b )
+gtr_action_set_important (const char * name, gboolean b)
 {
-    GtkAction * action = get_action( name );
+    GtkAction * action = get_action (name);
 
-    g_assert( action != NULL );
-    g_object_set( action, "is-important", b, NULL );
+    g_assert (action != NULL);
+    g_object_set (action, "is-important", b, NULL);
 }
 
 void
-gtr_action_set_toggled( const char * name, gboolean b )
+gtr_action_set_toggled (const char * name, gboolean b)
 {
-    GtkAction * action = get_action( name );
+    GtkAction * action = get_action (name);
 
-    gtk_toggle_action_set_active( GTK_TOGGLE_ACTION( action ), b );
+    gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), b);
 }
 
 GtkWidget*
-gtr_action_get_widget( const char * path )
+gtr_action_get_widget (const char * path)
 {
-    return gtk_ui_manager_get_widget( myUIManager, path );
+    return gtk_ui_manager_get_widget (myUIManager, path);
 }
 
diff --git a/gtk/actions.h b/gtk/actions.h
index f9f37fd9a..46587083e 100644
--- a/gtk/actions.h
+++ b/gtk/actions.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -21,14 +21,14 @@
 #define NOTIFICATION_ICON  "transmission-notification-icon"
 
 
-void        gtr_actions_init( GtkUIManager * ui_manager, gpointer callback_user_data );
-void        gtr_actions_set_core( TrCore * core );
-void        gtr_actions_handler( const char * action_name, gpointer user_data );
+void        gtr_actions_init (GtkUIManager * ui_manager, gpointer callback_user_data);
+void        gtr_actions_set_core (TrCore * core);
+void        gtr_actions_handler (const char * action_name, gpointer user_data);
 
-void        gtr_action_activate      ( const char * action_name );
-void        gtr_action_set_sensitive ( const char * action_name, gboolean is_sensitive );
-void        gtr_action_set_toggled   ( const char * action_name, gboolean is_toggled );
-void        gtr_action_set_important ( const char * action_name, gboolean is_important );
-GtkWidget*  gtr_action_get_widget    ( const char * path );
+void        gtr_action_activate    (const char * action_name);
+void        gtr_action_set_sensitive (const char * action_name, gboolean is_sensitive);
+void        gtr_action_set_toggled (const char * action_name, gboolean is_toggled);
+void        gtr_action_set_important (const char * action_name, gboolean is_important);
+GtkWidget*  gtr_action_get_widget  (const char * path);
 
 #endif
diff --git a/gtk/conf.c b/gtk/conf.c
index e158b7a60..de82552c0 100644
--- a/gtk/conf.c
+++ b/gtk/conf.c
@@ -24,7 +24,7 @@
 
 #include <errno.h>
 #include <stdio.h>
-#include <stdlib.h> /* strtol() */
+#include <stdlib.h> /* strtol () */
 #include <string.h>
 
 #include <unistd.h>
@@ -46,9 +46,9 @@
 static char * gl_confdir = NULL;
 
 void
-gtr_pref_init( const char * config_dir )
+gtr_pref_init (const char * config_dir)
 {
-    gl_confdir = g_strdup( config_dir );
+  gl_confdir = g_strdup (config_dir);
 }
 
 /***
@@ -57,85 +57,87 @@ gtr_pref_init( const char * config_dir )
 ****
 ***/
 
-static void cf_check_older_configs( void );
+static void cf_check_older_configs (void);
 
 /**
  * This is where we initialize the preferences file with the default values.
  * If you add a new preferences key, you /must/ add a default value here.
  */
 static void
-tr_prefs_init_defaults( tr_benc * d )
+tr_prefs_init_defaults (tr_benc * d)
 {
-    const char * str;
-    const char * special_dl_dir = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
-
-    cf_check_older_configs( );
-
-    str = NULL;
-    if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DOWNLOAD );
-    if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
-    if( !str ) str = tr_getDefaultDownloadDir( );
-    tr_bencDictAddStr ( d, PREF_KEY_DIR_WATCH, str );
-    tr_bencDictAddBool( d, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
-
-    tr_bencDictAddBool( d, PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, FALSE );
-    tr_bencDictAddBool( d, PREF_KEY_INHIBIT_HIBERNATION, FALSE );
-    tr_bencDictAddBool( d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
-
-    tr_bencDictAddStr ( d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
-
-    tr_bencDictAddBool( d, PREF_KEY_TOOLBAR, TRUE );
-    tr_bencDictAddBool( d, PREF_KEY_FILTERBAR, TRUE );
-    tr_bencDictAddBool( d, PREF_KEY_STATUSBAR, TRUE );
-    tr_bencDictAddBool( d, PREF_KEY_TRASH_CAN_ENABLED, TRUE );
-    tr_bencDictAddBool( d, PREF_KEY_SHOW_TRAY_ICON, FALSE );
-    tr_bencDictAddBool( d, PREF_KEY_SHOW_MORE_TRACKER_INFO, FALSE );
-    tr_bencDictAddBool( d, PREF_KEY_SHOW_MORE_PEER_INFO, FALSE );
-    tr_bencDictAddBool( d, PREF_KEY_SHOW_BACKUP_TRACKERS, FALSE );
-    tr_bencDictAddStr ( d, PREF_KEY_STATUSBAR_STATS, "total-ratio" );
-
-    tr_bencDictAddBool( d, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, true );
-    tr_bencDictAddBool( d, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, true );
-    tr_bencDictAddStr ( d, PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND, "canberra-gtk-play -i complete-download -d 'transmission torrent downloaded'" );
-    tr_bencDictAddBool( d, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, true );
-
-    tr_bencDictAddBool( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
-
-    tr_bencDictAddBool( d, PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, FALSE );
-    tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500 );
-    tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_WIDTH, 300 );
-    tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_X, 50 );
-    tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_Y, 50 );
-
-    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, special_dl_dir ? special_dl_dir : str );
-
-    tr_bencDictAddStr( d, PREF_KEY_SORT_MODE, "sort-by-name" );
-    tr_bencDictAddBool( d, PREF_KEY_SORT_REVERSED, FALSE );
-    tr_bencDictAddBool( d, PREF_KEY_COMPACT_VIEW, FALSE );
+  const char * str;
+  const char * special_dl_dir = g_get_user_special_dir (G_USER_DIRECTORY_DOWNLOAD);
+
+  cf_check_older_configs ();
+
+  str = g_get_user_special_dir (G_USER_DIRECTORY_DOWNLOAD);
+  if (!str)
+    str = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);
+  if (!str)
+    str = tr_getDefaultDownloadDir ();
+
+  tr_bencDictAddStr (d, PREF_KEY_DIR_WATCH, str);
+  tr_bencDictAddBool (d, PREF_KEY_DIR_WATCH_ENABLED, FALSE);
+
+  tr_bencDictAddBool (d, PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, FALSE);
+  tr_bencDictAddBool (d, PREF_KEY_INHIBIT_HIBERNATION, FALSE);
+  tr_bencDictAddBool (d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE);
+
+  tr_bencDictAddStr (d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir ());
+
+  tr_bencDictAddBool (d, PREF_KEY_TOOLBAR, TRUE);
+  tr_bencDictAddBool (d, PREF_KEY_FILTERBAR, TRUE);
+  tr_bencDictAddBool (d, PREF_KEY_STATUSBAR, TRUE);
+  tr_bencDictAddBool (d, PREF_KEY_TRASH_CAN_ENABLED, TRUE);
+  tr_bencDictAddBool (d, PREF_KEY_SHOW_TRAY_ICON, FALSE);
+  tr_bencDictAddBool (d, PREF_KEY_SHOW_MORE_TRACKER_INFO, FALSE);
+  tr_bencDictAddBool (d, PREF_KEY_SHOW_MORE_PEER_INFO, FALSE);
+  tr_bencDictAddBool (d, PREF_KEY_SHOW_BACKUP_TRACKERS, FALSE);
+  tr_bencDictAddStr (d, PREF_KEY_STATUSBAR_STATS, "total-ratio");
+
+  tr_bencDictAddBool (d, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, true);
+  tr_bencDictAddBool (d, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, true);
+  tr_bencDictAddStr (d, PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND, "canberra-gtk-play -i complete-download -d 'transmission torrent downloaded'");
+  tr_bencDictAddBool (d, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, true);
+
+  tr_bencDictAddBool (d, PREF_KEY_OPTIONS_PROMPT, TRUE);
+
+  tr_bencDictAddBool (d, PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, FALSE);
+  tr_bencDictAddInt (d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500);
+  tr_bencDictAddInt (d, PREF_KEY_MAIN_WINDOW_WIDTH, 300);
+  tr_bencDictAddInt (d, PREF_KEY_MAIN_WINDOW_X, 50);
+  tr_bencDictAddInt (d, PREF_KEY_MAIN_WINDOW_Y, 50);
+
+  tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, special_dl_dir ? special_dl_dir : str);
+
+  tr_bencDictAddStr (d, PREF_KEY_SORT_MODE, "sort-by-name");
+  tr_bencDictAddBool (d, PREF_KEY_SORT_REVERSED, FALSE);
+  tr_bencDictAddBool (d, PREF_KEY_COMPACT_VIEW, FALSE);
 }
 
 static char*
-getPrefsFilename( void )
+getPrefsFilename (void)
 {
-    g_assert( gl_confdir != NULL );
-    return g_build_filename( gl_confdir, "settings.json", NULL );
+  g_assert (gl_confdir != NULL);
+  return g_build_filename (gl_confdir, "settings.json", NULL);
 }
 
 static tr_benc*
-getPrefs( void )
+getPrefs (void)
 {
-    static tr_benc settings;
-    static gboolean loaded = FALSE;
+  static tr_benc settings;
+  static gboolean loaded = FALSE;
 
-    if( !loaded )
+  if (!loaded)
     {
-        tr_bencInitDict( &settings, 0 );
-        tr_prefs_init_defaults( &settings );
-        tr_sessionLoadSettings( &settings, gl_confdir, MY_CONFIG_NAME );
-        loaded = TRUE;
+      tr_bencInitDict (&settings, 0);
+      tr_prefs_init_defaults (&settings);
+      tr_sessionLoadSettings (&settings, gl_confdir, MY_CONFIG_NAME);
+      loaded = TRUE;
     }
 
-    return &settings;
+  return &settings;
 }
 
 /***
@@ -143,38 +145,41 @@ getPrefs( void )
 ***/
 
 tr_benc*
-gtr_pref_get_all( void )
+gtr_pref_get_all (void)
 {
-    return getPrefs( );
+  return getPrefs ();
 }
 
 int64_t
-gtr_pref_int_get( const char * key )
+gtr_pref_int_get (const char * key)
 {
-    int64_t i = 0;
+  int64_t i = 0;
 
-    tr_bencDictFindInt( getPrefs( ), key, &i );
-    return i;
+  tr_bencDictFindInt (getPrefs (), key, &i);
+
+  return i;
 }
 
 void
-gtr_pref_int_set( const char * key, int64_t value )
+gtr_pref_int_set (const char * key, int64_t value)
 {
-    tr_bencDictAddInt( getPrefs( ), key, value );
+  tr_bencDictAddInt (getPrefs (), key, value);
 }
 
 double
-gtr_pref_double_get( const char * key )
+gtr_pref_double_get (const char * key)
 {
-    double d = 0.0;
-    tr_bencDictFindReal( getPrefs( ), key, &d );
-    return d;
+  double d = 0.0;
+
+  tr_bencDictFindReal (getPrefs (), key, &d);
+
+  return d;
 }
 
 void
-gtr_pref_double_set( const char * key, double value )
+gtr_pref_double_set (const char * key, double value)
 {
-    tr_bencDictAddReal( getPrefs( ), key, value );
+  tr_bencDictAddReal (getPrefs (), key, value);
 }
 
 /***
@@ -182,17 +187,19 @@ gtr_pref_double_set( const char * key, double value )
 ***/
 
 gboolean
-gtr_pref_flag_get( const char * key )
+gtr_pref_flag_get (const char * key)
 {
-    bool boolVal;
-    tr_bencDictFindBool( getPrefs( ), key, &boolVal );
-    return boolVal != 0;
+  bool boolVal;
+
+  tr_bencDictFindBool (getPrefs (), key, &boolVal);
+
+  return boolVal != 0;
 }
 
 void
-gtr_pref_flag_set( const char * key, gboolean value )
+gtr_pref_flag_set (const char * key, gboolean value)
 {
-    tr_bencDictAddBool( getPrefs( ), key, value );
+  tr_bencDictAddBool (getPrefs (), key, value);
 }
 
 /***
@@ -200,17 +207,19 @@ gtr_pref_flag_set( const char * key, gboolean value )
 ***/
 
 const char*
-gtr_pref_string_get( const char * key )
+gtr_pref_string_get (const char * key)
 {
-    const char * str = NULL;
-    tr_bencDictFindStr( getPrefs( ), key, &str );
-    return str;
+  const char * str = NULL;
+
+  tr_bencDictFindStr (getPrefs (), key, &str);
+
+  return str;
 }
 
 void
-gtr_pref_string_set( const char * key, const char * value )
+gtr_pref_string_set (const char * key, const char * value)
 {
-    tr_bencDictAddStr( getPrefs( ), key, value );
+  tr_bencDictAddStr (getPrefs (), key, value);
 }
 
 /***
@@ -218,9 +227,9 @@ gtr_pref_string_set( const char * key, const char * value )
 ***/
 
 void
-gtr_pref_save( tr_session * session )
+gtr_pref_save (tr_session * session)
 {
-    tr_sessionSaveSettings( session, gl_confdir, getPrefs( ) );
+  tr_sessionSaveSettings (session, gl_confdir, getPrefs ());
 }
 
 /***
@@ -228,104 +237,107 @@ gtr_pref_save( tr_session * session )
 ***/
 
 static char*
-getCompat090PrefsFilename( void )
+getCompat090PrefsFilename (void)
 {
-    g_assert( gl_confdir != NULL );
+  g_assert (gl_confdir != NULL);
 
-    return g_build_filename( g_get_home_dir( ), ".transmission", "gtk", "prefs.ini", NULL );
+  return g_build_filename (g_get_home_dir (), ".transmission", "gtk", "prefs.ini", NULL);
 }
 
 static char*
-getCompat121PrefsFilename( void )
+getCompat121PrefsFilename (void)
 {
-    return g_build_filename( g_get_user_config_dir( ), "transmission", "gtk", "prefs.ini", NULL );
+  return g_build_filename (g_get_user_config_dir (), "transmission", "gtk", "prefs.ini", NULL);
 }
 
 static void
-translate_keyfile_to_json( const char * old_file, const char * new_file )
+translate_keyfile_to_json (const char * old_file, const char * new_file)
 {
-    tr_benc    dict;
-    GKeyFile * keyfile;
-    gchar **   keys;
-    gsize      i;
-    gsize      length;
-
-    static struct pref_entry {
-        const char*   oldkey;
-        const char*   newkey;
-    } renamed[] = {
-        { "default-download-directory", "download-dir"             },
-        { "encrypted-connections-only", "encryption"               },
-        { "listening-port",             "peer-port"                },
-        { "nat-traversal-enabled",      "port-forwarding-enabled"  },
-        { "open-dialog-folder",         "open-dialog-dir"          },
-        { "watch-folder",               "watch-dir"                },
-        { "watch-folder-enabled",       "watch-dir-enabled"        }
-    };
-
-    keyfile = g_key_file_new( );
-    g_key_file_load_from_file( keyfile, old_file, 0, NULL );
-    length = 0;
-    keys = g_key_file_get_keys( keyfile, "general", &length, NULL );
-
-    tr_bencInitDict( &dict, length );
-    for( i = 0; i < length; ++i )
+  tr_benc    dict;
+  GKeyFile * keyfile;
+  gchar **   keys;
+  gsize      i;
+  gsize      length;
+
+  static struct pref_entry {
+    const char*   oldkey;
+    const char*   newkey;
+  } renamed[] = {
+    { "default-download-directory", "download-dir"             },
+    { "encrypted-connections-only", "encryption"               },
+    { "listening-port",             "peer-port"                },
+    { "nat-traversal-enabled",      "port-forwarding-enabled"  },
+    { "open-dialog-folder",         "open-dialog-dir"          },
+    { "watch-folder",               "watch-dir"                },
+    { "watch-folder-enabled",       "watch-dir-enabled"        }
+  };
+
+  keyfile = g_key_file_new ();
+  g_key_file_load_from_file (keyfile, old_file, 0, NULL);
+  length = 0;
+  keys = g_key_file_get_keys (keyfile, "general", &length, NULL);
+
+  tr_bencInitDict (&dict, length);
+  for (i=0; i<length; i++)
     {
-        guint        j;
-        const char * key = keys[i];
-        gchar *      val = g_key_file_get_value( keyfile, "general", key,
-                                                 NULL );
-
-        for( j = 0; j < G_N_ELEMENTS( renamed ); ++j )
-            if( !strcmp( renamed[j].oldkey, key ) )
-                key = renamed[j].newkey;
-
-        if( !strcmp( val, "true" ) || !strcmp( val, "false" ) )
-            tr_bencDictAddInt( &dict, key, !strcmp( val, "true" ) );
-        else
+      guint j;
+      const char * key = keys[i];
+      gchar * val = g_key_file_get_value (keyfile, "general", key, NULL);
+
+      for (j=0; j<G_N_ELEMENTS (renamed); j++)
+        if (!strcmp (renamed[j].oldkey, key))
+          key = renamed[j].newkey;
+
+      if (!strcmp (val, "true") || !strcmp (val, "false"))
+        {
+          tr_bencDictAddInt (&dict, key, !strcmp (val, "true"));
+        }
+      else
         {
-            char * end;
-            long   l;
-            errno = 0;
-            l = strtol( val, &end, 10 );
-            if( !errno && end && !*end )
-                tr_bencDictAddInt( &dict, key, l );
-            else
-                tr_bencDictAddStr( &dict, key, val );
+          char * end;
+          long l;
+
+          errno = 0;
+
+          l = strtol (val, &end, 10);
+          if (!errno && end && !*end)
+            tr_bencDictAddInt (&dict, key, l);
+          else
+            tr_bencDictAddStr (&dict, key, val);
         }
 
-        g_free( val );
+      g_free (val);
     }
 
-    g_key_file_free( keyfile );
-    tr_bencToFile( &dict, TR_FMT_JSON, new_file );
-    tr_bencFree( &dict );
+  g_key_file_free (keyfile);
+  tr_bencToFile (&dict, TR_FMT_JSON, new_file);
+  tr_bencFree (&dict);
 }
 
 static void
-cf_check_older_configs( void )
+cf_check_older_configs (void)
 {
-    char * filename = getPrefsFilename( );
+  char * filename = getPrefsFilename ();
 
-    if( !g_file_test( filename, G_FILE_TEST_IS_REGULAR ) )
+  if (!g_file_test (filename, G_FILE_TEST_IS_REGULAR))
     {
-        char * key1 = getCompat121PrefsFilename( );
-        char * key2 = getCompat090PrefsFilename( );
+      char * key1 = getCompat121PrefsFilename ();
+      char * key2 = getCompat090PrefsFilename ();
 
-        if( g_file_test( key1, G_FILE_TEST_IS_REGULAR ) )
+      if (g_file_test (key1, G_FILE_TEST_IS_REGULAR))
         {
-            g_message( _( "Importing \"%s\"" ), key1 );
-            translate_keyfile_to_json( key1, filename );
+          g_message (_("Importing \"%s\""), key1);
+          translate_keyfile_to_json (key1, filename);
         }
-        else if( g_file_test( key2, G_FILE_TEST_IS_REGULAR ) )
+      else if (g_file_test (key2, G_FILE_TEST_IS_REGULAR))
         {
-            g_message( _( "Importing \"%s\"" ), key2 );
-            translate_keyfile_to_json( key2, filename );
+          g_message (_("Importing \"%s\""), key2);
+          translate_keyfile_to_json (key2, filename);
         }
 
-        g_free( key2 );
-        g_free( key1 );
+      g_free (key2);
+      g_free (key1);
     }
 
-    g_free( filename );
+  g_free (filename);
 }
diff --git a/gtk/conf.h b/gtk/conf.h
index a3fbf7fec..81e0dcc1c 100644
--- a/gtk/conf.h
+++ b/gtk/conf.h
@@ -28,21 +28,21 @@
 #include <inttypes.h>
 #include <libtransmission/transmission.h> /* tr_benc, tr_session */
 
-void             gtr_pref_init              ( const char * config_dir );
+void             gtr_pref_init            (const char * config_dir);
 
-int64_t          gtr_pref_int_get           ( const char * key );
-void             gtr_pref_int_set           ( const char * key, int64_t value );
+int64_t          gtr_pref_int_get         (const char * key);
+void             gtr_pref_int_set         (const char * key, int64_t value);
 
-double           gtr_pref_double_get        ( const char * key );
-void             gtr_pref_double_set        ( const char * key, double value );
+double           gtr_pref_double_get      (const char * key);
+void             gtr_pref_double_set      (const char * key, double value);
 
-gboolean         gtr_pref_flag_get          ( const char * key );
-void             gtr_pref_flag_set          ( const char * key, gboolean value );
+gboolean         gtr_pref_flag_get        (const char * key);
+void             gtr_pref_flag_set        (const char * key, gboolean value);
 
-const char*      gtr_pref_string_get        ( const char * key );
-void             gtr_pref_string_set        ( const char * key, const char * value );
+const char*      gtr_pref_string_get      (const char * key);
+void             gtr_pref_string_set      (const char * key, const char * value);
 
-void             gtr_pref_save              ( tr_session * );
-struct tr_benc*  gtr_pref_get_all           ( void );
+void             gtr_pref_save            (tr_session *);
+struct tr_benc*  gtr_pref_get_all         (void);
 
 #endif /* GTR_CONFIG_H */
diff --git a/gtk/details.c b/gtk/details.c
index 45e9f261a..60607d8b1 100644
--- a/gtk/details.c
+++ b/gtk/details.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,8 +11,8 @@
  */
 
 #include <stddef.h>
-#include <stdio.h> /* sscanf() */
-#include <stdlib.h> /* abort() */
+#include <stdio.h> /* sscanf () */
+#include <stdlib.h> /* abort () */
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
 
@@ -22,7 +22,7 @@
 #include "actions.h"
 #include "conf.h"
 #include "details.h"
-#include "favicon.h" /* gtr_get_favicon() */
+#include "favicon.h" /* gtr_get_favicon () */
 #include "file-list.h"
 #include "hig.h"
 #include "tr-prefs.h"
@@ -108,15 +108,15 @@ struct DetailsImpl
 };
 
 static tr_torrent**
-getTorrents( struct DetailsImpl * d, int * setmeCount )
+getTorrents (struct DetailsImpl * d, int * setmeCount)
 {
     GSList * l;
     int torrentCount = 0;
-    const int n = g_slist_length( d->ids );
-    tr_torrent ** torrents = g_new( tr_torrent*, n );
+    const int n = g_slist_length (d->ids);
+    tr_torrent ** torrents = g_new (tr_torrent*, n);
 
-    for( l=d->ids; l!=NULL; l=l->next )
-        if(( torrents[torrentCount] = gtr_core_find_torrent( d->core, GPOINTER_TO_INT( l->data ))))
+    for (l=d->ids; l!=NULL; l=l->next)
+        if ((torrents[torrentCount] = gtr_core_find_torrent (d->core, GPOINTER_TO_INT (l->data))))
             ++torrentCount;
 
     *setmeCount = torrentCount;
@@ -130,343 +130,343 @@ getTorrents( struct DetailsImpl * d, int * setmeCount )
 ****/
 
 static void
-set_togglebutton_if_different( GtkWidget * w, gulong tag, gboolean value )
+set_togglebutton_if_different (GtkWidget * w, gulong tag, gboolean value)
 {
-    GtkToggleButton * toggle = GTK_TOGGLE_BUTTON( w );
-    const gboolean currentValue = gtk_toggle_button_get_active( toggle );
-    if( currentValue != value )
+    GtkToggleButton * toggle = GTK_TOGGLE_BUTTON (w);
+    const gboolean currentValue = gtk_toggle_button_get_active (toggle);
+    if (currentValue != value)
     {
-        g_signal_handler_block( toggle, tag );
-        gtk_toggle_button_set_active( toggle, value );
-        g_signal_handler_unblock( toggle, tag );
+        g_signal_handler_block (toggle, tag);
+        gtk_toggle_button_set_active (toggle, value);
+        g_signal_handler_unblock (toggle, tag);
     }
 }
 
 static void
-set_int_spin_if_different( GtkWidget * w, gulong tag, int value )
+set_int_spin_if_different (GtkWidget * w, gulong tag, int value)
 {
-    GtkSpinButton * spin = GTK_SPIN_BUTTON( w );
-    const int currentValue = gtk_spin_button_get_value_as_int( spin );
-    if( currentValue != value )
+    GtkSpinButton * spin = GTK_SPIN_BUTTON (w);
+    const int currentValue = gtk_spin_button_get_value_as_int (spin);
+    if (currentValue != value)
     {
-        g_signal_handler_block( spin, tag );
-        gtk_spin_button_set_value( spin, value );
-        g_signal_handler_unblock( spin, tag );
+        g_signal_handler_block (spin, tag);
+        gtk_spin_button_set_value (spin, value);
+        g_signal_handler_unblock (spin, tag);
     }
 }
 
 static void
-set_double_spin_if_different( GtkWidget * w, gulong tag, double value )
+set_double_spin_if_different (GtkWidget * w, gulong tag, double value)
 {
-    GtkSpinButton * spin = GTK_SPIN_BUTTON( w );
-    const double currentValue = gtk_spin_button_get_value( spin );
-    if( ( (int)(currentValue*100) != (int)(value*100) ) )
+    GtkSpinButton * spin = GTK_SPIN_BUTTON (w);
+    const double currentValue = gtk_spin_button_get_value (spin);
+    if (((int)(currentValue*100) != (int)(value*100)))
     {
-        g_signal_handler_block( spin, tag );
-        gtk_spin_button_set_value( spin, value );
-        g_signal_handler_unblock( spin, tag );
+        g_signal_handler_block (spin, tag);
+        gtk_spin_button_set_value (spin, value);
+        g_signal_handler_unblock (spin, tag);
     }
 }
 
 static void
-unset_combo( GtkWidget * w, gulong tag )
+unset_combo (GtkWidget * w, gulong tag)
 {
-    GtkComboBox * combobox = GTK_COMBO_BOX( w );
+    GtkComboBox * combobox = GTK_COMBO_BOX (w);
 
-    g_signal_handler_block( combobox, tag );
-    gtk_combo_box_set_active( combobox, -1 );
-    g_signal_handler_unblock( combobox, tag );
+    g_signal_handler_block (combobox, tag);
+    gtk_combo_box_set_active (combobox, -1);
+    g_signal_handler_unblock (combobox, tag);
 }
 
 static void
-refreshOptions( struct DetailsImpl * di, tr_torrent ** torrents, int n )
+refreshOptions (struct DetailsImpl * di, tr_torrent ** torrents, int n)
 {
     /***
     ****  Options Page
     ***/
 
     /* honor_limits_check */
-    if( n ) {
-        const bool baseline = tr_torrentUsesSessionLimits( torrents[0] );
+    if (n) {
+        const bool baseline = tr_torrentUsesSessionLimits (torrents[0]);
         int i;
-        for( i=1; i<n; ++i )
-            if( baseline != tr_torrentUsesSessionLimits( torrents[i] ) )
+        for (i=1; i<n; ++i)
+            if (baseline != tr_torrentUsesSessionLimits (torrents[i]))
                 break;
-        if( i == n )
-            set_togglebutton_if_different( di->honor_limits_check,
-                                           di->honor_limits_check_tag, baseline );
+        if (i == n)
+            set_togglebutton_if_different (di->honor_limits_check,
+                                           di->honor_limits_check_tag, baseline);
     }
 
     /* down_limited_check */
-    if( n ) {
-        const bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_DOWN );
+    if (n) {
+        const bool baseline = tr_torrentUsesSpeedLimit (torrents[0], TR_DOWN);
         int i;
-        for( i=1; i<n; ++i )
-            if( baseline != tr_torrentUsesSpeedLimit( torrents[i], TR_DOWN ) )
+        for (i=1; i<n; ++i)
+            if (baseline != tr_torrentUsesSpeedLimit (torrents[i], TR_DOWN))
                 break;
-        if( i == n )
-            set_togglebutton_if_different( di->down_limited_check,
-                                           di->down_limited_check_tag, baseline );
+        if (i == n)
+            set_togglebutton_if_different (di->down_limited_check,
+                                           di->down_limited_check_tag, baseline);
     }
 
     /* down_limit_spin */
-    if( n ) {
-        const unsigned int baseline = tr_torrentGetSpeedLimit_KBps( torrents[0], TR_DOWN );
+    if (n) {
+        const unsigned int baseline = tr_torrentGetSpeedLimit_KBps (torrents[0], TR_DOWN);
         int i;
-        for( i=1; i<n; ++i )
-            if( baseline != ( tr_torrentGetSpeedLimit_KBps( torrents[i], TR_DOWN ) ) )
+        for (i=1; i<n; ++i)
+            if (baseline != (tr_torrentGetSpeedLimit_KBps (torrents[i], TR_DOWN)))
                 break;
-        if( i == n )
-            set_int_spin_if_different( di->down_limit_spin,
-                                       di->down_limit_spin_tag, baseline );
+        if (i == n)
+            set_int_spin_if_different (di->down_limit_spin,
+                                       di->down_limit_spin_tag, baseline);
     }
 
     /* up_limited_check */
-    if( n ) {
-        const bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_UP );
+    if (n) {
+        const bool baseline = tr_torrentUsesSpeedLimit (torrents[0], TR_UP);
         int i;
-        for( i=1; i<n; ++i )
-            if( baseline != tr_torrentUsesSpeedLimit( torrents[i], TR_UP ) )
+        for (i=1; i<n; ++i)
+            if (baseline != tr_torrentUsesSpeedLimit (torrents[i], TR_UP))
                 break;
-        if( i == n )
-            set_togglebutton_if_different( di->up_limited_check,
-                                           di->up_limited_check_tag, baseline );
+        if (i == n)
+            set_togglebutton_if_different (di->up_limited_check,
+                                           di->up_limited_check_tag, baseline);
     }
 
     /* up_limit_sping */
-    if( n ) {
-        const unsigned int  baseline = tr_torrentGetSpeedLimit_KBps( torrents[0], TR_UP );
+    if (n) {
+        const unsigned int  baseline = tr_torrentGetSpeedLimit_KBps (torrents[0], TR_UP);
         int i;
-        for( i=1; i<n; ++i )
-            if( baseline != ( tr_torrentGetSpeedLimit_KBps( torrents[i], TR_UP ) ) )
+        for (i=1; i<n; ++i)
+            if (baseline != (tr_torrentGetSpeedLimit_KBps (torrents[i], TR_UP)))
                 break;
-        if( i == n )
-            set_int_spin_if_different( di->up_limit_sping,
-                                       di->up_limit_spin_tag, baseline );
+        if (i == n)
+            set_int_spin_if_different (di->up_limit_sping,
+                                       di->up_limit_spin_tag, baseline);
     }
 
     /* bandwidth_combo */
-    if( n ) {
-        const int baseline = tr_torrentGetPriority( torrents[0] );
+    if (n) {
+        const int baseline = tr_torrentGetPriority (torrents[0]);
         int i;
-        for( i=1; i<n; ++i )
-            if( baseline != tr_torrentGetPriority( torrents[i] ) )
+        for (i=1; i<n; ++i)
+            if (baseline != tr_torrentGetPriority (torrents[i]))
                 break;
-        if( i == n ) {
+        if (i == n) {
             GtkWidget * w = di->bandwidth_combo;
-            g_signal_handler_block( w, di->bandwidth_combo_tag );
-            gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), baseline );
-            g_signal_handler_unblock( w, di->bandwidth_combo_tag );
+            g_signal_handler_block (w, di->bandwidth_combo_tag);
+            gtr_priority_combo_set_value (GTK_COMBO_BOX (w), baseline);
+            g_signal_handler_unblock (w, di->bandwidth_combo_tag);
         }
         else
-            unset_combo( di->bandwidth_combo, di->bandwidth_combo_tag );
+            unset_combo (di->bandwidth_combo, di->bandwidth_combo_tag);
     }
 
     /* ratio_combo */
     /* ratio_spin */
-    if( n ) {
+    if (n) {
         int i;
-        const int baseline = tr_torrentGetRatioMode( torrents[0] );
-        for( i=1; i<n; ++i )
-            if( baseline != (int)tr_torrentGetRatioMode( torrents[i] ) )
+        const int baseline = tr_torrentGetRatioMode (torrents[0]);
+        for (i=1; i<n; ++i)
+            if (baseline != (int)tr_torrentGetRatioMode (torrents[i]))
                 break;
-        if( i == n ) {
+        if (i == n) {
             GtkWidget * w = di->ratio_combo;
-            g_signal_handler_block( w, di->ratio_combo_tag );
-            gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), baseline );
-            gtr_widget_set_visible( di->ratio_spin, baseline == TR_RATIOLIMIT_SINGLE );
-            g_signal_handler_unblock( w, di->ratio_combo_tag );
+            g_signal_handler_block (w, di->ratio_combo_tag);
+            gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), baseline);
+            gtr_widget_set_visible (di->ratio_spin, baseline == TR_RATIOLIMIT_SINGLE);
+            g_signal_handler_unblock (w, di->ratio_combo_tag);
         }
     }
-    if( n ) {
-        const double baseline = tr_torrentGetRatioLimit( torrents[0] );
-        set_double_spin_if_different( di->ratio_spin,
-                                      di->ratio_spin_tag, baseline );
+    if (n) {
+        const double baseline = tr_torrentGetRatioLimit (torrents[0]);
+        set_double_spin_if_different (di->ratio_spin,
+                                      di->ratio_spin_tag, baseline);
     }
 
     /* idle_combo */
     /* idle_spin */
-    if( n ) {
+    if (n) {
         int i;
-        const int baseline = tr_torrentGetIdleMode( torrents[0] );
-        for( i=1; i<n; ++i )
-            if( baseline != (int)tr_torrentGetIdleMode( torrents[i] ) )
+        const int baseline = tr_torrentGetIdleMode (torrents[0]);
+        for (i=1; i<n; ++i)
+            if (baseline != (int)tr_torrentGetIdleMode (torrents[i]))
                 break;
-        if( i == n ) {
+        if (i == n) {
             GtkWidget * w = di->idle_combo;
-            g_signal_handler_block( w, di->idle_combo_tag );
-            gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), baseline );
-            gtr_widget_set_visible( di->idle_spin, baseline == TR_IDLELIMIT_SINGLE );
-            g_signal_handler_unblock( w, di->idle_combo_tag );
+            g_signal_handler_block (w, di->idle_combo_tag);
+            gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), baseline);
+            gtr_widget_set_visible (di->idle_spin, baseline == TR_IDLELIMIT_SINGLE);
+            g_signal_handler_unblock (w, di->idle_combo_tag);
         }
     }
-    if( n ) {
-        const int baseline = tr_torrentGetIdleLimit( torrents[0] );
-        set_int_spin_if_different( di->idle_spin,
-                                   di->idle_spin_tag, baseline );
+    if (n) {
+        const int baseline = tr_torrentGetIdleLimit (torrents[0]);
+        set_int_spin_if_different (di->idle_spin,
+                                   di->idle_spin_tag, baseline);
     }
 
     /* max_peers_spin */
-    if( n ) {
-        const int baseline = tr_torrentGetPeerLimit( torrents[0] );
-        set_int_spin_if_different( di->max_peers_spin,
-                                   di->max_peers_spin_tag, baseline );
+    if (n) {
+        const int baseline = tr_torrentGetPeerLimit (torrents[0]);
+        set_int_spin_if_different (di->max_peers_spin,
+                                   di->max_peers_spin_tag, baseline);
     }
 }
 
 static void
-torrent_set_bool( struct DetailsImpl * di, const char * key, gboolean value )
+torrent_set_bool (struct DetailsImpl * di, const char * key, gboolean value)
 {
     GSList *l;
     tr_benc top, *args, *ids;
 
-    tr_bencInitDict( &top, 2 );
-    tr_bencDictAddStr( &top, "method", "torrent-set" );
-    args = tr_bencDictAddDict( &top, "arguments", 2 );
-    tr_bencDictAddBool( args, key, value );
-    ids = tr_bencDictAddList( args, "ids", g_slist_length(di->ids) );
-    for( l=di->ids; l; l=l->next )
-        tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
+    tr_bencInitDict (&top, 2);
+    tr_bencDictAddStr (&top, "method", "torrent-set");
+    args = tr_bencDictAddDict (&top, "arguments", 2);
+    tr_bencDictAddBool (args, key, value);
+    ids = tr_bencDictAddList (args, "ids", g_slist_length (di->ids));
+    for (l=di->ids; l; l=l->next)
+        tr_bencListAddInt (ids, GPOINTER_TO_INT (l->data));
 
-    gtr_core_exec( di->core, &top );
-    tr_bencFree( &top );
+    gtr_core_exec (di->core, &top);
+    tr_bencFree (&top);
 }
 
 static void
-torrent_set_int( struct DetailsImpl * di, const char * key, int value )
+torrent_set_int (struct DetailsImpl * di, const char * key, int value)
 {
     GSList *l;
     tr_benc top, *args, *ids;
 
-    tr_bencInitDict( &top, 2 );
-    tr_bencDictAddStr( &top, "method", "torrent-set" );
-    args = tr_bencDictAddDict( &top, "arguments", 2 );
-    tr_bencDictAddInt( args, key, value );
-    ids = tr_bencDictAddList( args, "ids", g_slist_length(di->ids) );
-    for( l=di->ids; l; l=l->next )
-        tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
+    tr_bencInitDict (&top, 2);
+    tr_bencDictAddStr (&top, "method", "torrent-set");
+    args = tr_bencDictAddDict (&top, "arguments", 2);
+    tr_bencDictAddInt (args, key, value);
+    ids = tr_bencDictAddList (args, "ids", g_slist_length (di->ids));
+    for (l=di->ids; l; l=l->next)
+        tr_bencListAddInt (ids, GPOINTER_TO_INT (l->data));
 
-    gtr_core_exec( di->core, &top );
-    tr_bencFree( &top );
+    gtr_core_exec (di->core, &top);
+    tr_bencFree (&top);
 }
 
 static void
-torrent_set_real( struct DetailsImpl * di, const char * key, double value )
+torrent_set_real (struct DetailsImpl * di, const char * key, double value)
 {
     GSList *l;
     tr_benc top, *args, *ids;
 
-    tr_bencInitDict( &top, 2 );
-    tr_bencDictAddStr( &top, "method", "torrent-set" );
-    args = tr_bencDictAddDict( &top, "arguments", 2 );
-    tr_bencDictAddReal( args, key, value );
-    ids = tr_bencDictAddList( args, "ids", g_slist_length(di->ids) );
-    for( l=di->ids; l; l=l->next )
-        tr_bencListAddInt( ids, GPOINTER_TO_INT( l->data ) );
+    tr_bencInitDict (&top, 2);
+    tr_bencDictAddStr (&top, "method", "torrent-set");
+    args = tr_bencDictAddDict (&top, "arguments", 2);
+    tr_bencDictAddReal (args, key, value);
+    ids = tr_bencDictAddList (args, "ids", g_slist_length (di->ids));
+    for (l=di->ids; l; l=l->next)
+        tr_bencListAddInt (ids, GPOINTER_TO_INT (l->data));
 
-    gtr_core_exec( di->core, &top );
-    tr_bencFree( &top );
+    gtr_core_exec (di->core, &top);
+    tr_bencFree (&top);
 }
 
 static void
-up_speed_toggled_cb( GtkToggleButton * tb, gpointer d )
+up_speed_toggled_cb (GtkToggleButton * tb, gpointer d)
 {
-    torrent_set_bool( d, "uploadLimited", gtk_toggle_button_get_active( tb ) );
+    torrent_set_bool (d, "uploadLimited", gtk_toggle_button_get_active (tb));
 }
 
 static void
-down_speed_toggled_cb( GtkToggleButton *tb, gpointer d )
+down_speed_toggled_cb (GtkToggleButton *tb, gpointer d)
 {
-    torrent_set_bool( d, "downloadLimited", gtk_toggle_button_get_active( tb ) );
+    torrent_set_bool (d, "downloadLimited", gtk_toggle_button_get_active (tb));
 }
 
 static void
-global_speed_toggled_cb( GtkToggleButton * tb, gpointer d )
+global_speed_toggled_cb (GtkToggleButton * tb, gpointer d)
 {
-    torrent_set_bool( d, "honorsSessionLimits", gtk_toggle_button_get_active( tb ) );
+    torrent_set_bool (d, "honorsSessionLimits", gtk_toggle_button_get_active (tb));
 }
 
 static void
-up_speed_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
+up_speed_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
 {
-    torrent_set_int( di, "uploadLimit", gtk_spin_button_get_value_as_int( s ) );
+    torrent_set_int (di, "uploadLimit", gtk_spin_button_get_value_as_int (s));
 }
 
 static void
-down_speed_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
+down_speed_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
 {
-    torrent_set_int( di, "downloadLimit", gtk_spin_button_get_value_as_int( s ) );
+    torrent_set_int (di, "downloadLimit", gtk_spin_button_get_value_as_int (s));
 }
 
 static void
-idle_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
+idle_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
 {
-    torrent_set_int( di, "seedIdleLimit", gtk_spin_button_get_value_as_int( s ) );
+    torrent_set_int (di, "seedIdleLimit", gtk_spin_button_get_value_as_int (s));
 }
 
 static void
-ratio_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
+ratio_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
 {
-    torrent_set_real( di, "seedRatioLimit", gtk_spin_button_get_value( s ) );
+    torrent_set_real (di, "seedRatioLimit", gtk_spin_button_get_value (s));
 }
 
 static void
-max_peers_spun_cb( GtkSpinButton * s, struct DetailsImpl * di )
+max_peers_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
 {
-    torrent_set_int( di, "peer-limit", gtk_spin_button_get_value( s ) );
+    torrent_set_int (di, "peer-limit", gtk_spin_button_get_value (s));
 }
 
 static void
-onPriorityChanged( GtkComboBox * combo_box, struct DetailsImpl * di )
+onPriorityChanged (GtkComboBox * combo_box, struct DetailsImpl * di)
 {
-    const tr_priority_t priority = gtr_priority_combo_get_value( combo_box );
-    torrent_set_int( di, "bandwidthPriority", priority );
+    const tr_priority_t priority = gtr_priority_combo_get_value (combo_box);
+    torrent_set_int (di, "bandwidthPriority", priority);
 }
 
 static GtkWidget*
-new_priority_combo( struct DetailsImpl * di )
+new_priority_combo (struct DetailsImpl * di)
 {
-    GtkWidget * w = gtr_priority_combo_new( );
-    di->bandwidth_combo_tag = g_signal_connect( w, "changed", G_CALLBACK( onPriorityChanged ), di );
+    GtkWidget * w = gtr_priority_combo_new ();
+    di->bandwidth_combo_tag = g_signal_connect (w, "changed", G_CALLBACK (onPriorityChanged), di);
     return w;
 }
 
-static void refresh( struct DetailsImpl * di );
+static void refresh (struct DetailsImpl * di);
 
 static void
-onComboEnumChanged( GtkComboBox * combo_box, struct DetailsImpl * di )
+onComboEnumChanged (GtkComboBox * combo_box, struct DetailsImpl * di)
 {
-    const char * key = g_object_get_qdata( G_OBJECT( combo_box ), ARG_KEY );
-    torrent_set_int( di, key, gtr_combo_box_get_active_enum( combo_box ) );
-    refresh( di );
+    const char * key = g_object_get_qdata (G_OBJECT (combo_box), ARG_KEY);
+    torrent_set_int (di, key, gtr_combo_box_get_active_enum (combo_box));
+    refresh (di);
 }
 
 static GtkWidget*
-ratio_combo_new( void )
-{
-    GtkWidget * w = gtr_combo_box_new_enum(
-        _( "Use global settings" ),       TR_RATIOLIMIT_GLOBAL,
-        _( "Seed regardless of ratio" ),  TR_RATIOLIMIT_UNLIMITED,
-        _( "Stop seeding at ratio:" ),    TR_RATIOLIMIT_SINGLE,
-        NULL );
-    g_object_set_qdata( G_OBJECT( w ), ARG_KEY, (gpointer)"seedRatioMode" );
+ratio_combo_new (void)
+{
+    GtkWidget * w = gtr_combo_box_new_enum (
+        _("Use global settings"),       TR_RATIOLIMIT_GLOBAL,
+        _("Seed regardless of ratio"),  TR_RATIOLIMIT_UNLIMITED,
+        _("Stop seeding at ratio:"),    TR_RATIOLIMIT_SINGLE,
+        NULL);
+    g_object_set_qdata (G_OBJECT (w), ARG_KEY, (gpointer)"seedRatioMode");
     return w;
 }
 
 static GtkWidget*
-idle_combo_new( void )
+idle_combo_new (void)
 {
     GtkWidget * w = gtr_combo_box_new_enum (
-        _( "Use global settings" ),                 TR_IDLELIMIT_GLOBAL,
-        _( "Seed regardless of activity" ),         TR_IDLELIMIT_UNLIMITED,
-        _( "Stop seeding if idle for N minutes:" ), TR_IDLELIMIT_SINGLE,
-        NULL );
-    g_object_set_qdata( G_OBJECT( w ), ARG_KEY, (gpointer)"seedIdleMode" );
+        _("Use global settings"),                 TR_IDLELIMIT_GLOBAL,
+        _("Seed regardless of activity"),         TR_IDLELIMIT_UNLIMITED,
+        _("Stop seeding if idle for N minutes:"), TR_IDLELIMIT_SINGLE,
+        NULL);
+    g_object_set_qdata (G_OBJECT (w), ARG_KEY, (gpointer)"seedIdleMode");
     return w;
 }
 
 static GtkWidget*
-options_page_new( struct DetailsImpl * d )
+options_page_new (struct DetailsImpl * d)
 {
     guint row;
     gulong tag;
@@ -474,71 +474,71 @@ options_page_new( struct DetailsImpl * d )
     GtkWidget *t, *w, *tb, *h;
 
     row = 0;
-    t = hig_workarea_create( );
-    hig_workarea_add_section_title( t, &row, _( "Speed" ) );
+    t = hig_workarea_create ();
+    hig_workarea_add_section_title (t, &row, _("Speed"));
 
-    tb = hig_workarea_add_wide_checkbutton( t, &row, _( "Honor global _limits" ), 0 );
+    tb = hig_workarea_add_wide_checkbutton (t, &row, _("Honor global _limits"), 0);
     d->honor_limits_check = tb;
-    tag = g_signal_connect( tb, "toggled", G_CALLBACK( global_speed_toggled_cb ), d );
+    tag = g_signal_connect (tb, "toggled", G_CALLBACK (global_speed_toggled_cb), d);
     d->honor_limits_check_tag = tag;
 
-    g_snprintf( buf, sizeof( buf ), _( "Limit _download speed (%s):" ), _(speed_K_str) );
-    tb = gtk_check_button_new_with_mnemonic( buf );
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( tb ), FALSE );
+    g_snprintf (buf, sizeof (buf), _("Limit _download speed (%s):"), _ (speed_K_str));
+    tb = gtk_check_button_new_with_mnemonic (buf);
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tb), FALSE);
     d->down_limited_check = tb;
-    tag = g_signal_connect( tb, "toggled", G_CALLBACK( down_speed_toggled_cb ), d );
+    tag = g_signal_connect (tb, "toggled", G_CALLBACK (down_speed_toggled_cb), d);
     d->down_limited_check_tag = tag;
 
-    w = gtk_spin_button_new_with_range( 0, INT_MAX, 5 );
-    tag = g_signal_connect( w, "value-changed", G_CALLBACK( down_speed_spun_cb ), d );
+    w = gtk_spin_button_new_with_range (0, INT_MAX, 5);
+    tag = g_signal_connect (w, "value-changed", G_CALLBACK (down_speed_spun_cb), d);
     d->down_limit_spin_tag = tag;
-    hig_workarea_add_row_w( t, &row, tb, w, NULL );
+    hig_workarea_add_row_w (t, &row, tb, w, NULL);
     d->down_limit_spin = w;
 
-    g_snprintf( buf, sizeof( buf ), _( "Limit _upload speed (%s):" ), _(speed_K_str) );
-    tb = gtk_check_button_new_with_mnemonic( buf );
+    g_snprintf (buf, sizeof (buf), _("Limit _upload speed (%s):"), _ (speed_K_str));
+    tb = gtk_check_button_new_with_mnemonic (buf);
     d->up_limited_check = tb;
-    tag = g_signal_connect( tb, "toggled", G_CALLBACK( up_speed_toggled_cb ), d );
+    tag = g_signal_connect (tb, "toggled", G_CALLBACK (up_speed_toggled_cb), d);
     d->up_limited_check_tag = tag;
 
-    w = gtk_spin_button_new_with_range( 0, INT_MAX, 5 );
-    tag = g_signal_connect( w, "value-changed", G_CALLBACK( up_speed_spun_cb ), d );
+    w = gtk_spin_button_new_with_range (0, INT_MAX, 5);
+    tag = g_signal_connect (w, "value-changed", G_CALLBACK (up_speed_spun_cb), d);
     d->up_limit_spin_tag = tag;
-    hig_workarea_add_row_w( t, &row, tb, w, NULL );
+    hig_workarea_add_row_w (t, &row, tb, w, NULL);
     d->up_limit_sping = w;
 
-    w = new_priority_combo( d );
-    hig_workarea_add_row( t, &row, _( "Torrent _priority:" ), w, NULL );
+    w = new_priority_combo (d);
+    hig_workarea_add_row (t, &row, _("Torrent _priority:"), w, NULL);
     d->bandwidth_combo = w;
 
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, _( "Seeding Limits" ) );
-
-    h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD );
-    w = d->ratio_combo = ratio_combo_new( );
-    d->ratio_combo_tag = g_signal_connect( w, "changed", G_CALLBACK( onComboEnumChanged ), d );
-    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
-    w = d->ratio_spin = gtk_spin_button_new_with_range( 0, 1000, .05 );
-    gtk_entry_set_width_chars( GTK_ENTRY( w ), 7 );
-    d->ratio_spin_tag = g_signal_connect( w, "value-changed", G_CALLBACK( ratio_spun_cb ), d );
-    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
-    hig_workarea_add_row( t, &row, _( "_Ratio:" ), h, NULL );
-
-    h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD );
-    w = d->idle_combo = idle_combo_new( );
-    d->idle_combo_tag = g_signal_connect( w, "changed", G_CALLBACK( onComboEnumChanged ), d );
-    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
-    w = d->idle_spin = gtk_spin_button_new_with_range( 1, INT_MAX, 5 );
-    d->idle_spin_tag = g_signal_connect( w, "value-changed", G_CALLBACK( idle_spun_cb ), d );
-    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
-    hig_workarea_add_row( t, &row, _( "_Idle:" ), h, NULL );
-
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, _( "Peer Connections" ) );
-
-    w = gtk_spin_button_new_with_range( 1, 3000, 5 );
-    hig_workarea_add_row( t, &row, _( "_Maximum peers:" ), w, w );
-    tag = g_signal_connect( w, "value-changed", G_CALLBACK( max_peers_spun_cb ), d );
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Seeding Limits"));
+
+    h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
+    w = d->ratio_combo = ratio_combo_new ();
+    d->ratio_combo_tag = g_signal_connect (w, "changed", G_CALLBACK (onComboEnumChanged), d);
+    gtk_box_pack_start (GTK_BOX (h), w, TRUE, TRUE, 0);
+    w = d->ratio_spin = gtk_spin_button_new_with_range (0, 1000, .05);
+    gtk_entry_set_width_chars (GTK_ENTRY (w), 7);
+    d->ratio_spin_tag = g_signal_connect (w, "value-changed", G_CALLBACK (ratio_spun_cb), d);
+    gtk_box_pack_start (GTK_BOX (h), w, FALSE, FALSE, 0);
+    hig_workarea_add_row (t, &row, _("_Ratio:"), h, NULL);
+
+    h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
+    w = d->idle_combo = idle_combo_new ();
+    d->idle_combo_tag = g_signal_connect (w, "changed", G_CALLBACK (onComboEnumChanged), d);
+    gtk_box_pack_start (GTK_BOX (h), w, TRUE, TRUE, 0);
+    w = d->idle_spin = gtk_spin_button_new_with_range (1, INT_MAX, 5);
+    d->idle_spin_tag = g_signal_connect (w, "value-changed", G_CALLBACK (idle_spun_cb), d);
+    gtk_box_pack_start (GTK_BOX (h), w, FALSE, FALSE, 0);
+    hig_workarea_add_row (t, &row, _("_Idle:"), h, NULL);
+
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Peer Connections"));
+
+    w = gtk_spin_button_new_with_range (1, 3000, 5);
+    hig_workarea_add_row (t, &row, _("_Maximum peers:"), w, w);
+    tag = g_signal_connect (w, "value-changed", G_CALLBACK (max_peers_spun_cb), d);
     d->max_peers_spin = w;
     d->max_peers_spin_tag = tag;
 
@@ -552,204 +552,204 @@ options_page_new( struct DetailsImpl * d )
 ****/
 
 static const char *
-activityString( int activity, bool finished )
+activityString (int activity, bool finished)
 {
-    switch( activity )
+    switch (activity)
     {
-        case TR_STATUS_CHECK_WAIT:    return  _( "Queued for verification" );
-        case TR_STATUS_CHECK:         return  _( "Verifying local data" );
-        case TR_STATUS_DOWNLOAD_WAIT: return  _( "Queued for download" );
-        case TR_STATUS_DOWNLOAD:      return C_( "Verb", "Downloading" );
-        case TR_STATUS_SEED_WAIT:     return  _( "Queued for seeding" );
-        case TR_STATUS_SEED:          return C_( "Verb", "Seeding" );
-        case TR_STATUS_STOPPED:       return  finished ? _( "Finished" ) : _( "Paused" );
+        case TR_STATUS_CHECK_WAIT:    return  _("Queued for verification");
+        case TR_STATUS_CHECK:         return  _("Verifying local data");
+        case TR_STATUS_DOWNLOAD_WAIT: return  _("Queued for download");
+        case TR_STATUS_DOWNLOAD:      return C_("Verb", "Downloading");
+        case TR_STATUS_SEED_WAIT:     return  _("Queued for seeding");
+        case TR_STATUS_SEED:          return C_("Verb", "Seeding");
+        case TR_STATUS_STOPPED:       return  finished ? _("Finished") : _("Paused");
     }
 
     return "";
 }
 
-/* Only call gtk_text_buffer_set_text() if the new text differs from the old.
+/* Only call gtk_text_buffer_set_text () if the new text differs from the old.
  * This way if the user has text selected, refreshing won't deselect it */
 static void
-gtr_text_buffer_set_text( GtkTextBuffer * b, const char * str )
+gtr_text_buffer_set_text (GtkTextBuffer * b, const char * str)
 {
     char * old_str;
     GtkTextIter start, end;
 
-    if( str == NULL )
+    if (str == NULL)
         str = "";
 
-    gtk_text_buffer_get_bounds( b, &start, &end );
-    old_str = gtk_text_buffer_get_text( b, &start, &end, FALSE );
+    gtk_text_buffer_get_bounds (b, &start, &end);
+    old_str = gtk_text_buffer_get_text (b, &start, &end, FALSE);
 
-    if( ( old_str == NULL ) || strcmp( old_str, str ) )
-        gtk_text_buffer_set_text( b, str, -1 );
+    if ((old_str == NULL) || strcmp (old_str, str))
+        gtk_text_buffer_set_text (b, str, -1);
 
-    g_free( old_str );
+    g_free (old_str);
 }
 
 static char*
-get_short_date_string( time_t t )
+get_short_date_string (time_t t)
 {
     char buf[64];
     struct tm tm;
 
-    if( !t )
-        return g_strdup( _( "N/A" ) );
+    if (!t)
+        return g_strdup (_("N/A"));
 
-    tr_localtime_r( &t, &tm );
-    strftime( buf, sizeof( buf ), "%d %b %Y", &tm );
-    return g_locale_to_utf8( buf, -1, NULL, NULL, NULL );
+    tr_localtime_r (&t, &tm);
+    strftime (buf, sizeof (buf), "%d %b %Y", &tm);
+    return g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
 };
 
 static void
-refreshInfo( struct DetailsImpl * di, tr_torrent ** torrents, int n )
+refreshInfo (struct DetailsImpl * di, tr_torrent ** torrents, int n)
 {
     int i;
     const char * str;
-    const char * mixed = _( "Mixed" );
-    const char * no_torrent = _( "No Torrents Selected" );
+    const char * mixed = _("Mixed");
+    const char * no_torrent = _("No Torrents Selected");
     const char * stateString;
     char buf[512];
     uint64_t sizeWhenDone = 0;
-    const tr_stat ** stats = g_new( const tr_stat*, n );
-    const tr_info ** infos = g_new( const tr_info*, n );
-    for( i=0; i<n; ++i ) {
-        stats[i] = tr_torrentStatCached( torrents[i] );
-        infos[i] = tr_torrentInfo( torrents[i] );
+    const tr_stat ** stats = g_new (const tr_stat*, n);
+    const tr_info ** infos = g_new (const tr_info*, n);
+    for (i=0; i<n; ++i) {
+        stats[i] = tr_torrentStatCached (torrents[i]);
+        infos[i] = tr_torrentInfo (torrents[i]);
     }
 
     /* privacy_lb */
-    if( n<=0 )
+    if (n<=0)
         str = no_torrent;
     else {
         const bool baseline = infos[0]->isPrivate;
-        for( i=1; i<n; ++i )
-            if( baseline != infos[i]->isPrivate )
+        for (i=1; i<n; ++i)
+            if (baseline != infos[i]->isPrivate)
                 break;
-        if( i!=n )
+        if (i!=n)
             str = mixed;
-        else if( baseline )
-            str = _( "Private to this tracker -- DHT and PEX disabled" );
+        else if (baseline)
+            str = _("Private to this tracker -- DHT and PEX disabled");
         else
-            str = _( "Public torrent" );
+            str = _("Public torrent");
     }
-    gtr_label_set_text( GTK_LABEL( di->privacy_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->privacy_lb), str);
 
 
     /* origin_lb */
-    if( n<=0 )
+    if (n<=0)
         str = no_torrent;
     else {
         const char * creator = infos[0]->creator ? infos[0]->creator : "";
         const time_t date = infos[0]->dateCreated;
-        char * datestr = get_short_date_string( date );
+        char * datestr = get_short_date_string (date);
         gboolean mixed_creator = FALSE;
         gboolean mixed_date = FALSE;
 
-        for( i=1; i<n; ++i ) {
-            mixed_creator |= strcmp( creator, infos[i]->creator ? infos[i]->creator : "" );
-            mixed_date |= ( date != infos[i]->dateCreated );
+        for (i=1; i<n; ++i) {
+            mixed_creator |= strcmp (creator, infos[i]->creator ? infos[i]->creator : "");
+            mixed_date |= (date != infos[i]->dateCreated);
         }
-        if( mixed_date && mixed_creator )
+        if (mixed_date && mixed_creator)
             str = mixed;
         else {
-            if( mixed_date )
-                g_snprintf( buf, sizeof( buf ), _( "Created by %1$s" ), creator );
-            else if( mixed_creator || !*creator )
-                g_snprintf( buf, sizeof( buf ), _( "Created on %1$s" ), datestr );
+            if (mixed_date)
+                g_snprintf (buf, sizeof (buf), _("Created by %1$s"), creator);
+            else if (mixed_creator || !*creator)
+                g_snprintf (buf, sizeof (buf), _("Created on %1$s"), datestr);
             else
-                g_snprintf( buf, sizeof( buf ), _( "Created by %1$s on %2$s" ), creator, datestr );
+                g_snprintf (buf, sizeof (buf), _("Created by %1$s on %2$s"), creator, datestr);
             str = buf;
         }
 
-        g_free( datestr );
+        g_free (datestr);
     }
-    gtr_label_set_text( GTK_LABEL( di->origin_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->origin_lb), str);
 
 
     /* comment_buffer */
-    if( n<=0 )
+    if (n<=0)
         str = "";
     else {
         const char * baseline = infos[0]->comment ? infos[0]->comment : "";
-        for( i=1; i<n; ++i )
-            if( strcmp( baseline, infos[i]->comment ? infos[i]->comment : "" ) )
+        for (i=1; i<n; ++i)
+            if (strcmp (baseline, infos[i]->comment ? infos[i]->comment : ""))
                 break;
-        if( i==n )
+        if (i==n)
             str = baseline;
         else
             str = mixed;
     }
-    gtr_text_buffer_set_text( di->comment_buffer, str );
+    gtr_text_buffer_set_text (di->comment_buffer, str);
 
     /* destination_lb */
-    if( n<=0 )
+    if (n<=0)
         str = no_torrent;
     else {
-        const char * baseline = tr_torrentGetDownloadDir( torrents[0] );
-        for( i=1; i<n; ++i )
-            if( strcmp( baseline, tr_torrentGetDownloadDir( torrents[i] ) ) )
+        const char * baseline = tr_torrentGetDownloadDir (torrents[0]);
+        for (i=1; i<n; ++i)
+            if (strcmp (baseline, tr_torrentGetDownloadDir (torrents[i])))
                 break;
-        if( i==n )
+        if (i==n)
             str = baseline;
         else
             str = mixed;
     }
-    gtr_label_set_text( GTK_LABEL( di->destination_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->destination_lb), str);
 
     /* state_lb */
-    if( n<=0 )
+    if (n<=0)
         str = no_torrent;
     else {
         const tr_torrent_activity activity = stats[0]->activity;
         bool allFinished = stats[0]->finished;
-        for( i=1; i<n; ++i ) {
-            if( activity != stats[i]->activity )
+        for (i=1; i<n; ++i) {
+            if (activity != stats[i]->activity)
                 break;
-            if( !stats[i]->finished )
+            if (!stats[i]->finished)
                 allFinished = FALSE;
         }
-        str = i<n ? mixed : activityString( activity, allFinished );
+        str = i<n ? mixed : activityString (activity, allFinished);
     }
     stateString = str;
-    gtr_label_set_text( GTK_LABEL( di->state_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->state_lb), str);
 
 
     /* date started */
-    if( n<=0 )
+    if (n<=0)
         str = no_torrent;
     else {
         const time_t baseline = stats[0]->startDate;
-        for( i=1; i<n; ++i )
-            if( baseline != stats[i]->startDate )
+        for (i=1; i<n; ++i)
+            if (baseline != stats[i]->startDate)
                 break;
-        if( i != n )
+        if (i != n)
             str = mixed;
-        else if( ( baseline<=0 ) || ( stats[0]->activity == TR_STATUS_STOPPED ) )
+        else if ((baseline<=0) || (stats[0]->activity == TR_STATUS_STOPPED))
             str = stateString;
         else
-            str = tr_strltime( buf, time(NULL)-baseline, sizeof( buf ) );
+            str = tr_strltime (buf, time (NULL)-baseline, sizeof (buf));
     }
-    gtr_label_set_text( GTK_LABEL( di->date_started_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->date_started_lb), str);
 
 
     /* eta */
-    if( n<=0 )
+    if (n<=0)
         str = no_torrent;
     else {
         const int baseline = stats[0]->eta;
-        for( i=1; i<n; ++i )
-            if( baseline != stats[i]->eta )
+        for (i=1; i<n; ++i)
+            if (baseline != stats[i]->eta)
                 break;
-        if( i!=n )
+        if (i!=n)
             str = mixed;
-        else if( baseline < 0 )
-            str = _( "Unknown" );
+        else if (baseline < 0)
+            str = _("Unknown");
         else
-            str = tr_strltime( buf, baseline, sizeof( buf ) );
+            str = tr_strltime (buf, baseline, sizeof (buf));
     }
-    gtr_label_set_text( GTK_LABEL( di->eta_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->eta_lb), str);
 
 
     /* size_lb */
@@ -758,45 +758,45 @@ refreshInfo( struct DetailsImpl * di, tr_torrent ** torrents, int n )
         uint64_t size = 0;
         int pieces = 0;
         int32_t pieceSize = 0;
-        for( i=0; i<n; ++i ) {
+        for (i=0; i<n; ++i) {
             size += infos[i]->totalSize;
             pieces += infos[i]->pieceCount;
-            if( !pieceSize )
+            if (!pieceSize)
                 pieceSize = infos[i]->pieceSize;
-            else if( pieceSize != (int)infos[i]->pieceSize )
+            else if (pieceSize != (int)infos[i]->pieceSize)
                 pieceSize = -1;
         }
-        tr_strlsize( sizebuf, size, sizeof( sizebuf ) );
-        if( !size )
+        tr_strlsize (sizebuf, size, sizeof (sizebuf));
+        if (!size)
             str = "";
-        else if( pieceSize >= 0 ) {
+        else if (pieceSize >= 0) {
             char piecebuf[128];
-            tr_formatter_mem_B( piecebuf, pieceSize, sizeof( piecebuf ) );
-            g_snprintf( buf, sizeof( buf ),
-                        ngettext( "%1$s (%2$'d piece @ %3$s)",
-                                      "%1$s (%2$'d pieces @ %3$s)", pieces ),
-                        sizebuf, pieces, piecebuf );
+            tr_formatter_mem_B (piecebuf, pieceSize, sizeof (piecebuf));
+            g_snprintf (buf, sizeof (buf),
+                        ngettext ("%1$s (%2$'d piece @ %3$s)",
+                                      "%1$s (%2$'d pieces @ %3$s)", pieces),
+                        sizebuf, pieces, piecebuf);
             str = buf;
         } else {
-            g_snprintf( buf, sizeof( buf ),
-                        ngettext( "%1$s (%2$'d piece)",
-                                      "%1$s (%2$'d pieces)", pieces ),
-                        sizebuf, pieces );
+            g_snprintf (buf, sizeof (buf),
+                        ngettext ("%1$s (%2$'d piece)",
+                                      "%1$s (%2$'d pieces)", pieces),
+                        sizebuf, pieces);
             str = buf;
         }
-        gtr_label_set_text( GTK_LABEL( di->size_lb ), str );
+        gtr_label_set_text (GTK_LABEL (di->size_lb), str);
     }
 
 
     /* have_lb */
-    if( n <= 0 )
+    if (n <= 0)
         str = no_torrent;
     else {
         uint64_t leftUntilDone = 0;
         uint64_t haveUnchecked = 0;
         uint64_t haveValid = 0;
         uint64_t available = 0;
-        for( i=0; i<n; ++i ) {
+        for (i=0; i<n; ++i) {
             const tr_stat * st = stats[i];
             haveUnchecked += st->haveUnchecked;
             haveValid += st->haveValid;
@@ -806,224 +806,224 @@ refreshInfo( struct DetailsImpl * di, tr_torrent ** torrents, int n )
         }
         {
             char buf2[32], unver[64], total[64], avail[32];
-            const double d = sizeWhenDone ? ( 100.0 * available ) / sizeWhenDone : 0;
-            const double ratio = 100.0 * ( sizeWhenDone ? ( haveValid + haveUnchecked ) / (double)sizeWhenDone : 1 );
-            tr_strlpercent( avail, d, sizeof( avail ) );
-            tr_strlpercent( buf2, ratio, sizeof( buf2 ) );
-            tr_strlsize( total, haveUnchecked + haveValid, sizeof( total ) );
-            tr_strlsize( unver, haveUnchecked,             sizeof( unver ) );
-            if( !haveUnchecked && !leftUntilDone )
-                g_snprintf( buf, sizeof( buf ), _( "%1$s (%2$s%%)" ), total, buf2 );
-            else if( !haveUnchecked )
-                g_snprintf( buf, sizeof( buf ), _( "%1$s (%2$s%% of %3$s%% Available)" ), total, buf2, avail );
+            const double d = sizeWhenDone ? (100.0 * available) / sizeWhenDone : 0;
+            const double ratio = 100.0 * (sizeWhenDone ? (haveValid + haveUnchecked) / (double)sizeWhenDone : 1);
+            tr_strlpercent (avail, d, sizeof (avail));
+            tr_strlpercent (buf2, ratio, sizeof (buf2));
+            tr_strlsize (total, haveUnchecked + haveValid, sizeof (total));
+            tr_strlsize (unver, haveUnchecked,             sizeof (unver));
+            if (!haveUnchecked && !leftUntilDone)
+                g_snprintf (buf, sizeof (buf), _("%1$s (%2$s%%)"), total, buf2);
+            else if (!haveUnchecked)
+                g_snprintf (buf, sizeof (buf), _("%1$s (%2$s%% of %3$s%% Available)"), total, buf2, avail);
             else
-                g_snprintf( buf, sizeof( buf ), _( "%1$s (%2$s%% of %3$s%% Available); %4$s Unverified" ), total, buf2, avail, unver );
+                g_snprintf (buf, sizeof (buf), _("%1$s (%2$s%% of %3$s%% Available); %4$s Unverified"), total, buf2, avail, unver);
             str = buf;
         }
     }
-    gtr_label_set_text( GTK_LABEL( di->have_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->have_lb), str);
 
     /* dl_lb */
-    if( n <= 0 )
+    if (n <= 0)
         str = no_torrent;
     else {
         char dbuf[64], fbuf[64];
         uint64_t d=0, f=0;
-        for( i=0; i<n; ++i ) {
+        for (i=0; i<n; ++i) {
             d += stats[i]->downloadedEver;
             f += stats[i]->corruptEver;
         }
-        tr_strlsize( dbuf, d, sizeof( dbuf ) );
-        tr_strlsize( fbuf, f, sizeof( fbuf ) );
-        if( f )
-            g_snprintf( buf, sizeof( buf ), _( "%1$s (+%2$s corrupt)" ), dbuf, fbuf );
+        tr_strlsize (dbuf, d, sizeof (dbuf));
+        tr_strlsize (fbuf, f, sizeof (fbuf));
+        if (f)
+            g_snprintf (buf, sizeof (buf), _("%1$s (+%2$s corrupt)"), dbuf, fbuf);
         else
-            tr_strlcpy( buf, dbuf, sizeof( buf ) );
+            tr_strlcpy (buf, dbuf, sizeof (buf));
         str = buf;
     }
-    gtr_label_set_text( GTK_LABEL( di->dl_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->dl_lb), str);
 
 
     /* ul_lb */
-    if( n <= 0 )
+    if (n <= 0)
         str = no_torrent;
     else {
         char upstr[64];
         char ratiostr[64];
         uint64_t up = 0;
         uint64_t down = 0;
-        for( i=0; i<n; ++i ) {
+        for (i=0; i<n; ++i) {
             up += stats[i]->uploadedEver;
             down += stats[i]->downloadedEver;
         }
-        tr_strlsize( upstr, up, sizeof( upstr ) );
-        tr_strlratio( ratiostr, tr_getRatio( up, down ), sizeof( ratiostr ) );
-        g_snprintf( buf, sizeof( buf ), _( "%s (Ratio: %s)" ), upstr, ratiostr );
+        tr_strlsize (upstr, up, sizeof (upstr));
+        tr_strlratio (ratiostr, tr_getRatio (up, down), sizeof (ratiostr));
+        g_snprintf (buf, sizeof (buf), _("%s (Ratio: %s)"), upstr, ratiostr);
         str = buf;
     }
-    gtr_label_set_text( GTK_LABEL( di->ul_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->ul_lb), str);
 
     /* hash_lb */
-    if( n <= 0 )
+    if (n <= 0)
         str = no_torrent;
-    else if ( n==1 )
+    else if (n==1)
         str = infos[0]->hashString;
     else
         str = mixed;
-    gtr_label_set_text( GTK_LABEL( di->hash_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->hash_lb), str);
 
     /* error */
-    if( n <= 0 )
+    if (n <= 0)
         str = no_torrent;
     else {
         const char * baseline = stats[0]->errorString;
-        for( i=1; i<n; ++i )
-            if( strcmp( baseline, stats[i]->errorString ) )
+        for (i=1; i<n; ++i)
+            if (strcmp (baseline, stats[i]->errorString))
                 break;
-        if( i==n )
+        if (i==n)
             str = baseline;
         else
             str = mixed;
     }
-    if( !str || !*str )
-        str = _( "No errors" );
-    gtr_label_set_text( GTK_LABEL( di->error_lb ), str );
+    if (!str || !*str)
+        str = _("No errors");
+    gtr_label_set_text (GTK_LABEL (di->error_lb), str);
 
 
     /* activity date */
-    if( n <= 0 )
+    if (n <= 0)
         str = no_torrent;
     else {
         time_t latest = 0;
-        for( i=0; i<n; ++i )
-            if( latest < stats[i]->activityDate )
+        for (i=0; i<n; ++i)
+            if (latest < stats[i]->activityDate)
                 latest = stats[i]->activityDate;
-        if( latest <= 0 )
-            str = _( "Never" );
+        if (latest <= 0)
+            str = _("Never");
         else {
-            const int period = time( NULL ) - latest;
-            if( period < 5 )
-                tr_strlcpy( buf, _( "Active now" ), sizeof( buf ) );
+            const int period = time (NULL) - latest;
+            if (period < 5)
+                tr_strlcpy (buf, _("Active now"), sizeof (buf));
             else {
                 char tbuf[128];
-                tr_strltime( tbuf, period, sizeof( tbuf ) );
-                g_snprintf( buf, sizeof( buf ), _( "%1$s ago" ), tbuf );
+                tr_strltime (tbuf, period, sizeof (tbuf));
+                g_snprintf (buf, sizeof (buf), _("%1$s ago"), tbuf);
             }
             str = buf;
         }
     }
-    gtr_label_set_text( GTK_LABEL( di->last_activity_lb ), str );
+    gtr_label_set_text (GTK_LABEL (di->last_activity_lb), str);
 
-    g_free( stats );
-    g_free( infos );
+    g_free (stats);
+    g_free (infos);
 }
 
 static GtkWidget*
-info_page_new( struct DetailsImpl * di )
+info_page_new (struct DetailsImpl * di)
 {
     guint row = 0;
     GtkTextBuffer * b;
     GtkWidget *l, *w, *fr, *sw;
-    GtkWidget *t = hig_workarea_create( );
+    GtkWidget *t = hig_workarea_create ();
 
-    hig_workarea_add_section_title( t, &row, _( "Activity" ) );
+    hig_workarea_add_section_title (t, &row, _("Activity"));
 
         /* size */
-        l = di->size_lb = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "Torrent size:" ), l, NULL );
+        l = di->size_lb = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("Torrent size:"), l, NULL);
 
         /* have */
-        l = di->have_lb = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "Have:" ), l, NULL );
+        l = di->have_lb = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("Have:"), l, NULL);
 
         /* downloaded */
-        l = di->dl_lb = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "Downloaded:" ), l, NULL );
+        l = di->dl_lb = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("Downloaded:"), l, NULL);
 
         /* uploaded */
-        l = di->ul_lb = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "Uploaded:" ), l, NULL );
+        l = di->ul_lb = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("Uploaded:"), l, NULL);
 
         /* state */
-        l = di->state_lb = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "State:" ), l, NULL );
+        l = di->state_lb = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("State:"), l, NULL);
 
         /* running for */
-        l = di->date_started_lb = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "Running time:" ), l, NULL );
+        l = di->date_started_lb = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("Running time:"), l, NULL);
 
         /* eta */
-        l = di->eta_lb = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "Remaining time:" ), l, NULL );
+        l = di->eta_lb = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("Remaining time:"), l, NULL);
 
         /* last activity */
-        l = di->last_activity_lb = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "Last activity:" ), l, NULL );
+        l = di->last_activity_lb = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("Last activity:"), l, NULL);
 
         /* error */
-        l = g_object_new( GTK_TYPE_LABEL, "selectable", TRUE,
+        l = g_object_new (GTK_TYPE_LABEL, "selectable", TRUE,
                                           "ellipsize", PANGO_ELLIPSIZE_END,
-                                          NULL );
-        hig_workarea_add_row( t, &row, _( "Error:" ), l, NULL );
+                                          NULL);
+        hig_workarea_add_row (t, &row, _("Error:"), l, NULL);
         di->error_lb = l;
 
 
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, _( "Details" ) );
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Details"));
 
         /* destination */
-        l = g_object_new( GTK_TYPE_LABEL, "selectable", TRUE,
+        l = g_object_new (GTK_TYPE_LABEL, "selectable", TRUE,
                                           "ellipsize", PANGO_ELLIPSIZE_END,
-                                          NULL );
-        hig_workarea_add_row( t, &row, _( "Location:" ), l, NULL );
+                                          NULL);
+        hig_workarea_add_row (t, &row, _("Location:"), l, NULL);
         di->destination_lb = l;
 
         /* hash */
-        l = g_object_new( GTK_TYPE_LABEL, "selectable", TRUE,
+        l = g_object_new (GTK_TYPE_LABEL, "selectable", TRUE,
                                           "ellipsize", PANGO_ELLIPSIZE_END,
-                                           NULL );
-        hig_workarea_add_row( t, &row, _( "Hash:" ), l, NULL );
+                                           NULL);
+        hig_workarea_add_row (t, &row, _("Hash:"), l, NULL);
         di->hash_lb = l;
 
         /* privacy */
-        l = gtk_label_new( NULL );
-        gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-        hig_workarea_add_row( t, &row, _( "Privacy:" ), l, NULL );
+        l = gtk_label_new (NULL);
+        gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+        hig_workarea_add_row (t, &row, _("Privacy:"), l, NULL);
         di->privacy_lb = l;
 
         /* origins */
-        l = g_object_new( GTK_TYPE_LABEL, "selectable", TRUE,
+        l = g_object_new (GTK_TYPE_LABEL, "selectable", TRUE,
                                           "ellipsize", PANGO_ELLIPSIZE_END,
-                                          NULL );
-        hig_workarea_add_row( t, &row, _( "Origin:" ), l, NULL );
+                                          NULL);
+        hig_workarea_add_row (t, &row, _("Origin:"), l, NULL);
         di->origin_lb = l;
 
         /* comment */
-        b = di->comment_buffer = gtk_text_buffer_new( NULL );
-        w = gtk_text_view_new_with_buffer( b );
-        gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW( w ), GTK_WRAP_WORD );
-        gtk_text_view_set_editable( GTK_TEXT_VIEW( w ), FALSE );
-        sw = gtk_scrolled_window_new( NULL, NULL );
-        gtk_widget_set_size_request( sw, 350, 36 );
-        gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sw ),
+        b = di->comment_buffer = gtk_text_buffer_new (NULL);
+        w = gtk_text_view_new_with_buffer (b);
+        gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (w), GTK_WRAP_WORD);
+        gtk_text_view_set_editable (GTK_TEXT_VIEW (w), FALSE);
+        sw = gtk_scrolled_window_new (NULL, NULL);
+        gtk_widget_set_size_request (sw, 350, 36);
+        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                         GTK_POLICY_AUTOMATIC,
-                                        GTK_POLICY_AUTOMATIC );
-        gtk_container_add( GTK_CONTAINER( sw ), w );
-        fr = gtk_frame_new( NULL );
-        gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_IN );
-        gtk_container_add( GTK_CONTAINER( fr ), sw );
-        w = hig_workarea_add_tall_row( t, &row, _( "Comment:" ), fr, NULL );
-        gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.0f );
-
-    hig_workarea_add_section_divider( t, &row );
+                                        GTK_POLICY_AUTOMATIC);
+        gtk_container_add (GTK_CONTAINER (sw), w);
+        fr = gtk_frame_new (NULL);
+        gtk_frame_set_shadow_type (GTK_FRAME (fr), GTK_SHADOW_IN);
+        gtk_container_add (GTK_CONTAINER (fr), sw);
+        w = hig_workarea_add_tall_row (t, &row, _("Comment:"), fr, NULL);
+        gtk_misc_set_alignment (GTK_MISC (w), 0.0f, 0.0f);
+
+    hig_workarea_add_section_divider (t, &row);
     return t;
 }
 
@@ -1044,26 +1044,26 @@ enum
 };
 
 static const char*
-getWebseedColumnNames( int column )
+getWebseedColumnNames (int column)
 {
-    switch( column )
+    switch (column)
     {
-        case WEBSEED_COL_URL: return _( "Web Seeds" );
+        case WEBSEED_COL_URL: return _("Web Seeds");
         case WEBSEED_COL_DOWNLOAD_RATE_DOUBLE:
-        case WEBSEED_COL_DOWNLOAD_RATE_STRING: return _( "Down" );
+        case WEBSEED_COL_DOWNLOAD_RATE_STRING: return _("Down");
         default: return "";
     }
 }
 
 static GtkListStore*
-webseed_model_new( void )
+webseed_model_new (void)
 {
-    return gtk_list_store_new( N_WEBSEED_COLS,
+    return gtk_list_store_new (N_WEBSEED_COLS,
                                G_TYPE_STRING,   /* key */
                                G_TYPE_BOOLEAN,  /* was-updated */
                                G_TYPE_STRING,   /* url */
                                G_TYPE_DOUBLE,   /* download rate double */
-                               G_TYPE_STRING ); /* download rate string */
+                               G_TYPE_STRING); /* download rate string */
 }
 
 enum
@@ -1097,38 +1097,38 @@ enum
 };
 
 static const char*
-getPeerColumnName( int column )
+getPeerColumnName (int column)
 {
-    switch( column )
+    switch (column)
     {
-        case PEER_COL_ADDRESS: return _( "Address" );
+        case PEER_COL_ADDRESS: return _("Address");
         case PEER_COL_DOWNLOAD_RATE_STRING:
-        case PEER_COL_DOWNLOAD_RATE_DOUBLE: return _( "Down" );
+        case PEER_COL_DOWNLOAD_RATE_DOUBLE: return _("Down");
         case PEER_COL_UPLOAD_RATE_STRING:
-        case PEER_COL_UPLOAD_RATE_DOUBLE: return _( "Up" );
-        case PEER_COL_CLIENT: return _( "Client" );
-        case PEER_COL_PROGRESS: return _( "%" );
+        case PEER_COL_UPLOAD_RATE_DOUBLE: return _("Up");
+        case PEER_COL_CLIENT: return _("Client");
+        case PEER_COL_PROGRESS: return _("%");
         case PEER_COL_UPLOAD_REQUEST_COUNT_INT:
-        case PEER_COL_UPLOAD_REQUEST_COUNT_STRING: return _( "Up Reqs" );
+        case PEER_COL_UPLOAD_REQUEST_COUNT_STRING: return _("Up Reqs");
         case PEER_COL_DOWNLOAD_REQUEST_COUNT_INT:
-        case PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING: return _( "Dn Reqs" );
+        case PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING: return _("Dn Reqs");
         case PEER_COL_BLOCKS_DOWNLOADED_COUNT_INT:
-        case PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING: return _( "Dn Blocks" );
+        case PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING: return _("Dn Blocks");
         case PEER_COL_BLOCKS_UPLOADED_COUNT_INT:
-        case PEER_COL_BLOCKS_UPLOADED_COUNT_STRING: return _( "Up Blocks" );
+        case PEER_COL_BLOCKS_UPLOADED_COUNT_STRING: return _("Up Blocks");
         case PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_INT:
-        case PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING: return _( "We Cancelled" );
+        case PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING: return _("We Cancelled");
         case PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_INT:
-        case PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING: return _( "They Cancelled" );
-        case PEER_COL_FLAGS: return _( "Flags" );
+        case PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING: return _("They Cancelled");
+        case PEER_COL_FLAGS: return _("Flags");
         default: return "";
     }
 }
 
 static GtkListStore*
-peer_store_new( void )
+peer_store_new (void)
 {
-    return gtk_list_store_new( N_PEER_COLS,
+    return gtk_list_store_new (N_PEER_COLS,
                                G_TYPE_STRING,   /* key */
                                G_TYPE_BOOLEAN,  /* was-updated */
                                G_TYPE_STRING,   /* address */
@@ -1157,39 +1157,39 @@ peer_store_new( void )
 }
 
 static void
-initPeerRow( GtkListStore        * store,
+initPeerRow (GtkListStore        * store,
              GtkTreeIter         * iter,
              const char          * key,
              const char          * torrentName,
-             const tr_peer_stat  * peer )
+             const tr_peer_stat  * peer)
 {
     int q[4];
     char collated_name[128];
     const char * client = peer->client;
 
-    if( !client || !strcmp( client, "Unknown Client" ) )
+    if (!client || !strcmp (client, "Unknown Client"))
         client = "";
 
-    if( sscanf( peer->addr, "%d.%d.%d.%d", q, q+1, q+2, q+3 ) != 4 )
-        g_strlcpy( collated_name, peer->addr, sizeof( collated_name ) );
+    if (sscanf (peer->addr, "%d.%d.%d.%d", q, q+1, q+2, q+3) != 4)
+        g_strlcpy (collated_name, peer->addr, sizeof (collated_name));
     else
-        g_snprintf( collated_name, sizeof( collated_name ),
-                    "%03d.%03d.%03d.%03d", q[0], q[1], q[2], q[3] );
+        g_snprintf (collated_name, sizeof (collated_name),
+                    "%03d.%03d.%03d.%03d", q[0], q[1], q[2], q[3]);
 
-    gtk_list_store_set( store, iter,
+    gtk_list_store_set (store, iter,
                         PEER_COL_ADDRESS, peer->addr,
                         PEER_COL_ADDRESS_COLLATED, collated_name,
                         PEER_COL_CLIENT, client,
                         PEER_COL_ENCRYPTION_STOCK_ID, peer->isEncrypted ? "transmission-lock" : NULL,
                         PEER_COL_KEY, key,
                         PEER_COL_TORRENT_NAME, torrentName,
-                        -1 );
+                        -1);
 }
 
 static void
-refreshPeerRow( GtkListStore        * store,
+refreshPeerRow (GtkListStore        * store,
                 GtkTreeIter         * iter,
-                const tr_peer_stat  * peer )
+                const tr_peer_stat  * peer)
 {
     char up_speed[64] = { '\0' };
     char down_speed[64] = { '\0' };
@@ -1200,32 +1200,32 @@ refreshPeerRow( GtkListStore        * store,
     char cancelled_by_peer[64] = { '\0' };
     char cancelled_by_client[64] = { '\0' };
 
-    if( peer->rateToPeer_KBps > 0.01 )
-        tr_formatter_speed_KBps( up_speed, peer->rateToPeer_KBps, sizeof( up_speed ) );
+    if (peer->rateToPeer_KBps > 0.01)
+        tr_formatter_speed_KBps (up_speed, peer->rateToPeer_KBps, sizeof (up_speed));
 
-    if( peer->rateToClient_KBps > 0 )
-        tr_formatter_speed_KBps( down_speed, peer->rateToClient_KBps, sizeof( down_speed ) );
+    if (peer->rateToClient_KBps > 0)
+        tr_formatter_speed_KBps (down_speed, peer->rateToClient_KBps, sizeof (down_speed));
 
-    if( peer->pendingReqsToPeer > 0 )
-        g_snprintf( down_count, sizeof( down_count ), "%d", peer->pendingReqsToPeer );
+    if (peer->pendingReqsToPeer > 0)
+        g_snprintf (down_count, sizeof (down_count), "%d", peer->pendingReqsToPeer);
 
-    if( peer->pendingReqsToClient > 0 )
-        g_snprintf( up_count, sizeof( down_count ), "%d", peer->pendingReqsToClient );
+    if (peer->pendingReqsToClient > 0)
+        g_snprintf (up_count, sizeof (down_count), "%d", peer->pendingReqsToClient);
 
-    if( peer->blocksToPeer > 0 )
-        g_snprintf( blocks_to_peer, sizeof( blocks_to_peer ), "%"PRIu32, peer->blocksToPeer );
+    if (peer->blocksToPeer > 0)
+        g_snprintf (blocks_to_peer, sizeof (blocks_to_peer), "%"PRIu32, peer->blocksToPeer);
 
-    if( peer->blocksToClient > 0 )
-        g_snprintf( blocks_to_client, sizeof( blocks_to_client ), "%"PRIu32, peer->blocksToClient );
+    if (peer->blocksToClient > 0)
+        g_snprintf (blocks_to_client, sizeof (blocks_to_client), "%"PRIu32, peer->blocksToClient);
 
-    if( peer->cancelsToPeer > 0 )
-        g_snprintf( cancelled_by_client, sizeof( cancelled_by_client ), "%"PRIu32, peer->cancelsToPeer );
+    if (peer->cancelsToPeer > 0)
+        g_snprintf (cancelled_by_client, sizeof (cancelled_by_client), "%"PRIu32, peer->cancelsToPeer);
 
-    if( peer->cancelsToClient > 0 )
-        g_snprintf( cancelled_by_peer, sizeof( cancelled_by_peer ), "%"PRIu32, peer->cancelsToClient );
+    if (peer->cancelsToClient > 0)
+        g_snprintf (cancelled_by_peer, sizeof (cancelled_by_peer), "%"PRIu32, peer->cancelsToClient);
 
-    gtk_list_store_set( store, iter,
-        PEER_COL_PROGRESS, (int)( 100.0 * peer->progress ),
+    gtk_list_store_set (store, iter,
+        PEER_COL_PROGRESS, (int)(100.0 * peer->progress),
         PEER_COL_UPLOAD_REQUEST_COUNT_INT, peer->pendingReqsToClient,
         PEER_COL_UPLOAD_REQUEST_COUNT_STRING, up_count,
         PEER_COL_DOWNLOAD_REQUEST_COUNT_INT, peer->pendingReqsToPeer,
@@ -1244,11 +1244,11 @@ refreshPeerRow( GtkListStore        * store,
         PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING, cancelled_by_client,
         PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_INT, (int)peer->cancelsToClient,
         PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING, cancelled_by_peer,
-        -1 );
+        -1);
 }
 
 static void
-refreshPeerList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
+refreshPeerList (struct DetailsImpl * di, tr_torrent ** torrents, int n)
 {
     int i;
     int * peerCount;
@@ -1259,199 +1259,199 @@ refreshPeerList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
     struct tr_peer_stat ** peers;
 
     /* step 1: get all the peers */
-    peers = g_new( struct tr_peer_stat*, n );
-    peerCount = g_new( int, n );
-    for( i=0; i<n; ++i )
-        peers[i] = tr_torrentPeers( torrents[i], &peerCount[i] );
+    peers = g_new (struct tr_peer_stat*, n);
+    peerCount = g_new (int, n);
+    for (i=0; i<n; ++i)
+        peers[i] = tr_torrentPeers (torrents[i], &peerCount[i]);
 
     /* step 2: mark all the peers in the list as not-updated */
-    model = GTK_TREE_MODEL( store );
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
-        gtk_list_store_set( store, &iter, PEER_COL_WAS_UPDATED, FALSE, -1 );
-    while( gtk_tree_model_iter_next( model, &iter ) );
+    model = GTK_TREE_MODEL (store);
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
+        gtk_list_store_set (store, &iter, PEER_COL_WAS_UPDATED, FALSE, -1);
+    while (gtk_tree_model_iter_next (model, &iter));
 
     /* step 3: add any new peers */
-    for( i=0; i<n; ++i ) {
+    for (i=0; i<n; ++i) {
         int j;
         const tr_torrent * tor = torrents[i];
-        for( j=0; j<peerCount[i]; ++j ) {
+        for (j=0; j<peerCount[i]; ++j) {
             const tr_peer_stat * s = &peers[i][j];
             char key[128];
-            g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId(tor), s->addr );
-            if( g_hash_table_lookup( hash, key ) == NULL ) {
+            g_snprintf (key, sizeof (key), "%d.%s", tr_torrentId (tor), s->addr);
+            if (g_hash_table_lookup (hash, key) == NULL) {
                 GtkTreePath * p;
-                gtk_list_store_append( store, &iter );
-                initPeerRow( store, &iter, key, tr_torrentName( tor ), s );
-                p = gtk_tree_model_get_path( model, &iter );
-                g_hash_table_insert( hash, g_strdup( key ),
-                                     gtk_tree_row_reference_new( model, p ) );
-                gtk_tree_path_free( p );
+                gtk_list_store_append (store, &iter);
+                initPeerRow (store, &iter, key, tr_torrentName (tor), s);
+                p = gtk_tree_model_get_path (model, &iter);
+                g_hash_table_insert (hash, g_strdup (key),
+                                     gtk_tree_row_reference_new (model, p));
+                gtk_tree_path_free (p);
             }
         }
     }
 
     /* step 4: update the peers */
-    for( i=0; i<n; ++i ) {
+    for (i=0; i<n; ++i) {
         int j;
         const tr_torrent * tor = torrents[i];
-        for( j=0; j<peerCount[i]; ++j ) {
+        for (j=0; j<peerCount[i]; ++j) {
             const tr_peer_stat * s = &peers[i][j];
             char key[128];
             GtkTreeRowReference * ref;
             GtkTreePath * p;
-            g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId(tor), s->addr );
-            ref = g_hash_table_lookup( hash, key );
-            p = gtk_tree_row_reference_get_path( ref );
-            gtk_tree_model_get_iter( model, &iter, p );
-            refreshPeerRow( store, &iter, s );
-            gtk_tree_path_free( p );
+            g_snprintf (key, sizeof (key), "%d.%s", tr_torrentId (tor), s->addr);
+            ref = g_hash_table_lookup (hash, key);
+            p = gtk_tree_row_reference_get_path (ref);
+            gtk_tree_model_get_iter (model, &iter, p);
+            refreshPeerRow (store, &iter, s);
+            gtk_tree_path_free (p);
         }
     }
 
     /* step 5: remove peers that have disappeared */
-    model = GTK_TREE_MODEL( store );
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) {
+    model = GTK_TREE_MODEL (store);
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) {
         gboolean more = TRUE;
-        while( more ) {
+        while (more) {
             gboolean b;
-            gtk_tree_model_get( model, &iter, PEER_COL_WAS_UPDATED, &b, -1 );
-            if( b )
-                more = gtk_tree_model_iter_next( model, &iter );
+            gtk_tree_model_get (model, &iter, PEER_COL_WAS_UPDATED, &b, -1);
+            if (b)
+                more = gtk_tree_model_iter_next (model, &iter);
             else {
                 char * key;
-                gtk_tree_model_get( model, &iter, PEER_COL_KEY, &key, -1 );
-                g_hash_table_remove( hash, key );
-                more = gtk_list_store_remove( store, &iter );
-                g_free( key );
+                gtk_tree_model_get (model, &iter, PEER_COL_KEY, &key, -1);
+                g_hash_table_remove (hash, key);
+                more = gtk_list_store_remove (store, &iter);
+                g_free (key);
             }
         }
     }
 
     /* step 6: cleanup */
-    for( i=0; i<n; ++i )
-        tr_torrentPeersFree( peers[i], peerCount[i] );
-    tr_free( peers );
-    tr_free( peerCount );
+    for (i=0; i<n; ++i)
+        tr_torrentPeersFree (peers[i], peerCount[i]);
+    tr_free (peers);
+    tr_free (peerCount);
 }
 
 static void
-refreshWebseedList( struct DetailsImpl * di, tr_torrent ** torrents, int n )
+refreshWebseedList (struct DetailsImpl * di, tr_torrent ** torrents, int n)
 {
     int i;
     int total = 0;
     GtkTreeIter iter;
     GHashTable * hash = di->webseed_hash;
     GtkListStore * store = di->webseed_store;
-    GtkTreeModel * model = GTK_TREE_MODEL( store );
+    GtkTreeModel * model = GTK_TREE_MODEL (store);
 
     /* step 1: mark all webseeds as not-updated */
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
-        gtk_list_store_set( store, &iter, WEBSEED_COL_WAS_UPDATED, FALSE, -1 );
-    while( gtk_tree_model_iter_next( model, &iter ) );
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
+        gtk_list_store_set (store, &iter, WEBSEED_COL_WAS_UPDATED, FALSE, -1);
+    while (gtk_tree_model_iter_next (model, &iter));
 
     /* step 2: add any new webseeds */
-    for( i=0; i<n; ++i ) {
+    for (i=0; i<n; ++i) {
         int j;
         const tr_torrent * tor = torrents[i];
-        const tr_info * inf = tr_torrentInfo( tor );
+        const tr_info * inf = tr_torrentInfo (tor);
         total += inf->webseedCount;
-        for( j=0; j<inf->webseedCount; ++j ) {
+        for (j=0; j<inf->webseedCount; ++j) {
             char key[256];
             const char * url = inf->webseeds[j];
-            g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId( tor ), url );
-            if( g_hash_table_lookup( hash, key ) == NULL ) {
+            g_snprintf (key, sizeof (key), "%d.%s", tr_torrentId (tor), url);
+            if (g_hash_table_lookup (hash, key) == NULL) {
                 GtkTreePath * p;
-                gtk_list_store_append( store, &iter );
-                gtk_list_store_set( store, &iter, WEBSEED_COL_URL, url,
+                gtk_list_store_append (store, &iter);
+                gtk_list_store_set (store, &iter, WEBSEED_COL_URL, url,
                                                   WEBSEED_COL_KEY, key,
-                                                  -1 );
-                p = gtk_tree_model_get_path( model, &iter );
-                g_hash_table_insert( hash, g_strdup( key ),
-                                     gtk_tree_row_reference_new( model, p ) );
-                gtk_tree_path_free( p );
+                                                  -1);
+                p = gtk_tree_model_get_path (model, &iter);
+                g_hash_table_insert (hash, g_strdup (key),
+                                     gtk_tree_row_reference_new (model, p));
+                gtk_tree_path_free (p);
             }
         }
     }
 
     /* step 3: update the webseeds */
-    for( i=0; i<n; ++i ) {
+    for (i=0; i<n; ++i) {
         int j;
         const tr_torrent * tor = torrents[i];
-        const tr_info * inf = tr_torrentInfo( tor );
-        double * speeds_KBps = tr_torrentWebSpeeds_KBps( tor );
-        for( j=0; j<inf->webseedCount; ++j ) {
+        const tr_info * inf = tr_torrentInfo (tor);
+        double * speeds_KBps = tr_torrentWebSpeeds_KBps (tor);
+        for (j=0; j<inf->webseedCount; ++j) {
             char buf[128];
             char key[256];
             const char * url = inf->webseeds[j];
             GtkTreePath * p;
             GtkTreeRowReference * ref;
-            g_snprintf( key, sizeof(key), "%d.%s", tr_torrentId( tor ), url );
-            ref = g_hash_table_lookup( hash, key );
-            p = gtk_tree_row_reference_get_path( ref );
-            gtk_tree_model_get_iter( model, &iter, p );
-            if( speeds_KBps[j] > 0 )
-                tr_formatter_speed_KBps( buf, speeds_KBps[j], sizeof( buf ) );
+            g_snprintf (key, sizeof (key), "%d.%s", tr_torrentId (tor), url);
+            ref = g_hash_table_lookup (hash, key);
+            p = gtk_tree_row_reference_get_path (ref);
+            gtk_tree_model_get_iter (model, &iter, p);
+            if (speeds_KBps[j] > 0)
+                tr_formatter_speed_KBps (buf, speeds_KBps[j], sizeof (buf));
             else
                 *buf = '\0';
-            gtk_list_store_set( store, &iter,
+            gtk_list_store_set (store, &iter,
                 WEBSEED_COL_DOWNLOAD_RATE_DOUBLE, speeds_KBps[j],
                 WEBSEED_COL_DOWNLOAD_RATE_STRING, buf,
                 WEBSEED_COL_WAS_UPDATED, TRUE,
-                -1 );
-            gtk_tree_path_free( p );
+                -1);
+            gtk_tree_path_free (p);
         }
-        tr_free( speeds_KBps );
+        tr_free (speeds_KBps);
     }
 
     /* step 4: remove webseeds that have disappeared */
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) {
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) {
         gboolean more = TRUE;
-        while( more ) {
+        while (more) {
             gboolean b;
-            gtk_tree_model_get( model, &iter, WEBSEED_COL_WAS_UPDATED, &b, -1 );
-            if( b )
-                more = gtk_tree_model_iter_next( model, &iter );
+            gtk_tree_model_get (model, &iter, WEBSEED_COL_WAS_UPDATED, &b, -1);
+            if (b)
+                more = gtk_tree_model_iter_next (model, &iter);
             else {
                 char * key;
-                gtk_tree_model_get( model, &iter, WEBSEED_COL_KEY, &key, -1 );
-                if( key != NULL )
-                    g_hash_table_remove( hash, key );
-                more = gtk_list_store_remove( store, &iter );
-                g_free( key );
+                gtk_tree_model_get (model, &iter, WEBSEED_COL_KEY, &key, -1);
+                if (key != NULL)
+                    g_hash_table_remove (hash, key);
+                more = gtk_list_store_remove (store, &iter);
+                g_free (key);
             }
         }
     }
 
     /* most of the time there are no webseeds...
        don't waste space showing an empty list */
-    if( total > 0 )
-        gtk_widget_show( di->webseed_view );
+    if (total > 0)
+        gtk_widget_show (di->webseed_view);
     else
-        gtk_widget_hide( di->webseed_view );
+        gtk_widget_hide (di->webseed_view);
 }
 
 static void
-refreshPeers( struct DetailsImpl * di, tr_torrent ** torrents, int n )
+refreshPeers (struct DetailsImpl * di, tr_torrent ** torrents, int n)
 {
-    refreshPeerList( di, torrents, n );
-    refreshWebseedList( di, torrents, n );
+    refreshPeerList (di, torrents, n);
+    refreshWebseedList (di, torrents, n);
 }
 
 static gboolean
-onPeerViewQueryTooltip( GtkWidget   * widget,
+onPeerViewQueryTooltip (GtkWidget   * widget,
                         gint          x,
                         gint          y,
                         gboolean      keyboard_tip,
                         GtkTooltip  * tooltip,
-                        gpointer      gdi )
+                        gpointer      gdi)
 {
     gboolean       show_tip = FALSE;
     GtkTreeModel * model;
     GtkTreeIter    iter;
 
-    if( gtk_tree_view_get_tooltip_context( GTK_TREE_VIEW( widget ),
+    if (gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
                                            &x, &y, keyboard_tip,
-                                           &model, NULL, &iter ) )
+                                           &model, NULL, &iter))
     {
         struct DetailsImpl * di = gdi;
         const char * pch;
@@ -1460,45 +1460,45 @@ onPeerViewQueryTooltip( GtkWidget   * widget,
         char * markup = NULL;
         char * flagstr = NULL;
         GString * gstr = di->gstr;
-        gtk_tree_model_get( model, &iter, PEER_COL_TORRENT_NAME, &name,
+        gtk_tree_model_get (model, &iter, PEER_COL_TORRENT_NAME, &name,
                                           PEER_COL_ADDRESS, &addr,
                                           PEER_COL_FLAGS, &flagstr,
-                                          -1 );
+                                          -1);
 
-        g_string_truncate( gstr, 0 );
-        markup = g_markup_escape_text( name, -1 );
-        g_string_append_printf( gstr, "<b>%s</b>\n%s\n \n", markup, addr );
-        g_free( markup );
+        g_string_truncate (gstr, 0);
+        markup = g_markup_escape_text (name, -1);
+        g_string_append_printf (gstr, "<b>%s</b>\n%s\n \n", markup, addr);
+        g_free (markup);
 
-        for( pch = flagstr; pch && *pch; ++pch )
+        for (pch = flagstr; pch && *pch; ++pch)
         {
             const char * s = NULL;
-            switch( *pch )
+            switch (*pch)
             {
-                case 'O': s = _( "Optimistic unchoke" ); break;
-                case 'D': s = _( "Downloading from this peer" ); break;
-                case 'd': s = _( "We would download from this peer if they would let us" ); break;
-                case 'U': s = _( "Uploading to peer" ); break;
-                case 'u': s = _( "We would upload to this peer if they asked" ); break;
-                case 'K': s = _( "Peer has unchoked us, but we're not interested" ); break;
-                case '?': s = _( "We unchoked this peer, but they're not interested" ); break;
-                case 'E': s = _( "Encrypted connection" ); break;
-                case 'X': s = _( "Peer was found through Peer Exchange (PEX)" ); break;
-                case 'H': s = _( "Peer was found through DHT" ); break;
-                case 'I': s = _( "Peer is an incoming connection" ); break;
-                case 'T': s = _( "Peer is connected over µTP" ); break;
+                case 'O': s = _("Optimistic unchoke"); break;
+                case 'D': s = _("Downloading from this peer"); break;
+                case 'd': s = _("We would download from this peer if they would let us"); break;
+                case 'U': s = _("Uploading to peer"); break;
+                case 'u': s = _("We would upload to this peer if they asked"); break;
+                case 'K': s = _("Peer has unchoked us, but we're not interested"); break;
+                case '?': s = _("We unchoked this peer, but they're not interested"); break;
+                case 'E': s = _("Encrypted connection"); break;
+                case 'X': s = _("Peer was found through Peer Exchange (PEX)"); break;
+                case 'H': s = _("Peer was found through DHT"); break;
+                case 'I': s = _("Peer is an incoming connection"); break;
+                case 'T': s = _("Peer is connected over µTP"); break;
             }
-            if( s )
-                g_string_append_printf( gstr, "%c: %s\n", *pch, s );
+            if (s)
+                g_string_append_printf (gstr, "%c: %s\n", *pch, s);
         }
-        if( gstr->len ) /* remove the last linefeed */
-            g_string_set_size( gstr, gstr->len - 1 );
+        if (gstr->len) /* remove the last linefeed */
+            g_string_set_size (gstr, gstr->len - 1);
 
-        gtk_tooltip_set_markup( tooltip, gstr->str );
+        gtk_tooltip_set_markup (tooltip, gstr->str);
 
-        g_free( flagstr );
-        g_free( addr );
-        g_free( name );
+        g_free (flagstr);
+        g_free (addr);
+        g_free (name);
         show_tip = TRUE;
     }
 
@@ -1506,125 +1506,125 @@ onPeerViewQueryTooltip( GtkWidget   * widget,
 }
 
 static void
-setPeerViewColumns( GtkTreeView * peer_view )
+setPeerViewColumns (GtkTreeView * peer_view)
 {
     int i;
     int n = 0;
-    const bool more = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
+    const bool more = gtr_pref_flag_get (PREF_KEY_SHOW_MORE_PEER_INFO);
     int view_columns[32];
     GtkTreeViewColumn * c;
     GtkCellRenderer *   r;
 
     view_columns[n++] = PEER_COL_ENCRYPTION_STOCK_ID;
     view_columns[n++] = PEER_COL_UPLOAD_RATE_STRING;
-    if( more ) view_columns[n++] = PEER_COL_UPLOAD_REQUEST_COUNT_STRING;
+    if (more) view_columns[n++] = PEER_COL_UPLOAD_REQUEST_COUNT_STRING;
     view_columns[n++] = PEER_COL_DOWNLOAD_RATE_STRING;
-    if( more ) view_columns[n++] = PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING;
-    if( more ) view_columns[n++] = PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING;
-    if( more ) view_columns[n++] = PEER_COL_BLOCKS_UPLOADED_COUNT_STRING;
-    if( more ) view_columns[n++] = PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING;
-    if( more ) view_columns[n++] = PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING;
+    if (more) view_columns[n++] = PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING;
+    if (more) view_columns[n++] = PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING;
+    if (more) view_columns[n++] = PEER_COL_BLOCKS_UPLOADED_COUNT_STRING;
+    if (more) view_columns[n++] = PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING;
+    if (more) view_columns[n++] = PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING;
     view_columns[n++] = PEER_COL_PROGRESS;
     view_columns[n++] = PEER_COL_FLAGS;
     view_columns[n++] = PEER_COL_ADDRESS;
     view_columns[n++] = PEER_COL_CLIENT;
 
     /* remove any existing columns */
-    while(( c = gtk_tree_view_get_column( peer_view, 0 )))
-        gtk_tree_view_remove_column( peer_view, c );
+    while ((c = gtk_tree_view_get_column (peer_view, 0)))
+        gtk_tree_view_remove_column (peer_view, c);
 
-    for( i=0; i<n; ++i )
+    for (i=0; i<n; ++i)
     {
         const int col = view_columns[i];
-        const char * t = getPeerColumnName( col );
+        const char * t = getPeerColumnName (col);
         int sort_col = col;
 
-        switch( col )
+        switch (col)
         {
             case PEER_COL_ADDRESS:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_ADDRESS_COLLATED;
                 break;
 
             case PEER_COL_CLIENT:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 break;
 
             case PEER_COL_PROGRESS:
-                r = gtk_cell_renderer_progress_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "value", PEER_COL_PROGRESS, NULL );
+                r = gtk_cell_renderer_progress_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "value", PEER_COL_PROGRESS, NULL);
                 break;
 
             case PEER_COL_ENCRYPTION_STOCK_ID:
-                r = gtk_cell_renderer_pixbuf_new( );
-                g_object_set( r, "xalign", (gfloat)0.0,
+                r = gtk_cell_renderer_pixbuf_new ();
+                g_object_set (r, "xalign", (gfloat)0.0,
                                  "yalign", (gfloat)0.5,
-                                 NULL );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "stock-id", PEER_COL_ENCRYPTION_STOCK_ID, NULL );
-                gtk_tree_view_column_set_sizing( c, GTK_TREE_VIEW_COLUMN_FIXED );
-                gtk_tree_view_column_set_fixed_width( c, 20 );
+                                 NULL);
+                c = gtk_tree_view_column_new_with_attributes (t, r, "stock-id", PEER_COL_ENCRYPTION_STOCK_ID, NULL);
+                gtk_tree_view_column_set_sizing (c, GTK_TREE_VIEW_COLUMN_FIXED);
+                gtk_tree_view_column_set_fixed_width (c, 20);
                 break;
 
             case PEER_COL_DOWNLOAD_REQUEST_COUNT_STRING:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_DOWNLOAD_REQUEST_COUNT_INT;
                 break;
             case PEER_COL_UPLOAD_REQUEST_COUNT_STRING:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_UPLOAD_REQUEST_COUNT_INT;
                 break;
 
             case PEER_COL_BLOCKS_DOWNLOADED_COUNT_STRING:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_BLOCKS_DOWNLOADED_COUNT_INT;
                 break;
             case PEER_COL_BLOCKS_UPLOADED_COUNT_STRING:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_BLOCKS_UPLOADED_COUNT_INT;
                 break;
 
             case PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_STRING:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_REQS_CANCELLED_BY_CLIENT_COUNT_INT;
                 break;
             case PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_STRING:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_REQS_CANCELLED_BY_PEER_COUNT_INT;
                 break;
 
             case PEER_COL_DOWNLOAD_RATE_STRING:
-                r = gtk_cell_renderer_text_new( );
-                g_object_set( G_OBJECT( r ), "xalign", 1.0f, NULL );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                g_object_set (G_OBJECT (r), "xalign", 1.0f, NULL);
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_DOWNLOAD_RATE_DOUBLE;
                 break;
             case PEER_COL_UPLOAD_RATE_STRING:
-                r = gtk_cell_renderer_text_new( );
-                g_object_set( G_OBJECT( r ), "xalign", 1.0f, NULL );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                g_object_set (G_OBJECT (r), "xalign", 1.0f, NULL);
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 sort_col = PEER_COL_UPLOAD_RATE_DOUBLE;
                 break;
 
             case PEER_COL_FLAGS:
-                r = gtk_cell_renderer_text_new( );
-                c = gtk_tree_view_column_new_with_attributes( t, r, "text", col, NULL );
+                r = gtk_cell_renderer_text_new ();
+                c = gtk_tree_view_column_new_with_attributes (t, r, "text", col, NULL);
                 break;
 
             default:
-                abort( );
+                abort ();
         }
 
-        gtk_tree_view_column_set_resizable( c, FALSE );
-        gtk_tree_view_column_set_sort_column_id( c, sort_col );
-        gtk_tree_view_append_column( GTK_TREE_VIEW( peer_view ), c );
+        gtk_tree_view_column_set_resizable (c, FALSE);
+        gtk_tree_view_column_set_sort_column_id (c, sort_col);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (peer_view), c);
     }
 
     /* the 'expander' column has a 10-pixel margin on the left
@@ -1632,24 +1632,24 @@ setPeerViewColumns( GtkTreeView * peer_view )
        so create a non-visible column and assign it as the
        'expander column. */
     {
-        GtkTreeViewColumn *c = gtk_tree_view_column_new( );
-        gtk_tree_view_column_set_visible( c, FALSE );
-        gtk_tree_view_append_column( GTK_TREE_VIEW( peer_view ), c );
-        gtk_tree_view_set_expander_column( GTK_TREE_VIEW( peer_view ), c );
+        GtkTreeViewColumn *c = gtk_tree_view_column_new ();
+        gtk_tree_view_column_set_visible (c, FALSE);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (peer_view), c);
+        gtk_tree_view_set_expander_column (GTK_TREE_VIEW (peer_view), c);
     }
 }
 
 static void
-onMorePeerInfoToggled( GtkToggleButton * button, struct DetailsImpl * di )
+onMorePeerInfoToggled (GtkToggleButton * button, struct DetailsImpl * di)
 {
     const char * key = PREF_KEY_SHOW_MORE_PEER_INFO;
-    const gboolean value = gtk_toggle_button_get_active( button );
-    gtr_core_set_pref_bool( di->core, key, value );
-    setPeerViewColumns( GTK_TREE_VIEW( di->peer_view ) );
+    const gboolean value = gtk_toggle_button_get_active (button);
+    gtr_core_set_pref_bool (di->core, key, value);
+    setPeerViewColumns (GTK_TREE_VIEW (di->peer_view));
 }
 
 static GtkWidget*
-peer_page_new( struct DetailsImpl * di )
+peer_page_new (struct DetailsImpl * di)
 {
     gboolean b;
     const char * str;
@@ -1662,94 +1662,94 @@ peer_page_new( struct DetailsImpl * di )
 
     /* webseeds */
 
-    store = di->webseed_store = webseed_model_new( );
-    v = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) );
-    g_signal_connect( v, "button-release-event", G_CALLBACK( on_tree_view_button_released ), NULL );
-    gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( v ), TRUE );
-    g_object_unref( store );
-
-    str = getWebseedColumnNames( WEBSEED_COL_URL );
-    r = gtk_cell_renderer_text_new( );
-    g_object_set( G_OBJECT( r ), "ellipsize", PANGO_ELLIPSIZE_END, NULL );
-    c = gtk_tree_view_column_new_with_attributes( str, r, "text", WEBSEED_COL_URL, NULL );
-    g_object_set( G_OBJECT( c ), "expand", TRUE, NULL );
-    gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_URL );
-    gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
-
-    str = getWebseedColumnNames( WEBSEED_COL_DOWNLOAD_RATE_STRING );
-    r = gtk_cell_renderer_text_new( );
-    c = gtk_tree_view_column_new_with_attributes( str, r, "text", WEBSEED_COL_DOWNLOAD_RATE_STRING, NULL );
-    gtk_tree_view_column_set_sort_column_id( c, WEBSEED_COL_DOWNLOAD_RATE_DOUBLE );
-    gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
-
-    w = gtk_scrolled_window_new( NULL, NULL );
-    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
+    store = di->webseed_store = webseed_model_new ();
+    v = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
+    g_signal_connect (v, "button-release-event", G_CALLBACK (on_tree_view_button_released), NULL);
+    gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (v), TRUE);
+    g_object_unref (store);
+
+    str = getWebseedColumnNames (WEBSEED_COL_URL);
+    r = gtk_cell_renderer_text_new ();
+    g_object_set (G_OBJECT (r), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
+    c = gtk_tree_view_column_new_with_attributes (str, r, "text", WEBSEED_COL_URL, NULL);
+    g_object_set (G_OBJECT (c), "expand", TRUE, NULL);
+    gtk_tree_view_column_set_sort_column_id (c, WEBSEED_COL_URL);
+    gtk_tree_view_append_column (GTK_TREE_VIEW (v), c);
+
+    str = getWebseedColumnNames (WEBSEED_COL_DOWNLOAD_RATE_STRING);
+    r = gtk_cell_renderer_text_new ();
+    c = gtk_tree_view_column_new_with_attributes (str, r, "text", WEBSEED_COL_DOWNLOAD_RATE_STRING, NULL);
+    gtk_tree_view_column_set_sort_column_id (c, WEBSEED_COL_DOWNLOAD_RATE_DOUBLE);
+    gtk_tree_view_append_column (GTK_TREE_VIEW (v), c);
+
+    w = gtk_scrolled_window_new (NULL, NULL);
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w),
                                     GTK_POLICY_AUTOMATIC,
-                                    GTK_POLICY_AUTOMATIC );
-    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
-                                         GTK_SHADOW_IN );
-    gtk_container_add( GTK_CONTAINER( w ), v );
+                                    GTK_POLICY_AUTOMATIC);
+    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w),
+                                         GTK_SHADOW_IN);
+    gtk_container_add (GTK_CONTAINER (w), v);
 
     webtree = w;
     di->webseed_view = w;
 
     /* peers */
 
-    store  = di->peer_store = peer_store_new( );
-    m = gtk_tree_model_sort_new_with_model( GTK_TREE_MODEL( store ) );
-    gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE( m ),
+    store  = di->peer_store = peer_store_new ();
+    m = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
+    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (m),
                                           PEER_COL_PROGRESS,
-                                          GTK_SORT_DESCENDING );
-    v = GTK_WIDGET( g_object_new( GTK_TYPE_TREE_VIEW,
+                                          GTK_SORT_DESCENDING);
+    v = GTK_WIDGET (g_object_new (GTK_TYPE_TREE_VIEW,
                                   "model",  m,
                                   "rules-hint", TRUE,
                                   "has-tooltip", TRUE,
-                                  NULL ) );
+                                  NULL));
     di->peer_view = v;
 
-    g_signal_connect( v, "query-tooltip",
-                      G_CALLBACK( onPeerViewQueryTooltip ), di );
-    g_object_unref( store );
-    g_signal_connect( v, "button-release-event",
-                      G_CALLBACK( on_tree_view_button_released ), NULL );
+    g_signal_connect (v, "query-tooltip",
+                      G_CALLBACK (onPeerViewQueryTooltip), di);
+    g_object_unref (store);
+    g_signal_connect (v, "button-release-event",
+                      G_CALLBACK (on_tree_view_button_released), NULL);
 
-    setPeerViewColumns( GTK_TREE_VIEW( v ) );
+    setPeerViewColumns (GTK_TREE_VIEW (v));
 
-    w = sw = gtk_scrolled_window_new( NULL, NULL );
-    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
+    w = sw = gtk_scrolled_window_new (NULL, NULL);
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w),
                                     GTK_POLICY_AUTOMATIC,
-                                    GTK_POLICY_AUTOMATIC );
-    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
-                                         GTK_SHADOW_IN );
-    gtk_container_add( GTK_CONTAINER( w ), v );
+                                    GTK_POLICY_AUTOMATIC);
+    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w),
+                                         GTK_SHADOW_IN);
+    gtk_container_add (GTK_CONTAINER (w), v);
 
-    vbox = gtk_box_new( GTK_ORIENTATION_VERTICAL, GUI_PAD );
-    gtk_container_set_border_width( GTK_CONTAINER( vbox ), GUI_PAD_BIG );
+    vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, GUI_PAD);
+    gtk_container_set_border_width (GTK_CONTAINER (vbox), GUI_PAD_BIG);
 
-    v = gtk_paned_new( GTK_ORIENTATION_VERTICAL );
-    gtk_paned_pack1( GTK_PANED( v ), webtree, FALSE, TRUE );
-    gtk_paned_pack2( GTK_PANED( v ), sw, TRUE, TRUE );
-    gtk_box_pack_start( GTK_BOX( vbox ), v, TRUE, TRUE, 0 );
+    v = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
+    gtk_paned_pack1 (GTK_PANED (v), webtree, FALSE, TRUE);
+    gtk_paned_pack2 (GTK_PANED (v), sw, TRUE, TRUE);
+    gtk_box_pack_start (GTK_BOX (vbox), v, TRUE, TRUE, 0);
 
-    w = gtk_check_button_new_with_mnemonic( _( "Show _more details" ) );
+    w = gtk_check_button_new_with_mnemonic (_("Show _more details"));
     di->more_peer_details_check = w;
-    b = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
-    g_signal_connect( w, "toggled", G_CALLBACK( onMorePeerInfoToggled ), di );
-    gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
+    b = gtr_pref_flag_get (PREF_KEY_SHOW_MORE_PEER_INFO);
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), b);
+    g_signal_connect (w, "toggled", G_CALLBACK (onMorePeerInfoToggled), di);
+    gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
 
 
     /* ip-to-GtkTreeRowReference */
-    di->peer_hash = g_hash_table_new_full( g_str_hash,
+    di->peer_hash = g_hash_table_new_full (g_str_hash,
                                            g_str_equal,
-                                           (GDestroyNotify)g_free,
-                                           (GDestroyNotify)gtk_tree_row_reference_free );
+                                         (GDestroyNotify)g_free,
+                                         (GDestroyNotify)gtk_tree_row_reference_free);
 
     /* url-to-GtkTreeRowReference */
-    di->webseed_hash = g_hash_table_new_full( g_str_hash,
+    di->webseed_hash = g_hash_table_new_full (g_str_hash,
                                               g_str_equal,
-                                              (GDestroyNotify)g_free,
-                                              (GDestroyNotify)gtk_tree_row_reference_free );
+                                            (GDestroyNotify)g_free,
+                                            (GDestroyNotify)gtk_tree_row_reference_free);
     ret = vbox;
     return ret;
 }
@@ -1764,18 +1764,18 @@ peer_page_new( struct DetailsImpl * di )
 
 /* if it's been longer than a minute, don't bother showing the seconds */
 static void
-tr_strltime_rounded( char * buf, time_t t, size_t buflen )
+tr_strltime_rounded (char * buf, time_t t, size_t buflen)
 {
-    if( t > 60 ) t -= ( t % 60 );
-    tr_strltime( buf, t, buflen );
+    if (t > 60) t -= (t % 60);
+    tr_strltime (buf, t, buflen);
 }
 
 static void
-buildTrackerSummary( GString * gstr, const char * key, const tr_tracker_stat * st, gboolean showScrape )
+buildTrackerSummary (GString * gstr, const char * key, const tr_tracker_stat * st, gboolean showScrape)
 {
     char * str;
     char timebuf[256];
-    const time_t now = time( NULL );
+    const time_t now = time (NULL);
     const char * err_markup_begin = "<span color=\"red\">";
     const char * err_markup_end = "</span>";
     const char * timeout_markup_begin = "<span color=\"#224466\">";
@@ -1785,86 +1785,86 @@ buildTrackerSummary( GString * gstr, const char * key, const tr_tracker_stat * s
 
     /* hostname */
     {
-        g_string_append( gstr, st->isBackup ? "<i>" : "<b>" );
-        if( key )
-            str = g_markup_printf_escaped( "%s - %s", st->host, key );
+        g_string_append (gstr, st->isBackup ? "<i>" : "<b>");
+        if (key)
+            str = g_markup_printf_escaped ("%s - %s", st->host, key);
         else
-            str = g_markup_printf_escaped( "%s", st->host );
-        g_string_append( gstr, str );
-        g_free( str );
-        g_string_append( gstr, st->isBackup ? "</i>" : "</b>" );
+            str = g_markup_printf_escaped ("%s", st->host);
+        g_string_append (gstr, str);
+        g_free (str);
+        g_string_append (gstr, st->isBackup ? "</i>" : "</b>");
     }
 
-    if( !st->isBackup )
+    if (!st->isBackup)
     {
-        if( st->hasAnnounced && st->announceState != TR_TRACKER_INACTIVE )
+        if (st->hasAnnounced && st->announceState != TR_TRACKER_INACTIVE)
         {
-            g_string_append_c( gstr, '\n' );
-            tr_strltime_rounded( timebuf, now - st->lastAnnounceTime, sizeof( timebuf ) );
-            if( st->lastAnnounceSucceeded )
-                g_string_append_printf( gstr, _( "Got a list of %1$s%2$'d peers%3$s %4$s ago" ),
+            g_string_append_c (gstr, '\n');
+            tr_strltime_rounded (timebuf, now - st->lastAnnounceTime, sizeof (timebuf));
+            if (st->lastAnnounceSucceeded)
+                g_string_append_printf (gstr, _("Got a list of %1$s%2$'d peers%3$s %4$s ago"),
                                         success_markup_begin, st->lastAnnouncePeerCount, success_markup_end,
-                                        timebuf );
-            else if( st->lastAnnounceTimedOut )
-                g_string_append_printf( gstr, _( "Peer list request %1$stimed out%2$s %3$s ago; will retry" ),
-                                        timeout_markup_begin, timeout_markup_end, timebuf );
+                                        timebuf);
+            else if (st->lastAnnounceTimedOut)
+                g_string_append_printf (gstr, _("Peer list request %1$stimed out%2$s %3$s ago; will retry"),
+                                        timeout_markup_begin, timeout_markup_end, timebuf);
             else
-                g_string_append_printf( gstr, _( "Got an error %1$s\"%2$s\"%3$s %4$s ago" ),
-                                        err_markup_begin, st->lastAnnounceResult, err_markup_end, timebuf );
+                g_string_append_printf (gstr, _("Got an error %1$s\"%2$s\"%3$s %4$s ago"),
+                                        err_markup_begin, st->lastAnnounceResult, err_markup_end, timebuf);
         }
 
-        switch( st->announceState )
+        switch (st->announceState)
         {
             case TR_TRACKER_INACTIVE:
-                g_string_append_c( gstr, '\n' );
-                g_string_append( gstr, _( "No updates scheduled" ) );
+                g_string_append_c (gstr, '\n');
+                g_string_append (gstr, _("No updates scheduled"));
                 break;
             case TR_TRACKER_WAITING:
-                tr_strltime_rounded( timebuf, st->nextAnnounceTime - now, sizeof( timebuf ) );
-                g_string_append_c( gstr, '\n' );
-                g_string_append_printf( gstr, _( "Asking for more peers in %s" ), timebuf );
+                tr_strltime_rounded (timebuf, st->nextAnnounceTime - now, sizeof (timebuf));
+                g_string_append_c (gstr, '\n');
+                g_string_append_printf (gstr, _("Asking for more peers in %s"), timebuf);
                 break;
             case TR_TRACKER_QUEUED:
-                g_string_append_c( gstr, '\n' );
-                g_string_append( gstr, _( "Queued to ask for more peers" ) );
+                g_string_append_c (gstr, '\n');
+                g_string_append (gstr, _("Queued to ask for more peers"));
                 break;
             case TR_TRACKER_ACTIVE:
-                tr_strltime_rounded( timebuf, now - st->lastAnnounceStartTime, sizeof( timebuf ) );
-                g_string_append_c( gstr, '\n' );
-                g_string_append_printf( gstr, _( "Asking for more peers now… <small>%s</small>" ), timebuf );
+                tr_strltime_rounded (timebuf, now - st->lastAnnounceStartTime, sizeof (timebuf));
+                g_string_append_c (gstr, '\n');
+                g_string_append_printf (gstr, _("Asking for more peers now… <small>%s</small>"), timebuf);
                 break;
         }
 
-        if( showScrape )
+        if (showScrape)
         {
-            if( st->hasScraped ) {
-                g_string_append_c( gstr, '\n' );
-                tr_strltime_rounded( timebuf, now - st->lastScrapeTime, sizeof( timebuf ) );
-                if( st->lastScrapeSucceeded )
-                    g_string_append_printf( gstr, _( "Tracker had %s%'d seeders and %'d leechers%s %s ago" ),
+            if (st->hasScraped) {
+                g_string_append_c (gstr, '\n');
+                tr_strltime_rounded (timebuf, now - st->lastScrapeTime, sizeof (timebuf));
+                if (st->lastScrapeSucceeded)
+                    g_string_append_printf (gstr, _("Tracker had %s%'d seeders and %'d leechers%s %s ago"),
                                             success_markup_begin, st->seederCount, st->leecherCount, success_markup_end,
-                                            timebuf );
+                                            timebuf);
                 else
-                    g_string_append_printf( gstr, _( "Got a scrape error \"%s%s%s\" %s ago" ), err_markup_begin, st->lastScrapeResult, err_markup_end, timebuf );
+                    g_string_append_printf (gstr, _("Got a scrape error \"%s%s%s\" %s ago"), err_markup_begin, st->lastScrapeResult, err_markup_end, timebuf);
             }
 
-            switch( st->scrapeState )
+            switch (st->scrapeState)
             {
                 case TR_TRACKER_INACTIVE:
                     break;
                 case TR_TRACKER_WAITING:
-                    g_string_append_c( gstr, '\n' );
-                    tr_strltime_rounded( timebuf, st->nextScrapeTime - now, sizeof( timebuf ) );
-                    g_string_append_printf( gstr, _( "Asking for peer counts in %s" ), timebuf );
+                    g_string_append_c (gstr, '\n');
+                    tr_strltime_rounded (timebuf, st->nextScrapeTime - now, sizeof (timebuf));
+                    g_string_append_printf (gstr, _("Asking for peer counts in %s"), timebuf);
                     break;
                 case TR_TRACKER_QUEUED:
-                    g_string_append_c( gstr, '\n' );
-                    g_string_append( gstr, _( "Queued to ask for peer counts" ) );
+                    g_string_append_c (gstr, '\n');
+                    g_string_append (gstr, _("Queued to ask for peer counts"));
                     break;
                 case TR_TRACKER_ACTIVE:
-                    g_string_append_c( gstr, '\n' );
-                    tr_strltime_rounded( timebuf, now - st->lastScrapeStartTime, sizeof( timebuf ) );
-                    g_string_append_printf( gstr, _( "Asking for peer counts now… <small>%s</small>" ), timebuf );
+                    g_string_append_c (gstr, '\n');
+                    tr_strltime_rounded (timebuf, now - st->lastScrapeStartTime, sizeof (timebuf));
+                    g_string_append_printf (gstr, _("Asking for peer counts now… <small>%s</small>"), timebuf);
                     break;
             }
         }
@@ -1884,75 +1884,75 @@ enum
 };
 
 static gboolean
-trackerVisibleFunc( GtkTreeModel * model, GtkTreeIter * iter, gpointer data )
+trackerVisibleFunc (GtkTreeModel * model, GtkTreeIter * iter, gpointer data)
 {
     gboolean isBackup;
     struct DetailsImpl * di = data;
 
     /* show all */
-    if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( di->all_check ) ) )
+    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (di->all_check)))
         return TRUE;
 
      /* don't show the backups... */
-     gtk_tree_model_get( model, iter, TRACKER_COL_IS_BACKUP, &isBackup, -1 );
+     gtk_tree_model_get (model, iter, TRACKER_COL_IS_BACKUP, &isBackup, -1);
      return !isBackup;
 }
 
 static int
-tracker_list_get_current_torrent_id( struct DetailsImpl * di )
+tracker_list_get_current_torrent_id (struct DetailsImpl * di)
 {
     int torrent_id = -1;
 
     /* if there's only one torrent in the dialog, always use it */
-    if( torrent_id < 0 )
-        if( g_slist_length( di->ids ) == 1 )
-            torrent_id = GPOINTER_TO_INT( di->ids->data );
+    if (torrent_id < 0)
+        if (g_slist_length (di->ids) == 1)
+            torrent_id = GPOINTER_TO_INT (di->ids->data);
 
     /* otherwise, use the selected tracker's torrent */
-    if( torrent_id < 0 ) {
+    if (torrent_id < 0) {
         GtkTreeIter iter;
         GtkTreeModel * model;
-        GtkTreeSelection * sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( di->tracker_view ) );
-        if( gtk_tree_selection_get_selected( sel, &model, &iter ) )
-            gtk_tree_model_get( model, &iter, TRACKER_COL_TORRENT_ID, &torrent_id, -1 );
+        GtkTreeSelection * sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (di->tracker_view));
+        if (gtk_tree_selection_get_selected (sel, &model, &iter))
+            gtk_tree_model_get (model, &iter, TRACKER_COL_TORRENT_ID, &torrent_id, -1);
     }
 
     return torrent_id;
 }
 
 static tr_torrent*
-tracker_list_get_current_torrent( struct DetailsImpl * di )
+tracker_list_get_current_torrent (struct DetailsImpl * di)
 {
-    const int torrent_id = tracker_list_get_current_torrent_id( di );
-    return gtr_core_find_torrent( di->core, torrent_id );
+    const int torrent_id = tracker_list_get_current_torrent_id (di);
+    return gtr_core_find_torrent (di->core, torrent_id);
 }
 
 static void
-favicon_ready_cb( gpointer pixbuf, gpointer vreference )
+favicon_ready_cb (gpointer pixbuf, gpointer vreference)
 {
     GtkTreeIter iter;
     GtkTreeRowReference * reference = vreference;
 
-    if( pixbuf != NULL )
+    if (pixbuf != NULL)
     {
-        GtkTreePath * path = gtk_tree_row_reference_get_path( reference );
-        GtkTreeModel * model = gtk_tree_row_reference_get_model( reference );
+        GtkTreePath * path = gtk_tree_row_reference_get_path (reference);
+        GtkTreeModel * model = gtk_tree_row_reference_get_model (reference);
 
-        if( gtk_tree_model_get_iter( model, &iter, path ) )
-            gtk_list_store_set( GTK_LIST_STORE( model ), &iter,
+        if (gtk_tree_model_get_iter (model, &iter, path))
+            gtk_list_store_set (GTK_LIST_STORE (model), &iter,
                                 TRACKER_COL_FAVICON, pixbuf,
-                                -1 );
+                                -1);
 
-        gtk_tree_path_free( path );
+        gtk_tree_path_free (path);
 
-        g_object_unref( pixbuf );
+        g_object_unref (pixbuf);
     }
 
-    gtk_tree_row_reference_free( reference );
+    gtk_tree_row_reference_free (reference);
 }
 
 static void
-refreshTracker( struct DetailsImpl * di, tr_torrent ** torrents, int n )
+refreshTracker (struct DetailsImpl * di, tr_torrent ** torrents, int n)
 {
     int i;
     int * statCount;
@@ -1962,165 +1962,165 @@ refreshTracker( struct DetailsImpl * di, tr_torrent ** torrents, int n )
     GString * gstr = di->gstr; /* buffer for temporary strings */
     GHashTable * hash = di->tracker_hash;
     GtkListStore * store = di->tracker_store;
-    tr_session * session = gtr_core_session( di->core );
-    const gboolean showScrape = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( di->scrape_check ) );
+    tr_session * session = gtr_core_session (di->core);
+    const gboolean showScrape = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (di->scrape_check));
 
     /* step 1: get all the trackers */
-    statCount = g_new0( int, n );
-    stats = g_new0( tr_tracker_stat *, n );
-    for( i=0; i<n; ++i )
-        stats[i] = tr_torrentTrackers( torrents[i], &statCount[i] );
+    statCount = g_new0 (int, n);
+    stats = g_new0 (tr_tracker_stat *, n);
+    for (i=0; i<n; ++i)
+        stats[i] = tr_torrentTrackers (torrents[i], &statCount[i]);
 
     /* step 2: mark all the trackers in the list as not-updated */
-    model = GTK_TREE_MODEL( store );
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
-        gtk_list_store_set( store, &iter, TRACKER_COL_WAS_UPDATED, FALSE, -1 );
-    while( gtk_tree_model_iter_next( model, &iter ) );
+    model = GTK_TREE_MODEL (store);
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
+        gtk_list_store_set (store, &iter, TRACKER_COL_WAS_UPDATED, FALSE, -1);
+    while (gtk_tree_model_iter_next (model, &iter));
 
     /* step 3: add any new trackers */
-    for( i=0; i<n; ++i ) {
+    for (i=0; i<n; ++i) {
         int j;
         const int jn = statCount[i];
-        for( j=0; j<jn; ++j ) {
+        for (j=0; j<jn; ++j) {
             const tr_torrent * tor = torrents[i];
             const tr_tracker_stat * st = &stats[i][j];
-            const int torrent_id = tr_torrentId( tor );
+            const int torrent_id = tr_torrentId (tor);
 
             /* build the key to find the row */
-            g_string_truncate( gstr, 0 );
-            g_string_append_printf( gstr, "%d\t%d\t%s", torrent_id, st->tier, st->announce );
+            g_string_truncate (gstr, 0);
+            g_string_append_printf (gstr, "%d\t%d\t%s", torrent_id, st->tier, st->announce);
 
-            if( g_hash_table_lookup( hash, gstr->str ) == NULL ) {
+            if (g_hash_table_lookup (hash, gstr->str) == NULL) {
                 GtkTreePath * p;
                 GtkTreeIter iter;
                 GtkTreeRowReference * ref;
 
-                gtk_list_store_insert_with_values( store, &iter, -1,
+                gtk_list_store_insert_with_values (store, &iter, -1,
                     TRACKER_COL_TORRENT_ID, torrent_id,
                     TRACKER_COL_TRACKER_ID, st->id,
                     TRACKER_COL_KEY, gstr->str,
-                    -1 );
-
-                p = gtk_tree_model_get_path( model, &iter );
-                ref = gtk_tree_row_reference_new( model, p );
-                g_hash_table_insert( hash, g_strdup( gstr->str ), ref );
-                ref = gtk_tree_row_reference_new( model, p );
-                gtr_get_favicon_from_url( session, st->announce, favicon_ready_cb, ref );
-                gtk_tree_path_free( p );
+                    -1);
+
+                p = gtk_tree_model_get_path (model, &iter);
+                ref = gtk_tree_row_reference_new (model, p);
+                g_hash_table_insert (hash, g_strdup (gstr->str), ref);
+                ref = gtk_tree_row_reference_new (model, p);
+                gtr_get_favicon_from_url (session, st->announce, favicon_ready_cb, ref);
+                gtk_tree_path_free (p);
             }
         }
     }
 
     /* step 4: update the peers */
-    for( i=0; i<n; ++i )
+    for (i=0; i<n; ++i)
     {
         int j;
         const tr_torrent * tor = torrents[i];
-        const char * summary_name = n>1 ? tr_torrentName( tor ) : NULL;
-        for( j=0; j<statCount[i]; ++j )
+        const char * summary_name = n>1 ? tr_torrentName (tor) : NULL;
+        for (j=0; j<statCount[i]; ++j)
         {
             GtkTreePath * p;
             GtkTreeRowReference * ref;
             const tr_tracker_stat * st = &stats[i][j];
 
             /* build the key to find the row */
-            g_string_truncate( gstr, 0 );
-            g_string_append_printf( gstr, "%d\t%d\t%s", tr_torrentId( tor ), st->tier, st->announce );
-            ref = g_hash_table_lookup( hash, gstr->str );
-            p = gtk_tree_row_reference_get_path( ref );
-            gtk_tree_model_get_iter( model, &iter, p );
+            g_string_truncate (gstr, 0);
+            g_string_append_printf (gstr, "%d\t%d\t%s", tr_torrentId (tor), st->tier, st->announce);
+            ref = g_hash_table_lookup (hash, gstr->str);
+            p = gtk_tree_row_reference_get_path (ref);
+            gtk_tree_model_get_iter (model, &iter, p);
 
             /* update the row */
-            g_string_truncate( gstr, 0 );
-            buildTrackerSummary( gstr, summary_name, st, showScrape );
-            gtk_list_store_set( store, &iter, TRACKER_COL_TEXT, gstr->str,
+            g_string_truncate (gstr, 0);
+            buildTrackerSummary (gstr, summary_name, st, showScrape);
+            gtk_list_store_set (store, &iter, TRACKER_COL_TEXT, gstr->str,
                                               TRACKER_COL_IS_BACKUP, st->isBackup,
                                               TRACKER_COL_TRACKER_ID, st->id,
                                               TRACKER_COL_WAS_UPDATED, TRUE,
-                                              -1 );
+                                              -1);
 
             /* cleanup */
-            gtk_tree_path_free( p );
+            gtk_tree_path_free (p);
         }
     }
 
     /* step 5: remove trackers that have disappeared */
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) {
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) {
         gboolean more = TRUE;
-        while( more ) {
+        while (more) {
             gboolean b;
-            gtk_tree_model_get( model, &iter, TRACKER_COL_WAS_UPDATED, &b, -1 );
-            if( b )
-                more = gtk_tree_model_iter_next( model, &iter );
+            gtk_tree_model_get (model, &iter, TRACKER_COL_WAS_UPDATED, &b, -1);
+            if (b)
+                more = gtk_tree_model_iter_next (model, &iter);
             else {
                 char * key;
-                gtk_tree_model_get( model, &iter, TRACKER_COL_KEY, &key, -1 );
-                g_hash_table_remove( hash, key );
-                more = gtk_list_store_remove( store, &iter );
-                g_free( key );
+                gtk_tree_model_get (model, &iter, TRACKER_COL_KEY, &key, -1);
+                g_hash_table_remove (hash, key);
+                more = gtk_list_store_remove (store, &iter);
+                g_free (key);
             }
         }
     }
 
-    gtk_widget_set_sensitive( di->edit_trackers_button,
-                              tracker_list_get_current_torrent_id( di ) >= 0 );
+    gtk_widget_set_sensitive (di->edit_trackers_button,
+                              tracker_list_get_current_torrent_id (di) >= 0);
 
     /* cleanup */
-    for( i=0; i<n; ++i )
-        tr_torrentTrackersFree( stats[i], statCount[i] );
-    g_free( stats );
-    g_free( statCount );
+    for (i=0; i<n; ++i)
+        tr_torrentTrackersFree (stats[i], statCount[i]);
+    g_free (stats);
+    g_free (statCount);
 }
 
 static void
-onScrapeToggled( GtkToggleButton * button, struct DetailsImpl * di )
+onScrapeToggled (GtkToggleButton * button, struct DetailsImpl * di)
 {
     const char * key = PREF_KEY_SHOW_MORE_TRACKER_INFO;
-    const gboolean value = gtk_toggle_button_get_active( button );
-    gtr_core_set_pref_bool( di->core, key, value );
-    refresh( di );
+    const gboolean value = gtk_toggle_button_get_active (button);
+    gtr_core_set_pref_bool (di->core, key, value);
+    refresh (di);
 }
 
 static void
-onBackupToggled( GtkToggleButton * button, struct DetailsImpl * di )
+onBackupToggled (GtkToggleButton * button, struct DetailsImpl * di)
 {
     const char * key = PREF_KEY_SHOW_BACKUP_TRACKERS;
-    const gboolean value = gtk_toggle_button_get_active( button );
-    gtr_core_set_pref_bool( di->core, key, value );
-    refresh( di );
+    const gboolean value = gtk_toggle_button_get_active (button);
+    gtr_core_set_pref_bool (di->core, key, value);
+    refresh (di);
 }
 
 static void
-on_edit_trackers_response( GtkDialog * dialog, int response, gpointer data )
+on_edit_trackers_response (GtkDialog * dialog, int response, gpointer data)
 {
     gboolean do_destroy = TRUE;
     struct DetailsImpl * di = data;
 
-    if( response == GTK_RESPONSE_ACCEPT )
+    if (response == GTK_RESPONSE_ACCEPT)
     {
         int i, n;
         int tier;
         GtkTextIter start, end;
-        const int torrent_id = GPOINTER_TO_INT( g_object_get_qdata( G_OBJECT( dialog ), TORRENT_ID_KEY ) );
-        GtkTextBuffer * text_buffer = g_object_get_qdata( G_OBJECT( dialog ), TEXT_BUFFER_KEY );
-        tr_torrent * tor = gtr_core_find_torrent( di->core, torrent_id );
+        const int torrent_id = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (dialog), TORRENT_ID_KEY));
+        GtkTextBuffer * text_buffer = g_object_get_qdata (G_OBJECT (dialog), TEXT_BUFFER_KEY);
+        tr_torrent * tor = gtr_core_find_torrent (di->core, torrent_id);
 
-        if( tor != NULL )
+        if (tor != NULL)
         {
             tr_tracker_info * trackers;
             char ** tracker_strings;
             char * tracker_text;
 
             /* build the array of trackers */
-            gtk_text_buffer_get_bounds( text_buffer, &start, &end );
-            tracker_text = gtk_text_buffer_get_text( text_buffer, &start, &end, FALSE );
-            tracker_strings = g_strsplit( tracker_text, "\n", 0 );
-            for( i=0; tracker_strings[i]; )
+            gtk_text_buffer_get_bounds (text_buffer, &start, &end);
+            tracker_text = gtk_text_buffer_get_text (text_buffer, &start, &end, FALSE);
+            tracker_strings = g_strsplit (tracker_text, "\n", 0);
+            for (i=0; tracker_strings[i];)
                 ++i;
-            trackers = g_new0( tr_tracker_info, i );
-            for( i=n=tier=0; tracker_strings[i]; ++i ) {
+            trackers = g_new0 (tr_tracker_info, i);
+            for (i=n=tier=0; tracker_strings[i]; ++i) {
                 const char * str = tracker_strings[i];
-                if( !*str )
+                if (!*str)
                     ++tier;
                 else {
                     trackers[n].tier = tier;
@@ -2130,167 +2130,167 @@ on_edit_trackers_response( GtkDialog * dialog, int response, gpointer data )
             }
 
             /* update the torrent */
-            if( tr_torrentSetAnnounceList( tor, trackers, n ) )
-                refresh( di );
+            if (tr_torrentSetAnnounceList (tor, trackers, n))
+                refresh (di);
             else {
                 GtkWidget * w;
-                const char * text = _( "List contains invalid URLs" );
-                w = gtk_message_dialog_new( GTK_WINDOW( dialog ),
+                const char * text = _("List contains invalid URLs");
+                w = gtk_message_dialog_new (GTK_WINDOW (dialog),
                                             GTK_DIALOG_MODAL,
                                             GTK_MESSAGE_ERROR,
-                                            GTK_BUTTONS_CLOSE, "%s", text );
-                gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ), "%s", _( "Please correct the errors and try again." ) );
-                gtk_dialog_run( GTK_DIALOG( w ) );
-                gtk_widget_destroy( w );
+                                            GTK_BUTTONS_CLOSE, "%s", text);
+                gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w), "%s", _("Please correct the errors and try again."));
+                gtk_dialog_run (GTK_DIALOG (w));
+                gtk_widget_destroy (w);
                 do_destroy = FALSE;
             }
 
             /* cleanup */
-            g_free( trackers );
-            g_strfreev( tracker_strings );
-            g_free( tracker_text );
+            g_free (trackers);
+            g_strfreev (tracker_strings);
+            g_free (tracker_text);
         }
     }
 
-    if( do_destroy )
-        gtk_widget_destroy( GTK_WIDGET( dialog ) );
+    if (do_destroy)
+        gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 static void
-get_editable_tracker_list( GString * gstr, const tr_torrent * tor )
+get_editable_tracker_list (GString * gstr, const tr_torrent * tor)
 {
     int i;
     int tier = 0;
-    const tr_info * inf = tr_torrentInfo( tor );
-    for( i=0; i<inf->trackerCount; ++i ) {
+    const tr_info * inf = tr_torrentInfo (tor);
+    for (i=0; i<inf->trackerCount; ++i) {
         const tr_tracker_info * t = &inf->trackers[i];
-        if( tier != t->tier ) {
+        if (tier != t->tier) {
             tier = t->tier;
-            g_string_append_c( gstr, '\n' );
+            g_string_append_c (gstr, '\n');
         }
-        g_string_append_printf( gstr, "%s\n", t->announce );
+        g_string_append_printf (gstr, "%s\n", t->announce);
     }
-    if( gstr->len > 0 )
-        g_string_truncate( gstr, gstr->len-1 );
+    if (gstr->len > 0)
+        g_string_truncate (gstr, gstr->len-1);
 }
 
 static void
-on_edit_trackers( GtkButton * button, gpointer data )
+on_edit_trackers (GtkButton * button, gpointer data)
 {
     struct DetailsImpl * di = data;
-    tr_torrent * tor = tracker_list_get_current_torrent( di );
+    tr_torrent * tor = tracker_list_get_current_torrent (di);
 
-    if( tor != NULL )
+    if (tor != NULL)
     {
         guint row;
         GtkWidget *w, *d, *fr, *t, *l, *sw;
-        GtkWindow * win = GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( button ) ) );
+        GtkWindow * win = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (button)));
         GString * gstr = di->gstr; /* buffer for temporary strings */
-        const int torrent_id = tr_torrentId( tor );
+        const int torrent_id = tr_torrentId (tor);
 
-        g_string_truncate( gstr, 0 );
-        g_string_append_printf( gstr, _( "%s - Edit Trackers" ), tr_torrentName( tor ) );
-        d = gtk_dialog_new_with_buttons( gstr->str, win,
+        g_string_truncate (gstr, 0);
+        g_string_append_printf (gstr, _("%s - Edit Trackers"), tr_torrentName (tor));
+        d = gtk_dialog_new_with_buttons (gstr->str, win,
                 GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
-                NULL );
-        g_signal_connect( d, "response", G_CALLBACK( on_edit_trackers_response ), data );
+                NULL);
+        g_signal_connect (d, "response", G_CALLBACK (on_edit_trackers_response), data);
 
         row = 0;
-        t = hig_workarea_create( );
-        hig_workarea_add_section_title( t, &row, _( "Tracker Announce URLs" ) );
-
-        l = gtk_label_new( NULL );
-        gtk_label_set_markup( GTK_LABEL( l ), _( "To add a backup URL, add it on the line after the primary URL.\n"
-                                                 "To add another primary URL, add it after a blank line." ) );
-        gtk_label_set_justify( GTK_LABEL( l ), GTK_JUSTIFY_LEFT );
-        gtk_misc_set_alignment( GTK_MISC( l ), 0.0, 0.5 );
-        hig_workarea_add_wide_control( t, &row, l );
-
-        w = gtk_text_view_new( );
-        gtk_widget_set_size_request( w, 500u, 166u );
-        g_string_truncate( gstr, 0 );
-        get_editable_tracker_list( gstr, tor );
-        gtk_text_buffer_set_text( gtk_text_view_get_buffer( GTK_TEXT_VIEW( w ) ), gstr->str, -1 );
-        fr = gtk_frame_new( NULL );
-        gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_IN );
-        sw = gtk_scrolled_window_new( NULL, NULL );
-        gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sw ),
+        t = hig_workarea_create ();
+        hig_workarea_add_section_title (t, &row, _("Tracker Announce URLs"));
+
+        l = gtk_label_new (NULL);
+        gtk_label_set_markup (GTK_LABEL (l), _("To add a backup URL, add it on the line after the primary URL.\n"
+                                                 "To add another primary URL, add it after a blank line."));
+        gtk_label_set_justify (GTK_LABEL (l), GTK_JUSTIFY_LEFT);
+        gtk_misc_set_alignment (GTK_MISC (l), 0.0, 0.5);
+        hig_workarea_add_wide_control (t, &row, l);
+
+        w = gtk_text_view_new ();
+        gtk_widget_set_size_request (w, 500u, 166u);
+        g_string_truncate (gstr, 0);
+        get_editable_tracker_list (gstr, tor);
+        gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (w)), gstr->str, -1);
+        fr = gtk_frame_new (NULL);
+        gtk_frame_set_shadow_type (GTK_FRAME (fr), GTK_SHADOW_IN);
+        sw = gtk_scrolled_window_new (NULL, NULL);
+        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                         GTK_POLICY_AUTOMATIC,
-                                        GTK_POLICY_AUTOMATIC );
-        gtk_container_add( GTK_CONTAINER( sw ), w );
-        gtk_container_add( GTK_CONTAINER( fr ), sw );
-        hig_workarea_add_wide_tall_control( t, &row, fr );
+                                        GTK_POLICY_AUTOMATIC);
+        gtk_container_add (GTK_CONTAINER (sw), w);
+        gtk_container_add (GTK_CONTAINER (fr), sw);
+        hig_workarea_add_wide_tall_control (t, &row, fr);
 
-        gtr_dialog_set_content( GTK_DIALOG( d ), t );
+        gtr_dialog_set_content (GTK_DIALOG (d), t);
 
-        g_object_set_qdata( G_OBJECT( d ), TORRENT_ID_KEY, GINT_TO_POINTER( torrent_id ) );
-        g_object_set_qdata( G_OBJECT( d ), TEXT_BUFFER_KEY, gtk_text_view_get_buffer( GTK_TEXT_VIEW( w ) ) );
-        gtk_widget_show( d );
+        g_object_set_qdata (G_OBJECT (d), TORRENT_ID_KEY, GINT_TO_POINTER (torrent_id));
+        g_object_set_qdata (G_OBJECT (d), TEXT_BUFFER_KEY, gtk_text_view_get_buffer (GTK_TEXT_VIEW (w)));
+        gtk_widget_show (d);
     }
 }
 
 static void
-on_tracker_list_selection_changed( GtkTreeSelection * sel, gpointer gdi )
+on_tracker_list_selection_changed (GtkTreeSelection * sel, gpointer gdi)
 {
     struct DetailsImpl * di = gdi;
-    const int n = gtk_tree_selection_count_selected_rows( sel );
-    tr_torrent * tor = tracker_list_get_current_torrent( di );
+    const int n = gtk_tree_selection_count_selected_rows (sel);
+    tr_torrent * tor = tracker_list_get_current_torrent (di);
 
-    gtk_widget_set_sensitive( di->remove_tracker_button, n>0 );
-    gtk_widget_set_sensitive( di->add_tracker_button, tor!=NULL );
-    gtk_widget_set_sensitive( di->edit_trackers_button, tor!=NULL );
+    gtk_widget_set_sensitive (di->remove_tracker_button, n>0);
+    gtk_widget_set_sensitive (di->add_tracker_button, tor!=NULL);
+    gtk_widget_set_sensitive (di->edit_trackers_button, tor!=NULL);
 }
 
 static void
-on_add_tracker_response( GtkDialog * dialog, int response, gpointer gdi )
+on_add_tracker_response (GtkDialog * dialog, int response, gpointer gdi)
 {
     gboolean destroy = TRUE;
 
-    if( response == GTK_RESPONSE_ACCEPT )
+    if (response == GTK_RESPONSE_ACCEPT)
     {
         struct DetailsImpl * di = gdi;
-        GtkWidget * e = GTK_WIDGET( g_object_get_qdata( G_OBJECT( dialog ), URL_ENTRY_KEY ) );
-        const int torrent_id = GPOINTER_TO_INT( g_object_get_qdata( G_OBJECT( dialog ), TORRENT_ID_KEY ) );
-        char * url = g_strdup( gtk_entry_get_text( GTK_ENTRY( e ) ) );
-        g_strstrip( url );
+        GtkWidget * e = GTK_WIDGET (g_object_get_qdata (G_OBJECT (dialog), URL_ENTRY_KEY));
+        const int torrent_id = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (dialog), TORRENT_ID_KEY));
+        char * url = g_strdup (gtk_entry_get_text (GTK_ENTRY (e)));
+        g_strstrip (url);
 
-        if( url && *url )
+        if (url && *url)
         {
-            if( tr_urlIsValidTracker( url ) )
+            if (tr_urlIsValidTracker (url))
             {
-                char * json = g_strdup_printf(
+                char * json = g_strdup_printf (
                     "{\n"
                     "  \"method\": \"torrent-set\",\n"
                     "  \"arguments\": { \"id\": %d, \"trackerAdd\": [ \"%s\" ] }\n"
                     "}\n",
-                    torrent_id, url );
-                gtr_core_exec_json( di->core, json );
-                refresh( di );
-                g_free( json );
+                    torrent_id, url);
+                gtr_core_exec_json (di->core, json);
+                refresh (di);
+                g_free (json);
             }
             else
             {
-                gtr_unrecognized_url_dialog( GTK_WIDGET( dialog ), url );
+                gtr_unrecognized_url_dialog (GTK_WIDGET (dialog), url);
                 destroy = FALSE;
             }
         }
 
-        g_free( url );
+        g_free (url);
     }
 
-    if( destroy )
-        gtk_widget_destroy( GTK_WIDGET( dialog ) );
+    if (destroy)
+        gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 static void
-on_tracker_list_add_button_clicked( GtkButton * button UNUSED, gpointer gdi )
+on_tracker_list_add_button_clicked (GtkButton * button UNUSED, gpointer gdi)
 {
     struct DetailsImpl * di = gdi;
-    tr_torrent * tor = tracker_list_get_current_torrent( di );
+    tr_torrent * tor = tracker_list_get_current_torrent (di);
 
-    if( tor != NULL )
+    if (tor != NULL)
     {
         guint row;
         GtkWidget * e;
@@ -2298,159 +2298,159 @@ on_tracker_list_add_button_clicked( GtkButton * button UNUSED, gpointer gdi )
         GtkWidget * w;
         GString * gstr = di->gstr; /* buffer for temporary strings */
 
-        g_string_truncate( gstr, 0 );
-        g_string_append_printf( gstr, _( "%s - Add Tracker" ), tr_torrentName( tor ) );
-        w = gtk_dialog_new_with_buttons( gstr->str, GTK_WINDOW( di->dialog ),
+        g_string_truncate (gstr, 0);
+        g_string_append_printf (gstr, _("%s - Add Tracker"), tr_torrentName (tor));
+        w = gtk_dialog_new_with_buttons (gstr->str, GTK_WINDOW (di->dialog),
                                          GTK_DIALOG_DESTROY_WITH_PARENT,
                                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                          GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,
-                                         NULL );
-        gtk_dialog_set_alternative_button_order( GTK_DIALOG( w ),
+                                         NULL);
+        gtk_dialog_set_alternative_button_order (GTK_DIALOG (w),
                                                  GTK_RESPONSE_ACCEPT,
                                                  GTK_RESPONSE_CANCEL,
-                                                 -1 );
-        g_signal_connect( w, "response", G_CALLBACK( on_add_tracker_response ), gdi );
+                                                 -1);
+        g_signal_connect (w, "response", G_CALLBACK (on_add_tracker_response), gdi);
 
         row = 0;
-        t = hig_workarea_create( );
-        hig_workarea_add_section_title( t, &row, _( "Tracker" ) );
-        e = gtk_entry_new( );
-        gtk_widget_set_size_request( e, 400, -1 );
-        gtr_paste_clipboard_url_into_entry( e );
-        g_object_set_qdata( G_OBJECT( w ), URL_ENTRY_KEY, e );
-        g_object_set_qdata( G_OBJECT( w ), TORRENT_ID_KEY, GINT_TO_POINTER( tr_torrentId( tor ) ) );
-        hig_workarea_add_row( t, &row, _( "_Announce URL:" ), e, NULL );
-        gtr_dialog_set_content( GTK_DIALOG( w ), t );
-        gtk_widget_show_all( w );
+        t = hig_workarea_create ();
+        hig_workarea_add_section_title (t, &row, _("Tracker"));
+        e = gtk_entry_new ();
+        gtk_widget_set_size_request (e, 400, -1);
+        gtr_paste_clipboard_url_into_entry (e);
+        g_object_set_qdata (G_OBJECT (w), URL_ENTRY_KEY, e);
+        g_object_set_qdata (G_OBJECT (w), TORRENT_ID_KEY, GINT_TO_POINTER (tr_torrentId (tor)));
+        hig_workarea_add_row (t, &row, _("_Announce URL:"), e, NULL);
+        gtr_dialog_set_content (GTK_DIALOG (w), t);
+        gtk_widget_show_all (w);
     }
 }
 
 static void
-on_tracker_list_remove_button_clicked( GtkButton * button UNUSED, gpointer gdi )
+on_tracker_list_remove_button_clicked (GtkButton * button UNUSED, gpointer gdi)
 {
     GtkTreeIter iter;
     GtkTreeModel * model;
     struct DetailsImpl * di = gdi;
-    GtkTreeView * v = GTK_TREE_VIEW( di->tracker_view );
-    GtkTreeSelection * sel = gtk_tree_view_get_selection( v );
+    GtkTreeView * v = GTK_TREE_VIEW (di->tracker_view);
+    GtkTreeSelection * sel = gtk_tree_view_get_selection (v);
 
-    if( gtk_tree_selection_get_selected( sel, &model, &iter ) )
+    if (gtk_tree_selection_get_selected (sel, &model, &iter))
     {
         char * json;
         int torrent_id;
         int tracker_id;
-        gtk_tree_model_get( model, &iter, TRACKER_COL_TRACKER_ID, &tracker_id,
+        gtk_tree_model_get (model, &iter, TRACKER_COL_TRACKER_ID, &tracker_id,
                                           TRACKER_COL_TORRENT_ID, &torrent_id,
-                                          -1 );
-        json = g_strdup_printf( "{\n"
+                                          -1);
+        json = g_strdup_printf ("{\n"
                                 "  \"method\": \"torrent-set\",\n"
                                 "  \"arguments\": { \"id\": %d, \"trackerRemove\": [ %d ] }\n"
                                 "}\n",
-                                torrent_id, tracker_id );
-        gtr_core_exec_json( di->core, json );
-        refresh( di );
-        g_free( json );
+                                torrent_id, tracker_id);
+        gtr_core_exec_json (di->core, json);
+        refresh (di);
+        g_free (json);
     }
 }
 
 static GtkWidget*
-tracker_page_new( struct DetailsImpl * di )
+tracker_page_new (struct DetailsImpl * di)
 {
     gboolean b;
     GtkCellRenderer * r;
     GtkTreeViewColumn * c;
     GtkTreeSelection * sel;
     GtkWidget *vbox, *sw, *w, *v, *hbox;
-    const int pad = ( GUI_PAD + GUI_PAD_BIG ) / 2;
+    const int pad = (GUI_PAD + GUI_PAD_BIG) / 2;
 
-    vbox = gtk_box_new( GTK_ORIENTATION_VERTICAL, GUI_PAD );
-    gtk_container_set_border_width( GTK_CONTAINER( vbox ), GUI_PAD_BIG );
+    vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, GUI_PAD);
+    gtk_container_set_border_width (GTK_CONTAINER (vbox), GUI_PAD_BIG);
 
-    di->tracker_store = gtk_list_store_new( TRACKER_N_COLS, G_TYPE_INT,
+    di->tracker_store = gtk_list_store_new (TRACKER_N_COLS, G_TYPE_INT,
                                                             G_TYPE_STRING,
                                                             G_TYPE_BOOLEAN,
                                                             G_TYPE_INT,
                                                             GDK_TYPE_PIXBUF,
                                                             G_TYPE_BOOLEAN,
-                                                            G_TYPE_STRING );
-    di->tracker_hash = g_hash_table_new_full( g_str_hash,
+                                                            G_TYPE_STRING);
+    di->tracker_hash = g_hash_table_new_full (g_str_hash,
                                               g_str_equal,
-                                              (GDestroyNotify)g_free,
-                                              (GDestroyNotify)gtk_tree_row_reference_free );
-    di->trackers_filtered = gtk_tree_model_filter_new( GTK_TREE_MODEL( di->tracker_store ), NULL );
-    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( di->trackers_filtered ),
-                                            trackerVisibleFunc, di, NULL );
-
-    hbox = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG );
-
-        v = di->tracker_view = gtk_tree_view_new_with_model( GTK_TREE_MODEL( di->trackers_filtered ) );
-        g_object_unref( di->trackers_filtered );
-        gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( v ), FALSE );
-        g_signal_connect( v, "button-press-event", G_CALLBACK( on_tree_view_button_pressed ), NULL );
-        g_signal_connect( v, "button-release-event", G_CALLBACK( on_tree_view_button_released ), NULL );
-        gtk_tree_view_set_rules_hint( GTK_TREE_VIEW( v ), TRUE );
-
-        sel = gtk_tree_view_get_selection( GTK_TREE_VIEW( v ) );
-        g_signal_connect( sel, "changed", G_CALLBACK( on_tracker_list_selection_changed ), di );
-
-        c = gtk_tree_view_column_new( );
-        gtk_tree_view_column_set_title( c, _( "Trackers" ) );
-        gtk_tree_view_append_column( GTK_TREE_VIEW( v ), c );
-
-        r = gtk_cell_renderer_pixbuf_new( );
-        g_object_set( r, "width", 20 + (GUI_PAD_SMALL*2), "xpad", GUI_PAD_SMALL, "ypad", pad, "yalign", 0.0f, NULL );
-        gtk_tree_view_column_pack_start( c, r, FALSE );
-        gtk_tree_view_column_add_attribute( c, r, "pixbuf", TRACKER_COL_FAVICON );
-
-        r = gtk_cell_renderer_text_new( );
-        g_object_set( G_OBJECT( r ), "ellipsize", PANGO_ELLIPSIZE_END, "xpad", GUI_PAD_SMALL, "ypad", pad, NULL );
-        gtk_tree_view_column_pack_start( c, r, TRUE );
-        gtk_tree_view_column_add_attribute( c, r, "markup", TRACKER_COL_TEXT );
-
-        sw = gtk_scrolled_window_new( NULL, NULL );
-        gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sw ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
-        gtk_container_add( GTK_CONTAINER( sw ), v );
-        w = gtk_frame_new( NULL );
-        gtk_frame_set_shadow_type( GTK_FRAME( w ), GTK_SHADOW_IN );
-        gtk_container_add( GTK_CONTAINER( w ), sw );
-
-    gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
-
-        v = gtk_box_new( GTK_ORIENTATION_VERTICAL, GUI_PAD );
-
-        w = gtk_button_new_with_mnemonic( _( "_Add" ) );
+                                            (GDestroyNotify)g_free,
+                                            (GDestroyNotify)gtk_tree_row_reference_free);
+    di->trackers_filtered = gtk_tree_model_filter_new (GTK_TREE_MODEL (di->tracker_store), NULL);
+    gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (di->trackers_filtered),
+                                            trackerVisibleFunc, di, NULL);
+
+    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
+
+        v = di->tracker_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (di->trackers_filtered));
+        g_object_unref (di->trackers_filtered);
+        gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (v), FALSE);
+        g_signal_connect (v, "button-press-event", G_CALLBACK (on_tree_view_button_pressed), NULL);
+        g_signal_connect (v, "button-release-event", G_CALLBACK (on_tree_view_button_released), NULL);
+        gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (v), TRUE);
+
+        sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (v));
+        g_signal_connect (sel, "changed", G_CALLBACK (on_tracker_list_selection_changed), di);
+
+        c = gtk_tree_view_column_new ();
+        gtk_tree_view_column_set_title (c, _("Trackers"));
+        gtk_tree_view_append_column (GTK_TREE_VIEW (v), c);
+
+        r = gtk_cell_renderer_pixbuf_new ();
+        g_object_set (r, "width", 20 + (GUI_PAD_SMALL*2), "xpad", GUI_PAD_SMALL, "ypad", pad, "yalign", 0.0f, NULL);
+        gtk_tree_view_column_pack_start (c, r, FALSE);
+        gtk_tree_view_column_add_attribute (c, r, "pixbuf", TRACKER_COL_FAVICON);
+
+        r = gtk_cell_renderer_text_new ();
+        g_object_set (G_OBJECT (r), "ellipsize", PANGO_ELLIPSIZE_END, "xpad", GUI_PAD_SMALL, "ypad", pad, NULL);
+        gtk_tree_view_column_pack_start (c, r, TRUE);
+        gtk_tree_view_column_add_attribute (c, r, "markup", TRACKER_COL_TEXT);
+
+        sw = gtk_scrolled_window_new (NULL, NULL);
+        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+        gtk_container_add (GTK_CONTAINER (sw), v);
+        w = gtk_frame_new (NULL);
+        gtk_frame_set_shadow_type (GTK_FRAME (w), GTK_SHADOW_IN);
+        gtk_container_add (GTK_CONTAINER (w), sw);
+
+    gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
+
+        v = gtk_box_new (GTK_ORIENTATION_VERTICAL, GUI_PAD);
+
+        w = gtk_button_new_with_mnemonic (_("_Add"));
         di->add_tracker_button = w;
-        g_signal_connect( w, "clicked", G_CALLBACK( on_tracker_list_add_button_clicked ), di );
-        gtk_box_pack_start( GTK_BOX( v ), w, FALSE, FALSE, 0 );
+        g_signal_connect (w, "clicked", G_CALLBACK (on_tracker_list_add_button_clicked), di);
+        gtk_box_pack_start (GTK_BOX (v), w, FALSE, FALSE, 0);
 
-        w = gtk_button_new_with_mnemonic( _( "_Edit" ) );
-        gtk_button_set_image( GTK_BUTTON( w ), gtk_image_new_from_stock( GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON ) );
-        g_signal_connect( w, "clicked", G_CALLBACK( on_edit_trackers ), di );
+        w = gtk_button_new_with_mnemonic (_("_Edit"));
+        gtk_button_set_image (GTK_BUTTON (w), gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON));
+        g_signal_connect (w, "clicked", G_CALLBACK (on_edit_trackers), di);
         di->edit_trackers_button = w;
-        gtk_box_pack_start( GTK_BOX( v ), w, FALSE, FALSE, 0 );
+        gtk_box_pack_start (GTK_BOX (v), w, FALSE, FALSE, 0);
 
-        w = gtk_button_new_with_mnemonic( _( "_Remove" ) );
+        w = gtk_button_new_with_mnemonic (_("_Remove"));
         di->remove_tracker_button = w;
-        g_signal_connect( w, "clicked", G_CALLBACK( on_tracker_list_remove_button_clicked ), di );
-        gtk_box_pack_start( GTK_BOX( v ), w, FALSE, FALSE, 0 );
+        g_signal_connect (w, "clicked", G_CALLBACK (on_tracker_list_remove_button_clicked), di);
+        gtk_box_pack_start (GTK_BOX (v), w, FALSE, FALSE, 0);
 
-        gtk_box_pack_start( GTK_BOX( hbox ), v, FALSE, FALSE, 0 );
+        gtk_box_pack_start (GTK_BOX (hbox), v, FALSE, FALSE, 0);
 
-    gtk_box_pack_start( GTK_BOX( vbox ), hbox, TRUE, TRUE, 0 );
+    gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 
-    w = gtk_check_button_new_with_mnemonic( _( "Show _more details" ) );
+    w = gtk_check_button_new_with_mnemonic (_("Show _more details"));
     di->scrape_check = w;
-    b = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_TRACKER_INFO );
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
-    g_signal_connect( w, "toggled", G_CALLBACK( onScrapeToggled ), di );
-    gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
+    b = gtr_pref_flag_get (PREF_KEY_SHOW_MORE_TRACKER_INFO);
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), b);
+    g_signal_connect (w, "toggled", G_CALLBACK (onScrapeToggled), di);
+    gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
 
-    w = gtk_check_button_new_with_mnemonic( _( "Show _backup trackers" ) );
+    w = gtk_check_button_new_with_mnemonic (_("Show _backup trackers"));
     di->all_check = w;
-    b = gtr_pref_flag_get( PREF_KEY_SHOW_BACKUP_TRACKERS );
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
-    g_signal_connect( w, "toggled", G_CALLBACK( onBackupToggled ), di );
-    gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 0 );
+    b = gtr_pref_flag_get (PREF_KEY_SHOW_BACKUP_TRACKERS);
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), b);
+    g_signal_connect (w, "toggled", G_CALLBACK (onBackupToggled), di);
+    gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
 
     return vbox;
 }
@@ -2461,135 +2461,135 @@ tracker_page_new( struct DetailsImpl * di )
 ****/
 
 static void
-refresh( struct DetailsImpl * di )
+refresh (struct DetailsImpl * di)
 {
     int n;
-    tr_torrent ** torrents = getTorrents( di, &n );
+    tr_torrent ** torrents = getTorrents (di, &n);
 
-    refreshInfo( di, torrents, n );
-    refreshPeers( di, torrents, n );
-    refreshTracker( di, torrents, n );
-    refreshOptions( di, torrents, n );
+    refreshInfo (di, torrents, n);
+    refreshPeers (di, torrents, n);
+    refreshTracker (di, torrents, n);
+    refreshOptions (di, torrents, n);
 
-    if( n == 0 )
-        gtk_dialog_response( GTK_DIALOG( di->dialog ), GTK_RESPONSE_CLOSE );
+    if (n == 0)
+        gtk_dialog_response (GTK_DIALOG (di->dialog), GTK_RESPONSE_CLOSE);
 
-    g_free( torrents );
+    g_free (torrents);
 }
 
 static gboolean
-periodic_refresh( gpointer data )
+periodic_refresh (gpointer data)
 {
-    refresh( data );
+    refresh (data);
     return TRUE;
 }
 
 static void
-details_free( gpointer gdata )
+details_free (gpointer gdata)
 {
     struct DetailsImpl * data = gdata;
-    g_source_remove( data->periodic_refresh_tag );
-    g_hash_table_destroy( data->tracker_hash );
-    g_hash_table_destroy( data->webseed_hash );
-    g_hash_table_destroy( data->peer_hash );
-    g_string_free( data->gstr, TRUE );
-    g_slist_free( data->ids );
-    g_free( data );
+    g_source_remove (data->periodic_refresh_tag);
+    g_hash_table_destroy (data->tracker_hash);
+    g_hash_table_destroy (data->webseed_hash);
+    g_hash_table_destroy (data->peer_hash);
+    g_string_free (data->gstr, TRUE);
+    g_slist_free (data->ids);
+    g_free (data);
 }
 
 GtkWidget*
-gtr_torrent_details_dialog_new( GtkWindow * parent, TrCore * core )
+gtr_torrent_details_dialog_new (GtkWindow * parent, TrCore * core)
 {
     GtkWidget *d, *n, *v, *w, *l;
-    struct DetailsImpl * di = g_new0( struct DetailsImpl, 1 );
+    struct DetailsImpl * di = g_new0 (struct DetailsImpl, 1);
 
     /* one-time setup */
-    if( ARG_KEY == 0 )
+    if (ARG_KEY == 0)
     {
-        ARG_KEY          = g_quark_from_static_string( "tr-arg-key" );
-        DETAILS_KEY      = g_quark_from_static_string( "tr-details-data-key" );
-        TORRENT_ID_KEY   = g_quark_from_static_string( "tr-torrent-id-key" );
-        TEXT_BUFFER_KEY  = g_quark_from_static_string( "tr-text-buffer-key" );
-        URL_ENTRY_KEY    = g_quark_from_static_string( "tr-url-entry-key" );
+        ARG_KEY          = g_quark_from_static_string ("tr-arg-key");
+        DETAILS_KEY      = g_quark_from_static_string ("tr-details-data-key");
+        TORRENT_ID_KEY   = g_quark_from_static_string ("tr-torrent-id-key");
+        TEXT_BUFFER_KEY  = g_quark_from_static_string ("tr-text-buffer-key");
+        URL_ENTRY_KEY    = g_quark_from_static_string ("tr-url-entry-key");
     }
 
     /* create the dialog */
     di->core = core;
-    di->gstr = g_string_new( NULL );
-    d = gtk_dialog_new_with_buttons( NULL, parent, 0,
+    di->gstr = g_string_new (NULL);
+    d = gtk_dialog_new_with_buttons (NULL, parent, 0,
                                      GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
-                                     NULL );
+                                     NULL);
     di->dialog = d;
-    gtk_window_set_role( GTK_WINDOW( d ), "tr-info" );
-    g_signal_connect_swapped( d, "response",
-                              G_CALLBACK( gtk_widget_destroy ), d );
-    gtk_container_set_border_width( GTK_CONTAINER( d ), GUI_PAD );
-    g_object_set_qdata_full( G_OBJECT( d ), DETAILS_KEY, di, details_free );
-
-    n = gtk_notebook_new( );
-    gtk_container_set_border_width( GTK_CONTAINER( n ), GUI_PAD );
-
-    w = info_page_new( di );
-    l = gtk_label_new( _( "Information" ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
-
-    w = peer_page_new( di );
-    l = gtk_label_new( _( "Peers" ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ),  w, l );
-
-    w = tracker_page_new( di );
-    l = gtk_label_new( _( "Trackers" ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
-
-    v = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
-    di->file_list = gtr_file_list_new( core, 0 );
-    di->file_label = gtk_label_new( _( "File listing not available for combined torrent properties" ) );
-    gtk_box_pack_start( GTK_BOX( v ), di->file_list, TRUE, TRUE, 0 );
-    gtk_box_pack_start( GTK_BOX( v ), di->file_label, TRUE, TRUE, 0 );
-    gtk_container_set_border_width( GTK_CONTAINER( v ), GUI_PAD_BIG );
-    l = gtk_label_new( _( "Files" ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ), v, l );
-
-    w = options_page_new( di );
-    l = gtk_label_new( _( "Options" ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ), w, l );
-
-    gtr_dialog_set_content( GTK_DIALOG( d ), n );
-    di->periodic_refresh_tag = gdk_threads_add_timeout_seconds( SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS,
-                                                                periodic_refresh, di );
+    gtk_window_set_role (GTK_WINDOW (d), "tr-info");
+    g_signal_connect_swapped (d, "response",
+                              G_CALLBACK (gtk_widget_destroy), d);
+    gtk_container_set_border_width (GTK_CONTAINER (d), GUI_PAD);
+    g_object_set_qdata_full (G_OBJECT (d), DETAILS_KEY, di, details_free);
+
+    n = gtk_notebook_new ();
+    gtk_container_set_border_width (GTK_CONTAINER (n), GUI_PAD);
+
+    w = info_page_new (di);
+    l = gtk_label_new (_("Information"));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n), w, l);
+
+    w = peer_page_new (di);
+    l = gtk_label_new (_("Peers"));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n),  w, l);
+
+    w = tracker_page_new (di);
+    l = gtk_label_new (_("Trackers"));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n), w, l);
+
+    v = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+    di->file_list = gtr_file_list_new (core, 0);
+    di->file_label = gtk_label_new (_("File listing not available for combined torrent properties"));
+    gtk_box_pack_start (GTK_BOX (v), di->file_list, TRUE, TRUE, 0);
+    gtk_box_pack_start (GTK_BOX (v), di->file_label, TRUE, TRUE, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (v), GUI_PAD_BIG);
+    l = gtk_label_new (_("Files"));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n), v, l);
+
+    w = options_page_new (di);
+    l = gtk_label_new (_("Options"));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n), w, l);
+
+    gtr_dialog_set_content (GTK_DIALOG (d), n);
+    di->periodic_refresh_tag = gdk_threads_add_timeout_seconds (SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS,
+                                                                periodic_refresh, di);
     return d;
 }
 
 void
-gtr_torrent_details_dialog_set_torrents( GtkWidget * w, GSList * ids )
+gtr_torrent_details_dialog_set_torrents (GtkWidget * w, GSList * ids)
 {
     char title[256];
-    const int len = g_slist_length( ids );
-    struct DetailsImpl * di = g_object_get_qdata( G_OBJECT( w ), DETAILS_KEY );
+    const int len = g_slist_length (ids);
+    struct DetailsImpl * di = g_object_get_qdata (G_OBJECT (w), DETAILS_KEY);
 
-    g_slist_free( di->ids );
-    di->ids = g_slist_copy( ids );
+    g_slist_free (di->ids);
+    di->ids = g_slist_copy (ids);
 
-    if( len == 1 )
+    if (len == 1)
     {
-        const int id = GPOINTER_TO_INT( ids->data );
-        tr_torrent * tor = gtr_core_find_torrent( di->core, id );
-        const tr_info * inf = tr_torrentInfo( tor );
-        g_snprintf( title, sizeof( title ), _( "%s Properties" ), inf->name );
-
-        gtr_file_list_set_torrent( di->file_list, id );
-        gtk_widget_show( di->file_list );
-        gtk_widget_hide( di->file_label );
+        const int id = GPOINTER_TO_INT (ids->data);
+        tr_torrent * tor = gtr_core_find_torrent (di->core, id);
+        const tr_info * inf = tr_torrentInfo (tor);
+        g_snprintf (title, sizeof (title), _("%s Properties"), inf->name);
+
+        gtr_file_list_set_torrent (di->file_list, id);
+        gtk_widget_show (di->file_list);
+        gtk_widget_hide (di->file_label);
     }
    else
    {
-        gtr_file_list_clear( di->file_list );
-        gtk_widget_hide( di->file_list );
-        gtk_widget_show( di->file_label );
-        g_snprintf( title, sizeof( title ), _( "%'d Torrent Properties" ), len );
+        gtr_file_list_clear (di->file_list);
+        gtk_widget_hide (di->file_list);
+        gtk_widget_show (di->file_label);
+        g_snprintf (title, sizeof (title), _("%'d Torrent Properties"), len);
     }
 
-    gtk_window_set_title( GTK_WINDOW( w ), title );
+    gtk_window_set_title (GTK_WINDOW (w), title);
 
-    refresh( di );
+    refresh (di);
 }
diff --git a/gtk/details.h b/gtk/details.h
index bde444b81..439fc6980 100644
--- a/gtk/details.h
+++ b/gtk/details.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,10 +16,10 @@
 #include <gtk/gtk.h>
 #include "tr-core.h"
 
-GtkWidget*  gtr_torrent_details_dialog_new          ( GtkWindow * parent,
-                                                      TrCore    * core );
+GtkWidget*  gtr_torrent_details_dialog_new        (GtkWindow * parent,
+                                                      TrCore    * core);
 
-void        gtr_torrent_details_dialog_set_torrents ( GtkWidget * details_dialog,
-                                                      GSList    * torrent_ids );
+void        gtr_torrent_details_dialog_set_torrents (GtkWidget * details_dialog,
+                                                      GSList    * torrent_ids);
 
 #endif /* GTR_TORRENT_DETAILS_H */
diff --git a/gtk/dialogs.c b/gtk/dialogs.c
index 1644ecad9..84756b133 100644
--- a/gtk/dialogs.c
+++ b/gtk/dialogs.c
@@ -42,25 +42,25 @@ struct delete_data
 };
 
 static void
-on_remove_dialog_response( GtkDialog * dialog, gint response, gpointer gdd )
+on_remove_dialog_response (GtkDialog * dialog, gint response, gpointer gdd)
 {
     GSList * l;
     struct delete_data * dd = gdd;
 
-    if( response == GTK_RESPONSE_ACCEPT )
-        for( l=dd->torrent_ids; l!=NULL; l=l->next )
-            gtr_core_remove_torrent( dd->core, GPOINTER_TO_INT( l->data ), dd->delete_files );
+    if (response == GTK_RESPONSE_ACCEPT)
+        for (l=dd->torrent_ids; l!=NULL; l=l->next)
+            gtr_core_remove_torrent (dd->core, GPOINTER_TO_INT (l->data), dd->delete_files);
 
-    gtk_widget_destroy( GTK_WIDGET( dialog ) );
-    g_slist_free( dd->torrent_ids );
-    g_free( dd );
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+    g_slist_free (dd->torrent_ids);
+    g_free (dd);
 }
 
 void
-gtr_confirm_remove( GtkWindow  * parent,
+gtr_confirm_remove (GtkWindow  * parent,
                     TrCore     * core,
                     GSList     * torrent_ids,
-                    gboolean     delete_files )
+                    gboolean     delete_files)
 {
     GSList * l;
     GtkWidget * d;
@@ -69,99 +69,99 @@ gtr_confirm_remove( GtkWindow  * parent,
     struct delete_data * dd;
     int connected = 0;
     int incomplete = 0;
-    const int count = g_slist_length( torrent_ids );
+    const int count = g_slist_length (torrent_ids);
 
-    if( !count )
+    if (!count)
         return;
 
-    dd = g_new0( struct delete_data, 1 );
+    dd = g_new0 (struct delete_data, 1);
     dd->core = core;
     dd->torrent_ids = torrent_ids;
     dd->delete_files = delete_files;
 
-    for( l=torrent_ids; l!=NULL; l=l->next )
+    for (l=torrent_ids; l!=NULL; l=l->next)
     {
-        const int id = GPOINTER_TO_INT( l->data );
-        tr_torrent * tor = gtr_core_find_torrent( core, id );
-        const tr_stat * stat = tr_torrentStat( tor );
-        if( stat->leftUntilDone ) ++incomplete;
-        if( stat->peersConnected ) ++connected;
+        const int id = GPOINTER_TO_INT (l->data);
+        tr_torrent * tor = gtr_core_find_torrent (core, id);
+        const tr_stat * stat = tr_torrentStat (tor);
+        if (stat->leftUntilDone) ++incomplete;
+        if (stat->peersConnected) ++connected;
     }
 
-    primary_text = g_string_new( NULL );
+    primary_text = g_string_new (NULL);
 
-    if( !delete_files )
+    if (!delete_files)
     {
-        g_string_printf( primary_text, ngettext( "Remove torrent?",
+        g_string_printf (primary_text, ngettext ("Remove torrent?",
                                                  "Remove %d torrents?",
-                                                 count ), count );
+                                                 count), count);
     }
     else
     {
-        g_string_printf( primary_text, ngettext( "Delete this torrent's downloaded files?",
+        g_string_printf (primary_text, ngettext ("Delete this torrent's downloaded files?",
                                                  "Delete these %d torrents' downloaded files?",
-                                                 count ), count );
+                                                 count), count);
     }
 
-    secondary_text = g_string_new( NULL );
+    secondary_text = g_string_new (NULL);
 
-    if( !incomplete && !connected )
+    if (!incomplete && !connected)
     {
-        g_string_assign( secondary_text, ngettext(
+        g_string_assign (secondary_text, ngettext (
                 "Once removed, continuing the transfer will require the torrent file or magnet link.",
                 "Once removed, continuing the transfers will require the torrent files or magnet links.",
-                count ) );
+                count));
     }
-    else if( count == incomplete )
+    else if (count == incomplete)
     {
-        g_string_assign( secondary_text, ngettext( "This torrent has not finished downloading.",
+        g_string_assign (secondary_text, ngettext ("This torrent has not finished downloading.",
                                                    "These torrents have not finished downloading.",
-                                                   count ) );
+                                                   count));
     }
-    else if( count == connected )
+    else if (count == connected)
     {
-        g_string_assign( secondary_text, ngettext( "This torrent is connected to peers.",
+        g_string_assign (secondary_text, ngettext ("This torrent is connected to peers.",
                                                    "These torrents are connected to peers.",
-                                                   count ) );
+                                                   count));
     }
     else
     {
-        if( connected )
-            g_string_append( secondary_text, ngettext( "One of these torrents is connected to peers.",
+        if (connected)
+            g_string_append (secondary_text, ngettext ("One of these torrents is connected to peers.",
                                                        "Some of these torrents are connected to peers.",
-                                                       connected ) );
-        if( connected && incomplete )
-            g_string_append( secondary_text, "\n" );
+                                                       connected));
+        if (connected && incomplete)
+            g_string_append (secondary_text, "\n");
 
-        if( incomplete )
-            g_string_assign( secondary_text, ngettext( "One of these torrents has not finished downloading.",
+        if (incomplete)
+            g_string_assign (secondary_text, ngettext ("One of these torrents has not finished downloading.",
                                                        "Some of these torrents have not finished downloading.",
-                                                       incomplete ) );
+                                                       incomplete));
     }
 
-    d = gtk_message_dialog_new_with_markup( parent,
+    d = gtk_message_dialog_new_with_markup (parent,
                                             GTK_DIALOG_DESTROY_WITH_PARENT,
                                             GTK_MESSAGE_QUESTION,
                                             GTK_BUTTONS_NONE,
                                             "<big><b>%s</b></big>",
-                                            primary_text->str );
-    if( secondary_text->len )
-        gtk_message_dialog_format_secondary_markup( GTK_MESSAGE_DIALOG( d ),
-                                                    "%s", secondary_text->str );
-    gtk_dialog_add_buttons( GTK_DIALOG( d ),
+                                            primary_text->str);
+    if (secondary_text->len)
+        gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (d),
+                                                    "%s", secondary_text->str);
+    gtk_dialog_add_buttons (GTK_DIALOG (d),
                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                            ( delete_files ? GTK_STOCK_DELETE :
-                              GTK_STOCK_REMOVE ), GTK_RESPONSE_ACCEPT,
-                            NULL );
-    gtk_dialog_set_default_response( GTK_DIALOG ( d ),
-                                     GTK_RESPONSE_CANCEL );
-    gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
+                          (delete_files ? GTK_STOCK_DELETE :
+                              GTK_STOCK_REMOVE), GTK_RESPONSE_ACCEPT,
+                            NULL);
+    gtk_dialog_set_default_response (GTK_DIALOG (d),
+                                     GTK_RESPONSE_CANCEL);
+    gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
                                              GTK_RESPONSE_ACCEPT,
                                              GTK_RESPONSE_CANCEL,
-                                             -1 );
-    g_signal_connect( d, "response", G_CALLBACK( on_remove_dialog_response ), dd );
-    gtk_widget_show_all( d );
+                                             -1);
+    g_signal_connect (d, "response", G_CALLBACK (on_remove_dialog_response), dd);
+    gtk_widget_show_all (d);
 
-    g_string_free( primary_text, TRUE );
-    g_string_free( secondary_text, TRUE );
+    g_string_free (primary_text, TRUE);
+    g_string_free (secondary_text, TRUE);
 }
diff --git a/gtk/dialogs.h b/gtk/dialogs.h
index eefc23599..1af5d65b4 100644
--- a/gtk/dialogs.h
+++ b/gtk/dialogs.h
@@ -31,9 +31,9 @@
 /**
  * Prompt the user to confirm removing a torrent.
  */
-void gtr_confirm_remove ( GtkWindow * parent,
+void gtr_confirm_remove (GtkWindow * parent,
                           TrCore    * core,
                           GSList    * gtorrents,
-                          gboolean    doDelete );
+                          gboolean    doDelete);
 
 #endif /* GTR_DIALOGS_H */
diff --git a/gtk/favicon.c b/gtk/favicon.c
index 088c3a7e9..5ead99901 100644
--- a/gtk/favicon.c
+++ b/gtk/favicon.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,14 +10,14 @@
  * $Id$
  */
 
-#include <glib/gstdio.h> /* g_remove() */
+#include <glib/gstdio.h> /* g_remove () */
 #include <gtk/gtk.h>
 
 #include <libtransmission/transmission.h>
-#include <libtransmission/web.h> /* tr_webRun() */
+#include <libtransmission/web.h> /* tr_webRun () */
 
 #include "favicon.h"
-#include "util.h" /* gtr_get_host_from_url() */
+#include "util.h" /* gtr_get_host_from_url () */
 
 #define IMAGE_TYPES 4
 static const char * image_types[IMAGE_TYPES] = { "ico", "png", "gif", "jpg" };
@@ -34,151 +34,151 @@ struct favicon_data
 };
 
 static char*
-get_url( const char * host, int image_type )
+get_url (const char * host, int image_type)
 {
-    return g_strdup_printf( "http://%s/favicon.%s", host, image_types[image_type] );
+    return g_strdup_printf ("http://%s/favicon.%s", host, image_types[image_type]);
 }
 
 static char*
-favicon_get_cache_dir( void )
+favicon_get_cache_dir (void)
 {
     static char * dir = NULL;
 
-    if( dir == NULL )
+    if (dir == NULL)
     {
-        dir = g_build_filename( g_get_user_cache_dir(),
+        dir = g_build_filename (g_get_user_cache_dir (),
                                 "transmission",
                                 "favicons",
-                                NULL );
-        g_mkdir_with_parents( dir, 0777 );
+                                NULL);
+        g_mkdir_with_parents (dir, 0777);
     }
 
     return dir;
 }
 
 static char*
-favicon_get_cache_filename( const char * host )
+favicon_get_cache_filename (const char * host)
 {
-    return g_build_filename( favicon_get_cache_dir(), host, NULL );
+    return g_build_filename (favicon_get_cache_dir (), host, NULL);
 }
 
 static void
-favicon_save_to_cache( const char * host, const void * data, size_t len )
+favicon_save_to_cache (const char * host, const void * data, size_t len)
 {
-    char * filename = favicon_get_cache_filename( host );
-    g_file_set_contents( filename, data, len, NULL );
-    g_free( filename );
+    char * filename = favicon_get_cache_filename (host);
+    g_file_set_contents (filename, data, len, NULL);
+    g_free (filename);
 }
 
 static GdkPixbuf*
-favicon_load_from_cache( const char * host )
+favicon_load_from_cache (const char * host)
 {
-    char * filename = favicon_get_cache_filename( host );
-    GdkPixbuf * pixbuf = gdk_pixbuf_new_from_file_at_size( filename, 16, 16, NULL );
-    if( pixbuf == NULL ) /* bad file */
-        g_remove( filename );
-    g_free( filename );
+    char * filename = favicon_get_cache_filename (host);
+    GdkPixbuf * pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 16, 16, NULL);
+    if (pixbuf == NULL) /* bad file */
+        g_remove (filename);
+    g_free (filename);
     return pixbuf;
 }
 
-static void favicon_web_done_cb( tr_session*, bool, bool, long, const void*, size_t, void* );
+static void favicon_web_done_cb (tr_session*, bool, bool, long, const void*, size_t, void*);
 
 static gboolean
-favicon_web_done_idle_cb( gpointer vfav )
+favicon_web_done_idle_cb (gpointer vfav)
 {
     GdkPixbuf * pixbuf = NULL;
     gboolean finished = FALSE;
     struct favicon_data * fav = vfav;
 
-    if( fav->len > 0 ) /* we got something... try to make a pixbuf from it */
+    if (fav->len > 0) /* we got something... try to make a pixbuf from it */
     {
-        favicon_save_to_cache( fav->host, fav->contents, fav->len );
-        pixbuf = favicon_load_from_cache( fav->host );
+        favicon_save_to_cache (fav->host, fav->contents, fav->len);
+        pixbuf = favicon_load_from_cache (fav->host);
         finished = pixbuf != NULL;
     }
 
-    if( !finished ) /* no pixbuf yet... */
+    if (!finished) /* no pixbuf yet... */
     {
-        if( ++fav->type == IMAGE_TYPES ) /* failure */
+        if (++fav->type == IMAGE_TYPES) /* failure */
         {
             finished = TRUE;
         }
         else /* keep trying */
         {
-            char * url = get_url( fav->host, fav->type );
+            char * url = get_url (fav->host, fav->type);
 
-            g_free( fav->contents );
+            g_free (fav->contents);
             fav->contents = NULL;
             fav->len = 0;
 
-            tr_webRun( fav->session, url, NULL, NULL, favicon_web_done_cb, fav );
-            g_free( url );
+            tr_webRun (fav->session, url, NULL, NULL, favicon_web_done_cb, fav);
+            g_free (url);
         }
     }
 
-    if( finished )
+    if (finished)
     {
-        fav->func( pixbuf, fav->data );
-        g_free( fav->host );
-        g_free( fav->contents );
-        g_free( fav );
+        fav->func (pixbuf, fav->data);
+        g_free (fav->host);
+        g_free (fav->contents);
+        g_free (fav);
     }
 
     return FALSE;
 }
 
 static void
-favicon_web_done_cb( tr_session    * session UNUSED,
+favicon_web_done_cb (tr_session    * session UNUSED,
                      bool            did_connect UNUSED,
                      bool            did_timeout UNUSED,
                      long            code UNUSED,
                      const void    * data,
                      size_t          len,
-                     void          * vfav )
+                     void          * vfav)
 {
     struct favicon_data * fav = vfav;
-    fav->contents = g_memdup( data, len );
+    fav->contents = g_memdup (data, len);
     fav->len = len;
 
-    gdk_threads_add_idle( favicon_web_done_idle_cb, fav );
+    gdk_threads_add_idle (favicon_web_done_idle_cb, fav);
 }
 
 void
-gtr_get_favicon( tr_session  * session,
+gtr_get_favicon (tr_session  * session,
                  const char  * host,
                  GFunc         pixbuf_ready_func,
-                 gpointer      pixbuf_ready_func_data )
+                 gpointer      pixbuf_ready_func_data)
 {
-    GdkPixbuf * pixbuf = favicon_load_from_cache( host );
+    GdkPixbuf * pixbuf = favicon_load_from_cache (host);
 
-    if( pixbuf != NULL )
+    if (pixbuf != NULL)
     {
-        pixbuf_ready_func( pixbuf, pixbuf_ready_func_data );
+        pixbuf_ready_func (pixbuf, pixbuf_ready_func_data);
     }
     else
     {
         struct favicon_data * data;
-        char * url = get_url( host, 0 );
+        char * url = get_url (host, 0);
 
-        data = g_new( struct favicon_data, 1 );
+        data = g_new (struct favicon_data, 1);
         data->session = session;
         data->func = pixbuf_ready_func;
         data->data = pixbuf_ready_func_data;
-        data->host = g_strdup( host );
+        data->host = g_strdup (host);
         data->type = 0;
 
-        tr_webRun( session, url, NULL, NULL, favicon_web_done_cb, data );
-        g_free( url );
+        tr_webRun (session, url, NULL, NULL, favicon_web_done_cb, data);
+        g_free (url);
     }
 }
 
 void
-gtr_get_favicon_from_url( tr_session  * session,
+gtr_get_favicon_from_url (tr_session  * session,
                           const char  * url,
                           GFunc         pixbuf_ready_func,
-                          gpointer      pixbuf_ready_func_data )
+                          gpointer      pixbuf_ready_func_data)
 {
     char host[1024];
-    gtr_get_host_from_url( host, sizeof( host ), url );
-    gtr_get_favicon( session, host, pixbuf_ready_func, pixbuf_ready_func_data );
+    gtr_get_host_from_url (host, sizeof (host), url);
+    gtr_get_favicon (session, host, pixbuf_ready_func, pixbuf_ready_func_data);
 }
diff --git a/gtk/favicon.h b/gtk/favicon.h
index 617a30dd9..71b4562ec 100644
--- a/gtk/favicon.h
+++ b/gtk/favicon.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,15 +16,15 @@
 #include <gtk/gtk.h>
 #include <libtransmission/transmission.h>
 
-void gtr_get_favicon( tr_session  * session,
+void gtr_get_favicon (tr_session  * session,
                       const char  * host,
                       GFunc         pixbuf_ready_func,
-                      gpointer      pixbuf_ready_func_data );
+                      gpointer      pixbuf_ready_func_data);
 
-void gtr_get_favicon_from_url( tr_session  * session,
+void gtr_get_favicon_from_url (tr_session  * session,
                                const char  * url,
                                GFunc         pixbuf_ready_func,
-                               gpointer      pixbuf_ready_func_data );
+                               gpointer      pixbuf_ready_func_data);
 
 
 #endif
diff --git a/gtk/file-list.c b/gtk/file-list.c
index 2af5dbd4c..9852e081c 100644
--- a/gtk/file-list.c
+++ b/gtk/file-list.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -65,21 +65,21 @@ typedef struct
 FileData;
 
 static void
-clearData( FileData * data )
+clearData (FileData * data)
 {
     data->torrentId = -1;
 
-    if( data->timeout_tag ) {
-        g_source_remove( data->timeout_tag );
+    if (data->timeout_tag) {
+        g_source_remove (data->timeout_tag);
         data->timeout_tag = 0;
     }
 }
 
 static void
-freeData( gpointer data )
+freeData (gpointer data)
 {
-    clearData( data );
-    g_free( data );
+    clearData (data);
+    g_free (data);
 }
 
 /***
@@ -98,10 +98,10 @@ struct RefreshData
 };
 
 static gboolean
-refreshFilesForeach( GtkTreeModel * model,
+refreshFilesForeach (GtkTreeModel * model,
                      GtkTreePath  * path UNUSED,
                      GtkTreeIter  * iter,
-                     gpointer       gdata )
+                     gpointer       gdata)
 {
     struct RefreshData * refresh_data = gdata;
     FileData * data = refresh_data->file_data;
@@ -111,49 +111,49 @@ refreshFilesForeach( GtkTreeModel * model,
     int old_prog;
     int old_priority;
     int old_enabled;
-    const gboolean is_file = !gtk_tree_model_iter_has_child( model, iter );
+    const gboolean is_file = !gtk_tree_model_iter_has_child (model, iter);
 
-    gtk_tree_model_get( model, iter, FC_ENABLED, &old_enabled,
+    gtk_tree_model_get (model, iter, FC_ENABLED, &old_enabled,
                                      FC_PRIORITY, &old_priority,
                                      FC_INDEX, &index,
                                      FC_HAVE, &old_have,
                                      FC_SIZE, &size,
                                      FC_PROG, &old_prog,
-                                     -1  );
+                                     -1);
 
-    if( is_file )
+    if (is_file)
     {
         tr_torrent * tor = refresh_data->tor;
-        const tr_info * inf = tr_torrentInfo( tor );
+        const tr_info * inf = tr_torrentInfo (tor);
         const int enabled = !inf->files[index].dnd;
         const int priority = inf->files[index].priority;
         const uint64_t have = refresh_data->refresh_file_stat[index].bytesCompleted;
         const int prog = size ? (int)((100.0*have)/size) : 1;
 
-        if( (priority!=old_priority) || (enabled!=old_enabled) || (have!=old_have) || (prog!=old_prog) )
+        if ((priority!=old_priority) || (enabled!=old_enabled) || (have!=old_have) || (prog!=old_prog))
         {
             /* Changing a value in the sort column can trigger a resort
-             * which breaks this foreach() call. (See #3529)
+             * which breaks this foreach () call. (See #3529)
              * As a workaround: if that's about to happen, temporarily disable
              * sorting until we finish walking the tree. */
-            if( !refresh_data->resort_needed )
+            if (!refresh_data->resort_needed)
             {
-                if(( refresh_data->resort_needed =
-                    (( refresh_data->sort_column_id==FC_PRIORITY ) && ( priority!=old_priority )) ||
-                    (( refresh_data->sort_column_id==FC_ENABLED ) && ( enabled!=old_enabled ))))
+                if ((refresh_data->resort_needed =
+                  ((refresh_data->sort_column_id==FC_PRIORITY) && (priority!=old_priority)) ||
+                  ((refresh_data->sort_column_id==FC_ENABLED) && (enabled!=old_enabled))))
                 {
                     refresh_data->resort_needed = TRUE;
-                    gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE( data->model ),
+                    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->model),
                                                           GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
-                                                          GTK_SORT_ASCENDING );
+                                                          GTK_SORT_ASCENDING);
                 }
             }
 
-            gtk_tree_store_set( data->store, iter, FC_PRIORITY, priority,
+            gtk_tree_store_set (data->store, iter, FC_PRIORITY, priority,
                                                    FC_ENABLED, enabled,
                                                    FC_HAVE, have,
                                                    FC_PROG, prog,
-                                                   -1 );
+                                                   -1);
         }
     }
     else
@@ -165,52 +165,52 @@ refreshFilesForeach( GtkTreeModel * model,
         int enabled = NOT_SET;
         int priority = NOT_SET;
 
-        /* since gtk_tree_model_foreach() is depth-first, we can
+        /* since gtk_tree_model_foreach () is depth-first, we can
          * get the `sub' info by walking the immediate children */
 
-        if( gtk_tree_model_iter_children( model, &child, iter ) ) do
+        if (gtk_tree_model_iter_children (model, &child, iter)) do
         {
             int child_enabled;
             int child_priority;
             int64_t child_have, child_size;
 
-            gtk_tree_model_get( model, &child, FC_SIZE, &child_size,
+            gtk_tree_model_get (model, &child, FC_SIZE, &child_size,
                                                FC_HAVE, &child_have,
                                                FC_PRIORITY, &child_priority,
                                                FC_ENABLED, &child_enabled,
-                                               -1 );
+                                               -1);
 
             sub_size += child_size;
             have += child_have;
 
-            if( enabled == NOT_SET )
+            if (enabled == NOT_SET)
                 enabled = child_enabled;
-            else if( enabled != child_enabled )
+            else if (enabled != child_enabled)
                 enabled = MIXED;
 
-            if( priority == NOT_SET )
+            if (priority == NOT_SET)
                 priority = child_priority;
-            else if( priority != child_priority )
+            else if (priority != child_priority)
                 priority = MIXED;
         }
-        while( gtk_tree_model_iter_next( model, &child ) );
+        while (gtk_tree_model_iter_next (model, &child));
 
         prog = sub_size ? (int)((100.0*have)/sub_size) : 1;
 
-        if( (size!=sub_size) || (have!=old_have)
+        if ((size!=sub_size) || (have!=old_have)
                              || (priority!=old_priority)
                              || (enabled!=old_enabled)
-                             || (prog!=old_prog) )
+                             || (prog!=old_prog))
         {
             char size_str[64];
-            tr_strlsize( size_str, sub_size, sizeof size_str );
-            gtk_tree_store_set( data->store, iter, FC_SIZE, sub_size,
+            tr_strlsize (size_str, sub_size, sizeof size_str);
+            gtk_tree_store_set (data->store, iter, FC_SIZE, sub_size,
                                                    FC_SIZE_STR, size_str,
                                                    FC_HAVE, have,
                                                    FC_PRIORITY, priority,
                                                    FC_ENABLED, enabled,
                                                    FC_PROG, prog,
-                                                   -1 );
+                                                   -1);
         }
     }
 
@@ -218,38 +218,38 @@ refreshFilesForeach( GtkTreeModel * model,
 }
 
 static void
-gtr_tree_model_foreach_postorder_subtree( GtkTreeModel            * model,
+gtr_tree_model_foreach_postorder_subtree (GtkTreeModel            * model,
                                           GtkTreeIter             * parent,
                                           GtkTreeModelForeachFunc   func,
-                                          gpointer                  data )
+                                          gpointer                  data)
 {
     GtkTreeIter child;
-    if( gtk_tree_model_iter_children( model, &child, parent ) ) do
-        gtr_tree_model_foreach_postorder_subtree( model, &child, func, data );
-    while( gtk_tree_model_iter_next( model, &child ) );
-    if( parent )
-        func( model, NULL, parent, data );
+    if (gtk_tree_model_iter_children (model, &child, parent)) do
+        gtr_tree_model_foreach_postorder_subtree (model, &child, func, data);
+    while (gtk_tree_model_iter_next (model, &child));
+    if (parent)
+        func (model, NULL, parent, data);
 }
 
 static void
-gtr_tree_model_foreach_postorder( GtkTreeModel            * model,
+gtr_tree_model_foreach_postorder (GtkTreeModel            * model,
                                   GtkTreeModelForeachFunc   func,
-                                  gpointer                  data )
+                                  gpointer                  data)
 {
     GtkTreeIter iter;
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
-        gtr_tree_model_foreach_postorder_subtree( model, &iter, func, data );
-    while( gtk_tree_model_iter_next( model, &iter ) );
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
+        gtr_tree_model_foreach_postorder_subtree (model, &iter, func, data);
+    while (gtk_tree_model_iter_next (model, &iter));
 }
 
 static void
-refresh( FileData * data )
+refresh (FileData * data)
 {
-    tr_torrent * tor = gtr_core_find_torrent( data->core, data->torrentId );
+    tr_torrent * tor = gtr_core_find_torrent (data->core, data->torrentId);
 
-    if( tor == NULL )
+    if (tor == NULL)
     {
-        gtr_file_list_clear( data->top );
+        gtr_file_list_clear (data->top);
     }
     else
     {
@@ -257,28 +257,28 @@ refresh( FileData * data )
         int sort_column_id;
         tr_file_index_t fileCount;
         struct RefreshData refresh_data;
-        GtkTreeSortable * sortable = GTK_TREE_SORTABLE( data->model );
-        gtk_tree_sortable_get_sort_column_id( sortable, &sort_column_id, &order );
+        GtkTreeSortable * sortable = GTK_TREE_SORTABLE (data->model);
+        gtk_tree_sortable_get_sort_column_id (sortable, &sort_column_id, &order);
 
         refresh_data.sort_column_id = sort_column_id;
         refresh_data.resort_needed = FALSE;
-        refresh_data.refresh_file_stat = tr_torrentFiles( tor, &fileCount );
+        refresh_data.refresh_file_stat = tr_torrentFiles (tor, &fileCount);
         refresh_data.tor = tor;
         refresh_data.file_data = data;
 
-        gtr_tree_model_foreach_postorder( data->model, refreshFilesForeach, &refresh_data );
+        gtr_tree_model_foreach_postorder (data->model, refreshFilesForeach, &refresh_data);
 
-        if( refresh_data.resort_needed )
-            gtk_tree_sortable_set_sort_column_id( sortable, sort_column_id, order );
+        if (refresh_data.resort_needed)
+            gtk_tree_sortable_set_sort_column_id (sortable, sort_column_id, order);
 
-        tr_torrentFilesFree( refresh_data.refresh_file_stat, fileCount );
+        tr_torrentFilesFree (refresh_data.refresh_file_stat, fileCount);
     }
 }
 
 static gboolean
-refreshModel( gpointer file_data )
+refreshModel (gpointer file_data)
 {
-    refresh( file_data );
+    refresh (file_data);
     return TRUE;
 }
 
@@ -293,37 +293,37 @@ struct ActiveData
 };
 
 static gboolean
-getSelectedFilesForeach( GtkTreeModel * model,
+getSelectedFilesForeach (GtkTreeModel * model,
                          GtkTreePath  * path UNUSED,
                          GtkTreeIter  * iter,
-                         gpointer       gdata )
+                         gpointer       gdata)
 {
-    const gboolean is_file = !gtk_tree_model_iter_has_child( model, iter );
+    const gboolean is_file = !gtk_tree_model_iter_has_child (model, iter);
 
-    if( is_file )
+    if (is_file)
     {
         struct ActiveData * data = gdata;
 
         /* active means: if it's selected or any ancestor is selected */
 
-        gboolean is_active = gtk_tree_selection_iter_is_selected( data->sel, iter );
+        gboolean is_active = gtk_tree_selection_iter_is_selected (data->sel, iter);
 
-        if( !is_active )
+        if (!is_active)
         {
             GtkTreeIter walk = *iter;
             GtkTreeIter parent;
-            while( !is_active && gtk_tree_model_iter_parent( model, &parent, &walk ) )
+            while (!is_active && gtk_tree_model_iter_parent (model, &parent, &walk))
             {
-                is_active = gtk_tree_selection_iter_is_selected( data->sel, &parent );
+                is_active = gtk_tree_selection_iter_is_selected (data->sel, &parent);
                 walk = parent;
             }
         }
 
-        if( is_active )
+        if (is_active)
         {
             unsigned int i;
-            gtk_tree_model_get( model, iter, FC_INDEX, &i, -1 );
-            g_array_append_val( data->array, i );
+            gtk_tree_model_get (model, iter, FC_INDEX, &i, -1);
+            g_array_append_val (data->array, i);
         }
     }
 
@@ -331,14 +331,14 @@ getSelectedFilesForeach( GtkTreeModel * model,
 }
 
 static GArray*
-getSelectedFilesAndDescendants( GtkTreeView * view )
+getSelectedFilesAndDescendants (GtkTreeView * view)
 {
     struct ActiveData data;
 
-    data.sel = gtk_tree_view_get_selection( view );
-    data.array = g_array_new( FALSE, FALSE, sizeof( tr_file_index_t ) );
-    gtk_tree_model_foreach( gtk_tree_view_get_model( view ),
-                            getSelectedFilesForeach, &data );
+    data.sel = gtk_tree_view_get_selection (view);
+    data.array = g_array_new (FALSE, FALSE, sizeof (tr_file_index_t));
+    gtk_tree_model_foreach (gtk_tree_view_get_model (view),
+                            getSelectedFilesForeach, &data);
     return data.array;
 }
 
@@ -349,22 +349,22 @@ struct SubtreeForeachData
 };
 
 static gboolean
-getSubtreeForeach( GtkTreeModel   * model,
+getSubtreeForeach (GtkTreeModel   * model,
                    GtkTreePath    * path,
                    GtkTreeIter    * iter,
-                   gpointer         gdata )
+                   gpointer         gdata)
 {
-    const gboolean is_file = !gtk_tree_model_iter_has_child( model, iter );
+    const gboolean is_file = !gtk_tree_model_iter_has_child (model, iter);
 
-    if( is_file )
+    if (is_file)
     {
         struct SubtreeForeachData * data = gdata;
 
-        if( !gtk_tree_path_compare( path, data->path ) || gtk_tree_path_is_descendant( path, data->path ) )
+        if (!gtk_tree_path_compare (path, data->path) || gtk_tree_path_is_descendant (path, data->path))
         {
             unsigned int i;
-            gtk_tree_model_get( model, iter, FC_INDEX, &i, -1 );
-            g_array_append_val( data->array, i );
+            gtk_tree_model_get (model, iter, FC_INDEX, &i, -1);
+            g_array_append_val (data->array, i);
         }
     }
 
@@ -372,12 +372,12 @@ getSubtreeForeach( GtkTreeModel   * model,
 }
 
 static void
-getSubtree( GtkTreeView * view, GtkTreePath * path, GArray * indices )
+getSubtree (GtkTreeView * view, GtkTreePath * path, GArray * indices)
 {
     struct SubtreeForeachData tmp;
     tmp.array = indices;
     tmp.path = path;
-    gtk_tree_model_foreach( gtk_tree_view_get_model( view ), getSubtreeForeach, &tmp );
+    gtk_tree_model_foreach (gtk_tree_view_get_model (view), getSubtreeForeach, &tmp);
 }
 
 /* if `path' is a selected row, all selected rows are returned.
@@ -385,21 +385,21 @@ getSubtree( GtkTreeView * view, GtkTreePath * path, GArray * indices )
  * this is for toggling all the selected rows' states in a batch.
  */
 static GArray*
-getActiveFilesForPath( GtkTreeView * view, GtkTreePath * path )
+getActiveFilesForPath (GtkTreeView * view, GtkTreePath * path)
 {
     GArray * indices;
-    GtkTreeSelection * sel = gtk_tree_view_get_selection( view );
+    GtkTreeSelection * sel = gtk_tree_view_get_selection (view);
 
-    if( gtk_tree_selection_path_is_selected( sel, path ) )
+    if (gtk_tree_selection_path_is_selected (sel, path))
     {
         /* clicked in a selected row... use the current selection */
-        indices = getSelectedFilesAndDescendants( view );
+        indices = getSelectedFilesAndDescendants (view);
     }
     else
     {
         /* clicked OUTSIDE of the selected row... just use the clicked row */
-        indices = g_array_new( FALSE, FALSE, sizeof( tr_file_index_t ) );
-        getSubtree( view, path, indices );
+        indices = g_array_new (FALSE, FALSE, sizeof (tr_file_index_t));
+        getSubtree (view, path, indices);
     }
 
     return indices;
@@ -410,9 +410,9 @@ getActiveFilesForPath( GtkTreeView * view, GtkTreePath * path )
 ***/
 
 void
-gtr_file_list_clear( GtkWidget * w )
+gtr_file_list_clear (GtkWidget * w)
 {
-    gtr_file_list_set_torrent( w, -1 );
+    gtr_file_list_set_torrent (w, -1);
 }
 
 struct build_data
@@ -431,7 +431,7 @@ struct row_struct
 };
 
 static void
-buildTree( GNode * node, gpointer gdata )
+buildTree (GNode * node, gpointer gdata)
 {
     char size_str[64];
     GtkTreeIter child_iter;
@@ -439,16 +439,16 @@ buildTree( GNode * node, gpointer gdata )
     struct row_struct *child_data = node->data;
     const gboolean isLeaf = node->children == NULL;
 
-    const char * mime_type = isLeaf ? gtr_get_mime_type_from_filename( child_data->name ) : DIRECTORY_MIME_TYPE;
-    GdkPixbuf * icon = gtr_get_mime_type_icon( mime_type, GTK_ICON_SIZE_MENU, build->w );
-    const tr_info * inf = tr_torrentInfo( build->tor );
+    const char * mime_type = isLeaf ? gtr_get_mime_type_from_filename (child_data->name) : DIRECTORY_MIME_TYPE;
+    GdkPixbuf * icon = gtr_get_mime_type_icon (mime_type, GTK_ICON_SIZE_MENU, build->w);
+    const tr_info * inf = tr_torrentInfo (build->tor);
     const int priority = isLeaf ? inf->files[ child_data->index ].priority : 0;
     const gboolean enabled = isLeaf ? !inf->files[ child_data->index ].dnd : TRUE;
-    char * name_esc = g_markup_escape_text( child_data->name, -1 );
+    char * name_esc = g_markup_escape_text (child_data->name, -1);
 
-    tr_strlsize( size_str, child_data->length, sizeof size_str );
+    tr_strlsize (size_str, child_data->length, sizeof size_str);
 
-    gtk_tree_store_insert_with_values( build->store, &child_iter, build->iter, INT_MAX,
+    gtk_tree_store_insert_with_values (build->store, &child_iter, build->iter, INT_MAX,
                                        FC_INDEX, child_data->index,
                                        FC_LABEL, child_data->name,
                                        FC_LABEL_ESC, name_esc,
@@ -457,30 +457,30 @@ buildTree( GNode * node, gpointer gdata )
                                        FC_ICON, icon,
                                        FC_PRIORITY, priority,
                                        FC_ENABLED, enabled,
-                                       -1 );
+                                       -1);
 
-    if( !isLeaf )
+    if (!isLeaf)
     {
         struct build_data b = *build;
         b.iter = &child_iter;
-        g_node_children_foreach( node, G_TRAVERSE_ALL, buildTree, &b );
+        g_node_children_foreach (node, G_TRAVERSE_ALL, buildTree, &b);
     }
 
-    g_free( name_esc );
-    g_object_unref( icon );
+    g_free (name_esc);
+    g_object_unref (icon);
 
     /* we're done with this node */
-    g_free( child_data->name );
-    g_free( child_data );
+    g_free (child_data->name);
+    g_free (child_data);
 }
 
 static GNode*
-find_child( GNode* parent, const char * name )
+find_child (GNode* parent, const char * name)
 {
     GNode * child = parent->children;
-    while( child ) {
+    while (child) {
         const struct row_struct * child_data = child->data;
-        if( ( *child_data->name == *name ) && !strcmp( child_data->name, name ) )
+        if ((*child_data->name == *name) && !strcmp (child_data->name, name))
             break;
         child = child->next;
     }
@@ -488,16 +488,16 @@ find_child( GNode* parent, const char * name )
 }
 
 void
-gtr_file_list_set_torrent( GtkWidget * w, int torrentId )
+gtr_file_list_set_torrent (GtkWidget * w, int torrentId)
 {
     GtkTreeStore * store;
-    FileData * data = g_object_get_data( G_OBJECT( w ), "file-data" );
+    FileData * data = g_object_get_data (G_OBJECT (w), "file-data");
 
     /* unset the old fields */
-    clearData( data );
+    clearData (data);
 
     /* instantiate the model */
-    store = gtk_tree_store_new ( N_FILE_COLS,
+    store = gtk_tree_store_new (N_FILE_COLS,
                                  GDK_TYPE_PIXBUF,  /* icon */
                                  G_TYPE_STRING,    /* label */
                                  G_TYPE_STRING,    /* label esc */
@@ -507,50 +507,50 @@ gtr_file_list_set_torrent( GtkWidget * w, int torrentId )
                                  G_TYPE_STRING,    /* size str */
                                  G_TYPE_UINT64,    /* have */
                                  G_TYPE_INT,       /* priority */
-                                 G_TYPE_INT );     /* dl enabled */
+                                 G_TYPE_INT);     /* dl enabled */
 
     data->store = store;
-    data->model = GTK_TREE_MODEL( store );
+    data->model = GTK_TREE_MODEL (store);
     data->torrentId = torrentId;
 
     /* populate the model */
-    if( torrentId > 0 )
+    if (torrentId > 0)
     {
-        tr_torrent * tor = gtr_core_find_torrent( data->core, torrentId );
-        if( tor != NULL )
+        tr_torrent * tor = gtr_core_find_torrent (data->core, torrentId);
+        if (tor != NULL)
         {
             tr_file_index_t i;
-            const tr_info * inf = tr_torrentInfo( tor );
+            const tr_info * inf = tr_torrentInfo (tor);
             struct row_struct * root_data;
             GNode * root;
             struct build_data build;
 
             /* build a GNode tree of the files */
-            root_data = g_new0( struct row_struct, 1 );
-            root_data->name = g_strdup( tr_torrentName( tor ) );
+            root_data = g_new0 (struct row_struct, 1);
+            root_data->name = g_strdup (tr_torrentName (tor));
             root_data->index = -1;
             root_data->length = 0;
-            root = g_node_new( root_data );
-            for( i=0; i<inf->fileCount; ++i ) {
+            root = g_node_new (root_data);
+            for (i=0; i<inf->fileCount; ++i) {
                 int j;
                 GNode * parent = root;
                 const tr_file * file = &inf->files[i];
-                char ** tokens = g_strsplit( file->name, G_DIR_SEPARATOR_S, 0 );
-                for( j=0; tokens[j]; ++j ) {
+                char ** tokens = g_strsplit (file->name, G_DIR_SEPARATOR_S, 0);
+                for (j=0; tokens[j]; ++j) {
                     const gboolean isLeaf = tokens[j+1] == NULL;
                     const char * name = tokens[j];
-                    GNode * node = find_child( parent, name );
-                    if( node == NULL ) {
-                        struct row_struct * row = g_new( struct row_struct, 1 );
-                        row->name = g_strdup( name );
+                    GNode * node = find_child (parent, name);
+                    if (node == NULL) {
+                        struct row_struct * row = g_new (struct row_struct, 1);
+                        row->name = g_strdup (name);
                         row->index = isLeaf ? (int)i : -1;
                         row->length = isLeaf ? file->length : 0;
-                        node = g_node_new( row );
-                        g_node_append( parent, node );
+                        node = g_node_new (row);
+                        g_node_append (parent, node);
                     }
                     parent = node;
                 }
-                g_strfreev( tokens );
+                g_strfreev (tokens);
             }
 
             /* now, add them to the model */
@@ -558,21 +558,21 @@ gtr_file_list_set_torrent( GtkWidget * w, int torrentId )
             build.tor = tor;
             build.store = data->store;
             build.iter = NULL;
-            g_node_children_foreach( root, G_TRAVERSE_ALL, buildTree, &build );
+            g_node_children_foreach (root, G_TRAVERSE_ALL, buildTree, &build);
 
             /* cleanup */
-            g_node_destroy( root );
-            g_free( root_data->name );
-            g_free( root_data );
+            g_node_destroy (root);
+            g_free (root_data->name);
+            g_free (root_data);
         }
 
-        refresh( data );
-        data->timeout_tag = gdk_threads_add_timeout_seconds( SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS, refreshModel, data );
+        refresh (data);
+        data->timeout_tag = gdk_threads_add_timeout_seconds (SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS, refreshModel, data);
     }
 
-    gtk_tree_view_set_model( GTK_TREE_VIEW( data->view ), data->model );
-    gtk_tree_view_expand_all( GTK_TREE_VIEW( data->view ) );
-    g_object_unref( data->model );
+    gtk_tree_view_set_model (GTK_TREE_VIEW (data->view), data->model);
+    gtk_tree_view_expand_all (GTK_TREE_VIEW (data->view));
+    g_object_unref (data->model);
 }
 
 /***
@@ -580,89 +580,89 @@ gtr_file_list_set_torrent( GtkWidget * w, int torrentId )
 ***/
 
 static void
-renderDownload( GtkTreeViewColumn  * column UNUSED,
+renderDownload (GtkTreeViewColumn  * column UNUSED,
                 GtkCellRenderer    * renderer,
                 GtkTreeModel       * model,
                 GtkTreeIter        * iter,
-                gpointer             data   UNUSED )
+                gpointer             data   UNUSED)
 {
     gboolean enabled;
-    gtk_tree_model_get( model, iter, FC_ENABLED, &enabled, -1 );
-    g_object_set( renderer, "inconsistent", (enabled==MIXED),
+    gtk_tree_model_get (model, iter, FC_ENABLED, &enabled, -1);
+    g_object_set (renderer, "inconsistent", (enabled==MIXED),
                             "active", (enabled==TRUE),
-                            NULL );
+                            NULL);
 }
 
 static void
-renderPriority( GtkTreeViewColumn  * column UNUSED,
+renderPriority (GtkTreeViewColumn  * column UNUSED,
                 GtkCellRenderer    * renderer,
                 GtkTreeModel       * model,
                 GtkTreeIter        * iter,
-                gpointer             data   UNUSED )
+                gpointer             data   UNUSED)
 {
     int priority;
     const char * text;
-    gtk_tree_model_get( model, iter, FC_PRIORITY, &priority, -1 );
-    switch( priority ) {
-        case TR_PRI_HIGH:   text = _( "High" ); break;
-        case TR_PRI_NORMAL: text = _( "Normal" ); break;
-        case TR_PRI_LOW:    text = _( "Low" ); break;
-        default:            text = _( "Mixed" ); break;
+    gtk_tree_model_get (model, iter, FC_PRIORITY, &priority, -1);
+    switch (priority) {
+        case TR_PRI_HIGH:   text = _("High"); break;
+        case TR_PRI_NORMAL: text = _("Normal"); break;
+        case TR_PRI_LOW:    text = _("Low"); break;
+        default:            text = _("Mixed"); break;
     }
-    g_object_set( renderer, "text", text, NULL );
+    g_object_set (renderer, "text", text, NULL);
 }
 
-/* build a filename from tr_torrentGetCurrentDir() + the model's FC_LABELs */
+/* build a filename from tr_torrentGetCurrentDir () + the model's FC_LABELs */
 static char*
-buildFilename( tr_torrent * tor, GtkTreeModel * model,
-               GtkTreePath * path, GtkTreeIter * iter )
+buildFilename (tr_torrent * tor, GtkTreeModel * model,
+               GtkTreePath * path, GtkTreeIter * iter)
 {
     char * ret;
     GtkTreeIter child;
     GtkTreeIter parent = *iter;
-    int n = gtk_tree_path_get_depth( path );
-    char ** tokens = g_new0( char*, n + 2 );
-    tokens[0] = g_strdup( tr_torrentGetCurrentDir( tor ) );
+    int n = gtk_tree_path_get_depth (path);
+    char ** tokens = g_new0 (char*, n + 2);
+    tokens[0] = g_strdup (tr_torrentGetCurrentDir (tor));
     do {
         child = parent;
-        gtk_tree_model_get( model, &child, FC_LABEL, &tokens[n--], -1 );
-    } while( gtk_tree_model_iter_parent( model, &parent, &child ) );
-    ret = g_build_filenamev( tokens );
-    g_strfreev( tokens );
+        gtk_tree_model_get (model, &child, FC_LABEL, &tokens[n--], -1);
+    } while (gtk_tree_model_iter_parent (model, &parent, &child));
+    ret = g_build_filenamev (tokens);
+    g_strfreev (tokens);
     return ret;
 }
 
 static gboolean
-onRowActivated( GtkTreeView * view, GtkTreePath * path,
-                GtkTreeViewColumn * col UNUSED, gpointer gdata )
+onRowActivated (GtkTreeView * view, GtkTreePath * path,
+                GtkTreeViewColumn * col UNUSED, gpointer gdata)
 {
     gboolean handled = FALSE;
     FileData * data = gdata;
-    tr_torrent * tor = gtr_core_find_torrent( data->core, data->torrentId );
+    tr_torrent * tor = gtr_core_find_torrent (data->core, data->torrentId);
 
-    if( tor != NULL )
+    if (tor != NULL)
     {
         GtkTreeIter iter;
-        GtkTreeModel * model = gtk_tree_view_get_model( view );
+        GtkTreeModel * model = gtk_tree_view_get_model (view);
 
-        if( gtk_tree_model_get_iter( model, &iter, path ) )
+        if (gtk_tree_model_get_iter (model, &iter, path))
         {
             int prog;
-            char * filename = buildFilename( tor, model, path, &iter );
-            gtk_tree_model_get( model, &iter, FC_PROG, &prog, -1 );
+            char * filename = buildFilename (tor, model, path, &iter);
+            gtk_tree_model_get (model, &iter, FC_PROG, &prog, -1);
 
             /* if the file's not done, walk up the directory tree until we find
              * an ancestor that exists, and open that instead */
-            if( filename && ( prog<100 || !g_file_test( filename, G_FILE_TEST_EXISTS ) ) ) do
+            if (filename && (prog<100 || !g_file_test (filename, G_FILE_TEST_EXISTS))) do
             {
-                char * tmp = g_path_get_dirname( filename );
-                g_free( filename );
+                char * tmp = g_path_get_dirname (filename);
+                g_free (filename);
                 filename = tmp;
             }
-            while( filename && *filename && !g_file_test( filename, G_FILE_TEST_EXISTS ) );
+            while (filename && *filename && !g_file_test (filename, G_FILE_TEST_EXISTS));
 
-            if(( handled = filename && *filename ))
-                gtr_open_file( filename );
+            if ((handled = filename && *filename))
+                gtr_open_file (filename);
         }
     }
 
@@ -670,56 +670,56 @@ onRowActivated( GtkTreeView * view, GtkTreePath * path,
 }
 
 static gboolean
-onViewPathToggled( GtkTreeView       * view,
+onViewPathToggled (GtkTreeView       * view,
                    GtkTreeViewColumn * col,
                    GtkTreePath       * path,
-                   FileData          * data )
+                   FileData          * data)
 {
     int cid;
     tr_torrent * tor;
     gboolean handled = FALSE;
 
-    if( !col || !path )
+    if (!col || !path)
         return FALSE;
 
-    cid = GPOINTER_TO_INT( g_object_get_data( G_OBJECT( col ), TR_COLUMN_ID_KEY ) );
-    tor = gtr_core_find_torrent( data->core, data->torrentId );
-    if( ( tor != NULL ) && ( ( cid == FC_PRIORITY ) || ( cid == FC_ENABLED ) ) )
+    cid = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (col), TR_COLUMN_ID_KEY));
+    tor = gtr_core_find_torrent (data->core, data->torrentId);
+    if ((tor != NULL) && ((cid == FC_PRIORITY) || (cid == FC_ENABLED)))
     {
         GtkTreeIter iter;
-        GArray * indices = getActiveFilesForPath( view, path );
+        GArray * indices = getActiveFilesForPath (view, path);
         GtkTreeModel * model = data->model;
 
-        gtk_tree_model_get_iter( model, &iter, path );
+        gtk_tree_model_get_iter (model, &iter, path);
 
-        if( cid == FC_PRIORITY )
+        if (cid == FC_PRIORITY)
         {
             int priority;
-            gtk_tree_model_get( model, &iter, FC_PRIORITY, &priority, -1 );
-            switch( priority ) {
+            gtk_tree_model_get (model, &iter, FC_PRIORITY, &priority, -1);
+            switch (priority) {
                 case TR_PRI_NORMAL: priority = TR_PRI_HIGH; break;
                 case TR_PRI_HIGH:   priority = TR_PRI_LOW; break;
                 default:            priority = TR_PRI_NORMAL; break;
             }
-            tr_torrentSetFilePriorities( tor,
-                                         (tr_file_index_t *) indices->data,
-                                         (tr_file_index_t) indices->len,
-                                         priority );
+            tr_torrentSetFilePriorities (tor,
+                                       (tr_file_index_t *) indices->data,
+                                       (tr_file_index_t) indices->len,
+                                         priority);
         }
         else
         {
             int enabled;
-            gtk_tree_model_get( model, &iter, FC_ENABLED, &enabled, -1 );
+            gtk_tree_model_get (model, &iter, FC_ENABLED, &enabled, -1);
             enabled = !enabled;
 
-            tr_torrentSetFileDLs( tor,
-                                  (tr_file_index_t *) indices->data,
-                                  (tr_file_index_t) indices->len,
-                                  enabled );
+            tr_torrentSetFileDLs (tor,
+                                (tr_file_index_t *) indices->data,
+                                (tr_file_index_t) indices->len,
+                                  enabled);
         }
 
-        refresh( data );
-        g_array_free( indices, TRUE );
+        refresh (data);
+        g_array_free (indices, TRUE);
         handled = TRUE;
     }
 
@@ -730,22 +730,22 @@ onViewPathToggled( GtkTreeView       * view,
  * @note 'col' and 'path' are assumed not to be NULL.
  */
 static gboolean
-getAndSelectEventPath( GtkTreeView        * treeview,
+getAndSelectEventPath (GtkTreeView        * treeview,
                        GdkEventButton     * event,
                        GtkTreeViewColumn ** col,
-                       GtkTreePath       ** path )
+                       GtkTreePath       ** path)
 {
     GtkTreeSelection * sel;
 
-    if( gtk_tree_view_get_path_at_pos( treeview,
+    if (gtk_tree_view_get_path_at_pos (treeview,
                                        event->x, event->y,
-                                       path, col, NULL, NULL ) )
+                                       path, col, NULL, NULL))
     {
-        sel = gtk_tree_view_get_selection( treeview );
-        if( !gtk_tree_selection_path_is_selected( sel, *path ) )
+        sel = gtk_tree_view_get_selection (treeview);
+        if (!gtk_tree_selection_path_is_selected (sel, *path))
         {
-            gtk_tree_selection_unselect_all( sel );
-            gtk_tree_selection_select_path( sel, *path );
+            gtk_tree_selection_unselect_all (sel);
+            gtk_tree_selection_select_path (sel, *path);
         }
         return TRUE;
     }
@@ -754,30 +754,30 @@ getAndSelectEventPath( GtkTreeView        * treeview,
 }
 
 static gboolean
-onViewButtonPressed( GtkWidget * w, GdkEventButton * event, gpointer gdata )
+onViewButtonPressed (GtkWidget * w, GdkEventButton * event, gpointer gdata)
 {
     GtkTreeViewColumn * col;
     GtkTreePath * path = NULL;
     gboolean handled = FALSE;
-    GtkTreeView * treeview = GTK_TREE_VIEW( w );
+    GtkTreeView * treeview = GTK_TREE_VIEW (w);
     FileData * data = gdata;
 
-    if( ( event->type == GDK_BUTTON_PRESS )
-         && ( event->button == 1 )
-         && !( event->state & ( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) )
-         && getAndSelectEventPath( treeview, event, &col, &path ) )
+    if ((event->type == GDK_BUTTON_PRESS)
+         && (event->button == 1)
+         && ! (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK))
+         && getAndSelectEventPath (treeview, event, &col, &path))
     {
-        handled = onViewPathToggled( treeview, col, path, data );
+        handled = onViewPathToggled (treeview, col, path, data);
 
-        if( path != NULL )
-            gtk_tree_path_free( path );
+        if (path != NULL)
+            gtk_tree_path_free (path);
     }
 
     return handled;
 }
 
 GtkWidget *
-gtr_file_list_new( TrCore * core, int torrentId )
+gtr_file_list_new (TrCore * core, int torrentId)
 {
     int size;
     int width;
@@ -792,132 +792,132 @@ gtr_file_list_new( TrCore * core, int torrentId )
     PangoLayout * pango_layout;
     PangoContext * pango_context;
     PangoFontDescription * pango_font_description;
-    FileData * data = g_new0( FileData, 1 );
+    FileData * data = g_new0 (FileData, 1);
 
     data->core = core;
 
     /* create the view */
-    view = gtk_tree_view_new( );
-    tree_view = GTK_TREE_VIEW( view );
-    gtk_tree_view_set_rules_hint( tree_view, TRUE );
-    gtk_container_set_border_width( GTK_CONTAINER( view ), GUI_PAD_BIG );
-    g_signal_connect( view, "button-press-event",
-                      G_CALLBACK( onViewButtonPressed ), data );
-    g_signal_connect( view, "row_activated",
-                      G_CALLBACK( onRowActivated ), data );
-    g_signal_connect( view, "button-release-event",
-                      G_CALLBACK( on_tree_view_button_released ), NULL );
-
-
-    pango_context = gtk_widget_create_pango_context( view );
-    pango_font_description = pango_font_description_copy( pango_context_get_font_description( pango_context ) );
-    size = pango_font_description_get_size( pango_font_description );
-    pango_font_description_set_size( pango_font_description, size * 0.8 );
-    g_object_unref( G_OBJECT( pango_context ) );
+    view = gtk_tree_view_new ();
+    tree_view = GTK_TREE_VIEW (view);
+    gtk_tree_view_set_rules_hint (tree_view, TRUE);
+    gtk_container_set_border_width (GTK_CONTAINER (view), GUI_PAD_BIG);
+    g_signal_connect (view, "button-press-event",
+                      G_CALLBACK (onViewButtonPressed), data);
+    g_signal_connect (view, "row_activated",
+                      G_CALLBACK (onRowActivated), data);
+    g_signal_connect (view, "button-release-event",
+                      G_CALLBACK (on_tree_view_button_released), NULL);
+
+
+    pango_context = gtk_widget_create_pango_context (view);
+    pango_font_description = pango_font_description_copy (pango_context_get_font_description (pango_context));
+    size = pango_font_description_get_size (pango_font_description);
+    pango_font_description_set_size (pango_font_description, size * 0.8);
+    g_object_unref (G_OBJECT (pango_context));
 
     /* set up view */
-    sel = gtk_tree_view_get_selection( tree_view );
-    gtk_tree_selection_set_mode( sel, GTK_SELECTION_MULTIPLE );
-    gtk_tree_view_expand_all( tree_view );
-    gtk_tree_view_set_search_column( tree_view, FC_LABEL );
+    sel = gtk_tree_view_get_selection (tree_view);
+    gtk_tree_selection_set_mode (sel, GTK_SELECTION_MULTIPLE);
+    gtk_tree_view_expand_all (tree_view);
+    gtk_tree_view_set_search_column (tree_view, FC_LABEL);
 
     /* add file column */
-    col = GTK_TREE_VIEW_COLUMN ( g_object_new ( GTK_TYPE_TREE_VIEW_COLUMN,
+    col = GTK_TREE_VIEW_COLUMN (g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
                                                 "expand", TRUE,
-                                                "title", _( "Name" ),
-                                                NULL ) );
-    gtk_tree_view_column_set_resizable( col, TRUE );
-    rend = gtk_cell_renderer_pixbuf_new( );
-    gtk_tree_view_column_pack_start( col, rend, FALSE );
-    gtk_tree_view_column_add_attribute( col, rend, "pixbuf", FC_ICON );
+                                                "title", _("Name"),
+                                                NULL));
+    gtk_tree_view_column_set_resizable (col, TRUE);
+    rend = gtk_cell_renderer_pixbuf_new ();
+    gtk_tree_view_column_pack_start (col, rend, FALSE);
+    gtk_tree_view_column_add_attribute (col, rend, "pixbuf", FC_ICON);
     /* add text renderer */
-    rend = gtk_cell_renderer_text_new( );
-    g_object_set( rend, "ellipsize", PANGO_ELLIPSIZE_END, "font-desc", pango_font_description, NULL );
-    gtk_tree_view_column_pack_start( col, rend, TRUE );
-    gtk_tree_view_column_set_attributes( col, rend, "text", FC_LABEL, NULL );
-    gtk_tree_view_column_set_sort_column_id( col, FC_LABEL );
-    gtk_tree_view_append_column( tree_view, col );
+    rend = gtk_cell_renderer_text_new ();
+    g_object_set (rend, "ellipsize", PANGO_ELLIPSIZE_END, "font-desc", pango_font_description, NULL);
+    gtk_tree_view_column_pack_start (col, rend, TRUE);
+    gtk_tree_view_column_set_attributes (col, rend, "text", FC_LABEL, NULL);
+    gtk_tree_view_column_set_sort_column_id (col, FC_LABEL);
+    gtk_tree_view_append_column (tree_view, col);
 
     /* add "size" column */
-    title = _( "Size" );
-    rend = gtk_cell_renderer_text_new( );
-    g_object_set( rend, "alignment", PANGO_ALIGN_RIGHT,
+    title = _("Size");
+    rend = gtk_cell_renderer_text_new ();
+    g_object_set (rend, "alignment", PANGO_ALIGN_RIGHT,
                         "font-desc", pango_font_description,
                         "xpad", GUI_PAD,
                         "xalign", 1.0f,
                         "yalign", 0.5f,
-                        NULL );
-    col = gtk_tree_view_column_new_with_attributes( title, rend, NULL );
-    gtk_tree_view_column_set_sizing( col, GTK_TREE_VIEW_COLUMN_GROW_ONLY );
-    gtk_tree_view_column_set_sort_column_id( col, FC_SIZE );
-    gtk_tree_view_column_set_attributes( col, rend, "text", FC_SIZE_STR, NULL );
-    gtk_tree_view_append_column( tree_view, col );
+                        NULL);
+    col = gtk_tree_view_column_new_with_attributes (title, rend, NULL);
+    gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
+    gtk_tree_view_column_set_sort_column_id (col, FC_SIZE);
+    gtk_tree_view_column_set_attributes (col, rend, "text", FC_SIZE_STR, NULL);
+    gtk_tree_view_append_column (tree_view, col);
 
     /* add "progress" column */
-    title = _( "Have" );
-    pango_layout = gtk_widget_create_pango_layout( view, title );
-    pango_layout_get_pixel_size( pango_layout, &width, NULL );
+    title = _("Have");
+    pango_layout = gtk_widget_create_pango_layout (view, title);
+    pango_layout_get_pixel_size (pango_layout, &width, NULL);
     width += 30; /* room for the sort indicator */
-    g_object_unref( G_OBJECT( pango_layout ) );
-    rend = gtk_cell_renderer_progress_new( );
-    col = gtk_tree_view_column_new_with_attributes( title, rend, "value", FC_PROG, NULL );
-    gtk_tree_view_column_set_fixed_width( col, width );
-    gtk_tree_view_column_set_sizing( col, GTK_TREE_VIEW_COLUMN_FIXED );
-    gtk_tree_view_column_set_sort_column_id( col, FC_PROG );
-    gtk_tree_view_append_column( tree_view, col );
+    g_object_unref (G_OBJECT (pango_layout));
+    rend = gtk_cell_renderer_progress_new ();
+    col = gtk_tree_view_column_new_with_attributes (title, rend, "value", FC_PROG, NULL);
+    gtk_tree_view_column_set_fixed_width (col, width);
+    gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
+    gtk_tree_view_column_set_sort_column_id (col, FC_PROG);
+    gtk_tree_view_append_column (tree_view, col);
 
     /* add "enabled" column */
-    title = _( "Download" );
-    pango_layout = gtk_widget_create_pango_layout( view, title );
-    pango_layout_get_pixel_size( pango_layout, &width, NULL );
+    title = _("Download");
+    pango_layout = gtk_widget_create_pango_layout (view, title);
+    pango_layout_get_pixel_size (pango_layout, &width, NULL);
     width += 30; /* room for the sort indicator */
-    g_object_unref( G_OBJECT( pango_layout ) );
-    rend = gtk_cell_renderer_toggle_new( );
-    col = gtk_tree_view_column_new_with_attributes( title, rend, NULL );
-    g_object_set_data( G_OBJECT( col ), TR_COLUMN_ID_KEY,
-                       GINT_TO_POINTER( FC_ENABLED ) );
-    gtk_tree_view_column_set_fixed_width( col, width );
-    gtk_tree_view_column_set_sizing( col, GTK_TREE_VIEW_COLUMN_FIXED );
-    gtk_tree_view_column_set_cell_data_func( col, rend, renderDownload, NULL, NULL );
-    gtk_tree_view_column_set_sort_column_id( col, FC_ENABLED );
-    gtk_tree_view_append_column( tree_view, col );
+    g_object_unref (G_OBJECT (pango_layout));
+    rend = gtk_cell_renderer_toggle_new ();
+    col = gtk_tree_view_column_new_with_attributes (title, rend, NULL);
+    g_object_set_data (G_OBJECT (col), TR_COLUMN_ID_KEY,
+                       GINT_TO_POINTER (FC_ENABLED));
+    gtk_tree_view_column_set_fixed_width (col, width);
+    gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
+    gtk_tree_view_column_set_cell_data_func (col, rend, renderDownload, NULL, NULL);
+    gtk_tree_view_column_set_sort_column_id (col, FC_ENABLED);
+    gtk_tree_view_append_column (tree_view, col);
 
     /* add priority column */
-    title = _( "Priority" );
-    pango_layout = gtk_widget_create_pango_layout( view, title );
-    pango_layout_get_pixel_size( pango_layout, &width, NULL );
+    title = _("Priority");
+    pango_layout = gtk_widget_create_pango_layout (view, title);
+    pango_layout_get_pixel_size (pango_layout, &width, NULL);
     width += 30; /* room for the sort indicator */
-    g_object_unref( G_OBJECT( pango_layout ) );
-    rend = gtk_cell_renderer_text_new( );
-    g_object_set( rend, "xalign", (gfloat)0.5, "yalign", (gfloat)0.5, NULL );
-    col = gtk_tree_view_column_new_with_attributes( title, rend, NULL );
-    g_object_set_data( G_OBJECT( col ), TR_COLUMN_ID_KEY,
-                       GINT_TO_POINTER( FC_PRIORITY ) );
-    gtk_tree_view_column_set_fixed_width( col, width );
-    gtk_tree_view_column_set_sizing( col, GTK_TREE_VIEW_COLUMN_FIXED );
-    gtk_tree_view_column_set_sort_column_id( col, FC_PRIORITY );
-    gtk_tree_view_column_set_cell_data_func( col, rend, renderPriority, NULL, NULL );
-    gtk_tree_view_append_column( tree_view, col );
+    g_object_unref (G_OBJECT (pango_layout));
+    rend = gtk_cell_renderer_text_new ();
+    g_object_set (rend, "xalign", (gfloat)0.5, "yalign", (gfloat)0.5, NULL);
+    col = gtk_tree_view_column_new_with_attributes (title, rend, NULL);
+    g_object_set_data (G_OBJECT (col), TR_COLUMN_ID_KEY,
+                       GINT_TO_POINTER (FC_PRIORITY));
+    gtk_tree_view_column_set_fixed_width (col, width);
+    gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
+    gtk_tree_view_column_set_sort_column_id (col, FC_PRIORITY);
+    gtk_tree_view_column_set_cell_data_func (col, rend, renderPriority, NULL, NULL);
+    gtk_tree_view_append_column (tree_view, col);
 
     /* add tooltip to tree */
-    gtk_tree_view_set_tooltip_column( tree_view, FC_LABEL_ESC );
+    gtk_tree_view_set_tooltip_column (tree_view, FC_LABEL_ESC);
 
     /* create the scrolled window and stick the view in it */
-    scroll = gtk_scrolled_window_new( NULL, NULL );
-    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scroll ),
+    scroll = gtk_scrolled_window_new (NULL, NULL);
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
                                     GTK_POLICY_AUTOMATIC,
-                                    GTK_POLICY_AUTOMATIC );
-    gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW( scroll ),
-                                          GTK_SHADOW_IN );
-    gtk_container_add( GTK_CONTAINER( scroll ), view );
-    gtk_widget_set_size_request ( scroll, -1, 200 );
+                                    GTK_POLICY_AUTOMATIC);
+    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
+                                          GTK_SHADOW_IN);
+    gtk_container_add (GTK_CONTAINER (scroll), view);
+    gtk_widget_set_size_request (scroll, -1, 200);
 
     ret = scroll;
     data->view = view;
     data->top = scroll;
-    g_object_set_data_full( G_OBJECT( ret ), "file-data", data, freeData );
-    gtr_file_list_set_torrent( ret, torrentId );
+    g_object_set_data_full (G_OBJECT (ret), "file-data", data, freeData);
+    gtr_file_list_set_torrent (ret, torrentId);
 
-    pango_font_description_free( pango_font_description );
+    pango_font_description_free (pango_font_description);
     return ret;
 }
diff --git a/gtk/file-list.h b/gtk/file-list.h
index 2682b7740..62485911d 100644
--- a/gtk/file-list.h
+++ b/gtk/file-list.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,8 +16,8 @@
 #include <gtk/gtk.h>
 #include "tr-core.h"
 
-GtkWidget * gtr_file_list_new         ( TrCore *, int torrent_id );
-void        gtr_file_list_clear       ( GtkWidget * );
-void        gtr_file_list_set_torrent ( GtkWidget *, int torrent_id );
+GtkWidget * gtr_file_list_new       (TrCore *, int torrent_id);
+void        gtr_file_list_clear     (GtkWidget *);
+void        gtr_file_list_set_torrent (GtkWidget *, int torrent_id);
 
 #endif
diff --git a/gtk/filter.c b/gtk/filter.c
index ddeaf3306..a4bf4d36f 100644
--- a/gtk/filter.c
+++ b/gtk/filter.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,7 +10,7 @@
  * $Id$
  */
 
-#include <stdlib.h> /* qsort() */
+#include <stdlib.h> /* qsort () */
 
 #include <gtk/gtk.h>
 #include <glib/gi18n.h>
@@ -18,11 +18,11 @@
 #include <libtransmission/transmission.h>
 #include <libtransmission/utils.h>
 
-#include "favicon.h" /* gtr_get_favicon() */
+#include "favicon.h" /* gtr_get_favicon () */
 #include "filter.h"
 #include "hig.h" /* GUI_PAD */
 #include "tr-core.h" /* MC_TORRENT */
-#include "util.h" /* gtr_get_host_from_url() */
+#include "util.h" /* gtr_get_host_from_url () */
 
 static GQuark DIRTY_KEY = 0;
 static GQuark SESSION_KEY = 0;
@@ -60,66 +60,66 @@ enum
 };
 
 static int
-pstrcmp( const void * a, const void * b )
+pstrcmp (const void * a, const void * b)
 {
-    return strcmp( *(const char**)a, *(const char**)b );
+    return strcmp (* (const char**)a, * (const char**)b);
 }
 
 /* human-readable name; ie, Legaltorrents */
 static char*
-get_name_from_host( const char * host )
+get_name_from_host (const char * host)
 {
     char * name;
-    const char * dot = strrchr( host, '.' );
+    const char * dot = strrchr (host, '.');
 
-    if( tr_addressIsIP( host ) )
-        name = g_strdup( host );
-    else if( dot )
-        name = g_strndup( host, dot - host );
+    if (tr_addressIsIP (host))
+        name = g_strdup (host);
+    else if (dot)
+        name = g_strndup (host, dot - host);
     else
-        name = g_strdup( host );
+        name = g_strdup (host);
 
-    *name = g_ascii_toupper( *name );
+    *name = g_ascii_toupper (*name);
 
     return name;
 }
 
 static void
-category_model_update_count( GtkTreeStore * store, GtkTreeIter * iter, int n )
+category_model_update_count (GtkTreeStore * store, GtkTreeIter * iter, int n)
 {
     int count;
-    GtkTreeModel * model = GTK_TREE_MODEL( store );
-    gtk_tree_model_get( model, iter, CAT_FILTER_COL_COUNT, &count, -1 );
-    if( n != count )
-        gtk_tree_store_set( store, iter, CAT_FILTER_COL_COUNT, n, -1 );
+    GtkTreeModel * model = GTK_TREE_MODEL (store);
+    gtk_tree_model_get (model, iter, CAT_FILTER_COL_COUNT, &count, -1);
+    if (n != count)
+        gtk_tree_store_set (store, iter, CAT_FILTER_COL_COUNT, n, -1);
 }
 
 static void
-favicon_ready_cb( gpointer pixbuf, gpointer vreference )
+favicon_ready_cb (gpointer pixbuf, gpointer vreference)
 {
     GtkTreeIter iter;
     GtkTreeRowReference * reference = vreference;
 
-    if( pixbuf != NULL )
+    if (pixbuf != NULL)
     {
-        GtkTreePath * path = gtk_tree_row_reference_get_path( reference );
-        GtkTreeModel * model = gtk_tree_row_reference_get_model( reference );
+        GtkTreePath * path = gtk_tree_row_reference_get_path (reference);
+        GtkTreeModel * model = gtk_tree_row_reference_get_model (reference);
 
-        if( gtk_tree_model_get_iter( model, &iter, path ) )
-            gtk_tree_store_set( GTK_TREE_STORE( model ), &iter,
+        if (gtk_tree_model_get_iter (model, &iter, path))
+            gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
                                 CAT_FILTER_COL_PIXBUF, pixbuf,
-                                -1 );
+                                -1);
 
-        gtk_tree_path_free( path );
+        gtk_tree_path_free (path);
 
-        g_object_unref( pixbuf );
+        g_object_unref (pixbuf);
     }
 
-    gtk_tree_row_reference_free( reference );
+    gtk_tree_row_reference_free (reference);
 }
 
 static gboolean
-category_filter_model_update( GtkTreeStore * store )
+category_filter_model_update (GtkTreeStore * store)
 {
     int i, n;
     int low = 0;
@@ -131,403 +131,403 @@ category_filter_model_update( GtkTreeStore * store )
     int store_pos;
     GtkTreeIter top;
     GtkTreeIter iter;
-    GtkTreeModel * model = GTK_TREE_MODEL( store );
-    GPtrArray * hosts = g_ptr_array_new( );
-    GStringChunk * strings = g_string_chunk_new( 4096 );
-    GHashTable * hosts_hash = g_hash_table_new_full( g_str_hash, g_str_equal, NULL, g_free );
-    GObject * o = G_OBJECT( store );
-    GtkTreeModel * tmodel = GTK_TREE_MODEL( g_object_get_qdata( o, TORRENT_MODEL_KEY ) );
+    GtkTreeModel * model = GTK_TREE_MODEL (store);
+    GPtrArray * hosts = g_ptr_array_new ();
+    GStringChunk * strings = g_string_chunk_new (4096);
+    GHashTable * hosts_hash = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
+    GObject * o = G_OBJECT (store);
+    GtkTreeModel * tmodel = GTK_TREE_MODEL (g_object_get_qdata (o, TORRENT_MODEL_KEY));
 
-    g_object_steal_qdata( o, DIRTY_KEY );
+    g_object_steal_qdata (o, DIRTY_KEY);
 
     /* Walk through all the torrents, tallying how many matches there are
      * for the various categories. Also make a sorted list of all tracker
      * hosts s.t. we can merge it with the existing list */
-    if( gtk_tree_model_iter_nth_child( tmodel, &iter, NULL, 0 ) ) do
+    if (gtk_tree_model_iter_nth_child (tmodel, &iter, NULL, 0)) do
     {
         tr_torrent * tor;
         const tr_info * inf;
         int keyCount;
         char ** keys;
 
-        gtk_tree_model_get( tmodel, &iter, MC_TORRENT, &tor, -1 );
-        inf = tr_torrentInfo( tor );
+        gtk_tree_model_get (tmodel, &iter, MC_TORRENT, &tor, -1);
+        inf = tr_torrentInfo (tor);
         keyCount = 0;
-        keys = g_new( char*, inf->trackerCount );
+        keys = g_new (char*, inf->trackerCount);
 
-        for( i=0, n=inf->trackerCount; i<n; ++i )
+        for (i=0, n=inf->trackerCount; i<n; ++i)
         {
             int k;
             int * count;
             char buf[1024];
             char * key;
 
-            gtr_get_host_from_url( buf, sizeof( buf ), inf->trackers[i].announce );
-            key = g_string_chunk_insert_const( strings, buf );
+            gtr_get_host_from_url (buf, sizeof (buf), inf->trackers[i].announce);
+            key = g_string_chunk_insert_const (strings, buf);
 
-            count = g_hash_table_lookup( hosts_hash, key );
-            if( count == NULL )
+            count = g_hash_table_lookup (hosts_hash, key);
+            if (count == NULL)
             {
-                count = tr_new0( int, 1 );
-                g_hash_table_insert( hosts_hash, key, count );
-                g_ptr_array_add( hosts, key );
+                count = tr_new0 (int, 1);
+                g_hash_table_insert (hosts_hash, key, count);
+                g_ptr_array_add (hosts, key);
             }
 
-            for( k=0; k<keyCount; ++k )
-                if( !strcmp( keys[k], key ) )
+            for (k=0; k<keyCount; ++k)
+                if (!strcmp (keys[k], key))
                     break;
-            if( k==keyCount )
+            if (k==keyCount)
                 keys[keyCount++] = key;
         }
 
-        for( i=0; i<keyCount; ++i )
+        for (i=0; i<keyCount; ++i)
         {
-            int * incrementme = g_hash_table_lookup( hosts_hash, keys[i] );
+            int * incrementme = g_hash_table_lookup (hosts_hash, keys[i]);
             ++*incrementme;
         }
-        g_free( keys );
+        g_free (keys);
 
         ++all;
 
-        if( inf->isPrivate )
+        if (inf->isPrivate)
             ++private;
         else
             ++public;
 
-        switch( tr_torrentGetPriority( tor ) )
+        switch (tr_torrentGetPriority (tor))
         {
             case TR_PRI_HIGH: ++high; break;
             case TR_PRI_LOW: ++low; break;
             default: ++normal; break;
         }
     }
-    while( gtk_tree_model_iter_next( tmodel, &iter ) );
-    qsort( hosts->pdata, hosts->len, sizeof(char*), pstrcmp );
+    while (gtk_tree_model_iter_next (tmodel, &iter));
+    qsort (hosts->pdata, hosts->len, sizeof (char*), pstrcmp);
 
     /* update the "all" count */
-    gtk_tree_model_iter_children( model, &top, NULL );
-    category_model_update_count( store, &top, all );
+    gtk_tree_model_iter_children (model, &top, NULL);
+    category_model_update_count (store, &top, all);
 
     /* skip separator */
-    gtk_tree_model_iter_next( model, &top );
+    gtk_tree_model_iter_next (model, &top);
 
     /* update the "hosts" subtree */
-    gtk_tree_model_iter_next( model, &top );
-    for( i=store_pos=0, n=hosts->len ; ; )
+    gtk_tree_model_iter_next (model, &top);
+    for (i=store_pos=0, n=hosts->len ; ;)
     {
         const gboolean new_hosts_done = i >= n;
-        const gboolean old_hosts_done = !gtk_tree_model_iter_nth_child( model, &iter, &top, store_pos );
+        const gboolean old_hosts_done = !gtk_tree_model_iter_nth_child (model, &iter, &top, store_pos);
         gboolean remove_row = FALSE;
         gboolean insert_row = FALSE;
 
         /* are we done yet? */
-        if( new_hosts_done && old_hosts_done )
+        if (new_hosts_done && old_hosts_done)
             break;
 
         /* decide what to do */
-        if( new_hosts_done )
+        if (new_hosts_done)
             remove_row = TRUE;
-        else if( old_hosts_done )
+        else if (old_hosts_done)
             insert_row = TRUE;
         else {
             int cmp;
             char * host;
-            gtk_tree_model_get( model, &iter, CAT_FILTER_COL_HOST, &host,  -1 );
-            cmp = strcmp( host, hosts->pdata[i] );
-            if( cmp < 0 )
+            gtk_tree_model_get (model, &iter, CAT_FILTER_COL_HOST, &host,  -1);
+            cmp = strcmp (host, hosts->pdata[i]);
+            if (cmp < 0)
                 remove_row = TRUE;
-            else if( cmp > 0 )
+            else if (cmp > 0)
                 insert_row = TRUE;
-            g_free( host );
+            g_free (host);
         }
 
         /* do something */
-        if( remove_row ) {
-            /* g_message( "removing row and incrementing i" ); */
-            gtk_tree_store_remove( store, &iter );
-        } else if( insert_row ) {
+        if (remove_row) {
+            /* g_message ("removing row and incrementing i"); */
+            gtk_tree_store_remove (store, &iter);
+        } else if (insert_row) {
             GtkTreeIter add;
             GtkTreePath * path;
             GtkTreeRowReference * reference;
-            tr_session * session = g_object_get_qdata( G_OBJECT( store ), SESSION_KEY );
+            tr_session * session = g_object_get_qdata (G_OBJECT (store), SESSION_KEY);
             const char * host = hosts->pdata[i];
-            char * name = get_name_from_host( host );
-            const int count = *(int*)g_hash_table_lookup( hosts_hash, host );
-            gtk_tree_store_insert_with_values( store, &add, &top, store_pos,
+            char * name = get_name_from_host (host);
+            const int count = * (int*)g_hash_table_lookup (hosts_hash, host);
+            gtk_tree_store_insert_with_values (store, &add, &top, store_pos,
                 CAT_FILTER_COL_HOST, host,
                 CAT_FILTER_COL_NAME, name,
                 CAT_FILTER_COL_COUNT, count,
                 CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_HOST,
-                -1 );
-            path = gtk_tree_model_get_path( model, &add );
-            reference = gtk_tree_row_reference_new( model, path );
-            gtr_get_favicon( session, host, favicon_ready_cb, reference );
-            gtk_tree_path_free( path );
-            g_free( name );
+                -1);
+            path = gtk_tree_model_get_path (model, &add);
+            reference = gtk_tree_row_reference_new (model, path);
+            gtr_get_favicon (session, host, favicon_ready_cb, reference);
+            gtk_tree_path_free (path);
+            g_free (name);
             ++store_pos;
             ++i;
         } else { /* update row */
             const char * host = hosts->pdata[i];
-            const int count = *(int*)g_hash_table_lookup( hosts_hash, host );
-            category_model_update_count( store, &iter, count );
+            const int count = * (int*)g_hash_table_lookup (hosts_hash, host);
+            category_model_update_count (store, &iter, count);
             ++store_pos;
             ++i;
         }
     }
 
     /* update the "public" subtree */
-    gtk_tree_model_iter_next( model, &top );
-    gtk_tree_model_iter_children( model, &iter, &top );
-    category_model_update_count( store, &iter, public );
-    gtk_tree_model_iter_next( model, &iter );
-    category_model_update_count( store, &iter, private );
+    gtk_tree_model_iter_next (model, &top);
+    gtk_tree_model_iter_children (model, &iter, &top);
+    category_model_update_count (store, &iter, public);
+    gtk_tree_model_iter_next (model, &iter);
+    category_model_update_count (store, &iter, private);
 
     /* update the "priority" subtree */
-    gtk_tree_model_iter_next( model, &top );
-    gtk_tree_model_iter_children( model, &iter, &top );
-    category_model_update_count( store, &iter, high );
-    gtk_tree_model_iter_next( model, &iter );
-    category_model_update_count( store, &iter, normal );
-    gtk_tree_model_iter_next( model, &iter );
-    category_model_update_count( store, &iter, low );
+    gtk_tree_model_iter_next (model, &top);
+    gtk_tree_model_iter_children (model, &iter, &top);
+    category_model_update_count (store, &iter, high);
+    gtk_tree_model_iter_next (model, &iter);
+    category_model_update_count (store, &iter, normal);
+    gtk_tree_model_iter_next (model, &iter);
+    category_model_update_count (store, &iter, low);
 
     /* cleanup */
-    g_ptr_array_free( hosts, TRUE );
-    g_hash_table_unref( hosts_hash );
-    g_string_chunk_free( strings );
+    g_ptr_array_free (hosts, TRUE);
+    g_hash_table_unref (hosts_hash);
+    g_string_chunk_free (strings);
     return FALSE;
 }
 
 static GtkTreeModel *
-category_filter_model_new( GtkTreeModel * tmodel )
+category_filter_model_new (GtkTreeModel * tmodel)
 {
     GtkTreeIter iter;
     const int invisible_number = -1; /* doesn't get rendered */
-    GtkTreeStore * store = gtk_tree_store_new( CAT_FILTER_N_COLS,
+    GtkTreeStore * store = gtk_tree_store_new (CAT_FILTER_N_COLS,
                                                G_TYPE_STRING,
                                                G_TYPE_INT,
                                                G_TYPE_INT,
                                                G_TYPE_STRING,
-                                               GDK_TYPE_PIXBUF );
+                                               GDK_TYPE_PIXBUF);
 
-    gtk_tree_store_insert_with_values( store, NULL, NULL, -1,
-        CAT_FILTER_COL_NAME, _( "All" ),
+    gtk_tree_store_insert_with_values (store, NULL, NULL, -1,
+        CAT_FILTER_COL_NAME, _("All"),
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_ALL,
-        -1 );
-    gtk_tree_store_insert_with_values( store, NULL, NULL, -1,
+        -1);
+    gtk_tree_store_insert_with_values (store, NULL, NULL, -1,
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_SEPARATOR,
-        -1 );
+        -1);
 
-    gtk_tree_store_insert_with_values( store, &iter, NULL, -1,
-        CAT_FILTER_COL_NAME, _( "Trackers" ),
+    gtk_tree_store_insert_with_values (store, &iter, NULL, -1,
+        CAT_FILTER_COL_NAME, _("Trackers"),
         CAT_FILTER_COL_COUNT, invisible_number,
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_PARENT,
-        -1 );
+        -1);
 
-    gtk_tree_store_insert_with_values( store, &iter, NULL, -1,
-        CAT_FILTER_COL_NAME, _( "Privacy" ),
+    gtk_tree_store_insert_with_values (store, &iter, NULL, -1,
+        CAT_FILTER_COL_NAME, _("Privacy"),
         CAT_FILTER_COL_COUNT, invisible_number,
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_PARENT,
-        -1 );
-    gtk_tree_store_insert_with_values( store, NULL, &iter, -1,
-        CAT_FILTER_COL_NAME, _( "Public" ),
+        -1);
+    gtk_tree_store_insert_with_values (store, NULL, &iter, -1,
+        CAT_FILTER_COL_NAME, _("Public"),
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_PUBLIC,
-        -1 );
-    gtk_tree_store_insert_with_values( store, NULL, &iter, -1,
-        CAT_FILTER_COL_NAME, _( "Private" ),
+        -1);
+    gtk_tree_store_insert_with_values (store, NULL, &iter, -1,
+        CAT_FILTER_COL_NAME, _("Private"),
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_PRIVATE,
-        -1 );
+        -1);
 
-    gtk_tree_store_insert_with_values( store, &iter, NULL, -1,
-        CAT_FILTER_COL_NAME, _( "Priority" ),
+    gtk_tree_store_insert_with_values (store, &iter, NULL, -1,
+        CAT_FILTER_COL_NAME, _("Priority"),
         CAT_FILTER_COL_COUNT, invisible_number,
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_PARENT,
-        -1 );
-    gtk_tree_store_insert_with_values( store, NULL, &iter, -1,
-        CAT_FILTER_COL_NAME, _( "High" ),
+        -1);
+    gtk_tree_store_insert_with_values (store, NULL, &iter, -1,
+        CAT_FILTER_COL_NAME, _("High"),
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_PRI_HIGH,
-        -1 );
-    gtk_tree_store_insert_with_values( store, NULL, &iter, -1,
-        CAT_FILTER_COL_NAME, _( "Normal" ),
+        -1);
+    gtk_tree_store_insert_with_values (store, NULL, &iter, -1,
+        CAT_FILTER_COL_NAME, _("Normal"),
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_PRI_NORMAL,
-        -1 );
-    gtk_tree_store_insert_with_values( store, NULL, &iter, -1,
-        CAT_FILTER_COL_NAME, _( "Low" ),
+        -1);
+    gtk_tree_store_insert_with_values (store, NULL, &iter, -1,
+        CAT_FILTER_COL_NAME, _("Low"),
         CAT_FILTER_COL_TYPE, CAT_FILTER_TYPE_PRI_LOW,
-        -1 );
+        -1);
 
-    g_object_set_qdata( G_OBJECT( store ), TORRENT_MODEL_KEY, tmodel );
-    category_filter_model_update( store );
-    return GTK_TREE_MODEL( store );
+    g_object_set_qdata (G_OBJECT (store), TORRENT_MODEL_KEY, tmodel);
+    category_filter_model_update (store);
+    return GTK_TREE_MODEL (store);
 }
 
 static gboolean
-is_it_a_separator( GtkTreeModel * m, GtkTreeIter * iter, gpointer data UNUSED )
+is_it_a_separator (GtkTreeModel * m, GtkTreeIter * iter, gpointer data UNUSED)
 {
     int type;
-    gtk_tree_model_get( m, iter, CAT_FILTER_COL_TYPE, &type, -1 );
+    gtk_tree_model_get (m, iter, CAT_FILTER_COL_TYPE, &type, -1);
     return type == CAT_FILTER_TYPE_SEPARATOR;
 }
 
 static void
-category_model_update_idle( gpointer category_model )
+category_model_update_idle (gpointer category_model)
 {
-    GObject * o = G_OBJECT( category_model );
-    const gboolean pending = g_object_get_qdata( o, DIRTY_KEY ) != NULL;
-    if( !pending )
+    GObject * o = G_OBJECT (category_model);
+    const gboolean pending = g_object_get_qdata (o, DIRTY_KEY) != NULL;
+    if (!pending)
     {
         GSourceFunc func = (GSourceFunc) category_filter_model_update;
-        g_object_set_qdata( o, DIRTY_KEY, GINT_TO_POINTER(1) );
-        gdk_threads_add_idle( func, category_model );
+        g_object_set_qdata (o, DIRTY_KEY, GINT_TO_POINTER (1));
+        gdk_threads_add_idle (func, category_model);
     }
 }
 
 static void
-torrent_model_row_changed( GtkTreeModel  * tmodel UNUSED,
+torrent_model_row_changed (GtkTreeModel  * tmodel UNUSED,
                            GtkTreePath   * path UNUSED,
                            GtkTreeIter   * iter UNUSED,
-                           gpointer        category_model )
+                           gpointer        category_model)
 {
-    category_model_update_idle( category_model );
+    category_model_update_idle (category_model);
 }
 
 static void
-torrent_model_row_deleted_cb( GtkTreeModel * tmodel UNUSED,
+torrent_model_row_deleted_cb (GtkTreeModel * tmodel UNUSED,
                               GtkTreePath  * path UNUSED,
-                              gpointer       category_model )
+                              gpointer       category_model)
 {
-    category_model_update_idle( category_model );
+    category_model_update_idle (category_model);
 }
 
 static void
-render_pixbuf_func( GtkCellLayout    * cell_layout UNUSED,
+render_pixbuf_func (GtkCellLayout    * cell_layout UNUSED,
                     GtkCellRenderer  * cell_renderer,
                     GtkTreeModel     * tree_model,
                     GtkTreeIter      * iter,
-                    gpointer           data UNUSED )
+                    gpointer           data UNUSED)
 {
     int type;
     int width = 0;
-    const gboolean leaf = !gtk_tree_model_iter_has_child( tree_model, iter );
+    const gboolean leaf = !gtk_tree_model_iter_has_child (tree_model, iter);
 
-    gtk_tree_model_get( tree_model, iter, CAT_FILTER_COL_TYPE, &type, -1 );
-    if( type == CAT_FILTER_TYPE_HOST )
+    gtk_tree_model_get (tree_model, iter, CAT_FILTER_COL_TYPE, &type, -1);
+    if (type == CAT_FILTER_TYPE_HOST)
         width = 20;
 
-    g_object_set( cell_renderer, "width", width,
+    g_object_set (cell_renderer, "width", width,
                                  "sensitive", leaf,
-                                 NULL );
+                                 NULL);
 }
 
 static void
-is_capital_sensitive( GtkCellLayout   * cell_layout UNUSED,
+is_capital_sensitive (GtkCellLayout   * cell_layout UNUSED,
                       GtkCellRenderer * cell_renderer,
                       GtkTreeModel    * tree_model,
                       GtkTreeIter     * iter,
-                      gpointer          data UNUSED )
+                      gpointer          data UNUSED)
 {
-    const gboolean leaf = !gtk_tree_model_iter_has_child( tree_model, iter );
+    const gboolean leaf = !gtk_tree_model_iter_has_child (tree_model, iter);
 
-    g_object_set( cell_renderer, "sensitive", leaf,
-                                 NULL );
+    g_object_set (cell_renderer, "sensitive", leaf,
+                                 NULL);
 }
 
 static void
-render_number_func( GtkCellLayout    * cell_layout UNUSED,
+render_number_func (GtkCellLayout    * cell_layout UNUSED,
                     GtkCellRenderer  * cell_renderer,
                     GtkTreeModel     * tree_model,
                     GtkTreeIter      * iter,
-                    gpointer           data UNUSED )
+                    gpointer           data UNUSED)
 {
     int count;
     char buf[32];
-    const gboolean leaf = !gtk_tree_model_iter_has_child( tree_model, iter );
+    const gboolean leaf = !gtk_tree_model_iter_has_child (tree_model, iter);
 
-    gtk_tree_model_get( tree_model, iter, CAT_FILTER_COL_COUNT, &count, -1 );
+    gtk_tree_model_get (tree_model, iter, CAT_FILTER_COL_COUNT, &count, -1);
 
-    if( count >= 0 )
-        g_snprintf( buf, sizeof( buf ), "%'d", count );
+    if (count >= 0)
+        g_snprintf (buf, sizeof (buf), "%'d", count);
     else
         *buf = '\0';
 
-    g_object_set( cell_renderer, "text", buf,
+    g_object_set (cell_renderer, "text", buf,
                                  "sensitive", leaf,
-                                 NULL );
+                                 NULL);
 }
 
 static GtkCellRenderer *
-number_renderer_new( void )
+number_renderer_new (void)
 {
-    GtkCellRenderer * r = gtk_cell_renderer_text_new( );
+    GtkCellRenderer * r = gtk_cell_renderer_text_new ();
 
-    g_object_set( G_OBJECT( r ), "alignment", PANGO_ALIGN_RIGHT,
+    g_object_set (G_OBJECT (r), "alignment", PANGO_ALIGN_RIGHT,
                                  "weight", PANGO_WEIGHT_ULTRALIGHT,
                                  "xalign", 1.0,
                                  "xpad", GUI_PAD,
-                                 NULL );
+                                 NULL);
 
     return r;
 }
 
 static void
-disconnect_cat_model_callbacks( gpointer tmodel, GObject * cat_model )
+disconnect_cat_model_callbacks (gpointer tmodel, GObject * cat_model)
 {
-    g_signal_handlers_disconnect_by_func( tmodel, torrent_model_row_changed, cat_model );
-    g_signal_handlers_disconnect_by_func( tmodel, torrent_model_row_deleted_cb, cat_model );
+    g_signal_handlers_disconnect_by_func (tmodel, torrent_model_row_changed, cat_model);
+    g_signal_handlers_disconnect_by_func (tmodel, torrent_model_row_deleted_cb, cat_model);
 }
 
 static GtkWidget *
-category_combo_box_new( GtkTreeModel * tmodel )
+category_combo_box_new (GtkTreeModel * tmodel)
 {
     GtkWidget * c;
     GtkCellRenderer * r;
     GtkTreeModel * cat_model;
 
     /* create the category combobox */
-    cat_model = category_filter_model_new( tmodel );
-    c = gtk_combo_box_new_with_model( cat_model );
-    g_object_unref( cat_model );
-    gtk_combo_box_set_row_separator_func( GTK_COMBO_BOX( c ),
-                                          is_it_a_separator, NULL, NULL );
-    gtk_combo_box_set_active( GTK_COMBO_BOX( c ), 0 );
-
-    r = gtk_cell_renderer_pixbuf_new( );
-    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( c ), r, FALSE );
-    gtk_cell_layout_set_cell_data_func( GTK_CELL_LAYOUT( c ), r,
-                                        render_pixbuf_func, NULL, NULL );
-    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( c ), r,
+    cat_model = category_filter_model_new (tmodel);
+    c = gtk_combo_box_new_with_model (cat_model);
+    g_object_unref (cat_model);
+    gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (c),
+                                          is_it_a_separator, NULL, NULL);
+    gtk_combo_box_set_active (GTK_COMBO_BOX (c), 0);
+
+    r = gtk_cell_renderer_pixbuf_new ();
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (c), r, FALSE);
+    gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (c), r,
+                                        render_pixbuf_func, NULL, NULL);
+    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (c), r,
                                     "pixbuf", CAT_FILTER_COL_PIXBUF,
-                                    NULL );
+                                    NULL);
 
-    r = gtk_cell_renderer_text_new( );
-    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( c ), r, FALSE );
-    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( c ), r,
+    r = gtk_cell_renderer_text_new ();
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (c), r, FALSE);
+    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (c), r,
                                     "text", CAT_FILTER_COL_NAME,
-                                    NULL );
-    gtk_cell_layout_set_cell_data_func( GTK_CELL_LAYOUT( c ), r,
+                                    NULL);
+    gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (c), r,
                                         is_capital_sensitive,
                                         NULL, NULL);
 
 
-    r = number_renderer_new( );
-    gtk_cell_layout_pack_end( GTK_CELL_LAYOUT( c ), r, TRUE );
-    gtk_cell_layout_set_cell_data_func( GTK_CELL_LAYOUT( c ), r,
-                                        render_number_func, NULL, NULL );
+    r = number_renderer_new ();
+    gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (c), r, TRUE);
+    gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (c), r,
+                                        render_number_func, NULL, NULL);
 
-    g_object_weak_ref( G_OBJECT( cat_model ), disconnect_cat_model_callbacks, tmodel );
-    g_signal_connect( tmodel, "row-changed", G_CALLBACK( torrent_model_row_changed ), cat_model );
-    g_signal_connect( tmodel, "row-inserted", G_CALLBACK( torrent_model_row_changed ), cat_model );
-    g_signal_connect( tmodel, "row-deleted", G_CALLBACK( torrent_model_row_deleted_cb ), cat_model );
+    g_object_weak_ref (G_OBJECT (cat_model), disconnect_cat_model_callbacks, tmodel);
+    g_signal_connect (tmodel, "row-changed", G_CALLBACK (torrent_model_row_changed), cat_model);
+    g_signal_connect (tmodel, "row-inserted", G_CALLBACK (torrent_model_row_changed), cat_model);
+    g_signal_connect (tmodel, "row-deleted", G_CALLBACK (torrent_model_row_deleted_cb), cat_model);
 
     return c;
 }
 
 static gboolean
-test_category( tr_torrent * tor, int active_category_type, const char * host )
+test_category (tr_torrent * tor, int active_category_type, const char * host)
 {
-    const tr_info * const inf = tr_torrentInfo( tor );
+    const tr_info * const inf = tr_torrentInfo (tor);
 
-    switch( active_category_type )
+    switch (active_category_type)
     {
         case CAT_FILTER_TYPE_ALL:
             return TRUE;
@@ -539,20 +539,20 @@ test_category( tr_torrent * tor, int active_category_type, const char * host )
             return !inf->isPrivate;
 
         case CAT_FILTER_TYPE_PRI_HIGH:
-            return tr_torrentGetPriority( tor ) == TR_PRI_HIGH;
+            return tr_torrentGetPriority (tor) == TR_PRI_HIGH;
 
         case CAT_FILTER_TYPE_PRI_NORMAL:
-            return tr_torrentGetPriority( tor ) == TR_PRI_NORMAL;
+            return tr_torrentGetPriority (tor) == TR_PRI_NORMAL;
 
         case CAT_FILTER_TYPE_PRI_LOW:
-            return tr_torrentGetPriority( tor ) == TR_PRI_LOW;
+            return tr_torrentGetPriority (tor) == TR_PRI_LOW;
 
         case CAT_FILTER_TYPE_HOST: {
             int i;
             char tmp[1024];
-            for( i=0; i<inf->trackerCount; ++i ) {
-                gtr_get_host_from_url( tmp, sizeof( tmp ), inf->trackers[i].announce );
-                if( !strcmp( tmp, host ) )
+            for (i=0; i<inf->trackerCount; ++i) {
+                gtr_get_host_from_url (tmp, sizeof (tmp), inf->trackers[i].announce);
+                if (!strcmp (tmp, host))
                     break;
             }
             return i < inf->trackerCount;
@@ -596,33 +596,33 @@ enum
 };
 
 static gboolean
-activity_is_it_a_separator( GtkTreeModel * m, GtkTreeIter * i, gpointer d UNUSED )
+activity_is_it_a_separator (GtkTreeModel * m, GtkTreeIter * i, gpointer d UNUSED)
 {
     int type;
-    gtk_tree_model_get( m, i, ACTIVITY_FILTER_COL_TYPE, &type, -1 );
+    gtk_tree_model_get (m, i, ACTIVITY_FILTER_COL_TYPE, &type, -1);
     return type == ACTIVITY_FILTER_SEPARATOR;
 }
 
 static gboolean
-test_torrent_activity( tr_torrent * tor, int type )
+test_torrent_activity (tr_torrent * tor, int type)
 {
-    const tr_stat * st = tr_torrentStatCached( tor );
+    const tr_stat * st = tr_torrentStatCached (tor);
 
-    switch( type )
+    switch (type)
     {
         case ACTIVITY_FILTER_DOWNLOADING:
-            return ( st->activity == TR_STATUS_DOWNLOAD )
-                || ( st->activity == TR_STATUS_DOWNLOAD_WAIT );
+            return (st->activity == TR_STATUS_DOWNLOAD)
+                || (st->activity == TR_STATUS_DOWNLOAD_WAIT);
 
         case ACTIVITY_FILTER_SEEDING:
-            return ( st->activity == TR_STATUS_SEED )
-                || ( st->activity == TR_STATUS_SEED_WAIT );
+            return (st->activity == TR_STATUS_SEED)
+                || (st->activity == TR_STATUS_SEED_WAIT);
 
         case ACTIVITY_FILTER_ACTIVE:
-            return ( st->peersSendingToUs > 0 )
-                || ( st->peersGettingFromUs > 0 )
-                || ( st->webseedsSendingToUs > 0 )
-                || ( st->activity == TR_STATUS_CHECK );
+            return (st->peersSendingToUs > 0)
+                || (st->peersGettingFromUs > 0)
+                || (st->webseedsSendingToUs > 0)
+                || (st->activity == TR_STATUS_CHECK);
 
         case ACTIVITY_FILTER_PAUSED:
             return st->activity == TR_STATUS_STOPPED;
@@ -631,8 +631,8 @@ test_torrent_activity( tr_torrent * tor, int type )
             return st->finished == TRUE;
 
         case ACTIVITY_FILTER_VERIFYING:
-            return ( st->activity == TR_STATUS_CHECK )
-                || ( st->activity == TR_STATUS_CHECK_WAIT );
+            return (st->activity == TR_STATUS_CHECK)
+                || (st->activity == TR_STATUS_CHECK_WAIT);
 
         case ACTIVITY_FILTER_ERROR:
             return st->error != 0;
@@ -643,48 +643,48 @@ test_torrent_activity( tr_torrent * tor, int type )
 }
 
 static void
-status_model_update_count( GtkListStore * store, GtkTreeIter * iter, int n )
+status_model_update_count (GtkListStore * store, GtkTreeIter * iter, int n)
 {
     int count;
-    GtkTreeModel * model = GTK_TREE_MODEL( store );
-    gtk_tree_model_get( model, iter, ACTIVITY_FILTER_COL_COUNT, &count, -1 );
-    if( n != count )
-        gtk_list_store_set( store, iter, ACTIVITY_FILTER_COL_COUNT, n, -1 );
+    GtkTreeModel * model = GTK_TREE_MODEL (store);
+    gtk_tree_model_get (model, iter, ACTIVITY_FILTER_COL_COUNT, &count, -1);
+    if (n != count)
+        gtk_list_store_set (store, iter, ACTIVITY_FILTER_COL_COUNT, n, -1);
 }
 
 static void
-activity_filter_model_update( GtkListStore * store )
+activity_filter_model_update (GtkListStore * store)
 {
     GtkTreeIter iter;
-    GtkTreeModel * model = GTK_TREE_MODEL( store );
-    GObject * o = G_OBJECT( store );
-    GtkTreeModel * tmodel = GTK_TREE_MODEL( g_object_get_qdata( o, TORRENT_MODEL_KEY ) );
+    GtkTreeModel * model = GTK_TREE_MODEL (store);
+    GObject * o = G_OBJECT (store);
+    GtkTreeModel * tmodel = GTK_TREE_MODEL (g_object_get_qdata (o, TORRENT_MODEL_KEY));
 
-    g_object_steal_qdata( o, DIRTY_KEY );
+    g_object_steal_qdata (o, DIRTY_KEY);
 
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
     {
         int hits;
         int type;
         GtkTreeIter torrent_iter;
 
-        gtk_tree_model_get( model, &iter, ACTIVITY_FILTER_COL_TYPE, &type, -1 );
+        gtk_tree_model_get (model, &iter, ACTIVITY_FILTER_COL_TYPE, &type, -1);
 
         hits = 0;
-        if( gtk_tree_model_iter_nth_child( tmodel, &torrent_iter, NULL, 0 ) ) do {
+        if (gtk_tree_model_iter_nth_child (tmodel, &torrent_iter, NULL, 0)) do {
             tr_torrent * tor;
-            gtk_tree_model_get( tmodel, &torrent_iter, MC_TORRENT, &tor, -1 );
-            if( test_torrent_activity( tor, type ) )
+            gtk_tree_model_get (tmodel, &torrent_iter, MC_TORRENT, &tor, -1);
+            if (test_torrent_activity (tor, type))
                 ++hits;
-        } while( gtk_tree_model_iter_next( tmodel, &torrent_iter ) );
+        } while (gtk_tree_model_iter_next (tmodel, &torrent_iter));
 
-        status_model_update_count( store, &iter, hits );
+        status_model_update_count (store, &iter, hits);
 
-    } while( gtk_tree_model_iter_next( model, &iter ) );
+    } while (gtk_tree_model_iter_next (model, &iter));
 }
 
 static GtkTreeModel *
-activity_filter_model_new( GtkTreeModel * tmodel )
+activity_filter_model_new (GtkTreeModel * tmodel)
 {
     int i, n;
     struct {
@@ -693,132 +693,132 @@ activity_filter_model_new( GtkTreeModel * tmodel )
         const char * name;
         const char * stock_id;
     } types[] = {
-        { ACTIVITY_FILTER_ALL, NULL, N_( "All" ), NULL },
+        { ACTIVITY_FILTER_ALL, NULL, N_("All"), NULL },
         { ACTIVITY_FILTER_SEPARATOR, NULL, NULL, NULL },
-        { ACTIVITY_FILTER_ACTIVE, NULL, N_( "Active" ), GTK_STOCK_EXECUTE },
-        { ACTIVITY_FILTER_DOWNLOADING, "Verb", NC_( "Verb", "Downloading" ), GTK_STOCK_GO_DOWN },
-        { ACTIVITY_FILTER_SEEDING, "Verb", NC_( "Verb", "Seeding" ), GTK_STOCK_GO_UP },
-        { ACTIVITY_FILTER_PAUSED, NULL, N_( "Paused" ), GTK_STOCK_MEDIA_PAUSE },
-        { ACTIVITY_FILTER_FINISHED, NULL, N_( "Finished" ), NULL },
-        { ACTIVITY_FILTER_VERIFYING, "Verb", NC_( "Verb", "Verifying" ), GTK_STOCK_REFRESH },
-        { ACTIVITY_FILTER_ERROR, NULL, N_( "Error" ), GTK_STOCK_DIALOG_ERROR }
+        { ACTIVITY_FILTER_ACTIVE, NULL, N_("Active"), GTK_STOCK_EXECUTE },
+        { ACTIVITY_FILTER_DOWNLOADING, "Verb", NC_("Verb", "Downloading"), GTK_STOCK_GO_DOWN },
+        { ACTIVITY_FILTER_SEEDING, "Verb", NC_("Verb", "Seeding"), GTK_STOCK_GO_UP },
+        { ACTIVITY_FILTER_PAUSED, NULL, N_("Paused"), GTK_STOCK_MEDIA_PAUSE },
+        { ACTIVITY_FILTER_FINISHED, NULL, N_("Finished"), NULL },
+        { ACTIVITY_FILTER_VERIFYING, "Verb", NC_("Verb", "Verifying"), GTK_STOCK_REFRESH },
+        { ACTIVITY_FILTER_ERROR, NULL, N_("Error"), GTK_STOCK_DIALOG_ERROR }
     };
-    GtkListStore * store = gtk_list_store_new( ACTIVITY_FILTER_N_COLS,
+    GtkListStore * store = gtk_list_store_new (ACTIVITY_FILTER_N_COLS,
                                                G_TYPE_STRING,
                                                G_TYPE_INT,
                                                G_TYPE_INT,
-                                               G_TYPE_STRING );
-    for( i=0, n=G_N_ELEMENTS(types); i<n; ++i ) {
-        const char * name = types[i].context ? g_dpgettext2( NULL, types[i].context, types[i].name )
-                                             : _( types[i].name );
-        gtk_list_store_insert_with_values( store, NULL, -1,
+                                               G_TYPE_STRING);
+    for (i=0, n=G_N_ELEMENTS (types); i<n; ++i) {
+        const char * name = types[i].context ? g_dpgettext2 (NULL, types[i].context, types[i].name)
+                                             : _ (types[i].name);
+        gtk_list_store_insert_with_values (store, NULL, -1,
             ACTIVITY_FILTER_COL_NAME, name,
             ACTIVITY_FILTER_COL_TYPE, types[i].type,
             ACTIVITY_FILTER_COL_STOCK_ID, types[i].stock_id,
-            -1 );
+            -1);
     }
 
-    g_object_set_qdata( G_OBJECT( store ), TORRENT_MODEL_KEY, tmodel );
-    activity_filter_model_update( store );
-    return GTK_TREE_MODEL( store );
+    g_object_set_qdata (G_OBJECT (store), TORRENT_MODEL_KEY, tmodel);
+    activity_filter_model_update (store);
+    return GTK_TREE_MODEL (store);
 }
 
 static void
-render_activity_pixbuf_func( GtkCellLayout    * cell_layout UNUSED,
+render_activity_pixbuf_func (GtkCellLayout    * cell_layout UNUSED,
                              GtkCellRenderer  * cell_renderer,
                              GtkTreeModel     * tree_model,
                              GtkTreeIter      * iter,
-                             gpointer           data UNUSED )
+                             gpointer           data UNUSED)
 {
     int type;
     int width;
     int ypad;
-    const gboolean leaf = !gtk_tree_model_iter_has_child( tree_model, iter );
+    const gboolean leaf = !gtk_tree_model_iter_has_child (tree_model, iter);
 
-    gtk_tree_model_get( tree_model, iter, ACTIVITY_FILTER_COL_TYPE, &type, -1 );
+    gtk_tree_model_get (tree_model, iter, ACTIVITY_FILTER_COL_TYPE, &type, -1);
     width = type == ACTIVITY_FILTER_ALL ? 0 : 20;
     ypad = type == ACTIVITY_FILTER_ALL ? 0 : 2;
 
-    g_object_set( cell_renderer, "width", width,
+    g_object_set (cell_renderer, "width", width,
                                  "sensitive", leaf,
                                  "ypad", ypad,
-                                 NULL );
+                                 NULL);
 }
 
 static void
-activity_model_update_idle( gpointer activity_model )
+activity_model_update_idle (gpointer activity_model)
 {
-    GObject * o = G_OBJECT( activity_model );
-    const gboolean pending = g_object_get_qdata( o, DIRTY_KEY ) != NULL;
-    if( !pending )
+    GObject * o = G_OBJECT (activity_model);
+    const gboolean pending = g_object_get_qdata (o, DIRTY_KEY) != NULL;
+    if (!pending)
     {
         GSourceFunc func = (GSourceFunc) activity_filter_model_update;
-        g_object_set_qdata( o, DIRTY_KEY, GINT_TO_POINTER(1) );
-        gdk_threads_add_idle( func, activity_model );
+        g_object_set_qdata (o, DIRTY_KEY, GINT_TO_POINTER (1));
+        gdk_threads_add_idle (func, activity_model);
     }
 }
 
 static void
-activity_torrent_model_row_changed( GtkTreeModel  * tmodel UNUSED,
+activity_torrent_model_row_changed (GtkTreeModel  * tmodel UNUSED,
                                     GtkTreePath   * path UNUSED,
                                     GtkTreeIter   * iter UNUSED,
-                                    gpointer        activity_model )
+                                    gpointer        activity_model)
 {
-    activity_model_update_idle( activity_model );
+    activity_model_update_idle (activity_model);
 }
 
 static void
-activity_torrent_model_row_deleted_cb( GtkTreeModel  * tmodel UNUSED,
+activity_torrent_model_row_deleted_cb (GtkTreeModel  * tmodel UNUSED,
                                        GtkTreePath   * path UNUSED,
-                                       gpointer        activity_model )
+                                       gpointer        activity_model)
 {
-    activity_model_update_idle( activity_model );
+    activity_model_update_idle (activity_model);
 }
 
 static void
-disconnect_activity_model_callbacks( gpointer tmodel, GObject * cat_model )
+disconnect_activity_model_callbacks (gpointer tmodel, GObject * cat_model)
 {
-    g_signal_handlers_disconnect_by_func( tmodel, activity_torrent_model_row_changed, cat_model );
-    g_signal_handlers_disconnect_by_func( tmodel, activity_torrent_model_row_deleted_cb, cat_model );
+    g_signal_handlers_disconnect_by_func (tmodel, activity_torrent_model_row_changed, cat_model);
+    g_signal_handlers_disconnect_by_func (tmodel, activity_torrent_model_row_deleted_cb, cat_model);
 }
 
 static GtkWidget *
-activity_combo_box_new( GtkTreeModel * tmodel )
+activity_combo_box_new (GtkTreeModel * tmodel)
 {
     GtkWidget * c;
     GtkCellRenderer * r;
     GtkTreeModel * activity_model;
 
-    activity_model = activity_filter_model_new( tmodel );
-    c = gtk_combo_box_new_with_model( activity_model );
-    g_object_unref( activity_model );
-    gtk_combo_box_set_row_separator_func( GTK_COMBO_BOX( c ),
-                                       activity_is_it_a_separator, NULL, NULL );
-    gtk_combo_box_set_active( GTK_COMBO_BOX( c ), 0 );
+    activity_model = activity_filter_model_new (tmodel);
+    c = gtk_combo_box_new_with_model (activity_model);
+    g_object_unref (activity_model);
+    gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (c),
+                                       activity_is_it_a_separator, NULL, NULL);
+    gtk_combo_box_set_active (GTK_COMBO_BOX (c), 0);
 
-    r = gtk_cell_renderer_pixbuf_new( );
-    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( c ), r, FALSE );
-    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( c ), r,
+    r = gtk_cell_renderer_pixbuf_new ();
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (c), r, FALSE);
+    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (c), r,
                                     "stock-id", ACTIVITY_FILTER_COL_STOCK_ID,
-                                    NULL );
-    gtk_cell_layout_set_cell_data_func( GTK_CELL_LAYOUT( c ), r,
-                                        render_activity_pixbuf_func, NULL, NULL );
+                                    NULL);
+    gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (c), r,
+                                        render_activity_pixbuf_func, NULL, NULL);
 
-    r = gtk_cell_renderer_text_new( );
-    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( c ), r, TRUE );
-    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( c ), r,
+    r = gtk_cell_renderer_text_new ();
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (c), r, TRUE);
+    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (c), r,
                                     "text", ACTIVITY_FILTER_COL_NAME,
-                                    NULL );
+                                    NULL);
 
-    r = number_renderer_new( );
-    gtk_cell_layout_pack_end( GTK_CELL_LAYOUT( c ), r, TRUE );
-    gtk_cell_layout_set_cell_data_func( GTK_CELL_LAYOUT( c ), r,
-                                        render_number_func, NULL, NULL );
+    r = number_renderer_new ();
+    gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (c), r, TRUE);
+    gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (c), r,
+                                        render_number_func, NULL, NULL);
 
-    g_object_weak_ref( G_OBJECT( activity_model ), disconnect_activity_model_callbacks, tmodel );
-    g_signal_connect( tmodel, "row-changed", G_CALLBACK( activity_torrent_model_row_changed ), activity_model );
-    g_signal_connect( tmodel, "row-inserted", G_CALLBACK( activity_torrent_model_row_changed ), activity_model );
-    g_signal_connect( tmodel, "row-deleted", G_CALLBACK( activity_torrent_model_row_deleted_cb ), activity_model );
+    g_object_weak_ref (G_OBJECT (activity_model), disconnect_activity_model_callbacks, tmodel);
+    g_signal_connect (tmodel, "row-changed", G_CALLBACK (activity_torrent_model_row_changed), activity_model);
+    g_signal_connect (tmodel, "row-inserted", G_CALLBACK (activity_torrent_model_row_changed), activity_model);
+    g_signal_connect (tmodel, "row-deleted", G_CALLBACK (activity_torrent_model_row_deleted_cb), activity_model);
 
     return c;
 }
@@ -830,32 +830,32 @@ activity_combo_box_new( GtkTreeModel * tmodel )
 ****/
 
 static gboolean
-testText( const tr_torrent * tor, const char * key )
+testText (const tr_torrent * tor, const char * key)
 {
     gboolean ret = FALSE;
 
-    if( !key || !*key )
+    if (!key || !*key)
     {
         ret = TRUE;
     }
     else
     {
         tr_file_index_t i;
-        const tr_info * inf = tr_torrentInfo( tor );
+        const tr_info * inf = tr_torrentInfo (tor);
 
         /* test the torrent name... */
         {
-            char * pch = g_utf8_casefold( tr_torrentName( tor ), -1 );
-            ret = !key || strstr( pch, key ) != NULL;
-            g_free( pch );
+            char * pch = g_utf8_casefold (tr_torrentName (tor), -1);
+            ret = !key || strstr (pch, key) != NULL;
+            g_free (pch);
         }
 
         /* test the files... */
-        for( i=0; i<inf->fileCount && !ret; ++i )
+        for (i=0; i<inf->fileCount && !ret; ++i)
         {
-            char * pch = g_utf8_casefold( inf->files[i].name, -1 );
-            ret = !key || strstr( pch, key ) != NULL;
-            g_free( pch );
+            char * pch = g_utf8_casefold (inf->files[i].name, -1);
+            ret = !key || strstr (pch, key) != NULL;
+            g_free (pch);
         }
     }
 
@@ -863,24 +863,24 @@ testText( const tr_torrent * tor, const char * key )
 }
 
 static void
-entry_clear( GtkEntry * e )
+entry_clear (GtkEntry * e)
 {
-    gtk_entry_set_text( e, "" );
+    gtk_entry_set_text (e, "");
 }
 
 static void
-filter_entry_changed( GtkEditable * e, gpointer filter_model )
+filter_entry_changed (GtkEditable * e, gpointer filter_model)
 {
     char * pch;
     char * folded;
 
-    pch = gtk_editable_get_chars( e, 0, -1 );
-    folded = g_utf8_casefold( pch, -1 );
-    g_strstrip( folded );
-    g_object_set_qdata_full( filter_model, TEXT_KEY, folded, g_free );
-    g_free( pch );
+    pch = gtk_editable_get_chars (e, 0, -1);
+    folded = g_utf8_casefold (pch, -1);
+    g_strstrip (folded);
+    g_object_set_qdata_full (filter_model, TEXT_KEY, folded, g_free);
+    g_free (pch);
 
-    gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( filter_model ) );
+    gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (filter_model));
 }
 
 /*****
@@ -901,24 +901,24 @@ struct filter_data
 };
 
 static gboolean
-is_row_visible( GtkTreeModel * model, GtkTreeIter * iter, gpointer vdata )
+is_row_visible (GtkTreeModel * model, GtkTreeIter * iter, gpointer vdata)
 {
     const char * text;
     tr_torrent * tor;
     struct filter_data * data = vdata;
-    GObject * o = G_OBJECT( data->filter_model );
+    GObject * o = G_OBJECT (data->filter_model);
 
-    gtk_tree_model_get( model, iter, MC_TORRENT, &tor, -1 );
+    gtk_tree_model_get (model, iter, MC_TORRENT, &tor, -1);
 
-    text = (const char*) g_object_get_qdata( o, TEXT_KEY );
+    text = (const char*) g_object_get_qdata (o, TEXT_KEY);
 
-    return ( tor != NULL ) && test_category( tor, data->active_category_type, data->active_category_host )
-                           && test_torrent_activity( tor, data->active_activity_type )
-                           && testText( tor, text );
+    return (tor != NULL) && test_category (tor, data->active_category_type, data->active_category_host)
+                           && test_torrent_activity (tor, data->active_activity_type)
+                           && testText (tor, text);
 }
 
 static void
-selection_changed_cb( GtkComboBox * combo, gpointer vdata )
+selection_changed_cb (GtkComboBox * combo, gpointer vdata)
 {
     int type;
     char * host;
@@ -927,35 +927,35 @@ selection_changed_cb( GtkComboBox * combo, gpointer vdata )
     struct filter_data * data = vdata;
 
     /* set data->active_activity_type from the activity combobox */
-    combo = GTK_COMBO_BOX( data->activity );
-    model = gtk_combo_box_get_model( combo );
-    if( gtk_combo_box_get_active_iter( combo, &iter ) )
-        gtk_tree_model_get( model, &iter, ACTIVITY_FILTER_COL_TYPE, &type, -1 );
+    combo = GTK_COMBO_BOX (data->activity);
+    model = gtk_combo_box_get_model (combo);
+    if (gtk_combo_box_get_active_iter (combo, &iter))
+        gtk_tree_model_get (model, &iter, ACTIVITY_FILTER_COL_TYPE, &type, -1);
     else
         type = ACTIVITY_FILTER_ALL;
     data->active_activity_type = type;
 
     /* set the active category type & host from the category combobox */
-    combo = GTK_COMBO_BOX( data->category );
-    model = gtk_combo_box_get_model( combo );
-    if( gtk_combo_box_get_active_iter( combo, &iter ) ) {
-        gtk_tree_model_get( model, &iter, CAT_FILTER_COL_TYPE, &type,
+    combo = GTK_COMBO_BOX (data->category);
+    model = gtk_combo_box_get_model (combo);
+    if (gtk_combo_box_get_active_iter (combo, &iter)) {
+        gtk_tree_model_get (model, &iter, CAT_FILTER_COL_TYPE, &type,
                                           CAT_FILTER_COL_HOST, &host,
-                                          -1 );
+                                          -1);
     } else {
         type = CAT_FILTER_TYPE_ALL;
         host = NULL;
     }
-    g_free( data->active_category_host );
+    g_free (data->active_category_host);
     data->active_category_host = host;
     data->active_category_type = type;
 
     /* refilter */
-    gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( data->filter_model ) );
+    gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (data->filter_model));
 }
 
 GtkWidget *
-gtr_filter_bar_new( tr_session * session, GtkTreeModel * tmodel, GtkTreeModel ** filter_model )
+gtr_filter_bar_new (tr_session * session, GtkTreeModel * tmodel, GtkTreeModel ** filter_model)
 {
     GtkWidget * l;
     GtkWidget * w;
@@ -966,61 +966,61 @@ gtr_filter_bar_new( tr_session * session, GtkTreeModel * tmodel, GtkTreeModel **
     const char * str;
     struct filter_data * data;
 
-    g_assert( DIRTY_KEY == 0 );
-    TEXT_KEY = g_quark_from_static_string( "tr-filter-text-key" );
-    DIRTY_KEY = g_quark_from_static_string( "tr-filter-dirty-key" );
-    SESSION_KEY = g_quark_from_static_string( "tr-session-key" );
-    TORRENT_MODEL_KEY = g_quark_from_static_string( "tr-filter-torrent-model-key" );
+    g_assert (DIRTY_KEY == 0);
+    TEXT_KEY = g_quark_from_static_string ("tr-filter-text-key");
+    DIRTY_KEY = g_quark_from_static_string ("tr-filter-dirty-key");
+    SESSION_KEY = g_quark_from_static_string ("tr-session-key");
+    TORRENT_MODEL_KEY = g_quark_from_static_string ("tr-filter-torrent-model-key");
 
-    data = g_new0( struct filter_data, 1 );
-    data->activity = activity = activity_combo_box_new( tmodel );
-    data->category = category = category_combo_box_new( tmodel );
-    data->filter_model = gtk_tree_model_filter_new( tmodel, NULL );
+    data = g_new0 (struct filter_data, 1);
+    data->activity = activity = activity_combo_box_new (tmodel);
+    data->category = category = category_combo_box_new (tmodel);
+    data->filter_model = gtk_tree_model_filter_new (tmodel, NULL);
 
-    g_object_set( G_OBJECT( data->category ), "width-request", 170, NULL );
-    g_object_set_qdata( G_OBJECT( gtk_combo_box_get_model( GTK_COMBO_BOX( data->category ) ) ), SESSION_KEY, session );
+    g_object_set (G_OBJECT (data->category), "width-request", 170, NULL);
+    g_object_set_qdata (G_OBJECT (gtk_combo_box_get_model (GTK_COMBO_BOX (data->category))), SESSION_KEY, session);
 
-    gtk_tree_model_filter_set_visible_func(
-        GTK_TREE_MODEL_FILTER( data->filter_model ),
-        is_row_visible, data, g_free );
+    gtk_tree_model_filter_set_visible_func (
+        GTK_TREE_MODEL_FILTER (data->filter_model),
+        is_row_visible, data, g_free);
 
-    g_signal_connect( data->category, "changed", G_CALLBACK( selection_changed_cb ), data );
-    g_signal_connect( data->activity, "changed", G_CALLBACK( selection_changed_cb ), data );
+    g_signal_connect (data->category, "changed", G_CALLBACK (selection_changed_cb), data);
+    g_signal_connect (data->activity, "changed", G_CALLBACK (selection_changed_cb), data);
 
 
-    h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD_SMALL );
+    h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD_SMALL);
 
     /* add the activity combobox */
-    str = _( "_Show:" );
+    str = _("_Show:");
     w = activity;
-    l = gtk_label_new( NULL );
-    gtk_label_set_markup_with_mnemonic( GTK_LABEL( l ), str );
-    gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
-    gtk_box_pack_start( GTK_BOX( h ), l, FALSE, FALSE, 0 );
-    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
+    l = gtk_label_new (NULL);
+    gtk_label_set_markup_with_mnemonic (GTK_LABEL (l), str);
+    gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
+    gtk_box_pack_start (GTK_BOX (h), l, FALSE, FALSE, 0);
+    gtk_box_pack_start (GTK_BOX (h), w, TRUE, TRUE, 0);
 
     /* add a spacer */
-    w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
-    gtk_widget_set_size_request( w, 0u, GUI_PAD_BIG );
-    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
+    w = gtk_alignment_new (0.0f, 0.0f, 0.0f, 0.0f);
+    gtk_widget_set_size_request (w, 0u, GUI_PAD_BIG);
+    gtk_box_pack_start (GTK_BOX (h), w, FALSE, FALSE, 0);
 
     /* add the category combobox */
     w = category;
-    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
+    gtk_box_pack_start (GTK_BOX (h), w, TRUE, TRUE, 0);
 
     /* add a spacer */
-    w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
-    gtk_widget_set_size_request( w, 0u, GUI_PAD_BIG );
-    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
+    w = gtk_alignment_new (0.0f, 0.0f, 0.0f, 0.0f);
+    gtk_widget_set_size_request (w, 0u, GUI_PAD_BIG);
+    gtk_box_pack_start (GTK_BOX (h), w, FALSE, FALSE, 0);
 
     /* add the entry field */
-    s = gtk_entry_new( );
-    gtk_entry_set_icon_from_stock( GTK_ENTRY( s ), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR );
-    g_signal_connect( s, "icon-release", G_CALLBACK( entry_clear ), NULL );
-    gtk_box_pack_start( GTK_BOX( h ), s, TRUE, TRUE, 0 );
+    s = gtk_entry_new ();
+    gtk_entry_set_icon_from_stock (GTK_ENTRY (s), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
+    g_signal_connect (s, "icon-release", G_CALLBACK (entry_clear), NULL);
+    gtk_box_pack_start (GTK_BOX (h), s, TRUE, TRUE, 0);
 
-    g_signal_connect( s, "changed", G_CALLBACK( filter_entry_changed ), data->filter_model );
-    selection_changed_cb( NULL, data );
+    g_signal_connect (s, "changed", G_CALLBACK (filter_entry_changed), data->filter_model);
+    selection_changed_cb (NULL, data);
 
     *filter_model = data->filter_model;
     return h;
diff --git a/gtk/filter.h b/gtk/filter.h
index 0a0013cda..962eaed20 100644
--- a/gtk/filter.h
+++ b/gtk/filter.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,8 +16,8 @@
 #include <gtk/gtk.h>
 #include <libtransmission/transmission.h>
 
-GtkWidget * gtr_filter_bar_new( tr_session     * session,
+GtkWidget * gtr_filter_bar_new (tr_session     * session,
                                 GtkTreeModel   * torrent_model,
-                                GtkTreeModel  ** filter_model );
+                                GtkTreeModel  ** filter_model);
 
 #endif
diff --git a/gtk/hig.c b/gtk/hig.c
index 4e77b9f08..5eaaf012c 100644
--- a/gtk/hig.c
+++ b/gtk/hig.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -14,154 +14,154 @@
 #include "hig.h"
 
 GtkWidget*
-hig_workarea_create( void )
+hig_workarea_create (void)
 {
-    GtkWidget * grid = gtk_grid_new( );
+    GtkWidget * grid = gtk_grid_new ();
 
-    gtk_container_set_border_width( GTK_CONTAINER( grid ), GUI_PAD_BIG );
-    gtk_grid_set_row_spacing( GTK_GRID( grid ), GUI_PAD );
-    gtk_grid_set_column_spacing( GTK_GRID( grid ), GUI_PAD_BIG );
+    gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG);
+    gtk_grid_set_row_spacing (GTK_GRID (grid), GUI_PAD);
+    gtk_grid_set_column_spacing (GTK_GRID (grid), GUI_PAD_BIG);
 
     return grid;
 }
 
 void
-hig_workarea_add_section_divider( GtkWidget * t, guint * row )
+hig_workarea_add_section_divider (GtkWidget * t, guint * row)
 {
-    GtkWidget * w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
+    GtkWidget * w = gtk_alignment_new (0.0f, 0.0f, 0.0f, 0.0f);
 
-    gtk_widget_set_size_request( w, 0u, 6u );
-    gtk_grid_attach( GTK_GRID( t ), w, 0, *row, 2, 1 );
+    gtk_widget_set_size_request (w, 0u, 6u);
+    gtk_grid_attach (GTK_GRID (t), w, 0, *row, 2, 1);
     ++ * row;
 }
 
 void
-hig_workarea_add_section_title_widget( GtkWidget * t, guint * row, GtkWidget * w )
+hig_workarea_add_section_title_widget (GtkWidget * t, guint * row, GtkWidget * w)
 {
-    gtk_widget_set_hexpand( w, TRUE );
-    gtk_grid_attach( GTK_GRID( t ), w, 0, *row, 2, 1 );
+    gtk_widget_set_hexpand (w, TRUE);
+    gtk_grid_attach (GTK_GRID (t), w, 0, *row, 2, 1);
     ++ * row;
 }
 
 void
-hig_workarea_add_section_title( GtkWidget *  t, guint * row, const char * section_title )
+hig_workarea_add_section_title (GtkWidget *  t, guint * row, const char * section_title)
 {
     char buf[512];
     GtkWidget * l;
 
-    g_snprintf( buf, sizeof( buf ), "<b>%s</b>", section_title );
-    l = gtk_label_new( buf );
-    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
-    gtk_label_set_use_markup( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_section_title_widget( t, row, l );
+    g_snprintf (buf, sizeof (buf), "<b>%s</b>", section_title);
+    l = gtk_label_new (buf);
+    gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
+    gtk_label_set_use_markup (GTK_LABEL (l), TRUE);
+    hig_workarea_add_section_title_widget (t, row, l);
 }
 
 void
-hig_workarea_add_wide_control( GtkWidget * t, guint * row, GtkWidget * w )
+hig_workarea_add_wide_control (GtkWidget * t, guint * row, GtkWidget * w)
 {
-    gtk_widget_set_hexpand( w, TRUE );
-    gtk_widget_set_margin_left( w, 18 );
-    gtk_grid_attach( GTK_GRID( t ), w, 0, *row, 2, 1 );
+    gtk_widget_set_hexpand (w, TRUE);
+    gtk_widget_set_margin_left (w, 18);
+    gtk_grid_attach (GTK_GRID (t), w, 0, *row, 2, 1);
     ++ * row;
 }
 void
-hig_workarea_add_wide_tall_control( GtkWidget * t, guint * row, GtkWidget * w )
+hig_workarea_add_wide_tall_control (GtkWidget * t, guint * row, GtkWidget * w)
 {
-    gtk_widget_set_hexpand( w, TRUE );
-    hig_workarea_add_wide_control( t, row, w );
+    gtk_widget_set_hexpand (w, TRUE);
+    hig_workarea_add_wide_control (t, row, w);
 }
 
 GtkWidget *
-hig_workarea_add_wide_checkbutton( GtkWidget  * t,
+hig_workarea_add_wide_checkbutton (GtkWidget  * t,
                                    guint      * row,
                                    const char * mnemonic_string,
-                                   gboolean     is_active )
+                                   gboolean     is_active)
 {
-    GtkWidget * w = gtk_check_button_new_with_mnemonic( mnemonic_string );
+    GtkWidget * w = gtk_check_button_new_with_mnemonic (mnemonic_string);
 
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), is_active );
-    hig_workarea_add_wide_control( t, row, w );
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), is_active);
+    hig_workarea_add_wide_control (t, row, w);
     return w;
 }
 
 void
-hig_workarea_add_label_w( GtkWidget * t, guint row, GtkWidget * w )
+hig_workarea_add_label_w (GtkWidget * t, guint row, GtkWidget * w)
 {
-    gtk_widget_set_margin_left( w, 18 );
-    if( GTK_IS_MISC( w ) )
-        gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
-    if( GTK_IS_LABEL( w ) )
-        gtk_label_set_use_markup( GTK_LABEL( w ), TRUE );
-    gtk_grid_attach( GTK_GRID( t ), w, 0, row, 1, 1 );
+    gtk_widget_set_margin_left (w, 18);
+    if (GTK_IS_MISC (w))
+        gtk_misc_set_alignment (GTK_MISC (w), 0.0f, 0.5f);
+    if (GTK_IS_LABEL (w))
+        gtk_label_set_use_markup (GTK_LABEL (w), TRUE);
+    gtk_grid_attach (GTK_GRID (t), w, 0, row, 1, 1);
 }
 
 static void
-hig_workarea_add_tall_control( GtkWidget * t, guint row, GtkWidget * control )
+hig_workarea_add_tall_control (GtkWidget * t, guint row, GtkWidget * control)
 {
-    if( GTK_IS_MISC( control ) )
-        gtk_misc_set_alignment( GTK_MISC( control ), 0.0f, 0.5f );
+    if (GTK_IS_MISC (control))
+        gtk_misc_set_alignment (GTK_MISC (control), 0.0f, 0.5f);
 
-    g_object_set( control, "expand", TRUE, NULL );
-    gtk_grid_attach( GTK_GRID( t ), control, 1, row, 1, 1 );
+    g_object_set (control, "expand", TRUE, NULL);
+    gtk_grid_attach (GTK_GRID (t), control, 1, row, 1, 1);
 }
 
 static void
-hig_workarea_add_control( GtkWidget * t, guint row, GtkWidget * control )
+hig_workarea_add_control (GtkWidget * t, guint row, GtkWidget * control)
 {
-    if( GTK_IS_MISC( control ) )
-        gtk_misc_set_alignment( GTK_MISC( control ), 0.0f, 0.5f );
+    if (GTK_IS_MISC (control))
+        gtk_misc_set_alignment (GTK_MISC (control), 0.0f, 0.5f);
 
-    gtk_widget_set_hexpand( control, TRUE );
-    gtk_grid_attach( GTK_GRID( t ), control, 1, row, 1, 1 );
+    gtk_widget_set_hexpand (control, TRUE);
+    gtk_grid_attach (GTK_GRID (t), control, 1, row, 1, 1);
 }
 
 void
-hig_workarea_add_row_w( GtkWidget * t,
+hig_workarea_add_row_w (GtkWidget * t,
                         guint     * row,
                         GtkWidget * label,
                         GtkWidget * control,
-                        GtkWidget * mnemonic )
+                        GtkWidget * mnemonic)
 {
-    hig_workarea_add_label_w( t, *row, label );
-    hig_workarea_add_control( t, *row, control );
-    if( GTK_IS_LABEL( label ) )
-        gtk_label_set_mnemonic_widget( GTK_LABEL( label ),
-                                       mnemonic ? mnemonic : control );
+    hig_workarea_add_label_w (t, *row, label);
+    hig_workarea_add_control (t, *row, control);
+    if (GTK_IS_LABEL (label))
+        gtk_label_set_mnemonic_widget (GTK_LABEL (label),
+                                       mnemonic ? mnemonic : control);
     ++ * row;
 }
 
 GtkWidget*
-hig_workarea_add_row( GtkWidget  * t,
+hig_workarea_add_row (GtkWidget  * t,
                       guint      * row,
                       const char * mnemonic_string,
                       GtkWidget  * control,
-                      GtkWidget  * mnemonic )
+                      GtkWidget  * mnemonic)
 {
-    GtkWidget * l = gtk_label_new_with_mnemonic( mnemonic_string );
+    GtkWidget * l = gtk_label_new_with_mnemonic (mnemonic_string);
 
-    hig_workarea_add_row_w( t, row, l, control, mnemonic );
+    hig_workarea_add_row_w (t, row, l, control, mnemonic);
     return l;
 }
 
 GtkWidget*
-hig_workarea_add_tall_row( GtkWidget  * table,
+hig_workarea_add_tall_row (GtkWidget  * table,
                            guint      * row,
                            const char * mnemonic_string,
                            GtkWidget  * control,
-                           GtkWidget  * mnemonic )
+                           GtkWidget  * mnemonic)
 {
-    GtkWidget * l = gtk_label_new_with_mnemonic( mnemonic_string );
-    GtkWidget * h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 );
-    GtkWidget * v = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
-    gtk_box_pack_start( GTK_BOX( h ), l, FALSE, FALSE, 0 );
-    gtk_box_pack_start( GTK_BOX( v ), h, FALSE, FALSE, GUI_PAD_SMALL );
-
-    hig_workarea_add_label_w( table, *row, v );
-    hig_workarea_add_tall_control( table, *row, control );
-
-    if( GTK_IS_LABEL( l ) )
-        gtk_label_set_mnemonic_widget( GTK_LABEL( l ),
-                                       mnemonic ? mnemonic : control );
+    GtkWidget * l = gtk_label_new_with_mnemonic (mnemonic_string);
+    GtkWidget * h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+    GtkWidget * v = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+    gtk_box_pack_start (GTK_BOX (h), l, FALSE, FALSE, 0);
+    gtk_box_pack_start (GTK_BOX (v), h, FALSE, FALSE, GUI_PAD_SMALL);
+
+    hig_workarea_add_label_w (table, *row, v);
+    hig_workarea_add_tall_control (table, *row, control);
+
+    if (GTK_IS_LABEL (l))
+        gtk_label_set_mnemonic_widget (GTK_LABEL (l),
+                                       mnemonic ? mnemonic : control);
 
     ++ * row;
     return l;
diff --git a/gtk/hig.h b/gtk/hig.h
index db6fe5eec..1915c1406 100644
--- a/gtk/hig.h
+++ b/gtk/hig.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -20,53 +20,53 @@
 *** see section 8.2.2, Visual Design > Window Layout > Dialogs.
 **/
 
-GtkWidget* hig_workarea_create( void );
+GtkWidget* hig_workarea_create (void);
 
-void       hig_workarea_add_section_divider( GtkWidget * table,
-                                             guint     *  row );
+void       hig_workarea_add_section_divider (GtkWidget * table,
+                                             guint     *  row);
 
-void       hig_workarea_add_section_title_widget( GtkWidget * t,
+void       hig_workarea_add_section_title_widget (GtkWidget * t,
                                                   guint     * row,
-                                                  GtkWidget * w );
+                                                  GtkWidget * w);
 
-void       hig_workarea_add_section_title( GtkWidget  *  table,
+void       hig_workarea_add_section_title (GtkWidget  *  table,
                                            guint      * row,
-                                           const char * section_title );
+                                           const char * section_title);
 
-void       hig_workarea_add_wide_tall_control( GtkWidget * table,
+void       hig_workarea_add_wide_tall_control (GtkWidget * table,
                                                guint     * row,
-                                               GtkWidget * w );
+                                               GtkWidget * w);
 
-void       hig_workarea_add_wide_control( GtkWidget * table,
+void       hig_workarea_add_wide_control (GtkWidget * table,
                                           guint     * row,
-                                          GtkWidget * w );
+                                          GtkWidget * w);
 
-GtkWidget* hig_workarea_add_wide_checkbutton( GtkWidget  * table,
+GtkWidget* hig_workarea_add_wide_checkbutton (GtkWidget  * table,
                                               guint      * row,
                                               const char * mnemonic_string,
-                                              gboolean     is_active );
+                                              gboolean     is_active);
 
-void       hig_workarea_add_label_w( GtkWidget * table,
+void       hig_workarea_add_label_w (GtkWidget * table,
                                      guint       row,
-                                     GtkWidget * label_widget );
+                                     GtkWidget * label_widget);
 
-GtkWidget* hig_workarea_add_tall_row( GtkWidget  * table,
+GtkWidget* hig_workarea_add_tall_row (GtkWidget  * table,
                                       guint      * row,
                                       const char * mnemonic_string,
                                       GtkWidget  * control,
-                                      GtkWidget  * mnemonic_or_null_for_control );
+                                      GtkWidget  * mnemonic_or_null_for_control);
 
-GtkWidget* hig_workarea_add_row( GtkWidget  * table,
+GtkWidget* hig_workarea_add_row (GtkWidget  * table,
                                  guint      * row,
                                  const char * mnemonic_string,
                                  GtkWidget  * control,
-                                 GtkWidget  * mnemonic_or_null_for_control );
+                                 GtkWidget  * mnemonic_or_null_for_control);
 
-void       hig_workarea_add_row_w( GtkWidget * table,
+void       hig_workarea_add_row_w (GtkWidget * table,
                                    guint     * row,
                                    GtkWidget * label,
                                    GtkWidget * control,
-                                   GtkWidget * mnemonic_or_null_for_control );
+                                   GtkWidget * mnemonic_or_null_for_control);
 
 enum
 {
diff --git a/gtk/icon-lock.h b/gtk/icon-lock.h
index 157f5c437..1297c289c 100644
--- a/gtk/icon-lock.h
+++ b/gtk/icon-lock.h
@@ -4,7 +4,7 @@
  #pragma align 4 (tr_icon_lock)
 #endif
 #ifdef __GNUC__
-static const guint8 tr_icon_lock[] __attribute__ ( ( __aligned__ ( 4 ) ) )
+static const guint8 tr_icon_lock[] __attribute__ ((__aligned__ (4)))
     =
 #else
 static const guint8 tr_icon_lock[] =
diff --git a/gtk/icon-logo-24.h b/gtk/icon-logo-24.h
index 26df3a526..152abbbe4 100644
--- a/gtk/icon-logo-24.h
+++ b/gtk/icon-logo-24.h
@@ -54,7 +54,7 @@ static const guint8 tr_icon_logo_24[] =
   "UWS7hkg\361\215\220\215\377\201\204\177\377\357\361\356\377\377\377\377"
   "\377\311\315\310\377hki\377HML\377\202;@A\377\11MQP\377rvs\377\355\356"
   "\353\377\376\376\376\377\330\334\325\377Z\\W\377\243\245\242\377`b^\363"
-  "UWS(\204\0\0\0\0\24UWSXwzw\362\206\211\205\377\232\234\230\377\305\310"
+  "UWS (\204\0\0\0\0\24UWSXwzw\362\206\211\205\377\232\234\230\377\305\310"
   "\303\377\203\205\201\377{~z\377oqm\377QTP\377QUQ\377RTP\377RUQ\377}\200"
   "|\377\201\203\177\377\227\233\227\377\321\323\316\377kni\377\234\237"
   "\234\377psn\361UWSM\204\0\0\0\0\24UWSy\211\213\210\374\201\203\200\377"
diff --git a/gtk/icon-logo-48.h b/gtk/icon-logo-48.h
index 052b10ff0..114a34834 100644
--- a/gtk/icon-logo-48.h
+++ b/gtk/icon-logo-48.h
@@ -4,7 +4,7 @@
  #pragma align 4 (tr_icon_logo)
 #endif
 #ifdef __GNUC__
-static const guint8 tr_icon_logo_48[] __attribute__ ( ( __aligned__ ( 4 ) ) )
+static const guint8 tr_icon_logo_48[] __attribute__ ((__aligned__ (4)))
     =
 #else
 static const guint8 tr_icon_logo_48[] =
@@ -89,7 +89,7 @@ static const guint8 tr_icon_logo_48[] =
                         "\360\360\357\377\354\354\352\377\354\354\352\377\354\354\352\377\354"
                         "\354\352\377\360\360\356\377\223\215\210\377\334\22\22\377\345\6\6\377"
                         "\345\6\6\377\345\6\6\377\345\6\6\377\345\6\6\377\345\6\6\377\345\6\6"
-                        "\377\345\11\11\377\350((\377\353^^\377\227\2\2\370\231\0\0\17\377\377"
+                        "\377\345\11\11\377\350 ((\377\353^^\377\227\2\2\370\231\0\0\17\377\377"
                         "\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377"
                         "\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377"
                         "\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377\377\0\223\0"
@@ -102,7 +102,7 @@ static const guint8 tr_icon_logo_48[] =
                         "\0\0\30\377\377\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377"
                         "\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377"
                         "\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377\377\0\377\377"
-                        "\377\0\223\0\0\375\302((\377\276\20\20\377\272\1\1\377\272\0\0\377\272"
+                        "\377\0\223\0\0\375\302 ((\377\276\20\20\377\272\1\1\377\272\0\0\377\272"
                         "\0\0\377\272\0\0\377\272\0\0\377\272\0\0\377\272\0\0\377\272\0\0\377"
                         "\270\4\4\377\213\213\206\377\352\353\350\377\344\345\342\377\344\345"
                         "\342\377\344\345\342\377\344\345\342\377\352\352\350\377\221\214\207"
diff --git a/gtk/icons.c b/gtk/icons.c
index 99b4b9859..e69457f92 100644
--- a/gtk/icons.c
+++ b/gtk/icons.c
@@ -15,17 +15,17 @@
 #define VOID_PIXBUF_KEY "void-pixbuf"
 
 static const char *
-get_static_string( const char *s )
+get_static_string (const char *s)
 {
     static GStringChunk * static_strings = NULL;
 
-     if( s == NULL )
+     if (s == NULL)
          return NULL;
 
-     if( static_strings == NULL )
-         static_strings = g_string_chunk_new( 1024 );
+     if (static_strings == NULL)
+         static_strings = g_string_chunk_new (1024);
 
-    return g_string_chunk_insert_const( static_strings, s );
+    return g_string_chunk_insert_const (static_strings, s);
 }
 
 typedef struct {
@@ -44,28 +44,28 @@ create_void_pixbuf (int width,
 {
     GdkPixbuf *p;
 
-    p = gdk_pixbuf_new( GDK_COLORSPACE_RGB,
+    p = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
                         TRUE,
                         8,
                         width,
                         height);
-    gdk_pixbuf_fill( p, 0xFFFFFF00 );
+    gdk_pixbuf_fill (p, 0xFFFFFF00);
 
     return p;
 }
 
 
 static int
-get_size_in_pixels( GtkWidget   * widget,
-                    GtkIconSize   icon_size )
+get_size_in_pixels (GtkWidget   * widget,
+                    GtkIconSize   icon_size)
 {
     int width, height;
 
-    gtk_icon_size_lookup_for_settings( gtk_widget_get_settings( widget ),
+    gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (widget),
                                        icon_size,
                                        &width,
-                                       &height );
-    return MAX( width, height );
+                                       &height);
+    return MAX (width, height);
 }
 
 
@@ -74,46 +74,46 @@ icon_cache_new (GtkWidget * for_widget, int icon_size)
 {
     IconCache * icon_cache;
 
-    g_return_val_if_fail( for_widget != NULL, NULL );
+    g_return_val_if_fail (for_widget != NULL, NULL);
 
-    icon_cache = g_new0( IconCache, 1 );
-    icon_cache->icon_theme = gtk_icon_theme_get_for_screen( gtk_widget_get_screen( for_widget ));
-    icon_cache->icon_size = get_size_in_pixels( for_widget, icon_size );
+    icon_cache = g_new0 (IconCache, 1);
+    icon_cache->icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (for_widget));
+    icon_cache->icon_size = get_size_in_pixels (for_widget, icon_size);
     icon_cache->cache = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
 
-    g_hash_table_insert( icon_cache->cache, (void*)VOID_PIXBUF_KEY, create_void_pixbuf( icon_cache->icon_size, icon_cache->icon_size ));
+    g_hash_table_insert (icon_cache->cache, (void*)VOID_PIXBUF_KEY, create_void_pixbuf (icon_cache->icon_size, icon_cache->icon_size));
 
     return icon_cache;
 }
 
 static const char *
-_icon_cache_get_icon_key( GIcon * icon )
+_icon_cache_get_icon_key (GIcon * icon)
 {
     const char * key = NULL;
 
-    if ( G_IS_THEMED_ICON( icon )) {
+    if (G_IS_THEMED_ICON (icon)) {
         char ** icon_names;
         char  * name;
 
-        g_object_get( icon, "names", &icon_names, NULL );
-        name = g_strjoinv( ",", icon_names );
+        g_object_get (icon, "names", &icon_names, NULL);
+        name = g_strjoinv (",", icon_names);
 
-        key = get_static_string( name );
+        key = get_static_string (name);
 
-        g_free( name );
-        g_strfreev( icon_names );
+        g_free (name);
+        g_strfreev (icon_names);
     }
-    else if ( G_IS_FILE_ICON( icon )) {
+    else if (G_IS_FILE_ICON (icon)) {
         GFile * file;
         char  * filename;
 
-        file = g_file_icon_get_file( G_FILE_ICON( icon ));
-        filename = g_file_get_path( file );
+        file = g_file_icon_get_file (G_FILE_ICON (icon));
+        filename = g_file_get_path (file);
 
-        key = get_static_string( filename );
+        key = get_static_string (filename);
 
-        g_free( filename );
-        g_object_unref( file );
+        g_free (filename);
+        g_object_unref (file);
     }
 
     return key;
@@ -121,102 +121,102 @@ _icon_cache_get_icon_key( GIcon * icon )
 
 
 static GdkPixbuf *
-get_themed_icon_pixbuf( GThemedIcon   * icon,
+get_themed_icon_pixbuf (GThemedIcon   * icon,
                         int             size,
-                        GtkIconTheme  * icon_theme )
+                        GtkIconTheme  * icon_theme)
 {
     char        ** icon_names = NULL;
     GtkIconInfo  * icon_info;
     GdkPixbuf    * pixbuf;
     GError       * error = NULL;
 
-    g_object_get( icon, "names", &icon_names, NULL );
+    g_object_get (icon, "names", &icon_names, NULL);
 
-    icon_info = gtk_icon_theme_choose_icon( icon_theme, (const char **)icon_names, size, 0 );
-    if ( icon_info == NULL )
-        icon_info = gtk_icon_theme_lookup_icon( icon_theme, "text-x-generic", size, GTK_ICON_LOOKUP_USE_BUILTIN );
+    icon_info = gtk_icon_theme_choose_icon (icon_theme, (const char **)icon_names, size, 0);
+    if (icon_info == NULL)
+        icon_info = gtk_icon_theme_lookup_icon (icon_theme, "text-x-generic", size, GTK_ICON_LOOKUP_USE_BUILTIN);
 
-    pixbuf = gtk_icon_info_load_icon( icon_info, &error );
-    if ( pixbuf == NULL ) {
-        if( error && error->message )
-            g_warning( "could not load icon pixbuf: %s\n", error->message );
-        g_clear_error( &error );
+    pixbuf = gtk_icon_info_load_icon (icon_info, &error);
+    if (pixbuf == NULL) {
+        if (error && error->message)
+            g_warning ("could not load icon pixbuf: %s\n", error->message);
+        g_clear_error (&error);
     }
 
-    gtk_icon_info_free( icon_info );
-    g_strfreev( icon_names );
+    gtk_icon_info_free (icon_info);
+    g_strfreev (icon_names);
 
     return pixbuf;
 }
 
 
 static GdkPixbuf *
-get_file_icon_pixbuf( GFileIcon * icon, int size )
+get_file_icon_pixbuf (GFileIcon * icon, int size)
 {
     GFile     * file;
     char      * filename;
     GdkPixbuf * pixbuf;
 
-    file = g_file_icon_get_file( icon );
-    filename = g_file_get_path( file );
-    pixbuf = gdk_pixbuf_new_from_file_at_size( filename, size, -1, NULL );
-    g_free( filename );
-    g_object_unref( file );
+    file = g_file_icon_get_file (icon);
+    filename = g_file_get_path (file);
+    pixbuf = gdk_pixbuf_new_from_file_at_size (filename, size, -1, NULL);
+    g_free (filename);
+    g_object_unref (file);
 
     return pixbuf;
 }
 
 
 static GdkPixbuf *
-_get_icon_pixbuf( GIcon * icon, int size, GtkIconTheme * theme )
+_get_icon_pixbuf (GIcon * icon, int size, GtkIconTheme * theme)
 {
-    if ( icon == NULL )
+    if (icon == NULL)
         return NULL;
-    if ( G_IS_THEMED_ICON (icon) )
-        return get_themed_icon_pixbuf( G_THEMED_ICON( icon ), size, theme );
-    if ( G_IS_FILE_ICON (icon) )
-        return get_file_icon_pixbuf( G_FILE_ICON( icon ), size );
+    if (G_IS_THEMED_ICON (icon))
+        return get_themed_icon_pixbuf (G_THEMED_ICON (icon), size, theme);
+    if (G_IS_FILE_ICON (icon))
+        return get_file_icon_pixbuf (G_FILE_ICON (icon), size);
     return NULL;
 }
 
 
 static GdkPixbuf *
-icon_cache_get_mime_type_icon( IconCache * icon_cache, const char * mime_type )
+icon_cache_get_mime_type_icon (IconCache * icon_cache, const char * mime_type)
 {
     GIcon      * icon;
     const char * key = NULL;
     GdkPixbuf  * pixbuf;
 
-    icon = g_content_type_get_icon( mime_type );
-    key = _icon_cache_get_icon_key( icon );
+    icon = g_content_type_get_icon (mime_type);
+    key = _icon_cache_get_icon_key (icon);
 
     if (key == NULL)
         key = VOID_PIXBUF_KEY;
 
-    pixbuf = g_hash_table_lookup( icon_cache->cache, key );
+    pixbuf = g_hash_table_lookup (icon_cache->cache, key);
     if (pixbuf != NULL) {
-        g_object_ref( pixbuf );
-        g_object_unref( G_OBJECT( icon ) );
+        g_object_ref (pixbuf);
+        g_object_unref (G_OBJECT (icon));
         return pixbuf;
     }
 
-    pixbuf = _get_icon_pixbuf( icon, icon_cache->icon_size, icon_cache->icon_theme );
-    if( pixbuf != NULL )
-        g_hash_table_insert( icon_cache->cache, (gpointer) key, g_object_ref( pixbuf ) );
+    pixbuf = _get_icon_pixbuf (icon, icon_cache->icon_size, icon_cache->icon_theme);
+    if (pixbuf != NULL)
+        g_hash_table_insert (icon_cache->cache, (gpointer) key, g_object_ref (pixbuf));
 
-    g_object_unref( G_OBJECT( icon ) );
+    g_object_unref (G_OBJECT (icon));
 
     return pixbuf;
 }
 
 GdkPixbuf *
-gtr_get_mime_type_icon( const char   * mime_type,
+gtr_get_mime_type_icon (const char   * mime_type,
                         GtkIconSize    icon_size,
-                        GtkWidget    * for_widget )
+                        GtkWidget    * for_widget)
 {
     int n;
 
-    switch ( icon_size ) {
+    switch (icon_size) {
         case GTK_ICON_SIZE_MENU:            n = 1; break;
         case GTK_ICON_SIZE_SMALL_TOOLBAR:   n = 2; break;
         case GTK_ICON_SIZE_LARGE_TOOLBAR:   n = 3; break;
@@ -226,18 +226,18 @@ gtr_get_mime_type_icon( const char   * mime_type,
         default /*GTK_ICON_SIZE_INVALID*/:  n = 0; break;
     }
 
-    if( icon_cache[n] == NULL )
-        icon_cache[n] = icon_cache_new( for_widget, icon_size );
+    if (icon_cache[n] == NULL)
+        icon_cache[n] = icon_cache_new (for_widget, icon_size);
 
-    return icon_cache_get_mime_type_icon( icon_cache[n], mime_type );
+    return icon_cache_get_mime_type_icon (icon_cache[n], mime_type);
 }
 
 
 const char *
-gtr_get_mime_type_from_filename( const char * file G_GNUC_UNUSED )
+gtr_get_mime_type_from_filename (const char * file G_GNUC_UNUSED)
 {
-    char * tmp = g_content_type_guess( file, NULL, 0, NULL );
-    const char * ret = get_static_string( tmp );
-    g_free( tmp );
+    char * tmp = g_content_type_guess (file, NULL, 0, NULL);
+    const char * ret = get_static_string (tmp);
+    g_free (tmp);
     return ret;
 }
diff --git a/gtk/icons.h b/gtk/icons.h
index 437a4fe3c..cc02f6a11 100644
--- a/gtk/icons.h
+++ b/gtk/icons.h
@@ -12,10 +12,10 @@
 #define DIRECTORY_MIME_TYPE "folder"
 #define UNKNOWN_MIME_TYPE "unknown"
 
-const char * gtr_get_mime_type_from_filename( const char *file );
+const char * gtr_get_mime_type_from_filename (const char *file);
 
-GdkPixbuf  * gtr_get_mime_type_icon( const char   * mime_type,
+GdkPixbuf  * gtr_get_mime_type_icon (const char   * mime_type,
                                      GtkIconSize    icon_size,
-                                     GtkWidget    * for_widget );
+                                     GtkWidget    * for_widget);
 
 #endif
diff --git a/gtk/main.c b/gtk/main.c
index 170156668..03e7a9d3b 100644
--- a/gtk/main.c
+++ b/gtk/main.c
@@ -26,7 +26,7 @@
 #include <signal.h>
 #include <string.h>
 #include <stdio.h>
-#include <stdlib.h> /* exit() */
+#include <stdlib.h> /* exit () */
 #include <time.h>
 
 #include <glib/gi18n.h>
@@ -65,35 +65,35 @@
 static const char * LICENSE =
 "The OS X client, CLI client, and parts of libtransmission are licensed under the terms of the MIT license.\n\n"
 "The Transmission daemon, GTK+ client, Qt client, Web client, and most of libtransmission are licensed under the terms of the GNU GPL version 2, with two special exceptions:\n\n"
-"1. The MIT-licensed portions of Transmission listed above are exempt from GPLv2 clause 2(b) and may retain their MIT license.\n\n"
+"1. The MIT-licensed portions of Transmission listed above are exempt from GPLv2 clause 2 (b) and may retain their MIT license.\n\n"
 "2. Permission is granted to link the code in this release with the OpenSSL project's 'OpenSSL' library and to distribute the linked executables. Works derived from Transmission may, at their authors' discretion, keep or delete this exception.";
 
 struct cbdata
 {
-    char                      * config_dir;
-    gboolean                    start_paused;
-    gboolean                    is_iconified;
-
-    guint                       activation_count;
-    guint                       timer;
-    guint                       update_model_soon_tag;
-    guint                       refresh_actions_tag;
-    gpointer                    icon;
-    GtkWindow                 * wind;
-    TrCore                    * core;
-    GtkWidget                 * msgwin;
-    GtkWidget                 * prefs;
-    GSList                    * error_list;
-    GSList                    * duplicates_list;
-    GSList                    * details;
-    GtkTreeSelection          * sel;
-    gpointer                    quit_dialog;
+  char * config_dir;
+  gboolean start_paused;
+  gboolean is_iconified;
+
+  guint activation_count;
+  guint timer;
+  guint update_model_soon_tag;
+  guint refresh_actions_tag;
+  gpointer icon;
+  GtkWindow * wind;
+  TrCore * core;
+  GtkWidget * msgwin;
+  GtkWidget * prefs;
+  GSList * error_list;
+  GSList * duplicates_list;
+  GSList * details;
+  GtkTreeSelection * sel;
+  gpointer quit_dialog;
 };
 
 static void
-gtr_window_present( GtkWindow * window )
+gtr_window_present (GtkWindow * window)
 {
-    gtk_window_present_with_time( window, gtk_get_current_event_time( ) );
+  gtk_window_present_with_time (window, gtk_get_current_event_time ());
 }
 
 /***
@@ -103,79 +103,79 @@ gtr_window_present( GtkWindow * window )
 ***/
 
 static int
-compare_integers( gconstpointer a, gconstpointer b )
+compare_integers (gconstpointer a, gconstpointer b)
 {
-    return GPOINTER_TO_INT(a) - GPOINTER_TO_INT(b);
+  return GPOINTER_TO_INT (a) - GPOINTER_TO_INT (b);
 }
 
 static char*
-get_details_dialog_key( GSList * id_list )
+get_details_dialog_key (GSList * id_list)
 {
-    GSList * l;
-    GSList * tmp = g_slist_sort( g_slist_copy( id_list ), compare_integers );
-    GString * gstr = g_string_new( NULL );
+  GSList * l;
+  GSList * tmp = g_slist_sort (g_slist_copy (id_list), compare_integers);
+  GString * gstr = g_string_new (NULL);
 
-    for( l=tmp; l!=NULL; l=l->next )
-        g_string_append_printf( gstr, "%d ", GPOINTER_TO_INT(l->data) );
+  for (l=tmp; l!=NULL; l=l->next)
+    g_string_append_printf (gstr, "%d ", GPOINTER_TO_INT (l->data));
 
-    g_slist_free( tmp );
-    return g_string_free( gstr, FALSE );
+  g_slist_free (tmp);
+  return g_string_free (gstr, FALSE);
 }
 
 static void
-get_selected_torrent_ids_foreach( GtkTreeModel  * model,
+get_selected_torrent_ids_foreach (GtkTreeModel  * model,
                                   GtkTreePath   * p UNUSED,
                                   GtkTreeIter   * iter,
-                                  gpointer        gdata )
+                                  gpointer        gdata)
 {
-    int id;
-    GSList ** ids = gdata;
-    gtk_tree_model_get( model, iter, MC_TORRENT_ID, &id, -1 );
-    *ids = g_slist_append( *ids, GINT_TO_POINTER( id ) );
+  int id;
+  GSList ** ids = gdata;
+  gtk_tree_model_get (model, iter, MC_TORRENT_ID, &id, -1);
+  *ids = g_slist_append (*ids, GINT_TO_POINTER (id));
 }
 static GSList*
-get_selected_torrent_ids( struct cbdata * data )
+get_selected_torrent_ids (struct cbdata * data)
 {
-    GSList * ids = NULL;
-    gtk_tree_selection_selected_foreach( data->sel,
-                                         get_selected_torrent_ids_foreach,
-                                         &ids );
-    return ids;
+  GSList * ids = NULL;
+  gtk_tree_selection_selected_foreach (data->sel,
+                                       get_selected_torrent_ids_foreach,
+                                       &ids);
+  return ids;
 }
 
 static void
-on_details_dialog_closed( gpointer gdata, GObject * dead )
+on_details_dialog_closed (gpointer gdata, GObject * dead)
 {
-    struct cbdata * data = gdata;
+  struct cbdata * data = gdata;
 
-    data->details = g_slist_remove( data->details, dead );
+  data->details = g_slist_remove (data->details, dead);
 }
 
 static void
-show_details_dialog_for_selected_torrents( struct cbdata * data )
+show_details_dialog_for_selected_torrents (struct cbdata * data)
 {
-    GtkWidget * dialog = NULL;
-    GSList * l;
-    GSList * ids = get_selected_torrent_ids( data );
-    char * key = get_details_dialog_key( ids );
+  GtkWidget * dialog = NULL;
+  GSList * l;
+  GSList * ids = get_selected_torrent_ids (data);
+  char * key = get_details_dialog_key (ids);
 
-    for( l=data->details; dialog==NULL && l!=NULL; l=l->next )
-        if( !strcmp( key, g_object_get_data( l->data, "key" ) ) )
-            dialog = l->data;
+  for (l=data->details; dialog==NULL && l!=NULL; l=l->next)
+    if (!strcmp (key, g_object_get_data (l->data, "key")))
+      dialog = l->data;
 
-    if( dialog == NULL )
+  if (dialog == NULL)
     {
-        dialog = gtr_torrent_details_dialog_new( GTK_WINDOW( data->wind ), data->core );
-        gtr_torrent_details_dialog_set_torrents( dialog, ids );
-        g_object_set_data_full( G_OBJECT( dialog ), "key", g_strdup( key ), g_free );
-        g_object_weak_ref( G_OBJECT( dialog ), on_details_dialog_closed, data );
-        data->details = g_slist_append( data->details, dialog );
-        gtk_widget_show( dialog );
+      dialog = gtr_torrent_details_dialog_new (GTK_WINDOW (data->wind), data->core);
+      gtr_torrent_details_dialog_set_torrents (dialog, ids);
+      g_object_set_data_full (G_OBJECT (dialog), "key", g_strdup (key), g_free);
+      g_object_weak_ref (G_OBJECT (dialog), on_details_dialog_closed, data);
+      data->details = g_slist_append (data->details, dialog);
+      gtk_widget_show (dialog);
     }
 
-    gtr_window_present( GTK_WINDOW( dialog ) );
-    g_free( key );
-    g_slist_free( ids );
+  gtr_window_present (GTK_WINDOW (dialog));
+  g_free (key);
+  g_slist_free (ids);
 }
 
 /****
@@ -186,103 +186,103 @@ show_details_dialog_for_selected_torrents( struct cbdata * data )
 
 struct counts_data
 {
-    int total_count;
-    int queued_count;
-    int stopped_count;
+  int total_count;
+  int queued_count;
+  int stopped_count;
 };
 
 static void
-get_selected_torrent_counts_foreach( GtkTreeModel * model, GtkTreePath * path UNUSED,
-                                     GtkTreeIter * iter, gpointer user_data )
+get_selected_torrent_counts_foreach (GtkTreeModel * model, GtkTreePath * path UNUSED,
+                                     GtkTreeIter * iter, gpointer user_data)
 {
-    int activity = 0;
-    struct counts_data * counts = user_data;
+  int activity = 0;
+  struct counts_data * counts = user_data;
 
-    ++counts->total_count;
+  ++counts->total_count;
 
-    gtk_tree_model_get( model, iter, MC_ACTIVITY, &activity, -1 );
+  gtk_tree_model_get (model, iter, MC_ACTIVITY, &activity, -1);
 
-    if( ( activity == TR_STATUS_DOWNLOAD_WAIT ) || ( activity == TR_STATUS_SEED_WAIT ) )
-        ++counts->queued_count;
+  if ((activity == TR_STATUS_DOWNLOAD_WAIT) || (activity == TR_STATUS_SEED_WAIT))
+    ++counts->queued_count;
 
-    if( activity == TR_STATUS_STOPPED )
-        ++counts->stopped_count;
+  if (activity == TR_STATUS_STOPPED)
+    ++counts->stopped_count;
 }
 
 static void
-get_selected_torrent_counts( struct cbdata * data, struct counts_data * counts )
+get_selected_torrent_counts (struct cbdata * data, struct counts_data * counts)
 {
-    counts->total_count = 0;
-    counts->queued_count = 0;
-    counts->stopped_count = 0;
+  counts->total_count = 0;
+  counts->queued_count = 0;
+  counts->stopped_count = 0;
 
-    gtk_tree_selection_selected_foreach( data->sel, get_selected_torrent_counts_foreach, counts );
+  gtk_tree_selection_selected_foreach (data->sel, get_selected_torrent_counts_foreach, counts);
 }
 
 static void
-count_updatable_foreach( GtkTreeModel * model, GtkTreePath * path UNUSED,
-                         GtkTreeIter * iter, gpointer accumulated_status )
+count_updatable_foreach (GtkTreeModel * model, GtkTreePath * path UNUSED,
+                         GtkTreeIter * iter, gpointer accumulated_status)
 {
-    tr_torrent * tor;
-    gtk_tree_model_get( model, iter, MC_TORRENT, &tor, -1 );
-    *(int*)accumulated_status |= tr_torrentCanManualUpdate( tor );
+  tr_torrent * tor;
+  gtk_tree_model_get (model, iter, MC_TORRENT, &tor, -1);
+  *(int*)accumulated_status |= tr_torrentCanManualUpdate (tor);
 }
 
 static gboolean
-refresh_actions( gpointer gdata )
+refresh_actions (gpointer gdata)
 {
-    int canUpdate;
-    struct counts_data sel_counts;
-    struct cbdata * data = gdata;
-    const size_t total = gtr_core_get_torrent_count( data->core );
-    const size_t active = gtr_core_get_active_torrent_count( data->core );
-    const int torrent_count = gtk_tree_model_iter_n_children( gtr_core_model( data->core ), NULL );
-    bool has_selection;
-
-    get_selected_torrent_counts( data, &sel_counts );
-    has_selection = sel_counts.total_count > 0;
-
-    gtr_action_set_sensitive( "select-all", torrent_count != 0 );
-    gtr_action_set_sensitive( "deselect-all", torrent_count != 0 );
-    gtr_action_set_sensitive( "pause-all-torrents", active != 0 );
-    gtr_action_set_sensitive( "start-all-torrents", active != total );
-
-    gtr_action_set_sensitive( "torrent-stop", ( sel_counts.stopped_count < sel_counts.total_count ) );
-    gtr_action_set_sensitive( "torrent-start", ( sel_counts.stopped_count ) > 0 );
-    gtr_action_set_sensitive( "torrent-start-now", ( sel_counts.stopped_count + sel_counts.queued_count ) > 0 );
-    gtr_action_set_sensitive( "torrent-verify",          has_selection );
-    gtr_action_set_sensitive( "remove-torrent",          has_selection );
-    gtr_action_set_sensitive( "delete-torrent",          has_selection );
-    gtr_action_set_sensitive( "relocate-torrent",        has_selection );
-    gtr_action_set_sensitive( "queue-move-top",          has_selection );
-    gtr_action_set_sensitive( "queue-move-up",           has_selection );
-    gtr_action_set_sensitive( "queue-move-down",         has_selection );
-    gtr_action_set_sensitive( "queue-move-bottom",       has_selection );
-    gtr_action_set_sensitive( "show-torrent-properties", has_selection );
-    gtr_action_set_sensitive( "open-torrent-folder", sel_counts.total_count == 1 );
-    gtr_action_set_sensitive( "copy-magnet-link-to-clipboard", sel_counts.total_count == 1 );
-
-    canUpdate = 0;
-    gtk_tree_selection_selected_foreach( data->sel, count_updatable_foreach, &canUpdate );
-    gtr_action_set_sensitive( "torrent-reannounce", canUpdate != 0 );
-
-    data->refresh_actions_tag = 0;
-    return FALSE;
+  int canUpdate;
+  struct counts_data sel_counts;
+  struct cbdata * data = gdata;
+  const size_t total = gtr_core_get_torrent_count (data->core);
+  const size_t active = gtr_core_get_active_torrent_count (data->core);
+  const int torrent_count = gtk_tree_model_iter_n_children (gtr_core_model (data->core), NULL);
+  bool has_selection;
+
+  get_selected_torrent_counts (data, &sel_counts);
+  has_selection = sel_counts.total_count > 0;
+
+  gtr_action_set_sensitive ("select-all", torrent_count != 0);
+  gtr_action_set_sensitive ("deselect-all", torrent_count != 0);
+  gtr_action_set_sensitive ("pause-all-torrents", active != 0);
+  gtr_action_set_sensitive ("start-all-torrents", active != total);
+
+  gtr_action_set_sensitive ("torrent-stop", (sel_counts.stopped_count < sel_counts.total_count));
+  gtr_action_set_sensitive ("torrent-start", (sel_counts.stopped_count) > 0);
+  gtr_action_set_sensitive ("torrent-start-now", (sel_counts.stopped_count + sel_counts.queued_count) > 0);
+  gtr_action_set_sensitive ("torrent-verify",          has_selection);
+  gtr_action_set_sensitive ("remove-torrent",          has_selection);
+  gtr_action_set_sensitive ("delete-torrent",          has_selection);
+  gtr_action_set_sensitive ("relocate-torrent",        has_selection);
+  gtr_action_set_sensitive ("queue-move-top",          has_selection);
+  gtr_action_set_sensitive ("queue-move-up",           has_selection);
+  gtr_action_set_sensitive ("queue-move-down",         has_selection);
+  gtr_action_set_sensitive ("queue-move-bottom",       has_selection);
+  gtr_action_set_sensitive ("show-torrent-properties", has_selection);
+  gtr_action_set_sensitive ("open-torrent-folder", sel_counts.total_count == 1);
+  gtr_action_set_sensitive ("copy-magnet-link-to-clipboard", sel_counts.total_count == 1);
+
+  canUpdate = 0;
+  gtk_tree_selection_selected_foreach (data->sel, count_updatable_foreach, &canUpdate);
+  gtr_action_set_sensitive ("torrent-reannounce", canUpdate != 0);
+
+  data->refresh_actions_tag = 0;
+  return FALSE;
 }
 
 static void
-refresh_actions_soon( gpointer gdata )
+refresh_actions_soon (gpointer gdata)
 {
-    struct cbdata * data = gdata;
+  struct cbdata * data = gdata;
 
-    if( data->refresh_actions_tag == 0 )
-        data->refresh_actions_tag = gdk_threads_add_idle( refresh_actions, data );
+  if (data->refresh_actions_tag == 0)
+    data->refresh_actions_tag = gdk_threads_add_idle (refresh_actions, data);
 }
 
 static void
-on_selection_changed( GtkTreeSelection * s UNUSED, gpointer gdata )
+on_selection_changed (GtkTreeSelection * s UNUSED, gpointer gdata)
 {
-    refresh_actions_soon( gdata );
+  refresh_actions_soon (gdata);
 }
 
 /***
@@ -290,43 +290,43 @@ on_selection_changed( GtkTreeSelection * s UNUSED, gpointer gdata )
 ***/
 
 static void
-register_magnet_link_handler( void )
+register_magnet_link_handler (void)
 {
-    GAppInfo * app_info = g_app_info_get_default_for_uri_scheme( "magnet" );
-    if( app_info == NULL )
-    {
-        /* there's no default magnet handler, so register ourselves for the job... */
-        GError * error = NULL;
-        app_info = g_app_info_create_from_commandline( "transmission-gtk", "transmission-gtk", G_APP_INFO_CREATE_SUPPORTS_URIS, NULL );
-        g_app_info_set_as_default_for_type( app_info, "x-scheme-handler/magnet", &error );
-        if( error != NULL )
+  GAppInfo * app_info = g_app_info_get_default_for_uri_scheme ("magnet");
+  if (app_info == NULL)
+    {
+      /* there's no default magnet handler, so register ourselves for the job... */
+      GError * error = NULL;
+      app_info = g_app_info_create_from_commandline ("transmission-gtk", "transmission-gtk", G_APP_INFO_CREATE_SUPPORTS_URIS, NULL);
+      g_app_info_set_as_default_for_type (app_info, "x-scheme-handler/magnet", &error);
+      if (error != NULL)
         {
-            g_warning( _( "Error registering Transmission as x-scheme-handler/magnet handler: %s" ), error->message );
-            g_clear_error( &error );
+          g_warning (_("Error registering Transmission as x-scheme-handler/magnet handler: %s"), error->message);
+          g_clear_error (&error);
         }
     }
 }
 
 static void
-on_main_window_size_allocated( GtkWidget      * gtk_window,
+on_main_window_size_allocated (GtkWidget      * gtk_window,
                                GtkAllocation  * alloc UNUSED,
-                               gpointer         gdata UNUSED )
+                               gpointer         gdata UNUSED)
 {
-    GdkWindow * gdk_window = gtk_widget_get_window( gtk_window );
-    const gboolean isMaximized = ( gdk_window != NULL )
-                              && ( gdk_window_get_state( gdk_window ) & GDK_WINDOW_STATE_MAXIMIZED );
+  GdkWindow * gdk_window = gtk_widget_get_window (gtk_window);
+  const gboolean isMaximized = (gdk_window != NULL)
+                            && (gdk_window_get_state (gdk_window) & GDK_WINDOW_STATE_MAXIMIZED);
 
-    gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, isMaximized );
+  gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, isMaximized);
 
-    if( !isMaximized )
+  if (!isMaximized)
     {
-        int x, y, w, h;
-        gtk_window_get_position( GTK_WINDOW( gtk_window ), &x, &y );
-        gtk_window_get_size( GTK_WINDOW( gtk_window ), &w, &h );
-        gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_X, x );
-        gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_Y, y );
-        gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_WIDTH, w );
-        gtr_pref_int_set( PREF_KEY_MAIN_WINDOW_HEIGHT, h );
+      int x, y, w, h;
+      gtk_window_get_position (GTK_WINDOW (gtk_window), &x, &y);
+      gtk_window_get_size (GTK_WINDOW (gtk_window), &w, &h);
+      gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_X, x);
+      gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_Y, y);
+      gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_WIDTH, w);
+      gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_HEIGHT, h);
     }
 }
 
@@ -336,118 +336,121 @@ on_main_window_size_allocated( GtkWidget      * gtk_window,
 
 struct rpc_idle_data
 {
-    TrCore * core;
-    int id;
-    gboolean delete_files;
+  TrCore * core;
+  int id;
+  gboolean delete_files;
 };
 
 static gboolean
-rpc_torrent_remove_idle( gpointer gdata )
+rpc_torrent_remove_idle (gpointer gdata)
 {
-    struct rpc_idle_data * data = gdata;
+  struct rpc_idle_data * data = gdata;
 
-    gtr_core_remove_torrent( data->core, data->id, data->delete_files );
+  gtr_core_remove_torrent (data->core, data->id, data->delete_files);
 
-    g_free( data );
-    return FALSE; /* tell g_idle not to call this func twice */
+  g_free (data);
+  return FALSE; /* tell g_idle not to call this func twice */
 }
 
 static gboolean
-rpc_torrent_add_idle( gpointer gdata )
+rpc_torrent_add_idle (gpointer gdata)
 {
-    tr_torrent * tor;
-    struct rpc_idle_data * data = gdata;
+  tr_torrent * tor;
+  struct rpc_idle_data * data = gdata;
 
-    if(( tor = gtr_core_find_torrent( data->core, data->id )))
-        gtr_core_add_torrent( data->core, tor, TRUE );
+  if ((tor = gtr_core_find_torrent (data->core, data->id)))
+    gtr_core_add_torrent (data->core, tor, TRUE);
 
-    g_free( data );
-    return FALSE; /* tell g_idle not to call this func twice */
+  g_free (data);
+  return FALSE; /* tell g_idle not to call this func twice */
 }
 
 static tr_rpc_callback_status
-on_rpc_changed( tr_session            * session,
+on_rpc_changed (tr_session            * session,
                 tr_rpc_callback_type    type,
                 struct tr_torrent     * tor,
-                void                  * gdata )
+                void                  * gdata)
 {
-    tr_rpc_callback_status status = TR_RPC_OK;
-    struct cbdata * cbdata = gdata;
-    gdk_threads_enter( );
-
-    switch( type )
-    {
-        case TR_RPC_SESSION_CLOSE:
-            gtr_action_activate( "quit" );
-            break;
-
-        case TR_RPC_TORRENT_ADDED: {
-            struct rpc_idle_data * data = g_new0( struct rpc_idle_data, 1 );
-            data->id = tr_torrentId( tor );
-            data->core = cbdata->core;
-            gdk_threads_add_idle( rpc_torrent_add_idle, data );
-            break;
-        }
+  tr_rpc_callback_status status = TR_RPC_OK;
+  struct cbdata * cbdata = gdata;
+  gdk_threads_enter ();
+
+  switch (type)
+    {
+      case TR_RPC_SESSION_CLOSE:
+        gtr_action_activate ("quit");
+        break;
+
+      case TR_RPC_TORRENT_ADDED: {
+        struct rpc_idle_data * data = g_new0 (struct rpc_idle_data, 1);
+        data->id = tr_torrentId (tor);
+        data->core = cbdata->core;
+        gdk_threads_add_idle (rpc_torrent_add_idle, data);
+        break;
+      }
 
-        case TR_RPC_TORRENT_REMOVING:
-        case TR_RPC_TORRENT_TRASHING: {
-            struct rpc_idle_data * data = g_new0( struct rpc_idle_data, 1 );
-            data->id = tr_torrentId( tor );
-            data->core = cbdata->core;
-            data->delete_files = type == TR_RPC_TORRENT_TRASHING;
-            gdk_threads_add_idle( rpc_torrent_remove_idle, data );
-            status = TR_RPC_NOREMOVE;
-            break;
-        }
+      case TR_RPC_TORRENT_REMOVING:
+      case TR_RPC_TORRENT_TRASHING: {
+        struct rpc_idle_data * data = g_new0 (struct rpc_idle_data, 1);
+        data->id = tr_torrentId (tor);
+        data->core = cbdata->core;
+        data->delete_files = type == TR_RPC_TORRENT_TRASHING;
+        gdk_threads_add_idle (rpc_torrent_remove_idle, data);
+        status = TR_RPC_NOREMOVE;
+        break;
+      }
 
-        case TR_RPC_SESSION_CHANGED: {
-            int i;
-            tr_benc tmp;
-            tr_benc * newval;
-            tr_benc * oldvals = gtr_pref_get_all( );
-            const char * key;
-            GSList * l;
-            GSList * changed_keys = NULL;
-            tr_bencInitDict( &tmp, 100 );
-            tr_sessionGetSettings( session, &tmp );
-            for( i=0; tr_bencDictChild( &tmp, i, &key, &newval ); ++i )
-            {
-                bool changed;
-                tr_benc * oldval = tr_bencDictFind( oldvals, key );
-                if( !oldval )
-                    changed = true;
-                else {
-                    char * a = tr_bencToStr( oldval, TR_FMT_BENC, NULL );
-                    char * b = tr_bencToStr( newval, TR_FMT_BENC, NULL );
-                    changed = strcmp( a, b ) != 0;
-                    tr_free( b );
-                    tr_free( a );
-                }
-
-                if( changed )
-                    changed_keys = g_slist_append( changed_keys, (gpointer)key );
-            }
-            tr_sessionGetSettings( session, oldvals );
-
-            for( l=changed_keys; l!=NULL; l=l->next )
-                gtr_core_pref_changed( cbdata->core, l->data );
-
-            g_slist_free( changed_keys );
-            tr_bencFree( &tmp );
-            break;
-        }
+      case TR_RPC_SESSION_CHANGED: {
+        int i;
+        tr_benc tmp;
+        tr_benc * newval;
+        tr_benc * oldvals = gtr_pref_get_all ();
+        const char * key;
+        GSList * l;
+        GSList * changed_keys = NULL;
+        tr_bencInitDict (&tmp, 100);
+        tr_sessionGetSettings (session, &tmp);
+        for (i=0; tr_bencDictChild (&tmp, i, &key, &newval); ++i)
+          {
+            bool changed;
+            tr_benc * oldval = tr_bencDictFind (oldvals, key);
+            if (!oldval)
+              {
+                changed = true;
+              }
+            else
+              {
+                char * a = tr_bencToStr (oldval, TR_FMT_BENC, NULL);
+                char * b = tr_bencToStr (newval, TR_FMT_BENC, NULL);
+                changed = strcmp (a, b) != 0;
+                tr_free (b);
+                tr_free (a);
+              }
+
+            if (changed)
+              changed_keys = g_slist_append (changed_keys, (gpointer)key);
+          }
+        tr_sessionGetSettings (session, oldvals);
+
+        for (l=changed_keys; l!=NULL; l=l->next)
+          gtr_core_pref_changed (cbdata->core, l->data);
+
+        g_slist_free (changed_keys);
+        tr_bencFree (&tmp);
+        break;
+      }
 
-        case TR_RPC_TORRENT_CHANGED:
-        case TR_RPC_TORRENT_MOVED:
-        case TR_RPC_TORRENT_STARTED:
-        case TR_RPC_TORRENT_STOPPED:
-        case TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED:
-            /* nothing interesting to do here */
-            break;
+      case TR_RPC_TORRENT_CHANGED:
+      case TR_RPC_TORRENT_MOVED:
+      case TR_RPC_TORRENT_STARTED:
+      case TR_RPC_TORRENT_STOPPED:
+      case TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED:
+        /* nothing interesting to do here */
+        break;
     }
 
-    gdk_threads_leave( );
-    return status;
+  gdk_threads_leave ();
+  return status;
 }
 
 /***
@@ -458,17 +461,17 @@ static sig_atomic_t global_sigcount = 0;
 static struct cbdata * sighandler_cbdata = NULL;
 
 static void
-signal_handler( int sig )
+signal_handler (int sig)
 {
-    if( ++global_sigcount > 1 )
+  if (++global_sigcount > 1)
     {
-        signal( sig, SIG_DFL );
-        raise( sig );
+      signal (sig, SIG_DFL);
+      raise (sig);
     }
-    else if(( sig == SIGINT ) || ( sig == SIGTERM ))
+  else if ((sig == SIGINT) || (sig == SIGTERM))
     {
-        g_message( _( "Got signal %d; trying to shut down cleanly. Do it again if it gets stuck." ), sig );
-        gtr_actions_handler( "quit", sighandler_cbdata );
+      g_message (_("Got signal %d; trying to shut down cleanly. Do it again if it gets stuck."), sig);
+      gtr_actions_handler ("quit", sighandler_cbdata);
     }
 }
 
@@ -477,90 +480,92 @@ signal_handler( int sig )
 *****
 ****/
 
-static void app_setup( GtkWindow * wind, struct cbdata  * cbdata );
+static void app_setup (GtkWindow * wind, struct cbdata  * cbdata);
 
 static void
-on_startup( GApplication * application, gpointer user_data )
+on_startup (GApplication * application, gpointer user_data)
 {
-    GError * error;
-    const char * str;
-    GtkWindow * win;
-    GtkUIManager * ui_manager;
-    tr_session * session;
-    struct cbdata * cbdata = user_data;
-
-    signal( SIGINT, signal_handler );
-    signal( SIGTERM, signal_handler );
-
-    sighandler_cbdata = cbdata;
-
-    /* ensure the directories are created */
-    if(( str = gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR )))
-      g_mkdir_with_parents( str, 0777 );
-    if(( str = gtr_pref_string_get( TR_PREFS_KEY_INCOMPLETE_DIR )))
-      g_mkdir_with_parents( str, 0777 );
-
-    /* initialize the libtransmission session */
-    session = tr_sessionInit( "gtk", cbdata->config_dir, TRUE, gtr_pref_get_all( ) );
-
-    gtr_pref_flag_set( TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( session ) );
-    gtr_pref_int_set( TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( session ) );
-    cbdata->core = gtr_core_new( session );
-
-    /* init the ui manager */
-    error = NULL;
-    ui_manager = gtk_ui_manager_new ( );
-    gtr_actions_init ( ui_manager, cbdata );
-    gtk_ui_manager_add_ui_from_resource ( ui_manager, TR_RESOURCE_PATH "transmission-ui.xml", &error );
-    g_assert_no_error (error);
-    gtk_ui_manager_ensure_update ( ui_manager );
-
-    /* create main window now to be a parent to any error dialogs */
-    win = GTK_WINDOW( gtr_window_new( GTK_APPLICATION( application ), ui_manager, cbdata->core ) );
-    g_signal_connect( win, "size-allocate", G_CALLBACK( on_main_window_size_allocated ), cbdata );
-    g_application_hold( application );
-    g_object_weak_ref( G_OBJECT( win ), (GWeakNotify)g_application_release, application );
-    app_setup( win, cbdata );
-    tr_sessionSetRPCCallback( session, on_rpc_changed, cbdata );
-
-    /* check & see if it's time to update the blocklist */
-    if( gtr_pref_flag_get( TR_PREFS_KEY_BLOCKLIST_ENABLED ) ) {
-      if( gtr_pref_flag_get( PREF_KEY_BLOCKLIST_UPDATES_ENABLED ) ) {
-        const int64_t last_time = gtr_pref_int_get( "blocklist-date" );
-        const int SECONDS_IN_A_WEEK = 7 * 24 * 60 * 60;
-        const time_t now = time( NULL );
-        if( last_time + SECONDS_IN_A_WEEK < now )
-          gtr_core_blocklist_update( cbdata->core );
-      }
+  GError * error;
+  const char * str;
+  GtkWindow * win;
+  GtkUIManager * ui_manager;
+  tr_session * session;
+  struct cbdata * cbdata = user_data;
+
+  signal (SIGINT, signal_handler);
+  signal (SIGTERM, signal_handler);
+
+  sighandler_cbdata = cbdata;
+
+  /* ensure the directories are created */
+  if ((str = gtr_pref_string_get (TR_PREFS_KEY_DOWNLOAD_DIR)))
+    g_mkdir_with_parents (str, 0777);
+  if ((str = gtr_pref_string_get (TR_PREFS_KEY_INCOMPLETE_DIR)))
+    g_mkdir_with_parents (str, 0777);
+
+  /* initialize the libtransmission session */
+  session = tr_sessionInit ("gtk", cbdata->config_dir, TRUE, gtr_pref_get_all ());
+
+  gtr_pref_flag_set (TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed (session));
+  gtr_pref_int_set (TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort (session));
+  cbdata->core = gtr_core_new (session);
+
+  /* init the ui manager */
+  error = NULL;
+  ui_manager = gtk_ui_manager_new ();
+  gtr_actions_init (ui_manager, cbdata);
+  gtk_ui_manager_add_ui_from_resource (ui_manager, TR_RESOURCE_PATH "transmission-ui.xml", &error);
+  g_assert_no_error (error);
+  gtk_ui_manager_ensure_update (ui_manager);
+
+  /* create main window now to be a parent to any error dialogs */
+  win = GTK_WINDOW (gtr_window_new (GTK_APPLICATION (application), ui_manager, cbdata->core));
+  g_signal_connect (win, "size-allocate", G_CALLBACK (on_main_window_size_allocated), cbdata);
+  g_application_hold (application);
+  g_object_weak_ref (G_OBJECT (win), (GWeakNotify)g_application_release, application);
+  app_setup (win, cbdata);
+  tr_sessionSetRPCCallback (session, on_rpc_changed, cbdata);
+
+  /* check & see if it's time to update the blocklist */
+  if (gtr_pref_flag_get (TR_PREFS_KEY_BLOCKLIST_ENABLED))
+    {
+      if (gtr_pref_flag_get (PREF_KEY_BLOCKLIST_UPDATES_ENABLED))
+        {
+          const int64_t last_time = gtr_pref_int_get ("blocklist-date");
+          const int SECONDS_IN_A_WEEK = 7 * 24 * 60 * 60;
+          const time_t now = time (NULL);
+          if (last_time + SECONDS_IN_A_WEEK < now)
+            gtr_core_blocklist_update (cbdata->core);
+        }
     }
 
-    /* if there's no magnet link handler registered, register us */
-    register_magnet_link_handler( );
+  /* if there's no magnet link handler registered, register us */
+  register_magnet_link_handler ();
 }
 
 static void
-on_activate( GApplication * app UNUSED, struct cbdata * cbdata )
+on_activate (GApplication * app UNUSED, struct cbdata * cbdata)
 {
-    cbdata->activation_count++;
+  cbdata->activation_count++;
 
-    /* GApplication emits an 'activate' signal when bootstrapping the primary.
-     * Ordinarily we handle that by presenting the main window, but if the user
-     * user started Transmission minimized, ignore that initial signal... */
-    if( cbdata->is_iconified && ( cbdata->activation_count == 1 ) )
-        return;
+  /* GApplication emits an 'activate' signal when bootstrapping the primary.
+   * Ordinarily we handle that by presenting the main window, but if the user
+   * user started Transmission minimized, ignore that initial signal... */
+  if (cbdata->is_iconified && (cbdata->activation_count == 1))
+    return;
 
-    gtr_action_activate( "present-main-window" );
+  gtr_action_activate ("present-main-window");
 }
 
 static void
-open_files( GSList * files, gpointer gdata )
+open_files (GSList * files, gpointer gdata)
 {
-    struct cbdata * cbdata = gdata;
-    const gboolean do_start = gtr_pref_flag_get( TR_PREFS_KEY_START ) && !cbdata->start_paused;
-    const gboolean do_prompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
-    const gboolean do_notify = TRUE;
+  struct cbdata * cbdata = gdata;
+  const gboolean do_start = gtr_pref_flag_get (TR_PREFS_KEY_START) && !cbdata->start_paused;
+  const gboolean do_prompt = gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT);
+  const gboolean do_notify = TRUE;
 
-    gtr_core_add_files( cbdata->core, files, do_start, do_prompt, do_notify );
+  gtr_core_add_files (cbdata->core, files, do_start, do_prompt, do_notify);
 }
 
 static void
@@ -568,17 +573,17 @@ on_open (GApplication  * application UNUSED,
          GFile        ** f,
          gint            file_count,
          gchar         * hint UNUSED,
-         gpointer        gdata )
+         gpointer        gdata)
 {
-    int i;
-    GSList * files = NULL;
+  int i;
+  GSList * files = NULL;
 
-    for( i=0; i<file_count; ++i )
-        files = g_slist_prepend( files, f[i] );
+  for (i=0; i<file_count; i++)
+    files = g_slist_prepend (files, f[i]);
 
-    open_files( files, gdata );
+  open_files (files, gdata);
 
-    g_slist_free( files );
+  g_slist_free (files);
 }
 
 /***
@@ -586,1016 +591,1025 @@ on_open (GApplication  * application UNUSED,
 ***/
 
 int
-main( int argc, char ** argv )
+main (int argc, char ** argv)
 {
-    int ret;
-    struct stat sb;
-    char * application_id;
-    GtkApplication * app;
-    GOptionContext * option_context;
-    bool show_version = false;
-    GError * error = NULL;
-    struct cbdata cbdata;
-
-    GOptionEntry option_entries[] = {
-        { "config-dir", 'g', 0, G_OPTION_ARG_FILENAME, &cbdata.config_dir, _( "Where to look for configuration files" ), NULL },
-        { "paused",     'p', 0, G_OPTION_ARG_NONE, &cbdata.start_paused, _( "Start with all torrents paused" ), NULL },
-        { "minimized",  'm', 0, G_OPTION_ARG_NONE, &cbdata.is_iconified, _( "Start minimized in notification area" ), NULL },
-        { "version",    'v', 0, G_OPTION_ARG_NONE, &show_version, _( "Show version number and exit" ), NULL },
-        { NULL, 0,   0, 0, NULL, NULL, NULL }
-    };
-
-    /* default settings */
-    memset( &cbdata, 0, sizeof( struct cbdata ) );
-    cbdata.config_dir = (char*) tr_getDefaultConfigDir( MY_CONFIG_NAME );
-
-    /* init i18n */
-    setlocale( LC_ALL, "" );
-    bindtextdomain( MY_READABLE_NAME, TRANSMISSIONLOCALEDIR );
-    bind_textdomain_codeset( MY_READABLE_NAME, "UTF-8" );
-    textdomain( MY_READABLE_NAME );
-
-    /* init glib/gtk */
-    g_type_init ();
-    gtk_init (&argc, &argv);
-    g_set_application_name (_( "Transmission" ));
-    gtk_window_set_default_icon_name (MY_CONFIG_NAME);
-
-    /* parse the command line */
-    option_context = g_option_context_new( _( "[torrent files or urls]" ) );
-    g_option_context_add_main_entries( option_context, option_entries, GETTEXT_PACKAGE );
-    g_option_context_set_translation_domain( option_context, GETTEXT_PACKAGE );
-    if( !g_option_context_parse( option_context, &argc, &argv, &error ) ) {
-        g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"), error->message, argv[0]);
-        g_error_free (error);
-        g_option_context_free (option_context);
-        return 1;
-    }
-    g_option_context_free (option_context);
-
-    /* handle the trivial "version" option */
-    if( show_version ) {
-        fprintf( stderr, "%s %s\n", MY_READABLE_NAME, LONG_VERSION_STRING );
-        return 0;
-    }
-
-    /* init the unit formatters */
-    tr_formatter_mem_init( mem_K, _(mem_K_str), _(mem_M_str), _(mem_G_str), _(mem_T_str) );
-    tr_formatter_size_init( disk_K, _(disk_K_str), _(disk_M_str), _(disk_G_str), _(disk_T_str) );
-    tr_formatter_speed_init( speed_K, _(speed_K_str), _(speed_M_str), _(speed_G_str), _(speed_T_str) );
-
-    /* set up the config dir */
-    gtr_pref_init( cbdata.config_dir );
-    g_mkdir_with_parents( cbdata.config_dir, 0755 );
-
-    /* init notifications */
-    gtr_notify_init( );
-
-    /* init the application for the specified config dir */
-    stat( cbdata.config_dir, &sb );
-    application_id = g_strdup_printf( "com.transmissionbt.transmission_%lu_%lu", (unsigned long)sb.st_dev, (unsigned long)sb.st_ino );
-    app = gtk_application_new( application_id, G_APPLICATION_HANDLES_OPEN );
-    g_signal_connect( app, "open", G_CALLBACK(on_open), &cbdata );
-    g_signal_connect( app, "startup", G_CALLBACK(on_startup), &cbdata );
-    g_signal_connect( app, "activate", G_CALLBACK(on_activate), &cbdata );
-    ret = g_application_run( G_APPLICATION( app ), argc, argv);
-    g_object_unref( app );
-    g_free( application_id );
-    return ret;
+  int ret;
+  struct stat sb;
+  char * application_id;
+  GtkApplication * app;
+  GOptionContext * option_context;
+  bool show_version = false;
+  GError * error = NULL;
+  struct cbdata cbdata;
+
+  GOptionEntry option_entries[] = {
+    { "config-dir", 'g', 0, G_OPTION_ARG_FILENAME, &cbdata.config_dir, _("Where to look for configuration files"), NULL },
+    { "paused",     'p', 0, G_OPTION_ARG_NONE, &cbdata.start_paused, _("Start with all torrents paused"), NULL },
+    { "minimized",  'm', 0, G_OPTION_ARG_NONE, &cbdata.is_iconified, _("Start minimized in notification area"), NULL },
+    { "version",    'v', 0, G_OPTION_ARG_NONE, &show_version, _("Show version number and exit"), NULL },
+    { NULL, 0,   0, 0, NULL, NULL, NULL }
+  };
+
+  /* default settings */
+  memset (&cbdata, 0, sizeof (struct cbdata));
+  cbdata.config_dir = (char*) tr_getDefaultConfigDir (MY_CONFIG_NAME);
+
+  /* init i18n */
+  setlocale (LC_ALL, "");
+  bindtextdomain (MY_READABLE_NAME, TRANSMISSIONLOCALEDIR);
+  bind_textdomain_codeset (MY_READABLE_NAME, "UTF-8");
+  textdomain (MY_READABLE_NAME);
+
+  /* init glib/gtk */
+  g_type_init ();
+  gtk_init (&argc, &argv);
+  g_set_application_name (_("Transmission"));
+  gtk_window_set_default_icon_name (MY_CONFIG_NAME);
+
+  /* parse the command line */
+  option_context = g_option_context_new (_("[torrent files or urls]"));
+  g_option_context_add_main_entries (option_context, option_entries, GETTEXT_PACKAGE);
+  g_option_context_set_translation_domain (option_context, GETTEXT_PACKAGE);
+  if (!g_option_context_parse (option_context, &argc, &argv, &error))
+    {
+      g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"), error->message, argv[0]);
+      g_error_free (error);
+      g_option_context_free (option_context);
+      return 1;
+    }
+  g_option_context_free (option_context);
+
+  /* handle the trivial "version" option */
+  if (show_version)
+    {
+      fprintf (stderr, "%s %s\n", MY_READABLE_NAME, LONG_VERSION_STRING);
+      return 0;
+    }
+
+  /* init the unit formatters */
+  tr_formatter_mem_init (mem_K, _ (mem_K_str), _ (mem_M_str), _ (mem_G_str), _ (mem_T_str));
+  tr_formatter_size_init (disk_K, _ (disk_K_str), _ (disk_M_str), _ (disk_G_str), _ (disk_T_str));
+  tr_formatter_speed_init (speed_K, _ (speed_K_str), _ (speed_M_str), _ (speed_G_str), _ (speed_T_str));
+
+  /* set up the config dir */
+  gtr_pref_init (cbdata.config_dir);
+  g_mkdir_with_parents (cbdata.config_dir, 0755);
+
+  /* init notifications */
+  gtr_notify_init ();
+
+  /* init the application for the specified config dir */
+  stat (cbdata.config_dir, &sb);
+  application_id = g_strdup_printf ("com.transmissionbt.transmission_%lu_%lu", (unsigned long)sb.st_dev, (unsigned long)sb.st_ino);
+  app = gtk_application_new (application_id, G_APPLICATION_HANDLES_OPEN);
+  g_signal_connect (app, "open", G_CALLBACK (on_open), &cbdata);
+  g_signal_connect (app, "startup", G_CALLBACK (on_startup), &cbdata);
+  g_signal_connect (app, "activate", G_CALLBACK (on_activate), &cbdata);
+  ret = g_application_run (G_APPLICATION (app), argc, argv);
+  g_object_unref (app);
+  g_free (application_id);
+  return ret;
 }
 
 static void
-on_core_busy( TrCore * core UNUSED, gboolean busy, struct cbdata * c )
+on_core_busy (TrCore * core UNUSED, gboolean busy, struct cbdata * c)
 {
-    gtr_window_set_busy( c->wind, busy );
+  gtr_window_set_busy (c->wind, busy);
 }
 
-static void on_core_error( TrCore *, guint, const char *, struct cbdata * );
-static void on_add_torrent( TrCore *, tr_ctor *, gpointer );
-static void on_prefs_changed( TrCore * core, const char * key, gpointer );
-static void main_window_setup( struct cbdata * cbdata, GtkWindow * wind );
-static gboolean update_model_loop( gpointer gdata );
-static gboolean update_model_once( gpointer gdata );
+static void on_core_error (TrCore *, guint, const char *, struct cbdata *);
+static void on_add_torrent (TrCore *, tr_ctor *, gpointer);
+static void on_prefs_changed (TrCore * core, const char * key, gpointer);
+static void main_window_setup (struct cbdata * cbdata, GtkWindow * wind);
+static gboolean update_model_loop (gpointer gdata);
+static gboolean update_model_once (gpointer gdata);
 
 static void
-app_setup( GtkWindow * wind, struct cbdata * cbdata )
+app_setup (GtkWindow * wind, struct cbdata * cbdata)
 {
-    if( cbdata->is_iconified )
-        gtr_pref_flag_set( PREF_KEY_SHOW_TRAY_ICON, TRUE );
-
-    gtr_actions_set_core( cbdata->core );
-
-    /* set up core handlers */
-    g_signal_connect( cbdata->core, "busy", G_CALLBACK( on_core_busy ), cbdata );
-    g_signal_connect( cbdata->core, "add-error", G_CALLBACK( on_core_error ), cbdata );
-    g_signal_connect( cbdata->core, "add-prompt", G_CALLBACK( on_add_torrent ), cbdata );
-    g_signal_connect( cbdata->core, "prefs-changed", G_CALLBACK( on_prefs_changed ), cbdata );
-
-    /* add torrents from command-line and saved state */
-    gtr_core_load( cbdata->core, cbdata->start_paused );
-    gtr_core_torrents_added( cbdata->core );
-
-    /* set up main window */
-    main_window_setup( cbdata, wind );
-
-    /* set up the icon */
-    on_prefs_changed( cbdata->core, PREF_KEY_SHOW_TRAY_ICON, cbdata );
-
-    /* start model update timer */
-    cbdata->timer = gdk_threads_add_timeout_seconds( MAIN_WINDOW_REFRESH_INTERVAL_SECONDS, update_model_loop, cbdata );
-    update_model_once( cbdata );
-
-    /* either show the window or iconify it */
-    if( !cbdata->is_iconified )
-        gtk_widget_show( GTK_WIDGET( wind ) );
-    else
-    {
-        gtk_window_set_skip_taskbar_hint( cbdata->wind,
-                                          cbdata->icon != NULL );
-        cbdata->is_iconified = FALSE; // ensure that the next toggle iconifies
-        gtr_action_set_toggled( "toggle-main-window", FALSE );
-    }
-
-    if( !gtr_pref_flag_get( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT ) )
-    {
-        GtkWidget * w = gtk_message_dialog_new( GTK_WINDOW( wind ),
-                                                GTK_DIALOG_DESTROY_WITH_PARENT,
-                                                GTK_MESSAGE_INFO,
-                                                GTK_BUTTONS_NONE,
-                                                "%s",
-             _( "Transmission is a file-sharing program. When you run a torrent, its data will be made available to others by means of upload. You and you alone are fully responsible for exercising proper judgement and abiding by your local laws." ) );
-        gtk_dialog_add_button( GTK_DIALOG( w ), GTK_STOCK_QUIT, GTK_RESPONSE_REJECT );
-        gtk_dialog_add_button( GTK_DIALOG( w ), _( "I _Accept" ), GTK_RESPONSE_ACCEPT );
-        gtk_dialog_set_default_response( GTK_DIALOG( w ), GTK_RESPONSE_ACCEPT );
-        switch( gtk_dialog_run( GTK_DIALOG( w ) ) ) {
-            case GTK_RESPONSE_ACCEPT:
-                /* only show it once */
-                gtr_pref_flag_set( PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, TRUE );
-                gtk_widget_destroy( w );
-                break;
-            default:
-                exit( 0 );
+  if (cbdata->is_iconified)
+    gtr_pref_flag_set (PREF_KEY_SHOW_TRAY_ICON, TRUE);
+
+  gtr_actions_set_core (cbdata->core);
+
+  /* set up core handlers */
+  g_signal_connect (cbdata->core, "busy", G_CALLBACK (on_core_busy), cbdata);
+  g_signal_connect (cbdata->core, "add-error", G_CALLBACK (on_core_error), cbdata);
+  g_signal_connect (cbdata->core, "add-prompt", G_CALLBACK (on_add_torrent), cbdata);
+  g_signal_connect (cbdata->core, "prefs-changed", G_CALLBACK (on_prefs_changed), cbdata);
+
+  /* add torrents from command-line and saved state */
+  gtr_core_load (cbdata->core, cbdata->start_paused);
+  gtr_core_torrents_added (cbdata->core);
+
+  /* set up main window */
+  main_window_setup (cbdata, wind);
+
+  /* set up the icon */
+  on_prefs_changed (cbdata->core, PREF_KEY_SHOW_TRAY_ICON, cbdata);
+
+  /* start model update timer */
+  cbdata->timer = gdk_threads_add_timeout_seconds (MAIN_WINDOW_REFRESH_INTERVAL_SECONDS, update_model_loop, cbdata);
+  update_model_once (cbdata);
+
+  /* either show the window or iconify it */
+  if (!cbdata->is_iconified)
+    {
+      gtk_widget_show (GTK_WIDGET (wind));
+    }
+  else
+    {
+      gtk_window_set_skip_taskbar_hint (cbdata->wind,
+                                        cbdata->icon != NULL);
+      cbdata->is_iconified = FALSE; // ensure that the next toggle iconifies
+      gtr_action_set_toggled ("toggle-main-window", FALSE);
+    }
+
+  if (!gtr_pref_flag_get (PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT))
+    {
+      GtkWidget * w = gtk_message_dialog_new (GTK_WINDOW (wind),
+                                              GTK_DIALOG_DESTROY_WITH_PARENT,
+                                              GTK_MESSAGE_INFO,
+                                              GTK_BUTTONS_NONE,
+                                              "%s",
+        _("Transmission is a file-sharing program. When you run a torrent, its data will be made available to others by means of upload. You and you alone are fully responsible for exercising proper judgement and abiding by your local laws."));
+      gtk_dialog_add_button (GTK_DIALOG (w), GTK_STOCK_QUIT, GTK_RESPONSE_REJECT);
+      gtk_dialog_add_button (GTK_DIALOG (w), _("I _Accept"), GTK_RESPONSE_ACCEPT);
+      gtk_dialog_set_default_response (GTK_DIALOG (w), GTK_RESPONSE_ACCEPT);
+      switch (gtk_dialog_run (GTK_DIALOG (w)))
+        {
+          case GTK_RESPONSE_ACCEPT:
+            /* only show it once */
+            gtr_pref_flag_set (PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, TRUE);
+            gtk_widget_destroy (w);
+            break;
+
+          default:
+            exit (0);
         }
     }
 }
 
 static void
-presentMainWindow( struct cbdata * cbdata )
+presentMainWindow (struct cbdata * cbdata)
 {
-    GtkWindow * window = cbdata->wind;
+  GtkWindow * window = cbdata->wind;
 
-    if( cbdata->is_iconified )
+  if (cbdata->is_iconified)
     {
-        cbdata->is_iconified = false;
+      cbdata->is_iconified = false;
 
-        gtk_window_set_skip_taskbar_hint( window, FALSE );
+      gtk_window_set_skip_taskbar_hint (window, FALSE);
     }
 
-    if( !gtk_widget_get_visible( GTK_WIDGET( window ) ) )
+  if (!gtk_widget_get_visible (GTK_WIDGET (window)))
     {
-        gtk_window_resize( window, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
-                                   gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
-        gtk_window_move( window, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
-                                 gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
-        gtr_widget_set_visible( GTK_WIDGET( window ), TRUE );
+      gtk_window_resize (window, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_WIDTH),
+                                 gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_HEIGHT));
+      gtk_window_move (window, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_X),
+                               gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_Y));
+      gtr_widget_set_visible (GTK_WIDGET (window), TRUE);
     }
-    gtr_window_present( window );
+
+  gtr_window_present (window);
 }
 
 static void
-hideMainWindow( struct cbdata * cbdata )
+hideMainWindow (struct cbdata * cbdata)
 {
-    GtkWindow * window = cbdata->wind;
-    gtk_window_set_skip_taskbar_hint( window, TRUE );
-    gtr_widget_set_visible( GTK_WIDGET( window ), FALSE );
-    cbdata->is_iconified = true;
+  GtkWindow * window = cbdata->wind;
+  gtk_window_set_skip_taskbar_hint (window, TRUE);
+  gtr_widget_set_visible (GTK_WIDGET (window), FALSE);
+  cbdata->is_iconified = true;
 }
 
 static void
-toggleMainWindow( struct cbdata * cbdata )
+toggleMainWindow (struct cbdata * cbdata)
 {
-    if( cbdata->is_iconified )
-        presentMainWindow( cbdata );
-    else
-        hideMainWindow( cbdata );
+  if (cbdata->is_iconified)
+    presentMainWindow (cbdata);
+  else
+    hideMainWindow (cbdata);
 }
 
-static void on_app_exit( gpointer vdata );
+static void on_app_exit (gpointer vdata);
 
 static gboolean
-winclose( GtkWidget * w    UNUSED,
+winclose (GtkWidget * w    UNUSED,
           GdkEvent * event UNUSED,
-          gpointer         gdata )
+          gpointer         gdata)
 {
-    struct cbdata * cbdata = gdata;
+  struct cbdata * cbdata = gdata;
 
-    if( cbdata->icon != NULL )
-        gtr_action_activate ( "toggle-main-window" );
-    else
-        on_app_exit( cbdata );
+  if (cbdata->icon != NULL)
+    gtr_action_activate ("toggle-main-window");
+  else
+    on_app_exit (cbdata);
 
-    return TRUE; /* don't propagate event further */
+  return TRUE; /* don't propagate event further */
 }
 
 static void
-rowChangedCB( GtkTreeModel  * model UNUSED,
+rowChangedCB (GtkTreeModel  * model UNUSED,
               GtkTreePath   * path,
               GtkTreeIter   * iter  UNUSED,
-              gpointer        gdata )
+              gpointer        gdata)
 {
-    struct cbdata * data = gdata;
+  struct cbdata * data = gdata;
 
-    if( gtk_tree_selection_path_is_selected ( data->sel, path ) )
-        refresh_actions_soon( data );
+  if (gtk_tree_selection_path_is_selected (data->sel, path))
+    refresh_actions_soon (data);
 }
 
 static void
-on_drag_data_received( GtkWidget         * widget          UNUSED,
+on_drag_data_received (GtkWidget         * widget          UNUSED,
                        GdkDragContext    * drag_context,
                        gint                x               UNUSED,
                        gint                y               UNUSED,
                        GtkSelectionData  * selection_data,
                        guint               info            UNUSED,
                        guint               time_,
-                       gpointer            gdata )
+                       gpointer            gdata)
 {
-    guint i;
-    char ** uris = gtk_selection_data_get_uris( selection_data );
-    const guint file_count = g_strv_length( uris );
-    GSList * files = NULL;
+  guint i;
+  char ** uris = gtk_selection_data_get_uris (selection_data);
+  const guint file_count = g_strv_length (uris);
+  GSList * files = NULL;
 
-    for( i=0; i<file_count; ++i )
-        files = g_slist_prepend( files, g_file_new_for_uri( uris[i] ) );
+  for (i=0; i<file_count; ++i)
+    files = g_slist_prepend (files, g_file_new_for_uri (uris[i]));
 
-    open_files( files, gdata );
+  open_files (files, gdata);
 
-    /* cleanup */
-    g_slist_foreach( files, (GFunc)g_object_unref, NULL );
-    g_slist_free( files );
-    g_strfreev( uris );
+  /* cleanup */
+  g_slist_foreach (files, (GFunc)g_object_unref, NULL);
+  g_slist_free (files);
+  g_strfreev (uris);
 
-    gtk_drag_finish( drag_context, true, FALSE, time_ );
+  gtk_drag_finish (drag_context, true, FALSE, time_);
 }
 
 static void
-main_window_setup( struct cbdata * cbdata, GtkWindow * wind )
+main_window_setup (struct cbdata * cbdata, GtkWindow * wind)
 {
-    GtkWidget * w;
-    GtkTreeModel * model;
-    GtkTreeSelection * sel;
-
-    g_assert( NULL == cbdata->wind );
-    cbdata->wind = wind;
-    cbdata->sel = sel = GTK_TREE_SELECTION( gtr_window_get_selection( cbdata->wind ) );
-
-    g_signal_connect( sel, "changed", G_CALLBACK( on_selection_changed ), cbdata );
-    on_selection_changed( sel, cbdata );
-    model = gtr_core_model( cbdata->core );
-    g_signal_connect( model, "row-changed", G_CALLBACK( rowChangedCB ), cbdata );
-    g_signal_connect( wind, "delete-event", G_CALLBACK( winclose ), cbdata );
-    refresh_actions( cbdata );
-
-    /* register to handle URIs that get dragged onto our main window */
-    w = GTK_WIDGET( wind );
-    gtk_drag_dest_set( w, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY );
-    gtk_drag_dest_add_uri_targets( w );
-    g_signal_connect( w, "drag-data-received", G_CALLBACK(on_drag_data_received), cbdata );
+  GtkWidget * w;
+  GtkTreeModel * model;
+  GtkTreeSelection * sel;
+
+  g_assert (NULL == cbdata->wind);
+  cbdata->wind = wind;
+  cbdata->sel = sel = GTK_TREE_SELECTION (gtr_window_get_selection (cbdata->wind));
+
+  g_signal_connect (sel, "changed", G_CALLBACK (on_selection_changed), cbdata);
+  on_selection_changed (sel, cbdata);
+  model = gtr_core_model (cbdata->core);
+  g_signal_connect (model, "row-changed", G_CALLBACK (rowChangedCB), cbdata);
+  g_signal_connect (wind, "delete-event", G_CALLBACK (winclose), cbdata);
+  refresh_actions (cbdata);
+
+  /* register to handle URIs that get dragged onto our main window */
+  w = GTK_WIDGET (wind);
+  gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
+  gtk_drag_dest_add_uri_targets (w);
+  g_signal_connect (w, "drag-data-received", G_CALLBACK (on_drag_data_received), cbdata);
 }
 
 static gboolean
-on_session_closed( gpointer gdata )
+on_session_closed (gpointer gdata)
 {
-    GSList * tmp;
-    struct cbdata * cbdata = gdata;
-
-    tmp = g_slist_copy( cbdata->details );
-    g_slist_foreach( tmp, (GFunc)gtk_widget_destroy, NULL );
-    g_slist_free( tmp );
-
-    if( cbdata->prefs )
-        gtk_widget_destroy( GTK_WIDGET( cbdata->prefs ) );
-    if( cbdata->wind )
-        gtk_widget_destroy( GTK_WIDGET( cbdata->wind ) );
-    g_object_unref( cbdata->core );
-    if( cbdata->icon )
-        g_object_unref( cbdata->icon );
-    g_slist_foreach( cbdata->error_list, (GFunc)g_free, NULL );
-    g_slist_free( cbdata->error_list );
-    g_slist_foreach( cbdata->duplicates_list, (GFunc)g_free, NULL );
-    g_slist_free( cbdata->duplicates_list );
-
-    return FALSE;
+  GSList * tmp;
+  struct cbdata * cbdata = gdata;
+
+  tmp = g_slist_copy (cbdata->details);
+  g_slist_foreach (tmp, (GFunc)gtk_widget_destroy, NULL);
+  g_slist_free (tmp);
+
+  if (cbdata->prefs)
+    gtk_widget_destroy (GTK_WIDGET (cbdata->prefs));
+  if (cbdata->wind)
+    gtk_widget_destroy (GTK_WIDGET (cbdata->wind));
+  g_object_unref (cbdata->core);
+  if (cbdata->icon)
+    g_object_unref (cbdata->icon);
+  g_slist_foreach (cbdata->error_list, (GFunc)g_free, NULL);
+  g_slist_free (cbdata->error_list);
+  g_slist_foreach (cbdata->duplicates_list, (GFunc)g_free, NULL);
+  g_slist_free (cbdata->duplicates_list);
+
+  return FALSE;
 }
 
 static gpointer
-session_close_threadfunc( gpointer gdata )
+session_close_threadfunc (gpointer gdata)
 {
-    /* since tr_sessionClose() is a blocking function,
-     * call it from another thread... when it's done,
-     * punt the GUI teardown back to the GTK+ thread */
-    struct cbdata * cbdata = gdata;
-    gdk_threads_enter( );
-    gtr_core_close( cbdata->core );
-    gdk_threads_add_idle( on_session_closed, gdata );
-    gdk_threads_leave( );
-    return NULL;
+  /* since tr_sessionClose () is a blocking function,
+   * call it from another thread... when it's done,
+   * punt the GUI teardown back to the GTK+ thread */
+  struct cbdata * cbdata = gdata;
+  gdk_threads_enter ();
+  gtr_core_close (cbdata->core);
+  gdk_threads_add_idle (on_session_closed, gdata);
+  gdk_threads_leave ();
+  return NULL;
 }
 
 static void
-exit_now_cb( GtkWidget *w UNUSED, gpointer data UNUSED )
+exit_now_cb (GtkWidget *w UNUSED, gpointer data UNUSED)
 {
-    exit( 0 );
+  exit (0);
 }
 
 static void
-on_app_exit( gpointer vdata )
+on_app_exit (gpointer vdata)
 {
-    GtkWidget *r, *p, *b, *w, *c;
-    struct cbdata *cbdata = vdata;
+  GtkWidget *r, *p, *b, *w, *c;
+  struct cbdata *cbdata = vdata;
 
-    /* stop the update timer */
-    if( cbdata->timer )
+  /* stop the update timer */
+  if (cbdata->timer)
     {
-        g_source_remove( cbdata->timer );
-        cbdata->timer = 0;
+      g_source_remove (cbdata->timer);
+      cbdata->timer = 0;
     }
 
-    c = GTK_WIDGET( cbdata->wind );
-    gtk_container_remove( GTK_CONTAINER( c ), gtk_bin_get_child( GTK_BIN( c ) ) );
+  c = GTK_WIDGET (cbdata->wind);
+  gtk_container_remove (GTK_CONTAINER (c), gtk_bin_get_child (GTK_BIN (c)));
 
-    r = gtk_alignment_new( 0.5, 0.5, 0.01, 0.01 );
-    gtk_container_add( GTK_CONTAINER( c ), r );
+  r = gtk_alignment_new (0.5, 0.5, 0.01, 0.01);
+  gtk_container_add (GTK_CONTAINER (c), r);
 
-    p = gtk_grid_new( );
-    gtk_grid_set_column_spacing( GTK_GRID( p ), GUI_PAD_BIG );
-    gtk_container_add( GTK_CONTAINER( r ), p );
+  p = gtk_grid_new ();
+  gtk_grid_set_column_spacing (GTK_GRID (p), GUI_PAD_BIG);
+  gtk_container_add (GTK_CONTAINER (r), p);
 
-    w = gtk_image_new_from_stock( GTK_STOCK_NETWORK, GTK_ICON_SIZE_DIALOG );
-    gtk_grid_attach( GTK_GRID( p ), w, 0, 0, 1, 2 );
+  w = gtk_image_new_from_stock (GTK_STOCK_NETWORK, GTK_ICON_SIZE_DIALOG);
+  gtk_grid_attach (GTK_GRID (p), w, 0, 0, 1, 2);
 
-    w = gtk_label_new( NULL );
-    gtk_label_set_markup( GTK_LABEL( w ), _( "<b>Closing Connections</b>" ) );
-    gtk_misc_set_alignment( GTK_MISC( w ), 0.0, 0.5 );
-    gtk_grid_attach( GTK_GRID( p ), w, 1, 0, 1, 1 );
+  w = gtk_label_new (NULL);
+  gtk_label_set_markup (GTK_LABEL (w), _("<b>Closing Connections</b>"));
+  gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
+  gtk_grid_attach (GTK_GRID (p), w, 1, 0, 1, 1);
 
-    w = gtk_label_new( _( "Sending upload/download totals to tracker…" ) );
-    gtk_misc_set_alignment( GTK_MISC( w ), 0.0, 0.5 );
-    gtk_grid_attach( GTK_GRID( p ), w, 1, 1, 1, 1 );
+  w = gtk_label_new (_("Sending upload/download totals to tracker…"));
+  gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
+  gtk_grid_attach (GTK_GRID (p), w, 1, 1, 1, 1);
 
-    b = gtk_alignment_new( 0.0, 1.0, 0.01, 0.01 );
-    w = gtk_button_new_with_mnemonic( _( "_Quit Now" ) );
-    g_signal_connect( w, "clicked", G_CALLBACK( exit_now_cb ), NULL );
-    gtk_container_add( GTK_CONTAINER( b ), w );
-    gtk_grid_attach( GTK_GRID( p ), b, 1, 2, 1, 1 );
+  b = gtk_alignment_new (0.0, 1.0, 0.01, 0.01);
+  w = gtk_button_new_with_mnemonic (_("_Quit Now"));
+  g_signal_connect (w, "clicked", G_CALLBACK (exit_now_cb), NULL);
+  gtk_container_add (GTK_CONTAINER (b), w);
+  gtk_grid_attach (GTK_GRID (p), b, 1, 2, 1, 1);
 
-    gtk_widget_show_all( r );
-    gtk_widget_grab_focus( w );
+  gtk_widget_show_all (r);
+  gtk_widget_grab_focus (w);
 
-    /* clear the UI */
-    gtr_core_clear( cbdata->core );
+  /* clear the UI */
+  gtr_core_clear (cbdata->core);
 
-    /* ensure the window is in its previous position & size.
-     * this seems to be necessary because changing the main window's
-     * child seems to unset the size */
-    gtk_window_resize( cbdata->wind, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
-                                     gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
-    gtk_window_move( cbdata->wind, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
-                                   gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
+  /* ensure the window is in its previous position & size.
+   * this seems to be necessary because changing the main window's
+   * child seems to unset the size */
+  gtk_window_resize (cbdata->wind, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_WIDTH),
+                                   gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_HEIGHT));
+  gtk_window_move (cbdata->wind, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_X),
+                                 gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_Y));
 
-    /* shut down libT */
-    g_thread_new( "shutdown-thread", session_close_threadfunc, vdata );
+  /* shut down libT */
+  g_thread_new ("shutdown-thread", session_close_threadfunc, vdata);
 }
 
 static void
-show_torrent_errors( GtkWindow * window, const char * primary, GSList ** files )
+show_torrent_errors (GtkWindow * window, const char * primary, GSList ** files)
 {
-    GSList * l;
-    GtkWidget * w;
-    GString * s = g_string_new( NULL );
-    const char * leader = g_slist_length( *files ) > 1
-                        ? gtr_get_unicode_string( GTR_UNICODE_BULLET )
-                        : "";
-
-    for( l=*files; l!=NULL; l=l->next )
-        g_string_append_printf( s, "%s %s\n", leader, (const char*)l->data );
-
-    w = gtk_message_dialog_new( window,
-                                GTK_DIALOG_DESTROY_WITH_PARENT,
-                                GTK_MESSAGE_ERROR,
-                                GTK_BUTTONS_CLOSE,
-                                "%s", primary );
-    gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ),
-                                              "%s", s->str );
-    g_signal_connect_swapped( w, "response",
-                              G_CALLBACK( gtk_widget_destroy ), w );
-    gtk_widget_show( w );
-    g_string_free( s, TRUE );
-
-    g_slist_foreach( *files, (GFunc)g_free, NULL );
-    g_slist_free( *files );
-    *files = NULL;
+  GSList * l;
+  GtkWidget * w;
+  GString * s = g_string_new (NULL);
+  const char * leader = g_slist_length (*files) > 1
+                      ? gtr_get_unicode_string (GTR_UNICODE_BULLET)
+                      : "";
+
+  for (l=*files; l!=NULL; l=l->next)
+    g_string_append_printf (s, "%s %s\n", leader, (const char*)l->data);
+
+  w = gtk_message_dialog_new (window,
+                              GTK_DIALOG_DESTROY_WITH_PARENT,
+                              GTK_MESSAGE_ERROR,
+                              GTK_BUTTONS_CLOSE,
+                              "%s", primary);
+  gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w),
+                                            "%s", s->str);
+  g_signal_connect_swapped (w, "response",
+                            G_CALLBACK (gtk_widget_destroy), w);
+  gtk_widget_show (w);
+  g_string_free (s, TRUE);
+
+  g_slist_foreach (*files, (GFunc)g_free, NULL);
+  g_slist_free (*files);
+  *files = NULL;
 }
 
 static void
-flush_torrent_errors( struct cbdata * cbdata )
+flush_torrent_errors (struct cbdata * cbdata)
 {
-    if( cbdata->error_list )
-        show_torrent_errors( cbdata->wind,
-                              ngettext( "Couldn't add corrupt torrent",
-                                        "Couldn't add corrupt torrents",
-                                        g_slist_length( cbdata->error_list ) ),
-                              &cbdata->error_list );
-
-    if( cbdata->duplicates_list )
-        show_torrent_errors( cbdata->wind,
-                              ngettext( "Couldn't add duplicate torrent",
-                                        "Couldn't add duplicate torrents",
-                                        g_slist_length( cbdata->duplicates_list ) ),
-                              &cbdata->duplicates_list );
+  if (cbdata->error_list)
+    show_torrent_errors (cbdata->wind,
+                         ngettext ("Couldn't add corrupt torrent",
+                                   "Couldn't add corrupt torrents",
+                                   g_slist_length (cbdata->error_list)),
+                         &cbdata->error_list);
+
+  if (cbdata->duplicates_list)
+    show_torrent_errors (cbdata->wind,
+                         ngettext ("Couldn't add duplicate torrent",
+                                   "Couldn't add duplicate torrents",
+                                   g_slist_length (cbdata->duplicates_list)),
+                         &cbdata->duplicates_list);
 }
 
 static void
-on_core_error( TrCore * core UNUSED, guint code, const char * msg, struct cbdata * c )
+on_core_error (TrCore * core UNUSED, guint code, const char * msg, struct cbdata * c)
 {
-    switch( code )
+  switch (code)
     {
-        case TR_PARSE_ERR:
-            c->error_list =
-                g_slist_append( c->error_list, g_path_get_basename( msg ) );
-            break;
+      case TR_PARSE_ERR:
+        c->error_list = g_slist_append (c->error_list, g_path_get_basename (msg));
+        break;
 
-        case TR_PARSE_DUPLICATE:
-            c->duplicates_list = g_slist_append( c->duplicates_list, g_strdup( msg ) );
-            break;
+      case TR_PARSE_DUPLICATE:
+        c->duplicates_list = g_slist_append (c->duplicates_list, g_strdup (msg));
+        break;
 
-        case TR_CORE_ERR_NO_MORE_TORRENTS:
-            flush_torrent_errors( c );
-            break;
+      case TR_CORE_ERR_NO_MORE_TORRENTS:
+        flush_torrent_errors (c);
+        break;
 
-        default:
-            g_assert_not_reached( );
-            break;
+      default:
+        g_assert_not_reached ();
+        break;
     }
 }
 
 static gboolean
-on_main_window_focus_in( GtkWidget      * widget UNUSED,
+on_main_window_focus_in (GtkWidget      * widget UNUSED,
                          GdkEventFocus  * event  UNUSED,
-                         gpointer                gdata )
+                         gpointer         gdata)
 {
-    struct cbdata * cbdata = gdata;
+  struct cbdata * cbdata = gdata;
+
+  if (cbdata->wind)
+    gtk_window_set_urgency_hint (cbdata->wind, FALSE);
 
-    if( cbdata->wind )
-        gtk_window_set_urgency_hint( cbdata->wind, FALSE );
-    return FALSE;
+  return FALSE;
 }
 
 static void
-on_add_torrent( TrCore * core, tr_ctor * ctor, gpointer gdata )
+on_add_torrent (TrCore * core, tr_ctor * ctor, gpointer gdata)
 {
-    struct cbdata * cbdata = gdata;
-    GtkWidget * w = gtr_torrent_options_dialog_new( cbdata->wind, core, ctor );
+  struct cbdata * cbdata = gdata;
+  GtkWidget * w = gtr_torrent_options_dialog_new (cbdata->wind, core, ctor);
 
-    g_signal_connect( w, "focus-in-event",
-                      G_CALLBACK( on_main_window_focus_in ),  cbdata );
-    if( cbdata->wind )
-        gtk_window_set_urgency_hint( cbdata->wind, TRUE );
+  g_signal_connect (w, "focus-in-event",
+                    G_CALLBACK (on_main_window_focus_in),  cbdata);
+  if (cbdata->wind)
+    gtk_window_set_urgency_hint (cbdata->wind, TRUE);
 
-    gtk_widget_show( w );
+  gtk_widget_show (w);
 }
 
 static void
-on_prefs_changed( TrCore * core UNUSED, const char * key, gpointer data )
+on_prefs_changed (TrCore * core UNUSED, const char * key, gpointer data)
 {
-    struct cbdata * cbdata = data;
-    tr_session * tr = gtr_core_session( cbdata->core );
+  struct cbdata * cbdata = data;
+  tr_session * tr = gtr_core_session (cbdata->core);
 
-    if( !strcmp( key, TR_PREFS_KEY_ENCRYPTION ) )
+  if (!strcmp (key, TR_PREFS_KEY_ENCRYPTION))
     {
-        tr_sessionSetEncryption( tr, gtr_pref_int_get( key ) );
+      tr_sessionSetEncryption (tr, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_DOWNLOAD_DIR ) )
+  else if (!strcmp (key, TR_PREFS_KEY_DOWNLOAD_DIR))
     {
-        tr_sessionSetDownloadDir( tr, gtr_pref_string_get( key ) );
+      tr_sessionSetDownloadDir (tr, gtr_pref_string_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_MSGLEVEL ) )
+  else if (!strcmp (key, TR_PREFS_KEY_MSGLEVEL))
     {
-        tr_setMessageLevel( gtr_pref_int_get( key ) );
+      tr_setMessageLevel (gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
+  else if (!strcmp (key, TR_PREFS_KEY_PEER_PORT))
     {
-        tr_sessionSetPeerPort( tr, gtr_pref_int_get( key ) );
+      tr_sessionSetPeerPort (tr, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_BLOCKLIST_ENABLED))
     {
-        tr_blocklistSetEnabled( tr, gtr_pref_flag_get( key ) );
+        tr_blocklistSetEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_BLOCKLIST_URL ) )
+  else if (!strcmp (key, TR_PREFS_KEY_BLOCKLIST_URL))
     {
-        tr_blocklistSetURL( tr, gtr_pref_string_get( key ) );
+        tr_blocklistSetURL (tr, gtr_pref_string_get (key));
     }
-    else if( !strcmp( key, PREF_KEY_SHOW_TRAY_ICON ) )
+  else if (!strcmp (key, PREF_KEY_SHOW_TRAY_ICON))
     {
-        const int show = gtr_pref_flag_get( key );
-        if( show && !cbdata->icon )
-            cbdata->icon = gtr_icon_new( cbdata->core );
-        else if( !show && cbdata->icon ) {
-            g_object_unref( cbdata->icon );
-            cbdata->icon = NULL;
-        }
+      const int show = gtr_pref_flag_get (key);
+      if (show && !cbdata->icon)
+        cbdata->icon = gtr_icon_new (cbdata->core);
+      else if (!show && cbdata->icon)
+        g_clear_object (&cbdata->icon);
     }
-    else if( !strcmp( key, TR_PREFS_KEY_DSPEED_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_DSPEED_ENABLED))
     {
-        tr_sessionLimitSpeed( tr, TR_DOWN, gtr_pref_flag_get( key ) );
+      tr_sessionLimitSpeed (tr, TR_DOWN, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_DSPEED_KBps ) )
+  else if (!strcmp (key, TR_PREFS_KEY_DSPEED_KBps))
     {
-        tr_sessionSetSpeedLimit_KBps( tr, TR_DOWN, gtr_pref_int_get( key ) );
+      tr_sessionSetSpeedLimit_KBps (tr, TR_DOWN, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_USPEED_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_USPEED_ENABLED))
     {
-        tr_sessionLimitSpeed( tr, TR_UP, gtr_pref_flag_get( key ) );
+      tr_sessionLimitSpeed (tr, TR_UP, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_USPEED_KBps ) )
+  else if (!strcmp (key, TR_PREFS_KEY_USPEED_KBps))
     {
-        tr_sessionSetSpeedLimit_KBps( tr, TR_UP, gtr_pref_int_get( key ) );
+      tr_sessionSetSpeedLimit_KBps (tr, TR_UP, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RATIO_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RATIO_ENABLED))
     {
-        tr_sessionSetRatioLimited( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetRatioLimited (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RATIO ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RATIO))
     {
-        tr_sessionSetRatioLimit( tr, gtr_pref_double_get( key ) );
+      tr_sessionSetRatioLimit (tr, gtr_pref_double_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_IDLE_LIMIT ) )
+  else if (!strcmp (key, TR_PREFS_KEY_IDLE_LIMIT))
     {
-        tr_sessionSetIdleLimit( tr, gtr_pref_int_get( key ) );
+      tr_sessionSetIdleLimit (tr, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_IDLE_LIMIT_ENABLED))
     {
-        tr_sessionSetIdleLimited( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetIdleLimited (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_PORT_FORWARDING ) )
+  else if (!strcmp (key, TR_PREFS_KEY_PORT_FORWARDING))
     {
-        tr_sessionSetPortForwardingEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetPortForwardingEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_PEX_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_PEX_ENABLED))
     {
-        tr_sessionSetPexEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetPexEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RENAME_PARTIAL_FILES ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RENAME_PARTIAL_FILES))
     {
-        tr_sessionSetIncompleteFileNamingEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetIncompleteFileNamingEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE ) )
+  else if (!strcmp (key, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE))
     {
-        tr_sessionSetQueueSize( tr, TR_DOWN, gtr_pref_int_get( key ) );
+      tr_sessionSetQueueSize (tr, TR_DOWN, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_QUEUE_STALLED_MINUTES ) )
+  else if (!strcmp (key, TR_PREFS_KEY_QUEUE_STALLED_MINUTES))
     {
-        tr_sessionSetQueueStalledMinutes( tr, gtr_pref_int_get( key ) );
+      tr_sessionSetQueueStalledMinutes (tr, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_DHT_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_DHT_ENABLED))
     {
-        tr_sessionSetDHTEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetDHTEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_UTP_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_UTP_ENABLED))
     {
-        tr_sessionSetUTPEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetUTPEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_LPD_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_LPD_ENABLED))
     {
-        tr_sessionSetLPDEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetLPDEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RPC_PORT ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RPC_PORT))
     {
-        tr_sessionSetRPCPort( tr, gtr_pref_int_get( key ) );
+      tr_sessionSetRPCPort (tr, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RPC_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RPC_ENABLED))
     {
-        tr_sessionSetRPCEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetRPCEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RPC_WHITELIST))
     {
-        tr_sessionSetRPCWhitelist( tr, gtr_pref_string_get( key ) );
+      tr_sessionSetRPCWhitelist (tr, gtr_pref_string_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RPC_WHITELIST_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RPC_WHITELIST_ENABLED))
     {
-        tr_sessionSetRPCWhitelistEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetRPCWhitelistEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RPC_USERNAME ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RPC_USERNAME))
     {
-        tr_sessionSetRPCUsername( tr, gtr_pref_string_get( key ) );
+      tr_sessionSetRPCUsername (tr, gtr_pref_string_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RPC_PASSWORD ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RPC_PASSWORD))
     {
-        tr_sessionSetRPCPassword( tr, gtr_pref_string_get( key ) );
+      tr_sessionSetRPCPassword (tr, gtr_pref_string_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_RPC_AUTH_REQUIRED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_RPC_AUTH_REQUIRED))
     {
-        tr_sessionSetRPCPasswordEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetRPCPasswordEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP_KBps ) )
+  else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_UP_KBps))
     {
-        tr_sessionSetAltSpeed_KBps( tr, TR_UP, gtr_pref_int_get( key ) );
+      tr_sessionSetAltSpeed_KBps (tr, TR_UP, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ) )
+  else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps))
     {
-        tr_sessionSetAltSpeed_KBps( tr, TR_DOWN, gtr_pref_int_get( key ) );
+        tr_sessionSetAltSpeed_KBps (tr, TR_DOWN, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_ENABLED))
     {
-        const gboolean b = gtr_pref_flag_get( key );
-        tr_sessionUseAltSpeed( tr, b );
-        gtr_action_set_toggled( key, b );
+      const gboolean b = gtr_pref_flag_get (key);
+      tr_sessionUseAltSpeed (tr, b);
+      gtr_action_set_toggled (key, b);
     }
-    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN ) )
+  else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN))
     {
-        tr_sessionSetAltSpeedBegin( tr, gtr_pref_int_get( key ) );
+      tr_sessionSetAltSpeedBegin (tr, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_END ) )
+  else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_TIME_END))
     {
-        tr_sessionSetAltSpeedEnd( tr, gtr_pref_int_get( key ) );
+      tr_sessionSetAltSpeedEnd (tr, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED))
     {
-        tr_sessionUseAltSpeedTime( tr, gtr_pref_flag_get( key ) );
+      tr_sessionUseAltSpeedTime (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_TIME_DAY ) )
+  else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_TIME_DAY))
     {
-        tr_sessionSetAltSpeedDay( tr, gtr_pref_int_get( key ) );
+      tr_sessionSetAltSpeedDay (tr, gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START ) )
+  else if (!strcmp (key, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START))
     {
-        tr_sessionSetPeerPortRandomOnStart( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetPeerPortRandomOnStart (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_INCOMPLETE_DIR ) )
+  else if (!strcmp (key, TR_PREFS_KEY_INCOMPLETE_DIR))
     {
-        tr_sessionSetIncompleteDir( tr, gtr_pref_string_get( key ) );
+      tr_sessionSetIncompleteDir (tr, gtr_pref_string_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED))
     {
-        tr_sessionSetIncompleteDirEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetIncompleteDirEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED ) )
+  else if (!strcmp (key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED))
     {
-        tr_sessionSetTorrentDoneScriptEnabled( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetTorrentDoneScriptEnabled (tr, gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME ) )
+  else if (!strcmp (key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME))
     {
-        tr_sessionSetTorrentDoneScript( tr, gtr_pref_string_get( key ) );
+      tr_sessionSetTorrentDoneScript (tr, gtr_pref_string_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_START) )
+  else if (!strcmp (key, TR_PREFS_KEY_START))
     {
-        tr_sessionSetPaused( tr, !gtr_pref_flag_get( key ) );
+      tr_sessionSetPaused (tr, !gtr_pref_flag_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_TRASH_ORIGINAL ) )
+  else if (!strcmp (key, TR_PREFS_KEY_TRASH_ORIGINAL))
     {
-        tr_sessionSetDeleteSource( tr, gtr_pref_flag_get( key ) );
+      tr_sessionSetDeleteSource (tr, gtr_pref_flag_get (key));
     }
 }
 
 static gboolean
-update_model_once( gpointer gdata )
+update_model_once (gpointer gdata)
 {
-    struct cbdata *data = gdata;
+  struct cbdata *data = gdata;
 
-    /* update the torrent data in the model */
-    gtr_core_update( data->core );
+  /* update the torrent data in the model */
+  gtr_core_update (data->core);
 
-    /* refresh the main window's statusbar and toolbar buttons */
-    if( data->wind != NULL )
-        gtr_window_refresh( data->wind );
+  /* refresh the main window's statusbar and toolbar buttons */
+  if (data->wind != NULL)
+    gtr_window_refresh (data->wind);
 
-    /* update the actions */
-        refresh_actions( data );
+  /* update the actions */
+  refresh_actions (data);
 
-    /* update the status tray icon */
-    if( data->icon != NULL )
-        gtr_icon_refresh( data->icon );
+  /* update the status tray icon */
+  if (data->icon != NULL)
+    gtr_icon_refresh (data->icon);
 
-    data->update_model_soon_tag = 0;
-    return FALSE;
+  data->update_model_soon_tag = 0;
+  return FALSE;
 }
 
 static void
-update_model_soon( gpointer gdata )
+update_model_soon (gpointer gdata)
 {
-    struct cbdata *data = gdata;
+  struct cbdata *data = gdata;
 
-    if( data->update_model_soon_tag == 0 )
-        data->update_model_soon_tag = gdk_threads_add_idle( update_model_once, data );
+  if (data->update_model_soon_tag == 0)
+    data->update_model_soon_tag = gdk_threads_add_idle (update_model_once, data);
 }
 
 static gboolean
-update_model_loop( gpointer gdata )
+update_model_loop (gpointer gdata)
 {
-    const gboolean done = global_sigcount;
+  const gboolean done = global_sigcount;
 
-    if( !done )
-        update_model_once( gdata );
+  if (!done)
+    update_model_once (gdata);
 
-    return !done;
+  return !done;
 }
 
 static void
-show_about_dialog( GtkWindow * parent )
+show_about_dialog (GtkWindow * parent)
 {
-    const char * uri = "http://www.transmissionbt.com/";
-    const char * authors[] = { "Jordan Lee (Backend; GTK+)",
-                               "Mitchell Livingston (Backend; OS X)",
-                               NULL };
-
-    gtk_show_about_dialog( parent,
-        "authors", authors,
-        "comments", _( "A fast and easy BitTorrent client" ),
-        "copyright", _( "Copyright (c) The Transmission Project" ),
-        "logo-icon-name", MY_CONFIG_NAME,
-        "name", g_get_application_name( ),
-        /* Translators: translate "translator-credits" as your name
-           to have it appear in the credits in the "About"
-           dialog */
-        "translator-credits", _( "translator-credits" ),
-        "version", LONG_VERSION_STRING,
-        "website", uri,
-        "website-label", uri,
+  const char * uri = "http://www.transmissionbt.com/";
+  const char * authors[] = { "Jordan Lee (Backend; GTK+)",
+                             "Mitchell Livingston (Backend; OS X)",
+                             NULL };
+
+  gtk_show_about_dialog (parent,
+    "authors", authors,
+    "comments", _("A fast and easy BitTorrent client"),
+    "copyright", _("Copyright (c) The Transmission Project"),
+    "logo-icon-name", MY_CONFIG_NAME,
+    "name", g_get_application_name (),
+    /* Translators: translate "translator-credits" as your name
+       to have it appear in the credits in the "About"
+       dialog */
+    "translator-credits", _("translator-credits"),
+    "version", LONG_VERSION_STRING,
+    "website", uri,
+    "website-label", uri,
 #ifdef SHOW_LICENSE
-        "license", LICENSE,
-        "wrap-license", TRUE,
+    "license", LICENSE,
+    "wrap-license", TRUE,
 #endif
-        NULL );
+    NULL);
 }
 
 static void
-append_id_to_benc_list( GtkTreeModel * m, GtkTreePath * path UNUSED,
-                        GtkTreeIter * iter, gpointer list )
+append_id_to_benc_list (GtkTreeModel * m, GtkTreePath * path UNUSED,
+                        GtkTreeIter * iter, gpointer list)
 {
-    tr_torrent * tor = NULL;
-    gtk_tree_model_get( m, iter, MC_TORRENT, &tor, -1 );
-    tr_bencListAddInt( list, tr_torrentId( tor ) );
+  tr_torrent * tor = NULL;
+  gtk_tree_model_get (m, iter, MC_TORRENT, &tor, -1);
+  tr_bencListAddInt (list, tr_torrentId (tor));
 }
 
 static gboolean
-call_rpc_for_selected_torrents( struct cbdata * data, const char * method )
+call_rpc_for_selected_torrents (struct cbdata * data, const char * method)
 {
-    tr_benc top, *args, *ids;
-    gboolean invoked = FALSE;
-    GtkTreeSelection * s = data->sel;
-    tr_session * session = gtr_core_session( data->core );
+  tr_benc top, *args, *ids;
+  gboolean invoked = FALSE;
+  GtkTreeSelection * s = data->sel;
+  tr_session * session = gtr_core_session (data->core);
 
-    tr_bencInitDict( &top, 2 );
-    tr_bencDictAddStr( &top, "method", method );
-    args = tr_bencDictAddDict( &top, "arguments", 1 );
-    ids = tr_bencDictAddList( args, "ids", 0 );
-    gtk_tree_selection_selected_foreach( s, append_id_to_benc_list, ids );
+  tr_bencInitDict (&top, 2);
+  tr_bencDictAddStr (&top, "method", method);
+  args = tr_bencDictAddDict (&top, "arguments", 1);
+  ids = tr_bencDictAddList (args, "ids", 0);
+  gtk_tree_selection_selected_foreach (s, append_id_to_benc_list, ids);
 
-    if( tr_bencListSize( ids ) != 0 )
+  if (tr_bencListSize (ids) != 0)
     {
-        int json_len;
-        char * json = tr_bencToStr( &top, TR_FMT_JSON_LEAN, &json_len );
-        tr_rpc_request_exec_json( session, json, json_len, NULL, NULL );
-        g_free( json );
-        invoked = TRUE;
+      int json_len;
+      char * json = tr_bencToStr (&top, TR_FMT_JSON_LEAN, &json_len);
+      tr_rpc_request_exec_json (session, json, json_len, NULL, NULL);
+      g_free (json);
+      invoked = TRUE;
     }
 
-    tr_bencFree( &top );
-    return invoked;
+  tr_bencFree (&top);
+  return invoked;
 }
 
 static void
-open_folder_foreach( GtkTreeModel * model, GtkTreePath * path UNUSED,
-                     GtkTreeIter * iter, gpointer core )
+open_folder_foreach (GtkTreeModel * model, GtkTreePath * path UNUSED,
+                     GtkTreeIter * iter, gpointer core)
 {
-    int id;
-    gtk_tree_model_get( model, iter, MC_TORRENT_ID, &id, -1 );
-    gtr_core_open_folder( core, id );
+  int id;
+  gtk_tree_model_get (model, iter, MC_TORRENT_ID, &id, -1);
+  gtr_core_open_folder (core, id);
 }
 
 static gboolean
-on_message_window_closed( void )
+on_message_window_closed (void)
 {
-    gtr_action_set_toggled( "toggle-message-log", FALSE );
-    return FALSE;
+  gtr_action_set_toggled ("toggle-message-log", FALSE);
+  return FALSE;
 }
 
 static void
-accumulate_selected_torrents( GtkTreeModel  * model, GtkTreePath   * path UNUSED,
-                              GtkTreeIter   * iter, gpointer        gdata )
+accumulate_selected_torrents (GtkTreeModel  * model, GtkTreePath   * path UNUSED,
+                              GtkTreeIter   * iter, gpointer        gdata)
 {
-    int id;
-    GSList ** data = gdata;
+  int id;
+  GSList ** data = gdata;
 
-    gtk_tree_model_get( model, iter, MC_TORRENT_ID, &id, -1 );
-    *data = g_slist_append( *data, GINT_TO_POINTER( id ) );
+  gtk_tree_model_get (model, iter, MC_TORRENT_ID, &id, -1);
+  *data = g_slist_append (*data, GINT_TO_POINTER (id));
 }
 
 static void
-remove_selected( struct cbdata * data, gboolean delete_files )
+remove_selected (struct cbdata * data, gboolean delete_files)
 {
-    GSList * l = NULL;
+  GSList * l = NULL;
 
-    gtk_tree_selection_selected_foreach( data->sel, accumulate_selected_torrents, &l );
+  gtk_tree_selection_selected_foreach (data->sel, accumulate_selected_torrents, &l);
 
-    if( l != NULL )
-        gtr_confirm_remove( data->wind, data->core, l, delete_files );
+  if (l != NULL)
+    gtr_confirm_remove (data->wind, data->core, l, delete_files);
 }
 
 static void
-start_all_torrents( struct cbdata * data )
+start_all_torrents (struct cbdata * data)
 {
-    tr_session * session = gtr_core_session( data->core );
-    const char * cmd = "{ \"method\": \"torrent-start\" }";
-    tr_rpc_request_exec_json( session, cmd, strlen( cmd ), NULL, NULL );
+  tr_session * session = gtr_core_session (data->core);
+  const char * cmd = "{ \"method\": \"torrent-start\" }";
+  tr_rpc_request_exec_json (session, cmd, strlen (cmd), NULL, NULL);
 }
 
 static void
-pause_all_torrents( struct cbdata * data )
+pause_all_torrents (struct cbdata * data)
 {
-    tr_session * session = gtr_core_session( data->core );
-    const char * cmd = "{ \"method\": \"torrent-stop\" }";
-    tr_rpc_request_exec_json( session, cmd, strlen( cmd ), NULL, NULL );
+  tr_session * session = gtr_core_session (data->core);
+  const char * cmd = "{ \"method\": \"torrent-stop\" }";
+  tr_rpc_request_exec_json (session, cmd, strlen (cmd), NULL, NULL);
 }
 
 static tr_torrent*
-get_first_selected_torrent( struct cbdata * data )
+get_first_selected_torrent (struct cbdata * data)
 {
-    tr_torrent * tor = NULL;
-    GtkTreeModel * m;
-    GList * l = gtk_tree_selection_get_selected_rows( data->sel, &m );
-    if( l != NULL ) {
-        GtkTreePath * p = l->data;
-        GtkTreeIter i;
-        if( gtk_tree_model_get_iter( m, &i, p ) )
-            gtk_tree_model_get( m, &i, MC_TORRENT, &tor, -1 );
-    }
-    g_list_foreach( l, (GFunc)gtk_tree_path_free, NULL );
-    g_list_free( l );
-    return tor;
+  tr_torrent * tor = NULL;
+  GtkTreeModel * m;
+  GList * l = gtk_tree_selection_get_selected_rows (data->sel, &m);
+  if (l != NULL)
+    {
+      GtkTreePath * p = l->data;
+      GtkTreeIter i;
+      if (gtk_tree_model_get_iter (m, &i, p))
+        gtk_tree_model_get (m, &i, MC_TORRENT, &tor, -1);
+    }
+  g_list_foreach (l, (GFunc)gtk_tree_path_free, NULL);
+  g_list_free (l);
+  return tor;
 }
 
 static void
-copy_magnet_link_to_clipboard( GtkWidget * w, tr_torrent * tor )
+copy_magnet_link_to_clipboard (GtkWidget * w, tr_torrent * tor)
 {
-    char * magnet = tr_torrentGetMagnetLink( tor );
-    GdkDisplay * display = gtk_widget_get_display( w );
-    GdkAtom selection;
-    GtkClipboard * clipboard;
-
-    /* this is The Right Thing for copy/paste... */
-    selection = GDK_SELECTION_CLIPBOARD;
-    clipboard = gtk_clipboard_get_for_display( display, selection );
-    gtk_clipboard_set_text( clipboard, magnet, -1 );
-
-    /* ...but people using plain ol' X need this instead */
-    selection = GDK_SELECTION_PRIMARY;
-    clipboard = gtk_clipboard_get_for_display( display, selection );
-    gtk_clipboard_set_text( clipboard, magnet, -1 );
-
-    /* cleanup */
-    tr_free( magnet );
+  char * magnet = tr_torrentGetMagnetLink (tor);
+  GdkDisplay * display = gtk_widget_get_display (w);
+  GdkAtom selection;
+  GtkClipboard * clipboard;
+
+  /* this is The Right Thing for copy/paste... */
+  selection = GDK_SELECTION_CLIPBOARD;
+  clipboard = gtk_clipboard_get_for_display (display, selection);
+  gtk_clipboard_set_text (clipboard, magnet, -1);
+
+  /* ...but people using plain ol' X need this instead */
+  selection = GDK_SELECTION_PRIMARY;
+  clipboard = gtk_clipboard_get_for_display (display, selection);
+  gtk_clipboard_set_text (clipboard, magnet, -1);
+
+  /* cleanup */
+  tr_free (magnet);
 }
 
 void
-gtr_actions_handler( const char * action_name, gpointer user_data )
+gtr_actions_handler (const char * action_name, gpointer user_data)
 {
-    struct cbdata * data = user_data;
-    gboolean        changed = FALSE;
+  gboolean changed = FALSE;
+  struct cbdata * data = user_data;
 
-    if( !strcmp( action_name, "open-torrent-from-url" ) )
+  if (!strcmp (action_name, "open-torrent-from-url"))
     {
-        GtkWidget * w = gtr_torrent_open_from_url_dialog_new( data->wind, data->core );
-        gtk_widget_show( w );
+      GtkWidget * w = gtr_torrent_open_from_url_dialog_new (data->wind, data->core);
+      gtk_widget_show (w);
     }
-    else if(  !strcmp( action_name, "open-torrent-menu" )
-      || !strcmp( action_name, "open-torrent-toolbar" ) )
+  else if (!strcmp (action_name, "open-torrent-menu")
+        || !strcmp (action_name, "open-torrent-toolbar"))
     {
-        GtkWidget * w = gtr_torrent_open_from_file_dialog_new( data->wind, data->core );
-        gtk_widget_show( w );
+      GtkWidget * w = gtr_torrent_open_from_file_dialog_new (data->wind, data->core);
+      gtk_widget_show (w);
     }
-    else if( !strcmp( action_name, "show-stats" ) )
+    else if (!strcmp (action_name, "show-stats"))
     {
-        GtkWidget * dialog = gtr_stats_dialog_new( data->wind, data->core );
-        gtk_widget_show( dialog );
+        GtkWidget * dialog = gtr_stats_dialog_new (data->wind, data->core);
+        gtk_widget_show (dialog);
     }
-    else if( !strcmp( action_name, "donate" ) )
+  else if (!strcmp (action_name, "donate"))
     {
-        gtr_open_uri( "http://www.transmissionbt.com/donate.php" );
+      gtr_open_uri ("http://www.transmissionbt.com/donate.php");
     }
-    else if( !strcmp( action_name, "pause-all-torrents" ) )
+  else if (!strcmp (action_name, "pause-all-torrents"))
     {
-        pause_all_torrents( data );
+      pause_all_torrents (data);
     }
-    else if( !strcmp( action_name, "start-all-torrents" ) )
+  else if (!strcmp (action_name, "start-all-torrents"))
     {
-        start_all_torrents( data );
+      start_all_torrents (data);
     }
-    else if( !strcmp( action_name, "copy-magnet-link-to-clipboard" ) )
+  else if (!strcmp (action_name, "copy-magnet-link-to-clipboard"))
     {
-        tr_torrent * tor = get_first_selected_torrent( data );
-        if( tor != NULL )
+      tr_torrent * tor = get_first_selected_torrent (data);
+      if (tor != NULL)
         {
-            copy_magnet_link_to_clipboard( GTK_WIDGET( data->wind ), tor );
+          copy_magnet_link_to_clipboard (GTK_WIDGET (data->wind), tor);
         }
     }
-    else if( !strcmp( action_name, "relocate-torrent" ) )
+  else if (!strcmp (action_name, "relocate-torrent"))
     {
-        GSList * ids = get_selected_torrent_ids( data );
-        if( ids != NULL )
+      GSList * ids = get_selected_torrent_ids (data);
+      if (ids != NULL)
         {
-            GtkWindow * parent = data->wind;
-            GtkWidget * w = gtr_relocate_dialog_new( parent, data->core, ids );
-            gtk_widget_show( w );
+          GtkWindow * parent = data->wind;
+          GtkWidget * w = gtr_relocate_dialog_new (parent, data->core, ids);
+          gtk_widget_show (w);
         }
     }
-    else if( !strcmp( action_name, "torrent-start" )
-          || !strcmp( action_name, "torrent-start-now" )
-          || !strcmp( action_name, "torrent-stop" )
-          || !strcmp( action_name, "torrent-reannounce" )
-          || !strcmp( action_name, "torrent-verify" )
-          || !strcmp( action_name, "queue-move-top" )
-          || !strcmp( action_name, "queue-move-up" )
-          || !strcmp( action_name, "queue-move-down" )
-          || !strcmp( action_name, "queue-move-bottom" ) )
+  else if (!strcmp (action_name, "torrent-start")
+        || !strcmp (action_name, "torrent-start-now")
+        || !strcmp (action_name, "torrent-stop")
+        || !strcmp (action_name, "torrent-reannounce")
+        || !strcmp (action_name, "torrent-verify")
+        || !strcmp (action_name, "queue-move-top")
+        || !strcmp (action_name, "queue-move-up")
+        || !strcmp (action_name, "queue-move-down")
+        || !strcmp (action_name, "queue-move-bottom"))
     {
-        changed |= call_rpc_for_selected_torrents( data, action_name );
+      changed |= call_rpc_for_selected_torrents (data, action_name);
     }
-    else if( !strcmp( action_name, "open-torrent-folder" ) )
+  else if (!strcmp (action_name, "open-torrent-folder"))
     {
-        gtk_tree_selection_selected_foreach( data->sel, open_folder_foreach, data->core );
+      gtk_tree_selection_selected_foreach (data->sel, open_folder_foreach, data->core);
     }
-    else if( !strcmp( action_name, "show-torrent-properties" ) )
+  else if (!strcmp (action_name, "show-torrent-properties"))
     {
-        show_details_dialog_for_selected_torrents( data );
+      show_details_dialog_for_selected_torrents (data);
     }
-    else if( !strcmp( action_name, "new-torrent" ) )
+  else if (!strcmp (action_name, "new-torrent"))
     {
-        GtkWidget * w = gtr_torrent_creation_dialog_new( data->wind, data->core );
-        gtk_widget_show( w );
+      GtkWidget * w = gtr_torrent_creation_dialog_new (data->wind, data->core);
+      gtk_widget_show (w);
     }
-    else if( !strcmp( action_name, "remove-torrent" ) )
+  else if (!strcmp (action_name, "remove-torrent"))
     {
-        remove_selected( data, FALSE );
+      remove_selected (data, FALSE);
     }
-    else if( !strcmp( action_name, "delete-torrent" ) )
+  else if (!strcmp (action_name, "delete-torrent"))
     {
-        remove_selected( data, TRUE );
+      remove_selected (data, TRUE);
     }
-    else if( !strcmp( action_name, "quit" ) )
+  else if (!strcmp (action_name, "quit"))
     {
-        on_app_exit( data );
+      on_app_exit (data);
     }
-    else if( !strcmp( action_name, "select-all" ) )
+  else if (!strcmp (action_name, "select-all"))
     {
-        gtk_tree_selection_select_all( data->sel );
+      gtk_tree_selection_select_all (data->sel);
     }
-    else if( !strcmp( action_name, "deselect-all" ) )
+  else if (!strcmp (action_name, "deselect-all"))
     {
-        gtk_tree_selection_unselect_all( data->sel );
+      gtk_tree_selection_unselect_all (data->sel);
     }
-    else if( !strcmp( action_name, "edit-preferences" ) )
+  else if (!strcmp (action_name, "edit-preferences"))
     {
-        if( NULL == data->prefs )
+      if (NULL == data->prefs)
         {
-            data->prefs = gtr_prefs_dialog_new( data->wind, G_OBJECT( data->core ) );
-            g_signal_connect( data->prefs, "destroy",
-                              G_CALLBACK( gtk_widget_destroyed ), &data->prefs );
+          data->prefs = gtr_prefs_dialog_new (data->wind, G_OBJECT (data->core));
+          g_signal_connect (data->prefs, "destroy",
+                            G_CALLBACK (gtk_widget_destroyed), &data->prefs);
         }
-        gtr_window_present( GTK_WINDOW( data->prefs ) );
+        gtr_window_present (GTK_WINDOW (data->prefs));
     }
-    else if( !strcmp( action_name, "toggle-message-log" ) )
+  else if (!strcmp (action_name, "toggle-message-log"))
     {
-        if( !data->msgwin )
+      if (!data->msgwin)
         {
-            GtkWidget * win = gtr_message_log_window_new( data->wind, data->core );
-            g_signal_connect( win, "destroy", G_CALLBACK( on_message_window_closed ), NULL );
-            data->msgwin = win;
+          GtkWidget * win = gtr_message_log_window_new (data->wind, data->core);
+          g_signal_connect (win, "destroy", G_CALLBACK (on_message_window_closed), NULL);
+          data->msgwin = win;
         }
-        else
+      else
         {
-            gtr_action_set_toggled( "toggle-message-log", FALSE );
-            gtk_widget_destroy( data->msgwin );
-            data->msgwin = NULL;
+          gtr_action_set_toggled ("toggle-message-log", FALSE);
+          gtk_widget_destroy (data->msgwin);
+          data->msgwin = NULL;
         }
     }
-    else if( !strcmp( action_name, "show-about-dialog" ) )
+  else if (!strcmp (action_name, "show-about-dialog"))
+    {
+      show_about_dialog (data->wind);
+    }
+  else if (!strcmp (action_name, "help"))
     {
-        show_about_dialog( data->wind );
+      gtr_open_uri (gtr_get_help_uri ());
     }
-    else if( !strcmp ( action_name, "help" ) )
+  else if (!strcmp (action_name, "toggle-main-window"))
     {
-        gtr_open_uri( gtr_get_help_uri( ) );
+      toggleMainWindow (data);
     }
-    else if( !strcmp( action_name, "toggle-main-window" ) )
+  else if (!strcmp (action_name, "present-main-window"))
     {
-        toggleMainWindow( data );
+      presentMainWindow (data);
     }
-    else if( !strcmp( action_name, "present-main-window" ) )
+  else
     {
-        presentMainWindow( data );
+      g_error ("Unhandled action: %s", action_name);
     }
-    else g_error ( "Unhandled action: %s", action_name );
 
-    if( changed )
-        update_model_soon( data );
+  if (changed)
+    update_model_soon (data);
 }
diff --git a/gtk/makemeta-ui.c b/gtk/makemeta-ui.c
index 9343438e6..5f113cb8c 100644
--- a/gtk/makemeta-ui.c
+++ b/gtk/makemeta-ui.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -15,7 +15,7 @@
 
 #include <libtransmission/transmission.h>
 #include <libtransmission/makemeta.h>
-#include <libtransmission/utils.h> /* tr_formatter_mem_B() */
+#include <libtransmission/utils.h> /* tr_formatter_mem_B () */
 
 #include "hig.h"
 #include "makemeta-ui.h"
@@ -49,163 +49,163 @@ typedef struct
 MakeMetaUI;
 
 static void
-freeMetaUI( gpointer p )
+freeMetaUI (gpointer p)
 {
     MakeMetaUI * ui = p;
 
-    tr_metaInfoBuilderFree( ui->builder );
-    g_free( ui->target );
-    memset( ui, ~0, sizeof( MakeMetaUI ) );
-    g_free( ui );
+    tr_metaInfoBuilderFree (ui->builder);
+    g_free (ui->target);
+    memset (ui, ~0, sizeof (MakeMetaUI));
+    g_free (ui);
 }
 
 static gboolean
-onProgressDialogRefresh( gpointer data )
+onProgressDialogRefresh (gpointer data)
 {
     char * str = NULL;
     MakeMetaUI * ui = data;
     const tr_metainfo_builder * b = ui->builder;
-    GtkDialog * d = GTK_DIALOG( ui->progress_dialog );
-    GtkProgressBar * p = GTK_PROGRESS_BAR( ui->progress_bar );
+    GtkDialog * d = GTK_DIALOG (ui->progress_dialog);
+    GtkProgressBar * p = GTK_PROGRESS_BAR (ui->progress_bar);
     const double fraction = b->pieceCount ? ((double)b->pieceIndex / b->pieceCount) : 0;
-    char * base = g_path_get_basename( b->top );
+    char * base = g_path_get_basename (b->top);
 
     /* progress label */
-    if( !b->isDone )
-        str = g_strdup_printf( _( "Creating \"%s\"" ), base );
-    else if( b->result == TR_MAKEMETA_OK )
-        str = g_strdup_printf( _( "Created \"%s\"!" ), base );
-    else if( b->result == TR_MAKEMETA_URL )
-        str = g_strdup_printf( _( "Error: invalid announce URL \"%s\"" ), b->errfile );
-    else if( b->result == TR_MAKEMETA_CANCELLED )
-        str = g_strdup_printf( _( "Cancelled" ) );
-    else if( b->result == TR_MAKEMETA_IO_READ )
-        str = g_strdup_printf( _( "Error reading \"%s\": %s" ), b->errfile, g_strerror( b->my_errno ) );
-    else if( b->result == TR_MAKEMETA_IO_WRITE )
-        str = g_strdup_printf( _( "Error writing \"%s\": %s" ), b->errfile, g_strerror( b->my_errno ) );
+    if (!b->isDone)
+        str = g_strdup_printf (_("Creating \"%s\""), base);
+    else if (b->result == TR_MAKEMETA_OK)
+        str = g_strdup_printf (_("Created \"%s\"!"), base);
+    else if (b->result == TR_MAKEMETA_URL)
+        str = g_strdup_printf (_("Error: invalid announce URL \"%s\""), b->errfile);
+    else if (b->result == TR_MAKEMETA_CANCELLED)
+        str = g_strdup_printf (_("Cancelled"));
+    else if (b->result == TR_MAKEMETA_IO_READ)
+        str = g_strdup_printf (_("Error reading \"%s\": %s"), b->errfile, g_strerror (b->my_errno));
+    else if (b->result == TR_MAKEMETA_IO_WRITE)
+        str = g_strdup_printf (_("Error writing \"%s\": %s"), b->errfile, g_strerror (b->my_errno));
     else
-        g_assert_not_reached( );
+        g_assert_not_reached ();
 
-    if( str != NULL ) {
-        gtr_label_set_text( GTK_LABEL( ui->progress_label ), str );
-        g_free( str );
+    if (str != NULL) {
+        gtr_label_set_text (GTK_LABEL (ui->progress_label), str);
+        g_free (str);
     }
 
     /* progress bar */
-    if( !b->pieceIndex )
-        str = g_strdup( "" );
+    if (!b->pieceIndex)
+        str = g_strdup ("");
     else {
         char sizebuf[128];
-        tr_strlsize( sizebuf, (uint64_t)b->pieceIndex *
-                              (uint64_t)b->pieceSize, sizeof( sizebuf ) );
+        tr_strlsize (sizebuf, (uint64_t)b->pieceIndex *
+                            (uint64_t)b->pieceSize, sizeof (sizebuf));
         /* how much data we've scanned through to generate checksums */
-        str = g_strdup_printf( _( "Scanned %s" ), sizebuf );
+        str = g_strdup_printf (_("Scanned %s"), sizebuf);
     }
-    gtk_progress_bar_set_fraction( p, fraction );
-    gtk_progress_bar_set_text( p, str );
-    g_free( str );
+    gtk_progress_bar_set_fraction (p, fraction);
+    gtk_progress_bar_set_text (p, str);
+    g_free (str);
 
     /* buttons */
-    gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_CANCEL, !b->isDone );
-    gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_CLOSE, b->isDone );
-    gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_ACCEPT, b->isDone && !b->result );
+    gtk_dialog_set_response_sensitive (d, GTK_RESPONSE_CANCEL, !b->isDone);
+    gtk_dialog_set_response_sensitive (d, GTK_RESPONSE_CLOSE, b->isDone);
+    gtk_dialog_set_response_sensitive (d, GTK_RESPONSE_ACCEPT, b->isDone && !b->result);
 
-    g_free( base );
+    g_free (base);
     return TRUE;
 }
 
 static void
-onProgressDialogDestroyed( gpointer data, GObject * dead UNUSED )
+onProgressDialogDestroyed (gpointer data, GObject * dead UNUSED)
 {
     MakeMetaUI * ui = data;
-    g_source_remove( ui->progress_tag );
+    g_source_remove (ui->progress_tag);
 }
 
 static void
-addTorrent( MakeMetaUI * ui )
+addTorrent (MakeMetaUI * ui)
 {
     char * path;
     const tr_metainfo_builder * b = ui->builder;
-    tr_ctor * ctor = tr_ctorNew( gtr_core_session( ui->core ) );
+    tr_ctor * ctor = tr_ctorNew (gtr_core_session (ui->core));
 
-    tr_ctorSetMetainfoFromFile( ctor, ui->target );
+    tr_ctorSetMetainfoFromFile (ctor, ui->target);
 
-    path = g_path_get_dirname( b->top );
-    tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
-    g_free( path );
+    path = g_path_get_dirname (b->top);
+    tr_ctorSetDownloadDir (ctor, TR_FORCE, path);
+    g_free (path);
 
-    gtr_core_add_ctor( ui->core, ctor );
+    gtr_core_add_ctor (ui->core, ctor);
 }
 
 static void
-onProgressDialogResponse( GtkDialog * d, int response, gpointer data )
+onProgressDialogResponse (GtkDialog * d, int response, gpointer data)
 {
     MakeMetaUI * ui = data;
 
-    switch( response )
+    switch (response)
     {
         case GTK_RESPONSE_CANCEL:
             ui->builder->abortFlag = TRUE;
-            gtk_widget_destroy( GTK_WIDGET( d ) );
+            gtk_widget_destroy (GTK_WIDGET (d));
             break;
         case GTK_RESPONSE_ACCEPT:
-            addTorrent( ui );
+            addTorrent (ui);
             /* fall-through */
         case GTK_RESPONSE_CLOSE:
-            gtk_widget_destroy( ui->builder->result ? GTK_WIDGET( d ) : ui->dialog );
+            gtk_widget_destroy (ui->builder->result ? GTK_WIDGET (d) : ui->dialog);
             break;
         default:
-            g_assert( 0 && "unhandled response" );
+            g_assert (0 && "unhandled response");
     }
 }
 
 static void
-makeProgressDialog( GtkWidget * parent, MakeMetaUI * ui )
+makeProgressDialog (GtkWidget * parent, MakeMetaUI * ui)
 {
     GtkWidget *d, *l, *w, *v, *fr;
 
-    d = gtk_dialog_new_with_buttons( _( "New Torrent" ),
-            GTK_WINDOW( parent ),
+    d = gtk_dialog_new_with_buttons (_("New Torrent"),
+            GTK_WINDOW (parent),
             GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
             GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
             GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,
-            NULL );
+            NULL);
     ui->progress_dialog = d;
-    g_signal_connect( d, "response", G_CALLBACK( onProgressDialogResponse ), ui );
+    g_signal_connect (d, "response", G_CALLBACK (onProgressDialogResponse), ui);
 
-    fr = gtk_frame_new( NULL );
-    gtk_container_set_border_width( GTK_CONTAINER( fr ), GUI_PAD_BIG );
-    gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_NONE );
-    v = gtk_box_new( GTK_ORIENTATION_VERTICAL, GUI_PAD );
-    gtk_container_add( GTK_CONTAINER( fr ), v );
+    fr = gtk_frame_new (NULL);
+    gtk_container_set_border_width (GTK_CONTAINER (fr), GUI_PAD_BIG);
+    gtk_frame_set_shadow_type (GTK_FRAME (fr), GTK_SHADOW_NONE);
+    v = gtk_box_new (GTK_ORIENTATION_VERTICAL, GUI_PAD);
+    gtk_container_add (GTK_CONTAINER (fr), v);
 
-    l = gtk_label_new( _( "Creating torrent…" ) );
-    gtk_misc_set_alignment( GTK_MISC( l ), 0.0, 0.5 );
-    gtk_label_set_justify( GTK_LABEL( l ), GTK_JUSTIFY_LEFT );
+    l = gtk_label_new (_("Creating torrent…"));
+    gtk_misc_set_alignment (GTK_MISC (l), 0.0, 0.5);
+    gtk_label_set_justify (GTK_LABEL (l), GTK_JUSTIFY_LEFT);
     ui->progress_label = l;
-    gtk_box_pack_start( GTK_BOX( v ), l, FALSE, FALSE, 0 );
+    gtk_box_pack_start (GTK_BOX (v), l, FALSE, FALSE, 0);
 
-    w = gtk_progress_bar_new( );
+    w = gtk_progress_bar_new ();
     ui->progress_bar = w;
-    gtk_box_pack_start( GTK_BOX( v ), w, FALSE, FALSE, 0 );
+    gtk_box_pack_start (GTK_BOX (v), w, FALSE, FALSE, 0);
 
-    ui->progress_tag = gdk_threads_add_timeout_seconds( SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS, onProgressDialogRefresh, ui );
-    g_object_weak_ref( G_OBJECT( d ), onProgressDialogDestroyed, ui );
-    onProgressDialogRefresh( ui );
+    ui->progress_tag = gdk_threads_add_timeout_seconds (SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS, onProgressDialogRefresh, ui);
+    g_object_weak_ref (G_OBJECT (d), onProgressDialogDestroyed, ui);
+    onProgressDialogRefresh (ui);
 
-    gtr_dialog_set_content( GTK_DIALOG( d ), fr );
-    gtk_widget_show( d );
+    gtr_dialog_set_content (GTK_DIALOG (d), fr);
+    gtk_widget_show (d);
 }
 
 static void
-onResponse( GtkDialog* d, int response, gpointer user_data )
+onResponse (GtkDialog* d, int response, gpointer user_data)
 {
     MakeMetaUI * ui = user_data;
 
-    if( response == GTK_RESPONSE_ACCEPT )
+    if (response == GTK_RESPONSE_ACCEPT)
     {
-        if( ui->builder != NULL )
+        if (ui->builder != NULL)
         {
             int i;
             int n;
@@ -215,32 +215,32 @@ onResponse( GtkDialog* d, int response, gpointer user_data )
             char * base;
             char * tracker_text;
             char ** tracker_strings;
-            GtkEntry * c_entry = GTK_ENTRY( ui->comment_entry );
-            GtkToggleButton * p_check = GTK_TOGGLE_BUTTON( ui->private_check );
-            GtkToggleButton * c_check = GTK_TOGGLE_BUTTON( ui->comment_check );
-            const char * comment = gtk_entry_get_text( c_entry );
-            const gboolean isPrivate = gtk_toggle_button_get_active( p_check );
-            const gboolean useComment = gtk_toggle_button_get_active( c_check );
+            GtkEntry * c_entry = GTK_ENTRY (ui->comment_entry);
+            GtkToggleButton * p_check = GTK_TOGGLE_BUTTON (ui->private_check);
+            GtkToggleButton * c_check = GTK_TOGGLE_BUTTON (ui->comment_check);
+            const char * comment = gtk_entry_get_text (c_entry);
+            const gboolean isPrivate = gtk_toggle_button_get_active (p_check);
+            const gboolean useComment = gtk_toggle_button_get_active (c_check);
             tr_tracker_info * trackers;
 
             /* destination file */
-            dir = gtk_file_chooser_get_filename(
-                      GTK_FILE_CHOOSER( ui->destination_chooser ) );
-            base = g_path_get_basename( ui->builder->top );
-            g_free( ui->target );
-            ui->target = g_strdup_printf( "%s/%s.torrent", dir, base );
+            dir = gtk_file_chooser_get_filename (
+                      GTK_FILE_CHOOSER (ui->destination_chooser));
+            base = g_path_get_basename (ui->builder->top);
+            g_free (ui->target);
+            ui->target = g_strdup_printf ("%s/%s.torrent", dir, base);
 
             /* build the array of trackers */
-            gtk_text_buffer_get_bounds( ui->announce_text_buffer, &start, &end );
-            tracker_text = gtk_text_buffer_get_text( ui->announce_text_buffer,
-                                                     &start, &end, FALSE );
-            tracker_strings = g_strsplit( tracker_text, "\n", 0 );
-            for( i=0; tracker_strings[i]; )
+            gtk_text_buffer_get_bounds (ui->announce_text_buffer, &start, &end);
+            tracker_text = gtk_text_buffer_get_text (ui->announce_text_buffer,
+                                                     &start, &end, FALSE);
+            tracker_strings = g_strsplit (tracker_text, "\n", 0);
+            for (i=0; tracker_strings[i];)
                 ++i;
-            trackers = g_new0( tr_tracker_info, i );
-            for( i=n=tier=0; tracker_strings[i]; ++i ) {
+            trackers = g_new0 (tr_tracker_info, i);
+            for (i=n=tier=0; tracker_strings[i]; ++i) {
                 const char * str = tracker_strings[i];
-                if( !*str )
+                if (!*str)
                     ++tier;
                 else {
                     trackers[n].tier = tier;
@@ -250,21 +250,21 @@ onResponse( GtkDialog* d, int response, gpointer user_data )
             }
 
             /* build the .torrent */
-            makeProgressDialog( GTK_WIDGET( d ), ui );
-            tr_makeMetaInfo( ui->builder, ui->target, trackers, n,
-                             useComment ? comment : NULL, isPrivate );
+            makeProgressDialog (GTK_WIDGET (d), ui);
+            tr_makeMetaInfo (ui->builder, ui->target, trackers, n,
+                             useComment ? comment : NULL, isPrivate);
 
             /* cleanup */
-            g_free( trackers );
-            g_strfreev( tracker_strings );
-            g_free( tracker_text );
-            g_free( base );
-            g_free( dir );
+            g_free (trackers);
+            g_strfreev (tracker_strings);
+            g_free (tracker_text);
+            g_free (base);
+            g_free (dir);
         }
     }
-    else if( response == GTK_RESPONSE_CLOSE )
+    else if (response == GTK_RESPONSE_CLOSE)
     {
-        gtk_widget_destroy( GTK_WIDGET( d ) );
+        gtk_widget_destroy (GTK_WIDGET (d));
     }
 }
 
@@ -273,244 +273,244 @@ onResponse( GtkDialog* d, int response, gpointer user_data )
 ***/
 
 static void
-onSourceToggled( GtkToggleButton * tb, gpointer user_data )
+onSourceToggled (GtkToggleButton * tb, gpointer user_data)
 {
-    gtk_widget_set_sensitive( GTK_WIDGET( user_data ),
-                              gtk_toggle_button_get_active( tb ) );
+    gtk_widget_set_sensitive (GTK_WIDGET (user_data),
+                              gtk_toggle_button_get_active (tb));
 }
 
 static void
-updatePiecesLabel( MakeMetaUI * ui )
+updatePiecesLabel (MakeMetaUI * ui)
 {
     const tr_metainfo_builder * builder = ui->builder;
     const char * filename = builder ? builder->top : NULL;
-    GString * gstr = g_string_new( NULL );
+    GString * gstr = g_string_new (NULL);
 
-    g_string_append( gstr, "<i>" );
-    if( !filename )
+    g_string_append (gstr, "<i>");
+    if (!filename)
     {
-        g_string_append( gstr, _( "No source selected" ) );
+        g_string_append (gstr, _("No source selected"));
     }
     else
     {
         char buf[128];
-        tr_strlsize( buf, builder->totalSize, sizeof( buf ) );
-        g_string_append_printf( gstr, ngettext( "%1$s; %2$'d File",
+        tr_strlsize (buf, builder->totalSize, sizeof (buf));
+        g_string_append_printf (gstr, ngettext ("%1$s; %2$'d File",
                                                 "%1$s; %2$'d Files",
-                                                builder->fileCount ),
-                                buf, builder->fileCount );
-        g_string_append( gstr, "; " );
+                                                builder->fileCount),
+                                buf, builder->fileCount);
+        g_string_append (gstr, "; ");
 
-        tr_formatter_mem_B( buf, builder->pieceSize, sizeof( buf ) );
-        g_string_append_printf( gstr, ngettext( "%1$'d Piece @ %2$s",
+        tr_formatter_mem_B (buf, builder->pieceSize, sizeof (buf));
+        g_string_append_printf (gstr, ngettext ("%1$'d Piece @ %2$s",
                                                 "%1$'d Pieces @ %2$s",
-                                                builder->pieceCount ),
-                                      builder->pieceCount, buf );
+                                                builder->pieceCount),
+                                      builder->pieceCount, buf);
     }
-    g_string_append( gstr, "</i>" );
-    gtk_label_set_markup ( GTK_LABEL( ui->pieces_lb ), gstr->str );
-    g_string_free( gstr, TRUE );
+    g_string_append (gstr, "</i>");
+    gtk_label_set_markup (GTK_LABEL (ui->pieces_lb), gstr->str);
+    g_string_free (gstr, TRUE);
 }
 
 static void
-setFilename( MakeMetaUI * ui, const char * filename )
+setFilename (MakeMetaUI * ui, const char * filename)
 {
-    if( ui->builder ) {
-        tr_metaInfoBuilderFree( ui->builder );
+    if (ui->builder) {
+        tr_metaInfoBuilderFree (ui->builder);
         ui->builder = NULL;
     }
 
-    if( filename )
-        ui->builder = tr_metaInfoBuilderCreate( filename );
+    if (filename)
+        ui->builder = tr_metaInfoBuilderCreate (filename);
 
-    updatePiecesLabel( ui );
+    updatePiecesLabel (ui);
 }
 
 static void
-onChooserChosen( GtkFileChooser * chooser, gpointer user_data )
+onChooserChosen (GtkFileChooser * chooser, gpointer user_data)
 {
     char * filename;
     MakeMetaUI * ui = user_data;
 
-    g_object_set_data( G_OBJECT( chooser ), FILE_CHOSEN_KEY,
-                       GINT_TO_POINTER( TRUE ) );
+    g_object_set_data (G_OBJECT (chooser), FILE_CHOSEN_KEY,
+                       GINT_TO_POINTER (TRUE));
 
-    filename = gtk_file_chooser_get_filename( chooser );
-    setFilename( ui, filename );
-    g_free( filename );
+    filename = gtk_file_chooser_get_filename (chooser);
+    setFilename (ui, filename);
+    g_free (filename);
 }
 
 static void
-onSourceToggled2( GtkToggleButton * tb, GtkWidget * chooser, MakeMetaUI * ui )
+onSourceToggled2 (GtkToggleButton * tb, GtkWidget * chooser, MakeMetaUI * ui)
 {
-    if( gtk_toggle_button_get_active( tb ) )
+    if (gtk_toggle_button_get_active (tb))
     {
-        if( g_object_get_data( G_OBJECT( chooser ), FILE_CHOSEN_KEY ) != NULL )
-            onChooserChosen( GTK_FILE_CHOOSER( chooser ), ui );
+        if (g_object_get_data (G_OBJECT (chooser), FILE_CHOSEN_KEY) != NULL)
+            onChooserChosen (GTK_FILE_CHOOSER (chooser), ui);
         else
-            setFilename( ui, NULL );
+            setFilename (ui, NULL);
     }
 }
 static void
-onFolderToggled( GtkToggleButton * tb, gpointer data )
+onFolderToggled (GtkToggleButton * tb, gpointer data)
 {
     MakeMetaUI * ui = data;
-    onSourceToggled2( tb, ui->folder_chooser, ui );
+    onSourceToggled2 (tb, ui->folder_chooser, ui);
 }
 static void
-onFileToggled( GtkToggleButton * tb, gpointer data )
+onFileToggled (GtkToggleButton * tb, gpointer data)
 {
     MakeMetaUI * ui = data;
-    onSourceToggled2( tb, ui->file_chooser, ui );
+    onSourceToggled2 (tb, ui->file_chooser, ui);
 }
 
 static const char *
-getDefaultSavePath( void )
+getDefaultSavePath (void)
 {
-    return g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
+    return g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);
 }
 
 static void
-on_drag_data_received( GtkWidget         * widget           UNUSED,
+on_drag_data_received (GtkWidget         * widget           UNUSED,
                        GdkDragContext    * drag_context,
                        gint                x                UNUSED,
                        gint                y                UNUSED,
                        GtkSelectionData  * selection_data,
                        guint               info             UNUSED,
                        guint               time_,
-                       gpointer            user_data )
+                       gpointer            user_data)
 {
     gboolean success = FALSE;
     MakeMetaUI * ui = user_data;
-    char ** uris = gtk_selection_data_get_uris( selection_data );
+    char ** uris = gtk_selection_data_get_uris (selection_data);
 
-    if( uris && uris[0] )
+    if (uris && uris[0])
     {
         const char * uri = uris[ 0 ];
-        gchar * filename = g_filename_from_uri( uri, NULL, NULL );
+        gchar * filename = g_filename_from_uri (uri, NULL, NULL);
 
-        if( g_file_test( filename, G_FILE_TEST_IS_DIR ) )
+        if (g_file_test (filename, G_FILE_TEST_IS_DIR))
         {
             /* a directory was dragged onto the dialog... */
-            gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( ui->folder_radio ), TRUE );
-            gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( ui->folder_chooser ), filename );
+            gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ui->folder_radio), TRUE);
+            gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (ui->folder_chooser), filename);
             success = TRUE;
         }
-        else if( g_file_test( filename, G_FILE_TEST_IS_REGULAR ) )
+        else if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
         {
             /* a file was dragged on to the dialog... */
-            gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( ui->file_radio ), TRUE );
-            gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( ui->file_chooser ), filename );
+            gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ui->file_radio), TRUE);
+            gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (ui->file_chooser), filename);
             success = TRUE;
         }
 
-        g_free( filename );
+        g_free (filename);
     }
 
-    g_strfreev( uris );
-    gtk_drag_finish( drag_context, success, FALSE, time_ );
+    g_strfreev (uris);
+    gtk_drag_finish (drag_context, success, FALSE, time_);
 }
 
 GtkWidget*
-gtr_torrent_creation_dialog_new( GtkWindow  * parent, TrCore * core )
+gtr_torrent_creation_dialog_new (GtkWindow  * parent, TrCore * core)
 {
     const char * str;
     GtkWidget * d, *t, *w, *l, *fr, *sw, *v;
     GSList * slist;
     guint row = 0;
-    MakeMetaUI * ui = g_new0 ( MakeMetaUI, 1 );
+    MakeMetaUI * ui = g_new0 (MakeMetaUI, 1);
 
     ui->core = core;
 
-    d = gtk_dialog_new_with_buttons( _( "New Torrent" ),
+    d = gtk_dialog_new_with_buttons (_("New Torrent"),
                                      parent,
                                      GTK_DIALOG_DESTROY_WITH_PARENT,
                                      GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
                                      GTK_STOCK_NEW, GTK_RESPONSE_ACCEPT,
-                                     NULL );
+                                     NULL);
     ui->dialog = d;
-    g_signal_connect( d, "response", G_CALLBACK( onResponse ), ui );
-    g_object_set_data_full( G_OBJECT( d ), "ui", ui, freeMetaUI );
+    g_signal_connect (d, "response", G_CALLBACK (onResponse), ui);
+    g_object_set_data_full (G_OBJECT (d), "ui", ui, freeMetaUI);
 
-    t = hig_workarea_create ( );
+    t = hig_workarea_create ();
 
-    hig_workarea_add_section_title ( t, &row, _( "Files" ) );
+    hig_workarea_add_section_title (t, &row, _("Files"));
 
-        str = _( "Sa_ve to:" );
-        w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
-        gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), getDefaultSavePath( ) );
+        str = _("Sa_ve to:");
+        w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
+        gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), getDefaultSavePath ());
         ui->destination_chooser = w;
-        hig_workarea_add_row( t, &row, str, w, NULL );
-
-        l = gtk_radio_button_new_with_mnemonic( NULL, _( "Source F_older:" ) );
-        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( l ), FALSE );
-        w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
-        g_signal_connect( l, "toggled", G_CALLBACK( onFolderToggled ), ui );
-        g_signal_connect( l, "toggled", G_CALLBACK( onSourceToggled ), w );
-        g_signal_connect( w, "selection-changed", G_CALLBACK( onChooserChosen ), ui );
+        hig_workarea_add_row (t, &row, str, w, NULL);
+
+        l = gtk_radio_button_new_with_mnemonic (NULL, _("Source F_older:"));
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l), FALSE);
+        w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
+        g_signal_connect (l, "toggled", G_CALLBACK (onFolderToggled), ui);
+        g_signal_connect (l, "toggled", G_CALLBACK (onSourceToggled), w);
+        g_signal_connect (w, "selection-changed", G_CALLBACK (onChooserChosen), ui);
         ui->folder_radio = l;
         ui->folder_chooser = w;
-        gtk_widget_set_sensitive( GTK_WIDGET( w ), FALSE );
-        hig_workarea_add_row_w( t, &row, l, w, NULL );
-
-        slist = gtk_radio_button_get_group( GTK_RADIO_BUTTON( l ) ),
-        l = gtk_radio_button_new_with_mnemonic( slist, _( "Source _File:" ) );
-        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( l ), TRUE );
-        w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_OPEN );
-        g_signal_connect( l, "toggled", G_CALLBACK( onFileToggled ), ui );
-        g_signal_connect( l, "toggled", G_CALLBACK( onSourceToggled ), w );
-        g_signal_connect( w, "selection-changed", G_CALLBACK( onChooserChosen ), ui );
+        gtk_widget_set_sensitive (GTK_WIDGET (w), FALSE);
+        hig_workarea_add_row_w (t, &row, l, w, NULL);
+
+        slist = gtk_radio_button_get_group (GTK_RADIO_BUTTON (l)),
+        l = gtk_radio_button_new_with_mnemonic (slist, _("Source _File:"));
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l), TRUE);
+        w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_OPEN);
+        g_signal_connect (l, "toggled", G_CALLBACK (onFileToggled), ui);
+        g_signal_connect (l, "toggled", G_CALLBACK (onSourceToggled), w);
+        g_signal_connect (w, "selection-changed", G_CALLBACK (onChooserChosen), ui);
         ui->file_radio = l;
         ui->file_chooser = w;
-        hig_workarea_add_row_w( t, &row, l, w, NULL );
+        hig_workarea_add_row_w (t, &row, l, w, NULL);
 
-        w = gtk_label_new( NULL );
+        w = gtk_label_new (NULL);
         ui->pieces_lb = w;
-        gtk_label_set_markup( GTK_LABEL( w ), _( "<i>No source selected</i>" ) );
-        hig_workarea_add_row( t, &row, NULL, w, NULL );
-
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title ( t, &row, _( "Properties" ) );
-
-        str = _( "_Trackers:" );
-        v = gtk_box_new( GTK_ORIENTATION_VERTICAL, GUI_PAD_SMALL );
-        ui->announce_text_buffer = gtk_text_buffer_new( NULL );
-        w = gtk_text_view_new_with_buffer( ui->announce_text_buffer );
-        gtk_widget_set_size_request( w, -1, 80 );
-        sw = gtk_scrolled_window_new( NULL, NULL );
-        gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sw ),
+        gtk_label_set_markup (GTK_LABEL (w), _("<i>No source selected</i>"));
+        hig_workarea_add_row (t, &row, NULL, w, NULL);
+
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Properties"));
+
+        str = _("_Trackers:");
+        v = gtk_box_new (GTK_ORIENTATION_VERTICAL, GUI_PAD_SMALL);
+        ui->announce_text_buffer = gtk_text_buffer_new (NULL);
+        w = gtk_text_view_new_with_buffer (ui->announce_text_buffer);
+        gtk_widget_set_size_request (w, -1, 80);
+        sw = gtk_scrolled_window_new (NULL, NULL);
+        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                         GTK_POLICY_AUTOMATIC,
-                                        GTK_POLICY_AUTOMATIC );
-        gtk_container_add( GTK_CONTAINER( sw ), w );
-        fr = gtk_frame_new( NULL );
-        gtk_frame_set_shadow_type( GTK_FRAME( fr ), GTK_SHADOW_IN );
-        gtk_container_add( GTK_CONTAINER( fr ), sw );
-        gtk_box_pack_start( GTK_BOX( v ), fr, TRUE, TRUE, 0 );
-        l = gtk_label_new( NULL );
-        gtk_label_set_markup( GTK_LABEL( l ), _( "To add a backup URL, add it on the line after the primary URL.\n"
-                                                 "To add another primary URL, add it after a blank line." ) );
-        gtk_label_set_justify( GTK_LABEL( l ), GTK_JUSTIFY_LEFT );
-        gtk_misc_set_alignment( GTK_MISC( l ), 0.0, 0.5 );
-        gtk_box_pack_start( GTK_BOX( v ), l, FALSE, FALSE, 0 );
-        hig_workarea_add_tall_row( t, &row, str, v, NULL );
-
-        l = gtk_check_button_new_with_mnemonic( _( "Co_mment:" ) );
+                                        GTK_POLICY_AUTOMATIC);
+        gtk_container_add (GTK_CONTAINER (sw), w);
+        fr = gtk_frame_new (NULL);
+        gtk_frame_set_shadow_type (GTK_FRAME (fr), GTK_SHADOW_IN);
+        gtk_container_add (GTK_CONTAINER (fr), sw);
+        gtk_box_pack_start (GTK_BOX (v), fr, TRUE, TRUE, 0);
+        l = gtk_label_new (NULL);
+        gtk_label_set_markup (GTK_LABEL (l), _("To add a backup URL, add it on the line after the primary URL.\n"
+                                                 "To add another primary URL, add it after a blank line."));
+        gtk_label_set_justify (GTK_LABEL (l), GTK_JUSTIFY_LEFT);
+        gtk_misc_set_alignment (GTK_MISC (l), 0.0, 0.5);
+        gtk_box_pack_start (GTK_BOX (v), l, FALSE, FALSE, 0);
+        hig_workarea_add_tall_row (t, &row, str, v, NULL);
+
+        l = gtk_check_button_new_with_mnemonic (_("Co_mment:"));
         ui->comment_check = l;
-        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( l ), FALSE );
-        w = gtk_entry_new( );
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l), FALSE);
+        w = gtk_entry_new ();
         ui->comment_entry = w;
-        gtk_widget_set_sensitive( GTK_WIDGET( w ), FALSE );
-        g_signal_connect( l, "toggled", G_CALLBACK( onSourceToggled ), w );
-        hig_workarea_add_row_w( t, &row, l, w, NULL );
+        gtk_widget_set_sensitive (GTK_WIDGET (w), FALSE);
+        g_signal_connect (l, "toggled", G_CALLBACK (onSourceToggled), w);
+        hig_workarea_add_row_w (t, &row, l, w, NULL);
 
-        w = hig_workarea_add_wide_checkbutton( t, &row, _( "_Private torrent" ), FALSE );
+        w = hig_workarea_add_wide_checkbutton (t, &row, _("_Private torrent"), FALSE);
         ui->private_check = w;
 
-    gtr_dialog_set_content( GTK_DIALOG( d ), t );
+    gtr_dialog_set_content (GTK_DIALOG (d), t);
 
-    gtk_drag_dest_set( d, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY );
-    gtk_drag_dest_add_uri_targets( d );
-    g_signal_connect( d, "drag-data-received", G_CALLBACK( on_drag_data_received ), ui );
+    gtk_drag_dest_set (d, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
+    gtk_drag_dest_add_uri_targets (d);
+    g_signal_connect (d, "drag-data-received", G_CALLBACK (on_drag_data_received), ui);
 
     return d;
 }
diff --git a/gtk/makemeta-ui.h b/gtk/makemeta-ui.h
index ccb2274e0..c34e1f2f4 100644
--- a/gtk/makemeta-ui.h
+++ b/gtk/makemeta-ui.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,6 +16,6 @@
 #include <gtk/gtk.h>
 #include "tr-core.h"
 
-GtkWidget* gtr_torrent_creation_dialog_new( GtkWindow * parent, TrCore * core );
+GtkWidget* gtr_torrent_creation_dialog_new (GtkWindow * parent, TrCore * core);
 
 #endif
diff --git a/gtk/msgwin.c b/gtk/msgwin.c
index 07d95300e..3daa4595c 100644
--- a/gtk/msgwin.c
+++ b/gtk/msgwin.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -56,46 +56,46 @@ static struct tr_msg_list * myHead = NULL;
 
 /* is the user looking at the latest messages? */
 static gboolean
-is_pinned_to_new( struct MsgData * data )
+is_pinned_to_new (struct MsgData * data)
 {
-    gboolean pinned_to_new = FALSE;
+  gboolean pinned_to_new = FALSE;
 
-    if( data->view == NULL )
+  if (data->view == NULL)
     {
-        pinned_to_new = TRUE;
+      pinned_to_new = TRUE;
     }
     else
     {
-        GtkTreePath * last_visible;
-        if( gtk_tree_view_get_visible_range( data->view, NULL, &last_visible ) )
+      GtkTreePath * last_visible;
+      if (gtk_tree_view_get_visible_range (data->view, NULL, &last_visible))
         {
-            GtkTreeIter iter;
-            const int row_count = gtk_tree_model_iter_n_children( data->sort, NULL );
-            if( gtk_tree_model_iter_nth_child( data->sort, &iter, NULL, row_count-1 ) )
+          GtkTreeIter iter;
+          const int row_count = gtk_tree_model_iter_n_children (data->sort, NULL);
+          if (gtk_tree_model_iter_nth_child (data->sort, &iter, NULL, row_count-1))
             {
-                GtkTreePath * last_row = gtk_tree_model_get_path( data->sort, &iter );
-                pinned_to_new = !gtk_tree_path_compare( last_visible, last_row );
-                gtk_tree_path_free( last_row );
+              GtkTreePath * last_row = gtk_tree_model_get_path (data->sort, &iter);
+              pinned_to_new = !gtk_tree_path_compare (last_visible, last_row);
+              gtk_tree_path_free (last_row);
             }
-            gtk_tree_path_free( last_visible );
+          gtk_tree_path_free (last_visible);
         }
     }
 
-    return pinned_to_new;
+  return pinned_to_new;
 }
 
 static void
-scroll_to_bottom( struct MsgData * data )
+scroll_to_bottom (struct MsgData * data)
 {
-    if( data->sort != NULL )
+  if (data->sort != NULL)
     {
-        GtkTreeIter iter;
-        const int row_count = gtk_tree_model_iter_n_children( data->sort, NULL );
-        if( gtk_tree_model_iter_nth_child( data->sort, &iter, NULL, row_count-1 ) )
+      GtkTreeIter iter;
+      const int row_count = gtk_tree_model_iter_n_children (data->sort, NULL);
+      if (gtk_tree_model_iter_nth_child (data->sort, &iter, NULL, row_count-1))
         {
-            GtkTreePath * last_row = gtk_tree_model_get_path( data->sort, &iter );
-            gtk_tree_view_scroll_to_cell( data->view, last_row, NULL, TRUE, 1, 0 );
-            gtk_tree_path_free( last_row );
+          GtkTreePath * last_row = gtk_tree_model_get_path (data->sort, &iter);
+          gtk_tree_view_scroll_to_cell (data->view, last_row, NULL, TRUE, 1, 0);
+          gtk_tree_path_free (last_row);
         }
     }
 }
@@ -105,332 +105,343 @@ scroll_to_bottom( struct MsgData * data )
 ****/
 
 static void
-level_combo_changed_cb( GtkComboBox * combo_box, gpointer gdata )
+level_combo_changed_cb (GtkComboBox * combo_box, gpointer gdata)
 {
-    struct MsgData * data = gdata;
-    const int level = gtr_combo_box_get_active_enum( combo_box );
-    const gboolean pinned_to_new = is_pinned_to_new( data );
+  struct MsgData * data = gdata;
+  const int level = gtr_combo_box_get_active_enum (combo_box);
+  const gboolean pinned_to_new = is_pinned_to_new (data);
 
-    tr_setMessageLevel( level );
-    gtr_core_set_pref_int( data->core, TR_PREFS_KEY_MSGLEVEL, level );
-    data->maxLevel = level;
-    gtk_tree_model_filter_refilter( GTK_TREE_MODEL_FILTER( data->filter ) );
+  tr_setMessageLevel (level);
+  gtr_core_set_pref_int (data->core, TR_PREFS_KEY_MSGLEVEL, level);
+  data->maxLevel = level;
+  gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (data->filter));
 
-    if( pinned_to_new )
-        scroll_to_bottom( data );
+  if (pinned_to_new)
+    scroll_to_bottom (data);
 }
 
 /* similar to asctime, but is utf8-clean */
 static char*
-gtr_localtime( time_t time )
+gtr_localtime (time_t time)
 {
-    char buf[256], *eoln;
-    const struct tm tm = *localtime( &time );
+  char buf[256], *eoln;
+  const struct tm tm = *localtime (&time);
 
-    g_strlcpy( buf, asctime( &tm ), sizeof( buf ) );
-    if( ( eoln = strchr( buf, '\n' ) ) )
-        *eoln = '\0';
+  g_strlcpy (buf, asctime (&tm), sizeof (buf));
+  if ((eoln = strchr (buf, '\n')))
+    *eoln = '\0';
 
-    return g_locale_to_utf8( buf, -1, NULL, NULL, NULL );
+  return g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);
 }
 
 static void
-doSave( GtkWindow * parent, struct MsgData * data, const char * filename )
+doSave (GtkWindow * parent, struct MsgData * data, const char * filename)
 {
-    FILE * fp = fopen( filename, "w+" );
+  FILE * fp = fopen (filename, "w+");
 
-    if( !fp )
+  if (!fp)
     {
-        GtkWidget * w = gtk_message_dialog_new( parent, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _( "Couldn't save \"%s\"" ), filename );
-        gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ), "%s", g_strerror( errno ) );
-        g_signal_connect_swapped( w, "response", G_CALLBACK( gtk_widget_destroy ), w );
-        gtk_widget_show( w );
+      GtkWidget * w = gtk_message_dialog_new (parent, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Couldn't save \"%s\""), filename);
+      gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w), "%s", g_strerror (errno));
+      g_signal_connect_swapped (w, "response", G_CALLBACK (gtk_widget_destroy), w);
+      gtk_widget_show (w);
     }
-    else
+  else
     {
-        GtkTreeIter iter;
-        GtkTreeModel * model = GTK_TREE_MODEL( data->sort );
-        if( gtk_tree_model_iter_children( model, &iter, NULL ) ) do
+      GtkTreeIter iter;
+      GtkTreeModel * model = GTK_TREE_MODEL (data->sort);
+      if (gtk_tree_model_iter_children (model, &iter, NULL)) do
         {
-            char * date;
-            const char * levelStr;
-            const struct tr_msg_list * node;
-
-            gtk_tree_model_get( model, &iter, COL_TR_MSG, &node, -1 );
-            date = gtr_localtime( node->when );
-            switch( node->level ) {
-                case TR_MSG_DBG: levelStr = "debug"; break;
-                case TR_MSG_ERR: levelStr = "error"; break;
-                default:         levelStr = "     "; break;
+          char * date;
+          const char * levelStr;
+          const struct tr_msg_list * node;
+
+          gtk_tree_model_get (model, &iter, COL_TR_MSG, &node, -1);
+          date = gtr_localtime (node->when);
+          switch (node->level)
+           {
+             case TR_MSG_DBG:
+               levelStr = "debug";
+               break;
+
+             case TR_MSG_ERR:
+               levelStr = "error";
+               break;
+
+             default:
+               levelStr = "     ";
+               break;
             }
-            fprintf( fp, "%s\t%s\t%s\t%s\n", date, levelStr,
-                     ( node->name ? node->name : "" ),
-                     ( node->message ? node->message : "" ) );
-            g_free( date );
+
+          fprintf (fp, "%s\t%s\t%s\t%s\n", date, levelStr,
+                   (node->name ? node->name : ""),
+                   (node->message ? node->message : ""));
+          g_free (date);
         }
-        while( gtk_tree_model_iter_next( model, &iter ) );
+      while (gtk_tree_model_iter_next (model, &iter));
 
-        fclose( fp );
+      fclose (fp);
     }
 }
 
 static void
-onSaveDialogResponse( GtkWidget * d, int response, gpointer data )
+onSaveDialogResponse (GtkWidget * d, int response, gpointer data)
 {
-    if( response == GTK_RESPONSE_ACCEPT )
+  if (response == GTK_RESPONSE_ACCEPT)
     {
-        char * file = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( d ) );
-        doSave( GTK_WINDOW( d ), data, file );
-        g_free( file );
+      char * file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (d));
+      doSave (GTK_WINDOW (d), data, file);
+      g_free (file);
     }
 
-    gtk_widget_destroy( d );
+  gtk_widget_destroy (d);
 }
 
 static void
-onSaveRequest( GtkWidget * w,
-               gpointer    data )
+onSaveRequest (GtkWidget * w,
+               gpointer    data)
 {
-    GtkWindow * window = GTK_WINDOW( gtk_widget_get_toplevel( w ) );
-    GtkWidget * d = gtk_file_chooser_dialog_new( _( "Save Log" ), window,
-                                                 GTK_FILE_CHOOSER_ACTION_SAVE,
-                                                 GTK_STOCK_CANCEL,
-                                                 GTK_RESPONSE_CANCEL,
-                                                 GTK_STOCK_SAVE,
-                                                 GTK_RESPONSE_ACCEPT,
-                                                 NULL );
-
-    gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
-                                             GTK_RESPONSE_ACCEPT,
-                                             GTK_RESPONSE_CANCEL,
-                                             -1 );
-    g_signal_connect( d, "response",
-                      G_CALLBACK( onSaveDialogResponse ), data );
-    gtk_widget_show( d );
+  GtkWindow * window = GTK_WINDOW (gtk_widget_get_toplevel (w));
+  GtkWidget * d = gtk_file_chooser_dialog_new (_("Save Log"), window,
+                                               GTK_FILE_CHOOSER_ACTION_SAVE,
+                                               GTK_STOCK_CANCEL,
+                                               GTK_RESPONSE_CANCEL,
+                                               GTK_STOCK_SAVE,
+                                               GTK_RESPONSE_ACCEPT,
+                                               NULL);
+
+  gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
+                                           GTK_RESPONSE_ACCEPT,
+                                           GTK_RESPONSE_CANCEL,
+                                           -1);
+  g_signal_connect (d, "response",
+                    G_CALLBACK (onSaveDialogResponse), data);
+  gtk_widget_show (d);
 }
 
 static void
-onClearRequest( GtkWidget * w UNUSED, gpointer gdata )
+onClearRequest (GtkWidget * w UNUSED, gpointer gdata)
 {
-    struct MsgData * data = gdata;
+  struct MsgData * data = gdata;
 
-    gtk_list_store_clear( data->store );
-    tr_freeMessageList( myHead );
-    myHead = myTail = NULL;
+  gtk_list_store_clear (data->store);
+  tr_freeMessageList (myHead);
+  myHead = myTail = NULL;
 }
 
 static void
-onPauseToggled( GtkToggleToolButton * w, gpointer gdata )
+onPauseToggled (GtkToggleToolButton * w, gpointer gdata)
 {
-    struct MsgData * data = gdata;
+  struct MsgData * data = gdata;
 
-    data->isPaused = gtk_toggle_tool_button_get_active( w );
+  data->isPaused = gtk_toggle_tool_button_get_active (w);
 }
 
 static const char*
-getForegroundColor( int msgLevel )
+getForegroundColor (int msgLevel)
 {
-    switch( msgLevel )
+  switch (msgLevel)
     {
-        case TR_MSG_DBG: return "forestgreen";
-        case TR_MSG_INF: return "black";
-        case TR_MSG_ERR: return "red";
-        default: g_assert_not_reached( ); return "black";
+      case TR_MSG_DBG: return "forestgreen";
+      case TR_MSG_INF: return "black";
+      case TR_MSG_ERR: return "red";
+      default: g_assert_not_reached (); return "black";
     }
 }
 
 static void
-renderText( GtkTreeViewColumn  * column UNUSED,
+renderText (GtkTreeViewColumn  * column UNUSED,
             GtkCellRenderer *           renderer,
             GtkTreeModel *              tree_model,
             GtkTreeIter *               iter,
-            gpointer                    gcol )
+            gpointer                    gcol)
 {
-    const int                  col = GPOINTER_TO_INT( gcol );
-    char *                     str = NULL;
-    const struct tr_msg_list * node;
-
-    gtk_tree_model_get( tree_model, iter, col, &str, COL_TR_MSG, &node, -1 );
-    g_object_set( renderer, "text", str,
-                  "foreground", getForegroundColor( node->level ),
-                  "ellipsize", PANGO_ELLIPSIZE_END,
-                  NULL );
+  const int col = GPOINTER_TO_INT (gcol);
+  char * str = NULL;
+  const struct tr_msg_list * node;
+
+  gtk_tree_model_get (tree_model, iter, col, &str, COL_TR_MSG, &node, -1);
+  g_object_set (renderer, "text", str,
+                          "foreground", getForegroundColor (node->level),
+                          "ellipsize", PANGO_ELLIPSIZE_END,
+                          NULL);
 }
 
 static void
-renderTime( GtkTreeViewColumn  * column UNUSED,
+renderTime (GtkTreeViewColumn  * column UNUSED,
             GtkCellRenderer *           renderer,
             GtkTreeModel *              tree_model,
             GtkTreeIter *               iter,
-            gpointer             data   UNUSED )
+            gpointer             data   UNUSED)
 {
-    struct tm                  tm;
-    char                       buf[16];
-    const struct tr_msg_list * node;
-
-    gtk_tree_model_get( tree_model, iter, COL_TR_MSG, &node, -1 );
-    tm = *localtime( &node->when );
-    g_snprintf( buf, sizeof( buf ), "%02d:%02d:%02d", tm.tm_hour, tm.tm_min,
-                tm.tm_sec );
-    g_object_set ( renderer, "text", buf,
-                   "foreground", getForegroundColor( node->level ),
-                   NULL );
+  struct tm tm;
+  char buf[16];
+  const struct tr_msg_list * node;
+
+  gtk_tree_model_get (tree_model, iter, COL_TR_MSG, &node, -1);
+  tm = *localtime (&node->when);
+  g_snprintf (buf, sizeof (buf), "%02d:%02d:%02d", tm.tm_hour, tm.tm_min,
+              tm.tm_sec);
+  g_object_set (renderer, "text", buf,
+                          "foreground", getForegroundColor (node->level),
+                          NULL);
 }
 
 static void
-appendColumn( GtkTreeView * view,
-              int           col )
+appendColumn (GtkTreeView * view, int col)
 {
-    GtkCellRenderer *   r;
-    GtkTreeViewColumn * c;
-    const char *        title = NULL;
+  GtkCellRenderer *   r;
+  GtkTreeViewColumn * c;
+  const char * title = NULL;
 
-    switch( col )
+  switch (col)
     {
-        case COL_SEQUENCE:
-            title = _( "Time" ); break;
-
-        /* noun. column title for a list */
-        case COL_NAME:
-            title = _( "Name" ); break;
-
-        /* noun. column title for a list */
-        case COL_MESSAGE:
-            title = _( "Message" ); break;
-
-        default:
-            g_assert_not_reached( );
+      case COL_SEQUENCE:
+        title = _("Time");
+        break;
+
+      /* noun. column title for a list */
+      case COL_NAME:
+        title = _("Name");
+        break;
+
+      /* noun. column title for a list */
+      case COL_MESSAGE:
+        title = _("Message");
+        break;
+
+      default:
+        g_assert_not_reached ();
     }
 
-    switch( col )
+  switch (col)
     {
-        case COL_NAME:
-            r = gtk_cell_renderer_text_new( );
-            c = gtk_tree_view_column_new_with_attributes( title, r, NULL );
-            gtk_tree_view_column_set_cell_data_func( c, r, renderText,
-                                                     GINT_TO_POINTER(
-                                                         col ), NULL );
-            gtk_tree_view_column_set_sizing( c, GTK_TREE_VIEW_COLUMN_FIXED );
-            gtk_tree_view_column_set_fixed_width( c, 200 );
-            gtk_tree_view_column_set_resizable( c, TRUE );
-            break;
-
-        case COL_MESSAGE:
-            r = gtk_cell_renderer_text_new( );
-            c = gtk_tree_view_column_new_with_attributes( title, r, NULL );
-            gtk_tree_view_column_set_cell_data_func( c, r, renderText,
-                                                     GINT_TO_POINTER(
-                                                         col ), NULL );
-            gtk_tree_view_column_set_sizing( c, GTK_TREE_VIEW_COLUMN_FIXED );
-            gtk_tree_view_column_set_fixed_width( c, 500 );
-            gtk_tree_view_column_set_resizable( c, TRUE );
-            break;
-
-        case COL_SEQUENCE:
-            r = gtk_cell_renderer_text_new( );
-            c = gtk_tree_view_column_new_with_attributes( title, r, NULL );
-            gtk_tree_view_column_set_cell_data_func( c, r, renderTime, NULL,
-                                                     NULL );
-            gtk_tree_view_column_set_resizable( c, TRUE );
-            break;
-
-        default:
-            g_assert_not_reached( );
-            break;
+      case COL_NAME:
+        r = gtk_cell_renderer_text_new ();
+        c = gtk_tree_view_column_new_with_attributes (title, r, NULL);
+        gtk_tree_view_column_set_cell_data_func (c, r, renderText,
+                                                 GINT_TO_POINTER (col), NULL);
+        gtk_tree_view_column_set_sizing (c, GTK_TREE_VIEW_COLUMN_FIXED);
+        gtk_tree_view_column_set_fixed_width (c, 200);
+        gtk_tree_view_column_set_resizable (c, TRUE);
+        break;
+
+      case COL_MESSAGE:
+        r = gtk_cell_renderer_text_new ();
+        c = gtk_tree_view_column_new_with_attributes (title, r, NULL);
+        gtk_tree_view_column_set_cell_data_func (c, r, renderText,
+                                                 GINT_TO_POINTER (col), NULL);
+        gtk_tree_view_column_set_sizing (c, GTK_TREE_VIEW_COLUMN_FIXED);
+        gtk_tree_view_column_set_fixed_width (c, 500);
+        gtk_tree_view_column_set_resizable (c, TRUE);
+        break;
+
+      case COL_SEQUENCE:
+        r = gtk_cell_renderer_text_new ();
+        c = gtk_tree_view_column_new_with_attributes (title, r, NULL);
+        gtk_tree_view_column_set_cell_data_func (c, r, renderTime, NULL, NULL);
+        gtk_tree_view_column_set_resizable (c, TRUE);
+        break;
+
+      default:
+        g_assert_not_reached ();
+        break;
     }
 
-    gtk_tree_view_append_column( view, c );
+  gtk_tree_view_append_column (view, c);
 }
 
 static gboolean
-isRowVisible( GtkTreeModel * model, GtkTreeIter * iter, gpointer gdata )
+isRowVisible (GtkTreeModel * model, GtkTreeIter * iter, gpointer gdata)
 {
-    const struct MsgData *     data = gdata;
-    const struct tr_msg_list * node;
+  const struct tr_msg_list * node;
+  const struct MsgData * data = gdata;
+
+  gtk_tree_model_get (model, iter, COL_TR_MSG, &node, -1);
 
-    gtk_tree_model_get( model, iter, COL_TR_MSG, &node, -1 );
-    return node->level <= data->maxLevel;
+  return node->level <= data->maxLevel;
 }
 
 static void
-onWindowDestroyed( gpointer gdata, GObject * deadWindow UNUSED )
+onWindowDestroyed (gpointer gdata, GObject * deadWindow UNUSED)
 {
-    struct MsgData * data = gdata;
+  struct MsgData * data = gdata;
+
+  g_source_remove (data->refresh_tag);
 
-    g_source_remove( data->refresh_tag );
-    g_free( data );
+  g_free (data);
 }
 
 static tr_msg_list *
-addMessages( GtkListStore * store, struct tr_msg_list * head )
+addMessages (GtkListStore * store, struct tr_msg_list * head)
 {
-    tr_msg_list * i;
-    static unsigned int sequence = 0;
-    const char * default_name = g_get_application_name( );
+  tr_msg_list * i;
+  static unsigned int sequence = 0;
+  const char * default_name = g_get_application_name ();
 
-    for( i=head; i && i->next; i=i->next )
+  for (i=head; i && i->next; i=i->next)
     {
-        const char * name = i->name ? i->name : default_name;
+      const char * name = i->name ? i->name : default_name;
 
-        gtk_list_store_insert_with_values( store, NULL, 0,
-                                           COL_TR_MSG, i,
-                                           COL_NAME, name,
-                                           COL_MESSAGE, i->message,
-                                           COL_SEQUENCE, ++sequence,
-                                           -1 );
+      gtk_list_store_insert_with_values (store, NULL, 0,
+                                         COL_TR_MSG, i,
+                                         COL_NAME, name,
+                                         COL_MESSAGE, i->message,
+                                         COL_SEQUENCE, ++sequence,
+                                         -1);
 
-        /* if it's an error message, dump it to the terminal too */
-        if( i->level == TR_MSG_ERR )
+      /* if it's an error message, dump it to the terminal too */
+      if (i->level == TR_MSG_ERR)
         {
-            GString * gstr = g_string_sized_new( 512 );
-            g_string_append_printf( gstr, "%s:%d %s", i->file, i->line, i->message );
-            if( i->name != NULL )
-                g_string_append_printf( gstr, " (%s)", i->name );
-            g_warning( "%s", gstr->str );
-            g_string_free( gstr, TRUE );
+          GString * gstr = g_string_sized_new (512);
+          g_string_append_printf (gstr, "%s:%d %s", i->file, i->line, i->message);
+          if (i->name != NULL)
+            g_string_append_printf (gstr, " (%s)", i->name);
+          g_warning ("%s", gstr->str);
+          g_string_free (gstr, TRUE);
         }
     }
 
-    return i; /* tail */
+  return i; /* tail */
 }
 
 static gboolean
-onRefresh( gpointer gdata )
+onRefresh (gpointer gdata)
 {
-    struct MsgData * data = gdata;
-    const gboolean pinned_to_new = is_pinned_to_new( data );
+  struct MsgData * data = gdata;
+  const gboolean pinned_to_new = is_pinned_to_new (data);
 
-    if( !data->isPaused )
+  if (!data->isPaused)
     {
-        tr_msg_list * msgs = tr_getQueuedMessages( );
-        if( msgs )
+      tr_msg_list * msgs = tr_getQueuedMessages ();
+      if (msgs)
         {
-            /* add the new messages and append them to the end of
-             * our persistent list */
-            tr_msg_list * tail = addMessages( data->store, msgs );
-            if( myTail )
-                myTail->next = msgs;
-            else
-                myHead = msgs;
-            myTail = tail;
+          /* add the new messages and append them to the end of
+           * our persistent list */
+          tr_msg_list * tail = addMessages (data->store, msgs);
+          if (myTail)
+              myTail->next = msgs;
+          else
+              myHead = msgs;
+          myTail = tail;
         }
 
-        if( pinned_to_new )
-            scroll_to_bottom( data );
+      if (pinned_to_new)
+        scroll_to_bottom (data);
     }
 
-    return TRUE;
+  return TRUE;
 }
 
 static GtkWidget*
-debug_level_combo_new( void )
+debug_level_combo_new (void)
 {
-    GtkWidget * w = gtr_combo_box_new_enum( _( "Error" ),       TR_MSG_ERR,
-                                            _( "Information" ), TR_MSG_INF,
-                                            _( "Debug" ),       TR_MSG_DBG,
-                                            NULL );
-    gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( TR_PREFS_KEY_MSGLEVEL ) );
-    return w;
+  GtkWidget * w = gtr_combo_box_new_enum (_("Error"),       TR_MSG_ERR,
+                                          _("Information"), TR_MSG_INF,
+                                          _("Debug"),       TR_MSG_DBG,
+                                          NULL);
+  gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (TR_PREFS_KEY_MSGLEVEL));
+  return w;
 }
 
 /**
@@ -438,121 +449,118 @@ debug_level_combo_new( void )
 **/
 
 GtkWidget *
-gtr_message_log_window_new( GtkWindow * parent, TrCore * core )
+gtr_message_log_window_new (GtkWindow * parent, TrCore * core)
 {
-    GtkWidget *      win;
-    GtkWidget *      vbox;
-    GtkWidget *      toolbar;
-    GtkWidget *      w;
-    GtkWidget *      view;
-    GtkToolItem *    item;
-    struct MsgData * data;
-
-    data = g_new0( struct MsgData, 1 );
-    data->core = core;
-
-    win = gtk_window_new( GTK_WINDOW_TOPLEVEL );
-    gtk_window_set_transient_for( GTK_WINDOW( win ), parent );
-    gtk_window_set_title( GTK_WINDOW( win ), _( "Message Log" ) );
-    gtk_window_set_default_size( GTK_WINDOW( win ), 560, 350 );
-    gtk_window_set_role( GTK_WINDOW( win ), "message-log" );
-    vbox = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
-
-    /**
-    ***  toolbar
-    **/
-
-    toolbar = gtk_toolbar_new( );
-    gtk_toolbar_set_style( GTK_TOOLBAR( toolbar ), GTK_TOOLBAR_BOTH_HORIZ );
-    gtk_style_context_add_class( gtk_widget_get_style_context( toolbar ),
-                                 GTK_STYLE_CLASS_PRIMARY_TOOLBAR );
-
-    item = gtk_tool_button_new_from_stock( GTK_STOCK_SAVE_AS );
-    g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
-    g_signal_connect( item, "clicked", G_CALLBACK( onSaveRequest ), data );
-    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
-
-    item = gtk_tool_button_new_from_stock( GTK_STOCK_CLEAR );
-    g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
-    g_signal_connect( item, "clicked", G_CALLBACK( onClearRequest ), data );
-    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
-
-    item = gtk_separator_tool_item_new( );
-    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
-
-    item = gtk_toggle_tool_button_new_from_stock( GTK_STOCK_MEDIA_PAUSE );
-    g_object_set( G_OBJECT( item ), "is-important", TRUE, NULL );
-    g_signal_connect( item, "toggled", G_CALLBACK( onPauseToggled ), data );
-    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
-
-    item = gtk_separator_tool_item_new( );
-    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
-
-    w = gtk_label_new( _( "Level" ) );
-    gtk_misc_set_padding( GTK_MISC( w ), GUI_PAD, 0 );
-    item = gtk_tool_item_new( );
-    gtk_container_add( GTK_CONTAINER( item ), w );
-    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
-
-    w = debug_level_combo_new( );
-    g_signal_connect( w, "changed", G_CALLBACK( level_combo_changed_cb ), data );
-    item = gtk_tool_item_new( );
-    gtk_container_add( GTK_CONTAINER( item ), w );
-    gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), item, -1 );
-
-    gtk_box_pack_start( GTK_BOX( vbox ), toolbar, FALSE, FALSE, 0 );
-
-    /**
-    ***  messages
-    **/
-
-    data->store = gtk_list_store_new( N_COLUMNS,
-                                      G_TYPE_UINT,       /* sequence */
-                                      G_TYPE_POINTER,    /* category */
-                                      G_TYPE_POINTER,    /* message */
-                                      G_TYPE_POINTER );   /* struct tr_msg_list
-                                                            */
-
-    addMessages( data->store, myHead );
-    onRefresh( data ); /* much faster to populate *before* it has listeners */
-
-    data->filter = gtk_tree_model_filter_new( GTK_TREE_MODEL(
-                                                  data->store ), NULL );
-    data->sort = gtk_tree_model_sort_new_with_model( data->filter );
-    g_object_unref( data->filter );
-    gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE( data->sort ),
-                                          COL_SEQUENCE,
-                                          GTK_SORT_ASCENDING );
-    data->maxLevel = gtr_pref_int_get( TR_PREFS_KEY_MSGLEVEL );
-    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( data->
-                                                                   filter ),
-                                            isRowVisible, data, NULL );
-
-
-    view = gtk_tree_view_new_with_model( data->sort );
-    g_object_unref( data->sort );
-    g_signal_connect( view, "button-release-event",
-                      G_CALLBACK( on_tree_view_button_released ), NULL );
-    data->view = GTK_TREE_VIEW( view );
-    gtk_tree_view_set_rules_hint( data->view, TRUE );
-    appendColumn( data->view, COL_SEQUENCE );
-    appendColumn( data->view, COL_NAME );
-    appendColumn( data->view, COL_MESSAGE );
-    w = gtk_scrolled_window_new( NULL, NULL );
-    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
-                                    GTK_POLICY_AUTOMATIC,
-                                    GTK_POLICY_AUTOMATIC );
-    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
-                                         GTK_SHADOW_IN );
-    gtk_container_add( GTK_CONTAINER( w ), view );
-    gtk_box_pack_start( GTK_BOX( vbox ), w, TRUE, TRUE, 0 );
-    gtk_container_add( GTK_CONTAINER( win ), vbox );
-
-    data->refresh_tag = gdk_threads_add_timeout_seconds( SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS, onRefresh, data );
-    g_object_weak_ref( G_OBJECT( win ), onWindowDestroyed, data );
-
-    scroll_to_bottom( data );
-    gtk_widget_show_all( win );
-    return win;
+  GtkWidget * win;
+  GtkWidget * vbox;
+  GtkWidget * toolbar;
+  GtkWidget * w;
+  GtkWidget * view;
+  GtkToolItem * item;
+  struct MsgData * data;
+
+  data = g_new0 (struct MsgData, 1);
+  data->core = core;
+
+  win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_transient_for (GTK_WINDOW (win), parent);
+  gtk_window_set_title (GTK_WINDOW (win), _("Message Log"));
+  gtk_window_set_default_size (GTK_WINDOW (win), 560, 350);
+  gtk_window_set_role (GTK_WINDOW (win), "message-log");
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+
+  /**
+  ***  toolbar
+  **/
+
+  toolbar = gtk_toolbar_new ();
+  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
+  gtk_style_context_add_class (gtk_widget_get_style_context (toolbar),
+                               GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
+
+  item = gtk_tool_button_new_from_stock (GTK_STOCK_SAVE_AS);
+  g_object_set (G_OBJECT (item), "is-important", TRUE, NULL);
+  g_signal_connect (item, "clicked", G_CALLBACK (onSaveRequest), data);
+  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
+
+  item = gtk_tool_button_new_from_stock (GTK_STOCK_CLEAR);
+  g_object_set (G_OBJECT (item), "is-important", TRUE, NULL);
+  g_signal_connect (item, "clicked", G_CALLBACK (onClearRequest), data);
+  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
+
+  item = gtk_separator_tool_item_new ();
+  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
+
+  item = gtk_toggle_tool_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE);
+  g_object_set (G_OBJECT (item), "is-important", TRUE, NULL);
+  g_signal_connect (item, "toggled", G_CALLBACK (onPauseToggled), data);
+  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
+
+  item = gtk_separator_tool_item_new ();
+  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
+
+  w = gtk_label_new (_("Level"));
+  gtk_misc_set_padding (GTK_MISC (w), GUI_PAD, 0);
+  item = gtk_tool_item_new ();
+  gtk_container_add (GTK_CONTAINER (item), w);
+  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
+
+  w = debug_level_combo_new ();
+  g_signal_connect (w, "changed", G_CALLBACK (level_combo_changed_cb), data);
+  item = gtk_tool_item_new ();
+  gtk_container_add (GTK_CONTAINER (item), w);
+  gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
+
+  gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
+
+  /**
+  ***  messages
+  **/
+
+  data->store = gtk_list_store_new (N_COLUMNS,
+                                    G_TYPE_UINT,       /* sequence */
+                                    G_TYPE_POINTER,    /* category */
+                                    G_TYPE_POINTER,    /* message */
+                                    G_TYPE_POINTER);   /* struct tr_msg_list */
+
+  addMessages (data->store, myHead);
+  onRefresh (data); /* much faster to populate *before* it has listeners */
+
+  data->filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (data->store), NULL);
+  data->sort = gtk_tree_model_sort_new_with_model (data->filter);
+  g_object_unref (data->filter);
+  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->sort),
+                                        COL_SEQUENCE,
+                                        GTK_SORT_ASCENDING);
+  data->maxLevel = gtr_pref_int_get (TR_PREFS_KEY_MSGLEVEL);
+  gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (data->filter),
+                                          isRowVisible, data, NULL);
+
+
+  view = gtk_tree_view_new_with_model (data->sort);
+  g_object_unref (data->sort);
+  g_signal_connect (view, "button-release-event",
+                    G_CALLBACK (on_tree_view_button_released), NULL);
+  data->view = GTK_TREE_VIEW (view);
+  gtk_tree_view_set_rules_hint (data->view, TRUE);
+  appendColumn (data->view, COL_SEQUENCE);
+  appendColumn (data->view, COL_NAME);
+  appendColumn (data->view, COL_MESSAGE);
+  w = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w),
+                                  GTK_POLICY_AUTOMATIC,
+                                  GTK_POLICY_AUTOMATIC);
+  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w),
+                                       GTK_SHADOW_IN);
+  gtk_container_add (GTK_CONTAINER (w), view);
+  gtk_box_pack_start (GTK_BOX (vbox), w, TRUE, TRUE, 0);
+  gtk_container_add (GTK_CONTAINER (win), vbox);
+
+  data->refresh_tag = gdk_threads_add_timeout_seconds (SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS, onRefresh, data);
+  g_object_weak_ref (G_OBJECT (win), onWindowDestroyed, data);
+
+  scroll_to_bottom (data);
+  gtk_widget_show_all (win);
+  return win;
 }
 
diff --git a/gtk/msgwin.h b/gtk/msgwin.h
index cd1947e32..094c93234 100644
--- a/gtk/msgwin.h
+++ b/gtk/msgwin.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -15,6 +15,6 @@
 
 #include "tr-core.h"
 
-GtkWidget * gtr_message_log_window_new( GtkWindow * parent, TrCore * core );
+GtkWidget * gtr_message_log_window_new (GtkWindow * parent, TrCore * core);
 
 #endif
diff --git a/gtk/notify.c b/gtk/notify.c
index 121c2ea30..77d71bed0 100644
--- a/gtk/notify.c
+++ b/gtk/notify.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,7 +10,7 @@
  * $Id$
  */
 
-#include <string.h> /* strcmp() */
+#include <string.h> /* strcmp () */
 
 #include <gio/gio.h>
 
@@ -36,219 +36,219 @@ typedef struct _TrNotification
 } TrNotification;
 
 static void
-tr_notification_free( gpointer data )
+tr_notification_free (gpointer data)
 {
     TrNotification * n = data;
-    if( n->core )
-        g_object_unref( G_OBJECT( n->core ) );
-    g_free( n );
+    if (n->core)
+        g_object_unref (G_OBJECT (n->core));
+    g_free (n);
 }
 
 static void
-get_capabilities_callback( GObject      * source,
+get_capabilities_callback (GObject      * source,
                            GAsyncResult * res,
-                           gpointer       user_data UNUSED )
+                           gpointer       user_data UNUSED)
 {
     GVariant  *result;
     char     **caps;
     int        i;
 
-    result = g_dbus_proxy_call_finish( G_DBUS_PROXY( source ), res, NULL );
-    if( !result || !g_variant_is_of_type( result, G_VARIANT_TYPE( "(as)" ) ) )
+    result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source), res, NULL);
+    if (!result || !g_variant_is_of_type (result, G_VARIANT_TYPE (" (as)")))
     {
-        if( result )
-            g_variant_unref( result );
+        if (result)
+            g_variant_unref (result);
         return;
     }
 
-    g_variant_get( result, "(^a&s)", &caps );
-    for( i = 0; caps[i]; i++ )
+    g_variant_get (result, " (^a&s)", &caps);
+    for (i = 0; caps[i]; i++)
     {
-        if( strcmp( caps[i], "actions" ) == 0 )
+        if (strcmp (caps[i], "actions") == 0)
         {
             server_supports_actions = TRUE;
             break;
         }
     }
-    g_free( caps );
-    g_variant_unref( result );
+    g_free (caps);
+    g_variant_unref (result);
 }
 
 static void
-g_signal_callback( GDBusProxy * proxy UNUSED,
+g_signal_callback (GDBusProxy * proxy UNUSED,
                    char       * sender_name UNUSED,
                    char       * signal_name,
                    GVariant   * params,
-                   gpointer     user_data UNUSED )
+                   gpointer     user_data UNUSED)
 {
     TrNotification * n;
     guint id;
 
-    g_return_if_fail( g_variant_is_of_type( params, G_VARIANT_TYPE( "(u*)" ) ) );
+    g_return_if_fail (g_variant_is_of_type (params, G_VARIANT_TYPE (" (u*)")));
 
-    g_variant_get( params, "(u*)", &id, NULL );
-    n = g_hash_table_lookup( active_notifications,
-                             GINT_TO_POINTER( (int *) &id ) );
-    if( n == NULL )
+    g_variant_get (params, " (u*)", &id, NULL);
+    n = g_hash_table_lookup (active_notifications,
+                             GINT_TO_POINTER ((int *) &id));
+    if (n == NULL)
         return;
 
-    if( strcmp( signal_name, "NotificationClosed" ) == 0 )
+    if (strcmp (signal_name, "NotificationClosed") == 0)
     {
-        g_hash_table_remove( active_notifications,
-                             GINT_TO_POINTER( (int *) &n->id ) );
+        g_hash_table_remove (active_notifications,
+                             GINT_TO_POINTER ((int *) &n->id));
     }
-    else if( strcmp( signal_name, "ActionInvoked" ) == 0 &&
-             g_variant_is_of_type( params, G_VARIANT_TYPE( "(us)" ) ) )
+    else if (strcmp (signal_name, "ActionInvoked") == 0 &&
+             g_variant_is_of_type (params, G_VARIANT_TYPE (" (us)")))
     {
         char * action;
         tr_torrent * tor;
 
-        tor = gtr_core_find_torrent( n->core, n->torrent_id );
-        if( tor == NULL )
+        tor = gtr_core_find_torrent (n->core, n->torrent_id);
+        if (tor == NULL)
             return;
 
-        g_variant_get( params, "(u&s)", NULL, &action );
-        if( strcmp( action, "folder" ) == 0 )
+        g_variant_get (params, " (u&s)", NULL, &action);
+        if (strcmp (action, "folder") == 0)
         {
-            gtr_core_open_folder( n->core, n->torrent_id );
+            gtr_core_open_folder (n->core, n->torrent_id);
         }
-        else if( strcmp( action, "file" ) == 0)
+        else if (strcmp (action, "file") == 0)
         {
-            const tr_info * inf = tr_torrentInfo( tor );
-            const char * dir = tr_torrentGetDownloadDir( tor );
-            char * path = g_build_filename( dir, inf->files[0].name, NULL );
-            gtr_open_file( path );
-            g_free( path );
+            const tr_info * inf = tr_torrentInfo (tor);
+            const char * dir = tr_torrentGetDownloadDir (tor);
+            char * path = g_build_filename (dir, inf->files[0].name, NULL);
+            gtr_open_file (path);
+            g_free (path);
         }
     }
 }
 
 static void
-dbus_proxy_ready_callback( GObject      * source UNUSED,
+dbus_proxy_ready_callback (GObject      * source UNUSED,
                            GAsyncResult * res,
-                           gpointer       user_data UNUSED )
+                           gpointer       user_data UNUSED)
 {
-    proxy = g_dbus_proxy_new_for_bus_finish( res, NULL );
-    if( proxy == NULL )
+    proxy = g_dbus_proxy_new_for_bus_finish (res, NULL);
+    if (proxy == NULL)
     {
-        g_warning( "Failed to create proxy for %s", NOTIFICATIONS_DBUS_NAME );
+        g_warning ("Failed to create proxy for %s", NOTIFICATIONS_DBUS_NAME);
         return;
     }
 
-    g_signal_connect( proxy, "g-signal",
-                      G_CALLBACK( g_signal_callback ), NULL );
-    g_dbus_proxy_call( proxy,
+    g_signal_connect (proxy, "g-signal",
+                      G_CALLBACK (g_signal_callback), NULL);
+    g_dbus_proxy_call (proxy,
                        "GetCapabilities",
-                       g_variant_new( "()" ),
+                       g_variant_new ("()"),
                        G_DBUS_CALL_FLAGS_NONE, -1, NULL,
-                       get_capabilities_callback, NULL );
+                       get_capabilities_callback, NULL);
 }
 
 void
-gtr_notify_init( void )
+gtr_notify_init (void)
 {
-    active_notifications = g_hash_table_new_full( g_int_hash, g_int_equal,
-                                                  NULL, tr_notification_free );
-    g_dbus_proxy_new_for_bus( G_BUS_TYPE_SESSION,
+    active_notifications = g_hash_table_new_full (g_int_hash, g_int_equal,
+                                                  NULL, tr_notification_free);
+    g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
                               G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
                               NULL,
                               NOTIFICATIONS_DBUS_NAME,
                               NOTIFICATIONS_DBUS_CORE_OBJECT,
                               NOTIFICATIONS_DBUS_CORE_INTERFACE,
-                              NULL, dbus_proxy_ready_callback, NULL );
+                              NULL, dbus_proxy_ready_callback, NULL);
 }
 
 static void
-notify_callback( GObject      * source,
+notify_callback (GObject      * source,
                  GAsyncResult * res,
-                 gpointer       user_data )
+                 gpointer       user_data)
 {
     TrNotification * n = user_data;
     GVariant * result;
 
-    result = g_dbus_proxy_call_finish( G_DBUS_PROXY( source ), res, NULL );
-    if( !result || !g_variant_is_of_type( result, G_VARIANT_TYPE( "(u)" ) ) )
+    result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source), res, NULL);
+    if (!result || !g_variant_is_of_type (result, G_VARIANT_TYPE (" (u)")))
     {
-        if( result )
-            g_variant_unref( result );
-        tr_notification_free( n );
+        if (result)
+            g_variant_unref (result);
+        tr_notification_free (n);
         return;
     }
 
-    g_variant_get( result, "(u)", &n->id );
-    g_hash_table_insert( active_notifications,
-                         GINT_TO_POINTER( ( int * )&n->id ), n );
+    g_variant_get (result, " (u)", &n->id);
+    g_hash_table_insert (active_notifications,
+                         GINT_TO_POINTER ((int *)&n->id), n);
 
-    g_variant_unref( result );
+    g_variant_unref (result);
 }
 
 void
-gtr_notify_torrent_completed( TrCore * core, int torrent_id )
+gtr_notify_torrent_completed (TrCore * core, int torrent_id)
 {
     GVariantBuilder actions_builder;
     TrNotification * n;
     tr_torrent * tor;
-    const char * cmd = gtr_pref_string_get( PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND );
+    const char * cmd = gtr_pref_string_get (PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND);
 
-    if( gtr_pref_flag_get( PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED ) )
-        g_spawn_command_line_async( cmd, NULL );
+    if (gtr_pref_flag_get (PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED))
+        g_spawn_command_line_async (cmd, NULL);
 
-    if( ! gtr_pref_flag_get( PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED ) )
+    if (! gtr_pref_flag_get (PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED))
         return;
 
-    g_return_if_fail( G_IS_DBUS_PROXY( proxy ) );
+    g_return_if_fail (G_IS_DBUS_PROXY (proxy));
 
-    tor = gtr_core_find_torrent( core, torrent_id );
+    tor = gtr_core_find_torrent (core, torrent_id);
 
-    n = g_new0( TrNotification, 1 );
-    n->core = g_object_ref( G_OBJECT( core ) );
+    n = g_new0 (TrNotification, 1);
+    n->core = g_object_ref (G_OBJECT (core));
     n->torrent_id = torrent_id;
 
-    g_variant_builder_init( &actions_builder, G_VARIANT_TYPE( "as" ) );
+    g_variant_builder_init (&actions_builder, G_VARIANT_TYPE ("as"));
 
-    if( server_supports_actions )
+    if (server_supports_actions)
     {
-        const tr_info * inf = tr_torrentInfo( tor );
-        if( inf->fileCount == 1 )
+        const tr_info * inf = tr_torrentInfo (tor);
+        if (inf->fileCount == 1)
         {
-            g_variant_builder_add( &actions_builder, "s", "file" );
-            g_variant_builder_add( &actions_builder, "s", _( "Open File" ) );
+            g_variant_builder_add (&actions_builder, "s", "file");
+            g_variant_builder_add (&actions_builder, "s", _("Open File"));
         }
         else
         {
-            g_variant_builder_add( &actions_builder, "s", "folder" );
-            g_variant_builder_add( &actions_builder, "s", _( "Open Folder" ) );
+            g_variant_builder_add (&actions_builder, "s", "folder");
+            g_variant_builder_add (&actions_builder, "s", _("Open Folder"));
         }
     }
 
-    g_dbus_proxy_call( proxy,
+    g_dbus_proxy_call (proxy,
                        "Notify",
-                       g_variant_new( "(susssasa{sv}i)",
+                       g_variant_new ("(susssasa{sv}i)",
                                       "Transmission", n->id, "transmission",
-                                      _( "Torrent Complete" ),
-                                      tr_torrentName( tor ),
-                                      &actions_builder, NULL, -1 ),
+                                      _("Torrent Complete"),
+                                      tr_torrentName (tor),
+                                      &actions_builder, NULL, -1),
                        G_DBUS_CALL_FLAGS_NONE, -1, NULL,
-                       notify_callback, n );
+                       notify_callback, n);
 }
 
 void
-gtr_notify_torrent_added( const char * name )
+gtr_notify_torrent_added (const char * name)
 {
     TrNotification * n;
 
-    g_return_if_fail( G_IS_DBUS_PROXY( proxy ) );
+    g_return_if_fail (G_IS_DBUS_PROXY (proxy));
 
-    if( !gtr_pref_flag_get( PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED ) )
+    if (!gtr_pref_flag_get (PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED))
         return;
 
-    n = g_new0( TrNotification, 1 );
-    g_dbus_proxy_call( proxy,
+    n = g_new0 (TrNotification, 1);
+    g_dbus_proxy_call (proxy,
                        "Notify",
-                       g_variant_new( "(susssasa{sv}i)",
+                       g_variant_new ("(susssasa{sv}i)",
                                       "Transmission", 0, "transmission",
-                                      _( "Torrent Added" ), name,
-                                      NULL, NULL, -1 ),
+                                      _("Torrent Added"), name,
+                                      NULL, NULL, -1),
                        G_DBUS_CALL_FLAGS_NONE, -1, NULL,
-                       notify_callback, n );
+                       notify_callback, n);
 }
diff --git a/gtk/notify.h b/gtk/notify.h
index c462a7b82..ef908c739 100644
--- a/gtk/notify.h
+++ b/gtk/notify.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -15,10 +15,10 @@
 
 #include "tr-core.h"
 
-void gtr_notify_init( void );
+void gtr_notify_init (void);
 
-void gtr_notify_torrent_added     ( const char * name );
+void gtr_notify_torrent_added   (const char * name);
 
-void gtr_notify_torrent_completed ( TrCore * core, int torrent_id );
+void gtr_notify_torrent_completed (TrCore * core, int torrent_id);
 
 #endif
diff --git a/gtk/open-dialog.c b/gtk/open-dialog.c
index 9c8816d57..0ce792734 100644
--- a/gtk/open-dialog.c
+++ b/gtk/open-dialog.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,14 +16,14 @@
 #include <string.h>
 
 #include <libtransmission/transmission.h>
-#include <libtransmission/utils.h> /* tr_is_same_file() */
+#include <libtransmission/utils.h> /* tr_is_same_file () */
 
 #include "conf.h"
 #include "file-list.h"
 #include "hig.h"
 #include "open-dialog.h"
 #include "tr-prefs.h"
-#include "util.h" /* gtr_priority_combo_get_value() */
+#include "util.h" /* gtr_priority_combo_get_value () */
 
 /****
 *****
@@ -32,55 +32,55 @@
 #define N_RECENT 4
 
 static GSList*
-get_recent_destinations( void )
+get_recent_destinations (void)
 {
     int i;
     GSList * list = NULL;
 
-    for( i=0; i<N_RECENT; ++i )
+    for (i=0; i<N_RECENT; ++i)
     {
         char key[64];
         const char * val;
-        g_snprintf( key, sizeof( key ), "recent-download-dir-%d", i+1 );
-        if(( val = gtr_pref_string_get( key )))
-            list = g_slist_append( list, (void*)val );
+        g_snprintf (key, sizeof (key), "recent-download-dir-%d", i+1);
+        if ((val = gtr_pref_string_get (key)))
+            list = g_slist_append (list, (void*)val);
     }
     return list;
 }
 
 static void
-save_recent_destination( TrCore * core, const char * dir  )
+save_recent_destination (TrCore * core, const char * dir)
 {
     int i;
     GSList * l;
-    GSList * list = get_recent_destinations( );
+    GSList * list = get_recent_destinations ();
 
-    if( dir == NULL )
+    if (dir == NULL)
         return;
 
     /* if it was already in the list, remove it */
-    if(( l = g_slist_find_custom( list, dir, (GCompareFunc)strcmp )))
-        list = g_slist_delete_link( list, l );
+    if ((l = g_slist_find_custom (list, dir, (GCompareFunc)strcmp)))
+        list = g_slist_delete_link (list, l);
 
     /* add it to the front of the list */
-    list = g_slist_prepend( list, (void*)dir );
+    list = g_slist_prepend (list, (void*)dir);
 
     /* make local copies of the strings that aren't
-     * invalidated by gtr_pref_string_set() */
-    for( l=list; l; l=l->next )
-        l->data = g_strdup( l->data );
+     * invalidated by gtr_pref_string_set () */
+    for (l=list; l; l=l->next)
+        l->data = g_strdup (l->data);
 
     /* save the first N_RECENT directories */
-    for( l=list, i=0; l && ( i<N_RECENT ); ++i, l=l->next ) {
+    for (l=list, i=0; l && (i<N_RECENT); ++i, l=l->next) {
         char key[64];
-        g_snprintf( key, sizeof( key ), "recent-download-dir-%d", i + 1 );
-        gtr_pref_string_set( key, l->data );
+        g_snprintf (key, sizeof (key), "recent-download-dir-%d", i + 1);
+        gtr_pref_string_set (key, l->data);
     }
-    gtr_pref_save( gtr_core_session( core ) );
+    gtr_pref_save (gtr_core_session (core));
 
     /* cleanup */
-    g_slist_foreach( list, (GFunc)g_free, NULL );
-    g_slist_free( list );
+    g_slist_foreach (list, (GFunc)g_free, NULL);
+    g_slist_free (list);
 }
 
 /****
@@ -101,69 +101,69 @@ struct OpenData
 };
 
 static void
-removeOldTorrent( struct OpenData * o )
+removeOldTorrent (struct OpenData * o)
 {
-    if( o->tor )
+    if (o->tor)
     {
-        gtr_file_list_clear( o->file_list );
-        tr_torrentRemove( o->tor, FALSE, NULL );
+        gtr_file_list_clear (o->file_list);
+        tr_torrentRemove (o->tor, FALSE, NULL);
         o->tor = NULL;
     }
 }
 
 static void
-addResponseCB( GtkDialog * dialog,
+addResponseCB (GtkDialog * dialog,
                gint        response,
-               gpointer    gdata )
+               gpointer    gdata)
 {
     struct OpenData * o = gdata;
 
-    if( o->tor )
+    if (o->tor)
     {
-        if( response != GTK_RESPONSE_ACCEPT )
+        if (response != GTK_RESPONSE_ACCEPT)
         {
-            removeOldTorrent( o );
+            removeOldTorrent (o);
         }
         else
         {
-            tr_torrentSetPriority( o->tor, gtr_priority_combo_get_value( GTK_COMBO_BOX( o->priority_combo ) ) );
+            tr_torrentSetPriority (o->tor, gtr_priority_combo_get_value (GTK_COMBO_BOX (o->priority_combo)));
 
-            if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( o->run_check ) ) )
-                tr_torrentStart( o->tor );
+            if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (o->run_check)))
+                tr_torrentStart (o->tor);
 
-            gtr_core_add_torrent( o->core, o->tor, FALSE );
+            gtr_core_add_torrent (o->core, o->tor, FALSE);
 
-            if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( o->trash_check ) ) )
-                gtr_file_trash_or_remove( o->filename );
+            if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (o->trash_check)))
+                gtr_file_trash_or_remove (o->filename);
 
-            save_recent_destination( o->core, o->downloadDir );
+            save_recent_destination (o->core, o->downloadDir);
         }
     }
 
-    tr_ctorFree( o->ctor );
-    g_free( o->filename );
-    g_free( o->downloadDir );
-    g_free( o );
-    gtk_widget_destroy( GTK_WIDGET( dialog ) );
+    tr_ctorFree (o->ctor);
+    g_free (o->filename);
+    g_free (o->downloadDir);
+    g_free (o);
+    gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 static void
-updateTorrent( struct OpenData * o )
+updateTorrent (struct OpenData * o)
 {
-    const gboolean isLocalFile = tr_ctorGetSourceFile( o->ctor ) != NULL;
-    gtk_widget_set_sensitive( o->trash_check, isLocalFile );
+    const gboolean isLocalFile = tr_ctorGetSourceFile (o->ctor) != NULL;
+    gtk_widget_set_sensitive (o->trash_check, isLocalFile);
 
-    if( !o->tor )
+    if (!o->tor)
     {
-        gtr_file_list_clear( o->file_list );
-        gtk_widget_set_sensitive( o->file_list, FALSE );
+        gtr_file_list_clear (o->file_list);
+        gtk_widget_set_sensitive (o->file_list, FALSE);
     }
     else
     {
-        tr_torrentSetDownloadDir( o->tor, o->downloadDir );
-        gtk_widget_set_sensitive( o->file_list, tr_torrentHasMetadata( o->tor ) );
-        gtr_file_list_set_torrent( o->file_list, tr_torrentId( o->tor ) );
-        tr_torrentVerify( o->tor );
+        tr_torrentSetDownloadDir (o->tor, o->downloadDir);
+        gtk_widget_set_sensitive (o->file_list, tr_torrentHasMetadata (o->tor));
+        gtr_file_list_set_torrent (o->file_list, tr_torrentId (o->tor));
+        tr_torrentVerify (o->tor);
     }
 }
 
@@ -175,76 +175,76 @@ updateTorrent( struct OpenData * o )
  * metadata when that happens.
  */
 static void
-sourceChanged( GtkFileChooserButton * b, gpointer gdata )
+sourceChanged (GtkFileChooserButton * b, gpointer gdata)
 {
     struct OpenData * o = gdata;
-    char * filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( b ) );
+    char * filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (b));
 
     /* maybe instantiate a torrent */
-    if( filename || !o->tor )
+    if (filename || !o->tor)
     {
         int err = 0;
         int new_file = 0;
         tr_torrent * torrent;
 
-        if( filename && ( !o->filename || !tr_is_same_file( filename, o->filename ) ) )
+        if (filename && (!o->filename || !tr_is_same_file (filename, o->filename)))
         {
-            g_free( o->filename );
-            o->filename = g_strdup( filename );
-            tr_ctorSetMetainfoFromFile( o->ctor, o->filename );
+            g_free (o->filename);
+            o->filename = g_strdup (filename);
+            tr_ctorSetMetainfoFromFile (o->ctor, o->filename);
             new_file = 1;
         }
 
-        tr_ctorSetDownloadDir( o->ctor, TR_FORCE, o->downloadDir );
-        tr_ctorSetPaused( o->ctor, TR_FORCE, TRUE );
-        tr_ctorSetDeleteSource( o->ctor, FALSE );
+        tr_ctorSetDownloadDir (o->ctor, TR_FORCE, o->downloadDir);
+        tr_ctorSetPaused (o->ctor, TR_FORCE, TRUE);
+        tr_ctorSetDeleteSource (o->ctor, FALSE);
 
-        if(( torrent = tr_torrentNew( o->ctor, &err ) ) )
+        if ((torrent = tr_torrentNew (o->ctor, &err)))
         {
-            removeOldTorrent( o );
+            removeOldTorrent (o);
             o->tor = torrent;
         }
-        else if( new_file )
+        else if (new_file)
         {
-            gtr_add_torrent_error_dialog( GTK_WIDGET( b ), err, o->filename );
+            gtr_add_torrent_error_dialog (GTK_WIDGET (b), err, o->filename);
         }
 
-        updateTorrent( o );
+        updateTorrent (o);
     }
 
-    g_free( filename );
+    g_free (filename);
 }
 
 static void
-downloadDirChanged( GtkFileChooserButton * b, gpointer gdata )
+downloadDirChanged (GtkFileChooserButton * b, gpointer gdata)
 {
     struct OpenData * data = gdata;
-    char * fname = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( b ) );
+    char * fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (b));
 
-    if( fname && ( !data->downloadDir || !tr_is_same_file( fname, data->downloadDir ) ) )
+    if (fname && (!data->downloadDir || !tr_is_same_file (fname, data->downloadDir)))
     {
-        g_free( data->downloadDir );
-        data->downloadDir = g_strdup( fname );
-        updateTorrent( data );
+        g_free (data->downloadDir);
+        data->downloadDir = g_strdup (fname);
+        updateTorrent (data);
     }
 
-    g_free( fname );
+    g_free (fname);
 }
 
 static void
-addTorrentFilters( GtkFileChooser * chooser )
+addTorrentFilters (GtkFileChooser * chooser)
 {
     GtkFileFilter * filter;
 
-    filter = gtk_file_filter_new( );
-    gtk_file_filter_set_name( filter, _( "Torrent files" ) );
-    gtk_file_filter_add_pattern( filter, "*.torrent" );
-    gtk_file_chooser_add_filter( chooser, filter );
+    filter = gtk_file_filter_new ();
+    gtk_file_filter_set_name (filter, _("Torrent files"));
+    gtk_file_filter_add_pattern (filter, "*.torrent");
+    gtk_file_chooser_add_filter (chooser, filter);
 
-    filter = gtk_file_filter_new( );
-    gtk_file_filter_set_name( filter, _( "All files" ) );
-    gtk_file_filter_add_pattern( filter, "*" );
-    gtk_file_chooser_add_filter( chooser, filter );
+    filter = gtk_file_filter_new ();
+    gtk_file_filter_set_name (filter, _("All files"));
+    gtk_file_filter_add_pattern (filter, "*");
+    gtk_file_chooser_add_filter (chooser, filter);
 }
 
 /****
@@ -252,7 +252,7 @@ addTorrentFilters( GtkFileChooser * chooser )
 ****/
 
 GtkWidget*
-gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor )
+gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor)
 {
     const char *     str;
     GtkWidget *      w;
@@ -267,121 +267,121 @@ gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * cto
     GSList *         walk;
 
     /* make the dialog */
-    d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent,
+    d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent,
                                      GTK_DIALOG_DESTROY_WITH_PARENT,
                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                     NULL );
-    gtk_dialog_set_default_response( GTK_DIALOG( d ),
-                                     GTK_RESPONSE_ACCEPT );
-    gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
+                                     NULL);
+    gtk_dialog_set_default_response (GTK_DIALOG (d),
+                                     GTK_RESPONSE_ACCEPT);
+    gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
                                              GTK_RESPONSE_ACCEPT,
                                              GTK_RESPONSE_CANCEL,
-                                             -1 );
+                                             -1);
 
-    if( tr_ctorGetDownloadDir( ctor, TR_FORCE, &str ) )
-        g_assert_not_reached( );
-    g_assert( str );
+    if (tr_ctorGetDownloadDir (ctor, TR_FORCE, &str))
+        g_assert_not_reached ();
+    g_assert (str);
 
-    data = g_new0( struct OpenData, 1 );
+    data = g_new0 (struct OpenData, 1);
     data->core = core;
     data->ctor = ctor;
-    data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) );
-    data->downloadDir = g_strdup( str );
-    data->file_list = gtr_file_list_new( core, 0 );
-    str = _( "Mo_ve .torrent file to the trash" );
-    data->trash_check = gtk_check_button_new_with_mnemonic( str );
-    str = _( "_Start when added" );
-    data->run_check = gtk_check_button_new_with_mnemonic( str );
+    data->filename = g_strdup (tr_ctorGetSourceFile (ctor));
+    data->downloadDir = g_strdup (str);
+    data->file_list = gtr_file_list_new (core, 0);
+    str = _("Mo_ve .torrent file to the trash");
+    data->trash_check = gtk_check_button_new_with_mnemonic (str);
+    str = _("_Start when added");
+    data->run_check = gtk_check_button_new_with_mnemonic (str);
 
-    w = data->priority_combo = gtr_priority_combo_new( );
-    gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL );
+    w = data->priority_combo = gtr_priority_combo_new ();
+    gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL);
 
-    g_signal_connect( G_OBJECT( d ), "response",
-                      G_CALLBACK( addResponseCB ), data );
+    g_signal_connect (G_OBJECT (d), "response",
+                      G_CALLBACK (addResponseCB), data);
 
     row = 0;
-    grid = GTK_GRID( gtk_grid_new( ) );
-    gtk_container_set_border_width( GTK_CONTAINER( grid ), GUI_PAD_BIG );
-    gtk_grid_set_row_spacing( grid, GUI_PAD );
-    gtk_grid_set_column_spacing( grid, GUI_PAD_BIG );
+    grid = GTK_GRID (gtk_grid_new ());
+    gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG);
+    gtk_grid_set_row_spacing (grid, GUI_PAD);
+    gtk_grid_set_column_spacing (grid, GUI_PAD_BIG);
 
     // "torrent file" row
-    l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) );
-    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
-    gtk_grid_attach( grid, l, 0, row, 1, 1 );
-    w = gtk_file_chooser_button_new( _( "Select Source File" ),
-                                     GTK_FILE_CHOOSER_ACTION_OPEN );
+    l = gtk_label_new_with_mnemonic (_("_Torrent file:"));
+    gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
+    gtk_grid_attach (grid, l, 0, row, 1, 1);
+    w = gtk_file_chooser_button_new (_("Select Source File"),
+                                     GTK_FILE_CHOOSER_ACTION_OPEN);
     source_chooser = w;
-    gtk_widget_set_hexpand( w, TRUE );
-    gtk_grid_attach_next_to( grid, w, l, GTK_POS_RIGHT, 1, 1 );
-    gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
-    addTorrentFilters( GTK_FILE_CHOOSER( w ) );
-    g_signal_connect( w, "selection-changed",
-                      G_CALLBACK( sourceChanged ), data );
+    gtk_widget_set_hexpand (w, TRUE);
+    gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
+    gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
+    addTorrentFilters (GTK_FILE_CHOOSER (w));
+    g_signal_connect (w, "selection-changed",
+                      G_CALLBACK (sourceChanged), data);
 
     // "destination folder" row
     row++;
-    l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) );
-    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
-    gtk_grid_attach( grid, l, 0, row, 1, 1 );
-    w = gtk_file_chooser_button_new( _( "Select Destination Folder" ),
-                                     GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
-    if( !gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ),
-                                              data->downloadDir ) )
-        g_warning( "couldn't select '%s'", data->downloadDir );
-    list = get_recent_destinations( );
-    for( walk = list; walk; walk = walk->next )
-        gtk_file_chooser_add_shortcut_folder( GTK_FILE_CHOOSER( w ), walk->data, NULL );
-    g_slist_free( list );
-    gtk_grid_attach_next_to( grid, w, l, GTK_POS_RIGHT, 1, 1 );
-    gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
-    g_signal_connect( w, "selection-changed",
-                      G_CALLBACK( downloadDirChanged ), data );
+    l = gtk_label_new_with_mnemonic (_("_Destination folder:"));
+    gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
+    gtk_grid_attach (grid, l, 0, row, 1, 1);
+    w = gtk_file_chooser_button_new (_("Select Destination Folder"),
+                                     GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
+    if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w),
+                                              data->downloadDir))
+        g_warning ("couldn't select '%s'", data->downloadDir);
+    list = get_recent_destinations ();
+    for (walk = list; walk; walk = walk->next)
+        gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL);
+    g_slist_free (list);
+    gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
+    gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
+    g_signal_connect (w, "selection-changed",
+                      G_CALLBACK (downloadDirChanged), data);
 
     // file list row
     row++;
     w = data->file_list;
-    gtk_widget_set_vexpand( w, TRUE );
-    gtk_widget_set_size_request ( w, 466u, 300u );
-    gtk_grid_attach( grid, w, 0, row, 2, 1 );
+    gtk_widget_set_vexpand (w, TRUE);
+    gtk_widget_set_size_request (w, 466u, 300u);
+    gtk_grid_attach (grid, w, 0, row, 2, 1);
 
     // torrent priority row
     row++;
-    l = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) );
-    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
-    gtk_grid_attach( grid, l, 0, row, 1, 1 );
+    l = gtk_label_new_with_mnemonic (_("Torrent _priority:"));
+    gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
+    gtk_grid_attach (grid, l, 0, row, 1, 1);
     w = data->priority_combo;
-    gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w );
-    gtk_grid_attach_next_to( grid, w, l, GTK_POS_RIGHT, 1, 1 );
+    gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
+    gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
 
     // torrent priority row
     row++;
     w = data->run_check;
-    if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) )
-        g_assert_not_reached( );
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag );
-    gtk_grid_attach( grid, w, 0, row, 2, 1 );
+    if (tr_ctorGetPaused (ctor, TR_FORCE, &flag))
+        g_assert_not_reached ();
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !flag);
+    gtk_grid_attach (grid, w, 0, row, 2, 1);
 
     // "trash .torrent file" row
     row++;
     w = data->trash_check;
-    if( tr_ctorGetDeleteSource( ctor, &flag ) )
-        g_assert_not_reached( );
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag );
-    gtk_grid_attach( grid, w, 0, row, 2, 1 );
+    if (tr_ctorGetDeleteSource (ctor, &flag))
+        g_assert_not_reached ();
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag);
+    gtk_grid_attach (grid, w, 0, row, 2, 1);
 
     /* trigger sourceChanged, either directly or indirectly,
      * so that it creates the tor/gtor objects */
     w = source_chooser;
-    if( data->filename )
-        gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename );
+    if (data->filename)
+        gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), data->filename);
     else
-        sourceChanged( GTK_FILE_CHOOSER_BUTTON( w ), data );
+        sourceChanged (GTK_FILE_CHOOSER_BUTTON (w), data);
 
-    gtr_dialog_set_content( GTK_DIALOG( d ), GTK_WIDGET( grid ) );
-    w = gtk_dialog_get_widget_for_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT );
-    gtk_widget_grab_focus( w );
+    gtr_dialog_set_content (GTK_DIALOG (d), GTK_WIDGET (grid));
+    w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT);
+    gtk_widget_grab_focus (w);
     return d;
 }
 
@@ -390,61 +390,61 @@ gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * cto
 ****/
 
 static void
-onOpenDialogResponse( GtkDialog * dialog, int response, gpointer core )
+onOpenDialogResponse (GtkDialog * dialog, int response, gpointer core)
 {
     char * folder;
 
     /* remember this folder the next time we use this dialog */
-    folder = gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER( dialog ) );
-    gtr_pref_string_set( PREF_KEY_OPEN_DIALOG_FOLDER, folder );
-    g_free( folder );
+    folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
+    gtr_pref_string_set (PREF_KEY_OPEN_DIALOG_FOLDER, folder);
+    g_free (folder);
 
-    if( response == GTK_RESPONSE_ACCEPT )
+    if (response == GTK_RESPONSE_ACCEPT)
     {
-        GtkFileChooser  * chooser = GTK_FILE_CHOOSER( dialog );
-        GtkWidget       * w = gtk_file_chooser_get_extra_widget( chooser );
-        GtkToggleButton * tb = GTK_TOGGLE_BUTTON( w );
-        const gboolean    do_start = gtr_pref_flag_get( TR_PREFS_KEY_START );
-        const gboolean    do_prompt = gtk_toggle_button_get_active( tb );
+        GtkFileChooser  * chooser = GTK_FILE_CHOOSER (dialog);
+        GtkWidget       * w = gtk_file_chooser_get_extra_widget (chooser);
+        GtkToggleButton * tb = GTK_TOGGLE_BUTTON (w);
+        const gboolean    do_start = gtr_pref_flag_get (TR_PREFS_KEY_START);
+        const gboolean    do_prompt = gtk_toggle_button_get_active (tb);
         const gboolean    do_notify = FALSE;
-        GSList * files = gtk_file_chooser_get_files( chooser );
+        GSList * files = gtk_file_chooser_get_files (chooser);
 
-        gtr_core_add_files( core, files, do_start, do_prompt, do_notify );
-        g_slist_foreach( files, (GFunc)g_object_unref, NULL );
-        g_slist_free( files );
+        gtr_core_add_files (core, files, do_start, do_prompt, do_notify);
+        g_slist_foreach (files, (GFunc)g_object_unref, NULL);
+        g_slist_free (files);
     }
 
-    gtk_widget_destroy( GTK_WIDGET( dialog ) );
+    gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 GtkWidget*
-gtr_torrent_open_from_file_dialog_new( GtkWindow * parent, TrCore * core )
+gtr_torrent_open_from_file_dialog_new (GtkWindow * parent, TrCore * core)
 {
     GtkWidget *  w;
     GtkWidget *  c;
     const char * folder;
 
-    w = gtk_file_chooser_dialog_new( _( "Open a Torrent" ), parent,
+    w = gtk_file_chooser_dialog_new (_("Open a Torrent"), parent,
                                      GTK_FILE_CHOOSER_ACTION_OPEN,
                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                     NULL );
-    gtk_dialog_set_alternative_button_order( GTK_DIALOG( w ),
+                                     NULL);
+    gtk_dialog_set_alternative_button_order (GTK_DIALOG (w),
                                              GTK_RESPONSE_ACCEPT,
                                              GTK_RESPONSE_CANCEL,
-                                             -1 );
-    gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER( w ), TRUE );
-    addTorrentFilters( GTK_FILE_CHOOSER( w ) );
-    g_signal_connect( w, "response", G_CALLBACK( onOpenDialogResponse ), core );
+                                             -1);
+    gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (w), TRUE);
+    addTorrentFilters (GTK_FILE_CHOOSER (w));
+    g_signal_connect (w, "response", G_CALLBACK (onOpenDialogResponse), core);
 
-    if( ( folder = gtr_pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ) ) )
-        gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), folder );
+    if ((folder = gtr_pref_string_get (PREF_KEY_OPEN_DIALOG_FOLDER)))
+        gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), folder);
 
-    c = gtk_check_button_new_with_mnemonic( _( "Show _options dialog" ) );
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( c ),
-                                 gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) );
-    gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER( w ), c );
-    gtk_widget_show( c );
+    c = gtk_check_button_new_with_mnemonic (_("Show _options dialog"));
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c),
+                                 gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT));
+    gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (w), c);
+    gtk_widget_show (c);
 
     return w;
 }
@@ -454,66 +454,66 @@ gtr_torrent_open_from_file_dialog_new( GtkWindow * parent, TrCore * core )
 ***/
 
 static void
-onOpenURLResponse( GtkDialog * dialog, int response, gpointer user_data )
+onOpenURLResponse (GtkDialog * dialog, int response, gpointer user_data)
 {
     bool handled = false;
 
-    if( response == GTK_RESPONSE_ACCEPT )
+    if (response == GTK_RESPONSE_ACCEPT)
     {
-        GtkWidget * e = GTK_WIDGET( g_object_get_data( G_OBJECT( dialog ), "url-entry" ) );
-        char * url = g_strdup( gtk_entry_get_text( GTK_ENTRY( e ) ) );
-        g_strstrip( url );
-
-        if( url ) {
-            handled = gtr_core_add_from_url( user_data, url );
-            if( !handled )
-                gtr_unrecognized_url_dialog( GTK_WIDGET( dialog ), url );
-            g_free( url );
+        GtkWidget * e = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog), "url-entry"));
+        char * url = g_strdup (gtk_entry_get_text (GTK_ENTRY (e)));
+        g_strstrip (url);
+
+        if (url) {
+            handled = gtr_core_add_from_url (user_data, url);
+            if (!handled)
+                gtr_unrecognized_url_dialog (GTK_WIDGET (dialog), url);
+            g_free (url);
         }
     }
-    else if( response == GTK_RESPONSE_CANCEL )
+    else if (response == GTK_RESPONSE_CANCEL)
     {
         handled = TRUE;
     }
 
-    if( handled )
-        gtk_widget_destroy( GTK_WIDGET( dialog ) );
+    if (handled)
+        gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 GtkWidget*
-gtr_torrent_open_from_url_dialog_new( GtkWindow * parent, TrCore * core )
+gtr_torrent_open_from_url_dialog_new (GtkWindow * parent, TrCore * core)
 {
     guint row;
     GtkWidget * e;
     GtkWidget * t;
     GtkWidget * w;
 
-    w = gtk_dialog_new_with_buttons( _( "Open URL" ), parent,
+    w = gtk_dialog_new_with_buttons (_("Open URL"), parent,
                                      GTK_DIALOG_DESTROY_WITH_PARENT,
                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                     NULL );
-    gtk_dialog_set_alternative_button_order( GTK_DIALOG( w ),
+                                     NULL);
+    gtk_dialog_set_alternative_button_order (GTK_DIALOG (w),
                                              GTK_RESPONSE_ACCEPT,
                                              GTK_RESPONSE_CANCEL,
-                                             -1 );
-    g_signal_connect( w, "response", G_CALLBACK( onOpenURLResponse ), core );
+                                             -1);
+    g_signal_connect (w, "response", G_CALLBACK (onOpenURLResponse), core);
 
     row = 0;
-    t = hig_workarea_create( );
-    hig_workarea_add_section_title( t, &row, _( "Open torrent from URL" ) );
-    e = gtk_entry_new( );
-    gtk_widget_set_size_request( e, 400, -1 );
-    gtr_paste_clipboard_url_into_entry( e );
-    g_object_set_data( G_OBJECT( w ), "url-entry", e );
-    hig_workarea_add_row( t, &row, _( "_URL" ), e, NULL );
-
-    gtr_dialog_set_content( GTK_DIALOG( w ), t );
-
-    if( gtk_entry_get_text_length( GTK_ENTRY( e ) ) == 0 )
-        gtk_widget_grab_focus( e );
+    t = hig_workarea_create ();
+    hig_workarea_add_section_title (t, &row, _("Open torrent from URL"));
+    e = gtk_entry_new ();
+    gtk_widget_set_size_request (e, 400, -1);
+    gtr_paste_clipboard_url_into_entry (e);
+    g_object_set_data (G_OBJECT (w), "url-entry", e);
+    hig_workarea_add_row (t, &row, _("_URL"), e, NULL);
+
+    gtr_dialog_set_content (GTK_DIALOG (w), t);
+
+    if (gtk_entry_get_text_length (GTK_ENTRY (e)) == 0)
+        gtk_widget_grab_focus (e);
     else
-        gtk_widget_grab_focus( gtk_dialog_get_widget_for_response( GTK_DIALOG( w ), GTK_RESPONSE_ACCEPT ) );
+        gtk_widget_grab_focus (gtk_dialog_get_widget_for_response (GTK_DIALOG (w), GTK_RESPONSE_ACCEPT));
 
     return w;
 }
diff --git a/gtk/open-dialog.h b/gtk/open-dialog.h
index b582740a0..bf760542e 100644
--- a/gtk/open-dialog.h
+++ b/gtk/open-dialog.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,10 +16,10 @@
 #include <gtk/gtk.h>
 #include "tr-core.h"
 
-GtkWidget* gtr_torrent_open_from_url_dialog_new ( GtkWindow * parent, TrCore * core );
-GtkWidget* gtr_torrent_open_from_file_dialog_new( GtkWindow * parent, TrCore * core );
+GtkWidget* gtr_torrent_open_from_url_dialog_new (GtkWindow * parent, TrCore * core);
+GtkWidget* gtr_torrent_open_from_file_dialog_new (GtkWindow * parent, TrCore * core);
 
 /* This dialog assumes ownership of the ctor */
-GtkWidget* gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor );
+GtkWidget* gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor);
 
 #endif /* GTR_ADD_DIALOG */
diff --git a/gtk/relocate.c b/gtk/relocate.c
index f86f2cd77..f36029e7c 100644
--- a/gtk/relocate.c
+++ b/gtk/relocate.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -35,11 +35,11 @@ struct relocate_dialog_data
 };
 
 static void
-data_free( gpointer gdata )
+data_free (gpointer gdata)
 {
     struct relocate_dialog_data * data = gdata;
-    g_slist_free( data->torrent_ids );
-    g_free( data );
+    g_slist_free (data->torrent_ids);
+    g_free (data);
 }
 
 /***
@@ -47,54 +47,54 @@ data_free( gpointer gdata )
 ***/
 
 static void
-startMovingNextTorrent( struct relocate_dialog_data * data )
+startMovingNextTorrent (struct relocate_dialog_data * data)
 {
     char * str;
-    const int id = GPOINTER_TO_INT( data->torrent_ids->data );
+    const int id = GPOINTER_TO_INT (data->torrent_ids->data);
 
-    tr_torrent * tor = gtr_core_find_torrent( data->core, id );
-    if( tor != NULL )
-        tr_torrentSetLocation( tor, previousLocation, data->do_move, NULL, &data->done );
+    tr_torrent * tor = gtr_core_find_torrent (data->core, id);
+    if (tor != NULL)
+        tr_torrentSetLocation (tor, previousLocation, data->do_move, NULL, &data->done);
 
-    data->torrent_ids = g_slist_delete_link( data->torrent_ids,
-                                             data->torrent_ids );
+    data->torrent_ids = g_slist_delete_link (data->torrent_ids,
+                                             data->torrent_ids);
 
-    str = g_strdup_printf( _( "Moving \"%s\"" ), tr_torrentName( tor ) );
-    gtk_message_dialog_set_markup( GTK_MESSAGE_DIALOG( data->message_dialog ), str );
-    g_free( str );
+    str = g_strdup_printf (_("Moving \"%s\""), tr_torrentName (tor));
+    gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (data->message_dialog), str);
+    g_free (str);
 }
 
 /* every once in awhile, check to see if the move is done.
  * if so, delete the dialog */
 static gboolean
-onTimer( gpointer gdata )
+onTimer (gpointer gdata)
 {
     struct relocate_dialog_data * data = gdata;
     const int done = data->done;
 
-    if( done == TR_LOC_ERROR )
+    if (done == TR_LOC_ERROR)
     {
         const int flags = GTK_DIALOG_MODAL
                         | GTK_DIALOG_DESTROY_WITH_PARENT;
-        GtkWidget * w = gtk_message_dialog_new( GTK_WINDOW( data->message_dialog ),
+        GtkWidget * w = gtk_message_dialog_new (GTK_WINDOW (data->message_dialog),
                                                 flags,
                                                 GTK_MESSAGE_ERROR,
                                                 GTK_BUTTONS_CLOSE,
                                                 "%s",
-                                                _( "Couldn't move torrent" ) );
-        gtk_dialog_run( GTK_DIALOG( w ) );
-        gtk_widget_destroy( GTK_WIDGET( data->message_dialog ) );
+                                                _("Couldn't move torrent"));
+        gtk_dialog_run (GTK_DIALOG (w));
+        gtk_widget_destroy (GTK_WIDGET (data->message_dialog));
         return FALSE;
     }
-    else if( done == TR_LOC_DONE )
+    else if (done == TR_LOC_DONE)
     {
-        if( data->torrent_ids != NULL )
+        if (data->torrent_ids != NULL)
         {
-            startMovingNextTorrent( data );
+            startMovingNextTorrent (data);
         }
         else
         {
-            gtk_widget_destroy( GTK_WIDGET( data->chooser_dialog ) );
+            gtk_widget_destroy (GTK_WIDGET (data->chooser_dialog));
             return FALSE;
         }
     }
@@ -103,49 +103,49 @@ onTimer( gpointer gdata )
 }
 
 static void
-onResponse( GtkDialog * dialog, int response, gpointer unused UNUSED )
+onResponse (GtkDialog * dialog, int response, gpointer unused UNUSED)
 {
-    if( response == GTK_RESPONSE_APPLY )
+    if (response == GTK_RESPONSE_APPLY)
     {
         GtkWidget * w;
-        GObject * d = G_OBJECT( dialog );
-        struct relocate_dialog_data * data = g_object_get_data( d, DATA_KEY );
-        GtkFileChooser * chooser = g_object_get_data( d, "chooser" );
-        GtkToggleButton * move_tb = g_object_get_data( d, "move_rb" );
-        char * location = gtk_file_chooser_get_filename( chooser );
+        GObject * d = G_OBJECT (dialog);
+        struct relocate_dialog_data * data = g_object_get_data (d, DATA_KEY);
+        GtkFileChooser * chooser = g_object_get_data (d, "chooser");
+        GtkToggleButton * move_tb = g_object_get_data (d, "move_rb");
+        char * location = gtk_file_chooser_get_filename (chooser);
 
-        data->do_move = gtk_toggle_button_get_active( move_tb );
+        data->do_move = gtk_toggle_button_get_active (move_tb);
 
         /* pop up a dialog saying that the work is in progress */
-        w = gtk_message_dialog_new( GTK_WINDOW( dialog ),
+        w = gtk_message_dialog_new (GTK_WINDOW (dialog),
                                     GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
                                     GTK_MESSAGE_INFO,
                                     GTK_BUTTONS_CLOSE,
-                                    NULL );
-        gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ), _( "This may take a moment…" ) );
-        gtk_dialog_set_response_sensitive( GTK_DIALOG( w ), GTK_RESPONSE_CLOSE, FALSE );
-        gtk_widget_show( w );
+                                    NULL);
+        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w), _("This may take a moment…"));
+        gtk_dialog_set_response_sensitive (GTK_DIALOG (w), GTK_RESPONSE_CLOSE, FALSE);
+        gtk_widget_show (w);
 
         /* remember this location so that it can be the default next time */
-        g_free( previousLocation );
+        g_free (previousLocation);
         previousLocation = location;
 
         /* start the move and periodically check its status */
         data->message_dialog = w;
         data->done = TR_LOC_DONE;
-        onTimer( data );
-        gdk_threads_add_timeout_seconds( 1, onTimer, data );
+        onTimer (data);
+        gdk_threads_add_timeout_seconds (1, onTimer, data);
     }
     else
     {
-        gtk_widget_destroy( GTK_WIDGET( dialog ) );
+        gtk_widget_destroy (GTK_WIDGET (dialog));
     }
 }
 
 GtkWidget*
-gtr_relocate_dialog_new( GtkWindow * parent,
+gtr_relocate_dialog_new (GtkWindow * parent,
                          TrCore    * core,
-                         GSList    * torrent_ids )
+                         GSList    * torrent_ids)
 {
     guint row;
     GtkWidget * w;
@@ -153,42 +153,42 @@ gtr_relocate_dialog_new( GtkWindow * parent,
     GtkWidget * t;
     struct relocate_dialog_data * data;
 
-    d = gtk_dialog_new_with_buttons( _( "Set Torrent Location" ), parent,
+    d = gtk_dialog_new_with_buttons (_("Set Torrent Location"), parent,
                                      GTK_DIALOG_DESTROY_WITH_PARENT |
                                      GTK_DIALOG_MODAL,
                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                      GTK_STOCK_APPLY, GTK_RESPONSE_APPLY,
-                                     NULL );
-    gtk_dialog_set_default_response( GTK_DIALOG( d ),
-                                     GTK_RESPONSE_CANCEL );
-    gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
+                                     NULL);
+    gtk_dialog_set_default_response (GTK_DIALOG (d),
+                                     GTK_RESPONSE_CANCEL);
+    gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
                                              GTK_RESPONSE_APPLY,
                                              GTK_RESPONSE_CANCEL,
-                                             -1 );
-    g_signal_connect( d, "response", G_CALLBACK( onResponse ), NULL );
+                                             -1);
+    g_signal_connect (d, "response", G_CALLBACK (onResponse), NULL);
 
     row = 0;
-    t = hig_workarea_create( );
-    hig_workarea_add_section_title( t, &row, _( "Location" ) );
-
-    if( previousLocation == NULL )
-        previousLocation = g_strdup( gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR ) );
-    w = gtk_file_chooser_button_new( _( "Set Torrent Location" ), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
-    gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), previousLocation );
-    g_object_set_data( G_OBJECT( d ), "chooser", w );
-    hig_workarea_add_row( t, &row, _( "Torrent _location:" ), w, NULL );
-    w = gtk_radio_button_new_with_mnemonic( NULL, _( "_Move from the current folder" ) );
-    g_object_set_data( G_OBJECT( d ), "move_rb", w );
-    hig_workarea_add_wide_control( t, &row, w );
-    w = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON( w ), _( "Local data is _already there" ) );
-    hig_workarea_add_wide_control( t, &row, w );
-    gtr_dialog_set_content( GTK_DIALOG( d ), t );
-
-    data = g_new0( struct relocate_dialog_data, 1 );
+    t = hig_workarea_create ();
+    hig_workarea_add_section_title (t, &row, _("Location"));
+
+    if (previousLocation == NULL)
+        previousLocation = g_strdup (gtr_pref_string_get (TR_PREFS_KEY_DOWNLOAD_DIR));
+    w = gtk_file_chooser_button_new (_("Set Torrent Location"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
+    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), previousLocation);
+    g_object_set_data (G_OBJECT (d), "chooser", w);
+    hig_workarea_add_row (t, &row, _("Torrent _location:"), w, NULL);
+    w = gtk_radio_button_new_with_mnemonic (NULL, _("_Move from the current folder"));
+    g_object_set_data (G_OBJECT (d), "move_rb", w);
+    hig_workarea_add_wide_control (t, &row, w);
+    w = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (w), _("Local data is _already there"));
+    hig_workarea_add_wide_control (t, &row, w);
+    gtr_dialog_set_content (GTK_DIALOG (d), t);
+
+    data = g_new0 (struct relocate_dialog_data, 1);
     data->core = core;
     data->torrent_ids = torrent_ids;
     data->chooser_dialog = d;
-    g_object_set_data_full( G_OBJECT( d ), DATA_KEY, data, data_free );
+    g_object_set_data_full (G_OBJECT (d), DATA_KEY, data, data_free);
 
     return d;
 }
diff --git a/gtk/relocate.h b/gtk/relocate.h
index 145718f8e..cdca6ffcc 100644
--- a/gtk/relocate.h
+++ b/gtk/relocate.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,8 +16,8 @@
 #include <gtk/gtk.h>
 #include "tr-core.h"
 
-GtkWidget * gtr_relocate_dialog_new( GtkWindow * parent,
+GtkWidget * gtr_relocate_dialog_new (GtkWindow * parent,
                                      TrCore    * core,
-                                     GSList    * torrentIds );
+                                     GSList    * torrentIds);
 
 #endif
diff --git a/gtk/stats.c b/gtk/stats.c
index 74d103d84..bb636e5d3 100644
--- a/gtk/stats.c
+++ b/gtk/stats.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -38,150 +38,150 @@ struct stat_ui
 };
 
 static void
-setLabel( GtkWidget *  w, const char * str )
+setLabel (GtkWidget *  w, const char * str)
 {
-    gtr_label_set_text( GTK_LABEL( w ), str );
+    gtr_label_set_text (GTK_LABEL (w), str);
 }
 
 static void
-setLabelFromRatio( GtkWidget * w, double d )
+setLabelFromRatio (GtkWidget * w, double d)
 {
     char buf[128];
 
-    tr_strlratio( buf, d, sizeof( buf ) );
-    setLabel( w, buf );
+    tr_strlratio (buf, d, sizeof (buf));
+    setLabel (w, buf);
 }
 
 static gboolean
-updateStats( gpointer gdata )
+updateStats (gpointer gdata)
 {
     char buf[128];
     const char * fmt;
     tr_session_stats one, all;
-    const size_t buflen = sizeof( buf );
+    const size_t buflen = sizeof (buf);
     struct stat_ui * ui = gdata;
 
-    tr_sessionGetStats( gtr_core_session( ui->core ), &one );
-    tr_sessionGetCumulativeStats( gtr_core_session( ui->core ), &all );
+    tr_sessionGetStats (gtr_core_session (ui->core), &one);
+    tr_sessionGetCumulativeStats (gtr_core_session (ui->core), &all);
 
-    setLabel( ui->one_up_lb, tr_strlsize( buf, one.uploadedBytes, buflen ) );
-    setLabel( ui->one_down_lb, tr_strlsize( buf, one.downloadedBytes, buflen ) );
-    setLabel( ui->one_time_lb, tr_strltime( buf, one.secondsActive, buflen ) );
-    setLabelFromRatio( ui->one_ratio_lb, one.ratio );
+    setLabel (ui->one_up_lb, tr_strlsize (buf, one.uploadedBytes, buflen));
+    setLabel (ui->one_down_lb, tr_strlsize (buf, one.downloadedBytes, buflen));
+    setLabel (ui->one_time_lb, tr_strltime (buf, one.secondsActive, buflen));
+    setLabelFromRatio (ui->one_ratio_lb, one.ratio);
 
-    fmt = ngettext( "Started %'d time", "Started %'d times",
-                     (int)all.sessionCount );
-    g_snprintf( buf, buflen, fmt, (int)all.sessionCount );
-    setLabel( ui->all_sessions_lb, buf );
-    setLabel( ui->all_up_lb, tr_strlsize( buf, all.uploadedBytes, buflen ) );
-    setLabel( ui->all_down_lb, tr_strlsize( buf, all.downloadedBytes, buflen ) );
-    setLabel( ui->all_time_lb, tr_strltime( buf, all.secondsActive, buflen ) );
-    setLabelFromRatio( ui->all_ratio_lb, all.ratio );
+    fmt = ngettext ("Started %'d time", "Started %'d times",
+                   (int)all.sessionCount);
+    g_snprintf (buf, buflen, fmt, (int)all.sessionCount);
+    setLabel (ui->all_sessions_lb, buf);
+    setLabel (ui->all_up_lb, tr_strlsize (buf, all.uploadedBytes, buflen));
+    setLabel (ui->all_down_lb, tr_strlsize (buf, all.downloadedBytes, buflen));
+    setLabel (ui->all_time_lb, tr_strltime (buf, all.secondsActive, buflen));
+    setLabelFromRatio (ui->all_ratio_lb, all.ratio);
 
     return TRUE;
 }
 
 static void
-dialogDestroyed( gpointer p, GObject * dialog UNUSED )
+dialogDestroyed (gpointer p, GObject * dialog UNUSED)
 {
-    g_source_remove( GPOINTER_TO_UINT( p ) );
+    g_source_remove (GPOINTER_TO_UINT (p));
 }
 
 static void
-dialogResponse( GtkDialog * dialog, gint response, gpointer gdata )
+dialogResponse (GtkDialog * dialog, gint response, gpointer gdata)
 {
     struct stat_ui * ui = gdata;
 
-    if( response == TR_RESPONSE_RESET )
+    if (response == TR_RESPONSE_RESET)
     {
-        const char * primary = _( "Reset your statistics?" );
-        const char * secondary = _( "These statistics are for your information only. "
-                                    "Resetting them doesn't affect the statistics logged by your BitTorrent trackers." );
+        const char * primary = _("Reset your statistics?");
+        const char * secondary = _("These statistics are for your information only. "
+                                    "Resetting them doesn't affect the statistics logged by your BitTorrent trackers.");
         const int flags = GTK_DIALOG_DESTROY_WITH_PARENT
                         | GTK_DIALOG_MODAL;
-        GtkWidget * w = gtk_message_dialog_new( GTK_WINDOW( dialog ),
+        GtkWidget * w = gtk_message_dialog_new (GTK_WINDOW (dialog),
                                                 flags,
                                                 GTK_MESSAGE_QUESTION,
                                                 GTK_BUTTONS_NONE,
-                                                "%s", primary );
-        gtk_dialog_add_buttons( GTK_DIALOG( w ),
+                                                "%s", primary);
+        gtk_dialog_add_buttons (GTK_DIALOG (w),
                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                _( "_Reset" ), TR_RESPONSE_RESET,
-                                NULL );
-        gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ), "%s", secondary );
-        if( gtk_dialog_run( GTK_DIALOG( w ) ) == TR_RESPONSE_RESET )
+                                _("_Reset"), TR_RESPONSE_RESET,
+                                NULL);
+        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w), "%s", secondary);
+        if (gtk_dialog_run (GTK_DIALOG (w)) == TR_RESPONSE_RESET)
         {
-            tr_sessionClearStats( gtr_core_session( ui->core ) );
-            updateStats( ui );
+            tr_sessionClearStats (gtr_core_session (ui->core));
+            updateStats (ui);
         }
-        gtk_widget_destroy( w );
+        gtk_widget_destroy (w);
     }
 
-    if( response == GTK_RESPONSE_CLOSE )
-        gtk_widget_destroy( GTK_WIDGET( dialog ) );
+    if (response == GTK_RESPONSE_CLOSE)
+        gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 GtkWidget*
-gtr_stats_dialog_new( GtkWindow * parent, TrCore * core )
+gtr_stats_dialog_new (GtkWindow * parent, TrCore * core)
 {
     guint i;
     GtkWidget * d;
     GtkWidget * t;
     GtkWidget * l;
     guint row = 0;
-    struct stat_ui * ui = g_new0( struct stat_ui, 1 );
+    struct stat_ui * ui = g_new0 (struct stat_ui, 1);
 
-    d = gtk_dialog_new_with_buttons( _( "Statistics" ),
+    d = gtk_dialog_new_with_buttons (_("Statistics"),
                                      parent,
                                      GTK_DIALOG_DESTROY_WITH_PARENT,
-                                     _( "_Reset" ), TR_RESPONSE_RESET,
+                                     _("_Reset"), TR_RESPONSE_RESET,
                                      GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
-                                     NULL );
-    gtk_dialog_set_default_response( GTK_DIALOG( d ),
-                                     GTK_RESPONSE_CLOSE );
-    gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ),
+                                     NULL);
+    gtk_dialog_set_default_response (GTK_DIALOG (d),
+                                     GTK_RESPONSE_CLOSE);
+    gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
                                              GTK_RESPONSE_CLOSE,
                                              TR_RESPONSE_RESET,
-                                             -1 );
-    t = hig_workarea_create( );
+                                             -1);
+    t = hig_workarea_create ();
     ui->core = core;
 
-    hig_workarea_add_section_title( t, &row, _( "Current Session" ) );
-    l = ui->one_up_lb = gtk_label_new( NULL );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_row( t, &row, _( "Uploaded:" ), l, NULL );
-    l = ui->one_down_lb = gtk_label_new( NULL );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_row( t, &row, _( "Downloaded:" ), l, NULL );
-    l = ui->one_ratio_lb = gtk_label_new( NULL );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_row( t, &row, _( "Ratio:" ), l, NULL );
-    l = ui->one_time_lb = gtk_label_new( NULL );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_row( t, &row, _( "Duration:" ), l, NULL );
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, _( "Total" ) );
-    l = ui->all_sessions_lb = gtk_label_new( _( "Started %'d time" ) );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_label_w( t, row++, l );
-    l = ui->all_up_lb = gtk_label_new( NULL );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_row( t, &row, _( "Uploaded:" ), l, NULL );
-    l = ui->all_down_lb = gtk_label_new( NULL );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_row( t, &row, _( "Downloaded:" ), l, NULL );
-    l = ui->all_ratio_lb = gtk_label_new( NULL );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_row( t, &row, _( "Ratio:" ), l, NULL );
-    l = ui->all_time_lb = gtk_label_new( NULL );
-    gtk_label_set_single_line_mode( GTK_LABEL( l ), TRUE );
-    hig_workarea_add_row( t, &row, _( "Duration:" ), l, NULL );
-    gtr_dialog_set_content( GTK_DIALOG( d ), t );
-
-    updateStats( ui );
-    g_object_set_data_full( G_OBJECT( d ), "data", ui, g_free );
-    g_signal_connect( d, "response", G_CALLBACK( dialogResponse ), ui );
-    i = gdk_threads_add_timeout_seconds( SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS, updateStats, ui );
-    g_object_weak_ref( G_OBJECT( d ), dialogDestroyed, GUINT_TO_POINTER( i ) );
+    hig_workarea_add_section_title (t, &row, _("Current Session"));
+    l = ui->one_up_lb = gtk_label_new (NULL);
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_row (t, &row, _("Uploaded:"), l, NULL);
+    l = ui->one_down_lb = gtk_label_new (NULL);
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_row (t, &row, _("Downloaded:"), l, NULL);
+    l = ui->one_ratio_lb = gtk_label_new (NULL);
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_row (t, &row, _("Ratio:"), l, NULL);
+    l = ui->one_time_lb = gtk_label_new (NULL);
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_row (t, &row, _("Duration:"), l, NULL);
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Total"));
+    l = ui->all_sessions_lb = gtk_label_new (_("Started %'d time"));
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_label_w (t, row++, l);
+    l = ui->all_up_lb = gtk_label_new (NULL);
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_row (t, &row, _("Uploaded:"), l, NULL);
+    l = ui->all_down_lb = gtk_label_new (NULL);
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_row (t, &row, _("Downloaded:"), l, NULL);
+    l = ui->all_ratio_lb = gtk_label_new (NULL);
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_row (t, &row, _("Ratio:"), l, NULL);
+    l = ui->all_time_lb = gtk_label_new (NULL);
+    gtk_label_set_single_line_mode (GTK_LABEL (l), TRUE);
+    hig_workarea_add_row (t, &row, _("Duration:"), l, NULL);
+    gtr_dialog_set_content (GTK_DIALOG (d), t);
+
+    updateStats (ui);
+    g_object_set_data_full (G_OBJECT (d), "data", ui, g_free);
+    g_signal_connect (d, "response", G_CALLBACK (dialogResponse), ui);
+    i = gdk_threads_add_timeout_seconds (SECONDARY_WINDOW_REFRESH_INTERVAL_SECONDS, updateStats, ui);
+    g_object_weak_ref (G_OBJECT (d), dialogDestroyed, GUINT_TO_POINTER (i));
     return d;
 }
diff --git a/gtk/stats.h b/gtk/stats.h
index 5bb00a43d..bc0a4adf4 100644
--- a/gtk/stats.h
+++ b/gtk/stats.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,6 +16,6 @@
 #include <gtk/gtk.h>
 #include "tr-core.h"
 
-GtkWidget* gtr_stats_dialog_new( GtkWindow * parent, TrCore * core );
+GtkWidget* gtr_stats_dialog_new (GtkWindow * parent, TrCore * core);
 
 #endif /* GTR_STATS_DIALOG_H */
diff --git a/gtk/torrent-cell-renderer.c b/gtk/torrent-cell-renderer.c
index af2c84575..3d62cd026 100644
--- a/gtk/torrent-cell-renderer.c
+++ b/gtk/torrent-cell-renderer.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -13,7 +13,7 @@
 #include <gtk/gtk.h>
 #include <glib/gi18n.h>
 #include <libtransmission/transmission.h>
-#include <libtransmission/utils.h> /* tr_truncd() */
+#include <libtransmission/utils.h> /* tr_truncd () */
 #include "hig.h"
 #include "icons.h"
 #include "torrent-cell-renderer.h"
@@ -40,145 +40,145 @@ enum
 ***/
 
 static void
-getProgressString( GString          * gstr,
+getProgressString (GString          * gstr,
                    const tr_torrent * tor,
                    const tr_info    * info,
-                   const tr_stat    * st )
+                   const tr_stat    * st)
 {
     const int      isDone = st->leftUntilDone == 0;
     const uint64_t haveTotal = st->haveUnchecked + st->haveValid;
     const int      isSeed = st->haveValid >= info->totalSize;
     char           buf1[32], buf2[32], buf3[32], buf4[32], buf5[32], buf6[32];
     double         seedRatio;
-    const gboolean hasSeedRatio = tr_torrentGetSeedRatio( tor, &seedRatio );
+    const gboolean hasSeedRatio = tr_torrentGetSeedRatio (tor, &seedRatio);
 
-    if( !isDone ) /* downloading */
+    if (!isDone) /* downloading */
     {
-        g_string_append_printf( gstr,
+        g_string_append_printf (gstr,
             /* %1$s is how much we've got,
                %2$s is how much we'll have when done,
                %3$s%% is a percentage of the two */
-            _( "%1$s of %2$s (%3$s%%)" ),
-            tr_strlsize( buf1, haveTotal, sizeof( buf1 ) ),
-            tr_strlsize( buf2, st->sizeWhenDone, sizeof( buf2 ) ),
-            tr_strlpercent( buf3, st->percentDone * 100.0, sizeof( buf3 ) ) );
+            _("%1$s of %2$s (%3$s%%)"),
+            tr_strlsize (buf1, haveTotal, sizeof (buf1)),
+            tr_strlsize (buf2, st->sizeWhenDone, sizeof (buf2)),
+            tr_strlpercent (buf3, st->percentDone * 100.0, sizeof (buf3)));
     }
-    else if( !isSeed ) /* partial seeds */
+    else if (!isSeed) /* partial seeds */
     {
-        if( hasSeedRatio )
+        if (hasSeedRatio)
         {
-            g_string_append_printf( gstr,
+            g_string_append_printf (gstr,
                 /* %1$s is how much we've got,
                    %2$s is the torrent's total size,
                    %3$s%% is a percentage of the two,
                    %4$s is how much we've uploaded,
                    %5$s is our upload-to-download ratio,
                    %6$s is the ratio we want to reach before we stop uploading */
-                _( "%1$s of %2$s (%3$s%%), uploaded %4$s (Ratio: %5$s Goal: %6$s)" ),
-                tr_strlsize( buf1, haveTotal, sizeof( buf1 ) ),
-                tr_strlsize( buf2, info->totalSize, sizeof( buf2 ) ),
-                tr_strlpercent( buf3, st->percentComplete * 100.0, sizeof( buf3 ) ),
-                tr_strlsize( buf4, st->uploadedEver, sizeof( buf4 ) ),
-                tr_strlratio( buf5, st->ratio, sizeof( buf5 ) ),
-                tr_strlratio( buf6, seedRatio, sizeof( buf6 ) ) );
+                _("%1$s of %2$s (%3$s%%), uploaded %4$s (Ratio: %5$s Goal: %6$s)"),
+                tr_strlsize (buf1, haveTotal, sizeof (buf1)),
+                tr_strlsize (buf2, info->totalSize, sizeof (buf2)),
+                tr_strlpercent (buf3, st->percentComplete * 100.0, sizeof (buf3)),
+                tr_strlsize (buf4, st->uploadedEver, sizeof (buf4)),
+                tr_strlratio (buf5, st->ratio, sizeof (buf5)),
+                tr_strlratio (buf6, seedRatio, sizeof (buf6)));
         }
         else
         {
-            g_string_append_printf( gstr,
+            g_string_append_printf (gstr,
                 /* %1$s is how much we've got,
                    %2$s is the torrent's total size,
                    %3$s%% is a percentage of the two,
                    %4$s is how much we've uploaded,
                    %5$s is our upload-to-download ratio */
-                _( "%1$s of %2$s (%3$s%%), uploaded %4$s (Ratio: %5$s)" ),
-                tr_strlsize( buf1, haveTotal, sizeof( buf1 ) ),
-                tr_strlsize( buf2, info->totalSize, sizeof( buf2 ) ),
-                tr_strlpercent( buf3, st->percentComplete * 100.0, sizeof( buf3 ) ),
-                tr_strlsize( buf4, st->uploadedEver, sizeof( buf4 ) ),
-                tr_strlratio( buf5, st->ratio, sizeof( buf5 ) ) );
+                _("%1$s of %2$s (%3$s%%), uploaded %4$s (Ratio: %5$s)"),
+                tr_strlsize (buf1, haveTotal, sizeof (buf1)),
+                tr_strlsize (buf2, info->totalSize, sizeof (buf2)),
+                tr_strlpercent (buf3, st->percentComplete * 100.0, sizeof (buf3)),
+                tr_strlsize (buf4, st->uploadedEver, sizeof (buf4)),
+                tr_strlratio (buf5, st->ratio, sizeof (buf5)));
         }
     }
     else /* seeding */
     {
-        if( hasSeedRatio )
+        if (hasSeedRatio)
         {
-            g_string_append_printf( gstr,
+            g_string_append_printf (gstr,
                 /* %1$s is the torrent's total size,
                    %2$s is how much we've uploaded,
                    %3$s is our upload-to-download ratio,
                    %4$s is the ratio we want to reach before we stop uploading */
-                _( "%1$s, uploaded %2$s (Ratio: %3$s Goal: %4$s)" ),
-                tr_strlsize( buf1, info->totalSize, sizeof( buf1 ) ),
-                tr_strlsize( buf2, st->uploadedEver, sizeof( buf2 ) ),
-                tr_strlratio( buf3, st->ratio, sizeof( buf3 ) ),
-                tr_strlratio( buf4, seedRatio, sizeof( buf4 ) ) );
+                _("%1$s, uploaded %2$s (Ratio: %3$s Goal: %4$s)"),
+                tr_strlsize (buf1, info->totalSize, sizeof (buf1)),
+                tr_strlsize (buf2, st->uploadedEver, sizeof (buf2)),
+                tr_strlratio (buf3, st->ratio, sizeof (buf3)),
+                tr_strlratio (buf4, seedRatio, sizeof (buf4)));
         }
         else /* seeding w/o a ratio */
         {
-            g_string_append_printf( gstr,
+            g_string_append_printf (gstr,
                 /* %1$s is the torrent's total size,
                    %2$s is how much we've uploaded,
                    %3$s is our upload-to-download ratio */
-                _( "%1$s, uploaded %2$s (Ratio: %3$s)" ),
-                tr_strlsize( buf1, info->totalSize, sizeof( buf1 ) ),
-                tr_strlsize( buf2, st->uploadedEver, sizeof( buf2 ) ),
-                tr_strlratio( buf3, st->ratio, sizeof( buf3 ) ) );
+                _("%1$s, uploaded %2$s (Ratio: %3$s)"),
+                tr_strlsize (buf1, info->totalSize, sizeof (buf1)),
+                tr_strlsize (buf2, st->uploadedEver, sizeof (buf2)),
+                tr_strlratio (buf3, st->ratio, sizeof (buf3)));
         }
     }
 
     /* add time when downloading */
-    if( ( st->activity == TR_STATUS_DOWNLOAD )
-        || ( hasSeedRatio && ( st->activity == TR_STATUS_SEED ) ) )
+    if ((st->activity == TR_STATUS_DOWNLOAD)
+        || (hasSeedRatio && (st->activity == TR_STATUS_SEED)))
     {
         const int eta = st->eta;
-        g_string_append( gstr, " - " );
-        if( eta < 0 )
-            g_string_append( gstr, _( "Remaining time unknown" ) );
+        g_string_append (gstr, " - ");
+        if (eta < 0)
+            g_string_append (gstr, _("Remaining time unknown"));
         else
         {
             char timestr[128];
-            tr_strltime( timestr, eta, sizeof( timestr ) );
+            tr_strltime (timestr, eta, sizeof (timestr));
             /* time remaining */
-            g_string_append_printf( gstr, _( "%s remaining" ), timestr );
+            g_string_append_printf (gstr, _("%s remaining"), timestr);
         }
     }
 }
 
 static char*
-getShortTransferString( const tr_torrent  * tor,
+getShortTransferString (const tr_torrent  * tor,
                         const tr_stat     * st,
                         double              uploadSpeed_KBps,
                         double              downloadSpeed_KBps,
                         char              * buf,
-                        size_t              buflen )
+                        size_t              buflen)
 {
     char downStr[32], upStr[32];
-    const int haveMeta = tr_torrentHasMetadata( tor );
+    const int haveMeta = tr_torrentHasMetadata (tor);
     const int haveUp = haveMeta && st->peersGettingFromUs > 0;
-    const int haveDown = haveMeta && ( ( st->peersSendingToUs > 0 ) || ( st->webseedsSendingToUs > 0 ) );
+    const int haveDown = haveMeta && ((st->peersSendingToUs > 0) || (st->webseedsSendingToUs > 0));
 
-    if( haveDown )
-        tr_formatter_speed_KBps( downStr, downloadSpeed_KBps, sizeof( downStr ) );
-    if( haveUp )
-        tr_formatter_speed_KBps( upStr, uploadSpeed_KBps, sizeof( upStr ) );
+    if (haveDown)
+        tr_formatter_speed_KBps (downStr, downloadSpeed_KBps, sizeof (downStr));
+    if (haveUp)
+        tr_formatter_speed_KBps (upStr, uploadSpeed_KBps, sizeof (upStr));
 
-    if( haveDown && haveUp )
+    if (haveDown && haveUp)
         /* 1==down arrow, 2==down speed, 3==up arrow, 4==down speed */
-        g_snprintf( buf, buflen, _( "%1$s %2$s, %3$s %4$s" ),
-                    gtr_get_unicode_string( GTR_UNICODE_DOWN ), downStr,
-                    gtr_get_unicode_string( GTR_UNICODE_UP ), upStr );
-    else if( haveDown )
+        g_snprintf (buf, buflen, _("%1$s %2$s, %3$s %4$s"),
+                    gtr_get_unicode_string (GTR_UNICODE_DOWN), downStr,
+                    gtr_get_unicode_string (GTR_UNICODE_UP), upStr);
+    else if (haveDown)
         /* bandwidth speed + unicode arrow */
-        g_snprintf( buf, buflen, _( "%1$s %2$s" ),
-                    gtr_get_unicode_string( GTR_UNICODE_DOWN ), downStr );
-    else if( haveUp )
+        g_snprintf (buf, buflen, _("%1$s %2$s"),
+                    gtr_get_unicode_string (GTR_UNICODE_DOWN), downStr);
+    else if (haveUp)
         /* bandwidth speed + unicode arrow */
-        g_snprintf( buf, buflen, _( "%1$s %2$s" ),
-                    gtr_get_unicode_string( GTR_UNICODE_UP ), upStr );
-    else if( st->isStalled )
-        g_strlcpy( buf, _( "Stalled" ), buflen );
-    else if( haveMeta )
-        g_strlcpy( buf, _( "Idle" ), buflen );
+        g_snprintf (buf, buflen, _("%1$s %2$s"),
+                    gtr_get_unicode_string (GTR_UNICODE_UP), upStr);
+    else if (st->isStalled)
+        g_strlcpy (buf, _("Stalled"), buflen);
+    else if (haveMeta)
+        g_strlcpy (buf, _("Idle"), buflen);
     else
         *buf = '\0';
 
@@ -186,44 +186,44 @@ getShortTransferString( const tr_torrent  * tor,
 }
 
 static void
-getShortStatusString( GString           * gstr,
+getShortStatusString (GString           * gstr,
                       const tr_torrent  * tor,
                       const tr_stat     * st,
                       double              uploadSpeed_KBps,
-                      double              downloadSpeed_KBps )
+                      double              downloadSpeed_KBps)
 {
-    switch( st->activity )
+    switch (st->activity)
     {
         case TR_STATUS_STOPPED:
-            g_string_append( gstr, st->finished ? _( "Finished" ) : _( "Paused" ) );
+            g_string_append (gstr, st->finished ? _("Finished") : _("Paused"));
             break;
         case TR_STATUS_CHECK_WAIT:
-            g_string_append( gstr, _( "Queued for verification" ) );
+            g_string_append (gstr, _("Queued for verification"));
             break;
         case TR_STATUS_DOWNLOAD_WAIT:
-            g_string_append( gstr, _( "Queued for download" ) );
+            g_string_append (gstr, _("Queued for download"));
             break;
         case TR_STATUS_SEED_WAIT:
-            g_string_append( gstr, _( "Queued for seeding" ) );
+            g_string_append (gstr, _("Queued for seeding"));
             break;
 
         case TR_STATUS_CHECK:
-            g_string_append_printf( gstr, _( "Verifying local data (%.1f%% tested)" ),
-                                    tr_truncd( st->recheckProgress * 100.0, 1 ) );
+            g_string_append_printf (gstr, _("Verifying local data (%.1f%% tested)"),
+                                    tr_truncd (st->recheckProgress * 100.0, 1));
             break;
 
         case TR_STATUS_DOWNLOAD:
         case TR_STATUS_SEED:
         {
             char buf[512];
-            if( st->activity != TR_STATUS_DOWNLOAD )
+            if (st->activity != TR_STATUS_DOWNLOAD)
             {
-                tr_strlratio( buf, st->ratio, sizeof( buf ) );
-                g_string_append_printf( gstr, _( "Ratio %s" ), buf );
-                g_string_append( gstr, ", " );
+                tr_strlratio (buf, st->ratio, sizeof (buf));
+                g_string_append_printf (gstr, _("Ratio %s"), buf);
+                g_string_append (gstr, ", ");
             }
-            getShortTransferString( tor, st, uploadSpeed_KBps, downloadSpeed_KBps, buf, sizeof( buf ) );
-            g_string_append( gstr, buf );
+            getShortTransferString (tor, st, uploadSpeed_KBps, downloadSpeed_KBps, buf, sizeof (buf));
+            g_string_append (gstr, buf);
             break;
         }
 
@@ -233,20 +233,20 @@ getShortStatusString( GString           * gstr,
 }
 
 static void
-getStatusString( GString           * gstr,
+getStatusString (GString           * gstr,
                  const tr_torrent  * tor,
                  const tr_stat     * st,
                  const double        uploadSpeed_KBps,
-                 const double        downloadSpeed_KBps )
+                 const double        downloadSpeed_KBps)
 {
-    if( st->error )
+    if (st->error)
     {
-        const char * fmt[] = { NULL, N_( "Tracker gave a warning: \"%s\"" ),
-                                     N_( "Tracker gave an error: \"%s\"" ),
-                                     N_( "Error: %s" ) };
-        g_string_append_printf( gstr, _( fmt[st->error] ), st->errorString );
+        const char * fmt[] = { NULL, N_("Tracker gave a warning: \"%s\""),
+                                     N_("Tracker gave an error: \"%s\""),
+                                     N_("Error: %s") };
+        g_string_append_printf (gstr, _ (fmt[st->error]), st->errorString);
     }
-    else switch( st->activity )
+    else switch (st->activity)
     {
         case TR_STATUS_STOPPED:
         case TR_STATUS_CHECK_WAIT:
@@ -254,68 +254,68 @@ getStatusString( GString           * gstr,
         case TR_STATUS_DOWNLOAD_WAIT:
         case TR_STATUS_SEED_WAIT:
         {
-            getShortStatusString( gstr, tor, st, uploadSpeed_KBps, downloadSpeed_KBps );
+            getShortStatusString (gstr, tor, st, uploadSpeed_KBps, downloadSpeed_KBps);
             break;
         }
 
         case TR_STATUS_DOWNLOAD:
         {
-            if( !tr_torrentHasMetadata( tor ) )
+            if (!tr_torrentHasMetadata (tor))
             {
-                /* Downloading metadata from 2 peer(s) (50% done) */
-                g_string_append_printf( gstr, _("Downloading metadata from %1$'d %2$s (%3$d%% done)"),
+                /* Downloading metadata from 2 peer (s)(50% done) */
+                g_string_append_printf (gstr, _("Downloading metadata from %1$'d %2$s (%3$d%% done)"),
                                         st->peersConnected,
-                                        ngettext("peer","peers",st->peersConnected),
-                                        (int)(100.0*st->metadataPercentComplete) );
+                                        ngettext ("peer","peers",st->peersConnected),
+                                      (int)(100.0*st->metadataPercentComplete));
             }
             else if (st->peersSendingToUs && st->webseedsSendingToUs)
             {
-                /* Downloading from 2 of 3 peer(s) and 2 webseed(s) */
+                /* Downloading from 2 of 3 peer (s) and 2 webseed (s) */
                 g_string_append_printf (gstr, _("Downloading from %1$'d of %2$'d %3$s and %4$'d %5$s"),
                                         st->peersSendingToUs,
                                         st->peersConnected,
-                                        ngettext("peer","peers",st->peersSendingToUs),
+                                        ngettext ("peer","peers",st->peersSendingToUs),
                                         st->webseedsSendingToUs,
-                                        ngettext("web seed","web seeds",st->webseedsSendingToUs));
+                                        ngettext ("web seed","web seeds",st->webseedsSendingToUs));
             }
             else if (st->webseedsSendingToUs)
             {
-                /* Downloading from 3 web seed(s) */
+                /* Downloading from 3 web seed (s) */
                 g_string_append_printf (gstr, _("Downloading from %1$'d %2$s"),
                                         st->webseedsSendingToUs,
-                                        ngettext("web seed","web seeds",st->webseedsSendingToUs));
+                                        ngettext ("web seed","web seeds",st->webseedsSendingToUs));
             }
             else
             {
-                /* Downloading from 2 of 3 peer(s) */
+                /* Downloading from 2 of 3 peer (s) */
                 g_string_append_printf (gstr, _("Downloading from %1$'d of %2$'d %3$s"),
                                         st->peersSendingToUs,
                                         st->peersConnected,
-                                        ngettext("peer","peers",st->peersSendingToUs));
+                                        ngettext ("peer","peers",st->peersSendingToUs));
             }
             break;
         }
 
         case TR_STATUS_SEED:
-            g_string_append_printf( gstr,
-                ngettext( "Seeding to %1$'d of %2$'d connected peer",
+            g_string_append_printf (gstr,
+                ngettext ("Seeding to %1$'d of %2$'d connected peer",
                           "Seeding to %1$'d of %2$'d connected peers",
-                          st->peersConnected ),
+                          st->peersConnected),
                 st->peersGettingFromUs,
-                st->peersConnected );
+                st->peersConnected);
                 break;
     }
 
-    if( ( st->activity != TR_STATUS_CHECK_WAIT ) &&
-        ( st->activity != TR_STATUS_CHECK ) &&
-        ( st->activity != TR_STATUS_DOWNLOAD_WAIT ) &&
-        ( st->activity != TR_STATUS_SEED_WAIT ) &&
-        ( st->activity != TR_STATUS_STOPPED ) )
+    if ((st->activity != TR_STATUS_CHECK_WAIT) &&
+      (st->activity != TR_STATUS_CHECK) &&
+      (st->activity != TR_STATUS_DOWNLOAD_WAIT) &&
+      (st->activity != TR_STATUS_SEED_WAIT) &&
+      (st->activity != TR_STATUS_STOPPED))
     {
         char buf[256];
-        getShortTransferString( tor, st, uploadSpeed_KBps, downloadSpeed_KBps, buf, sizeof( buf ) );
-        if( *buf )
-            g_string_append_printf( gstr, " - %s", buf );
+        getShortTransferString (tor, st, uploadSpeed_KBps, downloadSpeed_KBps, buf, sizeof (buf));
+        if (*buf)
+            g_string_append_printf (gstr, " - %s", buf);
     }
 }
 
@@ -350,21 +350,21 @@ struct TorrentCellRendererPrivate
 ***/
 
 static GdkPixbuf*
-get_icon( const tr_torrent * tor, GtkIconSize icon_size, GtkWidget * for_widget )
+get_icon (const tr_torrent * tor, GtkIconSize icon_size, GtkWidget * for_widget)
 {
     const char * mime_type;
-    const tr_info * info = tr_torrentInfo( tor );
+    const tr_info * info = tr_torrentInfo (tor);
 
-    if( info->fileCount == 0  )
+    if (info->fileCount == 0)
         mime_type = UNKNOWN_MIME_TYPE;
-    else if( info->fileCount > 1 )
+    else if (info->fileCount > 1)
         mime_type = DIRECTORY_MIME_TYPE;
-    else if( strchr( info->files[0].name, '/' ) != NULL )
+    else if (strchr (info->files[0].name, '/') != NULL)
         mime_type = DIRECTORY_MIME_TYPE;
     else
-        mime_type = gtr_get_mime_type_from_filename( info->files[0].name );
+        mime_type = gtr_get_mime_type_from_filename (info->files[0].name);
 
-    return gtr_get_mime_type_icon( mime_type, icon_size, for_widget );
+    return gtr_get_mime_type_icon (mime_type, icon_size, for_widget);
 }
 
 /***
@@ -372,19 +372,19 @@ get_icon( const tr_torrent * tor, GtkIconSize icon_size, GtkWidget * for_widget
 ***/
 
 static void
-gtr_cell_renderer_get_preferred_size( GtkCellRenderer  * renderer,
+gtr_cell_renderer_get_preferred_size (GtkCellRenderer  * renderer,
                                       GtkWidget        * widget,
                                       GtkRequisition   * minimum_size,
-                                      GtkRequisition   * natural_size )
+                                      GtkRequisition   * natural_size)
 {
-    gtk_cell_renderer_get_preferred_size( renderer, widget, minimum_size, natural_size );
+    gtk_cell_renderer_get_preferred_size (renderer, widget, minimum_size, natural_size);
 }
 
 static void
-get_size_compact( TorrentCellRenderer * cell,
+get_size_compact (TorrentCellRenderer * cell,
                   GtkWidget           * widget,
                   gint                * width,
-                  gint                * height )
+                  gint                * height)
 {
     int xpad, ypad;
     GtkRequisition icon_size;
@@ -395,44 +395,44 @@ get_size_compact( TorrentCellRenderer * cell,
 
     struct TorrentCellRendererPrivate * p = cell->priv;
     const tr_torrent * tor = p->tor;
-    const tr_stat * st = tr_torrentStatCached( (tr_torrent*)tor );
+    const tr_stat * st = tr_torrentStatCached ((tr_torrent*)tor);
     GString * gstr_stat = p->gstr1;
 
-    icon = get_icon( tor, COMPACT_ICON_SIZE, widget );
-    name = tr_torrentName( tor );
-    g_string_truncate( gstr_stat, 0 );
-    getShortStatusString( gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps );
-    gtk_cell_renderer_get_padding( GTK_CELL_RENDERER( cell ), &xpad, &ypad );
+    icon = get_icon (tor, COMPACT_ICON_SIZE, widget);
+    name = tr_torrentName (tor);
+    g_string_truncate (gstr_stat, 0);
+    getShortStatusString (gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps);
+    gtk_cell_renderer_get_padding (GTK_CELL_RENDERER (cell), &xpad, &ypad);
 
     /* get the idealized cell dimensions */
-    g_object_set( p->icon_renderer, "pixbuf", icon, NULL );
-    gtr_cell_renderer_get_preferred_size( p->icon_renderer, widget, NULL, &icon_size );
-    g_object_set( p->text_renderer, "text", name, "ellipsize", PANGO_ELLIPSIZE_NONE,  "scale", 1.0, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &name_size );
-    g_object_set( p->text_renderer, "text", gstr_stat->str, "scale", SMALL_SCALE, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &stat_size );
+    g_object_set (p->icon_renderer, "pixbuf", icon, NULL);
+    gtr_cell_renderer_get_preferred_size (p->icon_renderer, widget, NULL, &icon_size);
+    g_object_set (p->text_renderer, "text", name, "ellipsize", PANGO_ELLIPSIZE_NONE,  "scale", 1.0, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &name_size);
+    g_object_set (p->text_renderer, "text", gstr_stat->str, "scale", SMALL_SCALE, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &stat_size);
 
     /**
     *** LAYOUT
     **/
 
 #define BAR_WIDTH 50
-    if( width != NULL )
+    if (width != NULL)
         *width = xpad * 2 + icon_size.width + GUI_PAD + name_size.width + GUI_PAD + BAR_WIDTH + GUI_PAD + stat_size.width;
-    if( height != NULL )
-        *height = ypad * 2 + MAX( name_size.height, p->bar_height );
+    if (height != NULL)
+        *height = ypad * 2 + MAX (name_size.height, p->bar_height);
 
     /* cleanup */
-    g_object_unref( icon );
+    g_object_unref (icon);
 }
 
 #define MAX3(a,b,c) MAX(a,MAX(b,c))
 
 static void
-get_size_full( TorrentCellRenderer * cell,
+get_size_full (TorrentCellRenderer * cell,
                GtkWidget           * widget,
                gint                * width,
-               gint                * height )
+               gint                * height)
 {
     int xpad, ypad;
     GtkRequisition icon_size;
@@ -444,76 +444,76 @@ get_size_full( TorrentCellRenderer * cell,
 
     struct TorrentCellRendererPrivate * p = cell->priv;
     const tr_torrent * tor = p->tor;
-    const tr_stat * st = tr_torrentStatCached( (tr_torrent*)tor );
-    const tr_info * inf = tr_torrentInfo( tor );
+    const tr_stat * st = tr_torrentStatCached ((tr_torrent*)tor);
+    const tr_info * inf = tr_torrentInfo (tor);
     GString * gstr_prog = p->gstr1;
     GString * gstr_stat = p->gstr2;
 
-    icon = get_icon( tor, FULL_ICON_SIZE, widget );
-    name = tr_torrentName( tor );
-    g_string_truncate( gstr_stat, 0 );
-    getStatusString( gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps );
-    g_string_truncate( gstr_prog, 0 );
-    getProgressString( gstr_prog, tor, inf, st );
-    gtk_cell_renderer_get_padding( GTK_CELL_RENDERER( cell ), &xpad, &ypad );
+    icon = get_icon (tor, FULL_ICON_SIZE, widget);
+    name = tr_torrentName (tor);
+    g_string_truncate (gstr_stat, 0);
+    getStatusString (gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps);
+    g_string_truncate (gstr_prog, 0);
+    getProgressString (gstr_prog, tor, inf, st);
+    gtk_cell_renderer_get_padding (GTK_CELL_RENDERER (cell), &xpad, &ypad);
 
     /* get the idealized cell dimensions */
-    g_object_set( p->icon_renderer, "pixbuf", icon, NULL );
-    gtr_cell_renderer_get_preferred_size( p->icon_renderer, widget, NULL, &icon_size );
-    g_object_set( p->text_renderer, "text", name, "weight", PANGO_WEIGHT_BOLD, "scale", 1.0, "ellipsize", PANGO_ELLIPSIZE_NONE, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &name_size );
-    g_object_set( p->text_renderer, "text", gstr_prog->str, "weight", PANGO_WEIGHT_NORMAL, "scale", SMALL_SCALE, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &prog_size );
-    g_object_set( p->text_renderer, "text", gstr_stat->str, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &stat_size );
+    g_object_set (p->icon_renderer, "pixbuf", icon, NULL);
+    gtr_cell_renderer_get_preferred_size (p->icon_renderer, widget, NULL, &icon_size);
+    g_object_set (p->text_renderer, "text", name, "weight", PANGO_WEIGHT_BOLD, "scale", 1.0, "ellipsize", PANGO_ELLIPSIZE_NONE, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &name_size);
+    g_object_set (p->text_renderer, "text", gstr_prog->str, "weight", PANGO_WEIGHT_NORMAL, "scale", SMALL_SCALE, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &prog_size);
+    g_object_set (p->text_renderer, "text", gstr_stat->str, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &stat_size);
 
     /**
     *** LAYOUT
     **/
 
-    if( width != NULL )
-        *width = xpad * 2 + icon_size.width + GUI_PAD + MAX3( name_size.width, prog_size.width, stat_size.width );
-    if( height != NULL )
+    if (width != NULL)
+        *width = xpad * 2 + icon_size.width + GUI_PAD + MAX3 (name_size.width, prog_size.width, stat_size.width);
+    if (height != NULL)
         *height = ypad * 2 + name_size.height + prog_size.height + GUI_PAD_SMALL + p->bar_height + GUI_PAD_SMALL + stat_size.height;
 
     /* cleanup */
-    g_object_unref( icon );
+    g_object_unref (icon);
 }
 
 
 static void
-torrent_cell_renderer_get_size( GtkCellRenderer     * cell,
+torrent_cell_renderer_get_size (GtkCellRenderer     * cell,
                                 GtkWidget           * widget,
                                 const GdkRectangle  * cell_area,
                                 gint                * x_offset,
                                 gint                * y_offset,
                                 gint                * width,
-                                gint                * height )
+                                gint                * height)
 {
-    TorrentCellRenderer * self = TORRENT_CELL_RENDERER( cell );
+    TorrentCellRenderer * self = TORRENT_CELL_RENDERER (cell);
 
-    if( self && self->priv->tor )
+    if (self && self->priv->tor)
     {
         int w, h;
         struct TorrentCellRendererPrivate * p = self->priv;
 
-        if( p->compact )
-            get_size_compact( TORRENT_CELL_RENDERER( cell ), widget, &w, &h );
+        if (p->compact)
+            get_size_compact (TORRENT_CELL_RENDERER (cell), widget, &w, &h);
         else
-            get_size_full( TORRENT_CELL_RENDERER( cell ), widget, &w, &h );
+            get_size_full (TORRENT_CELL_RENDERER (cell), widget, &w, &h);
 
-        if( width )
+        if (width)
             *width = w;
 
-        if( height )
+        if (height)
             *height = h;
 
-        if( x_offset )
+        if (x_offset)
             *x_offset = cell_area ? cell_area->x : 0;
 
-        if( y_offset ) {
+        if (y_offset) {
             int xpad, ypad;
-            gtk_cell_renderer_get_padding( cell, &xpad, &ypad );
+            gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
             *y_offset = cell_area ? (int)((cell_area->height - (ypad*2 +h)) / 2.0) : 0;
         }
     }
@@ -523,32 +523,32 @@ typedef GdkRGBA GtrColor;
 #define FOREGROUND_COLOR_KEY "foreground-rgba"
 
 static void
-get_text_color( GtkWidget * w, const tr_stat * st, GtrColor * setme )
+get_text_color (GtkWidget * w, const tr_stat * st, GtrColor * setme)
 {
     static const GdkRGBA red = { 1.0, 0, 0, 0 };
-    if( st->error )
+    if (st->error)
         *setme = red;
-    else if( st->activity == TR_STATUS_STOPPED )
-        gtk_style_context_get_color( gtk_widget_get_style_context( w ), GTK_STATE_FLAG_INSENSITIVE, setme );
+    else if (st->activity == TR_STATUS_STOPPED)
+        gtk_style_context_get_color (gtk_widget_get_style_context (w), GTK_STATE_FLAG_INSENSITIVE, setme);
     else
-        gtk_style_context_get_color( gtk_widget_get_style_context( w ), GTK_STATE_FLAG_NORMAL, setme );
+        gtk_style_context_get_color (gtk_widget_get_style_context (w), GTK_STATE_FLAG_NORMAL, setme);
 }
 
 
 static double
-get_percent_done( const tr_torrent * tor, const tr_stat * st, bool * seed )
+get_percent_done (const tr_torrent * tor, const tr_stat * st, bool * seed)
 {
     double d;
 
-    if( ( st->activity == TR_STATUS_SEED ) && tr_torrentGetSeedRatio( tor, &d ) )
+    if ((st->activity == TR_STATUS_SEED) && tr_torrentGetSeedRatio (tor, &d))
     {
         *seed = true;
-        d = MAX( 0.0, st->seedRatioPercentDone );
+        d = MAX (0.0, st->seedRatioPercentDone);
     }
     else
     {
         *seed = false;
-        d = MAX( 0.0, st->percentDone );
+        d = MAX (0.0, st->percentDone);
     }
 
     return d;
@@ -557,22 +557,22 @@ get_percent_done( const tr_torrent * tor, const tr_stat * st, bool * seed )
 typedef cairo_t GtrDrawable;
 
 static void
-gtr_cell_renderer_render( GtkCellRenderer       * renderer,
+gtr_cell_renderer_render (GtkCellRenderer       * renderer,
                           GtrDrawable           * drawable,
                           GtkWidget             * widget,
                           const GdkRectangle    * area,
                           GtkCellRendererState    flags)
 {
-    gtk_cell_renderer_render( renderer, drawable, widget, area, area, flags );
+    gtk_cell_renderer_render (renderer, drawable, widget, area, area, flags);
 }
 
 static void
-render_compact( TorrentCellRenderer   * cell,
+render_compact (TorrentCellRenderer   * cell,
                 GtrDrawable           * window,
                 GtkWidget             * widget,
                 const GdkRectangle    * background_area,
                 const GdkRectangle    * cell_area UNUSED,
-                GtkCellRendererState    flags )
+                GtkCellRendererState    flags)
 {
     int xpad, ypad;
     GtkRequisition size;
@@ -588,18 +588,18 @@ render_compact( TorrentCellRenderer   * cell,
 
     struct TorrentCellRendererPrivate * p = cell->priv;
     const tr_torrent * tor = p->tor;
-    const tr_stat * st = tr_torrentStatCached( (tr_torrent*)tor );
-    const gboolean active = ( st->activity != TR_STATUS_STOPPED ) && ( st->activity != TR_STATUS_DOWNLOAD_WAIT ) && ( st->activity != TR_STATUS_SEED_WAIT );
-    const double percentDone = get_percent_done( tor, st, &seed );
+    const tr_stat * st = tr_torrentStatCached ((tr_torrent*)tor);
+    const gboolean active = (st->activity != TR_STATUS_STOPPED) && (st->activity != TR_STATUS_DOWNLOAD_WAIT) && (st->activity != TR_STATUS_SEED_WAIT);
+    const double percentDone = get_percent_done (tor, st, &seed);
     const gboolean sensitive = active || st->error;
     GString * gstr_stat = p->gstr1;
 
-    icon = get_icon( tor, COMPACT_ICON_SIZE, widget );
-    name = tr_torrentName( tor );
-    g_string_truncate( gstr_stat, 0 );
-    getShortStatusString( gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps );
-    gtk_cell_renderer_get_padding( GTK_CELL_RENDERER( cell ), &xpad, &ypad );
-    get_text_color( widget, st, &text_color );
+    icon = get_icon (tor, COMPACT_ICON_SIZE, widget);
+    name = tr_torrentName (tor);
+    g_string_truncate (gstr_stat, 0);
+    getShortStatusString (gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps);
+    gtk_cell_renderer_get_padding (GTK_CELL_RENDERER (cell), &xpad, &ypad);
+    get_text_color (widget, st, &text_color);
 
     fill_area = *background_area;
     fill_area.x += xpad;
@@ -608,14 +608,14 @@ render_compact( TorrentCellRenderer   * cell,
     fill_area.height -= ypad * 2;
     icon_area = name_area = stat_area = prog_area = fill_area;
 
-    g_object_set( p->icon_renderer, "pixbuf", icon, NULL );
-    gtr_cell_renderer_get_preferred_size( p->icon_renderer, widget, NULL, &size );
+    g_object_set (p->icon_renderer, "pixbuf", icon, NULL);
+    gtr_cell_renderer_get_preferred_size (p->icon_renderer, widget, NULL, &size);
     icon_area.width = size.width;
-    g_object_set( p->text_renderer, "text", name, "ellipsize", PANGO_ELLIPSIZE_NONE, "scale", 1.0, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &size );
+    g_object_set (p->text_renderer, "text", name, "ellipsize", PANGO_ELLIPSIZE_NONE, "scale", 1.0, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &size);
     name_area.width = size.width;
-    g_object_set( p->text_renderer, "text", gstr_stat->str, "scale", SMALL_SCALE, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &size );
+    g_object_set (p->text_renderer, "text", gstr_stat->str, "scale", SMALL_SCALE, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &size);
     stat_area.width = size.width;
 
     icon_area.x = fill_area.x;
@@ -630,26 +630,26 @@ render_compact( TorrentCellRenderer   * cell,
     *** RENDER
     **/
 
-    g_object_set( p->icon_renderer, "pixbuf", icon, "sensitive", sensitive, NULL );
-    gtr_cell_renderer_render( p->icon_renderer, window, widget, &icon_area, flags );
-    g_object_set( p->progress_renderer, "value", (int)(percentDone*100.0), "text", NULL, "sensitive", sensitive, NULL );
-    gtr_cell_renderer_render( p->progress_renderer, window, widget, &prog_area, flags );
-    g_object_set( p->text_renderer, "text", gstr_stat->str, "scale", SMALL_SCALE, "ellipsize", PANGO_ELLIPSIZE_END, FOREGROUND_COLOR_KEY, &text_color, NULL );
-    gtr_cell_renderer_render( p->text_renderer, window, widget, &stat_area, flags );
-    g_object_set( p->text_renderer, "text", name, "scale", 1.0, FOREGROUND_COLOR_KEY, &text_color, NULL );
-    gtr_cell_renderer_render( p->text_renderer, window, widget, &name_area, flags );
+    g_object_set (p->icon_renderer, "pixbuf", icon, "sensitive", sensitive, NULL);
+    gtr_cell_renderer_render (p->icon_renderer, window, widget, &icon_area, flags);
+    g_object_set (p->progress_renderer, "value", (int)(percentDone*100.0), "text", NULL, "sensitive", sensitive, NULL);
+    gtr_cell_renderer_render (p->progress_renderer, window, widget, &prog_area, flags);
+    g_object_set (p->text_renderer, "text", gstr_stat->str, "scale", SMALL_SCALE, "ellipsize", PANGO_ELLIPSIZE_END, FOREGROUND_COLOR_KEY, &text_color, NULL);
+    gtr_cell_renderer_render (p->text_renderer, window, widget, &stat_area, flags);
+    g_object_set (p->text_renderer, "text", name, "scale", 1.0, FOREGROUND_COLOR_KEY, &text_color, NULL);
+    gtr_cell_renderer_render (p->text_renderer, window, widget, &name_area, flags);
 
     /* cleanup */
-    g_object_unref( icon );
+    g_object_unref (icon);
 }
 
 static void
-render_full( TorrentCellRenderer   * cell,
+render_full (TorrentCellRenderer   * cell,
              GtrDrawable           * window,
              GtkWidget             * widget,
              const GdkRectangle    * background_area,
              const GdkRectangle    * cell_area UNUSED,
-             GtkCellRendererState    flags )
+             GtkCellRendererState    flags)
 {
     int xpad, ypad;
     GtkRequisition size;
@@ -666,38 +666,38 @@ render_full( TorrentCellRenderer   * cell,
 
     struct TorrentCellRendererPrivate * p = cell->priv;
     const tr_torrent * tor = p->tor;
-    const tr_stat * st = tr_torrentStatCached( (tr_torrent*)tor );
-    const tr_info * inf = tr_torrentInfo( tor );
-    const gboolean active = ( st->activity != TR_STATUS_STOPPED ) && ( st->activity != TR_STATUS_DOWNLOAD_WAIT ) && ( st->activity != TR_STATUS_SEED_WAIT );
-    const double percentDone = get_percent_done( tor, st, &seed );
+    const tr_stat * st = tr_torrentStatCached ((tr_torrent*)tor);
+    const tr_info * inf = tr_torrentInfo (tor);
+    const gboolean active = (st->activity != TR_STATUS_STOPPED) && (st->activity != TR_STATUS_DOWNLOAD_WAIT) && (st->activity != TR_STATUS_SEED_WAIT);
+    const double percentDone = get_percent_done (tor, st, &seed);
     const gboolean sensitive = active || st->error;
     GString * gstr_prog = p->gstr1;
     GString * gstr_stat = p->gstr2;
 
-    icon = get_icon( tor, FULL_ICON_SIZE, widget );
-    name = tr_torrentName( tor );
-    g_string_truncate( gstr_prog, 0 );
-    getProgressString( gstr_prog, tor, inf, st );
-    g_string_truncate( gstr_stat, 0 );
-    getStatusString( gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps );
-    gtk_cell_renderer_get_padding( GTK_CELL_RENDERER( cell ), &xpad, &ypad );
-    get_text_color( widget, st, &text_color );
+    icon = get_icon (tor, FULL_ICON_SIZE, widget);
+    name = tr_torrentName (tor);
+    g_string_truncate (gstr_prog, 0);
+    getProgressString (gstr_prog, tor, inf, st);
+    g_string_truncate (gstr_stat, 0);
+    getStatusString (gstr_stat, tor, st, p->upload_speed_KBps, p->download_speed_KBps);
+    gtk_cell_renderer_get_padding (GTK_CELL_RENDERER (cell), &xpad, &ypad);
+    get_text_color (widget, st, &text_color);
 
     /* get the idealized cell dimensions */
-    g_object_set( p->icon_renderer, "pixbuf", icon, NULL );
-    gtr_cell_renderer_get_preferred_size( p->icon_renderer, widget, NULL, &size );
+    g_object_set (p->icon_renderer, "pixbuf", icon, NULL);
+    gtr_cell_renderer_get_preferred_size (p->icon_renderer, widget, NULL, &size);
     icon_area.width = size.width;
     icon_area.height = size.height;
-    g_object_set( p->text_renderer, "text", name, "weight", PANGO_WEIGHT_BOLD, "ellipsize", PANGO_ELLIPSIZE_NONE, "scale", 1.0, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &size );
+    g_object_set (p->text_renderer, "text", name, "weight", PANGO_WEIGHT_BOLD, "ellipsize", PANGO_ELLIPSIZE_NONE, "scale", 1.0, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &size);
     name_area.width = size.width;
     name_area.height = size.height;
-    g_object_set( p->text_renderer, "text", gstr_prog->str, "weight", PANGO_WEIGHT_NORMAL, "scale", SMALL_SCALE, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &size );
+    g_object_set (p->text_renderer, "text", gstr_prog->str, "weight", PANGO_WEIGHT_NORMAL, "scale", SMALL_SCALE, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &size);
     prog_area.width = size.width;
     prog_area.height = size.height;
-    g_object_set( p->text_renderer, "text", gstr_stat->str, NULL );
-    gtr_cell_renderer_get_preferred_size( p->text_renderer, widget, NULL, &size );
+    g_object_set (p->text_renderer, "text", gstr_stat->str, NULL);
+    gtr_cell_renderer_get_preferred_size (p->text_renderer, widget, NULL, &size);
     stat_area.width = size.width;
     stat_area.height = size.height;
 
@@ -713,7 +713,7 @@ render_full( TorrentCellRenderer   * cell,
 
     /* icon */
     icon_area.x = fill_area.x;
-    icon_area.y = fill_area.y + ( fill_area.height - icon_area.height ) / 2;
+    icon_area.y = fill_area.y + (fill_area.height - icon_area.height) / 2;
 
     /* name */
     name_area.x = icon_area.x + icon_area.width + GUI_PAD;
@@ -740,118 +740,118 @@ render_full( TorrentCellRenderer   * cell,
     *** RENDER
     **/
 
-    g_object_set( p->icon_renderer, "pixbuf", icon, "sensitive", sensitive, NULL );
-    gtr_cell_renderer_render( p->icon_renderer, window, widget, &icon_area, flags );
-    g_object_set( p->text_renderer, "text", name, "scale", 1.0, FOREGROUND_COLOR_KEY, &text_color, "ellipsize", PANGO_ELLIPSIZE_END, "weight", PANGO_WEIGHT_BOLD, NULL );
-    gtr_cell_renderer_render( p->text_renderer, window, widget, &name_area, flags );
-    g_object_set( p->text_renderer, "text", gstr_prog->str, "scale", SMALL_SCALE, "weight", PANGO_WEIGHT_NORMAL, NULL );
-    gtr_cell_renderer_render( p->text_renderer, window, widget, &prog_area, flags );
-    g_object_set( p->progress_renderer, "value", (int)(percentDone*100.0), "text", "", "sensitive", sensitive, NULL );
-    gtr_cell_renderer_render( p->progress_renderer, window, widget, &prct_area, flags );
-    g_object_set( p->text_renderer, "text", gstr_stat->str, FOREGROUND_COLOR_KEY, &text_color, NULL );
-    gtr_cell_renderer_render( p->text_renderer, window, widget, &stat_area, flags );
+    g_object_set (p->icon_renderer, "pixbuf", icon, "sensitive", sensitive, NULL);
+    gtr_cell_renderer_render (p->icon_renderer, window, widget, &icon_area, flags);
+    g_object_set (p->text_renderer, "text", name, "scale", 1.0, FOREGROUND_COLOR_KEY, &text_color, "ellipsize", PANGO_ELLIPSIZE_END, "weight", PANGO_WEIGHT_BOLD, NULL);
+    gtr_cell_renderer_render (p->text_renderer, window, widget, &name_area, flags);
+    g_object_set (p->text_renderer, "text", gstr_prog->str, "scale", SMALL_SCALE, "weight", PANGO_WEIGHT_NORMAL, NULL);
+    gtr_cell_renderer_render (p->text_renderer, window, widget, &prog_area, flags);
+    g_object_set (p->progress_renderer, "value", (int)(percentDone*100.0), "text", "", "sensitive", sensitive, NULL);
+    gtr_cell_renderer_render (p->progress_renderer, window, widget, &prct_area, flags);
+    g_object_set (p->text_renderer, "text", gstr_stat->str, FOREGROUND_COLOR_KEY, &text_color, NULL);
+    gtr_cell_renderer_render (p->text_renderer, window, widget, &stat_area, flags);
 
     /* cleanup */
-    g_object_unref( icon );
+    g_object_unref (icon);
 }
 
 static void
-torrent_cell_renderer_render( GtkCellRenderer       * cell,
+torrent_cell_renderer_render (GtkCellRenderer       * cell,
                               GtrDrawable           * window,
                               GtkWidget             * widget,
                               const GdkRectangle    * background_area,
                               const GdkRectangle    * cell_area,
-                              GtkCellRendererState    flags )
+                              GtkCellRendererState    flags)
 {
-    TorrentCellRenderer * self = TORRENT_CELL_RENDERER( cell );
+    TorrentCellRenderer * self = TORRENT_CELL_RENDERER (cell);
 
 #ifdef TEST_RTL
-    GtkTextDirection      real_dir = gtk_widget_get_direction( widget );
-    gtk_widget_set_direction( widget, GTK_TEXT_DIR_RTL );
+    GtkTextDirection      real_dir = gtk_widget_get_direction (widget);
+    gtk_widget_set_direction (widget, GTK_TEXT_DIR_RTL);
 #endif
 
-    if( self && self->priv->tor )
+    if (self && self->priv->tor)
     {
         struct TorrentCellRendererPrivate * p = self->priv;
-        if( p->compact )
-            render_compact( self, window, widget, background_area, cell_area, flags );
+        if (p->compact)
+            render_compact (self, window, widget, background_area, cell_area, flags);
         else
-            render_full( self, window, widget, background_area, cell_area, flags );
+            render_full (self, window, widget, background_area, cell_area, flags);
     }
 
 #ifdef TEST_RTL
-    gtk_widget_set_direction( widget, real_dir );
+    gtk_widget_set_direction (widget, real_dir);
 #endif
 }
 
 static void
-torrent_cell_renderer_set_property( GObject      * object,
+torrent_cell_renderer_set_property (GObject      * object,
                                     guint          property_id,
                                     const GValue * v,
-                                    GParamSpec   * pspec )
+                                    GParamSpec   * pspec)
 {
-    TorrentCellRenderer * self = TORRENT_CELL_RENDERER( object );
+    TorrentCellRenderer * self = TORRENT_CELL_RENDERER (object);
     struct TorrentCellRendererPrivate * p = self->priv;
 
-    switch( property_id )
+    switch (property_id)
     {
-        case P_TORRENT:        p->tor                 = g_value_get_pointer( v ); break;
-        case P_UPLOAD_SPEED:   p->upload_speed_KBps   = g_value_get_double( v ); break;
-        case P_DOWNLOAD_SPEED: p->download_speed_KBps = g_value_get_double( v ); break;
-        case P_BAR_HEIGHT:     p->bar_height          = g_value_get_int( v ); break;
-        case P_COMPACT:        p->compact             = g_value_get_boolean( v ); break;
-        default: G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec ); break;
+        case P_TORRENT:        p->tor                 = g_value_get_pointer (v); break;
+        case P_UPLOAD_SPEED:   p->upload_speed_KBps   = g_value_get_double (v); break;
+        case P_DOWNLOAD_SPEED: p->download_speed_KBps = g_value_get_double (v); break;
+        case P_BAR_HEIGHT:     p->bar_height          = g_value_get_int (v); break;
+        case P_COMPACT:        p->compact             = g_value_get_boolean (v); break;
+        default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break;
     }
 }
 
 static void
-torrent_cell_renderer_get_property( GObject     * object,
+torrent_cell_renderer_get_property (GObject     * object,
                                     guint         property_id,
                                     GValue      * v,
-                                    GParamSpec  * pspec )
+                                    GParamSpec  * pspec)
 {
-    const TorrentCellRenderer * self = TORRENT_CELL_RENDERER( object );
+    const TorrentCellRenderer * self = TORRENT_CELL_RENDERER (object);
     struct TorrentCellRendererPrivate * p = self->priv;
 
-    switch( property_id )
+    switch (property_id)
     {
-        case P_TORRENT:        g_value_set_pointer( v, p->tor ); break;
-        case P_UPLOAD_SPEED:   g_value_set_double( v, p->upload_speed_KBps ); break;
-        case P_DOWNLOAD_SPEED: g_value_set_double( v, p->download_speed_KBps ); break;
-        case P_BAR_HEIGHT:     g_value_set_int( v, p->bar_height ); break;
-        case P_COMPACT:        g_value_set_boolean( v, p->compact ); break;
-        default: G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec ); break;
+        case P_TORRENT:        g_value_set_pointer (v, p->tor); break;
+        case P_UPLOAD_SPEED:   g_value_set_double (v, p->upload_speed_KBps); break;
+        case P_DOWNLOAD_SPEED: g_value_set_double (v, p->download_speed_KBps); break;
+        case P_BAR_HEIGHT:     g_value_set_int (v, p->bar_height); break;
+        case P_COMPACT:        g_value_set_boolean (v, p->compact); break;
+        default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break;
     }
 }
 
 G_DEFINE_TYPE (TorrentCellRenderer, torrent_cell_renderer, GTK_TYPE_CELL_RENDERER)
 
 static void
-torrent_cell_renderer_dispose( GObject * o )
+torrent_cell_renderer_dispose (GObject * o)
 {
-    TorrentCellRenderer * r = TORRENT_CELL_RENDERER( o );
+    TorrentCellRenderer * r = TORRENT_CELL_RENDERER (o);
 
-    if( r && r->priv )
+    if (r && r->priv)
     {
-        g_string_free( r->priv->gstr1, TRUE );
-        g_string_free( r->priv->gstr2, TRUE );
-        g_object_unref( G_OBJECT( r->priv->text_renderer ) );
-        g_object_unref( G_OBJECT( r->priv->progress_renderer ) );
-        g_object_unref( G_OBJECT( r->priv->icon_renderer ) );
+        g_string_free (r->priv->gstr1, TRUE);
+        g_string_free (r->priv->gstr2, TRUE);
+        g_object_unref (G_OBJECT (r->priv->text_renderer));
+        g_object_unref (G_OBJECT (r->priv->progress_renderer));
+        g_object_unref (G_OBJECT (r->priv->icon_renderer));
         r->priv = NULL;
     }
 
-    G_OBJECT_CLASS( torrent_cell_renderer_parent_class )->dispose( o );
+    G_OBJECT_CLASS (torrent_cell_renderer_parent_class)->dispose (o);
 }
 
 static void
-torrent_cell_renderer_class_init( TorrentCellRendererClass * klass )
+torrent_cell_renderer_class_init (TorrentCellRendererClass * klass)
 {
-    GObjectClass *         gobject_class = G_OBJECT_CLASS( klass );
-    GtkCellRendererClass * cell_class = GTK_CELL_RENDERER_CLASS( klass );
+    GObjectClass *         gobject_class = G_OBJECT_CLASS (klass);
+    GtkCellRendererClass * cell_class = GTK_CELL_RENDERER_CLASS (klass);
 
-    g_type_class_add_private( klass,
-                             sizeof( struct TorrentCellRendererPrivate ) );
+    g_type_class_add_private (klass,
+                             sizeof (struct TorrentCellRendererPrivate));
 
     cell_class->render = torrent_cell_renderer_render;
     cell_class->get_size = torrent_cell_renderer_get_size;
@@ -859,67 +859,67 @@ torrent_cell_renderer_class_init( TorrentCellRendererClass * klass )
     gobject_class->get_property = torrent_cell_renderer_get_property;
     gobject_class->dispose = torrent_cell_renderer_dispose;
 
-    g_object_class_install_property( gobject_class, P_TORRENT,
-                                    g_param_spec_pointer( "torrent", NULL,
+    g_object_class_install_property (gobject_class, P_TORRENT,
+                                    g_param_spec_pointer ("torrent", NULL,
                                                           "tr_torrent*",
-                                                          G_PARAM_READWRITE ) );
+                                                          G_PARAM_READWRITE));
 
-    g_object_class_install_property( gobject_class, P_UPLOAD_SPEED,
-                                    g_param_spec_double( "piece-upload-speed", NULL,
+    g_object_class_install_property (gobject_class, P_UPLOAD_SPEED,
+                                    g_param_spec_double ("piece-upload-speed", NULL,
                                                          "tr_stat.pieceUploadSpeed_KBps",
                                                          0, INT_MAX, 0,
-                                                         G_PARAM_READWRITE ) );
+                                                         G_PARAM_READWRITE));
 
-    g_object_class_install_property( gobject_class, P_DOWNLOAD_SPEED,
-                                    g_param_spec_double( "piece-download-speed", NULL,
+    g_object_class_install_property (gobject_class, P_DOWNLOAD_SPEED,
+                                    g_param_spec_double ("piece-download-speed", NULL,
                                                          "tr_stat.pieceDownloadSpeed_KBps",
                                                          0, INT_MAX, 0,
-                                                         G_PARAM_READWRITE ) );
+                                                         G_PARAM_READWRITE));
 
-    g_object_class_install_property( gobject_class, P_BAR_HEIGHT,
-                                    g_param_spec_int( "bar-height", NULL,
+    g_object_class_install_property (gobject_class, P_BAR_HEIGHT,
+                                    g_param_spec_int ("bar-height", NULL,
                                                       "Bar Height",
                                                       1, INT_MAX,
                                                       DEFAULT_BAR_HEIGHT,
-                                                      G_PARAM_READWRITE ) );
+                                                      G_PARAM_READWRITE));
 
-    g_object_class_install_property( gobject_class, P_COMPACT,
-                                    g_param_spec_boolean( "compact", NULL,
+    g_object_class_install_property (gobject_class, P_COMPACT,
+                                    g_param_spec_boolean ("compact", NULL,
                                                           "Compact Mode",
                                                           FALSE,
-                                                          G_PARAM_READWRITE ) );
+                                                          G_PARAM_READWRITE));
 }
 
 static void
-torrent_cell_renderer_init( TorrentCellRenderer * self )
+torrent_cell_renderer_init (TorrentCellRenderer * self)
 {
     struct TorrentCellRendererPrivate * p;
 
-    p = self->priv = G_TYPE_INSTANCE_GET_PRIVATE(
+    p = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (
             self,
             TORRENT_CELL_RENDERER_TYPE,
             struct
-            TorrentCellRendererPrivate );
+            TorrentCellRendererPrivate);
 
     p->tor = NULL;
-    p->gstr1 = g_string_new( NULL );
-    p->gstr2 = g_string_new( NULL );
-    p->text_renderer = gtk_cell_renderer_text_new( );
-    g_object_set( p->text_renderer, "xpad", 0, "ypad", 0, NULL );
-    p->progress_renderer = gtk_cell_renderer_progress_new(  );
-    p->icon_renderer = gtk_cell_renderer_pixbuf_new(  );
-    g_object_ref_sink( p->text_renderer );
-    g_object_ref_sink( p->progress_renderer );
-    g_object_ref_sink( p->icon_renderer );
+    p->gstr1 = g_string_new (NULL);
+    p->gstr2 = g_string_new (NULL);
+    p->text_renderer = gtk_cell_renderer_text_new ();
+    g_object_set (p->text_renderer, "xpad", 0, "ypad", 0, NULL);
+    p->progress_renderer = gtk_cell_renderer_progress_new ();
+    p->icon_renderer = gtk_cell_renderer_pixbuf_new ();
+    g_object_ref_sink (p->text_renderer);
+    g_object_ref_sink (p->progress_renderer);
+    g_object_ref_sink (p->icon_renderer);
 
     p->bar_height = DEFAULT_BAR_HEIGHT;
 }
 
 
 GtkCellRenderer *
-torrent_cell_renderer_new( void )
+torrent_cell_renderer_new (void)
 {
-    return (GtkCellRenderer *) g_object_new( TORRENT_CELL_RENDERER_TYPE,
-                                             NULL );
+    return (GtkCellRenderer *) g_object_new (TORRENT_CELL_RENDERER_TYPE,
+                                             NULL);
 }
 
diff --git a/gtk/torrent-cell-renderer.h b/gtk/torrent-cell-renderer.h
index aa557c282..f2599c51d 100644
--- a/gtk/torrent-cell-renderer.h
+++ b/gtk/torrent-cell-renderer.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -15,12 +15,12 @@
 
 #include <gtk/gtk.h>
 
-#define TORRENT_CELL_RENDERER_TYPE ( torrent_cell_renderer_get_type( ) )
+#define TORRENT_CELL_RENDERER_TYPE (torrent_cell_renderer_get_type ())
 
-#define TORRENT_CELL_RENDERER( o ) \
-    ( G_TYPE_CHECK_INSTANCE_CAST( ( o ), \
+#define TORRENT_CELL_RENDERER(o) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((o), \
                                  TORRENT_CELL_RENDERER_TYPE, \
-                                 TorrentCellRenderer ) )
+                                 TorrentCellRenderer))
 
 typedef struct TorrentCellRenderer TorrentCellRenderer;
 
@@ -39,8 +39,8 @@ struct TorrentCellRendererClass
     GtkCellRendererClass parent;
 };
 
-GType torrent_cell_renderer_get_type( void ) G_GNUC_CONST;
+GType torrent_cell_renderer_get_type (void) G_GNUC_CONST;
 
-GtkCellRenderer * torrent_cell_renderer_new( void );
+GtkCellRenderer * torrent_cell_renderer_new (void);
 
 #endif /* GTR_TORRENT_CELL_RENDERER_H */
diff --git a/gtk/tr-core.c b/gtk/tr-core.c
index f30ce95f3..b7fc8c6fd 100644
--- a/gtk/tr-core.c
+++ b/gtk/tr-core.c
@@ -22,7 +22,7 @@
  * DEALINGS IN THE SOFTWARE.
  *****************************************************************************/
 
-#include <math.h> /* pow() */
+#include <math.h> /* pow () */
 #include <string.h> /* strcmp, strlen */
 
 #include <gtk/gtk.h>
@@ -62,163 +62,163 @@ enum
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
-static void core_maybe_inhibit_hibernation( TrCore * core );
+static void core_maybe_inhibit_hibernation (TrCore * core);
 
 struct TrCorePrivate
 {
-    GFileMonitor * monitor;
-    gulong         monitor_tag;
-    GFile        * monitor_dir;
-    GSList       * monitor_files;
-    gulong         monitor_idle_tag;
-
-    gboolean       adding_from_watch_dir;
-    gboolean       inhibit_allowed;
-    gboolean       have_inhibit_cookie;
-    gboolean       dbus_error;
-    guint          inhibit_cookie;
-    gint           busy_count;
-    GtkTreeModel * raw_model;
-    GtkTreeModel * sorted_model;
-    tr_session   * session;
-    GStringChunk * string_chunk;
+  GFileMonitor * monitor;
+  gulong         monitor_tag;
+  GFile        * monitor_dir;
+  GSList       * monitor_files;
+  gulong         monitor_idle_tag;
+
+  gboolean       adding_from_watch_dir;
+  gboolean       inhibit_allowed;
+  gboolean       have_inhibit_cookie;
+  gboolean       dbus_error;
+  guint          inhibit_cookie;
+  gint           busy_count;
+  GtkTreeModel * raw_model;
+  GtkTreeModel * sorted_model;
+  tr_session   * session;
+  GStringChunk * string_chunk;
 };
 
 static int
-core_is_disposed( const TrCore * core )
+core_is_disposed (const TrCore * core)
 {
-    return !core || !core->priv->sorted_model;
+  return !core || !core->priv->sorted_model;
 }
 
 G_DEFINE_TYPE (TrCore, tr_core, G_TYPE_OBJECT)
 
 static void
-core_dispose( GObject * o )
+core_dispose (GObject * o)
 {
-    TrCore * core = TR_CORE( o );
+  TrCore * core = TR_CORE (o);
 
-    if( core->priv->sorted_model != NULL )
+  if (core->priv->sorted_model != NULL)
     {
-        g_object_unref( core->priv->sorted_model );
-        core->priv->sorted_model = NULL;
-        core->priv->raw_model = NULL;
+      g_object_unref (core->priv->sorted_model);
+      core->priv->sorted_model = NULL;
+      core->priv->raw_model = NULL;
     }
 
-    G_OBJECT_CLASS( tr_core_parent_class )->dispose( o );
+  G_OBJECT_CLASS (tr_core_parent_class)->dispose (o);
 }
 
 static void
-core_finalize( GObject * o )
+core_finalize (GObject * o)
 {
-    TrCore * core = TR_CORE( o );
+  TrCore * core = TR_CORE (o);
 
-    g_string_chunk_free( core->priv->string_chunk );
+  g_string_chunk_free (core->priv->string_chunk);
 
-    G_OBJECT_CLASS( tr_core_parent_class )->finalize( o );
+  G_OBJECT_CLASS (tr_core_parent_class)->finalize (o);
 }
 
 static void
-tr_core_class_init( TrCoreClass * core_class )
-{
-    GObjectClass * gobject_class;
-    GType core_type = G_TYPE_FROM_CLASS( core_class );
-
-    g_type_class_add_private( core_class, sizeof( struct TrCorePrivate ) );
-
-    gobject_class = G_OBJECT_CLASS( core_class );
-    gobject_class->dispose = core_dispose;
-    gobject_class->finalize = core_finalize;
-
-    signals[ADD_ERROR_SIGNAL] =
-        g_signal_new( "add-error", core_type,
-                      G_SIGNAL_RUN_LAST,
-                      G_STRUCT_OFFSET(TrCoreClass, add_error),
-                      NULL, NULL,
-                      g_cclosure_marshal_VOID__UINT_POINTER,
-                      G_TYPE_NONE,
-                      2, G_TYPE_UINT, G_TYPE_POINTER );
-
-    signals[ADD_PROMPT_SIGNAL] =
-        g_signal_new( "add-prompt", core_type,
-                      G_SIGNAL_RUN_LAST,
-                      G_STRUCT_OFFSET(TrCoreClass, add_prompt),
-                      NULL, NULL,
-                      g_cclosure_marshal_VOID__POINTER,
-                      G_TYPE_NONE,
-                      1, G_TYPE_POINTER );
-
-    signals[BUSY_SIGNAL] =
-        g_signal_new( "busy", core_type,
-                      G_SIGNAL_RUN_FIRST,
-                      G_STRUCT_OFFSET(TrCoreClass, busy),
-                      NULL, NULL,
-                      g_cclosure_marshal_VOID__BOOLEAN,
-                      G_TYPE_NONE,
-                      1, G_TYPE_BOOLEAN );
-
-    signals[BLOCKLIST_SIGNAL] =
-        g_signal_new( "blocklist-updated", core_type,
-                      G_SIGNAL_RUN_FIRST,
-                      G_STRUCT_OFFSET(TrCoreClass, blocklist_updated),
-                      NULL, NULL,
-                      g_cclosure_marshal_VOID__INT,
-                      G_TYPE_NONE,
-                      1, G_TYPE_INT );
-
-    signals[PORT_SIGNAL] =
-        g_signal_new( "port-tested", core_type,
-                      G_SIGNAL_RUN_LAST,
-                      G_STRUCT_OFFSET(TrCoreClass, port_tested),
-                      NULL, NULL,
-                      g_cclosure_marshal_VOID__BOOLEAN,
-                      G_TYPE_NONE,
-                      1, G_TYPE_BOOLEAN );
-
-    signals[PREFS_SIGNAL] =
-        g_signal_new( "prefs-changed", core_type,
-                      G_SIGNAL_RUN_LAST,
-                      G_STRUCT_OFFSET(TrCoreClass, prefs_changed),
-                      NULL, NULL,
-                      g_cclosure_marshal_VOID__STRING,
-                      G_TYPE_NONE,
-                      1, G_TYPE_STRING );
+tr_core_class_init (TrCoreClass * core_class)
+{
+  GObjectClass * gobject_class;
+  GType core_type = G_TYPE_FROM_CLASS (core_class);
+
+  g_type_class_add_private (core_class, sizeof (struct TrCorePrivate));
+
+  gobject_class = G_OBJECT_CLASS (core_class);
+  gobject_class->dispose = core_dispose;
+  gobject_class->finalize = core_finalize;
+
+  signals[ADD_ERROR_SIGNAL] =
+    g_signal_new ("add-error", core_type,
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (TrCoreClass, add_error),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__UINT_POINTER,
+                  G_TYPE_NONE,
+                  2, G_TYPE_UINT, G_TYPE_POINTER);
+
+  signals[ADD_PROMPT_SIGNAL] =
+    g_signal_new ("add-prompt", core_type,
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (TrCoreClass, add_prompt),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__POINTER,
+                  G_TYPE_NONE,
+                  1, G_TYPE_POINTER);
+
+  signals[BUSY_SIGNAL] =
+    g_signal_new ("busy", core_type,
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (TrCoreClass, busy),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__BOOLEAN,
+                  G_TYPE_NONE,
+                  1, G_TYPE_BOOLEAN);
+
+  signals[BLOCKLIST_SIGNAL] =
+    g_signal_new ("blocklist-updated", core_type,
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (TrCoreClass, blocklist_updated),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__INT,
+                  G_TYPE_NONE,
+                  1, G_TYPE_INT);
+
+  signals[PORT_SIGNAL] =
+    g_signal_new ("port-tested", core_type,
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (TrCoreClass, port_tested),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__BOOLEAN,
+                  G_TYPE_NONE,
+                  1, G_TYPE_BOOLEAN);
+
+  signals[PREFS_SIGNAL] =
+    g_signal_new ("prefs-changed", core_type,
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (TrCoreClass, prefs_changed),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__STRING,
+                  G_TYPE_NONE,
+                  1, G_TYPE_STRING);
 }
 
 static void
-tr_core_init( TrCore * core )
+tr_core_init (TrCore * core)
 {
-    GtkListStore * store;
-    struct TrCorePrivate * p;
+  GtkListStore * store;
+  struct TrCorePrivate * p;
 
-    /* column types for the model used to store torrent information */
-    /* keep this in sync with the enum near the bottom of tr_core.h */
-    GType types[] = { G_TYPE_POINTER,   /* collated name */
-                      G_TYPE_POINTER,   /* tr_torrent* */
-                      G_TYPE_INT,       /* torrent id */
-                      G_TYPE_DOUBLE,    /* tr_stat.pieceUploadSpeed_KBps */
-                      G_TYPE_DOUBLE,    /* tr_stat.pieceDownloadSpeed_KBps */
-                      G_TYPE_DOUBLE,    /* tr_stat.recheckProgress */
-                      G_TYPE_BOOLEAN,   /* filter.c:ACTIVITY_FILTER_ACTIVE */
-                      G_TYPE_INT,       /* tr_stat.activity */
-                      G_TYPE_UCHAR,     /* tr_stat.finished */
-                      G_TYPE_CHAR,      /* tr_priority_t */
-                      G_TYPE_INT,       /* tr_stat.queuePosition */
-                      G_TYPE_UINT,      /* build_torrent_trackers_hash() */
-                      G_TYPE_INT,       /* MC_ERROR */
-                      G_TYPE_INT };     /* MC_ACTIVE_PEER_COUNT */
+  /* column types for the model used to store torrent information */
+  /* keep this in sync with the enum near the bottom of tr_core.h */
+  GType types[] = { G_TYPE_POINTER,   /* collated name */
+                    G_TYPE_POINTER,   /* tr_torrent* */
+                    G_TYPE_INT,       /* torrent id */
+                    G_TYPE_DOUBLE,    /* tr_stat.pieceUploadSpeed_KBps */
+                    G_TYPE_DOUBLE,    /* tr_stat.pieceDownloadSpeed_KBps */
+                    G_TYPE_DOUBLE,    /* tr_stat.recheckProgress */
+                    G_TYPE_BOOLEAN,   /* filter.c:ACTIVITY_FILTER_ACTIVE */
+                    G_TYPE_INT,       /* tr_stat.activity */
+                    G_TYPE_UCHAR,     /* tr_stat.finished */
+                    G_TYPE_CHAR,      /* tr_priority_t */
+                    G_TYPE_INT,       /* tr_stat.queuePosition */
+                    G_TYPE_UINT,      /* build_torrent_trackers_hash () */
+                    G_TYPE_INT,       /* MC_ERROR */
+                    G_TYPE_INT };     /* MC_ACTIVE_PEER_COUNT */
 
-    p = core->priv = G_TYPE_INSTANCE_GET_PRIVATE( core,
-                                                  TR_CORE_TYPE,
-                                                  struct TrCorePrivate );
+  p = core->priv = G_TYPE_INSTANCE_GET_PRIVATE (core,
+                                                TR_CORE_TYPE,
+                                                struct TrCorePrivate);
 
-    /* create the model used to store torrent data */
-    g_assert( G_N_ELEMENTS( types ) == MC_ROW_COUNT );
-    store = gtk_list_store_newv( MC_ROW_COUNT, types );
+  /* create the model used to store torrent data */
+  g_assert (G_N_ELEMENTS (types) == MC_ROW_COUNT);
+  store = gtk_list_store_newv (MC_ROW_COUNT, types);
 
-    p->raw_model = GTK_TREE_MODEL( store );
-    p->sorted_model = gtk_tree_model_sort_new_with_model( p->raw_model );
-    p->string_chunk = g_string_chunk_new( 2048 );
-    g_object_unref( p->raw_model );
+  p->raw_model = GTK_TREE_MODEL (store);
+  p->sorted_model = gtk_tree_model_sort_new_with_model (p->raw_model);
+  p->string_chunk = g_string_chunk_new (2048);
+  g_object_unref (p->raw_model);
 }
 
 
@@ -228,33 +228,33 @@ tr_core_init( TrCore * core )
 ***/
 
 static inline void
-core_emit_blocklist_udpated( TrCore * core, int ruleCount )
+core_emit_blocklist_udpated (TrCore * core, int ruleCount)
 {
-    g_signal_emit( core, signals[BLOCKLIST_SIGNAL], 0, ruleCount );
+  g_signal_emit (core, signals[BLOCKLIST_SIGNAL], 0, ruleCount);
 }
 
 static inline void
-core_emit_port_tested( TrCore * core, gboolean is_open )
+core_emit_port_tested (TrCore * core, gboolean is_open)
 {
-    g_signal_emit( core, signals[PORT_SIGNAL], 0, is_open );
+  g_signal_emit (core, signals[PORT_SIGNAL], 0, is_open);
 }
 
 static inline void
-core_emit_err( TrCore * core, enum tr_core_err type, const char * msg )
+core_emit_err (TrCore * core, enum tr_core_err type, const char * msg)
 {
-    g_signal_emit( core, signals[ADD_ERROR_SIGNAL], 0, type, msg );
+  g_signal_emit (core, signals[ADD_ERROR_SIGNAL], 0, type, msg);
 }
 
 static inline void
-core_emit_busy( TrCore * core, gboolean is_busy )
+core_emit_busy (TrCore * core, gboolean is_busy)
 {
-    g_signal_emit( core, signals[BUSY_SIGNAL], 0, is_busy );
+  g_signal_emit (core, signals[BUSY_SIGNAL], 0, is_busy);
 }
 
 void
-gtr_core_pref_changed( TrCore * core, const char * key )
+gtr_core_pref_changed (TrCore * core, const char * key)
 {
-    g_signal_emit( core, signals[PREFS_SIGNAL], 0, key );
+  g_signal_emit (core, signals[PREFS_SIGNAL], 0, key);
 }
 
 /***
@@ -262,21 +262,21 @@ gtr_core_pref_changed( TrCore * core, const char * key )
 ***/
 
 static GtkTreeModel *
-core_raw_model( TrCore * core )
+core_raw_model (TrCore * core)
 {
-    return core_is_disposed( core ) ? NULL : core->priv->raw_model;
+  return core_is_disposed (core) ? NULL : core->priv->raw_model;
 }
 
 GtkTreeModel *
-gtr_core_model( TrCore * core )
+gtr_core_model (TrCore * core)
 {
-    return core_is_disposed( core ) ? NULL : core->priv->sorted_model;
+  return core_is_disposed (core) ? NULL : core->priv->sorted_model;
 }
 
 tr_session *
-gtr_core_session( TrCore * core )
+gtr_core_session (TrCore * core)
 {
-    return core_is_disposed( core ) ? NULL : core->priv->session;
+  return core_is_disposed (core) ? NULL : core->priv->session;
 }
 
 /***
@@ -284,24 +284,24 @@ gtr_core_session( TrCore * core )
 ***/
 
 static bool
-core_is_busy( TrCore * core )
+core_is_busy (TrCore * core)
 {
-    return core->priv->busy_count > 0;
+  return core->priv->busy_count > 0;
 }
 
 static void
-core_add_to_busy( TrCore * core, int addMe )
+core_add_to_busy (TrCore * core, int addMe)
 {
-    const bool wasBusy = core_is_busy( core );
+  const bool wasBusy = core_is_busy (core);
 
-    core->priv->busy_count += addMe;
+  core->priv->busy_count += addMe;
 
-    if( wasBusy != core_is_busy( core ) )
-        core_emit_busy( core, core_is_busy( core ) );
+  if (wasBusy != core_is_busy (core))
+      core_emit_busy (core, core_is_busy (core));
 }
 
-static void core_inc_busy( TrCore * core ) { core_add_to_busy( core, 1 ); }
-static void core_dec_busy( TrCore * core ) { core_add_to_busy( core, -1 ); }
+static void core_inc_busy (TrCore * core) { core_add_to_busy (core, 1); }
+static void core_dec_busy (TrCore * core) { core_add_to_busy (core, -1); }
 
 /***
 ****
@@ -310,240 +310,332 @@ static void core_dec_busy( TrCore * core ) { core_add_to_busy( core, -1 ); }
 ***/
 
 static gboolean
-is_valid_eta( int t )
+is_valid_eta (int t)
 {
-    return ( t != TR_ETA_NOT_AVAIL ) && ( t != TR_ETA_UNKNOWN );
+  return (t != TR_ETA_NOT_AVAIL) && (t != TR_ETA_UNKNOWN);
 }
 
 static int
-compare_eta( int a, int b )
+compare_eta (int a, int b)
 {
-    const gboolean a_valid = is_valid_eta( a );
-    const gboolean b_valid = is_valid_eta( b );
+  int ret;
 
-    if( !a_valid && !b_valid ) return 0;
-    if( !a_valid ) return -1;
-    if( !b_valid ) return 1;
-    return a < b ? 1 : -1;
+  const gboolean a_valid = is_valid_eta (a);
+  const gboolean b_valid = is_valid_eta (b);
+
+  if (!a_valid && !b_valid)
+    ret = 0;
+  else if (!a_valid)
+    ret = -1;
+  else if (!b_valid)
+    ret = 1;
+  else
+    ret = a < b ? 1 : -1;
+
+  return ret;
 }
 
 static int
-compare_double( double a, double b )
+compare_double (double a, double b)
 {
-    if( a < b ) return -1;
-    if( a > b ) return 1;
-    return 0;
+  int ret;
+
+  if (a < b)
+    ret = -1;
+  else if (a > b)
+    ret = 1;
+  else
+    ret = 0;
+
+  return ret;
 }
 
 static int
-compare_uint64( uint64_t a, uint64_t b )
+compare_uint64 (uint64_t a, uint64_t b)
 {
-    if( a < b ) return -1;
-    if( a > b ) return 1;
-    return 0;
+  int ret;
+
+  if (a < b)
+    ret = -1;
+  else if (a > b)
+    ret = 1;
+  else
+    ret = 0;
+
+  return ret;
 }
 
 static int
-compare_int( int a, int b )
+compare_int (int a, int b)
 {
-    if( a < b ) return -1;
-    if( a > b ) return 1;
-    return 0;
+  int ret;
+
+  if (a < b)
+    ret = -1;
+  else if (a > b)
+    ret = 1;
+  else
+    ret = 0;
+
+  return ret;
 }
 
 static int
-compare_ratio( double a, double b )
+compare_ratio (double a, double b)
 {
-    if( (int)a == TR_RATIO_INF && (int)b == TR_RATIO_INF ) return 0;
-    if( (int)a == TR_RATIO_INF ) return 1;
-    if( (int)b == TR_RATIO_INF ) return -1;
-    return compare_double( a, b );
+  int ret;
+
+  if ((int)a == TR_RATIO_INF && (int)b == TR_RATIO_INF)
+    ret = 0;
+  else if ((int)a == TR_RATIO_INF)
+    ret = 1;
+  else if ((int)b == TR_RATIO_INF)
+    ret = -1;
+  else
+    ret = compare_double (a, b);
+
+  return ret;
 }
 
 static int
-compare_time( time_t a, time_t b )
+compare_time (time_t a, time_t b)
 {
-    if( a < b ) return -1;
-    if( a > b ) return 1;
-    return 0;
+  int ret;
+
+  if (a < b)
+    ret = -1;
+  if (a > b)
+    ret = 1;
+  else
+    ret = 0;
+
+  return ret;
 }
 
 static int
-compare_by_name( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data UNUSED )
+compare_by_name (GtkTreeModel * m,
+                 GtkTreeIter  * a,
+                 GtkTreeIter  * b,
+                 gpointer       user_data UNUSED)
 {
-    const char *ca, *cb;
-    gtk_tree_model_get( m, a, MC_NAME_COLLATED, &ca, -1 );
-    gtk_tree_model_get( m, b, MC_NAME_COLLATED, &cb, -1 );
-    return tr_strcmp0( ca, cb );
+  const char *ca, *cb;
+  gtk_tree_model_get (m, a, MC_NAME_COLLATED, &ca, -1);
+  gtk_tree_model_get (m, b, MC_NAME_COLLATED, &cb, -1);
+  return tr_strcmp0 (ca, cb);
 }
 
 static int
-compare_by_queue( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data UNUSED )
+compare_by_queue (GtkTreeModel * m,
+                  GtkTreeIter  * a,
+                  GtkTreeIter  * b,
+                  gpointer       user_data UNUSED)
 {
-    tr_torrent *ta, *tb;
-    const tr_stat *sa, *sb;
+  tr_torrent *ta, *tb;
+  const tr_stat *sa, *sb;
 
-    gtk_tree_model_get( m, a, MC_TORRENT, &ta, -1 );
-    sa = tr_torrentStatCached( ta );
-    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
-    sb = tr_torrentStatCached( tb );
+  gtk_tree_model_get (m, a, MC_TORRENT, &ta, -1);
+  sa = tr_torrentStatCached (ta);
+  gtk_tree_model_get (m, b, MC_TORRENT, &tb, -1);
+  sb = tr_torrentStatCached (tb);
 
-    return sb->queuePosition - sa->queuePosition;
+  return sb->queuePosition - sa->queuePosition;
 }
 
 static int
-compare_by_ratio( GtkTreeModel* m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data )
+compare_by_ratio (GtkTreeModel* m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data)
 {
-    int ret = 0;
-    tr_torrent *ta, *tb;
-    const tr_stat *sa, *sb;
+  int ret = 0;
+  tr_torrent *ta, *tb;
+  const tr_stat *sa, *sb;
 
-    gtk_tree_model_get( m, a, MC_TORRENT, &ta, -1 );
-    sa = tr_torrentStatCached( ta );
-    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
-    sb = tr_torrentStatCached( tb );
+  gtk_tree_model_get (m, a, MC_TORRENT, &ta, -1);
+  sa = tr_torrentStatCached (ta);
+  gtk_tree_model_get (m, b, MC_TORRENT, &tb, -1);
+  sb = tr_torrentStatCached (tb);
 
-    if( !ret ) ret = compare_ratio( sa->ratio, sb->ratio );
-    if( !ret ) ret = compare_by_queue( m, a, b, user_data );
-    return ret;
+  if (!ret)
+    ret = compare_ratio (sa->ratio, sb->ratio);
+  if (!ret)
+    ret = compare_by_queue (m, a, b, user_data);
+  return ret;
 }
 
 static int
-compare_by_activity( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data )
-{
-    int ret = 0;
-    tr_torrent *ta, *tb;
-    const tr_stat *sa, *sb;
-    double aUp, aDown, bUp, bDown;
-
-    gtk_tree_model_get( m, a, MC_SPEED_UP, &aUp,
-                              MC_SPEED_DOWN, &aDown,
-                              MC_TORRENT, &ta,
-                              -1 );
-    gtk_tree_model_get( m, b, MC_SPEED_UP, &bUp,
-                              MC_SPEED_DOWN, &bDown,
-                              MC_TORRENT, &tb,
-                              -1 );
-    sa = tr_torrentStatCached( ta );
-    sb = tr_torrentStatCached( tb );
-
-    if( !ret ) ret = compare_double( aUp+aDown, bUp+bDown );
-    if( !ret ) ret = compare_uint64( sa->uploadedEver, sb->uploadedEver );
-    if( !ret ) ret = compare_by_queue( m, a, b, user_data );
-    return ret;
+compare_by_activity (GtkTreeModel * m,
+                     GtkTreeIter  * a,
+                     GtkTreeIter  * b,
+                     gpointer       user_data)
+{
+  int ret = 0;
+  tr_torrent *ta, *tb;
+  const tr_stat *sa, *sb;
+  double aUp, aDown, bUp, bDown;
+
+  gtk_tree_model_get (m, a, MC_SPEED_UP, &aUp,
+                            MC_SPEED_DOWN, &aDown,
+                            MC_TORRENT, &ta,
+                            -1);
+  gtk_tree_model_get (m, b, MC_SPEED_UP, &bUp,
+                            MC_SPEED_DOWN, &bDown,
+                            MC_TORRENT, &tb,
+                            -1);
+  sa = tr_torrentStatCached (ta);
+  sb = tr_torrentStatCached (tb);
+
+  if (!ret)
+    ret = compare_double (aUp+aDown, bUp+bDown);
+  if (!ret)
+    ret = compare_uint64 (sa->uploadedEver, sb->uploadedEver);
+  if (!ret)
+    ret = compare_by_queue (m, a, b, user_data);
+
+  return ret;
 }
 
 static int
-compare_by_age( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer u )
+compare_by_age (GtkTreeModel * m,
+                GtkTreeIter  * a,
+                GtkTreeIter  * b,
+                gpointer       u)
 {
-    int ret = 0;
-    tr_torrent *ta, *tb;
+  int ret = 0;
+  tr_torrent *ta, *tb;
 
-    gtk_tree_model_get( m, a, MC_TORRENT, &ta, -1 );
-    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
+  gtk_tree_model_get (m, a, MC_TORRENT, &ta, -1);
+  gtk_tree_model_get (m, b, MC_TORRENT, &tb, -1);
 
-    if( !ret ) ret = compare_time( tr_torrentStatCached( ta )->addedDate,
-                                   tr_torrentStatCached( tb )->addedDate );
-    if( !ret ) ret = compare_by_name( m, a, b, u );
-    return ret;
+  if (!ret)
+    ret = compare_time (tr_torrentStatCached (ta)->addedDate,
+                        tr_torrentStatCached (tb)->addedDate);
+
+  if (!ret)
+    ret = compare_by_name (m, a, b, u);
+
+  return ret;
 }
 
 static int
-compare_by_size( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer u )
+compare_by_size (GtkTreeModel * m,
+                 GtkTreeIter  * a,
+                 GtkTreeIter  * b,
+                 gpointer       u)
 {
-    int ret = 0;
-    tr_torrent *t;
-    const tr_info *ia, *ib;
+  int ret = 0;
+  tr_torrent *t;
+  const tr_info *ia, *ib;
+
+  gtk_tree_model_get (m, a, MC_TORRENT, &t, -1);
+  ia = tr_torrentInfo (t);
+  gtk_tree_model_get (m, b, MC_TORRENT, &t, -1);
+  ib = tr_torrentInfo (t);
 
-    gtk_tree_model_get( m, a, MC_TORRENT, &t, -1 );
-    ia = tr_torrentInfo( t );
-    gtk_tree_model_get( m, b, MC_TORRENT, &t, -1 );
-    ib = tr_torrentInfo( t );
+  if (!ret)
+    ret = compare_uint64 (ia->totalSize, ib->totalSize);
+  if (!ret)
+    ret = compare_by_name (m, a, b, u);
 
-    if( !ret ) ret = compare_uint64( ia->totalSize, ib->totalSize );
-    if( !ret ) ret = compare_by_name( m, a, b, u );
-    return ret;
+  return ret;
 }
 
 static int
-compare_by_progress( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer u )
+compare_by_progress (GtkTreeModel * m,
+                     GtkTreeIter  * a,
+                     GtkTreeIter  * b,
+                     gpointer       u)
 {
-    int ret = 0;
-    tr_torrent * t;
-    const tr_stat *sa, *sb;
+  int ret = 0;
+  tr_torrent * t;
+  const tr_stat *sa, *sb;
 
-    gtk_tree_model_get( m, a, MC_TORRENT, &t, -1 );
-    sa = tr_torrentStatCached( t );
-    gtk_tree_model_get( m, b, MC_TORRENT, &t, -1 );
-    sb = tr_torrentStatCached( t );
+  gtk_tree_model_get (m, a, MC_TORRENT, &t, -1);
+  sa = tr_torrentStatCached (t);
+  gtk_tree_model_get (m, b, MC_TORRENT, &t, -1);
+  sb = tr_torrentStatCached (t);
 
-    if( !ret ) ret = compare_double( sa->percentComplete, sb->percentComplete );
-    if( !ret ) ret = compare_double( sa->seedRatioPercentDone, sb->seedRatioPercentDone );
-    if( !ret ) ret = compare_by_ratio( m, a, b, u );
-    return ret;
+  if (!ret)
+    ret = compare_double (sa->percentComplete, sb->percentComplete);
+  if (!ret)
+    ret = compare_double (sa->seedRatioPercentDone, sb->seedRatioPercentDone);
+  if (!ret)
+    ret = compare_by_ratio (m, a, b, u);
+
+  return ret;
 }
 
 static int
-compare_by_eta( GtkTreeModel * m, GtkTreeIter  * a, GtkTreeIter  * b, gpointer u )
+compare_by_eta (GtkTreeModel * m,
+                GtkTreeIter  * a,
+                GtkTreeIter  * b,
+                gpointer       u)
 {
-    int ret = 0;
-    tr_torrent *ta, *tb;
+  int ret = 0;
+  tr_torrent *ta, *tb;
+
+  gtk_tree_model_get (m, a, MC_TORRENT, &ta, -1);
+  gtk_tree_model_get (m, b, MC_TORRENT, &tb, -1);
 
-    gtk_tree_model_get( m, a, MC_TORRENT, &ta, -1 );
-    gtk_tree_model_get( m, b, MC_TORRENT, &tb, -1 );
+  if (!ret)
+    ret = compare_eta (tr_torrentStatCached (ta)->eta,
+                       tr_torrentStatCached (tb)->eta);
 
-    if( !ret ) ret = compare_eta( tr_torrentStatCached( ta )->eta,
-                                  tr_torrentStatCached( tb )->eta );
-    if( !ret ) ret = compare_by_name( m, a, b, u );
-    return ret;
+  if (!ret)
+    ret = compare_by_name (m, a, b, u);
+
+  return ret;
 }
 
 static int
-compare_by_state( GtkTreeModel * m, GtkTreeIter * a, GtkTreeIter * b, gpointer u )
+compare_by_state (GtkTreeModel * m,
+                  GtkTreeIter  * a,
+                  GtkTreeIter  * b,
+                  gpointer       u)
 {
-    int ret = 0;
-    int sa, sb;
-    tr_torrent *ta, *tb;
+  int ret = 0;
+  int sa, sb;
+  tr_torrent *ta, *tb;
+
+  gtk_tree_model_get (m, a, MC_ACTIVITY, &sa, MC_TORRENT, &ta, -1);
+  gtk_tree_model_get (m, b, MC_ACTIVITY, &sb, MC_TORRENT, &tb, -1);
 
-    gtk_tree_model_get( m, a, MC_ACTIVITY, &sa, MC_TORRENT, &ta, -1 );
-    gtk_tree_model_get( m, b, MC_ACTIVITY, &sb, MC_TORRENT, &tb, -1 );
+  if (!ret)
+    ret = compare_int (sa, sb);
+  if (!ret)
+    ret = compare_by_queue (m, a, b, u);
 
-    if( !ret ) ret = compare_int( sa, sb );
-    if( !ret ) ret = compare_by_queue( m, a, b, u );
-    return ret;
+  return ret;
 }
 
 static void
-core_set_sort_mode( TrCore * core, const char * mode, gboolean is_reversed )
-{
-    const int col = MC_TORRENT;
-    GtkTreeIterCompareFunc sort_func;
-    GtkSortType type = is_reversed ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING;
-    GtkTreeSortable * sortable = GTK_TREE_SORTABLE( gtr_core_model( core ) );
-
-    if( !strcmp( mode, "sort-by-activity" ) )
-        sort_func = compare_by_activity;
-    else if( !strcmp( mode, "sort-by-age" ) )
-        sort_func = compare_by_age;
-    else if( !strcmp( mode, "sort-by-progress" ) )
-        sort_func = compare_by_progress;
-    else if( !strcmp( mode, "sort-by-queue" ) )
-        sort_func = compare_by_queue;
-    else if( !strcmp( mode, "sort-by-time-left" ) )
-        sort_func = compare_by_eta;
-    else if( !strcmp( mode, "sort-by-ratio" ) )
-        sort_func = compare_by_ratio;
-    else if( !strcmp( mode, "sort-by-state" ) )
-        sort_func = compare_by_state;
-    else if( !strcmp( mode, "sort-by-size" ) )
-        sort_func = compare_by_size;
-    else {
-        sort_func = compare_by_name;
-        type = is_reversed ? GTK_SORT_DESCENDING : GTK_SORT_ASCENDING;
-    }
-
-    gtk_tree_sortable_set_sort_func( sortable, col, sort_func, NULL, NULL );
-    gtk_tree_sortable_set_sort_column_id( sortable, col, type );
+core_set_sort_mode (TrCore * core, const char * mode, gboolean is_reversed)
+{
+  const int col = MC_TORRENT;
+  GtkTreeIterCompareFunc sort_func;
+  GtkSortType type = is_reversed ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING;
+  GtkTreeSortable * sortable = GTK_TREE_SORTABLE (gtr_core_model (core));
+
+  if (!strcmp (mode, "sort-by-activity"))
+    sort_func = compare_by_activity;
+  else if (!strcmp (mode, "sort-by-age"))
+    sort_func = compare_by_age;
+  else if (!strcmp (mode, "sort-by-progress"))
+    sort_func = compare_by_progress;
+  else if (!strcmp (mode, "sort-by-queue"))
+    sort_func = compare_by_queue;
+  else if (!strcmp (mode, "sort-by-time-left"))
+    sort_func = compare_by_eta;
+  else if (!strcmp (mode, "sort-by-ratio"))
+    sort_func = compare_by_ratio;
+  else if (!strcmp (mode, "sort-by-state"))
+    sort_func = compare_by_state;
+  else if (!strcmp (mode, "sort-by-size"))
+    sort_func = compare_by_size;
+  else {
+    sort_func = compare_by_name;
+    type = is_reversed ? GTK_SORT_DESCENDING : GTK_SORT_ASCENDING;
+  }
+
+  gtk_tree_sortable_set_sort_func (sortable, col, sort_func, NULL, NULL);
+  gtk_tree_sortable_set_sort_column_id (sortable, col, type);
 }
 
 /***
@@ -553,168 +645,169 @@ core_set_sort_mode( TrCore * core, const char * mode, gboolean is_reversed )
 ***/
 
 static time_t
-get_file_mtime( GFile * file )
+get_file_mtime (GFile * file)
 {
-    time_t mtime;
-    GFileInfo * info = g_file_query_info( file, G_FILE_ATTRIBUTE_TIME_MODIFIED, 0, NULL, NULL );
-    mtime = g_file_info_get_attribute_uint64( info, G_FILE_ATTRIBUTE_TIME_MODIFIED );
-    g_object_unref( G_OBJECT( info ) );
-    return mtime;
+  time_t mtime;
+  GFileInfo * info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED, 0, NULL, NULL);
+  mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
+  g_object_unref (G_OBJECT (info));
+  return mtime;
 }
 
 static void
-rename_torrent_and_unref_file( GFile * file )
+rename_torrent_and_unref_file (GFile * file)
 {
-    GFileInfo * info = g_file_query_info( file, G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME, 0, NULL, NULL );
-    const char * old_name = g_file_info_get_attribute_string( info, G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME );
-    char * new_name = g_strdup_printf( "%s.added", old_name );
-    GFile * new_file = g_file_set_display_name( file, new_name, NULL, NULL );
-    g_object_unref( G_OBJECT( new_file ) );
-    g_free( new_name );
-    g_object_unref( G_OBJECT( info ) );
-    g_object_unref( G_OBJECT( file ) );
+  GFileInfo * info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME, 0, NULL, NULL);
+  const char * old_name = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME);
+  char * new_name = g_strdup_printf ("%s.added", old_name);
+  GFile * new_file = g_file_set_display_name (file, new_name, NULL, NULL);
+  g_object_unref (G_OBJECT (new_file));
+  g_free (new_name);
+  g_object_unref (G_OBJECT (info));
+  g_object_unref (G_OBJECT (file));
 }
 
 static gboolean
-core_watchdir_idle( gpointer gcore )
+core_watchdir_idle (gpointer gcore)
 {
-    GSList * l;
-    GSList * changing = NULL;
-    GSList * unchanging = NULL;
-    TrCore * core = TR_CORE( gcore );
-    const time_t now = tr_time( );
-    struct TrCorePrivate * p = core->priv;
+  GSList * l;
+  GSList * changing = NULL;
+  GSList * unchanging = NULL;
+  TrCore * core = TR_CORE (gcore);
+  const time_t now = tr_time ();
+  struct TrCorePrivate * p = core->priv;
 
-    /* separate the files into two lists: changing and unchanging */
-    for( l=p->monitor_files; l!=NULL; l=l->next )
+  /* separate the files into two lists: changing and unchanging */
+  for (l=p->monitor_files; l!=NULL; l=l->next)
     {
-        GFile * file = l->data;
-        const time_t mtime = get_file_mtime( file );
-        if( mtime + 2 >= now )
-            changing = g_slist_prepend( changing, file );
-        else
-            unchanging = g_slist_prepend( unchanging, file );
+      GFile * file = l->data;
+      const time_t mtime = get_file_mtime (file);
+      if (mtime + 2 >= now)
+        changing = g_slist_prepend (changing, file);
+      else
+        unchanging = g_slist_prepend (unchanging, file);
     }
 
-    /* add the files that have stopped changing */
-    if( unchanging != NULL )
+  /* add the files that have stopped changing */
+  if (unchanging != NULL)
     {
-        const gboolean do_start = gtr_pref_flag_get( TR_PREFS_KEY_START );
-        const gboolean do_prompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
-
-        core->priv->adding_from_watch_dir = TRUE;
-        gtr_core_add_files( core, unchanging, do_start, do_prompt, TRUE );
-        g_slist_foreach( unchanging, (GFunc)rename_torrent_and_unref_file, NULL );
-        g_slist_free( unchanging );
-        core->priv->adding_from_watch_dir = FALSE;
+      const gboolean do_start = gtr_pref_flag_get (TR_PREFS_KEY_START);
+      const gboolean do_prompt = gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT);
+
+      core->priv->adding_from_watch_dir = TRUE;
+      gtr_core_add_files (core, unchanging, do_start, do_prompt, TRUE);
+      g_slist_foreach (unchanging, (GFunc)rename_torrent_and_unref_file, NULL);
+      g_slist_free (unchanging);
+      core->priv->adding_from_watch_dir = FALSE;
     }
 
-    /* keep monitoring the ones that are still changing */
-    g_slist_free( p->monitor_files );
-    p->monitor_files = changing;
-
-    /* if monitor_files is nonempty, keep checking every second */
-    if( core->priv->monitor_files )
-        return TRUE;
-    core->priv->monitor_idle_tag = 0;
-    return FALSE;
+  /* keep monitoring the ones that are still changing */
+  g_slist_free (p->monitor_files);
+  p->monitor_files = changing;
 
+  /* if monitor_files is nonempty, keep checking every second */
+  if (core->priv->monitor_files)
+    return TRUE;
+  core->priv->monitor_idle_tag = 0;
+  return FALSE;
 }
 
 /* If this file is a torrent, add it to our list */
 static void
-core_watchdir_monitor_file( TrCore * core, GFile * file )
+core_watchdir_monitor_file (TrCore * core, GFile * file)
 {
-    char * filename = g_file_get_path( file );
-    const gboolean is_torrent = g_str_has_suffix( filename, ".torrent" );
+  char * filename = g_file_get_path (file);
+  const gboolean is_torrent = g_str_has_suffix (filename, ".torrent");
 
-    if( is_torrent )
+  if (is_torrent)
     {
-        GSList * l;
-        struct TrCorePrivate * p = core->priv;
-
-        /* if we're not already watching this file, start watching it now */
-        for( l=p->monitor_files; l!=NULL; l=l->next )
-            if( g_file_equal( file, l->data ) )
-                break;
-        if( l == NULL ) {
-            g_object_ref( file );
-            p->monitor_files = g_slist_prepend( p->monitor_files, file );
-            if( p->monitor_idle_tag == 0 )
-                p->monitor_idle_tag = gdk_threads_add_timeout_seconds( 1, core_watchdir_idle, core );
+      GSList * l;
+      struct TrCorePrivate * p = core->priv;
+
+      /* if we're not already watching this file, start watching it now */
+      for (l=p->monitor_files; l!=NULL; l=l->next)
+        if (g_file_equal (file, l->data))
+          break;
+
+      if (l == NULL)
+        {
+          g_object_ref (file);
+          p->monitor_files = g_slist_prepend (p->monitor_files, file);
+          if (p->monitor_idle_tag == 0)
+            p->monitor_idle_tag = gdk_threads_add_timeout_seconds (1, core_watchdir_idle, core);
         }
     }
 
-    g_free( filename );
+  g_free (filename);
 }
 
 /* GFileMonitor noticed a file was created */
 static void
-on_file_changed_in_watchdir( GFileMonitor       * monitor UNUSED,
+on_file_changed_in_watchdir (GFileMonitor       * monitor UNUSED,
                              GFile              * file,
                              GFile              * other_type UNUSED,
                              GFileMonitorEvent    event_type,
-                             gpointer             core )
+                             gpointer             core)
 {
-    if( event_type == G_FILE_MONITOR_EVENT_CREATED )
-        core_watchdir_monitor_file( core, file );
+  if (event_type == G_FILE_MONITOR_EVENT_CREATED)
+    core_watchdir_monitor_file (core, file);
 }
 
 /* walk through the pre-existing files in the watchdir */
 static void
-core_watchdir_scan( TrCore * core )
+core_watchdir_scan (TrCore * core)
 {
-    const char * dirname = gtr_pref_string_get( PREF_KEY_DIR_WATCH );
-    GDir * dir = g_dir_open( dirname, 0, NULL );
+  const char * dirname = gtr_pref_string_get (PREF_KEY_DIR_WATCH);
+  GDir * dir = g_dir_open (dirname, 0, NULL);
 
-    if( dir != NULL )
+  if (dir != NULL)
     {
-        const char * name;
-        while(( name = g_dir_read_name( dir )))
+      const char * name;
+      while ((name = g_dir_read_name (dir)))
         {
-            char * filename = g_build_filename( dirname, name, NULL );
-            GFile * file = g_file_new_for_path( filename );
-            core_watchdir_monitor_file( core, file );
-            g_object_unref( file );
-            g_free( filename );
+          char * filename = g_build_filename (dirname, name, NULL);
+          GFile * file = g_file_new_for_path (filename);
+          core_watchdir_monitor_file (core, file);
+          g_object_unref (file);
+          g_free (filename);
         }
 
-        g_dir_close( dir );
+      g_dir_close (dir);
     }
 }
 
 static void
-core_watchdir_update( TrCore * core )
+core_watchdir_update (TrCore * core)
 {
-    const gboolean is_enabled = gtr_pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED );
-    GFile * dir = g_file_new_for_path( gtr_pref_string_get( PREF_KEY_DIR_WATCH ) );
-    struct TrCorePrivate * p = core->priv;
+  const gboolean is_enabled = gtr_pref_flag_get (PREF_KEY_DIR_WATCH_ENABLED);
+  GFile * dir = g_file_new_for_path (gtr_pref_string_get (PREF_KEY_DIR_WATCH));
+  struct TrCorePrivate * p = core->priv;
 
-    if( p->monitor && ( !is_enabled || !g_file_equal( dir, p->monitor_dir ) ) )
+  if (p->monitor && (!is_enabled || !g_file_equal (dir, p->monitor_dir)))
     {
-        g_signal_handler_disconnect( p->monitor, p->monitor_tag );
-        g_file_monitor_cancel( p->monitor );
-        g_object_unref( p->monitor );
-        g_object_unref( p->monitor_dir );
-
-        p->monitor_dir = NULL;
-        p->monitor = NULL;
-        p->monitor_tag = 0;
+      g_signal_handler_disconnect (p->monitor, p->monitor_tag);
+      g_file_monitor_cancel (p->monitor);
+      g_object_unref (p->monitor);
+      g_object_unref (p->monitor_dir);
+
+      p->monitor_dir = NULL;
+      p->monitor = NULL;
+      p->monitor_tag = 0;
     }
 
-    if( is_enabled && !p->monitor )
+    if (is_enabled && !p->monitor)
     {
-        GFileMonitor * m = g_file_monitor_directory( dir, 0, NULL, NULL );
-        core_watchdir_scan( core );
-
-        g_object_ref( dir );
-        p->monitor = m;
-        p->monitor_dir = dir;
-        p->monitor_tag = g_signal_connect( m, "changed",
-                                           G_CALLBACK( on_file_changed_in_watchdir ), core );
+      GFileMonitor * m = g_file_monitor_directory (dir, 0, NULL, NULL);
+      core_watchdir_scan (core);
+
+      g_object_ref (dir);
+      p->monitor = m;
+      p->monitor_dir = dir;
+      p->monitor_tag = g_signal_connect (m, "changed",
+                                         G_CALLBACK (on_file_changed_in_watchdir), core);
     }
 
-    g_object_unref( dir );
+  g_object_unref (dir);
 }
 
 /***
@@ -722,33 +815,33 @@ core_watchdir_update( TrCore * core )
 ***/
 
 static void
-on_pref_changed( TrCore * core, const char * key, gpointer data UNUSED )
+on_pref_changed (TrCore * core, const char * key, gpointer data UNUSED)
 {
-    if( !strcmp( key, PREF_KEY_SORT_MODE )
-      || !strcmp( key, PREF_KEY_SORT_REVERSED ) )
+  if (!strcmp (key, PREF_KEY_SORT_MODE) ||
+      !strcmp (key, PREF_KEY_SORT_REVERSED))
     {
-        const char * mode = gtr_pref_string_get( PREF_KEY_SORT_MODE );
-        gboolean is_reversed = gtr_pref_flag_get( PREF_KEY_SORT_REVERSED );
-        core_set_sort_mode( core, mode, is_reversed );
+      const char * mode = gtr_pref_string_get (PREF_KEY_SORT_MODE);
+      gboolean is_reversed = gtr_pref_flag_get (PREF_KEY_SORT_REVERSED);
+      core_set_sort_mode (core, mode, is_reversed);
     }
-    else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_GLOBAL ) )
+  else if (!strcmp (key, TR_PREFS_KEY_PEER_LIMIT_GLOBAL))
     {
-        tr_sessionSetPeerLimit( gtr_core_session( core ),
-                                gtr_pref_int_get( key ) );
+      tr_sessionSetPeerLimit (gtr_core_session (core),
+                              gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, TR_PREFS_KEY_PEER_LIMIT_TORRENT ) )
+  else if (!strcmp (key, TR_PREFS_KEY_PEER_LIMIT_TORRENT))
     {
-        tr_sessionSetPeerLimitPerTorrent( gtr_core_session( core ),
-                                          gtr_pref_int_get( key ) );
+      tr_sessionSetPeerLimitPerTorrent (gtr_core_session (core),
+                                        gtr_pref_int_get (key));
     }
-    else if( !strcmp( key, PREF_KEY_INHIBIT_HIBERNATION ) )
+  else if (!strcmp (key, PREF_KEY_INHIBIT_HIBERNATION))
     {
-        core_maybe_inhibit_hibernation( core );
+      core_maybe_inhibit_hibernation (core);
     }
-    else if( !strcmp( key, PREF_KEY_DIR_WATCH )
-           || !strcmp( key, PREF_KEY_DIR_WATCH_ENABLED ) )
+  else if (!strcmp (key, PREF_KEY_DIR_WATCH)
+        || !strcmp (key, PREF_KEY_DIR_WATCH_ENABLED))
     {
-        core_watchdir_update( core );
+      core_watchdir_update (core);
     }
 }
 
@@ -757,33 +850,33 @@ on_pref_changed( TrCore * core, const char * key, gpointer data UNUSED )
 **/
 
 TrCore *
-gtr_core_new( tr_session * session )
+gtr_core_new (tr_session * session)
 {
-    TrCore * core = TR_CORE( g_object_new( TR_CORE_TYPE, NULL ) );
+  TrCore * core = TR_CORE (g_object_new (TR_CORE_TYPE, NULL));
 
-    core->priv->session = session;
+  core->priv->session = session;
 
-    /* init from prefs & listen to pref changes */
-    on_pref_changed( core, PREF_KEY_SORT_MODE, NULL );
-    on_pref_changed( core, PREF_KEY_SORT_REVERSED, NULL );
-    on_pref_changed( core, PREF_KEY_DIR_WATCH_ENABLED, NULL );
-    on_pref_changed( core, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, NULL );
-    on_pref_changed( core, PREF_KEY_INHIBIT_HIBERNATION, NULL );
-    g_signal_connect( core, "prefs-changed", G_CALLBACK( on_pref_changed ), NULL );
+  /* init from prefs & listen to pref changes */
+  on_pref_changed (core, PREF_KEY_SORT_MODE, NULL);
+  on_pref_changed (core, PREF_KEY_SORT_REVERSED, NULL);
+  on_pref_changed (core, PREF_KEY_DIR_WATCH_ENABLED, NULL);
+  on_pref_changed (core, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, NULL);
+  on_pref_changed (core, PREF_KEY_INHIBIT_HIBERNATION, NULL);
+  g_signal_connect (core, "prefs-changed", G_CALLBACK (on_pref_changed), NULL);
 
-    return core;
+  return core;
 }
 
 void
-gtr_core_close( TrCore * core )
+gtr_core_close (TrCore * core)
 {
-    tr_session * session = gtr_core_session( core );
+  tr_session * session = gtr_core_session (core);
 
-    if( session )
+  if (session)
     {
-        core->priv->session = NULL;
-        gtr_pref_save( session );
-        tr_sessionClose( session );
+      core->priv->session = NULL;
+      gtr_pref_save (session);
+      tr_sessionClose (session);
     }
 }
 
@@ -793,35 +886,35 @@ gtr_core_close( TrCore * core )
 
 struct notify_callback_data
 {
-    TrCore * core;
-    int torrent_id;
+  TrCore * core;
+  int torrent_id;
 };
 
 static gboolean
-on_torrent_completeness_changed_idle( gpointer gdata )
+on_torrent_completeness_changed_idle (gpointer gdata)
 {
-    struct notify_callback_data * data = gdata;
-    gtr_notify_torrent_completed( data->core, data->torrent_id );
-    g_object_unref( G_OBJECT( data->core ) );
-    g_free( data );
-    return FALSE;
+  struct notify_callback_data * data = gdata;
+  gtr_notify_torrent_completed (data->core, data->torrent_id);
+  g_object_unref (G_OBJECT (data->core));
+  g_free (data);
+  return FALSE;
 }
 
 /* this is called in the libtransmission thread, *NOT* the GTK+ thread,
    so delegate to the GTK+ thread before calling notify's dbus code... */
 static void
-on_torrent_completeness_changed( tr_torrent       * tor,
+on_torrent_completeness_changed (tr_torrent       * tor,
                                  tr_completeness    completeness,
                                  bool               was_running,
-                                 void             * gcore )
+                                 void             * gcore)
 {
-    if( was_running && ( completeness != TR_LEECH ) && ( tr_torrentStat( tor )->sizeWhenDone != 0 ) )
+  if (was_running && (completeness != TR_LEECH) && (tr_torrentStat (tor)->sizeWhenDone != 0))
     {
-        struct notify_callback_data * data = g_new( struct notify_callback_data, 1 );
-        data->core = gcore;
-        data->torrent_id = tr_torrentId( tor );
-        g_object_ref( G_OBJECT( data->core ) );
-        gdk_threads_add_idle( on_torrent_completeness_changed_idle, data );
+      struct notify_callback_data * data = g_new (struct notify_callback_data, 1);
+      data->core = gcore;
+      data->torrent_id = tr_torrentId (tor);
+      g_object_ref (G_OBJECT (data->core));
+      gdk_threads_add_idle (on_torrent_completeness_changed_idle, data);
     }
 }
 
@@ -830,77 +923,79 @@ on_torrent_completeness_changed( tr_torrent       * tor,
 ***/
 
 static const char*
-get_collated_name( TrCore * core, const tr_torrent * tor )
+get_collated_name (TrCore * core, const tr_torrent * tor)
 {
-    char buf[2048];
-    const char * name = tr_torrentName( tor );
-    char * down = g_utf8_strdown( name ? name : "", -1 );
-    const tr_info * inf = tr_torrentInfo( tor );
-    g_snprintf( buf, sizeof( buf ), "%s\t%s", down, inf->hashString );
-    g_free( down );
-    return g_string_chunk_insert_const( core->priv->string_chunk, buf );
+  char buf[2048];
+  const char * name = tr_torrentName (tor);
+  char * down = g_utf8_strdown (name ? name : "", -1);
+  const tr_info * inf = tr_torrentInfo (tor);
+  g_snprintf (buf, sizeof (buf), "%s\t%s", down, inf->hashString);
+  g_free (down);
+  return g_string_chunk_insert_const (core->priv->string_chunk, buf);
 }
 
 struct metadata_callback_data
 {
-    TrCore * core;
-    int torrent_id;
+  TrCore * core;
+  int torrent_id;
 };
 
 static gboolean
-find_row_from_torrent_id( GtkTreeModel * model, int id, GtkTreeIter * setme )
+find_row_from_torrent_id (GtkTreeModel * model, int id, GtkTreeIter * setme)
 {
-    GtkTreeIter iter;
-    gboolean match = FALSE;
+  GtkTreeIter iter;
+  gboolean match = FALSE;
 
-    if( gtk_tree_model_iter_children( model, &iter, NULL ) ) do
+  if (gtk_tree_model_iter_children (model, &iter, NULL)) do
     {
-        int row_id;
-        gtk_tree_model_get( model, &iter, MC_TORRENT_ID, &row_id, -1 );
-        match = id == row_id;
+      int row_id;
+      gtk_tree_model_get (model, &iter, MC_TORRENT_ID, &row_id, -1);
+      match = id == row_id;
     }
-    while( !match && gtk_tree_model_iter_next( model, &iter ) );
+  while (!match && gtk_tree_model_iter_next (model, &iter));
 
-    if( match )
-        *setme = iter;
+  if (match)
+    *setme = iter;
 
-    return match;
+  return match;
 }
 
 static gboolean
-on_torrent_metadata_changed_idle( gpointer gdata )
-{
-    struct notify_callback_data * data = gdata;
-    tr_session * session = gtr_core_session( data->core );
-    tr_torrent * tor = tr_torrentFindFromId( session, data->torrent_id );
-
-    /* update the torrent's collated name */
-    if( tor != NULL ) {
-        GtkTreeIter iter;
-        GtkTreeModel * model = core_raw_model( data->core );
-        if( find_row_from_torrent_id( model, data->torrent_id, &iter ) ) {
-            const char * collated = get_collated_name( data->core, tor );
-            GtkListStore * store = GTK_LIST_STORE( model );
-            gtk_list_store_set( store, &iter, MC_NAME_COLLATED, collated, -1 );
+on_torrent_metadata_changed_idle (gpointer gdata)
+{
+  struct notify_callback_data * data = gdata;
+  tr_session * session = gtr_core_session (data->core);
+  tr_torrent * tor = tr_torrentFindFromId (session, data->torrent_id);
+
+  /* update the torrent's collated name */
+  if (tor != NULL)
+    {
+      GtkTreeIter iter;
+      GtkTreeModel * model = core_raw_model (data->core);
+      if (find_row_from_torrent_id (model, data->torrent_id, &iter))
+        {
+          const char * collated = get_collated_name (data->core, tor);
+          GtkListStore * store = GTK_LIST_STORE (model);
+          gtk_list_store_set (store, &iter, MC_NAME_COLLATED, collated, -1);
         }
     }
 
-    /* cleanup */
-    g_object_unref( G_OBJECT( data->core ) );
-    g_free( data );
-    return FALSE;
+  /* cleanup */
+  g_object_unref (G_OBJECT (data->core));
+  g_free (data);
+  return FALSE;
 }
 
 /* this is called in the libtransmission thread, *NOT* the GTK+ thread,
    so delegate to the GTK+ thread before changing our list store... */
 static void
-on_torrent_metadata_changed( tr_torrent * tor, void * gcore )
+on_torrent_metadata_changed (tr_torrent * tor, void * gcore)
 {
-    struct notify_callback_data * data = g_new( struct notify_callback_data, 1 );
-    data->core = gcore;
-    data->torrent_id = tr_torrentId( tor );
-    g_object_ref( G_OBJECT( data->core ) );
-    gdk_threads_add_idle( on_torrent_metadata_changed_idle, data );
+  struct notify_callback_data * data = g_new (struct notify_callback_data, 1);
+  data->core = gcore;
+  data->torrent_id = tr_torrentId (tor);
+  g_object_ref (G_OBJECT (data->core));
+  gdk_threads_add_idle (on_torrent_metadata_changed_idle, data);
 }
 
 /***
@@ -910,87 +1005,87 @@ on_torrent_metadata_changed( tr_torrent * tor, void * gcore )
 ***/
 
 static unsigned int
-build_torrent_trackers_hash( tr_torrent * tor )
+build_torrent_trackers_hash (tr_torrent * tor)
 {
-    int i;
-    const char * pch;
-    uint64_t hash = 0;
-    const tr_info * const inf = tr_torrentInfo( tor );
+  int i;
+  const char * pch;
+  uint64_t hash = 0;
+  const tr_info * const inf = tr_torrentInfo (tor);
 
-    for( i=0; i<inf->trackerCount; ++i )
-        for( pch=inf->trackers[i].announce; *pch; ++pch )
-            hash = (hash<<4) ^ (hash>>28) ^ *pch;
+  for (i=0; i<inf->trackerCount; ++i)
+    for (pch=inf->trackers[i].announce; *pch; ++pch)
+      hash = (hash<<4) ^ (hash>>28) ^ *pch;
 
-    return hash;
+  return hash;
 }
 
 static gboolean
-is_torrent_active( const tr_stat * st )
+is_torrent_active (const tr_stat * st)
 {
-    return ( st->peersSendingToUs > 0 )
-        || ( st->peersGettingFromUs > 0 )
-        || ( st->activity == TR_STATUS_CHECK );
+  return (st->peersSendingToUs > 0)
+      || (st->peersGettingFromUs > 0)
+      || (st->activity == TR_STATUS_CHECK);
 }
 
 void
-gtr_core_add_torrent( TrCore * core, tr_torrent * tor, gboolean do_notify )
+gtr_core_add_torrent (TrCore * core, tr_torrent * tor, gboolean do_notify)
 {
-    if( tor != NULL )
+  if (tor != NULL)
     {
-        GtkTreeIter unused;
-        const tr_stat * st = tr_torrentStat( tor );
-        const char * collated = get_collated_name( core, tor );
-        const unsigned int trackers_hash = build_torrent_trackers_hash( tor );
-        GtkListStore * store = GTK_LIST_STORE( core_raw_model( core ) );
-
-        gtk_list_store_insert_with_values( store, &unused, 0,
-            MC_NAME_COLLATED,     collated,
-            MC_TORRENT,           tor,
-            MC_TORRENT_ID,        tr_torrentId( tor ),
-            MC_SPEED_UP,          st->pieceUploadSpeed_KBps,
-            MC_SPEED_DOWN,        st->pieceDownloadSpeed_KBps,
-            MC_RECHECK_PROGRESS,  st->recheckProgress,
-            MC_ACTIVE,            is_torrent_active( st ),
-            MC_ACTIVITY,          st->activity,
-            MC_FINISHED,          st->finished,
-            MC_PRIORITY,          tr_torrentGetPriority( tor ),
-            MC_QUEUE_POSITION,    st->queuePosition,
-            MC_TRACKERS,          trackers_hash,
-            -1 );
-
-        if( do_notify )
-            gtr_notify_torrent_added( tr_torrentName( tor ) );
-
-        tr_torrentSetMetadataCallback( tor, on_torrent_metadata_changed, core );
-        tr_torrentSetCompletenessCallback( tor, on_torrent_completeness_changed, core );
+      GtkTreeIter unused;
+      const tr_stat * st = tr_torrentStat (tor);
+      const char * collated = get_collated_name (core, tor);
+      const unsigned int trackers_hash = build_torrent_trackers_hash (tor);
+      GtkListStore * store = GTK_LIST_STORE (core_raw_model (core));
+
+      gtk_list_store_insert_with_values (store, &unused, 0,
+        MC_NAME_COLLATED,     collated,
+        MC_TORRENT,           tor,
+        MC_TORRENT_ID,        tr_torrentId (tor),
+        MC_SPEED_UP,          st->pieceUploadSpeed_KBps,
+        MC_SPEED_DOWN,        st->pieceDownloadSpeed_KBps,
+        MC_RECHECK_PROGRESS,  st->recheckProgress,
+        MC_ACTIVE,            is_torrent_active (st),
+        MC_ACTIVITY,          st->activity,
+        MC_FINISHED,          st->finished,
+        MC_PRIORITY,          tr_torrentGetPriority (tor),
+        MC_QUEUE_POSITION,    st->queuePosition,
+        MC_TRACKERS,          trackers_hash,
+        -1);
+
+      if (do_notify)
+        gtr_notify_torrent_added (tr_torrentName (tor));
+
+      tr_torrentSetMetadataCallback (tor, on_torrent_metadata_changed, core);
+      tr_torrentSetCompletenessCallback (tor, on_torrent_completeness_changed, core);
     }
 }
 
 static tr_torrent *
-core_create_new_torrent( TrCore * core, tr_ctor * ctor )
+core_create_new_torrent (TrCore * core, tr_ctor * ctor)
 {
-    int errcode = 0;
-    tr_torrent * tor;
-    bool do_trash = false;
-    tr_session * session = gtr_core_session( core );
+  int errcode = 0;
+  tr_torrent * tor;
+  bool do_trash = false;
+  tr_session * session = gtr_core_session (core);
 
-    /* let the gtk client handle the removal, since libT
-     * doesn't have any concept of the glib trash API */
-    tr_ctorGetDeleteSource( ctor, &do_trash );
-    tr_ctorSetDeleteSource( ctor, FALSE );
-    tor = tr_torrentNew( ctor, &errcode );
+  /* let the gtk client handle the removal, since libT
+   * doesn't have any concept of the glib trash API */
+  tr_ctorGetDeleteSource (ctor, &do_trash);
+  tr_ctorSetDeleteSource (ctor, FALSE);
+  tor = tr_torrentNew (ctor, &errcode);
 
-    if( tor && do_trash )
+  if (tor && do_trash)
     {
-        const char * config = tr_sessionGetConfigDir( session );
-        const char * source = tr_ctorGetSourceFile( ctor );
+      const char * config = tr_sessionGetConfigDir (session);
+      const char * source = tr_ctorGetSourceFile (ctor);
 
-        if( source != NULL )
+      if (source != NULL)
         {
           /* #1294: don't delete the .torrent file if it's our internal copy */
-          const int is_internal = ( strstr( source, config ) == source );
-          if( !is_internal )
-              gtr_file_trash_or_remove( source );
+          const int is_internal = (strstr (source, config) == source);
+          if (!is_internal)
+              gtr_file_trash_or_remove (source);
         }
     }
 
@@ -998,67 +1093,67 @@ core_create_new_torrent( TrCore * core, tr_ctor * ctor )
 }
 
 static int
-core_add_ctor( TrCore * core, tr_ctor * ctor,
-               gboolean do_prompt, gboolean do_notify )
+core_add_ctor (TrCore * core, tr_ctor * ctor,
+               gboolean do_prompt, gboolean do_notify)
 {
-    tr_info inf;
-    int err = tr_torrentParse( ctor, &inf );
+  tr_info inf;
+  int err = tr_torrentParse (ctor, &inf);
 
-    switch( err )
+  switch (err)
     {
-        case TR_PARSE_ERR:
-            break;
-
-        case TR_PARSE_DUPLICATE:
-            /* don't complain about .torrent files in the watch directory
-             * that have already been added... that gets annoying and we
-             * don't want to be nagging users to clean up their watch dirs */
-            if( !tr_ctorGetSourceFile(ctor) || !core->priv->adding_from_watch_dir )
-                core_emit_err( core, err, inf.name );
-            tr_metainfoFree( &inf );
-            tr_ctorFree( ctor );
-            break;
-
-        default:
-            if( do_prompt )
-                g_signal_emit( core, signals[ADD_PROMPT_SIGNAL], 0, ctor );
-            else {
-                gtr_core_add_torrent( core, core_create_new_torrent( core, ctor ), do_notify );
-                tr_ctorFree( ctor );
-            }
-            tr_metainfoFree( &inf );
-            break;
+      case TR_PARSE_ERR:
+        break;
+
+      case TR_PARSE_DUPLICATE:
+        /* don't complain about .torrent files in the watch directory
+         * that have already been added... that gets annoying and we
+         * don't want to be nagging users to clean up their watch dirs */
+        if (!tr_ctorGetSourceFile (ctor) || !core->priv->adding_from_watch_dir)
+          core_emit_err (core, err, inf.name);
+        tr_metainfoFree (&inf);
+        tr_ctorFree (ctor);
+        break;
+
+      default:
+        if (do_prompt)
+          {
+            g_signal_emit (core, signals[ADD_PROMPT_SIGNAL], 0, ctor);
+          }
+        else
+          {
+            gtr_core_add_torrent (core, core_create_new_torrent (core, ctor), do_notify);
+            tr_ctorFree (ctor);
+          }
+        tr_metainfoFree (&inf);
+        break;
     }
 
-    return err;
+  return err;
 }
 
 static void
-core_apply_defaults( tr_ctor * ctor )
+core_apply_defaults (tr_ctor * ctor)
 {
-    if( tr_ctorGetPaused( ctor, TR_FORCE, NULL ) )
-        tr_ctorSetPaused( ctor, TR_FORCE, !gtr_pref_flag_get( TR_PREFS_KEY_START ) );
+  if (tr_ctorGetPaused (ctor, TR_FORCE, NULL))
+    tr_ctorSetPaused (ctor, TR_FORCE, !gtr_pref_flag_get (TR_PREFS_KEY_START));
 
-    if( tr_ctorGetDeleteSource( ctor, NULL ) )
-        tr_ctorSetDeleteSource( ctor,
-                               gtr_pref_flag_get( TR_PREFS_KEY_TRASH_ORIGINAL ) );
+  if (tr_ctorGetDeleteSource (ctor, NULL))
+    tr_ctorSetDeleteSource (ctor, gtr_pref_flag_get (TR_PREFS_KEY_TRASH_ORIGINAL));
 
-    if( tr_ctorGetPeerLimit( ctor, TR_FORCE, NULL ) )
-        tr_ctorSetPeerLimit( ctor, TR_FORCE,
-                             gtr_pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
+  if (tr_ctorGetPeerLimit (ctor, TR_FORCE, NULL))
+    tr_ctorSetPeerLimit (ctor, TR_FORCE, gtr_pref_int_get (TR_PREFS_KEY_PEER_LIMIT_TORRENT));
 
-    if( tr_ctorGetDownloadDir( ctor, TR_FORCE, NULL ) )
-        tr_ctorSetDownloadDir( ctor, TR_FORCE,
-                               gtr_pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR ) );
+  if (tr_ctorGetDownloadDir (ctor, TR_FORCE, NULL))
+    tr_ctorSetDownloadDir (ctor, TR_FORCE, gtr_pref_string_get (TR_PREFS_KEY_DOWNLOAD_DIR));
 }
 
 void
-gtr_core_add_ctor( TrCore * core, tr_ctor * ctor )
+gtr_core_add_ctor (TrCore * core, tr_ctor * ctor)
 {
-    const gboolean do_notify = FALSE;
-    const gboolean do_prompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
-    core_apply_defaults( ctor );
-    core_add_ctor( core, ctor, do_prompt, do_notify );
+  const gboolean do_notify = FALSE;
+  const gboolean do_prompt = gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT);
+  core_apply_defaults (ctor);
+  core_add_ctor (core, ctor, do_prompt, do_notify);
 }
 
 /***
@@ -1067,203 +1162,207 @@ gtr_core_add_ctor( TrCore * core, tr_ctor * ctor )
 
 struct add_from_url_data
 {
-    TrCore * core;
-    tr_ctor * ctor;
-    bool do_prompt;
-    bool do_notify;
+  TrCore * core;
+  tr_ctor * ctor;
+  bool do_prompt;
+  bool do_notify;
 };
 
 static void
-add_file_async_callback( GObject * file, GAsyncResult * result, gpointer gdata )
+add_file_async_callback (GObject * file, GAsyncResult * result, gpointer gdata)
 {
-    gsize length;
-    char * contents;
-    GError * error = NULL;
-    struct add_from_url_data * data = gdata;
+  gsize length;
+  char * contents;
+  GError * error = NULL;
+  struct add_from_url_data * data = gdata;
 
-    if( !g_file_load_contents_finish( G_FILE( file ), result, &contents, &length, NULL, &error ) )
+  if (!g_file_load_contents_finish (G_FILE (file), result, &contents, &length, NULL, &error))
     {
-        g_message( _( "Couldn't read \"%s\": %s" ), g_file_get_parse_name( G_FILE( file ) ), error->message );
-        g_error_free( error );
+      g_message (_("Couldn't read \"%s\": %s"), g_file_get_parse_name (G_FILE (file)), error->message);
+      g_error_free (error);
     }
-    else if( !tr_ctorSetMetainfo( data->ctor, (const uint8_t*)contents, length ) )
+  else if (!tr_ctorSetMetainfo (data->ctor, (const uint8_t*)contents, length))
     {
-        core_add_ctor( data->core, data->ctor, data->do_prompt, data->do_notify );
+      core_add_ctor (data->core, data->ctor, data->do_prompt, data->do_notify);
     }
-    else
+  else
     {
-        tr_ctorFree( data->ctor );
+      tr_ctorFree (data->ctor);
     }
 
-    core_dec_busy( data->core );
-    g_free( data );
+  core_dec_busy (data->core);
+  g_free (data);
 }
 
 static bool
-add_file( TrCore      * core,
+add_file (TrCore      * core,
           GFile       * file,
           gboolean      do_start,
           gboolean      do_prompt,
-          gboolean      do_notify )
+          gboolean      do_notify)
 {
-    bool handled = false;
-    tr_session * session = gtr_core_session( core );
+  bool handled = false;
+  tr_session * session = gtr_core_session (core);
 
-    if( session != NULL )
+  if (session != NULL)
     {
-        tr_ctor * ctor;
-        bool tried = false;
-        bool loaded = false;
-
-        ctor = tr_ctorNew( session );
-        core_apply_defaults( ctor );
-        tr_ctorSetPaused( ctor, TR_FORCE, !do_start );
-
-        /* local files... */
-        if( !tried ) {
-            char * str = g_file_get_path( file );
-            if(( tried = g_file_test( str, G_FILE_TEST_EXISTS )))
-               loaded = !tr_ctorSetMetainfoFromFile( ctor, str );
-            g_free( str );
+      tr_ctor * ctor;
+      bool tried = false;
+      bool loaded = false;
+
+      ctor = tr_ctorNew (session);
+      core_apply_defaults (ctor);
+      tr_ctorSetPaused (ctor, TR_FORCE, !do_start);
+
+      /* local files... */
+      if (!tried)
+        {
+          char * str = g_file_get_path (file);
+          if ((tried = g_file_test (str, G_FILE_TEST_EXISTS)))
+             loaded = !tr_ctorSetMetainfoFromFile (ctor, str);
+          g_free (str);
         }
 
-        /* magnet links... */
-        if( !tried && g_file_has_uri_scheme( file, "magnet" ) ) {
-            /* GFile mangles the original string with /// so we have to un-mangle */
-            char * str = g_file_get_parse_name( file );
-            char * magnet = g_strdup_printf( "magnet:%s", strchr( str, '?' ) );
-            tried = true;
-            loaded = !tr_ctorSetMetainfoFromMagnetLink( ctor, magnet );
-            g_free( magnet );
-            g_free( str );
+      /* magnet links... */
+      if (!tried && g_file_has_uri_scheme (file, "magnet"))
+        {
+          /* GFile mangles the original string with /// so we have to un-mangle */
+          char * str = g_file_get_parse_name (file);
+          char * magnet = g_strdup_printf ("magnet:%s", strchr (str, '?'));
+          tried = true;
+          loaded = !tr_ctorSetMetainfoFromMagnetLink (ctor, magnet);
+          g_free (magnet);
+          g_free (str);
         }
 
-        /* hashcodes that we can turn into magnet links... */
-        if( !tried ) {
-            char * str = g_file_get_basename( file );
-            if( gtr_is_hex_hashcode( str ) ) {
-                char * magnet = g_strdup_printf( "magnet:?xt=urn:btih:%s", str );
-                tried = true;
-                loaded = !tr_ctorSetMetainfoFromMagnetLink( ctor, magnet );
-                g_free( magnet );
+      /* hashcodes that we can turn into magnet links... */
+      if (!tried)
+        {
+          char * str = g_file_get_basename (file);
+          if (gtr_is_hex_hashcode (str))
+            {
+              char * magnet = g_strdup_printf ("magnet:?xt=urn:btih:%s", str);
+              tried = true;
+              loaded = !tr_ctorSetMetainfoFromMagnetLink (ctor, magnet);
+              g_free (magnet);
             }
-            g_free( str );
+          g_free (str);
         }
 
-        /* if we were able to load the metainfo, add the torrent */
-        if( loaded )
+      /* if we were able to load the metainfo, add the torrent */
+      if (loaded)
         {
-            handled = true;
-            core_add_ctor( core, ctor, do_prompt, do_notify );
+          handled = true;
+          core_add_ctor (core, ctor, do_prompt, do_notify);
         }
-        else if( g_file_has_uri_scheme( file, "http" ) ||
-                 g_file_has_uri_scheme( file, "https" ) ||
-                 g_file_has_uri_scheme( file, "ftp" ) )
+      else if (g_file_has_uri_scheme (file, "http") ||
+               g_file_has_uri_scheme (file, "https") ||
+               g_file_has_uri_scheme (file, "ftp"))
         {
-            struct add_from_url_data * data;
+          struct add_from_url_data * data;
 
-            data = g_new0( struct add_from_url_data, 1 );
-            data->core = core;
-            data->ctor = ctor;
-            data->do_prompt = do_prompt;
-            data->do_notify = do_notify;
+          data = g_new0 (struct add_from_url_data, 1);
+          data->core = core;
+          data->ctor = ctor;
+          data->do_prompt = do_prompt;
+          data->do_notify = do_notify;
 
-            handled = true;
-            core_inc_busy( core );
-            g_file_load_contents_async( file, NULL, add_file_async_callback, data );
+          handled = true;
+          core_inc_busy (core);
+          g_file_load_contents_async (file, NULL, add_file_async_callback, data);
         }
-        else
+      else
         {
-            tr_ctorFree( ctor );
-            g_message( _( "Skipping unknown torrent \"%s\"" ), g_file_get_parse_name( file ) );
+          tr_ctorFree (ctor);
+          g_message (_("Skipping unknown torrent \"%s\""), g_file_get_parse_name (file));
         }
     }
 
-    return handled;
+  return handled;
 }
 
 bool
-gtr_core_add_from_url( TrCore * core, const char * uri )
+gtr_core_add_from_url (TrCore * core, const char * uri)
 {
-    bool handled;
-    const bool do_start = gtr_pref_flag_get( TR_PREFS_KEY_START );
-    const bool do_prompt = gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT );
-    const bool do_notify = false;
+  bool handled;
+  const bool do_start = gtr_pref_flag_get (TR_PREFS_KEY_START);
+  const bool do_prompt = gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT);
+  const bool do_notify = false;
 
-    GFile * file = g_file_new_for_uri( uri );
-    handled = add_file( core, file, do_start, do_prompt, do_notify );
-    g_object_unref( file );
-    gtr_core_torrents_added( core );
+  GFile * file = g_file_new_for_uri (uri);
+  handled = add_file (core, file, do_start, do_prompt, do_notify);
+  g_object_unref (file);
+  gtr_core_torrents_added (core);
 
-    return handled;
+  return handled;
 }
 
 void
-gtr_core_add_files( TrCore     * core,
+gtr_core_add_files (TrCore     * core,
                     GSList     * files,
                     gboolean     do_start,
                     gboolean     do_prompt,
-                    gboolean     do_notify )
+                    gboolean     do_notify)
 {
-    GSList * l;
+  GSList * l;
 
-    for( l=files; l!=NULL; l=l->next )
-        add_file( core, l->data, do_start, do_prompt, do_notify );
+  for (l=files; l!=NULL; l=l->next)
+    add_file (core, l->data, do_start, do_prompt, do_notify);
 
-    gtr_core_torrents_added( core );
+  gtr_core_torrents_added (core);
 }
 
 void
-gtr_core_torrents_added( TrCore * self )
+gtr_core_torrents_added (TrCore * self)
 {
-    gtr_core_update( self );
-    core_emit_err( self, TR_CORE_ERR_NO_MORE_TORRENTS, NULL );
+  gtr_core_update (self);
+  core_emit_err (self, TR_CORE_ERR_NO_MORE_TORRENTS, NULL);
 }
 
 void
-gtr_core_remove_torrent( TrCore * core, int id, gboolean delete_local_data )
+gtr_core_remove_torrent (TrCore * core, int id, gboolean delete_local_data)
 {
-    tr_torrent * tor = gtr_core_find_torrent( core, id );
+  tr_torrent * tor = gtr_core_find_torrent (core, id);
 
-    if( tor != NULL )
+  if (tor != NULL)
     {
-        /* remove from the gui */
-        GtkTreeIter iter;
-        GtkTreeModel * model = core_raw_model( core );
-        if( find_row_from_torrent_id( model, id, &iter ) )
-            gtk_list_store_remove( GTK_LIST_STORE( model ), &iter );
-
-        /* remove the torrent */
-        tr_torrentRemove( tor, delete_local_data, gtr_file_trash_or_remove );
+      /* remove from the gui */
+      GtkTreeIter iter;
+      GtkTreeModel * model = core_raw_model (core);
+      if (find_row_from_torrent_id (model, id, &iter))
+        gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
+
+      /* remove the torrent */
+      tr_torrentRemove (tor, delete_local_data, gtr_file_trash_or_remove);
     }
 }
 
 void
-gtr_core_load( TrCore * self, gboolean forcePaused )
+gtr_core_load (TrCore * self, gboolean forcePaused)
 {
-    int i;
-    tr_ctor * ctor;
-    tr_torrent ** torrents;
-    int count = 0;
+  int i;
+  tr_ctor * ctor;
+  tr_torrent ** torrents;
+  int count = 0;
 
-    ctor = tr_ctorNew( gtr_core_session( self ) );
-    if( forcePaused )
-        tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
-    tr_ctorSetPeerLimit( ctor, TR_FALLBACK,
-                         gtr_pref_int_get( TR_PREFS_KEY_PEER_LIMIT_TORRENT ) );
+  ctor = tr_ctorNew (gtr_core_session (self));
+  if (forcePaused)
+    tr_ctorSetPaused (ctor, TR_FORCE, TRUE);
+  tr_ctorSetPeerLimit (ctor, TR_FALLBACK,
+                       gtr_pref_int_get (TR_PREFS_KEY_PEER_LIMIT_TORRENT));
 
-    torrents = tr_sessionLoadTorrents ( gtr_core_session( self ), ctor, &count );
-    for( i=0; i<count; ++i )
-        gtr_core_add_torrent( self, torrents[i], FALSE );
+  torrents = tr_sessionLoadTorrents (gtr_core_session (self), ctor, &count);
+  for (i=0; i<count; ++i)
+    gtr_core_add_torrent (self, torrents[i], FALSE);
 
-    tr_free( torrents );
-    tr_ctorFree( ctor );
+  tr_free (torrents);
+  tr_ctorFree (ctor);
 }
 
 void
-gtr_core_clear( TrCore * self )
+gtr_core_clear (TrCore * self)
 {
-    gtk_list_store_clear( GTK_LIST_STORE( core_raw_model( self ) ) );
+  gtk_list_store_clear (GTK_LIST_STORE (core_raw_model (self)));
 }
 
 /***
@@ -1271,106 +1370,113 @@ gtr_core_clear( TrCore * self )
 ***/
 
 static int
-gtr_compare_double( const double a, const double b, int decimal_places )
+gtr_compare_double (const double a, const double b, int decimal_places)
 {
-    const int64_t ia = (int64_t)(a * pow( 10, decimal_places ) );
-    const int64_t ib = (int64_t)(b * pow( 10, decimal_places ) );
-    if( ia < ib ) return -1;
-    if( ia > ib ) return  1;
-    return 0;
+  int ret;
+  const int64_t ia = (int64_t)(a * pow (10, decimal_places));
+  const int64_t ib = (int64_t)(b * pow (10, decimal_places));
+
+  if (ia < ib)
+    ret = -1;
+  else if (ia > ib)
+    ret = 1;
+  else
+    ret = 0;
+
+  return ret;
 }
 
 static void
-update_foreach( GtkTreeModel * model, GtkTreeIter * iter )
-{
-    int oldActivity, newActivity;
-    int oldActivePeerCount, newActivePeerCount;
-    int oldError, newError;
-    bool oldFinished, newFinished;
-    int oldQueuePosition, newQueuePosition;
-    tr_priority_t oldPriority, newPriority;
-    unsigned int oldTrackers, newTrackers;
-    double oldUpSpeed, newUpSpeed;
-    double oldDownSpeed, newDownSpeed;
-    double oldRecheckProgress, newRecheckProgress;
-    gboolean oldActive, newActive;
-    const tr_stat * st;
-    tr_torrent * tor;
-
-    /* get the old states */
-    gtk_tree_model_get( model, iter,
-                        MC_TORRENT,  &tor,
-                        MC_ACTIVE, &oldActive,
-                        MC_ACTIVE_PEER_COUNT, &oldActivePeerCount,
-                        MC_ERROR, &oldError,
-                        MC_ACTIVITY, &oldActivity,
-                        MC_FINISHED, &oldFinished,
-                        MC_PRIORITY, &oldPriority,
-                        MC_QUEUE_POSITION, &oldQueuePosition,
-                        MC_TRACKERS, &oldTrackers,
-                        MC_SPEED_UP, &oldUpSpeed,
-                        MC_RECHECK_PROGRESS, &oldRecheckProgress,
-                        MC_SPEED_DOWN, &oldDownSpeed,
-                        -1 );
-
-    /* get the new states */
-    st = tr_torrentStat( tor );
-    newActive = is_torrent_active( st );
-    newActivity = st->activity;
-    newFinished = st->finished;
-    newPriority = tr_torrentGetPriority( tor );
-    newQueuePosition = st->queuePosition;
-    newTrackers = build_torrent_trackers_hash( tor );
-    newUpSpeed = st->pieceUploadSpeed_KBps;
-    newDownSpeed = st->pieceDownloadSpeed_KBps;
-    newRecheckProgress = st->recheckProgress;
-    newActivePeerCount = st->peersSendingToUs + st->peersGettingFromUs + st->webseedsSendingToUs;
-    newError = st->error;
-
-    /* updating the model triggers off resort/refresh,
-       so don't do it unless something's actually changed... */
-    if( ( newActive != oldActive )
-        || ( newActivity  != oldActivity )
-        || ( newFinished != oldFinished )
-        || ( newPriority != oldPriority )
-        || ( newQueuePosition != oldQueuePosition )
-        || ( newError != oldError )
-        || ( newActivePeerCount != oldActivePeerCount )
-        || ( newTrackers != oldTrackers )
-        || gtr_compare_double( newUpSpeed, oldUpSpeed, 2 )
-        || gtr_compare_double( newDownSpeed, oldDownSpeed, 2 )
-        || gtr_compare_double( newRecheckProgress, oldRecheckProgress, 2 ) )
+update_foreach (GtkTreeModel * model, GtkTreeIter * iter)
+{
+  int oldActivity, newActivity;
+  int oldActivePeerCount, newActivePeerCount;
+  int oldError, newError;
+  bool oldFinished, newFinished;
+  int oldQueuePosition, newQueuePosition;
+  tr_priority_t oldPriority, newPriority;
+  unsigned int oldTrackers, newTrackers;
+  double oldUpSpeed, newUpSpeed;
+  double oldDownSpeed, newDownSpeed;
+  double oldRecheckProgress, newRecheckProgress;
+  gboolean oldActive, newActive;
+  const tr_stat * st;
+  tr_torrent * tor;
+
+  /* get the old states */
+  gtk_tree_model_get (model, iter,
+                      MC_TORRENT,  &tor,
+                      MC_ACTIVE, &oldActive,
+                      MC_ACTIVE_PEER_COUNT, &oldActivePeerCount,
+                      MC_ERROR, &oldError,
+                      MC_ACTIVITY, &oldActivity,
+                      MC_FINISHED, &oldFinished,
+                      MC_PRIORITY, &oldPriority,
+                      MC_QUEUE_POSITION, &oldQueuePosition,
+                      MC_TRACKERS, &oldTrackers,
+                      MC_SPEED_UP, &oldUpSpeed,
+                      MC_RECHECK_PROGRESS, &oldRecheckProgress,
+                      MC_SPEED_DOWN, &oldDownSpeed,
+                      -1);
+
+  /* get the new states */
+  st = tr_torrentStat (tor);
+  newActive = is_torrent_active (st);
+  newActivity = st->activity;
+  newFinished = st->finished;
+  newPriority = tr_torrentGetPriority (tor);
+  newQueuePosition = st->queuePosition;
+  newTrackers = build_torrent_trackers_hash (tor);
+  newUpSpeed = st->pieceUploadSpeed_KBps;
+  newDownSpeed = st->pieceDownloadSpeed_KBps;
+  newRecheckProgress = st->recheckProgress;
+  newActivePeerCount = st->peersSendingToUs + st->peersGettingFromUs + st->webseedsSendingToUs;
+  newError = st->error;
+
+  /* updating the model triggers off resort/refresh,
+     so don't do it unless something's actually changed... */
+  if ((newActive != oldActive)
+        || (newActivity  != oldActivity)
+        || (newFinished != oldFinished)
+        || (newPriority != oldPriority)
+        || (newQueuePosition != oldQueuePosition)
+        || (newError != oldError)
+        || (newActivePeerCount != oldActivePeerCount)
+        || (newTrackers != oldTrackers)
+        || gtr_compare_double (newUpSpeed, oldUpSpeed, 2)
+        || gtr_compare_double (newDownSpeed, oldDownSpeed, 2)
+        || gtr_compare_double (newRecheckProgress, oldRecheckProgress, 2))
     {
-        gtk_list_store_set( GTK_LIST_STORE( model ), iter,
-                            MC_ACTIVE, newActive,
-                            MC_ACTIVE_PEER_COUNT, newActivePeerCount,
-                            MC_ERROR, newError,
-                            MC_ACTIVITY, newActivity,
-                            MC_FINISHED, newFinished,
-                            MC_PRIORITY, newPriority,
-                            MC_QUEUE_POSITION, newQueuePosition,
-                            MC_TRACKERS, newTrackers,
-                            MC_SPEED_UP, newUpSpeed,
-                            MC_SPEED_DOWN, newDownSpeed,
-                            MC_RECHECK_PROGRESS, newRecheckProgress,
-                            -1 );
+      gtk_list_store_set (GTK_LIST_STORE (model), iter,
+                          MC_ACTIVE, newActive,
+                          MC_ACTIVE_PEER_COUNT, newActivePeerCount,
+                          MC_ERROR, newError,
+                          MC_ACTIVITY, newActivity,
+                          MC_FINISHED, newFinished,
+                          MC_PRIORITY, newPriority,
+                          MC_QUEUE_POSITION, newQueuePosition,
+                          MC_TRACKERS, newTrackers,
+                          MC_SPEED_UP, newUpSpeed,
+                          MC_SPEED_DOWN, newDownSpeed,
+                          MC_RECHECK_PROGRESS, newRecheckProgress,
+                          -1);
     }
 }
 
 void
-gtr_core_update( TrCore * core )
+gtr_core_update (TrCore * core)
 {
-    GtkTreeIter iter;
-    GtkTreeModel * model;
+  GtkTreeIter iter;
+  GtkTreeModel * model;
 
-    /* update the model */
-    model = core_raw_model( core );
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
-        update_foreach( model, &iter );
-    while( gtk_tree_model_iter_next( model, &iter ) );
+  /* update the model */
+  model = core_raw_model (core);
+  if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
+    update_foreach (model, &iter);
+  while (gtk_tree_model_iter_next (model, &iter));
 
-    /* update hibernation */
-    core_maybe_inhibit_hibernation( core );
+  /* update hibernation */
+  core_maybe_inhibit_hibernation (core);
 }
 
 /**
@@ -1382,115 +1488,120 @@ gtr_core_update( TrCore * core )
 #define SESSION_MANAGER_OBJECT_PATH   "/org/gnome/SessionManager"
 
 static gboolean
-gtr_inhibit_hibernation( guint * cookie )
-{
-    gboolean success;
-    GVariant * response;
-    GDBusConnection * connection;
-    GError * err = NULL;
-    const char * application = "Transmission BitTorrent Client";
-    const char * reason = "BitTorrent Activity";
-    const int toplevel_xid = 0;
-    const int flags = 4; /* Inhibit suspending the session or computer */
-
-    connection = g_bus_get_sync( G_BUS_TYPE_SESSION, NULL, &err );
-
-    response = g_dbus_connection_call_sync( connection,
-                                            SESSION_MANAGER_SERVICE_NAME,
-                                            SESSION_MANAGER_OBJECT_PATH,
-                                            SESSION_MANAGER_INTERFACE,
-                                            "Inhibit",
-                                            g_variant_new( "(susu)", application, toplevel_xid, reason, flags ),
-                                            NULL, G_DBUS_CALL_FLAGS_NONE,
-                                            1000, NULL, &err );
-
-    if( response != NULL )
-        *cookie = g_variant_get_uint32( g_variant_get_child_value( response, 0 ) );
-
-    success = ( response != NULL ) && ( err == NULL );
-
-    /* logging */
-    if( success )
-        tr_inf( "%s", _( "Inhibiting desktop hibernation" ) );
-    else {
-        tr_err( _( "Couldn't inhibit desktop hibernation: %s" ), err->message );
-        g_error_free( err );
+gtr_inhibit_hibernation (guint * cookie)
+{
+  gboolean success;
+  GVariant * response;
+  GDBusConnection * connection;
+  GError * err = NULL;
+  const char * application = "Transmission BitTorrent Client";
+  const char * reason = "BitTorrent Activity";
+  const int toplevel_xid = 0;
+  const int flags = 4; /* Inhibit suspending the session or computer */
+
+  connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &err);
+
+  response = g_dbus_connection_call_sync (connection,
+                                          SESSION_MANAGER_SERVICE_NAME,
+                                          SESSION_MANAGER_OBJECT_PATH,
+                                          SESSION_MANAGER_INTERFACE,
+                                          "Inhibit",
+                                          g_variant_new ("(susu)", application, toplevel_xid, reason, flags),
+                                          NULL, G_DBUS_CALL_FLAGS_NONE,
+                                          1000, NULL, &err);
+
+  if (response != NULL)
+    *cookie = g_variant_get_uint32 (g_variant_get_child_value (response, 0));
+
+  success = (response != NULL) && (err == NULL);
+
+  /* logging */
+  if (success)
+    {
+      tr_inf ("%s", _("Inhibiting desktop hibernation"));
+    }
+  else
+    {
+      tr_err (_("Couldn't inhibit desktop hibernation: %s"), err->message);
+      g_error_free (err);
     }
 
-    /* cleanup */
-    if( response != NULL )
-        g_variant_unref( response );
-    if( connection != NULL )
-        g_object_unref( connection );
+  /* cleanup */
+  if (response != NULL)
+    g_variant_unref (response);
+  if (connection != NULL)
+    g_object_unref (connection);
 
-    return success;
+  return success;
 }
 
 static void
-gtr_uninhibit_hibernation( guint inhibit_cookie )
-{
-    GVariant * response;
-    GDBusConnection * connection;
-    GError * err = NULL;
-
-    connection = g_bus_get_sync( G_BUS_TYPE_SESSION, NULL, &err );
-
-    response = g_dbus_connection_call_sync( connection,
-                                            SESSION_MANAGER_SERVICE_NAME,
-                                            SESSION_MANAGER_OBJECT_PATH,
-                                            SESSION_MANAGER_INTERFACE,
-                                            "Uninhibit",
-                                            g_variant_new( "(u)", inhibit_cookie ),
-                                            NULL, G_DBUS_CALL_FLAGS_NONE,
-                                            1000, NULL, &err );
-
-    /* logging */
-    if( err == NULL )
-        tr_inf( "%s", _( "Allowing desktop hibernation" ) );
-    else {
-        g_warning( "Couldn't uninhibit desktop hibernation: %s.", err->message );
-        g_error_free( err );
+gtr_uninhibit_hibernation (guint inhibit_cookie)
+{
+  GVariant * response;
+  GDBusConnection * connection;
+  GError * err = NULL;
+
+  connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &err);
+
+  response = g_dbus_connection_call_sync (connection,
+                                          SESSION_MANAGER_SERVICE_NAME,
+                                          SESSION_MANAGER_OBJECT_PATH,
+                                          SESSION_MANAGER_INTERFACE,
+                                          "Uninhibit",
+                                          g_variant_new ("(u)", inhibit_cookie),
+                                          NULL, G_DBUS_CALL_FLAGS_NONE,
+                                          1000, NULL, &err);
+
+  /* logging */
+  if (err == NULL)
+    {
+      tr_inf ("%s", _("Allowing desktop hibernation"));
+    }
+  else
+    {
+      g_warning ("Couldn't uninhibit desktop hibernation: %s.", err->message);
+      g_error_free (err);
     }
 
-    /* cleanup */
-    g_variant_unref( response );
-    g_object_unref( connection );
+  /* cleanup */
+  g_variant_unref (response);
+  g_object_unref (connection);
 }
 
 static void
-gtr_core_set_hibernation_allowed( TrCore * core, gboolean allowed )
+gtr_core_set_hibernation_allowed (TrCore * core, gboolean allowed)
 {
-    g_return_if_fail( core );
-    g_return_if_fail( core->priv );
+  g_return_if_fail (core);
+  g_return_if_fail (core->priv);
 
-    core->priv->inhibit_allowed = allowed != 0;
+  core->priv->inhibit_allowed = allowed != 0;
 
-    if( allowed && core->priv->have_inhibit_cookie )
+  if (allowed && core->priv->have_inhibit_cookie)
     {
-        gtr_uninhibit_hibernation( core->priv->inhibit_cookie );
-        core->priv->have_inhibit_cookie = FALSE;
+      gtr_uninhibit_hibernation (core->priv->inhibit_cookie);
+      core->priv->have_inhibit_cookie = FALSE;
     }
 
-    if( !allowed
-      && !core->priv->have_inhibit_cookie
-      && !core->priv->dbus_error )
+  if (!allowed && !core->priv->have_inhibit_cookie
+               && !core->priv->dbus_error)
     {
-        if( gtr_inhibit_hibernation( &core->priv->inhibit_cookie ) )
-            core->priv->have_inhibit_cookie = TRUE;
-        else
-            core->priv->dbus_error = TRUE;
+      if (gtr_inhibit_hibernation (&core->priv->inhibit_cookie))
+        core->priv->have_inhibit_cookie = TRUE;
+      else
+        core->priv->dbus_error = TRUE;
     }
 }
 
 static void
-core_maybe_inhibit_hibernation( TrCore * core )
+core_maybe_inhibit_hibernation (TrCore * core)
 {
-    /* hibernation is allowed if EITHER
-     * (a) the "inhibit" pref is turned off OR
-     * (b) there aren't any active torrents */
-    const gboolean hibernation_allowed = !gtr_pref_flag_get( PREF_KEY_INHIBIT_HIBERNATION )
-                                      || !gtr_core_get_active_torrent_count( core );
-    gtr_core_set_hibernation_allowed( core, hibernation_allowed );
+  /* hibernation is allowed if EITHER
+   * (a) the "inhibit" pref is turned off OR
+   * (b) there aren't any active torrents */
+  const gboolean hibernation_allowed = !gtr_pref_flag_get (PREF_KEY_INHIBIT_HIBERNATION)
+                                    || !gtr_core_get_active_torrent_count (core);
+  gtr_core_set_hibernation_allowed (core, hibernation_allowed);
 }
 
 /**
@@ -1498,49 +1609,49 @@ core_maybe_inhibit_hibernation( TrCore * core )
 **/
 
 static void
-core_commit_prefs_change( TrCore * core, const char * key )
+core_commit_prefs_change (TrCore * core, const char * key)
 {
-    gtr_core_pref_changed( core, key );
-    gtr_pref_save( gtr_core_session( core ) );
+  gtr_core_pref_changed (core, key);
+  gtr_pref_save (gtr_core_session (core));
 }
 
 void
-gtr_core_set_pref( TrCore * self, const char * key, const char * newval )
+gtr_core_set_pref (TrCore * self, const char * key, const char * newval)
 {
-    if( tr_strcmp0( newval, gtr_pref_string_get( key ) ) )
+  if (tr_strcmp0 (newval, gtr_pref_string_get (key)))
     {
-        gtr_pref_string_set( key, newval );
-        core_commit_prefs_change( self, key );
+      gtr_pref_string_set (key, newval);
+      core_commit_prefs_change (self, key);
     }
 }
 
 void
-gtr_core_set_pref_bool( TrCore * self, const char * key, gboolean newval )
+gtr_core_set_pref_bool (TrCore * self, const char * key, gboolean newval)
 {
-    if( newval != gtr_pref_flag_get( key ) )
+  if (newval != gtr_pref_flag_get (key))
     {
-        gtr_pref_flag_set( key, newval );
-        core_commit_prefs_change( self, key );
+      gtr_pref_flag_set (key, newval);
+      core_commit_prefs_change (self, key);
     }
 }
 
 void
-gtr_core_set_pref_int( TrCore * self, const char * key, int newval )
+gtr_core_set_pref_int (TrCore * self, const char * key, int newval)
 {
-    if( newval != gtr_pref_int_get( key ) )
+  if (newval != gtr_pref_int_get (key))
     {
-        gtr_pref_int_set( key, newval );
-        core_commit_prefs_change( self, key );
+      gtr_pref_int_set (key, newval);
+      core_commit_prefs_change (self, key);
     }
 }
 
 void
-gtr_core_set_pref_double( TrCore * self, const char * key, double newval )
+gtr_core_set_pref_double (TrCore * self, const char * key, double newval)
 {
-    if( gtr_compare_double( newval, gtr_pref_double_get( key ), 4 ) )
+  if (gtr_compare_double (newval, gtr_pref_double_get (key), 4))
     {
-        gtr_pref_double_set( key, newval );
-        core_commit_prefs_change( self, key );
+      gtr_pref_double_set (key, newval);
+      core_commit_prefs_change (self, key);
     }
 }
 
@@ -1554,83 +1665,84 @@ gtr_core_set_pref_double( TrCore * self, const char * key, double newval )
 
 static int nextTag = 1;
 
-typedef void ( server_response_func )( TrCore * core, tr_benc * response, gpointer user_data );
+typedef void (server_response_func)(TrCore * core, tr_benc * response, gpointer user_data);
 
 struct pending_request_data
 {
-    TrCore * core;
-    server_response_func * response_func;
-    gpointer response_func_user_data;
+  TrCore * core;
+  server_response_func * response_func;
+  gpointer response_func_user_data;
 };
 
 static GHashTable * pendingRequests = NULL;
 
 static gboolean
-core_read_rpc_response_idle( void * vresponse )
+core_read_rpc_response_idle (void * vresponse)
 {
-    tr_benc top;
-    int64_t intVal;
-    struct evbuffer * response = vresponse;
+  tr_benc top;
+  int64_t intVal;
+  struct evbuffer * response = vresponse;
 
-    tr_jsonParse( NULL, evbuffer_pullup( response, -1 ), evbuffer_get_length( response ), &top, NULL );
+  tr_jsonParse (NULL, evbuffer_pullup (response, -1), evbuffer_get_length (response), &top, NULL);
 
-    if( tr_bencDictFindInt( &top, "tag", &intVal ) )
+  if (tr_bencDictFindInt (&top, "tag", &intVal))
     {
-        const int tag = (int)intVal;
-        struct pending_request_data * data = g_hash_table_lookup( pendingRequests, &tag );
-        if( data ) {
-            if( data->response_func )
-                (*data->response_func)(data->core, &top, data->response_func_user_data );
-            g_hash_table_remove( pendingRequests, &tag );
+      const int tag = (int)intVal;
+      struct pending_request_data * data = g_hash_table_lookup (pendingRequests, &tag);
+      if (data)
+        {
+          if (data->response_func)
+            (*data->response_func)(data->core, &top, data->response_func_user_data);
+          g_hash_table_remove (pendingRequests, &tag);
         }
     }
 
-    tr_bencFree( &top );
-    evbuffer_free( response );
-    return FALSE;
+  tr_bencFree (&top);
+  evbuffer_free (response);
+  return FALSE;
 }
 
 static void
-core_read_rpc_response( tr_session       * session UNUSED,
+core_read_rpc_response (tr_session       * session UNUSED,
                         struct evbuffer  * response,
-                        void             * unused UNUSED )
+                        void             * unused UNUSED)
 {
-    struct evbuffer * buf = evbuffer_new( );
-    evbuffer_add_buffer( buf, response );
-    gdk_threads_add_idle( core_read_rpc_response_idle, buf );
+  struct evbuffer * buf = evbuffer_new ();
+  evbuffer_add_buffer (buf, response);
+  gdk_threads_add_idle (core_read_rpc_response_idle, buf);
 }
 
 static void
-core_send_rpc_request( TrCore * core, const char * json, int tag,
+core_send_rpc_request (TrCore * core, const char * json, int tag,
                        server_response_func * response_func,
-                       void * response_func_user_data )
+                       void * response_func_user_data)
 {
-    tr_session * session = gtr_core_session( core );
+  tr_session * session = gtr_core_session (core);
 
-    if( pendingRequests == NULL )
+  if (pendingRequests == NULL)
     {
-        pendingRequests = g_hash_table_new_full( g_int_hash, g_int_equal, g_free, g_free );
+      pendingRequests = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, g_free);
     }
 
-    if( session == NULL )
+  if (session == NULL)
     {
-        g_error( "GTK+ client doesn't support connections to remote servers yet." );
+      g_error ("GTK+ client doesn't support connections to remote servers yet.");
     }
-    else
+  else
     {
-        /* remember this request */
-        struct pending_request_data * data;
-        data = g_new0( struct pending_request_data, 1 );
-        data->core = core;
-        data->response_func = response_func;
-        data->response_func_user_data = response_func_user_data;
-        g_hash_table_insert( pendingRequests, g_memdup( &tag, sizeof( int ) ), data );
-
-        /* make the request */
+      /* remember this request */
+      struct pending_request_data * data;
+      data = g_new0 (struct pending_request_data, 1);
+      data->core = core;
+      data->response_func = response_func;
+      data->response_func_user_data = response_func_user_data;
+      g_hash_table_insert (pendingRequests, g_memdup (&tag, sizeof (int)), data);
+
+      /* make the request */
 #ifdef DEBUG_RPC
-        g_message( "request: [%s]", json );
+      g_message ("request: [%s]", json);
 #endif
-        tr_rpc_request_exec_json( session, json, strlen( json ), core_read_rpc_response, GINT_TO_POINTER(tag) );
+      tr_rpc_request_exec_json (session, json, strlen (json), core_read_rpc_response, GINT_TO_POINTER (tag));
     }
 }
 
@@ -1639,24 +1751,24 @@ core_send_rpc_request( TrCore * core, const char * json, int tag,
 ***/
 
 static void
-on_port_test_response( TrCore * core, tr_benc * response, gpointer u UNUSED )
+on_port_test_response (TrCore * core, tr_benc * response, gpointer u UNUSED)
 {
-    tr_benc * args;
-    bool is_open = FALSE;
+  tr_benc * args;
+  bool is_open = FALSE;
 
-    if( tr_bencDictFindDict( response, "arguments", &args ) )
-        tr_bencDictFindBool( args, "port-is-open", &is_open );
+  if (tr_bencDictFindDict (response, "arguments", &args))
+    tr_bencDictFindBool (args, "port-is-open", &is_open);
 
-    core_emit_port_tested( core, is_open );
+  core_emit_port_tested (core, is_open);
 }
 
 void
-gtr_core_port_test( TrCore * core )
+gtr_core_port_test (TrCore * core)
 {
-    char buf[64];
-    const int tag = nextTag++;
-    g_snprintf( buf, sizeof( buf ), "{ \"method\": \"port-test\", \"tag\": %d }", tag );
-    core_send_rpc_request( core, buf, tag, on_port_test_response, NULL );
+  char buf[64];
+  const int tag = nextTag++;
+  g_snprintf (buf, sizeof (buf), "{ \"method\": \"port-test\", \"tag\": %d }", tag);
+  core_send_rpc_request (core, buf, tag, on_port_test_response, NULL);
 }
 
 /***
@@ -1664,27 +1776,27 @@ gtr_core_port_test( TrCore * core )
 ***/
 
 static void
-on_blocklist_response( TrCore * core, tr_benc * response, gpointer data UNUSED )
+on_blocklist_response (TrCore * core, tr_benc * response, gpointer data UNUSED)
 {
-    tr_benc * args;
-    int64_t ruleCount = -1;
+  tr_benc * args;
+  int64_t ruleCount = -1;
 
-    if( tr_bencDictFindDict( response, "arguments", &args ) )
-        tr_bencDictFindInt( args, "blocklist-size", &ruleCount );
+  if (tr_bencDictFindDict (response, "arguments", &args))
+    tr_bencDictFindInt (args, "blocklist-size", &ruleCount);
 
-    if( ruleCount > 0 )
-        gtr_pref_int_set( "blocklist-date", tr_time( ) );
+  if (ruleCount > 0)
+    gtr_pref_int_set ("blocklist-date", tr_time ());
 
-    core_emit_blocklist_udpated( core, ruleCount );
+  core_emit_blocklist_udpated (core, ruleCount);
 }
 
 void
-gtr_core_blocklist_update( TrCore * core )
+gtr_core_blocklist_update (TrCore * core)
 {
-    char buf[64];
-    const int tag = nextTag++;
-    g_snprintf( buf, sizeof( buf ), "{ \"method\": \"blocklist-update\", \"tag\": %d }", tag );
-    core_send_rpc_request( core, buf, tag, on_blocklist_response, NULL );
+  char buf[64];
+  const int tag = nextTag++;
+  g_snprintf (buf, sizeof (buf), "{ \"method\": \"blocklist-update\", \"tag\": %d }", tag);
+  core_send_rpc_request (core, buf, tag, on_blocklist_response, NULL);
 }
 
 /***
@@ -1692,18 +1804,18 @@ gtr_core_blocklist_update( TrCore * core )
 ***/
 
 void
-gtr_core_exec_json( TrCore * core, const char * json )
+gtr_core_exec_json (TrCore * core, const char * json)
 {
-    const int tag = nextTag++;
-    core_send_rpc_request( core, json, tag, NULL, NULL );
+  const int tag = nextTag++;
+  core_send_rpc_request (core, json, tag, NULL, NULL);
 }
 
 void
-gtr_core_exec( TrCore * core, const tr_benc * top )
+gtr_core_exec (TrCore * core, const tr_benc * top)
 {
-    char * json = tr_bencToStr( top, TR_FMT_JSON_LEAN, NULL );
-    gtr_core_exec_json( core, json );
-    tr_free( json );
+  char * json = tr_bencToStr (top, TR_FMT_JSON_LEAN, NULL);
+  gtr_core_exec_json (core, json);
+  tr_free (json);
 }
 
 /***
@@ -1711,58 +1823,62 @@ gtr_core_exec( TrCore * core, const tr_benc * top )
 ***/
 
 size_t
-gtr_core_get_torrent_count( TrCore * core )
+gtr_core_get_torrent_count (TrCore * core)
 {
-    return gtk_tree_model_iter_n_children( core_raw_model( core ), NULL );
+  return gtk_tree_model_iter_n_children (core_raw_model (core), NULL);
 }
 
 size_t
-gtr_core_get_active_torrent_count( TrCore * core )
+gtr_core_get_active_torrent_count (TrCore * core)
 {
-    GtkTreeIter iter;
-    size_t activeCount = 0;
-    GtkTreeModel * model = core_raw_model( core );
+  GtkTreeIter iter;
+  size_t activeCount = 0;
+  GtkTreeModel * model = core_raw_model (core);
 
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
+  if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
     {
-        int activity;
-        gtk_tree_model_get( model, &iter, MC_ACTIVITY, &activity, -1 );
+      int activity;
+      gtk_tree_model_get (model, &iter, MC_ACTIVITY, &activity, -1);
 
-        if( activity != TR_STATUS_STOPPED )
-            ++activeCount;
+      if (activity != TR_STATUS_STOPPED)
+        ++activeCount;
     }
-    while( gtk_tree_model_iter_next( model, &iter ) );
+  while (gtk_tree_model_iter_next (model, &iter));
 
-    return activeCount;
+  return activeCount;
 }
 
 tr_torrent *
-gtr_core_find_torrent( TrCore * core, int id )
+gtr_core_find_torrent (TrCore * core, int id)
 {
-    tr_session * session;
-    tr_torrent * tor = NULL;
+  tr_session * session;
+  tr_torrent * tor = NULL;
 
-    if(( session = gtr_core_session( core )))
-        tor = tr_torrentFindFromId( session, id );
+  if ((session = gtr_core_session (core)))
+    tor = tr_torrentFindFromId (session, id);
 
-    return tor;
+  return tor;
 }
 
 void
-gtr_core_open_folder( TrCore * core, int torrent_id )
+gtr_core_open_folder (TrCore * core, int torrent_id)
 {
-    const tr_torrent * tor = gtr_core_find_torrent( core, torrent_id );
+  const tr_torrent * tor = gtr_core_find_torrent (core, torrent_id);
 
-    if( tor != NULL )
+  if (tor != NULL)
     {
-        const gboolean single = tr_torrentInfo( tor )->fileCount == 1;
-        const char * currentDir = tr_torrentGetCurrentDir( tor );
-        if( single )
-            gtr_open_file( currentDir );
-        else {
-            char * path = g_build_filename( currentDir, tr_torrentName( tor ), NULL );
-            gtr_open_file( path );
-            g_free( path );
+      const gboolean single = tr_torrentInfo (tor)->fileCount == 1;
+      const char * currentDir = tr_torrentGetCurrentDir (tor);
+
+      if (single)
+        {
+          gtr_open_file (currentDir);
+        }
+      else
+        {
+          char * path = g_build_filename (currentDir, tr_torrentName (tor), NULL);
+          gtr_open_file (path);
+          g_free (path);
         }
     }
 }
diff --git a/gtk/tr-core.h b/gtk/tr-core.h
index b2c52bf7b..8a01fdc56 100644
--- a/gtk/tr-core.h
+++ b/gtk/tr-core.h
@@ -33,7 +33,7 @@
 G_BEGIN_DECLS
 
 #define TR_CORE_TYPE (tr_core_get_type ())
-#define TR_CORE(o)   (G_TYPE_CHECK_INSTANCE_CAST ((o), TR_CORE_TYPE, TrCore))
+#define TR_CORE(o)(G_TYPE_CHECK_INSTANCE_CAST ((o), TR_CORE_TYPE, TrCore))
 
 typedef struct _TrCore
 {
@@ -55,36 +55,36 @@ typedef struct _TrCoreClass
 {
     GObjectClass parent_class;
 
-    void (* add_error)         (TrCore*, enum tr_core_err, const char * name);
-    void (* add_prompt)        (TrCore*, gpointer ctor);
-    void (* blocklist_updated) (TrCore*, int ruleCount );
-    void (* busy)              (TrCore*, gboolean is_busy);
-    void (* prefs_changed)     (TrCore*, const char* key);
-    void (* port_tested)       (TrCore*, gboolean is_open);
-    void (* quit)              (TrCore*);
+    void (* add_error)       (TrCore*, enum tr_core_err, const char * name);
+    void (* add_prompt)      (TrCore*, gpointer ctor);
+    void (* blocklist_updated)(TrCore*, int ruleCount);
+    void (* busy)            (TrCore*, gboolean is_busy);
+    void (* prefs_changed)   (TrCore*, const char* key);
+    void (* port_tested)     (TrCore*, gboolean is_open);
+    void (* quit)            (TrCore*);
 }
 TrCoreClass;
 
 GType          tr_core_get_type (void) G_GNUC_CONST;
 
-TrCore *       gtr_core_new( tr_session * );
+TrCore *       gtr_core_new (tr_session *);
 
-void           gtr_core_close( TrCore* );
+void           gtr_core_close (TrCore*);
 
 /* Return the model used without incrementing the reference count */
-GtkTreeModel * gtr_core_model( TrCore * self );
+GtkTreeModel * gtr_core_model (TrCore * self);
 
-void           gtr_core_clear( TrCore * self );
+void           gtr_core_clear (TrCore * self);
 
-tr_session *   gtr_core_session( TrCore * self );
+tr_session *   gtr_core_session (TrCore * self);
 
-size_t         gtr_core_get_active_torrent_count( TrCore * self );
+size_t         gtr_core_get_active_torrent_count (TrCore * self);
 
-size_t         gtr_core_get_torrent_count( TrCore * self );
+size_t         gtr_core_get_torrent_count (TrCore * self);
 
-tr_torrent *   gtr_core_find_torrent( TrCore * core, int id );
+tr_torrent *   gtr_core_find_torrent (TrCore * core, int id);
 
-void           gtr_core_pref_changed( TrCore * core, const char * key );
+void           gtr_core_pref_changed (TrCore * core, const char * key);
 
 
 /******
@@ -95,7 +95,7 @@ void           gtr_core_pref_changed( TrCore * core, const char * key );
  * Load saved state and return number of torrents added.
  * May trigger one or more "error" signals with TR_CORE_ERR_ADD_TORRENT
  */
-void gtr_core_load( TrCore * self, gboolean forcepaused );
+void gtr_core_load (TrCore * self, gboolean forcepaused);
 
 /**
  * Add a list of torrents.
@@ -104,60 +104,60 @@ void gtr_core_load( TrCore * self, gboolean forcepaused );
  * May pop up dialogs for each torrent if that preference is enabled.
  * May trigger one or more "error" signals with TR_CORE_ERR_ADD_TORRENT
  */
-void gtr_core_add_files( TrCore     * core,
+void gtr_core_add_files (TrCore     * core,
                          GSList     * files,
                          gboolean     do_start,
                          gboolean     do_prompt,
-                         gboolean     do_notify );
+                         gboolean     do_notify);
 
 /** @brief Add a torrent from a URL */
-bool gtr_core_add_from_url( TrCore * core, const char * url );
+bool gtr_core_add_from_url (TrCore * core, const char * url);
 
 /** @brief Add a torrent.
     @param ctor this function assumes ownership of the ctor */
-void gtr_core_add_ctor( TrCore * core, tr_ctor * ctor );
+void gtr_core_add_ctor (TrCore * core, tr_ctor * ctor);
 
 /** Add a torrent. */
-void gtr_core_add_torrent( TrCore*, tr_torrent*, gboolean do_notify );
+void gtr_core_add_torrent (TrCore*, tr_torrent*, gboolean do_notify);
 
 /**
  * Notifies listeners that torrents have been added.
- * This should be called after one or more tr_core_add*() calls.
+ * This should be called after one or more tr_core_add* () calls.
  */
-void gtr_core_torrents_added( TrCore * self );
+void gtr_core_torrents_added (TrCore * self);
 
 /******
 *******
 ******/
 
 /* remove a torrent */
-void gtr_core_remove_torrent( TrCore * self, int id, gboolean delete_files );
+void gtr_core_remove_torrent (TrCore * self, int id, gboolean delete_files);
 
 /* update the model with current torrent status */
-void gtr_core_update( TrCore * self );
+void gtr_core_update (TrCore * self);
 
 /**
 ***  Set a preference value, save the prefs file, and emit the "prefs-changed" signal
 **/
 
-void gtr_core_set_pref       ( TrCore * self, const char * key, const char * val );
-void gtr_core_set_pref_bool  ( TrCore * self, const char * key, gboolean val );
-void gtr_core_set_pref_int   ( TrCore * self, const char * key, int val );
-void gtr_core_set_pref_double( TrCore * self, const char * key, double val );
+void gtr_core_set_pref     (TrCore * self, const char * key, const char * val);
+void gtr_core_set_pref_bool (TrCore * self, const char * key, gboolean val);
+void gtr_core_set_pref_int (TrCore * self, const char * key, int val);
+void gtr_core_set_pref_double (TrCore * self, const char * key, double val);
 
 /**
 ***
 **/
 
-void gtr_core_port_test( TrCore * core );
+void gtr_core_port_test (TrCore * core);
 
-void gtr_core_blocklist_update( TrCore * core );
+void gtr_core_blocklist_update (TrCore * core);
 
-void gtr_core_exec( TrCore * core, const tr_benc * benc );
+void gtr_core_exec (TrCore * core, const tr_benc * benc);
 
-void gtr_core_exec_json( TrCore * core, const char * json );
+void gtr_core_exec_json (TrCore * core, const char * json);
 
-void gtr_core_open_folder( TrCore * core, int torrent_id );
+void gtr_core_open_folder (TrCore * core, int torrent_id);
 
 
 /**
@@ -165,7 +165,7 @@ void gtr_core_open_folder( TrCore * core, int torrent_id );
 **/
 
 /* column names for the model used to store torrent information */
-/* keep this in sync with the type array in tr_core_init() in tr_core.c */
+/* keep this in sync with the type array in tr_core_init () in tr_core.c */
 enum
 {
     MC_NAME_COLLATED,
diff --git a/gtk/tr-icon.c b/gtk/tr-icon.c
index b75cd0faf..78314cc46 100644
--- a/gtk/tr-icon.c
+++ b/gtk/tr-icon.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -22,10 +22,10 @@
 #include "util.h"
 
 static GQuark
-get_core_quark( void )
+get_core_quark (void)
 {
     static GQuark quark = 0;
-    if( !quark ) quark = g_quark_from_static_string( "tr-core" );
+    if (!quark) quark = g_quark_from_static_string ("tr-core");
     return quark;
 }
 
@@ -33,31 +33,31 @@ get_core_quark( void )
 
 #ifdef HAVE_LIBAPPINDICATOR
 void
-gtr_icon_refresh( gpointer vindicator UNUSED )
+gtr_icon_refresh (gpointer vindicator UNUSED)
 {
 }
 #else
 static void
-activated( GtkStatusIcon * self UNUSED, gpointer user_data UNUSED )
+activated (GtkStatusIcon * self UNUSED, gpointer user_data UNUSED)
 {
-    gtr_action_activate( "toggle-main-window" );
+    gtr_action_activate ("toggle-main-window");
 }
 
 static void
-popup( GtkStatusIcon *       self,
+popup (GtkStatusIcon *       self,
        guint                 button,
        guint                 when,
-       gpointer         data UNUSED )
+       gpointer         data UNUSED)
 {
-    GtkWidget * w = gtr_action_get_widget( "/icon-popup" );
+    GtkWidget * w = gtr_action_get_widget ("/icon-popup");
 
-    gtk_menu_popup ( GTK_MENU( w ), NULL, NULL,
+    gtk_menu_popup (GTK_MENU (w), NULL, NULL,
                      gtk_status_icon_position_menu,
-                     self, button, when );
+                     self, button, when);
 }
 
 void
-gtr_icon_refresh( gpointer vicon )
+gtr_icon_refresh (gpointer vicon)
 {
     double KBps;
     double limit;
@@ -66,67 +66,67 @@ gtr_icon_refresh( gpointer vicon )
     char down[64];
     char downLimit[64];
     char tip[1024];
-    const char * idle = _( "Idle" );
-    GtkStatusIcon * icon = GTK_STATUS_ICON( vicon );
-    tr_session * session = gtr_core_session( g_object_get_qdata( G_OBJECT( icon ), get_core_quark( ) ) );
+    const char * idle = _("Idle");
+    GtkStatusIcon * icon = GTK_STATUS_ICON (vicon);
+    tr_session * session = gtr_core_session (g_object_get_qdata (G_OBJECT (icon), get_core_quark ()));
 
     /* up */
-    KBps = tr_sessionGetRawSpeed_KBps( session, TR_UP );
-    if( KBps < 0.001 )
-        g_strlcpy( up, idle, sizeof( up ) );
+    KBps = tr_sessionGetRawSpeed_KBps (session, TR_UP);
+    if (KBps < 0.001)
+        g_strlcpy (up, idle, sizeof (up));
     else
-        tr_formatter_speed_KBps( up, KBps, sizeof( up ) );
+        tr_formatter_speed_KBps (up, KBps, sizeof (up));
 
     /* up limit */
-    if( !tr_sessionGetActiveSpeedLimit_KBps( session, TR_UP, &limit ) )
+    if (!tr_sessionGetActiveSpeedLimit_KBps (session, TR_UP, &limit))
         *upLimit = '\0';
     else {
         char buf[64];
-        tr_formatter_speed_KBps( buf, limit, sizeof( buf ) );
-        g_snprintf( upLimit, sizeof( upLimit ), _( "(Limit: %s)" ), buf );
+        tr_formatter_speed_KBps (buf, limit, sizeof (buf));
+        g_snprintf (upLimit, sizeof (upLimit), _(" (Limit: %s)"), buf);
     }
 
     /* down */
-    KBps = tr_sessionGetRawSpeed_KBps( session, TR_DOWN );
-    if( KBps < 0.001 )
-        g_strlcpy( down, idle, sizeof( down ) );
+    KBps = tr_sessionGetRawSpeed_KBps (session, TR_DOWN);
+    if (KBps < 0.001)
+        g_strlcpy (down, idle, sizeof (down));
     else
-        tr_formatter_speed_KBps( down, KBps, sizeof( down ) );
+        tr_formatter_speed_KBps (down, KBps, sizeof (down));
 
     /* down limit */
-    if( !tr_sessionGetActiveSpeedLimit_KBps( session, TR_DOWN, &limit ) )
+    if (!tr_sessionGetActiveSpeedLimit_KBps (session, TR_DOWN, &limit))
         *downLimit = '\0';
     else {
         char buf[64];
-        tr_formatter_speed_KBps( buf, limit, sizeof( buf ) );
-        g_snprintf( downLimit, sizeof( downLimit ), _( "(Limit: %s)" ), buf );
+        tr_formatter_speed_KBps (buf, limit, sizeof (buf));
+        g_snprintf (downLimit, sizeof (downLimit), _(" (Limit: %s)"), buf);
     }
 
     /* %1$s: current upload speed
      * %2$s: current upload limit, if any
      * %3$s: current download speed
      * %4$s: current download limit, if any */
-    g_snprintf( tip, sizeof( tip ), _( "Transmission\nUp: %1$s %2$s\nDown: %3$s %4$s" ), up, upLimit, down, downLimit );
+    g_snprintf (tip, sizeof (tip), _("Transmission\nUp: %1$s %2$s\nDown: %3$s %4$s"), up, upLimit, down, downLimit);
 
-    gtk_status_icon_set_tooltip_text( GTK_STATUS_ICON( icon ), tip );
+    gtk_status_icon_set_tooltip_text (GTK_STATUS_ICON (icon), tip);
 }
 #endif
 
 static const char *
-getIconName( void )
+getIconName (void)
 {
     const char * icon_name;
 
-    GtkIconTheme * theme = gtk_icon_theme_get_default( );
+    GtkIconTheme * theme = gtk_icon_theme_get_default ();
 
     /* if the tray's icon is a 48x48 file, use it;
      * otherwise, use the fallback builtin icon */
-    if( !gtk_icon_theme_has_icon( theme, TRAY_ICON ) )
+    if (!gtk_icon_theme_has_icon (theme, TRAY_ICON))
         icon_name = ICON_NAME;
     else {
-        GtkIconInfo * icon_info = gtk_icon_theme_lookup_icon( theme, TRAY_ICON, 48, GTK_ICON_LOOKUP_USE_BUILTIN );
-        const gboolean icon_is_builtin = gtk_icon_info_get_filename ( icon_info ) == NULL;
-        gtk_icon_info_free ( icon_info );
+        GtkIconInfo * icon_info = gtk_icon_theme_lookup_icon (theme, TRAY_ICON, 48, GTK_ICON_LOOKUP_USE_BUILTIN);
+        const gboolean icon_is_builtin = gtk_icon_info_get_filename (icon_info) == NULL;
+        gtk_icon_info_free (icon_info);
         icon_name = icon_is_builtin ? ICON_NAME : TRAY_ICON;
     }
 
@@ -134,24 +134,24 @@ getIconName( void )
 }
 
 gpointer
-gtr_icon_new( TrCore * core)
+gtr_icon_new (TrCore * core)
 {
 #ifdef HAVE_LIBAPPINDICATOR
     GtkWidget * w;
-    const char * icon_name = getIconName( );
-    AppIndicator * indicator = app_indicator_new( ICON_NAME, icon_name, APP_INDICATOR_CATEGORY_SYSTEM_SERVICES );
-    app_indicator_set_status( indicator, APP_INDICATOR_STATUS_ACTIVE );
-    w = gtr_action_get_widget( "/icon-popup" );
-    app_indicator_set_menu( indicator, GTK_MENU ( w ) );
-    app_indicator_set_title( indicator, g_get_application_name( ) );
-    g_object_set_qdata( G_OBJECT( indicator ), get_core_quark( ), core );
+    const char * icon_name = getIconName ();
+    AppIndicator * indicator = app_indicator_new (ICON_NAME, icon_name, APP_INDICATOR_CATEGORY_SYSTEM_SERVICES);
+    app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE);
+    w = gtr_action_get_widget ("/icon-popup");
+    app_indicator_set_menu (indicator, GTK_MENU (w));
+    app_indicator_set_title (indicator, g_get_application_name ());
+    g_object_set_qdata (G_OBJECT (indicator), get_core_quark (), core);
     return indicator;
 #else
-    const char * icon_name = getIconName( );
-    GtkStatusIcon * icon = gtk_status_icon_new_from_icon_name( icon_name );
-    g_signal_connect( icon, "activate", G_CALLBACK( activated ), NULL );
-    g_signal_connect( icon, "popup-menu", G_CALLBACK( popup ), NULL );
-    g_object_set_qdata( G_OBJECT( icon ), get_core_quark( ), core );
+    const char * icon_name = getIconName ();
+    GtkStatusIcon * icon = gtk_status_icon_new_from_icon_name (icon_name);
+    g_signal_connect (icon, "activate", G_CALLBACK (activated), NULL);
+    g_signal_connect (icon, "popup-menu", G_CALLBACK (popup), NULL);
+    g_object_set_qdata (G_OBJECT (icon), get_core_quark (), core);
     return icon;
 #endif
 }
diff --git a/gtk/tr-icon.h b/gtk/tr-icon.h
index 5e8c90571..f853f738a 100644
--- a/gtk/tr-icon.h
+++ b/gtk/tr-icon.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,7 +16,7 @@
 #include <gtk/gtk.h>
 #include "tr-core.h"
 
-gpointer  gtr_icon_new      ( TrCore * core );
-void      gtr_icon_refresh  ( gpointer );
+gpointer  gtr_icon_new    (TrCore * core);
+void      gtr_icon_refresh (gpointer);
 
 #endif /* GTR_ICON_H */
diff --git a/gtk/tr-prefs.c b/gtk/tr-prefs.c
index cc6ac6f9d..2e918721d 100644
--- a/gtk/tr-prefs.c
+++ b/gtk/tr-prefs.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -12,7 +12,7 @@
 
 #include <ctype.h> /* isspace */
 #include <limits.h> /* USHRT_MAX */
-#include <string.h> /* strcmp() */
+#include <string.h> /* strcmp () */
 #include <unistd.h>
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
@@ -32,43 +32,43 @@
 #define PREF_KEY "pref-key"
 
 static void
-response_cb( GtkDialog *     dialog,
+response_cb (GtkDialog *     dialog,
              int             response,
-             gpointer unused UNUSED )
+             gpointer unused UNUSED)
 {
-    if( response == GTK_RESPONSE_HELP )
+    if (response == GTK_RESPONSE_HELP)
     {
-        char * uri = g_strconcat( gtr_get_help_uri(), "/html/preferences.html", NULL );
-        gtr_open_uri( uri );
-        g_free( uri );
+        char * uri = g_strconcat (gtr_get_help_uri (), "/html/preferences.html", NULL);
+        gtr_open_uri (uri);
+        g_free (uri);
     }
 
-    if( response == GTK_RESPONSE_CLOSE )
-        gtk_widget_destroy( GTK_WIDGET( dialog ) );
+    if (response == GTK_RESPONSE_CLOSE)
+        gtk_widget_destroy (GTK_WIDGET (dialog));
 }
 
 static void
-toggled_cb( GtkToggleButton * w,
-            gpointer          core )
+toggled_cb (GtkToggleButton * w,
+            gpointer          core)
 {
-    const char *   key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
-    const gboolean flag = gtk_toggle_button_get_active( w );
+    const char *   key = g_object_get_data (G_OBJECT (w), PREF_KEY);
+    const gboolean flag = gtk_toggle_button_get_active (w);
 
-    gtr_core_set_pref_bool( TR_CORE( core ), key, flag );
+    gtr_core_set_pref_bool (TR_CORE (core), key, flag);
 }
 
 static GtkWidget*
-new_check_button( const char * mnemonic,
+new_check_button (const char * mnemonic,
                   const char * key,
-                  gpointer     core )
+                  gpointer     core)
 {
-    GtkWidget * w = gtk_check_button_new_with_mnemonic( mnemonic );
+    GtkWidget * w = gtk_check_button_new_with_mnemonic (mnemonic);
 
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
-                                key ), g_free );
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ),
-                                 gtr_pref_flag_get( key ) );
-    g_signal_connect( w, "toggled", G_CALLBACK( toggled_cb ), core );
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (
+                                key), g_free);
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
+                                 gtr_pref_flag_get (key));
+    g_signal_connect (w, "toggled", G_CALLBACK (toggled_cb), core);
     return w;
 }
 
@@ -82,173 +82,173 @@ struct spin_idle_data
 };
 
 static void
-spin_idle_data_free( gpointer gdata )
+spin_idle_data_free (gpointer gdata)
 {
     struct spin_idle_data * data = gdata;
 
-    g_timer_destroy( data->last_change );
-    g_free( data );
+    g_timer_destroy (data->last_change);
+    g_free (data);
 }
 
 static gboolean
-spun_cb_idle( gpointer spin )
+spun_cb_idle (gpointer spin)
 {
     gboolean keep_waiting = TRUE;
-    GObject * o = G_OBJECT( spin );
-    struct spin_idle_data * data = g_object_get_data( o, IDLE_DATA );
+    GObject * o = G_OBJECT (spin);
+    struct spin_idle_data * data = g_object_get_data (o, IDLE_DATA);
 
     /* has the user stopped making changes? */
-    if( g_timer_elapsed( data->last_change, NULL ) > 0.33f )
+    if (g_timer_elapsed (data->last_change, NULL) > 0.33f)
     {
         /* update the core */
-        const char * key = g_object_get_data( o, PREF_KEY );
+        const char * key = g_object_get_data (o, PREF_KEY);
 
         if (data->isDouble)
         {
-            const double value = gtk_spin_button_get_value( GTK_SPIN_BUTTON( spin ) );
-            gtr_core_set_pref_double( TR_CORE( data->core ), key, value );
+            const double value = gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin));
+            gtr_core_set_pref_double (TR_CORE (data->core), key, value);
         }
         else
         {
-            const int value = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( spin ) );
-            gtr_core_set_pref_int( TR_CORE( data->core ), key, value );
+            const int value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
+            gtr_core_set_pref_int (TR_CORE (data->core), key, value);
         }
 
         /* cleanup */
-        g_object_set_data( o, IDLE_DATA, NULL );
+        g_object_set_data (o, IDLE_DATA, NULL);
         keep_waiting = FALSE;
-        g_object_unref( G_OBJECT( o ) );
+        g_object_unref (G_OBJECT (o));
     }
 
     return keep_waiting;
 }
 
 static void
-spun_cb( GtkSpinButton * w, gpointer core, gboolean isDouble )
+spun_cb (GtkSpinButton * w, gpointer core, gboolean isDouble)
 {
     /* user may be spinning through many values, so let's hold off
        for a moment to keep from flooding the core with changes */
-    GObject * o = G_OBJECT( w );
-    struct spin_idle_data * data = g_object_get_data( o, IDLE_DATA );
+    GObject * o = G_OBJECT (w);
+    struct spin_idle_data * data = g_object_get_data (o, IDLE_DATA);
 
-    if( data == NULL )
+    if (data == NULL)
     {
-        data = g_new( struct spin_idle_data, 1 );
+        data = g_new (struct spin_idle_data, 1);
         data->core = core;
-        data->last_change = g_timer_new( );
+        data->last_change = g_timer_new ();
         data->isDouble = isDouble;
-        g_object_set_data_full( o, IDLE_DATA, data, spin_idle_data_free );
-        g_object_ref( G_OBJECT( o ) );
-        gdk_threads_add_timeout_seconds( 1, spun_cb_idle, w );
+        g_object_set_data_full (o, IDLE_DATA, data, spin_idle_data_free);
+        g_object_ref (G_OBJECT (o));
+        gdk_threads_add_timeout_seconds (1, spun_cb_idle, w);
     }
-    g_timer_start( data->last_change );
+    g_timer_start (data->last_change);
 }
 
 static void
-spun_cb_int( GtkSpinButton * w, gpointer core )
+spun_cb_int (GtkSpinButton * w, gpointer core)
 {
-    spun_cb( w, core, FALSE );
+    spun_cb (w, core, FALSE);
 }
 
 static void
-spun_cb_double( GtkSpinButton * w, gpointer core )
+spun_cb_double (GtkSpinButton * w, gpointer core)
 {
-    spun_cb( w, core, TRUE );
+    spun_cb (w, core, TRUE);
 }
 
 static GtkWidget*
-new_spin_button( const char * key,
+new_spin_button (const char * key,
                  gpointer     core,
                  int          low,
                  int          high,
-                 int          step )
+                 int          step)
 {
-    GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
-    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 0 );
-    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), gtr_pref_int_get( key ) );
-    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_int ), core );
+    GtkWidget * w = gtk_spin_button_new_with_range (low, high, step);
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (key), g_free);
+    gtk_spin_button_set_digits (GTK_SPIN_BUTTON (w), 0);
+    gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), gtr_pref_int_get (key));
+    g_signal_connect (w, "value-changed", G_CALLBACK (spun_cb_int), core);
     return w;
 }
 
 static GtkWidget*
-new_spin_button_double( const char * key,
+new_spin_button_double (const char * key,
                        gpointer      core,
                        double        low,
                        double        high,
-                       double        step )
+                       double        step)
 {
-    GtkWidget * w = gtk_spin_button_new_with_range( low, high, step );
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
-    gtk_spin_button_set_digits( GTK_SPIN_BUTTON( w ), 2 );
-    gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), gtr_pref_double_get( key ) );
-    g_signal_connect( w, "value-changed", G_CALLBACK( spun_cb_double ), core );
+    GtkWidget * w = gtk_spin_button_new_with_range (low, high, step);
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (key), g_free);
+    gtk_spin_button_set_digits (GTK_SPIN_BUTTON (w), 2);
+    gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), gtr_pref_double_get (key));
+    g_signal_connect (w, "value-changed", G_CALLBACK (spun_cb_double), core);
     return w;
 }
 
 static void
-entry_changed_cb( GtkEntry * w, gpointer   core )
+entry_changed_cb (GtkEntry * w, gpointer   core)
 {
-    const char * key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
-    const char * value = gtk_entry_get_text( w );
+    const char * key = g_object_get_data (G_OBJECT (w), PREF_KEY);
+    const char * value = gtk_entry_get_text (w);
 
-    gtr_core_set_pref( TR_CORE( core ), key, value );
+    gtr_core_set_pref (TR_CORE (core), key, value);
 }
 
 static GtkWidget*
-new_entry( const char * key,
-           gpointer     core )
+new_entry (const char * key,
+           gpointer     core)
 {
-    GtkWidget *  w = gtk_entry_new( );
-    const char * value = gtr_pref_string_get( key );
-
-    if( value )
-        gtk_entry_set_text( GTK_ENTRY( w ), value );
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup(
-                                key ), g_free );
-    g_signal_connect( w, "changed", G_CALLBACK( entry_changed_cb ), core );
+    GtkWidget *  w = gtk_entry_new ();
+    const char * value = gtr_pref_string_get (key);
+
+    if (value)
+        gtk_entry_set_text (GTK_ENTRY (w), value);
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (
+                                key), g_free);
+    g_signal_connect (w, "changed", G_CALLBACK (entry_changed_cb), core);
     return w;
 }
 
 static void
-chosen_cb( GtkFileChooser * w, gpointer core )
+chosen_cb (GtkFileChooser * w, gpointer core)
 {
-    const char * key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
-    char * value = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( w ) );
-    gtr_core_set_pref( TR_CORE( core ), key, value );
-    g_free( value );
+    const char * key = g_object_get_data (G_OBJECT (w), PREF_KEY);
+    char * value = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w));
+    gtr_core_set_pref (TR_CORE (core), key, value);
+    g_free (value);
 }
 
 static GtkWidget*
-new_path_chooser_button( const char * key, gpointer core )
+new_path_chooser_button (const char * key, gpointer core)
 {
-    GtkWidget *  w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
-    const char * path = gtr_pref_string_get( key );
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
-    g_signal_connect( w, "selection-changed", G_CALLBACK( chosen_cb ), core );
-    if( path != NULL )
-        gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), path );
+    GtkWidget *  w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
+    const char * path = gtr_pref_string_get (key);
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (key), g_free);
+    g_signal_connect (w, "selection-changed", G_CALLBACK (chosen_cb), core);
+    if (path != NULL)
+        gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), path);
     return w;
 }
 
 static GtkWidget*
-new_file_chooser_button( const char * key, gpointer core )
+new_file_chooser_button (const char * key, gpointer core)
 {
-    GtkWidget *  w = gtk_file_chooser_button_new( NULL, GTK_FILE_CHOOSER_ACTION_OPEN );
-    const char * path = gtr_pref_string_get( key );
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, g_strdup( key ), g_free );
-    if( path != NULL )
-        gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), path );
-    g_signal_connect( w, "selection-changed", G_CALLBACK( chosen_cb ), core );
+    GtkWidget *  w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_OPEN);
+    const char * path = gtr_pref_string_get (key);
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (key), g_free);
+    if (path != NULL)
+        gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), path);
+    g_signal_connect (w, "selection-changed", G_CALLBACK (chosen_cb), core);
     return w;
 }
 
 static void
-target_cb( GtkWidget * tb, gpointer target )
+target_cb (GtkWidget * tb, gpointer target)
 {
-    const gboolean b = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( tb ) );
+    const gboolean b = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (tb));
 
-    gtk_widget_set_sensitive( GTK_WIDGET( target ), b );
+    gtk_widget_set_sensitive (GTK_WIDGET (target), b);
 }
 
 /****
@@ -256,7 +256,7 @@ target_cb( GtkWidget * tb, gpointer target )
 ****/
 
 static GtkWidget*
-downloadPage( GObject * core )
+downloadPage (GObject * core)
 {
     GtkWidget * t;
     GtkWidget * w;
@@ -264,44 +264,44 @@ downloadPage( GObject * core )
     const char * s;
     guint row = 0;
 
-    t = hig_workarea_create( );
+    t = hig_workarea_create ();
 
-    hig_workarea_add_section_title( t, &row, _( "Location" ) );
+    hig_workarea_add_section_title (t, &row, _("Location"));
 
-    w = new_path_chooser_button( TR_PREFS_KEY_DOWNLOAD_DIR, core );
-    hig_workarea_add_row( t, &row, _( "Save to _Location:" ), w, NULL );
+    w = new_path_chooser_button (TR_PREFS_KEY_DOWNLOAD_DIR, core);
+    hig_workarea_add_row (t, &row, _("Save to _Location:"), w, NULL);
 
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, _( "Queue" ) );
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Queue"));
 
-    s = _( "Maximum active _downloads:" );
-    w = new_spin_button( TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, core, 0, INT_MAX, 1 );
-    hig_workarea_add_row( t, &row, s, w, NULL );
+    s = _("Maximum active _downloads:");
+    w = new_spin_button (TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, core, 0, INT_MAX, 1);
+    hig_workarea_add_row (t, &row, s, w, NULL);
 
-    s = _( "Downloads sharing data in the last N minutes are _active:" );
-    w = new_spin_button( TR_PREFS_KEY_QUEUE_STALLED_MINUTES, core, 1, INT_MAX, 15 );
-    hig_workarea_add_row( t, &row, s, w, NULL );
+    s = _("Downloads sharing data in the last N minutes are _active:");
+    w = new_spin_button (TR_PREFS_KEY_QUEUE_STALLED_MINUTES, core, 1, INT_MAX, 15);
+    hig_workarea_add_row (t, &row, s, w, NULL);
 
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, _( "Incomplete" ) );
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Incomplete"));
 
-    s = _( "Append \"._part\" to incomplete files' names" );
-    w = new_check_button( s, TR_PREFS_KEY_RENAME_PARTIAL_FILES, core );
-    hig_workarea_add_wide_control( t, &row, w );
+    s = _("Append \"._part\" to incomplete files' names");
+    w = new_check_button (s, TR_PREFS_KEY_RENAME_PARTIAL_FILES, core);
+    hig_workarea_add_wide_control (t, &row, w);
 
-    s = _( "Keep _incomplete torrents in:" );
-    l = new_check_button( s, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, core );
-    w = new_path_chooser_button( TR_PREFS_KEY_INCOMPLETE_DIR, core );
-    gtk_widget_set_sensitive( GTK_WIDGET( w ), gtr_pref_flag_get( TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED ) );
-    g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
-    hig_workarea_add_row_w( t, &row, l, w, NULL );
+    s = _("Keep _incomplete torrents in:");
+    l = new_check_button (s, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, core);
+    w = new_path_chooser_button (TR_PREFS_KEY_INCOMPLETE_DIR, core);
+    gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED));
+    g_signal_connect (l, "toggled", G_CALLBACK (target_cb), w);
+    hig_workarea_add_row_w (t, &row, l, w, NULL);
 
-    s = _( "Call _script when torrent is completed:" );
-    l = new_check_button( s, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, core );
-    w = new_file_chooser_button( TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, core );
-    gtk_widget_set_sensitive( GTK_WIDGET( w ), gtr_pref_flag_get( TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED ) );
-    g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
-    hig_workarea_add_row_w( t, &row, l, w, NULL );
+    s = _("Call _script when torrent is completed:");
+    l = new_check_button (s, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, core);
+    w = new_file_chooser_button (TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, core);
+    gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED));
+    g_signal_connect (l, "toggled", G_CALLBACK (target_cb), w);
+    hig_workarea_add_row_w (t, &row, l, w, NULL);
 
     return t;
 }
@@ -311,7 +311,7 @@ downloadPage( GObject * core )
 ****/
 
 static GtkWidget*
-torrentPage( GObject * core )
+torrentPage (GObject * core)
 {
     const char * s;
     GtkWidget *  t;
@@ -320,44 +320,44 @@ torrentPage( GObject * core )
     GtkWidget *  l;
     guint row = 0;
 
-    t = hig_workarea_create( );
-    hig_workarea_add_section_title( t, &row, C_( "Gerund", "Adding" ) );
-
-    s = _( "_Start when added" );
-    w = new_check_button( s, TR_PREFS_KEY_START, core );
-    hig_workarea_add_wide_control( t, &row, w );
-
-    s = _( "Show _options dialog" );
-    w = new_check_button( s, PREF_KEY_OPTIONS_PROMPT, core );
-    hig_workarea_add_wide_control( t, &row, w );
-
-    s = _( "Mo_ve .torrent file to the trash" );
-    w = new_check_button( s, TR_PREFS_KEY_TRASH_ORIGINAL, core );
-    hig_workarea_add_wide_control( t, &row, w );
-
-    s = _( "Automatically _add torrents from:" );
-    l = new_check_button( s, PREF_KEY_DIR_WATCH_ENABLED, core );
-    w = new_path_chooser_button( PREF_KEY_DIR_WATCH, core );
-    gtk_widget_set_sensitive( GTK_WIDGET( w ), gtr_pref_flag_get( PREF_KEY_DIR_WATCH_ENABLED ) );
-    g_signal_connect( l, "toggled", G_CALLBACK( target_cb ), w );
-    hig_workarea_add_row_w( t, &row, l, w, NULL );
-
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, C_( "Gerund", "Seeding" ) );
-
-    s = _( "Stop seeding at _ratio:" );
-    w = new_check_button( s, TR_PREFS_KEY_RATIO_ENABLED, core );
-    w2 = new_spin_button_double( TR_PREFS_KEY_RATIO, core, 0, 1000, .05 );
-    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED ) );
-    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
-    hig_workarea_add_row_w( t, &row, w, w2, NULL );
-
-    s = _( "Stop seeding if idle for _N minutes:" );
-    w = new_check_button( s, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, core );
-    w2 = new_spin_button( TR_PREFS_KEY_IDLE_LIMIT, core, 1, 9999, 5 );
-    gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_IDLE_LIMIT_ENABLED ) );
-    g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
-    hig_workarea_add_row_w( t, &row, w, w2, NULL );
+    t = hig_workarea_create ();
+    hig_workarea_add_section_title (t, &row, C_("Gerund", "Adding"));
+
+    s = _("_Start when added");
+    w = new_check_button (s, TR_PREFS_KEY_START, core);
+    hig_workarea_add_wide_control (t, &row, w);
+
+    s = _("Show _options dialog");
+    w = new_check_button (s, PREF_KEY_OPTIONS_PROMPT, core);
+    hig_workarea_add_wide_control (t, &row, w);
+
+    s = _("Mo_ve .torrent file to the trash");
+    w = new_check_button (s, TR_PREFS_KEY_TRASH_ORIGINAL, core);
+    hig_workarea_add_wide_control (t, &row, w);
+
+    s = _("Automatically _add torrents from:");
+    l = new_check_button (s, PREF_KEY_DIR_WATCH_ENABLED, core);
+    w = new_path_chooser_button (PREF_KEY_DIR_WATCH, core);
+    gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (PREF_KEY_DIR_WATCH_ENABLED));
+    g_signal_connect (l, "toggled", G_CALLBACK (target_cb), w);
+    hig_workarea_add_row_w (t, &row, l, w, NULL);
+
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, C_("Gerund", "Seeding"));
+
+    s = _("Stop seeding at _ratio:");
+    w = new_check_button (s, TR_PREFS_KEY_RATIO_ENABLED, core);
+    w2 = new_spin_button_double (TR_PREFS_KEY_RATIO, core, 0, 1000, .05);
+    gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_PREFS_KEY_RATIO_ENABLED));
+    g_signal_connect (w, "toggled", G_CALLBACK (target_cb), w2);
+    hig_workarea_add_row_w (t, &row, w, w2, NULL);
+
+    s = _("Stop seeding if idle for _N minutes:");
+    w = new_check_button (s, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, core);
+    w2 = new_spin_button (TR_PREFS_KEY_IDLE_LIMIT, core, 1, 9999, 5);
+    gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_PREFS_KEY_IDLE_LIMIT_ENABLED));
+    g_signal_connect (w, "toggled", G_CALLBACK (target_cb), w2);
+    hig_workarea_add_row_w (t, &row, w, w2, NULL);
 
     return t;
 }
@@ -367,38 +367,38 @@ torrentPage( GObject * core )
 ****/
 
 static GtkWidget*
-desktopPage( GObject * core )
+desktopPage (GObject * core)
 {
     GtkWidget * t;
     GtkWidget * w;
     const char * s;
     guint row = 0;
 
-    t = hig_workarea_create( );
-    hig_workarea_add_section_title( t, &row, _( "Desktop" ) );
+    t = hig_workarea_create ();
+    hig_workarea_add_section_title (t, &row, _("Desktop"));
 
-    s = _( "_Inhibit hibernation when torrents are active" );
-    w = new_check_button( s, PREF_KEY_INHIBIT_HIBERNATION, core );
-    hig_workarea_add_wide_control( t, &row, w );
+    s = _("_Inhibit hibernation when torrents are active");
+    w = new_check_button (s, PREF_KEY_INHIBIT_HIBERNATION, core);
+    hig_workarea_add_wide_control (t, &row, w);
 
-    s = _( "Show Transmission icon in the _notification area" );
-    w = new_check_button( s, PREF_KEY_SHOW_TRAY_ICON, core );
-    hig_workarea_add_wide_control( t, &row, w );
+    s = _("Show Transmission icon in the _notification area");
+    w = new_check_button (s, PREF_KEY_SHOW_TRAY_ICON, core);
+    hig_workarea_add_wide_control (t, &row, w);
 
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title ( t, &row, _( "Notification" ) );
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Notification"));
 
-    s = _( "Show a notification when torrents are a_dded" );
-    w = new_check_button( s, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, core );
-    hig_workarea_add_wide_control( t, &row, w );
+    s = _("Show a notification when torrents are a_dded");
+    w = new_check_button (s, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, core);
+    hig_workarea_add_wide_control (t, &row, w);
 
-    s = _( "Show a notification when torrents _finish" );
-    w = new_check_button( s, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, core );
-    hig_workarea_add_wide_control( t, &row, w );
+    s = _("Show a notification when torrents _finish");
+    w = new_check_button (s, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, core);
+    hig_workarea_add_wide_control (t, &row, w);
 
-    s = _( "Play a _sound when torrents finish" );
-    w = new_check_button( s, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, core );
-    hig_workarea_add_wide_control( t, &row, w );
+    s = _("Play a _sound when torrents finish");
+    w = new_check_button (s, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, core);
+    hig_workarea_add_wide_control (t, &row, w);
 
     return t;
 }
@@ -418,106 +418,106 @@ struct blocklist_data
 };
 
 static void
-updateBlocklistText( GtkWidget * w, TrCore * core )
+updateBlocklistText (GtkWidget * w, TrCore * core)
 {
     char buf1[512];
     char buf2[512];
-    const int n = tr_blocklistGetRuleCount( gtr_core_session( core ) );
-    g_snprintf( buf1, sizeof( buf1 ),
-                ngettext( "Blocklist contains %'d rule",
-                          "Blocklist contains %'d rules", n ), n );
-    g_snprintf( buf2, sizeof( buf2 ), "<i>%s</i>", buf1 );
-    gtk_label_set_markup( GTK_LABEL( w ), buf2 );
+    const int n = tr_blocklistGetRuleCount (gtr_core_session (core));
+    g_snprintf (buf1, sizeof (buf1),
+                ngettext ("Blocklist contains %'d rule",
+                          "Blocklist contains %'d rules", n), n);
+    g_snprintf (buf2, sizeof (buf2), "<i>%s</i>", buf1);
+    gtk_label_set_markup (GTK_LABEL (w), buf2);
 }
 
 /* prefs dialog is being destroyed, so stop listening to blocklist updates */
 static void
-privacyPageDestroyed( gpointer gdata, GObject * dead UNUSED )
+privacyPageDestroyed (gpointer gdata, GObject * dead UNUSED)
 {
     struct blocklist_data * data = gdata;
-    if( data->updateBlocklistTag > 0 )
-        g_signal_handler_disconnect( data->core, data->updateBlocklistTag );
-    g_free( data );
+    if (data->updateBlocklistTag > 0)
+        g_signal_handler_disconnect (data->core, data->updateBlocklistTag);
+    g_free (data);
 }
 
 /* user hit "close" in the blocklist-update dialog */
 static void
-onBlocklistUpdateResponse( GtkDialog * dialog, gint response UNUSED, gpointer gdata )
+onBlocklistUpdateResponse (GtkDialog * dialog, gint response UNUSED, gpointer gdata)
 {
     struct blocklist_data * data = gdata;
-    gtk_widget_destroy( GTK_WIDGET( dialog ) );
-    gtk_widget_set_sensitive( data->updateBlocklistButton, TRUE );
+    gtk_widget_destroy (GTK_WIDGET (dialog));
+    gtk_widget_set_sensitive (data->updateBlocklistButton, TRUE);
     data->updateBlocklistDialog = NULL;
-    g_signal_handler_disconnect( data->core, data->updateBlocklistTag );
+    g_signal_handler_disconnect (data->core, data->updateBlocklistTag);
 }
 
 /* core says the blocklist was updated */
 static void
-onBlocklistUpdated( TrCore * core, int n, gpointer gdata )
+onBlocklistUpdated (TrCore * core, int n, gpointer gdata)
 {
     const bool success = n >= 0;
-    const int count = n >=0 ? n : tr_blocklistGetRuleCount( gtr_core_session( core ) );
-    const char * s = ngettext( "Blocklist has %'d rule.", "Blocklist has %'d rules.", count );
+    const int count = n >=0 ? n : tr_blocklistGetRuleCount (gtr_core_session (core));
+    const char * s = ngettext ("Blocklist has %'d rule.", "Blocklist has %'d rules.", count);
     struct blocklist_data * data = gdata;
-    GtkMessageDialog * d = GTK_MESSAGE_DIALOG( data->updateBlocklistDialog );
-    gtk_widget_set_sensitive( data->updateBlocklistButton, TRUE );
-    gtk_message_dialog_set_markup( d, success ? _( "<b>Update succeeded!</b>" ) : _( "<b>Unable to update.</b>" ) );
-    gtk_message_dialog_format_secondary_text( d, s, count );
-    updateBlocklistText( data->label, core );
+    GtkMessageDialog * d = GTK_MESSAGE_DIALOG (data->updateBlocklistDialog);
+    gtk_widget_set_sensitive (data->updateBlocklistButton, TRUE);
+    gtk_message_dialog_set_markup (d, success ? _("<b>Update succeeded!</b>") : _("<b>Unable to update.</b>"));
+    gtk_message_dialog_format_secondary_text (d, s, count);
+    updateBlocklistText (data->label, core);
 }
 
 /* user pushed a button to update the blocklist */
 static void
-onBlocklistUpdate( GtkButton * w, gpointer gdata )
+onBlocklistUpdate (GtkButton * w, gpointer gdata)
 {
     GtkWidget * d;
     struct blocklist_data * data = gdata;
-    d = gtk_message_dialog_new( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( w ) ) ),
+    d = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (w))),
                                 GTK_DIALOG_DESTROY_WITH_PARENT,
                                 GTK_MESSAGE_INFO,
                                 GTK_BUTTONS_CLOSE,
-                                "%s", _( "Update Blocklist" ) );
-    gtk_widget_set_sensitive( data->updateBlocklistButton, FALSE );
-    gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( d ), "%s", _( "Getting new blocklist…" ) );
+                                "%s", _("Update Blocklist"));
+    gtk_widget_set_sensitive (data->updateBlocklistButton, FALSE);
+    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (d), "%s", _("Getting new blocklist…"));
     data->updateBlocklistDialog = d;
-    g_signal_connect( d, "response", G_CALLBACK(onBlocklistUpdateResponse), data );
-    gtk_widget_show( d );
-    gtr_core_blocklist_update( data->core );
-    data->updateBlocklistTag = g_signal_connect( data->core, "blocklist-updated", G_CALLBACK( onBlocklistUpdated ), data );
+    g_signal_connect (d, "response", G_CALLBACK (onBlocklistUpdateResponse), data);
+    gtk_widget_show (d);
+    gtr_core_blocklist_update (data->core);
+    data->updateBlocklistTag = g_signal_connect (data->core, "blocklist-updated", G_CALLBACK (onBlocklistUpdated), data);
 }
 
 static void
-on_blocklist_url_changed( GtkEditable * e, gpointer gbutton )
+on_blocklist_url_changed (GtkEditable * e, gpointer gbutton)
 {
-    gchar * url = gtk_editable_get_chars( e, 0, -1 );
-    const gboolean err = tr_urlParse( url, -1, NULL, NULL, NULL, NULL );
-    gtk_widget_set_sensitive( GTK_WIDGET( gbutton ), !err );
-    g_free( url );
+    gchar * url = gtk_editable_get_chars (e, 0, -1);
+    const gboolean err = tr_urlParse (url, -1, NULL, NULL, NULL, NULL);
+    gtk_widget_set_sensitive (GTK_WIDGET (gbutton), !err);
+    g_free (url);
 }
 
 static void
-onIntComboChanged( GtkComboBox * combo_box, gpointer core )
+onIntComboChanged (GtkComboBox * combo_box, gpointer core)
 {
-    const int val = gtr_combo_box_get_active_enum( combo_box );
-    const char * key = g_object_get_data( G_OBJECT( combo_box ), PREF_KEY );
-    gtr_core_set_pref_int( TR_CORE( core ), key, val );
+    const int val = gtr_combo_box_get_active_enum (combo_box);
+    const char * key = g_object_get_data (G_OBJECT (combo_box), PREF_KEY);
+    gtr_core_set_pref_int (TR_CORE (core), key, val);
 }
 
 static GtkWidget*
-new_encryption_combo( GObject * core, const char * key )
+new_encryption_combo (GObject * core, const char * key)
 {
-    GtkWidget * w = gtr_combo_box_new_enum( _( "Allow encryption" ),   TR_CLEAR_PREFERRED,
-                                            _( "Prefer encryption" ),  TR_ENCRYPTION_PREFERRED,
-                                            _( "Require encryption" ), TR_ENCRYPTION_REQUIRED,
-                                            NULL );
-    gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( key ) );
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup( key ), g_free );
-    g_signal_connect( w, "changed", G_CALLBACK( onIntComboChanged ), core );
+    GtkWidget * w = gtr_combo_box_new_enum (_("Allow encryption"),   TR_CLEAR_PREFERRED,
+                                            _("Prefer encryption"),  TR_ENCRYPTION_PREFERRED,
+                                            _("Require encryption"), TR_ENCRYPTION_REQUIRED,
+                                            NULL);
+    gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (key));
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, tr_strdup (key), g_free);
+    g_signal_connect (w, "changed", G_CALLBACK (onIntComboChanged), core);
     return w;
 }
 
 static GtkWidget*
-privacyPage( GObject * core )
+privacyPage (GObject * core)
 {
     const char * s;
     GtkWidget * t;
@@ -528,67 +528,67 @@ privacyPage( GObject * core )
     struct blocklist_data * data;
     guint row = 0;
 
-    data = g_new0( struct blocklist_data, 1 );
-    data->core = TR_CORE( core );
+    data = g_new0 (struct blocklist_data, 1);
+    data->core = TR_CORE (core);
 
-    t = hig_workarea_create( );
-    hig_workarea_add_section_title( t, &row, _( "Blocklist" ) );
+    t = hig_workarea_create ();
+    hig_workarea_add_section_title (t, &row, _("Blocklist"));
 
-    b = new_check_button( _( "Enable _blocklist:" ), TR_PREFS_KEY_BLOCKLIST_ENABLED, core );
-    e = new_entry( TR_PREFS_KEY_BLOCKLIST_URL, core );
-    gtk_widget_set_size_request( e, 300, -1 );
-    hig_workarea_add_row_w( t, &row, b, e, NULL );
+    b = new_check_button (_("Enable _blocklist:"), TR_PREFS_KEY_BLOCKLIST_ENABLED, core);
+    e = new_entry (TR_PREFS_KEY_BLOCKLIST_URL, core);
+    gtk_widget_set_size_request (e, 300, -1);
+    hig_workarea_add_row_w (t, &row, b, e, NULL);
     data->check = b;
-    g_signal_connect( b, "toggled", G_CALLBACK( target_cb ), e );
-    target_cb( b, e );
+    g_signal_connect (b, "toggled", G_CALLBACK (target_cb), e);
+    target_cb (b, e);
 
-    w = gtk_label_new( "" );
-    gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
-    updateBlocklistText( w, TR_CORE( core ) );
+    w = gtk_label_new ("");
+    gtk_misc_set_alignment (GTK_MISC (w), 0.0f, 0.5f);
+    updateBlocklistText (w, TR_CORE (core));
     data->label = w;
-    h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG );
-    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
-    b = data->updateBlocklistButton = gtk_button_new_with_mnemonic( _( "_Update" ) );
-    g_object_set_data( G_OBJECT( b ), "session", gtr_core_session( TR_CORE( core ) ) );
-    g_signal_connect( b, "clicked", G_CALLBACK( onBlocklistUpdate ), data );
-    g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), b ); target_cb( data->check, b );
-    gtk_box_pack_start( GTK_BOX( h ), b, FALSE, FALSE, 0 );
-    g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), w ); target_cb( data->check, w );
-    hig_workarea_add_wide_control( t, &row, h );
-    g_signal_connect( e, "changed", G_CALLBACK( on_blocklist_url_changed ), data->updateBlocklistButton );
-    on_blocklist_url_changed( GTK_EDITABLE( e ), data->updateBlocklistButton );
-
-    s = _( "Enable _automatic updates" );
-    w = new_check_button( s, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, core );
-    hig_workarea_add_wide_control( t, &row, w );
-    g_signal_connect( data->check, "toggled", G_CALLBACK( target_cb ), w ); target_cb( data->check, w );
-
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title ( t, &row, _( "Privacy" ) );
-
-    s = _( "_Encryption mode:" );
-    w = new_encryption_combo( core, "encryption" );
-    hig_workarea_add_row( t, &row, s, w, NULL );
-
-    s = _( "Use PE_X to find more peers" );
-    w = new_check_button( s, TR_PREFS_KEY_PEX_ENABLED, core );
-    s = _( "PEX is a tool for exchanging peer lists with the peers you're connected to." );
-    gtk_widget_set_tooltip_text( w, s );
-    hig_workarea_add_wide_control( t, &row, w );
-
-    s = _( "Use _DHT to find more peers" );
-    w = new_check_button( s, TR_PREFS_KEY_DHT_ENABLED, core );
-    s = _( "DHT is a tool for finding peers without a tracker." );
-    gtk_widget_set_tooltip_text( w, s );
-    hig_workarea_add_wide_control( t, &row, w );
-
-    s = _( "Use _Local Peer Discovery to find more peers" );
-    w = new_check_button( s, TR_PREFS_KEY_LPD_ENABLED, core );
-    s = _( "LPD is a tool for finding peers on your local network." );
-    gtk_widget_set_tooltip_text( w, s );
-    hig_workarea_add_wide_control( t, &row, w );
-
-    g_object_weak_ref( G_OBJECT( t ), privacyPageDestroyed, data );
+    h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
+    gtk_box_pack_start (GTK_BOX (h), w, TRUE, TRUE, 0);
+    b = data->updateBlocklistButton = gtk_button_new_with_mnemonic (_("_Update"));
+    g_object_set_data (G_OBJECT (b), "session", gtr_core_session (TR_CORE (core)));
+    g_signal_connect (b, "clicked", G_CALLBACK (onBlocklistUpdate), data);
+    g_signal_connect (data->check, "toggled", G_CALLBACK (target_cb), b); target_cb (data->check, b);
+    gtk_box_pack_start (GTK_BOX (h), b, FALSE, FALSE, 0);
+    g_signal_connect (data->check, "toggled", G_CALLBACK (target_cb), w); target_cb (data->check, w);
+    hig_workarea_add_wide_control (t, &row, h);
+    g_signal_connect (e, "changed", G_CALLBACK (on_blocklist_url_changed), data->updateBlocklistButton);
+    on_blocklist_url_changed (GTK_EDITABLE (e), data->updateBlocklistButton);
+
+    s = _("Enable _automatic updates");
+    w = new_check_button (s, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, core);
+    hig_workarea_add_wide_control (t, &row, w);
+    g_signal_connect (data->check, "toggled", G_CALLBACK (target_cb), w); target_cb (data->check, w);
+
+    hig_workarea_add_section_divider (t, &row);
+    hig_workarea_add_section_title (t, &row, _("Privacy"));
+
+    s = _("_Encryption mode:");
+    w = new_encryption_combo (core, "encryption");
+    hig_workarea_add_row (t, &row, s, w, NULL);
+
+    s = _("Use PE_X to find more peers");
+    w = new_check_button (s, TR_PREFS_KEY_PEX_ENABLED, core);
+    s = _("PEX is a tool for exchanging peer lists with the peers you're connected to.");
+    gtk_widget_set_tooltip_text (w, s);
+    hig_workarea_add_wide_control (t, &row, w);
+
+    s = _("Use _DHT to find more peers");
+    w = new_check_button (s, TR_PREFS_KEY_DHT_ENABLED, core);
+    s = _("DHT is a tool for finding peers without a tracker.");
+    gtk_widget_set_tooltip_text (w, s);
+    hig_workarea_add_wide_control (t, &row, w);
+
+    s = _("Use _Local Peer Discovery to find more peers");
+    w = new_check_button (s, TR_PREFS_KEY_LPD_ENABLED, core);
+    s = _("LPD is a tool for finding peers on your local network.");
+    gtk_widget_set_tooltip_text (w, s);
+    hig_workarea_add_wide_control (t, &row, w);
+
+    g_object_weak_ref (G_OBJECT (t), privacyPageDestroyed, data);
     return t;
 }
 
@@ -603,27 +603,27 @@ enum
 };
 
 static GtkTreeModel*
-whitelist_tree_model_new( const char * whitelist )
+whitelist_tree_model_new (const char * whitelist)
 {
     int            i;
     char **        rules;
-    GtkListStore * store = gtk_list_store_new( N_COLS,
+    GtkListStore * store = gtk_list_store_new (N_COLS,
                                                G_TYPE_STRING,
-                                               G_TYPE_STRING );
+                                               G_TYPE_STRING);
 
-    rules = g_strsplit( whitelist, ",", 0 );
+    rules = g_strsplit (whitelist, ",", 0);
 
-    for( i = 0; rules && rules[i]; ++i )
+    for (i = 0; rules && rules[i]; ++i)
     {
         GtkTreeIter iter;
         const char * s = rules[i];
-        while( isspace( *s ) ) ++s;
-        gtk_list_store_append( store, &iter );
-        gtk_list_store_set( store, &iter, COL_ADDRESS, s, -1 );
+        while (isspace (*s)) ++s;
+        gtk_list_store_append (store, &iter);
+        gtk_list_store_set (store, &iter, COL_ADDRESS, s, -1);
     }
 
-    g_strfreev( rules );
-    return GTK_TREE_MODEL( store );
+    g_strfreev (rules);
+    return GTK_TREE_MODEL (store);
 }
 
 struct remote_page
@@ -641,221 +641,221 @@ struct remote_page
 };
 
 static void
-refreshWhitelist( struct remote_page * page )
+refreshWhitelist (struct remote_page * page)
 {
     GtkTreeIter iter;
-    GString * gstr = g_string_new( NULL );
-    GtkTreeModel * model = GTK_TREE_MODEL( page->store );
+    GString * gstr = g_string_new (NULL);
+    GtkTreeModel * model = GTK_TREE_MODEL (page->store);
 
-    if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
+    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
     {
         char * address;
-        gtk_tree_model_get( model, &iter, COL_ADDRESS, &address, -1 );
-        g_string_append( gstr, address );
-        g_string_append( gstr, "," );
-        g_free( address );
+        gtk_tree_model_get (model, &iter, COL_ADDRESS, &address, -1);
+        g_string_append (gstr, address);
+        g_string_append (gstr, ",");
+        g_free (address);
     }
-    while( gtk_tree_model_iter_next( model, &iter ) );
+    while (gtk_tree_model_iter_next (model, &iter));
 
-    g_string_truncate( gstr, gstr->len - 1 ); /* remove the trailing comma */
+    g_string_truncate (gstr, gstr->len - 1); /* remove the trailing comma */
 
-    gtr_core_set_pref( page->core, TR_PREFS_KEY_RPC_WHITELIST, gstr->str );
+    gtr_core_set_pref (page->core, TR_PREFS_KEY_RPC_WHITELIST, gstr->str);
 
-    g_string_free( gstr, TRUE );
+    g_string_free (gstr, TRUE);
 }
 
 static void
-onAddressEdited( GtkCellRendererText  * r UNUSED,
+onAddressEdited (GtkCellRendererText  * r UNUSED,
                  gchar *                  path_string,
                  gchar *                  address,
-                 gpointer                 gpage )
+                 gpointer                 gpage)
 {
     GtkTreeIter          iter;
     struct remote_page * page = gpage;
-    GtkTreeModel *       model = GTK_TREE_MODEL( page->store );
-    GtkTreePath *        path = gtk_tree_path_new_from_string( path_string );
+    GtkTreeModel *       model = GTK_TREE_MODEL (page->store);
+    GtkTreePath *        path = gtk_tree_path_new_from_string (path_string);
 
-    if( gtk_tree_model_get_iter( model, &iter, path ) )
-        gtk_list_store_set( page->store, &iter, COL_ADDRESS, address, -1 );
+    if (gtk_tree_model_get_iter (model, &iter, path))
+        gtk_list_store_set (page->store, &iter, COL_ADDRESS, address, -1);
 
-    gtk_tree_path_free( path );
-    refreshWhitelist( page );
+    gtk_tree_path_free (path);
+    refreshWhitelist (page);
 }
 
 static void
-onAddWhitelistClicked( GtkButton * b UNUSED,
-                 gpointer      gpage )
+onAddWhitelistClicked (GtkButton * b UNUSED,
+                 gpointer      gpage)
 {
     GtkTreeIter          iter;
     GtkTreePath *        path;
     struct remote_page * page = gpage;
 
-    gtk_list_store_append( page->store, &iter );
-    gtk_list_store_set( page->store, &iter,
+    gtk_list_store_append (page->store, &iter);
+    gtk_list_store_set (page->store, &iter,
                         COL_ADDRESS,  "0.0.0.0",
-                        -1 );
+                        -1);
 
-    path = gtk_tree_model_get_path( GTK_TREE_MODEL( page->store ), &iter );
-    gtk_tree_view_set_cursor(
+    path = gtk_tree_model_get_path (GTK_TREE_MODEL (page->store), &iter);
+    gtk_tree_view_set_cursor (
         page->view, path,
-        gtk_tree_view_get_column( page->view, COL_ADDRESS ),
-        TRUE );
-    gtk_tree_path_free( path );
+        gtk_tree_view_get_column (page->view, COL_ADDRESS),
+        TRUE);
+    gtk_tree_path_free (path);
 }
 
 static void
-onRemoveWhitelistClicked( GtkButton * b UNUSED,
-                    gpointer      gpage )
+onRemoveWhitelistClicked (GtkButton * b UNUSED,
+                    gpointer      gpage)
 {
     struct remote_page * page = gpage;
-    GtkTreeSelection *   sel = gtk_tree_view_get_selection( page->view );
+    GtkTreeSelection *   sel = gtk_tree_view_get_selection (page->view);
     GtkTreeIter          iter;
 
-    if( gtk_tree_selection_get_selected( sel, NULL, &iter ) )
+    if (gtk_tree_selection_get_selected (sel, NULL, &iter))
     {
-        gtk_list_store_remove( page->store, &iter );
-        refreshWhitelist( page );
+        gtk_list_store_remove (page->store, &iter);
+        refreshWhitelist (page);
     }
 }
 
 static void
-refreshRPCSensitivity( struct remote_page * page )
+refreshRPCSensitivity (struct remote_page * page)
 {
     GSList *           l;
-    const int          rpc_active = gtk_toggle_button_get_active(
-        page->rpc_tb );
-    const int          auth_active = gtk_toggle_button_get_active(
-        page->auth_tb );
-    const int          whitelist_active = gtk_toggle_button_get_active(
-        page->whitelist_tb );
-    GtkTreeSelection * sel = gtk_tree_view_get_selection( page->view );
+    const int          rpc_active = gtk_toggle_button_get_active (
+        page->rpc_tb);
+    const int          auth_active = gtk_toggle_button_get_active (
+        page->auth_tb);
+    const int          whitelist_active = gtk_toggle_button_get_active (
+        page->whitelist_tb);
+    GtkTreeSelection * sel = gtk_tree_view_get_selection (page->view);
     const int          have_addr =
-        gtk_tree_selection_get_selected( sel, NULL,
-                                         NULL );
-    const int          n_rules = gtk_tree_model_iter_n_children(
-        GTK_TREE_MODEL( page->store ), NULL );
+        gtk_tree_selection_get_selected (sel, NULL,
+                                         NULL);
+    const int          n_rules = gtk_tree_model_iter_n_children (
+        GTK_TREE_MODEL (page->store), NULL);
 
-    for( l = page->widgets; l != NULL; l = l->next )
-        gtk_widget_set_sensitive( GTK_WIDGET( l->data ), rpc_active );
+    for (l = page->widgets; l != NULL; l = l->next)
+        gtk_widget_set_sensitive (GTK_WIDGET (l->data), rpc_active);
 
-    for( l = page->auth_widgets; l != NULL; l = l->next )
-        gtk_widget_set_sensitive( GTK_WIDGET(
-                                      l->data ), rpc_active && auth_active );
+    for (l = page->auth_widgets; l != NULL; l = l->next)
+        gtk_widget_set_sensitive (GTK_WIDGET (
+                                      l->data), rpc_active && auth_active);
 
-    for( l = page->whitelist_widgets; l != NULL; l = l->next )
-        gtk_widget_set_sensitive( GTK_WIDGET( l->data ),
-                                  rpc_active && whitelist_active );
+    for (l = page->whitelist_widgets; l != NULL; l = l->next)
+        gtk_widget_set_sensitive (GTK_WIDGET (l->data),
+                                  rpc_active && whitelist_active);
 
-    gtk_widget_set_sensitive( page->remove_button,
-                              rpc_active && have_addr && n_rules > 1 );
+    gtk_widget_set_sensitive (page->remove_button,
+                              rpc_active && have_addr && n_rules > 1);
 }
 
 static void
-onRPCToggled( GtkToggleButton * tb UNUSED,
-              gpointer             page )
+onRPCToggled (GtkToggleButton * tb UNUSED,
+              gpointer             page)
 {
-    refreshRPCSensitivity( page );
+    refreshRPCSensitivity (page);
 }
 
 static void
-onWhitelistSelectionChanged( GtkTreeSelection * sel UNUSED,
-                       gpointer               page )
+onWhitelistSelectionChanged (GtkTreeSelection * sel UNUSED,
+                       gpointer               page)
 {
-    refreshRPCSensitivity( page );
+    refreshRPCSensitivity (page);
 }
 
 static void
-onLaunchClutchCB( GtkButton * w UNUSED, gpointer data UNUSED )
+onLaunchClutchCB (GtkButton * w UNUSED, gpointer data UNUSED)
 {
-    const int port = gtr_pref_int_get( TR_PREFS_KEY_RPC_PORT );
-    char * uri = g_strdup_printf( "http://localhost:%d/", port );
+    const int port = gtr_pref_int_get (TR_PREFS_KEY_RPC_PORT);
+    char * uri = g_strdup_printf ("http://localhost:%d/", port);
 
-    gtr_open_uri( uri );
-    g_free( uri );
+    gtr_open_uri (uri);
+    g_free (uri);
 }
 
 static void
-remotePageFree( gpointer gpage )
+remotePageFree (gpointer gpage)
 {
     struct remote_page * page = gpage;
 
-    g_slist_free( page->widgets );
-    g_slist_free( page->auth_widgets );
-    g_slist_free( page->whitelist_widgets );
-    g_free( page );
+    g_slist_free (page->widgets);
+    g_slist_free (page->auth_widgets);
+    g_slist_free (page->whitelist_widgets);
+    g_free (page);
 }
 
 static GtkWidget*
-webPage( GObject * core )
+webPage (GObject * core)
 {
     GtkWidget * t;
     GtkWidget * w;
     GtkWidget * h;
     const char * s;
     guint row = 0;
-    struct remote_page * page = g_new0( struct remote_page, 1 );
+    struct remote_page * page = g_new0 (struct remote_page, 1);
 
-    page->core = TR_CORE( core );
+    page->core = TR_CORE (core);
 
-    t = hig_workarea_create( );
-    g_object_set_data_full( G_OBJECT( t ), "page", page, remotePageFree );
+    t = hig_workarea_create ();
+    g_object_set_data_full (G_OBJECT (t), "page", page, remotePageFree);
 
-    hig_workarea_add_section_title( t, &row, _( "Web Client" ) );
+    hig_workarea_add_section_title (t, &row, _("Web Client"));
 
     /* "enabled" checkbutton */
-    s = _( "_Enable web client" );
-    w = new_check_button( s, TR_PREFS_KEY_RPC_ENABLED, core );
-    page->rpc_tb = GTK_TOGGLE_BUTTON( w );
-    g_signal_connect( w, "clicked", G_CALLBACK( onRPCToggled ), page );
-    h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG );
-    gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
-    w = gtk_button_new_with_mnemonic( _( "_Open web client" ) );
-    page->widgets = g_slist_prepend( page->widgets, w );
-    g_signal_connect( w, "clicked", G_CALLBACK( onLaunchClutchCB ), NULL );
-    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
-    hig_workarea_add_wide_control( t, &row, h );
+    s = _("_Enable web client");
+    w = new_check_button (s, TR_PREFS_KEY_RPC_ENABLED, core);
+    page->rpc_tb = GTK_TOGGLE_BUTTON (w);
+    g_signal_connect (w, "clicked", G_CALLBACK (onRPCToggled), page);
+    h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
+    gtk_box_pack_start (GTK_BOX (h), w, TRUE, TRUE, 0);
+    w = gtk_button_new_with_mnemonic (_("_Open web client"));
+    page->widgets = g_slist_prepend (page->widgets, w);
+    g_signal_connect (w, "clicked", G_CALLBACK (onLaunchClutchCB), NULL);
+    gtk_box_pack_start (GTK_BOX (h), w, FALSE, FALSE, 0);
+    hig_workarea_add_wide_control (t, &row, h);
 
     /* port */
-    w = new_spin_button( TR_PREFS_KEY_RPC_PORT, core, 0, USHRT_MAX, 1 );
-    page->widgets = g_slist_prepend( page->widgets, w );
-    w = hig_workarea_add_row( t, &row, _( "HTTP _port:" ), w, NULL );
-    page->widgets = g_slist_prepend( page->widgets, w );
+    w = new_spin_button (TR_PREFS_KEY_RPC_PORT, core, 0, USHRT_MAX, 1);
+    page->widgets = g_slist_prepend (page->widgets, w);
+    w = hig_workarea_add_row (t, &row, _("HTTP _port:"), w, NULL);
+    page->widgets = g_slist_prepend (page->widgets, w);
 
     /* require authentication */
-    s = _( "Use _authentication" );
-    w = new_check_button( s, TR_PREFS_KEY_RPC_AUTH_REQUIRED, core );
-    hig_workarea_add_wide_control( t, &row, w );
-    page->auth_tb = GTK_TOGGLE_BUTTON( w );
-    page->widgets = g_slist_prepend( page->widgets, w );
-    g_signal_connect( w, "clicked", G_CALLBACK( onRPCToggled ), page );
+    s = _("Use _authentication");
+    w = new_check_button (s, TR_PREFS_KEY_RPC_AUTH_REQUIRED, core);
+    hig_workarea_add_wide_control (t, &row, w);
+    page->auth_tb = GTK_TOGGLE_BUTTON (w);
+    page->widgets = g_slist_prepend (page->widgets, w);
+    g_signal_connect (w, "clicked", G_CALLBACK (onRPCToggled), page);
 
     /* username */
-    s = _( "_Username:" );
-    w = new_entry( TR_PREFS_KEY_RPC_USERNAME, core );
-    page->auth_widgets = g_slist_prepend( page->auth_widgets, w );
-    w = hig_workarea_add_row( t, &row, s, w, NULL );
-    page->auth_widgets = g_slist_prepend( page->auth_widgets, w );
+    s = _("_Username:");
+    w = new_entry (TR_PREFS_KEY_RPC_USERNAME, core);
+    page->auth_widgets = g_slist_prepend (page->auth_widgets, w);
+    w = hig_workarea_add_row (t, &row, s, w, NULL);
+    page->auth_widgets = g_slist_prepend (page->auth_widgets, w);
 
     /* password */
-    s = _( "Pass_word:" );
-    w = new_entry( TR_PREFS_KEY_RPC_PASSWORD, core );
-    gtk_entry_set_visibility( GTK_ENTRY( w ), FALSE );
-    page->auth_widgets = g_slist_prepend( page->auth_widgets, w );
-    w = hig_workarea_add_row( t, &row, s, w, NULL );
-    page->auth_widgets = g_slist_prepend( page->auth_widgets, w );
+    s = _("Pass_word:");
+    w = new_entry (TR_PREFS_KEY_RPC_PASSWORD, core);
+    gtk_entry_set_visibility (GTK_ENTRY (w), FALSE);
+    page->auth_widgets = g_slist_prepend (page->auth_widgets, w);
+    w = hig_workarea_add_row (t, &row, s, w, NULL);
+    page->auth_widgets = g_slist_prepend (page->auth_widgets, w);
 
     /* require authentication */
-    s = _( "Only allow these IP a_ddresses to connect:" );
-    w = new_check_button( s, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, core );
-    hig_workarea_add_wide_control( t, &row, w );
-    page->whitelist_tb = GTK_TOGGLE_BUTTON( w );
-    page->widgets = g_slist_prepend( page->widgets, w );
-    g_signal_connect( w, "clicked", G_CALLBACK( onRPCToggled ), page );
+    s = _("Only allow these IP a_ddresses to connect:");
+    w = new_check_button (s, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, core);
+    hig_workarea_add_wide_control (t, &row, w);
+    page->whitelist_tb = GTK_TOGGLE_BUTTON (w);
+    page->widgets = g_slist_prepend (page->widgets, w);
+    g_signal_connect (w, "clicked", G_CALLBACK (onRPCToggled), page);
 
     /* access control list */
     {
-        const char *        val = gtr_pref_string_get( TR_PREFS_KEY_RPC_WHITELIST );
-        GtkTreeModel *      m = whitelist_tree_model_new( val );
+        const char *        val = gtr_pref_string_get (TR_PREFS_KEY_RPC_WHITELIST);
+        GtkTreeModel *      m = whitelist_tree_model_new (val);
         GtkTreeViewColumn * c;
         GtkCellRenderer *   r;
         GtkTreeSelection *  sel;
@@ -863,60 +863,60 @@ webPage( GObject * core )
         GtkWidget *         w;
         GtkWidget *         h;
 
-        page->store = GTK_LIST_STORE( m );
-        w = gtk_tree_view_new_with_model( m );
-        g_signal_connect( w, "button-release-event",
-                          G_CALLBACK( on_tree_view_button_released ), NULL );
-
-        page->whitelist_widgets = g_slist_prepend( page->whitelist_widgets, w );
-        v = page->view = GTK_TREE_VIEW( w );
-        gtk_widget_set_tooltip_text( w, _( "IP addresses may use wildcards, such as 192.168.*.*" ) );
-        sel = gtk_tree_view_get_selection( v );
-        g_signal_connect( sel, "changed",
-                          G_CALLBACK( onWhitelistSelectionChanged ), page );
-        g_object_unref( G_OBJECT( m ) );
-        gtk_tree_view_set_headers_visible( v, TRUE );
-        w = gtk_frame_new( NULL );
-        gtk_frame_set_shadow_type( GTK_FRAME( w ), GTK_SHADOW_IN );
-        gtk_container_add( GTK_CONTAINER( w ), GTK_WIDGET( v ) );
+        page->store = GTK_LIST_STORE (m);
+        w = gtk_tree_view_new_with_model (m);
+        g_signal_connect (w, "button-release-event",
+                          G_CALLBACK (on_tree_view_button_released), NULL);
+
+        page->whitelist_widgets = g_slist_prepend (page->whitelist_widgets, w);
+        v = page->view = GTK_TREE_VIEW (w);
+        gtk_widget_set_tooltip_text (w, _("IP addresses may use wildcards, such as 192.168.*.*"));
+        sel = gtk_tree_view_get_selection (v);
+        g_signal_connect (sel, "changed",
+                          G_CALLBACK (onWhitelistSelectionChanged), page);
+        g_object_unref (G_OBJECT (m));
+        gtk_tree_view_set_headers_visible (v, TRUE);
+        w = gtk_frame_new (NULL);
+        gtk_frame_set_shadow_type (GTK_FRAME (w), GTK_SHADOW_IN);
+        gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (v));
 
         /* ip address column */
-        r = gtk_cell_renderer_text_new( );
-        g_signal_connect( r, "edited",
-                          G_CALLBACK( onAddressEdited ), page );
-        g_object_set( G_OBJECT( r ), "editable", TRUE, NULL );
-        c = gtk_tree_view_column_new_with_attributes( NULL, r,
+        r = gtk_cell_renderer_text_new ();
+        g_signal_connect (r, "edited",
+                          G_CALLBACK (onAddressEdited), page);
+        g_object_set (G_OBJECT (r), "editable", TRUE, NULL);
+        c = gtk_tree_view_column_new_with_attributes (NULL, r,
                                                       "text", COL_ADDRESS,
-                                                      NULL );
-        gtk_tree_view_column_set_expand( c, TRUE );
-        gtk_tree_view_append_column( v, c );
-        gtk_tree_view_set_headers_visible( v, FALSE );
-
-        s = _( "Addresses:" );
-        w = hig_workarea_add_row( t, &row, s, w, NULL );
-        gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.0f );
-        gtk_misc_set_padding( GTK_MISC( w ), 0, GUI_PAD );
-        page->whitelist_widgets = g_slist_prepend( page->whitelist_widgets, w );
-
-        h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD );
-        w = gtk_button_new_from_stock( GTK_STOCK_REMOVE );
-        g_signal_connect( w, "clicked", G_CALLBACK(
-                              onRemoveWhitelistClicked ), page );
+                                                      NULL);
+        gtk_tree_view_column_set_expand (c, TRUE);
+        gtk_tree_view_append_column (v, c);
+        gtk_tree_view_set_headers_visible (v, FALSE);
+
+        s = _("Addresses:");
+        w = hig_workarea_add_row (t, &row, s, w, NULL);
+        gtk_misc_set_alignment (GTK_MISC (w), 0.0f, 0.0f);
+        gtk_misc_set_padding (GTK_MISC (w), 0, GUI_PAD);
+        page->whitelist_widgets = g_slist_prepend (page->whitelist_widgets, w);
+
+        h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
+        w = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
+        g_signal_connect (w, "clicked", G_CALLBACK (
+                              onRemoveWhitelistClicked), page);
         page->remove_button = w;
-        onWhitelistSelectionChanged( sel, page );
-        gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
-        w = gtk_button_new_from_stock( GTK_STOCK_ADD );
-        page->whitelist_widgets = g_slist_prepend( page->whitelist_widgets, w );
-        g_signal_connect( w, "clicked", G_CALLBACK( onAddWhitelistClicked ), page );
-        gtk_box_pack_start( GTK_BOX( h ), w, TRUE, TRUE, 0 );
-        w = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 );
-        gtk_box_pack_start( GTK_BOX( w ), gtk_alignment_new( 0, 0, 0, 0 ),
-                            TRUE, TRUE, 0 );
-        gtk_box_pack_start( GTK_BOX( w ), h, FALSE, FALSE, 0 );
-        hig_workarea_add_wide_control( t, &row, w );
+        onWhitelistSelectionChanged (sel, page);
+        gtk_box_pack_start (GTK_BOX (h), w, TRUE, TRUE, 0);
+        w = gtk_button_new_from_stock (GTK_STOCK_ADD);
+        page->whitelist_widgets = g_slist_prepend (page->whitelist_widgets, w);
+        g_signal_connect (w, "clicked", G_CALLBACK (onAddWhitelistClicked), page);
+        gtk_box_pack_start (GTK_BOX (h), w, TRUE, TRUE, 0);
+        w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+        gtk_box_pack_start (GTK_BOX (w), gtk_alignment_new (0, 0, 0, 0),
+                            TRUE, TRUE, 0);
+        gtk_box_pack_start (GTK_BOX (w), h, FALSE, FALSE, 0);
+        hig_workarea_add_wide_control (t, &row, w);
     }
 
-    refreshRPCSensitivity( page );
+    refreshRPCSensitivity (page);
     return t;
 }
 
@@ -931,41 +931,41 @@ struct BandwidthPage
 };
 
 static void
-refreshSchedSensitivity( struct BandwidthPage * p )
+refreshSchedSensitivity (struct BandwidthPage * p)
 {
     GSList *       l;
-    const gboolean sched_enabled = gtr_pref_flag_get( TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED );
+    const gboolean sched_enabled = gtr_pref_flag_get (TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED);
 
-    for( l = p->sched_widgets; l != NULL; l = l->next )
-        gtk_widget_set_sensitive( GTK_WIDGET( l->data ), sched_enabled );
+    for (l = p->sched_widgets; l != NULL; l = l->next)
+        gtk_widget_set_sensitive (GTK_WIDGET (l->data), sched_enabled);
 }
 
 static void
-onSchedToggled( GtkToggleButton * tb UNUSED,
-                gpointer             user_data )
+onSchedToggled (GtkToggleButton * tb UNUSED,
+                gpointer             user_data)
 {
-    refreshSchedSensitivity( user_data );
+    refreshSchedSensitivity (user_data);
 }
 
 static void
-onTimeComboChanged( GtkComboBox * w,
-                    gpointer      core )
+onTimeComboChanged (GtkComboBox * w,
+                    gpointer      core)
 {
     GtkTreeIter iter;
 
-    if( gtk_combo_box_get_active_iter( w, &iter ) )
+    if (gtk_combo_box_get_active_iter (w, &iter))
     {
-        const char * key = g_object_get_data( G_OBJECT( w ), PREF_KEY );
+        const char * key = g_object_get_data (G_OBJECT (w), PREF_KEY);
         int          val = 0;
-        gtk_tree_model_get( gtk_combo_box_get_model(
-                                w ), &iter, 0, &val, -1 );
-        gtr_core_set_pref_int( TR_CORE( core ), key, val );
+        gtk_tree_model_get (gtk_combo_box_get_model (
+                                w), &iter, 0, &val, -1);
+        gtr_core_set_pref_int (TR_CORE (core), key, val);
     }
 }
 
 static GtkWidget*
-new_time_combo( GObject *    core,
-                const char * key )
+new_time_combo (GObject *    core,
+                const char * key)
 {
     int               val;
     int               i;
@@ -974,8 +974,8 @@ new_time_combo( GObject *    core,
     GtkListStore *    store;
 
     /* build a store at 15 minute intervals */
-    store = gtk_list_store_new( 2, G_TYPE_INT, G_TYPE_STRING );
-    for( i = 0; i < 60 * 24; i += 15 )
+    store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
+    for (i = 0; i < 60 * 24; i += 15)
     {
         char        buf[128];
         GtkTreeIter iter;
@@ -983,60 +983,60 @@ new_time_combo( GObject *    core,
         tm.tm_hour = i / 60;
         tm.tm_min = i % 60;
         tm.tm_sec = 0;
-        strftime( buf, sizeof( buf ), "%H:%M", &tm );
-        gtk_list_store_append( store, &iter );
-        gtk_list_store_set( store, &iter, 0, i, 1, buf, -1 );
+        strftime (buf, sizeof (buf), "%H:%M", &tm);
+        gtk_list_store_append (store, &iter);
+        gtk_list_store_set (store, &iter, 0, i, 1, buf, -1);
     }
 
     /* build the widget */
-    w = gtk_combo_box_new_with_model( GTK_TREE_MODEL( store ) );
-    gtk_combo_box_set_wrap_width( GTK_COMBO_BOX( w ), 4 );
-    r = gtk_cell_renderer_text_new( );
-    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( w ), r, TRUE );
-    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(
-                                        w ), r, "text", 1, NULL );
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup(
-                                key ), g_free );
-    val = gtr_pref_int_get( key );
-    gtk_combo_box_set_active( GTK_COMBO_BOX( w ), val / ( 15 ) );
-    g_signal_connect( w, "changed", G_CALLBACK( onTimeComboChanged ), core );
+    w = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
+    gtk_combo_box_set_wrap_width (GTK_COMBO_BOX (w), 4);
+    r = gtk_cell_renderer_text_new ();
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (w), r, TRUE);
+    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (
+                                        w), r, "text", 1, NULL);
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, tr_strdup (
+                                key), g_free);
+    val = gtr_pref_int_get (key);
+    gtk_combo_box_set_active (GTK_COMBO_BOX (w), val / (15));
+    g_signal_connect (w, "changed", G_CALLBACK (onTimeComboChanged), core);
 
     /* cleanup */
-    g_object_unref( G_OBJECT( store ) );
+    g_object_unref (G_OBJECT (store));
     return w;
 }
 
 static GtkWidget*
-new_week_combo( GObject * core, const char * key )
+new_week_combo (GObject * core, const char * key)
 {
-    GtkWidget * w = gtr_combo_box_new_enum( _( "Every Day" ), TR_SCHED_ALL,
-                                            _( "Weekdays" ),  TR_SCHED_WEEKDAY,
-                                            _( "Weekends" ),  TR_SCHED_WEEKEND,
-                                            _( "Sunday" ),    TR_SCHED_SUN,
-                                            _( "Monday" ),    TR_SCHED_MON,
-                                            _( "Tuesday" ),   TR_SCHED_TUES,
-                                            _( "Wednesday" ), TR_SCHED_WED,
-                                            _( "Thursday" ),  TR_SCHED_THURS,
-                                            _( "Friday" ),    TR_SCHED_FRI,
-                                            _( "Saturday" ),  TR_SCHED_SAT,
-                                            NULL );
-    gtr_combo_box_set_active_enum( GTK_COMBO_BOX( w ), gtr_pref_int_get( key ) );
-    g_object_set_data_full( G_OBJECT( w ), PREF_KEY, tr_strdup( key ), g_free );
-    g_signal_connect( w, "changed", G_CALLBACK( onIntComboChanged ), core );
+    GtkWidget * w = gtr_combo_box_new_enum (_("Every Day"), TR_SCHED_ALL,
+                                            _("Weekdays"),  TR_SCHED_WEEKDAY,
+                                            _("Weekends"),  TR_SCHED_WEEKEND,
+                                            _("Sunday"),    TR_SCHED_SUN,
+                                            _("Monday"),    TR_SCHED_MON,
+                                            _("Tuesday"),   TR_SCHED_TUES,
+                                            _("Wednesday"), TR_SCHED_WED,
+                                            _("Thursday"),  TR_SCHED_THURS,
+                                            _("Friday"),    TR_SCHED_FRI,
+                                            _("Saturday"),  TR_SCHED_SAT,
+                                            NULL);
+    gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (key));
+    g_object_set_data_full (G_OBJECT (w), PREF_KEY, tr_strdup (key), g_free);
+    g_signal_connect (w, "changed", G_CALLBACK (onIntComboChanged), core);
     return w;
 }
 
 static void
-bandwidthPageFree( gpointer gpage )
+bandwidthPageFree (gpointer gpage)
 {
     struct BandwidthPage * page = gpage;
 
-    g_slist_free( page->sched_widgets );
-    g_free( page );
+    g_slist_free (page->sched_widgets);
+    g_free (page);
 }
 
 static GtkWidget*
-bandwidthPage( GObject * core )
+bandwidthPage (GObject * core)
 {
     const char * s;
     GtkWidget * t;
@@ -1044,78 +1044,78 @@ bandwidthPage( GObject * core )
     GtkWidget * w, * w2, * h;
     char buf[512];
     guint row = 0;
-    struct BandwidthPage * page = tr_new0( struct BandwidthPage, 1 );
-
-    page->core = TR_CORE( core );
-
-    t = hig_workarea_create( );
-    hig_workarea_add_section_title( t, &row, _( "Speed Limits" ) );
-
-        g_snprintf( buf, sizeof( buf ), _( "_Upload (%s):" ), _(speed_K_str) );
-        w = new_check_button( buf, TR_PREFS_KEY_USPEED_ENABLED, core );
-        w2 = new_spin_button( TR_PREFS_KEY_USPEED_KBps, core, 0, INT_MAX, 5 );
-        gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED ) );
-        g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
-        hig_workarea_add_row_w( t, &row, w, w2, NULL );
-
-        g_snprintf( buf, sizeof( buf ), _( "_Download (%s):" ), _(speed_K_str) );
-        w = new_check_button( buf, TR_PREFS_KEY_DSPEED_ENABLED, core );
-        w2 = new_spin_button( TR_PREFS_KEY_DSPEED_KBps, core, 0, INT_MAX, 5 );
-        gtk_widget_set_sensitive( GTK_WIDGET( w2 ), gtr_pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED ) );
-        g_signal_connect( w, "toggled", G_CALLBACK( target_cb ), w2 );
-        hig_workarea_add_row_w( t, &row, w, w2, NULL );
-
-    hig_workarea_add_section_divider( t, &row );
-    h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD );
-    w = gtk_image_new_from_stock( "alt-speed-on", -1 );
-    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
-    g_snprintf( buf, sizeof( buf ), "<b>%s</b>", _( "Alternative Speed Limits" ) );
-    w = gtk_label_new( buf );
-    gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f );
-    gtk_label_set_use_markup( GTK_LABEL( w ), TRUE );
-    gtk_box_pack_start( GTK_BOX( h ), w, FALSE, FALSE, 0 );
-    hig_workarea_add_section_title_widget( t, &row, h );
-
-        s = _( "Override normal speed limits manually or at scheduled times" );
-        g_snprintf( buf, sizeof( buf ), "<small>%s</small>", s );
-        w = gtk_label_new( buf );
-        gtk_label_set_use_markup( GTK_LABEL( w ), TRUE );
-        gtk_misc_set_alignment( GTK_MISC( w ), 0.5f, 0.5f );
-        hig_workarea_add_wide_control( t, &row, w );
-
-        g_snprintf( buf, sizeof( buf ), _( "U_pload (%s):" ), _(speed_K_str) );
-        w = new_spin_button( TR_PREFS_KEY_ALT_SPEED_UP_KBps, core, 0, INT_MAX, 5 );
-        hig_workarea_add_row( t, &row, buf, w, NULL );
-
-        g_snprintf( buf, sizeof( buf ), _( "Do_wnload (%s):" ), _(speed_K_str) );
-        w = new_spin_button( TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, core, 0, INT_MAX, 5 );
-        hig_workarea_add_row( t, &row, buf, w, NULL );
-
-        s = _( "_Scheduled times:" );
-        h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 );
-        w2 = new_time_combo( core, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN );
-        page->sched_widgets = g_slist_prepend( page->sched_widgets, w2 );
-        gtk_box_pack_start( GTK_BOX( h ), w2, TRUE, TRUE, 0 );
-        w2 = l = gtk_label_new_with_mnemonic ( _( " _to " ) );
-        page->sched_widgets = g_slist_prepend( page->sched_widgets, w2 );
-        gtk_box_pack_start( GTK_BOX( h ), w2, FALSE, FALSE, 0 );
-        w2 = new_time_combo( core, TR_PREFS_KEY_ALT_SPEED_TIME_END );
-        gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w2 );
-        page->sched_widgets = g_slist_prepend( page->sched_widgets, w2 );
-        gtk_box_pack_start( GTK_BOX( h ), w2, TRUE, TRUE, 0 );
-        w = new_check_button( s, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, core );
-        g_signal_connect( w, "toggled", G_CALLBACK( onSchedToggled ), page );
-        hig_workarea_add_row_w( t, &row, w, h, NULL );
-
-        s = _( "_On days:" );
-        w = new_week_combo( core, TR_PREFS_KEY_ALT_SPEED_TIME_DAY );
-        page->sched_widgets = g_slist_prepend( page->sched_widgets, w );
-        w = hig_workarea_add_row( t, &row, s, w, NULL );
-        page->sched_widgets = g_slist_prepend( page->sched_widgets, w );
-
-    g_object_set_data_full( G_OBJECT( t ), "page", page, bandwidthPageFree );
-
-    refreshSchedSensitivity( page );
+    struct BandwidthPage * page = tr_new0 (struct BandwidthPage, 1);
+
+    page->core = TR_CORE (core);
+
+    t = hig_workarea_create ();
+    hig_workarea_add_section_title (t, &row, _("Speed Limits"));
+
+        g_snprintf (buf, sizeof (buf), _("_Upload (%s):"), _ (speed_K_str));
+        w = new_check_button (buf, TR_PREFS_KEY_USPEED_ENABLED, core);
+        w2 = new_spin_button (TR_PREFS_KEY_USPEED_KBps, core, 0, INT_MAX, 5);
+        gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_PREFS_KEY_USPEED_ENABLED));
+        g_signal_connect (w, "toggled", G_CALLBACK (target_cb), w2);
+        hig_workarea_add_row_w (t, &row, w, w2, NULL);
+
+        g_snprintf (buf, sizeof (buf), _("_Download (%s):"), _ (speed_K_str));
+        w = new_check_button (buf, TR_PREFS_KEY_DSPEED_ENABLED, core);
+        w2 = new_spin_button (TR_PREFS_KEY_DSPEED_KBps, core, 0, INT_MAX, 5);
+        gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_PREFS_KEY_DSPEED_ENABLED));
+        g_signal_connect (w, "toggled", G_CALLBACK (target_cb), w2);
+        hig_workarea_add_row_w (t, &row, w, w2, NULL);
+
+    hig_workarea_add_section_divider (t, &row);
+    h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
+    w = gtk_image_new_from_stock ("alt-speed-on", -1);
+    gtk_box_pack_start (GTK_BOX (h), w, FALSE, FALSE, 0);
+    g_snprintf (buf, sizeof (buf), "<b>%s</b>", _("Alternative Speed Limits"));
+    w = gtk_label_new (buf);
+    gtk_misc_set_alignment (GTK_MISC (w), 0.0f, 0.5f);
+    gtk_label_set_use_markup (GTK_LABEL (w), TRUE);
+    gtk_box_pack_start (GTK_BOX (h), w, FALSE, FALSE, 0);
+    hig_workarea_add_section_title_widget (t, &row, h);
+
+        s = _("Override normal speed limits manually or at scheduled times");
+        g_snprintf (buf, sizeof (buf), "<small>%s</small>", s);
+        w = gtk_label_new (buf);
+        gtk_label_set_use_markup (GTK_LABEL (w), TRUE);
+        gtk_misc_set_alignment (GTK_MISC (w), 0.5f, 0.5f);
+        hig_workarea_add_wide_control (t, &row, w);
+
+        g_snprintf (buf, sizeof (buf), _("U_pload (%s):"), _ (speed_K_str));
+        w = new_spin_button (TR_PREFS_KEY_ALT_SPEED_UP_KBps, core, 0, INT_MAX, 5);
+        hig_workarea_add_row (t, &row, buf, w, NULL);
+
+        g_snprintf (buf, sizeof (buf), _("Do_wnload (%s):"), _ (speed_K_str));
+        w = new_spin_button (TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, core, 0, INT_MAX, 5);
+        hig_workarea_add_row (t, &row, buf, w, NULL);
+
+        s = _("_Scheduled times:");
+        h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+        w2 = new_time_combo (core, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN);
+        page->sched_widgets = g_slist_prepend (page->sched_widgets, w2);
+        gtk_box_pack_start (GTK_BOX (h), w2, TRUE, TRUE, 0);
+        w2 = l = gtk_label_new_with_mnemonic (_(" _to "));
+        page->sched_widgets = g_slist_prepend (page->sched_widgets, w2);
+        gtk_box_pack_start (GTK_BOX (h), w2, FALSE, FALSE, 0);
+        w2 = new_time_combo (core, TR_PREFS_KEY_ALT_SPEED_TIME_END);
+        gtk_label_set_mnemonic_widget (GTK_LABEL (l), w2);
+        page->sched_widgets = g_slist_prepend (page->sched_widgets, w2);
+        gtk_box_pack_start (GTK_BOX (h), w2, TRUE, TRUE, 0);
+        w = new_check_button (s, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, core);
+        g_signal_connect (w, "toggled", G_CALLBACK (onSchedToggled), page);
+        hig_workarea_add_row_w (t, &row, w, h, NULL);
+
+        s = _("_On days:");
+        w = new_week_combo (core, TR_PREFS_KEY_ALT_SPEED_TIME_DAY);
+        page->sched_widgets = g_slist_prepend (page->sched_widgets, w);
+        w = hig_workarea_add_row (t, &row, s, w, NULL);
+        page->sched_widgets = g_slist_prepend (page->sched_widgets, w);
+
+    g_object_set_data_full (G_OBJECT (t), "page", page, bandwidthPageFree);
+
+    refreshSchedSensitivity (page);
     return t;
 }
 
@@ -1134,116 +1134,119 @@ struct network_page_data
 };
 
 static void
-onCorePrefsChanged( TrCore * core UNUSED, const char *  key, gpointer gdata )
+onCorePrefsChanged (TrCore * core UNUSED, const char *  key, gpointer gdata)
 {
-    if( !strcmp( key, TR_PREFS_KEY_PEER_PORT ) )
+  if (!strcmp (key, TR_PREFS_KEY_PEER_PORT))
     {
-        struct network_page_data * data = gdata;
-        gdk_threads_enter();
-        gtr_label_set_text( GTK_LABEL( data->portLabel ), _( "Status unknown" ) );
-        gtk_widget_set_sensitive( data->portButton, TRUE );
-        gtk_widget_set_sensitive( data->portSpin, TRUE );
-        gdk_threads_leave();
+      struct network_page_data * data = gdata;
+      gdk_threads_enter ();
+      gtr_label_set_text (GTK_LABEL (data->portLabel), _("Status unknown"));
+      gtk_widget_set_sensitive (data->portButton, TRUE);
+      gtk_widget_set_sensitive (data->portSpin, TRUE);
+      gdk_threads_leave ();
     }
 }
 
 static void
-networkPageDestroyed( gpointer gdata, GObject * dead UNUSED )
+networkPageDestroyed (gpointer gdata, GObject * dead UNUSED)
 {
-    struct network_page_data * data = gdata;
-    if( data->prefsTag > 0 )
-        g_signal_handler_disconnect( data->core, data->prefsTag );
-    if( data->portTag > 0 )
-        g_signal_handler_disconnect( data->core, data->portTag );
-    g_free( data );
+  struct network_page_data * data = gdata;
+
+  if (data->prefsTag > 0)
+    g_signal_handler_disconnect (data->core, data->prefsTag);
+  if (data->portTag > 0)
+    g_signal_handler_disconnect (data->core, data->portTag);
+
+  g_free (data);
 }
 
 static void
-onPortTested( TrCore * core UNUSED, gboolean isOpen, gpointer vdata )
+onPortTested (TrCore * core UNUSED, gboolean isOpen, gpointer vdata)
 {
-    struct network_page_data * data = vdata;
-    const char * markup = isOpen ? _( "Port is <b>open</b>" ) : _( "Port is <b>closed</b>" );
-    gdk_threads_enter();
-    gtk_label_set_markup( GTK_LABEL( data->portLabel ), markup );
-    gtk_widget_set_sensitive( data->portButton, TRUE );
-    gtk_widget_set_sensitive( data->portSpin, TRUE );
-    gdk_threads_leave();
+  struct network_page_data * data = vdata;
+  const char * markup = isOpen ? _("Port is <b>open</b>") : _("Port is <b>closed</b>");
+
+  gdk_threads_enter ();
+  gtk_label_set_markup (GTK_LABEL (data->portLabel), markup);
+  gtk_widget_set_sensitive (data->portButton, TRUE);
+  gtk_widget_set_sensitive (data->portSpin, TRUE);
+  gdk_threads_leave ();
 }
 
 static void
-onPortTest( GtkButton * button UNUSED, gpointer vdata )
+onPortTest (GtkButton * button UNUSED, gpointer vdata)
 {
-    struct network_page_data * data = vdata;
-    gtk_widget_set_sensitive( data->portButton, FALSE );
-    gtk_widget_set_sensitive( data->portSpin, FALSE );
-    gtk_label_set_markup( GTK_LABEL( data->portLabel ), _( "<i>Testing TCP port…</i>" ) );
-    if( !data->portTag )
-        data->portTag = g_signal_connect( data->core, "port-tested", G_CALLBACK(onPortTested), data );
-    gtr_core_port_test( data->core );
+  struct network_page_data * data = vdata;
+  gtk_widget_set_sensitive (data->portButton, FALSE);
+  gtk_widget_set_sensitive (data->portSpin, FALSE);
+  gtk_label_set_markup (GTK_LABEL (data->portLabel), _("<i>Testing TCP port…</i>"));
+  if (!data->portTag)
+    data->portTag = g_signal_connect (data->core, "port-tested", G_CALLBACK (onPortTested), data);
+  gtr_core_port_test (data->core);
 }
 
 static GtkWidget*
-networkPage( GObject * core )
+networkPage (GObject * core)
 {
-    GtkWidget * t;
-    GtkWidget * w;
-    GtkWidget * h;
-    GtkWidget * l;
-    const char * s;
-    struct network_page_data * data;
-    guint row = 0;
-
-    /* register to stop listening to core prefs changes when the page is destroyed */
-    data = g_new0( struct network_page_data, 1 );
-    data->core = TR_CORE( core );
-
-    /* build the page */
-    t = hig_workarea_create( );
-    hig_workarea_add_section_title( t, &row, _( "Listening Port" ) );
-
-    s = _( "_Port used for incoming connections:" );
-    w = data->portSpin = new_spin_button( TR_PREFS_KEY_PEER_PORT, core, 1, USHRT_MAX, 1 );
-    hig_workarea_add_row( t, &row, s, w, NULL );
-
-    h = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG );
-    l = data->portLabel = gtk_label_new( _( "Status unknown" ) );
-    gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f );
-    gtk_box_pack_start( GTK_BOX( h ), l, TRUE, TRUE, 0 );
-    w = data->portButton = gtk_button_new_with_mnemonic( _( "Te_st Port" ) );
-    gtk_box_pack_end( GTK_BOX( h ), w, FALSE, FALSE, 0 );
-    g_signal_connect( w, "clicked", G_CALLBACK(onPortTest), data );
-    hig_workarea_add_row( t, &row, NULL, h, NULL );
-    data->prefsTag = g_signal_connect( TR_CORE( core ), "prefs-changed", G_CALLBACK( onCorePrefsChanged ), data );
-    g_object_weak_ref( G_OBJECT( t ), networkPageDestroyed, data );
-
-    s = _( "Pick a _random port every time Transmission is started" );
-    w = new_check_button( s, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, core );
-    hig_workarea_add_wide_control( t, &row, w );
-
-    s = _( "Use UPnP or NAT-PMP port _forwarding from my router" );
-    w = new_check_button( s, TR_PREFS_KEY_PORT_FORWARDING, core );
-    hig_workarea_add_wide_control( t, &row, w );
-
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, _( "Peer Limits" ) );
-
-    w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_TORRENT, core, 1, FD_SETSIZE, 5 );
-    hig_workarea_add_row( t, &row, _( "Maximum peers per _torrent:" ), w, NULL );
-    w = new_spin_button( TR_PREFS_KEY_PEER_LIMIT_GLOBAL, core, 1, FD_SETSIZE, 5 );
-    hig_workarea_add_row( t, &row, _( "Maximum peers _overall:" ), w, NULL );
-
-    hig_workarea_add_section_divider( t, &row );
-    hig_workarea_add_section_title( t, &row, _( "Options" ) );
+  GtkWidget * t;
+  GtkWidget * w;
+  GtkWidget * h;
+  GtkWidget * l;
+  const char * s;
+  struct network_page_data * data;
+  guint row = 0;
+
+  /* register to stop listening to core prefs changes when the page is destroyed */
+  data = g_new0 (struct network_page_data, 1);
+  data->core = TR_CORE (core);
+
+  /* build the page */
+  t = hig_workarea_create ();
+  hig_workarea_add_section_title (t, &row, _("Listening Port"));
+
+  s = _("_Port used for incoming connections:");
+  w = data->portSpin = new_spin_button (TR_PREFS_KEY_PEER_PORT, core, 1, USHRT_MAX, 1);
+  hig_workarea_add_row (t, &row, s, w, NULL);
+
+  h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
+  l = data->portLabel = gtk_label_new (_("Status unknown"));
+  gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
+  gtk_box_pack_start (GTK_BOX (h), l, TRUE, TRUE, 0);
+  w = data->portButton = gtk_button_new_with_mnemonic (_("Te_st Port"));
+  gtk_box_pack_end (GTK_BOX (h), w, FALSE, FALSE, 0);
+  g_signal_connect (w, "clicked", G_CALLBACK (onPortTest), data);
+  hig_workarea_add_row (t, &row, NULL, h, NULL);
+  data->prefsTag = g_signal_connect (TR_CORE (core), "prefs-changed", G_CALLBACK (onCorePrefsChanged), data);
+  g_object_weak_ref (G_OBJECT (t), networkPageDestroyed, data);
+
+  s = _("Pick a _random port every time Transmission is started");
+  w = new_check_button (s, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, core);
+  hig_workarea_add_wide_control (t, &row, w);
+
+  s = _("Use UPnP or NAT-PMP port _forwarding from my router");
+  w = new_check_button (s, TR_PREFS_KEY_PORT_FORWARDING, core);
+  hig_workarea_add_wide_control (t, &row, w);
+
+  hig_workarea_add_section_divider (t, &row);
+  hig_workarea_add_section_title (t, &row, _("Peer Limits"));
+
+  w = new_spin_button (TR_PREFS_KEY_PEER_LIMIT_TORRENT, core, 1, FD_SETSIZE, 5);
+  hig_workarea_add_row (t, &row, _("Maximum peers per _torrent:"), w, NULL);
+  w = new_spin_button (TR_PREFS_KEY_PEER_LIMIT_GLOBAL, core, 1, FD_SETSIZE, 5);
+  hig_workarea_add_row (t, &row, _("Maximum peers _overall:"), w, NULL);
+
+  hig_workarea_add_section_divider (t, &row);
+  hig_workarea_add_section_title (t, &row, _("Options"));
 
 #ifdef WITH_UTP
-    s = _( "Enable _uTP for peer communication" );
-    w = new_check_button( s, TR_PREFS_KEY_UTP_ENABLED, core );
-    s = _( "uTP is a tool for reducing network congestion." );
-    gtk_widget_set_tooltip_text( w, s );
-    hig_workarea_add_wide_control( t, &row, w );
+  s = _("Enable _uTP for peer communication");
+  w = new_check_button (s, TR_PREFS_KEY_UTP_ENABLED, core);
+  s = _("uTP is a tool for reducing network congestion.");
+  gtk_widget_set_tooltip_text (w, s);
+  hig_workarea_add_wide_control (t, &row, w);
 #endif
 
-    return t;
+  return t;
 }
 
 /****
@@ -1251,48 +1254,47 @@ networkPage( GObject * core )
 ****/
 
 GtkWidget *
-gtr_prefs_dialog_new( GtkWindow * parent, GObject * core )
+gtr_prefs_dialog_new (GtkWindow * parent, GObject * core)
 {
-    GtkWidget * d;
-    GtkWidget * n;
-
-    d = gtk_dialog_new_with_buttons( _(
-                                         "Transmission Preferences" ),
-                                     parent,
-                                     GTK_DIALOG_DESTROY_WITH_PARENT,
-                                     GTK_STOCK_HELP, GTK_RESPONSE_HELP,
-                                     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
-                                     NULL );
-    gtk_window_set_role( GTK_WINDOW( d ), "transmission-preferences-dialog" );
-    gtk_container_set_border_width( GTK_CONTAINER( d ), GUI_PAD );
-
-    n = gtk_notebook_new( );
-    gtk_container_set_border_width ( GTK_CONTAINER ( n ), GUI_PAD );
-
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
-                              torrentPage( core ),
-                              gtk_label_new ( _( "Torrents" ) ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
-                              downloadPage( core ),
-                              gtk_label_new ( C_( "Gerund", "Downloading" ) ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
-                              bandwidthPage( core ),
-                              gtk_label_new ( _( "Speed" ) ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
-                              privacyPage( core ),
-                              gtk_label_new ( _( "Privacy" ) ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
-                              networkPage( core ),
-                              gtk_label_new ( _( "Network" ) ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
-                              desktopPage( core ),
-                              gtk_label_new ( _( "Desktop" ) ) );
-    gtk_notebook_append_page( GTK_NOTEBOOK( n ),
-                              webPage( core ),
-                              gtk_label_new ( _( "Web" ) ) );
-
-    g_signal_connect( d, "response", G_CALLBACK( response_cb ), core );
-    gtr_dialog_set_content( GTK_DIALOG( d ), n );
+  GtkWidget * d;
+  GtkWidget * n;
+
+  d = gtk_dialog_new_with_buttons (_("Transmission Preferences"),
+                                   parent,
+                                   GTK_DIALOG_DESTROY_WITH_PARENT,
+                                   GTK_STOCK_HELP, GTK_RESPONSE_HELP,
+                                   GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+                                   NULL);
+  gtk_window_set_role (GTK_WINDOW (d), "transmission-preferences-dialog");
+  gtk_container_set_border_width (GTK_CONTAINER (d), GUI_PAD);
+
+  n = gtk_notebook_new ();
+  gtk_container_set_border_width (GTK_CONTAINER (n), GUI_PAD);
+
+  gtk_notebook_append_page (GTK_NOTEBOOK (n),
+                            torrentPage (core),
+                            gtk_label_new (_("Torrents")));
+  gtk_notebook_append_page (GTK_NOTEBOOK (n),
+                            downloadPage (core),
+                            gtk_label_new (C_("Gerund", "Downloading")));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n),
+                              bandwidthPage (core),
+                              gtk_label_new (_("Speed")));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n),
+                              privacyPage (core),
+                              gtk_label_new (_("Privacy")));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n),
+                              networkPage (core),
+                              gtk_label_new (_("Network")));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n),
+                              desktopPage (core),
+                              gtk_label_new (_("Desktop")));
+    gtk_notebook_append_page (GTK_NOTEBOOK (n),
+                              webPage (core),
+                              gtk_label_new (_("Web")));
+
+    g_signal_connect (d, "response", G_CALLBACK (response_cb), core);
+    gtr_dialog_set_content (GTK_DIALOG (d), n);
     return d;
 }
 
diff --git a/gtk/tr-prefs.h b/gtk/tr-prefs.h
index 65c6a3de8..04bba7a6e 100644
--- a/gtk/tr-prefs.h
+++ b/gtk/tr-prefs.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -15,10 +15,10 @@
 
 #include <gtk/gtk.h>
 
-GtkWidget * gtr_prefs_dialog_new( GtkWindow * parent, GObject * core );
+GtkWidget * gtr_prefs_dialog_new (GtkWindow * parent, GObject * core);
 
 /* if you add a key here,  you /must/ add its
- * default in tr_prefs_init_defaults( void ) */
+ * default in tr_prefs_init_defaults (void) */
 
 #define PREF_KEY_BLOCKLIST_UPDATES_ENABLED               "blocklist-updates-enabled"
 #define PREF_KEY_COMPACT_VIEW                            "compact-view"
diff --git a/gtk/tr-window.c b/gtk/tr-window.c
index 9839baa3d..743eb5095 100644
--- a/gtk/tr-window.c
+++ b/gtk/tr-window.c
@@ -28,7 +28,7 @@
 #include <glib/gi18n.h>
 
 #include <libtransmission/transmission.h>
-#include <libtransmission/utils.h> /* tr_formatter_speed_KBps() */
+#include <libtransmission/utils.h> /* tr_formatter_speed_KBps () */
 
 #include "actions.h"
 #include "conf.h"
@@ -68,17 +68,17 @@ typedef struct
 PrivateData;
 
 static GQuark
-get_private_data_key( void )
+get_private_data_key (void)
 {
     static GQuark q = 0;
-    if( !q ) q = g_quark_from_static_string( "private-data" );
+    if (!q) q = g_quark_from_static_string ("private-data");
     return q;
 }
 
 static PrivateData*
-get_private_data( GtkWindow * w )
+get_private_data (GtkWindow * w)
 {
-    return g_object_get_qdata ( G_OBJECT( w ), get_private_data_key( ) );
+    return g_object_get_qdata (G_OBJECT (w), get_private_data_key ());
 }
 
 /***
@@ -86,46 +86,46 @@ get_private_data( GtkWindow * w )
 ***/
 
 static void
-on_popup_menu( GtkWidget * self UNUSED,
-               GdkEventButton * event )
+on_popup_menu (GtkWidget * self UNUSED,
+               GdkEventButton * event)
 {
-    GtkWidget * menu = gtr_action_get_widget ( "/main-window-popup" );
+    GtkWidget * menu = gtr_action_get_widget ("/main-window-popup");
 
-    gtk_menu_popup ( GTK_MENU( menu ), NULL, NULL, NULL, NULL,
-                    ( event ? event->button : 0 ),
-                    ( event ? event->time : 0 ) );
+    gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
+                  (event ? event->button : 0),
+                  (event ? event->time : 0));
 }
 
 static void
-view_row_activated( GtkTreeView       * tree_view UNUSED,
+view_row_activated (GtkTreeView       * tree_view UNUSED,
                     GtkTreePath       * path      UNUSED,
                     GtkTreeViewColumn * column    UNUSED,
-                    gpointer            user_data UNUSED )
+                    gpointer            user_data UNUSED)
 {
-    gtr_action_activate( "show-torrent-properties" );
+    gtr_action_activate ("show-torrent-properties");
 }
 
 static gboolean
-tree_view_search_equal_func( GtkTreeModel * model,
+tree_view_search_equal_func (GtkTreeModel * model,
                              gint           column UNUSED,
                              const gchar  * key,
                              GtkTreeIter  * iter,
-                             gpointer       search_data UNUSED )
+                             gpointer       search_data UNUSED)
 {
     gboolean match;
     char * lower;
     const char * name = NULL;
 
-    lower = g_strstrip( g_utf8_strdown( key, -1 ) );
-    gtk_tree_model_get( model, iter, MC_NAME_COLLATED, &name, -1 );
-    match = strstr( name, lower ) != NULL;
-    g_free( lower );
+    lower = g_strstrip (g_utf8_strdown (key, -1));
+    gtk_tree_model_get (model, iter, MC_NAME_COLLATED, &name, -1);
+    match = strstr (name, lower) != NULL;
+    g_free (lower);
 
     return !match;
 }
 
 static GtkWidget*
-makeview( PrivateData * p )
+makeview (PrivateData * p)
 {
     GtkWidget *         view;
     GtkTreeViewColumn * col;
@@ -133,16 +133,16 @@ makeview( PrivateData * p )
     GtkCellRenderer *   r;
     GtkTreeView * tree_view;
 
-    view = gtk_tree_view_new( );
-    tree_view = GTK_TREE_VIEW( view );
-    gtk_tree_view_set_search_column( tree_view, MC_NAME_COLLATED );
-    gtk_tree_view_set_search_equal_func( tree_view,
+    view = gtk_tree_view_new ();
+    tree_view = GTK_TREE_VIEW (view);
+    gtk_tree_view_set_search_column (tree_view, MC_NAME_COLLATED);
+    gtk_tree_view_set_search_equal_func (tree_view,
                                          tree_view_search_equal_func,
-                                         NULL, NULL );
-    gtk_tree_view_set_headers_visible( tree_view, FALSE );
-    gtk_tree_view_set_fixed_height_mode( tree_view, TRUE );
+                                         NULL, NULL);
+    gtk_tree_view_set_headers_visible (tree_view, FALSE);
+    gtk_tree_view_set_fixed_height_mode (tree_view, TRUE);
 
-    p->selection = gtk_tree_view_get_selection( tree_view );
+    p->selection = gtk_tree_view_get_selection (tree_view);
 
     p->column = col = GTK_TREE_VIEW_COLUMN (g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
         "title", _("Torrent"),
@@ -150,97 +150,97 @@ makeview( PrivateData * p )
         "sizing", GTK_TREE_VIEW_COLUMN_FIXED,
         NULL));
 
-    p->renderer = r = torrent_cell_renderer_new( );
-    gtk_tree_view_column_pack_start( col, r, FALSE );
-    gtk_tree_view_column_add_attribute( col, r, "torrent", MC_TORRENT );
-    gtk_tree_view_column_add_attribute( col, r, "piece-upload-speed", MC_SPEED_UP );
-    gtk_tree_view_column_add_attribute( col, r, "piece-download-speed", MC_SPEED_DOWN );
+    p->renderer = r = torrent_cell_renderer_new ();
+    gtk_tree_view_column_pack_start (col, r, FALSE);
+    gtk_tree_view_column_add_attribute (col, r, "torrent", MC_TORRENT);
+    gtk_tree_view_column_add_attribute (col, r, "piece-upload-speed", MC_SPEED_UP);
+    gtk_tree_view_column_add_attribute (col, r, "piece-download-speed", MC_SPEED_DOWN);
 
-    gtk_tree_view_append_column( tree_view, col );
-    g_object_set( r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL );
+    gtk_tree_view_append_column (tree_view, col);
+    g_object_set (r, "xpad", GUI_PAD_SMALL, "ypad", GUI_PAD_SMALL, NULL);
 
-    gtk_tree_view_set_rules_hint( tree_view, TRUE );
-    sel = gtk_tree_view_get_selection( tree_view );
-    gtk_tree_selection_set_mode( GTK_TREE_SELECTION( sel ),
-                                 GTK_SELECTION_MULTIPLE );
+    gtk_tree_view_set_rules_hint (tree_view, TRUE);
+    sel = gtk_tree_view_get_selection (tree_view);
+    gtk_tree_selection_set_mode (GTK_TREE_SELECTION (sel),
+                                 GTK_SELECTION_MULTIPLE);
 
-    g_signal_connect( view, "popup-menu",
-                      G_CALLBACK( on_popup_menu ), NULL );
-    g_signal_connect( view, "button-press-event",
-                      G_CALLBACK( on_tree_view_button_pressed ),
-                      (void *) on_popup_menu );
-    g_signal_connect( view, "button-release-event",
-                      G_CALLBACK( on_tree_view_button_released ), NULL );
-    g_signal_connect( view, "row-activated",
-                      G_CALLBACK( view_row_activated ), NULL );
+    g_signal_connect (view, "popup-menu",
+                      G_CALLBACK (on_popup_menu), NULL);
+    g_signal_connect (view, "button-press-event",
+                      G_CALLBACK (on_tree_view_button_pressed),
+                    (void *) on_popup_menu);
+    g_signal_connect (view, "button-release-event",
+                      G_CALLBACK (on_tree_view_button_released), NULL);
+    g_signal_connect (view, "row-activated",
+                      G_CALLBACK (view_row_activated), NULL);
 
 
-    gtk_tree_view_set_model( tree_view, p->filter_model );
-    g_object_unref( p->filter_model );
+    gtk_tree_view_set_model (tree_view, p->filter_model);
+    g_object_unref (p->filter_model);
 
     return view;
 }
 
-static void syncAltSpeedButton( PrivateData * p );
+static void syncAltSpeedButton (PrivateData * p);
 
 static void
-prefsChanged( TrCore * core UNUSED,
+prefsChanged (TrCore * core UNUSED,
               const char *  key,
-              gpointer      wind )
+              gpointer      wind)
 {
-    PrivateData * p = get_private_data( GTK_WINDOW( wind ) );
+    PrivateData * p = get_private_data (GTK_WINDOW (wind));
 
-    if( !strcmp( key, PREF_KEY_COMPACT_VIEW ) )
+    if (!strcmp (key, PREF_KEY_COMPACT_VIEW))
     {
-        g_object_set( p->renderer, "compact", gtr_pref_flag_get( key ), NULL );
+        g_object_set (p->renderer, "compact", gtr_pref_flag_get (key), NULL);
         /* since the cell size has changed, we need gtktreeview to revalidate
          * its fixed-height mode values. Unfortunately there's not an API call
          * for that, but it *does* revalidate when it thinks the style's been tweaked */
-        g_signal_emit_by_name( p->view, "style-updated", NULL, NULL );
+        g_signal_emit_by_name (p->view, "style-updated", NULL, NULL);
     }
-    else if( !strcmp( key, PREF_KEY_STATUSBAR ) )
+    else if (!strcmp (key, PREF_KEY_STATUSBAR))
     {
-        const gboolean isEnabled = gtr_pref_flag_get( key );
-        g_object_set( p->status, "visible", isEnabled, NULL );
+        const gboolean isEnabled = gtr_pref_flag_get (key);
+        g_object_set (p->status, "visible", isEnabled, NULL);
     }
-    else if( !strcmp( key, PREF_KEY_FILTERBAR ) )
+    else if (!strcmp (key, PREF_KEY_FILTERBAR))
     {
-        const gboolean isEnabled = gtr_pref_flag_get( key );
-        g_object_set( p->filter, "visible", isEnabled, NULL );
+        const gboolean isEnabled = gtr_pref_flag_get (key);
+        g_object_set (p->filter, "visible", isEnabled, NULL);
     }
-    else if( !strcmp( key, PREF_KEY_TOOLBAR ) )
+    else if (!strcmp (key, PREF_KEY_TOOLBAR))
     {
-        const gboolean isEnabled = gtr_pref_flag_get( key );
-        g_object_set( p->toolbar, "visible", isEnabled, NULL );
+        const gboolean isEnabled = gtr_pref_flag_get (key);
+        g_object_set (p->toolbar, "visible", isEnabled, NULL);
     }
-    else if( !strcmp( key, PREF_KEY_STATUSBAR_STATS ) )
+    else if (!strcmp (key, PREF_KEY_STATUSBAR_STATS))
     {
-        gtr_window_refresh( wind );
+        gtr_window_refresh (wind);
     }
-    else if( !strcmp( key, TR_PREFS_KEY_ALT_SPEED_ENABLED ) ||
-             !strcmp( key, TR_PREFS_KEY_ALT_SPEED_UP_KBps ) ||
-             !strcmp( key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ) )
+    else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_ENABLED) ||
+             !strcmp (key, TR_PREFS_KEY_ALT_SPEED_UP_KBps) ||
+             !strcmp (key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps))
     {
-        syncAltSpeedButton( p );
+        syncAltSpeedButton (p);
     }
 }
 
 static void
-privateFree( gpointer vprivate )
+privateFree (gpointer vprivate)
 {
     PrivateData * p = vprivate;
-    g_signal_handler_disconnect( p->core, p->pref_handler_id );
-    g_free( p );
+    g_signal_handler_disconnect (p->core, p->pref_handler_id);
+    g_free (p);
 }
 
 static void
-onYinYangReleased( GtkWidget * w UNUSED, gpointer vprivate )
+onYinYangReleased (GtkWidget * w UNUSED, gpointer vprivate)
 {
     PrivateData * p = vprivate;
 
-    gtk_menu_popup( GTK_MENU( p->status_menu ),
+    gtk_menu_popup (GTK_MENU (p->status_menu),
                     NULL, NULL, NULL, NULL, 0,
-                    gtk_get_current_event_time( ) );
+                    gtk_get_current_event_time ());
 }
 
 #define STATS_MODE "stats-mode"
@@ -249,56 +249,56 @@ static struct
 {
     const char *  val, *i18n;
 } stats_modes[] = {
-    { "total-ratio",      N_( "Total Ratio" )                },
-    { "session-ratio",    N_( "Session Ratio" )              },
-    { "total-transfer",   N_( "Total Transfer" )             },
-    { "session-transfer", N_( "Session Transfer" )           }
+    { "total-ratio",      N_("Total Ratio")                },
+    { "session-ratio",    N_("Session Ratio")              },
+    { "total-transfer",   N_("Total Transfer")             },
+    { "session-transfer", N_("Session Transfer")           }
 };
 
 static void
-status_menu_toggled_cb( GtkCheckMenuItem * menu_item,
-                        gpointer           vprivate )
+status_menu_toggled_cb (GtkCheckMenuItem * menu_item,
+                        gpointer           vprivate)
 {
-    if( gtk_check_menu_item_get_active( menu_item ) )
+    if (gtk_check_menu_item_get_active (menu_item))
     {
         PrivateData * p = vprivate;
-        const char *  val = g_object_get_data( G_OBJECT(
-                                                   menu_item ), STATS_MODE );
-        gtr_core_set_pref( p->core, PREF_KEY_STATUSBAR_STATS, val );
+        const char *  val = g_object_get_data (G_OBJECT (
+                                                   menu_item), STATS_MODE);
+        gtr_core_set_pref (p->core, PREF_KEY_STATUSBAR_STATS, val);
     }
 }
 
 static void
-syncAltSpeedButton( PrivateData * p )
+syncAltSpeedButton (PrivateData * p)
 {
     char u[32];
     char d[32];
     char * str;
     const char * fmt;
-    const gboolean b = gtr_pref_flag_get( TR_PREFS_KEY_ALT_SPEED_ENABLED );
+    const gboolean b = gtr_pref_flag_get (TR_PREFS_KEY_ALT_SPEED_ENABLED);
     const char * stock = b ? "alt-speed-on" : "alt-speed-off";
     GtkWidget * w = p->alt_speed_button;
 
-    tr_formatter_speed_KBps( u, gtr_pref_int_get( TR_PREFS_KEY_ALT_SPEED_UP_KBps ), sizeof( u ) );
-    tr_formatter_speed_KBps( d, gtr_pref_int_get( TR_PREFS_KEY_ALT_SPEED_DOWN_KBps ), sizeof( d ) );
-    fmt = b ? _( "Click to disable Alternative Speed Limits\n(%1$s down, %2$s up)" )
-            : _( "Click to enable Alternative Speed Limits\n(%1$s down, %2$s up)" );
-    str = g_strdup_printf( fmt, d, u );
+    tr_formatter_speed_KBps (u, gtr_pref_int_get (TR_PREFS_KEY_ALT_SPEED_UP_KBps), sizeof (u));
+    tr_formatter_speed_KBps (d, gtr_pref_int_get (TR_PREFS_KEY_ALT_SPEED_DOWN_KBps), sizeof (d));
+    fmt = b ? _("Click to disable Alternative Speed Limits\n (%1$s down, %2$s up)")
+            : _("Click to enable Alternative Speed Limits\n (%1$s down, %2$s up)");
+    str = g_strdup_printf (fmt, d, u);
 
-    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), b );
-    gtk_image_set_from_stock( GTK_IMAGE( p->alt_speed_image ), stock, -1 );
-    gtk_button_set_alignment( GTK_BUTTON( w ), 0.5, 0.5 );
-    gtk_widget_set_tooltip_text( w, str );
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), b);
+    gtk_image_set_from_stock (GTK_IMAGE (p->alt_speed_image), stock, -1);
+    gtk_button_set_alignment (GTK_BUTTON (w), 0.5, 0.5);
+    gtk_widget_set_tooltip_text (w, str);
 
-    g_free( str );
+    g_free (str);
 }
 
 static void
-alt_speed_toggled_cb( GtkToggleButton * button, gpointer vprivate )
+alt_speed_toggled_cb (GtkToggleButton * button, gpointer vprivate)
 {
     PrivateData * p = vprivate;
-    const gboolean b = gtk_toggle_button_get_active( button );
-    gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED,  b );
+    const gboolean b = gtk_toggle_button_get_active (button);
+    gtr_core_set_pref_bool (p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED,  b);
 }
 
 /***
@@ -306,36 +306,36 @@ alt_speed_toggled_cb( GtkToggleButton * button, gpointer vprivate )
 ***/
 
 static void
-findMaxAnnounceTime( GtkTreeModel *      model,
+findMaxAnnounceTime (GtkTreeModel *      model,
                      GtkTreePath  * path UNUSED,
                      GtkTreeIter *       iter,
-                     gpointer            gmaxTime )
+                     gpointer            gmaxTime)
 {
     tr_torrent *    tor;
     const tr_stat * torStat;
     time_t *        maxTime = gmaxTime;
 
-    gtk_tree_model_get( model, iter, MC_TORRENT, &tor, -1 );
-    torStat = tr_torrentStatCached( tor );
-    *maxTime = MAX( *maxTime, torStat->manualAnnounceTime );
+    gtk_tree_model_get (model, iter, MC_TORRENT, &tor, -1);
+    torStat = tr_torrentStatCached (tor);
+    *maxTime = MAX (*maxTime, torStat->manualAnnounceTime);
 }
 
 static gboolean
-onAskTrackerQueryTooltip( GtkWidget *            widget UNUSED,
+onAskTrackerQueryTooltip (GtkWidget *            widget UNUSED,
                           gint                   x UNUSED,
                           gint                   y UNUSED,
                           gboolean               keyboard_tip UNUSED,
                           GtkTooltip *           tooltip,
-                          gpointer               gdata )
+                          gpointer               gdata)
 {
-    const time_t now = time( NULL );
+    const time_t now = time (NULL);
     time_t       maxTime = 0;
     PrivateData * p = gdata;
 
-    gtk_tree_selection_selected_foreach( p->selection,
+    gtk_tree_selection_selected_foreach (p->selection,
                                          findMaxAnnounceTime,
-                                         &maxTime );
-    if( maxTime <= now )
+                                         &maxTime);
+    if (maxTime <= now)
     {
         return FALSE;
     }
@@ -345,28 +345,28 @@ onAskTrackerQueryTooltip( GtkWidget *            widget UNUSED,
         char      timebuf[64];
         const int seconds = maxTime - now;
 
-        tr_strltime( timebuf, seconds, sizeof( timebuf ) );
-        g_snprintf( buf, sizeof( buf ),
-                    _( "Tracker will allow requests in %s" ), timebuf );
-        gtk_tooltip_set_text( tooltip, buf );
+        tr_strltime (timebuf, seconds, sizeof (timebuf));
+        g_snprintf (buf, sizeof (buf),
+                    _("Tracker will allow requests in %s"), timebuf);
+        gtk_tooltip_set_text (tooltip, buf);
         return TRUE;
     }
 }
 
 static gboolean
-onAltSpeedToggledIdle( gpointer vp )
+onAltSpeedToggledIdle (gpointer vp)
 {
     PrivateData * p = vp;
-    gboolean b = tr_sessionUsesAltSpeed( gtr_core_session( p->core ) );
-    gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b );
+    gboolean b = tr_sessionUsesAltSpeed (gtr_core_session (p->core));
+    gtr_core_set_pref_bool (p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b);
 
     return FALSE;
 }
 
 static void
-onAltSpeedToggled( tr_session * s UNUSED, bool isEnabled UNUSED, bool byUser UNUSED, void * p )
+onAltSpeedToggled (tr_session * s UNUSED, bool isEnabled UNUSED, bool byUser UNUSED, void * p)
 {
-    gdk_threads_add_idle( onAltSpeedToggledIdle, p );
+    gdk_threads_add_idle (onAltSpeedToggledIdle, p);
 }
 
 /***
@@ -378,70 +378,70 @@ onAltSpeedToggled( tr_session * s UNUSED, bool isEnabled UNUSED, bool byUser UNU
 #define SPEED_KEY "speed-key"
 
 static void
-onSpeedToggled( GtkCheckMenuItem * check, gpointer vp )
+onSpeedToggled (GtkCheckMenuItem * check, gpointer vp)
 {
     PrivateData * p = vp;
-    GObject * o = G_OBJECT( check );
-    gboolean isEnabled = g_object_get_data( o, ENABLED_KEY ) != 0;
-    tr_direction dir = GPOINTER_TO_INT( g_object_get_data( o, DIRECTION_KEY ) );
+    GObject * o = G_OBJECT (check);
+    gboolean isEnabled = g_object_get_data (o, ENABLED_KEY) != 0;
+    tr_direction dir = GPOINTER_TO_INT (g_object_get_data (o, DIRECTION_KEY));
     const char * key = dir == TR_UP ? TR_PREFS_KEY_USPEED_ENABLED
                                     : TR_PREFS_KEY_DSPEED_ENABLED;
 
-    if( gtk_check_menu_item_get_active( check ) )
-        gtr_core_set_pref_bool( p->core, key, isEnabled );
+    if (gtk_check_menu_item_get_active (check))
+        gtr_core_set_pref_bool (p->core, key, isEnabled);
 }
 
 static void
-onSpeedSet( GtkCheckMenuItem * check, gpointer vp )
+onSpeedSet (GtkCheckMenuItem * check, gpointer vp)
 {
     const char * key;
     PrivateData * p = vp;
-    GObject * o = G_OBJECT( check );
-    const int KBps = GPOINTER_TO_INT( g_object_get_data( o, SPEED_KEY ) );
-    tr_direction dir = GPOINTER_TO_INT( g_object_get_data( o, DIRECTION_KEY ) );
+    GObject * o = G_OBJECT (check);
+    const int KBps = GPOINTER_TO_INT (g_object_get_data (o, SPEED_KEY));
+    tr_direction dir = GPOINTER_TO_INT (g_object_get_data (o, DIRECTION_KEY));
 
     key = dir==TR_UP ? TR_PREFS_KEY_USPEED_KBps : TR_PREFS_KEY_DSPEED_KBps;
-    gtr_core_set_pref_int( p->core, key, KBps );
+    gtr_core_set_pref_int (p->core, key, KBps);
 
     key = dir==TR_UP ? TR_PREFS_KEY_USPEED_ENABLED : TR_PREFS_KEY_DSPEED_ENABLED;
-    gtr_core_set_pref_bool( p->core, key, TRUE );
+    gtr_core_set_pref_bool (p->core, key, TRUE);
 }
 
 static GtkWidget*
-createSpeedMenu( PrivateData * p, tr_direction dir )
+createSpeedMenu (PrivateData * p, tr_direction dir)
 {
     int i, n;
     GtkWidget *w, *m;
     const int speeds_KBps[] = { 5, 10, 20, 30, 40, 50, 75, 100, 150, 200, 250, 500, 750 };
 
-    m = gtk_menu_new( );
+    m = gtk_menu_new ();
 
-    w = gtk_radio_menu_item_new_with_label( NULL, _( "Unlimited" ) );
+    w = gtk_radio_menu_item_new_with_label (NULL, _("Unlimited"));
     p->speedlimit_off_item[dir] = w;
-    g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
-    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( FALSE ) );
-    g_signal_connect( w, "toggled", G_CALLBACK(onSpeedToggled), p );
-    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
+    g_object_set_data (G_OBJECT (w), DIRECTION_KEY, GINT_TO_POINTER (dir));
+    g_object_set_data (G_OBJECT (w), ENABLED_KEY, GINT_TO_POINTER (FALSE));
+    g_signal_connect (w, "toggled", G_CALLBACK (onSpeedToggled), p);
+    gtk_menu_shell_append (GTK_MENU_SHELL (m), w);
 
-    w = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), "" );
+    w = gtk_radio_menu_item_new_with_label_from_widget (GTK_RADIO_MENU_ITEM (w), "");
     p->speedlimit_on_item[dir] = w;
-    g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
-    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( TRUE ) );
-    g_signal_connect( w, "toggled", G_CALLBACK(onSpeedToggled), p );
-    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
+    g_object_set_data (G_OBJECT (w), DIRECTION_KEY, GINT_TO_POINTER (dir));
+    g_object_set_data (G_OBJECT (w), ENABLED_KEY, GINT_TO_POINTER (TRUE));
+    g_signal_connect (w, "toggled", G_CALLBACK (onSpeedToggled), p);
+    gtk_menu_shell_append (GTK_MENU_SHELL (m), w);
 
-    w = gtk_separator_menu_item_new( );
-    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
+    w = gtk_separator_menu_item_new ();
+    gtk_menu_shell_append (GTK_MENU_SHELL (m), w);
 
-    for( i=0, n=G_N_ELEMENTS(speeds_KBps); i<n; ++i )
+    for (i=0, n=G_N_ELEMENTS (speeds_KBps); i<n; ++i)
     {
         char buf[128];
-        tr_formatter_speed_KBps( buf, speeds_KBps[i], sizeof( buf ) );
-        w = gtk_menu_item_new_with_label( buf );
-        g_object_set_data( G_OBJECT( w ), DIRECTION_KEY, GINT_TO_POINTER( dir ) );
-        g_object_set_data( G_OBJECT( w ), SPEED_KEY, GINT_TO_POINTER( speeds_KBps[i] ) );
-        g_signal_connect( w, "activate", G_CALLBACK(onSpeedSet), p );
-        gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
+        tr_formatter_speed_KBps (buf, speeds_KBps[i], sizeof (buf));
+        w = gtk_menu_item_new_with_label (buf);
+        g_object_set_data (G_OBJECT (w), DIRECTION_KEY, GINT_TO_POINTER (dir));
+        g_object_set_data (G_OBJECT (w), SPEED_KEY, GINT_TO_POINTER (speeds_KBps[i]));
+        g_signal_connect (w, "activate", G_CALLBACK (onSpeedSet), p);
+        gtk_menu_shell_append (GTK_MENU_SHELL (m), w);
     }
 
     return m;
@@ -456,56 +456,56 @@ createSpeedMenu( PrivateData * p, tr_direction dir )
 static const double stockRatios[] = { 0.25, 0.5, 0.75, 1, 1.5, 2, 3 };
 
 static void
-onRatioToggled( GtkCheckMenuItem * check, gpointer vp )
+onRatioToggled (GtkCheckMenuItem * check, gpointer vp)
 {
     PrivateData * p = vp;
-    if( gtk_check_menu_item_get_active( check ) )
+    if (gtk_check_menu_item_get_active (check))
     {
-        gboolean f = g_object_get_data( G_OBJECT( check ), ENABLED_KEY ) != 0;
-        gtr_core_set_pref_bool( p->core, TR_PREFS_KEY_RATIO_ENABLED, f );
+        gboolean f = g_object_get_data (G_OBJECT (check), ENABLED_KEY) != 0;
+        gtr_core_set_pref_bool (p->core, TR_PREFS_KEY_RATIO_ENABLED, f);
     }
 }
 static void
-onRatioSet( GtkCheckMenuItem * check, gpointer vp )
+onRatioSet (GtkCheckMenuItem * check, gpointer vp)
 {
     PrivateData * p = vp;
-    int i = GPOINTER_TO_INT( g_object_get_data( G_OBJECT( check ), RATIO_KEY ) );
+    int i = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (check), RATIO_KEY));
     const double ratio = stockRatios[i];
-    gtr_core_set_pref_double( p->core, TR_PREFS_KEY_RATIO, ratio );
-    gtr_core_set_pref_bool  ( p->core, TR_PREFS_KEY_RATIO_ENABLED, TRUE );
+    gtr_core_set_pref_double (p->core, TR_PREFS_KEY_RATIO, ratio);
+    gtr_core_set_pref_bool (p->core, TR_PREFS_KEY_RATIO_ENABLED, TRUE);
 }
 
 static GtkWidget*
-createRatioMenu( PrivateData * p )
+createRatioMenu (PrivateData * p)
 {
     int i, n;
     GtkWidget *m, *w;
 
-    m = gtk_menu_new( );
+    m = gtk_menu_new ();
 
-    w = gtk_radio_menu_item_new_with_label( NULL, _( "Seed Forever" ) );
+    w = gtk_radio_menu_item_new_with_label (NULL, _("Seed Forever"));
     p->ratio_off_item = w;
-    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( FALSE ) );
-    g_signal_connect( w, "toggled", G_CALLBACK(onRatioToggled), p );
-    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
+    g_object_set_data (G_OBJECT (w), ENABLED_KEY, GINT_TO_POINTER (FALSE));
+    g_signal_connect (w, "toggled", G_CALLBACK (onRatioToggled), p);
+    gtk_menu_shell_append (GTK_MENU_SHELL (m), w);
 
-    w = gtk_radio_menu_item_new_with_label_from_widget( GTK_RADIO_MENU_ITEM( w ), "" );
+    w = gtk_radio_menu_item_new_with_label_from_widget (GTK_RADIO_MENU_ITEM (w), "");
     p->ratio_on_item = w;
-    g_object_set_data( G_OBJECT( w ), ENABLED_KEY, GINT_TO_POINTER( TRUE ) );
-    g_signal_connect( w, "toggled", G_CALLBACK(onRatioToggled), p );
-    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
+    g_object_set_data (G_OBJECT (w), ENABLED_KEY, GINT_TO_POINTER (TRUE));
+    g_signal_connect (w, "toggled", G_CALLBACK (onRatioToggled), p);
+    gtk_menu_shell_append (GTK_MENU_SHELL (m), w);
 
-    w = gtk_separator_menu_item_new( );
-    gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
+    w = gtk_separator_menu_item_new ();
+    gtk_menu_shell_append (GTK_MENU_SHELL (m), w);
 
-    for( i=0, n=G_N_ELEMENTS(stockRatios); i<n; ++i )
+    for (i=0, n=G_N_ELEMENTS (stockRatios); i<n; ++i)
     {
         char buf[128];
-        tr_strlratio( buf, stockRatios[i], sizeof( buf ) );
-        w = gtk_menu_item_new_with_label( buf );
-        g_object_set_data( G_OBJECT( w ), RATIO_KEY, GINT_TO_POINTER( i ) );
-        g_signal_connect( w, "activate", G_CALLBACK(onRatioSet), p );
-        gtk_menu_shell_append( GTK_MENU_SHELL( m ), w );
+        tr_strlratio (buf, stockRatios[i], sizeof (buf));
+        w = gtk_menu_item_new_with_label (buf);
+        g_object_set_data (G_OBJECT (w), RATIO_KEY, GINT_TO_POINTER (i));
+        g_signal_connect (w, "activate", G_CALLBACK (onRatioSet), p);
+        gtk_menu_shell_append (GTK_MENU_SHELL (m), w);
     }
 
     return m;
@@ -516,32 +516,32 @@ createRatioMenu( PrivateData * p )
 ***/
 
 static GtkWidget*
-createOptionsMenu( PrivateData * p )
+createOptionsMenu (PrivateData * p)
 {
     GtkWidget * m;
-    GtkWidget * top = gtk_menu_new( );
+    GtkWidget * top = gtk_menu_new ();
 
-    m = gtk_menu_item_new_with_label( _( "Limit Download Speed" ) );
-    gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createSpeedMenu( p, TR_DOWN ) );
-    gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
+    m = gtk_menu_item_new_with_label (_("Limit Download Speed"));
+    gtk_menu_item_set_submenu (GTK_MENU_ITEM (m), createSpeedMenu (p, TR_DOWN));
+    gtk_menu_shell_append (GTK_MENU_SHELL (top), m);
 
-    m = gtk_menu_item_new_with_label( _( "Limit Upload Speed" ) );
-    gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createSpeedMenu( p, TR_UP ) );
-    gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
+    m = gtk_menu_item_new_with_label (_("Limit Upload Speed"));
+    gtk_menu_item_set_submenu (GTK_MENU_ITEM (m), createSpeedMenu (p, TR_UP));
+    gtk_menu_shell_append (GTK_MENU_SHELL (top), m);
 
-    m = gtk_separator_menu_item_new( );
-    gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
+    m = gtk_separator_menu_item_new ();
+    gtk_menu_shell_append (GTK_MENU_SHELL (top), m);
 
-    m = gtk_menu_item_new_with_label( _( "Stop Seeding at Ratio" ) );
-    gtk_menu_item_set_submenu( GTK_MENU_ITEM( m ), createRatioMenu( p ) );
-    gtk_menu_shell_append( GTK_MENU_SHELL( top ), m );
+    m = gtk_menu_item_new_with_label (_("Stop Seeding at Ratio"));
+    gtk_menu_item_set_submenu (GTK_MENU_ITEM (m), createRatioMenu (p));
+    gtk_menu_shell_append (GTK_MENU_SHELL (top), m);
 
-    gtk_widget_show_all( top );
+    gtk_widget_show_all (top);
     return top;
 }
 
 static void
-onOptionsClicked( GtkButton * button UNUSED, gpointer vp )
+onOptionsClicked (GtkButton * button UNUSED, gpointer vp)
 {
     char buf1[512];
     char buf2[512];
@@ -550,29 +550,29 @@ onOptionsClicked( GtkButton * button UNUSED, gpointer vp )
     PrivateData * p = vp;
 
     w = p->speedlimit_on_item[TR_DOWN];
-    tr_formatter_speed_KBps( buf1, gtr_pref_int_get( TR_PREFS_KEY_DSPEED_KBps ), sizeof( buf1 ) );
-    gtr_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
+    tr_formatter_speed_KBps (buf1, gtr_pref_int_get (TR_PREFS_KEY_DSPEED_KBps), sizeof (buf1));
+    gtr_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (w))), buf1);
 
-    b = gtr_pref_flag_get( TR_PREFS_KEY_DSPEED_ENABLED );
+    b = gtr_pref_flag_get (TR_PREFS_KEY_DSPEED_ENABLED);
     w = b ? p->speedlimit_on_item[TR_DOWN] : p->speedlimit_off_item[TR_DOWN];
-    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
+    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
 
     w = p->speedlimit_on_item[TR_UP];
-    tr_formatter_speed_KBps( buf1, gtr_pref_int_get( TR_PREFS_KEY_USPEED_KBps ), sizeof( buf1 ) );
-    gtr_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( w ) ) ), buf1 );
+    tr_formatter_speed_KBps (buf1, gtr_pref_int_get (TR_PREFS_KEY_USPEED_KBps), sizeof (buf1));
+    gtr_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (w))), buf1);
 
-    b = gtr_pref_flag_get( TR_PREFS_KEY_USPEED_ENABLED );
+    b = gtr_pref_flag_get (TR_PREFS_KEY_USPEED_ENABLED);
     w = b ? p->speedlimit_on_item[TR_UP] : p->speedlimit_off_item[TR_UP];
-    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ), TRUE );
+    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
 
-    tr_strlratio( buf1, gtr_pref_double_get( TR_PREFS_KEY_RATIO ), sizeof( buf1 ) );
-    g_snprintf( buf2, sizeof( buf2 ), _( "Stop at Ratio (%s)" ), buf1 );
-    gtr_label_set_text( GTK_LABEL( gtk_bin_get_child( GTK_BIN( p->ratio_on_item ) ) ), buf2 );
+    tr_strlratio (buf1, gtr_pref_double_get (TR_PREFS_KEY_RATIO), sizeof (buf1));
+    g_snprintf (buf2, sizeof (buf2), _("Stop at Ratio (%s)"), buf1);
+    gtr_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (p->ratio_on_item))), buf2);
 
-    b = gtr_pref_flag_get( TR_PREFS_KEY_RATIO_ENABLED );
-    gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( b ? p->ratio_on_item : p->ratio_off_item ), TRUE );
+    b = gtr_pref_flag_get (TR_PREFS_KEY_RATIO_ENABLED);
+    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (b ? p->ratio_on_item : p->ratio_off_item), TRUE);
 
-    gtk_menu_popup ( GTK_MENU( p->options_menu ), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time( ) );
+    gtk_menu_popup (GTK_MENU (p->options_menu), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time ());
 }
 
 /***
@@ -580,7 +580,7 @@ onOptionsClicked( GtkButton * button UNUSED, gpointer vp )
 ***/
 
 GtkWidget *
-gtr_window_new( GtkApplication * app, GtkUIManager * ui_mgr, TrCore * core )
+gtr_window_new (GtkApplication * app, GtkUIManager * ui_mgr, TrCore * core)
 {
     int           i, n;
     const char  * pch;
@@ -590,303 +590,303 @@ gtr_window_new( GtkApplication * app, GtkUIManager * ui_mgr, TrCore * core )
     GtkWindow   * win;
     GSList      * l;
 
-    p = g_new0( PrivateData, 1 );
+    p = g_new0 (PrivateData, 1);
 
     /* make the window */
-    self = gtk_application_window_new ( app );
-    g_object_set_qdata_full( G_OBJECT(self), get_private_data_key( ), p, privateFree );
-    win = GTK_WINDOW( self );
-    gtk_window_set_title( win, g_get_application_name( ) );
-    gtk_window_set_role( win, "tr-main" );
-    gtk_window_set_default_size( win,
-                                 gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_WIDTH ),
-                                 gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_HEIGHT ) );
-    gtk_window_move( win, gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_X ),
-                          gtr_pref_int_get( PREF_KEY_MAIN_WINDOW_Y ) );
-    if( gtr_pref_flag_get( PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED ) )
-        gtk_window_maximize( win );
-    gtk_window_add_accel_group( win, gtk_ui_manager_get_accel_group( ui_mgr ) );
+    self = gtk_application_window_new (app);
+    g_object_set_qdata_full (G_OBJECT (self), get_private_data_key (), p, privateFree);
+    win = GTK_WINDOW (self);
+    gtk_window_set_title (win, g_get_application_name ());
+    gtk_window_set_role (win, "tr-main");
+    gtk_window_set_default_size (win,
+                                 gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_WIDTH),
+                                 gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_HEIGHT));
+    gtk_window_move (win, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_X),
+                          gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_Y));
+    if (gtr_pref_flag_get (PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED))
+        gtk_window_maximize (win);
+    gtk_window_add_accel_group (win, gtk_ui_manager_get_accel_group (ui_mgr));
 
     /* window's main container */
-    vbox = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
-    gtk_container_add ( GTK_CONTAINER( self ), vbox );
+    vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+    gtk_container_add (GTK_CONTAINER (self), vbox);
 
     /* main menu */
-    mainmenu = gtr_action_get_widget( "/main-window-menu" );
-    w = gtr_action_get_widget( "/main-window-menu/torrent-menu/torrent-reannounce" );
-    g_signal_connect( w, "query-tooltip", G_CALLBACK( onAskTrackerQueryTooltip ), p );
+    mainmenu = gtr_action_get_widget ("/main-window-menu");
+    w = gtr_action_get_widget ("/main-window-menu/torrent-menu/torrent-reannounce");
+    g_signal_connect (w, "query-tooltip", G_CALLBACK (onAskTrackerQueryTooltip), p);
 
     /* toolbar */
-    toolbar = p->toolbar = gtr_action_get_widget( "/main-window-toolbar" );
-    gtk_style_context_add_class( gtk_widget_get_style_context( toolbar ),
-                                 GTK_STYLE_CLASS_PRIMARY_TOOLBAR );
-    gtr_action_set_important( "open-torrent-toolbar", TRUE );
-    gtr_action_set_important( "show-torrent-properties", TRUE );
+    toolbar = p->toolbar = gtr_action_get_widget ("/main-window-toolbar");
+    gtk_style_context_add_class (gtk_widget_get_style_context (toolbar),
+                                 GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
+    gtr_action_set_important ("open-torrent-toolbar", TRUE);
+    gtr_action_set_important ("show-torrent-properties", TRUE);
 
     /* filter */
-    h = filter = p->filter = gtr_filter_bar_new( gtr_core_session( core ),
-                                                 gtr_core_model( core ),
-                                                 &p->filter_model );
-    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
+    h = filter = p->filter = gtr_filter_bar_new (gtr_core_session (core),
+                                                 gtr_core_model (core),
+                                                 &p->filter_model);
+    gtk_container_set_border_width (GTK_CONTAINER (h), GUI_PAD_SMALL);
 
     /* status menu */
-    menu = p->status_menu = gtk_menu_new( );
+    menu = p->status_menu = gtk_menu_new ();
     l = NULL;
-    pch = gtr_pref_string_get( PREF_KEY_STATUSBAR_STATS );
-    for( i = 0, n = G_N_ELEMENTS( stats_modes ); i < n; ++i )
+    pch = gtr_pref_string_get (PREF_KEY_STATUSBAR_STATS);
+    for (i = 0, n = G_N_ELEMENTS (stats_modes); i < n; ++i)
     {
         const char * val = stats_modes[i].val;
-        w = gtk_radio_menu_item_new_with_label( l, _( stats_modes[i].i18n ) );
-        l = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM( w ) );
-        gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( w ),
-                                       !strcmp( val, pch ) );
-        g_object_set_data( G_OBJECT(
-                               w ), STATS_MODE,
-                           (gpointer)stats_modes[i].val );
-        g_signal_connect( w, "toggled", G_CALLBACK(
-                              status_menu_toggled_cb ), p );
-        gtk_menu_shell_append( GTK_MENU_SHELL( menu ), w );
-        gtk_widget_show( w );
+        w = gtk_radio_menu_item_new_with_label (l, _ (stats_modes[i].i18n));
+        l = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w));
+        gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
+                                       !strcmp (val, pch));
+        g_object_set_data (G_OBJECT (
+                               w), STATS_MODE,
+                         (gpointer)stats_modes[i].val);
+        g_signal_connect (w, "toggled", G_CALLBACK (
+                              status_menu_toggled_cb), p);
+        gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
+        gtk_widget_show (w);
     }
 
     /* status */
-    h = status = p->status = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG );
-    gtk_container_set_border_width( GTK_CONTAINER( h ), GUI_PAD_SMALL );
-
-        w = gtk_button_new( );
-        gtk_container_add( GTK_CONTAINER( w ), gtk_image_new_from_stock( "utilities", -1 ) );
-        gtk_widget_set_tooltip_text( w, _( "Options" ) );
-        gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
-        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
-        p->options_menu = createOptionsMenu( p );
-        g_signal_connect( w, "clicked", G_CALLBACK(onOptionsClicked), p );
-
-        p->alt_speed_image = gtk_image_new( );
-        w = p->alt_speed_button = gtk_toggle_button_new( );
-        gtk_button_set_image( GTK_BUTTON( w ), p->alt_speed_image );
-        gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
-        g_signal_connect( w, "toggled", G_CALLBACK(alt_speed_toggled_cb ), p );
-        gtk_box_pack_start( GTK_BOX( h ), w, 0, 0, 0 );
-
-        w = p->gutter_lb = gtk_label_new( "N Torrents" );
-        gtk_label_set_single_line_mode( GTK_LABEL( w ), TRUE );
-        gtk_box_pack_start( GTK_BOX( h ), w, 1, 1, GUI_PAD );
-
-        hbox = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD );
-            w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
-            gtk_widget_set_size_request( w, GUI_PAD, 0u );
-            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
-            w = p->ul_lb = gtk_label_new( NULL );
-            gtk_label_set_single_line_mode( GTK_LABEL( w ), TRUE );
-            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
-            w = gtk_image_new_from_stock( GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU );
-            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
-        gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
-
-        hbox = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD );
-            w = gtk_alignment_new( 0.0f, 0.0f, 0.0f, 0.0f );
-            gtk_widget_set_size_request( w, GUI_PAD, 0u );
-            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
-            w = p->dl_lb = gtk_label_new( NULL );
-            gtk_label_set_single_line_mode( GTK_LABEL( w ), TRUE );
-            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
-            w = gtk_image_new_from_stock( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU );
-            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
-        gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
-
-        hbox = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, GUI_PAD );
-            w = gtk_button_new( );
-            gtk_widget_set_tooltip_text( w, _( "Statistics" ) );
-            gtk_container_add( GTK_CONTAINER( w ), gtk_image_new_from_stock( "ratio", -1 ) );
-            gtk_button_set_relief( GTK_BUTTON( w ), GTK_RELIEF_NONE );
-            g_signal_connect( w, "clicked", G_CALLBACK( onYinYangReleased ), p );
-            gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
-            w = p->stats_lb = gtk_label_new( NULL );
-            gtk_label_set_single_line_mode( GTK_LABEL( w ), TRUE );
-            gtk_box_pack_end( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
-        gtk_box_pack_end( GTK_BOX( h ), hbox, FALSE, FALSE, 0 );
+    h = status = p->status = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD_BIG);
+    gtk_container_set_border_width (GTK_CONTAINER (h), GUI_PAD_SMALL);
+
+        w = gtk_button_new ();
+        gtk_container_add (GTK_CONTAINER (w), gtk_image_new_from_stock ("utilities", -1));
+        gtk_widget_set_tooltip_text (w, _("Options"));
+        gtk_box_pack_start (GTK_BOX (h), w, 0, 0, 0);
+        gtk_button_set_relief (GTK_BUTTON (w), GTK_RELIEF_NONE);
+        p->options_menu = createOptionsMenu (p);
+        g_signal_connect (w, "clicked", G_CALLBACK (onOptionsClicked), p);
+
+        p->alt_speed_image = gtk_image_new ();
+        w = p->alt_speed_button = gtk_toggle_button_new ();
+        gtk_button_set_image (GTK_BUTTON (w), p->alt_speed_image);
+        gtk_button_set_relief (GTK_BUTTON (w), GTK_RELIEF_NONE);
+        g_signal_connect (w, "toggled", G_CALLBACK (alt_speed_toggled_cb), p);
+        gtk_box_pack_start (GTK_BOX (h), w, 0, 0, 0);
+
+        w = p->gutter_lb = gtk_label_new ("N Torrents");
+        gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
+        gtk_box_pack_start (GTK_BOX (h), w, 1, 1, GUI_PAD);
+
+        hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
+            w = gtk_alignment_new (0.0f, 0.0f, 0.0f, 0.0f);
+            gtk_widget_set_size_request (w, GUI_PAD, 0u);
+            gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
+            w = p->ul_lb = gtk_label_new (NULL);
+            gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
+            gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
+            w = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU);
+            gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
+        gtk_box_pack_end (GTK_BOX (h), hbox, FALSE, FALSE, 0);
+
+        hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
+            w = gtk_alignment_new (0.0f, 0.0f, 0.0f, 0.0f);
+            gtk_widget_set_size_request (w, GUI_PAD, 0u);
+            gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
+            w = p->dl_lb = gtk_label_new (NULL);
+            gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
+            gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
+            w = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU);
+            gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
+        gtk_box_pack_end (GTK_BOX (h), hbox, FALSE, FALSE, 0);
+
+        hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, GUI_PAD);
+            w = gtk_button_new ();
+            gtk_widget_set_tooltip_text (w, _("Statistics"));
+            gtk_container_add (GTK_CONTAINER (w), gtk_image_new_from_stock ("ratio", -1));
+            gtk_button_set_relief (GTK_BUTTON (w), GTK_RELIEF_NONE);
+            g_signal_connect (w, "clicked", G_CALLBACK (onYinYangReleased), p);
+            gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
+            w = p->stats_lb = gtk_label_new (NULL);
+            gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
+            gtk_box_pack_end (GTK_BOX (hbox), w, FALSE, FALSE, 0);
+        gtk_box_pack_end (GTK_BOX (h), hbox, FALSE, FALSE, 0);
 
 
     /* workarea */
-    p->view = makeview( p );
-    w = list = p->scroll = gtk_scrolled_window_new( NULL, NULL );
-    gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( w ),
-                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
-    gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( w ),
-                                         GTK_SHADOW_IN );
-    gtk_container_add( GTK_CONTAINER( w ), p->view );
+    p->view = makeview (p);
+    w = list = p->scroll = gtk_scrolled_window_new (NULL, NULL);
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w),
+                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w),
+                                         GTK_SHADOW_IN);
+    gtk_container_add (GTK_CONTAINER (w), p->view);
 
     /* lay out the widgets */
-    gtk_box_pack_start( GTK_BOX( vbox ), mainmenu, FALSE, FALSE, 0 );
-    gtk_box_pack_start( GTK_BOX( vbox ), toolbar, FALSE, FALSE, 0 );
-    gtk_box_pack_start( GTK_BOX( vbox ), filter, FALSE, FALSE, 0 );
-    gtk_box_pack_start( GTK_BOX( vbox ), list, TRUE, TRUE, 0 );
-    gtk_box_pack_start( GTK_BOX( vbox ), status, FALSE, FALSE, 0 );
+    gtk_box_pack_start (GTK_BOX (vbox), mainmenu, FALSE, FALSE, 0);
+    gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
+    gtk_box_pack_start (GTK_BOX (vbox), filter, FALSE, FALSE, 0);
+    gtk_box_pack_start (GTK_BOX (vbox), list, TRUE, TRUE, 0);
+    gtk_box_pack_start (GTK_BOX (vbox), status, FALSE, FALSE, 0);
 
     {
         /* this is to determine the maximum width/height for the label */
         int w=0, h=0;
         PangoLayout * pango_layout;
-        pango_layout = gtk_widget_create_pango_layout( p->ul_lb, "999.99 kB/s" );
-        pango_layout_get_pixel_size( pango_layout, &w, &h );
-        gtk_widget_set_size_request( p->ul_lb, w, h );
-        gtk_widget_set_size_request( p->dl_lb, w, h );
-        gtk_misc_set_alignment( GTK_MISC( p->ul_lb ), 1.0, 0.5 );
-        gtk_misc_set_alignment( GTK_MISC( p->dl_lb ), 1.0, 0.5 );
-        g_object_unref( G_OBJECT( pango_layout ) );
+        pango_layout = gtk_widget_create_pango_layout (p->ul_lb, "999.99 kB/s");
+        pango_layout_get_pixel_size (pango_layout, &w, &h);
+        gtk_widget_set_size_request (p->ul_lb, w, h);
+        gtk_widget_set_size_request (p->dl_lb, w, h);
+        gtk_misc_set_alignment (GTK_MISC (p->ul_lb), 1.0, 0.5);
+        gtk_misc_set_alignment (GTK_MISC (p->dl_lb), 1.0, 0.5);
+        g_object_unref (G_OBJECT (pango_layout));
     }
 
     /* show all but the window */
-    gtk_widget_show_all( vbox );
+    gtk_widget_show_all (vbox);
 
     /* listen for prefs changes that affect the window */
     p->core = core;
-    prefsChanged( core, PREF_KEY_COMPACT_VIEW, self );
-    prefsChanged( core, PREF_KEY_FILTERBAR, self );
-    prefsChanged( core, PREF_KEY_STATUSBAR, self );
-    prefsChanged( core, PREF_KEY_STATUSBAR_STATS, self );
-    prefsChanged( core, PREF_KEY_TOOLBAR, self );
-    prefsChanged( core, TR_PREFS_KEY_ALT_SPEED_ENABLED, self );
-    p->pref_handler_id = g_signal_connect( core, "prefs-changed",
-                                           G_CALLBACK( prefsChanged ), self );
+    prefsChanged (core, PREF_KEY_COMPACT_VIEW, self);
+    prefsChanged (core, PREF_KEY_FILTERBAR, self);
+    prefsChanged (core, PREF_KEY_STATUSBAR, self);
+    prefsChanged (core, PREF_KEY_STATUSBAR_STATS, self);
+    prefsChanged (core, PREF_KEY_TOOLBAR, self);
+    prefsChanged (core, TR_PREFS_KEY_ALT_SPEED_ENABLED, self);
+    p->pref_handler_id = g_signal_connect (core, "prefs-changed",
+                                           G_CALLBACK (prefsChanged), self);
 
-    tr_sessionSetAltSpeedFunc( gtr_core_session( core ), onAltSpeedToggled, p );
+    tr_sessionSetAltSpeedFunc (gtr_core_session (core), onAltSpeedToggled, p);
 
     return self;
 }
 
 static void
-updateTorrentCount( PrivateData * p )
+updateTorrentCount (PrivateData * p)
 {
-    if( p && p->core )
+    if (p && p->core)
     {
         char      buf[512];
-        const int torrentCount = gtk_tree_model_iter_n_children( gtr_core_model( p->core ), NULL );
-        const int visibleCount = gtk_tree_model_iter_n_children( p->filter_model, NULL );
+        const int torrentCount = gtk_tree_model_iter_n_children (gtr_core_model (p->core), NULL);
+        const int visibleCount = gtk_tree_model_iter_n_children (p->filter_model, NULL);
 
-        if( !torrentCount )
+        if (!torrentCount)
             *buf = '\0';
-        else if( torrentCount != visibleCount )
-            g_snprintf( buf, sizeof( buf ),
-                        ngettext( "%1$'d of %2$'d Torrent",
+        else if (torrentCount != visibleCount)
+            g_snprintf (buf, sizeof (buf),
+                        ngettext ("%1$'d of %2$'d Torrent",
                                   "%1$'d of %2$'d Torrents",
-                                  torrentCount ),
-                        visibleCount, torrentCount );
+                                  torrentCount),
+                        visibleCount, torrentCount);
         else
-            g_snprintf( buf, sizeof( buf ),
-                        ngettext( "%'d Torrent", "%'d Torrents", torrentCount ),
-                        torrentCount );
-        gtr_label_set_text( GTK_LABEL( p->gutter_lb ), buf );
+            g_snprintf (buf, sizeof (buf),
+                        ngettext ("%'d Torrent", "%'d Torrents", torrentCount),
+                        torrentCount);
+        gtr_label_set_text (GTK_LABEL (p->gutter_lb), buf);
     }
 }
 
 static void
-updateStats( PrivateData * p )
+updateStats (PrivateData * p)
 {
     const char *            pch;
     char                    up[32], down[32], ratio[32], buf[512];
     struct tr_session_stats stats;
-    tr_session *            session = gtr_core_session( p->core );
+    tr_session *            session = gtr_core_session (p->core);
 
     /* update the stats */
-    pch = gtr_pref_string_get( PREF_KEY_STATUSBAR_STATS );
-    if( !strcmp( pch, "session-ratio" ) )
+    pch = gtr_pref_string_get (PREF_KEY_STATUSBAR_STATS);
+    if (!strcmp (pch, "session-ratio"))
     {
-        tr_sessionGetStats( session, &stats );
-        tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
-        g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
+        tr_sessionGetStats (session, &stats);
+        tr_strlratio (ratio, stats.ratio, sizeof (ratio));
+        g_snprintf (buf, sizeof (buf), _("Ratio: %s"), ratio);
     }
-    else if( !strcmp( pch, "session-transfer" ) )
+    else if (!strcmp (pch, "session-transfer"))
     {
-        tr_sessionGetStats( session, &stats );
-        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
-        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
+        tr_sessionGetStats (session, &stats);
+        tr_strlsize (up, stats.uploadedBytes, sizeof (up));
+        tr_strlsize (down, stats.downloadedBytes, sizeof (down));
         /* Translators: "size|" is here for disambiguation. Please remove it from your translation.
            %1$s is the size of the data we've downloaded
            %2$s is the size of the data we've uploaded */
-        g_snprintf( buf, sizeof( buf ), Q_(
-                        "Down: %1$s, Up: %2$s" ), down, up );
+        g_snprintf (buf, sizeof (buf), Q_ (
+                        "Down: %1$s, Up: %2$s"), down, up);
     }
-    else if( !strcmp( pch, "total-transfer" ) )
+    else if (!strcmp (pch, "total-transfer"))
     {
-        tr_sessionGetCumulativeStats( session, &stats );
-        tr_strlsize( up, stats.uploadedBytes, sizeof( up ) );
-        tr_strlsize( down, stats.downloadedBytes, sizeof( down ) );
+        tr_sessionGetCumulativeStats (session, &stats);
+        tr_strlsize (up, stats.uploadedBytes, sizeof (up));
+        tr_strlsize (down, stats.downloadedBytes, sizeof (down));
         /* Translators: "size|" is here for disambiguation. Please remove it from your translation.
            %1$s is the size of the data we've downloaded
            %2$s is the size of the data we've uploaded */
-        g_snprintf( buf, sizeof( buf ), Q_(
-                        "size|Down: %1$s, Up: %2$s" ), down, up );
+        g_snprintf (buf, sizeof (buf), Q_ (
+                        "size|Down: %1$s, Up: %2$s"), down, up);
     }
     else     /* default is total-ratio */
     {
-        tr_sessionGetCumulativeStats( session, &stats );
-        tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
-        g_snprintf( buf, sizeof( buf ), _( "Ratio: %s" ), ratio );
+        tr_sessionGetCumulativeStats (session, &stats);
+        tr_strlratio (ratio, stats.ratio, sizeof (ratio));
+        g_snprintf (buf, sizeof (buf), _("Ratio: %s"), ratio);
     }
-    gtr_label_set_text( GTK_LABEL( p->stats_lb ), buf );
+    gtr_label_set_text (GTK_LABEL (p->stats_lb), buf);
 }
 
 static void
-updateSpeeds( PrivateData * p )
+updateSpeeds (PrivateData * p)
 {
-    tr_session * session = gtr_core_session( p->core );
+    tr_session * session = gtr_core_session (p->core);
 
-    if( session != NULL )
+    if (session != NULL)
     {
         char buf[128];
         double up=0, down=0;
         GtkTreeIter iter;
-        GtkTreeModel * model = gtr_core_model( p->core );
+        GtkTreeModel * model = gtr_core_model (p->core);
 
-        if( gtk_tree_model_iter_nth_child( model, &iter, NULL, 0 ) ) do
+        if (gtk_tree_model_iter_nth_child (model, &iter, NULL, 0)) do
         {
             double u, d;
-            gtk_tree_model_get( model, &iter, MC_SPEED_UP, &u,
+            gtk_tree_model_get (model, &iter, MC_SPEED_UP, &u,
                                               MC_SPEED_DOWN, &d,
-                                              -1 );
+                                              -1);
             up += u;
             down += d;
         }
-        while( gtk_tree_model_iter_next( model, &iter ) );
+        while (gtk_tree_model_iter_next (model, &iter));
 
-        tr_formatter_speed_KBps( buf, down, sizeof( buf ) );
-        gtr_label_set_text( GTK_LABEL( p->dl_lb ), buf );
+        tr_formatter_speed_KBps (buf, down, sizeof (buf));
+        gtr_label_set_text (GTK_LABEL (p->dl_lb), buf);
 
-        tr_formatter_speed_KBps( buf, up, sizeof( buf ) );
-        gtr_label_set_text( GTK_LABEL( p->ul_lb ), buf );
+        tr_formatter_speed_KBps (buf, up, sizeof (buf));
+        gtr_label_set_text (GTK_LABEL (p->ul_lb), buf);
     }
 }
 
 void
-gtr_window_refresh( GtkWindow * self )
+gtr_window_refresh (GtkWindow * self)
 {
-    PrivateData * p = get_private_data( self );
+    PrivateData * p = get_private_data (self);
 
-    if( p && p->core && gtr_core_session( p->core ) )
+    if (p && p->core && gtr_core_session (p->core))
     {
-        updateSpeeds( p );
-        updateTorrentCount( p );
-        updateStats( p );
+        updateSpeeds (p);
+        updateTorrentCount (p);
+        updateStats (p);
     }
 }
 
 GtkTreeSelection*
-gtr_window_get_selection( GtkWindow * w )
+gtr_window_get_selection (GtkWindow * w)
 {
-    return get_private_data( w )->selection;
+    return get_private_data (w)->selection;
 }
 
 void
-gtr_window_set_busy( GtkWindow * w, gboolean isBusy )
+gtr_window_set_busy (GtkWindow * w, gboolean isBusy)
 {
-    if( w && gtk_widget_get_realized( GTK_WIDGET( w ) ) )
+    if (w && gtk_widget_get_realized (GTK_WIDGET (w)))
     {
-        GdkDisplay * display = gtk_widget_get_display( GTK_WIDGET( w ) );
-        GdkCursor * cursor = isBusy ? gdk_cursor_new_for_display( display, GDK_WATCH ) : NULL;
+        GdkDisplay * display = gtk_widget_get_display (GTK_WIDGET (w));
+        GdkCursor * cursor = isBusy ? gdk_cursor_new_for_display (display, GDK_WATCH) : NULL;
 
-        gdk_window_set_cursor( gtk_widget_get_window( GTK_WIDGET( w ) ), cursor );
-        gdk_display_flush( display );
+        gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (w)), cursor);
+        gdk_display_flush (display);
 
         g_clear_object (&cursor);
     }
diff --git a/gtk/tr-window.h b/gtk/tr-window.h
index 63b2d490e..3f01c776c 100644
--- a/gtk/tr-window.h
+++ b/gtk/tr-window.h
@@ -28,9 +28,9 @@
 #include <gtk/gtk.h>
 #include "tr-core.h"
 
-GtkWidget        * gtr_window_new( GtkApplication * app, GtkUIManager * uim, TrCore * core );
-GtkTreeSelection * gtr_window_get_selection( GtkWindow * );
-void               gtr_window_set_busy( GtkWindow *, gboolean isBusy );
-void               gtr_window_refresh( GtkWindow * );
+GtkWidget        * gtr_window_new (GtkApplication * app, GtkUIManager * uim, TrCore * core);
+GtkTreeSelection * gtr_window_get_selection (GtkWindow *);
+void               gtr_window_set_busy (GtkWindow *, gboolean isBusy);
+void               gtr_window_refresh (GtkWindow *);
 
 #endif /* GTR_WINDOW_H */
diff --git a/gtk/util.c b/gtk/util.c
index f94d11201..0a270b226 100644
--- a/gtk/util.c
+++ b/gtk/util.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,19 +10,19 @@
  * $Id$
  */
 
-#include <ctype.h> /* isxdigit() */
+#include <ctype.h> /* isxdigit () */
 #include <errno.h>
 #include <stdarg.h>
-#include <string.h> /* strchr(), strrchr(), strlen(), strstr() */
+#include <string.h> /* strchr (), strrchr (), strlen (), strstr () */
 
 #include <gtk/gtk.h>
 #include <glib/gi18n.h>
-#include <glib/gstdio.h> /* g_unlink() */
-#include <gio/gio.h> /* g_file_trash() */
+#include <glib/gstdio.h> /* g_unlink () */
+#include <gio/gio.h> /* g_file_trash () */
 
 #include <libtransmission/transmission.h> /* TR_RATIO_NA, TR_RATIO_INF */
-#include <libtransmission/utils.h> /* tr_strratio() */
-#include <libtransmission/web.h> /* tr_webResponseStr() */
+#include <libtransmission/utils.h> /* tr_strratio () */
+#include <libtransmission/web.h> /* tr_webResponseStr () */
 #include <libtransmission/version.h> /* SHORT_VERSION_STRING */
 
 #include "conf.h"
@@ -57,9 +57,9 @@ const char * speed_T_str = N_("TB/s");
 ***/
 
 const char*
-gtr_get_unicode_string( int i )
+gtr_get_unicode_string (int i)
 {
-    switch( i ) {
+    switch (i) {
         case GTR_UNICODE_UP:      return "\xE2\x86\x91";
         case GTR_UNICODE_DOWN:    return "\xE2\x86\x93";
         case GTR_UNICODE_INF:     return "\xE2\x88\x9E";
@@ -69,71 +69,71 @@ gtr_get_unicode_string( int i )
 }
 
 char*
-tr_strlratio( char * buf, double ratio, size_t buflen )
+tr_strlratio (char * buf, double ratio, size_t buflen)
 {
-    return tr_strratio( buf, buflen, ratio, gtr_get_unicode_string( GTR_UNICODE_INF ) );
+    return tr_strratio (buf, buflen, ratio, gtr_get_unicode_string (GTR_UNICODE_INF));
 }
 
 char*
-tr_strlpercent( char * buf, double x, size_t buflen )
+tr_strlpercent (char * buf, double x, size_t buflen)
 {
-    return tr_strpercent( buf, x, buflen );
+    return tr_strpercent (buf, x, buflen);
 }
 
 char*
-tr_strlsize( char * buf, guint64 bytes, size_t buflen )
+tr_strlsize (char * buf, guint64 bytes, size_t buflen)
 {
-    if( !bytes )
-        g_strlcpy( buf, Q_( "None" ), buflen );
+    if (!bytes)
+        g_strlcpy (buf, Q_("None"), buflen);
     else
-        tr_formatter_size_B( buf, bytes, buflen );
+        tr_formatter_size_B (buf, bytes, buflen);
 
     return buf;
 }
 
 char*
-tr_strltime( char * buf, int seconds, size_t buflen )
+tr_strltime (char * buf, int seconds, size_t buflen)
 {
     int  days, hours, minutes;
     char d[128], h[128], m[128], s[128];
 
-    if( seconds < 0 )
+    if (seconds < 0)
         seconds = 0;
 
     days = seconds / 86400;
-    hours = ( seconds % 86400 ) / 3600;
-    minutes = ( seconds % 3600 ) / 60;
-    seconds = ( seconds % 3600 ) % 60;
+    hours = (seconds % 86400) / 3600;
+    minutes = (seconds % 3600) / 60;
+    seconds = (seconds % 3600) % 60;
 
-    g_snprintf( d, sizeof( d ), ngettext( "%'d day", "%'d days", days ), days );
-    g_snprintf( h, sizeof( h ), ngettext( "%'d hour", "%'d hours", hours ), hours );
-    g_snprintf( m, sizeof( m ), ngettext( "%'d minute", "%'d minutes", minutes ), minutes );
-    g_snprintf( s, sizeof( s ), ngettext( "%'d second", "%'d seconds", seconds ), seconds );
+    g_snprintf (d, sizeof (d), ngettext ("%'d day", "%'d days", days), days);
+    g_snprintf (h, sizeof (h), ngettext ("%'d hour", "%'d hours", hours), hours);
+    g_snprintf (m, sizeof (m), ngettext ("%'d minute", "%'d minutes", minutes), minutes);
+    g_snprintf (s, sizeof (s), ngettext ("%'d second", "%'d seconds", seconds), seconds);
 
-    if( days )
+    if (days)
     {
-        if( days >= 4 || !hours )
-            g_strlcpy( buf, d, buflen );
+        if (days >= 4 || !hours)
+            g_strlcpy (buf, d, buflen);
         else
-            g_snprintf( buf, buflen, "%s, %s", d, h );
+            g_snprintf (buf, buflen, "%s, %s", d, h);
     }
-    else if( hours )
+    else if (hours)
     {
-        if( hours >= 4 || !minutes )
-            g_strlcpy( buf, h, buflen );
+        if (hours >= 4 || !minutes)
+            g_strlcpy (buf, h, buflen);
         else
-            g_snprintf( buf, buflen, "%s, %s", h, m );
+            g_snprintf (buf, buflen, "%s, %s", h, m);
     }
-    else if( minutes )
+    else if (minutes)
     {
-        if( minutes >= 4 || !seconds )
-            g_strlcpy( buf, m, buflen );
+        if (minutes >= 4 || !seconds)
+            g_strlcpy (buf, m, buflen);
         else
-            g_snprintf( buf, buflen, "%s, %s", m, s );
+            g_snprintf (buf, buflen, "%s, %s", m, s);
     }
     else
     {
-        g_strlcpy( buf, s, buflen );
+        g_strlcpy (buf, s, buflen);
     }
 
     return buf;
@@ -141,135 +141,135 @@ tr_strltime( char * buf, int seconds, size_t buflen )
 
 /* pattern-matching text; ie, legaltorrents.com */
 void
-gtr_get_host_from_url( char * buf, size_t buflen, const char * url )
+gtr_get_host_from_url (char * buf, size_t buflen, const char * url)
 {
     char host[1024];
     const char * pch;
 
-    if(( pch = strstr( url, "://" ))) {
-        const size_t hostlen = strcspn( pch+3, ":/" );
-        const size_t copylen = MIN( hostlen, sizeof(host)-1 );
-        memcpy( host, pch+3, copylen );
+    if ((pch = strstr (url, "://"))) {
+        const size_t hostlen = strcspn (pch+3, ":/");
+        const size_t copylen = MIN (hostlen, sizeof (host)-1);
+        memcpy (host, pch+3, copylen);
         host[copylen] = '\0';
     } else {
         *host = '\0';
     }
 
-    if( tr_addressIsIP( host ) )
-        g_strlcpy( buf, url, buflen );
+    if (tr_addressIsIP (host))
+        g_strlcpy (buf, url, buflen);
     else {
-        const char * first_dot = strchr( host, '.' );
-        const char * last_dot = strrchr( host, '.' );
-        if( ( first_dot ) && ( last_dot ) && ( first_dot != last_dot ) )
-            g_strlcpy( buf, first_dot + 1, buflen );
+        const char * first_dot = strchr (host, '.');
+        const char * last_dot = strrchr (host, '.');
+        if ((first_dot) && (last_dot) && (first_dot != last_dot))
+            g_strlcpy (buf, first_dot + 1, buflen);
         else
-            g_strlcpy( buf, host, buflen );
+            g_strlcpy (buf, host, buflen);
     }
 }
 
 static gboolean
-gtr_is_supported_url( const char * str )
+gtr_is_supported_url (const char * str)
 {
-    return ( ( str != NULL ) &&
-             ( g_str_has_prefix( str, "ftp://" ) ||
-               g_str_has_prefix( str, "http://" ) ||
-               g_str_has_prefix( str, "https://" ) ) );
+    return ((str != NULL) &&
+           (g_str_has_prefix (str, "ftp://") ||
+               g_str_has_prefix (str, "http://") ||
+               g_str_has_prefix (str, "https://")));
 }
 
 gboolean
-gtr_is_magnet_link( const char * str )
+gtr_is_magnet_link (const char * str)
 {
-    return ( str != NULL ) &&
-           ( g_str_has_prefix( str, "magnet:?" ) );
+    return (str != NULL) &&
+         (g_str_has_prefix (str, "magnet:?"));
 }
 
 gboolean
-gtr_is_hex_hashcode( const char * str )
+gtr_is_hex_hashcode (const char * str)
 {
     int i;
 
-    if( !str || ( strlen( str ) != 40 ) )
+    if (!str || (strlen (str) != 40))
         return FALSE;
 
-    for( i=0; i<40; ++i )
-        if( !isxdigit( str[i] ) )
+    for (i=0; i<40; ++i)
+        if (!isxdigit (str[i]))
             return FALSE;
 
     return TRUE;
 }
 
 static GtkWindow *
-getWindow( GtkWidget * w )
+getWindow (GtkWidget * w)
 {
-    if( w == NULL )
+    if (w == NULL)
         return NULL;
 
-    if( GTK_IS_WINDOW( w ) )
-        return GTK_WINDOW( w );
+    if (GTK_IS_WINDOW (w))
+        return GTK_WINDOW (w);
 
-    return GTK_WINDOW( gtk_widget_get_ancestor( w, GTK_TYPE_WINDOW ) );
+    return GTK_WINDOW (gtk_widget_get_ancestor (w, GTK_TYPE_WINDOW));
 }
 
 void
-gtr_add_torrent_error_dialog( GtkWidget * child, int err, const char * file )
+gtr_add_torrent_error_dialog (GtkWidget * child, int err, const char * file)
 {
     char * secondary;
     const char * fmt;
     GtkWidget * w;
-    GtkWindow * win = getWindow( child );
+    GtkWindow * win = getWindow (child);
 
-    switch( err )
+    switch (err)
     {
-        case TR_PARSE_ERR: fmt = _( "The torrent file \"%s\" contains invalid data." ); break;
-        case TR_PARSE_DUPLICATE: fmt = _( "The torrent file \"%s\" is already in use." ); break;
-        default: fmt = _( "The torrent file \"%s\" encountered an unknown error." ); break;
+        case TR_PARSE_ERR: fmt = _("The torrent file \"%s\" contains invalid data."); break;
+        case TR_PARSE_DUPLICATE: fmt = _("The torrent file \"%s\" is already in use."); break;
+        default: fmt = _("The torrent file \"%s\" encountered an unknown error."); break;
     }
-    secondary = g_strdup_printf( fmt, file );
+    secondary = g_strdup_printf (fmt, file);
 
-    w = gtk_message_dialog_new( win,
+    w = gtk_message_dialog_new (win,
                                 GTK_DIALOG_DESTROY_WITH_PARENT,
                                 GTK_MESSAGE_ERROR,
                                 GTK_BUTTONS_CLOSE,
-                                "%s", _( "Error opening torrent" ) );
-    gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ),
-                                              "%s", secondary );
-    g_signal_connect_swapped( w, "response",
-                              G_CALLBACK( gtk_widget_destroy ), w );
-    gtk_widget_show_all( w );
-    g_free( secondary );
+                                "%s", _("Error opening torrent"));
+    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w),
+                                              "%s", secondary);
+    g_signal_connect_swapped (w, "response",
+                              G_CALLBACK (gtk_widget_destroy), w);
+    gtk_widget_show_all (w);
+    g_free (secondary);
 }
 
-typedef void ( PopupFunc )( GtkWidget*, GdkEventButton* );
+typedef void (PopupFunc)(GtkWidget*, GdkEventButton*);
 
 /* pop up the context menu if a user right-clicks.
    if the row they right-click on isn't selected, select it. */
 
 gboolean
-on_tree_view_button_pressed( GtkWidget *      view,
+on_tree_view_button_pressed (GtkWidget *      view,
                              GdkEventButton * event,
-                             gpointer         func )
+                             gpointer         func)
 {
-    GtkTreeView * tv = GTK_TREE_VIEW( view );
+    GtkTreeView * tv = GTK_TREE_VIEW (view);
 
-    if( event->type == GDK_BUTTON_PRESS  &&  event->button == 3 )
+    if (event->type == GDK_BUTTON_PRESS  &&  event->button == 3)
     {
-        GtkTreeSelection * selection = gtk_tree_view_get_selection( tv );
+        GtkTreeSelection * selection = gtk_tree_view_get_selection (tv);
         GtkTreePath *      path;
-        if( gtk_tree_view_get_path_at_pos ( tv,
-                                            (gint) event->x,
-                                            (gint) event->y,
-                                            &path, NULL, NULL, NULL ) )
+        if (gtk_tree_view_get_path_at_pos (tv,
+                                          (gint) event->x,
+                                          (gint) event->y,
+                                            &path, NULL, NULL, NULL))
         {
-            if( !gtk_tree_selection_path_is_selected ( selection, path ) )
+            if (!gtk_tree_selection_path_is_selected (selection, path))
             {
-                gtk_tree_selection_unselect_all ( selection );
-                gtk_tree_selection_select_path ( selection, path );
+                gtk_tree_selection_unselect_all (selection);
+                gtk_tree_selection_select_path (selection, path);
             }
-            gtk_tree_path_free( path );
+            gtk_tree_path_free (path);
         }
 
-        if( func != NULL )
-            ( (PopupFunc*)func )( view, event );
+        if (func != NULL)
+          ((PopupFunc*)func)(view, event);
 
         return TRUE;
     }
@@ -280,113 +280,113 @@ on_tree_view_button_pressed( GtkWidget *      view,
 /* if the user clicked in an empty area of the list,
  * clear all the selections. */
 gboolean
-on_tree_view_button_released( GtkWidget *      view,
+on_tree_view_button_released (GtkWidget *      view,
                               GdkEventButton * event,
-                              gpointer         unused UNUSED )
+                              gpointer         unused UNUSED)
 {
-    GtkTreeView * tv = GTK_TREE_VIEW( view );
+    GtkTreeView * tv = GTK_TREE_VIEW (view);
 
-    if( !gtk_tree_view_get_path_at_pos ( tv,
-                                         (gint) event->x,
-                                         (gint) event->y,
-                                         NULL, NULL, NULL, NULL ) )
+    if (!gtk_tree_view_get_path_at_pos (tv,
+                                       (gint) event->x,
+                                       (gint) event->y,
+                                         NULL, NULL, NULL, NULL))
     {
-        GtkTreeSelection * selection = gtk_tree_view_get_selection( tv );
-        gtk_tree_selection_unselect_all ( selection );
+        GtkTreeSelection * selection = gtk_tree_view_get_selection (tv);
+        gtk_tree_selection_unselect_all (selection);
     }
 
     return FALSE;
 }
 
 int
-gtr_file_trash_or_remove( const char * filename )
+gtr_file_trash_or_remove (const char * filename)
 {
     GFile * file;
     gboolean trashed = FALSE;
 
     g_return_val_if_fail (filename && *filename, 0);
 
-    file = g_file_new_for_path( filename );
+    file = g_file_new_for_path (filename);
 
-    if( gtr_pref_flag_get( PREF_KEY_TRASH_CAN_ENABLED ) ) {
+    if (gtr_pref_flag_get (PREF_KEY_TRASH_CAN_ENABLED)) {
         GError * err = NULL;
-        trashed = g_file_trash( file, NULL, &err );
-        if( err ) {
-            g_message( "Unable to trash file \"%s\": %s", filename, err->message );
-            g_clear_error( &err );
+        trashed = g_file_trash (file, NULL, &err);
+        if (err) {
+            g_message ("Unable to trash file \"%s\": %s", filename, err->message);
+            g_clear_error (&err);
         }
     }
 
-    if( !trashed ) {
+    if (!trashed) {
         GError * err = NULL;
-        g_file_delete( file, NULL, &err );
-        if( err ) {
-            g_message( "Unable to delete file \"%s\": %s", filename, err->message );
-            g_clear_error( &err );
+        g_file_delete (file, NULL, &err);
+        if (err) {
+            g_message ("Unable to delete file \"%s\": %s", filename, err->message);
+            g_clear_error (&err);
         }
     }
 
-    g_object_unref( G_OBJECT( file ) );
+    g_object_unref (G_OBJECT (file));
     return 0;
 }
 
 const char*
-gtr_get_help_uri( void )
+gtr_get_help_uri (void)
 {
     static char * uri = NULL;
 
-    if( !uri )
+    if (!uri)
     {
         int major, minor;
         const char * fmt = "http://www.transmissionbt.com/help/gtk/%d.%dx";
-        sscanf( SHORT_VERSION_STRING, "%d.%d", &major, &minor );
-        uri = g_strdup_printf( fmt, major, minor / 10 );
+        sscanf (SHORT_VERSION_STRING, "%d.%d", &major, &minor);
+        uri = g_strdup_printf (fmt, major, minor / 10);
     }
 
     return uri;
 }
 
 void
-gtr_open_file( const char * path )
+gtr_open_file (const char * path)
 {
     char * uri;
 
-    GFile * file = g_file_new_for_path( path );
-    g_object_unref( G_OBJECT( file ) );
+    GFile * file = g_file_new_for_path (path);
+    g_object_unref (G_OBJECT (file));
 
-    if( g_path_is_absolute( path ) )
-        uri = g_strdup_printf( "file://%s", path );
+    if (g_path_is_absolute (path))
+        uri = g_strdup_printf ("file://%s", path);
     else {
-        char * cwd = g_get_current_dir();
-        uri = g_strdup_printf( "file://%s/%s", cwd, path );
-        g_free( cwd );
+        char * cwd = g_get_current_dir ();
+        uri = g_strdup_printf ("file://%s/%s", cwd, path);
+        g_free (cwd);
     }
 
-    gtr_open_uri( uri );
-    g_free( uri );
+    gtr_open_uri (uri);
+    g_free (uri);
 }
 
 void
-gtr_open_uri( const char * uri )
+gtr_open_uri (const char * uri)
 {
-    if( uri )
+    if (uri)
     {
         gboolean opened = FALSE;
 
-        if( !opened )
-            opened = gtk_show_uri( NULL, uri, GDK_CURRENT_TIME, NULL );
+        if (!opened)
+            opened = gtk_show_uri (NULL, uri, GDK_CURRENT_TIME, NULL);
 
-        if( !opened )
-            opened = g_app_info_launch_default_for_uri( uri, NULL, NULL );
+        if (!opened)
+            opened = g_app_info_launch_default_for_uri (uri, NULL, NULL);
 
-        if( !opened ) {
+        if (!opened) {
             char * argv[] = { (char*)"xdg-open", (char*)uri, NULL };
-            opened = g_spawn_async( NULL, argv, NULL, G_SPAWN_SEARCH_PATH,
-                                    NULL, NULL, NULL, NULL );
+            opened = g_spawn_async (NULL, argv, NULL, G_SPAWN_SEARCH_PATH,
+                                    NULL, NULL, NULL, NULL);
         }
 
-        if( !opened )
-            g_message( "Unable to open \"%s\"", uri );
+        if (!opened)
+            g_message ("Unable to open \"%s\"", uri);
     }
 }
 
@@ -395,27 +395,27 @@ gtr_open_uri( const char * uri )
 ***/
 
 void
-gtr_combo_box_set_active_enum( GtkComboBox * combo_box, int value )
+gtr_combo_box_set_active_enum (GtkComboBox * combo_box, int value)
 {
     int i;
     int currentValue;
     const int column = 0;
     GtkTreeIter iter;
-    GtkTreeModel * model = gtk_combo_box_get_model( combo_box );
+    GtkTreeModel * model = gtk_combo_box_get_model (combo_box);
 
     /* do the value and current value match? */
-    if( gtk_combo_box_get_active_iter( combo_box, &iter ) ) {
-        gtk_tree_model_get( model, &iter, column, &currentValue, -1 );
-        if( currentValue == value )
+    if (gtk_combo_box_get_active_iter (combo_box, &iter)) {
+        gtk_tree_model_get (model, &iter, column, &currentValue, -1);
+        if (currentValue == value)
             return;
     }
 
     /* find the one to select */
     i = 0;
-    while(( gtk_tree_model_iter_nth_child( model, &iter, NULL, i++ ))) {
-        gtk_tree_model_get( model, &iter, column, &currentValue, -1 );
-        if( currentValue == value ) {
-            gtk_combo_box_set_active_iter( combo_box, &iter );
+    while ((gtk_tree_model_iter_nth_child (model, &iter, NULL, i++))) {
+        gtk_tree_model_get (model, &iter, column, &currentValue, -1);
+        if (currentValue == value) {
+            gtk_combo_box_set_active_iter (combo_box, &iter);
             return;
         }
     }
@@ -423,55 +423,55 @@ gtr_combo_box_set_active_enum( GtkComboBox * combo_box, int value )
 
 
 GtkWidget *
-gtr_combo_box_new_enum( const char * text_1, ... )
+gtr_combo_box_new_enum (const char * text_1, ...)
 {
     GtkWidget * w;
     GtkCellRenderer * r;
     GtkListStore * store;
     va_list vl;
     const char * text;
-    va_start( vl, text_1 );
+    va_start (vl, text_1);
 
-    store = gtk_list_store_new( 2, G_TYPE_INT, G_TYPE_STRING );
+    store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
 
     text = text_1;
-    if( text != NULL ) do
+    if (text != NULL) do
     {
-        const int val = va_arg( vl, int );
-        gtk_list_store_insert_with_values( store, NULL, INT_MAX, 0, val, 1, text, -1 );
-        text = va_arg( vl, const char * );
+        const int val = va_arg (vl, int);
+        gtk_list_store_insert_with_values (store, NULL, INT_MAX, 0, val, 1, text, -1);
+        text = va_arg (vl, const char *);
     }
-    while( text != NULL );
+    while (text != NULL);
 
-    w = gtk_combo_box_new_with_model( GTK_TREE_MODEL( store ) );
-    r = gtk_cell_renderer_text_new( );
-    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( w ), r, TRUE );
-    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( w ), r, "text", 1, NULL );
+    w = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
+    r = gtk_cell_renderer_text_new ();
+    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (w), r, TRUE);
+    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (w), r, "text", 1, NULL);
 
     /* cleanup */
-    g_object_unref( store );
+    g_object_unref (store);
     return w;
 }
 
 int
-gtr_combo_box_get_active_enum( GtkComboBox * combo_box )
+gtr_combo_box_get_active_enum (GtkComboBox * combo_box)
 {
     int value = 0;
     GtkTreeIter iter;
 
-    if( gtk_combo_box_get_active_iter( combo_box, &iter ) )
-        gtk_tree_model_get( gtk_combo_box_get_model( combo_box ), &iter, 0, &value, -1 );
+    if (gtk_combo_box_get_active_iter (combo_box, &iter))
+        gtk_tree_model_get (gtk_combo_box_get_model (combo_box), &iter, 0, &value, -1);
 
     return value;
 }
 
 GtkWidget *
-gtr_priority_combo_new( void )
+gtr_priority_combo_new (void)
 {
-    return gtr_combo_box_new_enum( _( "High" ),   TR_PRI_HIGH,
-                                   _( "Normal" ), TR_PRI_NORMAL,
-                                   _( "Low" ),    TR_PRI_LOW,
-                                   NULL );
+    return gtr_combo_box_new_enum (_("High"),   TR_PRI_HIGH,
+                                   _("Normal"), TR_PRI_NORMAL,
+                                   _("Low"),    TR_PRI_LOW,
+                                   NULL);
 }
 
 /***
@@ -481,48 +481,48 @@ gtr_priority_combo_new( void )
 #define GTR_CHILD_HIDDEN "gtr-child-hidden"
 
 void
-gtr_widget_set_visible( GtkWidget * w, gboolean b )
+gtr_widget_set_visible (GtkWidget * w, gboolean b)
 {
     /* toggle the transient children, too */
-    if( GTK_IS_WINDOW( w ) )
+    if (GTK_IS_WINDOW (w))
     {
         GList * l;
-        GList * windows = gtk_window_list_toplevels( );
-        GtkWindow * window = GTK_WINDOW( w );
+        GList * windows = gtk_window_list_toplevels ();
+        GtkWindow * window = GTK_WINDOW (w);
 
-        for( l=windows; l!=NULL; l=l->next )
+        for (l=windows; l!=NULL; l=l->next)
         {
-            if( !GTK_IS_WINDOW( l->data ) )
+            if (!GTK_IS_WINDOW (l->data))
                 continue;
-            if( gtk_window_get_transient_for( GTK_WINDOW( l->data ) ) != window )
+            if (gtk_window_get_transient_for (GTK_WINDOW (l->data)) != window)
                 continue;
-            if( gtk_widget_get_visible( GTK_WIDGET( l->data ) ) == b )
+            if (gtk_widget_get_visible (GTK_WIDGET (l->data)) == b)
                 continue;
 
-            if( b && g_object_get_data( G_OBJECT( l->data ), GTR_CHILD_HIDDEN ) != NULL )
+            if (b && g_object_get_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN) != NULL)
             {
-                g_object_steal_data( G_OBJECT( l->data ), GTR_CHILD_HIDDEN );
-                gtr_widget_set_visible( GTK_WIDGET( l->data ), TRUE );
+                g_object_steal_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN);
+                gtr_widget_set_visible (GTK_WIDGET (l->data), TRUE);
             }
-            else if( !b )
+            else if (!b)
             {
-                g_object_set_data( G_OBJECT( l->data ), GTR_CHILD_HIDDEN, GINT_TO_POINTER( 1 ) );
-                gtr_widget_set_visible( GTK_WIDGET( l->data ), FALSE );
+                g_object_set_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN, GINT_TO_POINTER (1));
+                gtr_widget_set_visible (GTK_WIDGET (l->data), FALSE);
             }
         }
 
-        g_list_free( windows );
+        g_list_free (windows);
     }
 
-    gtk_widget_set_visible( w, b );
+    gtk_widget_set_visible (w, b);
 }
 
 void
-gtr_dialog_set_content( GtkDialog * dialog, GtkWidget * content )
+gtr_dialog_set_content (GtkDialog * dialog, GtkWidget * content)
 {
-    GtkWidget * vbox = gtk_dialog_get_content_area( dialog );
-    gtk_box_pack_start( GTK_BOX( vbox ), content, TRUE, TRUE, 0 );
-    gtk_widget_show_all( content );
+    GtkWidget * vbox = gtk_dialog_get_content_area (dialog);
+    gtk_box_pack_start (GTK_BOX (vbox), content, TRUE, TRUE, 0);
+    gtk_widget_show_all (content);
 }
 
 /***
@@ -530,50 +530,50 @@ gtr_dialog_set_content( GtkDialog * dialog, GtkWidget * content )
 ***/
 
 void
-gtr_http_failure_dialog( GtkWidget * parent, const char * url, long response_code )
+gtr_http_failure_dialog (GtkWidget * parent, const char * url, long response_code)
 {
-    GtkWindow * window = getWindow( parent );
+    GtkWindow * window = getWindow (parent);
 
-    GtkWidget * w = gtk_message_dialog_new( window, 0,
+    GtkWidget * w = gtk_message_dialog_new (window, 0,
                                             GTK_MESSAGE_ERROR,
                                             GTK_BUTTONS_CLOSE,
-                                            _( "Error opening \"%s\"" ), url );
+                                            _("Error opening \"%s\""), url);
 
-    gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ),
-                                              _( "Server returned \"%1$ld %2$s\"" ),
+    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w),
+                                              _("Server returned \"%1$ld %2$s\""),
                                               response_code,
-                                              tr_webGetResponseStr( response_code ) );
+                                              tr_webGetResponseStr (response_code));
 
-    g_signal_connect_swapped( w, "response", G_CALLBACK( gtk_widget_destroy ), w );
-    gtk_widget_show( w );
+    g_signal_connect_swapped (w, "response", G_CALLBACK (gtk_widget_destroy), w);
+    gtk_widget_show (w);
 }
 
 void
-gtr_unrecognized_url_dialog( GtkWidget * parent, const char * url )
+gtr_unrecognized_url_dialog (GtkWidget * parent, const char * url)
 {
     const char * xt = "xt=urn:btih";
 
-    GtkWindow * window = getWindow( parent );
+    GtkWindow * window = getWindow (parent);
 
-    GString * gstr = g_string_new( NULL );
+    GString * gstr = g_string_new (NULL);
 
-    GtkWidget * w = gtk_message_dialog_new( window, 0,
+    GtkWidget * w = gtk_message_dialog_new (window, 0,
                                             GTK_MESSAGE_ERROR,
                                             GTK_BUTTONS_CLOSE,
-                                            "%s", _( "Unrecognized URL" ) );
+                                            "%s", _("Unrecognized URL"));
 
-    g_string_append_printf( gstr, _( "Transmission doesn't know how to use \"%s\"" ), url );
+    g_string_append_printf (gstr, _("Transmission doesn't know how to use \"%s\""), url);
 
-    if( gtr_is_magnet_link( url ) && ( strstr( url, xt ) == NULL ) )
+    if (gtr_is_magnet_link (url) && (strstr (url, xt) == NULL))
     {
-        g_string_append_printf( gstr, "\n \n" );
-        g_string_append_printf( gstr, _( "This magnet link appears to be intended for something other than BitTorrent. BitTorrent magnet links have a section containing \"%s\"." ), xt );
+        g_string_append_printf (gstr, "\n \n");
+        g_string_append_printf (gstr, _("This magnet link appears to be intended for something other than BitTorrent. BitTorrent magnet links have a section containing \"%s\"."), xt);
     }
 
-    gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( w ), "%s", gstr->str );
-    g_signal_connect_swapped( w, "response", G_CALLBACK( gtk_widget_destroy ), w );
-    gtk_widget_show( w );
-    g_string_free( gstr, TRUE );
+    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (w), "%s", gstr->str);
+    g_signal_connect_swapped (w, "response", G_CALLBACK (gtk_widget_destroy), w);
+    gtk_widget_show (w);
+    g_string_free (gstr, TRUE);
 }
 
 /***
@@ -581,26 +581,26 @@ gtr_unrecognized_url_dialog( GtkWidget * parent, const char * url )
 ***/
 
 void
-gtr_paste_clipboard_url_into_entry( GtkWidget * e )
+gtr_paste_clipboard_url_into_entry (GtkWidget * e)
 {
   size_t i;
 
   char * text[] = {
-    g_strstrip( gtk_clipboard_wait_for_text( gtk_clipboard_get( GDK_SELECTION_PRIMARY ) ) ),
-    g_strstrip( gtk_clipboard_wait_for_text( gtk_clipboard_get( GDK_SELECTION_CLIPBOARD ) ) )
+    g_strstrip (gtk_clipboard_wait_for_text (gtk_clipboard_get (GDK_SELECTION_PRIMARY))),
+    g_strstrip (gtk_clipboard_wait_for_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD)))
   };
 
-  for( i=0; i<G_N_ELEMENTS(text); ++i ) {
+  for (i=0; i<G_N_ELEMENTS (text); ++i) {
       char * s = text[i];
-      if( s && ( gtr_is_supported_url( s ) || gtr_is_magnet_link( s )
-                                           || gtr_is_hex_hashcode( s ) ) ) {
-          gtk_entry_set_text( GTK_ENTRY( e ), s );
+      if (s && (gtr_is_supported_url (s) || gtr_is_magnet_link (s)
+                                           || gtr_is_hex_hashcode (s))) {
+          gtk_entry_set_text (GTK_ENTRY (e), s);
           break;
       }
   }
 
-  for( i=0; i<G_N_ELEMENTS(text); ++i )
-    g_free( text[i] );
+  for (i=0; i<G_N_ELEMENTS (text); ++i)
+    g_free (text[i]);
 }
 
 /***
@@ -608,10 +608,10 @@ gtr_paste_clipboard_url_into_entry( GtkWidget * e )
 ***/
 
 void
-gtr_label_set_text( GtkLabel * lb, const char * newstr )
+gtr_label_set_text (GtkLabel * lb, const char * newstr)
 {
-    const char * oldstr = gtk_label_get_text( lb );
+    const char * oldstr = gtk_label_get_text (lb);
 
-    if( tr_strcmp0( oldstr, newstr ) )
-        gtk_label_set_text( lb, newstr );
+    if (tr_strcmp0 (oldstr, newstr))
+        gtk_label_set_text (lb, newstr);
 }
diff --git a/gtk/util.h b/gtk/util.h
index aebc6a2b2..755c71bd3 100644
--- a/gtk/util.h
+++ b/gtk/util.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -49,94 +49,94 @@ enum
     GTR_UNICODE_INF,
     GTR_UNICODE_BULLET
 };
-const char * gtr_get_unicode_string( int );
+const char * gtr_get_unicode_string (int);
 
 /* return a percent formatted string of either x.xx, xx.x or xxx */
-char* tr_strlpercent( char * buf, double x, size_t buflen );
+char* tr_strlpercent (char * buf, double x, size_t buflen);
 
 /* return a human-readable string for the size given in bytes. */
-char* tr_strlsize( char * buf, guint64  size, size_t buflen );
+char* tr_strlsize (char * buf, guint64  size, size_t buflen);
 
 /* return a human-readable string for the given ratio. */
-char* tr_strlratio( char * buf, double ratio, size_t buflen );
+char* tr_strlratio (char * buf, double ratio, size_t buflen);
 
 /* return a human-readable string for the time given in seconds. */
-char* tr_strltime( char * buf, int secs, size_t buflen );
+char* tr_strltime (char * buf, int secs, size_t buflen);
 
 /***
 ****
 ***/
 
 /* http://www.legaltorrents.com/some/announce/url --> legaltorrents.com */
-void gtr_get_host_from_url( char * buf, size_t buflen, const char * url );
+void gtr_get_host_from_url (char * buf, size_t buflen, const char * url);
 
-gboolean gtr_is_magnet_link( const char * str );
+gboolean gtr_is_magnet_link (const char * str);
 
-gboolean gtr_is_hex_hashcode( const char * str );
+gboolean gtr_is_hex_hashcode (const char * str);
 
 /***
 ****
 ***/
 
-void        gtr_open_uri( const char * uri );
+void        gtr_open_uri (const char * uri);
 
-void        gtr_open_file( const char * path );
+void        gtr_open_file (const char * path);
 
-const char* gtr_get_help_uri( void );
+const char* gtr_get_help_uri (void);
 
 /***
 ****
 ***/
 
-/* backwards-compatible wrapper around gtk_widget_set_visible() */
-void gtr_widget_set_visible( GtkWidget *, gboolean );
+/* backwards-compatible wrapper around gtk_widget_set_visible () */
+void gtr_widget_set_visible (GtkWidget *, gboolean);
 
-void gtr_dialog_set_content( GtkDialog * dialog, GtkWidget * content );
+void gtr_dialog_set_content (GtkDialog * dialog, GtkWidget * content);
 
 /***
 ****
 ***/
 
-GtkWidget * gtr_priority_combo_new( void );
-#define gtr_priority_combo_get_value(w)     gtr_combo_box_get_active_enum(w)
-#define gtr_priority_combo_set_value(w,val) gtr_combo_box_set_active_enum(w,val)
+GtkWidget * gtr_priority_combo_new (void);
+#define gtr_priority_combo_get_value(w)     gtr_combo_box_get_active_enum (w)
+#define gtr_priority_combo_set_value(w,val) gtr_combo_box_set_active_enum (w,val)
 
-GtkWidget * gtr_combo_box_new_enum        ( const char * text_1, ... );
-int         gtr_combo_box_get_active_enum ( GtkComboBox * );
-void        gtr_combo_box_set_active_enum ( GtkComboBox *, int value );
+GtkWidget * gtr_combo_box_new_enum      (const char * text_1, ...);
+int         gtr_combo_box_get_active_enum (GtkComboBox *);
+void        gtr_combo_box_set_active_enum (GtkComboBox *, int value);
 
 /***
 ****
 ***/
 
-void gtr_unrecognized_url_dialog( GtkWidget * parent, const char * url );
+void gtr_unrecognized_url_dialog (GtkWidget * parent, const char * url);
 
-void gtr_http_failure_dialog( GtkWidget * parent, const char * url, long response_code );
+void gtr_http_failure_dialog (GtkWidget * parent, const char * url, long response_code);
 
-void gtr_add_torrent_error_dialog( GtkWidget  * window_or_child,
+void gtr_add_torrent_error_dialog (GtkWidget  * window_or_child,
                                    int          err,
-                                   const char * filename );
+                                   const char * filename);
 
 /* pop up the context menu if a user right-clicks.
    if the row they right-click on isn't selected, select it. */
-gboolean on_tree_view_button_pressed( GtkWidget      * view,
+gboolean on_tree_view_button_pressed (GtkWidget      * view,
                                       GdkEventButton * event,
-                                      gpointer         unused );
+                                      gpointer         unused);
 
 /* if the click didn't specify a row, clear the selection */
-gboolean on_tree_view_button_released( GtkWidget      * view,
+gboolean on_tree_view_button_released (GtkWidget      * view,
                                        GdkEventButton * event,
-                                       gpointer         unused );
+                                       gpointer         unused);
 
 
 /* move a file to the trashcan if GIO is available; otherwise, delete it */
-int gtr_file_trash_or_remove( const char * filename );
+int gtr_file_trash_or_remove (const char * filename);
 
-void gtr_paste_clipboard_url_into_entry( GtkWidget * entry );
+void gtr_paste_clipboard_url_into_entry (GtkWidget * entry);
 
-/* Only call gtk_label_set_text() if the new text differs from the old.
+/* Only call gtk_label_set_text () if the new text differs from the old.
  * This prevents the label from having to recalculate its size
  * and prevents selected text in the label from being deselected */
-void gtr_label_set_text( GtkLabel * lb, const char * text );
+void gtr_label_set_text (GtkLabel * lb, const char * text);
 
 #endif /* GTR_UTIL_H */
diff --git a/libtransmission/ConvertUTF.c b/libtransmission/ConvertUTF.c
index 235376349..84215ff32 100644
--- a/libtransmission/ConvertUTF.c
+++ b/libtransmission/ConvertUTF.c
@@ -42,7 +42,7 @@
 #ifdef CVTUTF_DEBUG
  #include <stdio.h>
 #endif
-#include <string.h> /* strlen() */
+#include <string.h> /* strlen () */
 #include "ConvertUTF.h"
 
 static const int halfShift  = 10; /* used for shifting by 10 bits */
@@ -50,10 +50,10 @@ static const int halfShift  = 10; /* used for shifting by 10 bits */
 static const UTF32 halfBase = 0x0010000UL;
 static const UTF32 halfMask = 0x3FFUL;
 
-#define UNI_SUR_HIGH_START  (UTF32)0xD800
-#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
-#define UNI_SUR_LOW_START   (UTF32)0xDC00
-#define UNI_SUR_LOW_END     (UTF32)0xDFFF
+#define UNI_SUR_HIGH_START (UTF32)0xD800
+#define UNI_SUR_HIGH_END  (UTF32)0xDBFF
+#define UNI_SUR_LOW_START (UTF32)0xDC00
+#define UNI_SUR_LOW_END   (UTF32)0xDFFF
 #define false	   0
 #define true	    1
 
@@ -156,8 +156,8 @@ ConversionResult ConvertUTF16toUTF32 (
     *targetStart = target;
 #ifdef CVTUTF_DEBUG
 if (result == sourceIllegal) {
-    fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
-    fflush(stderr);
+    fprintf (stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
+    fflush (stderr);
 }
 #endif
     return result;
@@ -271,7 +271,7 @@ ConversionResult ConvertUTF16toUTF8 (
 	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
 	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
 	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-	    case 1: *--target =  (UTF8)(ch | firstByteMark[bytesToWrite]);
+	    case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]);
 	}
 	target += bytesToWrite;
     }
@@ -293,7 +293,7 @@ ConversionResult ConvertUTF16toUTF8 (
  * definition of UTF-8 goes up to 4-byte sequences.
  */
 
-static Boolean isLegalUTF8(const UTF8 *source, int length) {
+static Boolean isLegalUTF8 (const UTF8 *source, int length) {
     UTF8 a;
     const UTF8 *srcptr = source+length;
     switch (length) {
@@ -325,7 +325,7 @@ static Boolean isLegalUTF8(const UTF8 *source, int length) {
  * This is not used here; it's just exported.
  */
 
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
+Boolean isLegalUTF8Sequence (const UTF8 *source, const UTF8 *sourceEnd) {
     int length;
     if (source == sourceEnd) {
         return true;
@@ -335,7 +335,7 @@ Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
         if (source+length > sourceEnd) {
             return false;
         }
-        if (!isLegalUTF8(source, length)) {
+        if (!isLegalUTF8 (source, length)) {
             return false;
         }
         source += length;
@@ -346,46 +346,46 @@ Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
 }
 
 /**
- * This is a variation of isLegalUTF8Sequence() that behaves like g_utf8_validate().
+ * This is a variation of isLegalUTF8Sequence () that behaves like g_utf8_validate ().
  * In addition to knowing if the sequence is legal, it also tells you the last good character.
  */
 Boolean
-tr_utf8_validate( const char * str, int max_len, const char ** end )
+tr_utf8_validate (const char * str, int max_len, const char ** end)
 {
     const UTF8* source = (const UTF8*) str;
     const UTF8* sourceEnd;
 
-    if( max_len == 0 )
+    if (max_len == 0)
         return true;
 
-    if( str == NULL )
+    if (str == NULL)
         return false;
 
-    sourceEnd = source + ((max_len < 0) ? strlen(str) : (size_t)max_len);
+    sourceEnd = source + ((max_len < 0) ? strlen (str) : (size_t)max_len);
 
-    if( source == sourceEnd )
+    if (source == sourceEnd)
     {
-        if( end != NULL )
+        if (end != NULL)
             *end = (const char*) source;
         return true;
     }
 
-    for( ;; )
+    for (;;)
     {
         const int length = trailingBytesForUTF8[*source] + 1;
         if (source + length > sourceEnd) {
-            if( end != NULL )
+            if (end != NULL)
                 *end = (const char*) source;
             return false;
         }
-        if (!isLegalUTF8(source, length)) {
-            if( end != NULL )
+        if (!isLegalUTF8 (source, length)) {
+            if (end != NULL)
                 *end = (const char*) source;
             return false;
         }
         source += length;
         if (source >= sourceEnd) {
-            if( end != NULL )
+            if (end != NULL)
                 *end = (const char*) source;
             return true;
         }
@@ -410,7 +410,7 @@ ConversionResult ConvertUTF8toUTF16 (
 	    result = sourceExhausted; break;
 	}
 	/* Do this check whether lenient or strict */
-	if (! isLegalUTF8(source, extraBytesToRead+1)) {
+	if (! isLegalUTF8 (source, extraBytesToRead+1)) {
 	    result = sourceIllegal;
 	    break;
 	}
@@ -482,7 +482,7 @@ ConversionResult ConvertUTF32toUTF8 (
 	const UTF32 byteMask = 0xBF;
 	const UTF32 byteMark = 0x80; 
 	ch = *source++;
-	if (flags == strictConversion ) {
+	if (flags == strictConversion) {
 	    /* UTF-16 surrogate values are illegal in UTF-32 */
 	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
 		--source; /* return to the illegal value itself */
@@ -512,7 +512,7 @@ ConversionResult ConvertUTF32toUTF8 (
 	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
 	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
 	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
-	    case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
+	    case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]);
 	}
 	target += bytesToWrite;
     }
@@ -536,7 +536,7 @@ ConversionResult ConvertUTF8toUTF32 (
 	    result = sourceExhausted; break;
 	}
 	/* Do this check whether lenient or strict */
-	if (! isLegalUTF8(source, extraBytesToRead+1)) {
+	if (! isLegalUTF8 (source, extraBytesToRead+1)) {
 	    result = sourceIllegal;
 	    break;
 	}
diff --git a/libtransmission/ConvertUTF.h b/libtransmission/ConvertUTF.h
index 59cc9dbb6..8a57fa979 100644
--- a/libtransmission/ConvertUTF.h
+++ b/libtransmission/ConvertUTF.h
@@ -41,11 +41,11 @@
     Each routine converts the text between *sourceStart and sourceEnd,
     putting the result into the buffer between *targetStart and
     targetEnd. Note: the end pointers are *after* the last item: e.g. 
-    *(sourceEnd - 1) is the last item.
+    * (sourceEnd - 1) is the last item.
 
     The return result indicates whether the conversion was successful,
     and if not, whether the problem was in the source or target buffers.
-    (Only the first encountered problem is indicated.)
+  (Only the first encountered problem is indicated.)
 
     After the conversion, *sourceStart and *targetStart are both
     updated to point to the end of last text successfully converted in
@@ -147,11 +147,11 @@ ConversionResult ConvertUTF32toUTF16 (
 		const UTF32** sourceStart, const UTF32* sourceEnd, 
 		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
 
-Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
+Boolean isLegalUTF8Sequence (const UTF8 *source, const UTF8 *sourceEnd);
 
 
 /* intended to work the same as g_utf8_validate */
-Boolean tr_utf8_validate( const char * str, int max_len, const char ** end );
+Boolean tr_utf8_validate (const char * str, int max_len, const char ** end);
 
 
 #ifdef __cplusplus
diff --git a/libtransmission/announcer-common.h b/libtransmission/announcer-common.h
index 634d8a1dc..7352c948d 100644
--- a/libtransmission/announcer-common.h
+++ b/libtransmission/announcer-common.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -96,18 +96,18 @@ typedef struct
 }
 tr_scrape_response;
 
-typedef void tr_scrape_response_func( const tr_scrape_response  * response,
-                                      void                      * user_data );
+typedef void tr_scrape_response_func (const tr_scrape_response  * response,
+                                      void                      * user_data);
 
-void tr_tracker_http_scrape( tr_session               * session,
+void tr_tracker_http_scrape (tr_session               * session,
                              const tr_scrape_request  * req,
                              tr_scrape_response_func    response_func,
-                             void                     * user_data );
+                             void                     * user_data);
 
-void tr_tracker_udp_scrape( tr_session               * session,
+void tr_tracker_udp_scrape (tr_session               * session,
                             const tr_scrape_request  * req,
                             tr_scrape_response_func    response_func,
-                            void                     * user_data );
+                            void                     * user_data);
 
 /***
 ****  ANNOUNCE
@@ -122,7 +122,7 @@ typedef enum
 }
 tr_announce_event;
 
-const char * tr_announce_event_get_string( tr_announce_event );
+const char * tr_announce_event_get_string (tr_announce_event);
 
 typedef struct
 {
@@ -223,19 +223,19 @@ typedef struct
 }
 tr_announce_response;
 
-typedef void tr_announce_response_func( const tr_announce_response * response,
-                                        void                       * userdata );
+typedef void tr_announce_response_func (const tr_announce_response * response,
+                                        void                       * userdata);
 
-void tr_tracker_http_announce( tr_session                 * session,
+void tr_tracker_http_announce (tr_session                 * session,
                                const tr_announce_request  * req,
                                tr_announce_response_func    response_func,
-                               void                       * user_data );
+                               void                       * user_data);
 
-void tr_tracker_udp_announce( tr_session                 * session,
+void tr_tracker_udp_announce (tr_session                 * session,
                               const tr_announce_request  * req,
                               tr_announce_response_func    response_func,
-                              void                       * user_data );
+                              void                       * user_data);
 
-void tr_tracker_udp_start_shutdown( tr_session * session );
+void tr_tracker_udp_start_shutdown (tr_session * session);
 
 #endif /* _TR_ANNOUNCER_COMMON_H_ */
diff --git a/libtransmission/announcer-http.c b/libtransmission/announcer-http.c
index 6089d654e..baf4a4147 100644
--- a/libtransmission/announcer-http.c
+++ b/libtransmission/announcer-http.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,9 +11,9 @@
  */
 
 #include <limits.h> /* USHRT_MAX */
-#include <stdio.h> /* fprintf() */
-#include <stdlib.h> /* getenv() */
-#include <string.h> /* strchr(), memcmp(), memcpy() */
+#include <stdio.h> /* fprintf () */
+#include <stdlib.h> /* getenv () */
+#include <string.h> /* strchr (), memcmp (), memcpy () */
 
 #include <event2/buffer.h>
 #include <event2/http.h> /* for HTTP_OK */
@@ -22,17 +22,17 @@
 
 #include "transmission.h"
 #include "announcer-common.h"
-#include "net.h" /* tr_globalIPv6() */
+#include "net.h" /* tr_globalIPv6 () */
 #include "peer-mgr.h" /* pex */
 #include "torrent.h"
-#include "trevent.h" /* tr_runInEventThread() */
+#include "trevent.h" /* tr_runInEventThread () */
 #include "utils.h"
-#include "web.h" /* tr_http_escape() */
+#include "web.h" /* tr_http_escape () */
 
-#define dbgmsg( name, ... ) \
-if( tr_deepLoggingIsActive( ) ) do { \
-  tr_deepLog( __FILE__, __LINE__, name, __VA_ARGS__ ); \
-} while( 0 )
+#define dbgmsg(name, ...) \
+if (tr_deepLoggingIsActive ()) do { \
+  tr_deepLog (__FILE__, __LINE__, name, __VA_ARGS__); \
+} while (0)
 
 /****
 *****
@@ -41,28 +41,28 @@ if( tr_deepLoggingIsActive( ) ) do { \
 ****/
 
 static const char*
-get_event_string( const tr_announce_request * req )
+get_event_string (const tr_announce_request * req)
 {
-    if( req->partial_seed )
-        if( req->event != TR_ANNOUNCE_EVENT_STOPPED )
+    if (req->partial_seed)
+        if (req->event != TR_ANNOUNCE_EVENT_STOPPED)
             return "paused";
 
-    return tr_announce_event_get_string( req->event );
+    return tr_announce_event_get_string (req->event);
 }
 
 static char*
-announce_url_new( const tr_session * session, const tr_announce_request * req )
+announce_url_new (const tr_session * session, const tr_announce_request * req)
 {
     const char * str;
     const unsigned char * ipv6;
-    struct evbuffer * buf = evbuffer_new( );
+    struct evbuffer * buf = evbuffer_new ();
     char escaped_info_hash[SHA_DIGEST_LENGTH*3 + 1];
 
-    tr_http_escape_sha1( escaped_info_hash, req->info_hash );
+    tr_http_escape_sha1 (escaped_info_hash, req->info_hash);
 
-    evbuffer_expand( buf, 1024 );
+    evbuffer_expand (buf, 1024);
 
-    evbuffer_add_printf( buf, "%s"
+    evbuffer_add_printf (buf, "%s"
                               "%c"
                               "info_hash=%s"
                               "&peer_id=%*.*s"
@@ -75,7 +75,7 @@ announce_url_new( const tr_session * session, const tr_announce_request * req )
                               "&compact=1"
                               "&supportcrypto=1",
                               req->url,
-                              strchr( req->url, '?' ) ? '&' : '?',
+                              strchr (req->url, '?') ? '&' : '?',
                               escaped_info_hash,
                               PEER_ID_LEN, PEER_ID_LEN, req->peer_id,
                               req->port,
@@ -83,21 +83,21 @@ announce_url_new( const tr_session * session, const tr_announce_request * req )
                               req->down,
                               req->leftUntilComplete,
                               req->numwant,
-                              req->key );
+                              req->key);
 
-    if( session->encryptionMode == TR_ENCRYPTION_REQUIRED )
-        evbuffer_add_printf( buf, "&requirecrypto=1" );
+    if (session->encryptionMode == TR_ENCRYPTION_REQUIRED)
+        evbuffer_add_printf (buf, "&requirecrypto=1");
 
-    if( req->corrupt )
-        evbuffer_add_printf( buf, "&corrupt=%" PRIu64, req->corrupt );
+    if (req->corrupt)
+        evbuffer_add_printf (buf, "&corrupt=%" PRIu64, req->corrupt);
 
-    str = get_event_string( req );
-    if( str && *str )
-        evbuffer_add_printf( buf, "&event=%s", str );
+    str = get_event_string (req);
+    if (str && *str)
+        evbuffer_add_printf (buf, "&event=%s", str);
 
     str = req->tracker_id_str;
-    if( str && *str )
-        evbuffer_add_printf( buf, "&trackerid=%s", str );
+    if (str && *str)
+        evbuffer_add_printf (buf, "&trackerid=%s", str);
 
     /* There are two incompatible techniques for announcing an IPv6 address.
        BEP-7 suggests adding an "ipv6=" parameter to the announce URL,
@@ -108,47 +108,47 @@ announce_url_new( const tr_session * session, const tr_announce_request * req )
        announce twice. At any rate, we're already computing our IPv6
        address (for the LTEP handshake), so this comes for free. */
 
-    ipv6 = tr_globalIPv6( );
-    if( ipv6 ) {
+    ipv6 = tr_globalIPv6 ();
+    if (ipv6) {
         char ipv6_readable[INET6_ADDRSTRLEN];
-        evutil_inet_ntop( AF_INET6, ipv6, ipv6_readable, INET6_ADDRSTRLEN );
-        evbuffer_add_printf( buf, "&ipv6=");
-        tr_http_escape( buf, ipv6_readable, -1, true );
+        evutil_inet_ntop (AF_INET6, ipv6, ipv6_readable, INET6_ADDRSTRLEN);
+        evbuffer_add_printf (buf, "&ipv6=");
+        tr_http_escape (buf, ipv6_readable, -1, true);
     }
 
-    return evbuffer_free_to_str( buf );
+    return evbuffer_free_to_str (buf);
 }
 
 static tr_pex*
-listToPex( tr_benc * peerList, size_t * setme_len )
+listToPex (tr_benc * peerList, size_t * setme_len)
 {
     size_t i;
     size_t n;
-    const size_t len = tr_bencListSize( peerList );
-    tr_pex * pex = tr_new0( tr_pex, len );
+    const size_t len = tr_bencListSize (peerList);
+    tr_pex * pex = tr_new0 (tr_pex, len);
 
-    for( i=n=0; i<len; ++i )
+    for (i=n=0; i<len; ++i)
     {
         int64_t port;
         const char * ip;
         tr_address addr;
-        tr_benc * peer = tr_bencListChild( peerList, i );
+        tr_benc * peer = tr_bencListChild (peerList, i);
 
-        if( peer == NULL )
+        if (peer == NULL)
             continue;
-        if( !tr_bencDictFindStr( peer, "ip", &ip ) )
+        if (!tr_bencDictFindStr (peer, "ip", &ip))
             continue;
-        if( !tr_address_from_string( &addr, ip ) )
+        if (!tr_address_from_string (&addr, ip))
             continue;
-        if( !tr_bencDictFindInt( peer, "port", &port ) )
+        if (!tr_bencDictFindInt (peer, "port", &port))
             continue;
-        if( ( port < 0 ) || ( port > USHRT_MAX ) )
+        if ((port < 0) || (port > USHRT_MAX))
             continue;
-        if( !tr_address_is_valid_for_peers( &addr, port ) )
+        if (!tr_address_is_valid_for_peers (&addr, port))
             continue;
 
         pex[n].addr = addr;
-        pex[n].port = htons( (uint16_t)port );
+        pex[n].port = htons ((uint16_t)port);
         ++n;
     }
 
@@ -165,30 +165,30 @@ struct announce_data
 };
 
 static void
-on_announce_done_eventthread( void * vdata )
+on_announce_done_eventthread (void * vdata)
 {
     struct announce_data * data = vdata;
 
-    if( data->response_func != NULL )
-        data->response_func( &data->response, data->response_func_user_data );
+    if (data->response_func != NULL)
+        data->response_func (&data->response, data->response_func_user_data);
 
-    tr_free( data->response.pex6 );
-    tr_free( data->response.pex );
-    tr_free( data->response.tracker_id_str );
-    tr_free( data->response.warning );
-    tr_free( data->response.errmsg );
-    tr_free( data );
+    tr_free (data->response.pex6);
+    tr_free (data->response.pex);
+    tr_free (data->response.tracker_id_str);
+    tr_free (data->response.warning);
+    tr_free (data->response.errmsg);
+    tr_free (data);
 }
 
 
 static void
-on_announce_done( tr_session   * session,
+on_announce_done (tr_session   * session,
                   bool           did_connect,
                   bool           did_timeout,
                   long           response_code,
                   const void   * msg,
                   size_t         msglen,
-                  void         * vdata )
+                  void         * vdata)
 {
     tr_announce_response * response;
     struct announce_data * data = vdata;
@@ -196,35 +196,35 @@ on_announce_done( tr_session   * session,
     response = &data->response;
     response->did_connect = did_connect;
     response->did_timeout = did_timeout;
-    dbgmsg( data->log_name, "Got announce response" );
+    dbgmsg (data->log_name, "Got announce response");
 
-    if( response_code != HTTP_OK )
+    if (response_code != HTTP_OK)
     {
-        const char * fmt = _( "Tracker gave HTTP response code %1$ld (%2$s)" );
-        const char * response_str = tr_webGetResponseStr( response_code );
-        response->errmsg = tr_strdup_printf( fmt, response_code, response_str );
+        const char * fmt = _ ("Tracker gave HTTP response code %1$ld (%2$s)");
+        const char * response_str = tr_webGetResponseStr (response_code);
+        response->errmsg = tr_strdup_printf (fmt, response_code, response_str);
     }
     else
     {
         tr_benc benc;
-        const int benc_loaded = !tr_bencLoad( msg, msglen, &benc, NULL );
+        const int benc_loaded = !tr_bencLoad (msg, msglen, &benc, NULL);
 
-        if( getenv( "TR_CURL_VERBOSE" ) != NULL )
+        if (getenv ("TR_CURL_VERBOSE") != NULL)
         {
-            if( !benc_loaded )
-                fprintf( stderr, "%s", "Announce response was not in benc format\n" );
+            if (!benc_loaded)
+                fprintf (stderr, "%s", "Announce response was not in benc format\n");
             else {
                 int i, len;
-                char * str = tr_bencToStr( &benc, TR_FMT_JSON, &len );
-                fprintf( stderr, "%s", "Announce response:\n< " );
-                for( i=0; i<len; ++i )
-                    fputc( str[i], stderr );
-                fputc( '\n', stderr );
-                tr_free( str );
+                char * str = tr_bencToStr (&benc, TR_FMT_JSON, &len);
+                fprintf (stderr, "%s", "Announce response:\n< ");
+                for (i=0; i<len; ++i)
+                    fputc (str[i], stderr);
+                fputc ('\n', stderr);
+                tr_free (str);
             }
         }
 
-        if( benc_loaded && tr_bencIsDict( &benc ) )
+        if (benc_loaded && tr_bencIsDict (&benc))
         {
             int64_t i;
             size_t rawlen;
@@ -232,76 +232,76 @@ on_announce_done( tr_session   * session,
             const char * str;
             const uint8_t * raw;
 
-            if( tr_bencDictFindStr( &benc, "failure reason", &str ) )
-                response->errmsg = tr_strdup( str );
+            if (tr_bencDictFindStr (&benc, "failure reason", &str))
+                response->errmsg = tr_strdup (str);
 
-            if( tr_bencDictFindStr( &benc, "warning message", &str ) )
-                response->warning = tr_strdup( str );
+            if (tr_bencDictFindStr (&benc, "warning message", &str))
+                response->warning = tr_strdup (str);
 
-            if( tr_bencDictFindInt( &benc, "interval", &i ) )
+            if (tr_bencDictFindInt (&benc, "interval", &i))
                 response->interval = i;
 
-            if( tr_bencDictFindInt( &benc, "min interval", &i ) )
+            if (tr_bencDictFindInt (&benc, "min interval", &i))
                 response->min_interval = i;
 
-            if( tr_bencDictFindStr( &benc, "tracker id", &str ) )
-                response->tracker_id_str = tr_strdup( str );
+            if (tr_bencDictFindStr (&benc, "tracker id", &str))
+                response->tracker_id_str = tr_strdup (str);
 
-            if( tr_bencDictFindInt( &benc, "complete", &i ) )
+            if (tr_bencDictFindInt (&benc, "complete", &i))
                 response->seeders = i;
 
-            if( tr_bencDictFindInt( &benc, "incomplete", &i ) )
+            if (tr_bencDictFindInt (&benc, "incomplete", &i))
                 response->leechers = i;
 
-            if( tr_bencDictFindInt( &benc, "downloaded", &i ) )
+            if (tr_bencDictFindInt (&benc, "downloaded", &i))
                 response->downloads = i;
 
-            if( tr_bencDictFindRaw( &benc, "peers6", &raw, &rawlen ) ) {
-                dbgmsg( data->log_name, "got a peers6 length of %zu", rawlen );
-                response->pex6 = tr_peerMgrCompact6ToPex( raw, rawlen,
-                                              NULL, 0, &response->pex6_count );
+            if (tr_bencDictFindRaw (&benc, "peers6", &raw, &rawlen)) {
+                dbgmsg (data->log_name, "got a peers6 length of %zu", rawlen);
+                response->pex6 = tr_peerMgrCompact6ToPex (raw, rawlen,
+                                              NULL, 0, &response->pex6_count);
             }
 
-            if( tr_bencDictFindRaw( &benc, "peers", &raw, &rawlen ) ) {
-                dbgmsg( data->log_name, "got a compact peers length of %zu", rawlen );
-                response->pex = tr_peerMgrCompactToPex( raw, rawlen,
-                                               NULL, 0, &response->pex_count );
-            } else if( tr_bencDictFindList( &benc, "peers", &tmp ) ) {
-                response->pex = listToPex( tmp, &response->pex_count );
-                dbgmsg( data->log_name, "got a peers list with %zu entries",
-                        response->pex_count );
+            if (tr_bencDictFindRaw (&benc, "peers", &raw, &rawlen)) {
+                dbgmsg (data->log_name, "got a compact peers length of %zu", rawlen);
+                response->pex = tr_peerMgrCompactToPex (raw, rawlen,
+                                               NULL, 0, &response->pex_count);
+            } else if (tr_bencDictFindList (&benc, "peers", &tmp)) {
+                response->pex = listToPex (tmp, &response->pex_count);
+                dbgmsg (data->log_name, "got a peers list with %zu entries",
+                        response->pex_count);
             }
         }
 
-        if( benc_loaded )
-            tr_bencFree( &benc );
+        if (benc_loaded)
+            tr_bencFree (&benc);
     }
 
-    tr_runInEventThread( session, on_announce_done_eventthread, data );
+    tr_runInEventThread (session, on_announce_done_eventthread, data);
 }
 
 void
-tr_tracker_http_announce( tr_session                 * session,
+tr_tracker_http_announce (tr_session                 * session,
                           const tr_announce_request  * request,
                           tr_announce_response_func    response_func,
-                          void                       * response_func_user_data )
+                          void                       * response_func_user_data)
 {
     struct announce_data * d;
-    char * url = announce_url_new( session, request );
+    char * url = announce_url_new (session, request);
 
-    d = tr_new0( struct announce_data, 1 );
+    d = tr_new0 (struct announce_data, 1);
     d->response.seeders = -1;
     d->response.leechers = -1;
     d->response.downloads = -1;
     d->response_func = response_func;
     d->response_func_user_data = response_func_user_data;
-    memcpy( d->response.info_hash, request->info_hash, SHA_DIGEST_LENGTH );
-    tr_strlcpy( d->log_name, request->log_name, sizeof( d->log_name ) );
+    memcpy (d->response.info_hash, request->info_hash, SHA_DIGEST_LENGTH);
+    tr_strlcpy (d->log_name, request->log_name, sizeof (d->log_name));
 
-    dbgmsg( request->log_name, "Sending announce to libcurl: \"%s\"", url );
-    tr_webRun( session, url, NULL, NULL, on_announce_done, d );
+    dbgmsg (request->log_name, "Sending announce to libcurl: \"%s\"", url);
+    tr_webRun (session, url, NULL, NULL, on_announce_done, d);
 
-    tr_free( url );
+    tr_free (url);
 }
 
 /****
@@ -319,26 +319,26 @@ struct scrape_data
 };
 
 static void
-on_scrape_done_eventthread( void * vdata )
+on_scrape_done_eventthread (void * vdata)
 {
     struct scrape_data * data = vdata;
 
-    if( data->response_func != NULL )
-        data->response_func( &data->response, data->response_func_user_data );
+    if (data->response_func != NULL)
+        data->response_func (&data->response, data->response_func_user_data);
 
-    tr_free( data->response.errmsg );
-    tr_free( data->response.url );
-    tr_free( data );
+    tr_free (data->response.errmsg);
+    tr_free (data->response.url);
+    tr_free (data);
 }
 
 static void
-on_scrape_done( tr_session   * session,
+on_scrape_done (tr_session   * session,
                 bool           did_connect,
                 bool           did_timeout,
                 long           response_code,
                 const void   * msg,
                 size_t         msglen,
-                void         * vdata )
+                void         * vdata)
 {
     tr_scrape_response * response;
     struct scrape_data * data = vdata;
@@ -346,13 +346,13 @@ on_scrape_done( tr_session   * session,
     response = &data->response;
     response->did_connect = did_connect;
     response->did_timeout = did_timeout;
-    dbgmsg( data->log_name, "Got scrape response for \"%s\"", response->url );
+    dbgmsg (data->log_name, "Got scrape response for \"%s\"", response->url);
 
-    if( response_code != HTTP_OK )
+    if (response_code != HTTP_OK)
     {
-        const char * fmt = _( "Tracker gave HTTP response code %1$ld (%2$s)" );
-        const char * response_str = tr_webGetResponseStr( response_code );
-        response->errmsg = tr_strdup_printf( fmt, response_code, response_str );
+        const char * fmt = _ ("Tracker gave HTTP response code %1$ld (%2$s)");
+        const char * response_str = tr_webGetResponseStr (response_code);
+        response->errmsg = tr_strdup_printf (fmt, response_code, response_str);
     }
     else
     {
@@ -361,59 +361,59 @@ on_scrape_done( tr_session   * session,
         tr_benc * files;
         tr_benc * flags;
         const char * str;
-        const int benc_loaded = !tr_bencLoad( msg, msglen, &top, NULL );
+        const int benc_loaded = !tr_bencLoad (msg, msglen, &top, NULL);
 
-        if( getenv( "TR_CURL_VERBOSE" ) != NULL )
+        if (getenv ("TR_CURL_VERBOSE") != NULL)
         {
-            if( !benc_loaded )
-                fprintf( stderr, "%s", "Scrape response was not in benc format\n" );
+            if (!benc_loaded)
+                fprintf (stderr, "%s", "Scrape response was not in benc format\n");
             else {
                 int i, len;
-                char * str = tr_bencToStr( &top, TR_FMT_JSON, &len );
-                fprintf( stderr, "%s", "Scrape response:\n< " );
-                for( i=0; i<len; ++i )
-                    fputc( str[i], stderr );
-                fputc( '\n', stderr );
-                tr_free( str );
+                char * str = tr_bencToStr (&top, TR_FMT_JSON, &len);
+                fprintf (stderr, "%s", "Scrape response:\n< ");
+                for (i=0; i<len; ++i)
+                    fputc (str[i], stderr);
+                fputc ('\n', stderr);
+                tr_free (str);
             }
         }
 
-        if( benc_loaded )
+        if (benc_loaded)
         {
-            if( tr_bencDictFindStr( &top, "failure reason", &str ) )
-                response->errmsg = tr_strdup( str );
+            if (tr_bencDictFindStr (&top, "failure reason", &str))
+                response->errmsg = tr_strdup (str);
 
-            if( tr_bencDictFindDict( &top, "flags", &flags ) )
-                if( tr_bencDictFindInt( flags, "min_request_interval", &intVal ) )
+            if (tr_bencDictFindDict (&top, "flags", &flags))
+                if (tr_bencDictFindInt (flags, "min_request_interval", &intVal))
                     response->min_request_interval = intVal;
 
-            if( tr_bencDictFindDict( &top, "files", &files ) )
+            if (tr_bencDictFindDict (&top, "files", &files))
             {
                 int i = 0;
 
-                for( ;; )
+                for (;;)
                 {
                     int j;
                     tr_benc * val;
                     const char * key;
 
                     /* get the next "file" */
-                    if( !tr_bencDictChild( files, i++, &key, &val ) )
+                    if (!tr_bencDictChild (files, i++, &key, &val))
                         break;
 
                     /* populate the corresponding row in our response array */
-                    for( j=0; j<response->row_count; ++j )
+                    for (j=0; j<response->row_count; ++j)
                     {
                         struct tr_scrape_response_row * row = &response->rows[j];
-                        if( !memcmp( key, row->info_hash, SHA_DIGEST_LENGTH ) )
+                        if (!memcmp (key, row->info_hash, SHA_DIGEST_LENGTH))
                         {
-                            if( tr_bencDictFindInt( val, "complete", &intVal ) )
+                            if (tr_bencDictFindInt (val, "complete", &intVal))
                                 row->seeders = intVal;
-                            if( tr_bencDictFindInt( val, "incomplete", &intVal ) )
+                            if (tr_bencDictFindInt (val, "incomplete", &intVal))
                                 row->leechers = intVal;
-                            if( tr_bencDictFindInt( val, "downloaded", &intVal ) )
+                            if (tr_bencDictFindInt (val, "downloaded", &intVal))
                                 row->downloads = intVal;
-                            if( tr_bencDictFindInt( val, "downloaders", &intVal ) )
+                            if (tr_bencDictFindInt (val, "downloaders", &intVal))
                                 row->downloaders = intVal;
                             break;
                         }
@@ -421,59 +421,59 @@ on_scrape_done( tr_session   * session,
                 }
             }
 
-            tr_bencFree( &top );
+            tr_bencFree (&top);
         }
     }
 
-    tr_runInEventThread( session, on_scrape_done_eventthread, data );
+    tr_runInEventThread (session, on_scrape_done_eventthread, data);
 }
 
 static char *
-scrape_url_new( const tr_scrape_request * req )
+scrape_url_new (const tr_scrape_request * req)
 {
     int i;
     char delimiter;
-    struct evbuffer * buf = evbuffer_new( );
+    struct evbuffer * buf = evbuffer_new ();
 
-    evbuffer_add_printf( buf, "%s", req->url );
-    delimiter = strchr( req->url, '?' ) ? '&' : '?';
-    for( i=0; i<req->info_hash_count; ++i )
+    evbuffer_add_printf (buf, "%s", req->url);
+    delimiter = strchr (req->url, '?') ? '&' : '?';
+    for (i=0; i<req->info_hash_count; ++i)
     {
         char str[SHA_DIGEST_LENGTH*3 + 1];
-        tr_http_escape_sha1( str, req->info_hash[i] );
-        evbuffer_add_printf( buf, "%cinfo_hash=%s", delimiter, str );
+        tr_http_escape_sha1 (str, req->info_hash[i]);
+        evbuffer_add_printf (buf, "%cinfo_hash=%s", delimiter, str);
         delimiter = '&';
     }
 
-    return evbuffer_free_to_str( buf );
+    return evbuffer_free_to_str (buf);
 }
 
 void
-tr_tracker_http_scrape( tr_session               * session,
+tr_tracker_http_scrape (tr_session               * session,
                         const tr_scrape_request  * request,
                         tr_scrape_response_func    response_func,
-                        void                     * response_func_user_data )
+                        void                     * response_func_user_data)
 {
     int i;
     struct scrape_data * d;
-    char * url = scrape_url_new( request );
+    char * url = scrape_url_new (request);
 
-    d = tr_new0( struct scrape_data, 1 );
-    d->response.url = tr_strdup( request->url );
+    d = tr_new0 (struct scrape_data, 1);
+    d->response.url = tr_strdup (request->url);
     d->response_func = response_func;
     d->response_func_user_data = response_func_user_data;
     d->response.row_count = request->info_hash_count;
-    for( i=0; i<d->response.row_count; ++i )
+    for (i=0; i<d->response.row_count; ++i)
     {
-        memcpy( d->response.rows[i].info_hash, request->info_hash[i], SHA_DIGEST_LENGTH );
+        memcpy (d->response.rows[i].info_hash, request->info_hash[i], SHA_DIGEST_LENGTH);
         d->response.rows[i].seeders = -1;
         d->response.rows[i].leechers = -1;
         d->response.rows[i].downloads = -1;
     }
-    tr_strlcpy( d->log_name, request->log_name, sizeof( d->log_name ) );
+    tr_strlcpy (d->log_name, request->log_name, sizeof (d->log_name));
 
-    dbgmsg( request->log_name, "Sending scrape to libcurl: \"%s\"", url );
-    tr_webRun( session, url, NULL, NULL, on_scrape_done, d );
+    dbgmsg (request->log_name, "Sending scrape to libcurl: \"%s\"", url);
+    tr_webRun (session, url, NULL, NULL, on_scrape_done, d);
 
-    tr_free( url );
+    tr_free (url);
 }
diff --git a/libtransmission/announcer-udp.c b/libtransmission/announcer-udp.c
index 0fb299a4c..df0c235ff 100644
--- a/libtransmission/announcer-udp.c
+++ b/libtransmission/announcer-udp.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -12,7 +12,7 @@
 
 #define __LIBTRANSMISSION_ANNOUNCER_MODULE___
 
-#include <string.h> /* memcpy(), memset() */
+#include <string.h> /* memcpy (), memset () */
 
 #include <event2/buffer.h>
 #include <event2/dns.h>
@@ -21,52 +21,52 @@
 #include "transmission.h"
 #include "announcer.h"
 #include "announcer-common.h"
-#include "crypto.h" /* tr_cryptoRandBuf() */
+#include "crypto.h" /* tr_cryptoRandBuf () */
 #include "peer-io.h"
-#include "peer-mgr.h" /* tr_peerMgrCompactToPex() */
+#include "peer-mgr.h" /* tr_peerMgrCompactToPex () */
 #include "ptrarray.h"
 #include "tr-udp.h"
 #include "utils.h"
 
-#define dbgmsg( name, ... ) \
-if( tr_deepLoggingIsActive( ) ) do { \
-  tr_deepLog( __FILE__, __LINE__, name, __VA_ARGS__ ); \
-} while( 0 )
+#define dbgmsg(name, ...) \
+if (tr_deepLoggingIsActive ()) do { \
+  tr_deepLog (__FILE__, __LINE__, name, __VA_ARGS__); \
+} while (0)
 
 /****
 *****
 ****/
 
 static void
-tau_sockaddr_setport( struct sockaddr * sa, tr_port port )
+tau_sockaddr_setport (struct sockaddr * sa, tr_port port)
 {
-    if( sa->sa_family == AF_INET )
-        ((struct sockaddr_in *)sa)->sin_port = htons(port);
+    if (sa->sa_family == AF_INET)
+      ((struct sockaddr_in *)sa)->sin_port = htons (port);
     else if (sa->sa_family == AF_INET6)
-        ((struct sockaddr_in6 *)sa)->sin6_port = htons(port);
+      ((struct sockaddr_in6 *)sa)->sin6_port = htons (port);
 }
 
 static int
-tau_sendto( tr_session * session,
+tau_sendto (tr_session * session,
             struct evutil_addrinfo * ai, tr_port port,
-            const void * buf, size_t buflen )
+            const void * buf, size_t buflen)
 {
     int sockfd;
 
-    if( ai->ai_addr->sa_family == AF_INET )
+    if (ai->ai_addr->sa_family == AF_INET)
         sockfd = session->udp_socket;
-    else if( ai->ai_addr->sa_family == AF_INET6 )
+    else if (ai->ai_addr->sa_family == AF_INET6)
         sockfd = session->udp6_socket;
     else
         sockfd = -1;
 
-    if( sockfd < 0 ) {
+    if (sockfd < 0) {
         errno = EAFNOSUPPORT;
         return -1;
     }
 
-    tau_sockaddr_setport( ai->ai_addr, port );
-    return sendto( sockfd, buf, buflen, 0, ai->ai_addr, ai->ai_addrlen );
+    tau_sockaddr_setport (ai->ai_addr, port);
+    return sendto (sockfd, buf, buflen, 0, ai->ai_addr, ai->ai_addrlen);
 }
 
 /****
@@ -74,19 +74,19 @@ tau_sendto( tr_session * session,
 ****/
 
 static uint32_t
-evbuffer_read_ntoh_32( struct evbuffer * buf )
+evbuffer_read_ntoh_32 (struct evbuffer * buf)
 {
     uint32_t val;
-    evbuffer_remove( buf, &val, sizeof( uint32_t ) );
-    return ntohl( val );
+    evbuffer_remove (buf, &val, sizeof (uint32_t));
+    return ntohl (val);
 }
 
 static uint64_t
-evbuffer_read_ntoh_64( struct evbuffer * buf )
+evbuffer_read_ntoh_64 (struct evbuffer * buf)
 {
     uint64_t val;
-    evbuffer_remove( buf, &val, sizeof( uint64_t ) );
-    return tr_ntohll( val );
+    evbuffer_remove (buf, &val, sizeof (uint64_t));
+    return tr_ntohll (val);
 }
 
 /****
@@ -103,10 +103,10 @@ enum
 typedef uint32_t tau_transaction_t;
 
 static tau_transaction_t
-tau_transaction_new( void )
+tau_transaction_new (void)
 {
     tau_transaction_t tmp;
-    tr_cryptoRandBuf( &tmp, sizeof( tau_transaction_t ) );
+    tr_cryptoRandBuf (&tmp, sizeof (tau_transaction_t));
     return tmp;
 }
 
@@ -121,12 +121,12 @@ typedef enum
 tau_action_t;
 
 static bool
-is_tau_response_message( int action, int msglen )
+is_tau_response_message (int action, int msglen)
 {
-    if( action == TAU_ACTION_CONNECT  ) return msglen == 16;
-    if( action == TAU_ACTION_ANNOUNCE ) return msglen >= 20;
-    if( action == TAU_ACTION_SCRAPE   ) return msglen >= 20;
-    if( action == TAU_ACTION_ERROR    ) return msglen >= 8;
+    if (action == TAU_ACTION_CONNECT) return msglen == 16;
+    if (action == TAU_ACTION_ANNOUNCE) return msglen >= 20;
+    if (action == TAU_ACTION_SCRAPE ) return msglen >= 20;
+    if (action == TAU_ACTION_ERROR  ) return msglen >= 8;
     return false;
 }
 
@@ -156,112 +156,112 @@ struct tau_scrape_request
 };
 
 static struct tau_scrape_request *
-tau_scrape_request_new( const tr_scrape_request  * in,
+tau_scrape_request_new (const tr_scrape_request  * in,
                         tr_scrape_response_func    callback,
-                        void                     * user_data )
+                        void                     * user_data)
 {
     int i;
     struct evbuffer * buf;
     struct tau_scrape_request * req;
-    const tau_transaction_t transaction_id = tau_transaction_new( );
+    const tau_transaction_t transaction_id = tau_transaction_new ();
 
     /* build the payload */
-    buf = evbuffer_new( );
-    evbuffer_add_hton_32( buf, TAU_ACTION_SCRAPE );
-    evbuffer_add_hton_32( buf, transaction_id );
-    for( i=0; i<in->info_hash_count; ++i )
-        evbuffer_add( buf, in->info_hash[i], SHA_DIGEST_LENGTH );
+    buf = evbuffer_new ();
+    evbuffer_add_hton_32 (buf, TAU_ACTION_SCRAPE);
+    evbuffer_add_hton_32 (buf, transaction_id);
+    for (i=0; i<in->info_hash_count; ++i)
+        evbuffer_add (buf, in->info_hash[i], SHA_DIGEST_LENGTH);
 
     /* build the tau_scrape_request */
-    req = tr_new0( struct tau_scrape_request, 1 );
-    req->created_at = tr_time( );
+    req = tr_new0 (struct tau_scrape_request, 1);
+    req->created_at = tr_time ();
     req->transaction_id = transaction_id;
     req->callback = callback;
     req->user_data = user_data;
-    req->response.url = tr_strdup( in->url );
+    req->response.url = tr_strdup (in->url);
     req->response.row_count = in->info_hash_count;
-    req->payload_len = evbuffer_get_length( buf );
-    req->payload = tr_memdup( evbuffer_pullup( buf, -1 ), req->payload_len );
-    for( i=0; i<req->response.row_count; ++i )
+    req->payload_len = evbuffer_get_length (buf);
+    req->payload = tr_memdup (evbuffer_pullup (buf, -1), req->payload_len);
+    for (i=0; i<req->response.row_count; ++i)
     {
         req->response.rows[i].seeders = -1;
         req->response.rows[i].leechers = -1;
         req->response.rows[i].downloads = -1;
-        memcpy( req->response.rows[i].info_hash,
-                in->info_hash[i], SHA_DIGEST_LENGTH );
+        memcpy (req->response.rows[i].info_hash,
+                in->info_hash[i], SHA_DIGEST_LENGTH);
     }
 
     /* cleanup */
-    evbuffer_free( buf );
+    evbuffer_free (buf);
     return req;
 }
 
 static void
-tau_scrape_request_free( struct tau_scrape_request * req )
+tau_scrape_request_free (struct tau_scrape_request * req)
 {
-    tr_free( req->response.errmsg );
-    tr_free( req->response.url );
-    tr_free( req->payload );
-    tr_free( req );
+    tr_free (req->response.errmsg);
+    tr_free (req->response.url);
+    tr_free (req->payload);
+    tr_free (req);
 }
 
 static void
-tau_scrape_request_finished( const struct tau_scrape_request  * request )
+tau_scrape_request_finished (const struct tau_scrape_request  * request)
 {
-    if( request->callback != NULL )
-        request->callback( &request->response, request->user_data );
+    if (request->callback != NULL)
+        request->callback (&request->response, request->user_data);
 }
 
 static void
-tau_scrape_request_fail( struct tau_scrape_request  * request,
+tau_scrape_request_fail (struct tau_scrape_request  * request,
                          bool                         did_connect,
                          bool                         did_timeout,
-                         const char                 * errmsg )
+                         const char                 * errmsg)
 {
     request->response.did_connect = did_connect;
     request->response.did_timeout = did_timeout;
-    request->response.errmsg = tr_strdup( errmsg );
-    tau_scrape_request_finished( request );
+    request->response.errmsg = tr_strdup (errmsg);
+    tau_scrape_request_finished (request);
 }
 
 static void
-on_scrape_response( struct tau_scrape_request  * request,
+on_scrape_response (struct tau_scrape_request  * request,
                     tau_action_t                 action,
-                    struct evbuffer            * buf )
+                    struct evbuffer            * buf)
 {
     request->response.did_connect = true;
     request->response.did_timeout = false;
 
-    if( action == TAU_ACTION_SCRAPE )
+    if (action == TAU_ACTION_SCRAPE)
     {
         int i;
-        for( i=0; i<request->response.row_count; ++i )
+        for (i=0; i<request->response.row_count; ++i)
         {
             struct tr_scrape_response_row * row;
 
-            if( evbuffer_get_length( buf ) < ( sizeof( uint32_t ) * 3 ) )
+            if (evbuffer_get_length (buf) < (sizeof (uint32_t) * 3))
                 break;
 
             row = &request->response.rows[i];
-            row->seeders   = evbuffer_read_ntoh_32( buf );
-            row->downloads = evbuffer_read_ntoh_32( buf );
-            row->leechers  = evbuffer_read_ntoh_32( buf );
+            row->seeders   = evbuffer_read_ntoh_32 (buf);
+            row->downloads = evbuffer_read_ntoh_32 (buf);
+            row->leechers  = evbuffer_read_ntoh_32 (buf);
         }
 
-        tau_scrape_request_finished( request );
+        tau_scrape_request_finished (request);
     }
     else
     {
         char * errmsg;
-        const size_t buflen = evbuffer_get_length( buf );
+        const size_t buflen = evbuffer_get_length (buf);
 
-        if( ( action == TAU_ACTION_ERROR ) && ( buflen > 0 ) )
-            errmsg = tr_strndup( evbuffer_pullup( buf, -1 ), buflen );
+        if ((action == TAU_ACTION_ERROR) && (buflen > 0))
+            errmsg = tr_strndup (evbuffer_pullup (buf, -1), buflen);
         else
-            errmsg = tr_strdup( _( "Unknown error" ) );
+            errmsg = tr_strdup (_ ("Unknown error"));
 
-        tau_scrape_request_fail( request, true, false, errmsg );
-        tr_free( errmsg );
+        tau_scrape_request_fail (request, true, false, errmsg);
+        tr_free (errmsg);
     }
 }
 
@@ -296,9 +296,9 @@ typedef enum
 tau_announce_event;
 
 static tau_announce_event
-get_tau_announce_event( tr_announce_event e )
+get_tau_announce_event (tr_announce_event e)
 {
-    switch( e )
+    switch (e)
     {
         case TR_ANNOUNCE_EVENT_COMPLETED: return TAU_ANNOUNCE_EVENT_COMPLETED;
         case TR_ANNOUNCE_EVENT_STARTED:   return TAU_ANNOUNCE_EVENT_STARTED;
@@ -308,110 +308,110 @@ get_tau_announce_event( tr_announce_event e )
 }
 
 static struct tau_announce_request *
-tau_announce_request_new( const tr_announce_request  * in,
+tau_announce_request_new (const tr_announce_request  * in,
                           tr_announce_response_func    callback,
-                          void                       * user_data )
+                          void                       * user_data)
 {
     struct evbuffer * buf;
     struct tau_announce_request * req;
-    const tau_transaction_t transaction_id = tau_transaction_new( );
+    const tau_transaction_t transaction_id = tau_transaction_new ();
 
     /* build the payload */
-    buf = evbuffer_new( );
-    evbuffer_add_hton_32( buf, TAU_ACTION_ANNOUNCE );
-    evbuffer_add_hton_32( buf, transaction_id );
-    evbuffer_add        ( buf, in->info_hash, SHA_DIGEST_LENGTH );
-    evbuffer_add        ( buf, in->peer_id, PEER_ID_LEN );
-    evbuffer_add_hton_64( buf, in->down );
-    evbuffer_add_hton_64( buf, in->leftUntilComplete );
-    evbuffer_add_hton_64( buf, in->up );
-    evbuffer_add_hton_32( buf, get_tau_announce_event( in->event ) );
-    evbuffer_add_hton_32( buf, 0 );
-    evbuffer_add_hton_32( buf, in->key );
-    evbuffer_add_hton_32( buf, in->numwant );
-    evbuffer_add_hton_16( buf, in->port );
+    buf = evbuffer_new ();
+    evbuffer_add_hton_32 (buf, TAU_ACTION_ANNOUNCE);
+    evbuffer_add_hton_32 (buf, transaction_id);
+    evbuffer_add      (buf, in->info_hash, SHA_DIGEST_LENGTH);
+    evbuffer_add      (buf, in->peer_id, PEER_ID_LEN);
+    evbuffer_add_hton_64 (buf, in->down);
+    evbuffer_add_hton_64 (buf, in->leftUntilComplete);
+    evbuffer_add_hton_64 (buf, in->up);
+    evbuffer_add_hton_32 (buf, get_tau_announce_event (in->event));
+    evbuffer_add_hton_32 (buf, 0);
+    evbuffer_add_hton_32 (buf, in->key);
+    evbuffer_add_hton_32 (buf, in->numwant);
+    evbuffer_add_hton_16 (buf, in->port);
 
     /* build the tau_announce_request */
-    req = tr_new0( struct tau_announce_request, 1 );
-    req->created_at = tr_time( );
+    req = tr_new0 (struct tau_announce_request, 1);
+    req->created_at = tr_time ();
     req->transaction_id = transaction_id;
     req->callback = callback;
     req->user_data = user_data;
-    req->payload_len = evbuffer_get_length( buf );
-    req->payload = tr_memdup( evbuffer_pullup( buf, -1 ), req->payload_len );
+    req->payload_len = evbuffer_get_length (buf);
+    req->payload = tr_memdup (evbuffer_pullup (buf, -1), req->payload_len);
     req->response.seeders = -1;
     req->response.leechers = -1;
     req->response.downloads = -1;
-    memcpy( req->response.info_hash, in->info_hash, SHA_DIGEST_LENGTH );
+    memcpy (req->response.info_hash, in->info_hash, SHA_DIGEST_LENGTH);
 
-    evbuffer_free( buf );
+    evbuffer_free (buf);
     return req;
 }
 
 static void
-tau_announce_request_free( struct tau_announce_request * req )
+tau_announce_request_free (struct tau_announce_request * req)
 {
-    tr_free( req->response.tracker_id_str );
-    tr_free( req->response.warning );
-    tr_free( req->response.errmsg );
-    tr_free( req->response.pex6 );
-    tr_free( req->response.pex );
-    tr_free( req->payload );
-    tr_free( req );
+    tr_free (req->response.tracker_id_str);
+    tr_free (req->response.warning);
+    tr_free (req->response.errmsg);
+    tr_free (req->response.pex6);
+    tr_free (req->response.pex);
+    tr_free (req->payload);
+    tr_free (req);
 }
 
 static void
-tau_announce_request_finished( const struct tau_announce_request * request )
+tau_announce_request_finished (const struct tau_announce_request * request)
 {
-    if( request->callback != NULL )
-        request->callback( &request->response, request->user_data );
+    if (request->callback != NULL)
+        request->callback (&request->response, request->user_data);
 }
 
 static void
-tau_announce_request_fail( struct tau_announce_request  * request,
+tau_announce_request_fail (struct tau_announce_request  * request,
                            bool                           did_connect,
                            bool                           did_timeout,
-                           const char                   * errmsg )
+                           const char                   * errmsg)
 {
     request->response.did_connect = did_connect;
     request->response.did_timeout = did_timeout;
-    request->response.errmsg = tr_strdup( errmsg );
-    tau_announce_request_finished( request );
+    request->response.errmsg = tr_strdup (errmsg);
+    tau_announce_request_finished (request);
 }
 
 static void
-on_announce_response( struct tau_announce_request  * request,
+on_announce_response (struct tau_announce_request  * request,
                       tau_action_t                   action,
-                      struct evbuffer              * buf )
+                      struct evbuffer              * buf)
 {
-    const size_t buflen = evbuffer_get_length( buf );
+    const size_t buflen = evbuffer_get_length (buf);
 
     request->response.did_connect = true;
     request->response.did_timeout = false;
 
-    if( ( action == TAU_ACTION_ANNOUNCE ) && ( buflen >= 3*sizeof(uint32_t) ) )
+    if ((action == TAU_ACTION_ANNOUNCE) && (buflen >= 3*sizeof (uint32_t)))
     {
         tr_announce_response * resp = &request->response;
-        resp->interval = evbuffer_read_ntoh_32( buf );
-        resp->leechers = evbuffer_read_ntoh_32( buf );
-        resp->seeders  = evbuffer_read_ntoh_32( buf );
-        resp->pex = tr_peerMgrCompactToPex( evbuffer_pullup( buf, -1 ),
-                                            evbuffer_get_length( buf ),
+        resp->interval = evbuffer_read_ntoh_32 (buf);
+        resp->leechers = evbuffer_read_ntoh_32 (buf);
+        resp->seeders  = evbuffer_read_ntoh_32 (buf);
+        resp->pex = tr_peerMgrCompactToPex (evbuffer_pullup (buf, -1),
+                                            evbuffer_get_length (buf),
                                             NULL, 0,
-                                            &request->response.pex_count );
-        tau_announce_request_finished( request );
+                                            &request->response.pex_count);
+        tau_announce_request_finished (request);
     }
     else
     {
         char * errmsg;
 
-        if( ( action == TAU_ACTION_ERROR ) && ( buflen > 0 ) )
-            errmsg = tr_strndup( evbuffer_pullup( buf, -1 ), buflen );
+        if ((action == TAU_ACTION_ERROR) && (buflen > 0))
+            errmsg = tr_strndup (evbuffer_pullup (buf, -1), buflen);
         else
-            errmsg = tr_strdup( _( "Unknown error" ) );
+            errmsg = tr_strdup (_ ("Unknown error"));
 
-        tau_announce_request_fail( request, true, false, errmsg );
-        tr_free( errmsg );
+        tau_announce_request_fail (request, true, false, errmsg);
+        tr_free (errmsg);
     }
 }
 
@@ -444,25 +444,25 @@ struct tau_tracker
     tr_ptrArray scrapes;
 };
 
-static void tau_tracker_upkeep( struct tau_tracker * );
+static void tau_tracker_upkeep (struct tau_tracker *);
 
 static void
-tau_tracker_free( struct tau_tracker * t )
+tau_tracker_free (struct tau_tracker * t)
 {
-    if( t->addr )
-        evutil_freeaddrinfo( t->addr );
-    tr_ptrArrayDestruct( &t->announces, (PtrArrayForeachFunc)tau_announce_request_free );
-    tr_ptrArrayDestruct( &t->scrapes, (PtrArrayForeachFunc)tau_scrape_request_free );
-    tr_free( t->host );
-    tr_free( t->key );
-    tr_free( t );
+    if (t->addr)
+        evutil_freeaddrinfo (t->addr);
+    tr_ptrArrayDestruct (&t->announces, (PtrArrayForeachFunc)tau_announce_request_free);
+    tr_ptrArrayDestruct (&t->scrapes, (PtrArrayForeachFunc)tau_scrape_request_free);
+    tr_free (t->host);
+    tr_free (t->key);
+    tr_free (t);
 }
 
 static void
-tau_tracker_fail_all( struct tau_tracker  * tracker,
+tau_tracker_fail_all (struct tau_tracker  * tracker,
                       bool                  did_connect,
                       bool                  did_timeout,
-                      const char          * errmsg )
+                      const char          * errmsg)
 {
     int i;
     int n;
@@ -470,84 +470,84 @@ tau_tracker_fail_all( struct tau_tracker  * tracker,
 
     /* fail all the scrapes */
     reqs = &tracker->scrapes;
-    for( i=0, n=tr_ptrArraySize(reqs); i<n; ++i )
-        tau_scrape_request_fail( tr_ptrArrayNth( reqs, i ),
-                                 did_connect, did_timeout, errmsg );
-    tr_ptrArrayDestruct( reqs, (PtrArrayForeachFunc)tau_scrape_request_free );
+    for (i=0, n=tr_ptrArraySize (reqs); i<n; ++i)
+        tau_scrape_request_fail (tr_ptrArrayNth (reqs, i),
+                                 did_connect, did_timeout, errmsg);
+    tr_ptrArrayDestruct (reqs, (PtrArrayForeachFunc)tau_scrape_request_free);
     *reqs = TR_PTR_ARRAY_INIT;
 
     /* fail all the announces */
     reqs = &tracker->announces;
-    for( i=0, n=tr_ptrArraySize(reqs); i<n; ++i )
-        tau_announce_request_fail( tr_ptrArrayNth( reqs, i ),
-                                   did_connect, did_timeout, errmsg );
-    tr_ptrArrayDestruct( reqs, (PtrArrayForeachFunc)tau_announce_request_free );
+    for (i=0, n=tr_ptrArraySize (reqs); i<n; ++i)
+        tau_announce_request_fail (tr_ptrArrayNth (reqs, i),
+                                   did_connect, did_timeout, errmsg);
+    tr_ptrArrayDestruct (reqs, (PtrArrayForeachFunc)tau_announce_request_free);
     *reqs = TR_PTR_ARRAY_INIT;
 
 }
 
 static void
-tau_tracker_on_dns( int errcode, struct evutil_addrinfo *addr, void * vtracker )
+tau_tracker_on_dns (int errcode, struct evutil_addrinfo *addr, void * vtracker)
 {
     struct tau_tracker * tracker = vtracker;
 
     tracker->is_asking_dns = false;
 
-    if ( errcode )
+    if (errcode)
     {
-        char * errmsg = tr_strdup_printf( _( "DNS Lookup failed: %s" ),
-                                          evdns_err_to_string( errcode ) );
-        dbgmsg( tracker->key, "%s", errmsg );
-        tau_tracker_fail_all( tracker, false, false, errmsg );
-        tr_free( errmsg );
+        char * errmsg = tr_strdup_printf (_ ("DNS Lookup failed: %s"),
+                                          evdns_err_to_string (errcode));
+        dbgmsg (tracker->key, "%s", errmsg);
+        tau_tracker_fail_all (tracker, false, false, errmsg);
+        tr_free (errmsg);
     }
     else
     {
-        dbgmsg( tracker->key, "DNS lookup succeeded" );
+        dbgmsg (tracker->key, "DNS lookup succeeded");
         tracker->addr = addr;
-        tracker->addr_expiration_time = tr_time() + (60*60); /* one hour */
-        tau_tracker_upkeep( tracker );
+        tracker->addr_expiration_time = tr_time () + (60*60); /* one hour */
+        tau_tracker_upkeep (tracker);
     }
 }
 
 static void
-tau_tracker_send_request( struct tau_tracker  * tracker,
+tau_tracker_send_request (struct tau_tracker  * tracker,
                           const void          * payload,
-                          size_t                payload_len )
+                          size_t                payload_len)
 {
-    struct evbuffer * buf = evbuffer_new( );
-    dbgmsg( tracker->key, "sending request w/connection id %"PRIu64"\n",
-                          tracker->connection_id );
-    evbuffer_add_hton_64( buf, tracker->connection_id );
-    evbuffer_add_reference( buf, payload, payload_len, NULL, NULL );
-    tau_sendto( tracker->session, tracker->addr, tracker->port,
-                evbuffer_pullup( buf, -1 ),
-                evbuffer_get_length( buf ) );
-    evbuffer_free( buf );
+    struct evbuffer * buf = evbuffer_new ();
+    dbgmsg (tracker->key, "sending request w/connection id %"PRIu64"\n",
+                          tracker->connection_id);
+    evbuffer_add_hton_64 (buf, tracker->connection_id);
+    evbuffer_add_reference (buf, payload, payload_len, NULL, NULL);
+    tau_sendto (tracker->session, tracker->addr, tracker->port,
+                evbuffer_pullup (buf, -1),
+                evbuffer_get_length (buf));
+    evbuffer_free (buf);
 }
 
 static void
-tau_tracker_send_reqs( struct tau_tracker * tracker )
+tau_tracker_send_reqs (struct tau_tracker * tracker)
 {
     int i, n;
     tr_ptrArray * reqs;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    assert( tracker->is_asking_dns == false );
-    assert( tracker->connecting_at == 0 );
-    assert( tracker->addr != NULL );
-    assert( tracker->connection_expiration_time > now );
+    assert (tracker->is_asking_dns == false);
+    assert (tracker->connecting_at == 0);
+    assert (tracker->addr != NULL);
+    assert (tracker->connection_expiration_time > now);
 
     reqs = &tracker->announces;
-    for( i=0, n=tr_ptrArraySize(reqs); i<n; ++i ) {
-        struct tau_announce_request * req = tr_ptrArrayNth( reqs, i );
-        if( !req->sent_at ) {
-            dbgmsg( tracker->key, "sending announce req %p", req );
+    for (i=0, n=tr_ptrArraySize (reqs); i<n; ++i) {
+        struct tau_announce_request * req = tr_ptrArrayNth (reqs, i);
+        if (!req->sent_at) {
+            dbgmsg (tracker->key, "sending announce req %p", req);
             req->sent_at = now;
-            tau_tracker_send_request( tracker, req->payload, req->payload_len );
-            if( req->callback == NULL ) {
-                tau_announce_request_free( req );
-                tr_ptrArrayRemove( reqs, i );
+            tau_tracker_send_request (tracker, req->payload, req->payload_len);
+            if (req->callback == NULL) {
+                tau_announce_request_free (req);
+                tr_ptrArrayRemove (reqs, i);
                 --i;
                 --n;
             }
@@ -555,15 +555,15 @@ tau_tracker_send_reqs( struct tau_tracker * tracker )
     }
 
     reqs = &tracker->scrapes;
-    for( i=0, n=tr_ptrArraySize(reqs); i<n; ++i ) {
-        struct tau_scrape_request * req = tr_ptrArrayNth( reqs, i );
-        if( !req->sent_at ) {
-            dbgmsg( tracker->key, "sending scrape req %p", req );
+    for (i=0, n=tr_ptrArraySize (reqs); i<n; ++i) {
+        struct tau_scrape_request * req = tr_ptrArrayNth (reqs, i);
+        if (!req->sent_at) {
+            dbgmsg (tracker->key, "sending scrape req %p", req);
             req->sent_at = now;
-            tau_tracker_send_request( tracker, req->payload, req->payload_len );
-            if( req->callback == NULL ) {
-                tau_scrape_request_free( req );
-                tr_ptrArrayRemove( reqs, i );
+            tau_tracker_send_request (tracker, req->payload, req->payload_len);
+            if (req->callback == NULL) {
+                tau_scrape_request_free (req);
+                tr_ptrArrayRemove (reqs, i);
                 --i;
                 --n;
             }
@@ -572,74 +572,74 @@ tau_tracker_send_reqs( struct tau_tracker * tracker )
 }
 
 static void
-on_tracker_connection_response( struct tau_tracker  * tracker,
+on_tracker_connection_response (struct tau_tracker  * tracker,
                                 tau_action_t          action,
-                                struct evbuffer     * buf )
+                                struct evbuffer     * buf)
 {
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
     tracker->connecting_at = 0;
     tracker->connection_transaction_id = 0;
 
-    if( action == TAU_ACTION_CONNECT )
+    if (action == TAU_ACTION_CONNECT)
     {
-        tracker->connection_id = evbuffer_read_ntoh_64( buf );
+        tracker->connection_id = evbuffer_read_ntoh_64 (buf);
         tracker->connection_expiration_time = now + TAU_CONNECTION_TTL_SECS;
-        dbgmsg( tracker->key, "Got a new connection ID from tracker: %"PRIu64,
-                tracker->connection_id );
+        dbgmsg (tracker->key, "Got a new connection ID from tracker: %"PRIu64,
+                tracker->connection_id);
     }
     else
     {
         char * errmsg;
-        const size_t buflen = buf ? evbuffer_get_length( buf ) : 0;
+        const size_t buflen = buf ? evbuffer_get_length (buf) : 0;
 
-        if( ( action == TAU_ACTION_ERROR ) && ( buflen > 0 ) )
-            errmsg = tr_strndup( evbuffer_pullup( buf, -1 ), buflen );
+        if ((action == TAU_ACTION_ERROR) && (buflen > 0))
+            errmsg = tr_strndup (evbuffer_pullup (buf, -1), buflen);
         else
-            errmsg = tr_strdup( _( "Connection failed" ) );
+            errmsg = tr_strdup (_ ("Connection failed"));
 
-        dbgmsg( tracker->key, "%s", errmsg );
-        tau_tracker_fail_all( tracker, true, false, errmsg );
-        tr_free( errmsg );
+        dbgmsg (tracker->key, "%s", errmsg);
+        tau_tracker_fail_all (tracker, true, false, errmsg);
+        tr_free (errmsg);
     }
 
-    tau_tracker_upkeep( tracker );
+    tau_tracker_upkeep (tracker);
 }
 
 static void
-tau_tracker_timeout_reqs( struct tau_tracker * tracker )
+tau_tracker_timeout_reqs (struct tau_tracker * tracker)
 {
     int i, n;
     tr_ptrArray * reqs;
-    const time_t now = time( NULL );
-    const bool cancel_all = tracker->close_at && ( tracker->close_at <= now );
+    const time_t now = time (NULL);
+    const bool cancel_all = tracker->close_at && (tracker->close_at <= now);
 
 
-    if( tracker->connecting_at && ( tracker->connecting_at + TAU_REQUEST_TTL < now ) ) {
-        on_tracker_connection_response( tracker, TAU_ACTION_ERROR, NULL );
+    if (tracker->connecting_at && (tracker->connecting_at + TAU_REQUEST_TTL < now)) {
+        on_tracker_connection_response (tracker, TAU_ACTION_ERROR, NULL);
     }
 
     reqs = &tracker->announces;
-    for( i=0, n=tr_ptrArraySize(reqs); i<n; ++i ) {
-        struct tau_announce_request * req = tr_ptrArrayNth( reqs, i );
-        if( cancel_all || ( req->created_at + TAU_REQUEST_TTL < now ) ) {
-            dbgmsg( tracker->key, "timeout announce req %p", req );
-            tau_announce_request_fail( req, false, true, NULL );
-            tau_announce_request_free( req );
-            tr_ptrArrayRemove( reqs, i );
+    for (i=0, n=tr_ptrArraySize (reqs); i<n; ++i) {
+        struct tau_announce_request * req = tr_ptrArrayNth (reqs, i);
+        if (cancel_all || (req->created_at + TAU_REQUEST_TTL < now)) {
+            dbgmsg (tracker->key, "timeout announce req %p", req);
+            tau_announce_request_fail (req, false, true, NULL);
+            tau_announce_request_free (req);
+            tr_ptrArrayRemove (reqs, i);
             --i;
             --n;
         }
     }
 
     reqs = &tracker->scrapes;
-    for( i=0, n=tr_ptrArraySize(reqs); i<n; ++i ) {
-        struct tau_scrape_request * req = tr_ptrArrayNth( reqs, i );
-        if( cancel_all || ( req->created_at + TAU_REQUEST_TTL < now ) ) {
-            dbgmsg( tracker->key, "timeout scrape req %p", req );
-            tau_scrape_request_fail( req, false, true, NULL );
-            tau_scrape_request_free( req );
-            tr_ptrArrayRemove( reqs, i );
+    for (i=0, n=tr_ptrArraySize (reqs); i<n; ++i) {
+        struct tau_scrape_request * req = tr_ptrArrayNth (reqs, i);
+        if (cancel_all || (req->created_at + TAU_REQUEST_TTL < now)) {
+            dbgmsg (tracker->key, "timeout scrape req %p", req);
+            tau_scrape_request_fail (req, false, true, NULL);
+            tau_scrape_request_free (req);
+            tr_ptrArrayRemove (reqs, i);
             --i;
             --n;
         }
@@ -647,74 +647,74 @@ tau_tracker_timeout_reqs( struct tau_tracker * tracker )
 }
 
 static bool
-tau_tracker_is_idle( const struct tau_tracker * tracker )
+tau_tracker_is_idle (const struct tau_tracker * tracker)
 {
-    return tr_ptrArrayEmpty( &tracker->announces )
-        && tr_ptrArrayEmpty( &tracker->scrapes );
+    return tr_ptrArrayEmpty (&tracker->announces)
+        && tr_ptrArrayEmpty (&tracker->scrapes);
 }
 
 static void
-tau_tracker_upkeep( struct tau_tracker * tracker )
+tau_tracker_upkeep (struct tau_tracker * tracker)
 {
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
     /* if the address info is too old, expire it */
-    if( tracker->addr && ( tracker->addr_expiration_time <= now ) ) {
-        dbgmsg( tracker->host, "Expiring old DNS result" );
-        evutil_freeaddrinfo( tracker->addr );
+    if (tracker->addr && (tracker->addr_expiration_time <= now)) {
+        dbgmsg (tracker->host, "Expiring old DNS result");
+        evutil_freeaddrinfo (tracker->addr);
         tracker->addr = NULL;
     }
 
     /* are there any requests pending? */
-    if( tau_tracker_is_idle( tracker ) )
+    if (tau_tracker_is_idle (tracker))
         return;
 
     /* if we don't have an address yet, try & get one now. */
-    if( !tracker->addr && !tracker->is_asking_dns )
+    if (!tracker->addr && !tracker->is_asking_dns)
     {
         struct evutil_addrinfo hints;
-        memset( &hints, 0, sizeof( hints ) );
+        memset (&hints, 0, sizeof (hints));
         hints.ai_family = AF_UNSPEC;
         hints.ai_flags = EVUTIL_AI_CANONNAME;
         hints.ai_socktype = SOCK_DGRAM;
         hints.ai_protocol = IPPROTO_UDP;
         tracker->is_asking_dns = true;
-        dbgmsg( tracker->host, "Trying a new DNS lookup" );
-        evdns_getaddrinfo( tracker->session->evdns_base,
+        dbgmsg (tracker->host, "Trying a new DNS lookup");
+        evdns_getaddrinfo (tracker->session->evdns_base,
                            tracker->host, NULL, &hints,
-                           tau_tracker_on_dns, tracker );
+                           tau_tracker_on_dns, tracker);
         return;
     }
 
-    dbgmsg( tracker->key, "addr %p -- connected %d (%zu %zu) -- connecting_at %zu",
+    dbgmsg (tracker->key, "addr %p -- connected %d (%zu %zu) -- connecting_at %zu",
             tracker->addr,
-            (int)(tracker->connection_expiration_time > now), (size_t)tracker->connection_expiration_time, (size_t)now,
-            (size_t)tracker->connecting_at );
+          (int)(tracker->connection_expiration_time > now), (size_t)tracker->connection_expiration_time, (size_t)now,
+          (size_t)tracker->connecting_at);
 
     /* also need a valid connection ID... */
-    if( tracker->addr
-        && ( tracker->connection_expiration_time <= now )
-        && ( !tracker->connecting_at ) )
+    if (tracker->addr
+        && (tracker->connection_expiration_time <= now)
+        && (!tracker->connecting_at))
     {
-        struct evbuffer * buf = evbuffer_new( );
+        struct evbuffer * buf = evbuffer_new ();
         tracker->connecting_at = now;
-        tracker->connection_transaction_id = tau_transaction_new( );
-        dbgmsg( tracker->key, "Trying to connect. Transaction ID is %u",
-                tracker->connection_transaction_id );
-        evbuffer_add_hton_64( buf, 0x41727101980LL );
-        evbuffer_add_hton_32( buf, TAU_ACTION_CONNECT );
-        evbuffer_add_hton_32( buf, tracker->connection_transaction_id );
-        tau_sendto( tracker->session, tracker->addr, tracker->port,
-                    evbuffer_pullup( buf, -1 ),
-                    evbuffer_get_length( buf ) );
-        evbuffer_free( buf );
+        tracker->connection_transaction_id = tau_transaction_new ();
+        dbgmsg (tracker->key, "Trying to connect. Transaction ID is %u",
+                tracker->connection_transaction_id);
+        evbuffer_add_hton_64 (buf, 0x41727101980LL);
+        evbuffer_add_hton_32 (buf, TAU_ACTION_CONNECT);
+        evbuffer_add_hton_32 (buf, tracker->connection_transaction_id);
+        tau_sendto (tracker->session, tracker->addr, tracker->port,
+                    evbuffer_pullup (buf, -1),
+                    evbuffer_get_length (buf));
+        evbuffer_free (buf);
         return;
     }
 
-    tau_tracker_timeout_reqs( tracker );
+    tau_tracker_timeout_reqs (tracker);
 
-    if( ( tracker->addr != NULL ) && ( tracker->connection_expiration_time > now ) )
-        tau_tracker_send_reqs( tracker );
+    if ((tracker->addr != NULL) && (tracker->connection_expiration_time > now))
+        tau_tracker_send_reqs (tracker);
 }
 
 /****
@@ -732,14 +732,14 @@ struct tr_announcer_udp
 };
 
 static struct tr_announcer_udp*
-announcer_udp_get( tr_session * session )
+announcer_udp_get (tr_session * session)
 {
     struct tr_announcer_udp * tau;
 
-    if( session->announcer_udp != NULL )
+    if (session->announcer_udp != NULL)
         return session->announcer_udp;
 
-    tau = tr_new0( struct tr_announcer_udp, 1 );
+    tau = tr_new0 (struct tr_announcer_udp, 1);
     tau->trackers = TR_PTR_ARRAY_INIT;
     tau->session = session;
     session->announcer_udp = tau;
@@ -749,7 +749,7 @@ announcer_udp_get( tr_session * session )
 /* Finds the tau_tracker struct that corresponds to this url.
    If it doesn't exist yet, create one. */
 static struct tau_tracker *
-tau_session_get_tracker( struct tr_announcer_udp * tau, const char * url )
+tau_session_get_tracker (struct tr_announcer_udp * tau, const char * url)
 {
     int i;
     int n;
@@ -759,31 +759,31 @@ tau_session_get_tracker( struct tr_announcer_udp * tau, const char * url )
     struct tau_tracker * tracker = NULL;
 
     /* see if we've already got a tracker that matches this host + port */
-    tr_urlParse( url, -1, NULL, &host, &port, NULL );
-    key = tr_strdup_printf( "%s:%d", host, port );
-    for( i=0, n=tr_ptrArraySize( &tau->trackers ); !tracker && i<n; ++i ) {
-        struct tau_tracker * tmp = tr_ptrArrayNth( &tau->trackers, i );
-        if( !tr_strcmp0( tmp->key, key ) )
+    tr_urlParse (url, -1, NULL, &host, &port, NULL);
+    key = tr_strdup_printf ("%s:%d", host, port);
+    for (i=0, n=tr_ptrArraySize (&tau->trackers); !tracker && i<n; ++i) {
+        struct tau_tracker * tmp = tr_ptrArrayNth (&tau->trackers, i);
+        if (!tr_strcmp0 (tmp->key, key))
             tracker = tmp;
     }
 
     /* if we don't have a match, build a new tracker */
-    if( tracker == NULL )
+    if (tracker == NULL)
     {
-        tracker = tr_new0( struct tau_tracker, 1 );
+        tracker = tr_new0 (struct tau_tracker, 1);
         tracker->session = tau->session;
         tracker->key = key;
         tracker->host = host;
         tracker->port = port;
         tracker->scrapes = TR_PTR_ARRAY_INIT;
         tracker->announces = TR_PTR_ARRAY_INIT;
-        tr_ptrArrayAppend( &tau->trackers, tracker );
-        dbgmsg( tracker->key, "New tau_tracker created" );
+        tr_ptrArrayAppend (&tau->trackers, tracker);
+        dbgmsg (tracker->key, "New tau_tracker created");
     }
     else
     {
-        tr_free( key );
-        tr_free( host );
+        tr_free (key);
+        tr_free (host);
     }
 
     return tracker;
@@ -796,25 +796,25 @@ tau_session_get_tracker( struct tr_announcer_udp * tau, const char * url )
 ****/
 
 void
-tr_tracker_udp_upkeep( tr_session * session )
+tr_tracker_udp_upkeep (tr_session * session)
 {
     struct tr_announcer_udp * tau = session->announcer_udp;
 
-    if( tau != NULL )
-        tr_ptrArrayForeach( &tau->trackers,
-                            (PtrArrayForeachFunc)tau_tracker_upkeep );
+    if (tau != NULL)
+        tr_ptrArrayForeach (&tau->trackers,
+                          (PtrArrayForeachFunc)tau_tracker_upkeep);
 }
 
 bool
-tr_tracker_udp_is_idle( const tr_session * session )
+tr_tracker_udp_is_idle (const tr_session * session)
 {
     int i;
     int n;
     struct tr_announcer_udp * tau = session->announcer_udp;
 
-    if( tau != NULL )
-        for( i=0, n=tr_ptrArraySize(&tau->trackers); i<n; ++i )
-            if( !tau_tracker_is_idle( tr_ptrArrayNth( &tau->trackers, i ) ) )
+    if (tau != NULL)
+        for (i=0, n=tr_ptrArraySize (&tau->trackers); i<n; ++i)
+            if (!tau_tracker_is_idle (tr_ptrArrayNth (&tau->trackers, i)))
                 return false;
 
     return true;
@@ -822,15 +822,15 @@ tr_tracker_udp_is_idle( const tr_session * session )
 
 /* drop dead now. */
 void
-tr_tracker_udp_close( tr_session * session )
+tr_tracker_udp_close (tr_session * session)
 {
     struct tr_announcer_udp * tau = session->announcer_udp;
 
-    if( tau != NULL )
+    if (tau != NULL)
     {
         session->announcer_udp = NULL;
-        tr_ptrArrayDestruct( &tau->trackers, (PtrArrayForeachFunc)tau_tracker_free );
-        tr_free( tau );
+        tr_ptrArrayDestruct (&tau->trackers, (PtrArrayForeachFunc)tau_tracker_free);
+        tr_free (tau);
     }
 }
 
@@ -838,19 +838,19 @@ tr_tracker_udp_close( tr_session * session )
    This doesn't destroy everything if there are requests,
    but sets a deadline on how much longer to wait for the remaining ones */
 void
-tr_tracker_udp_start_shutdown( tr_session * session )
+tr_tracker_udp_start_shutdown (tr_session * session)
 {
-    const time_t now = time( NULL );
+    const time_t now = time (NULL);
     struct tr_announcer_udp * tau = session->announcer_udp;
 
-    if( tau != NULL )
+    if (tau != NULL)
     {
         int i, n;
-        for( i=0, n=tr_ptrArraySize(&tau->trackers); i<n; ++i )
+        for (i=0, n=tr_ptrArraySize (&tau->trackers); i<n; ++i)
         {
-            struct tau_tracker * tracker = tr_ptrArrayNth( &tau->trackers, i );
+            struct tau_tracker * tracker = tr_ptrArrayNth (&tau->trackers, i);
             tracker->close_at = now + 3;
-            tau_tracker_upkeep( tracker );
+            tau_tracker_upkeep (tracker);
         }
     }
 }
@@ -858,7 +858,7 @@ tr_tracker_udp_start_shutdown( tr_session * session )
 /* @brief process an incoming udp message if it's a tracker response.
  * @return true if msg was a tracker response; false otherwise */
 bool
-tau_handle_message( tr_session * session, const uint8_t * msg, size_t msglen )
+tau_handle_message (tr_session * session, const uint8_t * msg, size_t msglen)
 {
     int i;
     int n;
@@ -867,102 +867,102 @@ tau_handle_message( tr_session * session, const uint8_t * msg, size_t msglen )
     tau_transaction_t transaction_id;
     struct evbuffer * buf;
 
-    /*fprintf( stderr, "got an incoming udp message w/len %zu\n", msglen );*/
+    /*fprintf (stderr, "got an incoming udp message w/len %zu\n", msglen);*/
 
-    if( !session || !session->announcer_udp )
+    if (!session || !session->announcer_udp)
         return false;
-    if( msglen < (sizeof(uint32_t)*2) )
+    if (msglen < (sizeof (uint32_t)*2))
         return false;
 
     /* extract the action_id and see if it makes sense */
-    buf = evbuffer_new( );
-    evbuffer_add_reference( buf, msg, msglen, NULL, NULL );
-    action_id = evbuffer_read_ntoh_32( buf );
-    if( !is_tau_response_message( action_id, msglen ) ) {
-        evbuffer_free( buf );
+    buf = evbuffer_new ();
+    evbuffer_add_reference (buf, msg, msglen, NULL, NULL);
+    action_id = evbuffer_read_ntoh_32 (buf);
+    if (!is_tau_response_message (action_id, msglen)) {
+        evbuffer_free (buf);
         return false;
     }
 
     /* extract the transaction_id and look for a match */
     tau = session->announcer_udp;
-    transaction_id = evbuffer_read_ntoh_32( buf );
-    /*fprintf( stderr, "UDP got a transaction_id %u...\n", transaction_id );*/
-    for( i=0, n=tr_ptrArraySize( &tau->trackers ); i<n; ++i )
+    transaction_id = evbuffer_read_ntoh_32 (buf);
+    /*fprintf (stderr, "UDP got a transaction_id %u...\n", transaction_id);*/
+    for (i=0, n=tr_ptrArraySize (&tau->trackers); i<n; ++i)
     {
         int j, jn;
         tr_ptrArray * reqs;
-        struct tau_tracker * tracker = tr_ptrArrayNth( &tau->trackers, i );
+        struct tau_tracker * tracker = tr_ptrArrayNth (&tau->trackers, i);
 
         /* is it a connection response? */
-        if( tracker->connecting_at
-            && ( transaction_id == tracker->connection_transaction_id ) )
+        if (tracker->connecting_at
+            && (transaction_id == tracker->connection_transaction_id))
         {
-            dbgmsg( tracker->key, "%"PRIu32" is my connection request!", transaction_id );
-            on_tracker_connection_response( tracker, action_id, buf );
-            evbuffer_free( buf );
+            dbgmsg (tracker->key, "%"PRIu32" is my connection request!", transaction_id);
+            on_tracker_connection_response (tracker, action_id, buf);
+            evbuffer_free (buf);
             return true;
         }
 
         /* is it a response to one of this tracker's announces? */
         reqs = &tracker->announces;
-        for( j=0, jn=tr_ptrArraySize(reqs); j<jn; ++j ) {
-            struct tau_announce_request * req = tr_ptrArrayNth( reqs, j );
-            if( req->sent_at && ( transaction_id == req->transaction_id ) ) {
-                dbgmsg( tracker->key, "%"PRIu32" is an announce request!", transaction_id );
-                tr_ptrArrayRemove( reqs, j );
-                on_announce_response( req, action_id, buf );
-                tau_announce_request_free( req );
-                evbuffer_free( buf );
+        for (j=0, jn=tr_ptrArraySize (reqs); j<jn; ++j) {
+            struct tau_announce_request * req = tr_ptrArrayNth (reqs, j);
+            if (req->sent_at && (transaction_id == req->transaction_id)) {
+                dbgmsg (tracker->key, "%"PRIu32" is an announce request!", transaction_id);
+                tr_ptrArrayRemove (reqs, j);
+                on_announce_response (req, action_id, buf);
+                tau_announce_request_free (req);
+                evbuffer_free (buf);
                 return true;
             }
         }
 
         /* is it a response to one of this tracker's scrapes? */
         reqs = &tracker->scrapes;
-        for( j=0, jn=tr_ptrArraySize(reqs); j<jn; ++j ) {
-            struct tau_scrape_request * req = tr_ptrArrayNth( reqs, j );
-            if( req->sent_at && ( transaction_id == req->transaction_id ) ) {
-                dbgmsg( tracker->key, "%"PRIu32" is a scrape request!", transaction_id );
-                tr_ptrArrayRemove( reqs, j );
-                on_scrape_response( req, action_id, buf );
-                tau_scrape_request_free( req );
-                evbuffer_free( buf );
+        for (j=0, jn=tr_ptrArraySize (reqs); j<jn; ++j) {
+            struct tau_scrape_request * req = tr_ptrArrayNth (reqs, j);
+            if (req->sent_at && (transaction_id == req->transaction_id)) {
+                dbgmsg (tracker->key, "%"PRIu32" is a scrape request!", transaction_id);
+                tr_ptrArrayRemove (reqs, j);
+                on_scrape_response (req, action_id, buf);
+                tau_scrape_request_free (req);
+                evbuffer_free (buf);
                 return true;
             }
         }
     }
 
     /* no match... */
-    evbuffer_free( buf );
+    evbuffer_free (buf);
     return false;
 }
 
 void
-tr_tracker_udp_announce( tr_session                 * session,
+tr_tracker_udp_announce (tr_session                 * session,
                          const tr_announce_request  * request,
                          tr_announce_response_func    response_func,
-                         void                       * user_data )
+                         void                       * user_data)
 {
-    struct tr_announcer_udp * tau = announcer_udp_get( session );
-    struct tau_tracker * tracker = tau_session_get_tracker( tau, request->url );
-    struct tau_announce_request * r = tau_announce_request_new( request,
+    struct tr_announcer_udp * tau = announcer_udp_get (session);
+    struct tau_tracker * tracker = tau_session_get_tracker (tau, request->url);
+    struct tau_announce_request * r = tau_announce_request_new (request,
                                                                 response_func,
-                                                                user_data );
-    tr_ptrArrayAppend( &tracker->announces, r );
-    tau_tracker_upkeep( tracker );
+                                                                user_data);
+    tr_ptrArrayAppend (&tracker->announces, r);
+    tau_tracker_upkeep (tracker);
 }
 
 void
-tr_tracker_udp_scrape( tr_session               * session,
+tr_tracker_udp_scrape (tr_session               * session,
                        const tr_scrape_request  * request,
                        tr_scrape_response_func    response_func,
-                       void                     * user_data )
+                       void                     * user_data)
 {
-    struct tr_announcer_udp * tau = announcer_udp_get( session );
-    struct tau_tracker * tracker = tau_session_get_tracker( tau, request->url );
-    struct tau_scrape_request * r = tau_scrape_request_new( request,
+    struct tr_announcer_udp * tau = announcer_udp_get (session);
+    struct tau_tracker * tracker = tau_session_get_tracker (tau, request->url);
+    struct tau_scrape_request * r = tau_scrape_request_new (request,
                                                             response_func,
-                                                            user_data );
-    tr_ptrArrayAppend( &tracker->scrapes, r );
-    tau_tracker_upkeep( tracker );
+                                                            user_data);
+    tr_ptrArrayAppend (&tracker->scrapes, r);
+    tau_tracker_upkeep (tracker);
 }
diff --git a/libtransmission/announcer.c b/libtransmission/announcer.c
index d9d466a82..5b445be19 100644
--- a/libtransmission/announcer.c
+++ b/libtransmission/announcer.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -13,8 +13,8 @@
 #include <assert.h>
 #include <limits.h> /* INT_MAX */
 #include <stdio.h>
-#include <stdlib.h> /* qsort() */
-#include <string.h> /* strcmp(), memcpy() */
+#include <stdlib.h> /* qsort () */
+#include <string.h> /* strcmp (), memcpy () */
 
 #include <event2/buffer.h>
 #include <event2/event.h> /* evtimer */
@@ -24,8 +24,8 @@
 #include "transmission.h"
 #include "announcer.h"
 #include "announcer-common.h"
-#include "crypto.h" /* tr_cryptoRandInt(), tr_cryptoWeakRandInt() */
-#include "peer-mgr.h" /* tr_peerMgrCompactToPex() */
+#include "crypto.h" /* tr_cryptoRandInt (), tr_cryptoWeakRandInt () */
+#include "peer-mgr.h" /* tr_peerMgrCompactToPex () */
 #include "ptrarray.h"
 #include "session.h"
 #include "torrent.h"
@@ -33,26 +33,26 @@
 
 struct tr_tier;
 
-static void tier_build_log_name( const struct tr_tier * tier,
-                                 char * buf, size_t buflen );
+static void tier_build_log_name (const struct tr_tier * tier,
+                                 char * buf, size_t buflen);
 
-#define dbgmsg( tier, ... ) \
-if( tr_deepLoggingIsActive( ) ) do { \
+#define dbgmsg(tier, ...) \
+if (tr_deepLoggingIsActive ()) do { \
   char name[128]; \
-  tier_build_log_name( tier, name, sizeof( name ) ); \
-  tr_deepLog( __FILE__, __LINE__, name, __VA_ARGS__ ); \
-} while( 0 )
+  tier_build_log_name (tier, name, sizeof (name)); \
+  tr_deepLog (__FILE__, __LINE__, name, __VA_ARGS__); \
+} while (0)
 
 enum
 {
     /* unless the tracker says otherwise, rescrape this frequently */
-    DEFAULT_SCRAPE_INTERVAL_SEC = ( 60 * 30 ),
+    DEFAULT_SCRAPE_INTERVAL_SEC = (60 * 30),
 
     /* unless the tracker says otherwise, this is the announce interval */
-    DEFAULT_ANNOUNCE_INTERVAL_SEC = ( 60 * 10 ),
+    DEFAULT_ANNOUNCE_INTERVAL_SEC = (60 * 10),
 
     /* unless the tracker says otherwise, this is the announce min_interval */
-    DEFAULT_ANNOUNCE_MIN_INTERVAL_SEC = ( 60 * 2 ),
+    DEFAULT_ANNOUNCE_MIN_INTERVAL_SEC = (60 * 2),
 
     /* how many web tasks we allow at one time */
     MAX_CONCURRENT_TASKS = 48,
@@ -71,9 +71,9 @@ enum
 ***/
 
 const char*
-tr_announce_event_get_string( tr_announce_event e )
+tr_announce_event_get_string (tr_announce_event e)
 {
-    switch( e )
+    switch (e)
     {
         case TR_ANNOUNCE_EVENT_COMPLETED:  return "completed";
         case TR_ANNOUNCE_EVENT_STARTED:    return "started";
@@ -87,15 +87,15 @@ tr_announce_event_get_string( tr_announce_event e )
 ***/
 
 static int
-compareTransfer( uint64_t a_uploaded, uint64_t a_downloaded,
-                 uint64_t b_uploaded, uint64_t b_downloaded )
+compareTransfer (uint64_t a_uploaded, uint64_t a_downloaded,
+                 uint64_t b_uploaded, uint64_t b_downloaded)
 {
     /* higher upload count goes first */
-    if( a_uploaded != b_uploaded )
+    if (a_uploaded != b_uploaded)
         return a_uploaded > b_uploaded ? -1 : 1;
 
     /* then higher download count goes first */
-    if( a_downloaded != b_downloaded )
+    if (a_downloaded != b_downloaded)
         return a_downloaded > b_downloaded ? -1 : 1;
 
     return 0;
@@ -109,22 +109,22 @@ compareTransfer( uint64_t a_uploaded, uint64_t a_downloaded,
  * used to satisfy the uniqueness requirement of a sorted tr_ptrArray.
  */
 static int
-compareStops( const void * va, const void * vb )
+compareStops (const void * va, const void * vb)
 {
     int i;
     const tr_announce_request * a = va;
     const tr_announce_request * b = vb;
 
     /* primary key: volume of data transferred. */
-    if(( i = compareTransfer( a->up, a->down, b->up, b->down)))
+    if ((i = compareTransfer (a->up, a->down, b->up, b->down)))
         return i;
 
     /* secondary key: the torrent's info_hash */
-    if(( i = memcmp( a->info_hash, b->info_hash, SHA_DIGEST_LENGTH )))
+    if ((i = memcmp (a->info_hash, b->info_hash, SHA_DIGEST_LENGTH)))
         return i;
 
     /* tertiary key: the tracker's announec url */
-    return tr_strcmp0( a->url, b->url );
+    return tr_strcmp0 (a->url, b->url);
 }
 
 /***
@@ -147,50 +147,50 @@ typedef struct tr_announcer
 tr_announcer;
 
 bool
-tr_announcerHasBacklog( const struct tr_announcer * announcer )
+tr_announcerHasBacklog (const struct tr_announcer * announcer)
 {
     return announcer->slotsAvailable < 1;
 }
 
 static void
-onUpkeepTimer( int foo UNUSED, short bar UNUSED, void * vannouncer );
+onUpkeepTimer (int foo UNUSED, short bar UNUSED, void * vannouncer);
 
 void
-tr_announcerInit( tr_session * session )
+tr_announcerInit (tr_session * session)
 {
     tr_announcer * a;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    a = tr_new0( tr_announcer, 1 );
+    a = tr_new0 (tr_announcer, 1);
     a->stops = TR_PTR_ARRAY_INIT;
-    a->key = tr_cryptoRandInt( INT_MAX );
+    a->key = tr_cryptoRandInt (INT_MAX);
     a->session = session;
     a->slotsAvailable = MAX_CONCURRENT_TASKS;
-    a->upkeepTimer = evtimer_new( session->event_base, onUpkeepTimer, a );
-    tr_timerAdd( a->upkeepTimer, UPKEEP_INTERVAL_SECS, 0 );
+    a->upkeepTimer = evtimer_new (session->event_base, onUpkeepTimer, a);
+    tr_timerAdd (a->upkeepTimer, UPKEEP_INTERVAL_SECS, 0);
 
     session->announcer = a;
 }
 
-static void flushCloseMessages( tr_announcer * announcer );
+static void flushCloseMessages (tr_announcer * announcer);
 
 void
-tr_announcerClose( tr_session * session )
+tr_announcerClose (tr_session * session)
 {
     tr_announcer * announcer = session->announcer;
 
-    flushCloseMessages( announcer );
+    flushCloseMessages (announcer);
 
-    tr_tracker_udp_start_shutdown( session );
+    tr_tracker_udp_start_shutdown (session);
 
-    event_free( announcer->upkeepTimer );
+    event_free (announcer->upkeepTimer);
     announcer->upkeepTimer = NULL;
 
-    tr_ptrArrayDestruct( &announcer->stops, NULL );
+    tr_ptrArrayDestruct (&announcer->stops, NULL);
 
     session->announcer = NULL;
-    tr_free( announcer );
+    tr_free (announcer);
 }
 
 /***
@@ -219,28 +219,28 @@ tr_tracker;
 
 /* format: host+':'+ port */
 static char *
-getKey( const char * url )
+getKey (const char * url)
 {
     char * ret;
     char * scheme = NULL;
     char * host = NULL;
     int port = 0;
 
-    tr_urlParse( url, -1, &scheme, &host, &port, NULL );
-    ret = tr_strdup_printf( "%s://%s:%d", (scheme?scheme:"invalid"), (host?host:"invalid"), port );
+    tr_urlParse (url, -1, &scheme, &host, &port, NULL);
+    ret = tr_strdup_printf ("%s://%s:%d", (scheme?scheme:"invalid"), (host?host:"invalid"), port);
 
-    tr_free( host );
-    tr_free( scheme );
+    tr_free (host);
+    tr_free (scheme);
     return ret;
 }
 
 static void
-trackerConstruct( tr_tracker * tracker, const tr_tracker_info * inf )
+trackerConstruct (tr_tracker * tracker, const tr_tracker_info * inf)
 {
-    memset( tracker, 0, sizeof( tr_tracker ) );
-    tracker->key = getKey( inf->announce );
-    tracker->announce = tr_strdup( inf->announce );
-    tracker->scrape = tr_strdup( inf->scrape );
+    memset (tracker, 0, sizeof (tr_tracker));
+    tracker->key = getKey (inf->announce);
+    tracker->announce = tr_strdup (inf->announce);
+    tracker->scrape = tr_strdup (inf->scrape);
     tracker->id = inf->id;
     tracker->seederCount = -1;
     tracker->leecherCount = -1;
@@ -248,12 +248,12 @@ trackerConstruct( tr_tracker * tracker, const tr_tracker_info * inf )
 }
 
 static void
-trackerDestruct( tr_tracker * tracker )
+trackerDestruct (tr_tracker * tracker)
 {
-    tr_free( tracker->tracker_id_str );
-    tr_free( tracker->scrape );
-    tr_free( tracker->announce );
-    tr_free( tracker->key );
+    tr_free (tracker->tracker_id_str);
+    tr_free (tracker->scrape);
+    tr_free (tracker->announce);
+    tr_free (tracker->key);
 }
 
 /***
@@ -313,13 +313,13 @@ typedef struct tr_tier
 tr_tier;
 
 static time_t
-get_next_scrape_time( const tr_session * session, const tr_tier * tier, int interval )
+get_next_scrape_time (const tr_session * session, const tr_tier * tier, int interval)
 {
     time_t ret;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
     /* Maybe don't scrape paused torrents */
-    if( !tier->isRunning && !session->scrapePausedTorrents )
+    if (!tier->isRunning && !session->scrapePausedTorrents)
         ret = 0;
 
     /* Add the interval, and then increment to the nearest 10th second.
@@ -327,7 +327,7 @@ get_next_scrape_time( const tr_session * session, const tr_tier * tier, int inte
      * due at the same time to improve multiscrape. */
     else {
         ret = now + interval;
-        while( ret % 10 )
+        while (ret % 10)
             ++ret;
     }
 
@@ -335,42 +335,42 @@ get_next_scrape_time( const tr_session * session, const tr_tier * tier, int inte
 }
 
 static void
-tierConstruct( tr_tier * tier, tr_torrent * tor )
+tierConstruct (tr_tier * tier, tr_torrent * tor)
 {
     static int nextKey = 1;
 
-    memset( tier, 0, sizeof( tr_tier ) );
+    memset (tier, 0, sizeof (tr_tier));
 
     tier->key = nextKey++;
     tier->currentTrackerIndex = -1;
     tier->scrapeIntervalSec = DEFAULT_SCRAPE_INTERVAL_SEC;
     tier->announceIntervalSec = DEFAULT_ANNOUNCE_INTERVAL_SEC;
     tier->announceMinIntervalSec = DEFAULT_ANNOUNCE_MIN_INTERVAL_SEC;
-    tier->scrapeAt = get_next_scrape_time( tor->session, tier, tr_cryptoWeakRandInt( 180 ) );
+    tier->scrapeAt = get_next_scrape_time (tor->session, tier, tr_cryptoWeakRandInt (180));
     tier->tor = tor;
 }
 
 static void
-tierDestruct( tr_tier * tier )
+tierDestruct (tr_tier * tier)
 {
-    tr_free( tier->announce_events );
+    tr_free (tier->announce_events);
 }
 
 static void
-tier_build_log_name( const tr_tier * tier, char * buf, size_t buflen )
+tier_build_log_name (const tr_tier * tier, char * buf, size_t buflen)
 {
-    tr_snprintf( buf, buflen, "[%s---%s]",
-       ( tier && tier->tor ) ? tr_torrentName( tier->tor ) : "?",
-       ( tier && tier->currentTracker ) ? tier->currentTracker->key : "?" );
+    tr_snprintf (buf, buflen, "[%s---%s]",
+     (tier && tier->tor) ? tr_torrentName (tier->tor) : "?",
+     (tier && tier->currentTracker) ? tier->currentTracker->key : "?");
 }
 
 static void
-tierIncrementTracker( tr_tier * tier )
+tierIncrementTracker (tr_tier * tier)
 {
     /* move our index to the next tracker in the tier */
-    const int i = ( tier->currentTracker == NULL )
+    const int i = (tier->currentTracker == NULL)
                 ? 0
-                : ( tier->currentTrackerIndex + 1 ) % tier->tracker_count;
+                : (tier->currentTrackerIndex + 1) % tier->tracker_count;
     tier->currentTrackerIndex = i;
     tier->currentTracker = &tier->trackers[i];
 
@@ -407,49 +407,49 @@ typedef struct tr_torrent_tiers
 tr_torrent_tiers;
 
 static tr_torrent_tiers*
-tiersNew( void )
+tiersNew (void)
 {
-    return tr_new0( tr_torrent_tiers, 1 );
+    return tr_new0 (tr_torrent_tiers, 1);
 }
 
 static void
-tiersDestruct( tr_torrent_tiers * tt )
+tiersDestruct (tr_torrent_tiers * tt)
 {
     int i;
 
-    for( i=0; i<tt->tracker_count; ++i )
-        trackerDestruct( &tt->trackers[i] );
-    tr_free( tt->trackers );
+    for (i=0; i<tt->tracker_count; ++i)
+        trackerDestruct (&tt->trackers[i]);
+    tr_free (tt->trackers);
 
-    for( i=0; i<tt->tier_count; ++i )
-        tierDestruct( &tt->tiers[i] );
-    tr_free( tt->tiers );
+    for (i=0; i<tt->tier_count; ++i)
+        tierDestruct (&tt->tiers[i]);
+    tr_free (tt->tiers);
 }
 
 static void
-tiersFree( tr_torrent_tiers * tt )
+tiersFree (tr_torrent_tiers * tt)
 {
-    tiersDestruct( tt );
-    tr_free( tt );
+    tiersDestruct (tt);
+    tr_free (tt);
 }
 
 static tr_tier*
-getTier( tr_announcer * announcer, const uint8_t * info_hash, int tierId )
+getTier (tr_announcer * announcer, const uint8_t * info_hash, int tierId)
 {
     tr_tier * tier = NULL;
 
-    if( announcer != NULL )
+    if (announcer != NULL)
     {
         tr_session * session = announcer->session;
-        tr_torrent * tor = tr_torrentFindFromHash( session, info_hash );
+        tr_torrent * tor = tr_torrentFindFromHash (session, info_hash);
 
-        if( tor && tor->tiers )
+        if (tor && tor->tiers)
         {
             int i;
             tr_torrent_tiers * tt = tor->tiers;
 
-            for( i=0; !tier && i<tt->tier_count; ++i )
-                if( tt->tiers[i].key == tierId )
+            for (i=0; !tier && i<tt->tier_count; ++i)
+                if (tt->tiers[i].key == tierId)
                     tier = &tt->tiers[i];
         }
     }
@@ -464,70 +464,70 @@ getTier( tr_announcer * announcer, const uint8_t * info_hash, int tierId )
 static const tr_tracker_event TRACKER_EVENT_INIT = { 0, 0, 0, 0, 0, 0 };
 
 static void
-publishMessage( tr_tier * tier, const char * msg, int type )
+publishMessage (tr_tier * tier, const char * msg, int type)
 {
-    if( tier && tier->tor && tier->tor->tiers && tier->tor->tiers->callback )
+    if (tier && tier->tor && tier->tor->tiers && tier->tor->tiers->callback)
     {
         tr_torrent_tiers * tiers = tier->tor->tiers;
         tr_tracker_event event = TRACKER_EVENT_INIT;
         event.messageType = type;
         event.text = msg;
-        if( tier->currentTracker )
+        if (tier->currentTracker)
             event.tracker = tier->currentTracker->announce;
 
-        tiers->callback( tier->tor, &event, tiers->callbackData );
+        tiers->callback (tier->tor, &event, tiers->callbackData);
     }
 }
 
 static void
-publishErrorClear( tr_tier * tier )
+publishErrorClear (tr_tier * tier)
 {
-    publishMessage( tier, NULL, TR_TRACKER_ERROR_CLEAR );
+    publishMessage (tier, NULL, TR_TRACKER_ERROR_CLEAR);
 }
 
 static void
-publishWarning( tr_tier * tier, const char * msg )
+publishWarning (tr_tier * tier, const char * msg)
 {
-    publishMessage( tier, msg, TR_TRACKER_WARNING );
+    publishMessage (tier, msg, TR_TRACKER_WARNING);
 }
 
 static void
-publishError( tr_tier * tier, const char * msg )
+publishError (tr_tier * tier, const char * msg)
 {
-    publishMessage( tier, msg, TR_TRACKER_ERROR );
+    publishMessage (tier, msg, TR_TRACKER_ERROR);
 }
 
 static int8_t
-getSeedProbability( tr_tier * tier, int seeds, int leechers, int pex_count )
+getSeedProbability (tr_tier * tier, int seeds, int leechers, int pex_count)
 {
     /* special case optimization:
        ocelot omits seeds from peer lists sent to seeds on private trackers.
        so check for that case... */
-    if( ( leechers == pex_count ) && tr_torrentIsPrivate( tier->tor )
-                                  && tr_torrentIsSeed( tier->tor )
-                                  && ( seeds + leechers < NUMWANT ) )
+    if ((leechers == pex_count) && tr_torrentIsPrivate (tier->tor)
+                                  && tr_torrentIsSeed (tier->tor)
+                                  && (seeds + leechers < NUMWANT))
         return 0;
 
-    if( seeds>=0 && leechers>=0 && (seeds+leechers>0) )
-        return (int8_t)((100.0*seeds)/(seeds+leechers));
+    if (seeds>=0 && leechers>=0 && (seeds+leechers>0))
+        return (int8_t)((100.0*seeds)/ (seeds+leechers));
 
     return -1; /* unknown */
 }
 
 static void
-publishPeersPex( tr_tier * tier, int seeds, int leechers,
-                 const tr_pex * pex, int n )
+publishPeersPex (tr_tier * tier, int seeds, int leechers,
+                 const tr_pex * pex, int n)
 {
-    if( tier->tor->tiers->callback )
+    if (tier->tor->tiers->callback)
     {
         tr_tracker_event e = TRACKER_EVENT_INIT;
         e.messageType = TR_TRACKER_PEERS;
-        e.seedProbability = getSeedProbability( tier, seeds, leechers, n );
+        e.seedProbability = getSeedProbability (tier, seeds, leechers, n);
         e.pex = pex;
         e.pexCount = n;
-        dbgmsg( tier, "got %d peers; seed prob %d", n, (int)e.seedProbability );
+        dbgmsg (tier, "got %d peers; seed prob %d", n, (int)e.seedProbability);
 
-        tier->tor->tiers->callback( tier->tor, &e, NULL );
+        tier->tor->tiers->callback (tier->tor, &e, NULL);
     }
 }
 
@@ -549,53 +549,53 @@ struct ann_tracker_info
 /* primary key: tier
  * secondary key: udp comes before http */
 static int
-filter_trackers_compare_func( const void * va, const void * vb )
+filter_trackers_compare_func (const void * va, const void * vb)
 {
     const struct ann_tracker_info * a = va;
     const struct ann_tracker_info * b = vb;
-    if( a->info.tier != b->info.tier )
+    if (a->info.tier != b->info.tier)
         return a->info.tier - b->info.tier;
-    return -strcmp( a->scheme, b->scheme );
+    return -strcmp (a->scheme, b->scheme);
 }
 
 /**
  * Massages the incoming list of trackers into something we can use.
  */
 static tr_tracker_info *
-filter_trackers( tr_tracker_info * input, int input_count, int * setme_count )
+filter_trackers (tr_tracker_info * input, int input_count, int * setme_count)
 {
     int i, in;
     int j, jn;
     int n = 0;
     struct tr_tracker_info * ret;
-    struct ann_tracker_info * tmp = tr_new0( struct ann_tracker_info, input_count );
+    struct ann_tracker_info * tmp = tr_new0 (struct ann_tracker_info, input_count);
 
-    /*for( i=0, in=input_count; i<in; ++i ) fprintf( stderr, "IN: [%d][%s]\n", input[i].tier, input[i].announce );*/
+    /*for (i=0, in=input_count; i<in; ++i) fprintf (stderr, "IN: [%d][%s]\n", input[i].tier, input[i].announce);*/
 
     /* build a list of valid trackers */
-    for( i=0, in=input_count; i<in; ++i ) {
-        if( tr_urlIsValidTracker( input[i].announce ) ) {
+    for (i=0, in=input_count; i<in; ++i) {
+        if (tr_urlIsValidTracker (input[i].announce)) {
             int port;
             char * scheme;
             char * host;
             char * path;
             bool is_duplicate = false;
-            tr_urlParse( input[i].announce, -1, &scheme, &host, &port, &path );
+            tr_urlParse (input[i].announce, -1, &scheme, &host, &port, &path);
 
             /* weed out one common source of duplicates:
              * "http://tracker/announce" +
              * "http://tracker:80/announce"
              */
-            for( j=0, jn=n; !is_duplicate && j<jn; ++j )
+            for (j=0, jn=n; !is_duplicate && j<jn; ++j)
                 is_duplicate = (tmp[j].port==port)
-                            && !strcmp(tmp[j].scheme,scheme)
-                            && !strcmp(tmp[j].host,host)
-                            && !strcmp(tmp[j].path,path);
-
-            if( is_duplicate ) {
-                tr_free( path );
-                tr_free( host );
-                tr_free( scheme );
+                            && !strcmp (tmp[j].scheme,scheme)
+                            && !strcmp (tmp[j].host,host)
+                            && !strcmp (tmp[j].path,path);
+
+            if (is_duplicate) {
+                tr_free (path);
+                tr_free (host);
+                tr_free (scheme);
                 continue;
             }
             tmp[n].info = input[i];
@@ -610,93 +610,93 @@ filter_trackers( tr_tracker_info * input, int input_count, int * setme_count )
     /* if two announce URLs differ only by scheme, put them in the same tier.
      * (note: this can leave gaps in the `tier' values, but since the calling
      * function doesn't care, there's no point in removing the gaps...) */
-    for( i=0, in=n; i<in; ++i )
-        for( j=i+1, jn=n; j<jn; ++j )
-            if( (tmp[i].info.tier!=tmp[j].info.tier)
+    for (i=0, in=n; i<in; ++i)
+        for (j=i+1, jn=n; j<jn; ++j)
+            if ((tmp[i].info.tier!=tmp[j].info.tier)
                        && (tmp[i].port==tmp[j].port)
-                       && !tr_strcmp0(tmp[i].host,tmp[j].host)
-                       && !tr_strcmp0(tmp[i].path,tmp[j].path) )
+                       && !tr_strcmp0 (tmp[i].host,tmp[j].host)
+                       && !tr_strcmp0 (tmp[i].path,tmp[j].path))
                 tmp[j].info.tier = tmp[i].info.tier;
 
     /* sort them, for two reasons:
      * (1) unjumble the tiers from the previous step
      * (2) move the UDP trackers to the front of each tier */
-    qsort( tmp, n, sizeof(struct ann_tracker_info), filter_trackers_compare_func );
+    qsort (tmp, n, sizeof (struct ann_tracker_info), filter_trackers_compare_func);
 
     /* build the output */
     *setme_count = n;
-    ret = tr_new0( tr_tracker_info, n );
-    for( i=0, in=n; i<in; ++i )
+    ret = tr_new0 (tr_tracker_info, n);
+    for (i=0, in=n; i<in; ++i)
         ret[i] = tmp[i].info;
 
     /* cleanup */
-    for( i=0, in=n; i<in; ++i ) {
-        tr_free( tmp[i].path );
-        tr_free( tmp[i].host );
-        tr_free( tmp[i].scheme );
+    for (i=0, in=n; i<in; ++i) {
+        tr_free (tmp[i].path);
+        tr_free (tmp[i].host);
+        tr_free (tmp[i].scheme);
     }
-    tr_free( tmp );
+    tr_free (tmp);
 
-    /*for( i=0, in=n; i<in; ++i ) fprintf( stderr, "OUT: [%d][%s]\n", ret[i].tier, ret[i].announce );*/
+    /*for (i=0, in=n; i<in; ++i) fprintf (stderr, "OUT: [%d][%s]\n", ret[i].tier, ret[i].announce);*/
     return ret;
 }
 
 
 static void
-addTorrentToTier( tr_torrent_tiers * tt, tr_torrent * tor )
+addTorrentToTier (tr_torrent_tiers * tt, tr_torrent * tor)
 {
     int i, n;
     int tier_count;
     tr_tier * tier;
-    tr_tracker_info * infos = filter_trackers( tor->info.trackers,
-                                               tor->info.trackerCount, &n );
+    tr_tracker_info * infos = filter_trackers (tor->info.trackers,
+                                               tor->info.trackerCount, &n);
 
     /* build the array of trackers */
-    tt->trackers = tr_new0( tr_tracker, n );
+    tt->trackers = tr_new0 (tr_tracker, n);
     tt->tracker_count = n;
-    for( i=0; i<n; ++i )
-        trackerConstruct( &tt->trackers[i], &infos[i] );
+    for (i=0; i<n; ++i)
+        trackerConstruct (&tt->trackers[i], &infos[i]);
 
     /* count how many tiers there are */
     tier_count = 0;
-    for( i=0; i<n; ++i )
-        if( !i || ( infos[i].tier != infos[i-1].tier ) )
+    for (i=0; i<n; ++i)
+        if (!i || (infos[i].tier != infos[i-1].tier))
             ++tier_count;
 
     /* build the array of tiers */
     tier = NULL;
-    tt->tiers = tr_new0( tr_tier, tier_count );
+    tt->tiers = tr_new0 (tr_tier, tier_count);
     tt->tier_count = 0;
-    for( i=0; i<n; ++i ) {
-        if( i && ( infos[i].tier == infos[i-1].tier ) )
+    for (i=0; i<n; ++i) {
+        if (i && (infos[i].tier == infos[i-1].tier))
             ++tier->tracker_count;
         else {
             tier = &tt->tiers[tt->tier_count++];
-            tierConstruct( tier, tor );
+            tierConstruct (tier, tor);
             tier->trackers = &tt->trackers[i];
             tier->tracker_count = 1;
-            tierIncrementTracker( tier );
+            tierIncrementTracker (tier);
         }
     }
 
     /* cleanup */
-    tr_free( infos );
+    tr_free (infos);
 }
 
 tr_torrent_tiers *
-tr_announcerAddTorrent( tr_torrent           * tor,
+tr_announcerAddTorrent (tr_torrent           * tor,
                         tr_tracker_callback  * callback,
-                        void                 * callbackData )
+                        void                 * callbackData)
 {
     tr_torrent_tiers * tiers;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tiers = tiersNew( );
+    tiers = tiersNew ();
     tiers->callback = callback;
     tiers->callbackData = callbackData;
 
-    addTorrentToTier( tiers, tor );
+    addTorrentToTier (tiers, tor);
 
     return tiers;
 }
@@ -706,174 +706,174 @@ tr_announcerAddTorrent( tr_torrent           * tor,
 ***/
 
 static bool
-tierCanManualAnnounce( const tr_tier * tier )
+tierCanManualAnnounce (const tr_tier * tier)
 {
-    return tier->manualAnnounceAllowedAt <= tr_time( );
+    return tier->manualAnnounceAllowedAt <= tr_time ();
 }
 
 bool
-tr_announcerCanManualAnnounce( const tr_torrent * tor )
+tr_announcerCanManualAnnounce (const tr_torrent * tor)
 {
     int i;
     struct tr_torrent_tiers * tt = NULL;
 
-    assert( tr_isTorrent( tor ) );
-    assert( tor->tiers != NULL );
+    assert (tr_isTorrent (tor));
+    assert (tor->tiers != NULL);
 
-    if( tor->isRunning )
+    if (tor->isRunning)
         tt = tor->tiers;
 
     /* return true if any tier can manual announce */
-    for( i=0; tt && i<tt->tier_count; ++i )
-        if( tierCanManualAnnounce( &tt->tiers[i] ) )
+    for (i=0; tt && i<tt->tier_count; ++i)
+        if (tierCanManualAnnounce (&tt->tiers[i]))
             return true;
 
     return false;
 }
 
 time_t
-tr_announcerNextManualAnnounce( const tr_torrent * tor )
+tr_announcerNextManualAnnounce (const tr_torrent * tor)
 {
     int i;
-    time_t ret = ~(time_t)0;
+    time_t ret = ~ (time_t)0;
     struct tr_torrent_tiers * tt = tor->tiers;
 
     /* find the earliest manual announce time from all peers */
-    for( i=0; tt && i<tt->tier_count; ++i )
-        if( tt->tiers[i].isRunning )
-            ret = MIN( ret, tt->tiers[i].manualAnnounceAllowedAt );
+    for (i=0; tt && i<tt->tier_count; ++i)
+        if (tt->tiers[i].isRunning)
+            ret = MIN (ret, tt->tiers[i].manualAnnounceAllowedAt);
 
     return ret;
 }
 
 static void
-dbgmsg_tier_announce_queue( const tr_tier * tier )
+dbgmsg_tier_announce_queue (const tr_tier * tier)
 {
-    if( tr_deepLoggingIsActive( ) )
+    if (tr_deepLoggingIsActive ())
     {
         int i;
         char name[128];
         char * message;
-        struct evbuffer * buf = evbuffer_new( );
+        struct evbuffer * buf = evbuffer_new ();
 
-        tier_build_log_name( tier, name, sizeof( name ) );
-        for( i=0; i<tier->announce_event_count; ++i )
+        tier_build_log_name (tier, name, sizeof (name));
+        for (i=0; i<tier->announce_event_count; ++i)
         {
             const tr_announce_event e = tier->announce_events[i];
-            const char * str = tr_announce_event_get_string( e );
-            evbuffer_add_printf( buf, "[%d:%s]", i, str );
+            const char * str = tr_announce_event_get_string (e);
+            evbuffer_add_printf (buf, "[%d:%s]", i, str);
         }
 
-        message = evbuffer_free_to_str( buf );
-        tr_deepLog( __FILE__, __LINE__, name, "announce queue is %s", message );
-        tr_free( message );
+        message = evbuffer_free_to_str (buf);
+        tr_deepLog (__FILE__, __LINE__, name, "announce queue is %s", message);
+        tr_free (message);
     }
 }
 
 static void
-tier_announce_remove_trailing( tr_tier * tier, tr_announce_event e )
+tier_announce_remove_trailing (tr_tier * tier, tr_announce_event e)
 {
-    while( ( tier->announce_event_count > 0 )
-        && ( tier->announce_events[tier->announce_event_count-1] == e ) )
+    while ((tier->announce_event_count > 0)
+        && (tier->announce_events[tier->announce_event_count-1] == e))
         --tier->announce_event_count;
 }
 
 static void
-tier_announce_event_push( tr_tier            * tier,
+tier_announce_event_push (tr_tier            * tier,
                           tr_announce_event    e,
-                          time_t               announceAt )
+                          time_t               announceAt)
 {
     int i;
 
-    assert( tier != NULL );
+    assert (tier != NULL);
 
-    dbgmsg_tier_announce_queue( tier );
-    dbgmsg( tier, "queued \"%s\"", tr_announce_event_get_string( e ) );
+    dbgmsg_tier_announce_queue (tier);
+    dbgmsg (tier, "queued \"%s\"", tr_announce_event_get_string (e));
 
-    if( tier->announce_event_count > 0 )
+    if (tier->announce_event_count > 0)
     {
         /* special case #1: if we're adding a "stopped" event,
          * dump everything leading up to it except "completed" */
-        if( e == TR_ANNOUNCE_EVENT_STOPPED ) {
+        if (e == TR_ANNOUNCE_EVENT_STOPPED) {
             bool has_completed = false;
             const tr_announce_event c = TR_ANNOUNCE_EVENT_COMPLETED;
-            for( i=0; !has_completed && i<tier->announce_event_count; ++i )
+            for (i=0; !has_completed && i<tier->announce_event_count; ++i)
                 has_completed = c == tier->announce_events[i];
             tier->announce_event_count = 0;
-            if( has_completed )
+            if (has_completed)
                 tier->announce_events[tier->announce_event_count++] = c;
         }
 
         /* special case #2: dump all empty strings leading up to this event */
-        tier_announce_remove_trailing( tier, TR_ANNOUNCE_EVENT_NONE );
+        tier_announce_remove_trailing (tier, TR_ANNOUNCE_EVENT_NONE);
 
         /* special case #3: no consecutive duplicates */
-        tier_announce_remove_trailing( tier, e );
+        tier_announce_remove_trailing (tier, e);
     }
 
     /* make room in the array for another event */
-    if( tier->announce_event_alloc <= tier->announce_event_count ) {
+    if (tier->announce_event_alloc <= tier->announce_event_count) {
         tier->announce_event_alloc += 4;
-        tier->announce_events = tr_renew( tr_announce_event,
+        tier->announce_events = tr_renew (tr_announce_event,
                                           tier->announce_events,
-                                          tier->announce_event_alloc );
+                                          tier->announce_event_alloc);
     }
 
     /* add it */
     tier->announce_events[tier->announce_event_count++] = e;
     tier->announceAt = announceAt;
 
-    dbgmsg_tier_announce_queue( tier );
-    dbgmsg( tier, "announcing in %d seconds", (int)difftime(announceAt,tr_time()) );
+    dbgmsg_tier_announce_queue (tier);
+    dbgmsg (tier, "announcing in %d seconds", (int)difftime (announceAt,tr_time ()));
 }
 
 static tr_announce_event
-tier_announce_event_pull( tr_tier * tier )
+tier_announce_event_pull (tr_tier * tier)
 {
     const tr_announce_event e = tier->announce_events[0];
 
-    tr_removeElementFromArray( tier->announce_events,
-                               0, sizeof( tr_announce_event ),
-                               tier->announce_event_count-- );
+    tr_removeElementFromArray (tier->announce_events,
+                               0, sizeof (tr_announce_event),
+                               tier->announce_event_count--);
 
     return e;
 }
 
 static void
-torrentAddAnnounce( tr_torrent * tor, tr_announce_event e, time_t announceAt )
+torrentAddAnnounce (tr_torrent * tor, tr_announce_event e, time_t announceAt)
 {
     int i;
     struct tr_torrent_tiers * tt = tor->tiers;
 
     /* walk through each tier and tell them to announce */
-    for( i=0; i<tt->tier_count; ++i )
-        tier_announce_event_push( &tt->tiers[i], e, announceAt );
+    for (i=0; i<tt->tier_count; ++i)
+        tier_announce_event_push (&tt->tiers[i], e, announceAt);
 }
 
 void
-tr_announcerTorrentStarted( tr_torrent * tor )
+tr_announcerTorrentStarted (tr_torrent * tor)
 {
-    torrentAddAnnounce( tor, TR_ANNOUNCE_EVENT_STARTED, tr_time( ) );
+    torrentAddAnnounce (tor, TR_ANNOUNCE_EVENT_STARTED, tr_time ());
 }
 void
-tr_announcerManualAnnounce( tr_torrent * tor )
+tr_announcerManualAnnounce (tr_torrent * tor)
 {
-    torrentAddAnnounce( tor, TR_ANNOUNCE_EVENT_NONE, tr_time( ) );
+    torrentAddAnnounce (tor, TR_ANNOUNCE_EVENT_NONE, tr_time ());
 }
 void
-tr_announcerTorrentStopped( tr_torrent * tor )
+tr_announcerTorrentStopped (tr_torrent * tor)
 {
-    torrentAddAnnounce( tor, TR_ANNOUNCE_EVENT_STOPPED, tr_time( ) );
+    torrentAddAnnounce (tor, TR_ANNOUNCE_EVENT_STOPPED, tr_time ());
 }
 void
-tr_announcerTorrentCompleted( tr_torrent * tor )
+tr_announcerTorrentCompleted (tr_torrent * tor)
 {
-    torrentAddAnnounce( tor, TR_ANNOUNCE_EVENT_COMPLETED, tr_time( ) );
+    torrentAddAnnounce (tor, TR_ANNOUNCE_EVENT_COMPLETED, tr_time ());
 }
 void
-tr_announcerChangeMyPort( tr_torrent * tor )
+tr_announcerChangeMyPort (tr_torrent * tor)
 {
-    tr_announcerTorrentStarted( tor );
+    tr_announcerTorrentStarted (tor);
 }
 
 /***
@@ -881,15 +881,15 @@ tr_announcerChangeMyPort( tr_torrent * tor )
 ***/
 
 void
-tr_announcerAddBytes( tr_torrent * tor, int type, uint32_t byteCount )
+tr_announcerAddBytes (tr_torrent * tor, int type, uint32_t byteCount)
 {
     int i;
     struct tr_torrent_tiers * tt = tor->tiers;
 
-    assert( tr_isTorrent( tor ) );
-    assert( type==TR_ANN_UP || type==TR_ANN_DOWN || type==TR_ANN_CORRUPT );
+    assert (tr_isTorrent (tor));
+    assert (type==TR_ANN_UP || type==TR_ANN_DOWN || type==TR_ANN_CORRUPT);
 
-    for( i=0; i<tt->tier_count; ++i )
+    for (i=0; i<tt->tier_count; ++i)
         tt->tiers[i].byteCounts[ type ] += byteCount;
 }
 
@@ -898,67 +898,67 @@ tr_announcerAddBytes( tr_torrent * tor, int type, uint32_t byteCount )
 ***/
 
 static tr_announce_request *
-announce_request_new( const tr_announcer  * announcer,
+announce_request_new (const tr_announcer  * announcer,
                       const tr_torrent    * tor,
                       const tr_tier       * tier,
-                      tr_announce_event     event )
-{
-    tr_announce_request * req = tr_new0( tr_announce_request, 1 );
-    req->port = tr_sessionGetPublicPeerPort( announcer->session );
-    req->url = tr_strdup( tier->currentTracker->announce );
-    req->tracker_id_str = tr_strdup( tier->currentTracker->tracker_id_str );
-    memcpy( req->info_hash, tor->info.hash, SHA_DIGEST_LENGTH );
-    memcpy( req->peer_id, tor->peer_id, PEER_ID_LEN );
+                      tr_announce_event     event)
+{
+    tr_announce_request * req = tr_new0 (tr_announce_request, 1);
+    req->port = tr_sessionGetPublicPeerPort (announcer->session);
+    req->url = tr_strdup (tier->currentTracker->announce);
+    req->tracker_id_str = tr_strdup (tier->currentTracker->tracker_id_str);
+    memcpy (req->info_hash, tor->info.hash, SHA_DIGEST_LENGTH);
+    memcpy (req->peer_id, tor->peer_id, PEER_ID_LEN);
     req->up = tier->byteCounts[TR_ANN_UP];
     req->down = tier->byteCounts[TR_ANN_DOWN];
     req->corrupt = tier->byteCounts[TR_ANN_CORRUPT];
-    req->leftUntilComplete = tr_torrentHasMetadata( tor )
-            ? tor->info.totalSize - tr_cpHaveTotal( &tor->completion )
-            : ~(uint64_t)0;
+    req->leftUntilComplete = tr_torrentHasMetadata (tor)
+            ? tor->info.totalSize - tr_cpHaveTotal (&tor->completion)
+            : ~ (uint64_t)0;
     req->event = event;
     req->numwant = event == TR_ANNOUNCE_EVENT_STOPPED ? 0 : NUMWANT;
     req->key = announcer->key;
-    req->partial_seed = tr_cpGetStatus( &tor->completion ) == TR_PARTIAL_SEED;
-    tier_build_log_name( tier, req->log_name, sizeof( req->log_name ) );
+    req->partial_seed = tr_cpGetStatus (&tor->completion) == TR_PARTIAL_SEED;
+    tier_build_log_name (tier, req->log_name, sizeof (req->log_name));
     return req;
 }
 
-static void announce_request_free( tr_announce_request * req );
+static void announce_request_free (tr_announce_request * req);
 
 void
-tr_announcerRemoveTorrent( tr_announcer * announcer, tr_torrent * tor )
+tr_announcerRemoveTorrent (tr_announcer * announcer, tr_torrent * tor)
 {
     struct tr_torrent_tiers * tt = tor->tiers;
 
-    if( tt != NULL )
+    if (tt != NULL)
     {
         int i;
-        for( i=0; i<tt->tier_count; ++i )
+        for (i=0; i<tt->tier_count; ++i)
         {
             tr_tier * tier = &tt->tiers[i];
-            if( tier->isRunning )
+            if (tier->isRunning)
             {
                 const tr_announce_event e = TR_ANNOUNCE_EVENT_STOPPED;
-                tr_announce_request * req = announce_request_new( announcer, tor, tier, e );
+                tr_announce_request * req = announce_request_new (announcer, tor, tier, e);
 
-                if( tr_ptrArrayFindSorted( &announcer->stops, req, compareStops ) != NULL )
-                    announce_request_free( req );
+                if (tr_ptrArrayFindSorted (&announcer->stops, req, compareStops) != NULL)
+                    announce_request_free (req);
                 else
-                    tr_ptrArrayInsertSorted( &announcer->stops, req, compareStops );
+                    tr_ptrArrayInsertSorted (&announcer->stops, req, compareStops);
             }
         }
 
-        tiersFree( tor->tiers );
+        tiersFree (tor->tiers);
         tor->tiers = NULL;
     }
 }
 
 static int
-getRetryInterval( const tr_tracker * t )
+getRetryInterval (const tr_tracker * t)
 {
     int minutes;
-    const unsigned int jitter_seconds = tr_cryptoWeakRandInt( 60 );
-    switch( t->consecutiveFailures ) {
+    const unsigned int jitter_seconds = tr_cryptoWeakRandInt (60);
+    switch (t->consecutiveFailures) {
         case 0:  minutes =   1; break;
         case 1:  minutes =   5; break;
         case 2:  minutes =  15; break;
@@ -966,7 +966,7 @@ getRetryInterval( const tr_tracker * t )
         case 4:  minutes =  60; break;
         default: minutes = 120; break;
     }
-    return ( minutes * 60 ) + jitter_seconds;
+    return (minutes * 60) + jitter_seconds;
 }
 
 struct announce_data
@@ -981,47 +981,47 @@ struct announce_data
 };
 
 static void
-on_announce_error( tr_tier * tier, const char * err, tr_announce_event e )
+on_announce_error (tr_tier * tier, const char * err, tr_announce_event e)
 {
     int interval;
 
     /* increment the error count */
-    if( tier->currentTracker != NULL )
+    if (tier->currentTracker != NULL)
         ++tier->currentTracker->consecutiveFailures;
 
     /* set the error message */
-    dbgmsg( tier, "%s", err );
-    tr_torinf( tier->tor, "%s", err );
-    tr_strlcpy( tier->lastAnnounceStr, err, sizeof( tier->lastAnnounceStr ) );
+    dbgmsg (tier, "%s", err);
+    tr_torinf (tier->tor, "%s", err);
+    tr_strlcpy (tier->lastAnnounceStr, err, sizeof (tier->lastAnnounceStr));
 
     /* switch to the next tracker */
-    tierIncrementTracker( tier );
+    tierIncrementTracker (tier);
 
     /* schedule a reannounce */
-    interval = getRetryInterval( tier->currentTracker );
-    dbgmsg( tier, "Retrying announce in %d seconds.", interval );
-    tr_torinf( tier->tor, "Retrying announce in %d seconds.", interval );
-    tier_announce_event_push( tier, e, tr_time( ) + interval );
+    interval = getRetryInterval (tier->currentTracker);
+    dbgmsg (tier, "Retrying announce in %d seconds.", interval);
+    tr_torinf (tier->tor, "Retrying announce in %d seconds.", interval);
+    tier_announce_event_push (tier, e, tr_time () + interval);
 }
 
 static void
-on_announce_done( const tr_announce_response  * response,
-                  void                        * vdata )
+on_announce_done (const tr_announce_response  * response,
+                  void                        * vdata)
 {
     struct announce_data * data = vdata;
     tr_announcer * announcer = data->session->announcer;
-    tr_tier * tier = getTier( announcer, response->info_hash, data->tierId );
-    const time_t now = tr_time( );
+    tr_tier * tier = getTier (announcer, response->info_hash, data->tierId);
+    const time_t now = tr_time ();
     const tr_announce_event event = data->event;
 
-    if( announcer )
+    if (announcer)
         ++announcer->slotsAvailable;
 
-    if( tier != NULL )
+    if (tier != NULL)
     {
         tr_tracker * tracker;
 
-        dbgmsg( tier, "Got announce response: "
+        dbgmsg (tier, "Got announce response: "
                       "connected:%d "
                       "timeout:%d "
                       "seeders:%d "
@@ -1034,8 +1034,8 @@ on_announce_done( const tr_announce_response  * response,
                       "pex6:%zu "
                       "err:%s "
                       "warn:%s",
-                      (int)response->did_connect,
-                      (int)response->did_timeout,
+                    (int)response->did_connect,
+                    (int)response->did_timeout,
                       response->seeders,
                       response->leechers,
                       response->downloads,
@@ -1045,7 +1045,7 @@ on_announce_done( const tr_announce_response  * response,
                       response->pex_count,
                       response->pex6_count,
                       response->errmsg ? response->errmsg : "none",
-                      response->warning ? response->warning : "none" );
+                      response->warning ? response->warning : "none");
 
         tier->lastAnnounceTime = now;
         tier->lastAnnounceTimedOut = response->did_timeout;
@@ -1053,24 +1053,24 @@ on_announce_done( const tr_announce_response  * response,
         tier->isAnnouncing = false;
         tier->manualAnnounceAllowedAt = now + tier->announceMinIntervalSec;
 
-        if( !response->did_connect )
+        if (!response->did_connect)
         {
-            on_announce_error( tier, _( "Could not connect to tracker" ), event );
+            on_announce_error (tier, _ ("Could not connect to tracker"), event);
         }
-        else if( response->did_timeout )
+        else if (response->did_timeout)
         {
-            on_announce_error( tier, _( "Tracker did not respond" ), event );
+            on_announce_error (tier, _ ("Tracker did not respond"), event);
         }
-        else if( response->errmsg )
+        else if (response->errmsg)
         {
             /* If the torrent's only tracker returned an error, publish it.
                Don't bother publishing if there are other trackers -- it's
                all too common for people to load up dozens of dead trackers
                in a torrent's metainfo... */
-            if( tier->tor->info.trackerCount < 2 )
-                publishError( tier, response->errmsg );
+            if (tier->tor->info.trackerCount < 2)
+                publishError (tier, response->errmsg);
 
-            on_announce_error( tier, response->errmsg, event );
+            on_announce_error (tier, response->errmsg, event);
         }
         else
         {
@@ -1082,86 +1082,86 @@ on_announce_done( const tr_announce_response  * response,
             int downloads = 0;
             const bool isStopped = event == TR_ANNOUNCE_EVENT_STOPPED;
 
-            publishErrorClear( tier );
+            publishErrorClear (tier);
 
-            if(( tracker = tier->currentTracker ))
+            if ((tracker = tier->currentTracker))
             {
                 tracker->consecutiveFailures = 0;
 
-                if( response->seeders >= 0 )
+                if (response->seeders >= 0)
                 {
                     tracker->seederCount = seeders = response->seeders;
                     ++scrape_fields;
                 }
 
-                if( response->leechers >= 0 )
+                if (response->leechers >= 0)
                 {
                     tracker->leecherCount = leechers = response->leechers;
                     ++scrape_fields;
                 }
-                if( response->downloads >= 0 )
+                if (response->downloads >= 0)
                 {
                     tracker->downloadCount = downloads = response->downloads;
                     ++scrape_fields;
                 }
 
-                if(( str = response->tracker_id_str ))
+                if ((str = response->tracker_id_str))
                 {
-                    tr_free( tracker->tracker_id_str );
-                    tracker->tracker_id_str = tr_strdup( str );
+                    tr_free (tracker->tracker_id_str);
+                    tracker->tracker_id_str = tr_strdup (str);
                 }
             }
 
-            if(( str = response->warning ))
+            if ((str = response->warning))
             {
-                tr_strlcpy( tier->lastAnnounceStr, str,
-                            sizeof( tier->lastAnnounceStr ) );
-                dbgmsg( tier, "tracker gave \"%s\"", str );
-                publishWarning( tier, str );
+                tr_strlcpy (tier->lastAnnounceStr, str,
+                            sizeof (tier->lastAnnounceStr));
+                dbgmsg (tier, "tracker gave \"%s\"", str);
+                publishWarning (tier, str);
             }
             else
             {
-                tr_strlcpy( tier->lastAnnounceStr, _( "Success" ),
-                            sizeof( tier->lastAnnounceStr ) );
+                tr_strlcpy (tier->lastAnnounceStr, _ ("Success"),
+                            sizeof (tier->lastAnnounceStr));
             }
 
-            if(( i = response->min_interval ))
+            if ((i = response->min_interval))
                 tier->announceMinIntervalSec = i;
 
-            if(( i = response->interval ))
+            if ((i = response->interval))
                 tier->announceIntervalSec = i;
 
-            if( response->pex_count > 0 )
-                publishPeersPex( tier, seeders, leechers,
-                                 response->pex, response->pex_count );
+            if (response->pex_count > 0)
+                publishPeersPex (tier, seeders, leechers,
+                                 response->pex, response->pex_count);
 
-            if( response->pex6_count > 0 )
-                publishPeersPex( tier, seeders, leechers,
-                                 response->pex6, response->pex6_count );
+            if (response->pex6_count > 0)
+                publishPeersPex (tier, seeders, leechers,
+                                 response->pex6, response->pex6_count);
 
             tier->isRunning = data->isRunningOnSuccess;
 
             /* if the tracker included scrape fields in its announce response,
                then a separate scrape isn't needed */
-            if( ( scrape_fields >= 3 ) || ( !tracker->scrape && ( scrape_fields >= 1 ) ) )
+            if ((scrape_fields >= 3) || (!tracker->scrape && (scrape_fields >= 1)))
             {
-                tr_tordbg( tier->tor, "Announce response contained scrape info; "
+                tr_tordbg (tier->tor, "Announce response contained scrape info; "
                                       "rescheduling next scrape to %d seconds from now.",
-                                      tier->scrapeIntervalSec );
-                tier->scrapeAt = get_next_scrape_time( announcer->session, tier, tier->scrapeIntervalSec );
+                                      tier->scrapeIntervalSec);
+                tier->scrapeAt = get_next_scrape_time (announcer->session, tier, tier->scrapeIntervalSec);
                 tier->lastScrapeTime = now;
                 tier->lastScrapeSucceeded = true;
             }
-            else if( tier->lastScrapeTime + tier->scrapeIntervalSec <= now )
+            else if (tier->lastScrapeTime + tier->scrapeIntervalSec <= now)
             {
-                tier->scrapeAt = get_next_scrape_time( announcer->session, tier, 0 );
+                tier->scrapeAt = get_next_scrape_time (announcer->session, tier, 0);
             }
 
             tier->lastAnnounceSucceeded = true;
             tier->lastAnnouncePeerCount = response->pex_count
                                         + response->pex6_count;
 
-            if( isStopped )
+            if (isStopped)
             {
                 /* now that we've successfully stopped the torrent,
                  * we can reset the up/down/corrupt count we've kept
@@ -1171,61 +1171,61 @@ on_announce_done( const tr_announce_response  * response,
                 tier->byteCounts[ TR_ANN_CORRUPT ] = 0;
             }
 
-            if( !isStopped && !tier->announce_event_count )
+            if (!isStopped && !tier->announce_event_count)
             {
                 /* the queue is empty, so enqueue a perodic update */
                 i = tier->announceIntervalSec;
-                dbgmsg( tier, "Sending periodic reannounce in %d seconds", i );
-                tier_announce_event_push( tier, TR_ANNOUNCE_EVENT_NONE, now + i );
+                dbgmsg (tier, "Sending periodic reannounce in %d seconds", i);
+                tier_announce_event_push (tier, TR_ANNOUNCE_EVENT_NONE, now + i);
             }
         }
     }
 
-    tr_free( data );
+    tr_free (data);
 }
 
 static void
-announce_request_free( tr_announce_request * req )
+announce_request_free (tr_announce_request * req)
 {
-    tr_free( req->tracker_id_str );
-    tr_free( req->url );
-    tr_free( req );
+    tr_free (req->tracker_id_str);
+    tr_free (req->url);
+    tr_free (req);
 }
 
 static void
-announce_request_delegate( tr_announcer               * announcer,
+announce_request_delegate (tr_announcer               * announcer,
                            tr_announce_request        * request,
                            tr_announce_response_func  * callback,
-                           void                       * callback_data )
+                           void                       * callback_data)
 {
     tr_session * session = announcer->session;
 
-    if( !memcmp( request->url, "http", 4 ) )
-        tr_tracker_http_announce( session, request, callback, callback_data );
-    else if( !memcmp( request->url, "udp://", 6 ) )
-        tr_tracker_udp_announce( session, request, callback, callback_data );
+    if (!memcmp (request->url, "http", 4))
+        tr_tracker_http_announce (session, request, callback, callback_data);
+    else if (!memcmp (request->url, "udp://", 6))
+        tr_tracker_udp_announce (session, request, callback, callback_data);
     else
-        tr_err( "Unsupported url: %s", request->url );
+        tr_err ("Unsupported url: %s", request->url);
 
-    announce_request_free( request );
+    announce_request_free (request);
 }
 
 static void
-tierAnnounce( tr_announcer * announcer, tr_tier * tier )
+tierAnnounce (tr_announcer * announcer, tr_tier * tier)
 {
     tr_announce_event announce_event;
     tr_announce_request * req;
     struct announce_data * data;
     const tr_torrent * tor = tier->tor;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    assert( !tier->isAnnouncing );
-    assert( tier->announce_event_count > 0 );
+    assert (!tier->isAnnouncing);
+    assert (tier->announce_event_count > 0);
 
-    announce_event = tier_announce_event_pull( tier );
-    req = announce_request_new( announcer, tor, tier, announce_event );
+    announce_event = tier_announce_event_pull (tier);
+    req = announce_request_new (announcer, tor, tier, announce_event);
 
-    data = tr_new0( struct announce_data, 1 );
+    data = tr_new0 (struct announce_data, 1);
     data->session = announcer->session;
     data->tierId = tier->key;
     data->isRunningOnSuccess = tor->isRunning;
@@ -1236,7 +1236,7 @@ tierAnnounce( tr_announcer * announcer, tr_tier * tier )
     tier->lastAnnounceStartTime = now;
     --announcer->slotsAvailable;
 
-    announce_request_delegate( announcer, req, on_announce_done, data );
+    announce_request_delegate (announcer, req, on_announce_done, data);
 }
 
 /***
@@ -1246,39 +1246,39 @@ tierAnnounce( tr_announcer * announcer, tr_tier * tier )
 ***/
 
 static void
-on_scrape_error( tr_session * session, tr_tier * tier, const char * errmsg )
+on_scrape_error (tr_session * session, tr_tier * tier, const char * errmsg)
 {
     int interval;
 
     /* increment the error count */
-    if( tier->currentTracker != NULL )
+    if (tier->currentTracker != NULL)
         ++tier->currentTracker->consecutiveFailures;
 
     /* set the error message */
-    dbgmsg( tier, "Scrape error: %s", errmsg );
-    tr_torinf( tier->tor, "Scrape error: %s", errmsg );
-    tr_strlcpy( tier->lastScrapeStr, errmsg, sizeof( tier->lastScrapeStr ) );
+    dbgmsg (tier, "Scrape error: %s", errmsg);
+    tr_torinf (tier->tor, "Scrape error: %s", errmsg);
+    tr_strlcpy (tier->lastScrapeStr, errmsg, sizeof (tier->lastScrapeStr));
 
     /* switch to the next tracker */
-    tierIncrementTracker( tier );
+    tierIncrementTracker (tier);
 
     /* schedule a rescrape */
-    interval = getRetryInterval( tier->currentTracker );
-    dbgmsg( tier, "Retrying scrape in %zu seconds.", (size_t)interval );
-    tr_torinf( tier->tor, "Retrying scrape in %zu seconds.", (size_t)interval );
+    interval = getRetryInterval (tier->currentTracker);
+    dbgmsg (tier, "Retrying scrape in %zu seconds.", (size_t)interval);
+    tr_torinf (tier->tor, "Retrying scrape in %zu seconds.", (size_t)interval);
     tier->lastScrapeSucceeded = false;
-    tier->scrapeAt = get_next_scrape_time( session, tier, interval );
+    tier->scrapeAt = get_next_scrape_time (session, tier, interval);
 }
 
 static tr_tier *
-find_tier( tr_torrent * tor, const char * scrape )
+find_tier (tr_torrent * tor, const char * scrape)
 {
     int i;
     struct tr_torrent_tiers * tt = tor->tiers;
 
-    for( i=0; tt && i<tt->tier_count; ++i ) {
+    for (i=0; tt && i<tt->tier_count; ++i) {
         const tr_tracker * const tracker = tt->tiers[i].currentTracker;
-        if( tracker && !tr_strcmp0( scrape, tracker->scrape ) )
+        if (tracker && !tr_strcmp0 (scrape, tracker->scrape))
             return &tt->tiers[i];
     }
 
@@ -1286,25 +1286,25 @@ find_tier( tr_torrent * tor, const char * scrape )
 }
 
 static void
-on_scrape_done( const tr_scrape_response * response, void * vsession )
+on_scrape_done (const tr_scrape_response * response, void * vsession)
 {
     int i;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
     tr_session * session = vsession;
     tr_announcer * announcer = session->announcer;
 
-    for( i=0; i<response->row_count; ++i )
+    for (i=0; i<response->row_count; ++i)
     {
         const struct tr_scrape_response_row * row = &response->rows[i];
-        tr_torrent * tor = tr_torrentFindFromHash( session, row->info_hash );
+        tr_torrent * tor = tr_torrentFindFromHash (session, row->info_hash);
 
-        if( tor != NULL )
+        if (tor != NULL)
         {
-            tr_tier * tier = find_tier( tor, response->url );
+            tr_tier * tier = find_tier (tor, response->url);
 
-            if( tier != NULL )
+            if (tier != NULL)
             {
-                dbgmsg( tier, "scraped url:%s -- "
+                dbgmsg (tier, "scraped url:%s -- "
                               "did_connect:%d "
                               "did_timeout:%d "
                               "seeders:%d "
@@ -1314,50 +1314,50 @@ on_scrape_done( const tr_scrape_response * response, void * vsession )
                               "min_request_interval:%d "
                               "err:%s ",
                               response->url,
-                              (int)response->did_connect,
-                              (int)response->did_timeout,
+                            (int)response->did_connect,
+                            (int)response->did_timeout,
                               row->seeders,
                               row->leechers,
                               row->downloads,
                               row->downloaders,
                               response->min_request_interval,
-                              response->errmsg ? response->errmsg : "none" );
+                              response->errmsg ? response->errmsg : "none");
 
                 tier->isScraping = false;
                 tier->lastScrapeTime = now;
                 tier->lastScrapeSucceeded = false;
                 tier->lastScrapeTimedOut = response->did_timeout;
 
-                if( !response->did_connect )
+                if (!response->did_connect)
                 {
-                    on_scrape_error( session, tier, _( "Could not connect to tracker" ) );
+                    on_scrape_error (session, tier, _ ("Could not connect to tracker"));
 		}
-                else if( response->did_timeout )
+                else if (response->did_timeout)
                 {
-                    on_scrape_error( session, tier, _( "Tracker did not respond" ) );
+                    on_scrape_error (session, tier, _ ("Tracker did not respond"));
                 }
-                else if( response->errmsg )
+                else if (response->errmsg)
                 {
-                    on_scrape_error( session, tier, response->errmsg );
+                    on_scrape_error (session, tier, response->errmsg);
                 }
                 else
                 {
                     tr_tracker * tracker;
 
                     tier->lastScrapeSucceeded = true;
-                    tier->scrapeIntervalSec = MAX( DEFAULT_SCRAPE_INTERVAL_SEC,
-                                                   response->min_request_interval );
-                    tier->scrapeAt = get_next_scrape_time( session, tier, tier->scrapeIntervalSec );
-                    tr_tordbg( tier->tor, "Scrape successful. Rescraping in %d seconds.",
-                               tier->scrapeIntervalSec );
+                    tier->scrapeIntervalSec = MAX (DEFAULT_SCRAPE_INTERVAL_SEC,
+                                                   response->min_request_interval);
+                    tier->scrapeAt = get_next_scrape_time (session, tier, tier->scrapeIntervalSec);
+                    tr_tordbg (tier->tor, "Scrape successful. Rescraping in %d seconds.",
+                               tier->scrapeIntervalSec);
 
-                    if(( tracker = tier->currentTracker ))
+                    if ((tracker = tier->currentTracker))
                     {
-                        if( row->seeders >= 0 )
+                        if (row->seeders >= 0)
                             tracker->seederCount = row->seeders;
-                        if( row->leechers >= 0 )
+                        if (row->leechers >= 0)
                             tracker->leecherCount = row->leechers;
-                        if( row->downloads >= 0 )
+                        if (row->downloads >= 0)
                             tracker->downloadCount = row->downloads;
                         tracker->downloaderCount = row->downloaders;
                         tracker->consecutiveFailures = 0;
@@ -1367,208 +1367,208 @@ on_scrape_done( const tr_scrape_response * response, void * vsession )
         }
     }
 
-    if( announcer )
+    if (announcer)
         ++announcer->slotsAvailable;
 }
 
 static void
-scrape_request_delegate( tr_announcer             * announcer,
+scrape_request_delegate (tr_announcer             * announcer,
                          const tr_scrape_request  * request,
                          tr_scrape_response_func  * callback,
-                         void                     * callback_data )
+                         void                     * callback_data)
 {
     tr_session * session = announcer->session;
 
-    if( !memcmp( request->url, "http", 4 ) )
-        tr_tracker_http_scrape( session, request, callback, callback_data );
-    else if( !memcmp( request->url, "udp://", 6 ) )
-        tr_tracker_udp_scrape( session, request, callback, callback_data );
+    if (!memcmp (request->url, "http", 4))
+        tr_tracker_http_scrape (session, request, callback, callback_data);
+    else if (!memcmp (request->url, "udp://", 6))
+        tr_tracker_udp_scrape (session, request, callback, callback_data);
     else
-        tr_err( "Unsupported url: %s", request->url );
+        tr_err ("Unsupported url: %s", request->url);
 }
 
 static void
-multiscrape( tr_announcer * announcer, tr_ptrArray * tiers )
+multiscrape (tr_announcer * announcer, tr_ptrArray * tiers)
 {
     int i;
     int request_count = 0;
-    const time_t now = tr_time( );
-    const int tier_count = tr_ptrArraySize( tiers );
-    const int max_request_count = MIN( announcer->slotsAvailable, tier_count );
-    tr_scrape_request * requests = tr_new0( tr_scrape_request, max_request_count );
+    const time_t now = tr_time ();
+    const int tier_count = tr_ptrArraySize (tiers);
+    const int max_request_count = MIN (announcer->slotsAvailable, tier_count);
+    tr_scrape_request * requests = tr_new0 (tr_scrape_request, max_request_count);
 
     /* batch as many info_hashes into a request as we can */
-    for( i=0; i<tier_count; ++i )
+    for (i=0; i<tier_count; ++i)
     {
         int j;
-        tr_tier * tier = tr_ptrArrayNth( tiers, i );
+        tr_tier * tier = tr_ptrArrayNth (tiers, i);
         char * url = tier->currentTracker->scrape;
         const uint8_t * hash = tier->tor->info.hash;
 
         /* if there's a request with this scrape URL and a free slot, use it */
-        for( j=0; j<request_count; ++j )
+        for (j=0; j<request_count; ++j)
         {
             tr_scrape_request * req = &requests[j];
 
-            if( req->info_hash_count >= TR_MULTISCRAPE_MAX )
+            if (req->info_hash_count >= TR_MULTISCRAPE_MAX)
                 continue;
-            if( tr_strcmp0( req->url, url ) )
+            if (tr_strcmp0 (req->url, url))
                 continue;
 
-            memcpy( req->info_hash[req->info_hash_count++], hash, SHA_DIGEST_LENGTH );
+            memcpy (req->info_hash[req->info_hash_count++], hash, SHA_DIGEST_LENGTH);
             tier->isScraping = true;
             tier->lastScrapeStartTime = now;
             break;
         }
 
         /* otherwise, if there's room for another request, build a new one */
-        if( ( j==request_count ) && ( request_count < max_request_count ) )
+        if ((j==request_count) && (request_count < max_request_count))
         {
             tr_scrape_request * req = &requests[request_count++];
             req->url = url;
-            tier_build_log_name( tier, req->log_name, sizeof( req->log_name ) );
+            tier_build_log_name (tier, req->log_name, sizeof (req->log_name));
 
-            memcpy( req->info_hash[req->info_hash_count++], hash, SHA_DIGEST_LENGTH );
+            memcpy (req->info_hash[req->info_hash_count++], hash, SHA_DIGEST_LENGTH);
             tier->isScraping = true;
             tier->lastScrapeStartTime = now;
         }
     }
 
     /* send the requests we just built */
-    for( i=0; i<request_count; ++i )
-        scrape_request_delegate( announcer, &requests[i], on_scrape_done, announcer->session );
+    for (i=0; i<request_count; ++i)
+        scrape_request_delegate (announcer, &requests[i], on_scrape_done, announcer->session);
 
     /* cleanup */
-    tr_free( requests );
+    tr_free (requests);
 }
 
 static void
-flushCloseMessages( tr_announcer * announcer )
+flushCloseMessages (tr_announcer * announcer)
 {
     int i;
-    const int n = tr_ptrArraySize( &announcer->stops );
+    const int n = tr_ptrArraySize (&announcer->stops);
 
-    for( i=0; i<n; ++i )
-        announce_request_delegate( announcer, tr_ptrArrayNth( &announcer->stops, i ), NULL, NULL );
+    for (i=0; i<n; ++i)
+        announce_request_delegate (announcer, tr_ptrArrayNth (&announcer->stops, i), NULL, NULL);
 
-    tr_ptrArrayClear( &announcer->stops );
+    tr_ptrArrayClear (&announcer->stops);
 }
 
 static bool
-tierNeedsToAnnounce( const tr_tier * tier, const time_t now )
+tierNeedsToAnnounce (const tr_tier * tier, const time_t now)
 {
     return !tier->isAnnouncing
         && !tier->isScraping
-        && ( tier->announceAt != 0 )
-        && ( tier->announceAt <= now )
-        && ( tier->announce_event_count > 0 );
+        && (tier->announceAt != 0)
+        && (tier->announceAt <= now)
+        && (tier->announce_event_count > 0);
 }
 
 static bool
-tierNeedsToScrape( const tr_tier * tier, const time_t now )
+tierNeedsToScrape (const tr_tier * tier, const time_t now)
 {
-    return ( !tier->isScraping )
-        && ( tier->scrapeAt != 0 )
-        && ( tier->scrapeAt <= now )
-        && ( tier->currentTracker != NULL )
-        && ( tier->currentTracker->scrape != NULL );
+    return (!tier->isScraping)
+        && (tier->scrapeAt != 0)
+        && (tier->scrapeAt <= now)
+        && (tier->currentTracker != NULL)
+        && (tier->currentTracker->scrape != NULL);
 }
 
 static int
-compareTiers( const void * va, const void * vb )
+compareTiers (const void * va, const void * vb)
 {
     int ret;
-    const tr_tier * a = *(const tr_tier**)va;
-    const tr_tier * b = *(const tr_tier**)vb;
+    const tr_tier * a = * (const tr_tier**)va;
+    const tr_tier * b = * (const tr_tier**)vb;
 
     /* primary key: larger stats come before smaller */
-    ret = compareTransfer( a->byteCounts[TR_ANN_UP], a->byteCounts[TR_ANN_DOWN],
-                           b->byteCounts[TR_ANN_UP], b->byteCounts[TR_ANN_DOWN] );
+    ret = compareTransfer (a->byteCounts[TR_ANN_UP], a->byteCounts[TR_ANN_DOWN],
+                           b->byteCounts[TR_ANN_UP], b->byteCounts[TR_ANN_DOWN]);
 
     /* secondary key: announcements that have been waiting longer go first */
-    if( !ret && ( a->announceAt != b->announceAt ) )
+    if (!ret && (a->announceAt != b->announceAt))
         ret = a->announceAt < b->announceAt ? -1 : 1;
 
     return ret;
 }
 
 static void
-announceMore( tr_announcer * announcer )
+announceMore (tr_announcer * announcer)
 {
     int i;
     int n;
     tr_torrent * tor;
     tr_ptrArray announceMe = TR_PTR_ARRAY_INIT;
     tr_ptrArray scrapeMe = TR_PTR_ARRAY_INIT;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    dbgmsg( NULL, "announceMore: slotsAvailable is %d", announcer->slotsAvailable );
+    dbgmsg (NULL, "announceMore: slotsAvailable is %d", announcer->slotsAvailable);
 
-    if( announcer->slotsAvailable < 1 )
+    if (announcer->slotsAvailable < 1)
         return;
 
     /* build a list of tiers that need to be announced */
     tor = NULL;
-    while(( tor = tr_torrentNext( announcer->session, tor ))) {
+    while ((tor = tr_torrentNext (announcer->session, tor))) {
         struct tr_torrent_tiers * tt = tor->tiers;
-        for( i=0; tt && i<tt->tier_count; ++i ) {
+        for (i=0; tt && i<tt->tier_count; ++i) {
             tr_tier * tier = &tt->tiers[i];
-            if( tierNeedsToAnnounce( tier, now ) )
-                tr_ptrArrayAppend( &announceMe, tier );
-            else if( tierNeedsToScrape( tier, now ) )
-                tr_ptrArrayAppend( &scrapeMe, tier );
+            if (tierNeedsToAnnounce (tier, now))
+                tr_ptrArrayAppend (&announceMe, tier);
+            else if (tierNeedsToScrape (tier, now))
+                tr_ptrArrayAppend (&scrapeMe, tier);
         }
     }
 
     /* if there are more tiers than slots available, prioritize */
-    n = tr_ptrArraySize( &announceMe );
-    if( n > announcer->slotsAvailable )
-        qsort( tr_ptrArrayBase(&announceMe), n, sizeof(tr_tier*), compareTiers );
+    n = tr_ptrArraySize (&announceMe);
+    if (n > announcer->slotsAvailable)
+        qsort (tr_ptrArrayBase (&announceMe), n, sizeof (tr_tier*), compareTiers);
 
     /* announce some */
-    n = MIN( tr_ptrArraySize( &announceMe ), announcer->slotsAvailable );
-    for( i=0; i<n; ++i ) {
-        tr_tier * tier = tr_ptrArrayNth( &announceMe, i );
-        tr_tordbg( tier->tor, "%s", "Announcing to tracker" );
-        dbgmsg( tier, "announcing tier %d of %d", i, n );
-        tierAnnounce( announcer, tier );
+    n = MIN (tr_ptrArraySize (&announceMe), announcer->slotsAvailable);
+    for (i=0; i<n; ++i) {
+        tr_tier * tier = tr_ptrArrayNth (&announceMe, i);
+        tr_tordbg (tier->tor, "%s", "Announcing to tracker");
+        dbgmsg (tier, "announcing tier %d of %d", i, n);
+        tierAnnounce (announcer, tier);
     }
 
     /* scrape some */
-    multiscrape( announcer, &scrapeMe );
+    multiscrape (announcer, &scrapeMe);
 
     /* cleanup */
-    tr_ptrArrayDestruct( &scrapeMe, NULL );
-    tr_ptrArrayDestruct( &announceMe, NULL );
+    tr_ptrArrayDestruct (&scrapeMe, NULL);
+    tr_ptrArrayDestruct (&announceMe, NULL);
 }
 
 static void
-onUpkeepTimer( int foo UNUSED, short bar UNUSED, void * vannouncer )
+onUpkeepTimer (int foo UNUSED, short bar UNUSED, void * vannouncer)
 {
     tr_announcer * announcer = vannouncer;
     tr_session * session = announcer->session;
     const bool is_closing = session->isClosed;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    tr_sessionLock( session );
+    tr_sessionLock (session);
 
     /* maybe send out some "stopped" messages for closed torrents */
-    flushCloseMessages( announcer );
+    flushCloseMessages (announcer);
 
     /* maybe send out some announcements to trackers */
-    if( !is_closing )
-        announceMore( announcer );
+    if (!is_closing)
+        announceMore (announcer);
 
     /* TAU upkeep */
-    if( announcer->tauUpkeepAt <= now ) {
+    if (announcer->tauUpkeepAt <= now) {
         announcer->tauUpkeepAt = now + TAU_UPKEEP_INTERVAL_SECS;
-        tr_tracker_udp_upkeep( session );
+        tr_tracker_udp_upkeep (session);
     }
 
     /* set up the next timer */
-    tr_timerAdd( announcer->upkeepTimer, UPKEEP_INTERVAL_SECS, 0 );
+    tr_timerAdd (announcer->upkeepTimer, UPKEEP_INTERVAL_SECS, 0);
 
-    tr_sessionUnlock( session );
+    tr_sessionUnlock (session);
 }
 
 /***
@@ -1576,41 +1576,41 @@ onUpkeepTimer( int foo UNUSED, short bar UNUSED, void * vannouncer )
 ***/
 
 tr_tracker_stat *
-tr_announcerStats( const tr_torrent * torrent, int * setmeTrackerCount )
+tr_announcerStats (const tr_torrent * torrent, int * setmeTrackerCount)
 {
     int i;
     int out = 0;
     tr_tracker_stat * ret;
     struct tr_torrent_tiers * tt;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    assert( tr_isTorrent( torrent ) );
-    assert( tr_torrentIsLocked( torrent ) );
+    assert (tr_isTorrent (torrent));
+    assert (tr_torrentIsLocked (torrent));
 
     tt = torrent->tiers;
 
     /* alloc the stats */
     *setmeTrackerCount = tt->tracker_count;
-    ret = tr_new0( tr_tracker_stat, tt->tracker_count );
+    ret = tr_new0 (tr_tracker_stat, tt->tracker_count);
 
     /* populate the stats */
-    for( i=0; i<tt->tier_count; ++i )
+    for (i=0; i<tt->tier_count; ++i)
     {
         int j;
         const tr_tier * const tier = &tt->tiers[i];
-        for( j=0; j<tier->tracker_count; ++j )
+        for (j=0; j<tier->tracker_count; ++j)
         {
             const tr_tracker * const tracker = &tier->trackers[j];
             tr_tracker_stat * st = &ret[out++];
 
             st->id = tracker->id;
-            tr_strlcpy( st->host, tracker->key, sizeof( st->host ) );
-            tr_strlcpy( st->announce, tracker->announce, sizeof( st->announce ) );
+            tr_strlcpy (st->host, tracker->key, sizeof (st->host));
+            tr_strlcpy (st->announce, tracker->announce, sizeof (st->announce));
             st->tier = i;
             st->isBackup = tracker != tier->currentTracker;
             st->lastScrapeStartTime = tier->lastScrapeStartTime;
-            if( tracker->scrape )
-                tr_strlcpy( st->scrape, tracker->scrape, sizeof( st->scrape ) );
+            if (tracker->scrape)
+                tr_strlcpy (st->scrape, tracker->scrape, sizeof (st->scrape));
             else
                 st->scrape[0] = '\0';
 
@@ -1618,7 +1618,7 @@ tr_announcerStats( const tr_torrent * torrent, int * setmeTrackerCount )
             st->leecherCount = tracker->leecherCount;
             st->downloadCount = tracker->downloadCount;
 
-            if( st->isBackup )
+            if (st->isBackup)
             {
                 st->scrapeState = TR_TRACKER_INACTIVE;
                 st->announceState = TR_TRACKER_INACTIVE;
@@ -1627,19 +1627,19 @@ tr_announcerStats( const tr_torrent * torrent, int * setmeTrackerCount )
             }
             else
             {
-                if(( st->hasScraped = tier->lastScrapeTime != 0 )) {
+                if ((st->hasScraped = tier->lastScrapeTime != 0)) {
                     st->lastScrapeTime = tier->lastScrapeTime;
                     st->lastScrapeSucceeded = tier->lastScrapeSucceeded;
                     st->lastScrapeTimedOut = tier->lastScrapeTimedOut;
-                    tr_strlcpy( st->lastScrapeResult, tier->lastScrapeStr,
-                                sizeof( st->lastScrapeResult ) );
+                    tr_strlcpy (st->lastScrapeResult, tier->lastScrapeStr,
+                                sizeof (st->lastScrapeResult));
                 }
 
-                if( tier->isScraping )
+                if (tier->isScraping)
                     st->scrapeState = TR_TRACKER_ACTIVE;
-                else if( !tier->scrapeAt )
+                else if (!tier->scrapeAt)
                     st->scrapeState = TR_TRACKER_INACTIVE;
-                else if( tier->scrapeAt > now )
+                else if (tier->scrapeAt > now)
                 {
                     st->scrapeState = TR_TRACKER_WAITING;
                     st->nextScrapeTime = tier->scrapeAt;
@@ -1649,20 +1649,20 @@ tr_announcerStats( const tr_torrent * torrent, int * setmeTrackerCount )
 
                 st->lastAnnounceStartTime = tier->lastAnnounceStartTime;
 
-                if(( st->hasAnnounced = tier->lastAnnounceTime != 0 )) {
+                if ((st->hasAnnounced = tier->lastAnnounceTime != 0)) {
                     st->lastAnnounceTime = tier->lastAnnounceTime;
-                    tr_strlcpy( st->lastAnnounceResult, tier->lastAnnounceStr,
-                                sizeof( st->lastAnnounceResult ) );
+                    tr_strlcpy (st->lastAnnounceResult, tier->lastAnnounceStr,
+                                sizeof (st->lastAnnounceResult));
                     st->lastAnnounceSucceeded = tier->lastAnnounceSucceeded;
                     st->lastAnnounceTimedOut = tier->lastAnnounceTimedOut;
                     st->lastAnnouncePeerCount = tier->lastAnnouncePeerCount;
                 }
 
-                if( tier->isAnnouncing )
+                if (tier->isAnnouncing)
                     st->announceState = TR_TRACKER_ACTIVE;
-                else if( !torrent->isRunning || !tier->announceAt )
+                else if (!torrent->isRunning || !tier->announceAt)
                     st->announceState = TR_TRACKER_INACTIVE;
-                else if( tier->announceAt > now )
+                else if (tier->announceAt > now)
                 {
                     st->announceState = TR_TRACKER_WAITING;
                     st->nextAnnounceTime = tier->announceAt;
@@ -1677,10 +1677,10 @@ tr_announcerStats( const tr_torrent * torrent, int * setmeTrackerCount )
 }
 
 void
-tr_announcerStatsFree( tr_tracker_stat * trackers,
-                       int trackerCount UNUSED )
+tr_announcerStatsFree (tr_tracker_stat * trackers,
+                       int trackerCount UNUSED)
 {
-    tr_free( trackers );
+    tr_free (trackers);
 }
 
 /***
@@ -1688,13 +1688,13 @@ tr_announcerStatsFree( tr_tracker_stat * trackers,
 ***/
 
 static void
-copy_tier_attributes_impl( struct tr_tier * tgt, int trackerIndex, const tr_tier * src )
+copy_tier_attributes_impl (struct tr_tier * tgt, int trackerIndex, const tr_tier * src)
 {
     const tr_tier keep = *tgt;
 
     /* sanity clause */
-    assert( trackerIndex < tgt->tracker_count );
-    assert( !tr_strcmp0( tgt->trackers[trackerIndex].announce, src->currentTracker->announce ) );
+    assert (trackerIndex < tgt->tracker_count);
+    assert (!tr_strcmp0 (tgt->trackers[trackerIndex].announce, src->currentTracker->announce));
 
     /* bitwise copy will handle most of tr_tier's fields... */
     *tgt = *src;
@@ -1703,7 +1703,7 @@ copy_tier_attributes_impl( struct tr_tier * tgt, int trackerIndex, const tr_tier
     tgt->wasCopied = true;
     tgt->trackers = keep.trackers;
     tgt->tracker_count = keep.tracker_count;
-    tgt->announce_events = tr_memdup( src->announce_events, sizeof( tr_announce_event ) * src->announce_event_count );
+    tgt->announce_events = tr_memdup (src->announce_events, sizeof (tr_announce_event) * src->announce_event_count);
     tgt->announce_event_count = src->announce_event_count;
     tgt->announce_event_alloc = src->announce_event_count;
     tgt->currentTrackerIndex = trackerIndex;
@@ -1715,27 +1715,27 @@ copy_tier_attributes_impl( struct tr_tier * tgt, int trackerIndex, const tr_tier
 }
 
 static void
-copy_tier_attributes( struct tr_torrent_tiers * tt, const tr_tier * src )
+copy_tier_attributes (struct tr_torrent_tiers * tt, const tr_tier * src)
 {
     int i, j;
     bool found = false;
 
     /* find a tier (if any) which has a match for src->currentTracker */
-    for( i=0; !found && i<tt->tier_count; ++i )
-        for( j=0; !found && j<tt->tiers[i].tracker_count; ++j )
-            if(( found = !tr_strcmp0( src->currentTracker->announce, tt->tiers[i].trackers[j].announce )))
-                copy_tier_attributes_impl( &tt->tiers[i], j, src );
+    for (i=0; !found && i<tt->tier_count; ++i)
+        for (j=0; !found && j<tt->tiers[i].tracker_count; ++j)
+            if ((found = !tr_strcmp0 (src->currentTracker->announce, tt->tiers[i].trackers[j].announce)))
+                copy_tier_attributes_impl (&tt->tiers[i], j, src);
 }
 
 void
-tr_announcerResetTorrent( tr_announcer * announcer UNUSED, tr_torrent * tor )
+tr_announcerResetTorrent (tr_announcer * announcer UNUSED, tr_torrent * tor)
 {
     int i;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
     struct tr_torrent_tiers * tt = tor->tiers;
     tr_torrent_tiers old = *tt;
 
-    assert( tt != NULL );
+    assert (tt != NULL);
 
     /* remove the old tiers / trackers */
     tt->tiers = NULL;
@@ -1744,19 +1744,19 @@ tr_announcerResetTorrent( tr_announcer * announcer UNUSED, tr_torrent * tor )
     tt->tracker_count = 0;
 
     /* create the new tiers / trackers */
-    addTorrentToTier( tt, tor );
+    addTorrentToTier (tt, tor);
 
     /* copy the old tiers' states into their replacements */
-    for( i=0; i<old.tier_count; ++i )
-        if( old.tiers[i].currentTracker != NULL )
-            copy_tier_attributes( tt, &old.tiers[i] );
+    for (i=0; i<old.tier_count; ++i)
+        if (old.tiers[i].currentTracker != NULL)
+            copy_tier_attributes (tt, &old.tiers[i]);
 
     /* kickstart any tiers that didn't get started */
-    if( tor->isRunning )
-        for( i=0; i<tt->tier_count; ++i )
-            if( !tt->tiers[i].wasCopied )
-                tier_announce_event_push( &tt->tiers[i], TR_ANNOUNCE_EVENT_STARTED, now );
+    if (tor->isRunning)
+        for (i=0; i<tt->tier_count; ++i)
+            if (!tt->tiers[i].wasCopied)
+                tier_announce_event_push (&tt->tiers[i], TR_ANNOUNCE_EVENT_STARTED, now);
 
     /* cleanup */
-    tiersDestruct( &old );
+    tiersDestruct (&old);
 }
diff --git a/libtransmission/announcer.h b/libtransmission/announcer.h
index 3d81072da..c7078d7c4 100644
--- a/libtransmission/announcer.h
+++ b/libtransmission/announcer.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -56,63 +56,63 @@ typedef struct
 }
 tr_tracker_event;
 
-typedef void tr_tracker_callback ( tr_torrent              * tor,
+typedef void tr_tracker_callback (tr_torrent              * tor,
                                    const tr_tracker_event  * event,
-                                   void                    * client_data );
+                                   void                    * client_data);
 
 /**
 ***  Session ctor/dtor
 **/
 
-void tr_announcerInit( tr_session * );
+void tr_announcerInit (tr_session *);
 
-void tr_announcerClose( tr_session * );
+void tr_announcerClose (tr_session *);
 
 /**
 ***  For torrent customers
 **/
 
-struct tr_torrent_tiers * tr_announcerAddTorrent( tr_torrent          * torrent,
+struct tr_torrent_tiers * tr_announcerAddTorrent (tr_torrent          * torrent,
                                                   tr_tracker_callback * cb,
-                                                  void                * cbdata );
+                                                  void                * cbdata);
 
-bool tr_announcerHasBacklog( const struct tr_announcer * );
+bool tr_announcerHasBacklog (const struct tr_announcer *);
 
-void tr_announcerResetTorrent( struct tr_announcer*, tr_torrent* );
+void tr_announcerResetTorrent (struct tr_announcer*, tr_torrent*);
 
-void tr_announcerRemoveTorrent( struct tr_announcer * ,
-                                tr_torrent          * );
+void tr_announcerRemoveTorrent (struct tr_announcer * ,
+                                tr_torrent          *);
 
-void tr_announcerChangeMyPort( tr_torrent * );
+void tr_announcerChangeMyPort (tr_torrent *);
 
-bool tr_announcerCanManualAnnounce( const tr_torrent * );
+bool tr_announcerCanManualAnnounce (const tr_torrent *);
 
-void tr_announcerManualAnnounce( tr_torrent * );
+void tr_announcerManualAnnounce (tr_torrent *);
 
-void tr_announcerTorrentStarted( tr_torrent * );
-void tr_announcerTorrentStopped( tr_torrent * );
-void tr_announcerTorrentCompleted( tr_torrent * );
+void tr_announcerTorrentStarted (tr_torrent *);
+void tr_announcerTorrentStopped (tr_torrent *);
+void tr_announcerTorrentCompleted (tr_torrent *);
 
 enum { TR_ANN_UP, TR_ANN_DOWN, TR_ANN_CORRUPT };
-void tr_announcerAddBytes( tr_torrent *, int up_down_or_corrupt, uint32_t byteCount );
+void tr_announcerAddBytes (tr_torrent *, int up_down_or_corrupt, uint32_t byteCount);
 
-time_t tr_announcerNextManualAnnounce( const tr_torrent * );
+time_t tr_announcerNextManualAnnounce (const tr_torrent *);
 
-tr_tracker_stat * tr_announcerStats( const tr_torrent * torrent,
-                                     int              * setmeTrackerCount );
+tr_tracker_stat * tr_announcerStats (const tr_torrent * torrent,
+                                     int              * setmeTrackerCount);
 
-void tr_announcerStatsFree( tr_tracker_stat * trackers,
-                            int               trackerCount );
+void tr_announcerStatsFree (tr_tracker_stat * trackers,
+                            int               trackerCount);
 
 /***
 ****
 ***/
 
-void tr_tracker_udp_upkeep( tr_session * session );
+void tr_tracker_udp_upkeep (tr_session * session);
 
-void tr_tracker_udp_close( tr_session * session );
+void tr_tracker_udp_close (tr_session * session);
 
-bool tr_tracker_udp_is_idle( const tr_session * session );
+bool tr_tracker_udp_is_idle (const tr_session * session);
 
 
 
diff --git a/libtransmission/bandwidth.c b/libtransmission/bandwidth.c
index 6370aa18b..91ce91e67 100644
--- a/libtransmission/bandwidth.c
+++ b/libtransmission/bandwidth.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -12,49 +12,49 @@
 
 #include <assert.h>
 #include <limits.h>
-#include <string.h> /* memset() */
+#include <string.h> /* memset () */
 
 #include "transmission.h"
 #include "bandwidth.h"
-#include "crypto.h" /* tr_cryptoWeakRandInt() */
+#include "crypto.h" /* tr_cryptoWeakRandInt () */
 #include "peer-io.h"
 #include "utils.h"
 
-#define dbgmsg( ... ) \
+#define dbgmsg(...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, NULL, __VA_ARGS__); \
+    } while (0)
 
 /***
 ****
 ***/
 
 static unsigned int
-getSpeed_Bps( const struct bratecontrol * r, unsigned int interval_msec, uint64_t now )
+getSpeed_Bps (const struct bratecontrol * r, unsigned int interval_msec, uint64_t now)
 {
-    if( !now )
-        now = tr_time_msec();
+    if (!now)
+        now = tr_time_msec ();
 
-    if( now != r->cache_time )
+    if (now != r->cache_time)
     {
         int i = r->newest;
         uint64_t bytes = 0;
         const uint64_t cutoff = now - interval_msec;
         struct bratecontrol * rvolatile = (struct bratecontrol*) r;
 
-        for( ;; )
+        for (;;)
         {
-            if( r->transfers[i].date <= cutoff )
+            if (r->transfers[i].date <= cutoff)
                 break;
 
             bytes += r->transfers[i].size;
 
-            if( --i == -1 ) i = HISTORY_SIZE - 1; /* circular history */
-            if( i == r->newest ) break; /* we've come all the way around */
+            if (--i == -1) i = HISTORY_SIZE - 1; /* circular history */
+            if (i == r->newest) break; /* we've come all the way around */
         }
 
-        rvolatile->cache_val = (unsigned int)(( bytes * 1000u ) / interval_msec);
+        rvolatile->cache_val = (unsigned int)((bytes * 1000u) / interval_msec);
         rvolatile->cache_time = now;
     }
 
@@ -62,13 +62,13 @@ getSpeed_Bps( const struct bratecontrol * r, unsigned int interval_msec, uint64_
 }
 
 static void
-bytesUsed( const uint64_t now, struct bratecontrol * r, size_t size )
+bytesUsed (const uint64_t now, struct bratecontrol * r, size_t size)
 {
-    if( r->transfers[r->newest].date + GRANULARITY_MSEC >= now )
+    if (r->transfers[r->newest].date + GRANULARITY_MSEC >= now)
         r->transfers[r->newest].size += size;
     else
     {
-        if( ++r->newest == HISTORY_SIZE ) r->newest = 0;
+        if (++r->newest == HISTORY_SIZE) r->newest = 0;
         r->transfers[r->newest].date = now;
         r->transfers[r->newest].size = size;
     }
@@ -83,7 +83,7 @@ bytesUsed( const uint64_t now, struct bratecontrol * r, size_t size )
 ******/
 
 static int
-compareBandwidth( const void * va, const void * vb )
+compareBandwidth (const void * va, const void * vb)
 {
     const tr_bandwidth * a = va;
     const tr_bandwidth * b = vb;
@@ -95,7 +95,7 @@ compareBandwidth( const void * va, const void * vb )
 ***/
 
 void
-tr_bandwidthConstruct( tr_bandwidth * b, tr_session * session, tr_bandwidth * parent )
+tr_bandwidthConstruct (tr_bandwidth * b, tr_session * session, tr_bandwidth * parent)
 {
     static unsigned int uniqueKey = 0;
 
@@ -105,18 +105,18 @@ tr_bandwidthConstruct( tr_bandwidth * b, tr_session * session, tr_bandwidth * pa
     b->uniqueKey = uniqueKey++;
     b->band[TR_UP].honorParentLimits = true;
     b->band[TR_DOWN].honorParentLimits = true;
-    tr_bandwidthSetParent( b, parent );
+    tr_bandwidthSetParent (b, parent);
 }
 
 void
-tr_bandwidthDestruct( tr_bandwidth * b )
+tr_bandwidthDestruct (tr_bandwidth * b)
 {
-    assert( tr_isBandwidth( b ) );
+    assert (tr_isBandwidth (b));
 
-    tr_bandwidthSetParent( b, NULL );
-    tr_ptrArrayDestruct( &b->children, NULL );
+    tr_bandwidthSetParent (b, NULL);
+    tr_ptrArrayDestruct (&b->children, NULL);
 
-    memset( b, ~0, sizeof( tr_bandwidth ) );
+    memset (b, ~0, sizeof (tr_bandwidth));
 }
 
 /***
@@ -124,33 +124,33 @@ tr_bandwidthDestruct( tr_bandwidth * b )
 ***/
 
 void
-tr_bandwidthSetParent( tr_bandwidth  * b,
-                       tr_bandwidth  * parent )
+tr_bandwidthSetParent (tr_bandwidth  * b,
+                       tr_bandwidth  * parent)
 {
-    assert( tr_isBandwidth( b ) );
-    assert( b != parent );
+    assert (tr_isBandwidth (b));
+    assert (b != parent);
 
-    if( b->parent )
+    if (b->parent)
     {
         void * removed;
 
-        assert( tr_isBandwidth( b->parent ) );
+        assert (tr_isBandwidth (b->parent));
 
-        removed = tr_ptrArrayRemoveSorted( &b->parent->children, b, compareBandwidth );
-        assert( removed == b );
-        assert( tr_ptrArrayFindSorted( &b->parent->children, b, compareBandwidth ) == NULL );
+        removed = tr_ptrArrayRemoveSorted (&b->parent->children, b, compareBandwidth);
+        assert (removed == b);
+        assert (tr_ptrArrayFindSorted (&b->parent->children, b, compareBandwidth) == NULL);
 
         b->parent = NULL;
     }
 
-    if( parent )
+    if (parent)
     {
-        assert( tr_isBandwidth( parent ) );
-        assert( parent->parent != b );
+        assert (tr_isBandwidth (parent));
+        assert (parent->parent != b);
 
-        assert( tr_ptrArrayFindSorted( &parent->children, b, compareBandwidth ) == NULL );
-        tr_ptrArrayInsertSorted( &parent->children, b, compareBandwidth );
-        assert( tr_ptrArrayFindSorted( &parent->children, b, compareBandwidth ) == b );
+        assert (tr_ptrArrayFindSorted (&parent->children, b, compareBandwidth) == NULL);
+        tr_ptrArrayInsertSorted (&parent->children, b, compareBandwidth);
+        assert (tr_ptrArrayFindSorted (&parent->children, b, compareBandwidth) == b);
         b->parent = parent;
     }
 }
@@ -160,67 +160,67 @@ tr_bandwidthSetParent( tr_bandwidth  * b,
 ***/
 
 static void
-allocateBandwidth( tr_bandwidth  * b,
+allocateBandwidth (tr_bandwidth  * b,
                    tr_priority_t   parent_priority,
                    tr_direction    dir,
                    unsigned int    period_msec,
-                   tr_ptrArray   * peer_pool )
+                   tr_ptrArray   * peer_pool)
 {
-    const tr_priority_t priority = MAX( parent_priority, b->priority );
+    const tr_priority_t priority = MAX (parent_priority, b->priority);
 
-    assert( tr_isBandwidth( b ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isBandwidth (b));
+    assert (tr_isDirection (dir));
 
     /* set the available bandwidth */
-    if( b->band[dir].isLimited )
+    if (b->band[dir].isLimited)
     {
         const uint64_t nextPulseSpeed = b->band[dir].desiredSpeed_Bps;
-        b->band[dir].bytesLeft = (unsigned int)( nextPulseSpeed * period_msec ) / 1000u;
+        b->band[dir].bytesLeft = (unsigned int)(nextPulseSpeed * period_msec) / 1000u;
     }
 
     /* add this bandwidth's peer, if any, to the peer pool */
-    if( b->peer != NULL ) {
+    if (b->peer != NULL) {
         b->peer->priority = priority;
-        tr_ptrArrayAppend( peer_pool, b->peer );
+        tr_ptrArrayAppend (peer_pool, b->peer);
     }
 
     /* traverse & repeat for the subtree */
-    if( 1 ) {
+    if (1) {
         int i;
-        struct tr_bandwidth ** children = (struct tr_bandwidth**) tr_ptrArrayBase( &b->children );
-        const int n = tr_ptrArraySize( &b->children );
-        for( i=0; i<n; ++i )
-            allocateBandwidth( children[i], priority, dir, period_msec, peer_pool );
+        struct tr_bandwidth ** children = (struct tr_bandwidth**) tr_ptrArrayBase (&b->children);
+        const int n = tr_ptrArraySize (&b->children);
+        for (i=0; i<n; ++i)
+            allocateBandwidth (children[i], priority, dir, period_msec, peer_pool);
     }
 }
 
 static void
-phaseOne( tr_ptrArray * peerArray, tr_direction dir )
+phaseOne (tr_ptrArray * peerArray, tr_direction dir)
 {
     int n;
-    int peerCount = tr_ptrArraySize( peerArray );
-    struct tr_peerIo ** peers = (struct tr_peerIo**) tr_ptrArrayBase( peerArray );
+    int peerCount = tr_ptrArraySize (peerArray);
+    struct tr_peerIo ** peers = (struct tr_peerIo**) tr_ptrArrayBase (peerArray);
 
     /* First phase of IO. Tries to distribute bandwidth fairly to keep faster
      * peers from starving the others. Loop through the peers, giving each a
      * small chunk of bandwidth. Keep looping until we run out of bandwidth
      * and/or peers that can use it */
     n = peerCount;
-    dbgmsg( "%d peers to go round-robin for %s", n, (dir==TR_UP?"upload":"download") );
-    while( n > 0 )
+    dbgmsg ("%d peers to go round-robin for %s", n, (dir==TR_UP?"upload":"download"));
+    while (n > 0)
     {
-        const int i = tr_cryptoWeakRandInt( n ); /* pick a peer at random */
+        const int i = tr_cryptoWeakRandInt (n); /* pick a peer at random */
 
         /* value of 3000 bytes chosen so that when using uTP we'll send a full-size
          * frame right away and leave enough buffered data for the next frame to go
          * out in a timely manner. */
         const size_t increment = 3000;
 
-        const int bytesUsed = tr_peerIoFlush( peers[i], dir, increment );
+        const int bytesUsed = tr_peerIoFlush (peers[i], dir, increment);
 
-        dbgmsg( "peer #%d of %d used %d bytes in this pass", i, n, bytesUsed );
+        dbgmsg ("peer #%d of %d used %d bytes in this pass", i, n, bytesUsed);
 
-        if( bytesUsed != (int)increment ) {
+        if (bytesUsed != (int)increment) {
             /* peer is done writing for now; move it to the end of the list */
             tr_peerIo * pio = peers[i];
             peers[i] = peers[n-1];
@@ -231,9 +231,9 @@ phaseOne( tr_ptrArray * peerArray, tr_direction dir )
 }
 
 void
-tr_bandwidthAllocate( tr_bandwidth  * b,
+tr_bandwidthAllocate (tr_bandwidth  * b,
                       tr_direction    dir,
-                      unsigned int    period_msec )
+                      unsigned int    period_msec)
 {
     int i, peerCount;
     tr_ptrArray tmp = TR_PTR_ARRAY_INIT;
@@ -242,24 +242,24 @@ tr_bandwidthAllocate( tr_bandwidth  * b,
     tr_ptrArray normal = TR_PTR_ARRAY_INIT;
     struct tr_peerIo ** peers;
 
-    /* allocateBandwidth() is a helper function with two purposes:
+    /* allocateBandwidth () is a helper function with two purposes:
      * 1. allocate bandwidth to b and its subtree
      * 2. accumulate an array of all the peerIos from b and its subtree. */
-    allocateBandwidth( b, TR_PRI_LOW, dir, period_msec, &tmp );
-    peers = (struct tr_peerIo**) tr_ptrArrayBase( &tmp );
-    peerCount = tr_ptrArraySize( &tmp );
+    allocateBandwidth (b, TR_PRI_LOW, dir, period_msec, &tmp);
+    peers = (struct tr_peerIo**) tr_ptrArrayBase (&tmp);
+    peerCount = tr_ptrArraySize (&tmp);
 
-    for( i=0; i<peerCount; ++i )
+    for (i=0; i<peerCount; ++i)
     {
         tr_peerIo * io = peers[i];
-        tr_peerIoRef( io );
+        tr_peerIoRef (io);
 
-        tr_peerIoFlushOutgoingProtocolMsgs( io );
+        tr_peerIoFlushOutgoingProtocolMsgs (io);
 
-        switch( io->priority ) {
-            case TR_PRI_HIGH:   tr_ptrArrayAppend( &high,   io ); /* fall through */
-            case TR_PRI_NORMAL: tr_ptrArrayAppend( &normal, io ); /* fall through */
-            default:            tr_ptrArrayAppend( &low,    io );
+        switch (io->priority) {
+            case TR_PRI_HIGH:   tr_ptrArrayAppend (&high,   io); /* fall through */
+            case TR_PRI_NORMAL: tr_ptrArrayAppend (&normal, io); /* fall through */
+            default:            tr_ptrArrayAppend (&low,    io);
         }
     }
 
@@ -267,32 +267,32 @@ tr_bandwidthAllocate( tr_bandwidth  * b,
      * peers from starving the others. Loop through the peers, giving each a
      * small chunk of bandwidth. Keep looping until we run out of bandwidth
      * and/or peers that can use it */
-    phaseOne( &high, dir );
-    phaseOne( &normal, dir );
-    phaseOne( &low, dir );
+    phaseOne (&high, dir);
+    phaseOne (&normal, dir);
+    phaseOne (&low, dir);
 
     /* Second phase of IO. To help us scale in high bandwidth situations,
      * enable on-demand IO for peers with bandwidth left to burn.
      * This on-demand IO is enabled until (1) the peer runs out of bandwidth,
-     * or (2) the next tr_bandwidthAllocate() call, when we start over again. */
-    for( i=0; i<peerCount; ++i )
-        tr_peerIoSetEnabled( peers[i], dir, tr_peerIoHasBandwidthLeft( peers[i], dir ) );
+     * or (2) the next tr_bandwidthAllocate () call, when we start over again. */
+    for (i=0; i<peerCount; ++i)
+        tr_peerIoSetEnabled (peers[i], dir, tr_peerIoHasBandwidthLeft (peers[i], dir));
 
-    for( i=0; i<peerCount; ++i )
-        tr_peerIoUnref( peers[i] );
+    for (i=0; i<peerCount; ++i)
+        tr_peerIoUnref (peers[i]);
 
     /* cleanup */
-    tr_ptrArrayDestruct( &normal, NULL );
-    tr_ptrArrayDestruct( &high, NULL );
-    tr_ptrArrayDestruct( &low, NULL );
-    tr_ptrArrayDestruct( &tmp, NULL );
+    tr_ptrArrayDestruct (&normal, NULL);
+    tr_ptrArrayDestruct (&high, NULL);
+    tr_ptrArrayDestruct (&low, NULL);
+    tr_ptrArrayDestruct (&tmp, NULL);
 }
 
 void
-tr_bandwidthSetPeer( tr_bandwidth * b, tr_peerIo * peer )
+tr_bandwidthSetPeer (tr_bandwidth * b, tr_peerIo * peer)
 {
-    assert( tr_isBandwidth( b ) );
-    assert( ( peer == NULL ) || tr_isPeerIo( peer ) );
+    assert (tr_isBandwidth (b));
+    assert ((peer == NULL) || tr_isPeerIo (peer));
 
     b->peer = peer;
 }
@@ -302,102 +302,102 @@ tr_bandwidthSetPeer( tr_bandwidth * b, tr_peerIo * peer )
 ***/
 
 static unsigned int
-bandwidthClamp( const tr_bandwidth  * b,
+bandwidthClamp (const tr_bandwidth  * b,
                 uint64_t              now,
                 tr_direction          dir,
-                unsigned int          byteCount )
+                unsigned int          byteCount)
 {
-    assert( tr_isBandwidth( b ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isBandwidth (b));
+    assert (tr_isDirection (dir));
 
-    if( b )
+    if (b)
     {
-        if( b->band[dir].isLimited )
+        if (b->band[dir].isLimited)
         {
-            byteCount = MIN( byteCount, b->band[dir].bytesLeft );
+            byteCount = MIN (byteCount, b->band[dir].bytesLeft);
 
             /* if we're getting close to exceeding the speed limit,
              * clamp down harder on the bytes available */
-            if( byteCount > 0 )
+            if (byteCount > 0)
             {
                 double current;
                 double desired;
                 double r;
 
-                if( now == 0 )
-                    now = tr_time_msec( );
+                if (now == 0)
+                    now = tr_time_msec ();
 
-                current = tr_bandwidthGetRawSpeed_Bps( b, now, TR_DOWN );
-                desired = tr_bandwidthGetDesiredSpeed_Bps( b, TR_DOWN );
+                current = tr_bandwidthGetRawSpeed_Bps (b, now, TR_DOWN);
+                desired = tr_bandwidthGetDesiredSpeed_Bps (b, TR_DOWN);
                 r = desired >= 1 ? current / desired : 0;
 
-                     if( r > 1.0 ) byteCount = 0;
-                else if( r > 0.9 ) byteCount *= 0.8;
-                else if( r > 0.8 ) byteCount *= 0.9;
+                     if (r > 1.0) byteCount = 0;
+                else if (r > 0.9) byteCount *= 0.8;
+                else if (r > 0.8) byteCount *= 0.9;
             }
         }
 
-        if( b->parent && b->band[dir].honorParentLimits && ( byteCount > 0 ) )
-            byteCount = bandwidthClamp( b->parent, now, dir, byteCount );
+        if (b->parent && b->band[dir].honorParentLimits && (byteCount > 0))
+            byteCount = bandwidthClamp (b->parent, now, dir, byteCount);
     }
 
     return byteCount;
 }
 unsigned int
-tr_bandwidthClamp( const tr_bandwidth  * b,
+tr_bandwidthClamp (const tr_bandwidth  * b,
                    tr_direction          dir,
-                   unsigned int          byteCount )
+                   unsigned int          byteCount)
 {
-    return bandwidthClamp( b, 0, dir, byteCount );
+    return bandwidthClamp (b, 0, dir, byteCount);
 }
 
 
 unsigned int
-tr_bandwidthGetRawSpeed_Bps( const tr_bandwidth * b, const uint64_t now, const tr_direction dir )
+tr_bandwidthGetRawSpeed_Bps (const tr_bandwidth * b, const uint64_t now, const tr_direction dir)
 {
-    assert( tr_isBandwidth( b ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isBandwidth (b));
+    assert (tr_isDirection (dir));
 
-    return getSpeed_Bps( &b->band[dir].raw, HISTORY_MSEC, now );
+    return getSpeed_Bps (&b->band[dir].raw, HISTORY_MSEC, now);
 }
 
 unsigned int
-tr_bandwidthGetPieceSpeed_Bps( const tr_bandwidth * b, const uint64_t now, const tr_direction dir )
+tr_bandwidthGetPieceSpeed_Bps (const tr_bandwidth * b, const uint64_t now, const tr_direction dir)
 {
-    assert( tr_isBandwidth( b ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isBandwidth (b));
+    assert (tr_isDirection (dir));
 
-    return getSpeed_Bps( &b->band[dir].piece, HISTORY_MSEC, now );
+    return getSpeed_Bps (&b->band[dir].piece, HISTORY_MSEC, now);
 }
 
 void
-tr_bandwidthUsed( tr_bandwidth  * b,
+tr_bandwidthUsed (tr_bandwidth  * b,
                   tr_direction    dir,
                   size_t          byteCount,
                   bool         isPieceData,
-                  uint64_t        now )
+                  uint64_t        now)
 {
     struct tr_band * band;
 
-    assert( tr_isBandwidth( b ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isBandwidth (b));
+    assert (tr_isDirection (dir));
 
     band = &b->band[dir];
 
-    if( band->isLimited && isPieceData )
-        band->bytesLeft -= MIN( band->bytesLeft, byteCount );
+    if (band->isLimited && isPieceData)
+        band->bytesLeft -= MIN (band->bytesLeft, byteCount);
 
 #ifdef DEBUG_DIRECTION
-if( ( dir == DEBUG_DIRECTION ) && ( band->isLimited ) )
-fprintf( stderr, "%p consumed %5zu bytes of %5s data... was %6zu, now %6zu left\n",
-         b, byteCount, (isPieceData?"piece":"raw"), oldBytesLeft, band->bytesLeft );
+if ((dir == DEBUG_DIRECTION) && (band->isLimited))
+fprintf (stderr, "%p consumed %5zu bytes of %5s data... was %6zu, now %6zu left\n",
+         b, byteCount, (isPieceData?"piece":"raw"), oldBytesLeft, band->bytesLeft);
 #endif
 
-    bytesUsed( now, &band->raw, byteCount );
+    bytesUsed (now, &band->raw, byteCount);
 
-    if( isPieceData )
-        bytesUsed( now, &band->piece, byteCount );
+    if (isPieceData)
+        bytesUsed (now, &band->piece, byteCount);
 
-    if( b->parent != NULL )
-        tr_bandwidthUsed( b->parent, dir, byteCount, isPieceData, now );
+    if (b->parent != NULL)
+        tr_bandwidthUsed (b->parent, dir, byteCount, isPieceData, now);
 }
diff --git a/libtransmission/bandwidth.h b/libtransmission/bandwidth.h
index 03b3394bd..99c06d266 100644
--- a/libtransmission/bandwidth.h
+++ b/libtransmission/bandwidth.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -21,7 +21,7 @@
 
 #include "transmission.h"
 #include "ptrarray.h"
-#include "utils.h" /* tr_new(), tr_free() */
+#include "utils.h" /* tr_new (), tr_free () */
 
 struct tr_peerIo;
 
@@ -37,7 +37,7 @@ enum
     HISTORY_MSEC = 2000u,
     INTERVAL_MSEC = HISTORY_MSEC,
     GRANULARITY_MSEC = 200,
-    HISTORY_SIZE = ( INTERVAL_MSEC / GRANULARITY_MSEC ),
+    HISTORY_SIZE = (INTERVAL_MSEC / GRANULARITY_MSEC),
     BANDWIDTH_MAGIC_NUMBER = 43143
 };
 
@@ -90,16 +90,16 @@ struct tr_band
  *
  * CONSTRAINING
  *
- *   Call tr_bandwidthAllocate() periodically. tr_bandwidth knows its current
+ *   Call tr_bandwidthAllocate () periodically. tr_bandwidth knows its current
  *   speed and will decide how many bytes to make available over the
  *   user-specified period to reach the user-specified desired speed.
  *   If appropriate, it notifies its peer-ios that new bandwidth is available.
  *
- *   tr_bandwidthAllocate() operates on the tr_bandwidth subtree, so usually
+ *   tr_bandwidthAllocate () operates on the tr_bandwidth subtree, so usually
  *   you'll only need to invoke it for the top-level tr_session bandwidth.
  *
  *   The peer-ios all have a pointer to their associated tr_bandwidth object,
- *   and call tr_bandwidthClamp() before performing I/O to see how much
+ *   and call tr_bandwidthClamp () before performing I/O to see how much
  *   bandwidth they can safely use.
  */
 typedef struct tr_bandwidth
@@ -123,16 +123,16 @@ tr_bandwidth;
 ***
 **/
 
-void tr_bandwidthConstruct( tr_bandwidth * bandwidth,
+void tr_bandwidthConstruct (tr_bandwidth * bandwidth,
                             tr_session   * session,
-                            tr_bandwidth * parent );
+                            tr_bandwidth * parent);
 
-void tr_bandwidthDestruct( tr_bandwidth * bandwidth );
+void tr_bandwidthDestruct (tr_bandwidth * bandwidth);
 
 /** @brief test to see if the pointer refers to a live bandwidth object */
-static inline bool tr_isBandwidth( const tr_bandwidth  * b )
+static inline bool tr_isBandwidth (const tr_bandwidth  * b)
 {
-    return ( b != NULL ) && ( b->magicNumber == BANDWIDTH_MAGIC_NUMBER );
+    return (b != NULL) && (b->magicNumber == BANDWIDTH_MAGIC_NUMBER);
 }
 
 /******
@@ -144,9 +144,9 @@ static inline bool tr_isBandwidth( const tr_bandwidth  * b )
  * @see tr_bandwidthAllocate
  * @see tr_bandwidthGetDesiredSpeed
  */
-static inline bool tr_bandwidthSetDesiredSpeed_Bps( tr_bandwidth        * bandwidth,
+static inline bool tr_bandwidthSetDesiredSpeed_Bps (tr_bandwidth        * bandwidth,
                                                     tr_direction          dir,
-                                                    unsigned int          desiredSpeed )
+                                                    unsigned int          desiredSpeed)
 {
     unsigned int * value = &bandwidth->band[dir].desiredSpeed_Bps;
     const bool didChange = desiredSpeed != *value;
@@ -159,7 +159,7 @@ static inline bool tr_bandwidthSetDesiredSpeed_Bps( tr_bandwidth        * bandwi
  * @see tr_bandwidthSetDesiredSpeed
  */
 static inline double
-tr_bandwidthGetDesiredSpeed_Bps( const tr_bandwidth  * bandwidth, tr_direction dir )
+tr_bandwidthGetDesiredSpeed_Bps (const tr_bandwidth  * bandwidth, tr_direction dir)
 {
     return bandwidth->band[dir].desiredSpeed_Bps;
 }
@@ -167,9 +167,9 @@ tr_bandwidthGetDesiredSpeed_Bps( const tr_bandwidth  * bandwidth, tr_direction d
 /**
  * @brief Set whether or not this bandwidth should throttle its peer-io's speeds
  */
-static inline bool tr_bandwidthSetLimited( tr_bandwidth  * bandwidth,
+static inline bool tr_bandwidthSetLimited (tr_bandwidth  * bandwidth,
                                            tr_direction    dir,
-                                           bool            isLimited )
+                                           bool            isLimited)
 {
     bool * value = &bandwidth->band[dir].isLimited;
     const bool didChange = isLimited != *value;
@@ -180,8 +180,8 @@ static inline bool tr_bandwidthSetLimited( tr_bandwidth  * bandwidth,
 /**
  * @return nonzero if this bandwidth throttles its peer-ios speeds
  */
-static inline bool tr_bandwidthIsLimited( const tr_bandwidth  * bandwidth,
-                                          tr_direction          dir )
+static inline bool tr_bandwidthIsLimited (const tr_bandwidth  * bandwidth,
+                                          tr_direction          dir)
 {
     return bandwidth->band[dir].isLimited;
 }
@@ -189,47 +189,47 @@ static inline bool tr_bandwidthIsLimited( const tr_bandwidth  * bandwidth,
 /**
  * @brief allocate the next period_msec's worth of bandwidth for the peer-ios to consume
  */
-void    tr_bandwidthAllocate          ( tr_bandwidth        * bandwidth,
+void    tr_bandwidthAllocate        (tr_bandwidth        * bandwidth,
                                         tr_direction          direction,
-                                        unsigned int          period_msec );
+                                        unsigned int          period_msec);
 
 /**
  * @brief clamps byteCount down to a number that this bandwidth will allow to be consumed
  */
-unsigned int  tr_bandwidthClamp       ( const tr_bandwidth  * bandwidth,
+unsigned int  tr_bandwidthClamp     (const tr_bandwidth  * bandwidth,
                                         tr_direction          direction,
-                                        unsigned int          byteCount );
+                                        unsigned int          byteCount);
 
 /******
 *******
 ******/
 
 /** @brief Get the raw total of bytes read or sent by this bandwidth subtree. */
-unsigned int tr_bandwidthGetRawSpeed_Bps( const tr_bandwidth  * bandwidth,
+unsigned int tr_bandwidthGetRawSpeed_Bps (const tr_bandwidth  * bandwidth,
                                            const uint64_t        now,
-                                           const tr_direction    direction );
+                                           const tr_direction    direction);
 
 /** @brief Get the number of piece data bytes read or sent by this bandwidth subtree. */
-unsigned int tr_bandwidthGetPieceSpeed_Bps( const tr_bandwidth  * bandwidth,
+unsigned int tr_bandwidthGetPieceSpeed_Bps (const tr_bandwidth  * bandwidth,
                                             const uint64_t        now,
-                                            const tr_direction    direction );
+                                            const tr_direction    direction);
 
 /**
  * @brief Notify the bandwidth object that some of its allocated bandwidth has been consumed.
  * This is is usually invoked by the peer-io after a read or write.
  */
-void    tr_bandwidthUsed              ( tr_bandwidth        * bandwidth,
+void    tr_bandwidthUsed            (tr_bandwidth        * bandwidth,
                                         tr_direction          direction,
                                         size_t                byteCount,
                                         bool                  isPieceData,
-                                        uint64_t              now );
+                                        uint64_t              now);
 
 /******
 *******
 ******/
 
-void    tr_bandwidthSetParent         ( tr_bandwidth        * bandwidth,
-                                        tr_bandwidth        * parent );
+void    tr_bandwidthSetParent       (tr_bandwidth        * bandwidth,
+                                        tr_bandwidth        * parent);
 
 /**
  * Almost all the time we do want to honor a parents' bandwidth cap, so that
@@ -237,9 +237,9 @@ void    tr_bandwidthSetParent         ( tr_bandwidth        * bandwidth,
  * But when we set a torrent's speed mode to TR_SPEEDLIMIT_UNLIMITED, then
  * in that particular case we want to ignore the global speed limit...
  */
-static inline bool tr_bandwidthHonorParentLimits ( tr_bandwidth   * bandwidth,
+static inline bool tr_bandwidthHonorParentLimits (tr_bandwidth   * bandwidth,
                                                    tr_direction     direction,
-                                                   bool             isEnabled )
+                                                   bool             isEnabled)
 {
     bool * value = &bandwidth->band[direction].honorParentLimits;
     const bool didChange = isEnabled != *value;
@@ -247,11 +247,11 @@ static inline bool tr_bandwidthHonorParentLimits ( tr_bandwidth   * bandwidth,
     return didChange;
 }
 
-static inline bool tr_bandwidthAreParentLimitsHonored( const tr_bandwidth  * bandwidth,
-                                                       tr_direction          direction )
+static inline bool tr_bandwidthAreParentLimitsHonored (const tr_bandwidth  * bandwidth,
+                                                       tr_direction          direction)
 {
-    assert( tr_isBandwidth( bandwidth ) );
-    assert( tr_isDirection( direction ) );
+    assert (tr_isBandwidth (bandwidth));
+    assert (tr_isDirection (direction));
 
     return bandwidth->band[direction].honorParentLimits;
 }
@@ -260,8 +260,8 @@ static inline bool tr_bandwidthAreParentLimitsHonored( const tr_bandwidth  * ban
 *******
 ******/
 
-void tr_bandwidthSetPeer( tr_bandwidth        * bandwidth,
-                          struct tr_peerIo    * peerIo );
+void tr_bandwidthSetPeer (tr_bandwidth        * bandwidth,
+                          struct tr_peerIo    * peerIo);
 
 /* @} */
 #endif
diff --git a/libtransmission/bencode-test.c b/libtransmission/bencode-test.c
index 5a5c1a66e..935261282 100644
--- a/libtransmission/bencode-test.c
+++ b/libtransmission/bencode-test.c
@@ -1,6 +1,6 @@
-#include <ctype.h> /* isspace() */
+#include <ctype.h> /* isspace () */
 #include <errno.h> /* EILSEQ */
-#include <string.h> /* strlen(), strncmp() */
+#include <string.h> /* strlen (), strncmp () */
 
 #include <event2/buffer.h>
 
@@ -14,11 +14,11 @@
 #ifndef WIN32
 #define STACK_SMASH_DEPTH (1 * 1000 * 1000)
 #else
-#define STACK_SMASH_DEPTH (     100 * 1000)
+#define STACK_SMASH_DEPTH ( 100 * 1000)
 #endif
 
 static int
-testInt( void )
+testInt (void)
 {
     uint8_t         buf[128];
     int64_t         val;
@@ -26,61 +26,61 @@ testInt( void )
     const uint8_t * end;
 
     /* good int string */
-    tr_snprintf( (char*)buf, sizeof( buf ), "i64e" );
-    err = tr_bencParseInt( buf, buf + 4, &end, &val );
-    check_int_eq( 0, err );
-    check_int_eq( 64, val );
-    check( (buf + 4) ==  end );
+    tr_snprintf ((char*)buf, sizeof (buf), "i64e");
+    err = tr_bencParseInt (buf, buf + 4, &end, &val);
+    check_int_eq (0, err);
+    check_int_eq (64, val);
+    check ((buf + 4) ==  end);
 
     /* missing 'e' */
     end = NULL;
     val = 888;
-    err = tr_bencParseInt( buf, buf + 3, &end, &val );
-    check_int_eq( EILSEQ, err );
-    check_int_eq( 888, val );
-    check( end == NULL );
+    err = tr_bencParseInt (buf, buf + 3, &end, &val);
+    check_int_eq (EILSEQ, err);
+    check_int_eq (888, val);
+    check (end == NULL);
 
     /* empty buffer */
-    err = tr_bencParseInt( buf, buf + 0, &end, &val );
-    check_int_eq( EILSEQ, err );
-    check_int_eq( 888, val );
-    check( end == NULL );
+    err = tr_bencParseInt (buf, buf + 0, &end, &val);
+    check_int_eq (EILSEQ, err);
+    check_int_eq (888, val);
+    check (end == NULL);
 
     /* bad number */
-    tr_snprintf( (char*)buf, sizeof( buf ), "i6z4e" );
-    err = tr_bencParseInt( buf, buf + 5, &end, &val );
-    check_int_eq( EILSEQ, err );
-    check_int_eq( 888, val );
-    check( end == NULL );
+    tr_snprintf ((char*)buf, sizeof (buf), "i6z4e");
+    err = tr_bencParseInt (buf, buf + 5, &end, &val);
+    check_int_eq (EILSEQ, err);
+    check_int_eq (888, val);
+    check (end == NULL);
 
     /* negative number */
-    tr_snprintf( (char*)buf, sizeof( buf ), "i-3e" );
-    err = tr_bencParseInt( buf, buf + 4, &end, &val );
-    check_int_eq( 0, err );
-    check_int_eq( -3, val );
-    check( (buf + 4) == end );
+    tr_snprintf ((char*)buf, sizeof (buf), "i-3e");
+    err = tr_bencParseInt (buf, buf + 4, &end, &val);
+    check_int_eq (0, err);
+    check_int_eq (-3, val);
+    check ((buf + 4) == end);
 
     /* zero */
-    tr_snprintf( (char*)buf, sizeof( buf ), "i0e" );
-    err = tr_bencParseInt( buf, buf + 4, &end, &val );
-    check_int_eq( 0, err );
-    check_int_eq( 0, val );
-    check( (buf + 3) == end );
+    tr_snprintf ((char*)buf, sizeof (buf), "i0e");
+    err = tr_bencParseInt (buf, buf + 4, &end, &val);
+    check_int_eq (0, err);
+    check_int_eq (0, val);
+    check ((buf + 3) == end);
 
     /* no leading zeroes allowed */
     val = 0;
     end = NULL;
-    tr_snprintf( (char*)buf, sizeof( buf ), "i04e" );
-    err = tr_bencParseInt( buf, buf + 4, &end, &val );
-    check_int_eq( EILSEQ, err );
-    check_int_eq( 0, val );
-    check( NULL == end );
+    tr_snprintf ((char*)buf, sizeof (buf), "i04e");
+    err = tr_bencParseInt (buf, buf + 4, &end, &val);
+    check_int_eq (EILSEQ, err);
+    check_int_eq (0, val);
+    check (NULL == end);
 
     return 0;
 }
 
 static int
-testStr( void )
+testStr (void)
 {
     uint8_t         buf[128];
     int             err;
@@ -89,42 +89,42 @@ testStr( void )
     size_t          len;
 
     /* good string */
-    tr_snprintf( (char*)buf, sizeof( buf ), "4:boat" );
-    err = tr_bencParseStr( buf, buf + 6, &end, &str, &len );
+    tr_snprintf ((char*)buf, sizeof (buf), "4:boat");
+    err = tr_bencParseStr (buf, buf + 6, &end, &str, &len);
     check_int_eq (0, err);
     check_int_eq (4, len);
-    check( !strncmp( (char*)str, "boat", len ) );
-    check( end == buf + 6 );
+    check (!strncmp ((char*)str, "boat", len));
+    check (end == buf + 6);
     str = NULL;
     end = NULL;
     len = 0;
 
     /* string goes past end of buffer */
-    err = tr_bencParseStr( buf, buf + 5, &end, &str, &len );
+    err = tr_bencParseStr (buf, buf + 5, &end, &str, &len);
     check_int_eq (EILSEQ, err);
     check_int_eq (0, len);
-    check( str == NULL );
-    check( end == NULL );
-    check( !len );
+    check (str == NULL);
+    check (end == NULL);
+    check (!len);
 
     /* empty string */
-    tr_snprintf( (char*)buf, sizeof( buf ), "0:" );
-    err = tr_bencParseStr( buf, buf + 2, &end, &str, &len );
+    tr_snprintf ((char*)buf, sizeof (buf), "0:");
+    err = tr_bencParseStr (buf, buf + 2, &end, &str, &len);
     check_int_eq (0, err);
     check_int_eq (0, len);
-    check( !*str );
-    check( end == buf + 2 );
+    check (!*str);
+    check (end == buf + 2);
     str = NULL;
     end = NULL;
     len = 0;
 
     /* short string */
-    tr_snprintf( (char*)buf, sizeof( buf ), "3:boat" );
-    err = tr_bencParseStr( buf, buf + 6, &end, &str, &len );
+    tr_snprintf ((char*)buf, sizeof (buf), "3:boat");
+    err = tr_bencParseStr (buf, buf + 6, &end, &str, &len);
     check_int_eq (0, err);
     check_int_eq (3, len);
-    check( !strncmp( (char*)str, "boa", len ) );
-    check( end == buf + 5 );
+    check (!strncmp ((char*)str, "boa", len));
+    check (end == buf + 5);
     str = NULL;
     end = NULL;
     len = 0;
@@ -133,39 +133,39 @@ testStr( void )
 }
 
 static int
-testString( const char * str,
-            int          isGood )
+testString (const char * str,
+            int          isGood)
 {
     tr_benc         val;
     const uint8_t * end = NULL;
     char *          saved;
-    const size_t    len = strlen( str );
+    const size_t    len = strlen (str);
     int             savedLen;
-    int             err = tr_bencParse( str, str + len, &val, &end );
+    int             err = tr_bencParse (str, str + len, &val, &end);
 
-    if( !isGood )
+    if (!isGood)
     {
-        check( err );
+        check (err);
     }
     else
     {
-        check( !err );
+        check (!err);
 #if 0
-        fprintf( stderr, "in: [%s]\n", str );
-        fprintf( stderr, "out:\n%s", tr_bencToStr( &val, TR_FMT_JSON, NULL ) );
+        fprintf (stderr, "in: [%s]\n", str);
+        fprintf (stderr, "out:\n%s", tr_bencToStr (&val, TR_FMT_JSON, NULL));
 #endif
-        check( end == (const uint8_t*)str + len );
-        saved = tr_bencToStr( &val, TR_FMT_BENC, &savedLen );
+        check (end == (const uint8_t*)str + len);
+        saved = tr_bencToStr (&val, TR_FMT_BENC, &savedLen);
         check_streq (str, saved);
         check_int_eq (savedLen, len);
-        tr_free( saved );
-        tr_bencFree( &val );
+        tr_free (saved);
+        tr_bencFree (&val);
     }
     return 0;
 }
 
 static int
-testParse( void )
+testParse (void)
 {
     tr_benc         val;
     tr_benc *       child;
@@ -177,151 +177,151 @@ testParse( void )
     int64_t         i;
     char *          saved;
 
-    tr_snprintf( (char*)buf, sizeof( buf ), "i64e" );
-    err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
-    check( !err );
-    check( tr_bencGetInt( &val, &i ) );
+    tr_snprintf ((char*)buf, sizeof (buf), "i64e");
+    err = tr_bencParse (buf, buf + sizeof (buf), &val, &end);
+    check (!err);
+    check (tr_bencGetInt (&val, &i));
     check_int_eq (64, i);
-    check( end == buf + 4 );
-    tr_bencFree( &val );
-
-    tr_snprintf( (char*)buf, sizeof( buf ), "li64ei32ei16ee" );
-    err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
-    check( !err );
-    check( end == buf + strlen( (char*)buf ) );
-    check( val.val.l.count == 3 );
-    check( tr_bencGetInt( &val.val.l.vals[0], &i ) );
+    check (end == buf + 4);
+    tr_bencFree (&val);
+
+    tr_snprintf ((char*)buf, sizeof (buf), "li64ei32ei16ee");
+    err = tr_bencParse (buf, buf + sizeof (buf), &val, &end);
+    check (!err);
+    check (end == buf + strlen ((char*)buf));
+    check (val.val.l.count == 3);
+    check (tr_bencGetInt (&val.val.l.vals[0], &i));
     check_int_eq (64, i);
-    check( tr_bencGetInt( &val.val.l.vals[1], &i ) );
+    check (tr_bencGetInt (&val.val.l.vals[1], &i));
     check_int_eq (32, i);
-    check( tr_bencGetInt( &val.val.l.vals[2], &i ) );
+    check (tr_bencGetInt (&val.val.l.vals[2], &i));
     check_int_eq (16, i);
-    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
+    saved = tr_bencToStr (&val, TR_FMT_BENC, &len);
     check_streq ((char*)buf, saved);
-    tr_free( saved );
-    tr_bencFree( &val );
+    tr_free (saved);
+    tr_bencFree (&val);
 
     end = NULL;
-    tr_snprintf( (char*)buf, sizeof( buf ), "lllee" );
-    err = tr_bencParse( buf, buf + strlen( (char*)buf ), &val, &end );
-    check( err );
-    check( end == NULL );
+    tr_snprintf ((char*)buf, sizeof (buf), "lllee");
+    err = tr_bencParse (buf, buf + strlen ((char*)buf), &val, &end);
+    check (err);
+    check (end == NULL);
 
     end = NULL;
-    tr_snprintf( (char*)buf, sizeof( buf ), "le" );
-    err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
-    check( !err );
-    check( end == buf + 2 );
-    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
-    check_streq( "le", saved );
-    tr_free( saved );
-    tr_bencFree( &val );
-
-    if( ( err = testString( "llleee", true ) ) )
+    tr_snprintf ((char*)buf, sizeof (buf), "le");
+    err = tr_bencParse (buf, buf + sizeof (buf), &val, &end);
+    check (!err);
+    check (end == buf + 2);
+    saved = tr_bencToStr (&val, TR_FMT_BENC, &len);
+    check_streq ("le", saved);
+    tr_free (saved);
+    tr_bencFree (&val);
+
+    if ((err = testString ("llleee", true)))
         return err;
-    if( ( err = testString( "d3:cow3:moo4:spam4:eggse", true ) ) )
+    if ((err = testString ("d3:cow3:moo4:spam4:eggse", true)))
         return err;
-    if( ( err = testString( "d4:spaml1:a1:bee", true ) ) )
+    if ((err = testString ("d4:spaml1:a1:bee", true)))
         return err;
-    if( ( err =
-             testString( "d5:greenli1ei2ei3ee4:spamd1:ai123e3:keyi214eee",
-                         true ) ) )
+    if ((err =
+             testString ("d5:greenli1ei2ei3ee4:spamd1:ai123e3:keyi214eee",
+                         true)))
         return err;
-    if( ( err =
-             testString(
+    if ((err =
+             testString (
                  "d9:publisher3:bob17:publisher-webpage15:www.example.com18:publisher.location4:homee",
-                 true ) ) )
+                 true)))
         return err;
-    if( ( err =
-             testString(
+    if ((err =
+             testString (
                  "d8:completei1e8:intervali1800e12:min intervali1800e5:peers0:e",
-                 true ) ) )
+                 true)))
         return err;
-    if( ( err = testString( "d1:ai0e1:be", false ) ) ) /* odd number of children
+    if ((err = testString ("d1:ai0e1:be", false))) /* odd number of children
                                                          */
         return err;
-    if( ( err = testString( "", false ) ) )
+    if ((err = testString ("", false)))
         return err;
-    if( ( err = testString( " ", false ) ) )
+    if ((err = testString (" ", false)))
         return err;
 
     /* nested containers
      * parse an unsorted dict
      * save as a sorted dict */
     end = NULL;
-    tr_snprintf( (char*)buf, sizeof( buf ), "lld1:bi32e1:ai64eeee" );
-    err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
-    check( !err );
-    check( end == buf + strlen( (const char*)buf ) );
-    check( ( child = tr_bencListChild( &val, 0 ) ) );
-    check( ( child2 = tr_bencListChild( child, 0 ) ) );
-    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
-    check_streq( "lld1:ai64e1:bi32eeee", saved );
-    tr_free( saved );
-    tr_bencFree( &val );
+    tr_snprintf ((char*)buf, sizeof (buf), "lld1:bi32e1:ai64eeee");
+    err = tr_bencParse (buf, buf + sizeof (buf), &val, &end);
+    check (!err);
+    check (end == buf + strlen ((const char*)buf));
+    check ((child = tr_bencListChild (&val, 0)));
+    check ((child2 = tr_bencListChild (child, 0)));
+    saved = tr_bencToStr (&val, TR_FMT_BENC, &len);
+    check_streq ("lld1:ai64e1:bi32eeee", saved);
+    tr_free (saved);
+    tr_bencFree (&val);
 
     /* too many endings */
     end = NULL;
-    tr_snprintf( (char*)buf, sizeof( buf ), "leee" );
-    err = tr_bencParse( buf, buf + sizeof( buf ), &val, &end );
-    check( !err );
-    check( end == buf + 2 );
-    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
-    check_streq( "le", saved );
-    tr_free( saved );
-    tr_bencFree( &val );
+    tr_snprintf ((char*)buf, sizeof (buf), "leee");
+    err = tr_bencParse (buf, buf + sizeof (buf), &val, &end);
+    check (!err);
+    check (end == buf + 2);
+    saved = tr_bencToStr (&val, TR_FMT_BENC, &len);
+    check_streq ("le", saved);
+    tr_free (saved);
+    tr_bencFree (&val);
 
     /* no ending */
     end = NULL;
-    tr_snprintf( (char*)buf, sizeof( buf ), "l1:a1:b1:c" );
-    err = tr_bencParse( buf, buf + strlen( (char*)buf ), &val, &end );
-    check( err );
+    tr_snprintf ((char*)buf, sizeof (buf), "l1:a1:b1:c");
+    err = tr_bencParse (buf, buf + strlen ((char*)buf), &val, &end);
+    check (err);
 
     /* incomplete string */
     end = NULL;
-    tr_snprintf( (char*)buf, sizeof( buf ), "1:" );
-    err = tr_bencParse( buf, buf + strlen( (char*)buf ), &val, &end );
-    check( err );
+    tr_snprintf ((char*)buf, sizeof (buf), "1:");
+    err = tr_bencParse (buf, buf + strlen ((char*)buf), &val, &end);
+    check (err);
 
     return 0;
 }
 
 static void
-stripWhitespace( char * in )
+stripWhitespace (char * in)
 {
     char * out;
 
-    for( out = in; *in; ++in )
-        if( !isspace( *in ) )
+    for (out = in; *in; ++in)
+        if (!isspace (*in))
             *out++ = *in;
     *out = '\0';
 }
 
 static int
-testJSONSnippet( const char * benc_str,
-                 const char * expected )
+testJSONSnippet (const char * benc_str,
+                 const char * expected)
 {
     tr_benc top;
     char * serialized;
     struct evbuffer * buf;
 
-    tr_bencLoad( benc_str, strlen( benc_str ), &top, NULL );
-    buf = tr_bencToBuf( &top, TR_FMT_JSON );
-    serialized = (char*) evbuffer_pullup( buf, -1 );
-    stripWhitespace( serialized );
+    tr_bencLoad (benc_str, strlen (benc_str), &top, NULL);
+    buf = tr_bencToBuf (&top, TR_FMT_JSON);
+    serialized = (char*) evbuffer_pullup (buf, -1);
+    stripWhitespace (serialized);
 #if 0
-    fprintf( stderr, "benc: %s\n", benc_str );
-    fprintf( stderr, "json: %s\n", serialized );
-    fprintf( stderr, "want: %s\n", expected );
+    fprintf (stderr, "benc: %s\n", benc_str);
+    fprintf (stderr, "json: %s\n", serialized);
+    fprintf (stderr, "want: %s\n", expected);
 #endif
     check_streq (expected, serialized);
-    tr_bencFree( &top );
-    evbuffer_free( buf );
+    tr_bencFree (&top);
+    evbuffer_free (buf);
     return 0;
 }
 
 static int
-testJSON( void )
+testJSON (void)
 {
     int          val;
     const char * benc_str;
@@ -329,84 +329,84 @@ testJSON( void )
 
     benc_str = "i6e";
     expected = "6";
-    if( ( val = testJSONSnippet( benc_str, expected ) ) )
+    if ((val = testJSONSnippet (benc_str, expected)))
         return val;
 
     benc_str = "d5:helloi1e5:worldi2ee";
     expected = "{\"hello\":1,\"world\":2}";
-    if( ( val = testJSONSnippet( benc_str, expected ) ) )
+    if ((val = testJSONSnippet (benc_str, expected)))
         return val;
 
     benc_str = "d5:helloi1e5:worldi2e3:fooli1ei2ei3eee";
     expected = "{\"foo\":[1,2,3],\"hello\":1,\"world\":2}";
-    if( ( val = testJSONSnippet( benc_str, expected ) ) )
+    if ((val = testJSONSnippet (benc_str, expected)))
         return val;
 
     benc_str = "d5:helloi1e5:worldi2e3:fooli1ei2ei3ed1:ai0eeee";
     expected = "{\"foo\":[1,2,3,{\"a\":0}],\"hello\":1,\"world\":2}";
-    if( ( val = testJSONSnippet( benc_str, expected ) ) )
+    if ((val = testJSONSnippet (benc_str, expected)))
         return val;
 
     benc_str = "d4:argsd6:statusle7:status2lee6:result7:successe";
     expected =
         "{\"args\":{\"status\":[],\"status2\":[]},\"result\":\"success\"}";
-    if( ( val = testJSONSnippet( benc_str, expected ) ) )
+    if ((val = testJSONSnippet (benc_str, expected)))
         return val;
 
     return 0;
 }
 
 static int
-testMerge( void )
+testMerge (void)
 {
     tr_benc dest, src;
     int64_t i;
     const char * s;
 
     /* initial dictionary (default values)  */
-    tr_bencInitDict( &dest, 10 );
-    tr_bencDictAddInt( &dest, "i1", 1 );
-    tr_bencDictAddInt( &dest, "i2", 2 );
-    tr_bencDictAddInt( &dest, "i4", -35 ); /* remains untouched */
-    tr_bencDictAddStr( &dest, "s5", "abc" );
-    tr_bencDictAddStr( &dest, "s6", "def" );
-    tr_bencDictAddStr( &dest, "s7", "127.0.0.1" ); /* remains untouched */
+    tr_bencInitDict (&dest, 10);
+    tr_bencDictAddInt (&dest, "i1", 1);
+    tr_bencDictAddInt (&dest, "i2", 2);
+    tr_bencDictAddInt (&dest, "i4", -35); /* remains untouched */
+    tr_bencDictAddStr (&dest, "s5", "abc");
+    tr_bencDictAddStr (&dest, "s6", "def");
+    tr_bencDictAddStr (&dest, "s7", "127.0.0.1"); /* remains untouched */
 
     /* new dictionary, will overwrite items in dest  */
-    tr_bencInitDict( &src, 10 );
-    tr_bencDictAddInt( &src, "i1", 1 );     /* same value */
-    tr_bencDictAddInt( &src, "i2", 4 );     /* new value */
-    tr_bencDictAddInt( &src, "i3", 3 );     /* new key:value */
-    tr_bencDictAddStr( &src, "s5", "abc" ); /* same value */
-    tr_bencDictAddStr( &src, "s6", "xyz" ); /* new value */
-    tr_bencDictAddStr( &src, "s8", "ghi" ); /* new key:value */
+    tr_bencInitDict (&src, 10);
+    tr_bencDictAddInt (&src, "i1", 1);     /* same value */
+    tr_bencDictAddInt (&src, "i2", 4);     /* new value */
+    tr_bencDictAddInt (&src, "i3", 3);     /* new key:value */
+    tr_bencDictAddStr (&src, "s5", "abc"); /* same value */
+    tr_bencDictAddStr (&src, "s6", "xyz"); /* new value */
+    tr_bencDictAddStr (&src, "s8", "ghi"); /* new key:value */
 
-    tr_bencMergeDicts( &dest, /*const*/ &src );
+    tr_bencMergeDicts (&dest, /*const*/ &src);
 
-    check( tr_bencDictFindInt( &dest, "i1", &i ));
+    check (tr_bencDictFindInt (&dest, "i1", &i));
     check_int_eq (1, i);
-    check( tr_bencDictFindInt( &dest, "i2", &i ));
+    check (tr_bencDictFindInt (&dest, "i2", &i));
     check_int_eq (4, i);
-    check( tr_bencDictFindInt( &dest, "i3", &i ));
+    check (tr_bencDictFindInt (&dest, "i3", &i));
     check_int_eq (3, i);
-    check( tr_bencDictFindInt( &dest, "i4", &i ));
+    check (tr_bencDictFindInt (&dest, "i4", &i));
     check_int_eq (-35, i);
-    check( tr_bencDictFindStr( &dest, "s5", &s ));
+    check (tr_bencDictFindStr (&dest, "s5", &s));
     check_streq ("abc", s);
-    check( tr_bencDictFindStr( &dest, "s6", &s ));
+    check (tr_bencDictFindStr (&dest, "s6", &s));
     check_streq ("xyz", s);
-    check( tr_bencDictFindStr( &dest, "s7", &s ));
+    check (tr_bencDictFindStr (&dest, "s7", &s));
     check_streq ("127.0.0.1", s);
-    check( tr_bencDictFindStr( &dest, "s8", &s ));
+    check (tr_bencDictFindStr (&dest, "s8", &s));
     check_streq ("ghi", s);
 
-    tr_bencFree( &dest );
-    tr_bencFree( &src );
+    tr_bencFree (&dest);
+    tr_bencFree (&src);
     return 0;
 }
 
 static int
-testStackSmash( void )
+testStackSmash (void)
 {
     int             i;
     int             len;
@@ -417,61 +417,61 @@ testStackSmash( void )
     char *          saved;
     const int       depth = STACK_SMASH_DEPTH;
 
-    in = tr_new( uint8_t, depth * 2 + 1 );
-    for( i = 0; i < depth; ++i )
+    in = tr_new (uint8_t, depth * 2 + 1);
+    for (i = 0; i < depth; ++i)
     {
         in[i] = 'l';
         in[depth + i] = 'e';
     }
     in[depth * 2] = '\0';
-    err = tr_bencParse( in, in + ( depth * 2 ), &val, &end );
-    check( !err );
-    check( end == in + ( depth * 2 ) );
-    saved = tr_bencToStr( &val, TR_FMT_BENC, &len );
+    err = tr_bencParse (in, in + (depth * 2), &val, &end);
+    check (!err);
+    check (end == in + (depth * 2));
+    saved = tr_bencToStr (&val, TR_FMT_BENC, &len);
     check_streq ((char*)in, saved);
-    tr_free( in );
-    tr_free( saved );
-    tr_bencFree( &val );
+    tr_free (in);
+    tr_free (saved);
+    tr_bencFree (&val);
 
     return 0;
 }
 
 static int
-testBool( void )
+testBool (void)
 {
     tr_benc top;
     int64_t intVal;
     bool boolVal;
 
-    tr_bencInitDict( &top, 0 );
-
-    tr_bencDictAddBool( &top, "key1", false );
-    tr_bencDictAddBool( &top, "key2", 0 );
-    tr_bencDictAddInt ( &top, "key3", true );
-    tr_bencDictAddInt ( &top, "key4", 1 );
-    check( tr_bencDictFindBool( &top, "key1", &boolVal ) );
-    check( !boolVal );
-    check( tr_bencDictFindBool( &top, "key2", &boolVal ) );
-    check( !boolVal );
-    check( tr_bencDictFindBool( &top, "key3", &boolVal ) );
-    check( boolVal );
-    check( tr_bencDictFindBool( &top, "key4", &boolVal ) );
-    check( boolVal );
-    check( tr_bencDictFindInt( &top, "key1", &intVal ) );
-    check( !intVal);
-    check( tr_bencDictFindInt( &top, "key2", &intVal ) );
-    check( !intVal );
-    check( tr_bencDictFindInt( &top, "key3", &intVal ) );
-    check( intVal );
-    check( tr_bencDictFindInt( &top, "key4", &intVal ) );
-    check( intVal );
-
-    tr_bencFree( &top );
+    tr_bencInitDict (&top, 0);
+
+    tr_bencDictAddBool (&top, "key1", false);
+    tr_bencDictAddBool (&top, "key2", 0);
+    tr_bencDictAddInt (&top, "key3", true);
+    tr_bencDictAddInt (&top, "key4", 1);
+    check (tr_bencDictFindBool (&top, "key1", &boolVal));
+    check (!boolVal);
+    check (tr_bencDictFindBool (&top, "key2", &boolVal));
+    check (!boolVal);
+    check (tr_bencDictFindBool (&top, "key3", &boolVal));
+    check (boolVal);
+    check (tr_bencDictFindBool (&top, "key4", &boolVal));
+    check (boolVal);
+    check (tr_bencDictFindInt (&top, "key1", &intVal));
+    check (!intVal);
+    check (tr_bencDictFindInt (&top, "key2", &intVal));
+    check (!intVal);
+    check (tr_bencDictFindInt (&top, "key3", &intVal));
+    check (intVal);
+    check (tr_bencDictFindInt (&top, "key4", &intVal));
+    check (intVal);
+
+    tr_bencFree (&top);
     return 0;
 }
 
 static int
-testParse2( void )
+testParse2 (void)
 {
     tr_benc top;
     tr_benc top2;
@@ -483,40 +483,40 @@ testParse2( void )
     char * benc;
     const uint8_t * end;
 
-    tr_bencInitDict( &top, 0 );
-    tr_bencDictAddBool( &top, "this-is-a-bool", true );
-    tr_bencDictAddInt( &top, "this-is-an-int", 1234 );
-    tr_bencDictAddReal( &top, "this-is-a-real", 0.5 );
-    tr_bencDictAddStr( &top, "this-is-a-string", "this-is-a-string" );
-
-    benc = tr_bencToStr( &top, TR_FMT_BENC, &len );
-    check_streq( "d14:this-is-a-booli1e14:this-is-a-real8:0.50000016:this-is-a-string16:this-is-a-string14:this-is-an-inti1234ee", benc );
-    check( !tr_bencParse( benc, benc+len, &top2, &end ) );
-    check( (char*)end == benc + len );
-    check( tr_bencIsDict( &top2 ) );
-    check( tr_bencDictFindInt( &top, "this-is-an-int", &intVal ) );
+    tr_bencInitDict (&top, 0);
+    tr_bencDictAddBool (&top, "this-is-a-bool", true);
+    tr_bencDictAddInt (&top, "this-is-an-int", 1234);
+    tr_bencDictAddReal (&top, "this-is-a-real", 0.5);
+    tr_bencDictAddStr (&top, "this-is-a-string", "this-is-a-string");
+
+    benc = tr_bencToStr (&top, TR_FMT_BENC, &len);
+    check_streq ("d14:this-is-a-booli1e14:this-is-a-real8:0.50000016:this-is-a-string16:this-is-a-string14:this-is-an-inti1234ee", benc);
+    check (!tr_bencParse (benc, benc+len, &top2, &end));
+    check ((char*)end == benc + len);
+    check (tr_bencIsDict (&top2));
+    check (tr_bencDictFindInt (&top, "this-is-an-int", &intVal));
     check_int_eq (1234, intVal);
-    check( tr_bencDictFindBool( &top, "this-is-a-bool", &boolVal ) );
-    check( boolVal == true );
-    check( tr_bencDictFindStr( &top, "this-is-a-string", &strVal ) );
+    check (tr_bencDictFindBool (&top, "this-is-a-bool", &boolVal));
+    check (boolVal == true);
+    check (tr_bencDictFindStr (&top, "this-is-a-string", &strVal));
     check_streq ("this-is-a-string", strVal);
-    check( tr_bencDictFindReal( &top, "this-is-a-real", &realVal ) );
+    check (tr_bencDictFindReal (&top, "this-is-a-real", &realVal));
     check_int_eq (50, (int)(realVal*100));
 
-    tr_bencFree( &top2 );
-    tr_free( benc );
-    tr_bencFree( &top );
+    tr_bencFree (&top2);
+    tr_free (benc);
+    tr_bencFree (&top);
 
     return 0;
 }
 
 int
-main( void )
+main (void)
 {
     static const testFunc tests[] = {
 	testInt, testStr, testParse, testJSON, testMerge, testBool,
 	testParse2, testStackSmash,
     };
 
-    return runTests(tests, NUM_TESTS(tests));
+    return runTests (tests, NUM_TESTS (tests));
 }
diff --git a/libtransmission/bencode.c b/libtransmission/bencode.c
index 127bd4234..576c973da 100644
--- a/libtransmission/bencode.c
+++ b/libtransmission/bencode.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,21 +11,21 @@
  */
 
 #include <assert.h>
-#include <ctype.h> /* isdigit() */
+#include <ctype.h> /* isdigit () */
 #include <errno.h>
-#include <math.h> /* fabs() */
-#include <stdio.h> /* rename() */
-#include <stdlib.h> /* strtoul(), strtod(), realloc(), qsort(), mkstemp() */
+#include <math.h> /* fabs () */
+#include <stdio.h> /* rename () */
+#include <stdlib.h> /* strtoul (), strtod (), realloc (), qsort (), mkstemp () */
 #include <string.h>
 
-#ifdef WIN32 /* tr_mkstemp() */
+#ifdef WIN32 /* tr_mkstemp () */
  #include <fcntl.h>
  #define _S_IREAD 256
  #define _S_IWRITE 128
 #endif
 
-#include <locale.h> /* setlocale() */
-#include <unistd.h> /* write(), unlink() */
+#include <locale.h> /* setlocale () */
+#include <unistd.h> /* write (), unlink () */
 
 #include <event2/buffer.h>
 
@@ -33,12 +33,12 @@
 
 #include "transmission.h"
 #include "bencode.h"
-#include "fdlimit.h" /* tr_close_file() */
+#include "fdlimit.h" /* tr_close_file () */
 #include "json.h"
 #include "list.h"
 #include "platform.h" /* TR_PATH_MAX */
 #include "ptrarray.h"
-#include "utils.h" /* tr_new(), tr_free() */
+#include "utils.h" /* tr_new (), tr_free () */
 
 #ifndef ENODATA
  #define ENODATA EIO
@@ -49,30 +49,30 @@
 **/
 
 static bool
-isContainer( const tr_benc * val )
+isContainer (const tr_benc * val)
 {
-    return tr_bencIsList( val ) || tr_bencIsDict( val );
+    return tr_bencIsList (val) || tr_bencIsDict (val);
 }
 
 static bool
-isSomething( const tr_benc * val )
+isSomething (const tr_benc * val)
 {
-    return isContainer( val ) || tr_bencIsInt( val )
-                              || tr_bencIsString( val )
-                              || tr_bencIsReal( val )
-                              || tr_bencIsBool( val );
+    return isContainer (val) || tr_bencIsInt (val)
+                              || tr_bencIsString (val)
+                              || tr_bencIsReal (val)
+                              || tr_bencIsBool (val);
 }
 
 static void
-tr_bencInit( tr_benc * val, char type )
+tr_bencInit (tr_benc * val, char type)
 {
-    memset( val, 0, sizeof( *val ) );
+    memset (val, 0, sizeof (*val));
     val->type = type;
 }
 
 /***
-****  tr_bencParse()
-****  tr_bencLoad()
+****  tr_bencParse ()
+****  tr_bencLoad ()
 ***/
 
 /**
@@ -85,31 +85,31 @@ tr_bencInit( tr_benc * val, char type )
  * "large files" aka .torrent for more that 4Gbyte
  */
 int
-tr_bencParseInt( const uint8_t *  buf,
+tr_bencParseInt (const uint8_t *  buf,
                  const uint8_t *  bufend,
                  const uint8_t ** setme_end,
-                 int64_t *        setme_val )
+                 int64_t *        setme_val)
 {
     char *       endptr;
     const void * begin;
     const void * end;
     int64_t      val;
 
-    if( buf >= bufend )
+    if (buf >= bufend)
         return EILSEQ;
-    if( *buf != 'i' )
+    if (*buf != 'i')
         return EILSEQ;
 
     begin = buf + 1;
-    end = memchr( begin, 'e', ( bufend - buf ) - 1 );
-    if( end == NULL )
+    end = memchr (begin, 'e', (bufend - buf) - 1);
+    if (end == NULL)
         return EILSEQ;
 
     errno = 0;
-    val = evutil_strtoll( begin, &endptr, 10 );
-    if( errno || ( endptr != end ) ) /* incomplete parse */
+    val = evutil_strtoll (begin, &endptr, 10);
+    if (errno || (endptr != end)) /* incomplete parse */
         return EILSEQ;
-    if( val && *(const char*)begin == '0' ) /* no leading zeroes! */
+    if (val && * (const char*)begin == '0') /* no leading zeroes! */
         return EILSEQ;
 
     *setme_end = (const uint8_t*)end + 1;
@@ -124,32 +124,32 @@ tr_bencParseInt( const uint8_t *  buf,
  * Example: 4:spam represents the string "spam"
  */
 int
-tr_bencParseStr( const uint8_t *  buf,
+tr_bencParseStr (const uint8_t *  buf,
                  const uint8_t *  bufend,
                  const uint8_t ** setme_end,
                  const uint8_t ** setme_str,
-                 size_t *         setme_strlen )
+                 size_t *         setme_strlen)
 {
     size_t       len;
     const void * end;
     char *       endptr;
 
-    if( buf >= bufend )
+    if (buf >= bufend)
         return EILSEQ;
 
-    if( !isdigit( *buf  ) )
+    if (!isdigit (*buf))
         return EILSEQ;
 
-    end = memchr( buf, ':', bufend - buf );
-    if( end == NULL )
+    end = memchr (buf, ':', bufend - buf);
+    if (end == NULL)
         return EILSEQ;
 
     errno = 0;
-    len = strtoul( (const char*)buf, &endptr, 10 );
-    if( errno || endptr != end )
+    len = strtoul ((const char*)buf, &endptr, 10);
+    if (errno || endptr != end)
         return EILSEQ;
 
-    if( (const uint8_t*)end + 1 + len > bufend )
+    if ((const uint8_t*)end + 1 + len > bufend)
         return EILSEQ;
 
     *setme_end = (const uint8_t*)end + 1 + len;
@@ -162,19 +162,19 @@ tr_bencParseStr( const uint8_t *  buf,
 #define LIST_SIZE 4 /* number of items to increment list/dict buffer by */
 
 static int
-makeroom( tr_benc * val,
-          size_t    count )
+makeroom (tr_benc * val,
+          size_t    count)
 {
-    assert( TR_TYPE_LIST == val->type || TR_TYPE_DICT == val->type );
+    assert (TR_TYPE_LIST == val->type || TR_TYPE_DICT == val->type);
 
-    if( val->val.l.count + count > val->val.l.alloc )
+    if (val->val.l.count + count > val->val.l.alloc)
     {
         /* We need a bigger boat */
         const int len = val->val.l.alloc + count +
-                        ( count % LIST_SIZE ? LIST_SIZE -
-                          ( count % LIST_SIZE ) : 0 );
-        void * tmp = realloc( val->val.l.vals, len * sizeof( tr_benc ) );
-        if( !tmp )
+                      (count % LIST_SIZE ? LIST_SIZE -
+                        (count % LIST_SIZE) : 0);
+        void * tmp = realloc (val->val.l.vals, len * sizeof (tr_benc));
+        if (!tmp)
             return 1;
 
         val->val.l.alloc = len;
@@ -185,28 +185,28 @@ makeroom( tr_benc * val,
 }
 
 static tr_benc*
-getNode( tr_benc *     top,
+getNode (tr_benc *     top,
          tr_ptrArray * parentStack,
-         int           type )
+         int           type)
 {
     tr_benc * parent;
 
-    assert( top );
-    assert( parentStack );
+    assert (top);
+    assert (parentStack);
 
-    if( tr_ptrArrayEmpty( parentStack ) )
+    if (tr_ptrArrayEmpty (parentStack))
         return top;
 
-    parent = tr_ptrArrayBack( parentStack );
-    assert( parent );
+    parent = tr_ptrArrayBack (parentStack);
+    assert (parent);
 
     /* dictionary keys must be strings */
-    if( ( parent->type == TR_TYPE_DICT )
-      && ( type != TR_TYPE_STR )
-      && ( !( parent->val.l.count % 2 ) ) )
+    if ((parent->type == TR_TYPE_DICT)
+      && (type != TR_TYPE_STR)
+      && (! (parent->val.l.count % 2)))
         return NULL;
 
-    makeroom( parent, 1 );
+    makeroom (parent, 1);
     return parent->val.l.vals + parent->val.l.count++;
 }
 
@@ -216,97 +216,97 @@ getNode( tr_benc *     top,
  * attack via maliciously-crafted bencoded data. (#667)
  */
 static int
-tr_bencParseImpl( const void *     buf_in,
+tr_bencParseImpl (const void *     buf_in,
                   const void *     bufend_in,
                   tr_benc *        top,
                   tr_ptrArray *    parentStack,
-                  const uint8_t ** setme_end )
+                  const uint8_t ** setme_end)
 {
     int             err;
     const uint8_t * buf = buf_in;
     const uint8_t * bufend = bufend_in;
 
-    tr_bencInit( top, 0 );
+    tr_bencInit (top, 0);
 
-    while( buf != bufend )
+    while (buf != bufend)
     {
-        if( buf > bufend ) /* no more text to parse... */
+        if (buf > bufend) /* no more text to parse... */
             return 1;
 
-        if( *buf == 'i' ) /* int */
+        if (*buf == 'i') /* int */
         {
             int64_t         val;
             const uint8_t * end;
             tr_benc *       node;
 
-            if( ( err = tr_bencParseInt( buf, bufend, &end, &val ) ) )
+            if ((err = tr_bencParseInt (buf, bufend, &end, &val)))
                 return err;
 
-            node = getNode( top, parentStack, TR_TYPE_INT );
-            if( !node )
+            node = getNode (top, parentStack, TR_TYPE_INT);
+            if (!node)
                 return EILSEQ;
 
-            tr_bencInitInt( node, val );
+            tr_bencInitInt (node, val);
             buf = end;
 
-            if( tr_ptrArrayEmpty( parentStack ) )
+            if (tr_ptrArrayEmpty (parentStack))
                 break;
         }
-        else if( *buf == 'l' ) /* list */
+        else if (*buf == 'l') /* list */
         {
-            tr_benc * node = getNode( top, parentStack, TR_TYPE_LIST );
-            if( !node )
+            tr_benc * node = getNode (top, parentStack, TR_TYPE_LIST);
+            if (!node)
                 return EILSEQ;
-            tr_bencInit( node, TR_TYPE_LIST );
-            tr_ptrArrayAppend( parentStack, node );
+            tr_bencInit (node, TR_TYPE_LIST);
+            tr_ptrArrayAppend (parentStack, node);
             ++buf;
         }
-        else if( *buf == 'd' ) /* dict */
+        else if (*buf == 'd') /* dict */
         {
-            tr_benc * node = getNode( top, parentStack, TR_TYPE_DICT );
-            if( !node )
+            tr_benc * node = getNode (top, parentStack, TR_TYPE_DICT);
+            if (!node)
                 return EILSEQ;
-            tr_bencInit( node, TR_TYPE_DICT );
-            tr_ptrArrayAppend( parentStack, node );
+            tr_bencInit (node, TR_TYPE_DICT);
+            tr_ptrArrayAppend (parentStack, node);
             ++buf;
         }
-        else if( *buf == 'e' ) /* end of list or dict */
+        else if (*buf == 'e') /* end of list or dict */
         {
             tr_benc * node;
             ++buf;
-            if( tr_ptrArrayEmpty( parentStack ) )
+            if (tr_ptrArrayEmpty (parentStack))
                 return EILSEQ;
 
-            node = tr_ptrArrayBack( parentStack );
-            if( tr_bencIsDict( node ) && ( node->val.l.count % 2 ) )
+            node = tr_ptrArrayBack (parentStack);
+            if (tr_bencIsDict (node) && (node->val.l.count % 2))
             {
                 /* odd # of children in dict */
-                tr_bencFree( &node->val.l.vals[--node->val.l.count] );
+                tr_bencFree (&node->val.l.vals[--node->val.l.count]);
                 return EILSEQ;
             }
 
-            tr_ptrArrayPop( parentStack );
-            if( tr_ptrArrayEmpty( parentStack ) )
+            tr_ptrArrayPop (parentStack);
+            if (tr_ptrArrayEmpty (parentStack))
                 break;
         }
-        else if( isdigit( *buf ) ) /* string? */
+        else if (isdigit (*buf)) /* string? */
         {
             const uint8_t * end;
             const uint8_t * str;
             size_t          str_len;
             tr_benc *       node;
 
-            if( ( err = tr_bencParseStr( buf, bufend, &end, &str, &str_len ) ) )
+            if ((err = tr_bencParseStr (buf, bufend, &end, &str, &str_len)))
                 return err;
 
-            node = getNode( top, parentStack, TR_TYPE_STR );
-            if( !node )
+            node = getNode (top, parentStack, TR_TYPE_STR);
+            if (!node)
                 return EILSEQ;
 
-            tr_bencInitStr( node, str, str_len );
+            tr_bencInitStr (node, str, str_len);
             buf = end;
 
-            if( tr_ptrArrayEmpty( parentStack ) )
+            if (tr_ptrArrayEmpty (parentStack))
                 break;
         }
         else /* invalid bencoded text... march past it */
@@ -315,43 +315,43 @@ tr_bencParseImpl( const void *     buf_in,
         }
     }
 
-    err = !isSomething( top ) || !tr_ptrArrayEmpty( parentStack );
+    err = !isSomething (top) || !tr_ptrArrayEmpty (parentStack);
 
-    if( !err && setme_end )
+    if (!err && setme_end)
         *setme_end = buf;
 
     return err;
 }
 
 int
-tr_bencParse( const void *     buf,
+tr_bencParse (const void *     buf,
               const void *     end,
               tr_benc *        top,
-              const uint8_t ** setme_end )
+              const uint8_t ** setme_end)
 {
     int           err;
     tr_ptrArray   parentStack = TR_PTR_ARRAY_INIT;
 
     top->type = 0; /* set to `uninitialized' */
-    err = tr_bencParseImpl( buf, end, top, &parentStack, setme_end );
-    if( err )
-        tr_bencFree( top );
+    err = tr_bencParseImpl (buf, end, top, &parentStack, setme_end);
+    if (err)
+        tr_bencFree (top);
 
-    tr_ptrArrayDestruct( &parentStack, NULL );
+    tr_ptrArrayDestruct (&parentStack, NULL);
     return err;
 }
 
 int
-tr_bencLoad( const void * buf_in,
+tr_bencLoad (const void * buf_in,
              size_t       buflen,
              tr_benc *    setme_benc,
-             char **      setme_end )
+             char **      setme_end)
 {
     const uint8_t * buf = buf_in;
     const uint8_t * end;
-    const int       ret = tr_bencParse( buf, buf + buflen, setme_benc, &end );
+    const int       ret = tr_bencParse (buf, buf + buflen, setme_benc, &end);
 
-    if( !ret && setme_end )
+    if (!ret && setme_end)
         *setme_end = (char*) end;
     return ret;
 }
@@ -363,32 +363,32 @@ tr_bencLoad( const void * buf_in,
 /* returns true if the benc's string was malloced.
  * this occurs when the string is too long for our string buffer */
 static inline int
-stringIsAlloced( const tr_benc * val )
+stringIsAlloced (const tr_benc * val)
 {
-    return val->val.s.len >= sizeof( val->val.s.str.buf );
+    return val->val.s.len >= sizeof (val->val.s.str.buf);
 }
 
 /* returns a const pointer to the benc's string */
 static inline const char*
-getStr( const tr_benc* val )
+getStr (const tr_benc* val)
 {
-    return stringIsAlloced(val) ? val->val.s.str.ptr : val->val.s.str.buf;
+    return stringIsAlloced (val) ? val->val.s.str.ptr : val->val.s.str.buf;
 }
 
 static int
-dictIndexOf( const tr_benc * val, const char * key )
+dictIndexOf (const tr_benc * val, const char * key)
 {
-    if( tr_bencIsDict( val ) )
+    if (tr_bencIsDict (val))
     {
         size_t       i;
-        const size_t len = strlen( key );
+        const size_t len = strlen (key);
 
-        for( i = 0; ( i + 1 ) < val->val.l.count; i += 2 )
+        for (i = 0; (i + 1) < val->val.l.count; i += 2)
         {
             const tr_benc * child = val->val.l.vals + i;
-            if( ( child->type == TR_TYPE_STR )
-              && ( child->val.s.len == len )
-              && !memcmp( getStr(child), key, len ) )
+            if ((child->type == TR_TYPE_STR)
+              && (child->val.s.len == len)
+              && !memcmp (getStr (child), key, len))
                 return i;
         }
     }
@@ -397,43 +397,43 @@ dictIndexOf( const tr_benc * val, const char * key )
 }
 
 tr_benc *
-tr_bencDictFind( tr_benc * val, const char * key )
+tr_bencDictFind (tr_benc * val, const char * key)
 {
-    const int i = dictIndexOf( val, key );
+    const int i = dictIndexOf (val, key);
 
     return i < 0 ? NULL : &val->val.l.vals[i + 1];
 }
 
 static bool
-tr_bencDictFindType( tr_benc * dict, const char * key, int type, tr_benc ** setme )
+tr_bencDictFindType (tr_benc * dict, const char * key, int type, tr_benc ** setme)
 {
-    return tr_bencIsType( *setme = tr_bencDictFind( dict, key ), type );
+    return tr_bencIsType (*setme = tr_bencDictFind (dict, key), type);
 }
 
 size_t
-tr_bencListSize( const tr_benc * list )
+tr_bencListSize (const tr_benc * list)
 {
-    return tr_bencIsList( list ) ? list->val.l.count : 0;
+    return tr_bencIsList (list) ? list->val.l.count : 0;
 }
 
 tr_benc*
-tr_bencListChild( tr_benc * val,
-                  size_t    i )
+tr_bencListChild (tr_benc * val,
+                  size_t    i)
 {
     tr_benc * ret = NULL;
 
-    if( tr_bencIsList( val ) && ( i < val->val.l.count ) )
+    if (tr_bencIsList (val) && (i < val->val.l.count))
         ret = val->val.l.vals + i;
     return ret;
 }
 
 int
-tr_bencListRemove( tr_benc * list, size_t i )
+tr_bencListRemove (tr_benc * list, size_t i)
 {
-    if( tr_bencIsList( list ) && ( i < list->val.l.count ) )
+    if (tr_bencIsList (list) && (i < list->val.l.count))
     {
-        tr_bencFree( &list->val.l.vals[i] );
-        tr_removeElementFromArray( list->val.l.vals, i, sizeof( tr_benc ), list->val.l.count-- );
+        tr_bencFree (&list->val.l.vals[i]);
+        tr_removeElementFromArray (list->val.l.vals, i, sizeof (tr_benc), list->val.l.count--);
         return 1;
     }
 
@@ -441,24 +441,24 @@ tr_bencListRemove( tr_benc * list, size_t i )
 }
 
 static void
-tr_benc_warning( const char * err )
+tr_benc_warning (const char * err)
 {
-    fprintf( stderr, "warning: %s\n", err );
+    fprintf (stderr, "warning: %s\n", err);
 }
 
 bool
-tr_bencGetInt( const tr_benc * val,
-               int64_t *       setme )
+tr_bencGetInt (const tr_benc * val,
+               int64_t *       setme)
 {
     bool success = false;
 
-    if( !success && (( success = tr_bencIsInt( val ))))
-        if( setme )
+    if (!success && ((success = tr_bencIsInt (val))))
+        if (setme)
             *setme = val->val.i;
 
-    if( !success && (( success = tr_bencIsBool( val )))) {
-        tr_benc_warning( "reading bool as an int" );
-        if( setme )
+    if (!success && ((success = tr_bencIsBool (val)))) {
+        tr_benc_warning ("reading bool as an int");
+        if (setme)
             *setme = val->val.b ? 1 : 0;
     }
 
@@ -466,23 +466,23 @@ tr_bencGetInt( const tr_benc * val,
 }
 
 bool
-tr_bencGetStr( const tr_benc * val, const char ** setme )
+tr_bencGetStr (const tr_benc * val, const char ** setme)
 {
-    const bool success = tr_bencIsString( val );
+    const bool success = tr_bencIsString (val);
 
-    if( success )
-        *setme = getStr( val );
+    if (success)
+        *setme = getStr (val);
 
     return success;
 }
 
 bool
-tr_bencGetRaw( const tr_benc * val, const uint8_t ** setme_raw, size_t * setme_len )
+tr_bencGetRaw (const tr_benc * val, const uint8_t ** setme_raw, size_t * setme_len)
 {
-    const bool success = tr_bencIsString( val );
+    const bool success = tr_bencIsString (val);
 
-    if( success ) {
-        *setme_raw = (uint8_t*) getStr(val);
+    if (success) {
+        *setme_raw = (uint8_t*) getStr (val);
         *setme_len = val->val.s.len;
     }
 
@@ -490,49 +490,49 @@ tr_bencGetRaw( const tr_benc * val, const uint8_t ** setme_raw, size_t * setme_l
 }
 
 bool
-tr_bencGetBool( const tr_benc * val, bool * setme )
+tr_bencGetBool (const tr_benc * val, bool * setme)
 {
     const char * str;
     bool success = false;
 
-    if(( success = tr_bencIsBool( val )))
+    if ((success = tr_bencIsBool (val)))
         *setme = val->val.b;
 
-    if( !success && tr_bencIsInt( val ) )
-        if(( success = ( val->val.i==0 || val->val.i==1 ) ))
+    if (!success && tr_bencIsInt (val))
+        if ((success = (val->val.i==0 || val->val.i==1)))
             *setme = val->val.i!=0;
 
-    if( !success && tr_bencGetStr( val, &str ) )
-        if(( success = ( !strcmp(str,"true") || !strcmp(str,"false"))))
-            *setme = !strcmp(str,"true");
+    if (!success && tr_bencGetStr (val, &str))
+        if ((success = (!strcmp (str,"true") || !strcmp (str,"false"))))
+            *setme = !strcmp (str,"true");
 
     return success;
 }
 
 bool
-tr_bencGetReal( const tr_benc * val, double * setme )
+tr_bencGetReal (const tr_benc * val, double * setme)
 {
     bool success = false;
 
-    if( !success && (( success = tr_bencIsReal( val ))))
+    if (!success && ((success = tr_bencIsReal (val))))
         *setme = val->val.d;
 
-    if( !success && (( success = tr_bencIsInt( val ))))
+    if (!success && ((success = tr_bencIsInt (val))))
         *setme = val->val.i;
 
-    if( !success && tr_bencIsString(val) )
+    if (!success && tr_bencIsString (val))
     {
         char * endptr;
         char locale[128];
         double d;
 
         /* the json spec requires a '.' decimal point regardless of locale */
-        tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
-        setlocale( LC_NUMERIC, "POSIX" );
-        d  = strtod( getStr(val), &endptr );
-        setlocale( LC_NUMERIC, locale );
+        tr_strlcpy (locale, setlocale (LC_NUMERIC, NULL), sizeof (locale));
+        setlocale (LC_NUMERIC, "POSIX");
+        d  = strtod (getStr (val), &endptr);
+        setlocale (LC_NUMERIC, locale);
 
-        if(( success = ( getStr(val) != endptr ) && !*endptr ))
+        if ((success = (getStr (val) != endptr) && !*endptr))
             *setme = d;
     }
 
@@ -541,45 +541,45 @@ tr_bencGetReal( const tr_benc * val, double * setme )
 }
 
 bool
-tr_bencDictFindInt( tr_benc * dict, const char * key, int64_t * setme )
+tr_bencDictFindInt (tr_benc * dict, const char * key, int64_t * setme)
 {
-    return tr_bencGetInt( tr_bencDictFind( dict, key ), setme );
+    return tr_bencGetInt (tr_bencDictFind (dict, key), setme);
 }
 
 bool
-tr_bencDictFindBool( tr_benc * dict, const char * key, bool * setme )
+tr_bencDictFindBool (tr_benc * dict, const char * key, bool * setme)
 {
-    return tr_bencGetBool( tr_bencDictFind( dict, key ), setme );
+    return tr_bencGetBool (tr_bencDictFind (dict, key), setme);
 }
 
 bool
-tr_bencDictFindReal( tr_benc * dict, const char * key, double * setme )
+tr_bencDictFindReal (tr_benc * dict, const char * key, double * setme)
 {
-    return tr_bencGetReal( tr_bencDictFind( dict, key ), setme );
+    return tr_bencGetReal (tr_bencDictFind (dict, key), setme);
 }
 
 bool
-tr_bencDictFindStr( tr_benc *  dict, const char *  key, const char ** setme )
+tr_bencDictFindStr (tr_benc *  dict, const char *  key, const char ** setme)
 {
-    return tr_bencGetStr( tr_bencDictFind( dict, key ), setme );
+    return tr_bencGetStr (tr_bencDictFind (dict, key), setme);
 }
 
 bool
-tr_bencDictFindList( tr_benc * dict, const char * key, tr_benc ** setme )
+tr_bencDictFindList (tr_benc * dict, const char * key, tr_benc ** setme)
 {
-    return tr_bencDictFindType( dict, key, TR_TYPE_LIST, setme );
+    return tr_bencDictFindType (dict, key, TR_TYPE_LIST, setme);
 }
 
 bool
-tr_bencDictFindDict( tr_benc * dict, const char * key, tr_benc ** setme )
+tr_bencDictFindDict (tr_benc * dict, const char * key, tr_benc ** setme)
 {
-    return tr_bencDictFindType( dict, key, TR_TYPE_DICT, setme );
+    return tr_bencDictFindType (dict, key, TR_TYPE_DICT, setme);
 }
 
 bool
-tr_bencDictFindRaw( tr_benc * dict, const char * key, const uint8_t  ** setme_raw, size_t * setme_len )
+tr_bencDictFindRaw (tr_benc * dict, const char * key, const uint8_t  ** setme_raw, size_t * setme_len)
 {
-    return tr_bencGetRaw( tr_bencDictFind( dict, key ), setme_raw, setme_len );
+    return tr_bencGetRaw (tr_bencDictFind (dict, key), setme_raw, setme_len);
 }
 
 /***
@@ -587,322 +587,322 @@ tr_bencDictFindRaw( tr_benc * dict, const char * key, const uint8_t  ** setme_ra
 ***/
 
 void
-tr_bencInitRaw( tr_benc * val, const void * src, size_t byteCount )
+tr_bencInitRaw (tr_benc * val, const void * src, size_t byteCount)
 {
     char * setme;
-    tr_bencInit( val, TR_TYPE_STR );
+    tr_bencInit (val, TR_TYPE_STR);
 
     /* There's no way in benc notation to distinguish between
      * zero-terminated strings and raw byte arrays.
-     * Because of this, tr_bencMergeDicts() and tr_bencListCopy()
+     * Because of this, tr_bencMergeDicts () and tr_bencListCopy ()
      * don't know whether or not a TR_TYPE_STR node needs a '\0'.
      * Append one, een to the raw arrays, just to be safe. */
 
-    if( byteCount < sizeof( val->val.s.str.buf ) )
+    if (byteCount < sizeof (val->val.s.str.buf))
         setme = val->val.s.str.buf;
     else
-        setme = val->val.s.str.ptr = tr_new( char, byteCount + 1 );
+        setme = val->val.s.str.ptr = tr_new (char, byteCount + 1);
 
-    memcpy( setme, src, byteCount );
+    memcpy (setme, src, byteCount);
     setme[byteCount] = '\0';
     val->val.s.len = byteCount;
 }
 
 void
-tr_bencInitStr( tr_benc * val, const void * str, int len )
+tr_bencInitStr (tr_benc * val, const void * str, int len)
 {
-    if( str == NULL )
+    if (str == NULL)
         len = 0;
-    else if( len < 0 )
-        len = strlen( str );
+    else if (len < 0)
+        len = strlen (str);
 
-    tr_bencInitRaw( val, str, len );
+    tr_bencInitRaw (val, str, len);
 }
 
 void
-tr_bencInitBool( tr_benc * b, int value )
+tr_bencInitBool (tr_benc * b, int value)
 {
-    tr_bencInit( b, TR_TYPE_BOOL );
+    tr_bencInit (b, TR_TYPE_BOOL);
     b->val.b = value != 0;
 }
 
 void
-tr_bencInitReal( tr_benc * b, double value )
+tr_bencInitReal (tr_benc * b, double value)
 {
-    tr_bencInit( b, TR_TYPE_REAL );
+    tr_bencInit (b, TR_TYPE_REAL);
     b->val.d = value;
 }
 
 void
-tr_bencInitInt( tr_benc * b, int64_t value )
+tr_bencInitInt (tr_benc * b, int64_t value)
 {
-    tr_bencInit( b, TR_TYPE_INT );
+    tr_bencInit (b, TR_TYPE_INT);
     b->val.i = value;
 }
 
 int
-tr_bencInitList( tr_benc * b, size_t reserveCount )
+tr_bencInitList (tr_benc * b, size_t reserveCount)
 {
-    tr_bencInit( b, TR_TYPE_LIST );
-    return tr_bencListReserve( b, reserveCount );
+    tr_bencInit (b, TR_TYPE_LIST);
+    return tr_bencListReserve (b, reserveCount);
 }
 
 int
-tr_bencListReserve( tr_benc * b, size_t count )
+tr_bencListReserve (tr_benc * b, size_t count)
 {
-    assert( tr_bencIsList( b ) );
-    return makeroom( b, count );
+    assert (tr_bencIsList (b));
+    return makeroom (b, count);
 }
 
 int
-tr_bencInitDict( tr_benc * b, size_t reserveCount )
+tr_bencInitDict (tr_benc * b, size_t reserveCount)
 {
-    tr_bencInit( b, TR_TYPE_DICT );
-    return tr_bencDictReserve( b, reserveCount );
+    tr_bencInit (b, TR_TYPE_DICT);
+    return tr_bencDictReserve (b, reserveCount);
 }
 
 int
-tr_bencDictReserve( tr_benc * b, size_t reserveCount )
+tr_bencDictReserve (tr_benc * b, size_t reserveCount)
 {
-    assert( tr_bencIsDict( b ) );
-    return makeroom( b, reserveCount * 2 );
+    assert (tr_bencIsDict (b));
+    return makeroom (b, reserveCount * 2);
 }
 
 tr_benc *
-tr_bencListAdd( tr_benc * list )
+tr_bencListAdd (tr_benc * list)
 {
     tr_benc * item;
 
-    assert( tr_bencIsList( list ) );
+    assert (tr_bencIsList (list));
 
-    if( list->val.l.count == list->val.l.alloc )
-        tr_bencListReserve( list, LIST_SIZE );
+    if (list->val.l.count == list->val.l.alloc)
+        tr_bencListReserve (list, LIST_SIZE);
 
-    assert( list->val.l.count < list->val.l.alloc );
+    assert (list->val.l.count < list->val.l.alloc);
 
     item = &list->val.l.vals[list->val.l.count];
     list->val.l.count++;
-    tr_bencInit( item, TR_TYPE_INT );
+    tr_bencInit (item, TR_TYPE_INT);
 
     return item;
 }
 
 tr_benc *
-tr_bencListAddInt( tr_benc * list, int64_t val )
+tr_bencListAddInt (tr_benc * list, int64_t val)
 {
-    tr_benc * node = tr_bencListAdd( list );
+    tr_benc * node = tr_bencListAdd (list);
 
-    tr_bencInitInt( node, val );
+    tr_bencInitInt (node, val);
     return node;
 }
 
 tr_benc *
-tr_bencListAddReal( tr_benc * list, double val )
+tr_bencListAddReal (tr_benc * list, double val)
 {
-    tr_benc * node = tr_bencListAdd( list );
-    tr_bencInitReal( node, val );
+    tr_benc * node = tr_bencListAdd (list);
+    tr_bencInitReal (node, val);
     return node;
 }
 
 tr_benc *
-tr_bencListAddBool( tr_benc * list, bool val )
+tr_bencListAddBool (tr_benc * list, bool val)
 {
-    tr_benc * node = tr_bencListAdd( list );
-    tr_bencInitBool( node, val );
+    tr_benc * node = tr_bencListAdd (list);
+    tr_bencInitBool (node, val);
     return node;
 }
 
 tr_benc *
-tr_bencListAddStr( tr_benc * list, const char * val )
+tr_bencListAddStr (tr_benc * list, const char * val)
 {
-    tr_benc * node = tr_bencListAdd( list );
-    tr_bencInitStr( node, val, -1 );
+    tr_benc * node = tr_bencListAdd (list);
+    tr_bencInitStr (node, val, -1);
     return node;
 }
 
 tr_benc *
-tr_bencListAddRaw( tr_benc * list, const uint8_t * val, size_t len )
+tr_bencListAddRaw (tr_benc * list, const uint8_t * val, size_t len)
 {
-    tr_benc * node = tr_bencListAdd( list );
-    tr_bencInitRaw( node, val, len );
+    tr_benc * node = tr_bencListAdd (list);
+    tr_bencInitRaw (node, val, len);
     return node;
 }
 
 tr_benc*
-tr_bencListAddList( tr_benc * list,
-                    size_t    reserveCount )
+tr_bencListAddList (tr_benc * list,
+                    size_t    reserveCount)
 {
-    tr_benc * child = tr_bencListAdd( list );
+    tr_benc * child = tr_bencListAdd (list);
 
-    tr_bencInitList( child, reserveCount );
+    tr_bencInitList (child, reserveCount);
     return child;
 }
 
 tr_benc*
-tr_bencListAddDict( tr_benc * list,
-                    size_t    reserveCount )
+tr_bencListAddDict (tr_benc * list,
+                    size_t    reserveCount)
 {
-    tr_benc * child = tr_bencListAdd( list );
+    tr_benc * child = tr_bencListAdd (list);
 
-    tr_bencInitDict( child, reserveCount );
+    tr_bencInitDict (child, reserveCount);
     return child;
 }
 
 tr_benc *
-tr_bencDictAdd( tr_benc *    dict,
-                const char * key )
+tr_bencDictAdd (tr_benc *    dict,
+                const char * key)
 {
     tr_benc * keyval, * itemval;
 
-    assert( tr_bencIsDict( dict ) );
-    if( dict->val.l.count + 2 > dict->val.l.alloc )
-        makeroom( dict, 2 );
-    assert( dict->val.l.count + 2 <= dict->val.l.alloc );
+    assert (tr_bencIsDict (dict));
+    if (dict->val.l.count + 2 > dict->val.l.alloc)
+        makeroom (dict, 2);
+    assert (dict->val.l.count + 2 <= dict->val.l.alloc);
 
     keyval = dict->val.l.vals + dict->val.l.count++;
-    tr_bencInitStr( keyval, key, -1 );
+    tr_bencInitStr (keyval, key, -1);
 
     itemval = dict->val.l.vals + dict->val.l.count++;
-    tr_bencInit( itemval, TR_TYPE_INT );
+    tr_bencInit (itemval, TR_TYPE_INT);
 
     return itemval;
 }
 
 static tr_benc*
-dictFindOrAdd( tr_benc * dict, const char * key, int type )
+dictFindOrAdd (tr_benc * dict, const char * key, int type)
 {
     tr_benc * child;
 
     /* see if it already exists, and if so, try to reuse it */
-    if(( child = tr_bencDictFind( dict, key ))) {
-        if( !tr_bencIsType( child, type ) ) {
-            tr_bencDictRemove( dict, key );
+    if ((child = tr_bencDictFind (dict, key))) {
+        if (!tr_bencIsType (child, type)) {
+            tr_bencDictRemove (dict, key);
             child = NULL;
         }
     }
 
     /* if it doesn't exist, create it */
-    if( child == NULL )
-        child = tr_bencDictAdd( dict, key );
+    if (child == NULL)
+        child = tr_bencDictAdd (dict, key);
 
     return child;
 }
 
 tr_benc*
-tr_bencDictAddInt( tr_benc *    dict,
+tr_bencDictAddInt (tr_benc *    dict,
                    const char * key,
-                   int64_t      val )
+                   int64_t      val)
 {
-    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_INT );
-    tr_bencInitInt( child, val );
+    tr_benc * child = dictFindOrAdd (dict, key, TR_TYPE_INT);
+    tr_bencInitInt (child, val);
     return child;
 }
 
 tr_benc*
-tr_bencDictAddBool( tr_benc * dict, const char * key, bool val )
+tr_bencDictAddBool (tr_benc * dict, const char * key, bool val)
 {
-    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_BOOL );
-    tr_bencInitBool( child, val );
+    tr_benc * child = dictFindOrAdd (dict, key, TR_TYPE_BOOL);
+    tr_bencInitBool (child, val);
     return child;
 }
 
 tr_benc*
-tr_bencDictAddReal( tr_benc * dict, const char * key, double val )
+tr_bencDictAddReal (tr_benc * dict, const char * key, double val)
 {
-    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_REAL );
-    tr_bencInitReal( child, val );
+    tr_benc * child = dictFindOrAdd (dict, key, TR_TYPE_REAL);
+    tr_bencInitReal (child, val);
     return child;
 }
 
 tr_benc*
-tr_bencDictAddStr( tr_benc * dict, const char * key, const char * val )
+tr_bencDictAddStr (tr_benc * dict, const char * key, const char * val)
 {
     tr_benc * child;
 
     /* see if it already exists, and if so, try to reuse it */
-    if(( child = tr_bencDictFind( dict, key ))) {
-        if( tr_bencIsString( child ) ) {
-            if( stringIsAlloced( child ) )
-                tr_free( child->val.s.str.ptr );
+    if ((child = tr_bencDictFind (dict, key))) {
+        if (tr_bencIsString (child)) {
+            if (stringIsAlloced (child))
+                tr_free (child->val.s.str.ptr);
         } else {
-            tr_bencDictRemove( dict, key );
+            tr_bencDictRemove (dict, key);
             child = NULL;
         }
     }
 
     /* if it doesn't exist, create it */
-    if( child == NULL )
-        child = tr_bencDictAdd( dict, key );
+    if (child == NULL)
+        child = tr_bencDictAdd (dict, key);
 
     /* set it */
-    tr_bencInitStr( child, val, -1 );
+    tr_bencInitStr (child, val, -1);
 
     return child;
 }
 
 tr_benc*
-tr_bencDictAddRaw( tr_benc *    dict,
+tr_bencDictAddRaw (tr_benc *    dict,
                    const char * key,
                    const void * src,
-                   size_t       len )
+                   size_t       len)
 {
     tr_benc * child;
 
     /* see if it already exists, and if so, try to reuse it */
-    if(( child = tr_bencDictFind( dict, key ))) {
-        if( tr_bencIsString( child ) ) {
-            if( stringIsAlloced( child ) )
-                tr_free( child->val.s.str.ptr );
+    if ((child = tr_bencDictFind (dict, key))) {
+        if (tr_bencIsString (child)) {
+            if (stringIsAlloced (child))
+                tr_free (child->val.s.str.ptr);
         } else {
-            tr_bencDictRemove( dict, key );
+            tr_bencDictRemove (dict, key);
             child = NULL;
         }
     }
 
     /* if it doesn't exist, create it */
-    if( child == NULL )
-        child = tr_bencDictAdd( dict, key );
+    if (child == NULL)
+        child = tr_bencDictAdd (dict, key);
 
     /* set it */
-    tr_bencInitRaw( child, src, len );
+    tr_bencInitRaw (child, src, len);
 
     return child;
 }
 
 tr_benc*
-tr_bencDictAddList( tr_benc *    dict,
+tr_bencDictAddList (tr_benc *    dict,
                     const char * key,
-                    size_t       reserveCount )
+                    size_t       reserveCount)
 {
-    tr_benc * child = tr_bencDictAdd( dict, key );
+    tr_benc * child = tr_bencDictAdd (dict, key);
 
-    tr_bencInitList( child, reserveCount );
+    tr_bencInitList (child, reserveCount);
     return child;
 }
 
 tr_benc*
-tr_bencDictAddDict( tr_benc *    dict,
+tr_bencDictAddDict (tr_benc *    dict,
                     const char * key,
-                    size_t       reserveCount )
+                    size_t       reserveCount)
 {
-    tr_benc * child = tr_bencDictAdd( dict, key );
+    tr_benc * child = tr_bencDictAdd (dict, key);
 
-    tr_bencInitDict( child, reserveCount );
+    tr_bencInitDict (child, reserveCount);
     return child;
 }
 
 int
-tr_bencDictRemove( tr_benc *    dict,
-                   const char * key )
+tr_bencDictRemove (tr_benc *    dict,
+                   const char * key)
 {
-    int i = dictIndexOf( dict, key );
+    int i = dictIndexOf (dict, key);
 
-    if( i >= 0 )
+    if (i >= 0)
     {
         const int n = dict->val.l.count;
-        tr_bencFree( &dict->val.l.vals[i] );
-        tr_bencFree( &dict->val.l.vals[i + 1] );
-        if( i + 2 < n )
+        tr_bencFree (&dict->val.l.vals[i]);
+        tr_bencFree (&dict->val.l.vals[i + 1]);
+        if (i + 2 < n)
         {
             dict->val.l.vals[i]   = dict->val.l.vals[n - 2];
             dict->val.l.vals[i + 1] = dict->val.l.vals[n - 1];
@@ -923,13 +923,13 @@ struct KeyIndex
 };
 
 static int
-compareKeyIndex( const void * va,
-                 const void * vb )
+compareKeyIndex (const void * va,
+                 const void * vb)
 {
     const struct KeyIndex * a = va;
     const struct KeyIndex * b = vb;
 
-    return strcmp( a->key, b->key );
+    return strcmp (a->key, b->key);
 }
 
 struct SaveNode
@@ -942,81 +942,81 @@ struct SaveNode
 };
 
 static void
-nodeInitDict( struct SaveNode * node, const tr_benc * val, bool sort_dicts )
+nodeInitDict (struct SaveNode * node, const tr_benc * val, bool sort_dicts)
 {
     const int n = val->val.l.count;
     const int nKeys = n / 2;
 
-    assert( tr_bencIsDict( val ) );
+    assert (tr_bencIsDict (val));
 
     node->val = val;
-    node->children = tr_new0( int, n );
+    node->children = tr_new0 (int, n);
 
-    if( sort_dicts )
+    if (sort_dicts)
     {
         int i, j;
-        struct KeyIndex * indices = tr_new( struct KeyIndex, nKeys );
-        for( i=j=0; i<n; i+=2, ++j )
+        struct KeyIndex * indices = tr_new (struct KeyIndex, nKeys);
+        for (i=j=0; i<n; i+=2, ++j)
         {
-            indices[j].key = getStr(&val->val.l.vals[i]);
+            indices[j].key = getStr (&val->val.l.vals[i]);
             indices[j].index = i;
         }
-        qsort( indices, j, sizeof( struct KeyIndex ), compareKeyIndex );
-        for( i = 0; i < j; ++i )
+        qsort (indices, j, sizeof (struct KeyIndex), compareKeyIndex);
+        for (i = 0; i < j; ++i)
         {
             const int index = indices[i].index;
             node->children[node->childCount++] = index;
             node->children[node->childCount++] = index + 1;
         }
 
-        tr_free( indices );
+        tr_free (indices);
     }
     else
     {
         int i;
 
-        for( i=0; i<n; ++i )
+        for (i=0; i<n; ++i)
             node->children[node->childCount++] = i;
     }
 
-    assert( node->childCount == n );
+    assert (node->childCount == n);
 }
 
 static void
-nodeInitList( struct SaveNode * node, const tr_benc * val )
+nodeInitList (struct SaveNode * node, const tr_benc * val)
 {
     int               i, n;
 
-    assert( tr_bencIsList( val ) );
+    assert (tr_bencIsList (val));
 
     n = val->val.l.count;
     node->val = val;
     node->childCount = n;
-    node->children = tr_new0( int, n );
-    for( i = 0; i < n; ++i ) /* a list's children don't need to be reordered */
+    node->children = tr_new0 (int, n);
+    for (i = 0; i < n; ++i) /* a list's children don't need to be reordered */
         node->children[i] = i;
 }
 
 static void
-nodeInitLeaf( struct SaveNode * node, const tr_benc * val )
+nodeInitLeaf (struct SaveNode * node, const tr_benc * val)
 {
-    assert( !isContainer( val ) );
+    assert (!isContainer (val));
 
     node->val = val;
 }
 
 static void
-nodeInit( struct SaveNode * node, const tr_benc * val, bool sort_dicts )
+nodeInit (struct SaveNode * node, const tr_benc * val, bool sort_dicts)
 {
     static const struct SaveNode INIT_NODE = { NULL, 0, 0, 0, NULL };
     *node = INIT_NODE;
 
-         if( tr_bencIsList( val ) ) nodeInitList( node, val );
-    else if( tr_bencIsDict( val ) ) nodeInitDict( node, val, sort_dicts );
-    else                            nodeInitLeaf( node, val );
+         if (tr_bencIsList (val)) nodeInitList (node, val);
+    else if (tr_bencIsDict (val)) nodeInitDict (node, val, sort_dicts);
+    else                            nodeInitLeaf (node, val);
 }
 
-typedef void ( *BencWalkFunc )( const tr_benc * val, void * user_data );
+typedef void (*BencWalkFunc)(const tr_benc * val, void * user_data);
 
 struct WalkFuncs
 {
@@ -1035,91 +1035,91 @@ struct WalkFuncs
  * attack via maliciously-crafted bencoded data. (#667)
  */
 static void
-bencWalk( const tr_benc          * top,
+bencWalk (const tr_benc          * top,
           const struct WalkFuncs * walkFuncs,
           void                   * user_data,
-          bool                     sort_dicts )
+          bool                     sort_dicts)
 {
     int stackSize = 0;
     int stackAlloc = 64;
-    struct SaveNode * stack = tr_new( struct SaveNode, stackAlloc );
+    struct SaveNode * stack = tr_new (struct SaveNode, stackAlloc);
 
-    nodeInit( &stack[stackSize++], top, sort_dicts );
+    nodeInit (&stack[stackSize++], top, sort_dicts);
 
-    while( stackSize > 0 )
+    while (stackSize > 0)
     {
         struct SaveNode * node = &stack[stackSize-1];
         const tr_benc *   val;
 
-        if( !node->valIsVisited )
+        if (!node->valIsVisited)
         {
             val = node->val;
             node->valIsVisited = true;
         }
-        else if( node->childIndex < node->childCount )
+        else if (node->childIndex < node->childCount)
         {
             const int index = node->children[node->childIndex++];
             val = node->val->val.l.vals +  index;
         }
         else /* done with this node */
         {
-            if( isContainer( node->val ) )
-                walkFuncs->containerEndFunc( node->val, user_data );
+            if (isContainer (node->val))
+                walkFuncs->containerEndFunc (node->val, user_data);
             --stackSize;
-            tr_free( node->children );
+            tr_free (node->children);
             continue;
         }
 
-        if( val ) switch( val->type )
+        if (val) switch (val->type)
             {
                 case TR_TYPE_INT:
-                    walkFuncs->intFunc( val, user_data );
+                    walkFuncs->intFunc (val, user_data);
                     break;
 
                 case TR_TYPE_BOOL:
-                    walkFuncs->boolFunc( val, user_data );
+                    walkFuncs->boolFunc (val, user_data);
                     break;
 
                 case TR_TYPE_REAL:
-                    walkFuncs->realFunc( val, user_data );
+                    walkFuncs->realFunc (val, user_data);
                     break;
 
                 case TR_TYPE_STR:
-                    walkFuncs->stringFunc( val, user_data );
+                    walkFuncs->stringFunc (val, user_data);
                     break;
 
                 case TR_TYPE_LIST:
-                    if( val == node->val )
-                        walkFuncs->listBeginFunc( val, user_data );
+                    if (val == node->val)
+                        walkFuncs->listBeginFunc (val, user_data);
                     else {
-                        if( stackAlloc == stackSize ) {
+                        if (stackAlloc == stackSize) {
                             stackAlloc *= 2;
-                            stack = tr_renew( struct SaveNode, stack, stackAlloc );
+                            stack = tr_renew (struct SaveNode, stack, stackAlloc);
                         }
-                        nodeInit( &stack[stackSize++], val, sort_dicts );
+                        nodeInit (&stack[stackSize++], val, sort_dicts);
                     }
                     break;
 
                 case TR_TYPE_DICT:
-                    if( val == node->val )
-                        walkFuncs->dictBeginFunc( val, user_data );
+                    if (val == node->val)
+                        walkFuncs->dictBeginFunc (val, user_data);
                     else {
-                        if( stackAlloc == stackSize ) {
+                        if (stackAlloc == stackSize) {
                             stackAlloc *= 2;
-                            stack = tr_renew( struct SaveNode, stack, stackAlloc );
+                            stack = tr_renew (struct SaveNode, stack, stackAlloc);
                         }
-                        nodeInit( &stack[stackSize++], val, sort_dicts );
+                        nodeInit (&stack[stackSize++], val, sort_dicts);
                     }
                     break;
 
                 default:
                     /* did caller give us an uninitialized val? */
-                    tr_err( "%s", _( "Invalid metadata" ) );
+                    tr_err ("%s", _ ("Invalid metadata"));
                     break;
             }
     }
 
-    tr_free( stack );
+    tr_free (stack);
 }
 
 /****
@@ -1127,61 +1127,61 @@ bencWalk( const tr_benc          * top,
 ****/
 
 static void
-saveIntFunc( const tr_benc * val, void * evbuf )
+saveIntFunc (const tr_benc * val, void * evbuf)
 {
-    evbuffer_add_printf( evbuf, "i%" PRId64 "e", val->val.i );
+    evbuffer_add_printf (evbuf, "i%" PRId64 "e", val->val.i);
 }
 
 static void
-saveBoolFunc( const tr_benc * val, void * evbuf )
+saveBoolFunc (const tr_benc * val, void * evbuf)
 {
-    if( val->val.b )
-        evbuffer_add( evbuf, "i1e", 3 );
+    if (val->val.b)
+        evbuffer_add (evbuf, "i1e", 3);
     else
-        evbuffer_add( evbuf, "i0e", 3 );
+        evbuffer_add (evbuf, "i0e", 3);
 }
 
 static void
-saveRealFunc( const tr_benc * val, void * evbuf )
+saveRealFunc (const tr_benc * val, void * evbuf)
 {
     char buf[128];
     char locale[128];
     size_t len;
 
     /* always use a '.' decimal point s.t. locale-hopping doesn't bite us */
-    tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
-    setlocale( LC_NUMERIC, "POSIX" );
-    tr_snprintf( buf, sizeof( buf ), "%f", val->val.d );
-    setlocale( LC_NUMERIC, locale );
+    tr_strlcpy (locale, setlocale (LC_NUMERIC, NULL), sizeof (locale));
+    setlocale (LC_NUMERIC, "POSIX");
+    tr_snprintf (buf, sizeof (buf), "%f", val->val.d);
+    setlocale (LC_NUMERIC, locale);
 
-    len = strlen( buf );
-    evbuffer_add_printf( evbuf, "%lu:", (unsigned long)len );
-    evbuffer_add( evbuf, buf, len );
+    len = strlen (buf);
+    evbuffer_add_printf (evbuf, "%lu:", (unsigned long)len);
+    evbuffer_add (evbuf, buf, len);
 }
 
 static void
-saveStringFunc( const tr_benc * val, void * evbuf )
+saveStringFunc (const tr_benc * val, void * evbuf)
 {
-    evbuffer_add_printf( evbuf, "%lu:", (unsigned long)val->val.s.len );
-    evbuffer_add( evbuf, getStr(val), val->val.s.len );
+    evbuffer_add_printf (evbuf, "%lu:", (unsigned long)val->val.s.len);
+    evbuffer_add (evbuf, getStr (val), val->val.s.len);
 }
 
 static void
-saveDictBeginFunc( const tr_benc * val UNUSED, void * evbuf )
+saveDictBeginFunc (const tr_benc * val UNUSED, void * evbuf)
 {
-    evbuffer_add( evbuf, "d", 1 );
+    evbuffer_add (evbuf, "d", 1);
 }
 
 static void
-saveListBeginFunc( const tr_benc * val UNUSED, void * evbuf )
+saveListBeginFunc (const tr_benc * val UNUSED, void * evbuf)
 {
-    evbuffer_add( evbuf, "l", 1 );
+    evbuffer_add (evbuf, "l", 1);
 }
 
 static void
-saveContainerEndFunc( const tr_benc * val UNUSED, void * evbuf )
+saveContainerEndFunc (const tr_benc * val UNUSED, void * evbuf)
 {
-    evbuffer_add( evbuf, "e", 1 );
+    evbuffer_add (evbuf, "e", 1);
 }
 
 static const struct WalkFuncs saveFuncs = { saveIntFunc,
@@ -1197,20 +1197,20 @@ static const struct WalkFuncs saveFuncs = { saveIntFunc,
 ***/
 
 static void
-freeDummyFunc( const tr_benc * val UNUSED, void * buf UNUSED  )
+freeDummyFunc (const tr_benc * val UNUSED, void * buf UNUSED)
 {}
 
 static void
-freeStringFunc( const tr_benc * val, void * unused UNUSED )
+freeStringFunc (const tr_benc * val, void * unused UNUSED)
 {
-    if( stringIsAlloced( val ) )
-        tr_free( val->val.s.str.ptr );
+    if (stringIsAlloced (val))
+        tr_free (val->val.s.str.ptr);
 }
 
 static void
-freeContainerEndFunc( const tr_benc * val, void * unused UNUSED )
+freeContainerEndFunc (const tr_benc * val, void * unused UNUSED)
 {
-    tr_free( val->val.l.vals );
+    tr_free (val->val.l.vals);
 }
 
 static const struct WalkFuncs freeWalkFuncs = { freeDummyFunc,
@@ -1222,17 +1222,17 @@ static const struct WalkFuncs freeWalkFuncs = { freeDummyFunc,
                                                 freeContainerEndFunc };
 
 void
-tr_bencFree( tr_benc * val )
+tr_bencFree (tr_benc * val)
 {
-    if( isSomething( val ) )
-        bencWalk( val, &freeWalkFuncs, NULL, false );
+    if (isSomething (val))
+        bencWalk (val, &freeWalkFuncs, NULL, false);
 }
 
 /***
 ****
 ***/
 
-/** @brief Implementation helper class for tr_bencToBuffer(TR_FMT_JSON) */
+/** @brief Implementation helper class for tr_bencToBuffer (TR_FMT_JSON) */
 struct ParentState
 {
     int    bencType;
@@ -1240,7 +1240,7 @@ struct ParentState
     int    childCount;
 };
 
-/** @brief Implementation helper class for tr_bencToBuffer(TR_FMT_JSON) */
+/** @brief Implementation helper class for tr_bencToBuffer (TR_FMT_JSON) */
 struct jsonWalk
 {
     bool doIndent;
@@ -1249,38 +1249,38 @@ struct jsonWalk
 };
 
 static void
-jsonIndent( struct jsonWalk * data )
+jsonIndent (struct jsonWalk * data)
 {
-    if( data->doIndent )
+    if (data->doIndent)
     {
         char buf[1024];
-        const int width = tr_list_size( data->parents ) * 4;
+        const int width = tr_list_size (data->parents) * 4;
 
         buf[0] = '\n';
-        memset( buf+1, ' ', width );
-        evbuffer_add( data->out, buf, 1+width );
+        memset (buf+1, ' ', width);
+        evbuffer_add (data->out, buf, 1+width);
     }
 }
 
 static void
-jsonChildFunc( struct jsonWalk * data )
+jsonChildFunc (struct jsonWalk * data)
 {
-    if( data->parents && data->parents->data )
+    if (data->parents && data->parents->data)
     {
         struct ParentState * parentState = data->parents->data;
 
-        switch( parentState->bencType )
+        switch (parentState->bencType)
         {
             case TR_TYPE_DICT:
             {
                 const int i = parentState->childIndex++;
-                if( !( i % 2 ) )
-                    evbuffer_add( data->out, ": ", data->doIndent ? 2 : 1 );
+                if (! (i % 2))
+                    evbuffer_add (data->out, ": ", data->doIndent ? 2 : 1);
                 else {
                     const bool isLast = parentState->childIndex == parentState->childCount;
-                    if( !isLast ) {
-                        evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
-                        jsonIndent( data );
+                    if (!isLast) {
+                        evbuffer_add (data->out, ", ", data->doIndent ? 2 : 1);
+                        jsonIndent (data);
                     }
                 }
                 break;
@@ -1289,9 +1289,9 @@ jsonChildFunc( struct jsonWalk * data )
             case TR_TYPE_LIST:
             {
                 const bool isLast = ++parentState->childIndex == parentState->childCount;
-                if( !isLast ) {
-                    evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
-                    jsonIndent( data );
+                if (!isLast) {
+                    evbuffer_add (data->out, ", ", data->doIndent ? 2 : 1);
+                    jsonIndent (data);
                 }
                 break;
             }
@@ -1303,86 +1303,86 @@ jsonChildFunc( struct jsonWalk * data )
 }
 
 static void
-jsonPushParent( struct jsonWalk * data,
-                const tr_benc *   benc )
+jsonPushParent (struct jsonWalk * data,
+                const tr_benc *   benc)
 {
-    struct ParentState * parentState = tr_new( struct ParentState, 1 );
+    struct ParentState * parentState = tr_new (struct ParentState, 1);
 
     parentState->bencType = benc->type;
     parentState->childIndex = 0;
     parentState->childCount = benc->val.l.count;
-    tr_list_prepend( &data->parents, parentState );
+    tr_list_prepend (&data->parents, parentState);
 }
 
 static void
-jsonPopParent( struct jsonWalk * data )
+jsonPopParent (struct jsonWalk * data)
 {
-    tr_free( tr_list_pop_front( &data->parents ) );
+    tr_free (tr_list_pop_front (&data->parents));
 }
 
 static void
-jsonIntFunc( const tr_benc * val,
-             void *          vdata )
+jsonIntFunc (const tr_benc * val,
+             void *          vdata)
 {
     struct jsonWalk * data = vdata;
 
-    evbuffer_add_printf( data->out, "%" PRId64, val->val.i );
-    jsonChildFunc( data );
+    evbuffer_add_printf (data->out, "%" PRId64, val->val.i);
+    jsonChildFunc (data);
 }
 
 static void
-jsonBoolFunc( const tr_benc * val, void * vdata )
+jsonBoolFunc (const tr_benc * val, void * vdata)
 {
     struct jsonWalk * data = vdata;
 
-    if( val->val.b )
-        evbuffer_add( data->out, "true", 4 );
+    if (val->val.b)
+        evbuffer_add (data->out, "true", 4);
     else
-        evbuffer_add( data->out, "false", 5 );
+        evbuffer_add (data->out, "false", 5);
 
-    jsonChildFunc( data );
+    jsonChildFunc (data);
 }
 
 static void
-jsonRealFunc( const tr_benc * val, void * vdata )
+jsonRealFunc (const tr_benc * val, void * vdata)
 {
     struct jsonWalk * data = vdata;
     char locale[128];
 
-    if( fabs( val->val.d - (int)val->val.d ) < 0.00001 )
-        evbuffer_add_printf( data->out, "%d", (int)val->val.d );
+    if (fabs (val->val.d - (int)val->val.d) < 0.00001)
+        evbuffer_add_printf (data->out, "%d", (int)val->val.d);
     else {
         /* json requires a '.' decimal point regardless of locale */
-        tr_strlcpy( locale, setlocale( LC_NUMERIC, NULL ), sizeof( locale ) );
-        setlocale( LC_NUMERIC, "POSIX" );
-        evbuffer_add_printf( data->out, "%.4f", tr_truncd( val->val.d, 4 ) );
-        setlocale( LC_NUMERIC, locale );
+        tr_strlcpy (locale, setlocale (LC_NUMERIC, NULL), sizeof (locale));
+        setlocale (LC_NUMERIC, "POSIX");
+        evbuffer_add_printf (data->out, "%.4f", tr_truncd (val->val.d, 4));
+        setlocale (LC_NUMERIC, locale);
     }
 
-    jsonChildFunc( data );
+    jsonChildFunc (data);
 }
 
 static void
-jsonStringFunc( const tr_benc * val, void * vdata )
+jsonStringFunc (const tr_benc * val, void * vdata)
 {
     char * out;
     char * outwalk;
     char * outend;
     struct evbuffer_iovec vec[1];
     struct jsonWalk * data = vdata;
-    const unsigned char * it = (const unsigned char *) getStr(val);
+    const unsigned char * it = (const unsigned char *) getStr (val);
     const unsigned char * end = it + val->val.s.len;
 
-    evbuffer_reserve_space( data->out, val->val.s.len * 4, vec, 1 );
+    evbuffer_reserve_space (data->out, val->val.s.len * 4, vec, 1);
     out = vec[0].iov_base;
     outend = out + vec[0].iov_len;
 
     outwalk = out;
     *outwalk++ = '"';
 
-    for( ; it!=end; ++it )
+    for (; it!=end; ++it)
     {
-        switch( *it )
+        switch (*it)
         {
             case '\b': *outwalk++ = '\\'; *outwalk++ = 'b'; break;
             case '\f': *outwalk++ = '\\'; *outwalk++ = 'f'; break;
@@ -1393,15 +1393,15 @@ jsonStringFunc( const tr_benc * val, void * vdata )
             case '\\': *outwalk++ = '\\'; *outwalk++ = '\\'; break;
 
             default:
-                if( isascii( *it ) )
+                if (isascii (*it))
                     *outwalk++ = *it;
                 else {
                     const UTF8 * tmp = it;
                     UTF32        buf[1] = { 0 };
                     UTF32 *      u32 = buf;
-                    ConversionResult result = ConvertUTF8toUTF32( &tmp, end, &u32, buf + 1, 0 );
-                    if((( result==conversionOK ) || (result==targetExhausted)) && (tmp!=it)) {
-                        outwalk += tr_snprintf( outwalk, outend-outwalk, "\\u%04x", (unsigned int)buf[0] );
+                    ConversionResult result = ConvertUTF8toUTF32 (&tmp, end, &u32, buf + 1, 0);
+                    if (((result==conversionOK) || (result==targetExhausted)) && (tmp!=it)) {
+                        outwalk += tr_snprintf (outwalk, outend-outwalk, "\\u%04x", (unsigned int)buf[0]);
                         it = tmp - 1;
                     }
                 }
@@ -1410,51 +1410,51 @@ jsonStringFunc( const tr_benc * val, void * vdata )
 
     *outwalk++ = '"';
     vec[0].iov_len = outwalk - out;
-    evbuffer_commit_space( data->out, vec, 1 );
+    evbuffer_commit_space (data->out, vec, 1);
 
-    jsonChildFunc( data );
+    jsonChildFunc (data);
 }
 
 static void
-jsonDictBeginFunc( const tr_benc * val,
-                   void *          vdata )
+jsonDictBeginFunc (const tr_benc * val,
+                   void *          vdata)
 {
     struct jsonWalk * data = vdata;
 
-    jsonPushParent( data, val );
-    evbuffer_add( data->out, "{", 1 );
-    if( val->val.l.count )
-        jsonIndent( data );
+    jsonPushParent (data, val);
+    evbuffer_add (data->out, "{", 1);
+    if (val->val.l.count)
+        jsonIndent (data);
 }
 
 static void
-jsonListBeginFunc( const tr_benc * val,
-                   void *          vdata )
+jsonListBeginFunc (const tr_benc * val,
+                   void *          vdata)
 {
-    const size_t      nChildren = tr_bencListSize( val );
+    const size_t      nChildren = tr_bencListSize (val);
     struct jsonWalk * data = vdata;
 
-    jsonPushParent( data, val );
-    evbuffer_add( data->out, "[", 1 );
-    if( nChildren )
-        jsonIndent( data );
+    jsonPushParent (data, val);
+    evbuffer_add (data->out, "[", 1);
+    if (nChildren)
+        jsonIndent (data);
 }
 
 static void
-jsonContainerEndFunc( const tr_benc * val,
-                      void *          vdata )
+jsonContainerEndFunc (const tr_benc * val,
+                      void *          vdata)
 {
     struct jsonWalk * data = vdata;
     int               emptyContainer = false;
 
-    jsonPopParent( data );
-    if( !emptyContainer )
-        jsonIndent( data );
-    if( tr_bencIsDict( val ) )
-        evbuffer_add( data->out, "}", 1 );
+    jsonPopParent (data);
+    if (!emptyContainer)
+        jsonIndent (data);
+    if (tr_bencIsDict (val))
+        evbuffer_add (data->out, "}", 1);
     else /* list */
-        evbuffer_add( data->out, "]", 1 );
-    jsonChildFunc( data );
+        evbuffer_add (data->out, "]", 1);
+    jsonChildFunc (data);
 }
 
 static const struct WalkFuncs jsonWalkFuncs = { jsonIntFunc,
@@ -1470,73 +1470,73 @@ static const struct WalkFuncs jsonWalkFuncs = { jsonIntFunc,
 ***/
 
 static void
-tr_bencListCopy( tr_benc * target, const tr_benc * src )
+tr_bencListCopy (tr_benc * target, const tr_benc * src)
 {
     int i = 0;
     const tr_benc * val;
 
-    while(( val = tr_bencListChild( (tr_benc*)src, i++ )))
+    while ((val = tr_bencListChild ((tr_benc*)src, i++)))
     {
-       if( tr_bencIsBool( val ) )
+       if (tr_bencIsBool (val))
        {
            bool boolVal = 0;
-           tr_bencGetBool( val, &boolVal );
-           tr_bencListAddBool( target, boolVal );
+           tr_bencGetBool (val, &boolVal);
+           tr_bencListAddBool (target, boolVal);
        }
-       else if( tr_bencIsReal( val ) )
+       else if (tr_bencIsReal (val))
        {
            double realVal = 0;
-           tr_bencGetReal( val, &realVal );
-           tr_bencListAddReal( target, realVal );
+           tr_bencGetReal (val, &realVal);
+           tr_bencListAddReal (target, realVal);
        }
-       else if( tr_bencIsInt( val ) )
+       else if (tr_bencIsInt (val))
        {
            int64_t intVal = 0;
-           tr_bencGetInt( val, &intVal );
-           tr_bencListAddInt( target, intVal );
+           tr_bencGetInt (val, &intVal);
+           tr_bencListAddInt (target, intVal);
        }
-       else if( tr_bencIsString( val ) )
+       else if (tr_bencIsString (val))
        {
-           tr_bencListAddRaw( target, (const uint8_t*)getStr( val ), val->val.s.len );
+           tr_bencListAddRaw (target, (const uint8_t*)getStr (val), val->val.s.len);
        }
-       else if( tr_bencIsDict( val ) )
+       else if (tr_bencIsDict (val))
        {
-           tr_bencMergeDicts( tr_bencListAddDict( target, 0 ), val );
+           tr_bencMergeDicts (tr_bencListAddDict (target, 0), val);
        }
-       else if ( tr_bencIsList( val ) )
+       else if (tr_bencIsList (val))
        {
-           tr_bencListCopy( tr_bencListAddList( target, 0 ), val );
+           tr_bencListCopy (tr_bencListAddList (target, 0), val);
        }
        else
        {
-           tr_err( "tr_bencListCopy skipping item" );
+           tr_err ("tr_bencListCopy skipping item");
        }
    }
 }
 
 static size_t
-tr_bencDictSize( const tr_benc * dict )
+tr_bencDictSize (const tr_benc * dict)
 {
     size_t count = 0;
 
-    if( tr_bencIsDict( dict ) )
+    if (tr_bencIsDict (dict))
         count = dict->val.l.count / 2;
 
     return count;
 }
 
 bool
-tr_bencDictChild( tr_benc * dict, size_t n, const char ** key, tr_benc ** val )
+tr_bencDictChild (tr_benc * dict, size_t n, const char ** key, tr_benc ** val)
 {
     bool success = 0;
 
-    assert( tr_bencIsDict( dict ) );
+    assert (tr_bencIsDict (dict));
 
-    if( tr_bencIsDict( dict ) && (n*2)+1 <= dict->val.l.count )
+    if (tr_bencIsDict (dict) && (n*2)+1 <= dict->val.l.count)
     {
         tr_benc * k = dict->val.l.vals + (n*2);
         tr_benc * v = dict->val.l.vals + (n*2) + 1;
-        if(( success = tr_bencGetStr( k, key ) && isSomething( v )))
+        if ((success = tr_bencGetStr (k, key) && isSomething (v)))
             *val = v;
     }
 
@@ -1544,68 +1544,68 @@ tr_bencDictChild( tr_benc * dict, size_t n, const char ** key, tr_benc ** val )
 }
 
 void
-tr_bencMergeDicts( tr_benc * target, const tr_benc * source )
+tr_bencMergeDicts (tr_benc * target, const tr_benc * source)
 {
     size_t i;
-    const size_t sourceCount = tr_bencDictSize( source );
+    const size_t sourceCount = tr_bencDictSize (source);
 
-    assert( tr_bencIsDict( target ) );
-    assert( tr_bencIsDict( source ) );
+    assert (tr_bencIsDict (target));
+    assert (tr_bencIsDict (source));
 
-    for( i=0; i<sourceCount; ++i )
+    for (i=0; i<sourceCount; ++i)
     {
         const char * key;
         tr_benc * val;
         tr_benc * t;
 
-        if( tr_bencDictChild( (tr_benc*)source, i, &key, &val ) )
+        if (tr_bencDictChild ((tr_benc*)source, i, &key, &val))
         {
-            if( tr_bencIsBool( val ) )
+            if (tr_bencIsBool (val))
             {
                 bool boolVal;
-                tr_bencGetBool( val, &boolVal );
-                tr_bencDictAddBool( target, key, boolVal );
+                tr_bencGetBool (val, &boolVal);
+                tr_bencDictAddBool (target, key, boolVal);
             }
-            else if( tr_bencIsReal( val ) )
+            else if (tr_bencIsReal (val))
             {
                 double realVal = 0;
-                tr_bencGetReal( val, &realVal );
-                tr_bencDictAddReal( target, key, realVal );
+                tr_bencGetReal (val, &realVal);
+                tr_bencDictAddReal (target, key, realVal);
             }
-            else if( tr_bencIsInt( val ) )
+            else if (tr_bencIsInt (val))
             {
                 int64_t intVal = 0;
-                tr_bencGetInt( val, &intVal );
-                tr_bencDictAddInt( target, key, intVal );
+                tr_bencGetInt (val, &intVal);
+                tr_bencDictAddInt (target, key, intVal);
             }
-            else if( tr_bencIsString( val ) )
+            else if (tr_bencIsString (val))
             {
-                tr_bencDictAddRaw( target, key, getStr( val ), val->val.s.len );
+                tr_bencDictAddRaw (target, key, getStr (val), val->val.s.len);
             }
-            else if( tr_bencIsDict( val ) && tr_bencDictFindDict( target, key, &t ) )
+            else if (tr_bencIsDict (val) && tr_bencDictFindDict (target, key, &t))
             {
-                tr_bencMergeDicts( t, val );
+                tr_bencMergeDicts (t, val);
             }
-            else if( tr_bencIsList( val ) )
+            else if (tr_bencIsList (val))
             {
-                if( tr_bencDictFind( target, key ) == NULL )
+                if (tr_bencDictFind (target, key) == NULL)
                 {
-                    tr_bencListCopy( tr_bencDictAddList( target, key, tr_bencListSize( val ) ), val );
+                    tr_bencListCopy (tr_bencDictAddList (target, key, tr_bencListSize (val)), val);
                 }
             }
-            else if( tr_bencIsDict( val ) )
+            else if (tr_bencIsDict (val))
             {
-                tr_benc * target_dict = tr_bencDictFind( target, key );
+                tr_benc * target_dict = tr_bencDictFind (target, key);
 
-                if( target_dict == NULL )
-                    target_dict = tr_bencDictAddDict( target, key, tr_bencDictSize( val ) );
+                if (target_dict == NULL)
+                    target_dict = tr_bencDictAddDict (target, key, tr_bencDictSize (val));
 
-                if( tr_bencIsDict( target_dict ) )
-                    tr_bencMergeDicts( target_dict, val );
+                if (tr_bencIsDict (target_dict))
+                    tr_bencMergeDicts (target_dict, val);
             }
             else
             {
-                tr_dbg( "tr_bencMergeDicts skipping \"%s\"", key );
+                tr_dbg ("tr_bencMergeDicts skipping \"%s\"", key);
             }
         }
     }
@@ -1616,16 +1616,16 @@ tr_bencMergeDicts( tr_benc * target, const tr_benc * source )
 ***/
 
 struct evbuffer *
-tr_bencToBuf( const tr_benc * top, tr_fmt_mode mode )
+tr_bencToBuf (const tr_benc * top, tr_fmt_mode mode)
 {
-    struct evbuffer * buf = evbuffer_new( );
+    struct evbuffer * buf = evbuffer_new ();
 
-    evbuffer_expand( buf, 4096 ); /* alloc a little memory to start off with */
+    evbuffer_expand (buf, 4096); /* alloc a little memory to start off with */
 
-    switch( mode )
+    switch (mode)
     {
         case TR_FMT_BENC:
-            bencWalk( top, &saveFuncs, buf, true );
+            bencWalk (top, &saveFuncs, buf, true);
             break;
 
         case TR_FMT_JSON:
@@ -1634,9 +1634,9 @@ tr_bencToBuf( const tr_benc * top, tr_fmt_mode mode )
             data.doIndent = mode==TR_FMT_JSON;
             data.out = buf;
             data.parents = NULL;
-            bencWalk( top, &jsonWalkFuncs, &data, true );
-            if( evbuffer_get_length( buf ) )
-                evbuffer_add_printf( buf, "\n" );
+            bencWalk (top, &jsonWalkFuncs, &data, true);
+            if (evbuffer_get_length (buf))
+                evbuffer_add_printf (buf, "\n");
             break;
         }
     }
@@ -1645,32 +1645,32 @@ tr_bencToBuf( const tr_benc * top, tr_fmt_mode mode )
 }
 
 char*
-tr_bencToStr( const tr_benc * top, tr_fmt_mode mode, int * len )
+tr_bencToStr (const tr_benc * top, tr_fmt_mode mode, int * len)
 {
-    struct evbuffer * buf = tr_bencToBuf( top, mode );
-    const size_t n = evbuffer_get_length( buf );
-    char * ret = evbuffer_free_to_str( buf );
-    if( len != NULL )
+    struct evbuffer * buf = tr_bencToBuf (top, mode);
+    const size_t n = evbuffer_get_length (buf);
+    char * ret = evbuffer_free_to_str (buf);
+    if (len != NULL)
         *len = (int) n;
     return ret;
 }
 
-/* portability wrapper for mkstemp(). */
+/* portability wrapper for mkstemp (). */
 static int
-tr_mkstemp( char * template )
+tr_mkstemp (char * template)
 {
 #ifdef WIN32
     const int flags = O_RDWR | O_BINARY | O_CREAT | O_EXCL | _O_SHORT_LIVED;
     const mode_t mode = _S_IREAD | _S_IWRITE;
-    mktemp( template );
-    return open( template, flags, mode );
+    mktemp (template);
+    return open (template, flags, mode);
 #else
-    return mkstemp( template );
+    return mkstemp (template);
 #endif
 }
 
 int
-tr_bencToFile( const tr_benc * top, tr_fmt_mode mode, const char * filename )
+tr_bencToFile (const tr_benc * top, tr_fmt_mode mode, const char * filename)
 {
     char * tmp;
     int fd;
@@ -1678,73 +1678,73 @@ tr_bencToFile( const tr_benc * top, tr_fmt_mode mode, const char * filename )
     char buf[TR_PATH_MAX];
 
     /* follow symlinks to find the "real" file, to make sure the temporary
-     * we build with tr_mkstemp() is created on the right partition */
-    if( tr_realpath( filename, buf ) != NULL )
+     * we build with tr_mkstemp () is created on the right partition */
+    if (tr_realpath (filename, buf) != NULL)
         filename = buf;
 
     /* if the file already exists, try to move it out of the way & keep it as a backup */
-    tmp = tr_strdup_printf( "%s.tmp.XXXXXX", filename );
-    fd = tr_mkstemp( tmp );
-    tr_set_file_for_single_pass( fd );
-    if( fd >= 0 )
+    tmp = tr_strdup_printf ("%s.tmp.XXXXXX", filename);
+    fd = tr_mkstemp (tmp);
+    tr_set_file_for_single_pass (fd);
+    if (fd >= 0)
     {
         int nleft;
 
         /* save the benc to a temporary file */
         {
-            struct evbuffer * buf = tr_bencToBuf( top, mode );
-            const char * walk = (const char *) evbuffer_pullup( buf, -1 );
-            nleft = evbuffer_get_length( buf );
+            struct evbuffer * buf = tr_bencToBuf (top, mode);
+            const char * walk = (const char *) evbuffer_pullup (buf, -1);
+            nleft = evbuffer_get_length (buf);
 
-            while( nleft > 0 ) {
-                const int n = write( fd, walk, nleft );
-                if( n >= 0 ) {
+            while (nleft > 0) {
+                const int n = write (fd, walk, nleft);
+                if (n >= 0) {
                     nleft -= n;
                     walk += n;
                 }
-                else if( errno != EAGAIN ) {
+                else if (errno != EAGAIN) {
                     err = errno;
                     break;
                 }
             }
 
-            evbuffer_free( buf );
+            evbuffer_free (buf);
         }
 
-        if( nleft > 0 )
+        if (nleft > 0)
         {
-            tr_err( _( "Couldn't save temporary file \"%1$s\": %2$s" ), tmp, tr_strerror( err ) );
-            tr_close_file( fd );
-            unlink( tmp );
+            tr_err (_ ("Couldn't save temporary file \"%1$s\": %2$s"), tmp, tr_strerror (err));
+            tr_close_file (fd);
+            unlink (tmp);
         }
         else
         {
-            //tr_fsync( fd );
-            tr_close_file( fd );
+            //tr_fsync (fd);
+            tr_close_file (fd);
 
 #ifdef WIN32
-            if( MoveFileEx( tmp, filename, MOVEFILE_REPLACE_EXISTING ) )
+            if (MoveFileEx (tmp, filename, MOVEFILE_REPLACE_EXISTING))
 #else
-            if( !rename( tmp, filename ) )
+            if (!rename (tmp, filename))
 #endif
             {
-                tr_inf( _( "Saved \"%s\"" ), filename );
+                tr_inf (_ ("Saved \"%s\""), filename);
             }
             else
             {
                 err = errno;
-                tr_err( _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
-                unlink( tmp );
+                tr_err (_ ("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (err));
+                unlink (tmp);
             }
         }
     }
     else
     {
         err = errno;
-        tr_err( _( "Couldn't save temporary file \"%1$s\": %2$s" ), tmp, tr_strerror( err ) );
+        tr_err (_ ("Couldn't save temporary file \"%1$s\": %2$s"), tmp, tr_strerror (err));
     }
 
-    tr_free( tmp );
+    tr_free (tmp);
     return err;
 }
 
@@ -1753,25 +1753,25 @@ tr_bencToFile( const tr_benc * top, tr_fmt_mode mode, const char * filename )
 ***/
 
 int
-tr_bencLoadFile( tr_benc * setme, tr_fmt_mode mode, const char * filename )
+tr_bencLoadFile (tr_benc * setme, tr_fmt_mode mode, const char * filename)
 {
     int err;
     size_t contentLen;
     uint8_t * content;
 
-    content = tr_loadFile( filename, &contentLen );
-    if( !content && errno )
+    content = tr_loadFile (filename, &contentLen);
+    if (!content && errno)
         err = errno;
-    else if( !content )
+    else if (!content)
         err = ENODATA;
     else {
-        if( mode == TR_FMT_BENC )
-            err = tr_bencLoad( content, contentLen, setme, NULL );
+        if (mode == TR_FMT_BENC)
+            err = tr_bencLoad (content, contentLen, setme, NULL);
         else
-            err = tr_jsonParse( filename, content, contentLen, setme, NULL );
+            err = tr_jsonParse (filename, content, contentLen, setme, NULL);
     }
 
-    tr_free( content );
+    tr_free (content);
     return err;
 }
 
diff --git a/libtransmission/bencode.h b/libtransmission/bencode.h
index b31e667e1..1adb567c0 100644
--- a/libtransmission/bencode.h
+++ b/libtransmission/bencode.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -83,31 +83,31 @@ typedef struct tr_benc
 ****
 ***/
 
-int       tr_bencParse( const void     * buf,
+int       tr_bencParse (const void     * buf,
                         const void     * bufend,
                         tr_benc        * setme_benc,
-                        const uint8_t ** setme_end );
+                        const uint8_t ** setme_end);
 
-int       tr_bencLoad( const void   * buf,
+int       tr_bencLoad (const void   * buf,
                        size_t         buflen,
                        tr_benc      * setme_benc,
-                       char        ** setme_end );
+                       char        ** setme_end);
 
-void      tr_bencFree( tr_benc * );
+void      tr_bencFree (tr_benc *);
 
-void      tr_bencInitStr( tr_benc *, const void * str, int str_len );
+void      tr_bencInitStr (tr_benc *, const void * str, int str_len);
 
-void      tr_bencInitRaw( tr_benc *, const void * raw, size_t raw_len );
+void      tr_bencInitRaw (tr_benc *, const void * raw, size_t raw_len);
 
-void      tr_bencInitInt( tr_benc *, int64_t num );
+void      tr_bencInitInt (tr_benc *, int64_t num);
 
-int       tr_bencInitDict( tr_benc *, size_t reserveCount );
+int       tr_bencInitDict (tr_benc *, size_t reserveCount);
 
-int       tr_bencInitList( tr_benc *, size_t reserveCount );
+int       tr_bencInitList (tr_benc *, size_t reserveCount);
 
-void      tr_bencInitBool( tr_benc *, int value );
+void      tr_bencInitBool (tr_benc *, int value);
 
-void      tr_bencInitReal( tr_benc *, double value );
+void      tr_bencInitReal (tr_benc *, double value);
 
 /***
 ****  Serialization / Deserialization
@@ -121,86 +121,86 @@ typedef enum
 }
 tr_fmt_mode;
 
-int tr_bencToFile( const tr_benc *, tr_fmt_mode, const char * filename );
+int tr_bencToFile (const tr_benc *, tr_fmt_mode, const char * filename);
 
-char* tr_bencToStr( const tr_benc *, tr_fmt_mode, int * len );
+char* tr_bencToStr (const tr_benc *, tr_fmt_mode, int * len);
 
-struct evbuffer * tr_bencToBuf( const tr_benc *, tr_fmt_mode );
+struct evbuffer * tr_bencToBuf (const tr_benc *, tr_fmt_mode);
 
 /* TR_FMT_JSON_LEAN and TR_FMT_JSON are equivalent in this function. */
-int tr_bencLoadFile( tr_benc * setme, tr_fmt_mode, const char * filename );
+int tr_bencLoadFile (tr_benc * setme, tr_fmt_mode, const char * filename);
 
 /***
 ****
 ***/
 
-int tr_bencListReserve( tr_benc *, size_t reserveCount );
+int tr_bencListReserve (tr_benc *, size_t reserveCount);
 
-tr_benc * tr_bencListAdd( tr_benc * );
+tr_benc * tr_bencListAdd (tr_benc *);
 
-tr_benc * tr_bencListAddBool( tr_benc *, bool val );
+tr_benc * tr_bencListAddBool (tr_benc *, bool val);
 
-tr_benc * tr_bencListAddInt( tr_benc *, int64_t val );
+tr_benc * tr_bencListAddInt (tr_benc *, int64_t val);
 
-tr_benc * tr_bencListAddReal( tr_benc *, double val );
+tr_benc * tr_bencListAddReal (tr_benc *, double val);
 
-tr_benc * tr_bencListAddStr( tr_benc *, const char * val );
+tr_benc * tr_bencListAddStr (tr_benc *, const char * val);
 
-tr_benc * tr_bencListAddRaw( tr_benc *, const uint8_t * val, size_t len );
+tr_benc * tr_bencListAddRaw (tr_benc *, const uint8_t * val, size_t len);
 
-tr_benc * tr_bencListAddList( tr_benc *, size_t reserveCount );
+tr_benc * tr_bencListAddList (tr_benc *, size_t reserveCount);
 
-tr_benc * tr_bencListAddDict( tr_benc *, size_t reserveCount );
+tr_benc * tr_bencListAddDict (tr_benc *, size_t reserveCount);
 
-size_t    tr_bencListSize( const tr_benc * list );
+size_t    tr_bencListSize (const tr_benc * list);
 
-tr_benc * tr_bencListChild( tr_benc * list, size_t n );
+tr_benc * tr_bencListChild (tr_benc * list, size_t n);
 
-int       tr_bencListRemove( tr_benc *, size_t n );
+int       tr_bencListRemove (tr_benc *, size_t n);
 
 /***
 ****
 ***/
 
-int       tr_bencDictReserve( tr_benc *, size_t reserveCount );
+int       tr_bencDictReserve (tr_benc *, size_t reserveCount);
 
-int       tr_bencDictRemove( tr_benc *, const char * key );
+int       tr_bencDictRemove (tr_benc *, const char * key);
 
-tr_benc * tr_bencDictAdd( tr_benc *, const char * key );
+tr_benc * tr_bencDictAdd (tr_benc *, const char * key);
 
-tr_benc * tr_bencDictAddReal( tr_benc *, const char * key, double );
+tr_benc * tr_bencDictAddReal (tr_benc *, const char * key, double);
 
-tr_benc * tr_bencDictAddInt( tr_benc *, const char * key, int64_t );
+tr_benc * tr_bencDictAddInt (tr_benc *, const char * key, int64_t);
 
-tr_benc * tr_bencDictAddBool( tr_benc *, const char * key, bool );
+tr_benc * tr_bencDictAddBool (tr_benc *, const char * key, bool);
 
-tr_benc * tr_bencDictAddStr( tr_benc *, const char * key, const char * );
+tr_benc * tr_bencDictAddStr (tr_benc *, const char * key, const char *);
 
-tr_benc * tr_bencDictAddList( tr_benc *, const char * key, size_t reserve );
+tr_benc * tr_bencDictAddList (tr_benc *, const char * key, size_t reserve);
 
-tr_benc * tr_bencDictAddDict( tr_benc *, const char * key, size_t reserve );
+tr_benc * tr_bencDictAddDict (tr_benc *, const char * key, size_t reserve);
 
-tr_benc * tr_bencDictAddRaw( tr_benc *, const char * key,
-                             const void * raw, size_t rawlen );
+tr_benc * tr_bencDictAddRaw (tr_benc *, const char * key,
+                             const void * raw, size_t rawlen);
 
-bool      tr_bencDictChild( tr_benc *, size_t i, const char ** key, tr_benc ** val );
+bool      tr_bencDictChild (tr_benc *, size_t i, const char ** key, tr_benc ** val);
 
-tr_benc*  tr_bencDictFind( tr_benc *, const char * key );
+tr_benc*  tr_bencDictFind (tr_benc *, const char * key);
 
-bool      tr_bencDictFindList( tr_benc *, const char * key, tr_benc ** setme );
+bool      tr_bencDictFindList (tr_benc *, const char * key, tr_benc ** setme);
 
-bool      tr_bencDictFindDict( tr_benc *, const char * key, tr_benc ** setme );
+bool      tr_bencDictFindDict (tr_benc *, const char * key, tr_benc ** setme);
 
-bool      tr_bencDictFindInt( tr_benc *, const char * key, int64_t * setme );
+bool      tr_bencDictFindInt (tr_benc *, const char * key, int64_t * setme);
 
-bool      tr_bencDictFindReal( tr_benc *, const char * key, double * setme );
+bool      tr_bencDictFindReal (tr_benc *, const char * key, double * setme);
 
-bool      tr_bencDictFindBool( tr_benc *, const char * key, bool * setme );
+bool      tr_bencDictFindBool (tr_benc *, const char * key, bool * setme);
 
-bool      tr_bencDictFindStr( tr_benc *, const char * key, const char ** setme );
+bool      tr_bencDictFindStr (tr_benc *, const char * key, const char ** setme);
 
-bool      tr_bencDictFindRaw( tr_benc *, const char * key,
-                              const uint8_t ** setme_raw, size_t * setme_len );
+bool      tr_bencDictFindRaw (tr_benc *, const char * key,
+                              const uint8_t ** setme_raw, size_t * setme_len);
 
 /***
 ****
@@ -208,52 +208,52 @@ bool      tr_bencDictFindRaw( tr_benc *, const char * key,
 
 /** @brief Get an int64_t from a variant object
     @return true if successful, or false if the variant could not be represented as an int64_t  */
-bool      tr_bencGetInt( const tr_benc * val, int64_t * setme );
+bool      tr_bencGetInt (const tr_benc * val, int64_t * setme);
 
 /** @brief Get an string from a variant object
     @return true if successful, or false if the variant could not be represented as a string  */
-bool      tr_bencGetStr( const tr_benc * val, const char ** setme );
+bool      tr_bencGetStr (const tr_benc * val, const char ** setme);
 
 /** @brief Get a raw byte array from a variant object
     @return true if successful, or false if the variant could not be represented as a raw byte array */
-bool      tr_bencGetRaw( const tr_benc * val, const uint8_t  ** setme_raw, size_t * setme_len );
+bool      tr_bencGetRaw (const tr_benc * val, const uint8_t  ** setme_raw, size_t * setme_len);
 
 /** @brief Get a boolean from a variant object
     @return true if successful, or false if the variant could not be represented as a boolean  */
-bool      tr_bencGetBool( const tr_benc * val, bool * setme );
+bool      tr_bencGetBool (const tr_benc * val, bool * setme);
 
 /** @brief Get a floating-point number from a variant object
     @return true if successful, or false if the variant could not be represented as a floating-point number  */
-bool      tr_bencGetReal( const tr_benc * val, double * setme );
+bool      tr_bencGetReal (const tr_benc * val, double * setme);
 
-static inline bool tr_bencIsType  ( const tr_benc * b, int type ) { return ( b != NULL ) && ( b->type == type ); }
+static inline bool tr_bencIsType (const tr_benc * b, int type) { return (b != NULL) && (b->type == type); }
 
-static inline bool tr_bencIsInt   ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_INT ); }
-static inline bool tr_bencIsDict  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_DICT ); }
-static inline bool tr_bencIsList  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_LIST ); }
-static inline bool tr_bencIsString( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_STR ); }
-static inline bool tr_bencIsBool  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_BOOL ); }
-static inline bool tr_bencIsReal  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_REAL ); }
+static inline bool tr_bencIsInt (const tr_benc * b) { return tr_bencIsType (b, TR_TYPE_INT); }
+static inline bool tr_bencIsDict (const tr_benc * b) { return tr_bencIsType (b, TR_TYPE_DICT); }
+static inline bool tr_bencIsList (const tr_benc * b) { return tr_bencIsType (b, TR_TYPE_LIST); }
+static inline bool tr_bencIsString (const tr_benc * b) { return tr_bencIsType (b, TR_TYPE_STR); }
+static inline bool tr_bencIsBool (const tr_benc * b) { return tr_bencIsType (b, TR_TYPE_BOOL); }
+static inline bool tr_bencIsReal (const tr_benc * b) { return tr_bencIsType (b, TR_TYPE_REAL); }
 
 /** @brief Private function that's exposed here only for unit tests */
-int tr_bencParseInt( const uint8_t *  buf,
+int tr_bencParseInt (const uint8_t *  buf,
                      const uint8_t *  bufend,
                      const uint8_t ** setme_end,
-                     int64_t *        setme_val );
+                     int64_t *        setme_val);
 
 /** @brief Private function that's exposed here only for unit tests */
-int tr_bencParseStr( const uint8_t *  buf,
+int tr_bencParseStr (const uint8_t *  buf,
                      const uint8_t *  bufend,
                      const uint8_t ** setme_end,
                      const uint8_t ** setme_str,
-                     size_t *         setme_strlen );
+                     size_t *         setme_strlen);
 
 /**
 ***
 **/
 
 /* this is only quasi-supported. don't rely on it too heavily outside of libT */
-void  tr_bencMergeDicts( tr_benc * target, const tr_benc * source );
+void  tr_bencMergeDicts (tr_benc * target, const tr_benc * source);
 
 /* @} */
 
diff --git a/libtransmission/bitfield.c b/libtransmission/bitfield.c
index db1682b9b..71aca992d 100644
--- a/libtransmission/bitfield.c
+++ b/libtransmission/bitfield.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,12 +11,12 @@
  */
 
 #include <assert.h>
-#include <stdlib.h> /* realloc() */
+#include <stdlib.h> /* realloc () */
 #include <string.h> /* memset */
 
 #include "transmission.h"
 #include "bitfield.h"
-#include "utils.h" /* tr_new0() */
+#include "utils.h" /* tr_new0 () */
 
 const tr_bitfield TR_BITFIELD_INIT = { NULL, 0, 0, 0, false, false };
 
@@ -26,105 +26,107 @@ const tr_bitfield TR_BITFIELD_INIT = { NULL, 0, 0, 0, false, false };
 
 static const int8_t trueBitCount[256] =
 {
-    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
-    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+  4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
 };
 
 static size_t
-countArray( const tr_bitfield * b )
+countArray (const tr_bitfield * b)
 {
-    size_t i;
-    size_t ret = 0;
+  size_t i;
+  size_t ret = 0;
 
-    for( i=0; i<b->alloc_count; ++i )
-        ret += trueBitCount[b->bits[i]];
+  for (i=0; i<b->alloc_count; ++i)
+    ret += trueBitCount[b->bits[i]];
 
-    return ret;
+  return ret;
 }
 
 static size_t
-countRange( const tr_bitfield * b, size_t begin, size_t end )
+countRange (const tr_bitfield * b, size_t begin, size_t end)
 {
-    size_t ret = 0;
-    const size_t first_byte = begin >> 3u;
-    const size_t last_byte = ( end - 1 ) >> 3u;
+  size_t ret = 0;
+  const size_t first_byte = begin >> 3u;
+  const size_t last_byte = (end - 1) >> 3u;
+
+  if (!b->bit_count)
+    return 0;
 
-    if( !b->bit_count )
-        return 0;
-    if( first_byte >= b->alloc_count )
-        return 0;
+  if (first_byte >= b->alloc_count)
+    return 0;
 
-    assert( begin < end );
-    assert( b->bits != NULL );
+  assert (begin < end);
+  assert (b->bits != NULL);
 
-    if( first_byte == last_byte )
+  if (first_byte == last_byte)
     {
-        int i;
-        uint8_t val = b->bits[first_byte];
+      int i;
+      uint8_t val = b->bits[first_byte];
 
-        i = begin - (first_byte * 8);
-        val <<= i;
-        val >>= i;
-        i = (last_byte+1)*8 - end;
-        val >>= i;
-        val <<= i;
+      i = begin - (first_byte * 8);
+      val <<= i;
+      val >>= i;
+      i = (last_byte+1)*8 - end;
+      val >>= i;
+      val <<= i;
 
-        ret += trueBitCount[val];
+      ret += trueBitCount[val];
     }
-    else
+  else
     {
-        size_t i;
-        uint8_t val;
-
-        /* first byte */
-        i = begin - (first_byte * 8);
-        val = b->bits[first_byte];
-        val <<= i;
-        val >>= i;
-        ret += trueBitCount[val];
-
-        /* middle bytes */
-        for( i=first_byte+1; i<b->alloc_count && i<last_byte; ++i )
-            ret += trueBitCount[b->bits[i]];
-
-        /* last byte */
-        if( last_byte < b->alloc_count ) {
-            i = (last_byte+1)*8 - end;
-            val = b->bits[last_byte];
-            val >>= i;
-            val <<= i;
-            ret += trueBitCount[val];
+      size_t i;
+      uint8_t val;
+
+      /* first byte */
+      i = begin - (first_byte * 8);
+      val = b->bits[first_byte];
+      val <<= i;
+      val >>= i;
+      ret += trueBitCount[val];
+
+      /* middle bytes */
+      for (i=first_byte+1; i<b->alloc_count && i<last_byte; ++i)
+        ret += trueBitCount[b->bits[i]];
+
+      /* last byte */
+      if (last_byte < b->alloc_count)
+        {
+          i = (last_byte+1)*8 - end;
+          val = b->bits[last_byte];
+          val >>= i;
+          val <<= i;
+          ret += trueBitCount[val];
         }
     }
 
-    assert( ret <= ( begin - end ) );
-    return ret;
+  assert (ret <= (begin - end));
+  return ret;
 }
 
 size_t
-tr_bitfieldCountRange( const tr_bitfield * b, size_t begin, size_t end )
+tr_bitfieldCountRange (const tr_bitfield * b, size_t begin, size_t end)
 {
-    if( tr_bitfieldHasAll( b ) )
-        return end - begin;
+  if (tr_bitfieldHasAll (b))
+    return end - begin;
 
-    if( tr_bitfieldHasNone( b ) )
-        return 0;
+  if (tr_bitfieldHasNone (b))
+    return 0;
 
-    return countRange( b, begin, end );
+  return countRange (b, begin, end);
 }
 
 /***
@@ -132,113 +134,120 @@ tr_bitfieldCountRange( const tr_bitfield * b, size_t begin, size_t end )
 ***/
 
 static bool
-tr_bitfieldIsValid( const tr_bitfield * b UNUSED )
+tr_bitfieldIsValid (const tr_bitfield * b UNUSED)
 {
-    assert( b != NULL );
-    assert( ( b->alloc_count == 0 ) == ( b->bits == 0 ) );
-    assert( !b->bits || ( b->true_count == countArray ( b ) ) );
-    return true;
+  assert (b != NULL);
+  assert ((b->alloc_count == 0) == (b->bits == 0));
+  assert (!b->bits || (b->true_count == countArray (b)));
+
+  return true;
 }
 
 size_t
-tr_bitfieldCountTrueBits( const tr_bitfield * b )
+tr_bitfieldCountTrueBits (const tr_bitfield * b)
 {
-    tr_bitfieldIsValid( b );
-    return b->true_count;
+  tr_bitfieldIsValid (b);
+
+  return b->true_count;
 }
 
 static size_t
-get_bytes_needed( size_t bit_count )
+get_bytes_needed (size_t bit_count)
 {
-    return ( bit_count + 7u ) / 8u;
+  return (bit_count + 7u) / 8u;
 }
 
 static void
-set_all_true( uint8_t * array, size_t bit_count )
+set_all_true (uint8_t * array, size_t bit_count)
 {
-    const uint8_t val = 0xFF;
-    const size_t n = get_bytes_needed( bit_count );
-    memset( array, val, n-1 );
-    array[n-1] = val << (n*8 - bit_count);
+  const uint8_t val = 0xFF;
+  const size_t n = get_bytes_needed (bit_count);
+
+  memset (array, val, n-1);
+
+  array[n-1] = val << (n*8 - bit_count);
 }
 
 void*
-tr_bitfieldGetRaw( const tr_bitfield * b, size_t * byte_count )
+tr_bitfieldGetRaw (const tr_bitfield * b, size_t * byte_count)
 {
-    const size_t n = get_bytes_needed( b->bit_count );
-    uint8_t * bits = tr_new0( uint8_t, n );
+  const size_t n = get_bytes_needed (b->bit_count);
+  uint8_t * bits = tr_new0 (uint8_t, n);
 
-    assert( b->bit_count > 0 );
+  assert (b->bit_count > 0);
 
-    if( b->alloc_count ) {
-        assert( b->alloc_count <= n );
-        memcpy( bits, b->bits, b->alloc_count );
-    } else if( tr_bitfieldHasAll( b ) ) {
-        set_all_true( bits, b->bit_count );
+  if (b->alloc_count)
+    {
+      assert (b->alloc_count <= n);
+      memcpy (bits, b->bits, b->alloc_count);
+    }
+  else if (tr_bitfieldHasAll (b))
+    {
+      set_all_true (bits, b->bit_count);
     }
 
-    *byte_count = n;
-    return bits;
+  *byte_count = n;
+  return bits;
 }
 
 static void
-tr_bitfieldEnsureBitsAlloced( tr_bitfield * b, size_t n )
+tr_bitfieldEnsureBitsAlloced (tr_bitfield * b, size_t n)
 {
-    size_t bytes_needed;
-    const bool has_all = tr_bitfieldHasAll( b );
+  size_t bytes_needed;
+  const bool has_all = tr_bitfieldHasAll (b);
 
-    if( has_all )
-        bytes_needed = get_bytes_needed( MAX( n, b->true_count ) );
-    else
-        bytes_needed = get_bytes_needed( n );
+  if (has_all)
+    bytes_needed = get_bytes_needed (MAX (n, b->true_count));
+  else
+    bytes_needed = get_bytes_needed (n);
 
-    if( b->alloc_count < bytes_needed )
+  if (b->alloc_count < bytes_needed)
     {
-        b->bits = tr_renew( uint8_t, b->bits, bytes_needed );
-        memset( b->bits + b->alloc_count, 0, bytes_needed - b->alloc_count );
-        b->alloc_count = bytes_needed;
+      b->bits = tr_renew (uint8_t, b->bits, bytes_needed);
+      memset (b->bits + b->alloc_count, 0, bytes_needed - b->alloc_count);
+      b->alloc_count = bytes_needed;
 
-        if( has_all )
-            set_all_true( b->bits, b->true_count );
+      if (has_all)
+        set_all_true (b->bits, b->true_count);
     }
 }
 
 static void
-tr_bitfieldEnsureNthBitAlloced( tr_bitfield * b, size_t nth )
+tr_bitfieldEnsureNthBitAlloced (tr_bitfield * b, size_t nth)
 {
-    /* count is zero-based, so we need to allocate nth+1 bits before setting the nth */
-    tr_bitfieldEnsureBitsAlloced( b, nth + 1 );
+  /* count is zero-based, so we need to allocate nth+1 bits before setting the nth */
+  tr_bitfieldEnsureBitsAlloced (b, nth + 1);
 }
 
 static void
-tr_bitfieldFreeArray( tr_bitfield * b )
+tr_bitfieldFreeArray (tr_bitfield * b)
 {
-    tr_free( b->bits );
-    b->bits = NULL;
-    b->alloc_count = 0;
+  tr_free (b->bits);
+  b->bits = NULL;
+  b->alloc_count = 0;
 }
 
 static void
-tr_bitfieldSetTrueCount( tr_bitfield * b, size_t n )
+tr_bitfieldSetTrueCount (tr_bitfield * b, size_t n)
 {
-    b->true_count = n;
+  b->true_count = n;
 
-    if( tr_bitfieldHasAll( b ) || tr_bitfieldHasNone( b ) )
-        tr_bitfieldFreeArray( b );
+  if (tr_bitfieldHasAll (b) || tr_bitfieldHasNone (b))
+    tr_bitfieldFreeArray (b);
 
-    assert( tr_bitfieldIsValid(  b ) );
+  assert (tr_bitfieldIsValid (b));
 }
 
 static void
-tr_bitfieldRebuildTrueCount( tr_bitfield * b )
+tr_bitfieldRebuildTrueCount (tr_bitfield * b)
 {
-    tr_bitfieldSetTrueCount( b, countArray( b ) );
+  tr_bitfieldSetTrueCount (b, countArray (b));
 }
 
 static void
-tr_bitfieldIncTrueCount( tr_bitfield * b, int i )
+tr_bitfieldIncTrueCount (tr_bitfield * b, int i)
 {
-    tr_bitfieldSetTrueCount( b, b->true_count + i );
+  tr_bitfieldSetTrueCount (b, b->true_count + i);
 }
 
 /****
@@ -246,189 +255,190 @@ tr_bitfieldIncTrueCount( tr_bitfield * b, int i )
 ****/
 
 void
-tr_bitfieldConstruct( tr_bitfield * b, size_t bit_count )
+tr_bitfieldConstruct (tr_bitfield * b, size_t bit_count)
 {
-    b->bit_count = bit_count;
-    b->true_count = 0;
-    b->bits = NULL;
-    b->alloc_count = 0;
-    b->have_all_hint = false;
-    b->have_none_hint = false;
-
-    assert( tr_bitfieldIsValid( b ) );
+  b->bit_count = bit_count;
+  b->true_count = 0;
+  b->bits = NULL;
+  b->alloc_count = 0;
+  b->have_all_hint = false;
+  b->have_none_hint = false;
+
+  assert (tr_bitfieldIsValid (b));
 }
 
 void
-tr_bitfieldSetHasNone( tr_bitfield * b )
+tr_bitfieldSetHasNone (tr_bitfield * b)
 {
-    tr_bitfieldFreeArray( b );
-    b->true_count = 0;
-    b->have_all_hint = false;
-    b->have_none_hint = true;
+  tr_bitfieldFreeArray (b);
+  b->true_count = 0;
+  b->have_all_hint = false;
+  b->have_none_hint = true;
 
-    assert( tr_bitfieldIsValid( b ) );
+  assert (tr_bitfieldIsValid (b));
 }
 
 void
-tr_bitfieldSetHasAll( tr_bitfield * b )
+tr_bitfieldSetHasAll (tr_bitfield * b)
 {
-    tr_bitfieldFreeArray( b );
-    b->true_count = b->bit_count;
-    b->have_all_hint = true;
-    b->have_none_hint = false;
+  tr_bitfieldFreeArray (b);
+  b->true_count = b->bit_count;
+  b->have_all_hint = true;
+  b->have_none_hint = false;
 
-    assert( tr_bitfieldIsValid( b ) );
+  assert (tr_bitfieldIsValid (b));
 }
 
 void
-tr_bitfieldSetFromBitfield( tr_bitfield * b, const tr_bitfield * src )
+tr_bitfieldSetFromBitfield (tr_bitfield * b, const tr_bitfield * src)
 {
-    if( tr_bitfieldHasAll( src ) )
-        tr_bitfieldSetHasAll( b );
-    else if( tr_bitfieldHasNone( src ) )
-        tr_bitfieldSetHasNone( b );
-    else
-        tr_bitfieldSetRaw( b, src->bits, src->alloc_count, true );
+  if (tr_bitfieldHasAll (src))
+    tr_bitfieldSetHasAll (b);
+  else if (tr_bitfieldHasNone (src))
+    tr_bitfieldSetHasNone (b);
+  else
+    tr_bitfieldSetRaw (b, src->bits, src->alloc_count, true);
 }
 
 void
-tr_bitfieldSetRaw( tr_bitfield * b, const void * bits, size_t byte_count, bool bounded )
+tr_bitfieldSetRaw (tr_bitfield * b, const void * bits, size_t byte_count, bool bounded)
 {
-    tr_bitfieldFreeArray( b );
-    b->true_count = 0;
-
-    if( bounded )
-        byte_count = MIN( byte_count, get_bytes_needed( b->bit_count ) );
-
-    b->bits = tr_memdup( bits, byte_count );
-    b->alloc_count = byte_count;
-
-    if( bounded ) {
-        /* ensure the excess bits are set to '0' */
-        const int excess_bit_count = byte_count*8 - b->bit_count;
-        assert( excess_bit_count >= 0 );
-        assert( excess_bit_count <= 7 );
-        if( excess_bit_count )
-            b->bits[b->alloc_count-1] &= ((0xff) << excess_bit_count);
+  tr_bitfieldFreeArray (b);
+  b->true_count = 0;
+
+  if (bounded)
+    byte_count = MIN (byte_count, get_bytes_needed (b->bit_count));
+
+  b->bits = tr_memdup (bits, byte_count);
+  b->alloc_count = byte_count;
+
+  if (bounded)
+    {
+      /* ensure the excess bits are set to '0' */
+      const int excess_bit_count = byte_count*8 - b->bit_count;
+      assert (excess_bit_count >= 0);
+      assert (excess_bit_count <= 7);
+      if (excess_bit_count)
+        b->bits[b->alloc_count-1] &= ((0xff) << excess_bit_count);
     }
 
-    tr_bitfieldRebuildTrueCount( b );
+  tr_bitfieldRebuildTrueCount (b);
 }
 
 void
-tr_bitfieldSetFromFlags( tr_bitfield * b, const bool * flags, size_t n )
+tr_bitfieldSetFromFlags (tr_bitfield * b, const bool * flags, size_t n)
 {
-    size_t i;
-    size_t trueCount = 0;
+  size_t i;
+  size_t trueCount = 0;
 
-    tr_bitfieldFreeArray( b );
-    tr_bitfieldEnsureBitsAlloced( b, n );
+  tr_bitfieldFreeArray (b);
+  tr_bitfieldEnsureBitsAlloced (b, n);
 
-    for( i=0; i<n; ++i )
+  for (i=0; i<n; ++i)
     {
-        if( flags[i] )
+      if (flags[i])
         {
-            ++trueCount;
-            b->bits[i >> 3u] |= ( 0x80 >> ( i & 7u ) );
+          ++trueCount;
+          b->bits[i >> 3u] |= (0x80 >> (i & 7u));
         }
     }
 
-    tr_bitfieldSetTrueCount( b, trueCount );
+  tr_bitfieldSetTrueCount (b, trueCount);
 }
 
 void
-tr_bitfieldAdd( tr_bitfield * b, size_t nth )
+tr_bitfieldAdd (tr_bitfield * b, size_t nth)
 {
-    if( !tr_bitfieldHas( b, nth ) )
+  if (!tr_bitfieldHas (b, nth))
     {
-        tr_bitfieldEnsureNthBitAlloced( b, nth );
-        b->bits[nth >> 3u] |= ( 0x80 >> ( nth & 7u ) );
-        tr_bitfieldIncTrueCount( b, 1 );
+      tr_bitfieldEnsureNthBitAlloced (b, nth);
+      b->bits[nth >> 3u] |= (0x80 >> (nth & 7u));
+      tr_bitfieldIncTrueCount (b, 1);
     }
 }
 
 /* Sets bit range [begin, end) to 1 */
 void
-tr_bitfieldAddRange( tr_bitfield * b, size_t begin, size_t end )
+tr_bitfieldAddRange (tr_bitfield * b, size_t begin, size_t end)
 {
-    size_t sb, eb;
-    unsigned char sm, em;
-    const size_t diff = (end-begin) - tr_bitfieldCountRange( b, begin, end );
+  size_t sb, eb;
+  unsigned char sm, em;
+  const size_t diff = (end-begin) - tr_bitfieldCountRange (b, begin, end);
 
-    if( diff == 0 )
-        return;
+  if (diff == 0)
+    return;
 
-    end--;
-    if( ( end >= b->bit_count ) || ( begin > end ) )
-        return;
+  end--;
+  if ((end >= b->bit_count) || (begin > end))
+    return;
 
-    sb = begin >> 3;
-    sm = ~( 0xff << ( 8 - ( begin & 7 ) ) );
-    eb = end >> 3;
-    em = 0xff << ( 7 - ( end & 7 ) );
+  sb = begin >> 3;
+  sm = ~ (0xff << (8 - (begin & 7)));
+  eb = end >> 3;
+  em = 0xff << (7 - (end & 7));
 
-    tr_bitfieldEnsureNthBitAlloced( b, end );
-    if( sb == eb )
+  tr_bitfieldEnsureNthBitAlloced (b, end);
+  if (sb == eb)
     {
-        b->bits[sb] |= ( sm & em );
+      b->bits[sb] |= (sm & em);
     }
-    else
+  else
     {
-        b->bits[sb] |= sm;
-        b->bits[eb] |= em;
-        if( ++sb < eb )
-            memset ( b->bits + sb, 0xff, eb - sb );
+      b->bits[sb] |= sm;
+      b->bits[eb] |= em;
+      if (++sb < eb)
+        memset (b->bits + sb, 0xff, eb - sb);
     }
 
-    tr_bitfieldIncTrueCount( b, diff );
+  tr_bitfieldIncTrueCount (b, diff);
 }
 
 void
-tr_bitfieldRem( tr_bitfield * b, size_t nth )
+tr_bitfieldRem (tr_bitfield * b, size_t nth)
 {
-    assert( tr_bitfieldIsValid( b ) );
+  assert (tr_bitfieldIsValid (b));
 
-    if( !tr_bitfieldHas( b, nth ) )
+  if (!tr_bitfieldHas (b, nth))
     {
-        tr_bitfieldEnsureNthBitAlloced( b, nth );
-        b->bits[nth >> 3u] &= ( 0xff7f >> ( nth & 7u ) );
-        tr_bitfieldIncTrueCount( b, -1 );
+      tr_bitfieldEnsureNthBitAlloced (b, nth);
+      b->bits[nth >> 3u] &= (0xff7f >> (nth & 7u));
+      tr_bitfieldIncTrueCount (b, -1);
     }
 }
 
 /* Clears bit range [begin, end) to 0 */
 void
-tr_bitfieldRemRange( tr_bitfield * b, size_t begin, size_t end )
+tr_bitfieldRemRange (tr_bitfield * b, size_t begin, size_t end)
 {
-    size_t sb, eb;
-    unsigned char sm, em;
-    const size_t diff = tr_bitfieldCountRange( b, begin, end );
+  size_t sb, eb;
+  unsigned char sm, em;
+  const size_t diff = tr_bitfieldCountRange (b, begin, end);
 
-    if( !diff )
-        return;
+  if (!diff)
+    return;
 
-    end--;
+  end--;
 
-    if( ( end >= b->bit_count ) || ( begin > end ) )
-        return;
+  if ((end >= b->bit_count) || (begin > end))
+    return;
 
-    sb = begin >> 3;
-    sm = 0xff << ( 8 - ( begin & 7 ) );
-    eb = end >> 3;
-    em = ~( 0xff << ( 7 - ( end & 7 ) ) );
+  sb = begin >> 3;
+  sm = 0xff << (8 - (begin & 7));
+  eb = end >> 3;
+  em = ~ (0xff << (7 - (end & 7)));
 
-    tr_bitfieldEnsureNthBitAlloced( b, end );
-    if( sb == eb )
+  tr_bitfieldEnsureNthBitAlloced (b, end);
+  if (sb == eb)
     {
-        b->bits[sb] &= ( sm | em );
+      b->bits[sb] &= (sm | em);
     }
-    else
+  else
     {
-        b->bits[sb] &= sm;
-        b->bits[eb] &= em;
-        if( ++sb < eb )
-            memset ( b->bits + sb, 0, eb - sb );
+      b->bits[sb] &= sm;
+      b->bits[eb] &= em;
+      if (++sb < eb)
+        memset (b->bits + sb, 0, eb - sb);
     }
 
-    tr_bitfieldIncTrueCount( b, -diff );
+  tr_bitfieldIncTrueCount (b, -diff);
 }
diff --git a/libtransmission/bitfield.h b/libtransmission/bitfield.h
index 616980537..a9fce49d4 100644
--- a/libtransmission/bitfield.h
+++ b/libtransmission/bitfield.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -22,17 +22,17 @@
 /** @brief Implementation of the BitTorrent spec's Bitfield array of bits */
 typedef struct tr_bitfield
 {
-    uint8_t *  bits;
-    size_t     alloc_count;
+  uint8_t *  bits;
+  size_t     alloc_count;
 
-    size_t     bit_count;
+  size_t     bit_count;
 
-    size_t     true_count;
+  size_t     true_count;
 
-    /* Special cases for when full or empty but we don't know the bitCount.
-       This occurs when a magnet link's peers send have all / have none */
-    bool       have_all_hint;
-    bool       have_none_hint;
+  /* Special cases for when full or empty but we don't know the bitCount.
+     This occurs when a magnet link's peers send have all / have none */
+  bool       have_all_hint;
+  bool       have_none_hint;
 }
 tr_bitfield;
 
@@ -40,17 +40,17 @@ tr_bitfield;
 ****
 ***/
 
-void   tr_bitfieldSetHasAll( tr_bitfield* );
+void   tr_bitfieldSetHasAll  (tr_bitfield*);
 
-void   tr_bitfieldSetHasNone( tr_bitfield* );
+void   tr_bitfieldSetHasNone (tr_bitfield*);
 
-void   tr_bitfieldAdd( tr_bitfield*, size_t bit );
+void   tr_bitfieldAdd        (tr_bitfield*, size_t bit);
 
-void   tr_bitfieldRem( tr_bitfield*, size_t bit );
+void   tr_bitfieldRem        (tr_bitfield*, size_t bit);
 
-void   tr_bitfieldAddRange( tr_bitfield*, size_t begin, size_t end );
+void   tr_bitfieldAddRange   (tr_bitfield*, size_t begin, size_t end);
 
-void   tr_bitfieldRemRange( tr_bitfield*, size_t begin, size_t end );
+void   tr_bitfieldRemRange   (tr_bitfield*, size_t begin, size_t end);
 
 /***
 ****  life cycle
@@ -58,53 +58,59 @@ void   tr_bitfieldRemRange( tr_bitfield*, size_t begin, size_t end );
 
 extern const tr_bitfield TR_BITFIELD_INIT;
 
-void   tr_bitfieldConstruct( tr_bitfield*, size_t bit_count );
+void   tr_bitfieldConstruct (tr_bitfield*, size_t bit_count);
 
 static inline void
-tr_bitfieldDestruct( tr_bitfield * b )
+tr_bitfieldDestruct (tr_bitfield * b)
 {
-    tr_bitfieldSetHasNone( b );
+  tr_bitfieldSetHasNone (b);
 }
 
 /***
 ****
 ***/
 
-void   tr_bitfieldSetFromFlags( tr_bitfield*, const bool * bytes, size_t n );
+void   tr_bitfieldSetFromFlags (tr_bitfield*, const bool * bytes, size_t n);
 
-void   tr_bitfieldSetFromBitfield( tr_bitfield*, const tr_bitfield* );
+void   tr_bitfieldSetFromBitfield (tr_bitfield*, const tr_bitfield*);
 
-void   tr_bitfieldSetRaw( tr_bitfield*, const void * bits, size_t byte_count, bool bounded );
+void   tr_bitfieldSetRaw (tr_bitfield*, const void * bits, size_t byte_count, bool bounded);
 
-void*  tr_bitfieldGetRaw( const tr_bitfield * b, size_t * byte_count );
+void*  tr_bitfieldGetRaw (const tr_bitfield * b, size_t * byte_count);
 
 /***
 ****
 ***/
 
-size_t  tr_bitfieldCountRange( const tr_bitfield*, size_t begin, size_t end );
+size_t  tr_bitfieldCountRange (const tr_bitfield*, size_t begin, size_t end);
 
-size_t  tr_bitfieldCountTrueBits( const tr_bitfield * b );
+size_t  tr_bitfieldCountTrueBits (const tr_bitfield * b);
 
 static inline bool
-tr_bitfieldHasAll( const tr_bitfield * b )
+tr_bitfieldHasAll (const tr_bitfield * b)
 {
-    return b->bit_count ? ( b->true_count == b->bit_count ) : b->have_all_hint;
+  return b->bit_count ? (b->true_count == b->bit_count) : b->have_all_hint;
 }
 
 static inline bool
-tr_bitfieldHasNone( const tr_bitfield * b )
+tr_bitfieldHasNone (const tr_bitfield * b)
 {
-    return b->bit_count ? ( b->true_count == 0 ) : b->have_none_hint;
+  return b->bit_count ? (b->true_count == 0) : b->have_none_hint;
 }
 
 static inline bool
-tr_bitfieldHas( const tr_bitfield * b, size_t n )
+tr_bitfieldHas (const tr_bitfield * b, size_t n)
 {
-    if( tr_bitfieldHasAll( b ) ) return true;
-    if( tr_bitfieldHasNone( b ) ) return false;
-    if( n>>3u >= b->alloc_count ) return false;
-    return ( b->bits[n>>3u] << ( n & 7u ) & 0x80 ) != 0;
+  if (tr_bitfieldHasAll (b))
+    return true;
+
+  if (tr_bitfieldHasNone (b))
+    return false;
+
+  if (n>>3u >= b->alloc_count)
+    return false;
+
+  return (b->bits[n>>3u] << (n & 7u) & 0x80) != 0;
 }
 
 #endif
diff --git a/libtransmission/blocklist-test.c b/libtransmission/blocklist-test.c
index e1cb328f5..d123846fc 100644
--- a/libtransmission/blocklist-test.c
+++ b/libtransmission/blocklist-test.c
@@ -17,7 +17,7 @@
 #define TEMPFILE_BIN  TEMPDIR_PREFIX "transmission-blocklist-test.bin"
 
 static void
-createTestBlocklist( const char * tmpfile )
+createTestBlocklist (const char * tmpfile)
 {
     const char * lines[] = { "Austin Law Firm:216.16.1.144-216.16.1.151",
                              "Sargent Controls and Aerospace:216.19.18.0-216.19.18.255",
@@ -25,63 +25,63 @@ createTestBlocklist( const char * tmpfile )
                              "Fox Speed Channel:216.79.131.192-216.79.131.223" };
     FILE *       out;
     int          i;
-    const int    lineCount = sizeof( lines ) / sizeof( lines[0] );
+    const int    lineCount = sizeof (lines) / sizeof (lines[0]);
 
     /* create the ascii file to feed to libtransmission */
-    out = fopen( tmpfile, "w+" );
-    for( i = 0; i < lineCount; ++i )
-        fprintf( out, "%s\n", lines[i] );
-    fclose( out );
+    out = fopen (tmpfile, "w+");
+    for (i = 0; i < lineCount; ++i)
+        fprintf (out, "%s\n", lines[i]);
+    fclose (out);
 }
 
 static int
-testBlockList( void )
+testBlockList (void)
 {
     const char * tmpfile_txt = TEMPFILE_TXT;
     const char * tmpfile_bin = TEMPFILE_BIN;
     struct tr_address addr;
     tr_blocklist * b;
 
-    remove( tmpfile_txt );
-    remove( tmpfile_bin );
+    remove (tmpfile_txt);
+    remove (tmpfile_bin);
 
-    b = _tr_blocklistNew( tmpfile_bin, true );
-    createTestBlocklist( tmpfile_txt );
-    _tr_blocklistSetContent( b, tmpfile_txt );
+    b = _tr_blocklistNew (tmpfile_bin, true);
+    createTestBlocklist (tmpfile_txt);
+    _tr_blocklistSetContent (b, tmpfile_txt);
 
     /* now run some tests */
-    check( tr_address_from_string( &addr, "216.16.1.143" ) );
-    check( !_tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.144" ) );
-    check( _tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.145" ) );
-    check( _tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.146" ) );
-    check( _tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.147" ) );
-    check( _tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.148" ) );
-    check( _tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.149" ) );
-    check( _tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.150" ) );
-    check( _tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.151" ) );
-    check( _tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.152" ) );
-    check( !_tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "216.16.1.153" ) );
-    check( !_tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "217.0.0.1" ) );
-    check( !_tr_blocklistHasAddress( b, &addr ) );
-    check( tr_address_from_string( &addr, "255.0.0.1" ) );
+    check (tr_address_from_string (&addr, "216.16.1.143"));
+    check (!_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.144"));
+    check (_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.145"));
+    check (_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.146"));
+    check (_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.147"));
+    check (_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.148"));
+    check (_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.149"));
+    check (_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.150"));
+    check (_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.151"));
+    check (_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.152"));
+    check (!_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "216.16.1.153"));
+    check (!_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "217.0.0.1"));
+    check (!_tr_blocklistHasAddress (b, &addr));
+    check (tr_address_from_string (&addr, "255.0.0.1"));
 
     /* cleanup */
-    _tr_blocklistFree( b );
-    remove( tmpfile_txt );
-    remove( tmpfile_bin );
+    _tr_blocklistFree (b);
+    remove (tmpfile_txt);
+    remove (tmpfile_bin);
     return 0;
 }
 
-MAIN_SINGLE_TEST(testBlockList)
+MAIN_SINGLE_TEST (testBlockList)
 
diff --git a/libtransmission/blocklist.c b/libtransmission/blocklist.c
index 0a7522887..1190f9fd2 100644
--- a/libtransmission/blocklist.c
+++ b/libtransmission/blocklist.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -13,10 +13,10 @@
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
-#include <stdlib.h> /* bsearch(), qsort() */
+#include <stdlib.h> /* bsearch (), qsort () */
 #include <string.h>
 
-#include <unistd.h> /* unlink() */
+#include <unistd.h> /* unlink () */
 
 #ifdef WIN32
  #include <w32api.h>
@@ -64,12 +64,12 @@ struct tr_blocklist
 };
 
 static void
-blocklistClose( tr_blocklist * b )
+blocklistClose (tr_blocklist * b)
 {
-    if( b->rules )
+    if (b->rules)
     {
-        munmap( b->rules, b->byteCount );
-        close( b->fd );
+        munmap (b->rules, b->byteCount);
+        close (b->fd);
         b->rules = NULL;
         b->ruleCount = 0;
         b->byteCount = 0;
@@ -78,69 +78,69 @@ blocklistClose( tr_blocklist * b )
 }
 
 static void
-blocklistLoad( tr_blocklist * b )
+blocklistLoad (tr_blocklist * b)
 {
     int fd;
     size_t byteCount;
     struct stat st;
-    const char * err_fmt = _( "Couldn't read \"%1$s\": %2$s" );
+    const char * err_fmt = _ ("Couldn't read \"%1$s\": %2$s");
 
-    blocklistClose( b );
+    blocklistClose (b);
 
-    if( stat( b->filename, &st ) == -1 )
+    if (stat (b->filename, &st) == -1)
         return;
 
-    fd = open( b->filename, O_RDONLY | O_BINARY );
-    if( fd == -1 )
+    fd = open (b->filename, O_RDONLY | O_BINARY);
+    if (fd == -1)
     {
-        tr_err( err_fmt, b->filename, tr_strerror( errno ) );
+        tr_err (err_fmt, b->filename, tr_strerror (errno));
         return;
     }
 
     byteCount = (size_t) st.st_size;
-    b->rules = mmap( NULL, byteCount, PROT_READ, MAP_PRIVATE, fd, 0 );
-    if( !b->rules )
+    b->rules = mmap (NULL, byteCount, PROT_READ, MAP_PRIVATE, fd, 0);
+    if (!b->rules)
     {
-        tr_err( err_fmt, b->filename, tr_strerror( errno ) );
-        close( fd );
+        tr_err (err_fmt, b->filename, tr_strerror (errno));
+        close (fd);
         return;
     }
 
     b->fd = fd;
     b->byteCount = byteCount;
-    b->ruleCount = byteCount / sizeof( struct tr_ipv4_range );
+    b->ruleCount = byteCount / sizeof (struct tr_ipv4_range);
 
     {
-        char * base = tr_basename( b->filename );
-        tr_inf( _( "Blocklist \"%s\" contains %zu entries" ), base, b->ruleCount );
-        tr_free( base );
+        char * base = tr_basename (b->filename);
+        tr_inf (_ ("Blocklist \"%s\" contains %zu entries"), base, b->ruleCount);
+        tr_free (base);
     }
 }
 
 static void
-blocklistEnsureLoaded( tr_blocklist * b )
+blocklistEnsureLoaded (tr_blocklist * b)
 {
-    if( !b->rules )
-        blocklistLoad( b );
+    if (!b->rules)
+        blocklistLoad (b);
 }
 
 static int
-compareAddressToRange( const void * va,
-                       const void * vb )
+compareAddressToRange (const void * va,
+                       const void * vb)
 {
     const uint32_t *             a = va;
     const struct tr_ipv4_range * b = vb;
 
-    if( *a < b->begin ) return -1;
-    if( *a > b->end ) return 1;
+    if (*a < b->begin) return -1;
+    if (*a > b->end) return 1;
     return 0;
 }
 
 static void
-blocklistDelete( tr_blocklist * b )
+blocklistDelete (tr_blocklist * b)
 {
-    blocklistClose( b );
-    unlink( b->filename );
+    blocklistClose (b);
+    unlink (b->filename);
 }
 
 /***
@@ -148,83 +148,83 @@ blocklistDelete( tr_blocklist * b )
 ***/
 
 tr_blocklist *
-_tr_blocklistNew( const char * filename, bool isEnabled )
+_tr_blocklistNew (const char * filename, bool isEnabled)
 {
     tr_blocklist * b;
 
-    b = tr_new0( tr_blocklist, 1 );
+    b = tr_new0 (tr_blocklist, 1);
     b->fd = -1;
-    b->filename = tr_strdup( filename );
+    b->filename = tr_strdup (filename);
     b->isEnabled = isEnabled;
 
     return b;
 }
 
 const char*
-_tr_blocklistGetFilename( const tr_blocklist * b )
+_tr_blocklistGetFilename (const tr_blocklist * b)
 {
     return b->filename;
 }
 
 void
-_tr_blocklistFree( tr_blocklist * b )
+_tr_blocklistFree (tr_blocklist * b)
 {
-    blocklistClose( b );
-    tr_free( b->filename );
-    tr_free( b );
+    blocklistClose (b);
+    tr_free (b->filename);
+    tr_free (b);
 }
 
 int
-_tr_blocklistExists( const tr_blocklist * b )
+_tr_blocklistExists (const tr_blocklist * b)
 {
     struct stat st;
 
-    return !stat( b->filename, &st );
+    return !stat (b->filename, &st);
 }
 
 int
-_tr_blocklistGetRuleCount( const tr_blocklist * b )
+_tr_blocklistGetRuleCount (const tr_blocklist * b)
 {
-    blocklistEnsureLoaded( (tr_blocklist*)b );
+    blocklistEnsureLoaded ((tr_blocklist*)b);
 
     return b->ruleCount;
 }
 
 int
-_tr_blocklistIsEnabled( tr_blocklist * b )
+_tr_blocklistIsEnabled (tr_blocklist * b)
 {
     return b->isEnabled;
 }
 
 void
-_tr_blocklistSetEnabled( tr_blocklist * b, bool isEnabled )
+_tr_blocklistSetEnabled (tr_blocklist * b, bool isEnabled)
 {
     b->isEnabled = isEnabled ? 1 : 0;
 }
 
 int
-_tr_blocklistHasAddress( tr_blocklist * b, const tr_address * addr )
+_tr_blocklistHasAddress (tr_blocklist * b, const tr_address * addr)
 {
     uint32_t                     needle;
     const struct tr_ipv4_range * range;
 
-    assert( tr_address_is_valid( addr ) );
+    assert (tr_address_is_valid (addr));
 
-    if( !b->isEnabled || addr->type == TR_AF_INET6 )
+    if (!b->isEnabled || addr->type == TR_AF_INET6)
         return 0;
 
-    blocklistEnsureLoaded( b );
+    blocklistEnsureLoaded (b);
 
-    if( !b->rules || !b->ruleCount )
+    if (!b->rules || !b->ruleCount)
         return 0;
 
-    needle = ntohl( addr->addr.addr4.s_addr );
+    needle = ntohl (addr->addr.addr4.s_addr);
 
-    range = bsearch( &needle,
+    range = bsearch (&needle,
                      b->rules,
                      b->ruleCount,
-                     sizeof( struct tr_ipv4_range ),
-                     compareAddressToRange );
+                     sizeof (struct tr_ipv4_range),
+                     compareAddressToRange);
 
     return range != NULL;
 }
@@ -235,7 +235,7 @@ _tr_blocklistHasAddress( tr_blocklist * b, const tr_address * addr )
  * http://en.wikipedia.org/wiki/PeerGuardian#P2P_plaintext_format
  */
 static bool
-parseLine1( const char * line, struct tr_ipv4_range * range )
+parseLine1 (const char * line, struct tr_ipv4_range * range)
 {
     char * walk;
     int b[4];
@@ -243,25 +243,25 @@ parseLine1( const char * line, struct tr_ipv4_range * range )
     char str[64];
     tr_address addr;
 
-    walk = strrchr( line, ':' );
-    if( !walk )
+    walk = strrchr (line, ':');
+    if (!walk)
         return false;
     ++walk; /* walk past the colon */
 
-    if( sscanf( walk, "%d.%d.%d.%d-%d.%d.%d.%d",
+    if (sscanf (walk, "%d.%d.%d.%d-%d.%d.%d.%d",
                 &b[0], &b[1], &b[2], &b[3],
-                &e[0], &e[1], &e[2], &e[3] ) != 8 )
+                &e[0], &e[1], &e[2], &e[3]) != 8)
         return false;
 
-    tr_snprintf( str, sizeof( str ), "%d.%d.%d.%d", b[0], b[1], b[2], b[3] );
-    if( !tr_address_from_string( &addr, str ) )
+    tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
+    if (!tr_address_from_string (&addr, str))
         return false;
-    range->begin = ntohl( addr.addr.addr4.s_addr );
+    range->begin = ntohl (addr.addr.addr4.s_addr);
 
-    tr_snprintf( str, sizeof( str ), "%d.%d.%d.%d", e[0], e[1], e[2], e[3] );
-    if( !tr_address_from_string( &addr, str ) )
+    tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", e[0], e[1], e[2], e[3]);
+    if (!tr_address_from_string (&addr, str))
         return false;
-    range->end = ntohl( addr.addr.addr4.s_addr );
+    range->end = ntohl (addr.addr.addr4.s_addr);
 
     return true;
 }
@@ -271,7 +271,7 @@ parseLine1( const char * line, struct tr_ipv4_range * range )
  * http://wiki.phoenixlabs.org/wiki/DAT_Format
  */
 static bool
-parseLine2( const char * line, struct tr_ipv4_range * range )
+parseLine2 (const char * line, struct tr_ipv4_range * range)
 {
     int unk;
     int a[4];
@@ -279,79 +279,79 @@ parseLine2( const char * line, struct tr_ipv4_range * range )
     char str[32];
     tr_address addr;
 
-    if( sscanf( line, "%3d.%3d.%3d.%3d - %3d.%3d.%3d.%3d , %3d , ",
+    if (sscanf (line, "%3d.%3d.%3d.%3d - %3d.%3d.%3d.%3d , %3d , ",
                 &a[0], &a[1], &a[2], &a[3],
                 &b[0], &b[1], &b[2], &b[3],
-                &unk ) != 9 )
+                &unk) != 9)
         return false;
 
-    tr_snprintf( str, sizeof(str), "%d.%d.%d.%d", a[0], a[1], a[2], a[3] );
-    if( !tr_address_from_string( &addr, str ) )
+    tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
+    if (!tr_address_from_string (&addr, str))
         return false;
-    range->begin = ntohl( addr.addr.addr4.s_addr );
+    range->begin = ntohl (addr.addr.addr4.s_addr);
 
-    tr_snprintf( str, sizeof(str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3] );
-    if( !tr_address_from_string( &addr, str ) )
+    tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
+    if (!tr_address_from_string (&addr, str))
         return false;
-    range->end = ntohl( addr.addr.addr4.s_addr );
+    range->end = ntohl (addr.addr.addr4.s_addr);
 
     return true;
 }
 
 static int
-parseLine( const char * line, struct tr_ipv4_range * range )
+parseLine (const char * line, struct tr_ipv4_range * range)
 {
-    return parseLine1( line, range )
-        || parseLine2( line, range );
+    return parseLine1 (line, range)
+        || parseLine2 (line, range);
 }
 
 static int
-compareAddressRangesByFirstAddress( const void * va, const void * vb )
+compareAddressRangesByFirstAddress (const void * va, const void * vb)
 {
     const struct tr_ipv4_range * a = va;
     const struct tr_ipv4_range * b = vb;
-    if( a->begin != b->begin )
+    if (a->begin != b->begin)
         return a->begin < b->begin ? -1 : 1;
     return 0;
 }
 
 int
-_tr_blocklistSetContent( tr_blocklist * b, const char * filename )
+_tr_blocklistSetContent (tr_blocklist * b, const char * filename)
 {
     FILE * in;
     FILE * out;
     int inCount = 0;
     char line[2048];
-    const char * err_fmt = _( "Couldn't read \"%1$s\": %2$s" );
+    const char * err_fmt = _ ("Couldn't read \"%1$s\": %2$s");
     struct tr_ipv4_range * ranges = NULL;
     size_t ranges_alloc = 0;
     size_t ranges_count = 0;
 
-    if( !filename )
+    if (!filename)
     {
-        blocklistDelete( b );
+        blocklistDelete (b);
         return 0;
     }
 
-    in = fopen( filename, "rb" );
-    if( !in )
+    in = fopen (filename, "rb");
+    if (!in)
     {
-        tr_err( err_fmt, filename, tr_strerror( errno ) );
+        tr_err (err_fmt, filename, tr_strerror (errno));
         return 0;
     }
 
-    blocklistClose( b );
+    blocklistClose (b);
 
-    out = fopen( b->filename, "wb+" );
-    if( !out )
+    out = fopen (b->filename, "wb+");
+    if (!out)
     {
-        tr_err( err_fmt, b->filename, tr_strerror( errno ) );
-        fclose( in );
+        tr_err (err_fmt, b->filename, tr_strerror (errno));
+        fclose (in);
         return 0;
     }
 
     /* load the rules into memory */
-    while( fgets( line, sizeof( line ), in ) != NULL )
+    while (fgets (line, sizeof (line), in) != NULL)
     {
         char * walk;
         struct tr_ipv4_range range;
@@ -359,40 +359,40 @@ _tr_blocklistSetContent( tr_blocklist * b, const char * filename )
         ++inCount;
 
         /* zap the linefeed */
-        if(( walk = strchr( line, '\r' ))) *walk = '\0';
-        if(( walk = strchr( line, '\n' ))) *walk = '\0';
+        if ((walk = strchr (line, '\r'))) *walk = '\0';
+        if ((walk = strchr (line, '\n'))) *walk = '\0';
 
-        if( !parseLine( line, &range ) )
+        if (!parseLine (line, &range))
         {
             /* don't try to display the actual lines - it causes issues */
-            tr_err( _( "blocklist skipped invalid address at line %d" ), inCount );
+            tr_err (_ ("blocklist skipped invalid address at line %d"), inCount);
             continue;
         }
 
-        if( ranges_alloc == ranges_count )
+        if (ranges_alloc == ranges_count)
         {
             ranges_alloc += 4096; /* arbitrary */
-            ranges = tr_renew( struct tr_ipv4_range, ranges, ranges_alloc );
+            ranges = tr_renew (struct tr_ipv4_range, ranges, ranges_alloc);
         }
 
         ranges[ranges_count++] = range;
     }
 
-    if( ranges_count > 0 ) /* sort and merge */
+    if (ranges_count > 0) /* sort and merge */
     {
         struct tr_ipv4_range * r;
         struct tr_ipv4_range * keep = ranges;
         const struct tr_ipv4_range * end;
 
         /* sort */
-        qsort( ranges, ranges_count, sizeof( struct tr_ipv4_range ),
-               compareAddressRangesByFirstAddress );
+        qsort (ranges, ranges_count, sizeof (struct tr_ipv4_range),
+               compareAddressRangesByFirstAddress);
 
         /* merge */
-        for( r=ranges+1, end=ranges+ranges_count; r!=end; ++r ) {
-            if( keep->end < r->begin )
+        for (r=ranges+1, end=ranges+ranges_count; r!=end; ++r) {
+            if (keep->end < r->begin)
                 *++keep = *r;
-            else if( keep->end < r->end )
+            else if (keep->end < r->end)
                 keep->end = r->end;
         }
 
@@ -404,28 +404,28 @@ _tr_blocklistSetContent( tr_blocklist * b, const char * filename )
         {
             size_t i;
 
-            for( i=0; i<ranges_count; ++i )
-                assert( ranges[i].begin <= ranges[i].end );
+            for (i=0; i<ranges_count; ++i)
+                assert (ranges[i].begin <= ranges[i].end);
 
-            for( i=1; i<ranges_count; ++i )
-                assert( ranges[i-1].end < ranges[i].begin );
+            for (i=1; i<ranges_count; ++i)
+                assert (ranges[i-1].end < ranges[i].begin);
         }
 #endif
     }
 
-    if( fwrite( ranges, sizeof( struct tr_ipv4_range ), ranges_count, out ) != ranges_count )
-        tr_err( _( "Couldn't save file \"%1$s\": %2$s" ), b->filename, tr_strerror( errno ) );
+    if (fwrite (ranges, sizeof (struct tr_ipv4_range), ranges_count, out) != ranges_count)
+        tr_err (_ ("Couldn't save file \"%1$s\": %2$s"), b->filename, tr_strerror (errno));
     else {
-        char * base = tr_basename( b->filename );
-        tr_inf( _( "Blocklist \"%s\" updated with %zu entries" ), base, ranges_count );
-        tr_free( base );
+        char * base = tr_basename (b->filename);
+        tr_inf (_ ("Blocklist \"%s\" updated with %zu entries"), base, ranges_count);
+        tr_free (base);
     }
 
-    tr_free( ranges );
-    fclose( out );
-    fclose( in );
+    tr_free (ranges);
+    fclose (out);
+    fclose (in);
 
-    blocklistLoad( b );
+    blocklistLoad (b);
 
     return ranges_count;
 }
diff --git a/libtransmission/blocklist.h b/libtransmission/blocklist.h
index 467cff2a8..90dbf9ffa 100644
--- a/libtransmission/blocklist.h
+++ b/libtransmission/blocklist.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -20,26 +20,26 @@
 struct tr_address;
 typedef struct tr_blocklist tr_blocklist;
 
-tr_blocklist* _tr_blocklistNew         ( const char              * filename,
-                                         bool                   isEnabled );
+tr_blocklist* _tr_blocklistNew       (const char              * filename,
+                                         bool                   isEnabled);
 
-int           _tr_blocklistExists      ( const tr_blocklist      * b );
+int           _tr_blocklistExists    (const tr_blocklist      * b);
 
-const char*   _tr_blocklistGetFilename ( const tr_blocklist      * b );
+const char*   _tr_blocklistGetFilename (const tr_blocklist      * b);
 
-int           _tr_blocklistGetRuleCount( const tr_blocklist      * b );
+int           _tr_blocklistGetRuleCount (const tr_blocklist      * b);
 
-void          _tr_blocklistFree        ( tr_blocklist * );
+void          _tr_blocklistFree      (tr_blocklist *);
 
-int           _tr_blocklistIsEnabled   ( tr_blocklist            * b );
+int           _tr_blocklistIsEnabled (tr_blocklist            * b);
 
-void          _tr_blocklistSetEnabled  ( tr_blocklist            * b,
-                                         bool                      isEnabled );
+void          _tr_blocklistSetEnabled (tr_blocklist            * b,
+                                         bool                      isEnabled);
 
-int           _tr_blocklistHasAddress  ( tr_blocklist            * b,
-                                         const struct tr_address * addr );
+int           _tr_blocklistHasAddress (tr_blocklist            * b,
+                                         const struct tr_address * addr);
 
-int           _tr_blocklistSetContent  ( tr_blocklist            * b,
-                                         const char              * filename );
+int           _tr_blocklistSetContent (tr_blocklist            * b,
+                                         const char              * filename);
 
 #endif
diff --git a/libtransmission/cache.c b/libtransmission/cache.c
index a94ccff41..054ba60be 100644
--- a/libtransmission/cache.c
+++ b/libtransmission/cache.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,7 +10,7 @@
  * $Id$
  */
 
-#include <stdlib.h> /* qsort() */
+#include <stdlib.h> /* qsort () */
 
 #include <event2/buffer.h>
 
@@ -24,12 +24,13 @@
 
 #define MY_NAME "Cache"
 
-#define dbgmsg( ... ) \
-    do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, MY_NAME, __VA_ARGS__ ); \
-    } while( 0 )
-
+#define dbgmsg(...) \
+  do \
+    { \
+      if (tr_deepLoggingIsActive ()) \
+        tr_deepLog (__FILE__, __LINE__, MY_NAME, __VA_ARGS__); \
+    } \
+  while (0)
 
 /****
 *****
@@ -37,28 +38,28 @@
 
 struct cache_block
 {
-    tr_torrent * tor;
+  tr_torrent * tor;
 
-    tr_piece_index_t piece;
-    uint32_t offset;
-    uint32_t length;
+  tr_piece_index_t piece;
+  uint32_t offset;
+  uint32_t length;
 
-    time_t time;
-    tr_block_index_t block;
+  time_t time;
+  tr_block_index_t block;
 
-    struct evbuffer * evbuf;
+  struct evbuffer * evbuf;
 };
 
 struct tr_cache
 {
-    tr_ptrArray blocks;
-    int max_blocks;
-    size_t max_bytes;
-
-    size_t disk_writes;
-    size_t disk_write_bytes;
-    size_t cache_writes;
-    size_t cache_write_bytes;
+  tr_ptrArray blocks;
+  int max_blocks;
+  size_t max_bytes;
+
+  size_t disk_writes;
+  size_t disk_write_bytes;
+  size_t cache_writes;
+  size_t cache_write_bytes;
 };
 
 /****
@@ -67,164 +68,176 @@ struct tr_cache
 
 struct run_info
 {
-  int       pos;
-  int       rank;
-  time_t    last_block_time;
-  bool      is_multi_piece;
-  bool      is_piece_done;
-  unsigned  len;
+  int pos;
+  int rank;
+  time_t last_block_time;
+  bool is_multi_piece;
+  bool is_piece_done;
+  unsigned len;
 };
 
 
 /* return a count of how many contiguous blocks there are starting at this pos */
 static int
-getBlockRun( const tr_cache * cache, int pos, struct run_info * info )
+getBlockRun (const tr_cache * cache, int pos, struct run_info * info)
 {
-    int i;
-    const int n = tr_ptrArraySize( &cache->blocks );
-    const struct cache_block ** blocks = (const struct cache_block**) tr_ptrArrayBase( &cache->blocks );
-    const struct cache_block * ref = blocks[pos];
-    tr_block_index_t block = ref->block;
-
-    for( i=pos; i<n; ++i, ++block ) {
-        const struct cache_block * b = blocks[i];
-        if( b->block != block ) break;
-        if( b->tor != ref->tor ) break;
-//fprintf( stderr, "pos %d tor %d block %zu time %zu\n", i, b->tor->uniqueId, (size_t)b->block, (size_t)b->time );
+  int i;
+  const int n = tr_ptrArraySize (&cache->blocks);
+  const struct cache_block ** blocks = (const struct cache_block**) tr_ptrArrayBase (&cache->blocks);
+  const struct cache_block * ref = blocks[pos];
+  tr_block_index_t block = ref->block;
+
+  for (i=pos; i<n; ++i, ++block)
+    {
+      const struct cache_block * b = blocks[i];
+      if (b->block != block)
+        break;
+      if (b->tor != ref->tor)
+        break;
+      //fprintf (stderr, "pos %d tor %d block %zu time %zu\n", i, b->tor->uniqueId, (size_t)b->block, (size_t)b->time);
     }
 
-//fprintf( stderr, "run is %d long from [%d to %d)\n", (int)(i-pos), i, (int)pos );
-    if( info != NULL ) {
-        const struct cache_block * b = blocks[i-1];
-        info->last_block_time = b->time;
-        info->is_piece_done = tr_cpPieceIsComplete( &b->tor->completion, b->piece );
-        info->is_multi_piece = b->piece != blocks[pos]->piece ? true : false;
-        info->len = i - pos;
-        info->pos = pos;
+  //fprintf (stderr, "run is %d long from [%d to %d)\n", (int)(i-pos), i, (int)pos);
+
+  if (info != NULL)
+    {
+      const struct cache_block * b = blocks[i-1];
+      info->last_block_time = b->time;
+      info->is_piece_done = tr_cpPieceIsComplete (&b->tor->completion, b->piece);
+      info->is_multi_piece = b->piece != blocks[pos]->piece ? true : false;
+      info->len = i - pos;
+      info->pos = pos;
     }
 
-    return i-pos;
+  return i-pos;
 }
 
 /* higher rank comes before lower rank */
 static int
-compareRuns( const void * va, const void * vb )
+compareRuns (const void * va, const void * vb)
 {
-    const struct run_info * a = va;
-    const struct run_info * b = vb;
-    return b->rank - a->rank;
+  const struct run_info * a = va;
+  const struct run_info * b = vb;
+  return b->rank - a->rank;
 }
 
 enum
 {
-    MULTIFLAG   = 0x1000,
-    DONEFLAG    = 0x2000,
-    SESSIONFLAG = 0x4000
+  MULTIFLAG   = 0x1000,
+  DONEFLAG    = 0x2000,
+  SESSIONFLAG = 0x4000
 };
+
 /* Calculte runs
  *   - Stale runs, runs sitting in cache for a long time or runs not growing, get priority.
  *     Returns number of runs.
  */
 static int
-calcRuns( tr_cache * cache, struct run_info * runs )
+calcRuns (tr_cache * cache, struct run_info * runs)
 {
-    const int n = tr_ptrArraySize( &cache->blocks );
-    int i = 0, pos;
-    const time_t now = tr_time();
+  const int n = tr_ptrArraySize (&cache->blocks);
+  int i = 0, pos;
+  const time_t now = tr_time ();
 
-    for( pos = 0; pos < n; pos += runs[i++].len )
+  for (pos = 0; pos < n; pos += runs[i++].len)
     {
-        int rank = getBlockRun( cache, pos, &runs[i] );
+      int rank = getBlockRun (cache, pos, &runs[i]);
+
+      /* This adds ~2 to the relative length of a run for every minute it has
+       * languished in the cache. */
+      rank += (now - runs[i].last_block_time) / 32;
 
-        /* This adds ~2 to the relative length of a run for every minute it has
-         * languished in the cache. */
-        rank += ( now - runs[i].last_block_time ) / 32;
+      /* Flushing stale blocks should be a top priority as the probability of them
+       * growing is very small, for blocks on piece boundaries, and nonexistant for
+       * blocks inside pieces. */
+      rank |= runs[i].is_piece_done ? DONEFLAG : 0;
 
-        /* Flushing stale blocks should be a top priority as the probability of them
-         * growing is very small, for blocks on piece boundaries, and nonexistant for
-         * blocks inside pieces. */
-        rank |= runs[i].is_piece_done ? DONEFLAG : 0;
+      /* Move the multi piece runs higher */
+      rank |= runs[i].is_multi_piece ? MULTIFLAG : 0;
 
-        /* Move the multi piece runs higher */
-        rank |= runs[i].is_multi_piece ? MULTIFLAG : 0;
+      runs[i].rank = rank;
 
-        runs[i].rank = rank;
-//fprintf(stderr,"block run at pos %d of length %d and age %ld adjusted +%d\n",runs[i].pos,runs[i].len,now-runs[i].last_block_time,rank-runs[i].len);
+      //fprintf (stderr,"block run at pos %d of length %d and age %ld adjusted +%d\n",runs[i].pos,runs[i].len,now-runs[i].last_block_time,rank-runs[i].len);
     }
 
-    //fprintf( stderr, "%d block runs\n", i );
-    qsort( runs, i, sizeof( struct run_info ), compareRuns );
-    return i;
+  //fprintf (stderr, "%d block runs\n", i);
+  qsort (runs, i, sizeof (struct run_info), compareRuns);
+  return i;
 }
 
 static int
-flushContiguous( tr_cache * cache, int pos, int n )
+flushContiguous (tr_cache * cache, int pos, int n)
 {
-    int i;
-    int err = 0;
-    uint8_t * buf = tr_new( uint8_t, n * MAX_BLOCK_SIZE );
-    uint8_t * walk = buf;
-    struct cache_block ** blocks = (struct cache_block**) tr_ptrArrayBase( &cache->blocks );
-
-    struct cache_block * b = blocks[pos];
-    tr_torrent * tor             = b->tor;
-    const tr_piece_index_t piece = b->piece;
-    const uint32_t offset        = b->offset;
-
-    for( i=pos; i<pos+n; ++i ) {
-        b = blocks[i];
-        evbuffer_copyout( b->evbuf, walk, b->length );
-        walk += b->length;
-        evbuffer_free( b->evbuf );
-        tr_free( b );
+  int i;
+  int err = 0;
+  uint8_t * buf = tr_new (uint8_t, n * MAX_BLOCK_SIZE);
+  uint8_t * walk = buf;
+  struct cache_block ** blocks = (struct cache_block**) tr_ptrArrayBase (&cache->blocks);
+
+  struct cache_block * b = blocks[pos];
+  tr_torrent * tor = b->tor;
+  const tr_piece_index_t piece = b->piece;
+  const uint32_t offset = b->offset;
+
+  for (i=pos; i<pos+n; ++i)
+    {
+      b = blocks[i];
+      evbuffer_copyout (b->evbuf, walk, b->length);
+      walk += b->length;
+      evbuffer_free (b->evbuf);
+      tr_free (b);
     }
-    tr_ptrArrayErase( &cache->blocks, pos, pos+n );
+  tr_ptrArrayErase (&cache->blocks, pos, pos+n);
 
-    err = tr_ioWrite( tor, piece, offset, walk-buf, buf );
-    tr_free( buf );
+  err = tr_ioWrite (tor, piece, offset, walk-buf, buf);
+  tr_free (buf);
 
-    ++cache->disk_writes;
-    cache->disk_write_bytes += walk-buf;
-    return err;
+  ++cache->disk_writes;
+  cache->disk_write_bytes += walk-buf;
+  return err;
 }
 
 static int
-flushRuns( tr_cache * cache, struct run_info * runs, int n )
+flushRuns (tr_cache * cache, struct run_info * runs, int n)
 {
-    int i, j, err = 0;
+  int i;
+  int err = 0;
 
-    for( i = 0; !err && i < n; ++i )
+  for (i=0; !err && i<n; i++)
     {
-        err = flushContiguous( cache, runs[i].pos, runs[i].len );
-        for( j = i + 1; j < n; ++j )
-            if( runs[j].pos > runs[i].pos )
-                runs[j].pos -= runs[i].len;
+      int j;
+
+      err = flushContiguous (cache, runs[i].pos, runs[i].len);
+
+      for (j=i+1; j<n; j++)
+        if (runs[j].pos > runs[i].pos)
+          runs[j].pos -= runs[i].len;
     }
 
-    return err;
+  return err;
 }
 
 static int
-cacheTrim( tr_cache * cache )
+cacheTrim (tr_cache * cache)
 {
-    int err = 0;
+  int err = 0;
 
-    if( tr_ptrArraySize( &cache->blocks ) > cache->max_blocks )
+  if (tr_ptrArraySize (&cache->blocks) > cache->max_blocks)
     {
-        /* Amount of cache that should be removed by the flush. This influences how large
-         * runs can grow as well as how often flushes will happen. */
-        const int cacheCutoff = 1 + cache->max_blocks / 4;
-        struct run_info * runs = tr_new( struct run_info, tr_ptrArraySize( &cache->blocks ) );
-        int i = 0, j = 0;
-
-        calcRuns( cache, runs );
-        while( j < cacheCutoff )
-            j += runs[i++].len;
-        err = flushRuns( cache, runs, i );
-        tr_free( runs );
+      /* Amount of cache that should be removed by the flush. This influences how large
+       * runs can grow as well as how often flushes will happen. */
+      const int cacheCutoff = 1 + cache->max_blocks / 4;
+      struct run_info * runs = tr_new (struct run_info, tr_ptrArraySize (&cache->blocks));
+      int i=0, j=0;
+
+      calcRuns (cache, runs);
+      while (j < cacheCutoff)
+        j += runs[i++].len;
+      err = flushRuns (cache, runs, i);
+      tr_free (runs);
     }
 
-    return err;
+  return err;
 }
 
 /***
@@ -232,47 +245,47 @@ cacheTrim( tr_cache * cache )
 ***/
 
 static int
-getMaxBlocks( int64_t max_bytes )
+getMaxBlocks (int64_t max_bytes)
 {
-    return max_bytes / (double)MAX_BLOCK_SIZE;
+  return max_bytes / (double)MAX_BLOCK_SIZE;
 }
 
 int
-tr_cacheSetLimit( tr_cache * cache, int64_t max_bytes )
+tr_cacheSetLimit (tr_cache * cache, int64_t max_bytes)
 {
-    char buf[128];
+  char buf[128];
 
-    cache->max_bytes = max_bytes;
-    cache->max_blocks = getMaxBlocks( max_bytes );
+  cache->max_bytes = max_bytes;
+  cache->max_blocks = getMaxBlocks (max_bytes);
 
-    tr_formatter_mem_B( buf, cache->max_bytes, sizeof( buf ) );
-    tr_ndbg( MY_NAME, "Maximum cache size set to %s (%d blocks)", buf, cache->max_blocks );
+  tr_formatter_mem_B (buf, cache->max_bytes, sizeof (buf));
+  tr_ndbg (MY_NAME, "Maximum cache size set to %s (%d blocks)", buf, cache->max_blocks);
 
-    return cacheTrim( cache );
+  return cacheTrim (cache);
 }
 
 int64_t
-tr_cacheGetLimit( const tr_cache * cache )
+tr_cacheGetLimit (const tr_cache * cache)
 {
-    return cache->max_bytes;
+  return cache->max_bytes;
 }
 
 tr_cache *
-tr_cacheNew( int64_t max_bytes )
+tr_cacheNew (int64_t max_bytes)
 {
-    tr_cache * cache = tr_new0( tr_cache, 1 );
-    cache->blocks = TR_PTR_ARRAY_INIT;
-    cache->max_bytes = max_bytes;
-    cache->max_blocks = getMaxBlocks( max_bytes );
-    return cache;
+  tr_cache * cache = tr_new0 (tr_cache, 1);
+  cache->blocks = TR_PTR_ARRAY_INIT;
+  cache->max_bytes = max_bytes;
+  cache->max_blocks = getMaxBlocks (max_bytes);
+  return cache;
 }
 
 void
-tr_cacheFree( tr_cache * cache )
+tr_cacheFree (tr_cache * cache)
 {
-    assert( tr_ptrArrayEmpty( &cache->blocks ) );
-    tr_ptrArrayDestruct( &cache->blocks, NULL );
-    tr_free( cache );
+  assert (tr_ptrArrayEmpty (&cache->blocks));
+  tr_ptrArrayDestruct (&cache->blocks, NULL);
+  tr_free (cache);
 }
 
 /***
@@ -280,102 +293,102 @@ tr_cacheFree( tr_cache * cache )
 ***/
 
 static int
-cache_block_compare( const void * va, const void * vb )
+cache_block_compare (const void * va, const void * vb)
 {
-    const struct cache_block * a = va;
-    const struct cache_block * b = vb;
+  const struct cache_block * a = va;
+  const struct cache_block * b = vb;
 
-    /* primary key: torrent id */
-    if( a->tor->uniqueId != b->tor->uniqueId )
-        return a->tor->uniqueId < b->tor->uniqueId ? -1 : 1;
+  /* primary key: torrent id */
+  if (a->tor->uniqueId != b->tor->uniqueId)
+    return a->tor->uniqueId < b->tor->uniqueId ? -1 : 1;
 
-    /* secondary key: block # */
-    if( a->block != b->block )
-        return a->block < b->block ? -1 : 1;
+  /* secondary key: block # */
+  if (a->block != b->block)
+    return a->block < b->block ? -1 : 1;
 
-    /* they're equal */
-    return 0;
+  /* they're equal */
+  return 0;
 }
 
 static struct cache_block *
-findBlock( tr_cache           * cache,
+findBlock (tr_cache           * cache,
            tr_torrent         * torrent,
            tr_piece_index_t     piece,
-           uint32_t             offset )
+           uint32_t             offset)
 {
-    struct cache_block key;
-    key.tor = torrent;
-    key.block = _tr_block( torrent, piece, offset );
-    return tr_ptrArrayFindSorted( &cache->blocks, &key, cache_block_compare );
+  struct cache_block key;
+  key.tor = torrent;
+  key.block = _tr_block (torrent, piece, offset);
+  return tr_ptrArrayFindSorted (&cache->blocks, &key, cache_block_compare);
 }
 
 int
-tr_cacheWriteBlock( tr_cache         * cache,
+tr_cacheWriteBlock (tr_cache         * cache,
                     tr_torrent       * torrent,
                     tr_piece_index_t   piece,
                     uint32_t           offset,
                     uint32_t           length,
-                    struct evbuffer  * writeme )
+                    struct evbuffer  * writeme)
 {
-    struct cache_block * cb = findBlock( cache, torrent, piece, offset );
+  struct cache_block * cb = findBlock (cache, torrent, piece, offset);
 
-    if( cb == NULL )
+  if (cb == NULL)
     {
-        cb = tr_new( struct cache_block, 1 );
-        cb->tor = torrent;
-        cb->piece = piece;
-        cb->offset = offset;
-        cb->length = length;
-        cb->block = _tr_block( torrent, piece, offset );
-        cb->evbuf = evbuffer_new( );
-        tr_ptrArrayInsertSorted( &cache->blocks, cb, cache_block_compare );
+      cb = tr_new (struct cache_block, 1);
+      cb->tor = torrent;
+      cb->piece = piece;
+      cb->offset = offset;
+      cb->length = length;
+      cb->block = _tr_block (torrent, piece, offset);
+      cb->evbuf = evbuffer_new ();
+      tr_ptrArrayInsertSorted (&cache->blocks, cb, cache_block_compare);
     }
 
-    cb->time = tr_time();
+  cb->time = tr_time ();
 
-    assert( cb->length == length );
-    evbuffer_drain( cb->evbuf, evbuffer_get_length( cb->evbuf ) );
-    evbuffer_remove_buffer( writeme, cb->evbuf, cb->length );
+  assert (cb->length == length);
+  evbuffer_drain (cb->evbuf, evbuffer_get_length (cb->evbuf));
+  evbuffer_remove_buffer (writeme, cb->evbuf, cb->length);
 
-    ++cache->cache_writes;
-    cache->cache_write_bytes += cb->length;
+  cache->cache_writes++;
+  cache->cache_write_bytes += cb->length;
 
-    return cacheTrim( cache );
+  return cacheTrim (cache);
 }
 
 int
-tr_cacheReadBlock( tr_cache         * cache,
+tr_cacheReadBlock (tr_cache         * cache,
                    tr_torrent       * torrent,
                    tr_piece_index_t   piece,
                    uint32_t           offset,
                    uint32_t           len,
-                   uint8_t          * setme )
+                   uint8_t          * setme)
 {
-    int err = 0;
-    struct cache_block * cb = findBlock( cache, torrent, piece, offset );
+  int err = 0;
+  struct cache_block * cb = findBlock (cache, torrent, piece, offset);
 
-    if( cb )
-        evbuffer_copyout( cb->evbuf, setme, len );
-    else
-        err = tr_ioRead( torrent, piece, offset, len, setme );
+  if (cb)
+    evbuffer_copyout (cb->evbuf, setme, len);
+  else
+    err = tr_ioRead (torrent, piece, offset, len, setme);
 
-    return err;
+  return err;
 }
 
 int
-tr_cachePrefetchBlock( tr_cache         * cache,
+tr_cachePrefetchBlock (tr_cache         * cache,
                        tr_torrent       * torrent,
                        tr_piece_index_t   piece,
                        uint32_t           offset,
-                       uint32_t           len )
+                       uint32_t           len)
 {
-    int err = 0;
-    struct cache_block * cb = findBlock( cache, torrent, piece, offset );
+  int err = 0;
+  struct cache_block * cb = findBlock (cache, torrent, piece, offset);
 
-    if( cb == NULL )
-        err = tr_ioPrefetch( torrent, piece, offset, len );
+  if (cb == NULL)
+    err = tr_ioPrefetch (torrent, piece, offset, len);
 
-    return err;
+  return err;
 }
 
 /***
@@ -383,69 +396,81 @@ tr_cachePrefetchBlock( tr_cache         * cache,
 ***/
 
 static int
-findBlockPos( tr_cache * cache, tr_torrent * torrent, tr_piece_index_t block )
+findBlockPos (tr_cache * cache, tr_torrent * torrent, tr_piece_index_t block)
 {
-    struct cache_block key;
-    key.tor = torrent;
-    key.block = block;
-    return tr_ptrArrayLowerBound( &cache->blocks, &key, cache_block_compare, NULL );
+  struct cache_block key;
+  key.tor = torrent;
+  key.block = block;
+  return tr_ptrArrayLowerBound (&cache->blocks, &key, cache_block_compare, NULL);
 }
 
-int tr_cacheFlushDone( tr_cache * cache )
+int tr_cacheFlushDone (tr_cache * cache)
 {
-    int err = 0;
+  int err = 0;
 
-    if( tr_ptrArraySize( &cache->blocks ) > 0 )
+  if (tr_ptrArraySize (&cache->blocks) > 0)
     {
-        struct run_info * runs = tr_new( struct run_info, tr_ptrArraySize( &cache->blocks ) );
-        int i = 0, n;
-
-        n = calcRuns( cache, runs );
-        while( i < n && ( runs[i].is_piece_done || runs[i].is_multi_piece ) )
-            runs[i++].rank |= SESSIONFLAG;
-        err = flushRuns( cache, runs, i );
-        tr_free( runs );
+      int i, n;
+      struct run_info * runs;
+
+      runs = tr_new (struct run_info, tr_ptrArraySize (&cache->blocks));
+      i = 0;
+      n = calcRuns (cache, runs);
+
+      while (i < n && (runs[i].is_piece_done || runs[i].is_multi_piece))
+        runs[i++].rank |= SESSIONFLAG;
+
+      err = flushRuns (cache, runs, i);
+      tr_free (runs);
     }
 
-    return err;
+  return err;
 }
 
 int
-tr_cacheFlushFile( tr_cache * cache, tr_torrent * torrent, tr_file_index_t i )
+tr_cacheFlushFile (tr_cache * cache, tr_torrent * torrent, tr_file_index_t i)
 {
-    int pos;
-    int err = 0;
-    tr_block_index_t first;
-    tr_block_index_t last;
-    tr_torGetFileBlockRange( torrent, i, &first, &last );
-    pos = findBlockPos( cache, torrent, first );
-    dbgmsg( "flushing file %d from cache to disk: blocks [%zu...%zu]", (int)i, (size_t)first, (size_t)last );
-
-    /* flush out all the blocks in that file */
-    while( !err && ( pos < tr_ptrArraySize( &cache->blocks ) ) )
+  int pos;
+  int err = 0;
+  tr_block_index_t first;
+  tr_block_index_t last;
+
+  tr_torGetFileBlockRange (torrent, i, &first, &last);
+  pos = findBlockPos (cache, torrent, first);
+  dbgmsg ("flushing file %d from cache to disk: blocks [%zu...%zu]", (int)i, (size_t)first, (size_t)last);
+
+  /* flush out all the blocks in that file */
+  while (!err && (pos < tr_ptrArraySize (&cache->blocks)))
     {
-        const struct cache_block * b = tr_ptrArrayNth( &cache->blocks, pos );
-        if( b->tor != torrent ) break;
-        if( ( b->block < first ) || ( b->block > last ) ) break;
-        err = flushContiguous( cache, pos, getBlockRun( cache, pos, NULL ) );
+      const struct cache_block * b = tr_ptrArrayNth (&cache->blocks, pos);
+
+      if (b->tor != torrent)
+        break;
+      if ((b->block < first) || (b->block > last))
+        break;
+
+      err = flushContiguous (cache, pos, getBlockRun (cache, pos, NULL));
     }
 
     return err;
 }
 
 int
-tr_cacheFlushTorrent( tr_cache * cache, tr_torrent * torrent )
+tr_cacheFlushTorrent (tr_cache * cache, tr_torrent * torrent)
 {
-    int err = 0;
-    const int pos = findBlockPos( cache, torrent, 0 );
+  int err = 0;
+  const int pos = findBlockPos (cache, torrent, 0);
 
-    /* flush out all the blocks in that torrent */
-    while( !err && ( pos < tr_ptrArraySize( &cache->blocks ) ) )
+  /* flush out all the blocks in that torrent */
+  while (!err && (pos < tr_ptrArraySize (&cache->blocks)))
     {
-        const struct cache_block * b = tr_ptrArrayNth( &cache->blocks, pos );
-        if( b->tor != torrent ) break;
-        err = flushContiguous( cache, pos, getBlockRun( cache, pos, NULL ) );
+      const struct cache_block * b = tr_ptrArrayNth (&cache->blocks, pos);
+
+      if (b->tor != torrent)
+        break;
+
+      err = flushContiguous (cache, pos, getBlockRun (cache, pos, NULL));
     }
 
-    return err;
+  return err;
 }
diff --git a/libtransmission/cache.h b/libtransmission/cache.h
index 8a0feb29a..d0b048b84 100644
--- a/libtransmission/cache.h
+++ b/libtransmission/cache.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -25,48 +25,49 @@ typedef struct tr_cache tr_cache;
 ****
 ***/
 
-tr_cache * tr_cacheNew( int64_t max_bytes );
+tr_cache * tr_cacheNew (int64_t max_bytes);
 
-void tr_cacheFree( tr_cache * );
+void tr_cacheFree (tr_cache *);
 
 /***
 ****
 ***/
 
-int tr_cacheSetLimit( tr_cache * cache, int64_t max_bytes );
+int tr_cacheSetLimit (tr_cache * cache, int64_t max_bytes);
 
-int64_t tr_cacheGetLimit( const tr_cache * );
+int64_t tr_cacheGetLimit (const tr_cache *);
 
-int tr_cacheWriteBlock( tr_cache         * cache,
+int tr_cacheWriteBlock (tr_cache         * cache,
                         tr_torrent       * torrent,
                         tr_piece_index_t   piece,
                         uint32_t           offset,
                         uint32_t           len,
-                        struct evbuffer  * writeme );
+                        struct evbuffer  * writeme);
 
-int tr_cacheReadBlock( tr_cache         * cache,
+int tr_cacheReadBlock (tr_cache         * cache,
                        tr_torrent       * torrent,
                        tr_piece_index_t   piece,
                        uint32_t           offset,
                        uint32_t           len,
-                       uint8_t          * setme );
+                       uint8_t          * setme);
 
-int tr_cachePrefetchBlock( tr_cache         * cache,
+int tr_cachePrefetchBlock (tr_cache         * cache,
                            tr_torrent       * torrent,
                            tr_piece_index_t   piece,
                            uint32_t           offset,
-                           uint32_t           len );
+                           uint32_t           len);
 
 /***
 ****
 ***/
-int tr_cacheFlushDone( tr_cache * cache );
 
-int tr_cacheFlushTorrent( tr_cache    * cache,
-                          tr_torrent  * torrent );
+int tr_cacheFlushDone (tr_cache * cache);
 
-int tr_cacheFlushFile( tr_cache         * cache,
+int tr_cacheFlushTorrent (tr_cache    * cache,
+                          tr_torrent  * torrent);
+
+int tr_cacheFlushFile (tr_cache         * cache,
                        tr_torrent       * torrent,
-                       tr_file_index_t    file );
+                       tr_file_index_t    file);
 
 #endif
diff --git a/libtransmission/clients-test.c b/libtransmission/clients-test.c
index 3b7248e45..02e0faac2 100644
--- a/libtransmission/clients-test.c
+++ b/libtransmission/clients-test.c
@@ -5,32 +5,32 @@
 #include "libtransmission-test.h"
 
 
-#define TEST_CLIENT( A, B ) \
-    tr_clientForId( buf, sizeof( buf ), A ); \
-    check_streq( B, buf );
+#define TEST_CLIENT(A, B) \
+    tr_clientForId (buf, sizeof (buf), A); \
+    check_streq (B, buf);
 
 int
-main( void )
+main (void)
 {
     char buf[128];
 
-    TEST_CLIENT( "-FC1013-", "FileCroc 1.0.1.3" );
-    TEST_CLIENT( "-MR1100-", "Miro 1.1.0.0" );
-    TEST_CLIENT( "-TR0006-", "Transmission 0.6" );
-    TEST_CLIENT( "-TR0072-", "Transmission 0.72" );
-    TEST_CLIENT( "-TR111Z-", "Transmission 1.11+" );
-    TEST_CLIENT( "O1008132", "Osprey 1.0.0" );
+    TEST_CLIENT ("-FC1013-", "FileCroc 1.0.1.3");
+    TEST_CLIENT ("-MR1100-", "Miro 1.1.0.0");
+    TEST_CLIENT ("-TR0006-", "Transmission 0.6");
+    TEST_CLIENT ("-TR0072-", "Transmission 0.72");
+    TEST_CLIENT ("-TR111Z-", "Transmission 1.11+");
+    TEST_CLIENT ("O1008132", "Osprey 1.0.0");
 
     /* gobbledygook */
-    TEST_CLIENT( "-IIO\x10\x2D\x04-", "-IIO%10-%04-" );
-    TEST_CLIENT( "-I\05O\x08\x03\x01-", "-I%05O%08%03%01-" );
+    TEST_CLIENT ("-IIO\x10\x2D\x04-", "-IIO%10-%04-");
+    TEST_CLIENT ("-I\05O\x08\x03\x01-", "-I%05O%08%03%01-");
 
-    TEST_CLIENT(
+    TEST_CLIENT (
         "\x65\x78\x62\x63\x00\x38\x7A\x44\x63\x10\x2D\x6E\x9A\xD6\x72\x3B\x33\x9F\x35\xA9",
-        "BitComet 0.56" );
-    TEST_CLIENT(
+        "BitComet 0.56");
+    TEST_CLIENT (
         "\x65\x78\x62\x63\x00\x38\x4C\x4F\x52\x44\x32\x00\x04\x8E\xCE\xD5\x7B\xD7\x10\x28",
-        "BitLord 0.56" );
+        "BitLord 0.56");
 
     /* cleanup */
     return 0;
diff --git a/libtransmission/clients.c b/libtransmission/clients.c
index 1a5ac9aad..7c2df0a1e 100644
--- a/libtransmission/clients.c
+++ b/libtransmission/clients.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -12,47 +12,47 @@
 
 /* thanks amc1! */
 
-#include <ctype.h> /* isprint() */
-#include <stdlib.h> /* strtol() */
+#include <ctype.h> /* isprint () */
+#include <stdlib.h> /* strtol () */
 #include <string.h>
 
 #include "transmission.h"
 #include "clients.h"
-#include "utils.h" /* tr_snprintf(), tr_strlcpy() */
+#include "utils.h" /* tr_snprintf (), tr_strlcpy () */
 
 static int
-charint( uint8_t ch )
+charint (uint8_t ch)
 {
-    if( '0' <= ch && ch <= '9' ) return      ch - '0';
-    if( 'A' <= ch && ch <= 'Z' ) return 10 + ch - 'A';
-    if( 'a' <= ch && ch <= 'z' ) return 36 + ch - 'a';
+    if ('0' <= ch && ch <= '9') return      ch - '0';
+    if ('A' <= ch && ch <= 'Z') return 10 + ch - 'A';
+    if ('a' <= ch && ch <= 'z') return 36 + ch - 'a';
     return 0;
 }
 
 static int
-getShadowInt( uint8_t ch, int * setme )
+getShadowInt (uint8_t ch, int * setme)
 {
     const char * str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-";
-    const char * pch = strchr( str, ch );
-    if( !pch )
+    const char * pch = strchr (str, ch);
+    if (!pch)
         return 0;
     *setme = pch - str;
     return 1;
 }
 
 static int
-strint( const void * pch, int span )
+strint (const void * pch, int span)
 {
     char tmp[64];
-    memcpy( tmp, pch, span );
+    memcpy (tmp, pch, span);
     tmp[span] = '\0';
-    return strtol( tmp, NULL, 0 );
+    return strtol (tmp, NULL, 0);
 }
 
 static const char*
-getMnemonicEnd( uint8_t ch )
+getMnemonicEnd (uint8_t ch)
 {
-    switch( ch )
+    switch (ch)
     {
         case 'b': case 'B': return " (Beta)";
         case 'd': return " (Debug)";
@@ -62,46 +62,46 @@ getMnemonicEnd( uint8_t ch )
 }
 
 static void
-three_digits( char * buf, size_t buflen, const char * name, const uint8_t * digits )
+three_digits (char * buf, size_t buflen, const char * name, const uint8_t * digits)
 {
-    tr_snprintf( buf, buflen, "%s %d.%d.%d", name,
-                 charint( digits[0] ),
-                 charint( digits[1] ),
-                 charint( digits[2] ) );
+    tr_snprintf (buf, buflen, "%s %d.%d.%d", name,
+                 charint (digits[0]),
+                 charint (digits[1]),
+                 charint (digits[2]));
 }
 static void
-four_digits( char * buf, size_t buflen, const char * name, const uint8_t * digits )
+four_digits (char * buf, size_t buflen, const char * name, const uint8_t * digits)
 {
-    tr_snprintf( buf, buflen, "%s %d.%d.%d.%d", name,
-                 charint( digits[0] ),
-                 charint( digits[1] ),
-                 charint( digits[2] ),
-                 charint( digits[3] ) );
+    tr_snprintf (buf, buflen, "%s %d.%d.%d.%d", name,
+                 charint (digits[0]),
+                 charint (digits[1]),
+                 charint (digits[2]),
+                 charint (digits[3]));
 }
 static void
-two_major_two_minor( char * buf, size_t buflen, const char * name, const uint8_t * digits )
+two_major_two_minor (char * buf, size_t buflen, const char * name, const uint8_t * digits)
 {
-    tr_snprintf( buf, buflen, "%s %d.%02d", name,
-                 strint( digits, 2 ),
-                 strint( digits+2, 2 ) );
+    tr_snprintf (buf, buflen, "%s %d.%02d", name,
+                 strint (digits, 2),
+                 strint (digits+2, 2));
 }
 static void
-no_version( char * buf, size_t buflen, const char * name )
+no_version (char * buf, size_t buflen, const char * name)
 {
-    tr_strlcpy( buf, name, buflen );
+    tr_strlcpy (buf, name, buflen);
 }
 
 static void
-mainline_style( char * buf, size_t buflen, const char * name, const uint8_t * id )
+mainline_style (char * buf, size_t buflen, const char * name, const uint8_t * id)
 {
-    if( id[4] == '-' && id[6] == '-' )
-        tr_snprintf( buf, buflen, "%s %c.%c.%c", name, id[1], id[3], id[5] );
-    else if( id[5] == '-' )
-        tr_snprintf( buf, buflen, "%s %c.%c%c.%c", name, id[1], id[3], id[4], id[6] );
+    if (id[4] == '-' && id[6] == '-')
+        tr_snprintf (buf, buflen, "%s %c.%c.%c", name, id[1], id[3], id[5]);
+    else if (id[5] == '-')
+        tr_snprintf (buf, buflen, "%s %c.%c%c.%c", name, id[1], id[3], id[4], id[6]);
 }
 
 static int
-isMainlineStyle( const uint8_t * peer_id )
+isMainlineStyle (const uint8_t * peer_id)
 {
     /**
      * One of the following styles will be used:
@@ -110,23 +110,23 @@ isMainlineStyle( const uint8_t * peer_id )
      */
     return peer_id[2]=='-'
         && peer_id[7]=='-'
-        && ( peer_id[4]=='-' || peer_id[5]=='-' );
+        && (peer_id[4]=='-' || peer_id[5]=='-');
 }
 
 static int
-decodeBitCometClient( char * buf, size_t buflen, const uint8_t * id )
+decodeBitCometClient (char * buf, size_t buflen, const uint8_t * id)
 {
     int is_bitlord;
     int major, minor;
     const char * name;
     const char * mod = NULL;
 
-    if( !memcmp( id, "exbc", 4 ) ) mod = "";
-    else if( !memcmp( id, "FUTB", 4 )) mod = "(Solidox Mod) ";
-    else if( !memcmp( id, "xUTB", 4 )) mod = "(Mod 2) ";
+    if (!memcmp (id, "exbc", 4)) mod = "";
+    else if (!memcmp (id, "FUTB", 4)) mod = " (Solidox Mod) ";
+    else if (!memcmp (id, "xUTB", 4)) mod = " (Mod 2) ";
     else return false;
 
-    is_bitlord = !memcmp( id+6, "LORD", 4 );
+    is_bitlord = !memcmp (id+6, "LORD", 4);
     name = (is_bitlord) ? "BitLord " : "BitComet ";
     major = id[4];
     minor = id[5];
@@ -135,298 +135,298 @@ decodeBitCometClient( char * buf, size_t buflen, const uint8_t * id )
      * Bitcomet, and older versions of BitLord, are of the form x.yy.
      * Bitcoment 1.0 and onwards are of the form x.y.
      */
-    if( is_bitlord && major>0 )
-        tr_snprintf( buf, buflen, "%s%s%d.%d", name, mod, major, minor );
+    if (is_bitlord && major>0)
+        tr_snprintf (buf, buflen, "%s%s%d.%d", name, mod, major, minor);
     else
-        tr_snprintf( buf, buflen, "%s%s%d.%02d", name, mod, major, minor );
+        tr_snprintf (buf, buflen, "%s%s%d.%02d", name, mod, major, minor);
 
     return true;
 }
 
 void
-tr_clientForId( char * buf, size_t buflen, const void * id_in )
+tr_clientForId (char * buf, size_t buflen, const void * id_in)
 {
     const uint8_t * id = id_in;
 
     *buf = '\0';
 
-    if( !id )
+    if (!id)
         return;
 
     /* Azureus-style */
-    if( id[0] == '-' && id[7] == '-' )
+    if (id[0] == '-' && id[7] == '-')
     {
-        if( !memcmp( id+1, "TR", 2 ) )
+        if (!memcmp (id+1, "TR", 2))
         {
-            if( !memcmp( id+3, "000", 3 ) ) /* very old client style: -TR0006- is 0.6 */
-                tr_snprintf( buf, buflen, "Transmission 0.%c", id[6] );
-            else if( !memcmp( id+3, "00", 2) ) /* previous client style: -TR0072- is 0.72 */
-                tr_snprintf( buf, buflen, "Transmission 0.%02d", strint(id+5,2) );
+            if (!memcmp (id+3, "000", 3)) /* very old client style: -TR0006- is 0.6 */
+                tr_snprintf (buf, buflen, "Transmission 0.%c", id[6]);
+            else if (!memcmp (id+3, "00", 2)) /* previous client style: -TR0072- is 0.72 */
+                tr_snprintf (buf, buflen, "Transmission 0.%02d", strint (id+5,2));
             else /* current client style: -TR111Z- is 1.11+ */
-                tr_snprintf( buf, buflen, "Transmission %d.%02d%s", strint(id+3,1), strint(id+4,2),
-                          id[6]=='Z' || id[6]=='X' ? "+" : "" );
+                tr_snprintf (buf, buflen, "Transmission %d.%02d%s", strint (id+3,1), strint (id+4,2),
+                          id[6]=='Z' || id[6]=='X' ? "+" : "");
         }
 
-        else if( !memcmp( id+1, "UT", 2 ) )
+        else if (!memcmp (id+1, "UT", 2))
         {
-            tr_snprintf( buf, buflen, "\xc2\xb5Torrent %d.%d.%d%s",
-                         strint(id+3,1), strint(id+4,1), strint(id+5,1), getMnemonicEnd(id[6]) );
+            tr_snprintf (buf, buflen, "\xc2\xb5Torrent %d.%d.%d%s",
+                         strint (id+3,1), strint (id+4,1), strint (id+5,1), getMnemonicEnd (id[6]));
         }
-        else if( !memcmp( id+1, "UM", 2 ) )
+        else if (!memcmp (id+1, "UM", 2))
         {
-            tr_snprintf( buf, buflen, "\xc2\xb5Torrent Mac %d.%d.%d%s",
-                         strint(id+3,1), strint(id+4,1), strint(id+5,1), getMnemonicEnd(id[6]) );
+            tr_snprintf (buf, buflen, "\xc2\xb5Torrent Mac %d.%d.%d%s",
+                         strint (id+3,1), strint (id+4,1), strint (id+5,1), getMnemonicEnd (id[6]));
         }
-        else if( !memcmp( id+1, "UE", 2 ) )
+        else if (!memcmp (id+1, "UE", 2))
         {
-            tr_snprintf( buf, buflen, "\xc2\xb5Torrent Embedded %d.%d.%d%s",
-                        strint(id+3,1), strint(id+4,1), strint(id+5,1), getMnemonicEnd(id[6]) );
+            tr_snprintf (buf, buflen, "\xc2\xb5Torrent Embedded %d.%d.%d%s",
+                        strint (id+3,1), strint (id+4,1), strint (id+5,1), getMnemonicEnd (id[6]));
         }
 
-        else if( !memcmp( id+1, "AZ", 2 ) )
+        else if (!memcmp (id+1, "AZ", 2))
         {
-            if( id[3] > '3' || ( id[3] == '3' && id[4] >= '1' ) ) /* Vuze starts at version 3.1.0.0 */
-                four_digits( buf, buflen, "Vuze", id+3 );
+            if (id[3] > '3' || (id[3] == '3' && id[4] >= '1')) /* Vuze starts at version 3.1.0.0 */
+                four_digits (buf, buflen, "Vuze", id+3);
             else
-                four_digits( buf, buflen, "Azureus", id+3 );
+                four_digits (buf, buflen, "Azureus", id+3);
         }
 
-        else if( !memcmp( id+1, "KT", 2 ) )
+        else if (!memcmp (id+1, "KT", 2))
         {
-            if( id[5] == 'D' )
-                tr_snprintf( buf, buflen, "KTorrent %d.%d Dev %d", charint(id[3]), charint(id[4]), charint(id[6]) );
-            else if( id[5] == 'R' )
-                tr_snprintf( buf, buflen, "KTorrent %d.%d RC %d", charint(id[3]), charint(id[4]), charint(id[6]) );
+            if (id[5] == 'D')
+                tr_snprintf (buf, buflen, "KTorrent %d.%d Dev %d", charint (id[3]), charint (id[4]), charint (id[6]));
+            else if (id[5] == 'R')
+                tr_snprintf (buf, buflen, "KTorrent %d.%d RC %d", charint (id[3]), charint (id[4]), charint (id[6]));
             else
-                three_digits( buf, buflen, "KTorrent", id+3 );
+                three_digits (buf, buflen, "KTorrent", id+3);
         }
 
-        else if( !memcmp( id+1, "AG", 2 ) ) four_digits( buf, buflen, "Ares", id+3 );
-        else if( !memcmp( id+1, "AR", 2 ) ) four_digits( buf, buflen, "Arctic", id+3 );
-        else if( !memcmp( id+1, "AT", 2 ) ) four_digits( buf, buflen, "Artemis", id+3 );
-        else if( !memcmp( id+1, "AV", 2 ) ) four_digits( buf, buflen, "Avicora", id+3 );
-        else if( !memcmp( id+1, "BB", 2 ) ) four_digits( buf, buflen, "BitBuddy", id+3 );
-        else if( !memcmp( id+1, "BE", 2 ) ) four_digits( buf, buflen, "BitTorrent SDK", id+3 );
-        else if( !memcmp( id+1, "BG", 2 ) ) four_digits( buf, buflen, "BTGetit", id+3 );
-        else if( !memcmp( id+1, "BH", 2 ) ) four_digits( buf, buflen, "BitZilla", id+3 );
-        else if( !memcmp( id+1, "BM", 2 ) ) four_digits( buf, buflen, "BitMagnet", id+3 );
-        else if( !memcmp( id+1, "BP", 2 ) ) four_digits( buf, buflen, "BitTorrent Pro (Azureus + Spyware)", id+3 );
-        else if( !memcmp( id+1, "BX", 2 ) ) four_digits( buf, buflen, "BittorrentX", id+3 );
-        else if( !memcmp( id+1, "bk", 2 ) ) four_digits( buf, buflen, "BitKitten (libtorrent)", id+3 );
-        else if( !memcmp( id+1, "BS", 2 ) ) four_digits( buf, buflen, "BTSlave", id+3 );
-        else if( !memcmp( id+1, "BW", 2 ) ) four_digits( buf, buflen, "BitWombat", id+3 );
-        else if( !memcmp( id+1, "BX", 2 ) ) four_digits( buf, buflen, "BittorrentX", id+3 );
-        else if( !memcmp( id+1, "EB", 2 ) ) four_digits( buf, buflen, "EBit", id+3 );
-        else if( !memcmp( id+1, "DE", 2 ) ) four_digits( buf, buflen, "Deluge", id+3 );
-        else if( !memcmp( id+1, "DP", 2 ) ) four_digits( buf, buflen, "Propogate Data Client", id+3 );
-        else if( !memcmp( id+1, "FC", 2 ) ) four_digits( buf, buflen, "FileCroc", id+3 );
-        else if( !memcmp( id+1, "FT", 2 ) ) four_digits( buf, buflen, "FoxTorrent/RedSwoosh", id+3 );
-        else if( !memcmp( id+1, "GR", 2 ) ) four_digits( buf, buflen, "GetRight", id+3 );
-        else if( !memcmp( id+1, "GS", 2 ) ) four_digits( buf, buflen, "GSTorrent", id+3 );
-        else if( !memcmp( id+1, "HK", 2 ) ) four_digits( buf, buflen, "Hekate", id+3 );
-        else if( !memcmp( id+1, "HN", 2 ) ) four_digits( buf, buflen, "Hydranode", id+3 );
-        else if( !memcmp( id+1, "KG", 2 ) ) four_digits( buf, buflen, "KGet", id+3 );
-        else if( !memcmp( id+1, "LC", 2 ) ) four_digits( buf, buflen, "LeechCraft", id+3 );
-        else if( !memcmp( id+1, "LH", 2 ) ) four_digits( buf, buflen, "LH-ABC", id+3 );
-        else if( !memcmp( id+1, "NX", 2 ) ) four_digits( buf, buflen, "Net Transport", id+3 );
-        else if( !memcmp( id+1, "MK", 2 ) ) four_digits( buf, buflen, "Meerkat", id+3 );
-        else if( !memcmp( id+1, "MO", 2 ) ) four_digits( buf, buflen, "MonoTorrent", id+3 );
-        else if( !memcmp( id+1, "MR", 2 ) ) four_digits( buf, buflen, "Miro", id+3 );
-        else if( !memcmp( id+1, "MT", 2 ) ) four_digits( buf, buflen, "Moonlight", id+3 );
-        else if( !memcmp( id+1, "OS", 2 ) ) four_digits( buf, buflen, "OneSwarm", id+3 );
-        else if( !memcmp( id+1, "OT", 2 ) ) four_digits( buf, buflen, "OmegaTorrent", id+3 );
-        else if( !memcmp( id+1, "PD", 2 ) ) four_digits( buf, buflen, "Pando", id+3 );
-        else if( !memcmp( id+1, "QD", 2 ) ) four_digits( buf, buflen, "QQDownload", id+3 );
-        else if( !memcmp( id+1, "RS", 2 ) ) four_digits( buf, buflen, "Rufus", id+3 );
-        else if( !memcmp( id+1, "RT", 2 ) ) four_digits( buf, buflen, "Retriever", id+3 );
-        else if( !memcmp( id+1, "RZ", 2 ) ) four_digits( buf, buflen, "RezTorrent", id+3 );
-        else if( !memcmp( id+1, "SD", 2 ) ) four_digits( buf, buflen, "Thunder", id+3 );
-        else if( !memcmp( id+1, "SM", 2 ) ) four_digits( buf, buflen, "SoMud", id+3 );
-        else if( !memcmp( id+1, "SS", 2 ) ) four_digits( buf, buflen, "SwarmScope", id+3 );
-        else if( !memcmp( id+1, "ST", 2 ) ) four_digits( buf, buflen, "SymTorrent", id+3 );
-        else if( !memcmp( id+1, "SZ", 2 ) ) four_digits( buf, buflen, "Shareaza", id+3 );
-        else if( !memcmp( id+1, "S~", 2 ) ) four_digits( buf, buflen, "Shareaza", id+3 );
-        else if( !memcmp( id+1, "st", 2 ) ) four_digits( buf, buflen, "SharkTorrent", id+3 );
-        else if( !memcmp( id+1, "TN", 2 ) ) four_digits( buf, buflen, "Torrent .NET", id+3 );
-        else if( !memcmp( id+1, "TS", 2 ) ) four_digits( buf, buflen, "TorrentStorm", id+3 );
-        else if( !memcmp( id+1, "TT", 2 ) ) four_digits( buf, buflen, "TuoTu", id+3 );
-        else if( !memcmp( id+1, "UL", 2 ) ) four_digits( buf, buflen, "uLeecher!", id+3 );
-        else if( !memcmp( id+1, "VG", 2 ) ) four_digits( buf, buflen, "Vagaa", id+3 );
-        else if( !memcmp( id+1, "WT", 2 ) ) four_digits( buf, buflen, "BitLet", id+3 );
-        else if( !memcmp( id+1, "WY", 2 ) ) four_digits( buf, buflen, "FireTorrent", id+3 );
-        else if( !memcmp( id+1, "XL", 2 ) ) four_digits( buf, buflen, "Xunlei", id+3 );
-        else if( !memcmp( id+1, "XS", 2 ) ) four_digits( buf, buflen, "XSwifter", id+3 );
-        else if( !memcmp( id+1, "XT", 2 ) ) four_digits( buf, buflen, "XanTorrent", id+3 );
-        else if( !memcmp( id+1, "XX", 2 ) ) four_digits( buf, buflen, "Xtorrent", id+3 );
-        else if( !memcmp( id+1, "ZT", 2 ) ) four_digits( buf, buflen, "Zip Torrent", id+3 );
-        else if( !memcmp( id+1, "ZO", 2 ) ) four_digits( buf, buflen, "Zona", id+3 );
-
-        else if( !memcmp( id+1, "AG", 2 ) ) three_digits( buf, buflen, "Ares", id+3 );
-        else if( !memcmp( id+1, "A~", 2 ) ) three_digits( buf, buflen, "Ares", id+3 );
-        else if( !memcmp( id+1, "ES", 2 ) ) three_digits( buf, buflen, "Electric Sheep", id+3 );
-        else if( !memcmp( id+1, "HL", 2 ) ) three_digits( buf, buflen, "Halite", id+3 );
-        else if( !memcmp( id+1, "LT", 2 ) ) three_digits( buf, buflen, "libtorrent (Rasterbar)", id+3 );
-        else if( !memcmp( id+1, "lt", 2 ) ) three_digits( buf, buflen, "libTorrent (Rakshasa)", id+3 );
-        else if( !memcmp( id+1, "MP", 2 ) ) three_digits( buf, buflen, "MooPolice", id+3 );
-        else if( !memcmp( id+1, "pb", 2 ) ) three_digits( buf, buflen, "pbTorrent", id+3 );
-        else if( !memcmp( id+1, "TT", 2 ) ) three_digits( buf, buflen, "TuoTu", id+3 );
-        else if( !memcmp( id+1, "qB", 2 ) ) three_digits( buf, buflen, "qBittorrent", id+3 );
-
-        else if( !memcmp( id+1, "AX", 2 ) ) two_major_two_minor( buf, buflen, "BitPump", id+3 );
-        else if( !memcmp( id+1, "BC", 2 ) ) two_major_two_minor( buf, buflen, "BitComet", id+3 );
-        else if( !memcmp( id+1, "CD", 2 ) ) two_major_two_minor( buf, buflen, "Enhanced CTorrent", id+3 );
-        else if( !memcmp( id+1, "LP", 2 ) ) two_major_two_minor( buf, buflen, "Lphant", id+3 );
-
-        else if( !memcmp( id+1, "BF", 2 ) ) no_version( buf, buflen, "BitFlu" );
-        else if( !memcmp( id+1, "LW", 2 ) ) no_version( buf, buflen, "LimeWire" );
-
-        else if( !memcmp( id+1, "BB", 2 ) )
+        else if (!memcmp (id+1, "AG", 2)) four_digits (buf, buflen, "Ares", id+3);
+        else if (!memcmp (id+1, "AR", 2)) four_digits (buf, buflen, "Arctic", id+3);
+        else if (!memcmp (id+1, "AT", 2)) four_digits (buf, buflen, "Artemis", id+3);
+        else if (!memcmp (id+1, "AV", 2)) four_digits (buf, buflen, "Avicora", id+3);
+        else if (!memcmp (id+1, "BB", 2)) four_digits (buf, buflen, "BitBuddy", id+3);
+        else if (!memcmp (id+1, "BE", 2)) four_digits (buf, buflen, "BitTorrent SDK", id+3);
+        else if (!memcmp (id+1, "BG", 2)) four_digits (buf, buflen, "BTGetit", id+3);
+        else if (!memcmp (id+1, "BH", 2)) four_digits (buf, buflen, "BitZilla", id+3);
+        else if (!memcmp (id+1, "BM", 2)) four_digits (buf, buflen, "BitMagnet", id+3);
+        else if (!memcmp (id+1, "BP", 2)) four_digits (buf, buflen, "BitTorrent Pro (Azureus + Spyware)", id+3);
+        else if (!memcmp (id+1, "BX", 2)) four_digits (buf, buflen, "BittorrentX", id+3);
+        else if (!memcmp (id+1, "bk", 2)) four_digits (buf, buflen, "BitKitten (libtorrent)", id+3);
+        else if (!memcmp (id+1, "BS", 2)) four_digits (buf, buflen, "BTSlave", id+3);
+        else if (!memcmp (id+1, "BW", 2)) four_digits (buf, buflen, "BitWombat", id+3);
+        else if (!memcmp (id+1, "BX", 2)) four_digits (buf, buflen, "BittorrentX", id+3);
+        else if (!memcmp (id+1, "EB", 2)) four_digits (buf, buflen, "EBit", id+3);
+        else if (!memcmp (id+1, "DE", 2)) four_digits (buf, buflen, "Deluge", id+3);
+        else if (!memcmp (id+1, "DP", 2)) four_digits (buf, buflen, "Propogate Data Client", id+3);
+        else if (!memcmp (id+1, "FC", 2)) four_digits (buf, buflen, "FileCroc", id+3);
+        else if (!memcmp (id+1, "FT", 2)) four_digits (buf, buflen, "FoxTorrent/RedSwoosh", id+3);
+        else if (!memcmp (id+1, "GR", 2)) four_digits (buf, buflen, "GetRight", id+3);
+        else if (!memcmp (id+1, "GS", 2)) four_digits (buf, buflen, "GSTorrent", id+3);
+        else if (!memcmp (id+1, "HK", 2)) four_digits (buf, buflen, "Hekate", id+3);
+        else if (!memcmp (id+1, "HN", 2)) four_digits (buf, buflen, "Hydranode", id+3);
+        else if (!memcmp (id+1, "KG", 2)) four_digits (buf, buflen, "KGet", id+3);
+        else if (!memcmp (id+1, "LC", 2)) four_digits (buf, buflen, "LeechCraft", id+3);
+        else if (!memcmp (id+1, "LH", 2)) four_digits (buf, buflen, "LH-ABC", id+3);
+        else if (!memcmp (id+1, "NX", 2)) four_digits (buf, buflen, "Net Transport", id+3);
+        else if (!memcmp (id+1, "MK", 2)) four_digits (buf, buflen, "Meerkat", id+3);
+        else if (!memcmp (id+1, "MO", 2)) four_digits (buf, buflen, "MonoTorrent", id+3);
+        else if (!memcmp (id+1, "MR", 2)) four_digits (buf, buflen, "Miro", id+3);
+        else if (!memcmp (id+1, "MT", 2)) four_digits (buf, buflen, "Moonlight", id+3);
+        else if (!memcmp (id+1, "OS", 2)) four_digits (buf, buflen, "OneSwarm", id+3);
+        else if (!memcmp (id+1, "OT", 2)) four_digits (buf, buflen, "OmegaTorrent", id+3);
+        else if (!memcmp (id+1, "PD", 2)) four_digits (buf, buflen, "Pando", id+3);
+        else if (!memcmp (id+1, "QD", 2)) four_digits (buf, buflen, "QQDownload", id+3);
+        else if (!memcmp (id+1, "RS", 2)) four_digits (buf, buflen, "Rufus", id+3);
+        else if (!memcmp (id+1, "RT", 2)) four_digits (buf, buflen, "Retriever", id+3);
+        else if (!memcmp (id+1, "RZ", 2)) four_digits (buf, buflen, "RezTorrent", id+3);
+        else if (!memcmp (id+1, "SD", 2)) four_digits (buf, buflen, "Thunder", id+3);
+        else if (!memcmp (id+1, "SM", 2)) four_digits (buf, buflen, "SoMud", id+3);
+        else if (!memcmp (id+1, "SS", 2)) four_digits (buf, buflen, "SwarmScope", id+3);
+        else if (!memcmp (id+1, "ST", 2)) four_digits (buf, buflen, "SymTorrent", id+3);
+        else if (!memcmp (id+1, "SZ", 2)) four_digits (buf, buflen, "Shareaza", id+3);
+        else if (!memcmp (id+1, "S~", 2)) four_digits (buf, buflen, "Shareaza", id+3);
+        else if (!memcmp (id+1, "st", 2)) four_digits (buf, buflen, "SharkTorrent", id+3);
+        else if (!memcmp (id+1, "TN", 2)) four_digits (buf, buflen, "Torrent .NET", id+3);
+        else if (!memcmp (id+1, "TS", 2)) four_digits (buf, buflen, "TorrentStorm", id+3);
+        else if (!memcmp (id+1, "TT", 2)) four_digits (buf, buflen, "TuoTu", id+3);
+        else if (!memcmp (id+1, "UL", 2)) four_digits (buf, buflen, "uLeecher!", id+3);
+        else if (!memcmp (id+1, "VG", 2)) four_digits (buf, buflen, "Vagaa", id+3);
+        else if (!memcmp (id+1, "WT", 2)) four_digits (buf, buflen, "BitLet", id+3);
+        else if (!memcmp (id+1, "WY", 2)) four_digits (buf, buflen, "FireTorrent", id+3);
+        else if (!memcmp (id+1, "XL", 2)) four_digits (buf, buflen, "Xunlei", id+3);
+        else if (!memcmp (id+1, "XS", 2)) four_digits (buf, buflen, "XSwifter", id+3);
+        else if (!memcmp (id+1, "XT", 2)) four_digits (buf, buflen, "XanTorrent", id+3);
+        else if (!memcmp (id+1, "XX", 2)) four_digits (buf, buflen, "Xtorrent", id+3);
+        else if (!memcmp (id+1, "ZT", 2)) four_digits (buf, buflen, "Zip Torrent", id+3);
+        else if (!memcmp (id+1, "ZO", 2)) four_digits (buf, buflen, "Zona", id+3);
+
+        else if (!memcmp (id+1, "AG", 2)) three_digits (buf, buflen, "Ares", id+3);
+        else if (!memcmp (id+1, "A~", 2)) three_digits (buf, buflen, "Ares", id+3);
+        else if (!memcmp (id+1, "ES", 2)) three_digits (buf, buflen, "Electric Sheep", id+3);
+        else if (!memcmp (id+1, "HL", 2)) three_digits (buf, buflen, "Halite", id+3);
+        else if (!memcmp (id+1, "LT", 2)) three_digits (buf, buflen, "libtorrent (Rasterbar)", id+3);
+        else if (!memcmp (id+1, "lt", 2)) three_digits (buf, buflen, "libTorrent (Rakshasa)", id+3);
+        else if (!memcmp (id+1, "MP", 2)) three_digits (buf, buflen, "MooPolice", id+3);
+        else if (!memcmp (id+1, "pb", 2)) three_digits (buf, buflen, "pbTorrent", id+3);
+        else if (!memcmp (id+1, "TT", 2)) three_digits (buf, buflen, "TuoTu", id+3);
+        else if (!memcmp (id+1, "qB", 2)) three_digits (buf, buflen, "qBittorrent", id+3);
+
+        else if (!memcmp (id+1, "AX", 2)) two_major_two_minor (buf, buflen, "BitPump", id+3);
+        else if (!memcmp (id+1, "BC", 2)) two_major_two_minor (buf, buflen, "BitComet", id+3);
+        else if (!memcmp (id+1, "CD", 2)) two_major_two_minor (buf, buflen, "Enhanced CTorrent", id+3);
+        else if (!memcmp (id+1, "LP", 2)) two_major_two_minor (buf, buflen, "Lphant", id+3);
+
+        else if (!memcmp (id+1, "BF", 2)) no_version (buf, buflen, "BitFlu");
+        else if (!memcmp (id+1, "LW", 2)) no_version (buf, buflen, "LimeWire");
+
+        else if (!memcmp (id+1, "BB", 2))
         {
-            tr_snprintf( buf, buflen, "BitBuddy %c.%c%c%c", id[3], id[4], id[5], id[6] );
+            tr_snprintf (buf, buflen, "BitBuddy %c.%c%c%c", id[3], id[4], id[5], id[6]);
         }
-        else if( !memcmp( id+1, "BR", 2 ) )
+        else if (!memcmp (id+1, "BR", 2))
         {
-            tr_snprintf( buf, buflen, "BitRocket %c.%c (%c%c)", id[3], id[4], id[5], id[6] );
+            tr_snprintf (buf, buflen, "BitRocket %c.%c (%c%c)", id[3], id[4], id[5], id[6]);
         }
-        else if( !memcmp( id+1, "CT", 2 ) )
+        else if (!memcmp (id+1, "CT", 2))
         {
-            tr_snprintf( buf, buflen, "CTorrent %d.%d.%02d", charint(id[3]), charint(id[4]), strint(id+5,2) );
+            tr_snprintf (buf, buflen, "CTorrent %d.%d.%02d", charint (id[3]), charint (id[4]), strint (id+5,2));
         }
-        else if( !memcmp( id+1, "XC", 2 ) || !memcmp( id+1, "XX", 2 ) )
+        else if (!memcmp (id+1, "XC", 2) || !memcmp (id+1, "XX", 2))
         {
-            tr_snprintf( buf, buflen, "Xtorrent %d.%d (%d)", charint(id[3]), charint(id[4]), strint(id+5,2) );
+            tr_snprintf (buf, buflen, "Xtorrent %d.%d (%d)", charint (id[3]), charint (id[4]), strint (id+5,2));
         }
-        else if( !memcmp( id+1, "BOW", 3 ) )
+        else if (!memcmp (id+1, "BOW", 3))
         {
-                 if( !memcmp( &id[4], "A0B", 3 ) ) tr_snprintf( buf, buflen, "Bits on Wheels 1.0.5" );
-            else if( !memcmp( &id[4], "A0C", 3 ) ) tr_snprintf( buf, buflen, "Bits on Wheels 1.0.6" );
-            else                                   tr_snprintf( buf, buflen, "Bits on Wheels %c.%c.%c", id[4], id[5], id[5] );
+                 if (!memcmp (&id[4], "A0B", 3)) tr_snprintf (buf, buflen, "Bits on Wheels 1.0.5");
+            else if (!memcmp (&id[4], "A0C", 3)) tr_snprintf (buf, buflen, "Bits on Wheels 1.0.6");
+            else                                   tr_snprintf (buf, buflen, "Bits on Wheels %c.%c.%c", id[4], id[5], id[5]);
         }
-        else if( !memcmp( id+1, "MG", 2 ) )
+        else if (!memcmp (id+1, "MG", 2))
         {
-            tr_snprintf( buf, buflen, "MediaGet %d.%02d", charint(id[3]), charint(id[4]) );
+            tr_snprintf (buf, buflen, "MediaGet %d.%02d", charint (id[3]), charint (id[4]));
         }
 
-        if( *buf )
+        if (*buf)
             return;
     }
 
     /* uTorrent will replace the trailing dash with an extra digit for longer version numbers */
-    if( id[0] == '-' )
+    if (id[0] == '-')
     {
-        if( !memcmp( id+1, "UT", 2 ) )
+        if (!memcmp (id+1, "UT", 2))
         {
-            tr_snprintf( buf, buflen, "\xc2\xb5Torrent %d.%d.%d%s",
-                        strint(id+3,1), strint(id+4,1), strint(id+5,2), getMnemonicEnd(id[7]) );
+            tr_snprintf (buf, buflen, "\xc2\xb5Torrent %d.%d.%d%s",
+                        strint (id+3,1), strint (id+4,1), strint (id+5,2), getMnemonicEnd (id[7]));
         }
-        else if( !memcmp( id+1, "UM", 2 ) )
+        else if (!memcmp (id+1, "UM", 2))
         {
-            tr_snprintf( buf, buflen, "\xc2\xb5Torrent Mac %d.%d.%d%s",
-                        strint(id+3,1), strint(id+4,1), strint(id+5,2), getMnemonicEnd(id[7]) );
+            tr_snprintf (buf, buflen, "\xc2\xb5Torrent Mac %d.%d.%d%s",
+                        strint (id+3,1), strint (id+4,1), strint (id+5,2), getMnemonicEnd (id[7]));
         }
-        else if( !memcmp( id+1, "UE", 2 ) )
+        else if (!memcmp (id+1, "UE", 2))
         {
-            tr_snprintf( buf, buflen, "\xc2\xb5Torrent Embedded %d.%d.%d%s",
-                        strint(id+3,1), strint(id+4,1), strint(id+5,2), getMnemonicEnd(id[7]) );
+            tr_snprintf (buf, buflen, "\xc2\xb5Torrent Embedded %d.%d.%d%s",
+                        strint (id+3,1), strint (id+4,1), strint (id+5,2), getMnemonicEnd (id[7]));
         }
 
-        if( *buf )
+        if (*buf)
             return;
     }
 
     /* Mainline */
-    if( isMainlineStyle( id ) )
+    if (isMainlineStyle (id))
     {
-        if( *id=='M' ) mainline_style( buf, buflen, "BitTorrent", id );
-        if( *id=='Q' ) mainline_style( buf, buflen, "Queen Bee", id );
-        if( *buf ) return;
+        if (*id=='M') mainline_style (buf, buflen, "BitTorrent", id);
+        if (*id=='Q') mainline_style (buf, buflen, "Queen Bee", id);
+        if (*buf) return;
     }
 
-    if( decodeBitCometClient( buf, buflen, id ) )
+    if (decodeBitCometClient (buf, buflen, id))
         return;
 
     /* Clients with no version */
-         if( !memcmp( id, "AZ2500BT", 8 ) )  no_version( buf, buflen, "BitTyrant (Azureus Mod)" );
-    else if( !memcmp( id, "LIME", 4 ) )      no_version( buf, buflen, "Limewire" );
-    else if( !memcmp( id, "martini", 7 ) )   no_version( buf, buflen, "Martini Man" );
-    else if( !memcmp( id, "Pando", 5 ) )     no_version( buf, buflen, "Pando" );
-    else if( !memcmp( id, "a00---0", 7 ) )   no_version( buf, buflen, "Swarmy" );
-    else if( !memcmp( id, "a02---0", 7 ) )   no_version( buf, buflen, "Swarmy" );
-    else if( !memcmp( id, "-G3", 3 ) )       no_version( buf, buflen, "G3 Torrent" );
-    else if( !memcmp( id, "10-------", 9 ) ) no_version( buf, buflen, "JVtorrent" );
-    else if( !memcmp( id, "346-", 4 ) )      no_version( buf, buflen, "TorrentTopia" );
-    else if( !memcmp( id, "eX", 2 ) )        no_version( buf, buflen, "eXeem" );
-    else if( !memcmp( id, "aria2-", 6 ) )    no_version( buf, buflen, "aria2" );
-    else if( !memcmp( id, "-WT-", 4 ) )      no_version( buf, buflen, "BitLet" );
-    else if( !memcmp( id, "-FG", 3 ) )       two_major_two_minor( buf, buflen, "FlashGet", id+3 );
+         if (!memcmp (id, "AZ2500BT", 8))  no_version (buf, buflen, "BitTyrant (Azureus Mod)");
+    else if (!memcmp (id, "LIME", 4))      no_version (buf, buflen, "Limewire");
+    else if (!memcmp (id, "martini", 7))   no_version (buf, buflen, "Martini Man");
+    else if (!memcmp (id, "Pando", 5))     no_version (buf, buflen, "Pando");
+    else if (!memcmp (id, "a00---0", 7))   no_version (buf, buflen, "Swarmy");
+    else if (!memcmp (id, "a02---0", 7))   no_version (buf, buflen, "Swarmy");
+    else if (!memcmp (id, "-G3", 3))       no_version (buf, buflen, "G3 Torrent");
+    else if (!memcmp (id, "10-------", 9)) no_version (buf, buflen, "JVtorrent");
+    else if (!memcmp (id, "346-", 4))      no_version (buf, buflen, "TorrentTopia");
+    else if (!memcmp (id, "eX", 2))        no_version (buf, buflen, "eXeem");
+    else if (!memcmp (id, "aria2-", 6))    no_version (buf, buflen, "aria2");
+    else if (!memcmp (id, "-WT-", 4))      no_version (buf, buflen, "BitLet");
+    else if (!memcmp (id, "-FG", 3))       two_major_two_minor (buf, buflen, "FlashGet", id+3);
 
     /* Everything else */
-    else if( !memcmp( id, "S3", 2 ) && id[2] == '-' && id[4] == '-' && id[6] == '-' )
+    else if (!memcmp (id, "S3", 2) && id[2] == '-' && id[4] == '-' && id[6] == '-')
     {
-        tr_snprintf( buf, buflen, "Amazon S3 %c.%c.%c", id[3], id[5], id[7] );
+        tr_snprintf (buf, buflen, "Amazon S3 %c.%c.%c", id[3], id[5], id[7]);
     }
-    else if( !memcmp( id, "OP", 2 ) )
+    else if (!memcmp (id, "OP", 2))
     {
-        tr_snprintf( buf, buflen, "Opera (Build %c%c%c%c)", id[2], id[3], id[4], id[5] );
+        tr_snprintf (buf, buflen, "Opera (Build %c%c%c%c)", id[2], id[3], id[4], id[5]);
     }
-    else if( !memcmp( id, "-ML", 3 ) )
+    else if (!memcmp (id, "-ML", 3))
     {
-        tr_snprintf( buf, buflen, "MLDonkey %c%c%c%c%c", id[3], id[4], id[5], id[6], id[7] );
+        tr_snprintf (buf, buflen, "MLDonkey %c%c%c%c%c", id[3], id[4], id[5], id[6], id[7]);
     }
-    else if( !memcmp( id, "DNA", 3 ) )
+    else if (!memcmp (id, "DNA", 3))
     {
-        tr_snprintf( buf, buflen, "BitTorrent DNA %d.%d.%d", strint(id+3,2),
-                                                             strint(id+5,2),
-                                                             strint(id+7,2) );
+        tr_snprintf (buf, buflen, "BitTorrent DNA %d.%d.%d", strint (id+3,2),
+                                                             strint (id+5,2),
+                                                             strint (id+7,2));
     }
-    else if( !memcmp( id, "Plus", 4 ) )
+    else if (!memcmp (id, "Plus", 4))
     {
-        tr_snprintf( buf, buflen, "Plus! v2 %c.%c%c", id[4], id[5], id[6] );
+        tr_snprintf (buf, buflen, "Plus! v2 %c.%c%c", id[4], id[5], id[6]);
     }
-    else if( !memcmp( id, "XBT", 3 ) )
+    else if (!memcmp (id, "XBT", 3))
     {
-        tr_snprintf( buf, buflen, "XBT Client %c.%c.%c%s", id[3], id[4], id[5], getMnemonicEnd(id[6]) );
+        tr_snprintf (buf, buflen, "XBT Client %c.%c.%c%s", id[3], id[4], id[5], getMnemonicEnd (id[6]));
     }
-    else if( !memcmp( id, "Mbrst", 5 ) )
+    else if (!memcmp (id, "Mbrst", 5))
     {
-        tr_snprintf( buf, buflen, "burst! %c.%c.%c", id[5], id[7], id[9] );
+        tr_snprintf (buf, buflen, "burst! %c.%c.%c", id[5], id[7], id[9]);
     }
-    else if( !memcmp( id, "btpd", 4 ) )
+    else if (!memcmp (id, "btpd", 4))
     {
-        tr_snprintf( buf, buflen, "BT Protocol Daemon %c%c%c", id[5], id[6], id[7] );
+        tr_snprintf (buf, buflen, "BT Protocol Daemon %c%c%c", id[5], id[6], id[7]);
     }
-    else if( !memcmp( id, "BLZ", 3 ) )
+    else if (!memcmp (id, "BLZ", 3))
     {
-        tr_snprintf( buf, buflen, "Blizzard Downloader %d.%d", id[3]+1, id[4] );
+        tr_snprintf (buf, buflen, "Blizzard Downloader %d.%d", id[3]+1, id[4]);
     }
-    else if( !memcmp( id, "-SP", 3 ) )
+    else if (!memcmp (id, "-SP", 3))
     {
-        three_digits( buf, buflen, "BitSpirit", id+3 );
+        three_digits (buf, buflen, "BitSpirit", id+3);
     }
-    else if( '\0' == id[0] && !memcmp( id+2, "BS", 2 ) )
+    else if ('\0' == id[0] && !memcmp (id+2, "BS", 2))
     {
-        tr_snprintf( buf, buflen, "BitSpirit %u", ( id[1] == 0 ? 1 : id[1] ) );
+        tr_snprintf (buf, buflen, "BitSpirit %u", (id[1] == 0 ? 1 : id[1]));
     }
-    else if( !memcmp( id, "QVOD", 4 ) )
+    else if (!memcmp (id, "QVOD", 4))
     {
-        four_digits( buf, buflen, "QVOD", id+4 );
+        four_digits (buf, buflen, "QVOD", id+4);
     }
-    else if( !memcmp( id, "-NE", 3 ) )
+    else if (!memcmp (id, "-NE", 3))
     {
-        four_digits( buf, buflen, "BT Next Evolution", id+3 );
+        four_digits (buf, buflen, "BT Next Evolution", id+3);
     }
 
     /* Shad0w-style */
     {
         int a, b, c;
-        if( strchr( "AOQRSTU", id[0] )
-            && getShadowInt( id[1], &a )
-            && getShadowInt( id[2], &b )
-            && getShadowInt( id[3], &c ) )
+        if (strchr ("AOQRSTU", id[0])
+            && getShadowInt (id[1], &a)
+            && getShadowInt (id[2], &b)
+            && getShadowInt (id[3], &c))
         {
             const char * name = NULL;
 
-            switch( id[0] )
+            switch (id[0])
             {
                 case 'A': name = "ABC"; break;
                 case 'O': name = "Osprey"; break;
@@ -437,28 +437,28 @@ tr_clientForId( char * buf, size_t buflen, const void * id_in )
                 case 'U': name = "UPnP NAT Bit Torrent"; break;
             }
 
-            if( name )
+            if (name)
             {
-                tr_snprintf( buf, buflen, "%s %d.%d.%d", name, a, b, c );
+                tr_snprintf (buf, buflen, "%s %d.%d.%d", name, a, b, c);
                 return;
             }
         }
     }
 
     /* No match */
-    if( !*buf )
+    if (!*buf)
     {
         char out[32], *walk=out;
         const char *in, *in_end;
-        for( in=(const char*)id, in_end=in+8; in!=in_end; ++in ) {
-            if( isprint( *in ) )
+        for (in= (const char*)id, in_end=in+8; in!=in_end; ++in) {
+            if (isprint (*in))
                 *walk++ = *in;
             else {
-                tr_snprintf( walk, out+sizeof(out)-walk, "%%%02X", (unsigned int)*in );
+                tr_snprintf (walk, out+sizeof (out)-walk, "%%%02X", (unsigned int)*in);
                 walk += 3;
             }
         }
         *walk = '\0';
-        tr_strlcpy( buf, out, buflen );
+        tr_strlcpy (buf, out, buflen);
     }
 }
diff --git a/libtransmission/clients.h b/libtransmission/clients.h
index d0b27eb49..dc18d5cab 100644
--- a/libtransmission/clients.h
+++ b/libtransmission/clients.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -21,6 +21,6 @@
  * @brief parse a peer-id into a human-readable client name and version number
  * @ingroup utils
  */
-void tr_clientForId( char * buf, size_t buflen, const void * peer_id );
+void tr_clientForId (char * buf, size_t buflen, const void * peer_id);
 
 #endif
diff --git a/libtransmission/completion.c b/libtransmission/completion.c
index 77a9015ec..801fc595d 100644
--- a/libtransmission/completion.c
+++ b/libtransmission/completion.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -22,37 +22,37 @@
 ***/
 
 static void
-tr_cpReset( tr_completion * cp )
+tr_cpReset (tr_completion * cp)
 {
     cp->sizeNow = 0;
     cp->sizeWhenDoneIsDirty = true;
     cp->haveValidIsDirty = true;
-    tr_bitfieldSetHasNone( &cp->blockBitfield );
+    tr_bitfieldSetHasNone (&cp->blockBitfield);
 }
 
 void
-tr_cpConstruct( tr_completion * cp, tr_torrent * tor )
+tr_cpConstruct (tr_completion * cp, tr_torrent * tor)
 {
     cp->tor = tor;
-    tr_bitfieldConstruct( &cp->blockBitfield, tor->blockCount );
-    tr_cpReset( cp );
+    tr_bitfieldConstruct (&cp->blockBitfield, tor->blockCount);
+    tr_cpReset (cp);
 }
 
 void
-tr_cpBlockInit( tr_completion * cp, const tr_bitfield * b )
+tr_cpBlockInit (tr_completion * cp, const tr_bitfield * b)
 {
-    tr_cpReset( cp );
+    tr_cpReset (cp);
 
     /* set blockBitfield */
-    tr_bitfieldSetFromBitfield( &cp->blockBitfield, b );
+    tr_bitfieldSetFromBitfield (&cp->blockBitfield, b);
 
     /* set sizeNow */
-    cp->sizeNow = tr_bitfieldCountTrueBits( &cp->blockBitfield );
-    assert( cp->sizeNow <= cp->tor->blockCount );
+    cp->sizeNow = tr_bitfieldCountTrueBits (&cp->blockBitfield);
+    assert (cp->sizeNow <= cp->tor->blockCount);
     cp->sizeNow *= cp->tor->blockSize;
-    if( tr_bitfieldHas( b, cp->tor->blockCount-1 ) )
-        cp->sizeNow -= ( cp->tor->blockSize - cp->tor->lastBlockSize );
-    assert( cp->sizeNow <= cp->tor->info.totalSize );
+    if (tr_bitfieldHas (b, cp->tor->blockCount-1))
+        cp->sizeNow -= (cp->tor->blockSize - cp->tor->lastBlockSize);
+    assert (cp->sizeNow <= cp->tor->info.totalSize);
 }
 
 /***
@@ -60,50 +60,50 @@ tr_cpBlockInit( tr_completion * cp, const tr_bitfield * b )
 ***/
 
 tr_completeness
-tr_cpGetStatus( const tr_completion * cp )
+tr_cpGetStatus (const tr_completion * cp)
 {
-    if( tr_cpHasAll( cp ) ) return TR_SEED;
-    if( !tr_torrentHasMetadata( cp->tor ) ) return TR_LEECH;
-    if( cp->sizeNow == tr_cpSizeWhenDone( cp ) ) return TR_PARTIAL_SEED;
+    if (tr_cpHasAll (cp)) return TR_SEED;
+    if (!tr_torrentHasMetadata (cp->tor)) return TR_LEECH;
+    if (cp->sizeNow == tr_cpSizeWhenDone (cp)) return TR_PARTIAL_SEED;
     return TR_LEECH;
 }
 
 void
-tr_cpPieceRem( tr_completion *  cp, tr_piece_index_t piece )
+tr_cpPieceRem (tr_completion *  cp, tr_piece_index_t piece)
 {
     tr_block_index_t i, f, l;
     const tr_torrent * tor = cp->tor;
 
-    tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
+    tr_torGetPieceBlockRange (cp->tor, piece, &f, &l);
 
-    for( i=f; i<=l; ++i )
-        if( tr_cpBlockIsComplete( cp, i ) )
-            cp->sizeNow -= tr_torBlockCountBytes( tor, i );
+    for (i=f; i<=l; ++i)
+        if (tr_cpBlockIsComplete (cp, i))
+            cp->sizeNow -= tr_torBlockCountBytes (tor, i);
 
     cp->haveValidIsDirty = true;
     cp->sizeWhenDoneIsDirty = true;
-    tr_bitfieldRemRange( &cp->blockBitfield, f, l+1 );
+    tr_bitfieldRemRange (&cp->blockBitfield, f, l+1);
 }
 
 void
-tr_cpPieceAdd( tr_completion * cp, tr_piece_index_t piece )
+tr_cpPieceAdd (tr_completion * cp, tr_piece_index_t piece)
 {
     tr_block_index_t i, f, l;
-    tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
+    tr_torGetPieceBlockRange (cp->tor, piece, &f, &l);
 
-    for( i=f; i<=l; ++i )
-        tr_cpBlockAdd( cp, i );
+    for (i=f; i<=l; ++i)
+        tr_cpBlockAdd (cp, i);
 }
 
 void
-tr_cpBlockAdd( tr_completion * cp, tr_block_index_t block )
+tr_cpBlockAdd (tr_completion * cp, tr_block_index_t block)
 {
     const tr_torrent * tor = cp->tor;
 
-    if( !tr_cpBlockIsComplete( cp, block ) )
+    if (!tr_cpBlockIsComplete (cp, block))
     {
-        tr_bitfieldAdd( &cp->blockBitfield, block );
-        cp->sizeNow += tr_torBlockCountBytes( tor, block );
+        tr_bitfieldAdd (&cp->blockBitfield, block);
+        cp->sizeNow += tr_torBlockCountBytes (tor, block);
 
         cp->haveValidIsDirty = true;
         cp->sizeWhenDoneIsDirty = true;
@@ -115,9 +115,9 @@ tr_cpBlockAdd( tr_completion * cp, tr_block_index_t block )
 ***/
 
 uint64_t
-tr_cpHaveValid( const tr_completion * ccp )
+tr_cpHaveValid (const tr_completion * ccp)
 {
-    if( ccp->haveValidIsDirty )
+    if (ccp->haveValidIsDirty)
     {
         tr_piece_index_t i;
         uint64_t size = 0;
@@ -125,9 +125,9 @@ tr_cpHaveValid( const tr_completion * ccp )
         const tr_torrent * tor = ccp->tor;
         const tr_info * info = &tor->info;
 
-        for( i=0; i<info->pieceCount; ++i )
-            if( tr_cpPieceIsComplete( ccp, i ) )
-                size += tr_torPieceCountBytes( tor, i );
+        for (i=0; i<info->pieceCount; ++i)
+            if (tr_cpPieceIsComplete (ccp, i))
+                size += tr_torPieceCountBytes (tor, i);
 
         cp->haveValidLazy = size;
         cp->haveValidIsDirty = false;
@@ -137,16 +137,16 @@ tr_cpHaveValid( const tr_completion * ccp )
 }
 
 uint64_t
-tr_cpSizeWhenDone( const tr_completion * ccp )
+tr_cpSizeWhenDone (const tr_completion * ccp)
 {
-    if( ccp->sizeWhenDoneIsDirty )
+    if (ccp->sizeWhenDoneIsDirty)
     {
         uint64_t size = 0;
         const tr_torrent * tor = ccp->tor;
-        const tr_info * inf = tr_torrentInfo( tor );
+        const tr_info * inf = tr_torrentInfo (tor);
         tr_completion * cp = (tr_completion *) ccp; /* mutable */
 
-        if( tr_cpHasAll( ccp ) )
+        if (tr_cpHasAll (ccp))
         {
             size = inf->totalSize;
         }
@@ -154,33 +154,33 @@ tr_cpSizeWhenDone( const tr_completion * ccp )
         {
             tr_piece_index_t p;
 
-            for( p=0; p<inf->pieceCount; ++p )
+            for (p=0; p<inf->pieceCount; ++p)
             {
                 uint64_t n = 0;
-                const uint64_t pieceSize = tr_torPieceCountBytes( tor, p );
+                const uint64_t pieceSize = tr_torPieceCountBytes (tor, p);
 
-                if( !inf->pieces[p].dnd )
+                if (!inf->pieces[p].dnd)
                 {
                     n = pieceSize;
                 }
                 else
                 {
                     tr_block_index_t f, l;
-                    tr_torGetPieceBlockRange( cp->tor, p, &f, &l );
+                    tr_torGetPieceBlockRange (cp->tor, p, &f, &l);
 
-                    n = tr_bitfieldCountRange( &cp->blockBitfield, f, l+1 );
+                    n = tr_bitfieldCountRange (&cp->blockBitfield, f, l+1);
                     n *= cp->tor->blockSize;
-                    if( l == ( cp->tor->blockCount - 1 )  && tr_bitfieldHas( &cp->blockBitfield, l ) )
-                        n -= ( cp->tor->blockSize - cp->tor->lastBlockSize );
+                    if (l == (cp->tor->blockCount - 1)  && tr_bitfieldHas (&cp->blockBitfield, l))
+                        n -= (cp->tor->blockSize - cp->tor->lastBlockSize);
                 }
 
-                assert( n <= tr_torPieceCountBytes( tor, p ) );
+                assert (n <= tr_torPieceCountBytes (tor, p));
                 size += n;
             }
         }
 
-        assert( size <= inf->totalSize );
-        assert( size >= cp->sizeNow );
+        assert (size <= inf->totalSize);
+        assert (size >= cp->sizeNow);
 
         cp->sizeWhenDoneLazy = size;
         cp->sizeWhenDoneIsDirty = false;
@@ -190,128 +190,128 @@ tr_cpSizeWhenDone( const tr_completion * ccp )
 }
 
 uint64_t
-tr_cpLeftUntilDone( const tr_completion * cp )
+tr_cpLeftUntilDone (const tr_completion * cp)
 {
-    const uint64_t sizeWhenDone = tr_cpSizeWhenDone( cp );
+    const uint64_t sizeWhenDone = tr_cpSizeWhenDone (cp);
 
-    assert( sizeWhenDone >= cp->sizeNow );
+    assert (sizeWhenDone >= cp->sizeNow);
 
     return sizeWhenDone - cp->sizeNow;
 }
 
 void
-tr_cpGetAmountDone( const tr_completion * cp, float * tab, int tabCount )
+tr_cpGetAmountDone (const tr_completion * cp, float * tab, int tabCount)
 {
     int i;
-    const bool seed = tr_cpHasAll( cp );
+    const bool seed = tr_cpHasAll (cp);
     const float interval = cp->tor->info.pieceCount / (float)tabCount;
 
-    for( i=0; i<tabCount; ++i ) {
-        if( seed )
+    for (i=0; i<tabCount; ++i) {
+        if (seed)
             tab[i] = 1.0f;
         else {
             tr_block_index_t f, l;
             const tr_piece_index_t piece = (tr_piece_index_t)i * interval;
-            tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
-            tab[i] = tr_bitfieldCountRange( &cp->blockBitfield, f, l+1 )
+            tr_torGetPieceBlockRange (cp->tor, piece, &f, &l);
+            tab[i] = tr_bitfieldCountRange (&cp->blockBitfield, f, l+1)
                                                             / (float)(l+1-f);
         }
     }
 }
 
 size_t
-tr_cpMissingBlocksInPiece( const tr_completion * cp, tr_piece_index_t piece )
+tr_cpMissingBlocksInPiece (const tr_completion * cp, tr_piece_index_t piece)
 {
-    if( tr_cpHasAll( cp ) )
+    if (tr_cpHasAll (cp))
         return 0;
     else {
         tr_block_index_t f, l;
-        tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
-        return (l+1-f) - tr_bitfieldCountRange( &cp->blockBitfield, f, l+1 );
+        tr_torGetPieceBlockRange (cp->tor, piece, &f, &l);
+        return (l+1-f) - tr_bitfieldCountRange (&cp->blockBitfield, f, l+1);
     }
 }
 
 size_t
-tr_cpMissingBytesInPiece( const tr_completion * cp, tr_piece_index_t piece )
+tr_cpMissingBytesInPiece (const tr_completion * cp, tr_piece_index_t piece)
 {
-    if( tr_cpHasAll( cp ) )
+    if (tr_cpHasAll (cp))
         return 0;
     else {
         size_t haveBytes = 0;
         tr_block_index_t f, l;
-        const size_t pieceByteSize = tr_torPieceCountBytes( cp->tor, piece );
-        tr_torGetPieceBlockRange( cp->tor, piece, &f, &l );
-        if( f != l ) {
-            /* nb: we don't pass the usual l+1 here to tr_bitfieldCountRange().
+        const size_t pieceByteSize = tr_torPieceCountBytes (cp->tor, piece);
+        tr_torGetPieceBlockRange (cp->tor, piece, &f, &l);
+        if (f != l) {
+            /* nb: we don't pass the usual l+1 here to tr_bitfieldCountRange ().
                It's faster to handle the last block separately because its size
                needs to be checked separately. */
-            haveBytes = tr_bitfieldCountRange( &cp->blockBitfield, f, l );
+            haveBytes = tr_bitfieldCountRange (&cp->blockBitfield, f, l);
             haveBytes *= cp->tor->blockSize;
         }
-        if( tr_bitfieldHas( &cp->blockBitfield, l ) ) /* handle the last block */
-            haveBytes += tr_torBlockCountBytes( cp->tor, l );
-        assert(  haveBytes <= pieceByteSize );
+        if (tr_bitfieldHas (&cp->blockBitfield, l)) /* handle the last block */
+            haveBytes += tr_torBlockCountBytes (cp->tor, l);
+        assert (haveBytes <= pieceByteSize);
         return pieceByteSize - haveBytes;
     }
 }
 
 bool
-tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t i )
+tr_cpFileIsComplete (const tr_completion * cp, tr_file_index_t i)
 {
-    if( cp->tor->info.files[i].length == 0 )
+    if (cp->tor->info.files[i].length == 0)
         return true;
     else {
         tr_block_index_t f, l;
-        tr_torGetFileBlockRange( cp->tor, i, &f, &l );
-        return tr_bitfieldCountRange( &cp->blockBitfield, f, l+1 ) == (l+1-f);
+        tr_torGetFileBlockRange (cp->tor, i, &f, &l);
+        return tr_bitfieldCountRange (&cp->blockBitfield, f, l+1) == (l+1-f);
     }
 }
 
 void *
-tr_cpCreatePieceBitfield( const tr_completion * cp, size_t * byte_count )
+tr_cpCreatePieceBitfield (const tr_completion * cp, size_t * byte_count)
 {
     void * ret;
     tr_piece_index_t n;
     tr_bitfield pieces;
 
-    assert( tr_torrentHasMetadata( cp->tor ) );
+    assert (tr_torrentHasMetadata (cp->tor));
 
     n = cp->tor->info.pieceCount;
-    tr_bitfieldConstruct( &pieces, n );
+    tr_bitfieldConstruct (&pieces, n);
 
-    if( tr_cpHasAll( cp ) )
-        tr_bitfieldSetHasAll( &pieces );
-    else if( !tr_cpHasNone( cp ) ) {
+    if (tr_cpHasAll (cp))
+        tr_bitfieldSetHasAll (&pieces);
+    else if (!tr_cpHasNone (cp)) {
         tr_piece_index_t i;
-        bool * flags = tr_new( bool, n );
-        for( i=0; i<n; ++i )
-            flags[i] = tr_cpPieceIsComplete( cp, i );
-        tr_bitfieldSetFromFlags( &pieces, flags, n );
-        tr_free( flags );
+        bool * flags = tr_new (bool, n);
+        for (i=0; i<n; ++i)
+            flags[i] = tr_cpPieceIsComplete (cp, i);
+        tr_bitfieldSetFromFlags (&pieces, flags, n);
+        tr_free (flags);
     }
 
-    ret = tr_bitfieldGetRaw( &pieces, byte_count );
-    tr_bitfieldDestruct( &pieces );
+    ret = tr_bitfieldGetRaw (&pieces, byte_count);
+    tr_bitfieldDestruct (&pieces);
     return ret;
 }
 
 double
-tr_cpPercentComplete( const tr_completion * cp )
+tr_cpPercentComplete (const tr_completion * cp)
 {
-    const double ratio = tr_getRatio( cp->sizeNow, cp->tor->info.totalSize );
+    const double ratio = tr_getRatio (cp->sizeNow, cp->tor->info.totalSize);
 
-    if( (int)ratio == TR_RATIO_NA )
+    if ((int)ratio == TR_RATIO_NA)
         return 0.0;
-    else if( (int)ratio == TR_RATIO_INF )
+    else if ((int)ratio == TR_RATIO_INF)
         return 1.0;
     else
         return ratio;
 }
 
 double
-tr_cpPercentDone( const tr_completion * cp )
+tr_cpPercentDone (const tr_completion * cp)
 {
-    const double ratio = tr_getRatio( cp->sizeNow, tr_cpSizeWhenDone( cp ) );
+    const double ratio = tr_getRatio (cp->sizeNow, tr_cpSizeWhenDone (cp));
     const int iratio = (int)ratio;
     return ((iratio == TR_RATIO_NA) || (iratio == TR_RATIO_INF)) ? 0.0 : ratio;
 }
diff --git a/libtransmission/completion.h b/libtransmission/completion.h
index 6bcbf66fb..d86c915d9 100644
--- a/libtransmission/completion.h
+++ b/libtransmission/completion.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -19,7 +19,7 @@
 
 #include "transmission.h"
 #include "bitfield.h"
-#include "utils.h" /* tr_getRatio() */
+#include "utils.h" /* tr_getRatio () */
 
 typedef struct tr_completion
 {
@@ -29,7 +29,7 @@ typedef struct tr_completion
 
     /* number of bytes we'll have when done downloading. [0..info.totalSize]
        DON'T access this directly; it's a lazy field.
-       use tr_cpSizeWhenDone() instead! */
+       use tr_cpSizeWhenDone () instead! */
     uint64_t sizeWhenDoneLazy;
 
     /* whether or not sizeWhenDone needs to be recalculated */
@@ -37,7 +37,7 @@ typedef struct tr_completion
 
     /* number of bytes we'll have when done downloading. [0..info.totalSize]
        DON'T access this directly; it's a lazy field.
-       use tr_cpHaveValid() instead! */
+       use tr_cpHaveValid () instead! */
     uint64_t haveValidLazy;
 
     /* whether or not haveValidLazy needs to be recalculated */
@@ -52,93 +52,93 @@ tr_completion;
 *** Life Cycle
 **/
 
-void  tr_cpConstruct( tr_completion *, tr_torrent * );
+void  tr_cpConstruct (tr_completion *, tr_torrent *);
 
-void  tr_cpBlockInit( tr_completion * cp, const tr_bitfield * blocks );
+void  tr_cpBlockInit (tr_completion * cp, const tr_bitfield * blocks);
 
 static inline void
-tr_cpDestruct( tr_completion * cp )
+tr_cpDestruct (tr_completion * cp)
 {
-    tr_bitfieldDestruct( &cp->blockBitfield );
+    tr_bitfieldDestruct (&cp->blockBitfield);
 }
 
 /**
 *** General
 **/
 
-double            tr_cpPercentComplete( const tr_completion * cp );
+double            tr_cpPercentComplete (const tr_completion * cp);
 
-double            tr_cpPercentDone( const tr_completion * cp );
+double            tr_cpPercentDone (const tr_completion * cp);
 
-tr_completeness   tr_cpGetStatus( const tr_completion * );
+tr_completeness   tr_cpGetStatus (const tr_completion *);
 
-uint64_t          tr_cpHaveValid( const tr_completion * );
+uint64_t          tr_cpHaveValid (const tr_completion *);
 
-uint64_t          tr_cpSizeWhenDone( const tr_completion * );
+uint64_t          tr_cpSizeWhenDone (const tr_completion *);
 
-uint64_t          tr_cpLeftUntilDone( const tr_completion * );
+uint64_t          tr_cpLeftUntilDone (const tr_completion *);
 
-void              tr_cpGetAmountDone( const   tr_completion * completion,
+void              tr_cpGetAmountDone (const   tr_completion * completion,
                                       float                 * tab,
-                                      int                     tabCount );
+                                      int                     tabCount);
 
 
 static inline uint64_t
-tr_cpHaveTotal( const tr_completion * cp )
+tr_cpHaveTotal (const tr_completion * cp)
 {
     return cp->sizeNow;
 }
 
-static inline bool tr_cpHasAll( const tr_completion * cp )
+static inline bool tr_cpHasAll (const tr_completion * cp)
 {
-    return tr_bitfieldHasAll( &cp->blockBitfield );
+    return tr_bitfieldHasAll (&cp->blockBitfield);
 }
 
-static inline bool tr_cpHasNone( const tr_completion * cp )
+static inline bool tr_cpHasNone (const tr_completion * cp)
 {
-    return tr_bitfieldHasNone( &cp->blockBitfield );
+    return tr_bitfieldHasNone (&cp->blockBitfield);
 }
 
 /**
 ***  Pieces
 **/
 
-void    tr_cpPieceAdd( tr_completion * cp, tr_piece_index_t i );
+void    tr_cpPieceAdd (tr_completion * cp, tr_piece_index_t i);
 
-void    tr_cpPieceRem( tr_completion * cp, tr_piece_index_t i );
+void    tr_cpPieceRem (tr_completion * cp, tr_piece_index_t i);
 
-size_t  tr_cpMissingBlocksInPiece( const tr_completion *, tr_piece_index_t );
+size_t  tr_cpMissingBlocksInPiece (const tr_completion *, tr_piece_index_t);
 
-size_t  tr_cpMissingBytesInPiece ( const tr_completion *, tr_piece_index_t );
+size_t  tr_cpMissingBytesInPiece (const tr_completion *, tr_piece_index_t);
 
 static inline bool
-tr_cpPieceIsComplete( const tr_completion * cp, tr_piece_index_t i )
+tr_cpPieceIsComplete (const tr_completion * cp, tr_piece_index_t i)
 {
-    return tr_cpMissingBlocksInPiece( cp, i ) == 0;
+    return tr_cpMissingBlocksInPiece (cp, i) == 0;
 }
 
 /**
 ***  Blocks
 **/
 
-void  tr_cpBlockAdd( tr_completion * cp, tr_block_index_t i );
+void  tr_cpBlockAdd (tr_completion * cp, tr_block_index_t i);
 
 static inline bool
-tr_cpBlockIsComplete( const tr_completion * cp, tr_block_index_t i )
+tr_cpBlockIsComplete (const tr_completion * cp, tr_block_index_t i)
 {
-    return tr_bitfieldHas( &cp->blockBitfield, i );
+    return tr_bitfieldHas (&cp->blockBitfield, i);
 }
 
 /***
 ****  Misc
 ***/
 
-bool  tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t );
+bool  tr_cpFileIsComplete (const tr_completion * cp, tr_file_index_t);
 
-void* tr_cpCreatePieceBitfield( const tr_completion * cp, size_t * byte_count );
+void* tr_cpCreatePieceBitfield (const tr_completion * cp, size_t * byte_count);
 
 static inline void
-tr_cpInvalidateDND( tr_completion * cp )
+tr_cpInvalidateDND (tr_completion * cp)
 {
     cp->sizeWhenDoneIsDirty = true;
 }
diff --git a/libtransmission/crypto.c b/libtransmission/crypto.c
index 96987b5f2..cf4c9af30 100644
--- a/libtransmission/crypto.c
+++ b/libtransmission/crypto.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -14,8 +14,8 @@
 #include <inttypes.h> /* uint8_t */
 #include <limits.h> /* INT_MAX */
 #include <stdarg.h>
-#include <stdlib.h> /* abs() */
-#include <string.h> /* memcpy(), memset(), strcmp() */
+#include <stdlib.h> /* abs () */
+#include <string.h> /* memcpy (), memset (), strcmp () */
 
 #include <openssl/bn.h>
 #include <openssl/dh.h>
@@ -35,21 +35,21 @@
 **/
 
 void
-tr_sha1( uint8_t * setme, const void * content1, int content1_len, ... )
+tr_sha1 (uint8_t * setme, const void * content1, int content1_len, ...)
 {
     va_list vl;
     SHA_CTX sha;
     const void * content;
 
-    SHA1_Init( &sha );
-    SHA1_Update( &sha, content1, content1_len );
+    SHA1_Init (&sha);
+    SHA1_Update (&sha, content1, content1_len);
 
-    va_start( vl, content1_len );
-    while(( content = va_arg( vl, const void* )))
-        SHA1_Update( &sha, content, va_arg( vl, int ) );
-    va_end( vl );
+    va_start (vl, content1_len);
+    while ((content = va_arg (vl, const void*)))
+        SHA1_Update (&sha, content, va_arg (vl, int));
+    va_end (vl);
 
-    SHA1_Final( setme, &sha );
+    SHA1_Final (setme, &sha);
 }
 
 /**
@@ -81,69 +81,69 @@ static const uint8_t dh_G[] = { 2 };
 ***
 **/
 
-#define logErrorFromSSL( ... ) \
+#define logErrorFromSSL(...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_ERR ) ) { \
+        if (tr_msgLoggingIsActive (TR_MSG_ERR)) { \
             char buf[512]; \
-            ERR_error_string_n( ERR_get_error( ), buf, sizeof( buf ) ); \
-            tr_msg( __FILE__, __LINE__, TR_MSG_ERR, MY_NAME, "%s", buf ); \
+            ERR_error_string_n (ERR_get_error (), buf, sizeof (buf)); \
+            tr_msg (__FILE__, __LINE__, TR_MSG_ERR, MY_NAME, "%s", buf); \
         } \
-    } while( 0 )
+    } while (0)
 
 static void
-ensureKeyExists( tr_crypto * crypto)
+ensureKeyExists (tr_crypto * crypto)
 {
-    if( crypto->dh == NULL )
+    if (crypto->dh == NULL)
     {
         int len, offset;
-        DH * dh = DH_new( );
+        DH * dh = DH_new ();
 
-        dh->p = BN_bin2bn( dh_P, sizeof( dh_P ), NULL );
-        if( dh->p == NULL )
-            logErrorFromSSL( );
+        dh->p = BN_bin2bn (dh_P, sizeof (dh_P), NULL);
+        if (dh->p == NULL)
+            logErrorFromSSL ();
 
-        dh->g = BN_bin2bn( dh_G, sizeof( dh_G ), NULL );
-        if( dh->g == NULL )
-            logErrorFromSSL( );
+        dh->g = BN_bin2bn (dh_G, sizeof (dh_G), NULL);
+        if (dh->g == NULL)
+            logErrorFromSSL ();
 
         /* private DH value: strong random BN of DH_PRIVKEY_LEN*8 bits */
-        dh->priv_key = BN_new( );
+        dh->priv_key = BN_new ();
         do {
-            if( BN_rand( dh->priv_key, DH_PRIVKEY_LEN * 8, -1, 0 ) != 1 )
-                logErrorFromSSL( );
-        } while ( BN_num_bits( dh->priv_key ) < DH_PRIVKEY_LEN_MIN * 8 );
+            if (BN_rand (dh->priv_key, DH_PRIVKEY_LEN * 8, -1, 0) != 1)
+                logErrorFromSSL ();
+        } while (BN_num_bits (dh->priv_key) < DH_PRIVKEY_LEN_MIN * 8);
 
-        if( !DH_generate_key( dh ) )
-            logErrorFromSSL( );
+        if (!DH_generate_key (dh))
+            logErrorFromSSL ();
 
         /* DH can generate key sizes that are smaller than the size of
            P with exponentially decreasing probability, in which case
            the msb's of myPublicKey need to be zeroed appropriately. */
-        len = BN_num_bytes( dh->pub_key );
+        len = BN_num_bytes (dh->pub_key);
         offset = KEY_LEN - len;
-        assert( len <= KEY_LEN );
-        memset( crypto->myPublicKey, 0, offset );
-        BN_bn2bin( dh->pub_key, crypto->myPublicKey + offset );
+        assert (len <= KEY_LEN);
+        memset (crypto->myPublicKey, 0, offset);
+        BN_bn2bin (dh->pub_key, crypto->myPublicKey + offset);
 
         crypto->dh = dh;
     }
 }
 
 void
-tr_cryptoConstruct( tr_crypto * crypto, const uint8_t * torrentHash, bool isIncoming )
+tr_cryptoConstruct (tr_crypto * crypto, const uint8_t * torrentHash, bool isIncoming)
 {
-    memset( crypto, 0, sizeof ( tr_crypto ) );
+    memset (crypto, 0, sizeof (tr_crypto));
 
     crypto->dh = NULL;
     crypto->isIncoming = isIncoming;
-    tr_cryptoSetTorrentHash( crypto, torrentHash );
+    tr_cryptoSetTorrentHash (crypto, torrentHash);
 }
 
 void
-tr_cryptoDestruct( tr_crypto * crypto )
+tr_cryptoDestruct (tr_crypto * crypto)
 {
-    if( crypto->dh != NULL )
-        DH_free( crypto->dh );
+    if (crypto->dh != NULL)
+        DH_free (crypto->dh);
 }
 
 /**
@@ -151,40 +151,40 @@ tr_cryptoDestruct( tr_crypto * crypto )
 **/
 
 const uint8_t*
-tr_cryptoComputeSecret( tr_crypto *     crypto,
-                        const uint8_t * peerPublicKey )
+tr_cryptoComputeSecret (tr_crypto *     crypto,
+                        const uint8_t * peerPublicKey)
 {
     int      len;
     uint8_t  secret[KEY_LEN];
-    BIGNUM * bn = BN_bin2bn( peerPublicKey, KEY_LEN, NULL );
+    BIGNUM * bn = BN_bin2bn (peerPublicKey, KEY_LEN, NULL);
     DH *     dh;
 
-    ensureKeyExists( crypto );
+    ensureKeyExists (crypto);
     dh = crypto->dh;
 
-    assert( DH_size( dh ) == KEY_LEN );
+    assert (DH_size (dh) == KEY_LEN);
 
-    len = DH_compute_key( secret, bn, dh );
-    if( len == -1 )
-        logErrorFromSSL( );
+    len = DH_compute_key (secret, bn, dh);
+    if (len == -1)
+        logErrorFromSSL ();
     else {
         int offset;
-        assert( len <= KEY_LEN );
+        assert (len <= KEY_LEN);
         offset = KEY_LEN - len;
-        memset( crypto->mySecret, 0, offset );
-        memcpy( crypto->mySecret + offset, secret, len );
+        memset (crypto->mySecret, 0, offset);
+        memcpy (crypto->mySecret + offset, secret, len);
         crypto->mySecretIsSet = 1;
     }
 
-    BN_free( bn );
+    BN_free (bn);
     return crypto->mySecret;
 }
 
 const uint8_t*
-tr_cryptoGetMyPublicKey( const tr_crypto * crypto,
-                         int *             setme_len )
+tr_cryptoGetMyPublicKey (const tr_crypto * crypto,
+                         int *             setme_len)
 {
-    ensureKeyExists( (tr_crypto *) crypto );
+    ensureKeyExists ((tr_crypto *) crypto);
     *setme_len = KEY_LEN;
     return crypto->myPublicKey;
 }
@@ -194,70 +194,70 @@ tr_cryptoGetMyPublicKey( const tr_crypto * crypto,
 **/
 
 static void
-initRC4( tr_crypto *  crypto,
+initRC4 (tr_crypto *  crypto,
          RC4_KEY *    setme,
-         const char * key )
+         const char * key)
 {
     SHA_CTX sha;
     uint8_t buf[SHA_DIGEST_LENGTH];
 
-    assert( crypto->torrentHashIsSet );
-    assert( crypto->mySecretIsSet );
+    assert (crypto->torrentHashIsSet);
+    assert (crypto->mySecretIsSet);
 
-    if( SHA1_Init( &sha )
-        && SHA1_Update( &sha, key, 4 )
-        && SHA1_Update( &sha, crypto->mySecret, KEY_LEN )
-        && SHA1_Update( &sha, crypto->torrentHash, SHA_DIGEST_LENGTH )
-        && SHA1_Final( buf, &sha ) )
+    if (SHA1_Init (&sha)
+        && SHA1_Update (&sha, key, 4)
+        && SHA1_Update (&sha, crypto->mySecret, KEY_LEN)
+        && SHA1_Update (&sha, crypto->torrentHash, SHA_DIGEST_LENGTH)
+        && SHA1_Final (buf, &sha))
     {
-        RC4_set_key( setme, SHA_DIGEST_LENGTH, buf );
+        RC4_set_key (setme, SHA_DIGEST_LENGTH, buf);
     }
     else
     {
-        logErrorFromSSL( );
+        logErrorFromSSL ();
     }
 }
 
 void
-tr_cryptoDecryptInit( tr_crypto * crypto )
+tr_cryptoDecryptInit (tr_crypto * crypto)
 {
     unsigned char discard[1024];
     const char *  txt = crypto->isIncoming ? "keyA" : "keyB";
 
-    initRC4( crypto, &crypto->dec_key, txt );
-    RC4( &crypto->dec_key, sizeof( discard ), discard, discard );
+    initRC4 (crypto, &crypto->dec_key, txt);
+    RC4 (&crypto->dec_key, sizeof (discard), discard, discard);
 }
 
 void
-tr_cryptoDecrypt( tr_crypto *  crypto,
+tr_cryptoDecrypt (tr_crypto *  crypto,
                   size_t       buf_len,
                   const void * buf_in,
-                  void *       buf_out )
+                  void *       buf_out)
 {
-    RC4( &crypto->dec_key, buf_len,
-         (const unsigned char*)buf_in,
-         (unsigned char*)buf_out );
+    RC4 (&crypto->dec_key, buf_len,
+       (const unsigned char*)buf_in,
+       (unsigned char*)buf_out);
 }
 
 void
-tr_cryptoEncryptInit( tr_crypto * crypto )
+tr_cryptoEncryptInit (tr_crypto * crypto)
 {
     unsigned char discard[1024];
     const char *  txt = crypto->isIncoming ? "keyB" : "keyA";
 
-    initRC4( crypto, &crypto->enc_key, txt );
-    RC4( &crypto->enc_key, sizeof( discard ), discard, discard );
+    initRC4 (crypto, &crypto->enc_key, txt);
+    RC4 (&crypto->enc_key, sizeof (discard), discard, discard);
 }
 
 void
-tr_cryptoEncrypt( tr_crypto *  crypto,
+tr_cryptoEncrypt (tr_crypto *  crypto,
                   size_t       buf_len,
                   const void * buf_in,
-                  void *       buf_out )
+                  void *       buf_out)
 {
-    RC4( &crypto->enc_key, buf_len,
-         (const unsigned char*)buf_in,
-         (unsigned char*)buf_out );
+    RC4 (&crypto->enc_key, buf_len,
+       (const unsigned char*)buf_in,
+       (unsigned char*)buf_out);
 }
 
 /**
@@ -265,75 +265,75 @@ tr_cryptoEncrypt( tr_crypto *  crypto,
 **/
 
 void
-tr_cryptoSetTorrentHash( tr_crypto *     crypto,
-                         const uint8_t * hash )
+tr_cryptoSetTorrentHash (tr_crypto *     crypto,
+                         const uint8_t * hash)
 {
     crypto->torrentHashIsSet = hash ? 1 : 0;
 
-    if( hash )
-        memcpy( crypto->torrentHash, hash, SHA_DIGEST_LENGTH );
+    if (hash)
+        memcpy (crypto->torrentHash, hash, SHA_DIGEST_LENGTH);
     else
-        memset( crypto->torrentHash, 0, SHA_DIGEST_LENGTH );
+        memset (crypto->torrentHash, 0, SHA_DIGEST_LENGTH);
 }
 
 const uint8_t*
-tr_cryptoGetTorrentHash( const tr_crypto * crypto )
+tr_cryptoGetTorrentHash (const tr_crypto * crypto)
 {
-    assert( crypto );
-    assert( crypto->torrentHashIsSet );
+    assert (crypto);
+    assert (crypto->torrentHashIsSet);
 
     return crypto->torrentHash;
 }
 
 int
-tr_cryptoHasTorrentHash( const tr_crypto * crypto )
+tr_cryptoHasTorrentHash (const tr_crypto * crypto)
 {
-    assert( crypto );
+    assert (crypto);
 
     return crypto->torrentHashIsSet ? 1 : 0;
 }
 
 int
-tr_cryptoRandInt( int upperBound )
+tr_cryptoRandInt (int upperBound)
 {
     int noise;
     int val;
 
-    assert( upperBound > 0 );
+    assert (upperBound > 0);
 
-    if( RAND_pseudo_bytes ( (unsigned char *) &noise, sizeof noise ) >= 0 )
+    if (RAND_pseudo_bytes ((unsigned char *) &noise, sizeof noise) >= 0)
     {
-        val = abs( noise ) % upperBound;
+        val = abs (noise) % upperBound;
     }
     else /* fall back to a weaker implementation... */
     {
-        val = tr_cryptoWeakRandInt( upperBound );
+        val = tr_cryptoWeakRandInt (upperBound);
     }
 
     return val;
 }
 
 int
-tr_cryptoWeakRandInt( int upperBound )
+tr_cryptoWeakRandInt (int upperBound)
 {
     static bool init = false;
 
-    assert( upperBound > 0 );
+    assert (upperBound > 0);
 
-    if( !init )
+    if (!init)
     {
-        srand( tr_time_msec( ) );
+        srand (tr_time_msec ());
         init = true;
     }
 
-    return rand( ) % upperBound;
+    return rand () % upperBound;
 }
 
 void
-tr_cryptoRandBuf( void * buf, size_t len )
+tr_cryptoRandBuf (void * buf, size_t len)
 {
-    if( RAND_pseudo_bytes ( (unsigned char*)buf, len ) != 1 )
-        logErrorFromSSL( );
+    if (RAND_pseudo_bytes ((unsigned char*)buf, len) != 1)
+        logErrorFromSSL ();
 }
 
 /***
@@ -341,7 +341,7 @@ tr_cryptoRandBuf( void * buf, size_t len )
 ***/
 
 char*
-tr_ssha1( const void * plaintext )
+tr_ssha1 (const void * plaintext)
 {
     enum { saltval_len = 8,
            salter_len  = 64 };
@@ -355,49 +355,49 @@ tr_ssha1( const void * plaintext )
     uint8_t sha[SHA_DIGEST_LENGTH];
     char buf[2*SHA_DIGEST_LENGTH + saltval_len + 2];
 
-    tr_cryptoRandBuf( salt, saltval_len );
-    for( i=0; i<saltval_len; ++i )
+    tr_cryptoRandBuf (salt, saltval_len);
+    for (i=0; i<saltval_len; ++i)
         salt[i] = salter[ salt[i] % salter_len ];
 
-    tr_sha1( sha, plaintext, strlen( plaintext ), salt, saltval_len, NULL );
-    tr_sha1_to_hex( &buf[1], sha );
-    memcpy( &buf[1+2*SHA_DIGEST_LENGTH], &salt, saltval_len );
+    tr_sha1 (sha, plaintext, strlen (plaintext), salt, saltval_len, NULL);
+    tr_sha1_to_hex (&buf[1], sha);
+    memcpy (&buf[1+2*SHA_DIGEST_LENGTH], &salt, saltval_len);
     buf[1+2*SHA_DIGEST_LENGTH + saltval_len] = '\0';
     buf[0] = '{'; /* signal that this is a hash. this makes saving/restoring
                      easier */
 
-    return tr_strdup( &buf );
+    return tr_strdup (&buf);
 }
 
 bool
-tr_ssha1_matches( const char * source, const char * pass )
+tr_ssha1_matches (const char * source, const char * pass)
 {
     char * salt;
     size_t saltlen;
     char * hashed;
     uint8_t buf[SHA_DIGEST_LENGTH];
     bool result;
-    const size_t sourcelen = strlen( source );
+    const size_t sourcelen = strlen (source);
 
     /* extract the salt */
-    if( sourcelen < 2*SHA_DIGEST_LENGTH-1 )
+    if (sourcelen < 2*SHA_DIGEST_LENGTH-1)
         return false;
     saltlen = sourcelen - 2*SHA_DIGEST_LENGTH-1;
-    salt = tr_malloc( saltlen );
-    memcpy( salt, source + 2*SHA_DIGEST_LENGTH+1, saltlen );
+    salt = tr_malloc (saltlen);
+    memcpy (salt, source + 2*SHA_DIGEST_LENGTH+1, saltlen);
 
     /* hash pass + salt */
-    hashed = tr_malloc( 2*SHA_DIGEST_LENGTH + saltlen + 2 );
-    tr_sha1( buf, pass, strlen( pass ), salt, saltlen, NULL );
-    tr_sha1_to_hex( &hashed[1], buf );
-    memcpy( hashed + 1+2*SHA_DIGEST_LENGTH, salt, saltlen );
+    hashed = tr_malloc (2*SHA_DIGEST_LENGTH + saltlen + 2);
+    tr_sha1 (buf, pass, strlen (pass), salt, saltlen, NULL);
+    tr_sha1_to_hex (&hashed[1], buf);
+    memcpy (hashed + 1+2*SHA_DIGEST_LENGTH, salt, saltlen);
     hashed[1+2*SHA_DIGEST_LENGTH + saltlen] = '\0';
     hashed[0] = '{';
 
-    result = strcmp( source, hashed ) == 0 ? true : false;
+    result = strcmp (source, hashed) == 0 ? true : false;
 
-    tr_free( hashed );
-    tr_free( salt );
+    tr_free (hashed);
+    tr_free (salt);
 
     return result;
 }
diff --git a/libtransmission/crypto.h b/libtransmission/crypto.h
index e041b046a..e8092307e 100644
--- a/libtransmission/crypto.h
+++ b/libtransmission/crypto.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -50,37 +50,37 @@ typedef struct
 tr_crypto;
 
 /** @brief construct a new tr_crypto object */
-void tr_cryptoConstruct( tr_crypto * crypto, const uint8_t * torrentHash, bool isIncoming );
+void tr_cryptoConstruct (tr_crypto * crypto, const uint8_t * torrentHash, bool isIncoming);
 
 /** @brief destruct an existing tr_crypto object */
-void tr_cryptoDestruct( tr_crypto * crypto );
+void tr_cryptoDestruct (tr_crypto * crypto);
 
 
-void tr_cryptoSetTorrentHash( tr_crypto * crypto, const uint8_t * torrentHash );
+void tr_cryptoSetTorrentHash (tr_crypto * crypto, const uint8_t * torrentHash);
 
-const uint8_t* tr_cryptoGetTorrentHash( const tr_crypto * crypto );
+const uint8_t* tr_cryptoGetTorrentHash (const tr_crypto * crypto);
 
-int            tr_cryptoHasTorrentHash( const tr_crypto * crypto );
+int            tr_cryptoHasTorrentHash (const tr_crypto * crypto);
 
-const uint8_t* tr_cryptoComputeSecret( tr_crypto *     crypto,
-                                       const uint8_t * peerPublicKey );
+const uint8_t* tr_cryptoComputeSecret (tr_crypto *     crypto,
+                                       const uint8_t * peerPublicKey);
 
-const uint8_t* tr_cryptoGetMyPublicKey( const tr_crypto * crypto,
-                                        int *             setme_len );
+const uint8_t* tr_cryptoGetMyPublicKey (const tr_crypto * crypto,
+                                        int *             setme_len);
 
-void           tr_cryptoDecryptInit( tr_crypto * crypto );
+void           tr_cryptoDecryptInit (tr_crypto * crypto);
 
-void           tr_cryptoDecrypt( tr_crypto *  crypto,
+void           tr_cryptoDecrypt (tr_crypto *  crypto,
                                  size_t       buflen,
                                  const void * buf_in,
-                                 void *       buf_out );
+                                 void *       buf_out);
 
-void           tr_cryptoEncryptInit( tr_crypto * crypto );
+void           tr_cryptoEncryptInit (tr_crypto * crypto);
 
-void           tr_cryptoEncrypt( tr_crypto *  crypto,
+void           tr_cryptoEncrypt (tr_crypto *  crypto,
                                  size_t       buflen,
                                  const void * buf_in,
-                                 void *       buf_out );
+                                 void *       buf_out);
 
 /* @} */
 
@@ -91,32 +91,32 @@ void           tr_cryptoEncrypt( tr_crypto *  crypto,
 
 
 /** @brief generate a SHA1 hash from one or more chunks of memory */
-void tr_sha1( uint8_t    * setme,
+void tr_sha1 (uint8_t    * setme,
               const void * content1,
               int          content1_len,
-              ... ) TR_GNUC_NULL_TERMINATED;
+              ...) TR_GNUC_NULL_TERMINATED;
 
 
 /** @brief returns a random number in the range of [0...n) */
-int tr_cryptoRandInt( int n );
+int tr_cryptoRandInt (int n);
 
 /**
  * @brief returns a pseudorandom number in the range of [0...n)
  *
- * This is faster, BUT WEAKER, than tr_cryptoRandInt() and never
+ * This is faster, BUT WEAKER, than tr_cryptoRandInt () and never
  * be used in sensitive cases.
- * @see tr_cryptoRandInt()
+ * @see tr_cryptoRandInt ()
  */
-int            tr_cryptoWeakRandInt( int n );
+int            tr_cryptoWeakRandInt (int n);
 
 /** @brief fill a buffer with random bytes */
-void  tr_cryptoRandBuf( void * buf, size_t len );
+void  tr_cryptoRandBuf (void * buf, size_t len);
 
 /** @brief generate a SSHA password from its plaintext source */
-char*  tr_ssha1( const void * plaintext );
+char*  tr_ssha1 (const void * plaintext);
 
 /** @brief Validate a test password against the a ssha1 password */
-bool tr_ssha1_matches( const char * ssha1, const char * pass );
+bool tr_ssha1_matches (const char * ssha1, const char * pass);
 
 /* @} */
 
diff --git a/libtransmission/fdlimit.c b/libtransmission/fdlimit.c
index 58fd60ebf..58fb2b4d2 100644
--- a/libtransmission/fdlimit.c
+++ b/libtransmission/fdlimit.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -27,7 +27,7 @@
 
 #ifdef HAVE_FALLOCATE64
   /* FIXME can't find the right #include voodoo to pick up the declaration.. */
-  extern int fallocate64( int fd, int mode, uint64_t offset, uint64_t len );
+  extern int fallocate64 (int fd, int mode, uint64_t offset, uint64_t len);
 #endif
 
 #ifdef HAVE_XFS_XFS_H
@@ -39,19 +39,19 @@
 #include <sys/time.h> /* getrlimit */
 #include <sys/resource.h> /* getrlimit */
 #include <fcntl.h> /* O_LARGEFILE posix_fadvise */
-#include <unistd.h> /* lseek(), write(), ftruncate(), pread(), pwrite(), etc */
+#include <unistd.h> /* lseek (), write (), ftruncate (), pread (), pwrite (), etc */
 
 #include "transmission.h"
 #include "fdlimit.h"
 #include "net.h"
 #include "session.h"
-#include "torrent.h" /* tr_isTorrent() */
+#include "torrent.h" /* tr_isTorrent () */
 
-#define dbgmsg( ... ) \
+#define dbgmsg(...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, NULL, __VA_ARGS__); \
+    } while (0)
 
 /***
 ****
@@ -73,67 +73,67 @@
 
 
 static bool
-preallocate_file_sparse( int fd, uint64_t length )
+preallocate_file_sparse (int fd, uint64_t length)
 {
     const char zero = '\0';
     bool success = 0;
 
-    if( !length )
+    if (!length)
         success = true;
 
 #ifdef HAVE_FALLOCATE64
-    if( !success ) /* fallocate64 is always preferred, so try it first */
-        success = !fallocate64( fd, 0, 0, length );
+    if (!success) /* fallocate64 is always preferred, so try it first */
+        success = !fallocate64 (fd, 0, 0, length);
 #endif
 
-    if( !success ) /* fallback: the old-style seek-and-write */
-        success = ( lseek( fd, length-1, SEEK_SET ) != -1 )
-               && ( write( fd, &zero, 1 ) != -1 )
-               && ( ftruncate( fd, length ) != -1 );
+    if (!success) /* fallback: the old-style seek-and-write */
+        success = (lseek (fd, length-1, SEEK_SET) != -1)
+               && (write (fd, &zero, 1) != -1)
+               && (ftruncate (fd, length) != -1);
 
     return success;
 }
 
 static bool
-preallocate_file_full( const char * filename, uint64_t length )
+preallocate_file_full (const char * filename, uint64_t length)
 {
     bool success = 0;
 
 #ifdef WIN32
 
-    HANDLE hFile = CreateFile( filename, GENERIC_WRITE, 0, 0, CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0 );
-    if( hFile != INVALID_HANDLE_VALUE )
+    HANDLE hFile = CreateFile (filename, GENERIC_WRITE, 0, 0, CREATE_NEW, FILE_FLAG_RANDOM_ACCESS, 0);
+    if (hFile != INVALID_HANDLE_VALUE)
     {
         LARGE_INTEGER li;
         li.QuadPart = length;
-        success = SetFilePointerEx( hFile, li, NULL, FILE_BEGIN ) && SetEndOfFile( hFile );
-        CloseHandle( hFile );
+        success = SetFilePointerEx (hFile, li, NULL, FILE_BEGIN) && SetEndOfFile (hFile);
+        CloseHandle (hFile);
     }
 
 #else
 
     int flags = O_RDWR | O_CREAT | O_LARGEFILE;
-    int fd = open( filename, flags, 0666 );
-    if( fd >= 0 )
+    int fd = open (filename, flags, 0666);
+    if (fd >= 0)
     {
 # ifdef HAVE_FALLOCATE64
-       if( !success )
+       if (!success)
        {
-           success = !fallocate64( fd, 0, 0, length );
+           success = !fallocate64 (fd, 0, 0, length);
        }
 # endif
 # ifdef HAVE_XFS_XFS_H
-        if( !success && platform_test_xfs_fd( fd ) )
+        if (!success && platform_test_xfs_fd (fd))
         {
             xfs_flock64_t fl;
             fl.l_whence = 0;
             fl.l_start = 0;
             fl.l_len = length;
-            success = !xfsctl( NULL, fd, XFS_IOC_RESVSP64, &fl );
+            success = !xfsctl (NULL, fd, XFS_IOC_RESVSP64, &fl);
         }
 # endif
 # ifdef SYS_DARWIN
-        if( !success )
+        if (!success)
         {
             fstore_t fst;
             fst.fst_flags = F_ALLOCATECONTIG;
@@ -141,30 +141,30 @@ preallocate_file_full( const char * filename, uint64_t length )
             fst.fst_offset = 0;
             fst.fst_length = length;
             fst.fst_bytesalloc = 0;
-            success = !fcntl( fd, F_PREALLOCATE, &fst );
+            success = !fcntl (fd, F_PREALLOCATE, &fst);
         }
 # endif
 # ifdef HAVE_POSIX_FALLOCATE
-        if( !success )
+        if (!success)
         {
-            success = !posix_fallocate( fd, 0, length );
+            success = !posix_fallocate (fd, 0, length);
         }
 # endif
 
-        if( !success ) /* if nothing else works, do it the old-fashioned way */
+        if (!success) /* if nothing else works, do it the old-fashioned way */
         {
             uint8_t buf[ 4096 ];
-            memset( buf, 0, sizeof( buf ) );
+            memset (buf, 0, sizeof (buf));
             success = true;
-            while ( success && ( length > 0 ) )
+            while (success && (length > 0))
             {
-                const int thisPass = MIN( length, sizeof( buf ) );
-                success = write( fd, buf, thisPass ) == thisPass;
+                const int thisPass = MIN (length, sizeof (buf));
+                success = write (fd, buf, thisPass) == thisPass;
                 length -= thisPass;
             }
         }
 
-        close( fd );
+        close (fd);
     }
 
 #endif
@@ -173,14 +173,14 @@ preallocate_file_full( const char * filename, uint64_t length )
 }
 
 
-/* portability wrapper for fsync(). */
+/* portability wrapper for fsync (). */
 int
-tr_fsync( int fd )
+tr_fsync (int fd)
 {
 #ifdef WIN32
-    return _commit( fd );
+    return _commit (fd);
 #else
-    return fsync( fd );
+    return fsync (fd);
 #endif
 }
 
@@ -192,11 +192,11 @@ tr_fsync( int fd )
  * https://trac.transmissionbt.com/ticket/3826 */
 #ifdef __UCLIBC__
 #define TR_UCLIBC_CHECK_VERSION(major,minor,micro) \
-    (__UCLIBC_MAJOR__ > (major) || \
-     (__UCLIBC_MAJOR__ == (major) && __UCLIBC_MINOR__ > (minor)) || \
-     (__UCLIBC_MAJOR__ == (major) && __UCLIBC_MINOR__ == (minor) && \
+  (__UCLIBC_MAJOR__ > (major) || \
+   (__UCLIBC_MAJOR__ == (major) && __UCLIBC_MINOR__ > (minor)) || \
+   (__UCLIBC_MAJOR__ == (major) && __UCLIBC_MINOR__ == (minor) && \
       __UCLIBC_SUBLEVEL__ >= (micro)))
-#if !TR_UCLIBC_CHECK_VERSION(0,9,28)
+#if !TR_UCLIBC_CHECK_VERSION (0,9,28)
  #undef HAVE_PREAD
  #undef HAVE_PWRITE
 #endif
@@ -208,99 +208,99 @@ tr_fsync( int fd )
 #endif
 
 ssize_t
-tr_pread( int fd, void *buf, size_t count, off_t offset )
+tr_pread (int fd, void *buf, size_t count, off_t offset)
 {
 #ifdef HAVE_PREAD
-    return pread( fd, buf, count, offset );
+    return pread (fd, buf, count, offset);
 #else
-    const off_t lrc = lseek( fd, offset, SEEK_SET );
-    if( lrc < 0 )
+    const off_t lrc = lseek (fd, offset, SEEK_SET);
+    if (lrc < 0)
         return -1;
-    return read( fd, buf, count );
+    return read (fd, buf, count);
 #endif
 }
 
 ssize_t
-tr_pwrite( int fd, const void *buf, size_t count, off_t offset )
+tr_pwrite (int fd, const void *buf, size_t count, off_t offset)
 {
 #ifdef HAVE_PWRITE
-    return pwrite( fd, buf, count, offset );
+    return pwrite (fd, buf, count, offset);
 #else
-    const off_t lrc = lseek( fd, offset, SEEK_SET );
-    if( lrc < 0 )
+    const off_t lrc = lseek (fd, offset, SEEK_SET);
+    if (lrc < 0)
         return -1;
-    return write( fd, buf, count );
+    return write (fd, buf, count);
 #endif
 }
 
 int
-tr_prefetch( int fd UNUSED, off_t offset UNUSED, size_t count UNUSED )
+tr_prefetch (int fd UNUSED, off_t offset UNUSED, size_t count UNUSED)
 {
 #ifdef HAVE_POSIX_FADVISE
-    return posix_fadvise( fd, offset, count, POSIX_FADV_WILLNEED );
-#elif defined(SYS_DARWIN)
+    return posix_fadvise (fd, offset, count, POSIX_FADV_WILLNEED);
+#elif defined (SYS_DARWIN)
     struct radvisory radv;
     radv.ra_offset = offset;
     radv.ra_count = count;
-    return fcntl( fd, F_RDADVISE, &radv );
+    return fcntl (fd, F_RDADVISE, &radv);
 #else
     return 0;
 #endif
 }
 
 void
-tr_set_file_for_single_pass( int fd )
+tr_set_file_for_single_pass (int fd)
 {
-    if( fd >= 0 )
+    if (fd >= 0)
     {
         /* Set hints about the lookahead buffer and caching. It's okay
            for these to fail silently, so don't let them affect errno */
         const int err = errno;
 #ifdef HAVE_POSIX_FADVISE
-        posix_fadvise( fd, 0, 0, POSIX_FADV_SEQUENTIAL );
+        posix_fadvise (fd, 0, 0, POSIX_FADV_SEQUENTIAL);
 #endif
 #ifdef SYS_DARWIN
-        fcntl( fd, F_RDAHEAD, 1 );
-        fcntl( fd, F_NOCACHE, 1 );
+        fcntl (fd, F_RDAHEAD, 1);
+        fcntl (fd, F_NOCACHE, 1);
 #endif
         errno = err;
     }
 }
 
 static int
-open_local_file( const char * filename, int flags )
+open_local_file (const char * filename, int flags)
 {
-    const int fd = open( filename, flags, 0666 );
-    tr_set_file_for_single_pass( fd );
+    const int fd = open (filename, flags, 0666);
+    tr_set_file_for_single_pass (fd);
     return fd;
 }
 int
-tr_open_file_for_writing( const char * filename )
+tr_open_file_for_writing (const char * filename)
 {
-    return open_local_file( filename, O_LARGEFILE|O_BINARY|O_CREAT|O_WRONLY );
+    return open_local_file (filename, O_LARGEFILE|O_BINARY|O_CREAT|O_WRONLY);
 }
 int
-tr_open_file_for_scanning( const char * filename )
+tr_open_file_for_scanning (const char * filename)
 {
-    return open_local_file( filename, O_LARGEFILE|O_BINARY|O_SEQUENTIAL|O_RDONLY );
+    return open_local_file (filename, O_LARGEFILE|O_BINARY|O_SEQUENTIAL|O_RDONLY);
 }
 
 void
-tr_close_file( int fd )
+tr_close_file (int fd)
 {
-#if defined(HAVE_POSIX_FADVISE)
+#if defined (HAVE_POSIX_FADVISE)
     /* Set hint about not caching this file.
        It's okay for this to fail silently, so don't let it affect errno */
     const int err = errno;
-    posix_fadvise( fd, 0, 0, POSIX_FADV_DONTNEED );
+    posix_fadvise (fd, 0, 0, POSIX_FADV_DONTNEED);
     errno = err;
 #endif
 #ifdef SYS_DARWIN
     /* it's unclear to me from the man pages if this actually flushes out the cache,
      * but it couldn't hurt... */
-    fcntl( fd, F_NOCACHE, 1 );
+    fcntl (fd, F_NOCACHE, 1);
 #endif
-    close( fd );
+    close (fd);
 }
 
 /*****
@@ -319,66 +319,66 @@ struct tr_cached_file
 };
 
 static inline bool
-cached_file_is_open( const struct tr_cached_file * o )
+cached_file_is_open (const struct tr_cached_file * o)
 {
-    assert( o != NULL );
+    assert (o != NULL);
 
     return o->fd >= 0;
 }
 
 static void
-cached_file_close( struct tr_cached_file * o )
+cached_file_close (struct tr_cached_file * o)
 {
-    assert( cached_file_is_open( o ) );
+    assert (cached_file_is_open (o));
 
-    tr_close_file( o->fd );
+    tr_close_file (o->fd);
     o->fd = -1;
 }
 
 /**
  * returns 0 on success, or an errno value on failure.
  * errno values include ENOENT if the parent folder doesn't exist,
- * plus the errno values set by tr_mkdirp() and open().
+ * plus the errno values set by tr_mkdirp () and open ().
  */
 static int
-cached_file_open( struct tr_cached_file  * o,
+cached_file_open (struct tr_cached_file  * o,
                   const char             * filename,
                   bool                     writable,
                   tr_preallocation_mode    allocation,
-                  uint64_t                 file_size )
+                  uint64_t                 file_size)
 {
     int flags;
     struct stat sb;
     bool alreadyExisted;
 
     /* create subfolders, if any */
-    if( writable )
+    if (writable)
     {
-        char * dir = tr_dirname( filename );
-        const int err = tr_mkdirp( dir, 0777 ) ? errno : 0;
-        if( err ) {
-            tr_err( _( "Couldn't create \"%1$s\": %2$s" ), dir, tr_strerror( err ) );
-            tr_free( dir );
+        char * dir = tr_dirname (filename);
+        const int err = tr_mkdirp (dir, 0777) ? errno : 0;
+        if (err) {
+            tr_err (_ ("Couldn't create \"%1$s\": %2$s"), dir, tr_strerror (err));
+            tr_free (dir);
             return err;
         }
-        tr_free( dir );
+        tr_free (dir);
     }
 
-    alreadyExisted = !stat( filename, &sb ) && S_ISREG( sb.st_mode );
+    alreadyExisted = !stat (filename, &sb) && S_ISREG (sb.st_mode);
 
-    if( writable && !alreadyExisted && ( allocation == TR_PREALLOCATE_FULL ) )
-        if( preallocate_file_full( filename, file_size ) )
-            tr_dbg( "Preallocated file \"%s\"", filename );
+    if (writable && !alreadyExisted && (allocation == TR_PREALLOCATE_FULL))
+        if (preallocate_file_full (filename, file_size))
+            tr_dbg ("Preallocated file \"%s\"", filename);
 
     /* open the file */
-    flags = writable ? ( O_RDWR | O_CREAT ) : O_RDONLY;
+    flags = writable ? (O_RDWR | O_CREAT) : O_RDONLY;
     flags |= O_LARGEFILE | O_BINARY | O_SEQUENTIAL;
-    o->fd = open( filename, flags, 0666 );
+    o->fd = open (filename, flags, 0666);
 
-    if( o->fd == -1 )
+    if (o->fd == -1)
     {
         const int err = errno;
-        tr_err( _( "Couldn't open \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
+        tr_err (_ ("Couldn't open \"%1$s\": %2$s"), filename, tr_strerror (err));
         return err;
     }
 
@@ -388,23 +388,23 @@ cached_file_open( struct tr_cached_file  * o,
      * http://trac.transmissionbt.com/ticket/2228
      * https://bugs.launchpad.net/ubuntu/+source/transmission/+bug/318249
      */
-    if( alreadyExisted && ( file_size < (uint64_t)sb.st_size ) )
+    if (alreadyExisted && (file_size < (uint64_t)sb.st_size))
     {
-        if( ftruncate( o->fd, file_size ) == -1 )
+        if (ftruncate (o->fd, file_size) == -1)
         {
             const int err = errno;
-            tr_err( _( "Couldn't truncate \"%1$s\": %2$s" ), filename, tr_strerror( err ) );
+            tr_err (_ ("Couldn't truncate \"%1$s\": %2$s"), filename, tr_strerror (err));
             return err;
         }
     }
 
-    if( writable && !alreadyExisted && ( allocation == TR_PREALLOCATE_SPARSE ) )
-        preallocate_file_sparse( o->fd, file_size );
+    if (writable && !alreadyExisted && (allocation == TR_PREALLOCATE_SPARSE))
+        preallocate_file_sparse (o->fd, file_size);
 
     /* Many (most?) clients request blocks in ascending order,
      * so increase the readahead buffer.
      * Also, disable OS-level caching because "inactive memory" angers users. */
-    tr_set_file_for_single_pass( o->fd );
+    tr_set_file_for_single_pass (o->fd);
 
     return 0;
 }
@@ -420,81 +420,81 @@ struct tr_fileset
 };
 
 static void
-fileset_construct( struct tr_fileset * set, int n )
+fileset_construct (struct tr_fileset * set, int n)
 {
     struct tr_cached_file * o;
     const struct tr_cached_file TR_CACHED_FILE_INIT = { 0, -1, 0, 0, 0 };
 
-    set->begin = tr_new( struct tr_cached_file, n );
+    set->begin = tr_new (struct tr_cached_file, n);
     set->end = set->begin + n;
 
-    for( o=set->begin; o!=set->end; ++o )
+    for (o=set->begin; o!=set->end; ++o)
         *o = TR_CACHED_FILE_INIT;
 }
 
 static void
-fileset_close_all( struct tr_fileset * set )
+fileset_close_all (struct tr_fileset * set)
 {
     struct tr_cached_file * o;
 
-    if( set != NULL )
-        for( o=set->begin; o!=set->end; ++o )
-            if( cached_file_is_open( o ) )
-                cached_file_close( o );
+    if (set != NULL)
+        for (o=set->begin; o!=set->end; ++o)
+            if (cached_file_is_open (o))
+                cached_file_close (o);
 }
 
 static void
-fileset_destruct( struct tr_fileset * set )
+fileset_destruct (struct tr_fileset * set)
 {
-    fileset_close_all( set );
-    tr_free( set->begin );
+    fileset_close_all (set);
+    tr_free (set->begin);
     set->end = set->begin = NULL;
 }
 
 static void
-fileset_close_torrent( struct tr_fileset * set, int torrent_id )
+fileset_close_torrent (struct tr_fileset * set, int torrent_id)
 {
     struct tr_cached_file * o;
 
-    if( set != NULL )
-        for( o=set->begin; o!=set->end; ++o )
-            if( ( o->torrent_id == torrent_id ) && cached_file_is_open( o ) )
-                cached_file_close( o );
+    if (set != NULL)
+        for (o=set->begin; o!=set->end; ++o)
+            if ((o->torrent_id == torrent_id) && cached_file_is_open (o))
+                cached_file_close (o);
 }
 
 static struct tr_cached_file *
-fileset_lookup( struct tr_fileset * set, int torrent_id, tr_file_index_t i )
+fileset_lookup (struct tr_fileset * set, int torrent_id, tr_file_index_t i)
 {
     struct tr_cached_file * o;
 
-    if( set != NULL )
-        for( o=set->begin; o!=set->end; ++o )
-            if( ( torrent_id == o->torrent_id ) && ( i == o->file_index ) && cached_file_is_open( o ) )
+    if (set != NULL)
+        for (o=set->begin; o!=set->end; ++o)
+            if ((torrent_id == o->torrent_id) && (i == o->file_index) && cached_file_is_open (o))
                 return o;
 
     return NULL;
 }
 
 static struct tr_cached_file *
-fileset_get_empty_slot( struct tr_fileset * set )
+fileset_get_empty_slot (struct tr_fileset * set)
 {
     struct tr_cached_file * cull = NULL;
 
-    if( set->begin != NULL )
+    if (set->begin != NULL)
     {
         struct tr_cached_file * o;
 
         /* try to find an unused slot */
-        for( o=set->begin; o!=set->end; ++o )
-            if( !cached_file_is_open( o ) )
+        for (o=set->begin; o!=set->end; ++o)
+            if (!cached_file_is_open (o))
                 return o;
 
         /* all slots are full... recycle the least recently used */
-        for( cull=NULL, o=set->begin; o!=set->end; ++o )
-            if( !cull || o->used_at < cull->used_at )
+        for (cull=NULL, o=set->begin; o!=set->end; ++o)
+            if (!cull || o->used_at < cull->used_at)
                 cull = o;
 
-        cached_file_close( cull );
+        cached_file_close (cull);
     }
 
     return cull;
@@ -513,45 +513,45 @@ struct tr_fdInfo
 };
 
 static void
-ensureSessionFdInfoExists( tr_session * session )
+ensureSessionFdInfoExists (tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    if( session->fdInfo == NULL )
+    if (session->fdInfo == NULL)
     {
         struct rlimit limit;
         struct tr_fdInfo * i;
         const int FILE_CACHE_SIZE = 32;
 
         /* Create the local file cache */
-        i = tr_new0( struct tr_fdInfo, 1 );
-        fileset_construct( &i->fileset, FILE_CACHE_SIZE );
+        i = tr_new0 (struct tr_fdInfo, 1);
+        fileset_construct (&i->fileset, FILE_CACHE_SIZE);
         session->fdInfo = i;
 
         /* set the open-file limit to the largest safe size wrt FD_SETSIZE */
-        if( !getrlimit( RLIMIT_NOFILE, &limit ) )
+        if (!getrlimit (RLIMIT_NOFILE, &limit))
         {
             const int old_limit = (int) limit.rlim_cur;
-            const int new_limit = MIN( limit.rlim_max, FD_SETSIZE );
-            if( new_limit != old_limit )
+            const int new_limit = MIN (limit.rlim_max, FD_SETSIZE);
+            if (new_limit != old_limit)
             {
                 limit.rlim_cur = new_limit;
-                setrlimit( RLIMIT_NOFILE, &limit );
-                getrlimit( RLIMIT_NOFILE, &limit );
-                tr_inf( "Changed open file limit from %d to %d", old_limit, (int)limit.rlim_cur );
+                setrlimit (RLIMIT_NOFILE, &limit);
+                getrlimit (RLIMIT_NOFILE, &limit);
+                tr_inf ("Changed open file limit from %d to %d", old_limit, (int)limit.rlim_cur);
             }
         }
     }
 }
 
 void
-tr_fdClose( tr_session * session )
+tr_fdClose (tr_session * session)
 {
-    if( session && session->fdInfo )
+    if (session && session->fdInfo)
     {
         struct tr_fdInfo * i = session->fdInfo;
-        fileset_destruct( &i->fileset );
-        tr_free( i );
+        fileset_destruct (&i->fileset);
+        tr_free (i);
         session->fdInfo = NULL;
     }
 }
@@ -561,102 +561,102 @@ tr_fdClose( tr_session * session )
 ***/
 
 static struct tr_fileset*
-get_fileset( tr_session * session )
+get_fileset (tr_session * session)
 {
-    if( !session )
+    if (!session)
         return NULL;
 
-    ensureSessionFdInfoExists( session );
+    ensureSessionFdInfoExists (session);
     return &session->fdInfo->fileset;
 }
 
 void
-tr_fdFileClose( tr_session * s, const tr_torrent * tor, tr_file_index_t i )
+tr_fdFileClose (tr_session * s, const tr_torrent * tor, tr_file_index_t i)
 {
     struct tr_cached_file * o;
 
-    if(( o = fileset_lookup( get_fileset( s ), tr_torrentId( tor ), i )))
+    if ((o = fileset_lookup (get_fileset (s), tr_torrentId (tor), i)))
     {
         /* flush writable files so that their mtimes will be
          * up-to-date when this function returns to the caller... */
-        if( o->is_writable )
-            tr_fsync( o->fd );
+        if (o->is_writable)
+            tr_fsync (o->fd);
 
-        cached_file_close( o );
+        cached_file_close (o);
     }
 }
 
 int
-tr_fdFileGetCached( tr_session * s, int torrent_id, tr_file_index_t i, bool writable )
+tr_fdFileGetCached (tr_session * s, int torrent_id, tr_file_index_t i, bool writable)
 {
-    struct tr_cached_file * o = fileset_lookup( get_fileset( s ), torrent_id, i );
+    struct tr_cached_file * o = fileset_lookup (get_fileset (s), torrent_id, i);
 
-    if( !o || ( writable && !o->is_writable ) )
+    if (!o || (writable && !o->is_writable))
         return -1;
 
-    o->used_at = tr_time( );
+    o->used_at = tr_time ();
     return o->fd;
 }
 
 #ifdef SYS_DARWIN
- #define TR_STAT_MTIME(sb) ((sb).st_mtimespec.tv_sec)
+ #define TR_STAT_MTIME(sb)((sb).st_mtimespec.tv_sec)
 #else
- #define TR_STAT_MTIME(sb) ((sb).st_mtime)
+ #define TR_STAT_MTIME(sb)((sb).st_mtime)
 #endif
 
 bool
-tr_fdFileGetCachedMTime( tr_session * s, int torrent_id, tr_file_index_t i, time_t * mtime )
+tr_fdFileGetCachedMTime (tr_session * s, int torrent_id, tr_file_index_t i, time_t * mtime)
 {
     bool success;
     struct stat sb;
-    struct tr_cached_file * o = fileset_lookup( get_fileset( s ), torrent_id, i );
+    struct tr_cached_file * o = fileset_lookup (get_fileset (s), torrent_id, i);
 
-    if(( success = ( o != NULL ) && !fstat( o->fd, &sb )))
-        *mtime = TR_STAT_MTIME( sb );
+    if ((success = (o != NULL) && !fstat (o->fd, &sb)))
+        *mtime = TR_STAT_MTIME (sb);
 
     return success;
 }
 
 void
-tr_fdTorrentClose( tr_session * session, int torrent_id )
+tr_fdTorrentClose (tr_session * session, int torrent_id)
 {
-    fileset_close_torrent( get_fileset( session ), torrent_id );
+    fileset_close_torrent (get_fileset (session), torrent_id);
 }
 
 /* returns an fd on success, or a -1 on failure and sets errno */
 int
-tr_fdFileCheckout( tr_session             * session,
+tr_fdFileCheckout (tr_session             * session,
                    int                      torrent_id,
                    tr_file_index_t          i,
                    const char             * filename,
                    bool                     writable,
                    tr_preallocation_mode    allocation,
-                   uint64_t                 file_size )
+                   uint64_t                 file_size)
 {
-    struct tr_fileset * set = get_fileset( session );
-    struct tr_cached_file * o = fileset_lookup( set, torrent_id, i );
+    struct tr_fileset * set = get_fileset (session);
+    struct tr_cached_file * o = fileset_lookup (set, torrent_id, i);
 
-    if( o && writable && !o->is_writable )
-        cached_file_close( o ); /* close it so we can reopen in rw mode */
-    else if( !o )
-        o = fileset_get_empty_slot( set );
+    if (o && writable && !o->is_writable)
+        cached_file_close (o); /* close it so we can reopen in rw mode */
+    else if (!o)
+        o = fileset_get_empty_slot (set);
 
-    if( !cached_file_is_open( o ) )
+    if (!cached_file_is_open (o))
     {
-        const int err = cached_file_open( o, filename, writable, allocation, file_size );
-        if( err ) {
+        const int err = cached_file_open (o, filename, writable, allocation, file_size);
+        if (err) {
             errno = err;
             return -1;
         }
 
-        dbgmsg( "opened '%s' writable %c", filename, writable?'y':'n' );
+        dbgmsg ("opened '%s' writable %c", filename, writable?'y':'n');
         o->is_writable = writable;
     }
 
-    dbgmsg( "checking out '%s'", filename );
+    dbgmsg ("checking out '%s'", filename);
     o->torrent_id = torrent_id;
     o->file_index = i;
-    o->used_at = tr_time( );
+    o->used_at = tr_time ();
     return o->fd;
 }
 
@@ -667,37 +667,37 @@ tr_fdFileCheckout( tr_session             * session,
 ***/
 
 int
-tr_fdSocketCreate( tr_session * session, int domain, int type )
+tr_fdSocketCreate (tr_session * session, int domain, int type)
 {
     int s = -1;
     struct tr_fdInfo * gFd;
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    ensureSessionFdInfoExists( session );
+    ensureSessionFdInfoExists (session);
     gFd = session->fdInfo;
 
-    if( gFd->peerCount < session->peerLimit )
-        if(( s = socket( domain, type, 0 )) < 0 )
-            if( sockerrno != EAFNOSUPPORT )
-                tr_err( _( "Couldn't create socket: %s" ), tr_strerror( sockerrno ) );
+    if (gFd->peerCount < session->peerLimit)
+        if ((s = socket (domain, type, 0)) < 0)
+            if (sockerrno != EAFNOSUPPORT)
+                tr_err (_ ("Couldn't create socket: %s"), tr_strerror (sockerrno));
 
-    if( s > -1 )
+    if (s > -1)
         ++gFd->peerCount;
 
-    assert( gFd->peerCount >= 0 );
+    assert (gFd->peerCount >= 0);
 
-    if( s >= 0 )
+    if (s >= 0)
     {
         static bool buf_logged = false;
-        if( !buf_logged )
+        if (!buf_logged)
         {
             int i;
-            socklen_t size = sizeof( int );
+            socklen_t size = sizeof (int);
             buf_logged = true;
-            getsockopt( s, SOL_SOCKET, SO_SNDBUF, &i, &size );
-            tr_dbg( "SO_SNDBUF size is %d", i );
-            getsockopt( s, SOL_SOCKET, SO_RCVBUF, &i, &size );
-            tr_dbg( "SO_RCVBUF size is %d", i );
+            getsockopt (s, SOL_SOCKET, SO_SNDBUF, &i, &size);
+            tr_dbg ("SO_SNDBUF size is %d", i);
+            getsockopt (s, SOL_SOCKET, SO_RCVBUF, &i, &size);
+            tr_dbg ("SO_RCVBUF size is %d", i);
         }
     }
 
@@ -705,33 +705,33 @@ tr_fdSocketCreate( tr_session * session, int domain, int type )
 }
 
 int
-tr_fdSocketAccept( tr_session * s, int sockfd, tr_address * addr, tr_port * port )
+tr_fdSocketAccept (tr_session * s, int sockfd, tr_address * addr, tr_port * port)
 {
     int fd;
     unsigned int len;
     struct tr_fdInfo * gFd;
     struct sockaddr_storage sock;
 
-    assert( tr_isSession( s ) );
-    assert( addr );
-    assert( port );
+    assert (tr_isSession (s));
+    assert (addr);
+    assert (port);
 
-    ensureSessionFdInfoExists( s );
+    ensureSessionFdInfoExists (s);
     gFd = s->fdInfo;
 
-    len = sizeof( struct sockaddr_storage );
-    fd = accept( sockfd, (struct sockaddr *) &sock, &len );
+    len = sizeof (struct sockaddr_storage);
+    fd = accept (sockfd, (struct sockaddr *) &sock, &len);
 
-    if( fd >= 0 )
+    if (fd >= 0)
     {
-        if( ( gFd->peerCount < s->peerLimit )
-            && tr_address_from_sockaddr_storage( addr, port, &sock ) )
+        if ((gFd->peerCount < s->peerLimit)
+            && tr_address_from_sockaddr_storage (addr, port, &sock))
         {
             ++gFd->peerCount;
         }
         else
         {
-            tr_netCloseSocket( fd );
+            tr_netCloseSocket (fd);
             fd = -1;
         }
     }
@@ -740,20 +740,20 @@ tr_fdSocketAccept( tr_session * s, int sockfd, tr_address * addr, tr_port * port
 }
 
 void
-tr_fdSocketClose( tr_session * session, int fd )
+tr_fdSocketClose (tr_session * session, int fd)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    if( session->fdInfo != NULL )
+    if (session->fdInfo != NULL)
     {
         struct tr_fdInfo * gFd = session->fdInfo;
 
-        if( fd >= 0 )
+        if (fd >= 0)
         {
-            tr_netCloseSocket( fd );
+            tr_netCloseSocket (fd);
             --gFd->peerCount;
         }
 
-        assert( gFd->peerCount >= 0 );
+        assert (gFd->peerCount >= 0);
     }
 }
diff --git a/libtransmission/fdlimit.h b/libtransmission/fdlimit.h
index 0b01190e2..97f0ce199 100644
--- a/libtransmission/fdlimit.h
+++ b/libtransmission/fdlimit.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -26,19 +26,19 @@
 ****
 ***/
 
-void tr_set_file_for_single_pass( int fd );
+void tr_set_file_for_single_pass (int fd);
 
-int tr_open_file_for_scanning( const char * filename );
+int tr_open_file_for_scanning (const char * filename);
 
-int tr_open_file_for_writing( const char * filename );
+int tr_open_file_for_writing (const char * filename);
 
-void tr_close_file( int fd );
+void tr_close_file (int fd);
 
-int tr_fsync(int fd);
+int tr_fsync (int fd);
 
-ssize_t tr_pread(int fd, void *buf, size_t count, off_t offset);
-ssize_t tr_pwrite(int fd, const void *buf, size_t count, off_t offset);
-int tr_prefetch(int fd, off_t offset, size_t count);
+ssize_t tr_pread (int fd, void *buf, size_t count, off_t offset);
+ssize_t tr_pwrite (int fd, const void *buf, size_t count, off_t offset);
+int tr_prefetch (int fd, off_t offset, size_t count);
 
 
 /**
@@ -56,61 +56,61 @@ int tr_prefetch(int fd, off_t offset, size_t count);
  *
  * @see tr_fdFileClose
  */
-int  tr_fdFileCheckout( tr_session             * session,
+int  tr_fdFileCheckout (tr_session             * session,
                         int                      torrent_id,
                         tr_file_index_t          file_num,
                         const char             * filename,
                         bool                     do_write,
                         tr_preallocation_mode    preallocation_mode,
-                        uint64_t                 preallocation_file_size );
+                        uint64_t                 preallocation_file_size);
 
-int tr_fdFileGetCached( tr_session             * session,
+int tr_fdFileGetCached (tr_session             * session,
                         int                      torrent_id,
                         tr_file_index_t          file_num,
-                        bool                  doWrite );
+                        bool                  doWrite);
 
-bool tr_fdFileGetCachedMTime( tr_session       * session,
+bool tr_fdFileGetCachedMTime (tr_session       * session,
                               int                torrent_id,
                               tr_file_index_t    file_num,
-                              time_t           * mtime );
+                              time_t           * mtime);
 
 
 /**
  * Closes a file that's being held by our file repository.
  *
- * If the file isn't checked out, it's fsync()ed and close()d immediately.
+ * If the file isn't checked out, it's fsync ()ed and close ()d immediately.
  * If the file is currently checked out, it will be closed upon its return.
  *
  * @see tr_fdFileCheckout
  */
-void tr_fdFileClose( tr_session        * session,
+void tr_fdFileClose (tr_session        * session,
                      const tr_torrent  * tor,
-                     tr_file_index_t     file_num );
+                     tr_file_index_t     file_num);
 
 
 /**
  * Closes all the files associated with a given torrent id
  */
-void tr_fdTorrentClose( tr_session * session, int torrentId );
+void tr_fdTorrentClose (tr_session * session, int torrentId);
 
 
 /***********************************************************************
  * Sockets
  **********************************************************************/
-int      tr_fdSocketCreate( tr_session * session, int domain, int type );
+int      tr_fdSocketCreate (tr_session * session, int domain, int type);
 
-int      tr_fdSocketAccept( tr_session  * session,
+int      tr_fdSocketAccept (tr_session  * session,
                             int           listening_sockfd,
                             tr_address  * addr,
-                            tr_port     * port );
+                            tr_port     * port);
 
-void     tr_fdSocketClose( tr_session * session, int s );
+void     tr_fdSocketClose (tr_session * session, int s);
 
 /***********************************************************************
  * tr_fdClose
  ***********************************************************************
  * Frees resources allocated by tr_fdInit.
  **********************************************************************/
-void     tr_fdClose( tr_session * session );
+void     tr_fdClose (tr_session * session);
 
 /* @} */
diff --git a/libtransmission/handshake.c b/libtransmission/handshake.c
index 07075afdb..f9d277e04 100644
--- a/libtransmission/handshake.c
+++ b/libtransmission/handshake.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -12,7 +12,7 @@
 
 #include <assert.h>
 #include <errno.h>
-#include <string.h> /* strcmp(), strlen() */
+#include <string.h> /* strcmp (), strlen () */
 
 #include <event2/buffer.h>
 #include <event2/event.h>
@@ -64,35 +64,34 @@ enum
 
 
 #ifdef ENABLE_LTEP
- #define HANDSHAKE_HAS_LTEP( bits ) ( ( ( bits )[5] & 0x10 ) ? 1 : 0 )
- #define HANDSHAKE_SET_LTEP( bits ) ( ( bits )[5] |= 0x10 )
+ #define HANDSHAKE_HAS_LTEP(bits)(((bits)[5] & 0x10) ? 1 : 0)
+ #define HANDSHAKE_SET_LTEP(bits)((bits)[5] |= 0x10)
 #else
- #define HANDSHAKE_HAS_LTEP( bits ) ( 0 )
- #define HANDSHAKE_SET_LTEP( bits ) ( (void)0 )
+ #define HANDSHAKE_HAS_LTEP(bits)(0)
+ #define HANDSHAKE_SET_LTEP(bits)((void)0)
 #endif
 
 #ifdef ENABLE_FAST
- #define HANDSHAKE_HAS_FASTEXT( bits ) ( ( ( bits )[7] & 0x04 ) ? 1 : 0 )
- #define HANDSHAKE_SET_FASTEXT( bits ) ( ( bits )[7] |= 0x04 )
+ #define HANDSHAKE_HAS_FASTEXT(bits)(((bits)[7] & 0x04) ? 1 : 0)
+ #define HANDSHAKE_SET_FASTEXT(bits)((bits)[7] |= 0x04)
 #else
- #define HANDSHAKE_HAS_FASTEXT( bits ) ( 0 )
- #define HANDSHAKE_SET_FASTEXT( bits ) ( (void)0 )
+ #define HANDSHAKE_HAS_FASTEXT(bits)(0)
+ #define HANDSHAKE_SET_FASTEXT(bits)((void)0)
 #endif
 
 #ifdef ENABLE_DHT
- #define HANDSHAKE_HAS_DHT( bits ) ( ( ( bits )[7] & 0x01 ) ? 1 : 0 )
- #define HANDSHAKE_SET_DHT( bits ) ( ( bits )[7] |= 0x01 )
+ #define HANDSHAKE_HAS_DHT(bits)(((bits)[7] & 0x01) ? 1 : 0)
+ #define HANDSHAKE_SET_DHT(bits)((bits)[7] |= 0x01)
 #else
- #define HANDSHAKE_HAS_DHT( bits ) ( 0 )
- #define HANDSHAKE_SET_DHT( bits ) ( (void)0 )
+ #define HANDSHAKE_HAS_DHT(bits)(0)
+ #define HANDSHAKE_SET_DHT(bits)((void)0)
 #endif
 
 /* http://www.azureuswiki.com/index.php/Extension_negotiation_protocol
    these macros are to be used if both extended messaging and the
    azureus protocol is supported, they indicate which protocol is preferred */
-#define HANDSHAKE_GET_EXTPREF( reserved )      ( ( reserved )[5] & 0x03 )
-#define HANDSHAKE_SET_EXTPREF( reserved, val ) ( ( reserved )[5] |= 0x03 &\
-                                                                    ( val ) )
+#define HANDSHAKE_GET_EXTPREF(reserved)    ((reserved)[5] & 0x03)
+#define HANDSHAKE_SET_EXTPREF(reserved, val)((reserved)[5] |= 0x03 & (val))
 
 typedef uint8_t handshake_state_t;
 
@@ -145,18 +144,18 @@ enum
 ***
 **/
 
-#define dbgmsg( handshake, ... ) \
+#define dbgmsg(handshake, ...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, tr_peerIoGetAddrStr( handshake->io ), __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, tr_peerIoGetAddrStr (handshake->io), __VA_ARGS__); \
+    } while (0)
 
 static const char*
-getStateName( const handshake_state_t state )
+getStateName (const handshake_state_t state)
 {
     const char * str = "f00!";
 
-    switch( state )
+    switch (state)
     {
         case AWAITING_HANDSHAKE:
             str = "awaiting handshake"; break;
@@ -195,49 +194,49 @@ getStateName( const handshake_state_t state )
 }
 
 static void
-setState( tr_handshake * handshake, handshake_state_t state )
+setState (tr_handshake * handshake, handshake_state_t state)
 {
-    dbgmsg( handshake, "setting to state [%s]", getStateName( state ) );
+    dbgmsg (handshake, "setting to state [%s]", getStateName (state));
     handshake->state = state;
 }
 
 static void
-setReadState( tr_handshake * handshake, handshake_state_t state )
+setReadState (tr_handshake * handshake, handshake_state_t state)
 {
-    setState( handshake, state );
+    setState (handshake, state);
 }
 
 static void
-buildHandshakeMessage( tr_handshake * handshake, uint8_t * buf )
+buildHandshakeMessage (tr_handshake * handshake, uint8_t * buf)
 {
     uint8_t          * walk = buf;
-    const uint8_t    * torrentHash = tr_cryptoGetTorrentHash( handshake->crypto );
-    const tr_torrent * tor = tr_torrentFindFromHash( handshake->session, torrentHash );
-    const uint8_t    * peer_id = tor && *tor->peer_id ? tor->peer_id : tr_getPeerId( handshake->session );
+    const uint8_t    * torrentHash = tr_cryptoGetTorrentHash (handshake->crypto);
+    const tr_torrent * tor = tr_torrentFindFromHash (handshake->session, torrentHash);
+    const uint8_t    * peer_id = tor && *tor->peer_id ? tor->peer_id : tr_getPeerId (handshake->session);
 
-    memcpy( walk, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
+    memcpy (walk, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN);
     walk += HANDSHAKE_NAME_LEN;
-    memset( walk, 0, HANDSHAKE_FLAGS_LEN );
-    HANDSHAKE_SET_LTEP( walk );
-    HANDSHAKE_SET_FASTEXT( walk );
+    memset (walk, 0, HANDSHAKE_FLAGS_LEN);
+    HANDSHAKE_SET_LTEP (walk);
+    HANDSHAKE_SET_FASTEXT (walk);
 
     /* Note that this doesn't depend on whether the torrent is private.
      * We don't accept DHT peers for a private torrent,
      * but we participate in the DHT regardless. */
-    if( tr_dhtEnabled( handshake->session ) )
-        HANDSHAKE_SET_DHT( walk );
+    if (tr_dhtEnabled (handshake->session))
+        HANDSHAKE_SET_DHT (walk);
 
     walk += HANDSHAKE_FLAGS_LEN;
-    memcpy( walk, torrentHash, SHA_DIGEST_LENGTH );
+    memcpy (walk, torrentHash, SHA_DIGEST_LENGTH);
     walk += SHA_DIGEST_LENGTH;
-    memcpy( walk, peer_id, PEER_ID_LEN );
+    memcpy (walk, peer_id, PEER_ID_LEN);
     walk += PEER_ID_LEN;
 
-    assert( walk - buf == HANDSHAKE_SIZE );
+    assert (walk - buf == HANDSHAKE_SIZE);
 }
 
-static int tr_handshakeDone( tr_handshake * handshake,
-                             bool           isConnected );
+static int tr_handshakeDone (tr_handshake * handshake,
+                             bool           isConnected);
 
 enum
 {
@@ -248,8 +247,8 @@ enum
 };
 
 static int
-parseHandshake( tr_handshake *    handshake,
-                struct evbuffer * inbuf )
+parseHandshake (tr_handshake *    handshake,
+                struct evbuffer * inbuf)
 {
     uint8_t name[HANDSHAKE_NAME_LEN];
     uint8_t reserved[HANDSHAKE_FLAGS_LEN];
@@ -258,44 +257,44 @@ parseHandshake( tr_handshake *    handshake,
     const uint8_t * tor_peer_id;
     uint8_t peer_id[PEER_ID_LEN];
 
-    dbgmsg( handshake, "payload: need %d, got %zu",
-            HANDSHAKE_SIZE, evbuffer_get_length( inbuf ) );
+    dbgmsg (handshake, "payload: need %d, got %zu",
+            HANDSHAKE_SIZE, evbuffer_get_length (inbuf));
 
-    if( evbuffer_get_length( inbuf ) < HANDSHAKE_SIZE )
+    if (evbuffer_get_length (inbuf) < HANDSHAKE_SIZE)
         return READ_LATER;
 
     /* confirm the protocol */
-    tr_peerIoReadBytes( handshake->io, inbuf, name, HANDSHAKE_NAME_LEN );
-    if( memcmp( name, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN ) )
+    tr_peerIoReadBytes (handshake->io, inbuf, name, HANDSHAKE_NAME_LEN);
+    if (memcmp (name, HANDSHAKE_NAME, HANDSHAKE_NAME_LEN))
         return HANDSHAKE_ENCRYPTION_WRONG;
 
     /* read the reserved bytes */
-    tr_peerIoReadBytes( handshake->io, inbuf, reserved, HANDSHAKE_FLAGS_LEN );
+    tr_peerIoReadBytes (handshake->io, inbuf, reserved, HANDSHAKE_FLAGS_LEN);
 
     /* torrent hash */
-    tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof( hash ) );
-    assert( tr_peerIoHasTorrentHash( handshake->io ) );
-    if( !tr_torrentExists( handshake->session, hash )
-      || memcmp( hash, tr_peerIoGetTorrentHash( handshake->io ),
-                 SHA_DIGEST_LENGTH ) )
+    tr_peerIoReadBytes (handshake->io, inbuf, hash, sizeof (hash));
+    assert (tr_peerIoHasTorrentHash (handshake->io));
+    if (!tr_torrentExists (handshake->session, hash)
+      || memcmp (hash, tr_peerIoGetTorrentHash (handshake->io),
+                 SHA_DIGEST_LENGTH))
     {
-        dbgmsg( handshake, "peer returned the wrong hash. wtf?" );
+        dbgmsg (handshake, "peer returned the wrong hash. wtf?");
         return HANDSHAKE_BAD_TORRENT;
     }
 
     /* peer_id */
-    tr_peerIoReadBytes( handshake->io, inbuf, peer_id, sizeof( peer_id ) );
-    tr_peerIoSetPeersId( handshake->io, peer_id );
+    tr_peerIoReadBytes (handshake->io, inbuf, peer_id, sizeof (peer_id));
+    tr_peerIoSetPeersId (handshake->io, peer_id);
 
     /* peer id */
     handshake->havePeerID = true;
-    dbgmsg( handshake, "peer-id is [%*.*s]", PEER_ID_LEN, PEER_ID_LEN, peer_id );
+    dbgmsg (handshake, "peer-id is [%*.*s]", PEER_ID_LEN, PEER_ID_LEN, peer_id);
 
-    tor = tr_torrentFindFromHash( handshake->session, hash );
-    tor_peer_id = tor ? tor->peer_id : tr_getPeerId( handshake->session );
-    if( !memcmp( peer_id, tor_peer_id, PEER_ID_LEN ) )
+    tor = tr_torrentFindFromHash (handshake->session, hash);
+    tor_peer_id = tor ? tor->peer_id : tr_getPeerId (handshake->session);
+    if (!memcmp (peer_id, tor_peer_id, PEER_ID_LEN))
     {
-        dbgmsg( handshake, "streuth!  we've connected to ourselves." );
+        dbgmsg (handshake, "streuth!  we've connected to ourselves.");
         return HANDSHAKE_PEER_IS_SELF;
     }
 
@@ -303,11 +302,11 @@ parseHandshake( tr_handshake *    handshake,
     *** Extensions
     **/
 
-    tr_peerIoEnableLTEP( handshake->io, HANDSHAKE_HAS_LTEP( reserved ) );
+    tr_peerIoEnableLTEP (handshake->io, HANDSHAKE_HAS_LTEP (reserved));
 
-    tr_peerIoEnableFEXT( handshake->io, HANDSHAKE_HAS_FASTEXT( reserved ) );
+    tr_peerIoEnableFEXT (handshake->io, HANDSHAKE_HAS_FASTEXT (reserved));
 
-    tr_peerIoEnableDHT( handshake->io, HANDSHAKE_HAS_DHT( reserved ) );
+    tr_peerIoEnableDHT (handshake->io, HANDSHAKE_HAS_DHT (reserved));
 
     return HANDSHAKE_OK;
 }
@@ -320,35 +319,35 @@ parseHandshake( tr_handshake *    handshake,
 
 /* 1 A->B: Diffie Hellman Ya, PadA */
 static void
-sendYa( tr_handshake * handshake )
+sendYa (tr_handshake * handshake)
 {
     int               len;
     const uint8_t *   public_key;
     char              outbuf[ KEY_LEN + PadA_MAXLEN ], *walk=outbuf;
 
     /* add our public key (Ya) */
-    public_key = tr_cryptoGetMyPublicKey( handshake->crypto, &len );
-    assert( len == KEY_LEN );
-    assert( public_key );
-    memcpy( walk, public_key, len );
+    public_key = tr_cryptoGetMyPublicKey (handshake->crypto, &len);
+    assert (len == KEY_LEN);
+    assert (public_key);
+    memcpy (walk, public_key, len);
     walk += len;
 
     /* add some bullshit padding */
-    len = tr_cryptoRandInt( PadA_MAXLEN );
-    tr_cryptoRandBuf( walk, len );
+    len = tr_cryptoRandInt (PadA_MAXLEN);
+    tr_cryptoRandBuf (walk, len);
     walk += len;
 
     /* send it */
-    setReadState( handshake, AWAITING_YB );
-    tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, false );
+    setReadState (handshake, AWAITING_YB);
+    tr_peerIoWriteBytes (handshake->io, outbuf, walk - outbuf, false);
 }
 
 static uint32_t
-getCryptoProvide( const tr_handshake * handshake )
+getCryptoProvide (const tr_handshake * handshake)
 {
     uint32_t provide = 0;
 
-    switch( handshake->encryptionMode )
+    switch (handshake->encryptionMode)
     {
         case TR_ENCRYPTION_REQUIRED:
         case TR_ENCRYPTION_PREFERRED:
@@ -364,13 +363,13 @@ getCryptoProvide( const tr_handshake * handshake )
 }
 
 static uint32_t
-getCryptoSelect( const tr_handshake * handshake,
-                 uint32_t             crypto_provide )
+getCryptoSelect (const tr_handshake * handshake,
+                 uint32_t             crypto_provide)
 {
     uint32_t choices[2];
     int      i, nChoices = 0;
 
-    switch( handshake->encryptionMode )
+    switch (handshake->encryptionMode)
     {
         case TR_ENCRYPTION_REQUIRED:
             choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
@@ -387,15 +386,15 @@ getCryptoSelect( const tr_handshake * handshake,
             break;
     }
 
-    for( i = 0; i < nChoices; ++i )
-        if( crypto_provide & choices[i] )
+    for (i = 0; i < nChoices; ++i)
+        if (crypto_provide & choices[i])
             return choices[i];
 
     return 0;
 }
 
 static int
-readYb( tr_handshake * handshake, struct evbuffer * inbuf )
+readYb (tr_handshake * handshake, struct evbuffer * inbuf)
 {
     int               isEncrypted;
     const uint8_t *   secret;
@@ -403,100 +402,100 @@ readYb( tr_handshake * handshake, struct evbuffer * inbuf )
     struct evbuffer * outbuf;
     size_t            needlen = HANDSHAKE_NAME_LEN;
 
-    if( evbuffer_get_length( inbuf ) < needlen )
+    if (evbuffer_get_length (inbuf) < needlen)
         return READ_LATER;
 
-    isEncrypted = memcmp( evbuffer_pullup( inbuf, HANDSHAKE_NAME_LEN ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
-    if( isEncrypted )
+    isEncrypted = memcmp (evbuffer_pullup (inbuf, HANDSHAKE_NAME_LEN), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN);
+    if (isEncrypted)
     {
         needlen = KEY_LEN;
-        if( evbuffer_get_length( inbuf ) < needlen )
+        if (evbuffer_get_length (inbuf) < needlen)
             return READ_LATER;
     }
 
-    dbgmsg( handshake, "got a %s handshake",
-           ( isEncrypted ? "encrypted" : "plaintext" ) );
+    dbgmsg (handshake, "got a %s handshake",
+         (isEncrypted ? "encrypted" : "plaintext"));
 
-    tr_peerIoSetEncryption( handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
-                                                       : PEER_ENCRYPTION_NONE );
-    if( !isEncrypted )
+    tr_peerIoSetEncryption (handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
+                                                       : PEER_ENCRYPTION_NONE);
+    if (!isEncrypted)
     {
-        setState( handshake, AWAITING_HANDSHAKE );
+        setState (handshake, AWAITING_HANDSHAKE);
         return READ_NOW;
     }
 
     handshake->haveReadAnythingFromPeer = true;
 
     /* compute the secret */
-    evbuffer_remove( inbuf, yb, KEY_LEN );
-    secret = tr_cryptoComputeSecret( handshake->crypto, yb );
-    memcpy( handshake->mySecret, secret, KEY_LEN );
+    evbuffer_remove (inbuf, yb, KEY_LEN);
+    secret = tr_cryptoComputeSecret (handshake->crypto, yb);
+    memcpy (handshake->mySecret, secret, KEY_LEN);
 
-    /* now send these: HASH('req1', S), HASH('req2', SKEY) xor HASH('req3', S),
-     * ENCRYPT(VC, crypto_provide, len(PadC), PadC, len(IA)), ENCRYPT(IA) */
-    outbuf = evbuffer_new( );
+    /* now send these: HASH ('req1', S), HASH ('req2', SKEY) xor HASH ('req3', S),
+     * ENCRYPT (VC, crypto_provide, len (PadC), PadC, len (IA)), ENCRYPT (IA) */
+    outbuf = evbuffer_new ();
 
-    /* HASH('req1', S) */
+    /* HASH ('req1', S) */
     {
         uint8_t req1[SHA_DIGEST_LENGTH];
-        tr_sha1( req1, "req1", 4, secret, KEY_LEN, NULL );
-        evbuffer_add( outbuf, req1, SHA_DIGEST_LENGTH );
+        tr_sha1 (req1, "req1", 4, secret, KEY_LEN, NULL);
+        evbuffer_add (outbuf, req1, SHA_DIGEST_LENGTH);
     }
 
-    /* HASH('req2', SKEY) xor HASH('req3', S) */
+    /* HASH ('req2', SKEY) xor HASH ('req3', S) */
     {
         int     i;
         uint8_t req2[SHA_DIGEST_LENGTH];
         uint8_t req3[SHA_DIGEST_LENGTH];
         uint8_t buf[SHA_DIGEST_LENGTH];
-        tr_sha1( req2, "req2", 4,
-                 tr_cryptoGetTorrentHash( handshake->crypto ),
-                 SHA_DIGEST_LENGTH, NULL );
-        tr_sha1( req3, "req3", 4, secret, KEY_LEN, NULL );
-        for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
+        tr_sha1 (req2, "req2", 4,
+                 tr_cryptoGetTorrentHash (handshake->crypto),
+                 SHA_DIGEST_LENGTH, NULL);
+        tr_sha1 (req3, "req3", 4, secret, KEY_LEN, NULL);
+        for (i = 0; i < SHA_DIGEST_LENGTH; ++i)
             buf[i] = req2[i] ^ req3[i];
-        evbuffer_add( outbuf, buf, SHA_DIGEST_LENGTH );
+        evbuffer_add (outbuf, buf, SHA_DIGEST_LENGTH);
     }
 
-    /* ENCRYPT(VC, crypto_provide, len(PadC), PadC
+    /* ENCRYPT (VC, crypto_provide, len (PadC), PadC
      * PadC is reserved for future extensions to the handshake...
      * standard practice at this time is for it to be zero-length */
     {
         uint8_t vc[VC_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 
-        tr_peerIoWriteBuf( handshake->io, outbuf, false );
-        tr_cryptoEncryptInit( handshake->crypto );
-        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
+        tr_peerIoWriteBuf (handshake->io, outbuf, false);
+        tr_cryptoEncryptInit (handshake->crypto);
+        tr_peerIoSetEncryption (handshake->io, PEER_ENCRYPTION_RC4);
 
-        evbuffer_add        ( outbuf, vc, VC_LENGTH );
-        evbuffer_add_uint32 ( outbuf, getCryptoProvide( handshake ) );
-        evbuffer_add_uint16 ( outbuf, 0 );
+        evbuffer_add      (outbuf, vc, VC_LENGTH);
+        evbuffer_add_uint32 (outbuf, getCryptoProvide (handshake));
+        evbuffer_add_uint16 (outbuf, 0);
     }
 
-    /* ENCRYPT len(IA)), ENCRYPT(IA) */
+    /* ENCRYPT len (IA)), ENCRYPT (IA) */
     {
         uint8_t msg[HANDSHAKE_SIZE];
-        buildHandshakeMessage( handshake, msg );
+        buildHandshakeMessage (handshake, msg);
 
-        evbuffer_add_uint16 ( outbuf, sizeof( msg ) );
-        evbuffer_add        ( outbuf, msg, sizeof( msg ) );
+        evbuffer_add_uint16 (outbuf, sizeof (msg));
+        evbuffer_add      (outbuf, msg, sizeof (msg));
 
         handshake->haveSentBitTorrentHandshake = 1;
     }
 
     /* send it */
-    tr_cryptoDecryptInit( handshake->crypto );
-    setReadState( handshake, AWAITING_VC );
-    tr_peerIoWriteBuf( handshake->io, outbuf, false );
+    tr_cryptoDecryptInit (handshake->crypto);
+    setReadState (handshake, AWAITING_VC);
+    tr_peerIoWriteBuf (handshake->io, outbuf, false);
 
     /* cleanup */
-    evbuffer_free( outbuf );
+    evbuffer_free (outbuf);
     return READ_LATER;
 }
 
 static int
-readVC( tr_handshake *    handshake,
-        struct evbuffer * inbuf )
+readVC (tr_handshake *    handshake,
+        struct evbuffer * inbuf)
 {
     const uint8_t key[VC_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 };
     const int     key_len = VC_LENGTH;
@@ -505,81 +504,81 @@ readVC( tr_handshake *    handshake,
     /* note: this works w/o having to `unwind' the buffer if
      * we read too much, but it is pretty brute-force.
      * it would be nice to make this cleaner. */
-    for( ; ; )
+    for (; ;)
     {
-        if( evbuffer_get_length( inbuf ) < VC_LENGTH )
+        if (evbuffer_get_length (inbuf) < VC_LENGTH)
         {
-            dbgmsg( handshake, "not enough bytes... returning read_more" );
+            dbgmsg (handshake, "not enough bytes... returning read_more");
             return READ_LATER;
         }
 
-        memcpy( tmp, evbuffer_pullup( inbuf, key_len ), key_len );
-        tr_cryptoDecryptInit( handshake->crypto );
-        tr_cryptoDecrypt( handshake->crypto, key_len, tmp, tmp );
-        if( !memcmp( tmp, key, key_len ) )
+        memcpy (tmp, evbuffer_pullup (inbuf, key_len), key_len);
+        tr_cryptoDecryptInit (handshake->crypto);
+        tr_cryptoDecrypt (handshake->crypto, key_len, tmp, tmp);
+        if (!memcmp (tmp, key, key_len))
             break;
 
-        evbuffer_drain( inbuf, 1 );
+        evbuffer_drain (inbuf, 1);
     }
 
-    dbgmsg( handshake, "got it!" );
-    evbuffer_drain( inbuf, key_len );
-    setState( handshake, AWAITING_CRYPTO_SELECT );
+    dbgmsg (handshake, "got it!");
+    evbuffer_drain (inbuf, key_len);
+    setState (handshake, AWAITING_CRYPTO_SELECT);
     return READ_NOW;
 }
 
 static int
-readCryptoSelect( tr_handshake *    handshake,
-                  struct evbuffer * inbuf )
+readCryptoSelect (tr_handshake *    handshake,
+                  struct evbuffer * inbuf)
 {
     uint32_t     crypto_select;
     uint16_t     pad_d_len;
-    const size_t needlen = sizeof( uint32_t ) + sizeof( uint16_t );
+    const size_t needlen = sizeof (uint32_t) + sizeof (uint16_t);
 
-    if( evbuffer_get_length( inbuf ) < needlen )
+    if (evbuffer_get_length (inbuf) < needlen)
         return READ_LATER;
 
-    tr_peerIoReadUint32( handshake->io, inbuf, &crypto_select );
+    tr_peerIoReadUint32 (handshake->io, inbuf, &crypto_select);
     handshake->crypto_select = crypto_select;
-    dbgmsg( handshake, "crypto select is %d", (int)crypto_select );
-    if( !( crypto_select & getCryptoProvide( handshake ) ) )
+    dbgmsg (handshake, "crypto select is %d", (int)crypto_select);
+    if (! (crypto_select & getCryptoProvide (handshake)))
     {
-        dbgmsg( handshake,
-                "peer selected an encryption option we didn't provide" );
-        return tr_handshakeDone( handshake, false );
+        dbgmsg (handshake,
+                "peer selected an encryption option we didn't provide");
+        return tr_handshakeDone (handshake, false);
     }
 
-    tr_peerIoReadUint16( handshake->io, inbuf, &pad_d_len );
-    dbgmsg( handshake, "pad_d_len is %d", (int)pad_d_len );
+    tr_peerIoReadUint16 (handshake->io, inbuf, &pad_d_len);
+    dbgmsg (handshake, "pad_d_len is %d", (int)pad_d_len);
 
-    if( pad_d_len > 512 )
+    if (pad_d_len > 512)
     {
-        dbgmsg( handshake, "encryption handshake: pad_d_len is too long" );
-        return tr_handshakeDone( handshake, false );
+        dbgmsg (handshake, "encryption handshake: pad_d_len is too long");
+        return tr_handshakeDone (handshake, false);
     }
 
     handshake->pad_d_len = pad_d_len;
 
-    setState( handshake, AWAITING_PAD_D );
+    setState (handshake, AWAITING_PAD_D);
     return READ_NOW;
 }
 
 static int
-readPadD( tr_handshake *    handshake,
-          struct evbuffer * inbuf )
+readPadD (tr_handshake *    handshake,
+          struct evbuffer * inbuf)
 {
     const size_t needlen = handshake->pad_d_len;
 
-    dbgmsg( handshake, "pad d: need %zu, got %zu",
-            needlen, evbuffer_get_length( inbuf ) );
-    if( evbuffer_get_length( inbuf ) < needlen )
+    dbgmsg (handshake, "pad d: need %zu, got %zu",
+            needlen, evbuffer_get_length (inbuf));
+    if (evbuffer_get_length (inbuf) < needlen)
         return READ_LATER;
 
-    tr_peerIoDrain( handshake->io, inbuf, needlen );
+    tr_peerIoDrain (handshake->io, inbuf, needlen);
 
-    tr_peerIoSetEncryption( handshake->io, handshake->crypto_select );
+    tr_peerIoSetEncryption (handshake->io, handshake->crypto_select);
 
-    setState( handshake, AWAITING_HANDSHAKE );
+    setState (handshake, AWAITING_HANDSHAKE);
     return READ_NOW;
 }
 
@@ -590,102 +589,102 @@ readPadD( tr_handshake *    handshake,
 ***/
 
 static int
-readHandshake( tr_handshake *    handshake,
-               struct evbuffer * inbuf )
+readHandshake (tr_handshake *    handshake,
+               struct evbuffer * inbuf)
 {
     uint8_t   pstrlen;
     uint8_t   pstr[20];
     uint8_t   reserved[HANDSHAKE_FLAGS_LEN];
     uint8_t   hash[SHA_DIGEST_LENGTH];
 
-    dbgmsg( handshake, "payload: need %d, got %zu",
-            INCOMING_HANDSHAKE_LEN, evbuffer_get_length( inbuf ) );
+    dbgmsg (handshake, "payload: need %d, got %zu",
+            INCOMING_HANDSHAKE_LEN, evbuffer_get_length (inbuf));
 
-    if( evbuffer_get_length( inbuf ) < INCOMING_HANDSHAKE_LEN )
+    if (evbuffer_get_length (inbuf) < INCOMING_HANDSHAKE_LEN)
         return READ_LATER;
 
     handshake->haveReadAnythingFromPeer = true;
 
-    pstrlen = evbuffer_pullup( inbuf, 1 )[0]; /* peek, don't read. We may be
+    pstrlen = evbuffer_pullup (inbuf, 1)[0]; /* peek, don't read. We may be
                                                  handing inbuf to AWAITING_YA */
 
-    if( pstrlen == 19 ) /* unencrypted */
+    if (pstrlen == 19) /* unencrypted */
     {
-        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
+        tr_peerIoSetEncryption (handshake->io, PEER_ENCRYPTION_NONE);
 
-        if( handshake->encryptionMode == TR_ENCRYPTION_REQUIRED )
+        if (handshake->encryptionMode == TR_ENCRYPTION_REQUIRED)
         {
-            dbgmsg( handshake,
-                    "peer is unencrypted, and we're disallowing that" );
-            return tr_handshakeDone( handshake, false );
+            dbgmsg (handshake,
+                    "peer is unencrypted, and we're disallowing that");
+            return tr_handshakeDone (handshake, false);
         }
     }
     else /* encrypted or corrupt */
     {
-        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
+        tr_peerIoSetEncryption (handshake->io, PEER_ENCRYPTION_RC4);
 
-        if( tr_peerIoIsIncoming( handshake->io ) )
+        if (tr_peerIoIsIncoming (handshake->io))
         {
-            dbgmsg( handshake,
-                    "I think peer is sending us an encrypted handshake..." );
-            setState( handshake, AWAITING_YA );
+            dbgmsg (handshake,
+                    "I think peer is sending us an encrypted handshake...");
+            setState (handshake, AWAITING_YA);
             return READ_NOW;
         }
-        tr_cryptoDecrypt( handshake->crypto, 1, &pstrlen, &pstrlen );
+        tr_cryptoDecrypt (handshake->crypto, 1, &pstrlen, &pstrlen);
 
-        if( pstrlen != 19 )
+        if (pstrlen != 19)
         {
-            dbgmsg( handshake,
-                    "I think peer has sent us a corrupt handshake..." );
-            return tr_handshakeDone( handshake, false );
+            dbgmsg (handshake,
+                    "I think peer has sent us a corrupt handshake...");
+            return tr_handshakeDone (handshake, false);
         }
     }
 
-    evbuffer_drain( inbuf, 1 );
+    evbuffer_drain (inbuf, 1);
 
     /* pstr (BitTorrent) */
-    assert( pstrlen == 19 );
-    tr_peerIoReadBytes( handshake->io, inbuf, pstr, pstrlen );
+    assert (pstrlen == 19);
+    tr_peerIoReadBytes (handshake->io, inbuf, pstr, pstrlen);
     pstr[pstrlen] = '\0';
-    if( memcmp( pstr, "BitTorrent protocol", 19 ) )
-        return tr_handshakeDone( handshake, false );
+    if (memcmp (pstr, "BitTorrent protocol", 19))
+        return tr_handshakeDone (handshake, false);
 
     /* reserved bytes */
-    tr_peerIoReadBytes( handshake->io, inbuf, reserved, sizeof( reserved ) );
+    tr_peerIoReadBytes (handshake->io, inbuf, reserved, sizeof (reserved));
 
     /**
     *** Extensions
     **/
 
-    tr_peerIoEnableLTEP( handshake->io, HANDSHAKE_HAS_LTEP( reserved ) );
+    tr_peerIoEnableLTEP (handshake->io, HANDSHAKE_HAS_LTEP (reserved));
 
-    tr_peerIoEnableFEXT( handshake->io, HANDSHAKE_HAS_FASTEXT( reserved ) );
+    tr_peerIoEnableFEXT (handshake->io, HANDSHAKE_HAS_FASTEXT (reserved));
 
-    tr_peerIoEnableDHT( handshake->io, HANDSHAKE_HAS_DHT( reserved ) );
+    tr_peerIoEnableDHT (handshake->io, HANDSHAKE_HAS_DHT (reserved));
 
     /* torrent hash */
-    tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof( hash ) );
-    if( tr_peerIoIsIncoming( handshake->io ) )
+    tr_peerIoReadBytes (handshake->io, inbuf, hash, sizeof (hash));
+    if (tr_peerIoIsIncoming (handshake->io))
     {
-        if( !tr_torrentExists( handshake->session, hash ) )
+        if (!tr_torrentExists (handshake->session, hash))
         {
-            dbgmsg( handshake, "peer is trying to connect to us for a torrent we don't have." );
-            return tr_handshakeDone( handshake, false );
+            dbgmsg (handshake, "peer is trying to connect to us for a torrent we don't have.");
+            return tr_handshakeDone (handshake, false);
         }
         else
         {
-            assert( !tr_peerIoHasTorrentHash( handshake->io ) );
-            tr_peerIoSetTorrentHash( handshake->io, hash );
+            assert (!tr_peerIoHasTorrentHash (handshake->io));
+            tr_peerIoSetTorrentHash (handshake->io, hash);
         }
     }
     else /* outgoing */
     {
-        assert( tr_peerIoHasTorrentHash( handshake->io ) );
-        if( memcmp( hash, tr_peerIoGetTorrentHash( handshake->io ),
-                    SHA_DIGEST_LENGTH ) )
+        assert (tr_peerIoHasTorrentHash (handshake->io));
+        if (memcmp (hash, tr_peerIoGetTorrentHash (handshake->io),
+                    SHA_DIGEST_LENGTH))
         {
-            dbgmsg( handshake, "peer returned the wrong hash. wtf?" );
-            return tr_handshakeDone( handshake, false );
+            dbgmsg (handshake, "peer returned the wrong hash. wtf?");
+            return tr_handshakeDone (handshake, false);
         }
     }
 
@@ -693,21 +692,21 @@ readHandshake( tr_handshake *    handshake,
     ***  If it's an incoming message, we need to send a response handshake
     **/
 
-    if( !handshake->haveSentBitTorrentHandshake )
+    if (!handshake->haveSentBitTorrentHandshake)
     {
         uint8_t msg[HANDSHAKE_SIZE];
-        buildHandshakeMessage( handshake, msg );
-        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), false );
+        buildHandshakeMessage (handshake, msg);
+        tr_peerIoWriteBytes (handshake->io, msg, sizeof (msg), false);
         handshake->haveSentBitTorrentHandshake = 1;
     }
 
-    setReadState( handshake, AWAITING_PEER_ID );
+    setReadState (handshake, AWAITING_PEER_ID);
     return READ_NOW;
 }
 
 static int
-readPeerId( tr_handshake    * handshake,
-            struct evbuffer * inbuf )
+readPeerId (tr_handshake    * handshake,
+            struct evbuffer * inbuf)
 {
     bool peerIsGood;
     char client[128];
@@ -715,88 +714,88 @@ readPeerId( tr_handshake    * handshake,
     const uint8_t * tor_peer_id;
     uint8_t peer_id[PEER_ID_LEN];
 
-    if( evbuffer_get_length( inbuf ) < PEER_ID_LEN )
+    if (evbuffer_get_length (inbuf) < PEER_ID_LEN)
         return READ_LATER;
 
     /* peer id */
-    tr_peerIoReadBytes( handshake->io, inbuf, peer_id, PEER_ID_LEN );
-    tr_peerIoSetPeersId( handshake->io, peer_id );
+    tr_peerIoReadBytes (handshake->io, inbuf, peer_id, PEER_ID_LEN);
+    tr_peerIoSetPeersId (handshake->io, peer_id);
     handshake->havePeerID = true;
-    tr_clientForId( client, sizeof( client ), peer_id );
-    dbgmsg( handshake, "peer-id is [%s] ... isIncoming is %d", client,
-            tr_peerIoIsIncoming( handshake->io ) );
+    tr_clientForId (client, sizeof (client), peer_id);
+    dbgmsg (handshake, "peer-id is [%s] ... isIncoming is %d", client,
+            tr_peerIoIsIncoming (handshake->io));
 
     /* if we've somehow connected to ourselves, don't keep the connection */
-    tor = tr_torrentFindFromHash( handshake->session, tr_peerIoGetTorrentHash( handshake->io ) );
-    tor_peer_id = tor ? tor->peer_id : tr_getPeerId( handshake->session );
-    peerIsGood = memcmp( peer_id, tor_peer_id, PEER_ID_LEN ) != 0;
-    dbgmsg( handshake, "isPeerGood == %d", (int)peerIsGood );
-    return tr_handshakeDone( handshake, peerIsGood );
+    tor = tr_torrentFindFromHash (handshake->session, tr_peerIoGetTorrentHash (handshake->io));
+    tor_peer_id = tor ? tor->peer_id : tr_getPeerId (handshake->session);
+    peerIsGood = memcmp (peer_id, tor_peer_id, PEER_ID_LEN) != 0;
+    dbgmsg (handshake, "isPeerGood == %d", (int)peerIsGood);
+    return tr_handshakeDone (handshake, peerIsGood);
 }
 
 static int
-readYa( tr_handshake *    handshake,
-        struct evbuffer * inbuf )
+readYa (tr_handshake *    handshake,
+        struct evbuffer * inbuf)
 {
     uint8_t        ya[KEY_LEN];
     uint8_t *      walk, outbuf[KEY_LEN + PadB_MAXLEN];
     const uint8_t *myKey, *secret;
     int            len;
 
-    dbgmsg( handshake, "in readYa... need %d, have %zu",
-            KEY_LEN, evbuffer_get_length( inbuf ) );
-    if( evbuffer_get_length( inbuf ) < KEY_LEN )
+    dbgmsg (handshake, "in readYa... need %d, have %zu",
+            KEY_LEN, evbuffer_get_length (inbuf));
+    if (evbuffer_get_length (inbuf) < KEY_LEN)
         return READ_LATER;
 
     /* read the incoming peer's public key */
-    evbuffer_remove( inbuf, ya, KEY_LEN );
-    secret = tr_cryptoComputeSecret( handshake->crypto, ya );
-    memcpy( handshake->mySecret, secret, KEY_LEN );
-    tr_sha1( handshake->myReq1, "req1", 4, secret, KEY_LEN, NULL );
+    evbuffer_remove (inbuf, ya, KEY_LEN);
+    secret = tr_cryptoComputeSecret (handshake->crypto, ya);
+    memcpy (handshake->mySecret, secret, KEY_LEN);
+    tr_sha1 (handshake->myReq1, "req1", 4, secret, KEY_LEN, NULL);
 
-    dbgmsg( handshake, "sending B->A: Diffie Hellman Yb, PadB" );
+    dbgmsg (handshake, "sending B->A: Diffie Hellman Yb, PadB");
     /* send our public key to the peer */
     walk = outbuf;
-    myKey = tr_cryptoGetMyPublicKey( handshake->crypto, &len );
-    memcpy( walk, myKey, len );
+    myKey = tr_cryptoGetMyPublicKey (handshake->crypto, &len);
+    memcpy (walk, myKey, len);
     walk += len;
-    len = tr_cryptoRandInt( PadB_MAXLEN );
-    tr_cryptoRandBuf( walk, len );
+    len = tr_cryptoRandInt (PadB_MAXLEN);
+    tr_cryptoRandBuf (walk, len);
     walk += len;
 
-    setReadState( handshake, AWAITING_PAD_A );
-    tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, false );
+    setReadState (handshake, AWAITING_PAD_A);
+    tr_peerIoWriteBytes (handshake->io, outbuf, walk - outbuf, false);
     return READ_NOW;
 }
 
 static int
-readPadA( tr_handshake * handshake, struct evbuffer * inbuf )
+readPadA (tr_handshake * handshake, struct evbuffer * inbuf)
 {
-    /* resynchronizing on HASH('req1',S) */
-    struct evbuffer_ptr ptr = evbuffer_search( inbuf, (const char*)handshake->myReq1, SHA_DIGEST_LENGTH, NULL );
+    /* resynchronizing on HASH ('req1',S) */
+    struct evbuffer_ptr ptr = evbuffer_search (inbuf, (const char*)handshake->myReq1, SHA_DIGEST_LENGTH, NULL);
 
-    if( ptr.pos != -1 ) /* match */
+    if (ptr.pos != -1) /* match */
     {
-        evbuffer_drain( inbuf, ptr.pos );
-        dbgmsg( handshake, "found it... looking setting to awaiting_crypto_provide" );
-        setState( handshake, AWAITING_CRYPTO_PROVIDE );
+        evbuffer_drain (inbuf, ptr.pos);
+        dbgmsg (handshake, "found it... looking setting to awaiting_crypto_provide");
+        setState (handshake, AWAITING_CRYPTO_PROVIDE);
         return READ_NOW;
     }
     else
     {
-        const size_t len = evbuffer_get_length( inbuf );
-        if( len > SHA_DIGEST_LENGTH )
-            evbuffer_drain( inbuf, len - SHA_DIGEST_LENGTH );
+        const size_t len = evbuffer_get_length (inbuf);
+        if (len > SHA_DIGEST_LENGTH)
+            evbuffer_drain (inbuf, len - SHA_DIGEST_LENGTH);
         return READ_LATER;
     }
 }
 
 static int
-readCryptoProvide( tr_handshake *    handshake,
-                   struct evbuffer * inbuf )
+readCryptoProvide (tr_handshake *    handshake,
+                   struct evbuffer * inbuf)
 {
-    /* HASH('req2', SKEY) xor HASH('req3', S), ENCRYPT(VC, crypto_provide,
-      len(PadC)) */
+    /* HASH ('req2', SKEY) xor HASH ('req3', S), ENCRYPT (VC, crypto_provide,
+      len (PadC)) */
 
     int          i;
     uint8_t      vc_in[VC_LENGTH];
@@ -805,74 +804,74 @@ readCryptoProvide( tr_handshake *    handshake,
     uint8_t      obfuscatedTorrentHash[SHA_DIGEST_LENGTH];
     uint16_t     padc_len = 0;
     uint32_t     crypto_provide = 0;
-    const size_t needlen = SHA_DIGEST_LENGTH /* HASH('req1',s) */
-                           + SHA_DIGEST_LENGTH /* HASH('req2', SKEY) xor
-                                                 HASH('req3', S) */
+    const size_t needlen = SHA_DIGEST_LENGTH /* HASH ('req1',s) */
+                           + SHA_DIGEST_LENGTH /* HASH ('req2', SKEY) xor
+                                                 HASH ('req3', S) */
                            + VC_LENGTH
-                           + sizeof( crypto_provide )
-                           + sizeof( padc_len );
+                           + sizeof (crypto_provide)
+                           + sizeof (padc_len);
     tr_torrent * tor = NULL;
 
-    if( evbuffer_get_length( inbuf ) < needlen )
+    if (evbuffer_get_length (inbuf) < needlen)
         return READ_LATER;
 
-    /* TODO: confirm they sent HASH('req1',S) here? */
-    evbuffer_drain( inbuf, SHA_DIGEST_LENGTH );
+    /* TODO: confirm they sent HASH ('req1',S) here? */
+    evbuffer_drain (inbuf, SHA_DIGEST_LENGTH);
 
-    /* This next piece is HASH('req2', SKEY) xor HASH('req3', S) ...
+    /* This next piece is HASH ('req2', SKEY) xor HASH ('req3', S) ...
      * we can get the first half of that (the obufscatedTorrentHash)
      * by building the latter and xor'ing it with what the peer sent us */
-    dbgmsg( handshake, "reading obfuscated torrent hash..." );
-    evbuffer_remove( inbuf, req2, SHA_DIGEST_LENGTH );
-    tr_sha1( req3, "req3", 4, handshake->mySecret, KEY_LEN, NULL );
-    for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
+    dbgmsg (handshake, "reading obfuscated torrent hash...");
+    evbuffer_remove (inbuf, req2, SHA_DIGEST_LENGTH);
+    tr_sha1 (req3, "req3", 4, handshake->mySecret, KEY_LEN, NULL);
+    for (i = 0; i < SHA_DIGEST_LENGTH; ++i)
         obfuscatedTorrentHash[i] = req2[i] ^ req3[i];
-    if(( tor = tr_torrentFindFromObfuscatedHash( handshake->session, obfuscatedTorrentHash )))
+    if ((tor = tr_torrentFindFromObfuscatedHash (handshake->session, obfuscatedTorrentHash)))
     {
-        const bool clientIsSeed = tr_torrentIsSeed( tor );
-        const bool peerIsSeed = tr_peerMgrPeerIsSeed( tor, tr_peerIoGetAddress( handshake->io, NULL ) );
-        dbgmsg( handshake, "got INCOMING connection's encrypted handshake for torrent [%s]",
-                tr_torrentName( tor ) );
-        tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
+        const bool clientIsSeed = tr_torrentIsSeed (tor);
+        const bool peerIsSeed = tr_peerMgrPeerIsSeed (tor, tr_peerIoGetAddress (handshake->io, NULL));
+        dbgmsg (handshake, "got INCOMING connection's encrypted handshake for torrent [%s]",
+                tr_torrentName (tor));
+        tr_peerIoSetTorrentHash (handshake->io, tor->info.hash);
 
-        if( clientIsSeed && peerIsSeed )
+        if (clientIsSeed && peerIsSeed)
         {
-            dbgmsg( handshake, "another seed tried to reconnect to us!" );
-            return tr_handshakeDone( handshake, false );
+            dbgmsg (handshake, "another seed tried to reconnect to us!");
+            return tr_handshakeDone (handshake, false);
         }
     }
     else
     {
-        dbgmsg( handshake, "can't find that torrent..." );
-        return tr_handshakeDone( handshake, false );
+        dbgmsg (handshake, "can't find that torrent...");
+        return tr_handshakeDone (handshake, false);
     }
 
-    /* next part: ENCRYPT(VC, crypto_provide, len(PadC), */
+    /* next part: ENCRYPT (VC, crypto_provide, len (PadC), */
 
-    tr_cryptoDecryptInit( handshake->crypto );
+    tr_cryptoDecryptInit (handshake->crypto);
 
-    tr_peerIoReadBytes( handshake->io, inbuf, vc_in, VC_LENGTH );
+    tr_peerIoReadBytes (handshake->io, inbuf, vc_in, VC_LENGTH);
 
-    tr_peerIoReadUint32( handshake->io, inbuf, &crypto_provide );
+    tr_peerIoReadUint32 (handshake->io, inbuf, &crypto_provide);
     handshake->crypto_provide = crypto_provide;
-    dbgmsg( handshake, "crypto_provide is %d", (int)crypto_provide );
+    dbgmsg (handshake, "crypto_provide is %d", (int)crypto_provide);
 
-    tr_peerIoReadUint16( handshake->io, inbuf, &padc_len );
-    dbgmsg( handshake, "padc is %d", (int)padc_len );
+    tr_peerIoReadUint16 (handshake->io, inbuf, &padc_len);
+    dbgmsg (handshake, "padc is %d", (int)padc_len);
     handshake->pad_c_len = padc_len;
-    setState( handshake, AWAITING_PAD_C );
+    setState (handshake, AWAITING_PAD_C);
     return READ_NOW;
 }
 
 static int
-readPadC( tr_handshake *    handshake,
-          struct evbuffer * inbuf )
+readPadC (tr_handshake *    handshake,
+          struct evbuffer * inbuf)
 {
     char       * padc;
     uint16_t     ia_len;
-    const size_t needlen = handshake->pad_c_len + sizeof( uint16_t );
+    const size_t needlen = handshake->pad_c_len + sizeof (uint16_t);
 
-    if( evbuffer_get_length( inbuf ) < needlen )
+    if (evbuffer_get_length (inbuf) < needlen)
         return READ_LATER;
 
     /* read the throwaway padc */
@@ -881,110 +880,110 @@ readPadC( tr_handshake *    handshake,
     tr_free (padc);
 
     /* read ia_len */
-    tr_peerIoReadUint16( handshake->io, inbuf, &ia_len );
-    dbgmsg( handshake, "ia_len is %d", (int)ia_len );
+    tr_peerIoReadUint16 (handshake->io, inbuf, &ia_len);
+    dbgmsg (handshake, "ia_len is %d", (int)ia_len);
     handshake->ia_len = ia_len;
-    setState( handshake, AWAITING_IA );
+    setState (handshake, AWAITING_IA);
     return READ_NOW;
 }
 
 static int
-readIA( tr_handshake *    handshake,
-        struct evbuffer * inbuf )
+readIA (tr_handshake *    handshake,
+        struct evbuffer * inbuf)
 {
     const size_t      needlen = handshake->ia_len;
     struct evbuffer * outbuf;
     uint32_t          crypto_select;
 
-    dbgmsg( handshake, "reading IA... have %zu, need %zu",
-            evbuffer_get_length( inbuf ), needlen );
-    if( evbuffer_get_length( inbuf ) < needlen )
+    dbgmsg (handshake, "reading IA... have %zu, need %zu",
+            evbuffer_get_length (inbuf), needlen);
+    if (evbuffer_get_length (inbuf) < needlen)
         return READ_LATER;
 
     /**
-    ***  B->A: ENCRYPT(VC, crypto_select, len(padD), padD), ENCRYPT2(Payload Stream)
+    ***  B->A: ENCRYPT (VC, crypto_select, len (padD), padD), ENCRYPT2 (Payload Stream)
     **/
 
-    tr_cryptoEncryptInit( handshake->crypto );
-    outbuf = evbuffer_new( );
+    tr_cryptoEncryptInit (handshake->crypto);
+    outbuf = evbuffer_new ();
 
-    dbgmsg( handshake, "sending vc" );
+    dbgmsg (handshake, "sending vc");
     /* send VC */
     {
         uint8_t vc[VC_LENGTH];
-        memset( vc, 0, VC_LENGTH );
-        evbuffer_add( outbuf, vc, VC_LENGTH );
+        memset (vc, 0, VC_LENGTH);
+        evbuffer_add (outbuf, vc, VC_LENGTH);
     }
 
     /* send crypto_select */
-    crypto_select = getCryptoSelect( handshake, handshake->crypto_provide );
-    if( crypto_select )
+    crypto_select = getCryptoSelect (handshake, handshake->crypto_provide);
+    if (crypto_select)
     {
-        dbgmsg( handshake, "selecting crypto mode '%d'", (int)crypto_select );
-        evbuffer_add_uint32( outbuf, crypto_select );
+        dbgmsg (handshake, "selecting crypto mode '%d'", (int)crypto_select);
+        evbuffer_add_uint32 (outbuf, crypto_select);
     }
     else
     {
-        dbgmsg( handshake, "peer didn't offer an encryption mode we like." );
-        evbuffer_free( outbuf );
-        return tr_handshakeDone( handshake, false );
+        dbgmsg (handshake, "peer didn't offer an encryption mode we like.");
+        evbuffer_free (outbuf);
+        return tr_handshakeDone (handshake, false);
     }
 
-    dbgmsg( handshake, "sending pad d" );
-    /* ENCRYPT(VC, crypto_provide, len(PadD), PadD
+    dbgmsg (handshake, "sending pad d");
+    /* ENCRYPT (VC, crypto_provide, len (PadD), PadD
      * PadD is reserved for future extensions to the handshake...
      * standard practice at this time is for it to be zero-length */
     {
         const uint16_t len = 0;
-        evbuffer_add_uint16( outbuf, len );
+        evbuffer_add_uint16 (outbuf, len);
     }
 
     /* maybe de-encrypt our connection */
-    if( crypto_select == CRYPTO_PROVIDE_PLAINTEXT )
+    if (crypto_select == CRYPTO_PROVIDE_PLAINTEXT)
     {
-        tr_peerIoWriteBuf( handshake->io, outbuf, false );
-        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
+        tr_peerIoWriteBuf (handshake->io, outbuf, false);
+        tr_peerIoSetEncryption (handshake->io, PEER_ENCRYPTION_NONE);
     }
 
-    dbgmsg( handshake, "sending handshake" );
+    dbgmsg (handshake, "sending handshake");
     /* send our handshake */
     {
         uint8_t msg[HANDSHAKE_SIZE];
-        buildHandshakeMessage( handshake, msg );
+        buildHandshakeMessage (handshake, msg);
 
-        evbuffer_add( outbuf, msg, sizeof( msg ) );
+        evbuffer_add (outbuf, msg, sizeof (msg));
         handshake->haveSentBitTorrentHandshake = 1;
     }
 
     /* send it out */
-    tr_peerIoWriteBuf( handshake->io, outbuf, false );
-    evbuffer_free( outbuf );
+    tr_peerIoWriteBuf (handshake->io, outbuf, false);
+    evbuffer_free (outbuf);
 
     /* now await the handshake */
-    setState( handshake, AWAITING_PAYLOAD_STREAM );
+    setState (handshake, AWAITING_PAYLOAD_STREAM);
     return READ_NOW;
 }
 
 static int
-readPayloadStream( tr_handshake    * handshake,
-                   struct evbuffer * inbuf )
+readPayloadStream (tr_handshake    * handshake,
+                   struct evbuffer * inbuf)
 {
     int i;
     const size_t      needlen = HANDSHAKE_SIZE;
 
-    dbgmsg( handshake, "reading payload stream... have %zu, need %zu",
-            evbuffer_get_length( inbuf ), needlen );
-    if( evbuffer_get_length( inbuf ) < needlen )
+    dbgmsg (handshake, "reading payload stream... have %zu, need %zu",
+            evbuffer_get_length (inbuf), needlen);
+    if (evbuffer_get_length (inbuf) < needlen)
         return READ_LATER;
 
     /* parse the handshake ... */
-    i = parseHandshake( handshake, inbuf );
-    dbgmsg( handshake, "parseHandshake returned %d", i );
-    if( i != HANDSHAKE_OK )
-        return tr_handshakeDone( handshake, false );
+    i = parseHandshake (handshake, inbuf);
+    dbgmsg (handshake, "parseHandshake returned %d", i);
+    if (i != HANDSHAKE_OK)
+        return tr_handshakeDone (handshake, false);
 
     /* we've completed the BT handshake... pass the work on to peer-msgs */
-    return tr_handshakeDone( handshake, true );
+    return tr_handshakeDone (handshake, true);
 }
 
 /***
@@ -994,180 +993,180 @@ readPayloadStream( tr_handshake    * handshake,
 ***/
 
 static ReadState
-canRead( struct tr_peerIo * io, void * arg, size_t * piece )
+canRead (struct tr_peerIo * io, void * arg, size_t * piece)
 {
     tr_handshake    * handshake = arg;
-    struct evbuffer * inbuf = tr_peerIoGetReadBuffer( io );
+    struct evbuffer * inbuf = tr_peerIoGetReadBuffer (io);
     ReadState         ret;
     bool              readyForMore = true;
 
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
     /* no piece data in handshake */
     *piece = 0;
 
-    dbgmsg( handshake, "handling canRead; state is [%s]",
-           getStateName( handshake->state ) );
+    dbgmsg (handshake, "handling canRead; state is [%s]",
+           getStateName (handshake->state));
 
-    while( readyForMore )
+    while (readyForMore)
     {
-        switch( handshake->state )
+        switch (handshake->state)
         {
             case AWAITING_HANDSHAKE:
-                ret = readHandshake    ( handshake, inbuf ); break;
+                ret = readHandshake  (handshake, inbuf); break;
 
             case AWAITING_PEER_ID:
-                ret = readPeerId       ( handshake, inbuf ); break;
+                ret = readPeerId     (handshake, inbuf); break;
 
             case AWAITING_YA:
-                ret = readYa           ( handshake, inbuf ); break;
+                ret = readYa         (handshake, inbuf); break;
 
             case AWAITING_PAD_A:
-                ret = readPadA         ( handshake, inbuf ); break;
+                ret = readPadA       (handshake, inbuf); break;
 
             case AWAITING_CRYPTO_PROVIDE:
-                ret = readCryptoProvide( handshake, inbuf ); break;
+                ret = readCryptoProvide (handshake, inbuf); break;
 
             case AWAITING_PAD_C:
-                ret = readPadC         ( handshake, inbuf ); break;
+                ret = readPadC       (handshake, inbuf); break;
 
             case AWAITING_IA:
-                ret = readIA           ( handshake, inbuf ); break;
+                ret = readIA         (handshake, inbuf); break;
 
             case AWAITING_PAYLOAD_STREAM:
-                ret = readPayloadStream( handshake, inbuf ); break;
+                ret = readPayloadStream (handshake, inbuf); break;
 
             case AWAITING_YB:
-                ret = readYb           ( handshake, inbuf ); break;
+                ret = readYb         (handshake, inbuf); break;
 
             case AWAITING_VC:
-                ret = readVC           ( handshake, inbuf ); break;
+                ret = readVC         (handshake, inbuf); break;
 
             case AWAITING_CRYPTO_SELECT:
-                ret = readCryptoSelect ( handshake, inbuf ); break;
+                ret = readCryptoSelect (handshake, inbuf); break;
 
             case AWAITING_PAD_D:
-                ret = readPadD         ( handshake, inbuf ); break;
+                ret = readPadD       (handshake, inbuf); break;
 
             default:
-                assert( 0 );
+                assert (0);
         }
 
-        if( ret != READ_NOW )
+        if (ret != READ_NOW)
             readyForMore = false;
-        else if( handshake->state == AWAITING_PAD_C )
-            readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_c_len;
-        else if( handshake->state == AWAITING_PAD_D )
-            readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_d_len;
-        else if( handshake->state == AWAITING_IA )
-            readyForMore = evbuffer_get_length( inbuf ) >= handshake->ia_len;
+        else if (handshake->state == AWAITING_PAD_C)
+            readyForMore = evbuffer_get_length (inbuf) >= handshake->pad_c_len;
+        else if (handshake->state == AWAITING_PAD_D)
+            readyForMore = evbuffer_get_length (inbuf) >= handshake->pad_d_len;
+        else if (handshake->state == AWAITING_IA)
+            readyForMore = evbuffer_get_length (inbuf) >= handshake->ia_len;
     }
 
     return ret;
 }
 
 static bool
-fireDoneFunc( tr_handshake * handshake, bool isConnected )
+fireDoneFunc (tr_handshake * handshake, bool isConnected)
 {
     const uint8_t * peer_id = isConnected && handshake->havePeerID
-                            ? tr_peerIoGetPeersId( handshake->io )
+                            ? tr_peerIoGetPeersId (handshake->io)
                             : NULL;
-    const bool success = ( *handshake->doneCB )( handshake,
+    const bool success = (*handshake->doneCB)(handshake,
                                                  handshake->io,
                                                  handshake->haveReadAnythingFromPeer,
                                                  isConnected,
                                                  peer_id,
-                                                 handshake->doneUserData );
+                                                 handshake->doneUserData);
 
     return success;
 }
 
 static void
-tr_handshakeFree( tr_handshake * handshake )
+tr_handshakeFree (tr_handshake * handshake)
 {
-    if( handshake->io )
-        tr_peerIoUnref( handshake->io ); /* balanced by the ref in tr_handshakeNew */
+    if (handshake->io)
+        tr_peerIoUnref (handshake->io); /* balanced by the ref in tr_handshakeNew */
 
-    event_free( handshake->timeout_timer );
-    tr_free( handshake );
+    event_free (handshake->timeout_timer);
+    tr_free (handshake);
 }
 
 static int
-tr_handshakeDone( tr_handshake * handshake, bool isOK )
+tr_handshakeDone (tr_handshake * handshake, bool isOK)
 {
     bool success;
 
-    dbgmsg( handshake, "handshakeDone: %s", isOK ? "connected" : "aborting" );
-    tr_peerIoSetIOFuncs( handshake->io, NULL, NULL, NULL, NULL );
+    dbgmsg (handshake, "handshakeDone: %s", isOK ? "connected" : "aborting");
+    tr_peerIoSetIOFuncs (handshake->io, NULL, NULL, NULL, NULL);
 
-    success = fireDoneFunc( handshake, isOK );
+    success = fireDoneFunc (handshake, isOK);
 
-    tr_handshakeFree( handshake );
+    tr_handshakeFree (handshake);
 
     return success ? READ_LATER : READ_ERR;
 }
 
 void
-tr_handshakeAbort( tr_handshake * handshake )
+tr_handshakeAbort (tr_handshake * handshake)
 {
-    if( handshake != NULL )
-        tr_handshakeDone( handshake, false );
+    if (handshake != NULL)
+        tr_handshakeDone (handshake, false);
 }
 
 static void
-gotError( tr_peerIo  * io,
+gotError (tr_peerIo  * io,
           short        what,
-          void       * vhandshake )
+          void       * vhandshake)
 {
     int errcode = errno;
     tr_handshake * handshake = vhandshake;
 
-    if( io->utp_socket && !io->isIncoming && handshake->state == AWAITING_YB ) {
+    if (io->utp_socket && !io->isIncoming && handshake->state == AWAITING_YB) {
         /* This peer probably doesn't speak uTP. */
         tr_torrent *tor =
-            tr_peerIoHasTorrentHash( io ) ?
-            tr_torrentFindFromHash( handshake->session,
-                                    tr_peerIoGetTorrentHash( io ) ) :
+            tr_peerIoHasTorrentHash (io) ?
+            tr_torrentFindFromHash (handshake->session,
+                                    tr_peerIoGetTorrentHash (io)) :
             NULL;
         /* Don't mark a peer as non-uTP unless it's really a connect failure. */
-        if( tor && ( errcode == ETIMEDOUT || errcode == ECONNREFUSED ) ) {
-            tr_torrentLock( tor );
-            tr_peerMgrSetUtpFailed( tor,
-                                    tr_peerIoGetAddress( io, NULL ),
-                                    true );
-            tr_torrentUnlock( tor );
+        if (tor && (errcode == ETIMEDOUT || errcode == ECONNREFUSED)) {
+            tr_torrentLock (tor);
+            tr_peerMgrSetUtpFailed (tor,
+                                    tr_peerIoGetAddress (io, NULL),
+                                    true);
+            tr_torrentUnlock (tor);
         }
 
-        if( !tr_peerIoReconnect( handshake->io ) ) {
+        if (!tr_peerIoReconnect (handshake->io)) {
             uint8_t msg[HANDSHAKE_SIZE];
-            buildHandshakeMessage( handshake, msg );
+            buildHandshakeMessage (handshake, msg);
             handshake->haveSentBitTorrentHandshake = 1;
-            setReadState( handshake, AWAITING_HANDSHAKE );
-            tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), false );
+            setReadState (handshake, AWAITING_HANDSHAKE);
+            tr_peerIoWriteBytes (handshake->io, msg, sizeof (msg), false);
         }
     }
 
     /* if the error happened while we were sending a public key, we might
      * have encountered a peer that doesn't do encryption... reconnect and
      * try a plaintext handshake */
-    if( ( ( handshake->state == AWAITING_YB )
-        || ( handshake->state == AWAITING_VC ) )
-      && ( handshake->encryptionMode != TR_ENCRYPTION_REQUIRED )
-      && ( !tr_peerIoReconnect( handshake->io ) ) )
+    if (((handshake->state == AWAITING_YB)
+        || (handshake->state == AWAITING_VC))
+      && (handshake->encryptionMode != TR_ENCRYPTION_REQUIRED)
+      && (!tr_peerIoReconnect (handshake->io)))
     {
         uint8_t msg[HANDSHAKE_SIZE];
 
-        dbgmsg( handshake, "handshake failed, trying plaintext..." );
-        buildHandshakeMessage( handshake, msg );
+        dbgmsg (handshake, "handshake failed, trying plaintext...");
+        buildHandshakeMessage (handshake, msg);
         handshake->haveSentBitTorrentHandshake = 1;
-        setReadState( handshake, AWAITING_HANDSHAKE );
-        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), false );
+        setReadState (handshake, AWAITING_HANDSHAKE);
+        tr_peerIoWriteBytes (handshake->io, msg, sizeof (msg), false);
     }
     else
     {
-        dbgmsg( handshake, "libevent got an error what==%d, errno=%d (%s)",
-               (int)what, errno, tr_strerror( errno ) );
-        tr_handshakeDone( handshake, false );
+        dbgmsg (handshake, "libevent got an error what==%d, errno=%d (%s)",
+             (int)what, errno, tr_strerror (errno));
+        tr_handshakeDone (handshake, false);
     }
 }
 
@@ -1176,67 +1175,67 @@ gotError( tr_peerIo  * io,
 **/
 
 static void
-handshakeTimeout( int foo UNUSED, short bar UNUSED, void * handshake )
+handshakeTimeout (int foo UNUSED, short bar UNUSED, void * handshake)
 {
-    tr_handshakeAbort( handshake );
+    tr_handshakeAbort (handshake);
 }
 
 tr_handshake*
-tr_handshakeNew( tr_peerIo           * io,
+tr_handshakeNew (tr_peerIo           * io,
                  tr_encryption_mode    encryptionMode,
                  handshakeDoneCB       doneCB,
-                 void                * doneUserData )
+                 void                * doneUserData)
 {
     tr_handshake * handshake;
-    tr_session * session = tr_peerIoGetSession( io );
+    tr_session * session = tr_peerIoGetSession (io);
 
-    handshake = tr_new0( tr_handshake, 1 );
+    handshake = tr_new0 (tr_handshake, 1);
     handshake->io = io;
-    handshake->crypto = tr_peerIoGetCrypto( io );
+    handshake->crypto = tr_peerIoGetCrypto (io);
     handshake->encryptionMode = encryptionMode;
     handshake->doneCB = doneCB;
     handshake->doneUserData = doneUserData;
     handshake->session = session;
-    handshake->timeout_timer = evtimer_new( session->event_base, handshakeTimeout, handshake );
-    tr_timerAdd( handshake->timeout_timer, HANDSHAKE_TIMEOUT_SEC, 0 );
+    handshake->timeout_timer = evtimer_new (session->event_base, handshakeTimeout, handshake);
+    tr_timerAdd (handshake->timeout_timer, HANDSHAKE_TIMEOUT_SEC, 0);
 
-    tr_peerIoRef( io ); /* balanced by the unref in tr_handshakeFree */
-    tr_peerIoSetIOFuncs( handshake->io, canRead, NULL, gotError, handshake );
-    tr_peerIoSetEncryption( io, PEER_ENCRYPTION_NONE );
+    tr_peerIoRef (io); /* balanced by the unref in tr_handshakeFree */
+    tr_peerIoSetIOFuncs (handshake->io, canRead, NULL, gotError, handshake);
+    tr_peerIoSetEncryption (io, PEER_ENCRYPTION_NONE);
 
-    if( tr_peerIoIsIncoming( handshake->io ) )
-        setReadState( handshake, AWAITING_HANDSHAKE );
-    else if( encryptionMode != TR_CLEAR_PREFERRED )
-        sendYa( handshake );
+    if (tr_peerIoIsIncoming (handshake->io))
+        setReadState (handshake, AWAITING_HANDSHAKE);
+    else if (encryptionMode != TR_CLEAR_PREFERRED)
+        sendYa (handshake);
     else
     {
         uint8_t msg[HANDSHAKE_SIZE];
-        buildHandshakeMessage( handshake, msg );
+        buildHandshakeMessage (handshake, msg);
 
         handshake->haveSentBitTorrentHandshake = 1;
-        setReadState( handshake, AWAITING_HANDSHAKE );
-        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), false );
+        setReadState (handshake, AWAITING_HANDSHAKE);
+        tr_peerIoWriteBytes (handshake->io, msg, sizeof (msg), false);
     }
 
     return handshake;
 }
 
 struct tr_peerIo*
-tr_handshakeGetIO( tr_handshake * handshake )
+tr_handshakeGetIO (tr_handshake * handshake)
 {
-    assert( handshake );
-    assert( handshake->io );
+    assert (handshake);
+    assert (handshake->io);
 
     return handshake->io;
 }
 
 struct tr_peerIo*
-tr_handshakeStealIO( tr_handshake * handshake )
+tr_handshakeStealIO (tr_handshake * handshake)
 {
     struct tr_peerIo * io;
 
-    assert( handshake );
-    assert( handshake->io );
+    assert (handshake);
+    assert (handshake->io);
 
     io = handshake->io;
     handshake->io = NULL;
@@ -1244,12 +1243,12 @@ tr_handshakeStealIO( tr_handshake * handshake )
 }
 
 const tr_address *
-tr_handshakeGetAddr( const struct tr_handshake * handshake,
-                     tr_port                   * port )
+tr_handshakeGetAddr (const struct tr_handshake * handshake,
+                     tr_port                   * port)
 {
-    assert( handshake );
-    assert( handshake->io );
+    assert (handshake);
+    assert (handshake->io);
 
-    return tr_peerIoGetAddress( handshake->io, port );
+    return tr_peerIoGetAddress (handshake->io, port);
 }
 
diff --git a/libtransmission/handshake.h b/libtransmission/handshake.h
index 0ca013472..8d4e85459 100644
--- a/libtransmission/handshake.h
+++ b/libtransmission/handshake.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -30,27 +30,27 @@ struct tr_peerIo;
 typedef struct tr_handshake tr_handshake;
 
 /* returns true on success, false on error */
-typedef bool ( *handshakeDoneCB )( struct tr_handshake * handshake,
+typedef bool (*handshakeDoneCB)(struct tr_handshake * handshake,
                                    struct tr_peerIo    * io,
                                    bool                  readAnythingFromPeer,
                                    bool                  isConnected,
                                    const uint8_t       * peerId,
-                                   void                * userData );
+                                   void                * userData);
 
 /** @brief instantiate a new handshake */
-tr_handshake *         tr_handshakeNew( struct tr_peerIo * io,
+tr_handshake *         tr_handshakeNew (struct tr_peerIo * io,
                                         tr_encryption_mode encryptionMode,
                                         handshakeDoneCB    doneCB,
-                                        void *             doneUserData );
+                                        void *             doneUserData);
 
-const tr_address *     tr_handshakeGetAddr( const struct tr_handshake  * handshake,
-                                            tr_port                    * port );
+const tr_address *     tr_handshakeGetAddr (const struct tr_handshake  * handshake,
+                                            tr_port                    * port);
 
-void                   tr_handshakeAbort( tr_handshake * handshake );
+void                   tr_handshakeAbort (tr_handshake * handshake);
 
-struct tr_peerIo*      tr_handshakeGetIO( tr_handshake * handshake );
+struct tr_peerIo*      tr_handshakeGetIO (tr_handshake * handshake);
 
-struct tr_peerIo*      tr_handshakeStealIO( tr_handshake * handshake );
+struct tr_peerIo*      tr_handshakeStealIO (tr_handshake * handshake);
 
 
 /** @} */
diff --git a/libtransmission/history-test.c b/libtransmission/history-test.c
index b4cd59f47..08a96be1b 100644
--- a/libtransmission/history-test.c
+++ b/libtransmission/history-test.c
@@ -1,4 +1,4 @@
-#include <string.h> /* memset() */
+#include <string.h> /* memset () */
 
 #include "transmission.h"
 #include "history.h"
@@ -7,23 +7,23 @@
 #include "libtransmission-test.h"
 
 static int
-test1( void )
+test1 (void)
 {
     tr_recentHistory h;
 
-    memset( &h, 0, sizeof( tr_recentHistory ) );
+    memset (&h, 0, sizeof (tr_recentHistory));
 
-    tr_historyAdd( &h, 10000, 1 );
-    check_int_eq( 0, (int)tr_historyGet( &h, 12000, 1000 ) );
-    check_int_eq( 1, (int)tr_historyGet( &h, 12000, 3000 ) );
-    check_int_eq( 1, (int)tr_historyGet( &h, 12000, 5000 ) );
-    tr_historyAdd( &h, 20000, 1 );
-    check_int_eq( 0, (int)tr_historyGet( &h, 22000,  1000 ) );
-    check_int_eq( 1, (int)tr_historyGet( &h, 22000,  3000 ) );
-    check_int_eq( 2, (int)tr_historyGet( &h, 22000, 15000 ) );
-    check_int_eq( 2, (int)tr_historyGet( &h, 22000, 20000 ) );
+    tr_historyAdd (&h, 10000, 1);
+    check_int_eq (0, (int)tr_historyGet (&h, 12000, 1000));
+    check_int_eq (1, (int)tr_historyGet (&h, 12000, 3000));
+    check_int_eq (1, (int)tr_historyGet (&h, 12000, 5000));
+    tr_historyAdd (&h, 20000, 1);
+    check_int_eq (0, (int)tr_historyGet (&h, 22000,  1000));
+    check_int_eq (1, (int)tr_historyGet (&h, 22000,  3000));
+    check_int_eq (2, (int)tr_historyGet (&h, 22000, 15000));
+    check_int_eq (2, (int)tr_historyGet (&h, 22000, 20000));
 
     return 0;
 }
 
-MAIN_SINGLE_TEST(test1)
+MAIN_SINGLE_TEST (test1)
diff --git a/libtransmission/history.c b/libtransmission/history.c
index 187df81d5..0f4d6f761 100644
--- a/libtransmission/history.c
+++ b/libtransmission/history.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,41 +11,48 @@
  */
 
 #include <assert.h>
-#include <string.h> /* memset() */
+#include <string.h> /* memset () */
 
 #include "transmission.h"
 #include "history.h"
 #include "utils.h"
 
 void
-tr_historyAdd( tr_recentHistory * h, time_t now, unsigned int n )
+tr_historyAdd (tr_recentHistory * h, time_t now, unsigned int n)
 {
-    if( h->slices[h->newest].date == now )
-        h->slices[h->newest].n += n;
-    else {
-        if( ++h->newest == TR_RECENT_HISTORY_PERIOD_SEC ) h->newest = 0;
-        h->slices[h->newest].date = now;
-        h->slices[h->newest].n = n;
+  if (h->slices[h->newest].date == now)
+    {
+      h->slices[h->newest].n += n;
+    }
+  else
+    {
+      if (++h->newest == TR_RECENT_HISTORY_PERIOD_SEC)
+        h->newest = 0;
+      h->slices[h->newest].date = now;
+      h->slices[h->newest].n = n;
     }
 }
 
 unsigned int
-tr_historyGet( const tr_recentHistory * h, time_t now, unsigned int sec )
+tr_historyGet (const tr_recentHistory * h, time_t now, unsigned int sec)
 {
-    unsigned int n = 0;
-    const time_t cutoff = (now?now:tr_time()) - sec;
-    int i = h->newest;
+  unsigned int n = 0;
+  const time_t cutoff = (now?now:tr_time ()) - sec;
+  int i = h->newest;
 
-    for( ;; )
+  for (;;)
     {
-        if( h->slices[i].date <= cutoff )
-            break;
+      if (h->slices[i].date <= cutoff)
+        break;
+
+      n += h->slices[i].n;
 
-        n += h->slices[i].n;
+      if (--i == -1)
+        i = TR_RECENT_HISTORY_PERIOD_SEC - 1; /* circular history */
 
-        if( --i == -1 ) i = TR_RECENT_HISTORY_PERIOD_SEC - 1; /* circular history */
-        if( i == h->newest ) break; /* we've come all the way around */
+      if (i == h->newest)
+        break; /* we've come all the way around */
     }
 
-    return n;
+  return n;
 }
diff --git a/libtransmission/history.h b/libtransmission/history.h
index cb0870400..0f26c626e 100644
--- a/libtransmission/history.h
+++ b/libtransmission/history.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -27,36 +27,36 @@
 
 enum
 {
-    TR_RECENT_HISTORY_PERIOD_SEC = 60
+  TR_RECENT_HISTORY_PERIOD_SEC = 60
 };
 
 
 typedef struct tr_recentHistory
 {
-    /* these are PRIVATE IMPLEMENTATION details included for composition only.
-     * Don't access these directly! */
+  /* these are PRIVATE IMPLEMENTATION details included for composition only.
+   * Don't access these directly! */
 
-    int newest;
+  int newest;
 
-    struct {
-        unsigned int n;
-        time_t date;
-    } slices[TR_RECENT_HISTORY_PERIOD_SEC];
+  struct {
+    unsigned int n;
+    time_t date;
+  } slices[TR_RECENT_HISTORY_PERIOD_SEC];
 }
 tr_recentHistory;
 
 /**
  * @brief add a counter to the recent history object.
- * @param when the current time in sec, such as from tr_time()
+ * @param when the current time in sec, such as from tr_time ()
  * @param n how many items to add to the history's counter
  */
-void tr_historyAdd( tr_recentHistory *, time_t when, unsigned int n );
+void tr_historyAdd (tr_recentHistory *, time_t when, unsigned int n);
 
 /**
  * @brief count how many events have occurred in the last N seconds.
- * @param when the current time in sec, such as from tr_time()
+ * @param when the current time in sec, such as from tr_time ()
  * @param seconds how many seconds to count back through.
  */
-unsigned int tr_historyGet( const tr_recentHistory *, time_t when, unsigned int seconds );
+unsigned int tr_historyGet (const tr_recentHistory *, time_t when, unsigned int seconds);
 
 #endif
diff --git a/libtransmission/inout.c b/libtransmission/inout.c
index ab51d2089..d534cbc2d 100644
--- a/libtransmission/inout.c
+++ b/libtransmission/inout.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -12,17 +12,17 @@
 
 #include <assert.h>
 #include <errno.h>
-#include <stdlib.h> /* bsearch() */
-#include <string.h> /* memcmp() */
+#include <stdlib.h> /* bsearch () */
+#include <string.h> /* memcmp () */
 
 #include <openssl/sha.h>
 
 #include "transmission.h"
-#include "cache.h" /* tr_cacheReadBlock() */
+#include "cache.h" /* tr_cacheReadBlock () */
 #include "fdlimit.h"
 #include "inout.h"
 #include "peer-common.h" /* MAX_BLOCK_SIZE */
-#include "stats.h" /* tr_statsFileCreated() */
+#include "stats.h" /* tr_statsFileCreated () */
 #include "torrent.h"
 #include "utils.h"
 
@@ -30,227 +30,238 @@
 *****  Low-level IO functions
 ****/
 
-enum { TR_IO_READ, TR_IO_PREFETCH,
-       /* Any operations that require write access must follow TR_IO_WRITE. */
-       TR_IO_WRITE
+enum
+{
+  TR_IO_READ,
+  TR_IO_PREFETCH,
+  /* Any operations that require write access must follow TR_IO_WRITE. */
+  TR_IO_WRITE
 };
 
 /* returns 0 on success, or an errno on failure */
 static int
-readOrWriteBytes( tr_session       * session,
+readOrWriteBytes (tr_session       * session,
                   tr_torrent       * tor,
                   int                ioMode,
                   tr_file_index_t    fileIndex,
                   uint64_t           fileOffset,
                   void             * buf,
-                  size_t             buflen )
+                  size_t             buflen)
 {
-    int fd;
-    int err = 0;
-    const bool doWrite = ioMode >= TR_IO_WRITE;
-    const tr_info * const info = &tor->info;
-    const tr_file * const file = &info->files[fileIndex];
+  int fd;
+  int err = 0;
+  const bool doWrite = ioMode >= TR_IO_WRITE;
+  const tr_info * const info = &tor->info;
+  const tr_file * const file = &info->files[fileIndex];
 
-    assert( fileIndex < info->fileCount );
-    assert( !file->length || ( fileOffset < file->length ) );
-    assert( fileOffset + buflen <= file->length );
+  assert (fileIndex < info->fileCount);
+  assert (!file->length || (fileOffset < file->length));
+  assert (fileOffset + buflen <= file->length);
 
-    if( !file->length )
-        return 0;
+  if (!file->length)
+    return 0;
 
-    /***
-    ****  Find the fd
-    ***/
+  /***
+  ****  Find the fd
+  ***/
 
-    fd = tr_fdFileGetCached( session, tr_torrentId( tor ), fileIndex, doWrite );
-    if( fd < 0 )
+  fd = tr_fdFileGetCached (session, tr_torrentId (tor), fileIndex, doWrite);
+  if (fd < 0)
     {
-        /* it's not cached, so open/create it now */
-        char * subpath;
-        const char * base;
+      /* it's not cached, so open/create it now */
+      char * subpath;
+      const char * base;
 
-        /* see if the file exists... */
-        if( !tr_torrentFindFile2( tor, fileIndex, &base, &subpath, NULL ) )
+      /* see if the file exists... */
+      if (!tr_torrentFindFile2 (tor, fileIndex, &base, &subpath, NULL))
         {
-            /* we can't read a file that doesn't exist... */
-            if( !doWrite )
-                err = ENOENT;
+          /* we can't read a file that doesn't exist... */
+          if (!doWrite)
+            err = ENOENT;
 
-            /* figure out where the file should go, so we can create it */
-            base = tr_torrentGetCurrentDir( tor );
-            subpath = tr_sessionIsIncompleteFileNamingEnabled( tor->session )
-                    ? tr_torrentBuildPartial( tor, fileIndex )
-                    : tr_strdup( file->name );
+          /* figure out where the file should go, so we can create it */
+          base = tr_torrentGetCurrentDir (tor);
+          subpath = tr_sessionIsIncompleteFileNamingEnabled (tor->session)
+                  ? tr_torrentBuildPartial (tor, fileIndex)
+                  : tr_strdup (file->name);
 
         }
 
-        if( !err )
+      if (!err)
         {
-            /* open (and maybe create) the file */
-            char * filename = tr_buildPath( base, subpath, NULL );
-            const int prealloc = file->dnd || !doWrite
-                               ? TR_PREALLOCATE_NONE
-                               : tor->session->preallocationMode;
-            if((( fd = tr_fdFileCheckout( session, tor->uniqueId, fileIndex,
-                                          filename, doWrite,
-                                          prealloc, file->length ))) < 0 )
+          /* open (and maybe create) the file */
+          char * filename = tr_buildPath (base, subpath, NULL);
+          const int prealloc = file->dnd || !doWrite
+                             ? TR_PREALLOCATE_NONE
+                             : tor->session->preallocationMode;
+          if (((fd = tr_fdFileCheckout (session, tor->uniqueId, fileIndex,
+                                        filename, doWrite,
+                                        prealloc, file->length))) < 0)
             {
-                err = errno;
-                tr_torerr( tor, "tr_fdFileCheckout failed for \"%s\": %s",
-                           filename, tr_strerror( err ) );
+              err = errno;
+              tr_torerr (tor, "tr_fdFileCheckout failed for \"%s\": %s",
+                         filename, tr_strerror (err));
             }
-            else if( doWrite )
+          else if (doWrite)
             {
-                /* make a note that we just created a file */
-                tr_statsFileCreated( tor->session );
+              /* make a note that we just created a file */
+              tr_statsFileCreated (tor->session);
             }
 
-            tr_free( filename );
+          tr_free (filename);
         }
 
-        tr_free( subpath );
+      tr_free (subpath);
     }
 
-    /***
-    ****  Use the fd
-    ***/
+  /***
+  ****  Use the fd
+  ***/
 
-    if( !err )
+  if (!err)
     {
-        if( ioMode == TR_IO_READ ) {
-            const int rc = tr_pread( fd, buf, buflen, fileOffset );
-            if( rc < 0 ) {
-                err = errno;
-                tr_torerr( tor, "read failed for \"%s\": %s",
-                           file->name, tr_strerror( err ) );
+      if (ioMode == TR_IO_READ)
+        {
+          const int rc = tr_pread (fd, buf, buflen, fileOffset);
+          if (rc < 0)
+            {
+              err = errno;
+              tr_torerr (tor, "read failed for \"%s\": %s", file->name, tr_strerror (err));
             }
-        } else if( ioMode == TR_IO_WRITE ) {
-            const int rc = tr_pwrite( fd, buf, buflen, fileOffset );
-            if( rc < 0 ) {
-                err = errno;
-                tr_torerr( tor, "write failed for \"%s\": %s",
-                           file->name, tr_strerror( err ) );
+        }
+      else if (ioMode == TR_IO_WRITE)
+        {
+          const int rc = tr_pwrite (fd, buf, buflen, fileOffset);
+          if (rc < 0)
+            {
+              err = errno;
+              tr_torerr (tor, "write failed for \"%s\": %s", file->name, tr_strerror (err));
             }
-        } else if( ioMode == TR_IO_PREFETCH ) {
-            tr_prefetch( fd, fileOffset, buflen );
-        } else {
-            abort();
+        }
+      else if (ioMode == TR_IO_PREFETCH)
+        {
+          tr_prefetch (fd, fileOffset, buflen);
+        }
+      else
+        {
+          abort ();
         }
     }
 
-    return err;
+  return err;
 }
 
 static int
-compareOffsetToFile( const void * a, const void * b )
+compareOffsetToFile (const void * a, const void * b)
 {
-    const uint64_t  offset = *(const uint64_t*)a;
-    const tr_file * file = b;
+  const uint64_t  offset = * (const uint64_t*)a;
+  const tr_file * file = b;
 
-    if( offset < file->offset ) return -1;
-    if( offset >= file->offset + file->length ) return 1;
-    return 0;
+  if (offset < file->offset)
+    return -1;
+
+  if (offset >= file->offset + file->length)
+    return 1;
+
+  return 0;
 }
 
 void
-tr_ioFindFileLocation( const tr_torrent * tor,
+tr_ioFindFileLocation (const tr_torrent * tor,
                        tr_piece_index_t   pieceIndex,
                        uint32_t           pieceOffset,
                        tr_file_index_t  * fileIndex,
-                       uint64_t         * fileOffset )
+                       uint64_t         * fileOffset)
 {
-    const uint64_t  offset = tr_pieceOffset( tor, pieceIndex, pieceOffset, 0 );
-    const tr_file * file;
+  const uint64_t  offset = tr_pieceOffset (tor, pieceIndex, pieceOffset, 0);
+  const tr_file * file;
 
-    assert( tr_isTorrent( tor ) );
-    assert( offset < tor->info.totalSize );
+  assert (tr_isTorrent (tor));
+  assert (offset < tor->info.totalSize);
 
-    file = bsearch( &offset,
-                    tor->info.files, tor->info.fileCount, sizeof( tr_file ),
-                    compareOffsetToFile );
+  file = bsearch (&offset,
+                  tor->info.files, tor->info.fileCount, sizeof (tr_file),
+                  compareOffsetToFile);
 
-    assert( file != NULL );
+  assert (file != NULL);
 
-    *fileIndex = file - tor->info.files;
-    *fileOffset = offset - file->offset;
+  *fileIndex = file - tor->info.files;
+  *fileOffset = offset - file->offset;
 
-    assert( *fileIndex < tor->info.fileCount );
-    assert( *fileOffset < file->length );
-    assert( tor->info.files[*fileIndex].offset + *fileOffset == offset );
+  assert (*fileIndex < tor->info.fileCount);
+  assert (*fileOffset < file->length);
+  assert (tor->info.files[*fileIndex].offset + *fileOffset == offset);
 }
 
 /* returns 0 on success, or an errno on failure */
 static int
-readOrWritePiece( tr_torrent       * tor,
+readOrWritePiece (tr_torrent       * tor,
                   int                ioMode,
                   tr_piece_index_t   pieceIndex,
                   uint32_t           pieceOffset,
                   uint8_t          * buf,
-                  size_t             buflen )
+                  size_t             buflen)
 {
-    int             err = 0;
-    tr_file_index_t fileIndex;
-    uint64_t        fileOffset;
-    const tr_info * info = &tor->info;
+  int err = 0;
+  tr_file_index_t fileIndex;
+  uint64_t fileOffset;
+  const tr_info * info = &tor->info;
 
-    if( pieceIndex >= tor->info.pieceCount )
-        return EINVAL;
+  if (pieceIndex >= tor->info.pieceCount)
+    return EINVAL;
 
-    tr_ioFindFileLocation( tor, pieceIndex, pieceOffset,
-                           &fileIndex, &fileOffset );
+  tr_ioFindFileLocation (tor, pieceIndex, pieceOffset,
+                         &fileIndex, &fileOffset);
 
-    while( buflen && !err )
+  while (buflen && !err)
     {
-        const tr_file * file = &info->files[fileIndex];
-        const uint64_t bytesThisPass = MIN( buflen, file->length - fileOffset );
+      const tr_file * file = &info->files[fileIndex];
+      const uint64_t bytesThisPass = MIN (buflen, file->length - fileOffset);
 
-        err = readOrWriteBytes( tor->session, tor, ioMode, fileIndex, fileOffset, buf, bytesThisPass );
-        buf += bytesThisPass;
-        buflen -= bytesThisPass;
-        ++fileIndex;
-        fileOffset = 0;
+      err = readOrWriteBytes (tor->session, tor, ioMode, fileIndex, fileOffset, buf, bytesThisPass);
+      buf += bytesThisPass;
+      buflen -= bytesThisPass;
+      fileIndex++;
+      fileOffset = 0;
 
-        if( ( err != 0 ) && (ioMode == TR_IO_WRITE ) && ( tor->error != TR_STAT_LOCAL_ERROR ) )
+      if ((err != 0) && (ioMode == TR_IO_WRITE) && (tor->error != TR_STAT_LOCAL_ERROR))
         {
-            char * path = tr_buildPath( tor->downloadDir, file->name, NULL );
-            tr_torrentSetLocalError( tor, "%s (%s)", tr_strerror( err ), path );
-            tr_free( path );
+          char * path = tr_buildPath (tor->downloadDir, file->name, NULL);
+          tr_torrentSetLocalError (tor, "%s (%s)", tr_strerror (err), path);
+          tr_free (path);
         }
     }
 
-    return err;
+  return err;
 }
 
 int
-tr_ioRead( tr_torrent       * tor,
+tr_ioRead (tr_torrent       * tor,
            tr_piece_index_t   pieceIndex,
            uint32_t           begin,
            uint32_t           len,
-           uint8_t          * buf )
+           uint8_t          * buf)
 {
-    return readOrWritePiece( tor, TR_IO_READ, pieceIndex, begin, buf, len );
+  return readOrWritePiece (tor, TR_IO_READ, pieceIndex, begin, buf, len);
 }
 
 int
-tr_ioPrefetch( tr_torrent       * tor,
+tr_ioPrefetch (tr_torrent       * tor,
                tr_piece_index_t   pieceIndex,
                uint32_t           begin,
                uint32_t           len)
 {
-    return readOrWritePiece( tor, TR_IO_PREFETCH, pieceIndex, begin,
-                             NULL, len );
+  return readOrWritePiece (tor, TR_IO_PREFETCH, pieceIndex, begin, NULL, len);
 }
 
 int
-tr_ioWrite( tr_torrent       * tor,
+tr_ioWrite (tr_torrent       * tor,
             tr_piece_index_t   pieceIndex,
             uint32_t           begin,
             uint32_t           len,
-            const uint8_t    * buf )
+            const uint8_t    * buf)
 {
-    return readOrWritePiece( tor, TR_IO_WRITE, pieceIndex, begin,
-                             (uint8_t*)buf,
-                             len );
+  return readOrWritePiece (tor, TR_IO_WRITE, pieceIndex, begin, (uint8_t*)buf, len);
 }
 
 /****
@@ -258,49 +269,49 @@ tr_ioWrite( tr_torrent       * tor,
 ****/
 
 static bool
-recalculateHash( tr_torrent * tor, tr_piece_index_t pieceIndex, uint8_t * setme )
+recalculateHash (tr_torrent * tor, tr_piece_index_t pieceIndex, uint8_t * setme)
 {
-    size_t   bytesLeft;
-    uint32_t offset = 0;
-    bool  success = true;
-    const size_t buflen = tor->blockSize;
-    void * buffer = tr_valloc( buflen );
-    SHA_CTX  sha;
+  size_t   bytesLeft;
+  uint32_t offset = 0;
+  bool  success = true;
+  const size_t buflen = tor->blockSize;
+  void * buffer = tr_valloc (buflen);
+  SHA_CTX  sha;
 
-    assert( tor != NULL );
-    assert( pieceIndex < tor->info.pieceCount );
-    assert( buffer != NULL );
-    assert( buflen > 0 );
-    assert( setme != NULL );
+  assert (tor != NULL);
+  assert (pieceIndex < tor->info.pieceCount);
+  assert (buffer != NULL);
+  assert (buflen > 0);
+  assert (setme != NULL);
 
-    SHA1_Init( &sha );
-    bytesLeft = tr_torPieceCountBytes( tor, pieceIndex );
+  SHA1_Init (&sha);
+  bytesLeft = tr_torPieceCountBytes (tor, pieceIndex);
 
-    tr_ioPrefetch( tor, pieceIndex, offset, bytesLeft );
+  tr_ioPrefetch (tor, pieceIndex, offset, bytesLeft);
 
-    while( bytesLeft )
+  while (bytesLeft)
     {
-        const int len = MIN( bytesLeft, buflen );
-        success = !tr_cacheReadBlock( tor->session->cache, tor, pieceIndex, offset, len, buffer );
-        if( !success )
-            break;
-        SHA1_Update( &sha, buffer, len );
-        offset += len;
-        bytesLeft -= len;
+      const int len = MIN (bytesLeft, buflen);
+      success = !tr_cacheReadBlock (tor->session->cache, tor, pieceIndex, offset, len, buffer);
+      if (!success)
+        break;
+      SHA1_Update (&sha, buffer, len);
+      offset += len;
+      bytesLeft -= len;
     }
 
-    if( success )
-        SHA1_Final( setme, &sha );
+  if (success)
+    SHA1_Final (setme, &sha);
 
-    tr_free( buffer );
-    return success;
+  tr_free (buffer);
+  return success;
 }
 
 bool
-tr_ioTestPiece( tr_torrent * tor, tr_piece_index_t piece )
+tr_ioTestPiece (tr_torrent * tor, tr_piece_index_t piece)
 {
-    uint8_t hash[SHA_DIGEST_LENGTH];
+  uint8_t hash[SHA_DIGEST_LENGTH];
 
-    return recalculateHash( tor, piece, hash )
-           && !memcmp( hash, tor->info.pieces[piece].hash, SHA_DIGEST_LENGTH );
+  return recalculateHash (tor, piece, hash)
+      && !memcmp (hash, tor->info.pieces[piece].hash, SHA_DIGEST_LENGTH);
 }
diff --git a/libtransmission/inout.h b/libtransmission/inout.h
index 72ecc1520..59adbcc35 100644
--- a/libtransmission/inout.h
+++ b/libtransmission/inout.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -28,42 +28,42 @@ struct tr_torrent;
  * Reads the block specified by the piece index, offset, and length.
  * @return 0 on success, or an errno value on failure.
  */
-int tr_ioRead( struct tr_torrent   * tor,
+int tr_ioRead (struct tr_torrent   * tor,
                tr_piece_index_t      pieceIndex,
                uint32_t              offset,
                uint32_t              len,
-               uint8_t             * setme );
+               uint8_t             * setme);
 
-int tr_ioPrefetch( tr_torrent       * tor,
+int tr_ioPrefetch (tr_torrent       * tor,
                    tr_piece_index_t   pieceIndex,
                    uint32_t           begin,
-                   uint32_t           len );
+                   uint32_t           len);
 
 /**
  * Writes the block specified by the piece index, offset, and length.
  * @return 0 on success, or an errno value on failure.
  */
-int tr_ioWrite( struct tr_torrent  * tor,
+int tr_ioWrite (struct tr_torrent  * tor,
                 tr_piece_index_t     pieceIndex,
                 uint32_t             offset,
                 uint32_t             len,
-                const uint8_t      * writeme );
+                const uint8_t      * writeme);
 
 /**
  * @brief Test to see if the piece matches its metainfo's SHA1 checksum.
  */
-bool tr_ioTestPiece( tr_torrent       * tor,
-                     tr_piece_index_t   piece );
+bool tr_ioTestPiece (tr_torrent       * tor,
+                     tr_piece_index_t   piece);
 
 
 /**
  * Converts a piece index + offset into a file index + offset.
  */
-void tr_ioFindFileLocation( const tr_torrent  * tor,
+void tr_ioFindFileLocation (const tr_torrent  * tor,
                              tr_piece_index_t   pieceIndex,
                              uint32_t           pieceOffset,
                              tr_file_index_t  * fileIndex,
-                             uint64_t         * fileOffset );
+                             uint64_t         * fileOffset);
 
 
 /* @} */
diff --git a/libtransmission/json-test.c b/libtransmission/json-test.c
index 1a3672323..772de8bb5 100644
--- a/libtransmission/json-test.c
+++ b/libtransmission/json-test.c
@@ -1,4 +1,4 @@
-#include <string.h> /* strlen() */
+#include <string.h> /* strlen () */
 #include "transmission.h"
 #include "bencode.h"
 #include "json.h"
@@ -26,7 +26,7 @@ test_elements (void)
          "  \"false\": false, "
          "  \"null\": null }";
 
-    err = tr_jsonParse (NULL, in, strlen(in), &top, NULL);
+    err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
     check_int_eq (0, err);
     check (tr_bencIsDict (&top));
     str = NULL;
@@ -54,7 +54,7 @@ test_elements (void)
     return 0;
 }
 static int
-test_utf8( void )
+test_utf8 (void)
 {
     const char      * in = "{ \"key\": \"Letöltések\" }";
     tr_benc           top;
@@ -62,22 +62,22 @@ test_utf8( void )
     char            * json;
     int               err;
 
-    err = tr_jsonParse( NULL, in, strlen( in ), &top, NULL );
-    check( !err );
-    check( tr_bencIsDict( &top ) );
-    check( tr_bencDictFindStr( &top, "key", &str ) );
-    check_streq( "Letöltések", str );
-    if( !err )
-        tr_bencFree( &top );
+    err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
+    check (!err);
+    check (tr_bencIsDict (&top));
+    check (tr_bencDictFindStr (&top, "key", &str));
+    check_streq ("Letöltések", str);
+    if (!err)
+        tr_bencFree (&top);
 
     in = "{ \"key\": \"\\u005C\" }";
-    err = tr_jsonParse( NULL, in, strlen( in ), &top, NULL );
-    check( !err );
-    check( tr_bencIsDict( &top ) );
-    check( tr_bencDictFindStr( &top, "key", &str ) );
-    check_streq( "\\", str );
-    if( !err )
-        tr_bencFree( &top );
+    err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
+    check (!err);
+    check (tr_bencIsDict (&top));
+    check (tr_bencDictFindStr (&top, "key", &str));
+    check_streq ("\\", str);
+    if (!err)
+        tr_bencFree (&top);
 
     /**
      * 1. Feed it JSON-escaped nonascii to the JSON decoder.
@@ -88,31 +88,31 @@ test_utf8( void )
      * 6. Confirm that the result is UTF-8.
      */
     in = "{ \"key\": \"Let\\u00f6lt\\u00e9sek\" }";
-    err = tr_jsonParse( NULL, in, strlen( in ), &top, NULL );
-    check( !err );
-    check( tr_bencIsDict( &top ) );
-    check( tr_bencDictFindStr( &top, "key", &str ) );
-    check_streq( "Letöltések", str );
-    json = tr_bencToStr( &top, TR_FMT_JSON, NULL );
-    if( !err )
-        tr_bencFree( &top );
-    check( json );
-    check( strstr( json, "\\u00f6" ) != NULL );
-    check( strstr( json, "\\u00e9" ) != NULL );
-    err = tr_jsonParse( NULL, json, strlen( json ), &top, NULL );
-    check( !err );
-    check( tr_bencIsDict( &top ) );
-    check( tr_bencDictFindStr( &top, "key", &str ) );
-    check_streq( "Letöltések", str );
-    if( !err )
-        tr_bencFree( &top );
-    tr_free( json );
+    err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
+    check (!err);
+    check (tr_bencIsDict (&top));
+    check (tr_bencDictFindStr (&top, "key", &str));
+    check_streq ("Letöltések", str);
+    json = tr_bencToStr (&top, TR_FMT_JSON, NULL);
+    if (!err)
+        tr_bencFree (&top);
+    check (json);
+    check (strstr (json, "\\u00f6") != NULL);
+    check (strstr (json, "\\u00e9") != NULL);
+    err = tr_jsonParse (NULL, json, strlen (json), &top, NULL);
+    check (!err);
+    check (tr_bencIsDict (&top));
+    check (tr_bencDictFindStr (&top, "key", &str));
+    check_streq ("Letöltések", str);
+    if (!err)
+        tr_bencFree (&top);
+    tr_free (json);
 
     return 0;
 }
 
 static int
-test1( void )
+test1 (void)
 {
     const char * in =
         "{\n"
@@ -130,51 +130,51 @@ test1( void )
     tr_benc      top, *headers, *body, *args, *ids;
     const char * str;
     int64_t      i;
-    const int    err = tr_jsonParse( NULL, in, strlen( in ), &top, NULL );
-
-    check( !err );
-    check( tr_bencIsDict( &top ) );
-    check( ( headers = tr_bencDictFind( &top, "headers" ) ) );
-    check( tr_bencIsDict( headers ) );
-    check( tr_bencDictFindStr( headers, "type", &str ) );
-    check_streq( "request", str );
-    check( tr_bencDictFindInt( headers, "tag", &i ) );
-    check_int_eq( 666, i );
-    check( ( body = tr_bencDictFind( &top, "body" ) ) );
-    check( tr_bencDictFindStr( body, "name", &str ) );
-    check_streq( "torrent-info", str );
-    check( ( args = tr_bencDictFind( body, "arguments" ) ) );
-    check( tr_bencIsDict( args ) );
-    check( ( ids = tr_bencDictFind( args, "ids" ) ) );
-    check( tr_bencIsList( ids ) );
-    check_int_eq( 2, tr_bencListSize( ids ) );
-    check( tr_bencGetInt( tr_bencListChild( ids, 0 ), &i ) );
-    check_int_eq( 7, i );
-    check( tr_bencGetInt( tr_bencListChild( ids, 1 ), &i ) );
-    check_int_eq( 10, i );
-
-    tr_bencFree( &top );
+    const int    err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
+
+    check (!err);
+    check (tr_bencIsDict (&top));
+    check ((headers = tr_bencDictFind (&top, "headers")));
+    check (tr_bencIsDict (headers));
+    check (tr_bencDictFindStr (headers, "type", &str));
+    check_streq ("request", str);
+    check (tr_bencDictFindInt (headers, "tag", &i));
+    check_int_eq (666, i);
+    check ((body = tr_bencDictFind (&top, "body")));
+    check (tr_bencDictFindStr (body, "name", &str));
+    check_streq ("torrent-info", str);
+    check ((args = tr_bencDictFind (body, "arguments")));
+    check (tr_bencIsDict (args));
+    check ((ids = tr_bencDictFind (args, "ids")));
+    check (tr_bencIsList (ids));
+    check_int_eq (2, tr_bencListSize (ids));
+    check (tr_bencGetInt (tr_bencListChild (ids, 0), &i));
+    check_int_eq (7, i);
+    check (tr_bencGetInt (tr_bencListChild (ids, 1), &i));
+    check_int_eq (10, i);
+
+    tr_bencFree (&top);
     return 0;
 }
 
 static int
-test2( void )
+test2 (void)
 {
     tr_benc top;
     const char * in = " ";
     int err;
 
     top.type = 0;
-    err = tr_jsonParse( NULL, in, strlen( in ), &top, NULL );
+    err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
 
-    check( err );
-    check( !tr_bencIsDict( &top ) );
+    check (err);
+    check (!tr_bencIsDict (&top));
 
     return 0;
 }
 
 static int
-test3( void )
+test3 (void)
 {
     const char * in = "{ \"error\": 2,"
                       "  \"errorString\": \"torrent not registered with this tracker 6UHsVW'*C\","
@@ -184,12 +184,12 @@ test3( void )
     tr_benc top;
     const char * str;
 
-    const int err = tr_jsonParse( NULL, in, strlen( in ), &top, NULL );
-    check( !err );
-    check( tr_bencDictFindStr( &top, "errorString", &str ) );
-    check_streq( "torrent not registered with this tracker 6UHsVW'*C", str );
+    const int err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
+    check (!err);
+    check (tr_bencDictFindStr (&top, "errorString", &str));
+    check_streq ("torrent not registered with this tracker 6UHsVW'*C", str);
 
-    tr_bencFree( &top );
+    tr_bencFree (&top);
     return 0;
 }
 
@@ -200,7 +200,7 @@ test_unescape (void)
     tr_benc top;
     const char * str;
 
-    const int err = tr_jsonParse (NULL, in, strlen(in), &top, NULL);
+    const int err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
     check_int_eq (0, err);
     check (tr_bencDictFindStr (&top, "string-1", &str));
     check_streq ("/usr/lib", str);
@@ -210,7 +210,7 @@ test_unescape (void)
 }
 
 int
-main( void )
+main (void)
 {
     const testFunc tests[] = { test_elements,
                                test_utf8,
@@ -219,5 +219,5 @@ main( void )
                                test3,
                                test_unescape };
 
-    return runTests(tests, NUM_TESTS(tests));
+    return runTests (tests, NUM_TESTS (tests));
 }
diff --git a/libtransmission/json.c b/libtransmission/json.c
index ba4fc1548..e413fa435 100644
--- a/libtransmission/json.c
+++ b/libtransmission/json.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,7 +16,7 @@
 #include <string.h>
 #include <errno.h> /* EILSEQ, EINVAL */
 
-#include <event2/util.h> /* evutil_strtoll() */
+#include <event2/util.h> /* evutil_strtoll () */
 
 #define JSONSL_STATE_USER_FIELDS /* no fields */
 #include "jsonsl.h"
@@ -85,14 +85,14 @@ error_handler (jsonsl_t                  jsn,
       tr_err ("JSON parse failed in %s at pos %zu: %s -- remaining text \"%.16s\"",
               data->source,
               jsn->pos,
-              jsonsl_strerror(error),
+              jsonsl_strerror (error),
               buf);
     }
   else
     {
       tr_err ("JSON parse failed at pos %zu: %s -- remaining text \"%.16s\"",
               jsn->pos,
-              jsonsl_strerror(error),
+              jsonsl_strerror (error),
               buf);
     }
 
@@ -159,7 +159,7 @@ extract_string (jsonsl_t jsn, struct jsonsl_state_st * state, size_t * len)
   out_buf = tr_new0 (char, out_buflen);
   out_it = out_buf;
 
-  for (in_it=in_begin; in_it!=in_end; )
+  for (in_it=in_begin; in_it!=in_end;)
     {
       bool unescaped = false;
 
@@ -264,7 +264,7 @@ action_callback_POP (jsonsl_t                  jsn,
       else if (state->special_flags & JSONSL_SPECIALf_NULL)
         {
           data->has_content = true;
-          tr_bencInitStr (get_node (jsn), "", 0 );
+          tr_bencInitStr (get_node (jsn), "", 0);
         }
     }
 }
@@ -307,7 +307,7 @@ tr_jsonParse (const char     * source,
 
   /* cleanup */
   error = data.error;
-  tr_ptrArrayDestruct( &data.stack, NULL );
+  tr_ptrArrayDestruct (&data.stack, NULL);
   jsonsl_destroy (jsn);
   return error;
 }
diff --git a/libtransmission/json.h b/libtransmission/json.h
index 83556952b..521d5e5ed 100644
--- a/libtransmission/json.h
+++ b/libtransmission/json.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -17,11 +17,11 @@ extern "C" {
 #endif
 
 /** @ingroup tr_benc */
-int tr_jsonParse( const char * source, /* Such as a filename. Only when logging an error */
+int tr_jsonParse (const char * source, /* Such as a filename. Only when logging an error */
                   const void *     vbuf,
                   size_t           len,
                   struct tr_benc * setme_benc,
-                  const uint8_t ** setme_end );
+                  const uint8_t ** setme_end);
 
 #ifdef __cplusplus
 }
diff --git a/libtransmission/libtransmission-test.h b/libtransmission/libtransmission-test.h
index 32f0ec03d..05d535114 100644
--- a/libtransmission/libtransmission-test.h
+++ b/libtransmission/libtransmission-test.h
@@ -5,12 +5,12 @@
 
 #include <stdio.h>
 
-#include "utils.h" /* tr_strcmp0() */
+#include "utils.h" /* tr_strcmp0 () */
 
 static int current_test = 0;
 
 #define REPORT_TEST(test, result) \
-    fprintf( stderr, "%s %s:%d\n", result, __FILE__, __LINE__ )
+    fprintf (stderr, "%s %s:%d\n", result, __FILE__, __LINE__)
 
 static inline bool
 should_print (bool pass)
@@ -45,7 +45,7 @@ check_streq_impl (const char * file, int line, const char * expected, const char
     if (pass)
       fprintf (stderr, "PASS %s:%d\n", file, line);
     else
-      fprintf (stderr, "FAIL %s:%d, expected \"%s\", got \"%s\"\n", file, line, expected?expected:"(null)", actual?actual:"(null)");
+      fprintf (stderr, "FAIL %s:%d, expected \"%s\", got \"%s\"\n", file, line, expected?expected:" (null)", actual?actual:" (null)");
   }
 
   return pass;
@@ -75,14 +75,14 @@ check_eq_impl (const char * file, int line, int64_t expected, int64_t actual)
     ++current_test; \
     if (!check_condition_impl (__FILE__, __LINE__, (condition))) \
       return current_test; \
-  } while(0)
+  } while (0)
 
 #define check_streq(expected, actual) \
   do { \
     ++current_test; \
     if (!check_streq_impl (__FILE__, __LINE__, (expected), (actual))) \
       return current_test; \
-  } while(0)
+  } while (0)
 
 #define check_int_eq(expected, actual) \
   do { \
@@ -95,27 +95,27 @@ check_eq_impl (const char * file, int line, int64_t expected, int64_t actual)
 ****
 ***/
 
-typedef int (*testFunc)( void );
-#define NUM_TESTS(tarray) ((int) (sizeof(tarray)/sizeof(tarray[0])))
+typedef int (*testFunc)(void);
+#define NUM_TESTS(tarray)((int)(sizeof (tarray)/sizeof (tarray[0])))
 
 static inline int
-runTests( const testFunc * const tests, int numTests )
+runTests (const testFunc * const tests, int numTests)
 {
     int ret, i;
 
-    (void) current_test; /* Use test even if we don't have any tests to run */
+  (void) current_test; /* Use test even if we don't have any tests to run */
 
-    for( i = 0; i < numTests; i++ )
-	if( (ret = (*tests[i])()) )
+    for (i = 0; i < numTests; i++)
+	if ((ret = (*tests[i])()))
 	    return ret;
 
     return 0; 	/* All tests passed */
 }
 
 #define MAIN_SINGLE_TEST(test) \
-int main( void ) { \
+int main (void) { \
     const testFunc tests[] = { test }; \
-    return runTests(tests, 1); \
+    return runTests (tests, 1); \
 }
 
 #endif /* !LIBTRANSMISSION_TEST_H */
diff --git a/libtransmission/list.c b/libtransmission/list.c
index ebb7858a5..3d3e51699 100644
--- a/libtransmission/list.c
+++ b/libtransmission/list.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -19,29 +19,32 @@ static const tr_list TR_LIST_CLEAR = { NULL, NULL, NULL };
 static tr_list * recycled_nodes = NULL;
 
 static tr_list*
-node_alloc( void )
+node_alloc (void)
 {
-    tr_list * ret;
+  tr_list * ret;
 
-    if( recycled_nodes == NULL )
-        ret = tr_new( tr_list, 1 );
-    else {
-        ret = recycled_nodes;
-        recycled_nodes = recycled_nodes->next;
+  if (recycled_nodes == NULL)
+    {
+      ret = tr_new (tr_list, 1);
+    }
+  else
+    {
+      ret = recycled_nodes;
+      recycled_nodes = recycled_nodes->next;
     }
 
-    *ret = TR_LIST_CLEAR;
-    return ret;
+  *ret = TR_LIST_CLEAR;
+  return ret;
 }
 
 static void
-node_free( tr_list* node )
+node_free (tr_list* node)
 {
-    if( node != NULL )
+  if (node != NULL)
     {
-        *node = TR_LIST_CLEAR;
-        node->next = recycled_nodes;
-        recycled_nodes = node;
+      *node = TR_LIST_CLEAR;
+      node->next = recycled_nodes;
+      recycled_nodes = node;
     }
 }
 
@@ -50,158 +53,168 @@ node_free( tr_list* node )
 ***/
 
 void
-tr_list_free( tr_list**         list,
-              TrListForeachFunc data_free_func )
+tr_list_free (tr_list**         list,
+              TrListForeachFunc data_free_func)
 {
-    while( *list )
+  while (*list)
     {
-        tr_list *node = *list;
-        *list = ( *list )->next;
-        if( data_free_func )
-            data_free_func( node->data );
-        node_free( node );
+      tr_list *node = *list;
+      *list = (*list)->next;
+      if (data_free_func)
+        data_free_func (node->data);
+      node_free (node);
     }
 }
 
 void
-tr_list_prepend( tr_list ** list,
-                 void *     data )
+tr_list_prepend (tr_list ** list,
+                 void *     data)
 {
-    tr_list * node = node_alloc ( );
+  tr_list * node = node_alloc ();
 
-    node->data = data;
-    node->next = *list;
-    if( *list )
-        ( *list )->prev = node;
-    *list = node;
+  node->data = data;
+  node->next = *list;
+  if (*list)
+    (*list)->prev = node;
+  *list = node;
 }
 
 void
-tr_list_append( tr_list ** list,
-                void *     data )
+tr_list_append (tr_list ** list,
+                void *     data)
 {
-    tr_list * node = node_alloc( );
+  tr_list * node = node_alloc ();
+
+  node->data = data;
 
-    node->data = data;
-    if( !*list )
-        *list = node;
-    else
+  if (!*list)
     {
-        tr_list * l = *list;
-        while( l->next )
-            l = l->next;
+      *list = node;
+    }
+  else
+    {
+      tr_list * l = *list;
+
+      while (l->next)
+        l = l->next;
 
-        l->next = node;
-        node->prev = l;
+      l->next = node;
+      node->prev = l;
     }
 }
 
 static tr_list*
-tr_list_find_data( tr_list *    list,
-                   const void * data )
+tr_list_find_data (tr_list *    list,
+                   const void * data)
 {
-    for( ; list; list = list->next )
-        if( list->data == data )
-            return list;
+  for (; list; list = list->next)
+    if (list->data == data)
+      return list;
 
-    return NULL;
+  return NULL;
 }
 
 static void*
-tr_list_remove_node( tr_list ** list,
-                     tr_list *  node )
+tr_list_remove_node (tr_list ** list,
+                     tr_list *  node)
 {
-    void *    data;
-    tr_list * prev = node ? node->prev : NULL;
-    tr_list * next = node ? node->next : NULL;
-
-    if( prev ) prev->next = next;
-    if( next ) next->prev = prev;
-    if( *list == node ) *list = next;
-    data = node ? node->data : NULL;
-    node_free( node );
-    return data;
+  void *    data;
+  tr_list * prev = node ? node->prev : NULL;
+  tr_list * next = node ? node->next : NULL;
+
+  if (prev) prev->next = next;
+  if (next) next->prev = prev;
+  if (*list == node) *list = next;
+  data = node ? node->data : NULL;
+  node_free (node);
+  return data;
 }
 
 void*
-tr_list_pop_front( tr_list ** list )
+tr_list_pop_front (tr_list ** list)
 {
-    void * ret = NULL;
+  void * ret = NULL;
 
-    if( *list )
+  if (*list)
     {
-        ret = ( *list )->data;
-        tr_list_remove_node( list, *list );
+      ret = (*list)->data;
+      tr_list_remove_node (list, *list);
     }
-    return ret;
+
+  return ret;
 }
 
 void*
-tr_list_remove_data( tr_list **   list,
-                     const void * data )
+tr_list_remove_data (tr_list **   list,
+                     const void * data)
 {
-    return tr_list_remove_node( list, tr_list_find_data( *list, data ) );
+  return tr_list_remove_node (list, tr_list_find_data (*list, data));
 }
 
 void*
-tr_list_remove( tr_list **        list,
+tr_list_remove (tr_list **        list,
                 const void *      b,
-                TrListCompareFunc compare_func )
+                TrListCompareFunc compare_func)
 {
-    return tr_list_remove_node( list, tr_list_find( *list, b, compare_func ) );
+  return tr_list_remove_node (list, tr_list_find (*list, b, compare_func));
 }
 
 tr_list*
-tr_list_find( tr_list *         list,
+tr_list_find (tr_list *         list,
               const void *      b,
-              TrListCompareFunc func )
+              TrListCompareFunc func)
 {
-    for( ; list; list = list->next )
-        if( !func( list->data, b ) )
-            return list;
+  for (; list; list = list->next)
+    if (!func (list->data, b))
+      return list;
 
-    return NULL;
+  return NULL;
 }
 
 void
-tr_list_insert_sorted( tr_list            ** list,
+tr_list_insert_sorted (tr_list            ** list,
                        void                * data,
-                       TrListCompareFunc     compare )
+                       TrListCompareFunc     compare)
 {
-    /* find l, the node that we'll insert this data before */
-    tr_list * l;
+  /* find l, the node that we'll insert this data before */
+  tr_list * l;
 
-    for( l = *list; l != NULL; l = l->next )
+  for (l = *list; l != NULL; l = l->next)
     {
-        const int c = (compare)( data, l->data );
-        if( c <= 0 )
-            break;
+      const int c = (compare)(data, l->data);
+      if (c <= 0)
+        break;
     }
 
-    if( l == NULL )
-        tr_list_append( list, data );
-    else if( l == *list )
-        tr_list_prepend( list, data );
-    else {
-        tr_list * node = node_alloc( );
-        node->data = data;
-        node->prev = l->prev;
-        node->next = l;
-        node->prev->next = node;
-        node->next->prev = node;
+  if (l == NULL)
+    {
+      tr_list_append (list, data);
+    }
+  else if (l == *list)
+    {
+      tr_list_prepend (list, data);
+    }
+  else
+    {
+      tr_list * node = node_alloc ();
+      node->data = data;
+      node->prev = l->prev;
+      node->next = l;
+      node->prev->next = node;
+      node->next->prev = node;
     }
 }
 
 int
-tr_list_size( const tr_list * list )
+tr_list_size (const tr_list * list)
 {
-    int size = 0;
+  int size = 0;
 
-    while( list )
+  while (list)
     {
-        ++size;
-        list = list->next;
+      ++size;
+      list = list->next;
     }
 
-    return size;
+  return size;
 }
diff --git a/libtransmission/list.h b/libtransmission/list.h
index 4c7a9611a..03641910a 100644
--- a/libtransmission/list.h
+++ b/libtransmission/list.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -33,42 +33,42 @@ typedef struct tr_list
 }
 tr_list;
 
-typedef int ( *TrListCompareFunc )( const void * a, const void * b );
-typedef void ( *TrListForeachFunc )( void * );
+typedef int (*TrListCompareFunc)(const void * a, const void * b);
+typedef void (*TrListForeachFunc)(void *);
 
 /**
  * @brief return the number of items in the list
  * @return the number of items in the list
  */
-int      tr_list_size( const tr_list * list );
+int      tr_list_size (const tr_list * list);
 
 /**
  * @brief free the specified list and set its pointer to NULL
  * @param list pointer to the list to be freed
  * @param func optional function to invoke on each item in the list
  */
-void     tr_list_free( tr_list ** list, TrListForeachFunc data_free_func );
+void     tr_list_free (tr_list ** list, TrListForeachFunc data_free_func);
 
 /**
  * @brief append an item to the specified list
  * @param list pointer to the list
  * @param item the item to append
  */
-void tr_list_append( tr_list ** list, void * data );
+void tr_list_append (tr_list ** list, void * data);
 
 /**
  * @brief prepend an item to the specified list
  * @param list pointer to the list
  * @param item the item to prepend
  */
-void tr_list_prepend( tr_list ** list, void * data );
+void tr_list_prepend (tr_list ** list, void * data);
 
 /**
  * @brief remove the next item in the list
  * @return the next item in the list, or NULL if the list is empty
  * @param list pointer to the list
  */
-void* tr_list_pop_front( tr_list ** list );
+void* tr_list_pop_front (tr_list ** list);
 
 /**
  * @brief remove the list's node that contains the specified data pointer
@@ -76,7 +76,7 @@ void* tr_list_pop_front( tr_list ** list );
  * @param data data to remove
  * @return the removed data pointer, or NULL if no match was found
  */
-void* tr_list_remove_data( tr_list ** list, const void * data );
+void* tr_list_remove_data (tr_list ** list, const void * data);
 
 /**
  * @brief remove the list's node that compares equal to "b" when compared with "compare_func"
@@ -85,9 +85,9 @@ void* tr_list_remove_data( tr_list ** list, const void * data );
  * @param compare_func the comparison function. The arguments passed to it will be the list's pointers and the comparison key "b"
  * @return the removed data pointer, or NULL if no match was found
  */
-void*    tr_list_remove( tr_list **        list,
+void*    tr_list_remove (tr_list **        list,
                          const void *      b,
-                         TrListCompareFunc compare_func );
+                         TrListCompareFunc compare_func);
 
 /**
  * @brief find the list node whose data that compares equal to "b" when compared with "compare_func"
@@ -96,9 +96,9 @@ void*    tr_list_remove( tr_list **        list,
  * @param compare_func the comparison function. The arguments passed to it will be the list's pointers and the comparison key "b"
  * @return the matching list node, or NULL if not match was found
  */
-tr_list* tr_list_find( tr_list *         list,
+tr_list* tr_list_find (tr_list *         list,
                        const void *      b,
-                       TrListCompareFunc compare_func );
+                       TrListCompareFunc compare_func);
 
 /**
  * @brief Insert in an ordered list
@@ -106,9 +106,9 @@ tr_list* tr_list_find( tr_list *         list,
  * @param item the item to be inserted
  * @param compare the comparison function.
  */
-void tr_list_insert_sorted( tr_list          ** list,
+void tr_list_insert_sorted (tr_list          ** list,
                             void              * data,
-                            TrListCompareFunc   compare );
+                            TrListCompareFunc   compare);
 
 
 
diff --git a/libtransmission/magnet-test.c b/libtransmission/magnet-test.c
index 4b0e7e912..6cc831a68 100644
--- a/libtransmission/magnet-test.c
+++ b/libtransmission/magnet-test.c
@@ -6,7 +6,7 @@
 #include "libtransmission-test.h"
 
 static int
-test1( void )
+test1 (void)
 {
     int i;
     const char * uri;
@@ -20,17 +20,17 @@ test1( void )
           "&tr=http%3A%2F%2Ftracker.openbittorrent.com%2Fannounce"
           "&tr=http%3A%2F%2Ftracker.opentracker.org%2Fannounce"
           "&ws=http%3A%2F%2Fserver.webseed.org%2Fpath%2Fto%2Ffile";
-    info = tr_magnetParse( uri );
-    check( info != NULL );
-    check_int_eq( 2, info->trackerCount );
-    check_streq( info->trackers[0], "http://tracker.openbittorrent.com/announce" );
-    check_streq( info->trackers[1], "http://tracker.opentracker.org/announce" );
-    check_int_eq( 1, info->webseedCount );
-    check_streq( "http://server.webseed.org/path/to/file", info->webseeds[0] );
-    check_streq( "Display Name", info->displayName );
-    for( i=0; i<20; ++i )
-        check( info->hash[i] == dec[i] );
-    tr_magnetFree( info );
+    info = tr_magnetParse (uri);
+    check (info != NULL);
+    check_int_eq (2, info->trackerCount);
+    check_streq (info->trackers[0], "http://tracker.openbittorrent.com/announce");
+    check_streq (info->trackers[1], "http://tracker.opentracker.org/announce");
+    check_int_eq (1, info->webseedCount);
+    check_streq ("http://server.webseed.org/path/to/file", info->webseeds[0]);
+    check_streq ("Display Name", info->displayName);
+    for (i=0; i<20; ++i)
+        check (info->hash[i] == dec[i]);
+    tr_magnetFree (info);
     info = NULL;
 
     /* same thing but in base32 encoding */
@@ -40,21 +40,21 @@ test1( void )
           "&tr=http%3A%2F%2Ftracker.openbittorrent.com%2Fannounce"
           "&ws=http%3A%2F%2Fserver.webseed.org%2Fpath%2Fto%2Ffile"
           "&tr=http%3A%2F%2Ftracker.opentracker.org%2Fannounce";
-    info = tr_magnetParse( uri );
-    check( info != NULL );
-    check_int_eq( 2, info->trackerCount );
-    check_streq( "http://tracker.openbittorrent.com/announce", info->trackers[0] );
-    check_streq( "http://tracker.opentracker.org/announce", info->trackers[1] );
-    check_int_eq( 1, info->webseedCount );
-    check_streq( "http://server.webseed.org/path/to/file", info->webseeds[0] );
-    check_streq( "Display Name", info->displayName );
-    for( i=0; i<20; ++i )
-        check( info->hash[i] == dec[i] );
-    tr_magnetFree( info );
+    info = tr_magnetParse (uri);
+    check (info != NULL);
+    check_int_eq (2, info->trackerCount);
+    check_streq ("http://tracker.openbittorrent.com/announce", info->trackers[0]);
+    check_streq ("http://tracker.opentracker.org/announce", info->trackers[1]);
+    check_int_eq (1, info->webseedCount);
+    check_streq ("http://server.webseed.org/path/to/file", info->webseeds[0]);
+    check_streq ("Display Name", info->displayName);
+    for (i=0; i<20; ++i)
+        check (info->hash[i] == dec[i]);
+    tr_magnetFree (info);
     info = NULL;
 
     return 0;
 }
 
-MAIN_SINGLE_TEST(test1)
+MAIN_SINGLE_TEST (test1)
 
diff --git a/libtransmission/magnet.c b/libtransmission/magnet.c
index 9265d4b04..10974c745 100644
--- a/libtransmission/magnet.c
+++ b/libtransmission/magnet.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,8 +11,8 @@
  */
 
 #include <assert.h>
-#include <string.h> /* strchr() */
-#include <stdio.h> /* sscanf() */
+#include <string.h> /* strchr () */
+#include <stdio.h> /* sscanf () */
 
 #include "transmission.h"
 #include "bencode.h"
@@ -29,64 +29,70 @@
 
 static const int base32Lookup[] =
 {
-    0xFF,0xFF,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F, /* '0', '1', '2', '3', '4', '5', '6', '7' */
-    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, /* '8', '9', ':', ';', '<', '=', '>', '?' */
-    0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06, /* '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G' */
-    0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E, /* 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O' */
-    0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16, /* 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W' */
-    0x17,0x18,0x19,0xFF,0xFF,0xFF,0xFF,0xFF, /* 'X', 'Y', 'Z', '[', '\', ']', '^', '_' */
-    0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06, /* '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g' */
-    0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E, /* 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o' */
-    0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16, /* 'p', 'q', 'r', 's', 't', 'u', 'v', 'w' */
-    0x17,0x18,0x19,0xFF,0xFF,0xFF,0xFF,0xFF  /* 'x', 'y', 'z', '{', '|', '}', '~', 'DEL' */
+  0xFF,0xFF,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F, /* '0', '1', '2', '3', '4', '5', '6', '7' */
+  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, /* '8', '9', ':', ';', '<', '=', '>', '?' */
+  0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06, /* '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G' */
+  0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E, /* 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O' */
+  0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16, /* 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W' */
+  0x17,0x18,0x19,0xFF,0xFF,0xFF,0xFF,0xFF, /* 'X', 'Y', 'Z', '[', '\', ']', '^', '_' */
+  0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06, /* '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g' */
+  0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E, /* 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o' */
+  0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16, /* 'p', 'q', 'r', 's', 't', 'u', 'v', 'w' */
+  0x17,0x18,0x19,0xFF,0xFF,0xFF,0xFF,0xFF  /* 'x', 'y', 'z', '{', '|', '}', '~', 'DEL' */
 };
 
-static const int base32LookupLen = sizeof( base32Lookup ) / sizeof( base32Lookup[0] );
+static const int base32LookupLen = sizeof (base32Lookup) / sizeof (base32Lookup[0]);
 
 static void
-base32_to_sha1( uint8_t * out, const char * in, const int inlen )
+base32_to_sha1 (uint8_t * out, const char * in, const int inlen)
 {
-    const int outlen = 20;
-    int i, index, offset;
+  const int outlen = 20;
+  int i, index, offset;
 
-    memset( out, 0, 20 );
+  memset (out, 0, 20);
 
-    assert( inlen == 32 );
+  assert (inlen == 32);
 
-    for( i=0, index=0, offset=0; i<inlen; ++i )
+  for (i=0, index=0, offset=0; i<inlen; ++i)
     {
-        int digit;
-        int lookup = in[i] - '0';
-
-        /* Skip chars outside the lookup table */
-        if( lookup<0 || lookup>=base32LookupLen )
-            continue;
-
-        /* If this digit is not in the table, ignore it */
-        digit = base32Lookup[lookup];
-        if( digit == 0xFF )
-            continue;
-
-        if( index <= 3 ) {
-            index = (index + 5) % 8;
-            if( index == 0 ) {
-                out[offset] |= digit;
-                offset++;
-                if( offset >= outlen )
-                    break;
-            } else {
-                out[offset] |= digit << (8 - index);
-            }
-        } else {
-            index = (index + 5) % 8;
-            out[offset] |= (digit >> index);
-            offset++;
+      int digit;
+      int lookup = in[i] - '0';
+
+      /* Skip chars outside the lookup table */
+      if (lookup<0 || lookup>=base32LookupLen)
+        continue;
+
+      /* If this digit is not in the table, ignore it */
+      digit = base32Lookup[lookup];
+      if (digit == 0xFF)
+        continue;
 
-            if( offset >= outlen )
+      if (index <= 3)
+        {
+          index = (index + 5) % 8;
+          if (index == 0)
+            {
+              out[offset] |= digit;
+              offset++;
+              if (offset >= outlen)
                 break;
-            out[offset] |= digit << (8 - index);
-       }
-   }
+            }
+          else
+            {
+              out[offset] |= digit << (8 - index);
+            }
+        }
+      else
+        {
+          index = (index + 5) % 8;
+          out[offset] |= (digit >> index);
+          offset++;
+
+          if (offset >= outlen)
+            break;
+          out[offset] |= digit << (8 - index);
+        }
+    }
 }
 
 /***
@@ -97,138 +103,145 @@ base32_to_sha1( uint8_t * out, const char * in, const int inlen )
 #define MAX_WEBSEEDS 64
 
 tr_magnet_info *
-tr_magnetParse( const char * uri )
+tr_magnetParse (const char * uri)
 {
-    bool got_checksum = false;
-    int trCount = 0;
-    int wsCount = 0;
-    char * tr[MAX_TRACKERS];
-    char * ws[MAX_WEBSEEDS];
-    char * displayName = NULL;
-    uint8_t sha1[SHA_DIGEST_LENGTH];
-    tr_magnet_info * info = NULL;
-
-    if( ( uri != NULL ) && !memcmp( uri, "magnet:?", 8 ) )
+  bool got_checksum = false;
+  int trCount = 0;
+  int wsCount = 0;
+  char * tr[MAX_TRACKERS];
+  char * ws[MAX_WEBSEEDS];
+  char * displayName = NULL;
+  uint8_t sha1[SHA_DIGEST_LENGTH];
+  tr_magnet_info * info = NULL;
+
+  if ((uri != NULL) && !memcmp (uri, "magnet:?", 8))
     {
-        const char * walk;
+      const char * walk;
 
-        for( walk=uri+8; walk && *walk; )
+      for (walk=uri+8; walk && *walk;)
         {
-            const char * key = walk;
-            const char * delim = strchr( key, '=' );
-            const char * val = delim == NULL ? NULL : delim + 1;
-            const char * next = strchr( delim == NULL ? key : val, '&' );
-            int keylen, vallen;
-
-            if( delim != NULL )
-                keylen = delim - key;
-            else if( next != NULL )
-                keylen = next - key;
-            else
-                keylen = strlen( key );
-
-            if( val == NULL )
-                vallen = 0;
-            else if( next != NULL )
-                vallen = next - val;
-            else
-                vallen = strlen( val );
-
-            if( ( keylen==2 ) && !memcmp( key, "xt", 2 ) && val && !memcmp( val, "urn:btih:", 9 ) )
+          const char * key = walk;
+          const char * delim = strchr (key, '=');
+          const char * val = delim == NULL ? NULL : delim + 1;
+          const char * next = strchr (delim == NULL ? key : val, '&');
+          int keylen, vallen;
+
+          if (delim != NULL)
+            keylen = delim - key;
+          else if (next != NULL)
+            keylen = next - key;
+          else
+            keylen = strlen (key);
+
+          if (val == NULL)
+            vallen = 0;
+          else if (next != NULL)
+            vallen = next - val;
+          else
+            vallen = strlen (val);
+
+          if ((keylen==2) && !memcmp (key, "xt", 2) && val && !memcmp (val, "urn:btih:", 9))
             {
-                const char * hash = val + 9;
-                const int hashlen = vallen - 9;
+              const char * hash = val + 9;
+              const int hashlen = vallen - 9;
 
-                if( hashlen == 40 ) {
-                    tr_hex_to_sha1( sha1, hash );
-                    got_checksum = true;
+              if (hashlen == 40)
+                {
+                  tr_hex_to_sha1 (sha1, hash);
+                  got_checksum = true;
                 }
-                else if( hashlen == 32 ) {
-                    base32_to_sha1( sha1, hash, hashlen );
-                    got_checksum = true;
+              else if (hashlen == 32)
+                {
+                  base32_to_sha1 (sha1, hash, hashlen);
+                  got_checksum = true;
                 }
             }
 
-            if( ( vallen > 0 ) && ( keylen==2 ) && !memcmp( key, "dn", 2 ) )
-                displayName = tr_http_unescape( val, vallen );
+          if ((vallen > 0) && (keylen==2) && !memcmp (key, "dn", 2))
+            displayName = tr_http_unescape (val, vallen);
 
-            if( ( vallen > 0 ) && ( trCount < MAX_TRACKERS ) ) {
-                int i;
-                if( ( keylen==2 ) && !memcmp( key, "tr", 2 ) )
-                    tr[trCount++] = tr_http_unescape( val, vallen );
-                else if( ( sscanf( key, "tr.%d=", &i ) == 1 ) && ( i >= 0 ) ) /* ticket #3341 and #5134 */
-                    tr[trCount++] = tr_http_unescape( val, vallen );
+          if ((vallen > 0) && (trCount < MAX_TRACKERS))
+            {
+              int i;
+              if ((keylen==2) && !memcmp (key, "tr", 2))
+                tr[trCount++] = tr_http_unescape (val, vallen);
+              else if ((sscanf (key, "tr.%d=", &i) == 1) && (i >= 0)) /* ticket #3341 and #5134 */
+                tr[trCount++] = tr_http_unescape (val, vallen);
             }
 
-            if( ( vallen > 0 ) && ( keylen==2 ) && !memcmp( key, "ws", 2 ) && ( wsCount < MAX_WEBSEEDS ) )
-                ws[wsCount++] = tr_http_unescape( val, vallen );
+          if ((vallen > 0) && (keylen==2) && !memcmp (key, "ws", 2) && (wsCount < MAX_WEBSEEDS))
+            ws[wsCount++] = tr_http_unescape (val, vallen);
 
-            walk = next != NULL ? next + 1 : NULL;
+          walk = next != NULL ? next + 1 : NULL;
         }
     }
 
-    if( got_checksum )
+  if (got_checksum)
     {
-        info = tr_new0( tr_magnet_info, 1 );
-        info->displayName = displayName;
-        info->trackerCount = trCount;
-        info->trackers = tr_memdup( tr, sizeof(char*) * trCount );
-        info->webseedCount = wsCount;
-        info->webseeds = tr_memdup( ws, sizeof(char*) * wsCount );
-        memcpy( info->hash, sha1, sizeof(uint8_t) * SHA_DIGEST_LENGTH );
+      info = tr_new0 (tr_magnet_info, 1);
+      info->displayName = displayName;
+      info->trackerCount = trCount;
+      info->trackers = tr_memdup (tr, sizeof (char*) * trCount);
+      info->webseedCount = wsCount;
+      info->webseeds = tr_memdup (ws, sizeof (char*) * wsCount);
+      memcpy (info->hash, sha1, sizeof (uint8_t) * SHA_DIGEST_LENGTH);
     }
 
-    return info;
+  return info;
 }
 
 void
-tr_magnetFree( tr_magnet_info * info )
+tr_magnetFree (tr_magnet_info * info)
 {
-    if( info != NULL )
+  if (info != NULL)
     {
-        int i;
+      int i;
 
-        for( i=0; i<info->trackerCount; ++i )
-            tr_free( info->trackers[i] );
-        tr_free( info->trackers );
+      for (i=0; i<info->trackerCount; ++i)
+        tr_free (info->trackers[i]);
+      tr_free (info->trackers);
 
-        for( i=0; i<info->webseedCount; ++i )
-            tr_free( info->webseeds[i] );
-        tr_free( info->webseeds );
+      for (i=0; i<info->webseedCount; ++i)
+        tr_free (info->webseeds[i]);
+      tr_free (info->webseeds);
 
-        tr_free( info->displayName );
-        tr_free( info );
+      tr_free (info->displayName);
+      tr_free (info);
     }
 }
 
 void
-tr_magnetCreateMetainfo( const tr_magnet_info * info, tr_benc * top )
+tr_magnetCreateMetainfo (const tr_magnet_info * info, tr_benc * top)
 {
-    int i;
-    tr_benc * d;
-    tr_bencInitDict( top, 4 );
-
-    /* announce list */
-    if( info->trackerCount == 1 )
-        tr_bencDictAddStr( top, "announce", info->trackers[0] );
-    else {
-        tr_benc * trackers = tr_bencDictAddList( top, "announce-list", info->trackerCount );
-        for( i=0; i<info->trackerCount; ++i )
-            tr_bencListAddStr( tr_bencListAddList( trackers, 1 ), info->trackers[i] );
+  int i;
+  tr_benc * d;
+  tr_bencInitDict (top, 4);
+
+  /* announce list */
+  if (info->trackerCount == 1)
+    {
+      tr_bencDictAddStr (top, "announce", info->trackers[0]);
+    }
+  else
+    {
+      tr_benc * trackers = tr_bencDictAddList (top, "announce-list", info->trackerCount);
+      for (i=0; i<info->trackerCount; ++i)
+        tr_bencListAddStr (tr_bencListAddList (trackers, 1), info->trackers[i]);
     }
 
-    /* webseeds */
-    if( info->webseedCount > 0 ) {
-        tr_benc * urls = tr_bencDictAddList( top, "url-list", info->webseedCount );
-        for( i=0; i<info->webseedCount; ++i )
-            tr_bencListAddStr( urls, info->webseeds[i] );
+  /* webseeds */
+  if (info->webseedCount > 0)
+    {
+      tr_benc * urls = tr_bencDictAddList (top, "url-list", info->webseedCount);
+      for (i=0; i<info->webseedCount; ++i)
+        tr_bencListAddStr (urls, info->webseeds[i]);
     }
 
-    /* nonstandard keys */
-    d = tr_bencDictAddDict( top, "magnet-info", 2 );
-    tr_bencDictAddRaw( d, "info_hash", info->hash, 20 );
-    if( info->displayName != NULL )
-        tr_bencDictAddStr( d, "display-name", info->displayName );
+  /* nonstandard keys */
+  d = tr_bencDictAddDict (top, "magnet-info", 2);
+  tr_bencDictAddRaw (d, "info_hash", info->hash, 20);
+  if (info->displayName != NULL)
+    tr_bencDictAddStr (d, "display-name", info->displayName);
 }
 
 
diff --git a/libtransmission/magnet.h b/libtransmission/magnet.h
index a3fca04d8..a3d6d3004 100644
--- a/libtransmission/magnet.h
+++ b/libtransmission/magnet.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -21,24 +21,24 @@
 
 typedef struct tr_magnet_info
 {
-    uint8_t hash[20];
+  uint8_t hash[20];
 
-    char * displayName;
+  char * displayName;
 
-    int trackerCount;
-    char ** trackers;
+  int trackerCount;
+  char ** trackers;
 
-    int webseedCount;
-    char ** webseeds;
+  int webseedCount;
+  char ** webseeds;
 }
 tr_magnet_info;
 
-tr_magnet_info * tr_magnetParse( const char * uri );
+tr_magnet_info * tr_magnetParse (const char * uri);
 
 struct tr_benc;
 
-void tr_magnetCreateMetainfo( const tr_magnet_info *, struct tr_benc * );
+void tr_magnetCreateMetainfo (const tr_magnet_info *, struct tr_benc *);
 
-void tr_magnetFree( tr_magnet_info * info );
+void tr_magnetFree (tr_magnet_info * info);
 
 #endif
diff --git a/libtransmission/makemeta.c b/libtransmission/makemeta.c
index 7188c7bbf..5816c3e76 100644
--- a/libtransmission/makemeta.c
+++ b/libtransmission/makemeta.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -18,14 +18,14 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <unistd.h> /* read() */
+#include <unistd.h> /* read () */
 #include <dirent.h>
 
-#include <event2/util.h> /* evutil_ascii_strcasecmp() */
+#include <event2/util.h> /* evutil_ascii_strcasecmp () */
 
 #include "transmission.h"
 #include "crypto.h" /* tr_sha1 */
-#include "fdlimit.h" /* tr_open_file_for_scanning() */
+#include "fdlimit.h" /* tr_open_file_for_scanning () */
 #include "session.h"
 #include "bencode.h"
 #include "makemeta.h"
@@ -45,9 +45,9 @@ struct FileList
 };
 
 static struct FileList*
-getFiles( const char *      dir,
+getFiles (const char *      dir,
           const char *      base,
-          struct FileList * list )
+          struct FileList * list)
 {
     int         i;
     char        * buf;
@@ -56,97 +56,97 @@ getFiles( const char *      dir,
 
     sb.st_size = 0;
 
-    buf = tr_buildPath( dir, base, NULL );
-    i = stat( buf, &sb );
-    if( i )
+    buf = tr_buildPath (dir, base, NULL);
+    i = stat (buf, &sb);
+    if (i)
     {
-        tr_err( _( "Torrent Creator is skipping file \"%s\": %s" ),
-                buf, tr_strerror( errno ) );
-        tr_free( buf );
+        tr_err (_ ("Torrent Creator is skipping file \"%s\": %s"),
+                buf, tr_strerror (errno));
+        tr_free (buf);
         return list;
     }
 
-    if( S_ISDIR( sb.st_mode ) && ( ( odir = opendir ( buf ) ) ) )
+    if (S_ISDIR (sb.st_mode) && ((odir = opendir (buf))))
     {
         struct dirent *d;
-        for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
-            if( d->d_name && d->d_name[0] != '.' ) /* skip dotfiles */
-                list = getFiles( buf, d->d_name, list );
-        closedir( odir );
+        for (d = readdir (odir); d != NULL; d = readdir (odir))
+            if (d->d_name && d->d_name[0] != '.') /* skip dotfiles */
+                list = getFiles (buf, d->d_name, list);
+        closedir (odir);
     }
-    else if( S_ISREG( sb.st_mode ) && ( sb.st_size > 0 ) )
+    else if (S_ISREG (sb.st_mode) && (sb.st_size > 0))
     {
-        struct FileList * node = tr_new( struct FileList, 1 );
+        struct FileList * node = tr_new (struct FileList, 1);
         node->size = sb.st_size;
-        node->filename = tr_strdup( buf );
+        node->filename = tr_strdup (buf);
         node->next = list;
         list = node;
     }
 
-    tr_free( buf );
+    tr_free (buf);
     return list;
 }
 
 static uint32_t
-bestPieceSize( uint64_t totalSize )
+bestPieceSize (uint64_t totalSize)
 {
     const uint32_t KiB = 1024;
     const uint32_t MiB = 1048576;
     const uint32_t GiB = 1073741824;
 
-    if( totalSize >=   ( 2 * GiB ) ) return   2 * MiB;
-    if( totalSize >=   ( 1 * GiB ) ) return   1 * MiB;
-    if( totalSize >= ( 512 * MiB ) ) return 512 * KiB;
-    if( totalSize >= ( 350 * MiB ) ) return 256 * KiB;
-    if( totalSize >= ( 150 * MiB ) ) return 128 * KiB;
-    if( totalSize >=  ( 50 * MiB ) ) return  64 * KiB;
+    if (totalSize >= (2 * GiB)) return   2 * MiB;
+    if (totalSize >= (1 * GiB)) return   1 * MiB;
+    if (totalSize >= (512 * MiB)) return 512 * KiB;
+    if (totalSize >= (350 * MiB)) return 256 * KiB;
+    if (totalSize >= (150 * MiB)) return 128 * KiB;
+    if (totalSize >= (50 * MiB)) return  64 * KiB;
     return 32 * KiB;  /* less than 50 meg */
 }
 
 static int
-builderFileCompare( const void * va, const void * vb )
+builderFileCompare (const void * va, const void * vb)
 {
     const tr_metainfo_builder_file * a = va;
     const tr_metainfo_builder_file * b = vb;
 
-    return evutil_ascii_strcasecmp( a->filename, b->filename );
+    return evutil_ascii_strcasecmp (a->filename, b->filename);
 }
 
 tr_metainfo_builder*
-tr_metaInfoBuilderCreate( const char * topFileArg )
+tr_metaInfoBuilderCreate (const char * topFileArg)
 {
     int i;
     struct FileList * files;
     struct FileList * walk;
     char topFile[TR_PATH_MAX];
-    tr_metainfo_builder * ret = tr_new0( tr_metainfo_builder, 1 );
+    tr_metainfo_builder * ret = tr_new0 (tr_metainfo_builder, 1);
 
-    tr_realpath( topFileArg, topFile );
+    tr_realpath (topFileArg, topFile);
 
-    ret->top = tr_strdup( topFile );
+    ret->top = tr_strdup (topFile);
 
     {
         struct stat sb;
-        stat( topFile, &sb );
-        ret->isSingleFile = !S_ISDIR( sb.st_mode );
+        stat (topFile, &sb);
+        ret->isSingleFile = !S_ISDIR (sb.st_mode);
     }
 
     /* build a list of files containing topFile and,
        if it's a directory, all of its children */
     {
-        char * dir = tr_dirname( topFile );
-        char * base = tr_basename( topFile );
-        files = getFiles( dir, base, NULL );
-        tr_free( base );
-        tr_free( dir );
+        char * dir = tr_dirname (topFile);
+        char * base = tr_basename (topFile);
+        files = getFiles (dir, base, NULL);
+        tr_free (base);
+        tr_free (dir);
     }
 
-    for( walk = files; walk != NULL; walk = walk->next )
+    for (walk = files; walk != NULL; walk = walk->next)
         ++ret->fileCount;
 
-    ret->files = tr_new0( tr_metainfo_builder_file, ret->fileCount );
+    ret->files = tr_new0 (tr_metainfo_builder_file, ret->fileCount);
 
-    for( i = 0, walk = files; walk != NULL; ++i )
+    for (i = 0, walk = files; walk != NULL; ++i)
     {
         struct FileList *          tmp = walk;
         tr_metainfo_builder_file * file = &ret->files[i];
@@ -154,39 +154,39 @@ tr_metaInfoBuilderCreate( const char * topFileArg )
         file->filename = tmp->filename;
         file->size = tmp->size;
         ret->totalSize += tmp->size;
-        tr_free( tmp );
+        tr_free (tmp);
     }
 
-    qsort( ret->files,
+    qsort (ret->files,
            ret->fileCount,
-           sizeof( tr_metainfo_builder_file ),
-           builderFileCompare );
+           sizeof (tr_metainfo_builder_file),
+           builderFileCompare);
 
-    ret->pieceSize = bestPieceSize( ret->totalSize );
-    ret->pieceCount = (int)( ret->totalSize / ret->pieceSize );
-    if( ret->totalSize % ret->pieceSize )
+    ret->pieceSize = bestPieceSize (ret->totalSize);
+    ret->pieceCount = (int)(ret->totalSize / ret->pieceSize);
+    if (ret->totalSize % ret->pieceSize)
         ++ret->pieceCount;
 
     return ret;
 }
 
 void
-tr_metaInfoBuilderFree( tr_metainfo_builder * builder )
+tr_metaInfoBuilderFree (tr_metainfo_builder * builder)
 {
-    if( builder )
+    if (builder)
     {
         tr_file_index_t t;
         int             i;
-        for( t = 0; t < builder->fileCount; ++t )
-            tr_free( builder->files[t].filename );
-        tr_free( builder->files );
-        tr_free( builder->top );
-        tr_free( builder->comment );
-        for( i = 0; i < builder->trackerCount; ++i )
-            tr_free( builder->trackers[i].announce );
-        tr_free( builder->trackers );
-        tr_free( builder->outputFile );
-        tr_free( builder );
+        for (t = 0; t < builder->fileCount; ++t)
+            tr_free (builder->files[t].filename);
+        tr_free (builder->files);
+        tr_free (builder->top);
+        tr_free (builder->comment);
+        for (i = 0; i < builder->trackerCount; ++i)
+            tr_free (builder->trackers[i].announce);
+        tr_free (builder->trackers);
+        tr_free (builder->outputFile);
+        tr_free (builder);
     }
 }
 
@@ -195,78 +195,78 @@ tr_metaInfoBuilderFree( tr_metainfo_builder * builder )
 ****/
 
 static uint8_t*
-getHashInfo( tr_metainfo_builder * b )
+getHashInfo (tr_metainfo_builder * b)
 {
     uint32_t fileIndex = 0;
-    uint8_t *ret = tr_new0( uint8_t, SHA_DIGEST_LENGTH * b->pieceCount );
+    uint8_t *ret = tr_new0 (uint8_t, SHA_DIGEST_LENGTH * b->pieceCount);
     uint8_t *walk = ret;
     uint8_t *buf;
     uint64_t totalRemain;
     uint64_t off = 0;
     int fd;
 
-    if( !b->totalSize )
+    if (!b->totalSize)
         return ret;
 
-    buf = tr_valloc( b->pieceSize );
+    buf = tr_valloc (b->pieceSize);
     b->pieceIndex = 0;
     totalRemain = b->totalSize;
-    fd = tr_open_file_for_scanning( b->files[fileIndex].filename );
-    if( fd < 0 )
+    fd = tr_open_file_for_scanning (b->files[fileIndex].filename);
+    if (fd < 0)
     {
         b->my_errno = errno;
-        tr_strlcpy( b->errfile,
+        tr_strlcpy (b->errfile,
                     b->files[fileIndex].filename,
-                    sizeof( b->errfile ) );
+                    sizeof (b->errfile));
         b->result = TR_MAKEMETA_IO_READ;
-        tr_free( buf );
-        tr_free( ret );
+        tr_free (buf);
+        tr_free (ret);
         return NULL;
     }
-    while( totalRemain )
+    while (totalRemain)
     {
         uint8_t * bufptr = buf;
-        const uint32_t thisPieceSize = (uint32_t) MIN( b->pieceSize, totalRemain );
+        const uint32_t thisPieceSize = (uint32_t) MIN (b->pieceSize, totalRemain);
         uint32_t leftInPiece = thisPieceSize;
 
-        assert( b->pieceIndex < b->pieceCount );
+        assert (b->pieceIndex < b->pieceCount);
 
-        while( leftInPiece )
+        while (leftInPiece)
         {
-            const size_t n_this_pass = (size_t) MIN( ( b->files[fileIndex].size - off ), leftInPiece );
-            const ssize_t n_read = read( fd, bufptr, n_this_pass );
+            const size_t n_this_pass = (size_t) MIN ((b->files[fileIndex].size - off), leftInPiece);
+            const ssize_t n_read = read (fd, bufptr, n_this_pass);
             bufptr += n_read;
             off += n_read;
             leftInPiece -= n_read;
-            if( off == b->files[fileIndex].size )
+            if (off == b->files[fileIndex].size)
             {
                 off = 0;
-                tr_close_file( fd );
+                tr_close_file (fd);
                 fd = -1;
-                if( ++fileIndex < b->fileCount )
+                if (++fileIndex < b->fileCount)
                 {
-                    fd = tr_open_file_for_scanning( b->files[fileIndex].filename );
-                    if( fd < 0 )
+                    fd = tr_open_file_for_scanning (b->files[fileIndex].filename);
+                    if (fd < 0)
                     {
                         b->my_errno = errno;
-                        tr_strlcpy( b->errfile,
+                        tr_strlcpy (b->errfile,
                                     b->files[fileIndex].filename,
-                                    sizeof( b->errfile ) );
+                                    sizeof (b->errfile));
                         b->result = TR_MAKEMETA_IO_READ;
-                        tr_free( buf );
-                        tr_free( ret );
+                        tr_free (buf);
+                        tr_free (ret);
                         return NULL;
                     }
                 }
             }
         }
 
-        assert( bufptr - buf == (int)thisPieceSize );
-        assert( leftInPiece == 0 );
-        tr_sha1( walk, buf, thisPieceSize, NULL );
+        assert (bufptr - buf == (int)thisPieceSize);
+        assert (leftInPiece == 0);
+        tr_sha1 (walk, buf, thisPieceSize, NULL);
         walk += SHA_DIGEST_LENGTH;
 
-        if( b->abortFlag )
+        if (b->abortFlag)
         {
             b->result = TR_MAKEMETA_CANCELLED;
             break;
@@ -276,107 +276,107 @@ getHashInfo( tr_metainfo_builder * b )
         ++b->pieceIndex;
     }
 
-    assert( b->abortFlag
-          || ( walk - ret == (int)( SHA_DIGEST_LENGTH * b->pieceCount ) ) );
-    assert( b->abortFlag || !totalRemain );
+    assert (b->abortFlag
+          || (walk - ret == (int)(SHA_DIGEST_LENGTH * b->pieceCount)));
+    assert (b->abortFlag || !totalRemain);
 
-    if( fd >= 0 )
-        tr_close_file( fd );
+    if (fd >= 0)
+        tr_close_file (fd);
 
-    tr_free( buf );
+    tr_free (buf);
     return ret;
 }
 
 static void
-getFileInfo( const char *                     topFile,
+getFileInfo (const char *                     topFile,
              const tr_metainfo_builder_file * file,
              tr_benc *                        uninitialized_length,
-             tr_benc *                        uninitialized_path )
+             tr_benc *                        uninitialized_path)
 {
     size_t offset;
 
     /* get the file size */
-    tr_bencInitInt( uninitialized_length, file->size );
+    tr_bencInitInt (uninitialized_length, file->size);
 
     /* how much of file->filename to walk past */
-    offset = strlen( topFile );
-    if( offset>0 && topFile[offset-1]!=TR_PATH_DELIMITER )
+    offset = strlen (topFile);
+    if (offset>0 && topFile[offset-1]!=TR_PATH_DELIMITER)
         ++offset; /* +1 for the path delimiter */
 
     /* build the path list */
-    tr_bencInitList( uninitialized_path, 0 );
-    if( strlen(file->filename) > offset ) {
-        char * filename = tr_strdup( file->filename + offset );
+    tr_bencInitList (uninitialized_path, 0);
+    if (strlen (file->filename) > offset) {
+        char * filename = tr_strdup (file->filename + offset);
         char * walk = filename;
         const char * token;
-        while(( token = tr_strsep( &walk, TR_PATH_DELIMITER_STR )))
-            tr_bencListAddStr( uninitialized_path, token );
-        tr_free( filename );
+        while ((token = tr_strsep (&walk, TR_PATH_DELIMITER_STR)))
+            tr_bencListAddStr (uninitialized_path, token);
+        tr_free (filename);
     }
 }
 
 static void
-makeInfoDict( tr_benc *             dict,
-              tr_metainfo_builder * builder )
+makeInfoDict (tr_benc *             dict,
+              tr_metainfo_builder * builder)
 {
     uint8_t * pch;
     char    * base;
 
-    tr_bencDictReserve( dict, 5 );
+    tr_bencDictReserve (dict, 5);
 
-    if( builder->isSingleFile )
+    if (builder->isSingleFile)
     {
-        tr_bencDictAddInt( dict, "length", builder->files[0].size );
+        tr_bencDictAddInt (dict, "length", builder->files[0].size);
     }
     else /* root node is a directory */
     {
         uint32_t  i;
-        tr_benc * list = tr_bencDictAddList( dict, "files",
-                                             builder->fileCount );
-        for( i = 0; i < builder->fileCount; ++i )
+        tr_benc * list = tr_bencDictAddList (dict, "files",
+                                             builder->fileCount);
+        for (i = 0; i < builder->fileCount; ++i)
         {
-            tr_benc * d = tr_bencListAddDict( list, 2 );
-            tr_benc * length = tr_bencDictAdd( d, "length" );
-            tr_benc * pathVal = tr_bencDictAdd( d, "path" );
-            getFileInfo( builder->top, &builder->files[i], length, pathVal );
+            tr_benc * d = tr_bencListAddDict (list, 2);
+            tr_benc * length = tr_bencDictAdd (d, "length");
+            tr_benc * pathVal = tr_bencDictAdd (d, "path");
+            getFileInfo (builder->top, &builder->files[i], length, pathVal);
         }
     }
 
-    base = tr_basename( builder->top );
-    tr_bencDictAddStr( dict, "name", base );
-    tr_free( base );
+    base = tr_basename (builder->top);
+    tr_bencDictAddStr (dict, "name", base);
+    tr_free (base);
 
-    tr_bencDictAddInt( dict, "piece length", builder->pieceSize );
+    tr_bencDictAddInt (dict, "piece length", builder->pieceSize);
 
-    if( ( pch = getHashInfo( builder ) ) )
+    if ((pch = getHashInfo (builder)))
     {
-        tr_bencDictAddRaw( dict, "pieces", pch,
-                           SHA_DIGEST_LENGTH * builder->pieceCount );
-        tr_free( pch );
+        tr_bencDictAddRaw (dict, "pieces", pch,
+                           SHA_DIGEST_LENGTH * builder->pieceCount);
+        tr_free (pch);
     }
 
-    tr_bencDictAddInt( dict, "private", builder->isPrivate ? 1 : 0 );
+    tr_bencDictAddInt (dict, "private", builder->isPrivate ? 1 : 0);
 }
 
 static void
-tr_realMakeMetaInfo( tr_metainfo_builder * builder )
+tr_realMakeMetaInfo (tr_metainfo_builder * builder)
 {
     int     i;
     tr_benc top;
 
     /* allow an empty set, but if URLs *are* listed, verify them. #814, #971 */
-    for( i = 0; i < builder->trackerCount && !builder->result; ++i ) {
-        if( !tr_urlIsValidTracker( builder->trackers[i].announce ) ) {
-            tr_strlcpy( builder->errfile, builder->trackers[i].announce,
-                       sizeof( builder->errfile ) );
+    for (i = 0; i < builder->trackerCount && !builder->result; ++i) {
+        if (!tr_urlIsValidTracker (builder->trackers[i].announce)) {
+            tr_strlcpy (builder->errfile, builder->trackers[i].announce,
+                       sizeof (builder->errfile));
             builder->result = TR_MAKEMETA_URL;
         }
     }
 
-    tr_bencInitDict( &top, 6 );
+    tr_bencInitDict (&top, 6);
 
-    if( !builder->fileCount || !builder->totalSize ||
-        !builder->pieceSize || !builder->pieceCount )
+    if (!builder->fileCount || !builder->totalSize ||
+        !builder->pieceSize || !builder->pieceCount)
     {
         builder->errfile[0] = '\0';
         builder->my_errno = ENOENT;
@@ -384,55 +384,55 @@ tr_realMakeMetaInfo( tr_metainfo_builder * builder )
         builder->isDone = true;
     }
 
-    if( !builder->result && builder->trackerCount )
+    if (!builder->result && builder->trackerCount)
     {
         int       prevTier = -1;
         tr_benc * tier = NULL;
 
-        if( builder->trackerCount > 1 )
+        if (builder->trackerCount > 1)
         {
-            tr_benc * annList = tr_bencDictAddList( &top, "announce-list",
-                                                    0 );
-            for( i = 0; i < builder->trackerCount; ++i )
+            tr_benc * annList = tr_bencDictAddList (&top, "announce-list",
+                                                    0);
+            for (i = 0; i < builder->trackerCount; ++i)
             {
-                if( prevTier != builder->trackers[i].tier )
+                if (prevTier != builder->trackers[i].tier)
                 {
                     prevTier = builder->trackers[i].tier;
-                    tier = tr_bencListAddList( annList, 0 );
+                    tier = tr_bencListAddList (annList, 0);
                 }
-                tr_bencListAddStr( tier, builder->trackers[i].announce );
+                tr_bencListAddStr (tier, builder->trackers[i].announce);
             }
         }
 
-        tr_bencDictAddStr( &top, "announce", builder->trackers[0].announce );
+        tr_bencDictAddStr (&top, "announce", builder->trackers[0].announce);
     }
 
-    if( !builder->result && !builder->abortFlag )
+    if (!builder->result && !builder->abortFlag)
     {
-        if( builder->comment && *builder->comment )
-            tr_bencDictAddStr( &top, "comment", builder->comment );
-        tr_bencDictAddStr( &top, "created by",
-                           TR_NAME "/" LONG_VERSION_STRING );
-        tr_bencDictAddInt( &top, "creation date", time( NULL ) );
-        tr_bencDictAddStr( &top, "encoding", "UTF-8" );
-        makeInfoDict( tr_bencDictAddDict( &top, "info", 666 ), builder );
+        if (builder->comment && *builder->comment)
+            tr_bencDictAddStr (&top, "comment", builder->comment);
+        tr_bencDictAddStr (&top, "created by",
+                           TR_NAME "/" LONG_VERSION_STRING);
+        tr_bencDictAddInt (&top, "creation date", time (NULL));
+        tr_bencDictAddStr (&top, "encoding", "UTF-8");
+        makeInfoDict (tr_bencDictAddDict (&top, "info", 666), builder);
     }
 
     /* save the file */
-    if( !builder->result && !builder->abortFlag )
+    if (!builder->result && !builder->abortFlag)
     {
-        if( tr_bencToFile( &top, TR_FMT_BENC, builder->outputFile ) )
+        if (tr_bencToFile (&top, TR_FMT_BENC, builder->outputFile))
         {
             builder->my_errno = errno;
-            tr_strlcpy( builder->errfile, builder->outputFile,
-                       sizeof( builder->errfile ) );
+            tr_strlcpy (builder->errfile, builder->outputFile,
+                       sizeof (builder->errfile));
             builder->result = TR_MAKEMETA_IO_WRITE;
         }
     }
 
     /* cleanup */
-    tr_bencFree( &top );
-    if( builder->abortFlag )
+    tr_bencFree (&top);
+    if (builder->abortFlag)
         builder->result = TR_MAKEMETA_CANCELLED;
     builder->isDone = 1;
 }
@@ -448,60 +448,60 @@ static tr_metainfo_builder * queue = NULL;
 static tr_thread *           workerThread = NULL;
 
 static tr_lock*
-getQueueLock( void )
+getQueueLock (void)
 {
     static tr_lock * lock = NULL;
 
-    if( !lock )
-        lock = tr_lockNew( );
+    if (!lock)
+        lock = tr_lockNew ();
 
     return lock;
 }
 
 static void
-makeMetaWorkerFunc( void * unused UNUSED )
+makeMetaWorkerFunc (void * unused UNUSED)
 {
-    for( ;; )
+    for (;;)
     {
         tr_metainfo_builder * builder = NULL;
 
         /* find the next builder to process */
-        tr_lock * lock = getQueueLock( );
-        tr_lockLock( lock );
-        if( queue )
+        tr_lock * lock = getQueueLock ();
+        tr_lockLock (lock);
+        if (queue)
         {
             builder = queue;
             queue = queue->nextBuilder;
         }
-        tr_lockUnlock( lock );
+        tr_lockUnlock (lock);
 
         /* if no builders, this worker thread is done */
-        if( builder == NULL )
+        if (builder == NULL)
             break;
 
-        tr_realMakeMetaInfo ( builder );
+        tr_realMakeMetaInfo (builder);
     }
 
     workerThread = NULL;
 }
 
 void
-tr_makeMetaInfo( tr_metainfo_builder *   builder,
+tr_makeMetaInfo (tr_metainfo_builder *   builder,
                  const char *            outputFile,
                  const tr_tracker_info * trackers,
                  int                     trackerCount,
                  const char *            comment,
-                 int                     isPrivate )
+                 int                     isPrivate)
 {
     int       i;
     tr_lock * lock;
 
     /* free any variables from a previous run */
-    for( i = 0; i < builder->trackerCount; ++i )
-        tr_free( builder->trackers[i].announce );
-    tr_free( builder->trackers );
-    tr_free( builder->comment );
-    tr_free( builder->outputFile );
+    for (i = 0; i < builder->trackerCount; ++i)
+        tr_free (builder->trackers[i].announce);
+    tr_free (builder->trackers);
+    tr_free (builder->comment);
+    tr_free (builder->outputFile);
 
     /* initialize the builder variables */
     builder->abortFlag = 0;
@@ -509,25 +509,25 @@ tr_makeMetaInfo( tr_metainfo_builder *   builder,
     builder->isDone = 0;
     builder->pieceIndex = 0;
     builder->trackerCount = trackerCount;
-    builder->trackers = tr_new0( tr_tracker_info, builder->trackerCount );
-    for( i = 0; i < builder->trackerCount; ++i ) {
+    builder->trackers = tr_new0 (tr_tracker_info, builder->trackerCount);
+    for (i = 0; i < builder->trackerCount; ++i) {
         builder->trackers[i].tier = trackers[i].tier;
-        builder->trackers[i].announce = tr_strdup( trackers[i].announce );
+        builder->trackers[i].announce = tr_strdup (trackers[i].announce);
     }
-    builder->comment = tr_strdup( comment );
+    builder->comment = tr_strdup (comment);
     builder->isPrivate = isPrivate;
-    if( outputFile && *outputFile )
-        builder->outputFile = tr_strdup( outputFile );
+    if (outputFile && *outputFile)
+        builder->outputFile = tr_strdup (outputFile);
     else
-        builder->outputFile = tr_strdup_printf( "%s.torrent", builder->top );
+        builder->outputFile = tr_strdup_printf ("%s.torrent", builder->top);
 
     /* enqueue the builder */
-    lock = getQueueLock ( );
-    tr_lockLock( lock );
+    lock = getQueueLock ();
+    tr_lockLock (lock);
     builder->nextBuilder = queue;
     queue = builder;
-    if( !workerThread )
-        workerThread = tr_threadNew( makeMetaWorkerFunc, NULL );
-    tr_lockUnlock( lock );
+    if (!workerThread)
+        workerThread = tr_threadNew (makeMetaWorkerFunc, NULL);
+    tr_lockUnlock (lock);
 }
 
diff --git a/libtransmission/makemeta.h b/libtransmission/makemeta.h
index fb66c6fe6..396ff4137 100644
--- a/libtransmission/makemeta.h
+++ b/libtransmission/makemeta.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -38,8 +38,8 @@ tr_metainfo_builder_err;
 typedef struct tr_metainfo_builder
 {
     /**
-    ***  These are set by tr_makeMetaInfoBuilderCreate()
-    ***  and cleaned up by tr_metaInfoBuilderFree()
+    ***  These are set by tr_makeMetaInfoBuilderCreate ()
+    ***  and cleaned up by tr_metaInfoBuilderFree ()
     **/
 
     char *                      top;
@@ -51,9 +51,9 @@ typedef struct tr_metainfo_builder
     int                         isSingleFile;
 
     /**
-    ***  These are set inside tr_makeMetaInfo()
+    ***  These are set inside tr_makeMetaInfo ()
     ***  by copying the arguments passed to it,
-    ***  and cleaned up by tr_metaInfoBuilderFree()
+    ***  and cleaned up by tr_metaInfoBuilderFree ()
     **/
 
     tr_tracker_info *  trackers;
@@ -63,10 +63,10 @@ typedef struct tr_metainfo_builder
     int                isPrivate;
 
     /**
-    ***  These are set inside tr_makeMetaInfo() so the client
+    ***  These are set inside tr_makeMetaInfo () so the client
     ***  can poll periodically to see what the status is.
     ***  The client can also set abortFlag to nonzero to
-    ***  tell tr_makeMetaInfo() to abort and clean up after itself.
+    ***  tell tr_makeMetaInfo () to abort and clean up after itself.
     **/
 
     uint32_t                   pieceIndex;
@@ -91,9 +91,9 @@ typedef struct tr_metainfo_builder
 tr_metainfo_builder;
 
 
-tr_metainfo_builder*tr_metaInfoBuilderCreate( const char * topFile );
+tr_metainfo_builder*tr_metaInfoBuilderCreate (const char * topFile);
 
-void                tr_metaInfoBuilderFree( tr_metainfo_builder* );
+void                tr_metaInfoBuilderFree (tr_metainfo_builder*);
 
 /**
  * @brief create a new .torrent file
@@ -103,7 +103,7 @@ void                tr_metaInfoBuilderFree( tr_metainfo_builder* );
  *
  * It is the caller's responsibility to poll builder->isDone
  * from time to time!  When the worker thread sets that flag,
- * the caller must pass the builder to tr_metaInfoBuilderFree().
+ * the caller must pass the builder to tr_metaInfoBuilderFree ().
  *
  * @param outputFile if NULL, builder->top + ".torrent" will be used.
 
@@ -112,12 +112,12 @@ void                tr_metaInfoBuilderFree( tr_metainfo_builder* );
  *
  * @param trackerCount size of the `trackers' array
  */
-void tr_makeMetaInfo( tr_metainfo_builder *   builder,
+void tr_makeMetaInfo (tr_metainfo_builder *   builder,
                       const char *            outputFile,
                       const tr_tracker_info * trackers,
                       int                     trackerCount,
                       const char *            comment,
-                      int                     isPrivate );
+                      int                     isPrivate);
 
 
 #ifdef __cplusplus
diff --git a/libtransmission/metainfo-test.c b/libtransmission/metainfo-test.c
index d02c60c81..6a445e9a6 100644
--- a/libtransmission/metainfo-test.c
+++ b/libtransmission/metainfo-test.c
@@ -4,7 +4,7 @@
 #include "libtransmission-test.h"
 
 static int
-test1( void )
+test1 (void)
 {
     tr_info inf;
     tr_ctor * ctor;
@@ -35,4 +35,4 @@ test1( void )
     return 0;
 }
 
-MAIN_SINGLE_TEST(test1)
+MAIN_SINGLE_TEST (test1)
diff --git a/libtransmission/metainfo.c b/libtransmission/metainfo.c
index 64961dc40..8dbf914b7 100644
--- a/libtransmission/metainfo.c
+++ b/libtransmission/metainfo.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -12,8 +12,8 @@
 
 #include <assert.h>
 #include <errno.h>
-#include <stdio.h> /* fopen(), fwrite(), fclose() */
-#include <string.h> /* strlen() */
+#include <stdio.h> /* fopen (), fwrite (), fclose () */
+#include <string.h> /* strlen () */
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -26,7 +26,7 @@
 #include "bencode.h"
 #include "crypto.h" /* tr_sha1 */
 #include "metainfo.h"
-#include "platform.h" /* tr_getTorrentDir() */
+#include "platform.h" /* tr_getTorrentDir () */
 #include "utils.h"
 
 /***
@@ -34,103 +34,100 @@
 ***/
 
 char*
-tr_metainfoGetBasename( const tr_info * inf )
+tr_metainfoGetBasename (const tr_info * inf)
 {
-    size_t i;
-    const size_t name_len = strlen( inf->name );
-    char * ret = tr_strdup_printf( "%s.%16.16s", inf->name, inf->hashString );
+  size_t i;
+  const size_t name_len = strlen (inf->name);
+  char * ret = tr_strdup_printf ("%s.%16.16s", inf->name, inf->hashString);
 
-    for( i=0; i<name_len; ++i )
-        if( ret[i] == '/' )
-            ret[i] = '_';
+  for (i=0; i<name_len; ++i)
+    if (ret[i] == '/')
+      ret[i] = '_';
 
-
-    return ret;
+  return ret;
 }
 
 static char*
-getTorrentFilename( const tr_session * session, const tr_info * inf )
+getTorrentFilename (const tr_session * session, const tr_info * inf)
 {
-    char * base = tr_metainfoGetBasename( inf );
-    char * filename = tr_strdup_printf( "%s" TR_PATH_DELIMITER_STR "%s.torrent",
-                                        tr_getTorrentDir( session ), base );
-    tr_free( base );
-    return filename;
+  char * base = tr_metainfoGetBasename (inf);
+  char * filename = tr_strdup_printf ("%s" TR_PATH_DELIMITER_STR "%s.torrent",
+                                      tr_getTorrentDir (session), base);
+  tr_free (base);
+  return filename;
 }
 
 static char*
-getOldTorrentFilename( const tr_session * session, const tr_info * inf )
+getOldTorrentFilename (const tr_session * session, const tr_info * inf)
 {
-    int i;
-    char * path;
-    struct stat sb;
-    const int tagCount = 5;
-    const char * tags[] = { "beos", "cli", "daemon", "macosx", "wx" };
-
-    /* test the beos, cli, daemon, macosx, wx tags */
-    for( i=0; i<tagCount; ++i ) {
-        path = tr_strdup_printf( "%s%c%s-%s", tr_getTorrentDir( session ), '/', inf->hashString, tags[i] );
-        if( !stat( path, &sb ) && ( ( sb.st_mode & S_IFMT ) == S_IFREG ) )
-            return path;
-        tr_free( path );
+  int i;
+  char * path;
+  struct stat sb;
+  const int tagCount = 5;
+  const char * tags[] = { "beos", "cli", "daemon", "macosx", "wx" };
+
+  /* test the beos, cli, daemon, macosx, wx tags */
+  for (i=0; i<tagCount; ++i)
+    {
+      path = tr_strdup_printf ("%s%c%s-%s", tr_getTorrentDir (session), '/', inf->hashString, tags[i]);
+      if (!stat (path, &sb) && ((sb.st_mode & S_IFMT) == S_IFREG))
+        return path;
+      tr_free (path);
     }
 
-    /* test a non-tagged file */
-    path = tr_buildPath( tr_getTorrentDir( session ), inf->hashString, NULL );
-    if( !stat( path, &sb ) && ( ( sb.st_mode & S_IFMT ) == S_IFREG ) )
-        return path;
-    tr_free( path );
+  /* test a non-tagged file */
+  path = tr_buildPath (tr_getTorrentDir (session), inf->hashString, NULL);
+  if (!stat (path, &sb) && ((sb.st_mode & S_IFMT) == S_IFREG))
+    return path;
+  tr_free (path);
 
-    /* return the -gtk form by default, since that's the most common case.
-       don't bother testing stat() on it since this is the last candidate
-       and we don't want to return NULL anyway */
-    return tr_strdup_printf( "%s%c%s-%s", tr_getTorrentDir( session ), '/', inf->hashString, "gtk" );
+  /* return the -gtk form by default, since that's the most common case.
+     don't bother testing stat () on it since this is the last candidate
+     and we don't want to return NULL anyway */
+  return tr_strdup_printf ("%s%c%s-%s", tr_getTorrentDir (session), '/', inf->hashString, "gtk");
 }
 
 /* this is for really old versions of T and will probably be removed someday */
 void
-tr_metainfoMigrate( tr_session * session,
-                    tr_info *   inf )
+tr_metainfoMigrate (tr_session * session, tr_info * inf)
 {
-    struct stat new_sb;
-    char *      name = getTorrentFilename( session, inf );
+  struct stat new_sb;
+  char * name = getTorrentFilename (session, inf);
 
-    if( stat( name, &new_sb ) || ( ( new_sb.st_mode & S_IFMT ) != S_IFREG ) )
+  if (stat (name, &new_sb) || ((new_sb.st_mode & S_IFMT) != S_IFREG))
     {
-        char *    old_name = getOldTorrentFilename( session, inf );
-        size_t    contentLen;
-        uint8_t * content;
+      char * old_name = getOldTorrentFilename (session, inf);
+      size_t contentLen;
+      uint8_t * content;
 
-        tr_mkdirp( tr_getTorrentDir( session ), 0777 );
-        if( ( content = tr_loadFile( old_name, &contentLen ) ) )
+      tr_mkdirp (tr_getTorrentDir (session), 0777);
+      if ((content = tr_loadFile (old_name, &contentLen)))
         {
-            FILE * out;
-            errno = 0;
-            out = fopen( name, "wb+" );
-            if( !out )
+          FILE * out;
+          errno = 0;
+          out = fopen (name, "wb+");
+          if (!out)
             {
-                tr_nerr( inf->name, _( "Couldn't create \"%1$s\": %2$s" ),
-                        name, tr_strerror( errno ) );
+              tr_nerr (inf->name, _ ("Couldn't create \"%1$s\": %2$s"), name, tr_strerror (errno));
             }
-            else
+          else
             {
-                if( fwrite( content, sizeof( uint8_t ), contentLen, out )
-                    == contentLen )
+              if (fwrite (content, sizeof (uint8_t), contentLen, out) == contentLen)
                 {
-                    tr_free( inf->torrent );
-                    inf->torrent = tr_strdup( name );
-                    tr_sessionSetTorrentFile( session, inf->hashString, name );
-                    unlink( old_name );
+                  tr_free (inf->torrent);
+                  inf->torrent = tr_strdup (name);
+                  tr_sessionSetTorrentFile (session, inf->hashString, name);
+                  unlink (old_name);
                 }
-                fclose( out );
+              fclose (out);
             }
         }
 
-        tr_free( content );
-        tr_free( old_name );
+      tr_free (content);
+      tr_free (old_name);
     }
 
-    tr_free( name );
+  tr_free (name);
 }
 
 /***
@@ -138,225 +135,231 @@ tr_metainfoMigrate( tr_session * session,
 ***/
 
 static bool
-path_is_suspicious( const char * path )
+path_is_suspicious (const char * path)
 {
-    return ( path == NULL )
-        || ( strstr( path, "../" ) != NULL );
+  return (path == NULL)
+      || (strstr (path, "../") != NULL);
 }
 
 static bool
-getfile( char ** setme, const char * root, tr_benc * path, struct evbuffer * buf )
+getfile (char ** setme, const char * root, tr_benc * path, struct evbuffer * buf)
 {
-    bool success = false;
+  bool success = false;
 
-    if( tr_bencIsList( path ) )
+  if (tr_bencIsList (path))
     {
-        int i;
-        const int n = tr_bencListSize( path );
+      int i;
+      const int n = tr_bencListSize (path);
 
-        evbuffer_drain( buf, evbuffer_get_length( buf ) );
-        evbuffer_add( buf, root, strlen( root ) );
-        for( i = 0; i < n; ++i )
+      evbuffer_drain (buf, evbuffer_get_length (buf));
+      evbuffer_add (buf, root, strlen (root));
+      for (i=0; i<n; i++)
         {
-            const char * str;
-            if( tr_bencGetStr( tr_bencListChild( path, i ), &str ) )
+          const char * str;
+
+          if (tr_bencGetStr (tr_bencListChild (path, i), &str))
             {
-                evbuffer_add( buf, TR_PATH_DELIMITER_STR, 1 );
-                evbuffer_add( buf, str, strlen( str ) );
+              evbuffer_add (buf, TR_PATH_DELIMITER_STR, 1);
+              evbuffer_add (buf, str, strlen (str));
             }
         }
 
-        *setme = tr_utf8clean( (char*)evbuffer_pullup( buf, -1 ), evbuffer_get_length( buf ) );
-        /* fprintf( stderr, "[%s]\n", *setme ); */
-        success = true;
+      *setme = tr_utf8clean ((char*)evbuffer_pullup (buf, -1), evbuffer_get_length (buf));
+      /* fprintf (stderr, "[%s]\n", *setme); */
+      success = true;
     }
 
-    if( ( *setme != NULL ) && path_is_suspicious( *setme ) )
+  if ((*setme != NULL) && path_is_suspicious (*setme))
     {
-        tr_free( *setme );
-        *setme = NULL;
-        success = false;
+      tr_free (*setme);
+      *setme = NULL;
+      success = false;
     }
 
-    return success;
+  return success;
 }
 
 static const char*
-parseFiles( tr_info * inf, tr_benc * files, const tr_benc * length )
+parseFiles (tr_info * inf, tr_benc * files, const tr_benc * length)
 {
-    int64_t len;
+  int64_t len;
 
-    inf->totalSize = 0;
+  inf->totalSize = 0;
 
-    if( tr_bencIsList( files ) ) /* multi-file mode */
+  if (tr_bencIsList (files)) /* multi-file mode */
     {
-        tr_file_index_t i;
-        struct evbuffer * buf = evbuffer_new( );
+      tr_file_index_t i;
+      struct evbuffer * buf = evbuffer_new ();
 
-        inf->isMultifile = 1;
-        inf->fileCount   = tr_bencListSize( files );
-        inf->files       = tr_new0( tr_file, inf->fileCount );
+      inf->isMultifile = 1;
+      inf->fileCount = tr_bencListSize (files);
+      inf->files = tr_new0 (tr_file, inf->fileCount);
 
-        for( i = 0; i < inf->fileCount; ++i )
+      for (i=0; i<inf->fileCount; i++)
         {
-            tr_benc * file;
-            tr_benc * path;
+          tr_benc * file;
+          tr_benc * path;
 
-            file = tr_bencListChild( files, i );
-            if( !tr_bencIsDict( file ) )
-                return "files";
+          file = tr_bencListChild (files, i);
+          if (!tr_bencIsDict (file))
+            return "files";
 
-            if( !tr_bencDictFindList( file, "path.utf-8", &path ) )
-                if( !tr_bencDictFindList( file, "path", &path ) )
-                    return "path";
+          if (!tr_bencDictFindList (file, "path.utf-8", &path))
+            if (!tr_bencDictFindList (file, "path", &path))
+              return "path";
 
-            if( !getfile( &inf->files[i].name, inf->name, path, buf ) )
-                return "path";
+          if (!getfile (&inf->files[i].name, inf->name, path, buf))
+            return "path";
 
-            if( !tr_bencDictFindInt( file, "length", &len ) )
-                return "length";
+          if (!tr_bencDictFindInt (file, "length", &len))
+            return "length";
 
-            inf->files[i].length = len;
-            inf->totalSize      += len;
+          inf->files[i].length = len;
+          inf->totalSize      += len;
         }
 
-        evbuffer_free( buf );
+      evbuffer_free (buf);
     }
-    else if( tr_bencGetInt( length, &len ) ) /* single-file mode */
+  else if (tr_bencGetInt (length, &len)) /* single-file mode */
     {
-        if( path_is_suspicious( inf->name ) )
-            return "path";
-
-        inf->isMultifile      = 0;
-        inf->fileCount        = 1;
-        inf->files            = tr_new0( tr_file, 1 );
-        inf->files[0].name    = tr_strdup( inf->name );
-        inf->files[0].length  = len;
-        inf->totalSize       += len;
+      if (path_is_suspicious (inf->name))
+        return "path";
+
+      inf->isMultifile      = 0;
+      inf->fileCount        = 1;
+      inf->files            = tr_new0 (tr_file, 1);
+      inf->files[0].name    = tr_strdup (inf->name);
+      inf->files[0].length  = len;
+      inf->totalSize       += len;
     }
-    else
+  else
     {
-        return "length";
+      return "length";
     }
 
-    return NULL;
+  return NULL;
 }
 
 static char *
-tr_convertAnnounceToScrape( const char * announce )
+tr_convertAnnounceToScrape (const char * announce)
 {
-    char *       scrape = NULL;
-    const char * s;
-
-    /* To derive the scrape URL use the following steps:
-     * Begin with the announce URL. Find the last '/' in it.
-     * If the text immediately following that '/' isn't 'announce'
-     * it will be taken as a sign that that tracker doesn't support
-     * the scrape convention. If it does, substitute 'scrape' for
-     * 'announce' to find the scrape page. */
-    if( ( ( s = strrchr( announce, '/' ) ) ) && !strncmp( ++s, "announce", 8 ) )
+  char * scrape = NULL;
+  const char * s;
+
+  /* To derive the scrape URL use the following steps:
+   * Begin with the announce URL. Find the last '/' in it.
+   * If the text immediately following that '/' isn't 'announce'
+   * it will be taken as a sign that that tracker doesn't support
+   * the scrape convention. If it does, substitute 'scrape' for
+   * 'announce' to find the scrape page. */
+  if (((s = strrchr (announce, '/'))) && !strncmp (++s, "announce", 8))
     {
-        const char * prefix = announce;
-        const size_t prefix_len = s - announce;
-        const char * suffix = s + 8;
-        const size_t suffix_len = strlen( suffix );
-        const size_t alloc_len = prefix_len + 6 + suffix_len + 1;
-        char * walk = scrape = tr_new( char, alloc_len );
-        memcpy( walk, prefix, prefix_len ); walk += prefix_len;
-        memcpy( walk, "scrape", 6 );        walk += 6;
-        memcpy( walk, suffix, suffix_len ); walk += suffix_len;
-        *walk++ = '\0';
-        assert( walk - scrape == (int)alloc_len );
+      const char * prefix = announce;
+      const size_t prefix_len = s - announce;
+      const char * suffix = s + 8;
+      const size_t suffix_len = strlen (suffix);
+      const size_t alloc_len = prefix_len + 6 + suffix_len + 1;
+      char * walk = scrape = tr_new (char, alloc_len);
+      memcpy (walk, prefix, prefix_len); walk += prefix_len;
+      memcpy (walk, "scrape", 6);        walk += 6;
+      memcpy (walk, suffix, suffix_len); walk += suffix_len;
+      *walk++ = '\0';
+      assert (walk - scrape == (int)alloc_len);
     }
-    /* Some torrents with UDP annouce URLs don't have /announce. */
-    else if ( !strncmp( announce, "udp:", 4 ) )
+  /* Some torrents with UDP annouce URLs don't have /announce. */
+  else if (!strncmp (announce, "udp:", 4))
     {
-        scrape = tr_strdup( announce );
+      scrape = tr_strdup (announce);
     }
 
-    return scrape;
+  return scrape;
 }
 
 static const char*
-getannounce( tr_info * inf, tr_benc * meta )
+getannounce (tr_info * inf, tr_benc * meta)
 {
-    const char *      str;
-    tr_tracker_info * trackers = NULL;
-    int               trackerCount = 0;
-    tr_benc *         tiers;
+  const char * str;
+  tr_tracker_info * trackers = NULL;
+  int trackerCount = 0;
+  tr_benc * tiers;
 
-    /* Announce-list */
-    if( tr_bencDictFindList( meta, "announce-list", &tiers ) )
+  /* Announce-list */
+  if (tr_bencDictFindList (meta, "announce-list", &tiers))
     {
-        int       n;
-        int       i, j, validTiers;
-        const int numTiers = tr_bencListSize( tiers );
+      int n;
+      int i, j, validTiers;
+      const int numTiers = tr_bencListSize (tiers);
 
-        n = 0;
-        for( i = 0; i < numTiers; ++i )
-            n += tr_bencListSize( tr_bencListChild( tiers, i ) );
+      n = 0;
+      for (i=0; i<numTiers; i++)
+        n += tr_bencListSize (tr_bencListChild (tiers, i));
 
-        trackers = tr_new0( tr_tracker_info, n );
+      trackers = tr_new0 (tr_tracker_info, n);
 
-        for( i = 0, validTiers = 0; i < numTiers; ++i )
+      for (i=0, validTiers=0; i<numTiers; i++)
         {
-            tr_benc * tier = tr_bencListChild( tiers, i );
-            const int tierSize = tr_bencListSize( tier );
-            bool anyAdded = false;
-            for( j = 0; j < tierSize; ++j )
+          tr_benc * tier = tr_bencListChild (tiers, i);
+          const int tierSize = tr_bencListSize (tier);
+          bool anyAdded = false;
+          for (j=0; j<tierSize; j++)
             {
-                if( tr_bencGetStr( tr_bencListChild( tier, j ), &str ) )
+              if (tr_bencGetStr (tr_bencListChild (tier, j), &str))
                 {
-                    char * url = tr_strstrip( tr_strdup( str ) );
-                    if( !tr_urlIsValidTracker( url ) )
-                        tr_free( url );
-                    else {
-                        tr_tracker_info * t = trackers + trackerCount;
-                        t->tier = validTiers;
-                        t->announce = url;
-                        t->scrape = tr_convertAnnounceToScrape( url );
-                        t->id = trackerCount;
-
-                        anyAdded = true;
-                        ++trackerCount;
+                  char * url = tr_strstrip (tr_strdup (str));
+                  if (!tr_urlIsValidTracker (url))
+                    {
+                      tr_free (url);
+                    }
+                  else
+                    {
+                      tr_tracker_info * t = trackers + trackerCount;
+                      t->tier = validTiers;
+                      t->announce = url;
+                      t->scrape = tr_convertAnnounceToScrape (url);
+                      t->id = trackerCount;
+
+                      anyAdded = true;
+                      ++trackerCount;
                     }
                 }
             }
 
-            if( anyAdded )
-                ++validTiers;
+          if (anyAdded)
+            ++validTiers;
         }
 
-        /* did we use any of the tiers? */
-        if( !trackerCount )
+      /* did we use any of the tiers? */
+      if (!trackerCount)
         {
-            tr_free( trackers );
-            trackers = NULL;
+          tr_free (trackers);
+          trackers = NULL;
         }
     }
 
-    /* Regular announce value */
-    if( !trackerCount
-      && tr_bencDictFindStr( meta, "announce", &str ) )
+  /* Regular announce value */
+  if (!trackerCount && tr_bencDictFindStr (meta, "announce", &str))
     {
-        char * url = tr_strstrip( tr_strdup( str ) );
-        if( !tr_urlIsValidTracker( url ) )
-            tr_free( url );
-        else {
-            trackers = tr_new0( tr_tracker_info, 1 );
-            trackers[trackerCount].tier = 0;
-            trackers[trackerCount].announce = url;
-            trackers[trackerCount].scrape = tr_convertAnnounceToScrape( url );
-            trackers[trackerCount].id = 0;
-            trackerCount++;
-            /*fprintf( stderr, "single announce: [%s]\n", url );*/
+      char * url = tr_strstrip (tr_strdup (str));
+      if (!tr_urlIsValidTracker (url))
+        {
+          tr_free (url);
+        }
+      else
+        {
+          trackers = tr_new0 (tr_tracker_info, 1);
+          trackers[trackerCount].tier = 0;
+          trackers[trackerCount].announce = url;
+          trackers[trackerCount].scrape = tr_convertAnnounceToScrape (url);
+          trackers[trackerCount].id = 0;
+          trackerCount++;
+          /*fprintf (stderr, "single announce: [%s]\n", url);*/
         }
     }
 
-    inf->trackers = trackers;
-    inf->trackerCount = trackerCount;
+  inf->trackers = trackers;
+  inf->trackerCount = trackerCount;
 
-    return NULL;
+  return NULL;
 }
 
 /**
@@ -371,277 +374,284 @@ getannounce( tr_info * inf, tr_benc * meta )
  * trailing slash for multifile torrents if omitted by the end user.
  */
 static char*
-fix_webseed_url( const tr_info * inf, const char * url_in )
+fix_webseed_url (const tr_info * inf, const char * url_in)
 {
-    size_t len;
-    char * url;
-    char * ret = NULL;
+  size_t len;
+  char * url;
+  char * ret = NULL;
 
-    url = tr_strdup( url_in );
-    tr_strstrip( url );
-    len = strlen( url );
+  url = tr_strdup (url_in);
+  tr_strstrip (url);
+  len = strlen (url);
 
-    if( tr_urlIsValid( url, len ) )
+  if (tr_urlIsValid (url, len))
     {
-        if( ( inf->fileCount > 1 ) && ( len > 0 ) && ( url[len-1] != '/' ) )
-            ret = tr_strdup_printf( "%*.*s/", (int)len, (int)len, url );
-        else
-            ret = tr_strndup( url, len );
+      if ((inf->fileCount > 1) && (len > 0) && (url[len-1] != '/'))
+        ret = tr_strdup_printf ("%*.*s/", (int)len, (int)len, url);
+      else
+        ret = tr_strndup (url, len);
     }
 
-    tr_free( url );
-    return ret;
+  tr_free (url);
+  return ret;
 }
 
 static void
-geturllist( tr_info * inf,
-            tr_benc * meta )
+geturllist (tr_info * inf, tr_benc * meta)
 {
-    tr_benc * urls;
-    const char * url;
+  tr_benc * urls;
+  const char * url;
 
-    if( tr_bencDictFindList( meta, "url-list", &urls ) )
+  if (tr_bencDictFindList (meta, "url-list", &urls))
     {
-        int          i;
-        const int    n = tr_bencListSize( urls );
+      int i;
+      const int n = tr_bencListSize (urls);
 
-        inf->webseedCount = 0;
-        inf->webseeds = tr_new0( char*, n );
+      inf->webseedCount = 0;
+      inf->webseeds = tr_new0 (char*, n);
 
-        for( i = 0; i < n; ++i )
+      for (i=0; i<n; i++)
         {
-            if( tr_bencGetStr( tr_bencListChild( urls, i ), &url ) )
+          if (tr_bencGetStr (tr_bencListChild (urls, i), &url))
             {
-                char * fixed_url = fix_webseed_url( inf, url );
+              char * fixed_url = fix_webseed_url (inf, url);
 
-                if( fixed_url != NULL )
-                    inf->webseeds[inf->webseedCount++] = fixed_url;
+              if (fixed_url != NULL)
+                inf->webseeds[inf->webseedCount++] = fixed_url;
             }
         }
     }
-    else if( tr_bencDictFindStr( meta, "url-list", &url ) ) /* handle single items in webseeds */
+  else if (tr_bencDictFindStr (meta, "url-list", &url)) /* handle single items in webseeds */
     {
-        char * fixed_url = fix_webseed_url( inf, url );
+      char * fixed_url = fix_webseed_url (inf, url);
 
-        if( fixed_url != NULL )
+      if (fixed_url != NULL)
         {
-            inf->webseedCount = 1;
-            inf->webseeds = tr_new0( char*, 1 );
-            inf->webseeds[0] = fixed_url;
+          inf->webseedCount = 1;
+          inf->webseeds = tr_new0 (char*, 1);
+          inf->webseeds[0] = fixed_url;
         }
     }
 }
 
 static const char*
-tr_metainfoParseImpl( const tr_session  * session,
+tr_metainfoParseImpl (const tr_session  * session,
                       tr_info           * inf,
                       bool              * hasInfoDict,
                       int               * infoDictLength,
-                      const tr_benc     * meta_in )
+                      const tr_benc     * meta_in)
 {
-    int64_t         i;
-    size_t          raw_len;
-    const char *    str;
-    const uint8_t * raw;
-    tr_benc *       d;
-    tr_benc *       infoDict = NULL;
-    tr_benc *       meta = (tr_benc *) meta_in;
-    bool            b;
-    bool            isMagnet = false;
-
-    /* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
-     * from the Metainfo file. Note that the value will be a bencoded
-     * dictionary, given the definition of the info key above. */
-    b = tr_bencDictFindDict( meta, "info", &infoDict );
-    if( hasInfoDict != NULL )
-        *hasInfoDict = b;
-    if( !b )
+  int64_t i;
+  size_t raw_len;
+  const char * str;
+  const uint8_t * raw;
+  tr_benc * d;
+  tr_benc * infoDict = NULL;
+  tr_benc * meta = (tr_benc *) meta_in;
+  bool b;
+  bool isMagnet = false;
+
+  /* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
+   * from the Metainfo file. Note that the value will be a bencoded
+   * dictionary, given the definition of the info key above. */
+  b = tr_bencDictFindDict (meta, "info", &infoDict);
+  if (hasInfoDict != NULL)
+    *hasInfoDict = b;
+
+  if (!b)
     {
-        /* no info dictionary... is this a magnet link? */
-        if( tr_bencDictFindDict( meta, "magnet-info", &d ) )
+      /* no info dictionary... is this a magnet link? */
+      if (tr_bencDictFindDict (meta, "magnet-info", &d))
         {
-            isMagnet = true;
-
-            /* get the info-hash */
-            if( !tr_bencDictFindRaw( d, "info_hash", &raw, &raw_len ) )
-                return "info_hash";
-            if( raw_len != SHA_DIGEST_LENGTH )
-                return "info_hash";
-            memcpy( inf->hash, raw, raw_len );
-            tr_sha1_to_hex( inf->hashString, inf->hash );
-
-            /* maybe get the display name */
-            if( tr_bencDictFindStr( d, "display-name", &str ) ) {
-                tr_free( inf->name );
-                inf->name = tr_strdup( str );
+          isMagnet = true;
+
+          /* get the info-hash */
+          if (!tr_bencDictFindRaw (d, "info_hash", &raw, &raw_len))
+            return "info_hash";
+          if (raw_len != SHA_DIGEST_LENGTH)
+            return "info_hash";
+          memcpy (inf->hash, raw, raw_len);
+          tr_sha1_to_hex (inf->hashString, inf->hash);
+
+          /* maybe get the display name */
+          if (tr_bencDictFindStr (d, "display-name", &str))
+            {
+              tr_free (inf->name);
+              inf->name = tr_strdup (str);
             }
 
-            if( !inf->name )
-                inf->name = tr_strdup( inf->hashString );
+          if (!inf->name)
+            inf->name = tr_strdup (inf->hashString);
         }
-        else /* not a magnet link and has no info dict... */
+      else /* not a magnet link and has no info dict... */
         {
-            return "info";
+          return "info";
         }
     }
-    else
+  else
     {
-        int len;
-        char * bstr = tr_bencToStr( infoDict, TR_FMT_BENC, &len );
-        tr_sha1( inf->hash, bstr, len, NULL );
-        tr_sha1_to_hex( inf->hashString, inf->hash );
+      int len;
+      char * bstr = tr_bencToStr (infoDict, TR_FMT_BENC, &len);
+      tr_sha1 (inf->hash, bstr, len, NULL);
+      tr_sha1_to_hex (inf->hashString, inf->hash);
 
-        if( infoDictLength != NULL )
-            *infoDictLength = len;
+      if (infoDictLength != NULL)
+        *infoDictLength = len;
 
-        tr_free( bstr );
+      tr_free (bstr);
     }
 
-    /* name */
-    if( !isMagnet ) {
-        if( !tr_bencDictFindStr( infoDict, "name.utf-8", &str ) )
-            if( !tr_bencDictFindStr( infoDict, "name", &str ) )
-                str = "";
-        if( !str || !*str )
-            return "name";
-        tr_free( inf->name );
-        inf->name = tr_utf8clean( str, -1 );
+  /* name */
+  if (!isMagnet)
+    {
+      if (!tr_bencDictFindStr (infoDict, "name.utf-8", &str))
+        if (!tr_bencDictFindStr (infoDict, "name", &str))
+          str = "";
+      if (!str || !*str)
+        return "name";
+      tr_free (inf->name);
+      inf->name = tr_utf8clean (str, -1);
     }
 
-    /* comment */
-    if( !tr_bencDictFindStr( meta, "comment.utf-8", &str ) )
-        if( !tr_bencDictFindStr( meta, "comment", &str ) )
-            str = "";
-    tr_free( inf->comment );
-    inf->comment = tr_utf8clean( str, -1 );
-
-    /* created by */
-    if( !tr_bencDictFindStr( meta, "created by.utf-8", &str ) )
-        if( !tr_bencDictFindStr( meta, "created by", &str ) )
-            str = "";
-    tr_free( inf->creator );
-    inf->creator = tr_utf8clean( str, -1 );
-
-    /* creation date */
-    if( !tr_bencDictFindInt( meta, "creation date", &i ) )
-        i = 0;
-    inf->dateCreated = i;
-
-    /* private */
-    if( !tr_bencDictFindInt( infoDict, "private", &i ) )
-        if( !tr_bencDictFindInt( meta, "private", &i ) )
-            i = 0;
-    inf->isPrivate = i != 0;
-
-    /* piece length */
-    if( !isMagnet ) {
-        if( !tr_bencDictFindInt( infoDict, "piece length", &i ) || ( i < 1 ) )
-            return "piece length";
-        inf->pieceSize = i;
+  /* comment */
+  if (!tr_bencDictFindStr (meta, "comment.utf-8", &str))
+    if (!tr_bencDictFindStr (meta, "comment", &str))
+      str = "";
+  tr_free (inf->comment);
+  inf->comment = tr_utf8clean (str, -1);
+
+  /* created by */
+  if (!tr_bencDictFindStr (meta, "created by.utf-8", &str))
+    if (!tr_bencDictFindStr (meta, "created by", &str))
+      str = "";
+  tr_free (inf->creator);
+  inf->creator = tr_utf8clean (str, -1);
+
+  /* creation date */
+  if (!tr_bencDictFindInt (meta, "creation date", &i))
+    i = 0;
+  inf->dateCreated = i;
+
+  /* private */
+  if (!tr_bencDictFindInt (infoDict, "private", &i))
+    if (!tr_bencDictFindInt (meta, "private", &i))
+      i = 0;
+  inf->isPrivate = i != 0;
+
+  /* piece length */
+  if (!isMagnet)
+    {
+      if (!tr_bencDictFindInt (infoDict, "piece length", &i) || (i < 1))
+        return "piece length";
+      inf->pieceSize = i;
     }
 
-    /* pieces */
-    if( !isMagnet ) {
-        if( !tr_bencDictFindRaw( infoDict, "pieces", &raw, &raw_len ) )
-            return "pieces";
-        if( raw_len % SHA_DIGEST_LENGTH )
-            return "pieces";
-        inf->pieceCount = raw_len / SHA_DIGEST_LENGTH;
-        inf->pieces = tr_new0( tr_piece, inf->pieceCount );
-        for( i = 0; i < inf->pieceCount; ++i )
-            memcpy( inf->pieces[i].hash, &raw[i * SHA_DIGEST_LENGTH],
-                    SHA_DIGEST_LENGTH );
+  /* pieces */
+  if (!isMagnet)
+    {
+      if (!tr_bencDictFindRaw (infoDict, "pieces", &raw, &raw_len))
+        return "pieces";
+      if (raw_len % SHA_DIGEST_LENGTH)
+        return "pieces";
+
+      inf->pieceCount = raw_len / SHA_DIGEST_LENGTH;
+      inf->pieces = tr_new0 (tr_piece, inf->pieceCount);
+      for (i=0; i<inf->pieceCount; i++)
+        memcpy (inf->pieces[i].hash, &raw[i * SHA_DIGEST_LENGTH], SHA_DIGEST_LENGTH);
     }
 
-    /* files */
-    if( !isMagnet ) {
-        if( ( str = parseFiles( inf, tr_bencDictFind( infoDict, "files" ),
-                                     tr_bencDictFind( infoDict, "length" ) ) ) )
-            return str;
-        if( !inf->fileCount || !inf->totalSize )
-            return "files";
-        if( (uint64_t) inf->pieceCount !=
-           ( inf->totalSize + inf->pieceSize - 1 ) / inf->pieceSize )
-            return "files";
+  /* files */
+  if (!isMagnet)
+    {
+      if ((str = parseFiles (inf, tr_bencDictFind (infoDict, "files"),
+                                  tr_bencDictFind (infoDict, "length"))))
+        return str;
+
+      if (!inf->fileCount || !inf->totalSize)
+        return "files";
+
+      if ((uint64_t) inf->pieceCount != (inf->totalSize + inf->pieceSize - 1) / inf->pieceSize)
+        return "files";
     }
 
-    /* get announce or announce-list */
-    if( ( str = getannounce( inf, meta ) ) )
-        return str;
+  /* get announce or announce-list */
+  if ((str = getannounce (inf, meta)))
+    return str;
 
-    /* get the url-list */
-    geturllist( inf, meta );
+  /* get the url-list */
+  geturllist (inf, meta);
 
-    /* filename of Transmission's copy */
-    tr_free( inf->torrent );
-    inf->torrent = session ?  getTorrentFilename( session, inf ) : NULL;
+  /* filename of Transmission's copy */
+  tr_free (inf->torrent);
+  inf->torrent = session ?  getTorrentFilename (session, inf) : NULL;
 
-    return NULL;
+  return NULL;
 }
 
 bool
-tr_metainfoParse( const tr_session * session,
+tr_metainfoParse (const tr_session * session,
                   const tr_benc    * meta_in,
                   tr_info          * inf,
                   bool             * hasInfoDict,
-                  int              * infoDictLength )
+                  int              * infoDictLength)
 {
-    const char * badTag = tr_metainfoParseImpl( session,
-                                                inf,
-                                                hasInfoDict,
-                                                infoDictLength,
-                                                meta_in );
-    const bool success = badTag == NULL;
-
-    if( badTag )
+  const char * badTag = tr_metainfoParseImpl (session,
+                                              inf,
+                                              hasInfoDict,
+                                              infoDictLength,
+                                              meta_in);
+  const bool success = badTag == NULL;
+
+  if (badTag)
     {
-        tr_nerr( inf->name, _( "Invalid metadata entry \"%s\"" ), badTag );
-        tr_metainfoFree( inf );
+      tr_nerr (inf->name, _ ("Invalid metadata entry \"%s\""), badTag);
+      tr_metainfoFree (inf);
     }
 
-    return success;
+  return success;
 }
 
 void
-tr_metainfoFree( tr_info * inf )
+tr_metainfoFree (tr_info * inf)
 {
-    int i;
-    tr_file_index_t ff;
+  int i;
+  tr_file_index_t ff;
 
-    for( i = 0; i < inf->webseedCount; ++i )
-        tr_free( inf->webseeds[i] );
+  for (i=0; i<inf->webseedCount; i++)
+    tr_free (inf->webseeds[i]);
 
-    for( ff = 0; ff < inf->fileCount; ++ff )
-        tr_free( inf->files[ff].name );
+  for (ff=0; ff<inf->fileCount; ff++)
+      tr_free (inf->files[ff].name);
 
-    tr_free( inf->webseeds );
-    tr_free( inf->pieces );
-    tr_free( inf->files );
-    tr_free( inf->comment );
-    tr_free( inf->creator );
-    tr_free( inf->torrent );
-    tr_free( inf->name );
+  tr_free (inf->webseeds);
+  tr_free (inf->pieces);
+  tr_free (inf->files);
+  tr_free (inf->comment);
+  tr_free (inf->creator);
+  tr_free (inf->torrent);
+  tr_free (inf->name);
 
-    for( i = 0; i < inf->trackerCount; ++i )
+  for (i=0; i<inf->trackerCount; i++)
     {
-        tr_free( inf->trackers[i].announce );
-        tr_free( inf->trackers[i].scrape );
+      tr_free (inf->trackers[i].announce);
+      tr_free (inf->trackers[i].scrape);
     }
-    tr_free( inf->trackers );
+  tr_free (inf->trackers);
 
-    memset( inf, '\0', sizeof( tr_info ) );
+  memset (inf, '\0', sizeof (tr_info));
 }
 
 void
-tr_metainfoRemoveSaved( const tr_session * session, const tr_info * inf )
+tr_metainfoRemoveSaved (const tr_session * session, const tr_info * inf)
 {
-    char * filename;
+  char * filename;
 
-    filename = getTorrentFilename( session, inf );
-    unlink( filename );
-    tr_free( filename );
+  filename = getTorrentFilename (session, inf);
+  unlink (filename);
+  tr_free (filename);
 
-    filename = getOldTorrentFilename( session, inf );
-    unlink( filename );
-    tr_free( filename );
+  filename = getOldTorrentFilename (session, inf);
+  unlink (filename);
+  tr_free (filename);
 }
+
diff --git a/libtransmission/metainfo.h b/libtransmission/metainfo.h
index b29d843b6..07f88d5a5 100644
--- a/libtransmission/metainfo.h
+++ b/libtransmission/metainfo.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -21,19 +21,19 @@
 
 struct tr_benc;
 
-bool  tr_metainfoParse( const tr_session     * session,
+bool  tr_metainfoParse (const tr_session     * session,
                         const struct tr_benc * benc,
                         tr_info              * setmeInfo,
                         bool                 * setmeHasInfoDict,
-                        int                  * setmeInfoDictLength );
+                        int                  * setmeInfoDictLength);
 
-void tr_metainfoRemoveSaved( const tr_session * session,
-                             const tr_info    * info );
+void tr_metainfoRemoveSaved (const tr_session * session,
+                             const tr_info    * info);
 
-void tr_metainfoMigrate( tr_session * session,
-                         tr_info    * inf );
+void tr_metainfoMigrate (tr_session * session,
+                         tr_info    * inf);
 
-char* tr_metainfoGetBasename( const tr_info * );
+char* tr_metainfoGetBasename (const tr_info *);
 
 
 #endif
diff --git a/libtransmission/natpmp.c b/libtransmission/natpmp.c
index 8b30fd2ca..afa3a7fd6 100644
--- a/libtransmission/natpmp.c
+++ b/libtransmission/natpmp.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -14,7 +14,7 @@
 #include <time.h>
 #include <inttypes.h>
 
-#include <event2/util.h> /* evutil_inet_ntop() */
+#include <event2/util.h> /* evutil_inet_ntop () */
 
 #define ENABLE_STRNATPMPERR
 #include "natpmp.h"
@@ -29,7 +29,7 @@
 #define COMMAND_WAIT_SECS 8
 
 static const char *
-getKey( void ) { return _( "Port Forwarding (NAT-PMP)" ); }
+getKey (void) { return _ ("Port Forwarding (NAT-PMP)"); }
 
 typedef enum
 {
@@ -63,26 +63,26 @@ struct tr_natpmp
 **/
 
 static void
-logVal( const char * func,
-        int          ret )
+logVal (const char * func,
+        int          ret)
 {
-    if( ret == NATPMP_TRYAGAIN )
+    if (ret == NATPMP_TRYAGAIN)
         return;
-    if( ret >= 0 )
-        tr_ninf( getKey( ), _( "%s succeeded (%d)" ), func, ret );
+    if (ret >= 0)
+        tr_ninf (getKey (), _ ("%s succeeded (%d)"), func, ret);
     else
-        tr_ndbg(
-             getKey( ),
+        tr_ndbg (
+             getKey (),
             "%s failed. Natpmp returned %d (%s); errno is %d (%s)",
-            func, ret, strnatpmperr( ret ), errno, tr_strerror( errno ) );
+            func, ret, strnatpmperr (ret), errno, tr_strerror (errno));
 }
 
 struct tr_natpmp*
-tr_natpmpInit( void )
+tr_natpmpInit (void)
 {
     struct tr_natpmp * nat;
 
-    nat = tr_new0( struct tr_natpmp, 1 );
+    nat = tr_new0 (struct tr_natpmp, 1);
     nat->state = TR_NATPMP_DISCOVER;
     nat->public_port = 0;
     nat->private_port = 0;
@@ -91,91 +91,91 @@ tr_natpmpInit( void )
 }
 
 void
-tr_natpmpClose( tr_natpmp * nat )
+tr_natpmpClose (tr_natpmp * nat)
 {
-    if( nat )
+    if (nat)
     {
-        if( nat->natpmp.s >= 0 )
-            tr_netCloseSocket( nat->natpmp.s );
-        tr_free( nat );
+        if (nat->natpmp.s >= 0)
+            tr_netCloseSocket (nat->natpmp.s);
+        tr_free (nat);
     }
 }
 
 static int
-canSendCommand( const struct tr_natpmp * nat )
+canSendCommand (const struct tr_natpmp * nat)
 {
-    return tr_time( ) >= nat->command_time;
+    return tr_time () >= nat->command_time;
 }
 
 static void
-setCommandTime( struct tr_natpmp * nat )
+setCommandTime (struct tr_natpmp * nat)
 {
-    nat->command_time = tr_time( ) + COMMAND_WAIT_SECS;
+    nat->command_time = tr_time () + COMMAND_WAIT_SECS;
 }
 
 int
-tr_natpmpPulse( struct tr_natpmp * nat, tr_port private_port, bool is_enabled, tr_port * public_port )
+tr_natpmpPulse (struct tr_natpmp * nat, tr_port private_port, bool is_enabled, tr_port * public_port)
 {
     int ret;
 
-    if( is_enabled && ( nat->state == TR_NATPMP_DISCOVER ) )
+    if (is_enabled && (nat->state == TR_NATPMP_DISCOVER))
     {
-        int val = initnatpmp( &nat->natpmp, 0, 0 );
-        logVal( "initnatpmp", val );
-        val = sendpublicaddressrequest( &nat->natpmp );
-        logVal( "sendpublicaddressrequest", val );
+        int val = initnatpmp (&nat->natpmp, 0, 0);
+        logVal ("initnatpmp", val);
+        val = sendpublicaddressrequest (&nat->natpmp);
+        logVal ("sendpublicaddressrequest", val);
         nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_PUB;
         nat->has_discovered = true;
-        setCommandTime( nat );
+        setCommandTime (nat);
     }
 
-    if( ( nat->state == TR_NATPMP_RECV_PUB ) && canSendCommand( nat ) )
+    if ((nat->state == TR_NATPMP_RECV_PUB) && canSendCommand (nat))
     {
         natpmpresp_t response;
-        const int val = readnatpmpresponseorretry( &nat->natpmp, &response );
-        logVal( "readnatpmpresponseorretry", val );
-        if( val >= 0 )
+        const int val = readnatpmpresponseorretry (&nat->natpmp, &response);
+        logVal ("readnatpmpresponseorretry", val);
+        if (val >= 0)
         {
             char str[128];
-            evutil_inet_ntop( AF_INET, &response.pnu.publicaddress.addr, str, sizeof( str ) );
-            tr_ninf( getKey( ), _( "Found public address \"%s\"" ), str );
+            evutil_inet_ntop (AF_INET, &response.pnu.publicaddress.addr, str, sizeof (str));
+            tr_ninf (getKey (), _ ("Found public address \"%s\""), str);
             nat->state = TR_NATPMP_IDLE;
         }
-        else if( val != NATPMP_TRYAGAIN )
+        else if (val != NATPMP_TRYAGAIN)
         {
             nat->state = TR_NATPMP_ERR;
         }
     }
 
-    if( ( nat->state == TR_NATPMP_IDLE ) || ( nat->state == TR_NATPMP_ERR ) )
+    if ((nat->state == TR_NATPMP_IDLE) || (nat->state == TR_NATPMP_ERR))
     {
-        if( nat->is_mapped && ( !is_enabled || ( nat->private_port != private_port ) ) )
+        if (nat->is_mapped && (!is_enabled || (nat->private_port != private_port)))
             nat->state = TR_NATPMP_SEND_UNMAP;
     }
 
-    if( ( nat->state == TR_NATPMP_SEND_UNMAP ) && canSendCommand( nat ) )
+    if ((nat->state == TR_NATPMP_SEND_UNMAP) && canSendCommand (nat))
     {
-        const int val = sendnewportmappingrequest( &nat->natpmp, NATPMP_PROTOCOL_TCP,
+        const int val = sendnewportmappingrequest (&nat->natpmp, NATPMP_PROTOCOL_TCP,
                                                    nat->private_port,
                                                    nat->public_port,
-                                                   0 );
-        logVal( "sendnewportmappingrequest", val );
+                                                   0);
+        logVal ("sendnewportmappingrequest", val);
         nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_UNMAP;
-        setCommandTime( nat );
+        setCommandTime (nat);
     }
 
-    if( nat->state == TR_NATPMP_RECV_UNMAP )
+    if (nat->state == TR_NATPMP_RECV_UNMAP)
     {
         natpmpresp_t resp;
-        const int val = readnatpmpresponseorretry( &nat->natpmp, &resp );
-        logVal( "readnatpmpresponseorretry", val );
-        if( val >= 0 )
+        const int val = readnatpmpresponseorretry (&nat->natpmp, &resp);
+        logVal ("readnatpmpresponseorretry", val);
+        if (val >= 0)
         {
             const int private_port = resp.pnu.newportmapping.privateport;
 
-            tr_ninf( getKey( ), _( "no longer forwarding port %d" ), private_port );
+            tr_ninf (getKey (), _ ("no longer forwarding port %d"), private_port);
 
-            if( nat->private_port == private_port )
+            if (nat->private_port == private_port)
             {
                 nat->private_port = 0;
                 nat->public_port = 0;
@@ -183,50 +183,50 @@ tr_natpmpPulse( struct tr_natpmp * nat, tr_port private_port, bool is_enabled, t
                 nat->is_mapped = false;
             }
         }
-        else if( val != NATPMP_TRYAGAIN )
+        else if (val != NATPMP_TRYAGAIN)
         {
             nat->state = TR_NATPMP_ERR;
         }
     }
 
-    if( nat->state == TR_NATPMP_IDLE )
+    if (nat->state == TR_NATPMP_IDLE)
     {
-        if( is_enabled && !nat->is_mapped && nat->has_discovered )
+        if (is_enabled && !nat->is_mapped && nat->has_discovered)
             nat->state = TR_NATPMP_SEND_MAP;
 
-        else if( nat->is_mapped && tr_time( ) >= nat->renew_time )
+        else if (nat->is_mapped && tr_time () >= nat->renew_time)
             nat->state = TR_NATPMP_SEND_MAP;
     }
 
-    if( ( nat->state == TR_NATPMP_SEND_MAP ) && canSendCommand( nat ) )
+    if ((nat->state == TR_NATPMP_SEND_MAP) && canSendCommand (nat))
     {
-        const int val = sendnewportmappingrequest( &nat->natpmp, NATPMP_PROTOCOL_TCP, private_port, private_port, LIFETIME_SECS );
-        logVal( "sendnewportmappingrequest", val );
+        const int val = sendnewportmappingrequest (&nat->natpmp, NATPMP_PROTOCOL_TCP, private_port, private_port, LIFETIME_SECS);
+        logVal ("sendnewportmappingrequest", val);
         nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_MAP;
-        setCommandTime( nat );
+        setCommandTime (nat);
     }
 
-    if( nat->state == TR_NATPMP_RECV_MAP )
+    if (nat->state == TR_NATPMP_RECV_MAP)
     {
         natpmpresp_t resp;
-        const int    val = readnatpmpresponseorretry( &nat->natpmp, &resp );
-        logVal( "readnatpmpresponseorretry", val );
-        if( val >= 0 )
+        const int    val = readnatpmpresponseorretry (&nat->natpmp, &resp);
+        logVal ("readnatpmpresponseorretry", val);
+        if (val >= 0)
         {
             nat->state = TR_NATPMP_IDLE;
             nat->is_mapped = true;
-            nat->renew_time = tr_time( ) + ( resp.pnu.newportmapping.lifetime / 2 );
+            nat->renew_time = tr_time () + (resp.pnu.newportmapping.lifetime / 2);
             nat->private_port = resp.pnu.newportmapping.privateport;
             nat->public_port = resp.pnu.newportmapping.mappedpublicport;
-            tr_ninf( getKey( ), _( "Port %d forwarded successfully" ), nat->private_port );
+            tr_ninf (getKey (), _ ("Port %d forwarded successfully"), nat->private_port);
         }
-        else if( val != NATPMP_TRYAGAIN )
+        else if (val != NATPMP_TRYAGAIN)
         {
             nat->state = TR_NATPMP_ERR;
         }
     }
 
-    switch( nat->state )
+    switch (nat->state)
     {
         case TR_NATPMP_IDLE:
             *public_port = nat->public_port;
diff --git a/libtransmission/natpmp_local.h b/libtransmission/natpmp_local.h
index 0ed7ef1c0..7a915ce7c 100644
--- a/libtransmission/natpmp_local.h
+++ b/libtransmission/natpmp_local.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -24,11 +24,11 @@
 
 typedef struct tr_natpmp tr_natpmp;
 
-tr_natpmp * tr_natpmpInit( void );
+tr_natpmp * tr_natpmpInit (void);
 
-void tr_natpmpClose( tr_natpmp * );
+void tr_natpmpClose (tr_natpmp *);
 
-int tr_natpmpPulse( tr_natpmp *, tr_port port, bool isEnabled, tr_port * public_port );
+int tr_natpmpPulse (tr_natpmp *, tr_port port, bool isEnabled, tr_port * public_port);
 
 /* @} */
 #endif
diff --git a/libtransmission/net.c b/libtransmission/net.c
index eb05de633..836cb5554 100644
--- a/libtransmission/net.c
+++ b/libtransmission/net.c
@@ -41,81 +41,81 @@
 #include <libutp/utp.h>
 
 #include "transmission.h"
-#include "fdlimit.h" /* tr_fdSocketClose() */
+#include "fdlimit.h" /* tr_fdSocketClose () */
 #include "net.h"
-#include "peer-io.h" /* tr_peerIoAddrStr() FIXME this should be moved to net.h */
-#include "session.h" /* tr_sessionGetPublicAddress() */
-#include "tr-utp.h" /* tr_utpSendTo() */
-#include "utils.h" /* tr_time(), tr_dbg() */
+#include "peer-io.h" /* tr_peerIoAddrStr () FIXME this should be moved to net.h */
+#include "session.h" /* tr_sessionGetPublicAddress () */
+#include "tr-utp.h" /* tr_utpSendTo () */
+#include "utils.h" /* tr_time (), tr_dbg () */
 
 #ifndef IN_MULTICAST
-#define IN_MULTICAST( a ) ( ( ( a ) & 0xf0000000 ) == 0xe0000000 )
+#define IN_MULTICAST(a) (((a) & 0xf0000000) == 0xe0000000)
 #endif
 
 const tr_address tr_in6addr_any = { TR_AF_INET6, { IN6ADDR_ANY_INIT } };
 const tr_address tr_inaddr_any = { TR_AF_INET, { { { { INADDR_ANY, 0x00, 0x00, 0x00 } } } } };
 
 void
-tr_netInit( void )
+tr_netInit (void)
 {
     static int initialized = false;
 
-    if( !initialized )
+    if (!initialized)
     {
 #ifdef WIN32
         WSADATA wsaData;
-        WSAStartup( MAKEWORD( 2, 2 ), &wsaData );
+        WSAStartup (MAKEWORD (2, 2), &wsaData);
 #endif
         initialized = true;
     }
 }
 
 char *
-tr_net_strerror( char * buf, size_t buflen, int err )
+tr_net_strerror (char * buf, size_t buflen, int err)
 {
     *buf = '\0';
 #ifdef WIN32
-    FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, buflen, NULL );
+    FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, buf, buflen, NULL);
 #else
-    tr_strlcpy( buf, tr_strerror( err ), buflen );
+    tr_strlcpy (buf, tr_strerror (err), buflen);
 #endif
     return buf;
 }
 
 const char *
-tr_address_to_string_with_buf( const tr_address * addr, char * buf, size_t buflen )
+tr_address_to_string_with_buf (const tr_address * addr, char * buf, size_t buflen)
 {
-    assert( tr_address_is_valid( addr ) );
+    assert (tr_address_is_valid (addr));
 
-    if( addr->type == TR_AF_INET )
-        return evutil_inet_ntop( AF_INET, &addr->addr, buf, buflen );
+    if (addr->type == TR_AF_INET)
+        return evutil_inet_ntop (AF_INET, &addr->addr, buf, buflen);
     else
-        return evutil_inet_ntop( AF_INET6, &addr->addr, buf, buflen );
+        return evutil_inet_ntop (AF_INET6, &addr->addr, buf, buflen);
 }
 
 /*
- * Non-threadsafe version of tr_address_to_string_with_buf()
+ * Non-threadsafe version of tr_address_to_string_with_buf ()
  * and uses a static memory area for a buffer.
  * This function is suitable to be called from libTransmission's networking code,
  * which is single-threaded.
  */
 const char *
-tr_address_to_string( const tr_address * addr )
+tr_address_to_string (const tr_address * addr)
 {
     static char buf[INET6_ADDRSTRLEN];
-    return tr_address_to_string_with_buf( addr, buf, sizeof( buf ) );
+    return tr_address_to_string_with_buf (addr, buf, sizeof (buf));
 }
 
 bool
-tr_address_from_string( tr_address * dst, const char * src )
+tr_address_from_string (tr_address * dst, const char * src)
 {
     bool ok;
 
-    if(( ok = evutil_inet_pton( AF_INET, src, &dst->addr ) == 1 ))
+    if ((ok = evutil_inet_pton (AF_INET, src, &dst->addr) == 1))
         dst->type = TR_AF_INET;
 
-    if( !ok ) /* try IPv6 */
-        if(( ok = evutil_inet_pton( AF_INET6, src, &dst->addr ) == 1 ))
+    if (!ok) /* try IPv6 */
+        if ((ok = evutil_inet_pton (AF_INET6, src, &dst->addr) == 1))
             dst->type = TR_AF_INET6;
 
     return ok;
@@ -129,15 +129,15 @@ tr_address_from_string( tr_address * dst, const char * src )
  * 0  if a == b
  */
 int
-tr_address_compare( const tr_address * a, const tr_address * b)
+tr_address_compare (const tr_address * a, const tr_address * b)
 {
-    static const int sizes[2] = { sizeof(struct in_addr), sizeof(struct in6_addr) };
+    static const int sizes[2] = { sizeof (struct in_addr), sizeof (struct in6_addr) };
 
     /* IPv6 addresses are always "greater than" IPv4 */
-    if( a->type != b->type )
+    if (a->type != b->type)
         return a->type == TR_AF_INET ? 1 : -1;
 
-    return memcmp( &a->addr, &b->addr, sizes[a->type] );
+    return memcmp (&a->addr, &b->addr, sizes[a->type]);
 }
 
 /***********************************************************************
@@ -145,21 +145,21 @@ tr_address_compare( const tr_address * a, const tr_address * b)
  **********************************************************************/
 
 int
-tr_netSetTOS( int s, int tos )
+tr_netSetTOS (int s, int tos)
 {
 #ifdef IP_TOS
-    return setsockopt( s, IPPROTO_IP, IP_TOS, (char*)&tos, sizeof( tos ) );
+    return setsockopt (s, IPPROTO_IP, IP_TOS, (char*)&tos, sizeof (tos));
 #else
     return 0;
 #endif
 }
 
 int
-tr_netSetCongestionControl( int s UNUSED, const char *algorithm UNUSED )
+tr_netSetCongestionControl (int s UNUSED, const char *algorithm UNUSED)
 {
 #ifdef TCP_CONGESTION
-    return setsockopt( s, IPPROTO_TCP, TCP_CONGESTION,
-                       algorithm, strlen(algorithm) + 1 );
+    return setsockopt (s, IPPROTO_TCP, TCP_CONGESTION,
+                       algorithm, strlen (algorithm) + 1);
 #else
     errno = ENOSYS;
     return -1;
@@ -167,11 +167,11 @@ tr_netSetCongestionControl( int s UNUSED, const char *algorithm UNUSED )
 }
 
 bool
-tr_address_from_sockaddr_storage( tr_address                     * setme_addr,
+tr_address_from_sockaddr_storage (tr_address                     * setme_addr,
                                   tr_port                        * setme_port,
-                                  const struct sockaddr_storage  * from )
+                                  const struct sockaddr_storage  * from)
 {
-    if( from->ss_family == AF_INET )
+    if (from->ss_family == AF_INET)
     {
         struct sockaddr_in * sin = (struct sockaddr_in *)from;
         setme_addr->type = TR_AF_INET;
@@ -180,7 +180,7 @@ tr_address_from_sockaddr_storage( tr_address                     * setme_addr,
         return true;
     }
 
-    if( from->ss_family == AF_INET6 )
+    if (from->ss_family == AF_INET6)
     {
         struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) from;
         setme_addr->type = TR_AF_INET6;
@@ -193,40 +193,40 @@ tr_address_from_sockaddr_storage( tr_address                     * setme_addr,
 }
 
 static socklen_t
-setup_sockaddr( const tr_address        * addr,
+setup_sockaddr (const tr_address        * addr,
                 tr_port                   port,
                 struct sockaddr_storage * sockaddr)
 {
-    assert( tr_address_is_valid( addr ) );
+    assert (tr_address_is_valid (addr));
 
-    if( addr->type == TR_AF_INET )
+    if (addr->type == TR_AF_INET)
     {
         struct sockaddr_in  sock4;
-        memset( &sock4, 0, sizeof( sock4 ) );
+        memset (&sock4, 0, sizeof (sock4));
         sock4.sin_family      = AF_INET;
         sock4.sin_addr.s_addr = addr->addr.addr4.s_addr;
         sock4.sin_port        = port;
-        memcpy( sockaddr, &sock4, sizeof( sock4 ) );
-        return sizeof( struct sockaddr_in );
+        memcpy (sockaddr, &sock4, sizeof (sock4));
+        return sizeof (struct sockaddr_in);
     }
     else
     {
         struct sockaddr_in6 sock6;
-        memset( &sock6, 0, sizeof( sock6 ) );
+        memset (&sock6, 0, sizeof (sock6));
         sock6.sin6_family   = AF_INET6;
         sock6.sin6_port     = port;
         sock6.sin6_flowinfo = 0;
         sock6.sin6_addr     = addr->addr.addr6;
-        memcpy( sockaddr, &sock6, sizeof( sock6 ) );
-        return sizeof( struct sockaddr_in6 );
+        memcpy (sockaddr, &sock6, sizeof (sock6));
+        return sizeof (struct sockaddr_in6);
     }
 }
 
 int
-tr_netOpenPeerSocket( tr_session        * session,
+tr_netOpenPeerSocket (tr_session        * session,
                       const tr_address  * addr,
                       tr_port             port,
-                      bool                clientIsSeed )
+                      bool                clientIsSeed)
 {
     static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
     int                     s;
@@ -236,80 +236,80 @@ tr_netOpenPeerSocket( tr_session        * session,
     socklen_t               sourcelen;
     struct sockaddr_storage source_sock;
 
-    assert( tr_address_is_valid( addr ) );
+    assert (tr_address_is_valid (addr));
 
-    if( !tr_address_is_valid_for_peers( addr, port ) )
+    if (!tr_address_is_valid_for_peers (addr, port))
         return -EINVAL;
 
-    s = tr_fdSocketCreate( session, domains[addr->type], SOCK_STREAM );
-    if( s < 0 )
+    s = tr_fdSocketCreate (session, domains[addr->type], SOCK_STREAM);
+    if (s < 0)
         return -1;
 
     /* seeds don't need much of a read buffer... */
-    if( clientIsSeed ) {
+    if (clientIsSeed) {
         int n = 8192;
-        if( setsockopt( s, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n) ) )
-            tr_inf( "Unable to set SO_RCVBUF on socket %d: %s", s, tr_strerror( sockerrno ) );
+        if (setsockopt (s, SOL_SOCKET, SO_RCVBUF, &n, sizeof (n)))
+            tr_inf ("Unable to set SO_RCVBUF on socket %d: %s", s, tr_strerror (sockerrno));
     }
 
-    if( evutil_make_socket_nonblocking( s ) < 0 ) {
-        tr_netClose( session, s );
+    if (evutil_make_socket_nonblocking (s) < 0) {
+        tr_netClose (session, s);
         return -1;
     }
 
-    addrlen = setup_sockaddr( addr, port, &sock );
+    addrlen = setup_sockaddr (addr, port, &sock);
 
     /* set source address */
-    source_addr = tr_sessionGetPublicAddress( session, addr->type, NULL );
-    assert( source_addr );
-    sourcelen = setup_sockaddr( source_addr, 0, &source_sock );
-    if( bind( s, ( struct sockaddr * ) &source_sock, sourcelen ) )
+    source_addr = tr_sessionGetPublicAddress (session, addr->type, NULL);
+    assert (source_addr);
+    sourcelen = setup_sockaddr (source_addr, 0, &source_sock);
+    if (bind (s, (struct sockaddr *) &source_sock, sourcelen))
     {
-        tr_err( _( "Couldn't set source address %s on %d: %s" ),
-                tr_address_to_string( source_addr ), s, tr_strerror( errno ) );
+        tr_err (_ ("Couldn't set source address %s on %d: %s"),
+                tr_address_to_string (source_addr), s, tr_strerror (errno));
         return -errno;
     }
 
-    if( ( connect( s, (struct sockaddr *) &sock,
-                  addrlen ) < 0 )
+    if ((connect (s, (struct sockaddr *) &sock,
+                  addrlen) < 0)
 #ifdef WIN32
-      && ( sockerrno != WSAEWOULDBLOCK )
+      && (sockerrno != WSAEWOULDBLOCK)
 #endif
-      && ( sockerrno != EINPROGRESS ) )
+      && (sockerrno != EINPROGRESS))
     {
         int tmperrno;
         tmperrno = sockerrno;
-        if( ( tmperrno != ENETUNREACH && tmperrno != EHOSTUNREACH )
-                || addr->type == TR_AF_INET )
-            tr_err( _( "Couldn't connect socket %d to %s, port %d (errno %d - %s)" ),
-                    s, tr_address_to_string( addr ), (int)ntohs( port ), tmperrno,
-                    tr_strerror( tmperrno ) );
-        tr_netClose( session, s );
+        if ((tmperrno != ENETUNREACH && tmperrno != EHOSTUNREACH)
+                || addr->type == TR_AF_INET)
+            tr_err (_ ("Couldn't connect socket %d to %s, port %d (errno %d - %s)"),
+                    s, tr_address_to_string (addr), (int)ntohs (port), tmperrno,
+                    tr_strerror (tmperrno));
+        tr_netClose (session, s);
         s = -tmperrno;
     }
 
-    tr_deepLog( __FILE__, __LINE__, NULL, "New OUTGOING connection %d (%s)",
-               s, tr_peerIoAddrStr( addr, port ) );
+    tr_deepLog (__FILE__, __LINE__, NULL, "New OUTGOING connection %d (%s)",
+               s, tr_peerIoAddrStr (addr, port));
 
     return s;
 }
 
 struct UTPSocket *
-tr_netOpenPeerUTPSocket( tr_session        * session,
+tr_netOpenPeerUTPSocket (tr_session        * session,
                          const tr_address  * addr,
                          tr_port             port,
-                         bool                clientIsSeed UNUSED )
+                         bool                clientIsSeed UNUSED)
 {
     struct sockaddr_storage ss;
     socklen_t sslen;
-    sslen = setup_sockaddr( addr, port, &ss );
+    sslen = setup_sockaddr (addr, port, &ss);
 
-    return UTP_Create( tr_utpSendTo, (void*)session,
-                       (struct sockaddr*)&ss, sslen );
+    return UTP_Create (tr_utpSendTo, (void*)session,
+                     (struct sockaddr*)&ss, sslen);
 }
 
 static int
-tr_netBindTCPImpl( const tr_address * addr, tr_port port, bool suppressMsgs, int * errOut )
+tr_netBindTCPImpl (const tr_address * addr, tr_port port, bool suppressMsgs, int * errOut)
 {
     static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
     struct sockaddr_storage sock;
@@ -317,64 +317,64 @@ tr_netBindTCPImpl( const tr_address * addr, tr_port port, bool suppressMsgs, int
     int addrlen;
     int optval;
 
-    assert( tr_address_is_valid( addr ) );
+    assert (tr_address_is_valid (addr));
 
-    fd = socket( domains[addr->type], SOCK_STREAM, 0 );
-    if( fd < 0 ) {
+    fd = socket (domains[addr->type], SOCK_STREAM, 0);
+    if (fd < 0) {
         *errOut = sockerrno;
         return -1;
     }
 
-    if( evutil_make_socket_nonblocking( fd ) < 0 ) {
+    if (evutil_make_socket_nonblocking (fd) < 0) {
         *errOut = sockerrno;
-        tr_netCloseSocket( fd );
+        tr_netCloseSocket (fd);
         return -1;
     }
 
     optval = 1;
-    setsockopt( fd, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval) );
-    setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval) );
+    setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof (optval));
+    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof (optval));
 
 #ifdef IPV6_V6ONLY
-    if( addr->type == TR_AF_INET6 )
-        if( setsockopt( fd, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof( optval ) ) == -1 )
-            if( sockerrno != ENOPROTOOPT ) { /* if the kernel doesn't support it, ignore it */
+    if (addr->type == TR_AF_INET6)
+        if (setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof (optval)) == -1)
+            if (sockerrno != ENOPROTOOPT) { /* if the kernel doesn't support it, ignore it */
                 *errOut = sockerrno;
                 return -1;
             }
 #endif
 
-    addrlen = setup_sockaddr( addr, htons( port ), &sock );
-    if( bind( fd, (struct sockaddr *) &sock, addrlen ) ) {
+    addrlen = setup_sockaddr (addr, htons (port), &sock);
+    if (bind (fd, (struct sockaddr *) &sock, addrlen)) {
         const int err = sockerrno;
-        if( !suppressMsgs )
+        if (!suppressMsgs)
         {
             const char * fmt;
             const char * hint;
 
-            if( err == EADDRINUSE )
-                hint = _( "Is another copy of Transmission already running?" );
+            if (err == EADDRINUSE)
+                hint = _ ("Is another copy of Transmission already running?");
             else
                 hint = NULL;
 
-            if( hint == NULL )
-                fmt = _( "Couldn't bind port %d on %s: %s" );
+            if (hint == NULL)
+                fmt = _ ("Couldn't bind port %d on %s: %s");
             else
-                fmt = _( "Couldn't bind port %d on %s: %s (%s)" );
+                fmt = _ ("Couldn't bind port %d on %s: %s (%s)");
 
-            tr_err( fmt, port, tr_address_to_string( addr ), tr_strerror( err ), hint );
+            tr_err (fmt, port, tr_address_to_string (addr), tr_strerror (err), hint);
         }
-        tr_netCloseSocket( fd );
+        tr_netCloseSocket (fd);
         *errOut = err;
         return -1;
     }
 
-    if( !suppressMsgs )
-        tr_dbg( "Bound socket %d to port %d on %s", fd, port, tr_address_to_string( addr ) );
+    if (!suppressMsgs)
+        tr_dbg ("Bound socket %d to port %d on %s", fd, port, tr_address_to_string (addr));
 
-    if( listen( fd, 128 ) == -1 ) {
+    if (listen (fd, 128) == -1) {
         *errOut = sockerrno;
-        tr_netCloseSocket( fd );
+        tr_netCloseSocket (fd);
         return -1;
     }
 
@@ -382,26 +382,26 @@ tr_netBindTCPImpl( const tr_address * addr, tr_port port, bool suppressMsgs, int
 }
 
 int
-tr_netBindTCP( const tr_address * addr, tr_port port, bool suppressMsgs )
+tr_netBindTCP (const tr_address * addr, tr_port port, bool suppressMsgs)
 {
     int unused;
-    return tr_netBindTCPImpl( addr, port, suppressMsgs, &unused );
+    return tr_netBindTCPImpl (addr, port, suppressMsgs, &unused);
 }
 
 bool
-tr_net_hasIPv6( tr_port port )
+tr_net_hasIPv6 (tr_port port)
 {
     static bool result = false;
     static bool alreadyDone = false;
 
-    if( !alreadyDone )
+    if (!alreadyDone)
     {
         int err;
-        int fd = tr_netBindTCPImpl( &tr_in6addr_any, port, true, &err );
-        if( fd >= 0 || err != EAFNOSUPPORT ) /* we support ipv6 */
+        int fd = tr_netBindTCPImpl (&tr_in6addr_any, port, true, &err);
+        if (fd >= 0 || err != EAFNOSUPPORT) /* we support ipv6 */
             result = true;
-        if( fd >= 0 )
-            tr_netCloseSocket( fd );
+        if (fd >= 0)
+            tr_netCloseSocket (fd);
         alreadyDone = true;
     }
 
@@ -409,15 +409,15 @@ tr_net_hasIPv6( tr_port port )
 }
 
 int
-tr_netAccept( tr_session  * session,
+tr_netAccept (tr_session  * session,
               int           b,
               tr_address  * addr,
-              tr_port     * port )
+              tr_port     * port)
 {
-    int fd = tr_fdSocketAccept( session, b, addr, port );
+    int fd = tr_fdSocketAccept (session, b, addr, port);
 
-    if( fd>=0 && evutil_make_socket_nonblocking(fd)<0 ) {
-        tr_netClose( session, fd );
+    if (fd>=0 && evutil_make_socket_nonblocking (fd)<0) {
+        tr_netClose (session, fd);
         fd = -1;
     }
 
@@ -425,19 +425,19 @@ tr_netAccept( tr_session  * session,
 }
 
 void
-tr_netCloseSocket( int fd )
+tr_netCloseSocket (int fd)
 {
-    evutil_closesocket( fd );
+    evutil_closesocket (fd);
 }
 
 void
-tr_netClose( tr_session * session, int s )
+tr_netClose (tr_session * session, int s)
 {
-    tr_fdSocketClose( session, s );
+    tr_fdSocketClose (session, s);
 }
 
 /*
-   get_source_address() and global_unicast_address() were written by
+   get_source_address () and global_unicast_address () were written by
    Juliusz Chroboczek, and are covered under the same license as dht.c.
    Please feel free to copy them into your software if it can help
    unbreaking the double-stack Internet. */
@@ -447,52 +447,52 @@ tr_netClose( tr_session * session, int s )
    a connected UDP socket (connected UDP... hmm...) and check its source
    address. */
 static int
-get_source_address( const struct sockaddr  * dst,
+get_source_address (const struct sockaddr  * dst,
                     socklen_t                dst_len,
                     struct sockaddr        * src,
-                    socklen_t              * src_len )
+                    socklen_t              * src_len)
 {
     int s, rc, save;
 
-    s = socket(dst->sa_family, SOCK_DGRAM, 0);
-    if(s < 0)
+    s = socket (dst->sa_family, SOCK_DGRAM, 0);
+    if (s < 0)
         goto fail;
 
     /* Since it's a UDP socket, this doesn't actually send any packets. */
-    rc = connect(s, dst, dst_len);
-    if(rc < 0)
+    rc = connect (s, dst, dst_len);
+    if (rc < 0)
         goto fail;
 
-    rc = getsockname(s, src, src_len);
-    if(rc < 0)
+    rc = getsockname (s, src, src_len);
+    if (rc < 0)
         goto fail;
 
-    evutil_closesocket( s );
+    evutil_closesocket (s);
 
     return rc;
 
  fail:
     save = errno;
-    evutil_closesocket( s );
+    evutil_closesocket (s);
     errno = save;
     return -1;
 }
 
 /* We all hate NATs. */
 static int
-global_unicast_address(struct sockaddr *sa)
+global_unicast_address (struct sockaddr *sa)
 {
-    if(sa->sa_family == AF_INET) {
+    if (sa->sa_family == AF_INET) {
         const unsigned char *a =
-            (unsigned char*)&((struct sockaddr_in*)sa)->sin_addr;
-        if(a[0] == 0 || a[0] == 127 || a[0] >= 224 ||
+          (unsigned char*)& ((struct sockaddr_in*)sa)->sin_addr;
+        if (a[0] == 0 || a[0] == 127 || a[0] >= 224 ||
            a[0] == 10 || (a[0] == 172 && a[1] >= 16 && a[1] <= 31) ||
-           (a[0] == 192 && a[1] == 168))
+         (a[0] == 192 && a[1] == 168))
             return 0;
         return 1;
-    } else if(sa->sa_family == AF_INET6) {
+    } else if (sa->sa_family == AF_INET6) {
         const unsigned char *a =
-            (unsigned char*)&((struct sockaddr_in6*)sa)->sin6_addr;
+          (unsigned char*)& ((struct sockaddr_in6*)sa)->sin6_addr;
         /* 2000::/3 */
         return (a[0] & 0xE0) == 0x20;
     } else {
@@ -502,58 +502,58 @@ global_unicast_address(struct sockaddr *sa)
 }
 
 static int
-tr_globalAddress( int af, void *addr, int *addr_len )
+tr_globalAddress (int af, void *addr, int *addr_len)
 {
     struct sockaddr_storage ss;
-    socklen_t sslen = sizeof(ss);
+    socklen_t sslen = sizeof (ss);
     struct sockaddr_in sin;
     struct sockaddr_in6 sin6;
     struct sockaddr *sa;
     socklen_t salen;
     int rc;
 
-    switch(af) {
+    switch (af) {
     case AF_INET:
-        memset(&sin, 0, sizeof(sin));
+        memset (&sin, 0, sizeof (sin));
         sin.sin_family = AF_INET;
-        evutil_inet_pton(AF_INET, "91.121.74.28", &sin.sin_addr);
-        sin.sin_port = htons(6969);
+        evutil_inet_pton (AF_INET, "91.121.74.28", &sin.sin_addr);
+        sin.sin_port = htons (6969);
         sa = (struct sockaddr*)&sin;
-        salen = sizeof(sin);
+        salen = sizeof (sin);
         break;
     case AF_INET6:
-        memset(&sin6, 0, sizeof(sin6));
+        memset (&sin6, 0, sizeof (sin6));
         sin6.sin6_family = AF_INET6;
         /* In order for address selection to work right, this should be
            a native IPv6 address, not Teredo or 6to4. */
-        evutil_inet_pton(AF_INET6, "2001:1890:1112:1::20", &sin6.sin6_addr);
-        sin6.sin6_port = htons(6969);
+        evutil_inet_pton (AF_INET6, "2001:1890:1112:1::20", &sin6.sin6_addr);
+        sin6.sin6_port = htons (6969);
         sa = (struct sockaddr*)&sin6;
-        salen = sizeof(sin6);
+        salen = sizeof (sin6);
         break;
     default:
         return -1;
     }
 
-    rc = get_source_address( sa, salen, (struct sockaddr*)&ss, &sslen );
+    rc = get_source_address (sa, salen, (struct sockaddr*)&ss, &sslen);
 
-    if( rc < 0 )
+    if (rc < 0)
         return -1;
 
-    if( !global_unicast_address( (struct sockaddr*)&ss) )
+    if (!global_unicast_address ((struct sockaddr*)&ss))
         return -1;
 
-    switch(af) {
+    switch (af) {
     case AF_INET:
-        if(*addr_len < 4)
+        if (*addr_len < 4)
             return -1;
-        memcpy(addr, &((struct sockaddr_in*)&ss)->sin_addr, 4);
+        memcpy (addr, & ((struct sockaddr_in*)&ss)->sin_addr, 4);
         *addr_len = 4;
         return 1;
     case AF_INET6:
-        if(*addr_len < 16)
+        if (*addr_len < 16)
             return -1;
-        memcpy(addr, &((struct sockaddr_in6*)&ss)->sin6_addr, 16);
+        memcpy (addr, & ((struct sockaddr_in6*)&ss)->sin6_addr, 16);
         *addr_len = 16;
         return 1;
     default:
@@ -564,19 +564,19 @@ tr_globalAddress( int af, void *addr, int *addr_len )
 /* Return our global IPv6 address, with caching. */
 
 const unsigned char *
-tr_globalIPv6( void )
+tr_globalIPv6 (void)
 {
     static unsigned char ipv6[16];
     static time_t last_time = 0;
     static int have_ipv6 = 0;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
     /* Re-check every half hour */
-    if( last_time < now - 1800 )
+    if (last_time < now - 1800)
     {
         int addrlen = 16;
-        const int rc = tr_globalAddress( AF_INET6, ipv6, &addrlen );
-        have_ipv6 = ( rc >= 0 ) && ( addrlen == 16 );
+        const int rc = tr_globalAddress (AF_INET6, ipv6, &addrlen);
+        have_ipv6 = (rc >= 0) && (addrlen == 16);
         last_time = now;
     }
 
@@ -589,49 +589,49 @@ tr_globalIPv6( void )
 ***/
 
 static bool
-isIPv4MappedAddress( const tr_address * addr )
+isIPv4MappedAddress (const tr_address * addr)
 {
-    return ( addr->type == TR_AF_INET6 ) && IN6_IS_ADDR_V4MAPPED( &addr->addr.addr6 );
+    return (addr->type == TR_AF_INET6) && IN6_IS_ADDR_V4MAPPED (&addr->addr.addr6);
 }
 
 static bool
-isIPv6LinkLocalAddress( const tr_address * addr )
+isIPv6LinkLocalAddress (const tr_address * addr)
 {
-    return ( ( addr->type == TR_AF_INET6 )
-                  && IN6_IS_ADDR_LINKLOCAL( &addr->addr.addr6 ) );
+    return ((addr->type == TR_AF_INET6)
+                  && IN6_IS_ADDR_LINKLOCAL (&addr->addr.addr6));
 }
 
 /* isMartianAddr was written by Juliusz Chroboczek,
    and is covered under the same license as third-party/dht/dht.c. */
 static bool
-isMartianAddr( const struct tr_address * a )
+isMartianAddr (const struct tr_address * a)
 {
     static const unsigned char zeroes[16] =
         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-    assert( tr_address_is_valid( a ) );
+    assert (tr_address_is_valid (a));
 
-    switch( a->type )
+    switch (a->type)
     {
         case TR_AF_INET: {
             const unsigned char * address = (const unsigned char*)&a->addr.addr4;
             return (address[0] == 0) ||
-                   (address[0] == 127) ||
-                   ((address[0] & 0xE0) == 0xE0);
+                 (address[0] == 127) ||
+                 ((address[0] & 0xE0) == 0xE0);
             break;
         }
 
         case TR_AF_INET6: {
             const unsigned char * address = (const unsigned char*)&a->addr.addr6;
             return (address[0] == 0xFF) ||
-                   (memcmp(address, zeroes, 15) == 0 &&
-                    (address[15] == 0 || address[15] == 1)) ||
+                 (memcmp (address, zeroes, 15) == 0 &&
+                  (address[15] == 0 || address[15] == 1)) ||
                    /* Addresses outside of 2000::/3 are currently reserved,
                       but might be allocated at some future time. Since
                       there are a lot of buggy peers pushing around such
                       addresses over PEX, we reject them until the end of
                       the 13th Baktun. */
-                   (tr_time() < 1356130800 && (address[0] & 0xE0) != 0x20);
+                 (tr_time () < 1356130800 && (address[0] & 0xE0) != 0x20);
             break;
         }
 
@@ -641,11 +641,11 @@ isMartianAddr( const struct tr_address * a )
 }
 
 bool
-tr_address_is_valid_for_peers( const tr_address * addr, tr_port port )
+tr_address_is_valid_for_peers (const tr_address * addr, tr_port port)
 {
-    return ( port != 0 )
-        && ( tr_address_is_valid( addr ) )
-        && ( !isIPv6LinkLocalAddress( addr ) )
-        && ( !isIPv4MappedAddress( addr ) )
-        && ( !isMartianAddr( addr ) );
+    return (port != 0)
+        && (tr_address_is_valid (addr))
+        && (!isIPv6LinkLocalAddress (addr))
+        && (!isIPv4MappedAddress (addr))
+        && (!isMartianAddr (addr));
 }
diff --git a/libtransmission/net.h b/libtransmission/net.h
index 09e10952a..4cc583c9b 100644
--- a/libtransmission/net.h
+++ b/libtransmission/net.h
@@ -47,7 +47,7 @@
  #define EWOULDBLOCK             WSAEWOULDBLOCK
  #define EAFNOSUPPORT            WSAEAFNOSUPPORT
  #define ENETUNREACH             WSAENETUNREACH
- #define sockerrno               WSAGetLastError( )
+ #define sockerrno               WSAGetLastError ()
 #else
  #include <errno.h>
  #define sockerrno errno
@@ -81,29 +81,29 @@ typedef struct tr_address
 extern const tr_address tr_inaddr_any;
 extern const tr_address tr_in6addr_any;
 
-const char* tr_address_to_string( const tr_address * addr );
+const char* tr_address_to_string (const tr_address * addr);
 
-const char* tr_address_to_string_with_buf( const tr_address  * addr,
+const char* tr_address_to_string_with_buf (const tr_address  * addr,
                                            char              * buf,
-                                           size_t              buflen );
+                                           size_t              buflen);
 
-bool tr_address_from_string ( tr_address  * setme,
-                              const char  * string );
+bool tr_address_from_string (tr_address  * setme,
+                              const char  * string);
 
-bool tr_address_from_sockaddr_storage( tr_address                     * setme,
+bool tr_address_from_sockaddr_storage (tr_address                     * setme,
                                        tr_port                        * port,
-                                       const struct sockaddr_storage  * src );
+                                       const struct sockaddr_storage  * src);
 
-int tr_address_compare( const tr_address * a,
-                        const tr_address * b );
+int tr_address_compare (const tr_address * a,
+                        const tr_address * b);
 
-bool tr_address_is_valid_for_peers( const tr_address  * addr,
-                                    tr_port             port );
+bool tr_address_is_valid_for_peers (const tr_address  * addr,
+                                    tr_port             port);
 
 static inline bool
-tr_address_is_valid( const tr_address * a )
+tr_address_is_valid (const tr_address * a)
 {
-    return ( a != NULL ) && ( a->type==TR_AF_INET || a->type==TR_AF_INET6 );
+    return (a != NULL) && (a->type==TR_AF_INET || a->type==TR_AF_INET6);
 }
 
 /***********************************************************************
@@ -112,49 +112,49 @@ tr_address_is_valid( const tr_address * a )
 
 struct tr_session;
 
-int  tr_netOpenPeerSocket( tr_session       * session,
+int  tr_netOpenPeerSocket (tr_session       * session,
                            const tr_address * addr,
                            tr_port            port,
-                           bool               clientIsSeed );
+                           bool               clientIsSeed);
 
 struct UTPSocket *
-tr_netOpenPeerUTPSocket( tr_session        * session,
+tr_netOpenPeerUTPSocket (tr_session        * session,
                          const tr_address  * addr,
                          tr_port             port,
                          bool                clientIsSeed);
 
-int  tr_netBindTCP( const tr_address * addr,
+int  tr_netBindTCP (const tr_address * addr,
                     tr_port            port,
-                    bool               suppressMsgs );
+                    bool               suppressMsgs);
 
-int  tr_netAccept( tr_session * session,
+int  tr_netAccept (tr_session * session,
                    int          bound,
                    tr_address * setme_addr,
-                   tr_port    * setme_port );
+                   tr_port    * setme_port);
 
-int  tr_netSetTOS( int s,
-                   int tos );
+int  tr_netSetTOS (int s,
+                   int tos);
 
-int tr_netSetCongestionControl( int s, const char *algorithm );
+int tr_netSetCongestionControl (int s, const char *algorithm);
 
-void tr_netClose( tr_session * session, int s );
+void tr_netClose (tr_session * session, int s);
 
-void tr_netCloseSocket( int fd );
+void tr_netCloseSocket (int fd);
 
-void tr_netInit( void );
+void tr_netInit (void);
 
-bool tr_net_hasIPv6( tr_port );
+bool tr_net_hasIPv6 (tr_port);
 
 
 /**
  * @brief get a human-representable string representing the network error.
  * @param err an errno on Unix/Linux and an WSAError on win32)
  */
-char* tr_net_strerror( char * buf, size_t buflen, int err );
+char* tr_net_strerror (char * buf, size_t buflen, int err);
 
-const unsigned char *tr_globalIPv6( void );
+const unsigned char *tr_globalIPv6 (void);
 
-#if defined( WIN32) && !defined(QT_DLL)
+#if defined (WIN32) && !defined (QT_DLL)
 /* The QT exclusion is because something clashes whith the next include */
 #include <ws2tcpip.h>		/* socklen_t */
 
diff --git a/libtransmission/peer-common.h b/libtransmission/peer-common.h
index 845e36403..deb83b578 100644
--- a/libtransmission/peer-common.h
+++ b/libtransmission/peer-common.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -40,7 +40,7 @@ enum
     /** this is the maximum size of a block request.
         most bittorrent clients will reject requests
         larger than this size. */
-    MAX_BLOCK_SIZE = ( 1024 * 16 )
+    MAX_BLOCK_SIZE = (1024 * 16)
 };
 
 /**
@@ -83,12 +83,12 @@ extern const tr_peer_event TR_PEER_EVENT_INIT;
 
 struct tr_peer;
 
-typedef void tr_peer_callback( struct tr_peer       * peer,
+typedef void tr_peer_callback (struct tr_peer       * peer,
                                const tr_peer_event  * event,
-                               void                 * client_data );
+                               void                 * client_data);
 
 /** Update the tr_peer.progress field based on the 'have' bitset. */
-void tr_peerUpdateProgress( tr_torrent * tor, struct tr_peer * );
+void tr_peerUpdateProgress (tr_torrent * tor, struct tr_peer *);
 
 
 #ifdef WIN32
diff --git a/libtransmission/peer-io.c b/libtransmission/peer-io.c
index 817a6d30b..cb2ab1382 100644
--- a/libtransmission/peer-io.c
+++ b/libtransmission/peer-io.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -27,7 +27,7 @@
 #include "net.h"
 #include "peer-common.h" /* MAX_BLOCK_SIZE */
 #include "peer-io.h"
-#include "trevent.h" /* tr_runInEventThread() */
+#include "trevent.h" /* tr_runInEventThread () */
 #include "tr-utp.h"
 #include "utils.h"
 
@@ -44,7 +44,7 @@
 #define UTP_READ_BUFFER_SIZE (256 * 1024)
 
 static size_t
-guessPacketOverhead( size_t d )
+guessPacketOverhead (size_t d)
 {
     /**
      * http://sd.wareonearth.com/~phil/net/overhead/
@@ -55,27 +55,27 @@ guessPacketOverhead( size_t d )
      * Add 20 TCP header
      * Add 12 bytes optional TCP timestamps
      * Max TCP Payload data rates over ethernet are thus:
-     *  (1500-40)/(38+1500) = 94.9285 %  IPv4, minimal headers
-     *  (1500-52)/(38+1500) = 94.1482 %  IPv4, TCP timestamps
-     *  (1500-52)/(42+1500) = 93.9040 %  802.1q, IPv4, TCP timestamps
-     *  (1500-60)/(38+1500) = 93.6281 %  IPv6, minimal headers
-     *  (1500-72)/(38+1500) = 92.8479 %  IPv6, TCP timestamps
-     *  (1500-72)/(42+1500) = 92.6070 %  802.1q, IPv6, ICP timestamps
+     * (1500-40)/ (38+1500) = 94.9285 %  IPv4, minimal headers
+     * (1500-52)/ (38+1500) = 94.1482 %  IPv4, TCP timestamps
+     * (1500-52)/ (42+1500) = 93.9040 %  802.1q, IPv4, TCP timestamps
+     * (1500-60)/ (38+1500) = 93.6281 %  IPv6, minimal headers
+     * (1500-72)/ (38+1500) = 92.8479 %  IPv6, TCP timestamps
+     * (1500-72)/ (42+1500) = 92.6070 %  802.1q, IPv6, ICP timestamps
      */
     const double assumed_payload_data_rate = 94.0;
 
-    return (unsigned int)( d * ( 100.0 / assumed_payload_data_rate ) - d );
+    return (unsigned int)(d * (100.0 / assumed_payload_data_rate) - d);
 }
 
 /**
 ***
 **/
 
-#define dbgmsg( io, ... ) \
+#define dbgmsg(io, ...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, tr_peerIoGetAddrStr( io ), __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, tr_peerIoGetAddrStr (io), __VA_ARGS__); \
+    } while (0)
 
 /**
 ***
@@ -93,12 +93,12 @@ static struct tr_datatype * datatype_pool = NULL;
 static const struct tr_datatype TR_DATATYPE_INIT = { NULL, 0, false };
 
 static struct tr_datatype *
-datatype_new( void )
+datatype_new (void)
 {
     struct tr_datatype * ret;
 
-    if( datatype_pool == NULL )
-        ret = tr_new( struct tr_datatype, 1 );
+    if (datatype_pool == NULL)
+        ret = tr_new (struct tr_datatype, 1);
     else {
         ret = datatype_pool;
         datatype_pool = datatype_pool->next;
@@ -109,31 +109,31 @@ datatype_new( void )
 }
 
 static void
-datatype_free( struct tr_datatype * datatype )
+datatype_free (struct tr_datatype * datatype)
 {
     datatype->next = datatype_pool;
     datatype_pool = datatype;
 }
 
 static void
-peer_io_pull_datatype( tr_peerIo * io )
+peer_io_pull_datatype (tr_peerIo * io)
 {
     struct tr_datatype * tmp;
 
-    if(( tmp = io->outbuf_datatypes ))
+    if ((tmp = io->outbuf_datatypes))
     {
         io->outbuf_datatypes = tmp->next;
-        datatype_free( tmp );
+        datatype_free (tmp);
     }
 }
 
 static void
-peer_io_push_datatype( tr_peerIo * io, struct tr_datatype * datatype )
+peer_io_push_datatype (tr_peerIo * io, struct tr_datatype * datatype)
 {
     struct tr_datatype * tmp;
 
-    if(( tmp = io->outbuf_datatypes )) {
-        while( tmp->next != NULL )
+    if ((tmp = io->outbuf_datatypes)) {
+        while (tmp->next != NULL)
             tmp = tmp->next;
         tmp->next = datatype;
     } else {
@@ -146,80 +146,80 @@ peer_io_push_datatype( tr_peerIo * io, struct tr_datatype * datatype )
 ***/
 
 static void
-didWriteWrapper( tr_peerIo * io, unsigned int bytes_transferred )
+didWriteWrapper (tr_peerIo * io, unsigned int bytes_transferred)
 {
-     while( bytes_transferred && tr_isPeerIo( io ) )
+     while (bytes_transferred && tr_isPeerIo (io))
      {
         struct tr_datatype * next = io->outbuf_datatypes;
 
-        const unsigned int payload = MIN( next->length, bytes_transferred );
+        const unsigned int payload = MIN (next->length, bytes_transferred);
         /* For uTP sockets, the overhead is computed in utp_on_overhead. */
         const unsigned int overhead =
-            io->socket ? guessPacketOverhead( payload ) : 0;
-        const uint64_t now = tr_time_msec( );
+            io->socket ? guessPacketOverhead (payload) : 0;
+        const uint64_t now = tr_time_msec ();
 
-        tr_bandwidthUsed( &io->bandwidth, TR_UP, payload, next->isPieceData, now );
+        tr_bandwidthUsed (&io->bandwidth, TR_UP, payload, next->isPieceData, now);
 
-        if( overhead > 0 )
-            tr_bandwidthUsed( &io->bandwidth, TR_UP, overhead, false, now );
+        if (overhead > 0)
+            tr_bandwidthUsed (&io->bandwidth, TR_UP, overhead, false, now);
 
-        if( io->didWrite )
-            io->didWrite( io, payload, next->isPieceData, io->userData );
+        if (io->didWrite)
+            io->didWrite (io, payload, next->isPieceData, io->userData);
 
-        if( tr_isPeerIo( io ) )
+        if (tr_isPeerIo (io))
         {
             bytes_transferred -= payload;
             next->length -= payload;
-            if( !next->length )
-                peer_io_pull_datatype( io );
+            if (!next->length)
+                peer_io_pull_datatype (io);
         }
     }
 }
 
 static void
-canReadWrapper( tr_peerIo * io )
+canReadWrapper (tr_peerIo * io)
 {
     bool err = 0;
     bool done = 0;
     tr_session * session;
 
-    dbgmsg( io, "canRead" );
+    dbgmsg (io, "canRead");
 
-    tr_peerIoRef( io );
+    tr_peerIoRef (io);
 
     session = io->session;
 
     /* try to consume the input buffer */
-    if( io->canRead )
+    if (io->canRead)
     {
-        const uint64_t now = tr_time_msec( );
+        const uint64_t now = tr_time_msec ();
 
-        tr_sessionLock( session );
+        tr_sessionLock (session);
 
-        while( !done && !err )
+        while (!done && !err)
         {
             size_t piece = 0;
-            const size_t oldLen = evbuffer_get_length( io->inbuf );
-            const int ret = io->canRead( io, io->userData, &piece );
-            const size_t used = oldLen - evbuffer_get_length( io->inbuf );
-            const unsigned int overhead = guessPacketOverhead( used );
+            const size_t oldLen = evbuffer_get_length (io->inbuf);
+            const int ret = io->canRead (io, io->userData, &piece);
+            const size_t used = oldLen - evbuffer_get_length (io->inbuf);
+            const unsigned int overhead = guessPacketOverhead (used);
 
-            if( piece || (piece!=used) )
+            if (piece || (piece!=used))
             {
-                if( piece )
-                    tr_bandwidthUsed( &io->bandwidth, TR_DOWN, piece, true, now );
+                if (piece)
+                    tr_bandwidthUsed (&io->bandwidth, TR_DOWN, piece, true, now);
 
-                if( used != piece )
-                    tr_bandwidthUsed( &io->bandwidth, TR_DOWN, used - piece, false, now );
+                if (used != piece)
+                    tr_bandwidthUsed (&io->bandwidth, TR_DOWN, used - piece, false, now);
             }
 
-            if( overhead > 0 )
-                tr_bandwidthUsed( &io->bandwidth, TR_UP, overhead, false, now );
+            if (overhead > 0)
+                tr_bandwidthUsed (&io->bandwidth, TR_UP, overhead, false, now);
 
-            switch( ret )
+            switch (ret)
             {
                 case READ_NOW:
-                    if( evbuffer_get_length( io->inbuf ) )
+                    if (evbuffer_get_length (io->inbuf))
                         continue;
                     done = 1;
                     break;
@@ -233,17 +233,17 @@ canReadWrapper( tr_peerIo * io )
                     break;
             }
 
-            assert( tr_isPeerIo( io ) );
+            assert (tr_isPeerIo (io));
         }
 
-        tr_sessionUnlock( session );
+        tr_sessionUnlock (session);
     }
 
-    tr_peerIoUnref( io );
+    tr_peerIoUnref (io);
 }
 
 static void
-event_read_cb( int fd, short event UNUSED, void * vio )
+event_read_cb (int fd, short event UNUSED, void * vio)
 {
     int res;
     int e;
@@ -255,74 +255,74 @@ event_read_cb( int fd, short event UNUSED, void * vio )
     const tr_direction dir = TR_DOWN;
     const unsigned int max = 256 * 1024;
 
-    assert( tr_isPeerIo( io ) );
-    assert( io->socket >= 0 );
+    assert (tr_isPeerIo (io));
+    assert (io->socket >= 0);
 
     io->pendingEvents &= ~EV_READ;
 
-    curlen = evbuffer_get_length( io->inbuf );
+    curlen = evbuffer_get_length (io->inbuf);
     howmuch = curlen >= max ? 0 : max - curlen;
-    howmuch = tr_bandwidthClamp( &io->bandwidth, TR_DOWN, howmuch );
+    howmuch = tr_bandwidthClamp (&io->bandwidth, TR_DOWN, howmuch);
 
-    dbgmsg( io, "libevent says this peer is ready to read" );
+    dbgmsg (io, "libevent says this peer is ready to read");
 
     /* if we don't have any bandwidth left, stop reading */
-    if( howmuch < 1 ) {
-        tr_peerIoSetEnabled( io, dir, false );
+    if (howmuch < 1) {
+        tr_peerIoSetEnabled (io, dir, false);
         return;
     }
 
-    EVUTIL_SET_SOCKET_ERROR( 0 );
-    res = evbuffer_read( io->inbuf, fd, (int)howmuch );
-    e = EVUTIL_SOCKET_ERROR( );
+    EVUTIL_SET_SOCKET_ERROR (0);
+    res = evbuffer_read (io->inbuf, fd, (int)howmuch);
+    e = EVUTIL_SOCKET_ERROR ();
 
-    if( res > 0 )
+    if (res > 0)
     {
-        tr_peerIoSetEnabled( io, dir, true );
+        tr_peerIoSetEnabled (io, dir, true);
 
         /* Invoke the user callback - must always be called last */
-        canReadWrapper( io );
+        canReadWrapper (io);
     }
     else
     {
         char errstr[512];
         short what = BEV_EVENT_READING;
 
-        if( res == 0 ) /* EOF */
+        if (res == 0) /* EOF */
             what |= BEV_EVENT_EOF;
-        else if( res == -1 ) {
-            if( e == EAGAIN || e == EINTR ) {
-                tr_peerIoSetEnabled( io, dir, true );
+        else if (res == -1) {
+            if (e == EAGAIN || e == EINTR) {
+                tr_peerIoSetEnabled (io, dir, true);
                 return;
             }
             what |= BEV_EVENT_ERROR;
         }
 
-        dbgmsg( io, "event_read_cb got an error. res is %d, what is %hd, errno is %d (%s)",
-                res, what, e, tr_net_strerror( errstr, sizeof( errstr ), e ) );
+        dbgmsg (io, "event_read_cb got an error. res is %d, what is %hd, errno is %d (%s)",
+                res, what, e, tr_net_strerror (errstr, sizeof (errstr), e));
 
-        if( io->gotError != NULL )
-            io->gotError( io, what, io->userData );
+        if (io->gotError != NULL)
+            io->gotError (io, what, io->userData);
     }
 }
 
 static int
-tr_evbuffer_write( tr_peerIo * io, int fd, size_t howmuch )
+tr_evbuffer_write (tr_peerIo * io, int fd, size_t howmuch)
 {
     int e;
     int n;
     char errstr[256];
 
-    EVUTIL_SET_SOCKET_ERROR( 0 );
-    n = evbuffer_write_atmost( io->outbuf, fd, howmuch );
-    e = EVUTIL_SOCKET_ERROR( );
-    dbgmsg( io, "wrote %d to peer (%s)", n, (n==-1?tr_net_strerror(errstr,sizeof(errstr),e):"") );
+    EVUTIL_SET_SOCKET_ERROR (0);
+    n = evbuffer_write_atmost (io->outbuf, fd, howmuch);
+    e = EVUTIL_SOCKET_ERROR ();
+    dbgmsg (io, "wrote %d to peer (%s)", n, (n==-1?tr_net_strerror (errstr,sizeof (errstr),e):""));
 
     return n;
 }
 
 static void
-event_write_cb( int fd, short event UNUSED, void * vio )
+event_write_cb (int fd, short event UNUSED, void * vio)
 {
     int res = 0;
     int e;
@@ -332,26 +332,26 @@ event_write_cb( int fd, short event UNUSED, void * vio )
     const tr_direction dir = TR_UP;
     char errstr[1024];
 
-    assert( tr_isPeerIo( io ) );
-    assert( io->socket >= 0 );
+    assert (tr_isPeerIo (io));
+    assert (io->socket >= 0);
 
     io->pendingEvents &= ~EV_WRITE;
 
-    dbgmsg( io, "libevent says this peer is ready to write" );
+    dbgmsg (io, "libevent says this peer is ready to write");
 
-    /* Write as much as possible, since the socket is non-blocking, write() will
+    /* Write as much as possible, since the socket is non-blocking, write () will
      * return if it can't write any more data without blocking */
-    howmuch = tr_bandwidthClamp( &io->bandwidth, dir, evbuffer_get_length( io->outbuf ) );
+    howmuch = tr_bandwidthClamp (&io->bandwidth, dir, evbuffer_get_length (io->outbuf));
 
     /* if we don't have any bandwidth left, stop writing */
-    if( howmuch < 1 ) {
-        tr_peerIoSetEnabled( io, dir, false );
+    if (howmuch < 1) {
+        tr_peerIoSetEnabled (io, dir, false);
         return;
     }
 
-    EVUTIL_SET_SOCKET_ERROR( 0 );
-    res = tr_evbuffer_write( io, fd, howmuch );
-    e = EVUTIL_SOCKET_ERROR( );
+    EVUTIL_SET_SOCKET_ERROR (0);
+    res = tr_evbuffer_write (io, fd, howmuch);
+    e = EVUTIL_SOCKET_ERROR ();
 
     if (res == -1) {
         if (!e || e == EAGAIN || e == EINTR || e == EINPROGRESS)
@@ -365,24 +365,24 @@ event_write_cb( int fd, short event UNUSED, void * vio )
     if (res <= 0)
         goto error;
 
-    if( evbuffer_get_length( io->outbuf ) )
-        tr_peerIoSetEnabled( io, dir, true );
+    if (evbuffer_get_length (io->outbuf))
+        tr_peerIoSetEnabled (io, dir, true);
 
-    didWriteWrapper( io, res );
+    didWriteWrapper (io, res);
     return;
 
  reschedule:
-    if( evbuffer_get_length( io->outbuf ) )
-        tr_peerIoSetEnabled( io, dir, true );
+    if (evbuffer_get_length (io->outbuf))
+        tr_peerIoSetEnabled (io, dir, true);
     return;
 
  error:
 
-    tr_net_strerror( errstr, sizeof( errstr ), e );
-    dbgmsg( io, "event_write_cb got an error. res is %d, what is %hd, errno is %d (%s)", res, what, e, errstr );
+    tr_net_strerror (errstr, sizeof (errstr), e);
+    dbgmsg (io, "event_write_cb got an error. res is %d, what is %hd, errno is %d (%s)", res, what, e, errstr);
 
-    if( io->gotError != NULL )
-        io->gotError( io, what, io->userData );
+    if (io->gotError != NULL)
+        io->gotError (io, what, io->userData);
 }
 
 /**
@@ -390,15 +390,15 @@ event_write_cb( int fd, short event UNUSED, void * vio )
 **/
 
 static void
-maybeSetCongestionAlgorithm( int socket, const char * algorithm )
+maybeSetCongestionAlgorithm (int socket, const char * algorithm)
 {
-    if( algorithm && *algorithm )
+    if (algorithm && *algorithm)
     {
-        const int rc = tr_netSetCongestionControl( socket, algorithm );
+        const int rc = tr_netSetCongestionControl (socket, algorithm);
 
-        if( rc < 0 )
-            tr_ninf( "Net", "Can't set congestion control algorithm '%s': %s",
-                     algorithm, tr_strerror( errno ));
+        if (rc < 0)
+            tr_ninf ("Net", "Can't set congestion control algorithm '%s': %s",
+                     algorithm, tr_strerror (errno));
     }
 }
 
@@ -406,115 +406,115 @@ maybeSetCongestionAlgorithm( int socket, const char * algorithm )
 /* UTP callbacks */
 
 static void
-utp_on_read(void *closure, const unsigned char *buf, size_t buflen)
+utp_on_read (void *closure, const unsigned char *buf, size_t buflen)
 {
     int rc;
     tr_peerIo *io = closure;
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    rc = evbuffer_add( io->inbuf, buf, buflen );
-    dbgmsg( io, "utp_on_read got %zu bytes", buflen );
+    rc = evbuffer_add (io->inbuf, buf, buflen);
+    dbgmsg (io, "utp_on_read got %zu bytes", buflen);
 
-    if( rc < 0 ) {
-        tr_nerr( "UTP", "On read evbuffer_add" );
+    if (rc < 0) {
+        tr_nerr ("UTP", "On read evbuffer_add");
         return;
     }
 
-    tr_peerIoSetEnabled( io, TR_DOWN, true );
-    canReadWrapper( io );
+    tr_peerIoSetEnabled (io, TR_DOWN, true);
+    canReadWrapper (io);
 }
 
 static void
-utp_on_write(void *closure, unsigned char *buf, size_t buflen)
+utp_on_write (void *closure, unsigned char *buf, size_t buflen)
 {
     int rc;
     tr_peerIo *io = closure;
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    rc = evbuffer_remove( io->outbuf, buf, buflen );
-    dbgmsg( io, "utp_on_write sending %zu bytes... evbuffer_remove returned %d", buflen, rc );
-    assert( rc == (int)buflen ); /* if this fails, we've corrupted our bookkeeping somewhere */
-    if( rc < (long)buflen ) {
-        tr_nerr( "UTP", "Short write: %d < %ld", rc, (long)buflen);
+    rc = evbuffer_remove (io->outbuf, buf, buflen);
+    dbgmsg (io, "utp_on_write sending %zu bytes... evbuffer_remove returned %d", buflen, rc);
+    assert (rc == (int)buflen); /* if this fails, we've corrupted our bookkeeping somewhere */
+    if (rc < (long)buflen) {
+        tr_nerr ("UTP", "Short write: %d < %ld", rc, (long)buflen);
     }
 
-    didWriteWrapper( io, buflen );
+    didWriteWrapper (io, buflen);
 }
 
 static size_t
-utp_get_rb_size(void *closure)
+utp_get_rb_size (void *closure)
 {
     size_t bytes;
     tr_peerIo *io = closure;
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    bytes = tr_bandwidthClamp( &io->bandwidth, TR_DOWN, UTP_READ_BUFFER_SIZE );
+    bytes = tr_bandwidthClamp (&io->bandwidth, TR_DOWN, UTP_READ_BUFFER_SIZE);
 
-    dbgmsg( io, "utp_get_rb_size is saying it's ready to read %zu bytes", bytes );
+    dbgmsg (io, "utp_get_rb_size is saying it's ready to read %zu bytes", bytes);
     return UTP_READ_BUFFER_SIZE - bytes;
 }
 
-static int tr_peerIoTryWrite( tr_peerIo * io, size_t howmuch );
+static int tr_peerIoTryWrite (tr_peerIo * io, size_t howmuch);
 
 static void
-utp_on_writable( tr_peerIo *io )
+utp_on_writable (tr_peerIo *io)
 {
     int n;
 
-    dbgmsg( io, "libutp says this peer is ready to write" );
+    dbgmsg (io, "libutp says this peer is ready to write");
 
-    n = tr_peerIoTryWrite( io, SIZE_MAX );
-    tr_peerIoSetEnabled( io, TR_UP, n && evbuffer_get_length( io->outbuf ) );
+    n = tr_peerIoTryWrite (io, SIZE_MAX);
+    tr_peerIoSetEnabled (io, TR_UP, n && evbuffer_get_length (io->outbuf));
 }
 
 static void
-utp_on_state_change(void *closure, int state)
+utp_on_state_change (void *closure, int state)
 {
     tr_peerIo *io = closure;
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    if( state == UTP_STATE_CONNECT ) {
-        dbgmsg( io, "utp_on_state_change -- changed to connected" );
+    if (state == UTP_STATE_CONNECT) {
+        dbgmsg (io, "utp_on_state_change -- changed to connected");
         io->utpSupported = true;
-    } else if( state == UTP_STATE_WRITABLE ) {
-        dbgmsg( io, "utp_on_state_change -- changed to writable" );
-        if ( io->pendingEvents & EV_WRITE )
-            utp_on_writable( io );
-    } else if( state == UTP_STATE_EOF ) {
-        if( io->gotError )
-            io->gotError( io, BEV_EVENT_EOF, io->userData );
-    } else if( state == UTP_STATE_DESTROYING ) {
-        tr_nerr( "UTP", "Impossible state UTP_STATE_DESTROYING" );
+    } else if (state == UTP_STATE_WRITABLE) {
+        dbgmsg (io, "utp_on_state_change -- changed to writable");
+        if (io->pendingEvents & EV_WRITE)
+            utp_on_writable (io);
+    } else if (state == UTP_STATE_EOF) {
+        if (io->gotError)
+            io->gotError (io, BEV_EVENT_EOF, io->userData);
+    } else if (state == UTP_STATE_DESTROYING) {
+        tr_nerr ("UTP", "Impossible state UTP_STATE_DESTROYING");
         return;
     } else {
-        tr_nerr( "UTP", "Unknown state %d", state );
+        tr_nerr ("UTP", "Unknown state %d", state);
     }
 }
 
 static void
-utp_on_error(void *closure, int errcode)
+utp_on_error (void *closure, int errcode)
 {
     tr_peerIo *io = closure;
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    dbgmsg( io, "utp_on_error -- errcode is %d", errcode );
+    dbgmsg (io, "utp_on_error -- errcode is %d", errcode);
 
-    if( io->gotError ) {
+    if (io->gotError) {
         errno = errcode;
-        io->gotError( io, BEV_EVENT_ERROR, io->userData );
+        io->gotError (io, BEV_EVENT_ERROR, io->userData);
     }
 }
 
 static void
-utp_on_overhead(void *closure, bool send, size_t count, int type UNUSED)
+utp_on_overhead (void *closure, bool send, size_t count, int type UNUSED)
 {
     tr_peerIo *io = closure;
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    dbgmsg( io, "utp_on_overhead -- count is %zu", count );
+    dbgmsg (io, "utp_on_overhead -- count is %zu", count);
 
-    tr_bandwidthUsed( &io->bandwidth, send ? TR_UP : TR_DOWN,
-                      count, false, tr_time_msec() );
+    tr_bandwidthUsed (&io->bandwidth, send ? TR_UP : TR_DOWN,
+                      count, false, tr_time_msec ());
 }
 
 static struct UTPFunctionTable utp_function_table = {
@@ -532,42 +532,42 @@ static struct UTPFunctionTable utp_function_table = {
    destroyed -- see io_dtor. */
 
 static void
-dummy_read( void * closure UNUSED, const unsigned char *buf UNUSED, size_t buflen UNUSED )
+dummy_read (void * closure UNUSED, const unsigned char *buf UNUSED, size_t buflen UNUSED)
 {
     /* This cannot happen, as far as I'm aware. */
-    tr_nerr( "UTP", "On_read called on closed socket" );
+    tr_nerr ("UTP", "On_read called on closed socket");
 
 }
 
 static void
-dummy_write(void * closure UNUSED, unsigned char *buf, size_t buflen)
+dummy_write (void * closure UNUSED, unsigned char *buf, size_t buflen)
 {
     /* This can very well happen if we've shut down a peer connection that
        had unflushed buffers.  Complain and send zeroes. */
-    tr_ndbg( "UTP", "On_write called on closed socket" );
-    memset( buf, 0, buflen );
+    tr_ndbg ("UTP", "On_write called on closed socket");
+    memset (buf, 0, buflen);
 }
 
 static size_t
-dummy_get_rb_size( void * closure UNUSED )
+dummy_get_rb_size (void * closure UNUSED)
 {
     return 0;
 }
 
 static void
-dummy_on_state_change(void * closure UNUSED, int state UNUSED )
+dummy_on_state_change (void * closure UNUSED, int state UNUSED)
 {
     return;
 }
 
 static void
-dummy_on_error( void * closure UNUSED, int errcode UNUSED )
+dummy_on_error (void * closure UNUSED, int errcode UNUSED)
 {
     return;
 }
 
 static void
-dummy_on_overhead( void *closure UNUSED, bool send UNUSED, size_t count UNUSED, int type UNUSED )
+dummy_on_overhead (void *closure UNUSED, bool send UNUSED, size_t count UNUSED, int type UNUSED)
 {
     return;
 }
@@ -584,7 +584,7 @@ static struct UTPFunctionTable dummy_utp_function_table = {
 #endif /* #ifdef WITH_UTP */
 
 static tr_peerIo*
-tr_peerIoNew( tr_session       * session,
+tr_peerIoNew (tr_session       * session,
               tr_bandwidth     * parent,
               const tr_address * addr,
               tr_port            port,
@@ -596,25 +596,25 @@ tr_peerIoNew( tr_session       * session,
 {
     tr_peerIo * io;
 
-    assert( session != NULL );
-    assert( session->events != NULL );
-    assert( tr_isBool( isIncoming ) );
-    assert( tr_isBool( isSeed ) );
-    assert( tr_amInEventThread( session ) );
-    assert( (socket < 0) == (utp_socket != NULL) );
+    assert (session != NULL);
+    assert (session->events != NULL);
+    assert (tr_isBool (isIncoming));
+    assert (tr_isBool (isSeed));
+    assert (tr_amInEventThread (session));
+    assert ((socket < 0) == (utp_socket != NULL));
 #ifndef WITH_UTP
-    assert( socket >= 0 );
+    assert (socket >= 0);
 #endif
 
-    if( socket >= 0 ) {
-        tr_netSetTOS( socket, session->peerSocketTOS );
-        maybeSetCongestionAlgorithm( socket, session->peer_congestion_algorithm );
+    if (socket >= 0) {
+        tr_netSetTOS (socket, session->peerSocketTOS);
+        maybeSetCongestionAlgorithm (socket, session->peer_congestion_algorithm);
     }
 
-    io = tr_new0( tr_peerIo, 1 );
+    io = tr_new0 (tr_peerIo, 1);
     io->magicNumber = PEER_IO_MAGIC_NUMBER;
     io->refCount = 1;
-    tr_cryptoConstruct( &io->crypto, torrentHash, isIncoming );
+    tr_cryptoConstruct (&io->crypto, torrentHash, isIncoming);
     io->session = session;
     io->addr = *addr;
     io->isSeed = isSeed;
@@ -622,30 +622,30 @@ tr_peerIoNew( tr_session       * session,
     io->socket = socket;
     io->utp_socket = utp_socket;
     io->isIncoming = isIncoming != 0;
-    io->timeCreated = tr_time( );
-    io->inbuf = evbuffer_new( );
-    io->outbuf = evbuffer_new( );
-    tr_bandwidthConstruct( &io->bandwidth, session, parent );
-    tr_bandwidthSetPeer( &io->bandwidth, io );
-    dbgmsg( io, "bandwidth is %p; its parent is %p", &io->bandwidth, parent );
-    dbgmsg( io, "socket is %d, utp_socket is %p", socket, utp_socket );
-
-    if( io->socket >= 0 ) {
-        io->event_read = event_new( session->event_base,
-                                    io->socket, EV_READ, event_read_cb, io );
-        io->event_write = event_new( session->event_base,
-                                     io->socket, EV_WRITE, event_write_cb, io );
+    io->timeCreated = tr_time ();
+    io->inbuf = evbuffer_new ();
+    io->outbuf = evbuffer_new ();
+    tr_bandwidthConstruct (&io->bandwidth, session, parent);
+    tr_bandwidthSetPeer (&io->bandwidth, io);
+    dbgmsg (io, "bandwidth is %p; its parent is %p", &io->bandwidth, parent);
+    dbgmsg (io, "socket is %d, utp_socket is %p", socket, utp_socket);
+
+    if (io->socket >= 0) {
+        io->event_read = event_new (session->event_base,
+                                    io->socket, EV_READ, event_read_cb, io);
+        io->event_write = event_new (session->event_base,
+                                     io->socket, EV_WRITE, event_write_cb, io);
     }
 #ifdef WITH_UTP
     else {
-        UTP_SetSockopt( utp_socket, SO_RCVBUF, UTP_READ_BUFFER_SIZE );
-        dbgmsg( io, "%s", "calling UTP_SetCallbacks &utp_function_table" );
-        UTP_SetCallbacks( utp_socket,
+        UTP_SetSockopt (utp_socket, SO_RCVBUF, UTP_READ_BUFFER_SIZE);
+        dbgmsg (io, "%s", "calling UTP_SetCallbacks &utp_function_table");
+        UTP_SetCallbacks (utp_socket,
                           &utp_function_table,
-                          io );
-        if( !isIncoming ) {
-            dbgmsg( io, "%s", "calling UTP_Connect" );
-            UTP_Connect( utp_socket );
+                          io);
+        if (!isIncoming) {
+            dbgmsg (io, "%s", "calling UTP_Connect");
+            UTP_Connect (utp_socket);
         }
     }
 #endif
@@ -654,49 +654,49 @@ tr_peerIoNew( tr_session       * session,
 }
 
 tr_peerIo*
-tr_peerIoNewIncoming( tr_session        * session,
+tr_peerIoNewIncoming (tr_session        * session,
                       tr_bandwidth      * parent,
                       const tr_address  * addr,
                       tr_port             port,
                       int                 fd,
-                      struct UTPSocket  * utp_socket )
+                      struct UTPSocket  * utp_socket)
 {
-    assert( session );
-    assert( tr_address_is_valid( addr ) );
+    assert (session);
+    assert (tr_address_is_valid (addr));
 
-    return tr_peerIoNew( session, parent, addr, port, NULL, true, false,
-                         fd, utp_socket );
+    return tr_peerIoNew (session, parent, addr, port, NULL, true, false,
+                         fd, utp_socket);
 }
 
 tr_peerIo*
-tr_peerIoNewOutgoing( tr_session        * session,
+tr_peerIoNewOutgoing (tr_session        * session,
                       tr_bandwidth      * parent,
                       const tr_address  * addr,
                       tr_port             port,
                       const uint8_t     * torrentHash,
                       bool                isSeed,
-                      bool                utp )
+                      bool                utp)
 {
     int fd = -1;
     struct UTPSocket * utp_socket = NULL;
 
-    assert( session );
-    assert( tr_address_is_valid( addr ) );
-    assert( torrentHash );
+    assert (session);
+    assert (tr_address_is_valid (addr));
+    assert (torrentHash);
 
-    if( utp )
-        utp_socket = tr_netOpenPeerUTPSocket( session, addr, port, isSeed );
+    if (utp)
+        utp_socket = tr_netOpenPeerUTPSocket (session, addr, port, isSeed);
 
-    if( !utp_socket ) {
-        fd = tr_netOpenPeerSocket( session, addr, port, isSeed );
-        dbgmsg( NULL, "tr_netOpenPeerSocket returned fd %d", fd );
+    if (!utp_socket) {
+        fd = tr_netOpenPeerSocket (session, addr, port, isSeed);
+        dbgmsg (NULL, "tr_netOpenPeerSocket returned fd %d", fd);
     }
 
-    if( fd < 0 && utp_socket == NULL )
+    if (fd < 0 && utp_socket == NULL)
         return NULL;
 
-    return tr_peerIoNew( session, parent, addr, port,
-                         torrentHash, false, isSeed, fd, utp_socket );
+    return tr_peerIoNew (session, parent, addr, port,
+                         torrentHash, false, isSeed, fd, utp_socket);
 }
 
 /***
@@ -704,110 +704,110 @@ tr_peerIoNewOutgoing( tr_session        * session,
 ***/
 
 static void
-event_enable( tr_peerIo * io, short event )
+event_enable (tr_peerIo * io, short event)
 {
-    assert( tr_amInEventThread( io->session ) );
-    assert( io->session != NULL );
-    assert( io->session->events != NULL );
+    assert (tr_amInEventThread (io->session));
+    assert (io->session != NULL);
+    assert (io->session->events != NULL);
 
-    if( io->socket >= 0 )
+    if (io->socket >= 0)
     {
-        assert( event_initialized( io->event_read ) );
-        assert( event_initialized( io->event_write ) );
+        assert (event_initialized (io->event_read));
+        assert (event_initialized (io->event_write));
     }
 
-    if( ( event & EV_READ ) && ! ( io->pendingEvents & EV_READ ) )
+    if ((event & EV_READ) && ! (io->pendingEvents & EV_READ))
     {
-        dbgmsg( io, "enabling ready-to-read polling" );
-        if( io->socket >= 0 )
-            event_add( io->event_read, NULL );
+        dbgmsg (io, "enabling ready-to-read polling");
+        if (io->socket >= 0)
+            event_add (io->event_read, NULL);
         io->pendingEvents |= EV_READ;
     }
 
-    if( ( event & EV_WRITE ) && ! ( io->pendingEvents & EV_WRITE ) )
+    if ((event & EV_WRITE) && ! (io->pendingEvents & EV_WRITE))
     {
-        dbgmsg( io, "enabling ready-to-write polling" );
-        if( io->socket >= 0 )
-            event_add( io->event_write, NULL );
+        dbgmsg (io, "enabling ready-to-write polling");
+        if (io->socket >= 0)
+            event_add (io->event_write, NULL);
         io->pendingEvents |= EV_WRITE;
     }
 }
 
 static void
-event_disable( struct tr_peerIo * io, short event )
+event_disable (struct tr_peerIo * io, short event)
 {
-    assert( tr_amInEventThread( io->session ) );
-    assert( io->session != NULL );
-    assert( io->session->events != NULL );
+    assert (tr_amInEventThread (io->session));
+    assert (io->session != NULL);
+    assert (io->session->events != NULL);
 
-    if( io->socket >= 0 )
+    if (io->socket >= 0)
     {
-        assert( event_initialized( io->event_read ) );
-        assert( event_initialized( io->event_write ) );
+        assert (event_initialized (io->event_read));
+        assert (event_initialized (io->event_write));
     }
 
-    if( ( event & EV_READ ) && ( io->pendingEvents & EV_READ ) )
+    if ((event & EV_READ) && (io->pendingEvents & EV_READ))
     {
-        dbgmsg( io, "disabling ready-to-read polling" );
-        if( io->socket >= 0 )
-            event_del( io->event_read );
+        dbgmsg (io, "disabling ready-to-read polling");
+        if (io->socket >= 0)
+            event_del (io->event_read);
         io->pendingEvents &= ~EV_READ;
     }
 
-    if( ( event & EV_WRITE ) && ( io->pendingEvents & EV_WRITE ) )
+    if ((event & EV_WRITE) && (io->pendingEvents & EV_WRITE))
     {
-        dbgmsg( io, "disabling ready-to-write polling" );
-        if( io->socket >= 0 )
-            event_del( io->event_write );
+        dbgmsg (io, "disabling ready-to-write polling");
+        if (io->socket >= 0)
+            event_del (io->event_write);
         io->pendingEvents &= ~EV_WRITE;
     }
 }
 
 void
-tr_peerIoSetEnabled( tr_peerIo    * io,
+tr_peerIoSetEnabled (tr_peerIo    * io,
                      tr_direction   dir,
-                     bool           isEnabled )
+                     bool           isEnabled)
 {
     const short event = dir == TR_UP ? EV_WRITE : EV_READ;
 
-    assert( tr_isPeerIo( io ) );
-    assert( tr_isDirection( dir ) );
-    assert( tr_amInEventThread( io->session ) );
-    assert( io->session->events != NULL );
+    assert (tr_isPeerIo (io));
+    assert (tr_isDirection (dir));
+    assert (tr_amInEventThread (io->session));
+    assert (io->session->events != NULL);
 
-    if( isEnabled )
-        event_enable( io, event );
+    if (isEnabled)
+        event_enable (io, event);
     else
-        event_disable( io, event );
+        event_disable (io, event);
 }
 
 /***
 ****
 ***/
 static void
-io_close_socket( tr_peerIo * io )
+io_close_socket (tr_peerIo * io)
 {
-    if( io->socket >= 0 ) {
-        tr_netClose( io->session, io->socket );
+    if (io->socket >= 0) {
+        tr_netClose (io->session, io->socket);
         io->socket = -1;
     }
 
-    if( io->event_read != NULL) {
-        event_free( io->event_read );
+    if (io->event_read != NULL) {
+        event_free (io->event_read);
         io->event_read = NULL;
     }
 
-    if( io->event_write != NULL) {
-        event_free( io->event_write );
+    if (io->event_write != NULL) {
+        event_free (io->event_write);
         io->event_write = NULL;
     }
 
 #ifdef WITH_UTP
-    if( io->utp_socket ) {
-        UTP_SetCallbacks( io->utp_socket,
+    if (io->utp_socket) {
+        UTP_SetCallbacks (io->utp_socket,
                           &dummy_utp_function_table,
-                          NULL );
-        UTP_Close( io->utp_socket );
+                          NULL);
+        UTP_Close (io->utp_socket);
 
         io->utp_socket = NULL;
     }
@@ -815,95 +815,95 @@ io_close_socket( tr_peerIo * io )
 }
 
 static void
-io_dtor( void * vio )
+io_dtor (void * vio)
 {
     tr_peerIo * io = vio;
 
-    assert( tr_isPeerIo( io ) );
-    assert( tr_amInEventThread( io->session ) );
-    assert( io->session->events != NULL );
+    assert (tr_isPeerIo (io));
+    assert (tr_amInEventThread (io->session));
+    assert (io->session->events != NULL);
 
-    dbgmsg( io, "in tr_peerIo destructor" );
-    event_disable( io, EV_READ | EV_WRITE );
-    tr_bandwidthDestruct( &io->bandwidth );
-    evbuffer_free( io->outbuf );
-    evbuffer_free( io->inbuf );
-    io_close_socket( io );
-    tr_cryptoDestruct( &io->crypto );
+    dbgmsg (io, "in tr_peerIo destructor");
+    event_disable (io, EV_READ | EV_WRITE);
+    tr_bandwidthDestruct (&io->bandwidth);
+    evbuffer_free (io->outbuf);
+    evbuffer_free (io->inbuf);
+    io_close_socket (io);
+    tr_cryptoDestruct (&io->crypto);
 
-    while( io->outbuf_datatypes != NULL )
-        peer_io_pull_datatype( io );
+    while (io->outbuf_datatypes != NULL)
+        peer_io_pull_datatype (io);
 
-    memset( io, ~0, sizeof( tr_peerIo ) );
-    tr_free( io );
+    memset (io, ~0, sizeof (tr_peerIo));
+    tr_free (io);
 }
 
 static void
-tr_peerIoFree( tr_peerIo * io )
+tr_peerIoFree (tr_peerIo * io)
 {
-    if( io )
+    if (io)
     {
-        dbgmsg( io, "in tr_peerIoFree" );
+        dbgmsg (io, "in tr_peerIoFree");
         io->canRead = NULL;
         io->didWrite = NULL;
         io->gotError = NULL;
-        tr_runInEventThread( io->session, io_dtor, io );
+        tr_runInEventThread (io->session, io_dtor, io);
     }
 }
 
 void
-tr_peerIoRefImpl( const char * file, int line, tr_peerIo * io )
+tr_peerIoRefImpl (const char * file, int line, tr_peerIo * io)
 {
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    dbgmsg( io, "%s:%d is incrementing the IO's refcount from %d to %d",
-                file, line, io->refCount, io->refCount+1 );
+    dbgmsg (io, "%s:%d is incrementing the IO's refcount from %d to %d",
+                file, line, io->refCount, io->refCount+1);
 
     ++io->refCount;
 }
 
 void
-tr_peerIoUnrefImpl( const char * file, int line, tr_peerIo * io )
+tr_peerIoUnrefImpl (const char * file, int line, tr_peerIo * io)
 {
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    dbgmsg( io, "%s:%d is decrementing the IO's refcount from %d to %d",
-                file, line, io->refCount, io->refCount-1 );
+    dbgmsg (io, "%s:%d is decrementing the IO's refcount from %d to %d",
+                file, line, io->refCount, io->refCount-1);
 
-    if( !--io->refCount )
-        tr_peerIoFree( io );
+    if (!--io->refCount)
+        tr_peerIoFree (io);
 }
 
 const tr_address*
-tr_peerIoGetAddress( const tr_peerIo * io, tr_port   * port )
+tr_peerIoGetAddress (const tr_peerIo * io, tr_port   * port)
 {
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    if( port )
+    if (port)
         *port = io->port;
 
     return &io->addr;
 }
 
 const char*
-tr_peerIoAddrStr( const tr_address * addr, tr_port port )
+tr_peerIoAddrStr (const tr_address * addr, tr_port port)
 {
     static char buf[512];
-    tr_snprintf( buf, sizeof( buf ), "[%s]:%u", tr_address_to_string( addr ), ntohs( port ) );
+    tr_snprintf (buf, sizeof (buf), "[%s]:%u", tr_address_to_string (addr), ntohs (port));
     return buf;
 }
 
-const char* tr_peerIoGetAddrStr( const tr_peerIo * io )
+const char* tr_peerIoGetAddrStr (const tr_peerIo * io)
 {
-    return tr_isPeerIo( io ) ? tr_peerIoAddrStr( &io->addr, io->port ) : "error";
+    return tr_isPeerIo (io) ? tr_peerIoAddrStr (&io->addr, io->port) : "error";
 }
 
 void
-tr_peerIoSetIOFuncs( tr_peerIo        * io,
+tr_peerIoSetIOFuncs (tr_peerIo        * io,
                      tr_can_read_cb     readcb,
                      tr_did_write_cb    writecb,
                      tr_net_error_cb    errcb,
-                     void             * userData )
+                     void             * userData)
 {
     io->canRead = readcb;
     io->didWrite = writecb;
@@ -912,38 +912,38 @@ tr_peerIoSetIOFuncs( tr_peerIo        * io,
 }
 
 void
-tr_peerIoClear( tr_peerIo * io )
+tr_peerIoClear (tr_peerIo * io)
 {
-    tr_peerIoSetIOFuncs( io, NULL, NULL, NULL, NULL );
-    tr_peerIoSetEnabled( io, TR_UP, false );
-    tr_peerIoSetEnabled( io, TR_DOWN, false );
+    tr_peerIoSetIOFuncs (io, NULL, NULL, NULL, NULL);
+    tr_peerIoSetEnabled (io, TR_UP, false);
+    tr_peerIoSetEnabled (io, TR_DOWN, false);
 }
 
 int
-tr_peerIoReconnect( tr_peerIo * io )
+tr_peerIoReconnect (tr_peerIo * io)
 {
     short int pendingEvents;
     tr_session * session;
 
-    assert( tr_isPeerIo( io ) );
-    assert( !tr_peerIoIsIncoming( io ) );
+    assert (tr_isPeerIo (io));
+    assert (!tr_peerIoIsIncoming (io));
 
-    session = tr_peerIoGetSession( io );
+    session = tr_peerIoGetSession (io);
 
     pendingEvents = io->pendingEvents;
-    event_disable( io, EV_READ | EV_WRITE );
+    event_disable (io, EV_READ | EV_WRITE);
 
-    io_close_socket( io );
+    io_close_socket (io);
 
-    io->socket = tr_netOpenPeerSocket( session, &io->addr, io->port, io->isSeed );
-    io->event_read = event_new( session->event_base, io->socket, EV_READ, event_read_cb, io );
-    io->event_write = event_new( session->event_base, io->socket, EV_WRITE, event_write_cb, io );
+    io->socket = tr_netOpenPeerSocket (session, &io->addr, io->port, io->isSeed);
+    io->event_read = event_new (session->event_base, io->socket, EV_READ, event_read_cb, io);
+    io->event_write = event_new (session->event_base, io->socket, EV_WRITE, event_write_cb, io);
 
-    if( io->socket >= 0 )
+    if (io->socket >= 0)
     {
-        event_enable( io, pendingEvents );
-        tr_netSetTOS( io->socket, session->peerSocketTOS );
-        maybeSetCongestionAlgorithm( io->socket, session->peer_congestion_algorithm );
+        event_enable (io, pendingEvents);
+        tr_netSetTOS (io->socket, session->peerSocketTOS);
+        maybeSetCongestionAlgorithm (io->socket, session->peer_congestion_algorithm);
         return 0;
     }
 
@@ -955,28 +955,28 @@ tr_peerIoReconnect( tr_peerIo * io )
 **/
 
 void
-tr_peerIoSetTorrentHash( tr_peerIo *     io,
-                         const uint8_t * hash )
+tr_peerIoSetTorrentHash (tr_peerIo *     io,
+                         const uint8_t * hash)
 {
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    tr_cryptoSetTorrentHash( &io->crypto, hash );
+    tr_cryptoSetTorrentHash (&io->crypto, hash);
 }
 
 const uint8_t*
-tr_peerIoGetTorrentHash( tr_peerIo * io )
+tr_peerIoGetTorrentHash (tr_peerIo * io)
 {
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    return tr_cryptoGetTorrentHash( &io->crypto );
+    return tr_cryptoGetTorrentHash (&io->crypto);
 }
 
 int
-tr_peerIoHasTorrentHash( const tr_peerIo * io )
+tr_peerIoHasTorrentHash (const tr_peerIo * io)
 {
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    return tr_cryptoHasTorrentHash( &io->crypto );
+    return tr_cryptoHasTorrentHash (&io->crypto);
 }
 
 /**
@@ -984,14 +984,14 @@ tr_peerIoHasTorrentHash( const tr_peerIo * io )
 **/
 
 void
-tr_peerIoSetPeersId( tr_peerIo * io, const uint8_t * peer_id )
+tr_peerIoSetPeersId (tr_peerIo * io, const uint8_t * peer_id)
 {
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    if( ( io->peerIdIsSet = peer_id != NULL ) )
-        memcpy( io->peerId, peer_id, 20 );
+    if ((io->peerIdIsSet = peer_id != NULL))
+        memcpy (io->peerId, peer_id, 20);
     else
-        memset( io->peerId, 0, 20 );
+        memset (io->peerId, 0, 20);
 }
 
 /**
@@ -999,27 +999,27 @@ tr_peerIoSetPeersId( tr_peerIo * io, const uint8_t * peer_id )
 **/
 
 static unsigned int
-getDesiredOutputBufferSize( const tr_peerIo * io, uint64_t now )
+getDesiredOutputBufferSize (const tr_peerIo * io, uint64_t now)
 {
     /* this is all kind of arbitrary, but what seems to work well is
      * being large enough to hold the next 20 seconds' worth of input,
      * or a few blocks, whichever is bigger.
      * It's okay to tweak this as needed */
-    const unsigned int currentSpeed_Bps = tr_bandwidthGetPieceSpeed_Bps( &io->bandwidth, now, TR_UP );
+    const unsigned int currentSpeed_Bps = tr_bandwidthGetPieceSpeed_Bps (&io->bandwidth, now, TR_UP);
     const unsigned int period = 15u; /* arbitrary */
     /* the 3 is arbitrary; the .5 is to leave room for messages */
-    static const unsigned int ceiling =  (unsigned int)( MAX_BLOCK_SIZE * 3.5 );
-    return MAX( ceiling, currentSpeed_Bps*period );
+    static const unsigned int ceiling = (unsigned int)(MAX_BLOCK_SIZE * 3.5);
+    return MAX (ceiling, currentSpeed_Bps*period);
 }
 
 size_t
-tr_peerIoGetWriteBufferSpace( const tr_peerIo * io, uint64_t now )
+tr_peerIoGetWriteBufferSpace (const tr_peerIo * io, uint64_t now)
 {
-    const size_t desiredLen = getDesiredOutputBufferSize( io, now );
-    const size_t currentLen = evbuffer_get_length( io->outbuf );
+    const size_t desiredLen = getDesiredOutputBufferSize (io, now);
+    const size_t currentLen = evbuffer_get_length (io->outbuf);
     size_t freeSpace = 0;
 
-    if( desiredLen > currentLen )
+    if (desiredLen > currentLen)
         freeSpace = desiredLen - currentLen;
 
     return freeSpace;
@@ -1030,11 +1030,11 @@ tr_peerIoGetWriteBufferSpace( const tr_peerIo * io, uint64_t now )
 **/
 
 void
-tr_peerIoSetEncryption( tr_peerIo * io, tr_encryption_type encryption_type )
+tr_peerIoSetEncryption (tr_peerIo * io, tr_encryption_type encryption_type)
 {
-    assert( tr_isPeerIo( io ) );
-    assert( encryption_type == PEER_ENCRYPTION_NONE
-         || encryption_type == PEER_ENCRYPTION_RC4 );
+    assert (tr_isPeerIo (io));
+    assert (encryption_type == PEER_ENCRYPTION_NONE
+         || encryption_type == PEER_ENCRYPTION_RC4);
 
     io->encryption_type = encryption_type;
 }
@@ -1044,53 +1044,53 @@ tr_peerIoSetEncryption( tr_peerIo * io, tr_encryption_type encryption_type )
 **/
 
 static void
-addDatatype( tr_peerIo * io, size_t byteCount, bool isPieceData )
+addDatatype (tr_peerIo * io, size_t byteCount, bool isPieceData)
 {
     struct tr_datatype * d;
-    d = datatype_new( );
+    d = datatype_new ();
     d->isPieceData = isPieceData != 0;
     d->length = byteCount;
-    peer_io_push_datatype( io, d );
+    peer_io_push_datatype (io, d);
 }
 
 static void
-maybeEncryptBuffer( tr_peerIo * io, struct evbuffer * buf )
+maybeEncryptBuffer (tr_peerIo * io, struct evbuffer * buf)
 {
-    if( io->encryption_type == PEER_ENCRYPTION_RC4 )
+    if (io->encryption_type == PEER_ENCRYPTION_RC4)
     {
         struct evbuffer_ptr pos;
         struct evbuffer_iovec iovec;
-        evbuffer_ptr_set( buf, &pos, 0, EVBUFFER_PTR_SET );
+        evbuffer_ptr_set (buf, &pos, 0, EVBUFFER_PTR_SET);
         do {
-            evbuffer_peek( buf, -1, &pos, &iovec, 1 );
-            tr_cryptoEncrypt( &io->crypto, iovec.iov_len, iovec.iov_base, iovec.iov_base );
-        } while( !evbuffer_ptr_set( buf, &pos, iovec.iov_len, EVBUFFER_PTR_ADD ) );
+            evbuffer_peek (buf, -1, &pos, &iovec, 1);
+            tr_cryptoEncrypt (&io->crypto, iovec.iov_len, iovec.iov_base, iovec.iov_base);
+        } while (!evbuffer_ptr_set (buf, &pos, iovec.iov_len, EVBUFFER_PTR_ADD));
     }
 }
 
 void
-tr_peerIoWriteBuf( tr_peerIo * io, struct evbuffer * buf, bool isPieceData )
+tr_peerIoWriteBuf (tr_peerIo * io, struct evbuffer * buf, bool isPieceData)
 {
-    const size_t byteCount = evbuffer_get_length( buf );
-    maybeEncryptBuffer( io, buf );
-    evbuffer_add_buffer( io->outbuf, buf );
-    addDatatype( io, byteCount, isPieceData );
+    const size_t byteCount = evbuffer_get_length (buf);
+    maybeEncryptBuffer (io, buf);
+    evbuffer_add_buffer (io->outbuf, buf);
+    addDatatype (io, byteCount, isPieceData);
 }
 
 void
-tr_peerIoWriteBytes( tr_peerIo * io, const void * bytes, size_t byteCount, bool isPieceData )
+tr_peerIoWriteBytes (tr_peerIo * io, const void * bytes, size_t byteCount, bool isPieceData)
 {
     struct evbuffer_iovec iovec;
-    evbuffer_reserve_space( io->outbuf, byteCount, &iovec, 1 );
+    evbuffer_reserve_space (io->outbuf, byteCount, &iovec, 1);
 
     iovec.iov_len = byteCount;
-    if( io->encryption_type == PEER_ENCRYPTION_RC4 )
-        tr_cryptoEncrypt( &io->crypto, iovec.iov_len, bytes, iovec.iov_base );
+    if (io->encryption_type == PEER_ENCRYPTION_RC4)
+        tr_cryptoEncrypt (&io->crypto, iovec.iov_len, bytes, iovec.iov_base);
     else
-        memcpy( iovec.iov_base, bytes, iovec.iov_len );
-    evbuffer_commit_space( io->outbuf, &iovec, 1 );
+        memcpy (iovec.iov_base, bytes, iovec.iov_len);
+    evbuffer_commit_space (io->outbuf, &iovec, 1);
 
-    addDatatype( io, byteCount, isPieceData );
+    addDatatype (io, byteCount, isPieceData);
 }
 
 /***
@@ -1098,30 +1098,30 @@ tr_peerIoWriteBytes( tr_peerIo * io, const void * bytes, size_t byteCount, bool
 ***/
 
 void
-evbuffer_add_uint8( struct evbuffer * outbuf, uint8_t byte )
+evbuffer_add_uint8 (struct evbuffer * outbuf, uint8_t byte)
 {
-    evbuffer_add( outbuf, &byte, 1 );
+    evbuffer_add (outbuf, &byte, 1);
 }
 
 void
-evbuffer_add_uint16( struct evbuffer * outbuf, uint16_t addme_hs )
+evbuffer_add_uint16 (struct evbuffer * outbuf, uint16_t addme_hs)
 {
-    const uint16_t ns = htons( addme_hs );
-    evbuffer_add( outbuf, &ns, sizeof( ns ) );
+    const uint16_t ns = htons (addme_hs);
+    evbuffer_add (outbuf, &ns, sizeof (ns));
 }
 
 void
-evbuffer_add_uint32( struct evbuffer * outbuf, uint32_t addme_hl )
+evbuffer_add_uint32 (struct evbuffer * outbuf, uint32_t addme_hl)
 {
-    const uint32_t nl = htonl( addme_hl );
-    evbuffer_add( outbuf, &nl, sizeof( nl ) );
+    const uint32_t nl = htonl (addme_hl);
+    evbuffer_add (outbuf, &nl, sizeof (nl));
 }
 
 void
-evbuffer_add_uint64( struct evbuffer * outbuf, uint64_t addme_hll )
+evbuffer_add_uint64 (struct evbuffer * outbuf, uint64_t addme_hll)
 {
-    const uint64_t nll = tr_htonll( addme_hll );
-    evbuffer_add( outbuf, &nll, sizeof( nll ) );
+    const uint64_t nll = tr_htonll (addme_hll);
+    evbuffer_add (outbuf, &nll, sizeof (nll));
 }
 
 /***
@@ -1129,86 +1129,86 @@ evbuffer_add_uint64( struct evbuffer * outbuf, uint64_t addme_hll )
 ***/
 
 void
-tr_peerIoReadBytesToBuf( tr_peerIo * io, struct evbuffer * inbuf, struct evbuffer * outbuf, size_t byteCount )
+tr_peerIoReadBytesToBuf (tr_peerIo * io, struct evbuffer * inbuf, struct evbuffer * outbuf, size_t byteCount)
 {
     struct evbuffer * tmp;
-    const size_t old_length = evbuffer_get_length( outbuf );
+    const size_t old_length = evbuffer_get_length (outbuf);
 
-    assert( tr_isPeerIo( io ) );
-    assert( evbuffer_get_length( inbuf ) >= byteCount );
+    assert (tr_isPeerIo (io));
+    assert (evbuffer_get_length (inbuf) >= byteCount);
 
     /* append it to outbuf */
-    tmp = evbuffer_new( );
-    evbuffer_remove_buffer( inbuf, tmp, byteCount );
-    evbuffer_add_buffer( outbuf, tmp );
-    evbuffer_free( tmp );
+    tmp = evbuffer_new ();
+    evbuffer_remove_buffer (inbuf, tmp, byteCount);
+    evbuffer_add_buffer (outbuf, tmp);
+    evbuffer_free (tmp);
 
     /* decrypt if needed */
-    if( io->encryption_type == PEER_ENCRYPTION_RC4 ) {
+    if (io->encryption_type == PEER_ENCRYPTION_RC4) {
         struct evbuffer_ptr pos;
         struct evbuffer_iovec iovec;
-        evbuffer_ptr_set( outbuf, &pos, old_length, EVBUFFER_PTR_SET );
+        evbuffer_ptr_set (outbuf, &pos, old_length, EVBUFFER_PTR_SET);
         do {
-            evbuffer_peek( outbuf, byteCount, &pos, &iovec, 1 );
-            tr_cryptoDecrypt( &io->crypto, iovec.iov_len, iovec.iov_base, iovec.iov_base );
+            evbuffer_peek (outbuf, byteCount, &pos, &iovec, 1);
+            tr_cryptoDecrypt (&io->crypto, iovec.iov_len, iovec.iov_base, iovec.iov_base);
             byteCount -= iovec.iov_len;
-        } while( !evbuffer_ptr_set( outbuf, &pos, iovec.iov_len, EVBUFFER_PTR_ADD ) );
+        } while (!evbuffer_ptr_set (outbuf, &pos, iovec.iov_len, EVBUFFER_PTR_ADD));
     }
 }
 
 void
-tr_peerIoReadBytes( tr_peerIo * io, struct evbuffer * inbuf, void * bytes, size_t byteCount )
+tr_peerIoReadBytes (tr_peerIo * io, struct evbuffer * inbuf, void * bytes, size_t byteCount)
 {
-    assert( tr_isPeerIo( io ) );
-    assert( evbuffer_get_length( inbuf )  >= byteCount );
+    assert (tr_isPeerIo (io));
+    assert (evbuffer_get_length (inbuf)  >= byteCount);
 
-    switch( io->encryption_type )
+    switch (io->encryption_type)
     {
         case PEER_ENCRYPTION_NONE:
-            evbuffer_remove( inbuf, bytes, byteCount );
+            evbuffer_remove (inbuf, bytes, byteCount);
             break;
 
         case PEER_ENCRYPTION_RC4:
-            evbuffer_remove( inbuf, bytes, byteCount );
-            tr_cryptoDecrypt( &io->crypto, byteCount, bytes, bytes );
+            evbuffer_remove (inbuf, bytes, byteCount);
+            tr_cryptoDecrypt (&io->crypto, byteCount, bytes, bytes);
             break;
 
         default:
-            assert( 0 );
+            assert (0);
     }
 }
 
 void
-tr_peerIoReadUint16( tr_peerIo        * io,
+tr_peerIoReadUint16 (tr_peerIo        * io,
                      struct evbuffer  * inbuf,
-                     uint16_t         * setme )
+                     uint16_t         * setme)
 {
     uint16_t tmp;
-    tr_peerIoReadBytes( io, inbuf, &tmp, sizeof( uint16_t ) );
-    *setme = ntohs( tmp );
+    tr_peerIoReadBytes (io, inbuf, &tmp, sizeof (uint16_t));
+    *setme = ntohs (tmp);
 }
 
-void tr_peerIoReadUint32( tr_peerIo        * io,
+void tr_peerIoReadUint32 (tr_peerIo        * io,
                           struct evbuffer  * inbuf,
-                          uint32_t         * setme )
+                          uint32_t         * setme)
 {
     uint32_t tmp;
-    tr_peerIoReadBytes( io, inbuf, &tmp, sizeof( uint32_t ) );
-    *setme = ntohl( tmp );
+    tr_peerIoReadBytes (io, inbuf, &tmp, sizeof (uint32_t));
+    *setme = ntohl (tmp);
 }
 
 void
-tr_peerIoDrain( tr_peerIo       * io,
+tr_peerIoDrain (tr_peerIo       * io,
                 struct evbuffer * inbuf,
-                size_t            byteCount )
+                size_t            byteCount)
 {
     char buf[4096];
-    const size_t buflen = sizeof( buf );
+    const size_t buflen = sizeof (buf);
 
-    while( byteCount > 0 )
+    while (byteCount > 0)
     {
-        const size_t thisPass = MIN( byteCount, buflen );
-        tr_peerIoReadBytes( io, inbuf, buf, thisPass );
+        const size_t thisPass = MIN (byteCount, buflen);
+        tr_peerIoReadBytes (io, inbuf, buf, thisPass);
         byteCount -= thisPass;
     }
 }
@@ -1218,42 +1218,42 @@ tr_peerIoDrain( tr_peerIo       * io,
 ***/
 
 static int
-tr_peerIoTryRead( tr_peerIo * io, size_t howmuch )
+tr_peerIoTryRead (tr_peerIo * io, size_t howmuch)
 {
     int res = 0;
 
-    if(( howmuch = tr_bandwidthClamp( &io->bandwidth, TR_DOWN, howmuch )))
+    if ((howmuch = tr_bandwidthClamp (&io->bandwidth, TR_DOWN, howmuch)))
     {
-        if( io->utp_socket != NULL ) /* utp peer connection */
+        if (io->utp_socket != NULL) /* utp peer connection */
         {
             /* UTP_RBDrained notifies libutp that your read buffer is emtpy.
              * It opens up the congestion window by sending an ACK (soonish)
              * if one was not going to be sent. */
-            if( evbuffer_get_length( io->inbuf ) == 0 )
-                UTP_RBDrained( io->utp_socket );
+            if (evbuffer_get_length (io->inbuf) == 0)
+                UTP_RBDrained (io->utp_socket);
         }
         else /* tcp peer connection */
         {
             int e;
 
-            EVUTIL_SET_SOCKET_ERROR( 0 );
-            res = evbuffer_read( io->inbuf, io->socket, (int)howmuch );
-            e = EVUTIL_SOCKET_ERROR( );
+            EVUTIL_SET_SOCKET_ERROR (0);
+            res = evbuffer_read (io->inbuf, io->socket, (int)howmuch);
+            e = EVUTIL_SOCKET_ERROR ();
 
-            dbgmsg( io, "read %d from peer (%s)", res, (res==-1?tr_strerror(e):"") );
+            dbgmsg (io, "read %d from peer (%s)", res, (res==-1?tr_strerror (e):""));
 
-            if( evbuffer_get_length( io->inbuf ) )
-                canReadWrapper( io );
+            if (evbuffer_get_length (io->inbuf))
+                canReadWrapper (io);
 
-            if( ( res <= 0 ) && ( io->gotError ) && ( e != EAGAIN ) && ( e != EINTR ) && ( e != EINPROGRESS ) )
+            if ((res <= 0) && (io->gotError) && (e != EAGAIN) && (e != EINTR) && (e != EINPROGRESS))
             {
                 char errstr[512];
                 short what = BEV_EVENT_READING | BEV_EVENT_ERROR;
-                if( res == 0 )
+                if (res == 0)
                     what |= BEV_EVENT_EOF;
-                dbgmsg( io, "tr_peerIoTryRead got an error. res is %d, what is %hd, errno is %d (%s)",
-                        res, what, e, tr_net_strerror( errstr, sizeof( errstr ), e ) );
-                io->gotError( io, what, io->userData );
+                dbgmsg (io, "tr_peerIoTryRead got an error. res is %d, what is %hd, errno is %d (%s)",
+                        res, what, e, tr_net_strerror (errstr, sizeof (errstr), e));
+                io->gotError (io, what, io->userData);
             }
         }
     }
@@ -1262,43 +1262,43 @@ tr_peerIoTryRead( tr_peerIo * io, size_t howmuch )
 }
 
 static int
-tr_peerIoTryWrite( tr_peerIo * io, size_t howmuch )
+tr_peerIoTryWrite (tr_peerIo * io, size_t howmuch)
 {
     int n = 0;
-    const size_t old_len = evbuffer_get_length( io->outbuf );
-    dbgmsg( io, "in tr_peerIoTryWrite %zu", howmuch );
+    const size_t old_len = evbuffer_get_length (io->outbuf);
+    dbgmsg (io, "in tr_peerIoTryWrite %zu", howmuch);
 
-    if( howmuch > old_len )
+    if (howmuch > old_len)
         howmuch = old_len;
 
-    if(( howmuch = tr_bandwidthClamp( &io->bandwidth, TR_UP, howmuch )))
+    if ((howmuch = tr_bandwidthClamp (&io->bandwidth, TR_UP, howmuch)))
     {
-        if( io->utp_socket != NULL ) /* utp peer connection */
+        if (io->utp_socket != NULL) /* utp peer connection */
         {
-            UTP_Write( io->utp_socket, howmuch );
-            n = old_len - evbuffer_get_length( io->outbuf );
+            UTP_Write (io->utp_socket, howmuch);
+            n = old_len - evbuffer_get_length (io->outbuf);
         }
         else
         {
             int e;
 
-            EVUTIL_SET_SOCKET_ERROR( 0 );
-            n = tr_evbuffer_write( io, io->socket, howmuch );
-            e = EVUTIL_SOCKET_ERROR( );
+            EVUTIL_SET_SOCKET_ERROR (0);
+            n = tr_evbuffer_write (io, io->socket, howmuch);
+            e = EVUTIL_SOCKET_ERROR ();
 
-            if( n > 0 )
-                didWriteWrapper( io, n );
+            if (n > 0)
+                didWriteWrapper (io, n);
 
-            if( ( n < 0 ) && ( io->gotError ) && e && ( e != EPIPE ) && ( e != EAGAIN ) && ( e != EINTR ) && ( e != EINPROGRESS ) )
+            if ((n < 0) && (io->gotError) && e && (e != EPIPE) && (e != EAGAIN) && (e != EINTR) && (e != EINPROGRESS))
             {
                 char errstr[512];
                 const short what = BEV_EVENT_WRITING | BEV_EVENT_ERROR;
 
-                dbgmsg( io, "tr_peerIoTryWrite got an error. res is %d, what is %hd, errno is %d (%s)",
-                        n, what, e, tr_net_strerror( errstr, sizeof( errstr ), e ) );
+                dbgmsg (io, "tr_peerIoTryWrite got an error. res is %d, what is %hd, errno is %d (%s)",
+                        n, what, e, tr_net_strerror (errstr, sizeof (errstr), e));
 
-                if( io->gotError != NULL )
-                    io->gotError( io, what, io->userData );
+                if (io->gotError != NULL)
+                    io->gotError (io, what, io->userData);
             }
         }
     }
@@ -1307,35 +1307,35 @@ tr_peerIoTryWrite( tr_peerIo * io, size_t howmuch )
 }
 
 int
-tr_peerIoFlush( tr_peerIo  * io, tr_direction dir, size_t limit )
+tr_peerIoFlush (tr_peerIo  * io, tr_direction dir, size_t limit)
 {
     int bytesUsed = 0;
 
-    assert( tr_isPeerIo( io ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isPeerIo (io));
+    assert (tr_isDirection (dir));
 
-    if( dir == TR_DOWN )
-        bytesUsed = tr_peerIoTryRead( io, limit );
+    if (dir == TR_DOWN)
+        bytesUsed = tr_peerIoTryRead (io, limit);
     else
-        bytesUsed = tr_peerIoTryWrite( io, limit );
+        bytesUsed = tr_peerIoTryWrite (io, limit);
 
-    dbgmsg( io, "flushing peer-io, direction %d, limit %zu, bytesUsed %d", (int)dir, limit, bytesUsed );
+    dbgmsg (io, "flushing peer-io, direction %d, limit %zu, bytesUsed %d", (int)dir, limit, bytesUsed);
     return bytesUsed;
 }
 
 int
-tr_peerIoFlushOutgoingProtocolMsgs( tr_peerIo * io )
+tr_peerIoFlushOutgoingProtocolMsgs (tr_peerIo * io)
 {
     size_t byteCount = 0;
     const struct tr_datatype * it;
 
     /* count up how many bytes are used by non-piece-data messages
        at the front of our outbound queue */
-    for( it=io->outbuf_datatypes; it!=NULL; it=it->next )
-        if( it->isPieceData )
+    for (it=io->outbuf_datatypes; it!=NULL; it=it->next)
+        if (it->isPieceData)
             break;
         else
             byteCount += it->length;
 
-    return tr_peerIoFlush( io, TR_UP, byteCount );
+    return tr_peerIoFlush (io, TR_UP, byteCount);
 }
diff --git a/libtransmission/peer-io.h b/libtransmission/peer-io.h
index 44caccced..8bd346c64 100644
--- a/libtransmission/peer-io.h
+++ b/libtransmission/peer-io.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -27,7 +27,7 @@
 #include "bandwidth.h"
 #include "crypto.h"
 #include "net.h" /* tr_address */
-#include "utils.h" /* tr_time() */
+#include "utils.h" /* tr_time () */
 
 struct evbuffer;
 struct tr_bandwidth;
@@ -50,24 +50,24 @@ ReadState;
 typedef enum
 {
     /* these match the values in MSE's crypto_select */
-    PEER_ENCRYPTION_NONE  = ( 1 << 0 ),
-    PEER_ENCRYPTION_RC4   = ( 1 << 1 )
+    PEER_ENCRYPTION_NONE  = (1 << 0),
+    PEER_ENCRYPTION_RC4   = (1 << 1)
 }
 tr_encryption_type;
 
 
-typedef ReadState ( *tr_can_read_cb  )( struct tr_peerIo * io,
+typedef ReadState (*tr_can_read_cb)(struct tr_peerIo * io,
                                         void             * user_data,
-                                        size_t           * setme_piece_byte_count );
+                                        size_t           * setme_piece_byte_count);
 
-typedef void      ( *tr_did_write_cb )( struct tr_peerIo * io,
+typedef void    (*tr_did_write_cb)(struct tr_peerIo * io,
                                         size_t             bytesWritten,
                                         int                wasPieceData,
-                                        void             * userData );
+                                        void             * userData);
 
-typedef void      ( *tr_net_error_cb )( struct tr_peerIo * io,
+typedef void    (*tr_net_error_cb)(struct tr_peerIo * io,
                                         short              what,
-                                        void             * userData );
+                                        void             * userData);
 
 typedef struct tr_peerIo
 {
@@ -122,78 +122,78 @@ tr_peerIo;
 ***
 **/
 
-tr_peerIo*  tr_peerIoNewOutgoing( tr_session              * session,
+tr_peerIo*  tr_peerIoNewOutgoing (tr_session              * session,
                                   struct tr_bandwidth     * parent,
                                   const struct tr_address * addr,
                                   tr_port                   port,
                                   const  uint8_t          * torrentHash,
                                   bool                      isSeed,
-                                  bool                      utp );
+                                  bool                      utp);
 
 
-tr_peerIo*  tr_peerIoNewIncoming( tr_session              * session,
+tr_peerIo*  tr_peerIoNewIncoming (tr_session              * session,
                                   struct tr_bandwidth     * parent,
                                   const struct tr_address * addr,
                                   tr_port                   port,
                                   int                       socket,
-                                  struct UTPSocket *        utp_socket );
+                                  struct UTPSocket *        utp_socket);
 
-void tr_peerIoRefImpl           ( const char              * file,
+void tr_peerIoRefImpl         (const char              * file,
                                   int                       line,
-                                  tr_peerIo               * io );
+                                  tr_peerIo               * io);
 
-#define tr_peerIoRef(io) tr_peerIoRefImpl( __FILE__, __LINE__, (io) );
+#define tr_peerIoRef(io) tr_peerIoRefImpl (__FILE__, __LINE__, (io));
 
-void tr_peerIoUnrefImpl         ( const char              * file,
+void tr_peerIoUnrefImpl       (const char              * file,
                                   int                       line,
-                                  tr_peerIo               * io );
+                                  tr_peerIo               * io);
 
-#define tr_peerIoUnref(io) tr_peerIoUnrefImpl( __FILE__, __LINE__, (io) );
+#define tr_peerIoUnref(io) tr_peerIoUnrefImpl (__FILE__, __LINE__, (io));
 
 #define PEER_IO_MAGIC_NUMBER 206745
 
 static inline bool
-tr_isPeerIo( const tr_peerIo * io )
+tr_isPeerIo (const tr_peerIo * io)
 {
-    return ( io != NULL )
-        && ( io->magicNumber == PEER_IO_MAGIC_NUMBER )
-        && ( io->refCount >= 0 )
-        && ( tr_isBandwidth( &io->bandwidth ) )
-        && ( tr_address_is_valid( &io->addr ) );
+    return (io != NULL)
+        && (io->magicNumber == PEER_IO_MAGIC_NUMBER)
+        && (io->refCount >= 0)
+        && (tr_isBandwidth (&io->bandwidth))
+        && (tr_address_is_valid (&io->addr));
 }
 
 /**
 ***
 **/
 
-static inline void tr_peerIoEnableFEXT( tr_peerIo * io, bool flag )
+static inline void tr_peerIoEnableFEXT (tr_peerIo * io, bool flag)
 {
     io->fastExtensionSupported = flag;
 }
-static inline bool tr_peerIoSupportsFEXT( const tr_peerIo * io )
+static inline bool tr_peerIoSupportsFEXT (const tr_peerIo * io)
 {
     return io->fastExtensionSupported;
 }
 
-static inline void tr_peerIoEnableLTEP( tr_peerIo * io, bool flag )
+static inline void tr_peerIoEnableLTEP (tr_peerIo * io, bool flag)
 {
     io->extendedProtocolSupported = flag;
 }
-static inline bool tr_peerIoSupportsLTEP( const tr_peerIo * io )
+static inline bool tr_peerIoSupportsLTEP (const tr_peerIo * io)
 {
     return io->extendedProtocolSupported;
 }
 
-static inline void tr_peerIoEnableDHT( tr_peerIo * io, bool flag )
+static inline void tr_peerIoEnableDHT (tr_peerIo * io, bool flag)
 {
     io->dhtSupported = flag;
 }
-static inline bool tr_peerIoSupportsDHT( const tr_peerIo * io )
+static inline bool tr_peerIoSupportsDHT (const tr_peerIo * io)
 {
     return io->dhtSupported;
 }
 
-static inline bool tr_peerIoSupportsUTP( const tr_peerIo * io )
+static inline bool tr_peerIoSupportsUTP (const tr_peerIo * io)
 {
     return io->dhtSupported;
 }
@@ -202,39 +202,39 @@ static inline bool tr_peerIoSupportsUTP( const tr_peerIo * io )
 ***
 **/
 
-static inline tr_session* tr_peerIoGetSession ( tr_peerIo * io )
+static inline tr_session* tr_peerIoGetSession (tr_peerIo * io)
 {
-    assert( tr_isPeerIo( io ) );
-    assert( io->session );
+    assert (tr_isPeerIo (io));
+    assert (io->session);
 
     return io->session;
 }
 
-const char* tr_peerIoAddrStr( const struct tr_address * addr,
-                              tr_port                   port );
+const char* tr_peerIoAddrStr (const struct tr_address * addr,
+                              tr_port                   port);
 
-const char* tr_peerIoGetAddrStr( const tr_peerIo * io );
+const char* tr_peerIoGetAddrStr (const tr_peerIo * io);
 
-const struct tr_address * tr_peerIoGetAddress( const tr_peerIo * io,
-                                               tr_port         * port );
+const struct tr_address * tr_peerIoGetAddress (const tr_peerIo * io,
+                                               tr_port         * port);
 
-const uint8_t*       tr_peerIoGetTorrentHash( tr_peerIo * io );
+const uint8_t*       tr_peerIoGetTorrentHash (tr_peerIo * io);
 
-int                  tr_peerIoHasTorrentHash( const tr_peerIo * io );
+int                  tr_peerIoHasTorrentHash (const tr_peerIo * io);
 
-void                 tr_peerIoSetTorrentHash( tr_peerIo *     io,
-                                              const uint8_t * hash );
+void                 tr_peerIoSetTorrentHash (tr_peerIo *     io,
+                                              const uint8_t * hash);
 
-int                  tr_peerIoReconnect( tr_peerIo * io );
+int                  tr_peerIoReconnect (tr_peerIo * io);
 
-static inline bool tr_peerIoIsIncoming( const tr_peerIo * io )
+static inline bool tr_peerIoIsIncoming (const tr_peerIo * io)
 {
     return io->isIncoming;
 }
 
-static inline int    tr_peerIoGetAge( const tr_peerIo * io )
+static inline int    tr_peerIoGetAge (const tr_peerIo * io)
 {
-    return tr_time() - io->timeCreated;
+    return tr_time () - io->timeCreated;
 }
 
 
@@ -242,13 +242,13 @@ static inline int    tr_peerIoGetAge( const tr_peerIo * io )
 ***
 **/
 
-void                 tr_peerIoSetPeersId( tr_peerIo *     io,
-                                          const uint8_t * peer_id );
+void                 tr_peerIoSetPeersId (tr_peerIo *     io,
+                                          const uint8_t * peer_id);
 
-static inline const uint8_t* tr_peerIoGetPeersId( const tr_peerIo * io )
+static inline const uint8_t* tr_peerIoGetPeersId (const tr_peerIo * io)
 {
-    assert( tr_isPeerIo( io ) );
-    assert( io->peerIdIsSet );
+    assert (tr_isPeerIo (io));
+    assert (io->peerIdIsSet);
 
     return io->peerId;
 }
@@ -257,144 +257,144 @@ static inline const uint8_t* tr_peerIoGetPeersId( const tr_peerIo * io )
 ***
 **/
 
-void    tr_peerIoSetIOFuncs      ( tr_peerIo        * io,
+void    tr_peerIoSetIOFuncs    (tr_peerIo        * io,
                                    tr_can_read_cb     readcb,
                                    tr_did_write_cb    writecb,
                                    tr_net_error_cb    errcb,
-                                   void             * user_data );
+                                   void             * user_data);
 
-void    tr_peerIoClear           ( tr_peerIo        * io );
+void    tr_peerIoClear         (tr_peerIo        * io);
 
 /**
 ***
 **/
 
-void    tr_peerIoWriteBytes     ( tr_peerIo         * io,
+void    tr_peerIoWriteBytes   (tr_peerIo         * io,
                                   const void        * writeme,
                                   size_t              writemeLen,
-                                  bool                isPieceData );
+                                  bool                isPieceData);
 
-void    tr_peerIoWriteBuf       ( tr_peerIo         * io,
+void    tr_peerIoWriteBuf     (tr_peerIo         * io,
                                   struct evbuffer   * buf,
-                                  bool                isPieceData );
+                                  bool                isPieceData);
 
 /**
 ***
 **/
 
-static inline tr_crypto * tr_peerIoGetCrypto( tr_peerIo * io )
+static inline tr_crypto * tr_peerIoGetCrypto (tr_peerIo * io)
 {
     return &io->crypto;
 }
 
-void tr_peerIoSetEncryption( tr_peerIo * io, tr_encryption_type encryption_type );
+void tr_peerIoSetEncryption (tr_peerIo * io, tr_encryption_type encryption_type);
 
 static inline bool
-tr_peerIoIsEncrypted( const tr_peerIo * io )
+tr_peerIoIsEncrypted (const tr_peerIo * io)
 {
-    return ( io != NULL ) && ( io->encryption_type == PEER_ENCRYPTION_RC4 );
+    return (io != NULL) && (io->encryption_type == PEER_ENCRYPTION_RC4);
 }
 
-void evbuffer_add_uint8 ( struct evbuffer * outbuf, uint8_t byte );
-void evbuffer_add_uint16( struct evbuffer * outbuf, uint16_t hs );
-void evbuffer_add_uint32( struct evbuffer * outbuf, uint32_t hl );
-void evbuffer_add_uint64( struct evbuffer * outbuf, uint64_t hll );
+void evbuffer_add_uint8 (struct evbuffer * outbuf, uint8_t byte);
+void evbuffer_add_uint16 (struct evbuffer * outbuf, uint16_t hs);
+void evbuffer_add_uint32 (struct evbuffer * outbuf, uint32_t hl);
+void evbuffer_add_uint64 (struct evbuffer * outbuf, uint64_t hll);
 
 static inline void
-evbuffer_add_hton_16( struct evbuffer * buf, uint16_t val )
+evbuffer_add_hton_16 (struct evbuffer * buf, uint16_t val)
 {
-   evbuffer_add_uint16( buf, val );
+   evbuffer_add_uint16 (buf, val);
 }
 static inline void
-evbuffer_add_hton_32( struct evbuffer * buf, uint32_t val )
+evbuffer_add_hton_32 (struct evbuffer * buf, uint32_t val)
 {
-   evbuffer_add_uint32( buf, val );
+   evbuffer_add_uint32 (buf, val);
 }
 static inline void
-evbuffer_add_hton_64( struct evbuffer * buf, uint64_t val )
+evbuffer_add_hton_64 (struct evbuffer * buf, uint64_t val)
 {
-   evbuffer_add_uint64( buf, val );
+   evbuffer_add_uint64 (buf, val);
 }
 
-void tr_peerIoReadBytesToBuf( tr_peerIo       * io,
+void tr_peerIoReadBytesToBuf (tr_peerIo       * io,
                               struct evbuffer * inbuf,
                               struct evbuffer * outbuf,
-                              size_t            byteCount );
+                              size_t            byteCount);
 
-void tr_peerIoReadBytes( tr_peerIo        * io,
+void tr_peerIoReadBytes (tr_peerIo        * io,
                          struct evbuffer  * inbuf,
                          void             * bytes,
-                         size_t             byteCount );
+                         size_t             byteCount);
 
-static inline void tr_peerIoReadUint8( tr_peerIo        * io,
+static inline void tr_peerIoReadUint8 (tr_peerIo        * io,
                                           struct evbuffer  * inbuf,
-                                          uint8_t          * setme )
+                                          uint8_t          * setme)
 {
-    tr_peerIoReadBytes( io, inbuf, setme, sizeof( uint8_t ) );
+    tr_peerIoReadBytes (io, inbuf, setme, sizeof (uint8_t));
 }
 
-void tr_peerIoReadUint16( tr_peerIo        * io,
+void tr_peerIoReadUint16 (tr_peerIo        * io,
                           struct evbuffer  * inbuf,
-                          uint16_t         * setme );
+                          uint16_t         * setme);
 
-void tr_peerIoReadUint32( tr_peerIo        * io,
+void tr_peerIoReadUint32 (tr_peerIo        * io,
                           struct evbuffer  * inbuf,
-                          uint32_t         * setme );
+                          uint32_t         * setme);
 
-void      tr_peerIoDrain( tr_peerIo        * io,
+void      tr_peerIoDrain (tr_peerIo        * io,
                           struct evbuffer  * inbuf,
-                          size_t             byteCount );
+                          size_t             byteCount);
 
 /**
 ***
 **/
 
-size_t    tr_peerIoGetWriteBufferSpace( const tr_peerIo * io, uint64_t now );
+size_t    tr_peerIoGetWriteBufferSpace (const tr_peerIo * io, uint64_t now);
 
-static inline void tr_peerIoSetParent( tr_peerIo            * io,
-                                          struct tr_bandwidth  * parent )
+static inline void tr_peerIoSetParent (tr_peerIo            * io,
+                                          struct tr_bandwidth  * parent)
 {
-    assert( tr_isPeerIo( io ) );
+    assert (tr_isPeerIo (io));
 
-    tr_bandwidthSetParent( &io->bandwidth, parent );
+    tr_bandwidthSetParent (&io->bandwidth, parent);
 }
 
-void      tr_peerIoBandwidthUsed( tr_peerIo           * io,
+void      tr_peerIoBandwidthUsed (tr_peerIo           * io,
                                   tr_direction          direction,
                                   size_t                byteCount,
-                                  int                   isPieceData );
+                                  int                   isPieceData);
 
 static inline bool
-tr_peerIoHasBandwidthLeft( const tr_peerIo * io, tr_direction dir )
+tr_peerIoHasBandwidthLeft (const tr_peerIo * io, tr_direction dir)
 {
-    return tr_bandwidthClamp( &io->bandwidth, dir, 1024 ) > 0;
+    return tr_bandwidthClamp (&io->bandwidth, dir, 1024) > 0;
 }
 
 static inline unsigned int
-tr_peerIoGetPieceSpeed_Bps( const tr_peerIo * io, uint64_t now, tr_direction dir )
+tr_peerIoGetPieceSpeed_Bps (const tr_peerIo * io, uint64_t now, tr_direction dir)
 {
-    return tr_bandwidthGetPieceSpeed_Bps( &io->bandwidth, now, dir );
+    return tr_bandwidthGetPieceSpeed_Bps (&io->bandwidth, now, dir);
 }
 
 /**
 ***
 **/
 
-void      tr_peerIoSetEnabled( tr_peerIo    * io,
+void      tr_peerIoSetEnabled (tr_peerIo    * io,
                                tr_direction   dir,
-                               bool           isEnabled );
+                               bool           isEnabled);
 
-int       tr_peerIoFlush( tr_peerIo     * io,
+int       tr_peerIoFlush (tr_peerIo     * io,
                           tr_direction    dir,
-                          size_t          byteLimit );
+                          size_t          byteLimit);
 
-int       tr_peerIoFlushOutgoingProtocolMsgs( tr_peerIo * io );
+int       tr_peerIoFlushOutgoingProtocolMsgs (tr_peerIo * io);
 
 /**
 ***
 **/
 
-static inline struct evbuffer * tr_peerIoGetReadBuffer( tr_peerIo * io )
+static inline struct evbuffer * tr_peerIoGetReadBuffer (tr_peerIo * io)
 {
     return io->inbuf;
 }
diff --git a/libtransmission/peer-mgr.c b/libtransmission/peer-mgr.c
index ce8b0a55d..4816a230a 100644
--- a/libtransmission/peer-mgr.c
+++ b/libtransmission/peer-mgr.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -44,29 +44,29 @@
 enum
 {
     /* how frequently to cull old atoms */
-    ATOM_PERIOD_MSEC = ( 60 * 1000 ),
+    ATOM_PERIOD_MSEC = (60 * 1000),
 
     /* how frequently to change which peers are choked */
-    RECHOKE_PERIOD_MSEC = ( 10 * 1000 ),
+    RECHOKE_PERIOD_MSEC = (10 * 1000),
 
     /* an optimistically unchoked peer is immune from rechoking
-       for this many calls to rechokeUploads(). */
+       for this many calls to rechokeUploads (). */
     OPTIMISTIC_UNCHOKE_MULTIPLIER = 4,
 
     /* how frequently to reallocate bandwidth */
     BANDWIDTH_PERIOD_MSEC = 500,
 
     /* how frequently to age out old piece request lists */
-    REFILL_UPKEEP_PERIOD_MSEC = ( 10 * 1000 ),
+    REFILL_UPKEEP_PERIOD_MSEC = (10 * 1000),
 
     /* how frequently to decide which peers live and die */
     RECONNECT_PERIOD_MSEC = 500,
 
     /* when many peers are available, keep idle ones this long */
-    MIN_UPLOAD_IDLE_SECS = ( 60 ),
+    MIN_UPLOAD_IDLE_SECS = (60),
 
     /* when few peers are available, keep idle ones this long */
-    MAX_UPLOAD_IDLE_SECS = ( 60 * 5 ),
+    MAX_UPLOAD_IDLE_SECS = (60 * 5),
 
     /* max number of peers to ask for per second overall.
      * this throttle is to avoid overloading the router */
@@ -144,19 +144,19 @@ struct peer_atom
 #define tr_isAtom(a) (TRUE)
 #else
 static bool
-tr_isAtom( const struct peer_atom * atom )
+tr_isAtom (const struct peer_atom * atom)
 {
-    return ( atom != NULL )
-        && ( atom->fromFirst < TR_PEER_FROM__MAX )
-        && ( atom->fromBest < TR_PEER_FROM__MAX )
-        && ( tr_address_is_valid( &atom->addr ) );
+    return (atom != NULL)
+        && (atom->fromFirst < TR_PEER_FROM__MAX)
+        && (atom->fromBest < TR_PEER_FROM__MAX)
+        && (tr_address_is_valid (&atom->addr));
 }
 #endif
 
 static const char*
-tr_atomAddrStr( const struct peer_atom * atom )
+tr_atomAddrStr (const struct peer_atom * atom)
 {
-    return atom ? tr_peerIoAddrStr( &atom->addr, atom->port ) : "[no atom]";
+    return atom ? tr_peerIoAddrStr (&atom->addr, atom->port) : "[no atom]";
 }
 
 struct block_request
@@ -234,50 +234,54 @@ struct tr_peerMgr
     struct event  * atomTimer;
 };
 
-#define tordbg( t, ... ) \
-    do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, tr_torrentName( t->tor ), __VA_ARGS__ ); \
-    } while( 0 )
-
-#define dbgmsg( ... ) \
-    do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
-    } while( 0 )
+#define tordbg(t, ...) \
+  do \
+    { \
+      if (tr_deepLoggingIsActive ()) \
+        tr_deepLog (__FILE__, __LINE__, tr_torrentName (t->tor), __VA_ARGS__); \
+    } \
+  while (0)
+
+#define dbgmsg(...) \
+  do \
+    { \
+      if (tr_deepLoggingIsActive ()) \
+        tr_deepLog (__FILE__, __LINE__, NULL, __VA_ARGS__); \
+    } \
+  while (0)
 
 /**
 ***
 **/
 
 static inline void
-managerLock( const struct tr_peerMgr * manager )
+managerLock (const struct tr_peerMgr * manager)
 {
-    tr_sessionLock( manager->session );
+    tr_sessionLock (manager->session);
 }
 
 static inline void
-managerUnlock( const struct tr_peerMgr * manager )
+managerUnlock (const struct tr_peerMgr * manager)
 {
-    tr_sessionUnlock( manager->session );
+    tr_sessionUnlock (manager->session);
 }
 
 static inline void
-torrentLock( Torrent * torrent )
+torrentLock (Torrent * torrent)
 {
-    managerLock( torrent->manager );
+    managerLock (torrent->manager);
 }
 
 static inline void
-torrentUnlock( Torrent * torrent )
+torrentUnlock (Torrent * torrent)
 {
-    managerUnlock( torrent->manager );
+    managerUnlock (torrent->manager);
 }
 
 static inline int
-torrentIsLocked( const Torrent * t )
+torrentIsLocked (const Torrent * t)
 {
-    return tr_sessionIsLocked( t->manager->session );
+    return tr_sessionIsLocked (t->manager->session);
 }
 
 /**
@@ -285,44 +289,44 @@ torrentIsLocked( const Torrent * t )
 **/
 
 static int
-handshakeCompareToAddr( const void * va, const void * vb )
+handshakeCompareToAddr (const void * va, const void * vb)
 {
     const tr_handshake * a = va;
 
-    return tr_address_compare( tr_handshakeGetAddr( a, NULL ), vb );
+    return tr_address_compare (tr_handshakeGetAddr (a, NULL), vb);
 }
 
 static int
-handshakeCompare( const void * a, const void * b )
+handshakeCompare (const void * a, const void * b)
 {
-    return handshakeCompareToAddr( a, tr_handshakeGetAddr( b, NULL ) );
+    return handshakeCompareToAddr (a, tr_handshakeGetAddr (b, NULL));
 }
 
 static inline tr_handshake*
-getExistingHandshake( tr_ptrArray * handshakes, const tr_address * addr )
+getExistingHandshake (tr_ptrArray * handshakes, const tr_address * addr)
 {
-    if( tr_ptrArrayEmpty( handshakes ) )
+    if (tr_ptrArrayEmpty (handshakes))
         return NULL;
 
-    return tr_ptrArrayFindSorted( handshakes, addr, handshakeCompareToAddr );
+    return tr_ptrArrayFindSorted (handshakes, addr, handshakeCompareToAddr);
 }
 
 static int
-comparePeerAtomToAddress( const void * va, const void * vb )
+comparePeerAtomToAddress (const void * va, const void * vb)
 {
     const struct peer_atom * a = va;
 
-    return tr_address_compare( &a->addr, vb );
+    return tr_address_compare (&a->addr, vb);
 }
 
 static int
-compareAtomsByAddress( const void * va, const void * vb )
+compareAtomsByAddress (const void * va, const void * vb)
 {
     const struct peer_atom * b = vb;
 
-    assert( tr_isAtom( b ) );
+    assert (tr_isAtom (b));
 
-    return comparePeerAtomToAddress( va, &b->addr );
+    return comparePeerAtomToAddress (va, &b->addr);
 }
 
 /**
@@ -330,60 +334,60 @@ compareAtomsByAddress( const void * va, const void * vb )
 **/
 
 const tr_address *
-tr_peerAddress( const tr_peer * peer )
+tr_peerAddress (const tr_peer * peer)
 {
     return &peer->atom->addr;
 }
 
 static Torrent*
-getExistingTorrent( tr_peerMgr *    manager,
-                    const uint8_t * hash )
+getExistingTorrent (tr_peerMgr *    manager,
+                    const uint8_t * hash)
 {
-    tr_torrent * tor = tr_torrentFindFromHash( manager->session, hash );
+    tr_torrent * tor = tr_torrentFindFromHash (manager->session, hash);
 
     return tor == NULL ? NULL : tor->torrentPeers;
 }
 
 static int
-peerCompare( const void * a, const void * b )
+peerCompare (const void * a, const void * b)
 {
-    return tr_address_compare( tr_peerAddress( a ), tr_peerAddress( b ) );
+    return tr_address_compare (tr_peerAddress (a), tr_peerAddress (b));
 }
 
 static struct peer_atom*
-getExistingAtom( const Torrent    * t,
-                 const tr_address * addr )
+getExistingAtom (const Torrent    * t,
+                 const tr_address * addr)
 {
     Torrent * tt = (Torrent*)t;
-    assert( torrentIsLocked( t ) );
-    return tr_ptrArrayFindSorted( &tt->pool, addr, comparePeerAtomToAddress );
+    assert (torrentIsLocked (t));
+    return tr_ptrArrayFindSorted (&tt->pool, addr, comparePeerAtomToAddress);
 }
 
 static bool
-peerIsInUse( const Torrent * ct, const struct peer_atom * atom )
+peerIsInUse (const Torrent * ct, const struct peer_atom * atom)
 {
     Torrent * t = (Torrent*) ct;
 
-    assert( torrentIsLocked ( t ) );
+    assert (torrentIsLocked (t));
 
-    return ( atom->peer != NULL )
-        || getExistingHandshake( &t->outgoingHandshakes, &atom->addr )
-        || getExistingHandshake( &t->manager->incomingHandshakes, &atom->addr );
+    return (atom->peer != NULL)
+        || getExistingHandshake (&t->outgoingHandshakes, &atom->addr)
+        || getExistingHandshake (&t->manager->incomingHandshakes, &atom->addr);
 }
 
 void
-tr_peerConstruct( tr_peer * peer )
+tr_peerConstruct (tr_peer * peer)
 {
-    memset( peer, 0, sizeof( tr_peer ) );
+    memset (peer, 0, sizeof (tr_peer));
 
     peer->have = TR_BITFIELD_INIT;
 }
 
 static tr_peer*
-peerNew( struct peer_atom * atom )
+peerNew (struct peer_atom * atom)
 {
-    tr_peer * peer = tr_new( tr_peer, 1 );
-    tr_peerConstruct( peer );
+    tr_peer * peer = tr_new (tr_peer, 1);
+    tr_peerConstruct (peer);
 
     peer->atom = atom;
     atom->peer = peer;
@@ -392,91 +396,91 @@ peerNew( struct peer_atom * atom )
 }
 
 static tr_peer*
-getPeer( Torrent * torrent, struct peer_atom * atom )
+getPeer (Torrent * torrent, struct peer_atom * atom)
 {
     tr_peer * peer;
 
-    assert( torrentIsLocked( torrent ) );
+    assert (torrentIsLocked (torrent));
 
     peer = atom->peer;
 
-    if( peer == NULL )
+    if (peer == NULL)
     {
-        peer = peerNew( atom );
-        tr_bitfieldConstruct( &peer->have, torrent->tor->info.pieceCount );
-        tr_bitfieldConstruct( &peer->blame, torrent->tor->blockCount );
-        tr_ptrArrayInsertSorted( &torrent->peers, peer, peerCompare );
+        peer = peerNew (atom);
+        tr_bitfieldConstruct (&peer->have, torrent->tor->info.pieceCount);
+        tr_bitfieldConstruct (&peer->blame, torrent->tor->blockCount);
+        tr_ptrArrayInsertSorted (&torrent->peers, peer, peerCompare);
     }
 
     return peer;
 }
 
-static void peerDeclinedAllRequests( Torrent *, const tr_peer * );
+static void peerDeclinedAllRequests (Torrent *, const tr_peer *);
 
 void
-tr_peerDestruct( tr_torrent * tor, tr_peer * peer )
+tr_peerDestruct (tr_torrent * tor, tr_peer * peer)
 {
-    assert( peer != NULL );
+    assert (peer != NULL);
 
-    peerDeclinedAllRequests( tor->torrentPeers, peer );
+    peerDeclinedAllRequests (tor->torrentPeers, peer);
 
-    if( peer->msgs != NULL )
-        tr_peerMsgsFree( peer->msgs );
+    if (peer->msgs != NULL)
+        tr_peerMsgsFree (peer->msgs);
 
-    if( peer->io ) {
-        tr_peerIoClear( peer->io );
-        tr_peerIoUnref( peer->io ); /* balanced by the ref in handshakeDoneCB() */
+    if (peer->io) {
+        tr_peerIoClear (peer->io);
+        tr_peerIoUnref (peer->io); /* balanced by the ref in handshakeDoneCB () */
     }
 
-    tr_bitfieldDestruct( &peer->have );
-    tr_bitfieldDestruct( &peer->blame );
-    tr_free( peer->client );
+    tr_bitfieldDestruct (&peer->have);
+    tr_bitfieldDestruct (&peer->blame);
+    tr_free (peer->client);
 
-    if( peer->atom )
+    if (peer->atom)
         peer->atom->peer = NULL;
 }
 
 static void
-peerDelete( Torrent * t, tr_peer * peer )
+peerDelete (Torrent * t, tr_peer * peer)
 {
-    tr_peerDestruct( t->tor, peer );
-    tr_free( peer );
+    tr_peerDestruct (t->tor, peer);
+    tr_free (peer);
 }
 
 static bool
-replicationExists( const Torrent * t )
+replicationExists (const Torrent * t)
 {
     return t->pieceReplication != NULL;
 }
 
 static void
-replicationFree( Torrent * t )
+replicationFree (Torrent * t)
 {
-    tr_free( t->pieceReplication );
+    tr_free (t->pieceReplication);
     t->pieceReplication = NULL;
     t->pieceReplicationSize = 0;
 }
 
 static void
-replicationNew( Torrent * t )
+replicationNew (Torrent * t)
 {
     tr_piece_index_t piece_i;
     const tr_piece_index_t piece_count = t->tor->info.pieceCount;
-    tr_peer ** peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
-    const int peer_count = tr_ptrArraySize( &t->peers );
+    tr_peer ** peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
+    const int peer_count = tr_ptrArraySize (&t->peers);
 
-    assert( !replicationExists( t ) );
+    assert (!replicationExists (t));
 
     t->pieceReplicationSize = piece_count;
-    t->pieceReplication = tr_new0( uint16_t, piece_count );
+    t->pieceReplication = tr_new0 (uint16_t, piece_count);
 
-    for( piece_i=0; piece_i<piece_count; ++piece_i )
+    for (piece_i=0; piece_i<piece_count; ++piece_i)
     {
         int peer_i;
         uint16_t r = 0;
 
-        for( peer_i=0; peer_i<peer_count; ++peer_i )
-            if( tr_bitfieldHas( &peers[peer_i]->have, piece_i ) )
+        for (peer_i=0; peer_i<peer_count; ++peer_i)
+            if (tr_bitfieldHas (&peers[peer_i]->have, piece_i))
                 ++r;
 
         t->pieceReplication[piece_i] = r;
@@ -484,54 +488,54 @@ replicationNew( Torrent * t )
 }
 
 static void
-torrentFree( void * vt )
+torrentFree (void * vt)
 {
     Torrent * t = vt;
 
-    assert( t );
-    assert( !t->isRunning );
-    assert( torrentIsLocked( t ) );
-    assert( tr_ptrArrayEmpty( &t->outgoingHandshakes ) );
-    assert( tr_ptrArrayEmpty( &t->peers ) );
+    assert (t);
+    assert (!t->isRunning);
+    assert (torrentIsLocked (t));
+    assert (tr_ptrArrayEmpty (&t->outgoingHandshakes));
+    assert (tr_ptrArrayEmpty (&t->peers));
 
-    tr_ptrArrayDestruct( &t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
-    tr_ptrArrayDestruct( &t->pool, (PtrArrayForeachFunc)tr_free );
-    tr_ptrArrayDestruct( &t->outgoingHandshakes, NULL );
-    tr_ptrArrayDestruct( &t->peers, NULL );
+    tr_ptrArrayDestruct (&t->webseeds, (PtrArrayForeachFunc)tr_webseedFree);
+    tr_ptrArrayDestruct (&t->pool, (PtrArrayForeachFunc)tr_free);
+    tr_ptrArrayDestruct (&t->outgoingHandshakes, NULL);
+    tr_ptrArrayDestruct (&t->peers, NULL);
 
-    replicationFree( t );
+    replicationFree (t);
 
-    tr_free( t->requests );
-    tr_free( t->pieces );
-    tr_free( t );
+    tr_free (t->requests);
+    tr_free (t->pieces);
+    tr_free (t);
 }
 
-static void peerCallbackFunc( tr_peer *, const tr_peer_event *, void * );
+static void peerCallbackFunc (tr_peer *, const tr_peer_event *, void *);
 
 static void
-rebuildWebseedArray( Torrent * t, tr_torrent * tor )
+rebuildWebseedArray (Torrent * t, tr_torrent * tor)
 {
     int i;
     const tr_info * inf = &tor->info;
 
     /* clear the array */
-    tr_ptrArrayDestruct( &t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
+    tr_ptrArrayDestruct (&t->webseeds, (PtrArrayForeachFunc)tr_webseedFree);
     t->webseeds = TR_PTR_ARRAY_INIT;
 
     /* repopulate it */
-    for( i = 0; i < inf->webseedCount; ++i )
+    for (i = 0; i < inf->webseedCount; ++i)
     {
-        tr_webseed * w = tr_webseedNew( tor, inf->webseeds[i], peerCallbackFunc, t );
-        tr_ptrArrayAppend( &t->webseeds, w );
+        tr_webseed * w = tr_webseedNew (tor, inf->webseeds[i], peerCallbackFunc, t);
+        tr_ptrArrayAppend (&t->webseeds, w);
     }
 }
 
 static Torrent*
-torrentNew( tr_peerMgr * manager, tr_torrent * tor )
+torrentNew (tr_peerMgr * manager, tr_torrent * tor)
 {
     Torrent * t;
 
-    t = tr_new0( Torrent, 1 );
+    t = tr_new0 (Torrent, 1);
     t->manager = manager;
     t->tor = tor;
     t->pool = TR_PTR_ARRAY_INIT;
@@ -539,71 +543,71 @@ torrentNew( tr_peerMgr * manager, tr_torrent * tor )
     t->webseeds = TR_PTR_ARRAY_INIT;
     t->outgoingHandshakes = TR_PTR_ARRAY_INIT;
 
-    rebuildWebseedArray( t, tor );
+    rebuildWebseedArray (t, tor);
 
     return t;
 }
 
-static void ensureMgrTimersExist( struct tr_peerMgr * m );
+static void ensureMgrTimersExist (struct tr_peerMgr * m);
 
 tr_peerMgr*
-tr_peerMgrNew( tr_session * session )
+tr_peerMgrNew (tr_session * session)
 {
-    tr_peerMgr * m = tr_new0( tr_peerMgr, 1 );
+    tr_peerMgr * m = tr_new0 (tr_peerMgr, 1);
     m->session = session;
     m->incomingHandshakes = TR_PTR_ARRAY_INIT;
-    ensureMgrTimersExist( m );
+    ensureMgrTimersExist (m);
     return m;
 }
 
 static void
-deleteTimer( struct event ** t )
+deleteTimer (struct event ** t)
 {
-    if( *t != NULL )
+    if (*t != NULL)
     {
-        event_free( *t );
+        event_free (*t);
         *t = NULL;
     }
 }
 
 static void
-deleteTimers( struct tr_peerMgr * m )
+deleteTimers (struct tr_peerMgr * m)
 {
-    deleteTimer( &m->atomTimer );
-    deleteTimer( &m->bandwidthTimer );
-    deleteTimer( &m->rechokeTimer );
-    deleteTimer( &m->refillUpkeepTimer );
+    deleteTimer (&m->atomTimer);
+    deleteTimer (&m->bandwidthTimer);
+    deleteTimer (&m->rechokeTimer);
+    deleteTimer (&m->refillUpkeepTimer);
 }
 
 void
-tr_peerMgrFree( tr_peerMgr * manager )
+tr_peerMgrFree (tr_peerMgr * manager)
 {
-    managerLock( manager );
+    managerLock (manager);
 
-    deleteTimers( manager );
+    deleteTimers (manager);
 
-    /* free the handshakes. Abort invokes handshakeDoneCB(), which removes
+    /* free the handshakes. Abort invokes handshakeDoneCB (), which removes
      * the item from manager->handshakes, so this is a little roundabout... */
-    while( !tr_ptrArrayEmpty( &manager->incomingHandshakes ) )
-        tr_handshakeAbort( tr_ptrArrayNth( &manager->incomingHandshakes, 0 ) );
+    while (!tr_ptrArrayEmpty (&manager->incomingHandshakes))
+        tr_handshakeAbort (tr_ptrArrayNth (&manager->incomingHandshakes, 0));
 
-    tr_ptrArrayDestruct( &manager->incomingHandshakes, NULL );
+    tr_ptrArrayDestruct (&manager->incomingHandshakes, NULL);
 
-    managerUnlock( manager );
-    tr_free( manager );
+    managerUnlock (manager);
+    tr_free (manager);
 }
 
 static int
-clientIsDownloadingFrom( const tr_torrent * tor, const tr_peer * peer )
+clientIsDownloadingFrom (const tr_torrent * tor, const tr_peer * peer)
 {
-    if( !tr_torrentHasMetadata( tor ) )
+    if (!tr_torrentHasMetadata (tor))
         return true;
 
     return peer->clientIsInterested && !peer->clientIsChoked;
 }
 
 static int
-clientIsUploadingTo( const tr_peer * peer )
+clientIsUploadingTo (const tr_peer * peer)
 {
     return peer->peerIsInterested && !peer->peerIsChoked;
 }
@@ -613,32 +617,32 @@ clientIsUploadingTo( const tr_peer * peer )
 ***/
 
 void
-tr_peerMgrOnBlocklistChanged( tr_peerMgr * mgr )
+tr_peerMgrOnBlocklistChanged (tr_peerMgr * mgr)
 {
     tr_torrent * tor = NULL;
     tr_session * session = mgr->session;
 
     /* we cache whether or not a peer is blocklisted...
        since the blocklist has changed, erase that cached value */
-    while(( tor = tr_torrentNext( session, tor )))
+    while ((tor = tr_torrentNext (session, tor)))
     {
         int i;
         Torrent * t = tor->torrentPeers;
-        const int n = tr_ptrArraySize( &t->pool );
-        for( i=0; i<n; ++i ) {
-            struct peer_atom * atom = tr_ptrArrayNth( &t->pool, i );
+        const int n = tr_ptrArraySize (&t->pool);
+        for (i=0; i<n; ++i) {
+            struct peer_atom * atom = tr_ptrArrayNth (&t->pool, i);
             atom->blocklisted = -1;
         }
     }
 }
 
 static bool
-isAtomBlocklisted( tr_session * session, struct peer_atom * atom )
+isAtomBlocklisted (tr_session * session, struct peer_atom * atom)
 {
-    if( atom->blocklisted < 0 )
-        atom->blocklisted = tr_sessionIsAddressBlocked( session, &atom->addr );
+    if (atom->blocklisted < 0)
+        atom->blocklisted = tr_sessionIsAddressBlocked (session, &atom->addr);
 
-    assert( tr_isBool( atom->blocklisted ) );
+    assert (tr_isBool (atom->blocklisted));
     return atom->blocklisted;
 }
 
@@ -648,66 +652,66 @@ isAtomBlocklisted( tr_session * session, struct peer_atom * atom )
 ***/
 
 static void
-atomSetSeedProbability( struct peer_atom * atom, int seedProbability )
+atomSetSeedProbability (struct peer_atom * atom, int seedProbability)
 {
-    assert( atom != NULL );
-    assert( -1<=seedProbability && seedProbability<=100 );
+    assert (atom != NULL);
+    assert (-1<=seedProbability && seedProbability<=100);
 
     atom->seedProbability = seedProbability;
 
-    if( seedProbability == 100 )
+    if (seedProbability == 100)
         atom->flags |= ADDED_F_SEED_FLAG;
-    else if( seedProbability != -1 )
+    else if (seedProbability != -1)
         atom->flags &= ~ADDED_F_SEED_FLAG;
 }
 
 static inline bool
-atomIsSeed( const struct peer_atom * atom )
+atomIsSeed (const struct peer_atom * atom)
 {
     return atom->seedProbability == 100;
 }
 
 static void
-atomSetSeed( const Torrent * t, struct peer_atom * atom )
+atomSetSeed (const Torrent * t, struct peer_atom * atom)
 {
-    if( !atomIsSeed( atom ) )
+    if (!atomIsSeed (atom))
     {
-        tordbg( t, "marking peer %s as a seed", tr_atomAddrStr( atom ) );
+        tordbg (t, "marking peer %s as a seed", tr_atomAddrStr (atom));
 
-        atomSetSeedProbability( atom, 100 );
+        atomSetSeedProbability (atom, 100);
     }
 }
 
 
 bool
-tr_peerMgrPeerIsSeed( const tr_torrent  * tor,
-                      const tr_address  * addr )
+tr_peerMgrPeerIsSeed (const tr_torrent  * tor,
+                      const tr_address  * addr)
 {
     bool isSeed = false;
     const Torrent * t = tor->torrentPeers;
-    const struct peer_atom * atom = getExistingAtom( t, addr );
+    const struct peer_atom * atom = getExistingAtom (t, addr);
 
-    if( atom )
-        isSeed = atomIsSeed( atom );
+    if (atom)
+        isSeed = atomIsSeed (atom);
 
     return isSeed;
 }
 
 void
-tr_peerMgrSetUtpSupported( tr_torrent * tor, const tr_address * addr )
+tr_peerMgrSetUtpSupported (tr_torrent * tor, const tr_address * addr)
 {
-    struct peer_atom * atom = getExistingAtom( tor->torrentPeers, addr );
+    struct peer_atom * atom = getExistingAtom (tor->torrentPeers, addr);
 
-    if( atom )
+    if (atom)
         atom->flags |= ADDED_F_UTP_FLAGS;
 }
 
 void
-tr_peerMgrSetUtpFailed( tr_torrent *tor, const tr_address *addr, bool failed )
+tr_peerMgrSetUtpFailed (tr_torrent *tor, const tr_address *addr, bool failed)
 {
-    struct peer_atom * atom = getExistingAtom( tor->torrentPeers, addr );
+    struct peer_atom * atom = getExistingAtom (tor->torrentPeers, addr);
 
-    if( atom )
+    if (atom)
         atom->utp_failed = failed;
 }
 
@@ -724,7 +728,7 @@ tr_peerMgrSetUtpFailed( tr_torrent *tor, const tr_address *addr, bool failed )
 ***
 *** 2. Torrent::pieces, an array of "struct weighted_piece" which lists the
 ***    pieces that we want to request. It's used to decide which blocks to
-***    return next when tr_peerMgrGetBlockRequests() is called.
+***    return next when tr_peerMgrGetBlockRequests () is called.
 **/
 
 /**
@@ -732,75 +736,75 @@ tr_peerMgrSetUtpFailed( tr_torrent *tor, const tr_address *addr, bool failed )
 **/
 
 static int
-compareReqByBlock( const void * va, const void * vb )
+compareReqByBlock (const void * va, const void * vb)
 {
     const struct block_request * a = va;
     const struct block_request * b = vb;
 
     /* primary key: block */
-    if( a->block < b->block ) return -1;
-    if( a->block > b->block ) return 1;
+    if (a->block < b->block) return -1;
+    if (a->block > b->block) return 1;
 
     /* secondary key: peer */
-    if( a->peer < b->peer ) return -1;
-    if( a->peer > b->peer ) return 1;
+    if (a->peer < b->peer) return -1;
+    if (a->peer > b->peer) return 1;
 
     return 0;
 }
 
 static void
-requestListAdd( Torrent * t, tr_block_index_t block, tr_peer * peer )
+requestListAdd (Torrent * t, tr_block_index_t block, tr_peer * peer)
 {
     struct block_request key;
 
     /* ensure enough room is available... */
-    if( t->requestCount + 1 >= t->requestAlloc )
+    if (t->requestCount + 1 >= t->requestAlloc)
     {
         const int CHUNK_SIZE = 128;
         t->requestAlloc += CHUNK_SIZE;
-        t->requests = tr_renew( struct block_request,
-                                t->requests, t->requestAlloc );
+        t->requests = tr_renew (struct block_request,
+                                t->requests, t->requestAlloc);
     }
 
     /* populate the record we're inserting */
     key.block = block;
     key.peer = peer;
-    key.sentAt = tr_time( );
+    key.sentAt = tr_time ();
 
     /* insert the request to our array... */
     {
         bool exact;
-        const int pos = tr_lowerBound( &key, t->requests, t->requestCount,
-                                       sizeof( struct block_request ),
-                                       compareReqByBlock, &exact );
-        assert( !exact );
-        memmove( t->requests + pos + 1,
+        const int pos = tr_lowerBound (&key, t->requests, t->requestCount,
+                                       sizeof (struct block_request),
+                                       compareReqByBlock, &exact);
+        assert (!exact);
+        memmove (t->requests + pos + 1,
                  t->requests + pos,
-                 sizeof( struct block_request ) * ( t->requestCount++ - pos ) );
+                 sizeof (struct block_request) * (t->requestCount++ - pos));
         t->requests[pos] = key;
     }
 
-    if( peer != NULL )
+    if (peer != NULL)
     {
         ++peer->pendingReqsToPeer;
-        assert( peer->pendingReqsToPeer >= 0 );
+        assert (peer->pendingReqsToPeer >= 0);
     }
 
-    /*fprintf( stderr, "added request of block %lu from peer %s... "
+    /*fprintf (stderr, "added request of block %lu from peer %s... "
                        "there are now %d block\n",
-                       (unsigned long)block, tr_atomAddrStr( peer->atom ), t->requestCount );*/
+                     (unsigned long)block, tr_atomAddrStr (peer->atom), t->requestCount);*/
 }
 
 static struct block_request *
-requestListLookup( Torrent * t, tr_block_index_t block, const tr_peer * peer )
+requestListLookup (Torrent * t, tr_block_index_t block, const tr_peer * peer)
 {
     struct block_request key;
     key.block = block;
     key.peer = (tr_peer*) peer;
 
-    return bsearch( &key, t->requests, t->requestCount,
-                    sizeof( struct block_request ),
-                    compareReqByBlock );
+    return bsearch (&key, t->requests, t->requestCount,
+                    sizeof (struct block_request),
+                    compareReqByBlock);
 }
 
 /**
@@ -808,8 +812,8 @@ requestListLookup( Torrent * t, tr_block_index_t block, const tr_peer * peer )
  * with index @a block from and append them to @a peerArr.
  */
 static void
-getBlockRequestPeers( Torrent * t, tr_block_index_t block,
-                      tr_ptrArray * peerArr )
+getBlockRequestPeers (Torrent * t, tr_block_index_t block,
+                      tr_ptrArray * peerArr)
 {
     bool exact;
     int i, pos;
@@ -817,99 +821,99 @@ getBlockRequestPeers( Torrent * t, tr_block_index_t block,
 
     key.block = block;
     key.peer = NULL;
-    pos = tr_lowerBound( &key, t->requests, t->requestCount,
-                         sizeof( struct block_request ),
-                         compareReqByBlock, &exact );
+    pos = tr_lowerBound (&key, t->requests, t->requestCount,
+                         sizeof (struct block_request),
+                         compareReqByBlock, &exact);
 
-    assert( !exact ); /* shouldn't have a request with .peer == NULL */
+    assert (!exact); /* shouldn't have a request with .peer == NULL */
 
-    for( i = pos; i < t->requestCount; ++i )
+    for (i = pos; i < t->requestCount; ++i)
     {
-        if( t->requests[i].block != block )
+        if (t->requests[i].block != block)
             break;
-        tr_ptrArrayAppend( peerArr, t->requests[i].peer );
+        tr_ptrArrayAppend (peerArr, t->requests[i].peer);
     }
 }
 
 static void
-decrementPendingReqCount( const struct block_request * b )
+decrementPendingReqCount (const struct block_request * b)
 {
-    if( b->peer != NULL )
-        if( b->peer->pendingReqsToPeer > 0 )
+    if (b->peer != NULL)
+        if (b->peer->pendingReqsToPeer > 0)
             --b->peer->pendingReqsToPeer;
 }
 
 static void
-requestListRemove( Torrent * t, tr_block_index_t block, const tr_peer * peer )
+requestListRemove (Torrent * t, tr_block_index_t block, const tr_peer * peer)
 {
-    const struct block_request * b = requestListLookup( t, block, peer );
-    if( b != NULL )
+    const struct block_request * b = requestListLookup (t, block, peer);
+    if (b != NULL)
     {
         const int pos = b - t->requests;
-        assert( pos < t->requestCount );
+        assert (pos < t->requestCount);
 
-        decrementPendingReqCount( b );
+        decrementPendingReqCount (b);
 
-        tr_removeElementFromArray( t->requests,
+        tr_removeElementFromArray (t->requests,
                                    pos,
-                                   sizeof( struct block_request ),
-                                   t->requestCount-- );
+                                   sizeof (struct block_request),
+                                   t->requestCount--);
 
-        /*fprintf( stderr, "removing request of block %lu from peer %s... "
+        /*fprintf (stderr, "removing request of block %lu from peer %s... "
                            "there are now %d block requests left\n",
-                           (unsigned long)block, tr_atomAddrStr( peer->atom ), t->requestCount );*/
+                         (unsigned long)block, tr_atomAddrStr (peer->atom), t->requestCount);*/
     }
 }
 
 static int
-countActiveWebseeds( const Torrent * t )
+countActiveWebseeds (const Torrent * t)
 {
     int activeCount = 0;
-    const tr_webseed ** w = (const tr_webseed **) tr_ptrArrayBase( &t->webseeds );
-    const tr_webseed ** const wend = w + tr_ptrArraySize( &t->webseeds );
+    const tr_webseed ** w = (const tr_webseed **) tr_ptrArrayBase (&t->webseeds);
+    const tr_webseed ** const wend = w + tr_ptrArraySize (&t->webseeds);
 
-    for( ; w!=wend; ++w )
-        if( tr_webseedIsActive( *w ) )
+    for (; w!=wend; ++w)
+        if (tr_webseedIsActive (*w))
             ++activeCount;
 
     return activeCount;
 }
 
 static bool
-testForEndgame( const Torrent * t )
+testForEndgame (const Torrent * t)
 {
     /* we consider ourselves to be in endgame if the number of bytes
        we've got requested is >= the number of bytes left to download */
-    return ( t->requestCount * t->tor->blockSize )
-               >= tr_cpLeftUntilDone( &t->tor->completion );
+    return (t->requestCount * t->tor->blockSize)
+               >= tr_cpLeftUntilDone (&t->tor->completion);
 }
 
 static void
-updateEndgame( Torrent * t )
+updateEndgame (Torrent * t)
 {
-    assert( t->requestCount >= 0 );
+    assert (t->requestCount >= 0);
 
-    if( !testForEndgame( t ) )
+    if (!testForEndgame (t))
     {
         /* not in endgame */
         t->endgame = 0;
     }
-    else if( !t->endgame ) /* only recalculate when endgame first begins */
+    else if (!t->endgame) /* only recalculate when endgame first begins */
     {
         int numDownloading = 0;
-        const tr_peer ** p = (const tr_peer **) tr_ptrArrayBase( &t->peers );
-        const tr_peer ** const pend = p + tr_ptrArraySize( &t->peers );
+        const tr_peer ** p = (const tr_peer **) tr_ptrArrayBase (&t->peers);
+        const tr_peer ** const pend = p + tr_ptrArraySize (&t->peers);
 
         /* add the active bittorrent peers... */
-        for( ; p!=pend; ++p )
-            if( (*p)->pendingReqsToPeer > 0 )
+        for (; p!=pend; ++p)
+            if ((*p)->pendingReqsToPeer > 0)
                 ++numDownloading;
 
         /* add the active webseeds... */
-        numDownloading += countActiveWebseeds( t );
+        numDownloading += countActiveWebseeds (t);
 
         /* average number of pending requests per downloading peer */
-        t->endgame = t->requestCount / MAX( numDownloading, 1 );
+        t->endgame = t->requestCount / MAX (numDownloading, 1);
     }
 }
 
@@ -921,7 +925,7 @@ updateEndgame( Torrent * t )
 ****/
 
 static inline void
-invalidatePieceSorting( Torrent * t )
+invalidatePieceSorting (Torrent * t)
 {
     t->pieceSortState = PIECES_UNSORTED;
 }
@@ -931,10 +935,10 @@ static const tr_torrent * weightTorrent;
 static const uint16_t * weightReplication;
 
 static void
-setComparePieceByWeightTorrent( Torrent * t )
+setComparePieceByWeightTorrent (Torrent * t)
 {
-    if( !replicationExists( t ) )
-        replicationNew( t );
+    if (!replicationExists (t))
+        replicationNew (t);
 
     weightTorrent = t->tor;
     weightReplication = t->pieceReplication;
@@ -943,7 +947,7 @@ setComparePieceByWeightTorrent( Torrent * t )
 /* we try to create a "weight" s.t. high-priority pieces come before others,
  * and that partially-complete pieces come before empty ones. */
 static int
-comparePieceByWeight( const void * va, const void * vb )
+comparePieceByWeight (const void * va, const void * vb)
 {
     const struct weighted_piece * a = va;
     const struct weighted_piece * b = vb;
@@ -952,59 +956,59 @@ comparePieceByWeight( const void * va, const void * vb )
     const uint16_t * rep = weightReplication;
 
     /* primary key: weight */
-    missing = tr_cpMissingBlocksInPiece( &tor->completion, a->index );
+    missing = tr_cpMissingBlocksInPiece (&tor->completion, a->index);
     pending = a->requestCount;
     ia = missing > pending ? missing - pending : (tor->blockCountInPiece + pending);
-    missing = tr_cpMissingBlocksInPiece( &tor->completion, b->index );
+    missing = tr_cpMissingBlocksInPiece (&tor->completion, b->index);
     pending = b->requestCount;
     ib = missing > pending ? missing - pending : (tor->blockCountInPiece + pending);
-    if( ia < ib ) return -1;
-    if( ia > ib ) return 1;
+    if (ia < ib) return -1;
+    if (ia > ib) return 1;
 
     /* secondary key: higher priorities go first */
     ia = tor->info.pieces[a->index].priority;
     ib = tor->info.pieces[b->index].priority;
-    if( ia > ib ) return -1;
-    if( ia < ib ) return 1;
+    if (ia > ib) return -1;
+    if (ia < ib) return 1;
 
     /* tertiary key: rarest first. */
     ia = rep[a->index];
     ib = rep[b->index];
-    if( ia < ib ) return -1;
-    if( ia > ib ) return 1;
+    if (ia < ib) return -1;
+    if (ia > ib) return 1;
 
     /* quaternary key: random */
-    if( a->salt < b->salt ) return -1;
-    if( a->salt > b->salt ) return 1;
+    if (a->salt < b->salt) return -1;
+    if (a->salt > b->salt) return 1;
 
     /* okay, they're equal */
     return 0;
 }
 
 static int
-comparePieceByIndex( const void * va, const void * vb )
+comparePieceByIndex (const void * va, const void * vb)
 {
     const struct weighted_piece * a = va;
     const struct weighted_piece * b = vb;
-    if( a->index < b->index ) return -1;
-    if( a->index > b->index ) return 1;
+    if (a->index < b->index) return -1;
+    if (a->index > b->index) return 1;
     return 0;
 }
 
 static void
-pieceListSort( Torrent * t, enum piece_sort_state state )
+pieceListSort (Torrent * t, enum piece_sort_state state)
 {
-    assert( state==PIECES_SORTED_BY_INDEX
-         || state==PIECES_SORTED_BY_WEIGHT );
+    assert (state==PIECES_SORTED_BY_INDEX
+         || state==PIECES_SORTED_BY_WEIGHT);
 
 
-    if( state == PIECES_SORTED_BY_WEIGHT )
+    if (state == PIECES_SORTED_BY_WEIGHT)
     {
-        setComparePieceByWeightTorrent( t );
-        qsort( t->pieces, t->pieceCount, sizeof( struct weighted_piece ), comparePieceByWeight );
+        setComparePieceByWeightTorrent (t);
+        qsort (t->pieces, t->pieceCount, sizeof (struct weighted_piece), comparePieceByWeight);
     }
     else
-        qsort( t->pieces, t->pieceCount, sizeof( struct weighted_piece ), comparePieceByIndex );
+        qsort (t->pieces, t->pieceCount, sizeof (struct weighted_piece), comparePieceByIndex);
 
     t->pieceSortState = state;
 }
@@ -1018,18 +1022,18 @@ pieceListSort( Torrent * t, enum piece_sort_state state )
 #define assertReplicationCountIsExact(t)
 #else
 static void
-assertWeightedPiecesAreSorted( Torrent * t )
+assertWeightedPiecesAreSorted (Torrent * t)
 {
-    if( !t->endgame )
+    if (!t->endgame)
     {
         int i;
-        setComparePieceByWeightTorrent( t );
-        for( i=0; i<t->pieceCount-1; ++i )
-            assert( comparePieceByWeight( &t->pieces[i], &t->pieces[i+1] ) <= 0 );
+        setComparePieceByWeightTorrent (t);
+        for (i=0; i<t->pieceCount-1; ++i)
+            assert (comparePieceByWeight (&t->pieces[i], &t->pieces[i+1]) <= 0);
     }
 }
 static void
-assertReplicationCountIsExact( Torrent * t )
+assertReplicationCountIsExact (Torrent * t)
 {
     /* This assert might fail due to errors of implementations in other
      * clients. It happens when receiving duplicate bitfields/HaveAll/HaveNone
@@ -1039,186 +1043,186 @@ assertReplicationCountIsExact( Torrent * t )
     size_t piece_i;
     const uint16_t * rep = t->pieceReplication;
     const size_t piece_count = t->pieceReplicationSize;
-    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
-    const int peer_count = tr_ptrArraySize( &t->peers );
+    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
+    const int peer_count = tr_ptrArraySize (&t->peers);
 
-    assert( piece_count == t->tor->info.pieceCount );
+    assert (piece_count == t->tor->info.pieceCount);
 
-    for( piece_i=0; piece_i<piece_count; ++piece_i )
+    for (piece_i=0; piece_i<piece_count; ++piece_i)
     {
         int peer_i;
         uint16_t r = 0;
 
-        for( peer_i=0; peer_i<peer_count; ++peer_i )
-            if( tr_bitsetHas( &peers[peer_i]->have, piece_i ) )
+        for (peer_i=0; peer_i<peer_count; ++peer_i)
+            if (tr_bitsetHas (&peers[peer_i]->have, piece_i))
                 ++r;
 
-        assert( rep[piece_i] == r );
+        assert (rep[piece_i] == r);
     }
 }
 #endif
 
 static struct weighted_piece *
-pieceListLookup( Torrent * t, tr_piece_index_t index )
+pieceListLookup (Torrent * t, tr_piece_index_t index)
 {
     int i;
 
-    for( i=0; i<t->pieceCount; ++i )
-        if( t->pieces[i].index == index )
+    for (i=0; i<t->pieceCount; ++i)
+        if (t->pieces[i].index == index)
             return &t->pieces[i];
 
     return NULL;
 }
 
 static void
-pieceListRebuild( Torrent * t )
+pieceListRebuild (Torrent * t)
 {
 
-    if( !tr_torrentIsSeed( t->tor ) )
+    if (!tr_torrentIsSeed (t->tor))
     {
         tr_piece_index_t i;
         tr_piece_index_t * pool;
         tr_piece_index_t poolCount = 0;
         const tr_torrent * tor = t->tor;
-        const tr_info * inf = tr_torrentInfo( tor );
+        const tr_info * inf = tr_torrentInfo (tor);
         struct weighted_piece * pieces;
         int pieceCount;
 
         /* build the new list */
-        pool = tr_new( tr_piece_index_t, inf->pieceCount );
-        for( i=0; i<inf->pieceCount; ++i )
-            if( !inf->pieces[i].dnd )
-                if( !tr_cpPieceIsComplete( &tor->completion, i ) )
+        pool = tr_new (tr_piece_index_t, inf->pieceCount);
+        for (i=0; i<inf->pieceCount; ++i)
+            if (!inf->pieces[i].dnd)
+                if (!tr_cpPieceIsComplete (&tor->completion, i))
                     pool[poolCount++] = i;
         pieceCount = poolCount;
-        pieces = tr_new0( struct weighted_piece, pieceCount );
-        for( i=0; i<poolCount; ++i ) {
+        pieces = tr_new0 (struct weighted_piece, pieceCount);
+        for (i=0; i<poolCount; ++i) {
             struct weighted_piece * piece = pieces + i;
             piece->index = pool[i];
             piece->requestCount = 0;
-            piece->salt = tr_cryptoWeakRandInt( 4096 );
+            piece->salt = tr_cryptoWeakRandInt (4096);
         }
 
         /* if we already had a list of pieces, merge it into
          * the new list so we don't lose its requestCounts */
-        if( t->pieces != NULL )
+        if (t->pieces != NULL)
         {
             struct weighted_piece * o = t->pieces;
             struct weighted_piece * oend = o + t->pieceCount;
             struct weighted_piece * n = pieces;
             struct weighted_piece * nend = n + pieceCount;
 
-            pieceListSort( t, PIECES_SORTED_BY_INDEX );
+            pieceListSort (t, PIECES_SORTED_BY_INDEX);
 
-            while( o!=oend && n!=nend ) {
-                if( o->index < n->index )
+            while (o!=oend && n!=nend) {
+                if (o->index < n->index)
                     ++o;
-                else if( o->index > n->index )
+                else if (o->index > n->index)
                     ++n;
                 else
                     *n++ = *o++;
             }
 
-            tr_free( t->pieces );
+            tr_free (t->pieces);
         }
 
         t->pieces = pieces;
         t->pieceCount = pieceCount;
 
-        pieceListSort( t, PIECES_SORTED_BY_WEIGHT );
+        pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
 
         /* cleanup */
-        tr_free( pool );
+        tr_free (pool);
     }
 }
 
 static void
-pieceListRemovePiece( Torrent * t, tr_piece_index_t piece )
+pieceListRemovePiece (Torrent * t, tr_piece_index_t piece)
 {
     struct weighted_piece * p;
 
-    if(( p = pieceListLookup( t, piece )))
+    if ((p = pieceListLookup (t, piece)))
     {
         const int pos = p - t->pieces;
 
-        tr_removeElementFromArray( t->pieces,
+        tr_removeElementFromArray (t->pieces,
                                    pos,
-                                   sizeof( struct weighted_piece ),
-                                   t->pieceCount-- );
+                                   sizeof (struct weighted_piece),
+                                   t->pieceCount--);
 
-        if( t->pieceCount == 0 )
+        if (t->pieceCount == 0)
         {
-            tr_free( t->pieces );
+            tr_free (t->pieces);
             t->pieces = NULL;
         }
     }
 }
 
 static void
-pieceListResortPiece( Torrent * t, struct weighted_piece * p )
+pieceListResortPiece (Torrent * t, struct weighted_piece * p)
 {
     int pos;
     bool isSorted = true;
 
-    if( p == NULL )
+    if (p == NULL)
         return;
 
     /* is the torrent already sorted? */
     pos = p - t->pieces;
-    setComparePieceByWeightTorrent( t );
-    if( isSorted && ( pos > 0 ) && ( comparePieceByWeight( p-1, p ) > 0 ) )
+    setComparePieceByWeightTorrent (t);
+    if (isSorted && (pos > 0) && (comparePieceByWeight (p-1, p) > 0))
         isSorted = false;
-    if( isSorted && ( pos < t->pieceCount - 1 ) && ( comparePieceByWeight( p, p+1 ) > 0 ) )
+    if (isSorted && (pos < t->pieceCount - 1) && (comparePieceByWeight (p, p+1) > 0))
         isSorted = false;
 
-    if( t->pieceSortState != PIECES_SORTED_BY_WEIGHT )
+    if (t->pieceSortState != PIECES_SORTED_BY_WEIGHT)
     {
-       pieceListSort( t, PIECES_SORTED_BY_WEIGHT);
+       pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
        isSorted = true;
     }
 
     /* if it's not sorted, move it around */
-    if( !isSorted )
+    if (!isSorted)
     {
         bool exact;
         const struct weighted_piece tmp = *p;
 
-        tr_removeElementFromArray( t->pieces,
+        tr_removeElementFromArray (t->pieces,
                                    pos,
-                                   sizeof( struct weighted_piece ),
-                                   t->pieceCount-- );
+                                   sizeof (struct weighted_piece),
+                                   t->pieceCount--);
 
-        pos = tr_lowerBound( &tmp, t->pieces, t->pieceCount,
-                             sizeof( struct weighted_piece ),
-                             comparePieceByWeight, &exact );
+        pos = tr_lowerBound (&tmp, t->pieces, t->pieceCount,
+                             sizeof (struct weighted_piece),
+                             comparePieceByWeight, &exact);
 
-        memmove( &t->pieces[pos + 1],
+        memmove (&t->pieces[pos + 1],
                  &t->pieces[pos],
-                 sizeof( struct weighted_piece ) * ( t->pieceCount++ - pos ) );
+                 sizeof (struct weighted_piece) * (t->pieceCount++ - pos));
 
         t->pieces[pos] = tmp;
     }
 
-    assertWeightedPiecesAreSorted( t );
+    assertWeightedPiecesAreSorted (t);
 }
 
 static void
-pieceListRemoveRequest( Torrent * t, tr_block_index_t block )
+pieceListRemoveRequest (Torrent * t, tr_block_index_t block)
 {
     struct weighted_piece * p;
-    const tr_piece_index_t index = tr_torBlockPiece( t->tor, block );
+    const tr_piece_index_t index = tr_torBlockPiece (t->tor, block);
 
-    if( ((p = pieceListLookup( t, index ))) && ( p->requestCount > 0 ) )
+    if (((p = pieceListLookup (t, index))) && (p->requestCount > 0))
     {
         --p->requestCount;
-        pieceListResortPiece( t, p );
+        pieceListResortPiece (t, p);
     }
 }
 
 
 /****
 *****
-*****  Replication count ( for rarest first policy )
+*****  Replication count (for rarest first policy)
 *****
 ****/
 
@@ -1227,52 +1231,52 @@ pieceListRemoveRequest( Torrent * t, tr_block_index_t block )
  * piece list is already sorted
  */
 static void
-tr_incrReplicationOfPiece( Torrent * t, const size_t index )
+tr_incrReplicationOfPiece (Torrent * t, const size_t index)
 {
-    assert( replicationExists( t ) );
-    assert( t->pieceReplicationSize == t->tor->info.pieceCount );
+    assert (replicationExists (t));
+    assert (t->pieceReplicationSize == t->tor->info.pieceCount);
 
     /* One more replication of this piece is present in the swarm */
     ++t->pieceReplication[index];
 
     /* we only resort the piece if the list is already sorted */
-    if( t->pieceSortState == PIECES_SORTED_BY_WEIGHT )
-        pieceListResortPiece( t, pieceListLookup( t, index ) );
+    if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
+        pieceListResortPiece (t, pieceListLookup (t, index));
 }
 
 /**
  * Increases the replication count of pieces present in the bitfield
  */
 static void
-tr_incrReplicationFromBitfield( Torrent * t, const tr_bitfield * b )
+tr_incrReplicationFromBitfield (Torrent * t, const tr_bitfield * b)
 {
     size_t i;
     uint16_t * rep = t->pieceReplication;
     const size_t n = t->tor->info.pieceCount;
 
-    assert( replicationExists( t ) );
+    assert (replicationExists (t));
 
-    for( i=0; i<n; ++i )
-        if( tr_bitfieldHas( b, i ) )
+    for (i=0; i<n; ++i)
+        if (tr_bitfieldHas (b, i))
             ++rep[i];
 
-    if( t->pieceSortState == PIECES_SORTED_BY_WEIGHT )
-        invalidatePieceSorting( t );
+    if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
+        invalidatePieceSorting (t);
 }
 
 /**
  * Increase the replication count of every piece
  */
 static void
-tr_incrReplication( Torrent * t )
+tr_incrReplication (Torrent * t)
 {
     int i;
     const int n = t->pieceReplicationSize;
 
-    assert( replicationExists( t ) );
-    assert( t->pieceReplicationSize == t->tor->info.pieceCount );
+    assert (replicationExists (t));
+    assert (t->pieceReplicationSize == t->tor->info.pieceCount);
 
-    for( i=0; i<n; ++i )
+    for (i=0; i<n; ++i)
         ++t->pieceReplication[i];
 }
 
@@ -1280,27 +1284,27 @@ tr_incrReplication( Torrent * t )
  * Decrease the replication count of pieces present in the bitset.
  */
 static void
-tr_decrReplicationFromBitfield( Torrent * t, const tr_bitfield * b )
+tr_decrReplicationFromBitfield (Torrent * t, const tr_bitfield * b)
 {
     int i;
     const int n = t->pieceReplicationSize;
 
-    assert( replicationExists( t ) );
-    assert( t->pieceReplicationSize == t->tor->info.pieceCount );
+    assert (replicationExists (t));
+    assert (t->pieceReplicationSize == t->tor->info.pieceCount);
 
-    if( tr_bitfieldHasAll( b ) )
+    if (tr_bitfieldHasAll (b))
     {
-        for( i=0; i<n; ++i )
+        for (i=0; i<n; ++i)
             --t->pieceReplication[i];
     }
-    else if ( !tr_bitfieldHasNone( b ) )
+    else if (!tr_bitfieldHasNone (b))
     {
-        for( i=0; i<n; ++i )
-            if( tr_bitfieldHas( b, i ) )
+        for (i=0; i<n; ++i)
+            if (tr_bitfieldHas (b, i))
                 --t->pieceReplication[i];
 
-        if( t->pieceSortState == PIECES_SORTED_BY_WEIGHT )
-            invalidatePieceSorting( t );
+        if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
+            invalidatePieceSorting (t);
     }
 }
 
@@ -1309,20 +1313,20 @@ tr_decrReplicationFromBitfield( Torrent * t, const tr_bitfield * b )
 **/
 
 void
-tr_peerMgrRebuildRequests( tr_torrent * tor )
+tr_peerMgrRebuildRequests (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    pieceListRebuild( tor->torrentPeers );
+    pieceListRebuild (tor->torrentPeers);
 }
 
 void
-tr_peerMgrGetNextRequests( tr_torrent           * tor,
+tr_peerMgrGetNextRequests (tr_torrent           * tor,
                            tr_peer              * peer,
                            int                    numwant,
                            tr_block_index_t     * setme,
                            int                  * numgot,
-                           bool                   get_intervals )
+                           bool                   get_intervals)
 {
     int i;
     int got;
@@ -1331,82 +1335,82 @@ tr_peerMgrGetNextRequests( tr_torrent           * tor,
     const tr_bitfield * const have = &peer->have;
 
     /* sanity clause */
-    assert( tr_isTorrent( tor ) );
-    assert( peer->clientIsInterested );
-    assert( !peer->clientIsChoked );
-    assert( numwant > 0 );
+    assert (tr_isTorrent (tor));
+    assert (peer->clientIsInterested);
+    assert (!peer->clientIsChoked);
+    assert (numwant > 0);
 
     /* walk through the pieces and find blocks that should be requested */
     got = 0;
     t = tor->torrentPeers;
 
     /* prep the pieces list */
-    if( t->pieces == NULL )
-        pieceListRebuild( t );
+    if (t->pieces == NULL)
+        pieceListRebuild (t);
 
-    if( t->pieceSortState != PIECES_SORTED_BY_WEIGHT )
-        pieceListSort( t, PIECES_SORTED_BY_WEIGHT );
+    if (t->pieceSortState != PIECES_SORTED_BY_WEIGHT)
+        pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
 
-    assertReplicationCountIsExact( t );
-    assertWeightedPiecesAreSorted( t );
+    assertReplicationCountIsExact (t);
+    assertWeightedPiecesAreSorted (t);
 
-    updateEndgame( t );
+    updateEndgame (t);
     pieces = t->pieces;
-    for( i=0; i<t->pieceCount && got<numwant; ++i )
+    for (i=0; i<t->pieceCount && got<numwant; ++i)
     {
         struct weighted_piece * p = pieces + i;
 
         /* if the peer has this piece that we want... */
-        if( tr_bitfieldHas( have, p->index ) )
+        if (tr_bitfieldHas (have, p->index))
         {
             tr_block_index_t b;
             tr_block_index_t first;
             tr_block_index_t last;
             tr_ptrArray peerArr = TR_PTR_ARRAY_INIT;
 
-            tr_torGetPieceBlockRange( tor, p->index, &first, &last );
+            tr_torGetPieceBlockRange (tor, p->index, &first, &last);
 
-            for( b=first; b<=last && (got<numwant || (get_intervals && setme[2*got-1] == b-1)); ++b )
+            for (b=first; b<=last && (got<numwant || (get_intervals && setme[2*got-1] == b-1)); ++b)
             {
                 int peerCount;
                 tr_peer ** peers;
 
                 /* don't request blocks we've already got */
-                if( tr_cpBlockIsComplete( &tor->completion, b ) )
+                if (tr_cpBlockIsComplete (&tor->completion, b))
                     continue;
 
                 /* always add peer if this block has no peers yet */
-                tr_ptrArrayClear( &peerArr );
-                getBlockRequestPeers( t, b, &peerArr );
-                peers = (tr_peer **) tr_ptrArrayPeek( &peerArr, &peerCount );
-                if( peerCount != 0 )
+                tr_ptrArrayClear (&peerArr);
+                getBlockRequestPeers (t, b, &peerArr);
+                peers = (tr_peer **) tr_ptrArrayPeek (&peerArr, &peerCount);
+                if (peerCount != 0)
                 {
                     /* don't make a second block request until the endgame */
-                    if( !t->endgame )
+                    if (!t->endgame)
                         continue;
 
                     /* don't have more than two peers requesting this block */
-                    if( peerCount > 1 )
+                    if (peerCount > 1)
                         continue;
 
                     /* don't send the same request to the same peer twice */
-                    if( peer == peers[0] )
+                    if (peer == peers[0])
                         continue;
 
                     /* in the endgame allow an additional peer to download a
                        block but only if the peer seems to be handling requests
                        relatively fast */
-                    if( peer->pendingReqsToPeer + numwant - got < t->endgame )
+                    if (peer->pendingReqsToPeer + numwant - got < t->endgame)
                         continue;
                 }
 
                 /* update the caller's table */
-                if( !get_intervals ) {
+                if (!get_intervals) {
                     setme[got++] = b;
                 }
                 /* if intervals are requested two array entries are necessarry:
                    one for the interval's starting block and one for its end block */
-                else if( got && setme[2 * got - 1] == b - 1 && b != first ) {
+                else if (got && setme[2 * got - 1] == b - 1 && b != first) {
                     /* expand the last interval */
                     ++setme[2 * got - 1];
                 }
@@ -1417,59 +1421,59 @@ tr_peerMgrGetNextRequests( tr_torrent           * tor,
                 }
 
                 /* update our own tables */
-                requestListAdd( t, b, peer );
+                requestListAdd (t, b, peer);
                 ++p->requestCount;
             }
 
-            tr_ptrArrayDestruct( &peerArr, NULL );
+            tr_ptrArrayDestruct (&peerArr, NULL);
         }
     }
 
     /* In most cases we've just changed the weights of a small number of pieces.
-     * So rather than qsort()ing the entire array, it's faster to apply an
+     * So rather than qsort ()ing the entire array, it's faster to apply an
      * adaptive insertion sort algorithm. */
-    if( got > 0 )
+    if (got > 0)
     {
         /* not enough requests || last piece modified */
-        if ( i == t->pieceCount ) --i;
+        if (i == t->pieceCount) --i;
 
-        setComparePieceByWeightTorrent( t );
-        while( --i >= 0 )
+        setComparePieceByWeightTorrent (t);
+        while (--i >= 0)
         {
             bool exact;
 
             /* relative position! */
-            const int newpos = tr_lowerBound( &t->pieces[i], &t->pieces[i + 1],
+            const int newpos = tr_lowerBound (&t->pieces[i], &t->pieces[i + 1],
                                               t->pieceCount - (i + 1),
-                                              sizeof( struct weighted_piece ),
-                                              comparePieceByWeight, &exact );
-            if( newpos > 0 )
+                                              sizeof (struct weighted_piece),
+                                              comparePieceByWeight, &exact);
+            if (newpos > 0)
             {
                 const struct weighted_piece piece = t->pieces[i];
-                memmove( &t->pieces[i],
+                memmove (&t->pieces[i],
                          &t->pieces[i + 1],
-                         sizeof( struct weighted_piece ) * ( newpos ) );
+                         sizeof (struct weighted_piece) * (newpos));
                 t->pieces[i + newpos] = piece;
             }
         }
     }
 
-    assertWeightedPiecesAreSorted( t );
+    assertWeightedPiecesAreSorted (t);
     *numgot = got;
 }
 
 bool
-tr_peerMgrDidPeerRequest( const tr_torrent  * tor,
+tr_peerMgrDidPeerRequest (const tr_torrent  * tor,
                           const tr_peer     * peer,
-                          tr_block_index_t    block )
+                          tr_block_index_t    block)
 {
     const Torrent * t = tor->torrentPeers;
-    return requestListLookup( (Torrent*)t, block, peer ) != NULL;
+    return requestListLookup ((Torrent*)t, block, peer) != NULL;
 }
 
 /* cancel requests that are too old */
 static void
-refillUpkeep( int foo UNUSED, short bar UNUSED, void * vmgr )
+refillUpkeep (int foo UNUSED, short bar UNUSED, void * vmgr)
 {
     time_t now;
     time_t too_old;
@@ -1477,38 +1481,38 @@ refillUpkeep( int foo UNUSED, short bar UNUSED, void * vmgr )
     int cancel_buflen = 0;
     struct block_request * cancel = NULL;
     tr_peerMgr * mgr = vmgr;
-    managerLock( mgr );
+    managerLock (mgr);
 
-    now = tr_time( );
+    now = tr_time ();
     too_old = now - REQUEST_TTL_SECS;
 
     /* alloc the temporary "cancel" buffer */
     tor = NULL;
-    while(( tor = tr_torrentNext( mgr->session, tor )))
-        cancel_buflen = MAX( cancel_buflen, tor->torrentPeers->requestCount );
-    if( cancel_buflen > 0 )
-        cancel = tr_new( struct block_request, cancel_buflen );
+    while ((tor = tr_torrentNext (mgr->session, tor)))
+        cancel_buflen = MAX (cancel_buflen, tor->torrentPeers->requestCount);
+    if (cancel_buflen > 0)
+        cancel = tr_new (struct block_request, cancel_buflen);
 
     /* prune requests that are too old */
     tor = NULL;
-    while(( tor = tr_torrentNext( mgr->session, tor )))
+    while ((tor = tr_torrentNext (mgr->session, tor)))
     {
         Torrent * t = tor->torrentPeers;
         const int n = t->requestCount;
-        if( n > 0 )
+        if (n > 0)
         {
             int keepCount = 0;
             int cancelCount = 0;
             const struct block_request * it;
             const struct block_request * end;
 
-            for( it=t->requests, end=it+n; it!=end; ++it )
+            for (it=t->requests, end=it+n; it!=end; ++it)
             {
-                if( ( it->sentAt <= too_old ) && it->peer->msgs && !tr_peerMsgsIsReadingBlock( it->peer->msgs, it->block ) )
+                if ((it->sentAt <= too_old) && it->peer->msgs && !tr_peerMsgsIsReadingBlock (it->peer->msgs, it->block))
                     cancel[cancelCount++] = *it;
                 else
                 {
-                    if( it != &t->requests[keepCount] )
+                    if (it != &t->requests[keepCount])
                         t->requests[keepCount] = *it;
                     keepCount++;
                 }
@@ -1518,77 +1522,77 @@ refillUpkeep( int foo UNUSED, short bar UNUSED, void * vmgr )
             t->requestCount = keepCount;
 
             /* send cancel messages for all the "cancel" ones */
-            for( it=cancel, end=it+cancelCount; it!=end; ++it ) {
-                if( ( it->peer != NULL ) && ( it->peer->msgs != NULL ) ) {
-                    tr_historyAdd( &it->peer->cancelsSentToPeer, now, 1 );
-                    tr_peerMsgsCancel( it->peer->msgs, it->block );
-                    decrementPendingReqCount( it );
+            for (it=cancel, end=it+cancelCount; it!=end; ++it) {
+                if ((it->peer != NULL) && (it->peer->msgs != NULL)) {
+                    tr_historyAdd (&it->peer->cancelsSentToPeer, now, 1);
+                    tr_peerMsgsCancel (it->peer->msgs, it->block);
+                    decrementPendingReqCount (it);
                 }
             }
 
             /* decrement the pending request counts for the timed-out blocks */
-            for( it=cancel, end=it+cancelCount; it!=end; ++it )
-                pieceListRemoveRequest( t, it->block );
+            for (it=cancel, end=it+cancelCount; it!=end; ++it)
+                pieceListRemoveRequest (t, it->block);
         }
     }
 
-    tr_free( cancel );
-    tr_timerAddMsec( mgr->refillUpkeepTimer, REFILL_UPKEEP_PERIOD_MSEC );
-    managerUnlock( mgr );
+    tr_free (cancel);
+    tr_timerAddMsec (mgr->refillUpkeepTimer, REFILL_UPKEEP_PERIOD_MSEC);
+    managerUnlock (mgr);
 }
 
 static void
-addStrike( Torrent * t, tr_peer * peer )
+addStrike (Torrent * t, tr_peer * peer)
 {
-    tordbg( t, "increasing peer %s strike count to %d",
-            tr_atomAddrStr( peer->atom ), peer->strikes + 1 );
+    tordbg (t, "increasing peer %s strike count to %d",
+            tr_atomAddrStr (peer->atom), peer->strikes + 1);
 
-    if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
+    if (++peer->strikes >= MAX_BAD_PIECES_PER_PEER)
     {
         struct peer_atom * atom = peer->atom;
         atom->flags2 |= MYFLAG_BANNED;
         peer->doPurge = 1;
-        tordbg( t, "banning peer %s", tr_atomAddrStr( atom ) );
+        tordbg (t, "banning peer %s", tr_atomAddrStr (atom));
     }
 }
 
 static void
-gotBadPiece( Torrent * t, tr_piece_index_t pieceIndex )
+gotBadPiece (Torrent * t, tr_piece_index_t pieceIndex)
 {
     tr_torrent *   tor = t->tor;
-    const uint32_t byteCount = tr_torPieceCountBytes( tor, pieceIndex );
+    const uint32_t byteCount = tr_torPieceCountBytes (tor, pieceIndex);
 
     tor->corruptCur += byteCount;
-    tor->downloadedCur -= MIN( tor->downloadedCur, byteCount );
+    tor->downloadedCur -= MIN (tor->downloadedCur, byteCount);
 
-    tr_announcerAddBytes( tor, TR_ANN_CORRUPT, byteCount );
+    tr_announcerAddBytes (tor, TR_ANN_CORRUPT, byteCount);
 }
 
 static void
-peerSuggestedPiece( Torrent            * t UNUSED,
+peerSuggestedPiece (Torrent            * t UNUSED,
                     tr_peer            * peer UNUSED,
                     tr_piece_index_t     pieceIndex UNUSED,
-                    int                  isFastAllowed UNUSED )
+                    int                  isFastAllowed UNUSED)
 {
 #if 0
-    assert( t );
-    assert( peer );
-    assert( peer->msgs );
+    assert (t);
+    assert (peer);
+    assert (peer->msgs);
 
     /* is this a valid piece? */
-    if(  pieceIndex >= t->tor->info.pieceCount )
+    if (pieceIndex >= t->tor->info.pieceCount)
         return;
 
     /* don't ask for it if we've already got it */
-    if( tr_cpPieceIsComplete( t->tor->completion, pieceIndex ) )
+    if (tr_cpPieceIsComplete (t->tor->completion, pieceIndex))
         return;
 
     /* don't ask for it if they don't have it */
-    if( !tr_bitfieldHas( peer->have, pieceIndex ) )
+    if (!tr_bitfieldHas (peer->have, pieceIndex))
         return;
 
     /* don't ask for it if we're choked and it's not fast */
-    if( !isFastAllowed && peer->clientIsChoked )
+    if (!isFastAllowed && peer->clientIsChoked)
         return;
 
     /* request the blocks that we don't have in this piece */
@@ -1598,16 +1602,16 @@ peerSuggestedPiece( Torrent            * t UNUSED,
         tr_block_index_t last;
         const tr_torrent * tor = t->tor;
 
-        tr_torGetPieceBlockRange( t->tor, pieceIndex, &first, &last );
+        tr_torGetPieceBlockRange (t->tor, pieceIndex, &first, &last);
 
-        for( b=first; b<=last; ++b )
+        for (b=first; b<=last; ++b)
         {
-            if( !tr_cpBlockIsComplete( tor->completion, b ) )
+            if (!tr_cpBlockIsComplete (tor->completion, b))
             {
-                const uint32_t offset = getBlockOffsetInPiece( tor, b );
-                const uint32_t length = tr_torBlockCountBytes( tor, b );
-                tr_peerMsgsAddRequest( peer->msgs, pieceIndex, offset, length );
-                incrementPieceRequests( t, pieceIndex );
+                const uint32_t offset = getBlockOffsetInPiece (tor, b);
+                const uint32_t length = tr_torBlockCountBytes (tor, b);
+                tr_peerMsgsAddRequest (peer->msgs, pieceIndex, offset, length);
+                incrementPieceRequests (t, pieceIndex);
             }
         }
     }
@@ -1615,78 +1619,78 @@ peerSuggestedPiece( Torrent            * t UNUSED,
 }
 
 static void
-removeRequestFromTables( Torrent * t, tr_block_index_t block, const tr_peer * peer )
+removeRequestFromTables (Torrent * t, tr_block_index_t block, const tr_peer * peer)
 {
-    requestListRemove( t, block, peer );
-    pieceListRemoveRequest( t, block );
+    requestListRemove (t, block, peer);
+    pieceListRemoveRequest (t, block);
 }
 
 /* peer choked us, or maybe it disconnected.
    either way we need to remove all its requests */
 static void
-peerDeclinedAllRequests( Torrent * t, const tr_peer * peer )
+peerDeclinedAllRequests (Torrent * t, const tr_peer * peer)
 {
     int i, n;
-    tr_block_index_t * blocks = tr_new( tr_block_index_t, t->requestCount );
+    tr_block_index_t * blocks = tr_new (tr_block_index_t, t->requestCount);
 
-    for( i=n=0; i<t->requestCount; ++i )
-        if( peer == t->requests[i].peer )
+    for (i=n=0; i<t->requestCount; ++i)
+        if (peer == t->requests[i].peer)
             blocks[n++] = t->requests[i].block;
 
-    for( i=0; i<n; ++i )
-        removeRequestFromTables( t, blocks[i], peer );
+    for (i=0; i<n; ++i)
+        removeRequestFromTables (t, blocks[i], peer);
 
-    tr_free( blocks );
+    tr_free (blocks);
 }
 
-static void tr_peerMgrSetBlame( tr_torrent *, tr_piece_index_t, int );
+static void tr_peerMgrSetBlame (tr_torrent *, tr_piece_index_t, int);
 
 static void
-peerCallbackFunc( tr_peer * peer, const tr_peer_event * e, void * vt )
+peerCallbackFunc (tr_peer * peer, const tr_peer_event * e, void * vt)
 {
     Torrent * t = vt;
 
-    torrentLock( t );
+    torrentLock (t);
 
-    assert( peer != NULL );
+    assert (peer != NULL);
 
-    switch( e->eventType )
+    switch (e->eventType)
     {
         case TR_PEER_PEER_GOT_DATA:
         {
-            const time_t now = tr_time( );
+            const time_t now = tr_time ();
             tr_torrent * tor = t->tor;
 
-            if( e->wasPieceData )
+            if (e->wasPieceData)
             {
                 tor->uploadedCur += e->length;
-                tr_announcerAddBytes( tor, TR_ANN_UP, e->length );
-                tr_torrentSetActivityDate( tor, now );
-                tr_torrentSetDirty( tor );
+                tr_announcerAddBytes (tor, TR_ANN_UP, e->length);
+                tr_torrentSetActivityDate (tor, now);
+                tr_torrentSetDirty (tor);
             }
 
             /* update the stats */
-            if( e->wasPieceData )
-                tr_statsAddUploaded( tor->session, e->length );
+            if (e->wasPieceData)
+                tr_statsAddUploaded (tor->session, e->length);
 
             /* update our atom */
-            if( peer->atom && e->wasPieceData )
+            if (peer->atom && e->wasPieceData)
                 peer->atom->piece_data_time = now;
 
             break;
         }
 
         case TR_PEER_CLIENT_GOT_HAVE:
-            if( replicationExists( t ) ) {
-                tr_incrReplicationOfPiece( t, e->pieceIndex );
-                assertReplicationCountIsExact( t );
+            if (replicationExists (t)) {
+                tr_incrReplicationOfPiece (t, e->pieceIndex);
+                assertReplicationCountIsExact (t);
             }
             break;
 
         case TR_PEER_CLIENT_GOT_HAVE_ALL:
-            if( replicationExists( t ) ) {
-                tr_incrReplication( t );
-                assertReplicationCountIsExact( t );
+            if (replicationExists (t)) {
+                tr_incrReplication (t);
+                assertReplicationCountIsExact (t);
             }
             break;
 
@@ -1695,58 +1699,58 @@ peerCallbackFunc( tr_peer * peer, const tr_peer_event * e, void * vt )
             break;
 
         case TR_PEER_CLIENT_GOT_BITFIELD:
-            assert( e->bitfield != NULL );
-            if( replicationExists( t ) ) {
-                tr_incrReplicationFromBitfield( t, e->bitfield );
-                assertReplicationCountIsExact( t );
+            assert (e->bitfield != NULL);
+            if (replicationExists (t)) {
+                tr_incrReplicationFromBitfield (t, e->bitfield);
+                assertReplicationCountIsExact (t);
             }
             break;
 
         case TR_PEER_CLIENT_GOT_REJ: {
-            tr_block_index_t b = _tr_block( t->tor, e->pieceIndex, e->offset );
-            if( b < t->tor->blockCount )
-                removeRequestFromTables( t, b, peer );
+            tr_block_index_t b = _tr_block (t->tor, e->pieceIndex, e->offset);
+            if (b < t->tor->blockCount)
+                removeRequestFromTables (t, b, peer);
             else
-                tordbg( t, "Peer %s sent an out-of-range reject message",
-                           tr_atomAddrStr( peer->atom ) );
+                tordbg (t, "Peer %s sent an out-of-range reject message",
+                           tr_atomAddrStr (peer->atom));
             break;
         }
 
         case TR_PEER_CLIENT_GOT_CHOKE:
-            peerDeclinedAllRequests( t, peer );
+            peerDeclinedAllRequests (t, peer);
             break;
 
         case TR_PEER_CLIENT_GOT_PORT:
-            if( peer->atom )
+            if (peer->atom)
                 peer->atom->port = e->port;
             break;
 
         case TR_PEER_CLIENT_GOT_SUGGEST:
-            peerSuggestedPiece( t, peer, e->pieceIndex, false );
+            peerSuggestedPiece (t, peer, e->pieceIndex, false);
             break;
 
         case TR_PEER_CLIENT_GOT_ALLOWED_FAST:
-            peerSuggestedPiece( t, peer, e->pieceIndex, true );
+            peerSuggestedPiece (t, peer, e->pieceIndex, true);
             break;
 
         case TR_PEER_CLIENT_GOT_DATA:
         {
-            const time_t now = tr_time( );
+            const time_t now = tr_time ();
             tr_torrent * tor = t->tor;
 
-            if( e->wasPieceData )
+            if (e->wasPieceData)
             {
                 tor->downloadedCur += e->length;
-                tr_torrentSetActivityDate( tor, now );
-                tr_torrentSetDirty( tor );
+                tr_torrentSetActivityDate (tor, now);
+                tr_torrentSetDirty (tor);
             }
 
             /* update the stats */
-            if( e->wasPieceData )
-                tr_statsAddDownloaded( tor->session, e->length );
+            if (e->wasPieceData)
+                tr_statsAddDownloaded (tor->session, e->length);
 
             /* update our atom */
-            if( peer->atom && e->wasPieceData )
+            if (peer->atom && e->wasPieceData)
                 peer->atom->piece_data_time = now;
 
             break;
@@ -1755,61 +1759,61 @@ peerCallbackFunc( tr_peer * peer, const tr_peer_event * e, void * vt )
         case TR_PEER_CLIENT_GOT_BLOCK:
         {
             tr_torrent * tor = t->tor;
-            tr_block_index_t block = _tr_block( tor, e->pieceIndex, e->offset );
+            tr_block_index_t block = _tr_block (tor, e->pieceIndex, e->offset);
             int i, peerCount;
             tr_peer ** peers;
             tr_ptrArray peerArr = TR_PTR_ARRAY_INIT;
 
-            removeRequestFromTables( t, block, peer );
-            getBlockRequestPeers( t, block, &peerArr );
-            peers = (tr_peer **) tr_ptrArrayPeek( &peerArr, &peerCount );
+            removeRequestFromTables (t, block, peer);
+            getBlockRequestPeers (t, block, &peerArr);
+            peers = (tr_peer **) tr_ptrArrayPeek (&peerArr, &peerCount);
 
             /* remove additional block requests and send cancel to peers */
-            for( i=0; i<peerCount; i++ ) {
+            for (i=0; i<peerCount; i++) {
                 tr_peer * p = peers[i];
-                assert( p != peer );
-                if( p->msgs ) {
-                    tr_historyAdd( &p->cancelsSentToPeer, tr_time( ), 1 );
-                    tr_peerMsgsCancel( p->msgs, block );
+                assert (p != peer);
+                if (p->msgs) {
+                    tr_historyAdd (&p->cancelsSentToPeer, tr_time (), 1);
+                    tr_peerMsgsCancel (p->msgs, block);
                 }
-                removeRequestFromTables( t, block, p );
+                removeRequestFromTables (t, block, p);
             }
 
-            tr_ptrArrayDestruct( &peerArr, false );
+            tr_ptrArrayDestruct (&peerArr, false);
 
-            tr_historyAdd( &peer->blocksSentToClient, tr_time( ), 1 );
+            tr_historyAdd (&peer->blocksSentToClient, tr_time (), 1);
 
-            if( tr_cpBlockIsComplete( &tor->completion, block ) )
+            if (tr_cpBlockIsComplete (&tor->completion, block))
             {
                 /* we already have this block... */
-                const uint32_t n = tr_torBlockCountBytes( tor, block );
-                tor->downloadedCur -= MIN( tor->downloadedCur, n );
-                tordbg( t, "we have this block already..." );
+                const uint32_t n = tr_torBlockCountBytes (tor, block);
+                tor->downloadedCur -= MIN (tor->downloadedCur, n);
+                tordbg (t, "we have this block already...");
             }
             else
             {
-                tr_cpBlockAdd( &tor->completion, block );
-                pieceListResortPiece( t, pieceListLookup( t, e->pieceIndex ) );
-                tr_torrentSetDirty( tor );
+                tr_cpBlockAdd (&tor->completion, block);
+                pieceListResortPiece (t, pieceListLookup (t, e->pieceIndex));
+                tr_torrentSetDirty (tor);
 
-                if( tr_cpPieceIsComplete( &tor->completion, e->pieceIndex ) )
+                if (tr_cpPieceIsComplete (&tor->completion, e->pieceIndex))
                 {
                     const tr_piece_index_t p = e->pieceIndex;
-                    const bool ok = tr_torrentCheckPiece( tor, p );
+                    const bool ok = tr_torrentCheckPiece (tor, p);
 
-                    tordbg( t, "[LAZY] checked just-completed piece %zu", (size_t)p );
+                    tordbg (t, "[LAZY] checked just-completed piece %zu", (size_t)p);
 
-                    if( !ok )
+                    if (!ok)
                     {
-                        tr_torerr( tor, _( "Piece %lu, which was just downloaded, failed its checksum test" ),
-                                   (unsigned long)p );
+                        tr_torerr (tor, _ ("Piece %lu, which was just downloaded, failed its checksum test"),
+                                 (unsigned long)p);
                     }
 
-                    tr_peerMgrSetBlame( tor, p, ok );
+                    tr_peerMgrSetBlame (tor, p, ok);
 
-                    if( !ok )
+                    if (!ok)
                     {
-                        gotBadPiece( t, p );
+                        gotBadPiece (t, p);
                     }
                     else
                     {
@@ -1824,27 +1828,27 @@ peerCallbackFunc( tr_peer * peer, const tr_peer_event * e, void * vt )
                          * content distributor, not the peers, it is the tracker's job
                          * to manage the swarms, not the web server and does not fit
                          * into the jurisdiction of the tracker." */
-                        if( peer->msgs != NULL ) {
-                            const uint32_t n = tr_torPieceCountBytes( tor, p );
-                            tr_announcerAddBytes( tor, TR_ANN_DOWN, n );
+                        if (peer->msgs != NULL) {
+                            const uint32_t n = tr_torPieceCountBytes (tor, p);
+                            tr_announcerAddBytes (tor, TR_ANN_DOWN, n);
                         }
 
-                        peerCount = tr_ptrArraySize( &t->peers );
-                        peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
-                        for( i=0; i<peerCount; ++i )
-                            tr_peerMsgsHave( peers[i]->msgs, p );
+                        peerCount = tr_ptrArraySize (&t->peers);
+                        peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
+                        for (i=0; i<peerCount; ++i)
+                            tr_peerMsgsHave (peers[i]->msgs, p);
 
-                        for( fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex ) {
+                        for (fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex) {
                             const tr_file * file = &tor->info.files[fileIndex];
-                            if( ( file->firstPiece <= p ) && ( p <= file->lastPiece ) ) {
-                                if( tr_cpFileIsComplete( &tor->completion, fileIndex ) ) {
-                                    tr_cacheFlushFile( tor->session->cache, tor, fileIndex );
-                                    tr_torrentFileCompleted( tor, fileIndex );
+                            if ((file->firstPiece <= p) && (p <= file->lastPiece)) {
+                                if (tr_cpFileIsComplete (&tor->completion, fileIndex)) {
+                                    tr_cacheFlushFile (tor->session->cache, tor, fileIndex);
+                                    tr_torrentFileCompleted (tor, fileIndex);
                                 }
                             }
                         }
 
-                        pieceListRemovePiece( t, p );
+                        pieceListRemovePiece (t, p);
                     }
                 }
 
@@ -1854,32 +1858,32 @@ peerCallbackFunc( tr_peer * peer, const tr_peer_event * e, void * vt )
         }
 
         case TR_PEER_ERROR:
-            if( ( e->err == ERANGE ) || ( e->err == EMSGSIZE ) || ( e->err == ENOTCONN ) )
+            if ((e->err == ERANGE) || (e->err == EMSGSIZE) || (e->err == ENOTCONN))
             {
                 /* some protocol error from the peer */
                 peer->doPurge = 1;
-                tordbg( t, "setting %s doPurge flag because we got an ERANGE, EMSGSIZE, or ENOTCONN error",
-                        tr_atomAddrStr( peer->atom ) );
+                tordbg (t, "setting %s doPurge flag because we got an ERANGE, EMSGSIZE, or ENOTCONN error",
+                        tr_atomAddrStr (peer->atom));
             }
             else
             {
-                tordbg( t, "unhandled error: %s", tr_strerror( e->err ) );
+                tordbg (t, "unhandled error: %s", tr_strerror (e->err));
             }
             break;
 
         default:
-            assert( 0 );
+            assert (0);
     }
 
-    torrentUnlock( t );
+    torrentUnlock (t);
 }
 
 static int
-getDefaultShelfLife( uint8_t from )
+getDefaultShelfLife (uint8_t from)
 {
     /* in general, peers obtained from firsthand contact
      * are better than those from secondhand, etc etc */
-    switch( from )
+    switch (from)
     {
         case TR_PEER_FROM_INCOMING : return 60 * 60 * 6;
         case TR_PEER_FROM_LTEP     : return 60 * 60 * 6;
@@ -1893,68 +1897,68 @@ getDefaultShelfLife( uint8_t from )
 }
 
 static void
-ensureAtomExists( Torrent           * t,
+ensureAtomExists (Torrent           * t,
                   const tr_address  * addr,
                   const tr_port       port,
                   const uint8_t       flags,
                   const int8_t        seedProbability,
-                  const uint8_t       from )
+                  const uint8_t       from)
 {
     struct peer_atom * a;
 
-    assert( tr_address_is_valid( addr ) );
-    assert( from < TR_PEER_FROM__MAX );
+    assert (tr_address_is_valid (addr));
+    assert (from < TR_PEER_FROM__MAX);
 
-    a = getExistingAtom( t, addr );
+    a = getExistingAtom (t, addr);
 
-    if( a == NULL )
+    if (a == NULL)
     {
-        const int jitter = tr_cryptoWeakRandInt( 60*10 );
-        a = tr_new0( struct peer_atom, 1 );
+        const int jitter = tr_cryptoWeakRandInt (60*10);
+        a = tr_new0 (struct peer_atom, 1);
         a->addr = *addr;
         a->port = port;
         a->flags = flags;
         a->fromFirst = from;
         a->fromBest = from;
-        a->shelf_date = tr_time( ) + getDefaultShelfLife( from ) + jitter;
+        a->shelf_date = tr_time () + getDefaultShelfLife (from) + jitter;
         a->blocklisted = -1;
-        atomSetSeedProbability( a, seedProbability );
-        tr_ptrArrayInsertSorted( &t->pool, a, compareAtomsByAddress );
+        atomSetSeedProbability (a, seedProbability);
+        tr_ptrArrayInsertSorted (&t->pool, a, compareAtomsByAddress);
 
-        tordbg( t, "got a new atom: %s", tr_atomAddrStr( a ) );
+        tordbg (t, "got a new atom: %s", tr_atomAddrStr (a));
     }
     else
     {
-        if( from < a->fromBest )
+        if (from < a->fromBest)
             a->fromBest = from;
 
-        if( a->seedProbability == -1 )
-            atomSetSeedProbability( a, seedProbability );
+        if (a->seedProbability == -1)
+            atomSetSeedProbability (a, seedProbability);
 
         a->flags |= flags;
     }
 }
 
 static int
-getMaxPeerCount( const tr_torrent * tor )
+getMaxPeerCount (const tr_torrent * tor)
 {
     return tor->maxConnectedPeers;
 }
 
 static int
-getPeerCount( const Torrent * t )
+getPeerCount (const Torrent * t)
 {
-    return tr_ptrArraySize( &t->peers );/* + tr_ptrArraySize( &t->outgoingHandshakes ); */
+    return tr_ptrArraySize (&t->peers);/* + tr_ptrArraySize (&t->outgoingHandshakes); */
 }
 
 /* FIXME: this is kind of a mess. */
 static bool
-myHandshakeDoneCB( tr_handshake  * handshake,
+myHandshakeDoneCB (tr_handshake  * handshake,
                    tr_peerIo     * io,
                    bool            readAnythingFromPeer,
                    bool            isConnected,
                    const uint8_t * peer_id,
-                   void          * vmanager )
+                   void          * vmanager)
 {
     bool               ok = isConnected;
     bool               success = false;
@@ -1964,42 +1968,42 @@ myHandshakeDoneCB( tr_handshake  * handshake,
     Torrent          * t;
     tr_handshake     * ours;
 
-    assert( io );
-    assert( tr_isBool( ok ) );
+    assert (io);
+    assert (tr_isBool (ok));
 
-    t = tr_peerIoHasTorrentHash( io )
-        ? getExistingTorrent( manager, tr_peerIoGetTorrentHash( io ) )
+    t = tr_peerIoHasTorrentHash (io)
+        ? getExistingTorrent (manager, tr_peerIoGetTorrentHash (io))
         : NULL;
 
-    if( tr_peerIoIsIncoming ( io ) )
-        ours = tr_ptrArrayRemoveSorted( &manager->incomingHandshakes,
-                                        handshake, handshakeCompare );
-    else if( t )
-        ours = tr_ptrArrayRemoveSorted( &t->outgoingHandshakes,
-                                        handshake, handshakeCompare );
+    if (tr_peerIoIsIncoming (io))
+        ours = tr_ptrArrayRemoveSorted (&manager->incomingHandshakes,
+                                        handshake, handshakeCompare);
+    else if (t)
+        ours = tr_ptrArrayRemoveSorted (&t->outgoingHandshakes,
+                                        handshake, handshakeCompare);
     else
         ours = handshake;
 
-    assert( ours );
-    assert( ours == handshake );
+    assert (ours);
+    assert (ours == handshake);
 
-    if( t )
-        torrentLock( t );
+    if (t)
+        torrentLock (t);
 
-    addr = tr_peerIoGetAddress( io, &port );
+    addr = tr_peerIoGetAddress (io, &port);
 
-    if( !ok || !t || !t->isRunning )
+    if (!ok || !t || !t->isRunning)
     {
-        if( t )
+        if (t)
         {
-            struct peer_atom * atom = getExistingAtom( t, addr );
-            if( atom )
+            struct peer_atom * atom = getExistingAtom (t, addr);
+            if (atom)
             {
                 ++atom->numFails;
 
-                if( !readAnythingFromPeer )
+                if (!readAnythingFromPeer)
                 {
-                    tordbg( t, "marking peer %s as unreachable... numFails is %d", tr_atomAddrStr( atom ), (int)atom->numFails );
+                    tordbg (t, "marking peer %s as unreachable... numFails is %d", tr_atomAddrStr (atom), (int)atom->numFails);
                     atom->flags2 |= MYFLAG_UNREACHABLE;
                 }
             }
@@ -2009,13 +2013,13 @@ myHandshakeDoneCB( tr_handshake  * handshake,
     {
         struct peer_atom * atom;
 
-        ensureAtomExists( t, addr, port, 0, -1, TR_PEER_FROM_INCOMING );
-        atom = getExistingAtom( t, addr );
-        atom->time = tr_time( );
+        ensureAtomExists (t, addr, port, 0, -1, TR_PEER_FROM_INCOMING);
+        atom = getExistingAtom (t, addr);
+        atom->time = tr_time ();
         atom->piece_data_time = 0;
-        atom->lastConnectionAt = tr_time( );
+        atom->lastConnectionAt = tr_time ();
 
-        if( !tr_peerIoIsIncoming( io ) )
+        if (!tr_peerIoIsIncoming (io))
         {
             atom->flags |= ADDED_F_CONNECTABLE;
             atom->flags2 &= ~MYFLAG_UNREACHABLE;
@@ -2023,16 +2027,16 @@ myHandshakeDoneCB( tr_handshake  * handshake,
 
         /* In principle, this flag specifies whether the peer groks uTP,
            not whether it's currently connected over uTP. */
-        if( io->utp_socket )
+        if (io->utp_socket)
             atom->flags |= ADDED_F_UTP_FLAGS;
 
-        if( atom->flags2 & MYFLAG_BANNED )
+        if (atom->flags2 & MYFLAG_BANNED)
         {
-            tordbg( t, "banned peer %s tried to reconnect",
-                    tr_atomAddrStr( atom ) );
+            tordbg (t, "banned peer %s tried to reconnect",
+                    tr_atomAddrStr (atom));
         }
-        else if( tr_peerIoIsIncoming( io )
-               && ( getPeerCount( t ) >= getMaxPeerCount( t->tor ) ) )
+        else if (tr_peerIoIsIncoming (io)
+               && (getPeerCount (t) >= getMaxPeerCount (t->tor)))
 
         {
         }
@@ -2040,135 +2044,135 @@ myHandshakeDoneCB( tr_handshake  * handshake,
         {
             tr_peer * peer = atom->peer;
 
-            if( peer ) /* we already have this peer */
+            if (peer) /* we already have this peer */
             {
             }
             else
             {
-                peer = getPeer( t, atom );
-                tr_free( peer->client );
+                peer = getPeer (t, atom);
+                tr_free (peer->client);
 
-                if( !peer_id )
+                if (!peer_id)
                     peer->client = NULL;
                 else {
                     char client[128];
-                    tr_clientForId( client, sizeof( client ), peer_id );
-                    peer->client = tr_strdup( client );
+                    tr_clientForId (client, sizeof (client), peer_id);
+                    peer->client = tr_strdup (client);
                 }
 
-                peer->io = tr_handshakeStealIO( handshake ); /* this steals its refcount too, which is
-                                                                balanced by our unref in peerDelete()  */
-                tr_peerIoSetParent( peer->io, &t->tor->bandwidth );
-                tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t );
+                peer->io = tr_handshakeStealIO (handshake); /* this steals its refcount too, which is
+                                                                balanced by our unref in peerDelete ()  */
+                tr_peerIoSetParent (peer->io, &t->tor->bandwidth);
+                tr_peerMsgsNew (t->tor, peer, peerCallbackFunc, t);
 
                 success = true;
             }
         }
     }
 
-    if( t )
-        torrentUnlock( t );
+    if (t)
+        torrentUnlock (t);
 
     return success;
 }
 
 void
-tr_peerMgrAddIncoming( tr_peerMgr * manager,
+tr_peerMgrAddIncoming (tr_peerMgr * manager,
                        tr_address * addr,
                        tr_port      port,
                        int          socket,
-                       struct UTPSocket * utp_socket )
+                       struct UTPSocket * utp_socket)
 {
     tr_session * session;
 
-    managerLock( manager );
+    managerLock (manager);
 
-    assert( tr_isSession( manager->session ) );
+    assert (tr_isSession (manager->session));
     session = manager->session;
 
-    if( tr_sessionIsAddressBlocked( session, addr ) )
+    if (tr_sessionIsAddressBlocked (session, addr))
     {
-        tr_dbg( "Banned IP address \"%s\" tried to connect to us", tr_address_to_string( addr ) );
-        if(socket >= 0)
-            tr_netClose( session, socket );
+        tr_dbg ("Banned IP address \"%s\" tried to connect to us", tr_address_to_string (addr));
+        if (socket >= 0)
+            tr_netClose (session, socket);
         else
-            UTP_Close( utp_socket );
+            UTP_Close (utp_socket);
     }
-    else if( getExistingHandshake( &manager->incomingHandshakes, addr ) )
+    else if (getExistingHandshake (&manager->incomingHandshakes, addr))
     {
-        if(socket >= 0)
-            tr_netClose( session, socket );
+        if (socket >= 0)
+            tr_netClose (session, socket);
         else
-            UTP_Close( utp_socket );
+            UTP_Close (utp_socket);
     }
     else /* we don't have a connection to them yet... */
     {
         tr_peerIo *    io;
         tr_handshake * handshake;
 
-        io = tr_peerIoNewIncoming( session, &session->bandwidth, addr, port, socket, utp_socket );
+        io = tr_peerIoNewIncoming (session, &session->bandwidth, addr, port, socket, utp_socket);
 
-        handshake = tr_handshakeNew( io,
+        handshake = tr_handshakeNew (io,
                                      session->encryptionMode,
                                      myHandshakeDoneCB,
-                                     manager );
+                                     manager);
 
-        tr_peerIoUnref( io ); /* balanced by the implicit ref in tr_peerIoNewIncoming() */
+        tr_peerIoUnref (io); /* balanced by the implicit ref in tr_peerIoNewIncoming () */
 
-        tr_ptrArrayInsertSorted( &manager->incomingHandshakes, handshake,
-                                 handshakeCompare );
+        tr_ptrArrayInsertSorted (&manager->incomingHandshakes, handshake,
+                                 handshakeCompare);
     }
 
-    managerUnlock( manager );
+    managerUnlock (manager);
 }
 
 void
-tr_peerMgrAddPex( tr_torrent * tor, uint8_t from,
-                  const tr_pex * pex, int8_t seedProbability )
+tr_peerMgrAddPex (tr_torrent * tor, uint8_t from,
+                  const tr_pex * pex, int8_t seedProbability)
 {
-    if( tr_isPex( pex ) ) /* safeguard against corrupt data */
+    if (tr_isPex (pex)) /* safeguard against corrupt data */
     {
         Torrent * t = tor->torrentPeers;
-        managerLock( t->manager );
+        managerLock (t->manager);
 
-        if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
-            if( tr_address_is_valid_for_peers( &pex->addr, pex->port ) )
-                ensureAtomExists( t, &pex->addr, pex->port, pex->flags, seedProbability, from );
+        if (!tr_sessionIsAddressBlocked (t->manager->session, &pex->addr))
+            if (tr_address_is_valid_for_peers (&pex->addr, pex->port))
+                ensureAtomExists (t, &pex->addr, pex->port, pex->flags, seedProbability, from);
 
-        managerUnlock( t->manager );
+        managerUnlock (t->manager);
     }
 }
 
 void
-tr_peerMgrMarkAllAsSeeds( tr_torrent * tor )
+tr_peerMgrMarkAllAsSeeds (tr_torrent * tor)
 {
     Torrent * t = tor->torrentPeers;
-    const int n = tr_ptrArraySize( &t->pool );
-    struct peer_atom ** it = (struct peer_atom**) tr_ptrArrayBase( &t->pool );
+    const int n = tr_ptrArraySize (&t->pool);
+    struct peer_atom ** it = (struct peer_atom**) tr_ptrArrayBase (&t->pool);
     struct peer_atom ** end = it + n;
 
-    while( it != end )
-        atomSetSeed( t, *it++ );
+    while (it != end)
+        atomSetSeed (t, *it++);
 }
 
 tr_pex *
-tr_peerMgrCompactToPex( const void *    compact,
+tr_peerMgrCompactToPex (const void *    compact,
                         size_t          compactLen,
                         const uint8_t * added_f,
                         size_t          added_f_len,
-                        size_t *        pexCount )
+                        size_t *        pexCount)
 {
     size_t          i;
     size_t          n = compactLen / 6;
     const uint8_t * walk = compact;
-    tr_pex *        pex = tr_new0( tr_pex, n );
+    tr_pex *        pex = tr_new0 (tr_pex, n);
 
-    for( i = 0; i < n; ++i )
+    for (i = 0; i < n; ++i)
     {
         pex[i].addr.type = TR_AF_INET;
-        memcpy( &pex[i].addr.addr, walk, 4 ); walk += 4;
-        memcpy( &pex[i].port, walk, 2 ); walk += 2;
-        if( added_f && ( n == added_f_len ) )
+        memcpy (&pex[i].addr.addr, walk, 4); walk += 4;
+        memcpy (&pex[i].port, walk, 2); walk += 2;
+        if (added_f && (n == added_f_len))
             pex[i].flags = added_f[i];
     }
 
@@ -2177,23 +2181,23 @@ tr_peerMgrCompactToPex( const void *    compact,
 }
 
 tr_pex *
-tr_peerMgrCompact6ToPex( const void    * compact,
+tr_peerMgrCompact6ToPex (const void    * compact,
                          size_t          compactLen,
                          const uint8_t * added_f,
                          size_t          added_f_len,
-                         size_t        * pexCount )
+                         size_t        * pexCount)
 {
     size_t          i;
     size_t          n = compactLen / 18;
     const uint8_t * walk = compact;
-    tr_pex *        pex = tr_new0( tr_pex, n );
+    tr_pex *        pex = tr_new0 (tr_pex, n);
 
-    for( i = 0; i < n; ++i )
+    for (i = 0; i < n; ++i)
     {
         pex[i].addr.type = TR_AF_INET6;
-        memcpy( &pex[i].addr.addr.addr6.s6_addr, walk, 16 ); walk += 16;
-        memcpy( &pex[i].port, walk, 2 ); walk += 2;
-        if( added_f && ( n == added_f_len ) )
+        memcpy (&pex[i].addr.addr.addr6.s6_addr, walk, 16); walk += 16;
+        memcpy (&pex[i].port, walk, 2); walk += 2;
+        if (added_f && (n == added_f_len))
             pex[i].flags = added_f[i];
     }
 
@@ -2202,21 +2206,21 @@ tr_peerMgrCompact6ToPex( const void    * compact,
 }
 
 tr_pex *
-tr_peerMgrArrayToPex( const void * array,
+tr_peerMgrArrayToPex (const void * array,
                       size_t       arrayLen,
-                      size_t      * pexCount )
+                      size_t      * pexCount)
 {
     size_t          i;
-    size_t          n = arrayLen / ( sizeof( tr_address ) + 2 );
-    /*size_t          n = arrayLen / sizeof( tr_peerArrayElement );*/
+    size_t          n = arrayLen / (sizeof (tr_address) + 2);
+    /*size_t          n = arrayLen / sizeof (tr_peerArrayElement);*/
     const uint8_t * walk = array;
-    tr_pex        * pex = tr_new0( tr_pex, n );
+    tr_pex        * pex = tr_new0 (tr_pex, n);
 
-    for( i = 0 ; i < n ; i++ ) {
-        memcpy( &pex[i].addr, walk, sizeof( tr_address ) );
-        memcpy( &pex[i].port, walk + sizeof( tr_address ), 2 );
+    for (i = 0 ; i < n ; i++) {
+        memcpy (&pex[i].addr, walk, sizeof (tr_address));
+        memcpy (&pex[i].port, walk + sizeof (tr_address), 2);
         pex[i].flags = 0x00;
-        walk += sizeof( tr_address ) + 2;
+        walk += sizeof (tr_address) + 2;
     }
 
     *pexCount = n;
@@ -2228,47 +2232,47 @@ tr_peerMgrArrayToPex( const void * array,
 **/
 
 static void
-tr_peerMgrSetBlame( tr_torrent     * tor,
+tr_peerMgrSetBlame (tr_torrent     * tor,
                     tr_piece_index_t pieceIndex,
-                    int              success )
+                    int              success)
 {
-    if( !success )
+    if (!success)
     {
         int        peerCount, i;
         Torrent *  t = tor->torrentPeers;
         tr_peer ** peers;
 
-        assert( torrentIsLocked( t ) );
+        assert (torrentIsLocked (t));
 
-        peers = (tr_peer **) tr_ptrArrayPeek( &t->peers, &peerCount );
-        for( i = 0; i < peerCount; ++i )
+        peers = (tr_peer **) tr_ptrArrayPeek (&t->peers, &peerCount);
+        for (i = 0; i < peerCount; ++i)
         {
             tr_peer * peer = peers[i];
-            if( tr_bitfieldHas( &peer->blame, pieceIndex ) )
+            if (tr_bitfieldHas (&peer->blame, pieceIndex))
             {
-                tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
-                        tr_atomAddrStr( peer->atom ),
-                        pieceIndex, (int)peer->strikes + 1 );
-                addStrike( t, peer );
+                tordbg (t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
+                        tr_atomAddrStr (peer->atom),
+                        pieceIndex, (int)peer->strikes + 1);
+                addStrike (t, peer);
             }
         }
     }
 }
 
 int
-tr_pexCompare( const void * va, const void * vb )
+tr_pexCompare (const void * va, const void * vb)
 {
     const tr_pex * a = va;
     const tr_pex * b = vb;
     int i;
 
-    assert( tr_isPex( a ) );
-    assert( tr_isPex( b ) );
+    assert (tr_isPex (a));
+    assert (tr_isPex (b));
 
-    if(( i = tr_address_compare( &a->addr, &b->addr )))
+    if ((i = tr_address_compare (&a->addr, &b->addr)))
         return i;
 
-    if( a->port != b->port )
+    if (a->port != b->port)
         return a->port < b->port ? -1 : 1;
 
     return 0;
@@ -2276,48 +2280,48 @@ tr_pexCompare( const void * va, const void * vb )
 
 /* better goes first */
 static int
-compareAtomsByUsefulness( const void * va, const void *vb )
+compareAtomsByUsefulness (const void * va, const void *vb)
 {
     const struct peer_atom * a = * (const struct peer_atom**) va;
     const struct peer_atom * b = * (const struct peer_atom**) vb;
 
-    assert( tr_isAtom( a ) );
-    assert( tr_isAtom( b ) );
+    assert (tr_isAtom (a));
+    assert (tr_isAtom (b));
 
-    if( a->piece_data_time != b->piece_data_time )
+    if (a->piece_data_time != b->piece_data_time)
         return a->piece_data_time > b->piece_data_time ? -1 : 1;
-    if( a->fromBest != b->fromBest )
+    if (a->fromBest != b->fromBest)
         return a->fromBest < b->fromBest ? -1 : 1;
-    if( a->numFails != b->numFails )
+    if (a->numFails != b->numFails)
         return a->numFails < b->numFails ? -1 : 1;
 
     return 0;
 }
 
 static bool
-isAtomInteresting( const tr_torrent * tor, struct peer_atom * atom )
+isAtomInteresting (const tr_torrent * tor, struct peer_atom * atom)
 {
-    if( tr_torrentIsSeed( tor ) && atomIsSeed( atom ) )
+    if (tr_torrentIsSeed (tor) && atomIsSeed (atom))
         return false;
 
-    if( peerIsInUse( tor->torrentPeers, atom ) )
+    if (peerIsInUse (tor->torrentPeers, atom))
         return true;
 
-    if( isAtomBlocklisted( tor->session, atom ) )
+    if (isAtomBlocklisted (tor->session, atom))
         return false;
 
-    if( atom->flags2 & MYFLAG_BANNED )
+    if (atom->flags2 & MYFLAG_BANNED)
         return false;
 
     return true;
 }
 
 int
-tr_peerMgrGetPeers( tr_torrent   * tor,
+tr_peerMgrGetPeers (tr_torrent   * tor,
                     tr_pex      ** setme_pex,
                     uint8_t        af,
                     uint8_t        list_mode,
-                    int            maxCount )
+                    int            maxCount)
 {
     int i;
     int n;
@@ -2328,52 +2332,52 @@ tr_peerMgrGetPeers( tr_torrent   * tor,
     tr_pex * pex;
     tr_pex * walk;
 
-    assert( tr_isTorrent( tor ) );
-    assert( setme_pex != NULL );
-    assert( af==TR_AF_INET || af==TR_AF_INET6 );
-    assert( list_mode==TR_PEERS_CONNECTED || list_mode==TR_PEERS_INTERESTING );
+    assert (tr_isTorrent (tor));
+    assert (setme_pex != NULL);
+    assert (af==TR_AF_INET || af==TR_AF_INET6);
+    assert (list_mode==TR_PEERS_CONNECTED || list_mode==TR_PEERS_INTERESTING);
 
-    managerLock( t->manager );
+    managerLock (t->manager);
 
     /**
     ***  build a list of atoms
     **/
 
-    if( list_mode == TR_PEERS_CONNECTED ) /* connected peers only */
+    if (list_mode == TR_PEERS_CONNECTED) /* connected peers only */
     {
         int i;
-        const tr_peer ** peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
-        atomCount = tr_ptrArraySize( &t->peers );
-        atoms = tr_new( struct peer_atom *, atomCount );
-        for( i=0; i<atomCount; ++i )
+        const tr_peer ** peers = (const tr_peer **) tr_ptrArrayBase (&t->peers);
+        atomCount = tr_ptrArraySize (&t->peers);
+        atoms = tr_new (struct peer_atom *, atomCount);
+        for (i=0; i<atomCount; ++i)
             atoms[i] = peers[i]->atom;
     }
     else /* TR_PEERS_INTERESTING */
     {
         int i;
-        struct peer_atom ** atomBase = (struct peer_atom**) tr_ptrArrayBase( &t->pool );
-        n = tr_ptrArraySize( &t->pool );
-        atoms = tr_new( struct peer_atom *, n );
-        for( i=0; i<n; ++i )
-            if( isAtomInteresting( tor, atomBase[i] ) )
+        struct peer_atom ** atomBase = (struct peer_atom**) tr_ptrArrayBase (&t->pool);
+        n = tr_ptrArraySize (&t->pool);
+        atoms = tr_new (struct peer_atom *, n);
+        for (i=0; i<n; ++i)
+            if (isAtomInteresting (tor, atomBase[i]))
                 atoms[atomCount++] = atomBase[i];
     }
 
-    qsort( atoms, atomCount, sizeof( struct peer_atom * ), compareAtomsByUsefulness );
+    qsort (atoms, atomCount, sizeof (struct peer_atom *), compareAtomsByUsefulness);
 
     /**
     ***  add the first N of them into our return list
     **/
 
-    n = MIN( atomCount, maxCount );
-    pex = walk = tr_new0( tr_pex, n );
+    n = MIN (atomCount, maxCount);
+    pex = walk = tr_new0 (tr_pex, n);
 
-    for( i=0; i<atomCount && count<n; ++i )
+    for (i=0; i<atomCount && count<n; ++i)
     {
         const struct peer_atom * atom = atoms[i];
-        if( atom->addr.type == af )
+        if (atom->addr.type == af)
         {
-            assert( tr_address_is_valid( &atom->addr ) );
+            assert (tr_address_is_valid (&atom->addr));
             walk->addr = atom->addr;
             walk->port = atom->port;
             walk->flags = atom->flags;
@@ -2382,196 +2386,196 @@ tr_peerMgrGetPeers( tr_torrent   * tor,
         }
     }
 
-    qsort( pex, count, sizeof( tr_pex ), tr_pexCompare );
+    qsort (pex, count, sizeof (tr_pex), tr_pexCompare);
 
-    assert( ( walk - pex ) == count );
+    assert ((walk - pex) == count);
     *setme_pex = pex;
 
     /* cleanup */
-    tr_free( atoms );
-    managerUnlock( t->manager );
+    tr_free (atoms);
+    managerUnlock (t->manager);
     return count;
 }
 
-static void atomPulse      ( int, short, void * );
-static void bandwidthPulse ( int, short, void * );
-static void rechokePulse   ( int, short, void * );
-static void reconnectPulse ( int, short, void * );
+static void atomPulse    (int, short, void *);
+static void bandwidthPulse (int, short, void *);
+static void rechokePulse (int, short, void *);
+static void reconnectPulse (int, short, void *);
 
 static struct event *
-createTimer( tr_session * session, int msec, void (*callback)(int, short, void *), void * cbdata )
+createTimer (tr_session * session, int msec, void (*callback)(int, short, void *), void * cbdata)
 {
-    struct event * timer = evtimer_new( session->event_base, callback, cbdata );
-    tr_timerAddMsec( timer, msec );
+    struct event * timer = evtimer_new (session->event_base, callback, cbdata);
+    tr_timerAddMsec (timer, msec);
     return timer;
 }
 
 static void
-ensureMgrTimersExist( struct tr_peerMgr * m )
+ensureMgrTimersExist (struct tr_peerMgr * m)
 {
-    if( m->atomTimer == NULL )
-        m->atomTimer = createTimer( m->session, ATOM_PERIOD_MSEC, atomPulse, m );
+    if (m->atomTimer == NULL)
+        m->atomTimer = createTimer (m->session, ATOM_PERIOD_MSEC, atomPulse, m);
 
-    if( m->bandwidthTimer == NULL )
-        m->bandwidthTimer = createTimer( m->session, BANDWIDTH_PERIOD_MSEC, bandwidthPulse, m );
+    if (m->bandwidthTimer == NULL)
+        m->bandwidthTimer = createTimer (m->session, BANDWIDTH_PERIOD_MSEC, bandwidthPulse, m);
 
-    if( m->rechokeTimer == NULL )
-        m->rechokeTimer = createTimer( m->session, RECHOKE_PERIOD_MSEC, rechokePulse, m );
+    if (m->rechokeTimer == NULL)
+        m->rechokeTimer = createTimer (m->session, RECHOKE_PERIOD_MSEC, rechokePulse, m);
 
-    if( m->refillUpkeepTimer == NULL )
-        m->refillUpkeepTimer = createTimer( m->session, REFILL_UPKEEP_PERIOD_MSEC, refillUpkeep, m );
+    if (m->refillUpkeepTimer == NULL)
+        m->refillUpkeepTimer = createTimer (m->session, REFILL_UPKEEP_PERIOD_MSEC, refillUpkeep, m);
 }
 
 void
-tr_peerMgrStartTorrent( tr_torrent * tor )
+tr_peerMgrStartTorrent (tr_torrent * tor)
 {
     Torrent * t = tor->torrentPeers;
 
-    assert( tr_isTorrent( tor ) );
-    assert( tr_torrentIsLocked( tor ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_torrentIsLocked (tor));
 
-    ensureMgrTimersExist( t->manager );
+    ensureMgrTimersExist (t->manager);
 
     t->isRunning = true;
     t->maxPeers = t->tor->maxConnectedPeers;
     t->pieceSortState = PIECES_UNSORTED;
 
-    rechokePulse( 0, 0, t->manager );
+    rechokePulse (0, 0, t->manager);
 }
 
 static void
-stopTorrent( Torrent * t )
+stopTorrent (Torrent * t)
 {
     tr_peer * peer;
 
     t->isRunning = false;
 
-    replicationFree( t );
-    invalidatePieceSorting( t );
+    replicationFree (t);
+    invalidatePieceSorting (t);
 
     /* disconnect the peers. */
-    while(( peer = tr_ptrArrayPop( &t->peers )))
-        peerDelete( t, peer );
+    while ((peer = tr_ptrArrayPop (&t->peers)))
+        peerDelete (t, peer);
 
-    /* disconnect the handshakes. handshakeAbort calls handshakeDoneCB(),
+    /* disconnect the handshakes. handshakeAbort calls handshakeDoneCB (),
      * which removes the handshake from t->outgoingHandshakes... */
-    while( !tr_ptrArrayEmpty( &t->outgoingHandshakes ) )
-        tr_handshakeAbort( tr_ptrArrayNth( &t->outgoingHandshakes, 0 ) );
+    while (!tr_ptrArrayEmpty (&t->outgoingHandshakes))
+        tr_handshakeAbort (tr_ptrArrayNth (&t->outgoingHandshakes, 0));
 }
 
 void
-tr_peerMgrStopTorrent( tr_torrent * tor )
+tr_peerMgrStopTorrent (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_torrentIsLocked( tor ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_torrentIsLocked (tor));
 
-    stopTorrent( tor->torrentPeers );
+    stopTorrent (tor->torrentPeers);
 }
 
 void
-tr_peerMgrAddTorrent( tr_peerMgr * manager, tr_torrent * tor )
+tr_peerMgrAddTorrent (tr_peerMgr * manager, tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_torrentIsLocked( tor ) );
-    assert( tor->torrentPeers == NULL );
+    assert (tr_isTorrent (tor));
+    assert (tr_torrentIsLocked (tor));
+    assert (tor->torrentPeers == NULL);
 
-    tor->torrentPeers = torrentNew( manager, tor );
+    tor->torrentPeers = torrentNew (manager, tor);
 }
 
 void
-tr_peerMgrRemoveTorrent( tr_torrent * tor )
+tr_peerMgrRemoveTorrent (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_torrentIsLocked( tor ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_torrentIsLocked (tor));
 
-    stopTorrent( tor->torrentPeers );
-    torrentFree( tor->torrentPeers );
+    stopTorrent (tor->torrentPeers);
+    torrentFree (tor->torrentPeers);
 }
 
 void
-tr_peerUpdateProgress( tr_torrent * tor, tr_peer * peer )
+tr_peerUpdateProgress (tr_torrent * tor, tr_peer * peer)
 {
     const tr_bitfield * have = &peer->have;
 
-    if( tr_bitfieldHasAll( have ) )
+    if (tr_bitfieldHasAll (have))
     {
         peer->progress = 1.0;
     }
-    else if( tr_bitfieldHasNone( have ) )
+    else if (tr_bitfieldHasNone (have))
     {
         peer->progress = 0.0;
     }
     else
     {
-        const float true_count = tr_bitfieldCountTrueBits( have );
+        const float true_count = tr_bitfieldCountTrueBits (have);
 
-        if( tr_torrentHasMetadata( tor ) )
+        if (tr_torrentHasMetadata (tor))
         {
             peer->progress = true_count / tor->info.pieceCount;
         }
         else /* without pieceCount, this result is only a best guess... */
         {
-            peer->progress = true_count / ( have->bit_count + 1 );
+            peer->progress = true_count / (have->bit_count + 1);
         }
     }
 
     /* clamp the progress range */
-    if ( peer->progress < 0.0 )
+    if (peer->progress < 0.0)
         peer->progress = 0.0;
-    if ( peer->progress > 1.0 )
+    if (peer->progress > 1.0)
         peer->progress = 1.0;
 
-    if( peer->atom && ( peer->progress >= 1.0 ) )
-        atomSetSeed( tor->torrentPeers, peer->atom );
+    if (peer->atom && (peer->progress >= 1.0))
+        atomSetSeed (tor->torrentPeers, peer->atom);
 }
 
 void
-tr_peerMgrOnTorrentGotMetainfo( tr_torrent * tor )
+tr_peerMgrOnTorrentGotMetainfo (tr_torrent * tor)
 {
     int i;
     int peerCount;
     tr_peer ** peers;
 
     /* the webseed list may have changed... */
-    rebuildWebseedArray( tor->torrentPeers, tor );
+    rebuildWebseedArray (tor->torrentPeers, tor);
 
     /* some peer_msgs' progress fields may not be accurate if we
        didn't have the metadata before now... so refresh them all... */
-    peerCount = tr_ptrArraySize( &tor->torrentPeers->peers );
-    peers = (tr_peer**) tr_ptrArrayBase( &tor->torrentPeers->peers );
-    for( i=0; i<peerCount; ++i )
-        tr_peerUpdateProgress( tor, peers[i] );
+    peerCount = tr_ptrArraySize (&tor->torrentPeers->peers);
+    peers = (tr_peer**) tr_ptrArrayBase (&tor->torrentPeers->peers);
+    for (i=0; i<peerCount; ++i)
+        tr_peerUpdateProgress (tor, peers[i]);
 
 }
 
 void
-tr_peerMgrTorrentAvailability( const tr_torrent * tor, int8_t * tab, unsigned int tabCount )
+tr_peerMgrTorrentAvailability (const tr_torrent * tor, int8_t * tab, unsigned int tabCount)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( torrentIsLocked( tor->torrentPeers ) );
-    assert( tab != NULL );
-    assert( tabCount > 0 );
+    assert (tr_isTorrent (tor));
+    assert (torrentIsLocked (tor->torrentPeers));
+    assert (tab != NULL);
+    assert (tabCount > 0);
 
-    memset( tab, 0, tabCount );
+    memset (tab, 0, tabCount);
 
-    if( tr_torrentHasMetadata( tor ) )
+    if (tr_torrentHasMetadata (tor))
     {
         tr_piece_index_t i;
-        const int peerCount = tr_ptrArraySize( &tor->torrentPeers->peers );
-        const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &tor->torrentPeers->peers );
+        const int peerCount = tr_ptrArraySize (&tor->torrentPeers->peers);
+        const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&tor->torrentPeers->peers);
         const float interval = tor->info.pieceCount / (float)tabCount;
-        const bool isSeed = tr_cpGetStatus( &tor->completion ) == TR_SEED;
+        const bool isSeed = tr_cpGetStatus (&tor->completion) == TR_SEED;
 
-        for( i=0; i<tabCount; ++i )
+        for (i=0; i<tabCount; ++i)
         {
             const int piece = i * interval;
 
-            if( isSeed || tr_cpPieceIsComplete( &tor->completion, piece ) )
+            if (isSeed || tr_cpPieceIsComplete (&tor->completion, piece))
                 tab[i] = -1;
-            else if( peerCount ) {
+            else if (peerCount) {
                 int j;
-                for( j=0; j<peerCount; ++j )
-                    if( tr_bitfieldHas( &peers[j]->have, piece ) )
+                for (j=0; j<peerCount; ++j)
+                    if (tr_bitfieldHas (&peers[j]->have, piece))
                         ++tab[i];
             }
         }
@@ -2579,12 +2583,12 @@ tr_peerMgrTorrentAvailability( const tr_torrent * tor, int8_t * tab, unsigned in
 }
 
 static bool
-peerIsSeed( const tr_peer * peer )
+peerIsSeed (const tr_peer * peer)
 {
-    if( peer->progress >= 1.0 )
+    if (peer->progress >= 1.0)
         return true;
 
-    if( peer->atom && atomIsSeed( peer->atom ) )
+    if (peer->atom && atomIsSeed (peer->atom))
         return true;
 
     return false;
@@ -2592,7 +2596,7 @@ peerIsSeed( const tr_peer * peer )
 
 /* count how many bytes we want that connected peers have */
 uint64_t
-tr_peerMgrGetDesiredAvailable( const tr_torrent * tor )
+tr_peerMgrGetDesiredAvailable (const tr_torrent * tor)
 {
     size_t i;
     size_t n;
@@ -2601,101 +2605,101 @@ tr_peerMgrGetDesiredAvailable( const tr_torrent * tor )
 
     /* common shortcuts... */
 
-    if( tr_torrentIsSeed( t->tor ) )
+    if (tr_torrentIsSeed (t->tor))
         return 0;
 
-    if( !tr_torrentHasMetadata( tor ) )
+    if (!tr_torrentHasMetadata (tor))
         return 0;
 
-    n = tr_ptrArraySize( &t->peers );
-    if( n == 0 )
+    n = tr_ptrArraySize (&t->peers);
+    if (n == 0)
         return 0;
     else {
-        const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
-        for( i=0; i<n; ++i )
-            if( peers[i]->atom && atomIsSeed( peers[i]->atom ) )
-                return tr_cpLeftUntilDone( &tor->completion );
+        const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
+        for (i=0; i<n; ++i)
+            if (peers[i]->atom && atomIsSeed (peers[i]->atom))
+                return tr_cpLeftUntilDone (&tor->completion);
     }
 
-    if( !t->pieceReplication || !t->pieceReplicationSize )
+    if (!t->pieceReplication || !t->pieceReplicationSize)
         return 0;
 
     /* do it the hard way */
 
     desiredAvailable = 0;
-    for( i=0, n=MIN(tor->info.pieceCount, t->pieceReplicationSize); i<n; ++i )
-        if( !tor->info.pieces[i].dnd && ( t->pieceReplication[i] > 0 ) )
-            desiredAvailable += tr_cpMissingBytesInPiece( &t->tor->completion, i );
+    for (i=0, n=MIN (tor->info.pieceCount, t->pieceReplicationSize); i<n; ++i)
+        if (!tor->info.pieces[i].dnd && (t->pieceReplication[i] > 0))
+            desiredAvailable += tr_cpMissingBytesInPiece (&t->tor->completion, i);
 
-    assert( desiredAvailable <= tor->info.totalSize );
+    assert (desiredAvailable <= tor->info.totalSize);
     return desiredAvailable;
 }
 
 void
-tr_peerMgrTorrentStats( tr_torrent  * tor,
+tr_peerMgrTorrentStats (tr_torrent  * tor,
                         int         * setmePeersConnected,
                         int         * setmeWebseedsSendingToUs,
                         int         * setmePeersSendingToUs,
                         int         * setmePeersGettingFromUs,
-                        int         * setmePeersFrom )
+                        int         * setmePeersFrom)
 {
     int i, size;
     const Torrent * t = tor->torrentPeers;
     const tr_peer ** peers;
 
-    assert( tr_torrentIsLocked( tor ) );
+    assert (tr_torrentIsLocked (tor));
 
-    peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
-    size = tr_ptrArraySize( &t->peers );
+    peers = (const tr_peer **) tr_ptrArrayBase (&t->peers);
+    size = tr_ptrArraySize (&t->peers);
 
     *setmePeersConnected       = 0;
     *setmePeersGettingFromUs   = 0;
     *setmePeersSendingToUs     = 0;
     *setmeWebseedsSendingToUs  = 0;
 
-    for( i=0; i<TR_PEER_FROM__MAX; ++i )
+    for (i=0; i<TR_PEER_FROM__MAX; ++i)
         setmePeersFrom[i] = 0;
 
-    for( i=0; i<size; ++i )
+    for (i=0; i<size; ++i)
     {
         const tr_peer * peer = peers[i];
         const struct peer_atom * atom = peer->atom;
 
-        if( peer->io == NULL ) /* not connected */
+        if (peer->io == NULL) /* not connected */
             continue;
 
         ++*setmePeersConnected;
 
         ++setmePeersFrom[atom->fromFirst];
 
-        if( clientIsDownloadingFrom( tor, peer ) )
+        if (clientIsDownloadingFrom (tor, peer))
             ++*setmePeersSendingToUs;
 
-        if( clientIsUploadingTo( peer ) )
+        if (clientIsUploadingTo (peer))
             ++*setmePeersGettingFromUs;
     }
 
-    *setmeWebseedsSendingToUs = countActiveWebseeds( t );
+    *setmeWebseedsSendingToUs = countActiveWebseeds (t);
 }
 
 double*
-tr_peerMgrWebSpeeds_KBps( const tr_torrent * tor )
+tr_peerMgrWebSpeeds_KBps (const tr_torrent * tor)
 {
     int i;
     const Torrent * t = tor->torrentPeers;
-    const int webseedCount = tr_ptrArraySize( &t->webseeds );
-    const tr_webseed ** webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
-    const uint64_t now = tr_time_msec( );
-    double * ret = tr_new0( double, webseedCount );
+    const int webseedCount = tr_ptrArraySize (&t->webseeds);
+    const tr_webseed ** webseeds = (const tr_webseed**) tr_ptrArrayBase (&t->webseeds);
+    const uint64_t now = tr_time_msec ();
+    double * ret = tr_new0 (double, webseedCount);
 
-    assert( tr_isTorrent( tor ) );
-    assert( tr_torrentIsLocked( tor ) );
-    assert( t->manager != NULL );
-    assert( webseedCount == tor->info.webseedCount );
+    assert (tr_isTorrent (tor));
+    assert (tr_torrentIsLocked (tor));
+    assert (t->manager != NULL);
+    assert (webseedCount == tor->info.webseedCount);
 
-    for( i=0; i<webseedCount; ++i ) {
+    for (i=0; i<webseedCount; ++i) {
         unsigned int Bps;
-        if( tr_webseedGetSpeed_Bps( webseeds[i], now, &Bps ) )
+        if (tr_webseedGetSpeed_Bps (webseeds[i], now, &Bps))
             ret[i] = Bps / (double)tr_speed_K;
         else
             ret[i] = -1.0;
@@ -2705,73 +2709,73 @@ tr_peerMgrWebSpeeds_KBps( const tr_torrent * tor )
 }
 
 unsigned int
-tr_peerGetPieceSpeed_Bps( const tr_peer * peer, uint64_t now, tr_direction direction )
+tr_peerGetPieceSpeed_Bps (const tr_peer * peer, uint64_t now, tr_direction direction)
 {
-    return peer->io ? tr_peerIoGetPieceSpeed_Bps( peer->io, now, direction ) : 0.0;
+    return peer->io ? tr_peerIoGetPieceSpeed_Bps (peer->io, now, direction) : 0.0;
 }
 
 struct tr_peer_stat *
-tr_peerMgrPeerStats( const tr_torrent * tor, int * setmeCount )
+tr_peerMgrPeerStats (const tr_torrent * tor, int * setmeCount)
 {
     int i;
     const Torrent * t = tor->torrentPeers;
-    const int size = tr_ptrArraySize( &t->peers );
-    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
-    const uint64_t now_msec = tr_time_msec( );
-    const time_t now = tr_time();
-    tr_peer_stat * ret = tr_new0( tr_peer_stat, size );
+    const int size = tr_ptrArraySize (&t->peers);
+    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
+    const uint64_t now_msec = tr_time_msec ();
+    const time_t now = tr_time ();
+    tr_peer_stat * ret = tr_new0 (tr_peer_stat, size);
 
-    assert( tr_isTorrent( tor ) );
-    assert( tr_torrentIsLocked( tor ) );
-    assert( t->manager );
+    assert (tr_isTorrent (tor));
+    assert (tr_torrentIsLocked (tor));
+    assert (t->manager);
 
-    for( i=0; i<size; ++i )
+    for (i=0; i<size; ++i)
     {
         char *                   pch;
         const tr_peer *          peer = peers[i];
         const struct peer_atom * atom = peer->atom;
         tr_peer_stat *           stat = ret + i;
 
-        tr_address_to_string_with_buf( &atom->addr, stat->addr, sizeof( stat->addr ) );
-        tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
-                   sizeof( stat->client ) );
-        stat->port                = ntohs( peer->atom->port );
+        tr_address_to_string_with_buf (&atom->addr, stat->addr, sizeof (stat->addr));
+        tr_strlcpy (stat->client, (peer->client ? peer->client : ""),
+                   sizeof (stat->client));
+        stat->port                = ntohs (peer->atom->port);
         stat->from                = atom->fromFirst;
         stat->progress            = peer->progress;
         stat->isUTP               = peer->io->utp_socket != NULL;
-        stat->isEncrypted         = tr_peerIoIsEncrypted( peer->io ) ? 1 : 0;
-        stat->rateToPeer_KBps     = toSpeedKBps( tr_peerGetPieceSpeed_Bps( peer, now_msec, TR_CLIENT_TO_PEER ) );
-        stat->rateToClient_KBps   = toSpeedKBps( tr_peerGetPieceSpeed_Bps( peer, now_msec, TR_PEER_TO_CLIENT ) );
+        stat->isEncrypted         = tr_peerIoIsEncrypted (peer->io) ? 1 : 0;
+        stat->rateToPeer_KBps     = toSpeedKBps (tr_peerGetPieceSpeed_Bps (peer, now_msec, TR_CLIENT_TO_PEER));
+        stat->rateToClient_KBps   = toSpeedKBps (tr_peerGetPieceSpeed_Bps (peer, now_msec, TR_PEER_TO_CLIENT));
         stat->peerIsChoked        = peer->peerIsChoked;
         stat->peerIsInterested    = peer->peerIsInterested;
         stat->clientIsChoked      = peer->clientIsChoked;
         stat->clientIsInterested  = peer->clientIsInterested;
-        stat->isIncoming          = tr_peerIoIsIncoming( peer->io );
-        stat->isDownloadingFrom   = clientIsDownloadingFrom( tor, peer );
-        stat->isUploadingTo       = clientIsUploadingTo( peer );
-        stat->isSeed              = peerIsSeed( peer );
+        stat->isIncoming          = tr_peerIoIsIncoming (peer->io);
+        stat->isDownloadingFrom   = clientIsDownloadingFrom (tor, peer);
+        stat->isUploadingTo       = clientIsUploadingTo (peer);
+        stat->isSeed              = peerIsSeed (peer);
 
-        stat->blocksToPeer        = tr_historyGet( &peer->blocksSentToPeer,    now, CANCEL_HISTORY_SEC );
-        stat->blocksToClient      = tr_historyGet( &peer->blocksSentToClient,  now, CANCEL_HISTORY_SEC );
-        stat->cancelsToPeer       = tr_historyGet( &peer->cancelsSentToPeer,   now, CANCEL_HISTORY_SEC );
-        stat->cancelsToClient     = tr_historyGet( &peer->cancelsSentToClient, now, CANCEL_HISTORY_SEC );
+        stat->blocksToPeer        = tr_historyGet (&peer->blocksSentToPeer,    now, CANCEL_HISTORY_SEC);
+        stat->blocksToClient      = tr_historyGet (&peer->blocksSentToClient,  now, CANCEL_HISTORY_SEC);
+        stat->cancelsToPeer       = tr_historyGet (&peer->cancelsSentToPeer,   now, CANCEL_HISTORY_SEC);
+        stat->cancelsToClient     = tr_historyGet (&peer->cancelsSentToClient, now, CANCEL_HISTORY_SEC);
 
         stat->pendingReqsToPeer   = peer->pendingReqsToPeer;
         stat->pendingReqsToClient = peer->pendingReqsToClient;
 
         pch = stat->flagStr;
-        if( stat->isUTP ) *pch++ = 'T';
-        if( t->optimistic == peer ) *pch++ = 'O';
-        if( stat->isDownloadingFrom ) *pch++ = 'D';
-        else if( stat->clientIsInterested ) *pch++ = 'd';
-        if( stat->isUploadingTo ) *pch++ = 'U';
-        else if( stat->peerIsInterested ) *pch++ = 'u';
-        if( !stat->clientIsChoked && !stat->clientIsInterested ) *pch++ = 'K';
-        if( !stat->peerIsChoked && !stat->peerIsInterested ) *pch++ = '?';
-        if( stat->isEncrypted ) *pch++ = 'E';
-        if( stat->from == TR_PEER_FROM_DHT ) *pch++ = 'H';
-        else if( stat->from == TR_PEER_FROM_PEX ) *pch++ = 'X';
-        if( stat->isIncoming ) *pch++ = 'I';
+        if (stat->isUTP) *pch++ = 'T';
+        if (t->optimistic == peer) *pch++ = 'O';
+        if (stat->isDownloadingFrom) *pch++ = 'D';
+        else if (stat->clientIsInterested) *pch++ = 'd';
+        if (stat->isUploadingTo) *pch++ = 'U';
+        else if (stat->peerIsInterested) *pch++ = 'u';
+        if (!stat->clientIsChoked && !stat->clientIsInterested) *pch++ = 'K';
+        if (!stat->peerIsChoked && !stat->peerIsInterested) *pch++ = '?';
+        if (stat->isEncrypted) *pch++ = 'E';
+        if (stat->from == TR_PEER_FROM_DHT) *pch++ = 'H';
+        else if (stat->from == TR_PEER_FROM_PEX) *pch++ = 'X';
+        if (stat->isIncoming) *pch++ = 'I';
         *pch = '\0';
     }
 
@@ -2786,39 +2790,39 @@ tr_peerMgrPeerStats( const tr_torrent * tor, int * setmeCount )
 ***/
 
 void
-tr_peerMgrClearInterest( tr_torrent * tor )
+tr_peerMgrClearInterest (tr_torrent * tor)
 {
     int i;
     Torrent * t = tor->torrentPeers;
-    const int peerCount = tr_ptrArraySize( &t->peers );
+    const int peerCount = tr_ptrArraySize (&t->peers);
 
-    assert( tr_isTorrent( tor ) );
-    assert( tr_torrentIsLocked( tor ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_torrentIsLocked (tor));
 
-    for( i=0; i<peerCount; ++i )
+    for (i=0; i<peerCount; ++i)
     {
-        const tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
-        tr_peerMsgsSetInterested( peer->msgs, false );
+        const tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
+        tr_peerMsgsSetInterested (peer->msgs, false);
     }
 }
 
 /* does this peer have any pieces that we want? */
 static bool
-isPeerInteresting( const tr_torrent  * const tor,
+isPeerInteresting (const tr_torrent  * const tor,
                    const bool        * const piece_is_interesting,
-                   const tr_peer     * const peer )
+                   const tr_peer     * const peer)
 {
     tr_piece_index_t i, n;
 
     /* these cases should have already been handled by the calling code... */
-    assert( !tr_torrentIsSeed( tor ) );
-    assert( tr_torrentIsPieceTransferAllowed( tor, TR_PEER_TO_CLIENT ) );
+    assert (!tr_torrentIsSeed (tor));
+    assert (tr_torrentIsPieceTransferAllowed (tor, TR_PEER_TO_CLIENT));
 
-    if( peerIsSeed( peer ) )
+    if (peerIsSeed (peer))
         return true;
 
-    for( i=0, n=tor->info.pieceCount; i<n; ++i )
-        if( piece_is_interesting[i] && tr_bitfieldHas( &peer->have, i ) )
+    for (i=0, n=tor->info.pieceCount; i<n; ++i)
+        if (piece_is_interesting[i] && tr_bitfieldHas (&peer->have, i))
             return true;
 
     return false;
@@ -2840,12 +2844,12 @@ struct tr_rechoke_info
 };
 
 static int
-compare_rechoke_info( const void * va, const void * vb )
+compare_rechoke_info (const void * va, const void * vb)
 {
     const struct tr_rechoke_info * a = va;
     const struct tr_rechoke_info * b = vb;
 
-    if( a->rechoke_state != b->rechoke_state )
+    if (a->rechoke_state != b->rechoke_state)
         return a->rechoke_state - b->rechoke_state;
 
     return a->salt - b->salt;
@@ -2853,20 +2857,20 @@ compare_rechoke_info( const void * va, const void * vb )
 
 /* determines who we send "interested" messages to */
 static void
-rechokeDownloads( Torrent * t )
+rechokeDownloads (Torrent * t)
 {
     int i;
     int maxPeers = 0;
     int rechoke_count = 0;
     struct tr_rechoke_info * rechoke = NULL;
     const int MIN_INTERESTING_PEERS = 5;
-    const int peerCount = tr_ptrArraySize( &t->peers );
-    const time_t now = tr_time( );
+    const int peerCount = tr_ptrArraySize (&t->peers);
+    const time_t now = tr_time ();
 
     /* some cases where this function isn't necessary */
-    if( tr_torrentIsSeed( t->tor ) )
+    if (tr_torrentIsSeed (t->tor))
         return;
-    if ( !tr_torrentIsPieceTransferAllowed( t->tor, TR_PEER_TO_CLIENT ) )
+    if (!tr_torrentIsPieceTransferAllowed (t->tor, TR_PEER_TO_CLIENT))
         return;
 
     /* decide HOW MANY peers to be interested in */
@@ -2889,113 +2893,113 @@ rechokeDownloads( Torrent * t )
          * peers in our calculations lest they confuse Transmission into
          * thinking it's hit its bandwidth cap.
          */
-        for( i=0; i<peerCount; ++i )
+        for (i=0; i<peerCount; ++i)
         {
-            const tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
-            const int b = tr_historyGet( &peer->blocksSentToClient, now, CANCEL_HISTORY_SEC );
-            const int c = tr_historyGet( &peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC );
+            const tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
+            const int b = tr_historyGet (&peer->blocksSentToClient, now, CANCEL_HISTORY_SEC);
+            const int c = tr_historyGet (&peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC);
 
-            if( b == 0 ) /* ignore unresponsive peers, as described above */
+            if (b == 0) /* ignore unresponsive peers, as described above */
                 continue;
 
             blocks += b;
             cancels += c;
         }
 
-        if( cancels > 0 )
+        if (cancels > 0)
         {
             /* cancelRate: of the block requests we've recently made, the percentage we cancelled.
              * higher values indicate more congestion. */
             const double cancelRate = cancels / (double)(cancels + blocks);
-            const double mult = 1 - MIN( cancelRate, 0.5 );
+            const double mult = 1 - MIN (cancelRate, 0.5);
             maxPeers = t->interestedCount * mult;
-            tordbg( t, "cancel rate is %.3f -- reducing the "
+            tordbg (t, "cancel rate is %.3f -- reducing the "
                        "number of peers we're interested in by %.0f percent",
-                       cancelRate, mult * 100 );
+                       cancelRate, mult * 100);
             t->lastCancel = now;
         }
 
         timeSinceCancel = now - t->lastCancel;
-        if( timeSinceCancel )
+        if (timeSinceCancel)
         {
             const int maxIncrease = 15;
             const time_t maxHistory = 2 * CANCEL_HISTORY_SEC;
-            const double mult = MIN( timeSinceCancel, maxHistory ) / (double) maxHistory;
+            const double mult = MIN (timeSinceCancel, maxHistory) / (double) maxHistory;
             const int inc = maxIncrease * mult;
             maxPeers = t->maxPeers + inc;
-            tordbg( t, "time since last cancel is %li -- increasing the "
+            tordbg (t, "time since last cancel is %li -- increasing the "
                        "number of peers we're interested in by %d",
-                       timeSinceCancel, inc );
+                       timeSinceCancel, inc);
         }
     }
 
     /* don't let the previous section's number tweaking go too far... */
-    if( maxPeers < MIN_INTERESTING_PEERS )
+    if (maxPeers < MIN_INTERESTING_PEERS)
         maxPeers = MIN_INTERESTING_PEERS;
-    if( maxPeers > t->tor->maxConnectedPeers )
+    if (maxPeers > t->tor->maxConnectedPeers)
         maxPeers = t->tor->maxConnectedPeers;
 
     t->maxPeers = maxPeers;
 
-    if( peerCount > 0 )
+    if (peerCount > 0)
     {
         bool * piece_is_interesting;
         const tr_torrent * const tor = t->tor;
         const int n = tor->info.pieceCount;
 
         /* build a bitfield of interesting pieces... */
-        piece_is_interesting = tr_new( bool, n );
-        for( i=0; i<n; i++ )
-            piece_is_interesting[i] = !tor->info.pieces[i].dnd && !tr_cpPieceIsComplete( &tor->completion, i );
+        piece_is_interesting = tr_new (bool, n);
+        for (i=0; i<n; i++)
+            piece_is_interesting[i] = !tor->info.pieces[i].dnd && !tr_cpPieceIsComplete (&tor->completion, i);
 
         /* decide WHICH peers to be interested in (based on their cancel-to-block ratio) */
-        for( i=0; i<peerCount; ++i )
+        for (i=0; i<peerCount; ++i)
         {
-            tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
+            tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
 
-            if( !isPeerInteresting( t->tor, piece_is_interesting, peer ) )
+            if (!isPeerInteresting (t->tor, piece_is_interesting, peer))
             {
-                tr_peerMsgsSetInterested( peer->msgs, false );
+                tr_peerMsgsSetInterested (peer->msgs, false);
             }
             else
             {
                 tr_rechoke_state rechoke_state;
-                const int blocks = tr_historyGet( &peer->blocksSentToClient, now, CANCEL_HISTORY_SEC );
-                const int cancels = tr_historyGet( &peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC );
+                const int blocks = tr_historyGet (&peer->blocksSentToClient, now, CANCEL_HISTORY_SEC);
+                const int cancels = tr_historyGet (&peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC);
 
-                if( !blocks && !cancels )
+                if (!blocks && !cancels)
                     rechoke_state = RECHOKE_STATE_UNTESTED;
-                else if( !cancels )
+                else if (!cancels)
                     rechoke_state = RECHOKE_STATE_GOOD;
-                else if( !blocks )
+                else if (!blocks)
                     rechoke_state = RECHOKE_STATE_BAD;
-                else if( ( cancels * 10 ) < blocks )
+                else if ((cancels * 10) < blocks)
                     rechoke_state = RECHOKE_STATE_GOOD;
                 else
                     rechoke_state = RECHOKE_STATE_BAD;
 
-                if( rechoke == NULL )
-                    rechoke = tr_new( struct tr_rechoke_info, peerCount );
+                if (rechoke == NULL)
+                    rechoke = tr_new (struct tr_rechoke_info, peerCount);
 
                  rechoke[rechoke_count].peer = peer;
                  rechoke[rechoke_count].rechoke_state = rechoke_state;
-                 rechoke[rechoke_count].salt = tr_cryptoWeakRandInt( INT_MAX );
+                 rechoke[rechoke_count].salt = tr_cryptoWeakRandInt (INT_MAX);
                  rechoke_count++;
             }
 
         }
 
-        tr_free( piece_is_interesting );
+        tr_free (piece_is_interesting);
     }
 
     /* now that we know which & how many peers to be interested in... update the peer interest */
-    qsort( rechoke, rechoke_count, sizeof( struct tr_rechoke_info ), compare_rechoke_info );
-    t->interestedCount = MIN( maxPeers, rechoke_count );
-    for( i=0; i<rechoke_count; ++i )
-        tr_peerMsgsSetInterested( rechoke[i].peer->msgs, i<t->interestedCount );
+    qsort (rechoke, rechoke_count, sizeof (struct tr_rechoke_info), compare_rechoke_info);
+    t->interestedCount = MIN (maxPeers, rechoke_count);
+    for (i=0; i<rechoke_count; ++i)
+        tr_peerMsgsSetInterested (rechoke[i].peer->msgs, i<t->interestedCount);
 
     /* cleanup */
-    tr_free( rechoke );
+    tr_free (rechoke);
 }
 
 /**
@@ -3013,18 +3017,18 @@ struct ChokeData
 };
 
 static int
-compareChoke( const void * va, const void * vb )
+compareChoke (const void * va, const void * vb)
 {
     const struct ChokeData * a = va;
     const struct ChokeData * b = vb;
 
-    if( a->rate != b->rate ) /* prefer higher overall speeds */
+    if (a->rate != b->rate) /* prefer higher overall speeds */
         return a->rate > b->rate ? -1 : 1;
 
-    if( a->wasChoked != b->wasChoked ) /* prefer unchoked */
+    if (a->wasChoked != b->wasChoked) /* prefer unchoked */
         return a->wasChoked ? 1 : -1;
 
-    if( a->salt != b->salt ) /* random order */
+    if (a->salt != b->salt) /* random order */
         return a->salt - b->salt;
 
     return 0;
@@ -3032,94 +3036,94 @@ compareChoke( const void * va, const void * vb )
 
 /* is this a new connection? */
 static int
-isNew( const tr_peer * peer )
+isNew (const tr_peer * peer)
 {
-    return peer && peer->io && tr_peerIoGetAge( peer->io ) < 45;
+    return peer && peer->io && tr_peerIoGetAge (peer->io) < 45;
 }
 
 /* get a rate for deciding which peers to choke and unchoke. */
 static int
-getRate( const tr_torrent * tor, struct peer_atom * atom, uint64_t now )
+getRate (const tr_torrent * tor, struct peer_atom * atom, uint64_t now)
 {
     unsigned int Bps;
 
-    if( tr_torrentIsSeed( tor ) )
-        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_CLIENT_TO_PEER );
+    if (tr_torrentIsSeed (tor))
+        Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_CLIENT_TO_PEER);
 
     /* downloading a private torrent... take upload speed into account
      * because there may only be a small window of opportunity to share */
-    else if( tr_torrentIsPrivate( tor ) )
-        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_PEER_TO_CLIENT )
-            + tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_CLIENT_TO_PEER );
+    else if (tr_torrentIsPrivate (tor))
+        Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_PEER_TO_CLIENT)
+            + tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_CLIENT_TO_PEER);
 
     /* downloading a public torrent */
     else
-        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_PEER_TO_CLIENT );
+        Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_PEER_TO_CLIENT);
 
     /* convert it to bytes per second */
     return Bps;
 }
 
 static inline bool
-isBandwidthMaxedOut( const tr_bandwidth * b,
-                     const uint64_t now_msec, tr_direction dir )
+isBandwidthMaxedOut (const tr_bandwidth * b,
+                     const uint64_t now_msec, tr_direction dir)
 {
-    if( !tr_bandwidthIsLimited( b, dir ) )
+    if (!tr_bandwidthIsLimited (b, dir))
         return false;
     else {
-        const unsigned int got = tr_bandwidthGetPieceSpeed_Bps( b, now_msec, dir );
-        const unsigned int want = tr_bandwidthGetDesiredSpeed_Bps( b, dir );
+        const unsigned int got = tr_bandwidthGetPieceSpeed_Bps (b, now_msec, dir);
+        const unsigned int want = tr_bandwidthGetDesiredSpeed_Bps (b, dir);
         return got >= want;
     }
 }
 
 static void
-rechokeUploads( Torrent * t, const uint64_t now )
+rechokeUploads (Torrent * t, const uint64_t now)
 {
     int i, size, unchokedInterested;
-    const int peerCount = tr_ptrArraySize( &t->peers );
-    tr_peer ** peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
-    struct ChokeData * choke = tr_new0( struct ChokeData, peerCount );
+    const int peerCount = tr_ptrArraySize (&t->peers);
+    tr_peer ** peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
+    struct ChokeData * choke = tr_new0 (struct ChokeData, peerCount);
     const tr_session * session = t->manager->session;
-    const int chokeAll = !tr_torrentIsPieceTransferAllowed( t->tor, TR_CLIENT_TO_PEER );
-    const bool isMaxedOut = isBandwidthMaxedOut( &t->tor->bandwidth, now, TR_UP );
+    const int chokeAll = !tr_torrentIsPieceTransferAllowed (t->tor, TR_CLIENT_TO_PEER);
+    const bool isMaxedOut = isBandwidthMaxedOut (&t->tor->bandwidth, now, TR_UP);
 
-    assert( torrentIsLocked( t ) );
+    assert (torrentIsLocked (t));
 
     /* an optimistic unchoke peer's "optimistic"
-     * state lasts for N calls to rechokeUploads(). */
-    if( t->optimisticUnchokeTimeScaler > 0 )
+     * state lasts for N calls to rechokeUploads (). */
+    if (t->optimisticUnchokeTimeScaler > 0)
         t->optimisticUnchokeTimeScaler--;
     else
         t->optimistic = NULL;
 
     /* sort the peers by preference and rate */
-    for( i = 0, size = 0; i < peerCount; ++i )
+    for (i = 0, size = 0; i < peerCount; ++i)
     {
         tr_peer * peer = peers[i];
         struct peer_atom * atom = peer->atom;
 
-        if( peerIsSeed( peer ) ) /* choke seeds and partial seeds */
+        if (peerIsSeed (peer)) /* choke seeds and partial seeds */
         {
-            tr_peerMsgsSetChoke( peer->msgs, true );
+            tr_peerMsgsSetChoke (peer->msgs, true);
         }
-        else if( chokeAll ) /* choke everyone if we're not uploading */
+        else if (chokeAll) /* choke everyone if we're not uploading */
         {
-            tr_peerMsgsSetChoke( peer->msgs, true );
+            tr_peerMsgsSetChoke (peer->msgs, true);
         }
-        else if( peer != t->optimistic )
+        else if (peer != t->optimistic)
         {
             struct ChokeData * n = &choke[size++];
             n->peer         = peer;
             n->isInterested = peer->peerIsInterested;
             n->wasChoked    = peer->peerIsChoked;
-            n->rate         = getRate( t->tor, atom, now );
-            n->salt         = tr_cryptoWeakRandInt( INT_MAX );
+            n->rate         = getRate (t->tor, atom, now);
+            n->salt         = tr_cryptoWeakRandInt (INT_MAX);
             n->isChoked     = true;
         }
     }
 
-    qsort( choke, size, sizeof( struct ChokeData ), compareChoke );
+    qsort (choke, size, sizeof (struct ChokeData), compareChoke);
 
     /**
      * Reciprocation and number of uploads capping is managed by unchoking
@@ -3137,70 +3141,70 @@ rechokeUploads( Torrent * t, const uint64_t now )
      * If our bandwidth is maxed out, don't unchoke any more peers.
      */
     unchokedInterested = 0;
-    for( i=0; i<size && unchokedInterested<session->uploadSlotsPerTorrent; ++i ) {
+    for (i=0; i<size && unchokedInterested<session->uploadSlotsPerTorrent; ++i) {
         choke[i].isChoked = isMaxedOut ? choke[i].wasChoked : false;
-        if( choke[i].isInterested )
+        if (choke[i].isInterested)
             ++unchokedInterested;
     }
 
     /* optimistic unchoke */
-    if( !t->optimistic && !isMaxedOut && (i<size) )
+    if (!t->optimistic && !isMaxedOut && (i<size))
     {
         int n;
         struct ChokeData * c;
         tr_ptrArray randPool = TR_PTR_ARRAY_INIT;
 
-        for( ; i<size; ++i )
+        for (; i<size; ++i)
         {
-            if( choke[i].isInterested )
+            if (choke[i].isInterested)
             {
                 const tr_peer * peer = choke[i].peer;
                 int x = 1, y;
-                if( isNew( peer ) ) x *= 3;
-                for( y=0; y<x; ++y )
-                    tr_ptrArrayAppend( &randPool, &choke[i] );
+                if (isNew (peer)) x *= 3;
+                for (y=0; y<x; ++y)
+                    tr_ptrArrayAppend (&randPool, &choke[i]);
             }
         }
 
-        if(( n = tr_ptrArraySize( &randPool )))
+        if ((n = tr_ptrArraySize (&randPool)))
         {
-            c = tr_ptrArrayNth( &randPool, tr_cryptoWeakRandInt( n ));
+            c = tr_ptrArrayNth (&randPool, tr_cryptoWeakRandInt (n));
             c->isChoked = false;
             t->optimistic = c->peer;
             t->optimisticUnchokeTimeScaler = OPTIMISTIC_UNCHOKE_MULTIPLIER;
         }
 
-        tr_ptrArrayDestruct( &randPool, NULL );
+        tr_ptrArrayDestruct (&randPool, NULL);
     }
 
-    for( i=0; i<size; ++i )
-        tr_peerMsgsSetChoke( choke[i].peer->msgs, choke[i].isChoked );
+    for (i=0; i<size; ++i)
+        tr_peerMsgsSetChoke (choke[i].peer->msgs, choke[i].isChoked);
 
     /* cleanup */
-    tr_free( choke );
+    tr_free (choke);
 }
 
 static void
-rechokePulse( int foo UNUSED, short bar UNUSED, void * vmgr )
+rechokePulse (int foo UNUSED, short bar UNUSED, void * vmgr)
 {
     tr_torrent * tor = NULL;
     tr_peerMgr * mgr = vmgr;
-    const uint64_t now = tr_time_msec( );
+    const uint64_t now = tr_time_msec ();
 
-    managerLock( mgr );
+    managerLock (mgr);
 
-    while(( tor = tr_torrentNext( mgr->session, tor ))) {
-        if( tor->isRunning ) {
+    while ((tor = tr_torrentNext (mgr->session, tor))) {
+        if (tor->isRunning) {
             Torrent * t = tor->torrentPeers;
-            if( !tr_ptrArrayEmpty( &t->peers ) ) {
-                rechokeUploads( t, now );
-                rechokeDownloads( t );
+            if (!tr_ptrArrayEmpty (&t->peers)) {
+                rechokeUploads (t, now);
+                rechokeDownloads (t);
             }
         }
     }
 
-    tr_timerAddMsec( mgr->rechokeTimer, RECHOKE_PERIOD_MSEC );
-    managerUnlock( mgr );
+    tr_timerAddMsec (mgr->rechokeTimer, RECHOKE_PERIOD_MSEC);
+    managerUnlock (mgr);
 }
 
 /***
@@ -3210,30 +3214,30 @@ rechokePulse( int foo UNUSED, short bar UNUSED, void * vmgr )
 ***/
 
 static bool
-shouldPeerBeClosed( const Torrent    * t,
+shouldPeerBeClosed (const Torrent    * t,
                     const tr_peer    * peer,
                     int                peerCount,
-                    const time_t       now )
+                    const time_t       now)
 {
     const tr_torrent *       tor = t->tor;
     const struct peer_atom * atom = peer->atom;
 
     /* if it's marked for purging, close it */
-    if( peer->doPurge )
+    if (peer->doPurge)
     {
-        tordbg( t, "purging peer %s because its doPurge flag is set",
-                tr_atomAddrStr( atom ) );
+        tordbg (t, "purging peer %s because its doPurge flag is set",
+                tr_atomAddrStr (atom));
         return true;
     }
 
     /* disconnect if we're both seeds and enough time has passed for PEX */
-    if( tr_torrentIsSeed( tor ) && peerIsSeed( peer ) )
-        return !tr_torrentAllowsPex(tor) || (now-atom->time>=30);
+    if (tr_torrentIsSeed (tor) && peerIsSeed (peer))
+        return !tr_torrentAllowsPex (tor) || (now-atom->time>=30);
 
     /* disconnect if it's been too long since piece data has been transferred.
      * this is on a sliding scale based on number of available peers... */
     {
-        const int relaxStrictnessIfFewerThanN = (int)( ( getMaxPeerCount( tor ) * 0.9 ) + 0.5 );
+        const int relaxStrictnessIfFewerThanN = (int)((getMaxPeerCount (tor) * 0.9) + 0.5);
         /* if we have >= relaxIfFewerThan, strictness is 100%.
          * if we have zero connections, strictness is 0% */
         const float strictness = peerCount >= relaxStrictnessIfFewerThanN
@@ -3241,12 +3245,12 @@ shouldPeerBeClosed( const Torrent    * t,
                                : peerCount / (float)relaxStrictnessIfFewerThanN;
         const int lo = MIN_UPLOAD_IDLE_SECS;
         const int hi = MAX_UPLOAD_IDLE_SECS;
-        const int limit = hi - ( ( hi - lo ) * strictness );
-        const int idleTime = now - MAX( atom->time, atom->piece_data_time );
-/*fprintf( stderr, "strictness is %.3f, limit is %d seconds... time since connect is %d, time since piece is %d ... idleTime is %d, doPurge is %d\n", (double)strictness, limit, (int)(now - atom->time), (int)(now - atom->piece_data_time), idleTime, idleTime > limit );*/
-        if( idleTime > limit ) {
-            tordbg( t, "purging peer %s because it's been %d secs since we shared anything",
-                       tr_atomAddrStr( atom ), idleTime );
+        const int limit = hi - ((hi - lo) * strictness);
+        const int idleTime = now - MAX (atom->time, atom->piece_data_time);
+/*fprintf (stderr, "strictness is %.3f, limit is %d seconds... time since connect is %d, time since piece is %d ... idleTime is %d, doPurge is %d\n", (double)strictness, limit, (int)(now - atom->time), (int)(now - atom->piece_data_time), idleTime, idleTime > limit);*/
+        if (idleTime > limit) {
+            tordbg (t, "purging peer %s because it's been %d secs since we shared anything",
+                       tr_atomAddrStr (atom), idleTime);
             return true;
         }
     }
@@ -3255,18 +3259,18 @@ shouldPeerBeClosed( const Torrent    * t,
 }
 
 static tr_peer **
-getPeersToClose( Torrent * t, const time_t now_sec, int * setmeSize )
+getPeersToClose (Torrent * t, const time_t now_sec, int * setmeSize)
 {
     int i, peerCount, outsize;
     struct tr_peer ** ret = NULL;
-    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek( &t->peers, &peerCount );
+    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek (&t->peers, &peerCount);
 
-    assert( torrentIsLocked( t ) );
+    assert (torrentIsLocked (t));
 
-    for( i = outsize = 0; i < peerCount; ++i ) {
-        if( shouldPeerBeClosed( t, peers[i], peerCount, now_sec ) ) {
-            if( ret == NULL )
-                ret = tr_new( tr_peer *, peerCount );
+    for (i = outsize = 0; i < peerCount; ++i) {
+        if (shouldPeerBeClosed (t, peers[i], peerCount, now_sec)) {
+            if (ret == NULL)
+                ret = tr_new (tr_peer *, peerCount);
             ret[outsize++] = peers[i];
         }
     }
@@ -3276,23 +3280,23 @@ getPeersToClose( Torrent * t, const time_t now_sec, int * setmeSize )
 }
 
 static int
-getReconnectIntervalSecs( const struct peer_atom * atom, const time_t now )
+getReconnectIntervalSecs (const struct peer_atom * atom, const time_t now)
 {
     int sec;
 
     /* if we were recently connected to this peer and transferring piece
      * data, try to reconnect to them sooner rather that later -- we don't
      * want network troubles to get in the way of a good peer. */
-    if( ( now - atom->piece_data_time ) <= ( MINIMUM_RECONNECT_INTERVAL_SECS * 2 ) )
+    if ((now - atom->piece_data_time) <= (MINIMUM_RECONNECT_INTERVAL_SECS * 2))
         sec = MINIMUM_RECONNECT_INTERVAL_SECS;
 
     /* don't allow reconnects more often than our minimum */
-    else if( ( now - atom->time ) < MINIMUM_RECONNECT_INTERVAL_SECS )
+    else if ((now - atom->time) < MINIMUM_RECONNECT_INTERVAL_SECS)
         sec = MINIMUM_RECONNECT_INTERVAL_SECS;
 
     /* otherwise, the interval depends on how many times we've tried
      * and failed to connect to the peer */
-    else switch( atom->numFails ) {
+    else switch (atom->numFails) {
         case 0: sec = 0; break;
         case 1: sec = 5; break;
         case 2: sec = 2 * 60; break;
@@ -3303,76 +3307,76 @@ getReconnectIntervalSecs( const struct peer_atom * atom, const time_t now )
     }
 
     /* penalize peers that were unreachable the last time we tried */
-    if( atom->flags2 & MYFLAG_UNREACHABLE )
+    if (atom->flags2 & MYFLAG_UNREACHABLE)
         sec += sec;
 
-    dbgmsg( "reconnect interval for %s is %d seconds", tr_atomAddrStr( atom ), sec );
+    dbgmsg ("reconnect interval for %s is %d seconds", tr_atomAddrStr (atom), sec);
     return sec;
 }
 
 static void
-removePeer( Torrent * t, tr_peer * peer )
+removePeer (Torrent * t, tr_peer * peer)
 {
     tr_peer * removed;
     struct peer_atom * atom = peer->atom;
 
-    assert( torrentIsLocked( t ) );
-    assert( atom );
+    assert (torrentIsLocked (t));
+    assert (atom);
 
-    atom->time = tr_time( );
+    atom->time = tr_time ();
 
-    removed = tr_ptrArrayRemoveSorted( &t->peers, peer, peerCompare );
+    removed = tr_ptrArrayRemoveSorted (&t->peers, peer, peerCompare);
 
-    if( replicationExists( t ) )
-        tr_decrReplicationFromBitfield( t, &peer->have );
+    if (replicationExists (t))
+        tr_decrReplicationFromBitfield (t, &peer->have);
 
-    assert( removed == peer );
-    peerDelete( t, removed );
+    assert (removed == peer);
+    peerDelete (t, removed);
 }
 
 static void
-closePeer( Torrent * t, tr_peer * peer )
+closePeer (Torrent * t, tr_peer * peer)
 {
     struct peer_atom * atom;
 
-    assert( t != NULL );
-    assert( peer != NULL );
+    assert (t != NULL);
+    assert (peer != NULL);
 
     atom = peer->atom;
 
     /* if we transferred piece data, then they might be good peers,
        so reset their `numFails' weight to zero. otherwise we connected
        to them fruitlessly, so mark it as another fail */
-    if( atom->piece_data_time ) {
-        tordbg( t, "resetting atom %s numFails to 0", tr_atomAddrStr(atom) );
+    if (atom->piece_data_time) {
+        tordbg (t, "resetting atom %s numFails to 0", tr_atomAddrStr (atom));
         atom->numFails = 0;
     } else {
         ++atom->numFails;
-        tordbg( t, "incremented atom %s numFails to %d", tr_atomAddrStr(atom), (int)atom->numFails );
+        tordbg (t, "incremented atom %s numFails to %d", tr_atomAddrStr (atom), (int)atom->numFails);
     }
 
-    tordbg( t, "removing bad peer %s", tr_peerIoGetAddrStr( peer->io ) );
-    removePeer( t, peer );
+    tordbg (t, "removing bad peer %s", tr_peerIoGetAddrStr (peer->io));
+    removePeer (t, peer);
 }
 
 static void
-removeAllPeers( Torrent * t )
+removeAllPeers (Torrent * t)
 {
-    while( !tr_ptrArrayEmpty( &t->peers ) )
-        removePeer( t, tr_ptrArrayNth( &t->peers, 0 ) );
+    while (!tr_ptrArrayEmpty (&t->peers))
+        removePeer (t, tr_ptrArrayNth (&t->peers, 0));
 }
 
 static void
-closeBadPeers( Torrent * t, const time_t now_sec )
+closeBadPeers (Torrent * t, const time_t now_sec)
 {
-    if( !tr_ptrArrayEmpty( &t->peers ) )
+    if (!tr_ptrArrayEmpty (&t->peers))
     {
         int i;
         int peerCount;
-        struct tr_peer ** peers = getPeersToClose( t, now_sec, &peerCount );
-        for( i=0; i<peerCount; ++i )
-            closePeer( t, peers[i] );
-        tr_free( peers );
+        struct tr_peer ** peers = getPeersToClose (t, now_sec, &peerCount);
+        for (i=0; i<peerCount; ++i)
+            closePeer (t, peers[i]);
+        tr_free (peers);
     }
 }
 
@@ -3387,144 +3391,144 @@ struct peer_liveliness
 };
 
 static int
-comparePeerLiveliness( const void * va, const void * vb )
+comparePeerLiveliness (const void * va, const void * vb)
 {
     const struct peer_liveliness * a = va;
     const struct peer_liveliness * b = vb;
 
-    if( a->doPurge != b->doPurge )
+    if (a->doPurge != b->doPurge)
         return a->doPurge ? 1 : -1;
 
-    if( a->speed != b->speed ) /* faster goes first */
+    if (a->speed != b->speed) /* faster goes first */
         return a->speed > b->speed ? -1 : 1;
 
     /* the one to give us data more recently goes first */
-    if( a->pieceDataTime != b->pieceDataTime )
+    if (a->pieceDataTime != b->pieceDataTime)
         return a->pieceDataTime > b->pieceDataTime ? -1 : 1;
 
     /* the one we connected to most recently goes first */
-    if( a->time != b->time )
+    if (a->time != b->time)
         return a->time > b->time ? -1 : 1;
 
     return 0;
 }
 
 static void
-sortPeersByLivelinessImpl( tr_peer  ** peers,
+sortPeersByLivelinessImpl (tr_peer  ** peers,
                            void     ** clientData,
                            int         n,
                            uint64_t    now,
-                           int (*compare) ( const void *va, const void *vb ) )
+                           int (*compare)(const void *va, const void *vb))
 {
     int i;
     struct peer_liveliness *lives, *l;
 
     /* build a sortable array of peer + extra info */
-    lives = l = tr_new0( struct peer_liveliness, n );
-    for( i=0; i<n; ++i, ++l )
+    lives = l = tr_new0 (struct peer_liveliness, n);
+    for (i=0; i<n; ++i, ++l)
     {
         tr_peer * p = peers[i];
         l->peer = p;
         l->doPurge = p->doPurge;
         l->pieceDataTime = p->atom->piece_data_time;
         l->time = p->atom->time;
-        l->speed = tr_peerGetPieceSpeed_Bps( p, now, TR_UP )
-                 + tr_peerGetPieceSpeed_Bps( p, now, TR_DOWN );
-        if( clientData )
+        l->speed = tr_peerGetPieceSpeed_Bps (p, now, TR_UP)
+                 + tr_peerGetPieceSpeed_Bps (p, now, TR_DOWN);
+        if (clientData)
             l->clientData = clientData[i];
     }
 
     /* sort 'em */
-    assert( n == ( l - lives ) );
-    qsort( lives, n, sizeof( struct peer_liveliness ), compare );
+    assert (n == (l - lives));
+    qsort (lives, n, sizeof (struct peer_liveliness), compare);
 
     /* build the peer array */
-    for( i=0, l=lives; i<n; ++i, ++l ) {
+    for (i=0, l=lives; i<n; ++i, ++l) {
         peers[i] = l->peer;
-        if( clientData )
+        if (clientData)
             clientData[i] = l->clientData;
     }
-    assert( n == ( l - lives ) );
+    assert (n == (l - lives));
 
     /* cleanup */
-    tr_free( lives );
+    tr_free (lives);
 }
 
 static void
-sortPeersByLiveliness( tr_peer ** peers, void ** clientData, int n, uint64_t now )
+sortPeersByLiveliness (tr_peer ** peers, void ** clientData, int n, uint64_t now)
 {
-    sortPeersByLivelinessImpl( peers, clientData, n, now, comparePeerLiveliness );
+    sortPeersByLivelinessImpl (peers, clientData, n, now, comparePeerLiveliness);
 }
 
 
 static void
-enforceTorrentPeerLimit( Torrent * t, uint64_t now )
+enforceTorrentPeerLimit (Torrent * t, uint64_t now)
 {
-    int n = tr_ptrArraySize( &t->peers );
-    const int max = tr_torrentGetPeerLimit( t->tor );
-    if( n > max )
+    int n = tr_ptrArraySize (&t->peers);
+    const int max = tr_torrentGetPeerLimit (t->tor);
+    if (n > max)
     {
-        void * base = tr_ptrArrayBase( &t->peers );
-        tr_peer ** peers = tr_memdup( base, n*sizeof( tr_peer* ) );
-        sortPeersByLiveliness( peers, NULL, n, now );
-        while( n > max )
-            closePeer( t, peers[--n] );
-        tr_free( peers );
+        void * base = tr_ptrArrayBase (&t->peers);
+        tr_peer ** peers = tr_memdup (base, n*sizeof (tr_peer*));
+        sortPeersByLiveliness (peers, NULL, n, now);
+        while (n > max)
+            closePeer (t, peers[--n]);
+        tr_free (peers);
     }
 }
 
 static void
-enforceSessionPeerLimit( tr_session * session, uint64_t now )
+enforceSessionPeerLimit (tr_session * session, uint64_t now)
 {
     int n = 0;
     tr_torrent * tor = NULL;
-    const int max = tr_sessionGetPeerLimit( session );
+    const int max = tr_sessionGetPeerLimit (session);
 
     /* count the total number of peers */
-    while(( tor = tr_torrentNext( session, tor )))
-        n += tr_ptrArraySize( &tor->torrentPeers->peers );
+    while ((tor = tr_torrentNext (session, tor)))
+        n += tr_ptrArraySize (&tor->torrentPeers->peers);
 
     /* if there are too many, prune out the worst */
-    if( n > max )
+    if (n > max)
     {
-        tr_peer ** peers = tr_new( tr_peer*, n );
-        Torrent ** torrents = tr_new( Torrent*, n );
+        tr_peer ** peers = tr_new (tr_peer*, n);
+        Torrent ** torrents = tr_new (Torrent*, n);
 
         /* populate the peer array */
         n = 0;
         tor = NULL;
-        while(( tor = tr_torrentNext( session, tor ))) {
+        while ((tor = tr_torrentNext (session, tor))) {
             int i;
             Torrent * t = tor->torrentPeers;
-            const int tn = tr_ptrArraySize( &t->peers );
-            for( i=0; i<tn; ++i, ++n ) {
-                peers[n] = tr_ptrArrayNth( &t->peers, i );
+            const int tn = tr_ptrArraySize (&t->peers);
+            for (i=0; i<tn; ++i, ++n) {
+                peers[n] = tr_ptrArrayNth (&t->peers, i);
                 torrents[n] = t;
             }
         }
 
         /* sort 'em */
-        sortPeersByLiveliness( peers, (void**)torrents, n, now );
+        sortPeersByLiveliness (peers, (void**)torrents, n, now);
 
         /* cull out the crappiest */
-        while( n-- > max )
-            closePeer( torrents[n], peers[n] );
+        while (n-- > max)
+            closePeer (torrents[n], peers[n]);
 
         /* cleanup */
-        tr_free( torrents );
-        tr_free( peers );
+        tr_free (torrents);
+        tr_free (peers);
     }
 }
 
-static void makeNewPeerConnections( tr_peerMgr * mgr, const int max );
+static void makeNewPeerConnections (tr_peerMgr * mgr, const int max);
 
 static void
-reconnectPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
+reconnectPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
 {
     tr_torrent * tor;
     tr_peerMgr * mgr = vmgr;
-    const time_t now_sec = tr_time( );
-    const uint64_t now_msec = tr_time_msec( );
+    const time_t now_sec = tr_time ();
+    const uint64_t now_msec = tr_time_msec ();
 
     /**
     ***  enforce the per-session and per-torrent peer limits
@@ -3532,23 +3536,23 @@ reconnectPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
 
     /* if we're over the per-torrent peer limits, cull some peers */
     tor = NULL;
-    while(( tor = tr_torrentNext( mgr->session, tor )))
-        if( tor->isRunning )
-            enforceTorrentPeerLimit( tor->torrentPeers, now_msec );
+    while ((tor = tr_torrentNext (mgr->session, tor)))
+        if (tor->isRunning)
+            enforceTorrentPeerLimit (tor->torrentPeers, now_msec);
 
     /* if we're over the per-session peer limits, cull some peers */
-    enforceSessionPeerLimit( mgr->session, now_msec );
+    enforceSessionPeerLimit (mgr->session, now_msec);
 
     /* remove crappy peers */
     tor = NULL;
-    while(( tor = tr_torrentNext( mgr->session, tor )))
-        if( !tor->torrentPeers->isRunning )
-            removeAllPeers( tor->torrentPeers );
+    while ((tor = tr_torrentNext (mgr->session, tor)))
+        if (!tor->torrentPeers->isRunning)
+            removeAllPeers (tor->torrentPeers);
         else
-            closeBadPeers( tor->torrentPeers, now_sec );
+            closeBadPeers (tor->torrentPeers, now_sec);
 
     /* try to make new peer connections */
-    makeNewPeerConnections( mgr, MAX_CONNECTIONS_PER_PULSE );
+    makeNewPeerConnections (mgr, MAX_CONNECTIONS_PER_PULSE);
 }
 
 /****
@@ -3558,86 +3562,86 @@ reconnectPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
 ****/
 
 static void
-pumpAllPeers( tr_peerMgr * mgr )
+pumpAllPeers (tr_peerMgr * mgr)
 {
     tr_torrent * tor = NULL;
 
-    while(( tor = tr_torrentNext( mgr->session, tor )))
+    while ((tor = tr_torrentNext (mgr->session, tor)))
     {
         int j;
         Torrent * t = tor->torrentPeers;
 
-        for( j=0; j<tr_ptrArraySize( &t->peers ); ++j )
+        for (j=0; j<tr_ptrArraySize (&t->peers); ++j)
         {
-            tr_peer * peer = tr_ptrArrayNth( &t->peers, j );
-            tr_peerMsgsPulse( peer->msgs );
+            tr_peer * peer = tr_ptrArrayNth (&t->peers, j);
+            tr_peerMsgsPulse (peer->msgs);
         }
     }
 }
 
 static void
-queuePulse( tr_session * session, tr_direction dir )
+queuePulse (tr_session * session, tr_direction dir)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isSession (session));
+    assert (tr_isDirection (dir));
 
-    if( tr_sessionGetQueueEnabled( session, dir ) )
+    if (tr_sessionGetQueueEnabled (session, dir))
     {
         int i;
-        const int n = tr_sessionCountQueueFreeSlots( session, dir );
-        for( i=0; i<n; i++ ) {
-            tr_torrent * tor = tr_sessionGetNextQueuedTorrent( session, dir );
-            if( tor != NULL ) {
-                tr_torrentStartNow( tor );
-                if( tor->queue_started_callback != NULL )
-                    (*tor->queue_started_callback)( tor, tor->queue_started_user_data );
+        const int n = tr_sessionCountQueueFreeSlots (session, dir);
+        for (i=0; i<n; i++) {
+            tr_torrent * tor = tr_sessionGetNextQueuedTorrent (session, dir);
+            if (tor != NULL) {
+                tr_torrentStartNow (tor);
+                if (tor->queue_started_callback != NULL)
+                  (*tor->queue_started_callback)(tor, tor->queue_started_user_data);
             }
         }
     }
 }
 
 static void
-bandwidthPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
+bandwidthPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
 {
     tr_torrent * tor;
     tr_peerMgr * mgr = vmgr;
     tr_session * session = mgr->session;
-    managerLock( mgr );
+    managerLock (mgr);
 
     /* FIXME: this next line probably isn't necessary... */
-    pumpAllPeers( mgr );
+    pumpAllPeers (mgr);
 
     /* allocate bandwidth to the peers */
-    tr_bandwidthAllocate( &session->bandwidth, TR_UP, BANDWIDTH_PERIOD_MSEC );
-    tr_bandwidthAllocate( &session->bandwidth, TR_DOWN, BANDWIDTH_PERIOD_MSEC );
+    tr_bandwidthAllocate (&session->bandwidth, TR_UP, BANDWIDTH_PERIOD_MSEC);
+    tr_bandwidthAllocate (&session->bandwidth, TR_DOWN, BANDWIDTH_PERIOD_MSEC);
 
     /* torrent upkeep */
     tor = NULL;
-    while(( tor = tr_torrentNext( session, tor )))
+    while ((tor = tr_torrentNext (session, tor)))
     {
         /* possibly stop torrents that have seeded enough */
-        tr_torrentCheckSeedLimit( tor );
+        tr_torrentCheckSeedLimit (tor);
 
         /* run the completeness check for any torrents that need it */
-        if( tor->torrentPeers->needsCompletenessCheck ) {
+        if (tor->torrentPeers->needsCompletenessCheck) {
             tor->torrentPeers->needsCompletenessCheck  = false;
-            tr_torrentRecheckCompleteness( tor );
+            tr_torrentRecheckCompleteness (tor);
         }
 
         /* stop torrents that are ready to stop, but couldn't be stopped
            earlier during the peer-io callback call chain */
-        if( tor->isStopping )
-            tr_torrentStop( tor );
+        if (tor->isStopping)
+            tr_torrentStop (tor);
     }
 
     /* pump the queues */
-    queuePulse( session, TR_UP );
-    queuePulse( session, TR_DOWN );
+    queuePulse (session, TR_UP);
+    queuePulse (session, TR_DOWN);
 
-    reconnectPulse( 0, 0, mgr );
+    reconnectPulse (0, 0, mgr);
 
-    tr_timerAddMsec( mgr->bandwidthTimer, BANDWIDTH_PERIOD_MSEC );
-    managerUnlock( mgr );
+    tr_timerAddMsec (mgr->bandwidthTimer, BANDWIDTH_PERIOD_MSEC);
+    managerUnlock (mgr);
 }
 
 /***
@@ -3645,80 +3649,80 @@ bandwidthPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
 ***/
 
 static int
-compareAtomPtrsByAddress( const void * va, const void *vb )
+compareAtomPtrsByAddress (const void * va, const void *vb)
 {
     const struct peer_atom * a = * (const struct peer_atom**) va;
     const struct peer_atom * b = * (const struct peer_atom**) vb;
 
-    assert( tr_isAtom( a ) );
-    assert( tr_isAtom( b ) );
+    assert (tr_isAtom (a));
+    assert (tr_isAtom (b));
 
-    return tr_address_compare( &a->addr, &b->addr );
+    return tr_address_compare (&a->addr, &b->addr);
 }
 
 /* best come first, worst go last */
 static int
-compareAtomPtrsByShelfDate( const void * va, const void *vb )
+compareAtomPtrsByShelfDate (const void * va, const void *vb)
 {
     time_t atime;
     time_t btime;
     const struct peer_atom * a = * (const struct peer_atom**) va;
     const struct peer_atom * b = * (const struct peer_atom**) vb;
     const int data_time_cutoff_secs = 60 * 60;
-    const time_t tr_now = tr_time( );
+    const time_t tr_now = tr_time ();
 
-    assert( tr_isAtom( a ) );
-    assert( tr_isAtom( b ) );
+    assert (tr_isAtom (a));
+    assert (tr_isAtom (b));
 
     /* primary key: the last piece data time *if* it was within the last hour */
-    atime = a->piece_data_time; if( atime + data_time_cutoff_secs < tr_now ) atime = 0;
-    btime = b->piece_data_time; if( btime + data_time_cutoff_secs < tr_now ) btime = 0;
-    if( atime != btime )
+    atime = a->piece_data_time; if (atime + data_time_cutoff_secs < tr_now) atime = 0;
+    btime = b->piece_data_time; if (btime + data_time_cutoff_secs < tr_now) btime = 0;
+    if (atime != btime)
         return atime > btime ? -1 : 1;
 
     /* secondary key: shelf date. */
-    if( a->shelf_date != b->shelf_date )
+    if (a->shelf_date != b->shelf_date)
         return a->shelf_date > b->shelf_date ? -1 : 1;
 
     return 0;
 }
 
 static int
-getMaxAtomCount( const tr_torrent * tor )
+getMaxAtomCount (const tr_torrent * tor)
 {
     const int n = tor->maxConnectedPeers;
     /* approximate fit of the old jump discontinuous function */
-    if( n >= 55 ) return     n + 150;
-    if( n >= 20 ) return 2 * n + 95;
+    if (n >= 55) return     n + 150;
+    if (n >= 20) return 2 * n + 95;
     return               4 * n + 55;
 }
 
 static void
-atomPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
+atomPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
 {
     tr_torrent * tor = NULL;
     tr_peerMgr * mgr = vmgr;
-    managerLock( mgr );
+    managerLock (mgr);
 
-    while(( tor = tr_torrentNext( mgr->session, tor )))
+    while ((tor = tr_torrentNext (mgr->session, tor)))
     {
         int atomCount;
         Torrent * t = tor->torrentPeers;
-        const int maxAtomCount = getMaxAtomCount( tor );
-        struct peer_atom ** atoms = (struct peer_atom**) tr_ptrArrayPeek( &t->pool, &atomCount );
+        const int maxAtomCount = getMaxAtomCount (tor);
+        struct peer_atom ** atoms = (struct peer_atom**) tr_ptrArrayPeek (&t->pool, &atomCount);
 
-        if( atomCount > maxAtomCount ) /* we've got too many atoms... time to prune */
+        if (atomCount > maxAtomCount) /* we've got too many atoms... time to prune */
         {
             int i;
             int keepCount = 0;
             int testCount = 0;
-            struct peer_atom ** keep = tr_new( struct peer_atom*, atomCount );
-            struct peer_atom ** test = tr_new( struct peer_atom*, atomCount );
+            struct peer_atom ** keep = tr_new (struct peer_atom*, atomCount);
+            struct peer_atom ** test = tr_new (struct peer_atom*, atomCount);
 
             /* keep the ones that are in use */
-            for( i=0; i<atomCount; ++i ) {
+            for (i=0; i<atomCount; ++i) {
                 struct peer_atom * atom = atoms[i];
-                if( peerIsInUse( t, atom ) )
+                if (peerIsInUse (t, atom))
                     keep[keepCount++] = atom;
                 else
                     test[testCount++] = atom;
@@ -3726,33 +3730,33 @@ atomPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
 
             /* if there's room, keep the best of what's left */
             i = 0;
-            if( keepCount < maxAtomCount ) {
-                qsort( test, testCount, sizeof( struct peer_atom * ), compareAtomPtrsByShelfDate );
-                while( i<testCount && keepCount<maxAtomCount )
+            if (keepCount < maxAtomCount) {
+                qsort (test, testCount, sizeof (struct peer_atom *), compareAtomPtrsByShelfDate);
+                while (i<testCount && keepCount<maxAtomCount)
                     keep[keepCount++] = test[i++];
             }
 
             /* free the culled atoms */
-            while( i<testCount )
-                tr_free( test[i++] );
+            while (i<testCount)
+                tr_free (test[i++]);
 
             /* rebuild Torrent.pool with what's left */
-            tr_ptrArrayDestruct( &t->pool, NULL );
+            tr_ptrArrayDestruct (&t->pool, NULL);
             t->pool = TR_PTR_ARRAY_INIT;
-            qsort( keep, keepCount, sizeof( struct peer_atom * ), compareAtomPtrsByAddress );
-            for( i=0; i<keepCount; ++i )
-                tr_ptrArrayAppend( &t->pool, keep[i] );
+            qsort (keep, keepCount, sizeof (struct peer_atom *), compareAtomPtrsByAddress);
+            for (i=0; i<keepCount; ++i)
+                tr_ptrArrayAppend (&t->pool, keep[i]);
 
-            tordbg( t, "max atom count is %d... pruned from %d to %d\n", maxAtomCount, atomCount, keepCount );
+            tordbg (t, "max atom count is %d... pruned from %d to %d\n", maxAtomCount, atomCount, keepCount);
 
             /* cleanup */
-            tr_free( test );
-            tr_free( keep );
+            tr_free (test);
+            tr_free (keep);
         }
     }
 
-    tr_timerAddMsec( mgr->atomTimer, ATOM_PERIOD_MSEC );
-    managerUnlock( mgr );
+    tr_timerAddMsec (mgr->atomTimer, ATOM_PERIOD_MSEC);
+    managerUnlock (mgr);
 }
 
 /***
@@ -3763,26 +3767,26 @@ atomPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
 
 /* is this atom someone that we'd want to initiate a connection to? */
 static bool
-isPeerCandidate( const tr_torrent * tor, struct peer_atom * atom, const time_t now )
+isPeerCandidate (const tr_torrent * tor, struct peer_atom * atom, const time_t now)
 {
     /* not if we're both seeds */
-    if( tr_torrentIsSeed( tor ) && atomIsSeed( atom ) )
+    if (tr_torrentIsSeed (tor) && atomIsSeed (atom))
         return false;
 
     /* not if we've already got a connection to them... */
-    if( peerIsInUse( tor->torrentPeers, atom ) )
+    if (peerIsInUse (tor->torrentPeers, atom))
         return false;
 
     /* not if we just tried them already */
-    if( ( now - atom->time ) < getReconnectIntervalSecs( atom, now ) )
+    if ((now - atom->time) < getReconnectIntervalSecs (atom, now))
         return false;
 
     /* not if they're blocklisted */
-    if( isAtomBlocklisted( tor->session, atom ) )
+    if (isAtomBlocklisted (tor->session, atom))
         return false;
 
     /* not if they're banned... */
-    if( atom->flags2 & MYFLAG_BANNED )
+    if (atom->flags2 & MYFLAG_BANNED)
         return false;
 
     return true;
@@ -3796,13 +3800,13 @@ struct peer_candidate
 };
 
 static bool
-torrentWasRecentlyStarted( const tr_torrent * tor )
+torrentWasRecentlyStarted (const tr_torrent * tor)
 {
-    return difftime( tr_time( ), tor->startDate ) < 120;
+    return difftime (tr_time (), tor->startDate) < 120;
 }
 
 static inline uint64_t
-addValToKey( uint64_t value, int width, uint64_t addme )
+addValToKey (uint64_t value, int width, uint64_t addme)
 {
     value = (value << (uint64_t)width);
     value |= addme;
@@ -3811,7 +3815,7 @@ addValToKey( uint64_t value, int width, uint64_t addme )
 
 /* smaller value is better */
 static uint64_t
-getPeerCandidateScore( const tr_torrent * tor, const struct peer_atom * atom, uint8_t salt  )
+getPeerCandidateScore (const tr_torrent * tor, const struct peer_atom * atom, uint8_t salt)
 {
     uint64_t i;
     uint64_t score = 0;
@@ -3819,72 +3823,72 @@ getPeerCandidateScore( const tr_torrent * tor, const struct peer_atom * atom, ui
 
     /* prefer peers we've connected to, or never tried, over peers we failed to connect to. */
     i = failed ? 1 : 0;
-    score = addValToKey( score, 1, i );
+    score = addValToKey (score, 1, i);
 
     /* prefer the one we attempted least recently (to cycle through all peers) */
     i = atom->lastConnectionAttemptAt;
-    score = addValToKey( score, 32, i );
+    score = addValToKey (score, 32, i);
 
     /* prefer peers belonging to a torrent of a higher priority */
-    switch( tr_torrentGetPriority( tor ) ) {
+    switch (tr_torrentGetPriority (tor)) {
         case TR_PRI_HIGH:    i = 0; break;
         case TR_PRI_NORMAL:  i = 1; break;
         case TR_PRI_LOW:     i = 2; break;
     }
-    score = addValToKey( score, 4, i );
+    score = addValToKey (score, 4, i);
 
     /* prefer recently-started torrents */
-    i = torrentWasRecentlyStarted( tor ) ? 0 : 1;
-    score = addValToKey( score, 1, i );
+    i = torrentWasRecentlyStarted (tor) ? 0 : 1;
+    score = addValToKey (score, 1, i);
 
     /* prefer torrents we're downloading with */
-    i = tr_torrentIsSeed( tor ) ? 1 : 0;
-    score = addValToKey( score, 1, i );
+    i = tr_torrentIsSeed (tor) ? 1 : 0;
+    score = addValToKey (score, 1, i);
 
     /* prefer peers that are known to be connectible */
-    i = ( atom->flags & ADDED_F_CONNECTABLE ) ? 0 : 1;
-    score = addValToKey( score, 1, i );
+    i = (atom->flags & ADDED_F_CONNECTABLE) ? 0 : 1;
+    score = addValToKey (score, 1, i);
 
     /* prefer peers that we might have a chance of uploading to...
        so lower seed probability is better */
-    if( atom->seedProbability == 100 ) i = 101;
-    else if( atom->seedProbability == -1 ) i = 100;
+    if (atom->seedProbability == 100) i = 101;
+    else if (atom->seedProbability == -1) i = 100;
     else i = atom->seedProbability;
-    score = addValToKey( score, 8, i );
+    score = addValToKey (score, 8, i);
 
     /* Prefer peers that we got from more trusted sources.
      * lower `fromBest' values indicate more trusted sources */
-    score = addValToKey( score, 4, atom->fromBest );
+    score = addValToKey (score, 4, atom->fromBest);
 
     /* salt */
-    score = addValToKey( score, 8, salt );
+    score = addValToKey (score, 8, salt);
 
     return score;
 }
 
 #ifndef NDEBUG
 static int
-checkPartition( const struct peer_candidate * candidates, int left, int right, uint64_t pivotScore, int storeIndex )
+checkPartition (const struct peer_candidate * candidates, int left, int right, uint64_t pivotScore, int storeIndex)
 {
     int i;
 
-    assert( storeIndex >= left );
-    assert( storeIndex <= right );
-    assert( candidates[storeIndex].score == pivotScore );
+    assert (storeIndex >= left);
+    assert (storeIndex <= right);
+    assert (candidates[storeIndex].score == pivotScore);
 
-    for( i=left; i<storeIndex; ++i )
-        assert( candidates[i].score < pivotScore );
-    for( i=storeIndex+1; i<=right; ++i )
-        assert( candidates[i].score >= pivotScore );
+    for (i=left; i<storeIndex; ++i)
+        assert (candidates[i].score < pivotScore);
+    for (i=storeIndex+1; i<=right; ++i)
+        assert (candidates[i].score >= pivotScore);
 
     return true;
 }
 #endif
 
-/* Helper to selectBestCandidates().
+/* Helper to selectBestCandidates ().
  * Adapted from http://en.wikipedia.org/wiki/Selection_algorithm */
 static int
-partitionPeerCandidates( struct peer_candidate * candidates, int left, int right, int pivotIndex )
+partitionPeerCandidates (struct peer_candidate * candidates, int left, int right, int pivotIndex)
 {
     int i;
     int storeIndex;
@@ -3897,9 +3901,9 @@ partitionPeerCandidates( struct peer_candidate * candidates, int left, int right
     candidates[pivotIndex] = tmp;
 
     storeIndex = left;
-    for( i=left; i<=right; ++i )
+    for (i=left; i<=right; ++i)
     {
-        if( candidates[i].score < pivotValue.score )
+        if (candidates[i].score < pivotValue.score)
         {
             tmp = candidates[storeIndex];
             candidates[storeIndex] = candidates[i];
@@ -3914,45 +3918,45 @@ partitionPeerCandidates( struct peer_candidate * candidates, int left, int right
     candidates[storeIndex] = tmp;
 
     /* sanity check */
-    assert( checkPartition( candidates, left, right, pivotValue.score, storeIndex ) );
+    assert (checkPartition (candidates, left, right, pivotValue.score, storeIndex));
 
     return storeIndex;
 }
 
 /* Adapted from http://en.wikipedia.org/wiki/Selection_algorithm */
 static void
-selectPeerCandidates( struct peer_candidate * candidates, int left, int right, int k )
+selectPeerCandidates (struct peer_candidate * candidates, int left, int right, int k)
 {
-    if( right > left )
+    if (right > left)
     {
         const int pivotIndex = left + (right-left)/2;
 
-        int pivotNewIndex = partitionPeerCandidates( candidates, left, right, pivotIndex );
+        int pivotNewIndex = partitionPeerCandidates (candidates, left, right, pivotIndex);
 
-        if( pivotNewIndex > left + k ) /* new condition */
-            selectPeerCandidates( candidates, left, pivotNewIndex-1, k );
-        else if( pivotNewIndex < left + k )
-            selectPeerCandidates( candidates, pivotNewIndex+1, right, k+left-pivotNewIndex-1 );
+        if (pivotNewIndex > left + k) /* new condition */
+            selectPeerCandidates (candidates, left, pivotNewIndex-1, k);
+        else if (pivotNewIndex < left + k)
+            selectPeerCandidates (candidates, pivotNewIndex+1, right, k+left-pivotNewIndex-1);
     }
 }
 
 #ifndef NDEBUG
 static bool
-checkBestScoresComeFirst( const struct peer_candidate * candidates, int n, int k )
+checkBestScoresComeFirst (const struct peer_candidate * candidates, int n, int k)
 {
     int i;
     uint64_t worstFirstScore = 0;
-    const int x = MIN( n, k ) - 1;
+    const int x = MIN (n, k) - 1;
 
-    for( i=0; i<x; i++ )
-        if( worstFirstScore < candidates[i].score )
+    for (i=0; i<x; i++)
+        if (worstFirstScore < candidates[i].score)
             worstFirstScore = candidates[i].score;
 
-    for( i=0; i<x; i++ )
-        assert( candidates[i].score <= worstFirstScore );
+    for (i=0; i<x; i++)
+        assert (candidates[i].score <= worstFirstScore);
 
-    for( i=x+1; i<n; i++ )
-        assert( candidates[i].score >= worstFirstScore );
+    for (i=x+1; i<n; i++)
+        assert (candidates[i].score >= worstFirstScore);
 
     return true;
 }
@@ -3960,125 +3964,125 @@ checkBestScoresComeFirst( const struct peer_candidate * candidates, int n, int k
 
 /** @return an array of all the atoms we might want to connect to */
 static struct peer_candidate*
-getPeerCandidates( tr_session * session, int * candidateCount, int max )
+getPeerCandidates (tr_session * session, int * candidateCount, int max)
 {
     int atomCount;
     int peerCount;
     tr_torrent * tor;
     struct peer_candidate * candidates;
     struct peer_candidate * walk;
-    const time_t now = tr_time( );
-    const uint64_t now_msec = tr_time_msec( );
+    const time_t now = tr_time ();
+    const uint64_t now_msec = tr_time_msec ();
     /* leave 5% of connection slots for incoming connections -- ticket #2609 */
-    const int maxCandidates = tr_sessionGetPeerLimit( session ) * 0.95;
+    const int maxCandidates = tr_sessionGetPeerLimit (session) * 0.95;
 
     /* count how many peers and atoms we've got */
     tor= NULL;
     atomCount = 0;
     peerCount = 0;
-    while(( tor = tr_torrentNext( session, tor ))) {
-        atomCount += tr_ptrArraySize( &tor->torrentPeers->pool );
-        peerCount += tr_ptrArraySize( &tor->torrentPeers->peers );
+    while ((tor = tr_torrentNext (session, tor))) {
+        atomCount += tr_ptrArraySize (&tor->torrentPeers->pool);
+        peerCount += tr_ptrArraySize (&tor->torrentPeers->peers);
     }
 
     /* don't start any new handshakes if we're full up */
-    if( maxCandidates <= peerCount ) {
+    if (maxCandidates <= peerCount) {
         *candidateCount = 0;
         return NULL;
     }
 
     /* allocate an array of candidates */
-    walk = candidates = tr_new( struct peer_candidate, atomCount );
+    walk = candidates = tr_new (struct peer_candidate, atomCount);
 
     /* populate the candidate array */
     tor = NULL;
-    while(( tor = tr_torrentNext( session, tor )))
+    while ((tor = tr_torrentNext (session, tor)))
     {
         int i, nAtoms;
         struct peer_atom ** atoms;
 
-        if( !tor->torrentPeers->isRunning )
+        if (!tor->torrentPeers->isRunning)
             continue;
 
         /* if we've already got enough peers in this torrent... */
-        if( tr_torrentGetPeerLimit( tor ) <= tr_ptrArraySize( &tor->torrentPeers->peers ) )
+        if (tr_torrentGetPeerLimit (tor) <= tr_ptrArraySize (&tor->torrentPeers->peers))
             continue;
 
         /* if we've already got enough speed in this torrent... */
-        if( tr_torrentIsSeed( tor ) && isBandwidthMaxedOut( &tor->bandwidth, now_msec, TR_UP ) )
+        if (tr_torrentIsSeed (tor) && isBandwidthMaxedOut (&tor->bandwidth, now_msec, TR_UP))
             continue;
 
-        atoms = (struct peer_atom**) tr_ptrArrayPeek( &tor->torrentPeers->pool, &nAtoms );
-        for( i=0; i<nAtoms; ++i )
+        atoms = (struct peer_atom**) tr_ptrArrayPeek (&tor->torrentPeers->pool, &nAtoms);
+        for (i=0; i<nAtoms; ++i)
         {
             struct peer_atom * atom = atoms[i];
 
-            if( isPeerCandidate( tor, atom, now ) )
+            if (isPeerCandidate (tor, atom, now))
             {
-                const uint8_t salt = tr_cryptoWeakRandInt( 1024 );
+                const uint8_t salt = tr_cryptoWeakRandInt (1024);
                 walk->tor = tor;
                 walk->atom = atom;
-                walk->score = getPeerCandidateScore( tor, atom, salt );
+                walk->score = getPeerCandidateScore (tor, atom, salt);
                 ++walk;
             }
         }
     }
 
     *candidateCount = walk - candidates;
-    if( walk != candidates )
-        selectPeerCandidates( candidates, 0, (walk-candidates)-1, max );
+    if (walk != candidates)
+        selectPeerCandidates (candidates, 0, (walk-candidates)-1, max);
 
-    assert( checkBestScoresComeFirst( candidates, *candidateCount, max ) );
+    assert (checkBestScoresComeFirst (candidates, *candidateCount, max));
 
     return candidates;
 }
 
 static void
-initiateConnection( tr_peerMgr * mgr, Torrent * t, struct peer_atom * atom )
+initiateConnection (tr_peerMgr * mgr, Torrent * t, struct peer_atom * atom)
 {
     tr_peerIo * io;
-    const time_t now = tr_time( );
-    bool utp = tr_sessionIsUTPEnabled(mgr->session) && !atom->utp_failed;
+    const time_t now = tr_time ();
+    bool utp = tr_sessionIsUTPEnabled (mgr->session) && !atom->utp_failed;
 
-    if( atom->fromFirst == TR_PEER_FROM_PEX )
+    if (atom->fromFirst == TR_PEER_FROM_PEX)
         /* PEX has explicit signalling for uTP support.  If an atom
            originally came from PEX and doesn't have the uTP flag, skip the
            uTP connection attempt.  Are we being optimistic here? */
         utp = utp && (atom->flags & ADDED_F_UTP_FLAGS);
 
-    tordbg( t, "Starting an OUTGOING%s connection with %s",
+    tordbg (t, "Starting an OUTGOING%s connection with %s",
             utp ? " µTP" : "",
-            tr_atomAddrStr( atom ) );
+            tr_atomAddrStr (atom));
 
-    io = tr_peerIoNewOutgoing( mgr->session,
+    io = tr_peerIoNewOutgoing (mgr->session,
                                &mgr->session->bandwidth,
                                &atom->addr,
                                atom->port,
                                t->tor->info.hash,
                                t->tor->completeness == TR_SEED,
-                               utp );
+                               utp);
 
-    if( io == NULL )
+    if (io == NULL)
     {
-        tordbg( t, "peerIo not created; marking peer %s as unreachable",
-                tr_atomAddrStr( atom ) );
+        tordbg (t, "peerIo not created; marking peer %s as unreachable",
+                tr_atomAddrStr (atom));
         atom->flags2 |= MYFLAG_UNREACHABLE;
         atom->numFails++;
     }
     else
     {
-        tr_handshake * handshake = tr_handshakeNew( io,
+        tr_handshake * handshake = tr_handshakeNew (io,
                                                     mgr->session->encryptionMode,
                                                     myHandshakeDoneCB,
-                                                    mgr );
+                                                    mgr);
 
-        assert( tr_peerIoGetTorrentHash( io ) );
+        assert (tr_peerIoGetTorrentHash (io));
 
-        tr_peerIoUnref( io ); /* balanced by the initial ref
-                                 in tr_peerIoNewOutgoing() */
+        tr_peerIoUnref (io); /* balanced by the initial ref
+                                 in tr_peerIoNewOutgoing () */
 
-        tr_ptrArrayInsertSorted( &t->outgoingHandshakes, handshake,
-                                 handshakeCompare );
+        tr_ptrArrayInsertSorted (&t->outgoingHandshakes, handshake,
+                                 handshakeCompare);
     }
 
     atom->lastConnectionAttemptAt = now;
@@ -4086,30 +4090,30 @@ initiateConnection( tr_peerMgr * mgr, Torrent * t, struct peer_atom * atom )
 }
 
 static void
-initiateCandidateConnection( tr_peerMgr * mgr, struct peer_candidate * c )
+initiateCandidateConnection (tr_peerMgr * mgr, struct peer_candidate * c)
 {
 #if 0
-    fprintf( stderr, "Starting an OUTGOING connection with %s - [%s] seedProbability==%d; %s, %s\n",
-             tr_atomAddrStr( c->atom ),
-             tr_torrentName( c->tor ),
-             (int)c->atom->seedProbability,
-             tr_torrentIsPrivate( c->tor ) ? "private" : "public",
-             tr_torrentIsSeed( c->tor ) ? "seed" : "downloader" );
+    fprintf (stderr, "Starting an OUTGOING connection with %s - [%s] seedProbability==%d; %s, %s\n",
+             tr_atomAddrStr (c->atom),
+             tr_torrentName (c->tor),
+           (int)c->atom->seedProbability,
+             tr_torrentIsPrivate (c->tor) ? "private" : "public",
+             tr_torrentIsSeed (c->tor) ? "seed" : "downloader");
 #endif
 
-    initiateConnection( mgr, c->tor->torrentPeers, c->atom );
+    initiateConnection (mgr, c->tor->torrentPeers, c->atom);
 }
 
 static void
-makeNewPeerConnections( struct tr_peerMgr * mgr, const int max )
+makeNewPeerConnections (struct tr_peerMgr * mgr, const int max)
 {
     int i, n;
     struct peer_candidate * candidates;
 
-    candidates = getPeerCandidates( mgr->session, &n, max );
+    candidates = getPeerCandidates (mgr->session, &n, max);
 
-    for( i=0; i<n && i<max; ++i )
-        initiateCandidateConnection( mgr, &candidates[i] );
+    for (i=0; i<n && i<max; ++i)
+        initiateCandidateConnection (mgr, &candidates[i]);
 
-    tr_free( candidates );
+    tr_free (candidates);
 }
diff --git a/libtransmission/peer-mgr.h b/libtransmission/peer-mgr.h
index 16caa2092..6ebf5b5bd 100644
--- a/libtransmission/peer-mgr.h
+++ b/libtransmission/peer-mgr.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -130,79 +130,79 @@ typedef struct tr_peer
 }
 tr_peer;
 
-void tr_peerConstruct( struct tr_peer * peer );
+void tr_peerConstruct (struct tr_peer * peer);
 
-void tr_peerDestruct( tr_torrent * tor, struct tr_peer * peer );
+void tr_peerDestruct (tr_torrent * tor, struct tr_peer * peer);
 
 
 static inline bool
-tr_isPex( const tr_pex * pex )
+tr_isPex (const tr_pex * pex)
 {
-    return pex && tr_address_is_valid( &pex->addr );
+    return pex && tr_address_is_valid (&pex->addr);
 }
 
-const tr_address * tr_peerAddress( const tr_peer * );
+const tr_address * tr_peerAddress (const tr_peer *);
 
-int tr_pexCompare( const void * a, const void * b );
+int tr_pexCompare (const void * a, const void * b);
 
-tr_peerMgr* tr_peerMgrNew( tr_session * );
+tr_peerMgr* tr_peerMgrNew (tr_session *);
 
-void tr_peerMgrFree( tr_peerMgr * manager );
+void tr_peerMgrFree (tr_peerMgr * manager);
 
-bool tr_peerMgrPeerIsSeed( const tr_torrent * tor,
-                              const tr_address * addr );
+bool tr_peerMgrPeerIsSeed (const tr_torrent * tor,
+                              const tr_address * addr);
 
-void tr_peerMgrSetUtpSupported( tr_torrent       * tor,
-                                const tr_address * addr );
+void tr_peerMgrSetUtpSupported (tr_torrent       * tor,
+                                const tr_address * addr);
 
-void tr_peerMgrSetUtpFailed( tr_torrent *tor,
+void tr_peerMgrSetUtpFailed (tr_torrent *tor,
                              const tr_address *addr,
-                             bool failed );
+                             bool failed);
 
-void tr_peerMgrGetNextRequests( tr_torrent          * torrent,
+void tr_peerMgrGetNextRequests (tr_torrent          * torrent,
                                 tr_peer             * peer,
                                 int                   numwant,
                                 tr_block_index_t    * setme,
                                 int                 * numgot,
-                                bool                  get_intervals );
+                                bool                  get_intervals);
 
-bool tr_peerMgrDidPeerRequest( const tr_torrent  * torrent,
+bool tr_peerMgrDidPeerRequest (const tr_torrent  * torrent,
                                const tr_peer     * peer,
-                               tr_block_index_t    block );
+                               tr_block_index_t    block);
 
-void tr_peerMgrRebuildRequests( tr_torrent * torrent );
+void tr_peerMgrRebuildRequests (tr_torrent * torrent);
 
-void tr_peerMgrAddIncoming( tr_peerMgr  * manager,
+void tr_peerMgrAddIncoming (tr_peerMgr  * manager,
                             tr_address  * addr,
                             tr_port       port,
                             int           socket,
-                            struct UTPSocket *utp_socket );
+                            struct UTPSocket *utp_socket);
 
-tr_pex * tr_peerMgrCompactToPex( const void    * compact,
+tr_pex * tr_peerMgrCompactToPex (const void    * compact,
                                  size_t          compactLen,
                                  const uint8_t * added_f,
                                  size_t          added_f_len,
-                                 size_t        * setme_pex_count );
+                                 size_t        * setme_pex_count);
 
-tr_pex * tr_peerMgrCompact6ToPex( const void    * compact,
+tr_pex * tr_peerMgrCompact6ToPex (const void    * compact,
                                   size_t          compactLen,
                                   const uint8_t * added_f,
                                   size_t          added_f_len,
-                                  size_t        * pexCount );
+                                  size_t        * pexCount);
 
-tr_pex * tr_peerMgrArrayToPex( const void * array,
+tr_pex * tr_peerMgrArrayToPex (const void * array,
                                size_t       arrayLen,
-                               size_t      * setme_pex_count );
+                               size_t      * setme_pex_count);
 
 /**
  * @param seedProbability [0..100] for likelihood that the peer is a seed; -1 for unknown
  */
-void tr_peerMgrAddPex( tr_torrent     * tor,
+void tr_peerMgrAddPex (tr_torrent     * tor,
                        uint8_t          from,
                        const tr_pex   * pex,
-                       int8_t           seedProbability );
+                       int8_t           seedProbability);
 
-void tr_peerMgrMarkAllAsSeeds( tr_torrent * tor );
+void tr_peerMgrMarkAllAsSeeds (tr_torrent * tor);
 
 enum
 {
@@ -210,49 +210,49 @@ enum
     TR_PEERS_INTERESTING
 };
 
-int  tr_peerMgrGetPeers( tr_torrent      * tor,
+int  tr_peerMgrGetPeers (tr_torrent      * tor,
                          tr_pex         ** setme_pex,
                          uint8_t           address_type,
                          uint8_t           peer_list_mode,
-                         int               max_peer_count );
+                         int               max_peer_count);
 
-void tr_peerMgrStartTorrent( tr_torrent * tor );
+void tr_peerMgrStartTorrent (tr_torrent * tor);
 
-void tr_peerMgrStopTorrent( tr_torrent * tor );
+void tr_peerMgrStopTorrent (tr_torrent * tor);
 
-void tr_peerMgrAddTorrent( tr_peerMgr         * manager,
-                           struct tr_torrent  * tor );
+void tr_peerMgrAddTorrent (tr_peerMgr         * manager,
+                           struct tr_torrent  * tor);
 
-void tr_peerMgrRemoveTorrent( tr_torrent * tor );
+void tr_peerMgrRemoveTorrent (tr_torrent * tor);
 
-void tr_peerMgrTorrentAvailability( const tr_torrent * tor,
+void tr_peerMgrTorrentAvailability (const tr_torrent * tor,
                                     int8_t           * tab,
-                                    unsigned int       tabCount );
+                                    unsigned int       tabCount);
 
-uint64_t tr_peerMgrGetDesiredAvailable( const tr_torrent * tor );
+uint64_t tr_peerMgrGetDesiredAvailable (const tr_torrent * tor);
 
-void tr_peerMgrOnTorrentGotMetainfo( tr_torrent * tor );
+void tr_peerMgrOnTorrentGotMetainfo (tr_torrent * tor);
 
-void tr_peerMgrOnBlocklistChanged( tr_peerMgr * manager );
+void tr_peerMgrOnBlocklistChanged (tr_peerMgr * manager);
 
-void tr_peerMgrTorrentStats( tr_torrent * tor,
+void tr_peerMgrTorrentStats (tr_torrent * tor,
                              int * setmePeersConnected,
                              int * setmeWebseedsSendingToUs,
                              int * setmePeersSendingToUs,
                              int * setmePeersGettingFromUs,
-                             int * setmePeersFrom ); /* TR_PEER_FROM__MAX */
+                             int * setmePeersFrom); /* TR_PEER_FROM__MAX */
 
-struct tr_peer_stat* tr_peerMgrPeerStats( const tr_torrent * tor,
-                                          int              * setmeCount );
+struct tr_peer_stat* tr_peerMgrPeerStats (const tr_torrent * tor,
+                                          int              * setmeCount);
 
-double* tr_peerMgrWebSpeeds_KBps( const tr_torrent * tor );
+double* tr_peerMgrWebSpeeds_KBps (const tr_torrent * tor);
 
 
-unsigned int tr_peerGetPieceSpeed_Bps( const tr_peer    * peer,
+unsigned int tr_peerGetPieceSpeed_Bps (const tr_peer    * peer,
                                        uint64_t           now,
-                                       tr_direction       direction );
+                                       tr_direction       direction);
 
-void tr_peerMgrClearInterest( tr_torrent * tor );
+void tr_peerMgrClearInterest (tr_torrent * tor);
 
 /* @} */
 
diff --git a/libtransmission/peer-msgs-test.c b/libtransmission/peer-msgs-test.c
index eef8ce8b7..edada0623 100644
--- a/libtransmission/peer-msgs-test.c
+++ b/libtransmission/peer-msgs-test.c
@@ -7,7 +7,7 @@
 #include "libtransmission-test.h"
 
 int
-main( void )
+main (void)
 {
 #if 0
     uint32_t           i;
@@ -19,21 +19,21 @@ main( void )
     tr_piece_index_t pieces[] = { 1059, 431, 808, 1217, 287, 376, 1188, 353, 508 };
     tr_piece_index_t buf[16];
 
-    for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
+    for (i = 0; i < SHA_DIGEST_LENGTH; ++i)
         infohash[i] = 0xaa;
-    tr_address_from_string( &addr, "80.4.4.200" );
+    tr_address_from_string (&addr, "80.4.4.200");
 
     numwant = 7;
-    numgot = tr_generateAllowedSet( buf, numwant, pieceCount, infohash, &addr );
-    check( numgot == numwant );
-    for( i=0; i<numgot; ++i )
-        check( buf[i] == pieces[i] );
+    numgot = tr_generateAllowedSet (buf, numwant, pieceCount, infohash, &addr);
+    check (numgot == numwant);
+    for (i=0; i<numgot; ++i)
+        check (buf[i] == pieces[i]);
 
     numwant = 9;
-    numgot = tr_generateAllowedSet( buf, numwant, pieceCount, infohash, &addr );
-    check( numgot == numwant );
-    for( i=0; i<numgot; ++i )
-        check( buf[i] == pieces[i] );
+    numgot = tr_generateAllowedSet (buf, numwant, pieceCount, infohash, &addr);
+    check (numgot == numwant);
+    for (i=0; i<numgot; ++i)
+        check (buf[i] == pieces[i]);
 #endif
 
     return 0;
diff --git a/libtransmission/peer-msgs.c b/libtransmission/peer-msgs.c
index fb91164c5..ae3087b5a 100644
--- a/libtransmission/peer-msgs.c
+++ b/libtransmission/peer-msgs.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -24,7 +24,7 @@
 #include "bencode.h"
 #include "cache.h"
 #include "completion.h"
-#include "crypto.h" /* tr_sha1() */
+#include "crypto.h" /* tr_sha1 () */
 #include "peer-io.h"
 #include "peer-mgr.h"
 #include "peer-msgs.h"
@@ -72,7 +72,7 @@ enum
     /* idle seconds before we send a keepalive */
     KEEPALIVE_INTERVAL_SECS = 100,
 
-    PEX_INTERVAL_SECS       = 90, /* sec between sendPex() calls */
+    PEX_INTERVAL_SECS       = 90, /* sec between sendPex () calls */
 
     REQQ                    = 512,
 
@@ -112,13 +112,13 @@ struct peer_request
 };
 
 static void
-blockToReq( const tr_torrent     * tor,
+blockToReq (const tr_torrent     * tor,
             tr_block_index_t       block,
-            struct peer_request  * setme )
+            struct peer_request  * setme)
 {
-    tr_torrentGetBlockLocation( tor, block, &setme->index,
+    tr_torrentGetBlockLocation (tor, block, &setme->index,
                                             &setme->offset,
-                                            &setme->length );
+                                            &setme->length);
 }
 
 /**
@@ -217,7 +217,7 @@ struct tr_peermsgs
 **/
 
 static inline tr_session*
-getSession( struct tr_peermsgs * msgs )
+getSession (struct tr_peermsgs * msgs)
 {
     return msgs->torrent->session;
 }
@@ -227,197 +227,199 @@ getSession( struct tr_peermsgs * msgs )
 **/
 
 static void
-myDebug( const char * file, int line,
+myDebug (const char * file, int line,
          const struct tr_peermsgs * msgs,
-         const char * fmt, ... )
+         const char * fmt, ...)
 {
-    FILE * fp = tr_getLog( );
+    FILE * fp = tr_getLog ();
 
-    if( fp )
+    if (fp)
     {
         va_list           args;
         char              timestr[64];
-        struct evbuffer * buf = evbuffer_new( );
-        char *            base = tr_basename( file );
+        struct evbuffer * buf = evbuffer_new ();
+        char *            base = tr_basename (file);
         char *            message;
 
-        evbuffer_add_printf( buf, "[%s] %s - %s [%s]: ",
-                             tr_getLogTimeStr( timestr, sizeof( timestr ) ),
-                             tr_torrentName( msgs->torrent ),
-                             tr_peerIoGetAddrStr( msgs->peer->io ),
-                             msgs->peer->client );
-        va_start( args, fmt );
-        evbuffer_add_vprintf( buf, fmt, args );
-        va_end( args );
-        evbuffer_add_printf( buf, " (%s:%d)\n", base, line );
-
-        message = evbuffer_free_to_str( buf );
-        fputs( message, fp );
-
-        tr_free( base );
-        tr_free( message );
+        evbuffer_add_printf (buf, "[%s] %s - %s [%s]: ",
+                             tr_getLogTimeStr (timestr, sizeof (timestr)),
+                             tr_torrentName (msgs->torrent),
+                             tr_peerIoGetAddrStr (msgs->peer->io),
+                             msgs->peer->client);
+        va_start (args, fmt);
+        evbuffer_add_vprintf (buf, fmt, args);
+        va_end (args);
+        evbuffer_add_printf (buf, " (%s:%d)\n", base, line);
+
+        message = evbuffer_free_to_str (buf);
+        fputs (message, fp);
+
+        tr_free (base);
+        tr_free (message);
     }
 }
 
-#define dbgmsg( msgs, ... ) \
-    do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            myDebug( __FILE__, __LINE__, msgs, __VA_ARGS__ ); \
-    } while( 0 )
+#define dbgmsg(msgs, ...) \
+  do \
+    { \
+      if (tr_deepLoggingIsActive ()) \
+        myDebug (__FILE__, __LINE__, msgs, __VA_ARGS__); \
+    } \
+  while (0)
 
 /**
 ***
 **/
 
 static void
-pokeBatchPeriod( tr_peermsgs * msgs, int interval )
+pokeBatchPeriod (tr_peermsgs * msgs, int interval)
 {
-    if( msgs->outMessagesBatchPeriod > interval )
+    if (msgs->outMessagesBatchPeriod > interval)
     {
         msgs->outMessagesBatchPeriod = interval;
-        dbgmsg( msgs, "lowering batch interval to %d seconds", interval );
+        dbgmsg (msgs, "lowering batch interval to %d seconds", interval);
     }
 }
 
 static void
-dbgOutMessageLen( tr_peermsgs * msgs )
+dbgOutMessageLen (tr_peermsgs * msgs)
 {
-    dbgmsg( msgs, "outMessage size is now %zu", evbuffer_get_length( msgs->outMessages ) );
+    dbgmsg (msgs, "outMessage size is now %zu", evbuffer_get_length (msgs->outMessages));
 }
 
 static void
-protocolSendReject( tr_peermsgs * msgs, const struct peer_request * req )
+protocolSendReject (tr_peermsgs * msgs, const struct peer_request * req)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    assert( tr_peerIoSupportsFEXT( msgs->peer->io ) );
+    assert (tr_peerIoSupportsFEXT (msgs->peer->io));
 
-    evbuffer_add_uint32( out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
-    evbuffer_add_uint8 ( out, BT_FEXT_REJECT );
-    evbuffer_add_uint32( out, req->index );
-    evbuffer_add_uint32( out, req->offset );
-    evbuffer_add_uint32( out, req->length );
+    evbuffer_add_uint32 (out, sizeof (uint8_t) + 3 * sizeof (uint32_t));
+    evbuffer_add_uint8 (out, BT_FEXT_REJECT);
+    evbuffer_add_uint32 (out, req->index);
+    evbuffer_add_uint32 (out, req->offset);
+    evbuffer_add_uint32 (out, req->length);
 
-    dbgmsg( msgs, "rejecting %u:%u->%u...", req->index, req->offset, req->length );
-    dbgOutMessageLen( msgs );
+    dbgmsg (msgs, "rejecting %u:%u->%u...", req->index, req->offset, req->length);
+    dbgOutMessageLen (msgs);
 }
 
 static void
-protocolSendRequest( tr_peermsgs * msgs, const struct peer_request * req )
+protocolSendRequest (tr_peermsgs * msgs, const struct peer_request * req)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    evbuffer_add_uint32( out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
-    evbuffer_add_uint8 ( out, BT_REQUEST );
-    evbuffer_add_uint32( out, req->index );
-    evbuffer_add_uint32( out, req->offset );
-    evbuffer_add_uint32( out, req->length );
+    evbuffer_add_uint32 (out, sizeof (uint8_t) + 3 * sizeof (uint32_t));
+    evbuffer_add_uint8 (out, BT_REQUEST);
+    evbuffer_add_uint32 (out, req->index);
+    evbuffer_add_uint32 (out, req->offset);
+    evbuffer_add_uint32 (out, req->length);
 
-    dbgmsg( msgs, "requesting %u:%u->%u...", req->index, req->offset, req->length );
-    dbgOutMessageLen( msgs );
-    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
+    dbgmsg (msgs, "requesting %u:%u->%u...", req->index, req->offset, req->length);
+    dbgOutMessageLen (msgs);
+    pokeBatchPeriod (msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS);
 }
 
 static void
-protocolSendCancel( tr_peermsgs * msgs, const struct peer_request * req )
+protocolSendCancel (tr_peermsgs * msgs, const struct peer_request * req)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    evbuffer_add_uint32( out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
-    evbuffer_add_uint8 ( out, BT_CANCEL );
-    evbuffer_add_uint32( out, req->index );
-    evbuffer_add_uint32( out, req->offset );
-    evbuffer_add_uint32( out, req->length );
+    evbuffer_add_uint32 (out, sizeof (uint8_t) + 3 * sizeof (uint32_t));
+    evbuffer_add_uint8 (out, BT_CANCEL);
+    evbuffer_add_uint32 (out, req->index);
+    evbuffer_add_uint32 (out, req->offset);
+    evbuffer_add_uint32 (out, req->length);
 
-    dbgmsg( msgs, "cancelling %u:%u->%u...", req->index, req->offset, req->length );
-    dbgOutMessageLen( msgs );
-    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
+    dbgmsg (msgs, "cancelling %u:%u->%u...", req->index, req->offset, req->length);
+    dbgOutMessageLen (msgs);
+    pokeBatchPeriod (msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS);
 }
 
 static void
-protocolSendPort(tr_peermsgs *msgs, uint16_t port)
+protocolSendPort (tr_peermsgs *msgs, uint16_t port)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    dbgmsg( msgs, "sending Port %u", port);
-    evbuffer_add_uint32( out, 3 );
-    evbuffer_add_uint8 ( out, BT_PORT );
-    evbuffer_add_uint16( out, port);
+    dbgmsg (msgs, "sending Port %u", port);
+    evbuffer_add_uint32 (out, 3);
+    evbuffer_add_uint8 (out, BT_PORT);
+    evbuffer_add_uint16 (out, port);
 }
 
 static void
-protocolSendHave( tr_peermsgs * msgs, uint32_t index )
+protocolSendHave (tr_peermsgs * msgs, uint32_t index)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    evbuffer_add_uint32( out, sizeof(uint8_t) + sizeof(uint32_t) );
-    evbuffer_add_uint8 ( out, BT_HAVE );
-    evbuffer_add_uint32( out, index );
+    evbuffer_add_uint32 (out, sizeof (uint8_t) + sizeof (uint32_t));
+    evbuffer_add_uint8 (out, BT_HAVE);
+    evbuffer_add_uint32 (out, index);
 
-    dbgmsg( msgs, "sending Have %u", index );
-    dbgOutMessageLen( msgs );
-    pokeBatchPeriod( msgs, LOW_PRIORITY_INTERVAL_SECS );
+    dbgmsg (msgs, "sending Have %u", index);
+    dbgOutMessageLen (msgs);
+    pokeBatchPeriod (msgs, LOW_PRIORITY_INTERVAL_SECS);
 }
 
 #if 0
 static void
-protocolSendAllowedFast( tr_peermsgs * msgs, uint32_t pieceIndex )
+protocolSendAllowedFast (tr_peermsgs * msgs, uint32_t pieceIndex)
 {
     tr_peerIo       * io  = msgs->peer->io;
     struct evbuffer * out = msgs->outMessages;
 
-    assert( tr_peerIoSupportsFEXT( msgs->peer->io ) );
+    assert (tr_peerIoSupportsFEXT (msgs->peer->io));
 
-    evbuffer_add_uint32( io, out, sizeof(uint8_t) + sizeof(uint32_t) );
-    evbuffer_add_uint8 ( io, out, BT_FEXT_ALLOWED_FAST );
-    evbuffer_add_uint32( io, out, pieceIndex );
+    evbuffer_add_uint32 (io, out, sizeof (uint8_t) + sizeof (uint32_t));
+    evbuffer_add_uint8 (io, out, BT_FEXT_ALLOWED_FAST);
+    evbuffer_add_uint32 (io, out, pieceIndex);
 
-    dbgmsg( msgs, "sending Allowed Fast %u...", pieceIndex );
-    dbgOutMessageLen( msgs );
+    dbgmsg (msgs, "sending Allowed Fast %u...", pieceIndex);
+    dbgOutMessageLen (msgs);
 }
 #endif
 
 static void
-protocolSendChoke( tr_peermsgs * msgs, int choke )
+protocolSendChoke (tr_peermsgs * msgs, int choke)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    evbuffer_add_uint32( out, sizeof( uint8_t ) );
-    evbuffer_add_uint8 ( out, choke ? BT_CHOKE : BT_UNCHOKE );
+    evbuffer_add_uint32 (out, sizeof (uint8_t));
+    evbuffer_add_uint8 (out, choke ? BT_CHOKE : BT_UNCHOKE);
 
-    dbgmsg( msgs, "sending %s...", choke ? "Choke" : "Unchoke" );
-    dbgOutMessageLen( msgs );
-    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
+    dbgmsg (msgs, "sending %s...", choke ? "Choke" : "Unchoke");
+    dbgOutMessageLen (msgs);
+    pokeBatchPeriod (msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS);
 }
 
 static void
-protocolSendHaveAll( tr_peermsgs * msgs )
+protocolSendHaveAll (tr_peermsgs * msgs)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    assert( tr_peerIoSupportsFEXT( msgs->peer->io ) );
+    assert (tr_peerIoSupportsFEXT (msgs->peer->io));
 
-    evbuffer_add_uint32( out, sizeof( uint8_t ) );
-    evbuffer_add_uint8 ( out, BT_FEXT_HAVE_ALL );
+    evbuffer_add_uint32 (out, sizeof (uint8_t));
+    evbuffer_add_uint8 (out, BT_FEXT_HAVE_ALL);
 
-    dbgmsg( msgs, "sending HAVE_ALL..." );
-    dbgOutMessageLen( msgs );
-    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
+    dbgmsg (msgs, "sending HAVE_ALL...");
+    dbgOutMessageLen (msgs);
+    pokeBatchPeriod (msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS);
 }
 
 static void
-protocolSendHaveNone( tr_peermsgs * msgs )
+protocolSendHaveNone (tr_peermsgs * msgs)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    assert( tr_peerIoSupportsFEXT( msgs->peer->io ) );
+    assert (tr_peerIoSupportsFEXT (msgs->peer->io));
 
-    evbuffer_add_uint32( out, sizeof( uint8_t ) );
-    evbuffer_add_uint8 ( out, BT_FEXT_HAVE_NONE );
+    evbuffer_add_uint32 (out, sizeof (uint8_t));
+    evbuffer_add_uint8 (out, BT_FEXT_HAVE_NONE);
 
-    dbgmsg( msgs, "sending HAVE_NONE..." );
-    dbgOutMessageLen( msgs );
-    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
+    dbgmsg (msgs, "sending HAVE_NONE...");
+    dbgOutMessageLen (msgs);
+    pokeBatchPeriod (msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS);
 }
 
 /**
@@ -425,128 +427,128 @@ protocolSendHaveNone( tr_peermsgs * msgs )
 **/
 
 static void
-publish( tr_peermsgs * msgs, tr_peer_event * e )
+publish (tr_peermsgs * msgs, tr_peer_event * e)
 {
-    assert( msgs->peer );
-    assert( msgs->peer->msgs == msgs );
+    assert (msgs->peer);
+    assert (msgs->peer->msgs == msgs);
 
-    if( msgs->callback != NULL )
-        msgs->callback( msgs->peer, e, msgs->callbackData );
+    if (msgs->callback != NULL)
+        msgs->callback (msgs->peer, e, msgs->callbackData);
 }
 
 static void
-fireError( tr_peermsgs * msgs, int err )
+fireError (tr_peermsgs * msgs, int err)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_ERROR;
     e.err = err;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireGotBlock( tr_peermsgs * msgs, const struct peer_request * req )
+fireGotBlock (tr_peermsgs * msgs, const struct peer_request * req)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_BLOCK;
     e.pieceIndex = req->index;
     e.offset = req->offset;
     e.length = req->length;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireGotRej( tr_peermsgs * msgs, const struct peer_request * req )
+fireGotRej (tr_peermsgs * msgs, const struct peer_request * req)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_REJ;
     e.pieceIndex = req->index;
     e.offset = req->offset;
     e.length = req->length;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireGotChoke( tr_peermsgs * msgs )
+fireGotChoke (tr_peermsgs * msgs)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_CHOKE;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireClientGotHaveAll( tr_peermsgs * msgs )
+fireClientGotHaveAll (tr_peermsgs * msgs)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_HAVE_ALL;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireClientGotHaveNone( tr_peermsgs * msgs )
+fireClientGotHaveNone (tr_peermsgs * msgs)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_HAVE_NONE;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireClientGotData( tr_peermsgs * msgs, uint32_t length, int wasPieceData )
+fireClientGotData (tr_peermsgs * msgs, uint32_t length, int wasPieceData)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
 
     e.length = length;
     e.eventType = TR_PEER_CLIENT_GOT_DATA;
     e.wasPieceData = wasPieceData;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireClientGotSuggest( tr_peermsgs * msgs, uint32_t pieceIndex )
+fireClientGotSuggest (tr_peermsgs * msgs, uint32_t pieceIndex)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_SUGGEST;
     e.pieceIndex = pieceIndex;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireClientGotPort( tr_peermsgs * msgs, tr_port port )
+fireClientGotPort (tr_peermsgs * msgs, tr_port port)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_PORT;
     e.port = port;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireClientGotAllowedFast( tr_peermsgs * msgs, uint32_t pieceIndex )
+fireClientGotAllowedFast (tr_peermsgs * msgs, uint32_t pieceIndex)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_ALLOWED_FAST;
     e.pieceIndex = pieceIndex;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireClientGotBitfield( tr_peermsgs * msgs, tr_bitfield * bitfield )
+fireClientGotBitfield (tr_peermsgs * msgs, tr_bitfield * bitfield)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_BITFIELD;
     e.bitfield = bitfield;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-fireClientGotHave( tr_peermsgs * msgs, tr_piece_index_t index )
+fireClientGotHave (tr_peermsgs * msgs, tr_piece_index_t index)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_HAVE;
     e.pieceIndex = index;
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 static void
-firePeerGotData( tr_peermsgs * msgs, uint32_t length, bool wasPieceData )
+firePeerGotData (tr_peermsgs * msgs, uint32_t length, bool wasPieceData)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
 
@@ -554,7 +556,7 @@ firePeerGotData( tr_peermsgs * msgs, uint32_t length, bool wasPieceData )
     e.eventType = TR_PEER_PEER_GOT_DATA;
     e.wasPieceData = wasPieceData;
 
-    publish( msgs, &e );
+    publish (msgs, &e);
 }
 
 /**
@@ -564,53 +566,53 @@ firePeerGotData( tr_peermsgs * msgs, uint32_t length, bool wasPieceData )
 
 #if 0
 size_t
-tr_generateAllowedSet( tr_piece_index_t * setmePieces,
+tr_generateAllowedSet (tr_piece_index_t * setmePieces,
                        size_t             desiredSetSize,
                        size_t             pieceCount,
                        const uint8_t    * infohash,
-                       const tr_address * addr )
+                       const tr_address * addr)
 {
     size_t setSize = 0;
 
-    assert( setmePieces );
-    assert( desiredSetSize <= pieceCount );
-    assert( desiredSetSize );
-    assert( pieceCount );
-    assert( infohash );
-    assert( addr );
+    assert (setmePieces);
+    assert (desiredSetSize <= pieceCount);
+    assert (desiredSetSize);
+    assert (pieceCount);
+    assert (infohash);
+    assert (addr);
 
-    if( addr->type == TR_AF_INET )
+    if (addr->type == TR_AF_INET)
     {
         uint8_t w[SHA_DIGEST_LENGTH + 4], *walk=w;
         uint8_t x[SHA_DIGEST_LENGTH];
 
-        uint32_t ui32 = ntohl( htonl( addr->addr.addr4.s_addr ) & 0xffffff00 );   /* (1) */
-        memcpy( w, &ui32, sizeof( uint32_t ) );
-        walk += sizeof( uint32_t );
-        memcpy( walk, infohash, SHA_DIGEST_LENGTH );                 /* (2) */
+        uint32_t ui32 = ntohl (htonl (addr->addr.addr4.s_addr) & 0xffffff00);   /* (1) */
+        memcpy (w, &ui32, sizeof (uint32_t));
+        walk += sizeof (uint32_t);
+        memcpy (walk, infohash, SHA_DIGEST_LENGTH);                 /* (2) */
         walk += SHA_DIGEST_LENGTH;
-        tr_sha1( x, w, walk-w, NULL );                               /* (3) */
-        assert( sizeof( w ) == walk-w );
+        tr_sha1 (x, w, walk-w, NULL);                               /* (3) */
+        assert (sizeof (w) == walk-w);
 
-        while( setSize<desiredSetSize )
+        while (setSize<desiredSetSize)
         {
             int i;
-            for( i=0; i<5 && setSize<desiredSetSize; ++i )           /* (4) */
+            for (i=0; i<5 && setSize<desiredSetSize; ++i)           /* (4) */
             {
                 size_t k;
                 uint32_t j = i * 4;                                  /* (5) */
-                uint32_t y = ntohl( *( uint32_t* )( x + j ) );       /* (6) */
+                uint32_t y = ntohl (* (uint32_t*)(x + j));       /* (6) */
                 uint32_t index = y % pieceCount;                     /* (7) */
 
-                for( k=0; k<setSize; ++k )                           /* (8) */
-                    if( setmePieces[k] == index )
+                for (k=0; k<setSize; ++k)                           /* (8) */
+                    if (setmePieces[k] == index)
                         break;
 
-                if( k == setSize )
+                if (k == setSize)
                     setmePieces[setSize++] = index;                  /* (9) */
             }
 
-            tr_sha1( x, x, sizeof( x ), NULL );                      /* (3) */
+            tr_sha1 (x, x, sizeof (x), NULL);                      /* (3) */
         }
     }
 
@@ -618,25 +620,25 @@ tr_generateAllowedSet( tr_piece_index_t * setmePieces,
 }
 
 static void
-updateFastSet( tr_peermsgs * msgs UNUSED )
+updateFastSet (tr_peermsgs * msgs UNUSED)
 {
-    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
+    const bool fext = tr_peerIoSupportsFEXT (msgs->peer->io);
     const int peerIsNeedy = msgs->peer->progress < 0.10;
 
-    if( fext && peerIsNeedy && !msgs->haveFastSet )
+    if (fext && peerIsNeedy && !msgs->haveFastSet)
     {
         size_t i;
-        const struct tr_address * addr = tr_peerIoGetAddress( msgs->peer->io, NULL );
+        const struct tr_address * addr = tr_peerIoGetAddress (msgs->peer->io, NULL);
         const tr_info * inf = &msgs->torrent->info;
-        const size_t numwant = MIN( MAX_FAST_SET_SIZE, inf->pieceCount );
+        const size_t numwant = MIN (MAX_FAST_SET_SIZE, inf->pieceCount);
 
         /* build the fast set */
-        msgs->fastsetSize = tr_generateAllowedSet( msgs->fastset, numwant, inf->pieceCount, inf->hash, addr );
+        msgs->fastsetSize = tr_generateAllowedSet (msgs->fastset, numwant, inf->pieceCount, inf->hash, addr);
         msgs->haveFastSet = 1;
 
         /* send it to the peer */
-        for( i=0; i<msgs->fastsetSize; ++i )
-            protocolSendAllowedFast( msgs, msgs->fastset[i] );
+        for (i=0; i<msgs->fastsetSize; ++i)
+            protocolSendAllowedFast (msgs, msgs->fastset[i]);
     }
 }
 #endif
@@ -646,96 +648,96 @@ updateFastSet( tr_peermsgs * msgs UNUSED )
 **/
 
 static void
-sendInterest( tr_peermsgs * msgs, bool clientIsInterested )
+sendInterest (tr_peermsgs * msgs, bool clientIsInterested)
 {
     struct evbuffer * out = msgs->outMessages;
 
-    assert( msgs );
-    assert( tr_isBool( clientIsInterested ) );
+    assert (msgs);
+    assert (tr_isBool (clientIsInterested));
 
     msgs->peer->clientIsInterested = clientIsInterested;
-    dbgmsg( msgs, "Sending %s", clientIsInterested ? "Interested" : "Not Interested" );
-    evbuffer_add_uint32( out, sizeof( uint8_t ) );
-    evbuffer_add_uint8 ( out, clientIsInterested ? BT_INTERESTED : BT_NOT_INTERESTED );
+    dbgmsg (msgs, "Sending %s", clientIsInterested ? "Interested" : "Not Interested");
+    evbuffer_add_uint32 (out, sizeof (uint8_t));
+    evbuffer_add_uint8 (out, clientIsInterested ? BT_INTERESTED : BT_NOT_INTERESTED);
 
-    pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
-    dbgOutMessageLen( msgs );
+    pokeBatchPeriod (msgs, HIGH_PRIORITY_INTERVAL_SECS);
+    dbgOutMessageLen (msgs);
 }
 
 static void
-updateInterest( tr_peermsgs * msgs UNUSED )
+updateInterest (tr_peermsgs * msgs UNUSED)
 {
     /* FIXME -- might need to poke the mgr on startup */
 }
 
 void
-tr_peerMsgsSetInterested( tr_peermsgs * msgs, bool clientIsInterested )
+tr_peerMsgsSetInterested (tr_peermsgs * msgs, bool clientIsInterested)
 {
-    assert( tr_isBool( clientIsInterested ) );
+    assert (tr_isBool (clientIsInterested));
 
-    if( clientIsInterested != msgs->peer->clientIsInterested )
-        sendInterest( msgs, clientIsInterested );
+    if (clientIsInterested != msgs->peer->clientIsInterested)
+        sendInterest (msgs, clientIsInterested);
 }
 
 static bool
-popNextMetadataRequest( tr_peermsgs * msgs, int * piece )
+popNextMetadataRequest (tr_peermsgs * msgs, int * piece)
 {
-    if( msgs->peerAskedForMetadataCount == 0 )
+    if (msgs->peerAskedForMetadataCount == 0)
         return false;
 
     *piece = msgs->peerAskedForMetadata[0];
 
-    tr_removeElementFromArray( msgs->peerAskedForMetadata, 0, sizeof( int ),
-                               msgs->peerAskedForMetadataCount-- );
+    tr_removeElementFromArray (msgs->peerAskedForMetadata, 0, sizeof (int),
+                               msgs->peerAskedForMetadataCount--);
 
     return true;
 }
 
 static bool
-popNextRequest( tr_peermsgs * msgs, struct peer_request * setme )
+popNextRequest (tr_peermsgs * msgs, struct peer_request * setme)
 {
-    if( msgs->peer->pendingReqsToClient == 0 )
+    if (msgs->peer->pendingReqsToClient == 0)
         return false;
 
     *setme = msgs->peerAskedFor[0];
 
-    tr_removeElementFromArray( msgs->peerAskedFor, 0, sizeof( struct peer_request ),
-                               msgs->peer->pendingReqsToClient-- );
+    tr_removeElementFromArray (msgs->peerAskedFor, 0, sizeof (struct peer_request),
+                               msgs->peer->pendingReqsToClient--);
 
     return true;
 }
 
 static void
-cancelAllRequestsToClient( tr_peermsgs * msgs )
+cancelAllRequestsToClient (tr_peermsgs * msgs)
 {
     struct peer_request req;
-    const int mustSendCancel = tr_peerIoSupportsFEXT( msgs->peer->io );
+    const int mustSendCancel = tr_peerIoSupportsFEXT (msgs->peer->io);
 
-    while( popNextRequest( msgs, &req ))
-        if( mustSendCancel )
-            protocolSendReject( msgs, &req );
+    while (popNextRequest (msgs, &req))
+        if (mustSendCancel)
+            protocolSendReject (msgs, &req);
 }
 
 void
-tr_peerMsgsSetChoke( tr_peermsgs * msgs, bool peerIsChoked )
+tr_peerMsgsSetChoke (tr_peermsgs * msgs, bool peerIsChoked)
 {
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
     const time_t fibrillationTime = now - MIN_CHOKE_PERIOD_SEC;
 
-    assert( msgs );
-    assert( msgs->peer );
-    assert( tr_isBool( peerIsChoked ) );
+    assert (msgs);
+    assert (msgs->peer);
+    assert (tr_isBool (peerIsChoked));
 
-    if( msgs->peer->chokeChangedAt > fibrillationTime )
+    if (msgs->peer->chokeChangedAt > fibrillationTime)
     {
-        dbgmsg( msgs, "Not changing choke to %d to avoid fibrillation", peerIsChoked );
+        dbgmsg (msgs, "Not changing choke to %d to avoid fibrillation", peerIsChoked);
     }
-    else if( msgs->peer->peerIsChoked != peerIsChoked )
+    else if (msgs->peer->peerIsChoked != peerIsChoked)
     {
         msgs->peer->peerIsChoked = peerIsChoked;
-        if( peerIsChoked )
-            cancelAllRequestsToClient( msgs );
-        protocolSendChoke( msgs, peerIsChoked );
+        if (peerIsChoked)
+            cancelAllRequestsToClient (msgs);
+        protocolSendChoke (msgs, peerIsChoked);
         msgs->peer->chokeChangedAt = now;
     }
 }
@@ -745,12 +747,12 @@ tr_peerMsgsSetChoke( tr_peermsgs * msgs, bool peerIsChoked )
 **/
 
 void
-tr_peerMsgsHave( tr_peermsgs * msgs, uint32_t index )
+tr_peerMsgsHave (tr_peermsgs * msgs, uint32_t index)
 {
-    protocolSendHave( msgs, index );
+    protocolSendHave (msgs, index);
 
     /* since we have more pieces now, we might not be interested in this peer */
-    updateInterest( msgs );
+    updateInterest (msgs);
 }
 
 /**
@@ -758,27 +760,27 @@ tr_peerMsgsHave( tr_peermsgs * msgs, uint32_t index )
 **/
 
 static bool
-reqIsValid( const tr_peermsgs * peer,
+reqIsValid (const tr_peermsgs * peer,
             uint32_t            index,
             uint32_t            offset,
-            uint32_t            length )
+            uint32_t            length)
 {
-    return tr_torrentReqIsValid( peer->torrent, index, offset, length );
+    return tr_torrentReqIsValid (peer->torrent, index, offset, length);
 }
 
 static bool
-requestIsValid( const tr_peermsgs * msgs, const struct peer_request * req )
+requestIsValid (const tr_peermsgs * msgs, const struct peer_request * req)
 {
-    return reqIsValid( msgs, req->index, req->offset, req->length );
+    return reqIsValid (msgs, req->index, req->offset, req->length);
 }
 
 void
-tr_peerMsgsCancel( tr_peermsgs * msgs, tr_block_index_t block )
+tr_peerMsgsCancel (tr_peermsgs * msgs, tr_block_index_t block)
 {
     struct peer_request req;
-/*fprintf( stderr, "SENDING CANCEL MESSAGE FOR BLOCK %zu\n\t\tFROM PEER %p ------------------------------------\n", (size_t)block, msgs->peer );*/
-    blockToReq( msgs->torrent, block, &req );
-    protocolSendCancel( msgs, &req );
+/*fprintf (stderr, "SENDING CANCEL MESSAGE FOR BLOCK %zu\n\t\tFROM PEER %p ------------------------------------\n", (size_t)block, msgs->peer);*/
+    blockToReq (msgs->torrent, block, &req);
+    protocolSendCancel (msgs, &req);
 }
 
 /**
@@ -786,98 +788,98 @@ tr_peerMsgsCancel( tr_peermsgs * msgs, tr_block_index_t block )
 **/
 
 static void
-sendLtepHandshake( tr_peermsgs * msgs )
+sendLtepHandshake (tr_peermsgs * msgs)
 {
     tr_benc val;
     bool allow_pex;
     bool allow_metadata_xfer;
     struct evbuffer * payload;
     struct evbuffer * out = msgs->outMessages;
-    const unsigned char * ipv6 = tr_globalIPv6();
+    const unsigned char * ipv6 = tr_globalIPv6 ();
 
-    if( msgs->clientSentLtepHandshake )
+    if (msgs->clientSentLtepHandshake)
         return;
 
-    dbgmsg( msgs, "sending an ltep handshake" );
+    dbgmsg (msgs, "sending an ltep handshake");
     msgs->clientSentLtepHandshake = 1;
 
     /* decide if we want to advertise metadata xfer support (BEP 9) */
-    if( tr_torrentIsPrivate( msgs->torrent ) )
+    if (tr_torrentIsPrivate (msgs->torrent))
         allow_metadata_xfer = 0;
     else
         allow_metadata_xfer = 1;
 
     /* decide if we want to advertise pex support */
-    if( !tr_torrentAllowsPex( msgs->torrent ) )
+    if (!tr_torrentAllowsPex (msgs->torrent))
         allow_pex = 0;
-    else if( msgs->peerSentLtepHandshake )
+    else if (msgs->peerSentLtepHandshake)
         allow_pex = msgs->peerSupportsPex ? 1 : 0;
     else
         allow_pex = 1;
 
-    tr_bencInitDict( &val, 8 );
-    tr_bencDictAddInt( &val, "e", getSession(msgs)->encryptionMode != TR_CLEAR_PREFERRED );
-    if( ipv6 != NULL )
-        tr_bencDictAddRaw( &val, "ipv6", ipv6, 16 );
-    if( allow_metadata_xfer && tr_torrentHasMetadata( msgs->torrent )
-                            && ( msgs->torrent->infoDictLength > 0 ) )
-        tr_bencDictAddInt( &val, "metadata_size", msgs->torrent->infoDictLength );
-    tr_bencDictAddInt( &val, "p", tr_sessionGetPublicPeerPort( getSession(msgs) ) );
-    tr_bencDictAddInt( &val, "reqq", REQQ );
-    tr_bencDictAddInt( &val, "upload_only", tr_torrentIsSeed( msgs->torrent ) );
-    tr_bencDictAddStr( &val, "v", TR_NAME " " USERAGENT_PREFIX );
-    if( allow_metadata_xfer || allow_pex ) {
-        tr_benc * m  = tr_bencDictAddDict( &val, "m", 2 );
-        if( allow_metadata_xfer )
-            tr_bencDictAddInt( m, "ut_metadata", UT_METADATA_ID );
-        if( allow_pex )
-            tr_bencDictAddInt( m, "ut_pex", UT_PEX_ID );
+    tr_bencInitDict (&val, 8);
+    tr_bencDictAddInt (&val, "e", getSession (msgs)->encryptionMode != TR_CLEAR_PREFERRED);
+    if (ipv6 != NULL)
+        tr_bencDictAddRaw (&val, "ipv6", ipv6, 16);
+    if (allow_metadata_xfer && tr_torrentHasMetadata (msgs->torrent)
+                            && (msgs->torrent->infoDictLength > 0))
+        tr_bencDictAddInt (&val, "metadata_size", msgs->torrent->infoDictLength);
+    tr_bencDictAddInt (&val, "p", tr_sessionGetPublicPeerPort (getSession (msgs)));
+    tr_bencDictAddInt (&val, "reqq", REQQ);
+    tr_bencDictAddInt (&val, "upload_only", tr_torrentIsSeed (msgs->torrent));
+    tr_bencDictAddStr (&val, "v", TR_NAME " " USERAGENT_PREFIX);
+    if (allow_metadata_xfer || allow_pex) {
+        tr_benc * m  = tr_bencDictAddDict (&val, "m", 2);
+        if (allow_metadata_xfer)
+            tr_bencDictAddInt (m, "ut_metadata", UT_METADATA_ID);
+        if (allow_pex)
+            tr_bencDictAddInt (m, "ut_pex", UT_PEX_ID);
     }
 
-    payload = tr_bencToBuf( &val, TR_FMT_BENC );
+    payload = tr_bencToBuf (&val, TR_FMT_BENC);
 
-    evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + evbuffer_get_length( payload ) );
-    evbuffer_add_uint8 ( out, BT_LTEP );
-    evbuffer_add_uint8 ( out, LTEP_HANDSHAKE );
-    evbuffer_add_buffer( out, payload );
-    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
-    dbgOutMessageLen( msgs );
+    evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload));
+    evbuffer_add_uint8 (out, BT_LTEP);
+    evbuffer_add_uint8 (out, LTEP_HANDSHAKE);
+    evbuffer_add_buffer (out, payload);
+    pokeBatchPeriod (msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS);
+    dbgOutMessageLen (msgs);
 
     /* cleanup */
-    evbuffer_free( payload );
-    tr_bencFree( &val );
+    evbuffer_free (payload);
+    tr_bencFree (&val);
 }
 
 static void
-parseLtepHandshake( tr_peermsgs * msgs, int len, struct evbuffer * inbuf )
+parseLtepHandshake (tr_peermsgs * msgs, int len, struct evbuffer * inbuf)
 {
     int64_t   i;
     tr_benc   val, * sub;
-    uint8_t * tmp = tr_new( uint8_t, len );
+    uint8_t * tmp = tr_new (uint8_t, len);
     const uint8_t *addr;
     size_t addr_len;
     tr_pex pex;
     int8_t seedProbability = -1;
 
-    memset( &pex, 0, sizeof( tr_pex ) );
+    memset (&pex, 0, sizeof (tr_pex));
 
-    tr_peerIoReadBytes( msgs->peer->io, inbuf, tmp, len );
+    tr_peerIoReadBytes (msgs->peer->io, inbuf, tmp, len);
     msgs->peerSentLtepHandshake = 1;
 
-    if( tr_bencLoad( tmp, len, &val, NULL ) || !tr_bencIsDict( &val ) )
+    if (tr_bencLoad (tmp, len, &val, NULL) || !tr_bencIsDict (&val))
     {
-        dbgmsg( msgs, "GET  extended-handshake, couldn't get dictionary" );
-        tr_free( tmp );
+        dbgmsg (msgs, "GET  extended-handshake, couldn't get dictionary");
+        tr_free (tmp);
         return;
     }
 
-    dbgmsg( msgs, "here is the handshake: [%*.*s]", len, len,  tmp );
+    dbgmsg (msgs, "here is the handshake: [%*.*s]", len, len,  tmp);
 
     /* does the peer prefer encrypted connections? */
-    if( tr_bencDictFindInt( &val, "e", &i ) ) {
+    if (tr_bencDictFindInt (&val, "e", &i)) {
         msgs->peer->encryption_preference = i ? ENCRYPTION_PREFERENCE_YES
                                               : ENCRYPTION_PREFERENCE_NO;
-        if( i )
+        if (i)
             pex.flags |= ADDED_F_ENCRYPTION_FLAG;
     }
 
@@ -885,71 +887,71 @@ parseLtepHandshake( tr_peermsgs * msgs, int len, struct evbuffer * inbuf )
     msgs->peerSupportsPex = 0;
     msgs->peerSupportsMetadataXfer = 0;
 
-    if( tr_bencDictFindDict( &val, "m", &sub ) ) {
-        if( tr_bencDictFindInt( sub, "ut_pex", &i ) ) {
+    if (tr_bencDictFindDict (&val, "m", &sub)) {
+        if (tr_bencDictFindInt (sub, "ut_pex", &i)) {
             msgs->peerSupportsPex = i != 0;
             msgs->ut_pex_id = (uint8_t) i;
-            dbgmsg( msgs, "msgs->ut_pex is %d", (int)msgs->ut_pex_id );
+            dbgmsg (msgs, "msgs->ut_pex is %d", (int)msgs->ut_pex_id);
         }
-        if( tr_bencDictFindInt( sub, "ut_metadata", &i ) ) {
+        if (tr_bencDictFindInt (sub, "ut_metadata", &i)) {
             msgs->peerSupportsMetadataXfer = i != 0;
             msgs->ut_metadata_id = (uint8_t) i;
-            dbgmsg( msgs, "msgs->ut_metadata_id is %d", (int)msgs->ut_metadata_id );
+            dbgmsg (msgs, "msgs->ut_metadata_id is %d", (int)msgs->ut_metadata_id);
         }
-        if( tr_bencDictFindInt( sub, "ut_holepunch", &i ) ) {
+        if (tr_bencDictFindInt (sub, "ut_holepunch", &i)) {
             /* Mysterious µTorrent extension that we don't grok.  However,
                it implies support for µTP, so use it to indicate that. */
-            tr_peerMgrSetUtpFailed( msgs->torrent,
-                                    tr_peerIoGetAddress( msgs->peer->io, NULL ),
-                                    false );
+            tr_peerMgrSetUtpFailed (msgs->torrent,
+                                    tr_peerIoGetAddress (msgs->peer->io, NULL),
+                                    false);
         }
     }
 
     /* look for metainfo size (BEP 9) */
-    if( tr_bencDictFindInt( &val, "metadata_size", &i ) ) {
-        tr_torrentSetMetadataSizeHint( msgs->torrent, i );
+    if (tr_bencDictFindInt (&val, "metadata_size", &i)) {
+        tr_torrentSetMetadataSizeHint (msgs->torrent, i);
         msgs->metadata_size_hint = (size_t) i;
     }
 
     /* look for upload_only (BEP 21) */
-    if( tr_bencDictFindInt( &val, "upload_only", &i ) )
+    if (tr_bencDictFindInt (&val, "upload_only", &i))
         seedProbability = i==0 ? 0 : 100;
 
     /* get peer's listening port */
-    if( tr_bencDictFindInt( &val, "p", &i ) ) {
-        pex.port = htons( (uint16_t)i );
-        fireClientGotPort( msgs, pex.port );
-        dbgmsg( msgs, "peer's port is now %d", (int)i );
+    if (tr_bencDictFindInt (&val, "p", &i)) {
+        pex.port = htons ((uint16_t)i);
+        fireClientGotPort (msgs, pex.port);
+        dbgmsg (msgs, "peer's port is now %d", (int)i);
     }
 
-    if( tr_peerIoIsIncoming( msgs->peer->io )
-        && tr_bencDictFindRaw( &val, "ipv4", &addr, &addr_len )
-        && ( addr_len == 4 ) )
+    if (tr_peerIoIsIncoming (msgs->peer->io)
+        && tr_bencDictFindRaw (&val, "ipv4", &addr, &addr_len)
+        && (addr_len == 4))
     {
         pex.addr.type = TR_AF_INET;
-        memcpy( &pex.addr.addr.addr4, addr, 4 );
-        tr_peerMgrAddPex( msgs->torrent, TR_PEER_FROM_LTEP, &pex, seedProbability );
+        memcpy (&pex.addr.addr.addr4, addr, 4);
+        tr_peerMgrAddPex (msgs->torrent, TR_PEER_FROM_LTEP, &pex, seedProbability);
     }
 
-    if( tr_peerIoIsIncoming( msgs->peer->io )
-        && tr_bencDictFindRaw( &val, "ipv6", &addr, &addr_len )
-        && ( addr_len == 16 ) )
+    if (tr_peerIoIsIncoming (msgs->peer->io)
+        && tr_bencDictFindRaw (&val, "ipv6", &addr, &addr_len)
+        && (addr_len == 16))
     {
         pex.addr.type = TR_AF_INET6;
-        memcpy( &pex.addr.addr.addr6, addr, 16 );
-        tr_peerMgrAddPex( msgs->torrent, TR_PEER_FROM_LTEP, &pex, seedProbability );
+        memcpy (&pex.addr.addr.addr6, addr, 16);
+        tr_peerMgrAddPex (msgs->torrent, TR_PEER_FROM_LTEP, &pex, seedProbability);
     }
 
     /* get peer's maximum request queue size */
-    if( tr_bencDictFindInt( &val, "reqq", &i ) )
+    if (tr_bencDictFindInt (&val, "reqq", &i))
         msgs->reqq = i;
 
-    tr_bencFree( &val );
-    tr_free( tmp );
+    tr_bencFree (&val);
+    tr_free (tmp);
 }
 
 static void
-parseUtMetadata( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
+parseUtMetadata (tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf)
 {
     tr_benc dict;
     char * msg_end;
@@ -957,42 +959,42 @@ parseUtMetadata( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
     int64_t msg_type = -1;
     int64_t piece = -1;
     int64_t total_size = 0;
-    uint8_t * tmp = tr_new( uint8_t, msglen );
+    uint8_t * tmp = tr_new (uint8_t, msglen);
 
-    tr_peerIoReadBytes( msgs->peer->io, inbuf, tmp, msglen );
+    tr_peerIoReadBytes (msgs->peer->io, inbuf, tmp, msglen);
     msg_end = (char*)tmp + msglen;
 
-    if( !tr_bencLoad( tmp, msglen, &dict, &benc_end ) )
+    if (!tr_bencLoad (tmp, msglen, &dict, &benc_end))
     {
-        tr_bencDictFindInt( &dict, "msg_type", &msg_type );
-        tr_bencDictFindInt( &dict, "piece", &piece );
-        tr_bencDictFindInt( &dict, "total_size", &total_size );
-        tr_bencFree( &dict );
+        tr_bencDictFindInt (&dict, "msg_type", &msg_type);
+        tr_bencDictFindInt (&dict, "piece", &piece);
+        tr_bencDictFindInt (&dict, "total_size", &total_size);
+        tr_bencFree (&dict);
     }
 
-    dbgmsg( msgs, "got ut_metadata msg: type %d, piece %d, total_size %d",
-            (int)msg_type, (int)piece, (int)total_size );
+    dbgmsg (msgs, "got ut_metadata msg: type %d, piece %d, total_size %d",
+          (int)msg_type, (int)piece, (int)total_size);
 
-    if( msg_type == METADATA_MSG_TYPE_REJECT )
+    if (msg_type == METADATA_MSG_TYPE_REJECT)
     {
         /* NOOP */
     }
 
-    if( ( msg_type == METADATA_MSG_TYPE_DATA )
-        && ( !tr_torrentHasMetadata( msgs->torrent ) )
-        && ( msg_end - benc_end <= METADATA_PIECE_SIZE )
-        && ( piece * METADATA_PIECE_SIZE + (msg_end - benc_end) <= total_size ) )
+    if ((msg_type == METADATA_MSG_TYPE_DATA)
+        && (!tr_torrentHasMetadata (msgs->torrent))
+        && (msg_end - benc_end <= METADATA_PIECE_SIZE)
+        && (piece * METADATA_PIECE_SIZE + (msg_end - benc_end) <= total_size))
     {
         const int pieceLen = msg_end - benc_end;
-        tr_torrentSetMetadataPiece( msgs->torrent, piece, benc_end, pieceLen );
+        tr_torrentSetMetadataPiece (msgs->torrent, piece, benc_end, pieceLen);
     }
 
-    if( msg_type == METADATA_MSG_TYPE_REQUEST )
+    if (msg_type == METADATA_MSG_TYPE_REQUEST)
     {
-        if( ( piece >= 0 )
-            && tr_torrentHasMetadata( msgs->torrent )
-            && !tr_torrentIsPrivate( msgs->torrent )
-            && ( msgs->peerAskedForMetadataCount < METADATA_REQQ ) )
+        if ((piece >= 0)
+            && tr_torrentHasMetadata (msgs->torrent)
+            && !tr_torrentIsPrivate (msgs->torrent)
+            && (msgs->peerAskedForMetadataCount < METADATA_REQQ))
         {
             msgs->peerAskedForMetadata[msgs->peerAskedForMetadataCount++] = piece;
         }
@@ -1003,142 +1005,142 @@ parseUtMetadata( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
             struct evbuffer * out = msgs->outMessages;
 
             /* build the rejection message */
-            tr_bencInitDict( &tmp, 2 );
-            tr_bencDictAddInt( &tmp, "msg_type", METADATA_MSG_TYPE_REJECT );
-            tr_bencDictAddInt( &tmp, "piece", piece );
-            payload = tr_bencToBuf( &tmp, TR_FMT_BENC );
+            tr_bencInitDict (&tmp, 2);
+            tr_bencDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REJECT);
+            tr_bencDictAddInt (&tmp, "piece", piece);
+            payload = tr_bencToBuf (&tmp, TR_FMT_BENC);
 
             /* write it out as a LTEP message to our outMessages buffer */
-            evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + evbuffer_get_length( payload ) );
-            evbuffer_add_uint8 ( out, BT_LTEP );
-            evbuffer_add_uint8 ( out, msgs->ut_metadata_id );
-            evbuffer_add_buffer( out, payload );
-            pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
-            dbgOutMessageLen( msgs );
+            evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload));
+            evbuffer_add_uint8 (out, BT_LTEP);
+            evbuffer_add_uint8 (out, msgs->ut_metadata_id);
+            evbuffer_add_buffer (out, payload);
+            pokeBatchPeriod (msgs, HIGH_PRIORITY_INTERVAL_SECS);
+            dbgOutMessageLen (msgs);
 
             /* cleanup */
-            evbuffer_free( payload );
-            tr_bencFree( &tmp );
+            evbuffer_free (payload);
+            tr_bencFree (&tmp);
         }
     }
 
-    tr_free( tmp );
+    tr_free (tmp);
 }
 
 static void
-parseUtPex( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
+parseUtPex (tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf)
 {
     int loaded = 0;
-    uint8_t * tmp = tr_new( uint8_t, msglen );
+    uint8_t * tmp = tr_new (uint8_t, msglen);
     tr_benc val;
     tr_torrent * tor = msgs->torrent;
     const uint8_t * added;
     size_t added_len;
 
-    tr_peerIoReadBytes( msgs->peer->io, inbuf, tmp, msglen );
+    tr_peerIoReadBytes (msgs->peer->io, inbuf, tmp, msglen);
 
-    if( tr_torrentAllowsPex( tor )
-      && ( ( loaded = !tr_bencLoad( tmp, msglen, &val, NULL ) ) ) )
+    if (tr_torrentAllowsPex (tor)
+      && ((loaded = !tr_bencLoad (tmp, msglen, &val, NULL))))
     {
-        if( tr_bencDictFindRaw( &val, "added", &added, &added_len ) )
+        if (tr_bencDictFindRaw (&val, "added", &added, &added_len))
         {
             tr_pex * pex;
             size_t i, n;
             size_t added_f_len = 0;
             const uint8_t * added_f = NULL;
 
-            tr_bencDictFindRaw( &val, "added.f", &added_f, &added_f_len );
-            pex = tr_peerMgrCompactToPex( added, added_len, added_f, added_f_len, &n );
+            tr_bencDictFindRaw (&val, "added.f", &added_f, &added_f_len);
+            pex = tr_peerMgrCompactToPex (added, added_len, added_f, added_f_len, &n);
 
-            n = MIN( n, MAX_PEX_PEER_COUNT );
-            for( i=0; i<n; ++i )
+            n = MIN (n, MAX_PEX_PEER_COUNT);
+            for (i=0; i<n; ++i)
             {
                 int seedProbability = -1;
-                if( i < added_f_len ) seedProbability = ( added_f[i] & ADDED_F_SEED_FLAG ) ? 100 : 0;
-                tr_peerMgrAddPex( tor, TR_PEER_FROM_PEX, pex+i, seedProbability );
+                if (i < added_f_len) seedProbability = (added_f[i] & ADDED_F_SEED_FLAG) ? 100 : 0;
+                tr_peerMgrAddPex (tor, TR_PEER_FROM_PEX, pex+i, seedProbability);
             }
 
-            tr_free( pex );
+            tr_free (pex);
         }
 
-        if( tr_bencDictFindRaw( &val, "added6", &added, &added_len ) )
+        if (tr_bencDictFindRaw (&val, "added6", &added, &added_len))
         {
             tr_pex * pex;
             size_t i, n;
             size_t added_f_len = 0;
             const uint8_t * added_f = NULL;
 
-            tr_bencDictFindRaw( &val, "added6.f", &added_f, &added_f_len );
-            pex = tr_peerMgrCompact6ToPex( added, added_len, added_f, added_f_len, &n );
+            tr_bencDictFindRaw (&val, "added6.f", &added_f, &added_f_len);
+            pex = tr_peerMgrCompact6ToPex (added, added_len, added_f, added_f_len, &n);
 
-            n = MIN( n, MAX_PEX_PEER_COUNT );
-            for( i=0; i<n; ++i )
+            n = MIN (n, MAX_PEX_PEER_COUNT);
+            for (i=0; i<n; ++i)
             {
                 int seedProbability = -1;
-                if( i < added_f_len ) seedProbability = ( added_f[i] & ADDED_F_SEED_FLAG ) ? 100 : 0;
-                tr_peerMgrAddPex( tor, TR_PEER_FROM_PEX, pex+i, seedProbability );
+                if (i < added_f_len) seedProbability = (added_f[i] & ADDED_F_SEED_FLAG) ? 100 : 0;
+                tr_peerMgrAddPex (tor, TR_PEER_FROM_PEX, pex+i, seedProbability);
             }
 
-            tr_free( pex );
+            tr_free (pex);
         }
     }
 
-    if( loaded )
-        tr_bencFree( &val );
-    tr_free( tmp );
+    if (loaded)
+        tr_bencFree (&val);
+    tr_free (tmp);
 }
 
-static void sendPex( tr_peermsgs * msgs );
+static void sendPex (tr_peermsgs * msgs);
 
 static void
-parseLtep( tr_peermsgs * msgs, int msglen, struct evbuffer  * inbuf )
+parseLtep (tr_peermsgs * msgs, int msglen, struct evbuffer  * inbuf)
 {
     uint8_t ltep_msgid;
 
-    tr_peerIoReadUint8( msgs->peer->io, inbuf, &ltep_msgid );
+    tr_peerIoReadUint8 (msgs->peer->io, inbuf, &ltep_msgid);
     msglen--;
 
-    if( ltep_msgid == LTEP_HANDSHAKE )
+    if (ltep_msgid == LTEP_HANDSHAKE)
     {
-        dbgmsg( msgs, "got ltep handshake" );
-        parseLtepHandshake( msgs, msglen, inbuf );
-        if( tr_peerIoSupportsLTEP( msgs->peer->io ) )
+        dbgmsg (msgs, "got ltep handshake");
+        parseLtepHandshake (msgs, msglen, inbuf);
+        if (tr_peerIoSupportsLTEP (msgs->peer->io))
         {
-            sendLtepHandshake( msgs );
-            sendPex( msgs );
+            sendLtepHandshake (msgs);
+            sendPex (msgs);
         }
     }
-    else if( ltep_msgid == UT_PEX_ID )
+    else if (ltep_msgid == UT_PEX_ID)
     {
-        dbgmsg( msgs, "got ut pex" );
+        dbgmsg (msgs, "got ut pex");
         msgs->peerSupportsPex = 1;
-        parseUtPex( msgs, msglen, inbuf );
+        parseUtPex (msgs, msglen, inbuf);
     }
-    else if( ltep_msgid == UT_METADATA_ID )
+    else if (ltep_msgid == UT_METADATA_ID)
     {
-        dbgmsg( msgs, "got ut metadata" );
+        dbgmsg (msgs, "got ut metadata");
         msgs->peerSupportsMetadataXfer = 1;
-        parseUtMetadata( msgs, msglen, inbuf );
+        parseUtMetadata (msgs, msglen, inbuf);
     }
     else
     {
-        dbgmsg( msgs, "skipping unknown ltep message (%d)", (int)ltep_msgid );
-        evbuffer_drain( inbuf, msglen );
+        dbgmsg (msgs, "skipping unknown ltep message (%d)", (int)ltep_msgid);
+        evbuffer_drain (inbuf, msglen);
     }
 }
 
 static int
-readBtLength( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
+readBtLength (tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen)
 {
     uint32_t len;
 
-    if( inlen < sizeof( len ) )
+    if (inlen < sizeof (len))
         return READ_LATER;
 
-    tr_peerIoReadUint32( msgs->peer->io, inbuf, &len );
+    tr_peerIoReadUint32 (msgs->peer->io, inbuf, &len);
 
-    if( len == 0 ) /* peer sent us a keepalive message */
-        dbgmsg( msgs, "got KeepAlive" );
+    if (len == 0) /* peer sent us a keepalive message */
+        dbgmsg (msgs, "got KeepAlive");
     else
     {
         msgs->incoming.length = len;
@@ -1148,95 +1150,95 @@ readBtLength( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
     return READ_NOW;
 }
 
-static int readBtMessage( tr_peermsgs *, struct evbuffer *, size_t );
+static int readBtMessage (tr_peermsgs *, struct evbuffer *, size_t);
 
 static int
-readBtId( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
+readBtId (tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen)
 {
     uint8_t id;
 
-    if( inlen < sizeof( uint8_t ) )
+    if (inlen < sizeof (uint8_t))
         return READ_LATER;
 
-    tr_peerIoReadUint8( msgs->peer->io, inbuf, &id );
+    tr_peerIoReadUint8 (msgs->peer->io, inbuf, &id);
     msgs->incoming.id = id;
-    dbgmsg( msgs, "msgs->incoming.id is now %d; msgs->incoming.length is %zu", id, (size_t)msgs->incoming.length );
+    dbgmsg (msgs, "msgs->incoming.id is now %d; msgs->incoming.length is %zu", id, (size_t)msgs->incoming.length);
 
-    if( id == BT_PIECE )
+    if (id == BT_PIECE)
     {
         msgs->state = AWAITING_BT_PIECE;
         return READ_NOW;
     }
-    else if( msgs->incoming.length != 1 )
+    else if (msgs->incoming.length != 1)
     {
         msgs->state = AWAITING_BT_MESSAGE;
         return READ_NOW;
     }
-    else return readBtMessage( msgs, inbuf, inlen - 1 );
+    else return readBtMessage (msgs, inbuf, inlen - 1);
 }
 
 static void
-updatePeerProgress( tr_peermsgs * msgs )
+updatePeerProgress (tr_peermsgs * msgs)
 {
-    tr_peerUpdateProgress( msgs->torrent, msgs->peer );
+    tr_peerUpdateProgress (msgs->torrent, msgs->peer);
 
-    /*updateFastSet( msgs );*/
-    updateInterest( msgs );
+    /*updateFastSet (msgs);*/
+    updateInterest (msgs);
 }
 
 static void
-prefetchPieces( tr_peermsgs *msgs )
+prefetchPieces (tr_peermsgs *msgs)
 {
     int i;
 
-    if( !getSession(msgs)->isPrefetchEnabled )
+    if (!getSession (msgs)->isPrefetchEnabled)
         return;
 
     /* Maintain 12 prefetched blocks per unchoked peer */
-    for( i=msgs->prefetchCount; i<msgs->peer->pendingReqsToClient && i<12; ++i )
+    for (i=msgs->prefetchCount; i<msgs->peer->pendingReqsToClient && i<12; ++i)
     {
         const struct peer_request * req = msgs->peerAskedFor + i;
-        if( requestIsValid( msgs, req ) )
+        if (requestIsValid (msgs, req))
         {
-            tr_cachePrefetchBlock( getSession(msgs)->cache, msgs->torrent, req->index, req->offset, req->length );
+            tr_cachePrefetchBlock (getSession (msgs)->cache, msgs->torrent, req->index, req->offset, req->length);
             ++msgs->prefetchCount;
         }
     }
 }
 
 static void
-peerMadeRequest( tr_peermsgs * msgs, const struct peer_request * req )
+peerMadeRequest (tr_peermsgs * msgs, const struct peer_request * req)
 {
-    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
-    const int reqIsValid = requestIsValid( msgs, req );
-    const int clientHasPiece = reqIsValid && tr_cpPieceIsComplete( &msgs->torrent->completion, req->index );
+    const bool fext = tr_peerIoSupportsFEXT (msgs->peer->io);
+    const int reqIsValid = requestIsValid (msgs, req);
+    const int clientHasPiece = reqIsValid && tr_cpPieceIsComplete (&msgs->torrent->completion, req->index);
     const int peerIsChoked = msgs->peer->peerIsChoked;
 
     int allow = false;
 
-    if( !reqIsValid )
-        dbgmsg( msgs, "rejecting an invalid request." );
-    else if( !clientHasPiece )
-        dbgmsg( msgs, "rejecting request for a piece we don't have." );
-    else if( peerIsChoked )
-        dbgmsg( msgs, "rejecting request from choked peer" );
-    else if( msgs->peer->pendingReqsToClient + 1 >= REQQ )
-        dbgmsg( msgs, "rejecting request ... reqq is full" );
+    if (!reqIsValid)
+        dbgmsg (msgs, "rejecting an invalid request.");
+    else if (!clientHasPiece)
+        dbgmsg (msgs, "rejecting request for a piece we don't have.");
+    else if (peerIsChoked)
+        dbgmsg (msgs, "rejecting request from choked peer");
+    else if (msgs->peer->pendingReqsToClient + 1 >= REQQ)
+        dbgmsg (msgs, "rejecting request ... reqq is full");
     else
         allow = true;
 
-    if( allow ) {
+    if (allow) {
         msgs->peerAskedFor[msgs->peer->pendingReqsToClient++] = *req;
-        prefetchPieces( msgs );
-    } else if( fext ) {
-        protocolSendReject( msgs, req );
+        prefetchPieces (msgs);
+    } else if (fext) {
+        protocolSendReject (msgs, req);
     }
 }
 
 static bool
-messageLengthIsCorrect( const tr_peermsgs * msg, uint8_t id, uint32_t len )
+messageLengthIsCorrect (const tr_peermsgs * msg, uint8_t id, uint32_t len)
 {
-    switch( id )
+    switch (id)
     {
         case BT_CHOKE:
         case BT_UNCHOKE:
@@ -1252,11 +1254,11 @@ messageLengthIsCorrect( const tr_peermsgs * msg, uint8_t id, uint32_t len )
             return len == 5;
 
         case BT_BITFIELD:
-            if( tr_torrentHasMetadata( msg->torrent ) )
-                return len == ( msg->torrent->info.pieceCount + 7u ) / 8u + 1u;
+            if (tr_torrentHasMetadata (msg->torrent))
+                return len == (msg->torrent->info.pieceCount + 7u) / 8u + 1u;
             /* we don't know the piece count yet,
                so we can only guess whether to send true or false */
-            if( msg->metadata_size_hint > 0 )
+            if (msg->metadata_size_hint > 0)
                 return len <= msg->metadata_size_hint;
             return true;
 
@@ -1279,30 +1281,30 @@ messageLengthIsCorrect( const tr_peermsgs * msg, uint8_t id, uint32_t len )
     }
 }
 
-static int clientGotBlock( tr_peermsgs *               msgs,
+static int clientGotBlock (tr_peermsgs *               msgs,
                            struct evbuffer *           block,
-                           const struct peer_request * req );
+                           const struct peer_request * req);
 
 static int
-readBtPiece( tr_peermsgs      * msgs,
+readBtPiece (tr_peermsgs      * msgs,
              struct evbuffer  * inbuf,
              size_t             inlen,
-             size_t           * setme_piece_bytes_read )
+             size_t           * setme_piece_bytes_read)
 {
     struct peer_request * req = &msgs->incoming.blockReq;
 
-    assert( evbuffer_get_length( inbuf ) >= inlen );
-    dbgmsg( msgs, "In readBtPiece" );
+    assert (evbuffer_get_length (inbuf) >= inlen);
+    dbgmsg (msgs, "In readBtPiece");
 
-    if( !req->length )
+    if (!req->length)
     {
-        if( inlen < 8 )
+        if (inlen < 8)
             return READ_LATER;
 
-        tr_peerIoReadUint32( msgs->peer->io, inbuf, &req->index );
-        tr_peerIoReadUint32( msgs->peer->io, inbuf, &req->offset );
+        tr_peerIoReadUint32 (msgs->peer->io, inbuf, &req->index);
+        tr_peerIoReadUint32 (msgs->peer->io, inbuf, &req->offset);
         req->length = msgs->incoming.length - 9;
-        dbgmsg( msgs, "got incoming block header %u:%u->%u", req->index, req->offset, req->length );
+        dbgmsg (msgs, "got incoming block header %u:%u->%u", req->index, req->offset, req->length);
         return READ_NOW;
     }
     else
@@ -1312,27 +1314,27 @@ readBtPiece( tr_peermsgs      * msgs,
         size_t nLeft;
         struct evbuffer * block_buffer;
 
-        if( msgs->incoming.block == NULL )
-            msgs->incoming.block = evbuffer_new( );
+        if (msgs->incoming.block == NULL)
+            msgs->incoming.block = evbuffer_new ();
         block_buffer = msgs->incoming.block;
 
         /* read in another chunk of data */
-        nLeft = req->length - evbuffer_get_length( block_buffer );
-        n = MIN( nLeft, inlen );
+        nLeft = req->length - evbuffer_get_length (block_buffer);
+        n = MIN (nLeft, inlen);
 
-        tr_peerIoReadBytesToBuf( msgs->peer->io, inbuf, block_buffer, n );
+        tr_peerIoReadBytesToBuf (msgs->peer->io, inbuf, block_buffer, n);
 
-        fireClientGotData( msgs, n, true );
+        fireClientGotData (msgs, n, true);
         *setme_piece_bytes_read += n;
-        dbgmsg( msgs, "got %zu bytes for block %u:%u->%u ... %d remain",
+        dbgmsg (msgs, "got %zu bytes for block %u:%u->%u ... %d remain",
                n, req->index, req->offset, req->length,
-               (int)( req->length - evbuffer_get_length( block_buffer ) ) );
-        if( evbuffer_get_length( block_buffer ) < req->length )
+             (int)(req->length - evbuffer_get_length (block_buffer)));
+        if (evbuffer_get_length (block_buffer) < req->length)
             return READ_LATER;
 
         /* pass the block along... */
-        err = clientGotBlock( msgs, block_buffer, req );
-        evbuffer_drain( block_buffer, evbuffer_get_length( block_buffer ) );
+        err = clientGotBlock (msgs, block_buffer, req);
+        evbuffer_drain (block_buffer, evbuffer_get_length (block_buffer));
 
         /* cleanup */
         req->length = 0;
@@ -1341,95 +1343,95 @@ readBtPiece( tr_peermsgs      * msgs,
     }
 }
 
-static void updateDesiredRequestCount( tr_peermsgs * msgs );
+static void updateDesiredRequestCount (tr_peermsgs * msgs);
 
 static int
-readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
+readBtMessage (tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen)
 {
     uint32_t      ui32;
     uint32_t      msglen = msgs->incoming.length;
     const uint8_t id = msgs->incoming.id;
 #ifndef NDEBUG
-    const size_t  startBufLen = evbuffer_get_length( inbuf );
+    const size_t  startBufLen = evbuffer_get_length (inbuf);
 #endif
-    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
+    const bool fext = tr_peerIoSupportsFEXT (msgs->peer->io);
 
     --msglen; /* id length */
 
-    dbgmsg( msgs, "got BT id %d, len %d, buffer size is %zu", (int)id, (int)msglen, inlen );
+    dbgmsg (msgs, "got BT id %d, len %d, buffer size is %zu", (int)id, (int)msglen, inlen);
 
-    if( inlen < msglen )
+    if (inlen < msglen)
         return READ_LATER;
 
-    if( !messageLengthIsCorrect( msgs, id, msglen + 1 ) )
+    if (!messageLengthIsCorrect (msgs, id, msglen + 1))
     {
-        dbgmsg( msgs, "bad packet - BT message #%d with a length of %d", (int)id, (int)msglen );
-        fireError( msgs, EMSGSIZE );
+        dbgmsg (msgs, "bad packet - BT message #%d with a length of %d", (int)id, (int)msglen);
+        fireError (msgs, EMSGSIZE);
         return READ_ERR;
     }
 
-    switch( id )
+    switch (id)
     {
         case BT_CHOKE:
-            dbgmsg( msgs, "got Choke" );
+            dbgmsg (msgs, "got Choke");
             msgs->peer->clientIsChoked = 1;
-            if( !fext )
-                fireGotChoke( msgs );
+            if (!fext)
+                fireGotChoke (msgs);
             break;
 
         case BT_UNCHOKE:
-            dbgmsg( msgs, "got Unchoke" );
+            dbgmsg (msgs, "got Unchoke");
             msgs->peer->clientIsChoked = 0;
-            updateDesiredRequestCount( msgs );
+            updateDesiredRequestCount (msgs);
             break;
 
         case BT_INTERESTED:
-            dbgmsg( msgs, "got Interested" );
+            dbgmsg (msgs, "got Interested");
             msgs->peer->peerIsInterested = 1;
             break;
 
         case BT_NOT_INTERESTED:
-            dbgmsg( msgs, "got Not Interested" );
+            dbgmsg (msgs, "got Not Interested");
             msgs->peer->peerIsInterested = 0;
             break;
 
         case BT_HAVE:
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &ui32 );
-            dbgmsg( msgs, "got Have: %u", ui32 );
-            if( tr_torrentHasMetadata( msgs->torrent )
-                    && ( ui32 >= msgs->torrent->info.pieceCount ) )
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &ui32);
+            dbgmsg (msgs, "got Have: %u", ui32);
+            if (tr_torrentHasMetadata (msgs->torrent)
+                    && (ui32 >= msgs->torrent->info.pieceCount))
             {
-                fireError( msgs, ERANGE );
+                fireError (msgs, ERANGE);
                 return READ_ERR;
             }
 
             /* a peer can send the same HAVE message twice... */
-            if( !tr_bitfieldHas( &msgs->peer->have, ui32 ) ) {
-                tr_bitfieldAdd( &msgs->peer->have, ui32 );
-                fireClientGotHave( msgs, ui32 );
+            if (!tr_bitfieldHas (&msgs->peer->have, ui32)) {
+                tr_bitfieldAdd (&msgs->peer->have, ui32);
+                fireClientGotHave (msgs, ui32);
             }
-            updatePeerProgress( msgs );
+            updatePeerProgress (msgs);
             break;
 
         case BT_BITFIELD: {
-            uint8_t * tmp = tr_new( uint8_t, msglen );
-            dbgmsg( msgs, "got a bitfield" );
-            tr_peerIoReadBytes( msgs->peer->io, inbuf, tmp, msglen );
-            tr_bitfieldSetRaw( &msgs->peer->have, tmp, msglen, tr_torrentHasMetadata( msgs->torrent ) );
-            fireClientGotBitfield( msgs, &msgs->peer->have );
-            updatePeerProgress( msgs );
-            tr_free( tmp );
+            uint8_t * tmp = tr_new (uint8_t, msglen);
+            dbgmsg (msgs, "got a bitfield");
+            tr_peerIoReadBytes (msgs->peer->io, inbuf, tmp, msglen);
+            tr_bitfieldSetRaw (&msgs->peer->have, tmp, msglen, tr_torrentHasMetadata (msgs->torrent));
+            fireClientGotBitfield (msgs, &msgs->peer->have);
+            updatePeerProgress (msgs);
+            tr_free (tmp);
             break;
         }
 
         case BT_REQUEST:
         {
             struct peer_request r;
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.index );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.offset );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.length );
-            dbgmsg( msgs, "got Request: %u:%u->%u", r.index, r.offset, r.length );
-            peerMadeRequest( msgs, &r );
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.index);
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.offset);
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.length);
+            dbgmsg (msgs, "got Request: %u:%u->%u", r.index, r.offset, r.length);
+            peerMadeRequest (msgs, &r);
             break;
         }
 
@@ -1437,80 +1439,80 @@ readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
         {
             int i;
             struct peer_request r;
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.index );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.offset );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.length );
-            tr_historyAdd( &msgs->peer->cancelsSentToClient, tr_time( ), 1 );
-            dbgmsg( msgs, "got a Cancel %u:%u->%u", r.index, r.offset, r.length );
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.index);
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.offset);
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.length);
+            tr_historyAdd (&msgs->peer->cancelsSentToClient, tr_time (), 1);
+            dbgmsg (msgs, "got a Cancel %u:%u->%u", r.index, r.offset, r.length);
 
-            for( i=0; i<msgs->peer->pendingReqsToClient; ++i ) {
+            for (i=0; i<msgs->peer->pendingReqsToClient; ++i) {
                 const struct peer_request * req = msgs->peerAskedFor + i;
-                if( ( req->index == r.index ) && ( req->offset == r.offset ) && ( req->length == r.length ) )
+                if ((req->index == r.index) && (req->offset == r.offset) && (req->length == r.length))
                     break;
             }
 
-            if( i < msgs->peer->pendingReqsToClient )
-                tr_removeElementFromArray( msgs->peerAskedFor, i, sizeof( struct peer_request ),
-                                           msgs->peer->pendingReqsToClient-- );
+            if (i < msgs->peer->pendingReqsToClient)
+                tr_removeElementFromArray (msgs->peerAskedFor, i, sizeof (struct peer_request),
+                                           msgs->peer->pendingReqsToClient--);
             break;
         }
 
         case BT_PIECE:
-            assert( 0 ); /* handled elsewhere! */
+            assert (0); /* handled elsewhere! */
             break;
 
         case BT_PORT:
-            dbgmsg( msgs, "Got a BT_PORT" );
-            tr_peerIoReadUint16( msgs->peer->io, inbuf, &msgs->peer->dht_port );
-            if( msgs->peer->dht_port > 0 )
-                tr_dhtAddNode( getSession(msgs),
-                               tr_peerAddress( msgs->peer ),
-                               msgs->peer->dht_port, 0 );
+            dbgmsg (msgs, "Got a BT_PORT");
+            tr_peerIoReadUint16 (msgs->peer->io, inbuf, &msgs->peer->dht_port);
+            if (msgs->peer->dht_port > 0)
+                tr_dhtAddNode (getSession (msgs),
+                               tr_peerAddress (msgs->peer),
+                               msgs->peer->dht_port, 0);
             break;
 
         case BT_FEXT_SUGGEST:
-            dbgmsg( msgs, "Got a BT_FEXT_SUGGEST" );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &ui32 );
-            if( fext )
-                fireClientGotSuggest( msgs, ui32 );
+            dbgmsg (msgs, "Got a BT_FEXT_SUGGEST");
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &ui32);
+            if (fext)
+                fireClientGotSuggest (msgs, ui32);
             else {
-                fireError( msgs, EMSGSIZE );
+                fireError (msgs, EMSGSIZE);
                 return READ_ERR;
             }
             break;
 
         case BT_FEXT_ALLOWED_FAST:
-            dbgmsg( msgs, "Got a BT_FEXT_ALLOWED_FAST" );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &ui32 );
-            if( fext )
-                fireClientGotAllowedFast( msgs, ui32 );
+            dbgmsg (msgs, "Got a BT_FEXT_ALLOWED_FAST");
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &ui32);
+            if (fext)
+                fireClientGotAllowedFast (msgs, ui32);
             else {
-                fireError( msgs, EMSGSIZE );
+                fireError (msgs, EMSGSIZE);
                 return READ_ERR;
             }
             break;
 
         case BT_FEXT_HAVE_ALL:
-            dbgmsg( msgs, "Got a BT_FEXT_HAVE_ALL" );
-            if( fext ) {
-                tr_bitfieldSetHasAll( &msgs->peer->have );
-assert( tr_bitfieldHasAll( &msgs->peer->have ) );
-                fireClientGotHaveAll( msgs );
-                updatePeerProgress( msgs );
+            dbgmsg (msgs, "Got a BT_FEXT_HAVE_ALL");
+            if (fext) {
+                tr_bitfieldSetHasAll (&msgs->peer->have);
+assert (tr_bitfieldHasAll (&msgs->peer->have));
+                fireClientGotHaveAll (msgs);
+                updatePeerProgress (msgs);
             } else {
-                fireError( msgs, EMSGSIZE );
+                fireError (msgs, EMSGSIZE);
                 return READ_ERR;
             }
             break;
 
         case BT_FEXT_HAVE_NONE:
-            dbgmsg( msgs, "Got a BT_FEXT_HAVE_NONE" );
-            if( fext ) {
-                tr_bitfieldSetHasNone( &msgs->peer->have );
-                fireClientGotHaveNone( msgs );
-                updatePeerProgress( msgs );
+            dbgmsg (msgs, "Got a BT_FEXT_HAVE_NONE");
+            if (fext) {
+                tr_bitfieldSetHasNone (&msgs->peer->have);
+                fireClientGotHaveNone (msgs);
+                updatePeerProgress (msgs);
             } else {
-                fireError( msgs, EMSGSIZE );
+                fireError (msgs, EMSGSIZE);
                 return READ_ERR;
             }
             break;
@@ -1518,32 +1520,32 @@ assert( tr_bitfieldHasAll( &msgs->peer->have ) );
         case BT_FEXT_REJECT:
         {
             struct peer_request r;
-            dbgmsg( msgs, "Got a BT_FEXT_REJECT" );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.index );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.offset );
-            tr_peerIoReadUint32( msgs->peer->io, inbuf, &r.length );
-            if( fext )
-                fireGotRej( msgs, &r );
+            dbgmsg (msgs, "Got a BT_FEXT_REJECT");
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.index);
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.offset);
+            tr_peerIoReadUint32 (msgs->peer->io, inbuf, &r.length);
+            if (fext)
+                fireGotRej (msgs, &r);
             else {
-                fireError( msgs, EMSGSIZE );
+                fireError (msgs, EMSGSIZE);
                 return READ_ERR;
             }
             break;
         }
 
         case BT_LTEP:
-            dbgmsg( msgs, "Got a BT_LTEP" );
-            parseLtep( msgs, msglen, inbuf );
+            dbgmsg (msgs, "Got a BT_LTEP");
+            parseLtep (msgs, msglen, inbuf);
             break;
 
         default:
-            dbgmsg( msgs, "peer sent us an UNKNOWN: %d", (int)id );
-            tr_peerIoDrain( msgs->peer->io, inbuf, msglen );
+            dbgmsg (msgs, "peer sent us an UNKNOWN: %d", (int)id);
+            tr_peerIoDrain (msgs->peer->io, inbuf, msglen);
             break;
     }
 
-    assert( msglen + 1 == msgs->incoming.length );
-    assert( evbuffer_get_length( inbuf ) == startBufLen - msglen );
+    assert (msglen + 1 == msgs->incoming.length);
+    assert (evbuffer_get_length (inbuf) == startBufLen - msglen);
 
     msgs->state = AWAITING_BT_LENGTH;
     return READ_NOW;
@@ -1551,31 +1553,31 @@ assert( tr_bitfieldHasAll( &msgs->peer->have ) );
 
 /* returns 0 on success, or an errno on failure */
 static int
-clientGotBlock( tr_peermsgs                * msgs,
+clientGotBlock (tr_peermsgs                * msgs,
                 struct evbuffer            * data,
-                const struct peer_request  * req )
+                const struct peer_request  * req)
 {
     int err;
     tr_torrent * tor = msgs->torrent;
-    const tr_block_index_t block = _tr_block( tor, req->index, req->offset );
+    const tr_block_index_t block = _tr_block (tor, req->index, req->offset);
 
-    assert( msgs );
-    assert( req );
+    assert (msgs);
+    assert (req);
 
-    if( req->length != tr_torBlockCountBytes( msgs->torrent, block ) ) {
-        dbgmsg( msgs, "wrong block size -- expected %u, got %d",
-                tr_torBlockCountBytes( msgs->torrent, block ), req->length );
+    if (req->length != tr_torBlockCountBytes (msgs->torrent, block)) {
+        dbgmsg (msgs, "wrong block size -- expected %u, got %d",
+                tr_torBlockCountBytes (msgs->torrent, block), req->length);
         return EMSGSIZE;
     }
 
-    dbgmsg( msgs, "got block %u:%u->%u", req->index, req->offset, req->length );
+    dbgmsg (msgs, "got block %u:%u->%u", req->index, req->offset, req->length);
 
-    if( !tr_peerMgrDidPeerRequest( msgs->torrent, msgs->peer, block ) ) {
-        dbgmsg( msgs, "we didn't ask for this message..." );
+    if (!tr_peerMgrDidPeerRequest (msgs->torrent, msgs->peer, block)) {
+        dbgmsg (msgs, "we didn't ask for this message...");
         return 0;
     }
-    if( tr_cpPieceIsComplete( &msgs->torrent->completion, req->index ) ) {
-        dbgmsg( msgs, "we did ask for this message, but the piece is already complete..." );
+    if (tr_cpPieceIsComplete (&msgs->torrent->completion, req->index)) {
+        dbgmsg (msgs, "we did ask for this message, but the piece is already complete...");
         return 0;
     }
 
@@ -1583,78 +1585,78 @@ clientGotBlock( tr_peermsgs                * msgs,
     ***  Save the block
     **/
 
-    if(( err = tr_cacheWriteBlock( getSession(msgs)->cache, tor, req->index, req->offset, req->length, data )))
+    if ((err = tr_cacheWriteBlock (getSession (msgs)->cache, tor, req->index, req->offset, req->length, data)))
         return err;
 
-    tr_bitfieldAdd( &msgs->peer->blame, req->index );
-    fireGotBlock( msgs, req );
+    tr_bitfieldAdd (&msgs->peer->blame, req->index);
+    fireGotBlock (msgs, req);
     return 0;
 }
 
-static int peerPulse( void * vmsgs );
+static int peerPulse (void * vmsgs);
 
 static void
-didWrite( tr_peerIo * io UNUSED, size_t bytesWritten, int wasPieceData, void * vmsgs )
+didWrite (tr_peerIo * io UNUSED, size_t bytesWritten, int wasPieceData, void * vmsgs)
 {
     tr_peermsgs * msgs = vmsgs;
-    firePeerGotData( msgs, bytesWritten, wasPieceData );
+    firePeerGotData (msgs, bytesWritten, wasPieceData);
 
-    if ( tr_isPeerIo( io ) && io->userData )
-        peerPulse( msgs );
+    if (tr_isPeerIo (io) && io->userData)
+        peerPulse (msgs);
 }
 
 static ReadState
-canRead( tr_peerIo * io, void * vmsgs, size_t * piece )
+canRead (tr_peerIo * io, void * vmsgs, size_t * piece)
 {
     ReadState         ret;
     tr_peermsgs *     msgs = vmsgs;
-    struct evbuffer * in = tr_peerIoGetReadBuffer( io );
-    const size_t      inlen = evbuffer_get_length( in );
+    struct evbuffer * in = tr_peerIoGetReadBuffer (io);
+    const size_t      inlen = evbuffer_get_length (in);
 
-    dbgmsg( msgs, "canRead: inlen is %zu, msgs->state is %d", inlen, msgs->state );
+    dbgmsg (msgs, "canRead: inlen is %zu, msgs->state is %d", inlen, msgs->state);
 
-    if( !inlen )
+    if (!inlen)
     {
         ret = READ_LATER;
     }
-    else if( msgs->state == AWAITING_BT_PIECE )
+    else if (msgs->state == AWAITING_BT_PIECE)
     {
-        ret = readBtPiece( msgs, in, inlen, piece );
+        ret = readBtPiece (msgs, in, inlen, piece);
     }
-    else switch( msgs->state )
+    else switch (msgs->state)
     {
         case AWAITING_BT_LENGTH:
-            ret = readBtLength ( msgs, in, inlen ); break;
+            ret = readBtLength (msgs, in, inlen); break;
 
         case AWAITING_BT_ID:
-            ret = readBtId     ( msgs, in, inlen ); break;
+            ret = readBtId   (msgs, in, inlen); break;
 
         case AWAITING_BT_MESSAGE:
-            ret = readBtMessage( msgs, in, inlen ); break;
+            ret = readBtMessage (msgs, in, inlen); break;
 
         default:
             ret = READ_ERR;
-            assert( 0 );
+            assert (0);
     }
 
-    dbgmsg( msgs, "canRead: ret is %d", (int)ret );
+    dbgmsg (msgs, "canRead: ret is %d", (int)ret);
 
     /* log the raw data that was read */
-    if( ( ret != READ_ERR ) && ( evbuffer_get_length( in ) != inlen ) )
-        fireClientGotData( msgs, inlen - evbuffer_get_length( in ), false );
+    if ((ret != READ_ERR) && (evbuffer_get_length (in) != inlen))
+        fireClientGotData (msgs, inlen - evbuffer_get_length (in), false);
 
     return ret;
 }
 
 int
-tr_peerMsgsIsReadingBlock( const tr_peermsgs * msgs, tr_block_index_t block )
+tr_peerMsgsIsReadingBlock (const tr_peermsgs * msgs, tr_block_index_t block)
 {
-    if( msgs->state != AWAITING_BT_PIECE )
+    if (msgs->state != AWAITING_BT_PIECE)
         return false;
 
-    return block == _tr_block( msgs->torrent,
+    return block == _tr_block (msgs->torrent,
                                msgs->incoming.blockReq.index,
-                               msgs->incoming.blockReq.offset );
+                               msgs->incoming.blockReq.offset);
 }
 
 /**
@@ -1662,14 +1664,14 @@ tr_peerMsgsIsReadingBlock( const tr_peermsgs * msgs, tr_block_index_t block )
 **/
 
 static void
-updateDesiredRequestCount( tr_peermsgs * msgs )
+updateDesiredRequestCount (tr_peermsgs * msgs)
 {
     const tr_torrent * const torrent = msgs->torrent;
 
     /* there are lots of reasons we might not want to request any blocks... */
-    if( tr_torrentIsSeed( torrent ) || !tr_torrentHasMetadata( torrent )
+    if (tr_torrentIsSeed (torrent) || !tr_torrentHasMetadata (torrent)
                                     || msgs->peer->clientIsChoked
-                                    || !msgs->peer->clientIsInterested )
+                                    || !msgs->peer->clientIsInterested)
     {
         msgs->desiredRequestCount = 0;
     }
@@ -1680,114 +1682,114 @@ updateDesiredRequestCount( tr_peermsgs * msgs )
         unsigned int irate_Bps;
         const int floor = 4;
         const int seconds = REQUEST_BUF_SECS;
-        const uint64_t now = tr_time_msec( );
+        const uint64_t now = tr_time_msec ();
 
         /* Get the rate limit we should use.
          * FIXME: this needs to consider all the other peers as well... */
-        rate_Bps = tr_peerGetPieceSpeed_Bps( msgs->peer, now, TR_PEER_TO_CLIENT );
-        if( tr_torrentUsesSpeedLimit( torrent, TR_PEER_TO_CLIENT ) )
-            rate_Bps = MIN( rate_Bps, tr_torrentGetSpeedLimit_Bps( torrent, TR_PEER_TO_CLIENT ) );
+        rate_Bps = tr_peerGetPieceSpeed_Bps (msgs->peer, now, TR_PEER_TO_CLIENT);
+        if (tr_torrentUsesSpeedLimit (torrent, TR_PEER_TO_CLIENT))
+            rate_Bps = MIN (rate_Bps, tr_torrentGetSpeedLimit_Bps (torrent, TR_PEER_TO_CLIENT));
 
         /* honor the session limits, if enabled */
-        if( tr_torrentUsesSessionLimits( torrent ) &&
-	    tr_sessionGetActiveSpeedLimit_Bps( torrent->session, TR_PEER_TO_CLIENT, &irate_Bps ) )
-                rate_Bps = MIN( rate_Bps, irate_Bps );
+        if (tr_torrentUsesSessionLimits (torrent) &&
+	    tr_sessionGetActiveSpeedLimit_Bps (torrent->session, TR_PEER_TO_CLIENT, &irate_Bps))
+                rate_Bps = MIN (rate_Bps, irate_Bps);
 
         /* use this desired rate to figure out how
          * many requests we should send to this peer */
-        estimatedBlocksInPeriod = ( rate_Bps * seconds ) / torrent->blockSize;
-        msgs->desiredRequestCount = MAX( floor, estimatedBlocksInPeriod );
+        estimatedBlocksInPeriod = (rate_Bps * seconds) / torrent->blockSize;
+        msgs->desiredRequestCount = MAX (floor, estimatedBlocksInPeriod);
 
         /* honor the peer's maximum request count, if specified */
-        if( msgs->reqq > 0 )
-            if( msgs->desiredRequestCount > msgs->reqq )
+        if (msgs->reqq > 0)
+            if (msgs->desiredRequestCount > msgs->reqq)
                 msgs->desiredRequestCount = msgs->reqq;
     }
 }
 
 static void
-updateMetadataRequests( tr_peermsgs * msgs, time_t now )
+updateMetadataRequests (tr_peermsgs * msgs, time_t now)
 {
     int piece;
 
-    if( msgs->peerSupportsMetadataXfer
-        && tr_torrentGetNextMetadataRequest( msgs->torrent, now, &piece ) )
+    if (msgs->peerSupportsMetadataXfer
+        && tr_torrentGetNextMetadataRequest (msgs->torrent, now, &piece))
     {
         tr_benc tmp;
         struct evbuffer * payload;
         struct evbuffer * out = msgs->outMessages;
 
         /* build the data message */
-        tr_bencInitDict( &tmp, 3 );
-        tr_bencDictAddInt( &tmp, "msg_type", METADATA_MSG_TYPE_REQUEST );
-        tr_bencDictAddInt( &tmp, "piece", piece );
-        payload = tr_bencToBuf( &tmp, TR_FMT_BENC );
+        tr_bencInitDict (&tmp, 3);
+        tr_bencDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REQUEST);
+        tr_bencDictAddInt (&tmp, "piece", piece);
+        payload = tr_bencToBuf (&tmp, TR_FMT_BENC);
 
-        dbgmsg( msgs, "requesting metadata piece #%d", piece );
+        dbgmsg (msgs, "requesting metadata piece #%d", piece);
 
         /* write it out as a LTEP message to our outMessages buffer */
-        evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + evbuffer_get_length( payload ) );
-        evbuffer_add_uint8 ( out, BT_LTEP );
-        evbuffer_add_uint8 ( out, msgs->ut_metadata_id );
-        evbuffer_add_buffer( out, payload );
-        pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
-        dbgOutMessageLen( msgs );
+        evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload));
+        evbuffer_add_uint8 (out, BT_LTEP);
+        evbuffer_add_uint8 (out, msgs->ut_metadata_id);
+        evbuffer_add_buffer (out, payload);
+        pokeBatchPeriod (msgs, HIGH_PRIORITY_INTERVAL_SECS);
+        dbgOutMessageLen (msgs);
 
         /* cleanup */
-        evbuffer_free( payload );
-        tr_bencFree( &tmp );
+        evbuffer_free (payload);
+        tr_bencFree (&tmp);
     }
 }
 
 static void
-updateBlockRequests( tr_peermsgs * msgs )
+updateBlockRequests (tr_peermsgs * msgs)
 {
-    if( tr_torrentIsPieceTransferAllowed( msgs->torrent, TR_PEER_TO_CLIENT )
-        && ( msgs->desiredRequestCount > 0 )
-        && ( msgs->peer->pendingReqsToPeer <= ( msgs->desiredRequestCount * 0.66 ) ) )
+    if (tr_torrentIsPieceTransferAllowed (msgs->torrent, TR_PEER_TO_CLIENT)
+        && (msgs->desiredRequestCount > 0)
+        && (msgs->peer->pendingReqsToPeer <= (msgs->desiredRequestCount * 0.66)))
     {
         int i;
         int n;
         const int numwant = msgs->desiredRequestCount - msgs->peer->pendingReqsToPeer;
-        tr_block_index_t * blocks = tr_new( tr_block_index_t, numwant );
+        tr_block_index_t * blocks = tr_new (tr_block_index_t, numwant);
 
-        tr_peerMgrGetNextRequests( msgs->torrent, msgs->peer, numwant, blocks, &n, false );
+        tr_peerMgrGetNextRequests (msgs->torrent, msgs->peer, numwant, blocks, &n, false);
 
-        for( i=0; i<n; ++i )
+        for (i=0; i<n; ++i)
         {
             struct peer_request req;
-            blockToReq( msgs->torrent, blocks[i], &req );
-            protocolSendRequest( msgs, &req );
+            blockToReq (msgs->torrent, blocks[i], &req);
+            protocolSendRequest (msgs, &req);
         }
 
-        tr_free( blocks );
+        tr_free (blocks);
     }
 }
 
 static size_t
-fillOutputBuffer( tr_peermsgs * msgs, time_t now )
+fillOutputBuffer (tr_peermsgs * msgs, time_t now)
 {
     int piece;
     size_t bytesWritten = 0;
     struct peer_request req;
-    const bool haveMessages = evbuffer_get_length( msgs->outMessages ) != 0;
-    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
+    const bool haveMessages = evbuffer_get_length (msgs->outMessages) != 0;
+    const bool fext = tr_peerIoSupportsFEXT (msgs->peer->io);
 
     /**
     ***  Protocol messages
     **/
 
-    if( haveMessages && !msgs->outMessagesBatchedAt ) /* fresh batch */
+    if (haveMessages && !msgs->outMessagesBatchedAt) /* fresh batch */
     {
-        dbgmsg( msgs, "started an outMessages batch (length is %zu)", evbuffer_get_length( msgs->outMessages ) );
+        dbgmsg (msgs, "started an outMessages batch (length is %zu)", evbuffer_get_length (msgs->outMessages));
         msgs->outMessagesBatchedAt = now;
     }
-    else if( haveMessages && ( ( now - msgs->outMessagesBatchedAt ) >= msgs->outMessagesBatchPeriod ) )
+    else if (haveMessages && ((now - msgs->outMessagesBatchedAt) >= msgs->outMessagesBatchPeriod))
     {
-        const size_t len = evbuffer_get_length( msgs->outMessages );
+        const size_t len = evbuffer_get_length (msgs->outMessages);
         /* flush the protocol messages */
-        dbgmsg( msgs, "flushing outMessages... to %p (length is %zu)", msgs->peer->io, len );
-        tr_peerIoWriteBuf( msgs->peer->io, msgs->outMessages, false );
+        dbgmsg (msgs, "flushing outMessages... to %p (length is %zu)", msgs->peer->io, len);
+        tr_peerIoWriteBuf (msgs->peer->io, msgs->outMessages, false);
         msgs->clientSentAnythingAt = now;
         msgs->outMessagesBatchedAt = 0;
         msgs->outMessagesBatchPeriod = LOW_PRIORITY_INTERVAL_SECS;
@@ -1798,65 +1800,65 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
     ***  Metadata Pieces
     **/
 
-    if( ( tr_peerIoGetWriteBufferSpace( msgs->peer->io, now ) >= METADATA_PIECE_SIZE )
-        && popNextMetadataRequest( msgs, &piece ) )
+    if ((tr_peerIoGetWriteBufferSpace (msgs->peer->io, now) >= METADATA_PIECE_SIZE)
+        && popNextMetadataRequest (msgs, &piece))
     {
         char * data;
         int dataLen;
         bool ok = false;
 
-        data = tr_torrentGetMetadataPiece( msgs->torrent, piece, &dataLen );
-        if( ( dataLen > 0 ) && ( data != NULL ) )
+        data = tr_torrentGetMetadataPiece (msgs->torrent, piece, &dataLen);
+        if ((dataLen > 0) && (data != NULL))
         {
             tr_benc tmp;
             struct evbuffer * payload;
             struct evbuffer * out = msgs->outMessages;
 
             /* build the data message */
-            tr_bencInitDict( &tmp, 3 );
-            tr_bencDictAddInt( &tmp, "msg_type", METADATA_MSG_TYPE_DATA );
-            tr_bencDictAddInt( &tmp, "piece", piece );
-            tr_bencDictAddInt( &tmp, "total_size", msgs->torrent->infoDictLength );
-            payload = tr_bencToBuf( &tmp, TR_FMT_BENC );
+            tr_bencInitDict (&tmp, 3);
+            tr_bencDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_DATA);
+            tr_bencDictAddInt (&tmp, "piece", piece);
+            tr_bencDictAddInt (&tmp, "total_size", msgs->torrent->infoDictLength);
+            payload = tr_bencToBuf (&tmp, TR_FMT_BENC);
 
             /* write it out as a LTEP message to our outMessages buffer */
-            evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + evbuffer_get_length( payload ) + dataLen );
-            evbuffer_add_uint8 ( out, BT_LTEP );
-            evbuffer_add_uint8 ( out, msgs->ut_metadata_id );
-            evbuffer_add_buffer( out, payload );
-            evbuffer_add       ( out, data, dataLen );
-            pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
-            dbgOutMessageLen( msgs );
-
-            evbuffer_free( payload );
-            tr_bencFree( &tmp );
-            tr_free( data );
+            evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload) + dataLen);
+            evbuffer_add_uint8 (out, BT_LTEP);
+            evbuffer_add_uint8 (out, msgs->ut_metadata_id);
+            evbuffer_add_buffer (out, payload);
+            evbuffer_add     (out, data, dataLen);
+            pokeBatchPeriod (msgs, HIGH_PRIORITY_INTERVAL_SECS);
+            dbgOutMessageLen (msgs);
+
+            evbuffer_free (payload);
+            tr_bencFree (&tmp);
+            tr_free (data);
 
             ok = true;
         }
 
-        if( !ok ) /* send a rejection message */
+        if (!ok) /* send a rejection message */
         {
             tr_benc tmp;
             struct evbuffer * payload;
             struct evbuffer * out = msgs->outMessages;
 
             /* build the rejection message */
-            tr_bencInitDict( &tmp, 2 );
-            tr_bencDictAddInt( &tmp, "msg_type", METADATA_MSG_TYPE_REJECT );
-            tr_bencDictAddInt( &tmp, "piece", piece );
-            payload = tr_bencToBuf( &tmp, TR_FMT_BENC );
+            tr_bencInitDict (&tmp, 2);
+            tr_bencDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REJECT);
+            tr_bencDictAddInt (&tmp, "piece", piece);
+            payload = tr_bencToBuf (&tmp, TR_FMT_BENC);
 
             /* write it out as a LTEP message to our outMessages buffer */
-            evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + evbuffer_get_length( payload ) );
-            evbuffer_add_uint8 ( out, BT_LTEP );
-            evbuffer_add_uint8 ( out, msgs->ut_metadata_id );
-            evbuffer_add_buffer( out, payload );
-            pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
-            dbgOutMessageLen( msgs );
-
-            evbuffer_free( payload );
-            tr_bencFree( &tmp );
+            evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload));
+            evbuffer_add_uint8 (out, BT_LTEP);
+            evbuffer_add_uint8 (out, msgs->ut_metadata_id);
+            evbuffer_add_buffer (out, payload);
+            pokeBatchPeriod (msgs, HIGH_PRIORITY_INTERVAL_SECS);
+            dbgOutMessageLen (msgs);
+
+            evbuffer_free (payload);
+            tr_bencFree (&tmp);
         }
     }
 
@@ -1864,158 +1866,158 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
     ***  Data Blocks
     **/
 
-    if( ( tr_peerIoGetWriteBufferSpace( msgs->peer->io, now ) >= msgs->torrent->blockSize )
-        && popNextRequest( msgs, &req ) )
+    if ((tr_peerIoGetWriteBufferSpace (msgs->peer->io, now) >= msgs->torrent->blockSize)
+        && popNextRequest (msgs, &req))
     {
         --msgs->prefetchCount;
 
-        if( requestIsValid( msgs, &req )
-            && tr_cpPieceIsComplete( &msgs->torrent->completion, req.index ) )
+        if (requestIsValid (msgs, &req)
+            && tr_cpPieceIsComplete (&msgs->torrent->completion, req.index))
         {
             int err;
             const uint32_t msglen = 4 + 1 + 4 + 4 + req.length;
             struct evbuffer * out;
             struct evbuffer_iovec iovec[1];
 
-            out = evbuffer_new( );
-            evbuffer_expand( out, msglen );
+            out = evbuffer_new ();
+            evbuffer_expand (out, msglen);
 
-            evbuffer_add_uint32( out, sizeof( uint8_t ) + 2 * sizeof( uint32_t ) + req.length );
-            evbuffer_add_uint8 ( out, BT_PIECE );
-            evbuffer_add_uint32( out, req.index );
-            evbuffer_add_uint32( out, req.offset );
+            evbuffer_add_uint32 (out, sizeof (uint8_t) + 2 * sizeof (uint32_t) + req.length);
+            evbuffer_add_uint8 (out, BT_PIECE);
+            evbuffer_add_uint32 (out, req.index);
+            evbuffer_add_uint32 (out, req.offset);
 
-            evbuffer_reserve_space( out, req.length, iovec, 1 );
-            err = tr_cacheReadBlock( getSession(msgs)->cache, msgs->torrent, req.index, req.offset, req.length, iovec[0].iov_base );
+            evbuffer_reserve_space (out, req.length, iovec, 1);
+            err = tr_cacheReadBlock (getSession (msgs)->cache, msgs->torrent, req.index, req.offset, req.length, iovec[0].iov_base);
             iovec[0].iov_len = req.length;
-            evbuffer_commit_space( out, iovec, 1 );
+            evbuffer_commit_space (out, iovec, 1);
 
             /* check the piece if it needs checking... */
-            if( !err && tr_torrentPieceNeedsCheck( msgs->torrent, req.index ) )
-                if(( err = !tr_torrentCheckPiece( msgs->torrent, req.index )))
-                    tr_torrentSetLocalError( msgs->torrent, _( "Please Verify Local Data! Piece #%zu is corrupt." ), (size_t)req.index );
+            if (!err && tr_torrentPieceNeedsCheck (msgs->torrent, req.index))
+                if ((err = !tr_torrentCheckPiece (msgs->torrent, req.index)))
+                    tr_torrentSetLocalError (msgs->torrent, _ ("Please Verify Local Data! Piece #%zu is corrupt."), (size_t)req.index);
 
-            if( err )
+            if (err)
             {
-                if( fext )
-                    protocolSendReject( msgs, &req );
+                if (fext)
+                    protocolSendReject (msgs, &req);
             }
             else
             {
-                const size_t n = evbuffer_get_length( out );
-                dbgmsg( msgs, "sending block %u:%u->%u", req.index, req.offset, req.length );
-                assert( n == msglen );
-                tr_peerIoWriteBuf( msgs->peer->io, out, true );
+                const size_t n = evbuffer_get_length (out);
+                dbgmsg (msgs, "sending block %u:%u->%u", req.index, req.offset, req.length);
+                assert (n == msglen);
+                tr_peerIoWriteBuf (msgs->peer->io, out, true);
                 bytesWritten += n;
                 msgs->clientSentAnythingAt = now;
-                tr_historyAdd( &msgs->peer->blocksSentToPeer, tr_time( ), 1 );
+                tr_historyAdd (&msgs->peer->blocksSentToPeer, tr_time (), 1);
             }
 
-            evbuffer_free( out );
+            evbuffer_free (out);
 
-            if( err )
+            if (err)
             {
                 bytesWritten = 0;
                 msgs = NULL;
             }
         }
-        else if( fext ) /* peer needs a reject message */
+        else if (fext) /* peer needs a reject message */
         {
-            protocolSendReject( msgs, &req );
+            protocolSendReject (msgs, &req);
         }
 
-        if( msgs != NULL )
-            prefetchPieces( msgs );
+        if (msgs != NULL)
+            prefetchPieces (msgs);
     }
 
     /**
     ***  Keepalive
     **/
 
-    if( ( msgs != NULL )
-        && ( msgs->clientSentAnythingAt != 0 )
-        && ( ( now - msgs->clientSentAnythingAt ) > KEEPALIVE_INTERVAL_SECS ) )
+    if ((msgs != NULL)
+        && (msgs->clientSentAnythingAt != 0)
+        && ((now - msgs->clientSentAnythingAt) > KEEPALIVE_INTERVAL_SECS))
     {
-        dbgmsg( msgs, "sending a keepalive message" );
-        evbuffer_add_uint32( msgs->outMessages, 0 );
-        pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
+        dbgmsg (msgs, "sending a keepalive message");
+        evbuffer_add_uint32 (msgs->outMessages, 0);
+        pokeBatchPeriod (msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS);
     }
 
     return bytesWritten;
 }
 
 static int
-peerPulse( void * vmsgs )
+peerPulse (void * vmsgs)
 {
     tr_peermsgs * msgs = vmsgs;
-    const time_t  now = tr_time( );
+    const time_t  now = tr_time ();
 
-    if ( tr_isPeerIo( msgs->peer->io ) ) {
-        updateDesiredRequestCount( msgs );
-        updateBlockRequests( msgs );
-        updateMetadataRequests( msgs, now );
+    if (tr_isPeerIo (msgs->peer->io)) {
+        updateDesiredRequestCount (msgs);
+        updateBlockRequests (msgs);
+        updateMetadataRequests (msgs, now);
     }
 
-    for( ;; )
-        if( fillOutputBuffer( msgs, now ) < 1 )
+    for (;;)
+        if (fillOutputBuffer (msgs, now) < 1)
             break;
 
     return true; /* loop forever */
 }
 
 void
-tr_peerMsgsPulse( tr_peermsgs * msgs )
+tr_peerMsgsPulse (tr_peermsgs * msgs)
 {
-    if( msgs != NULL )
-        peerPulse( msgs );
+    if (msgs != NULL)
+        peerPulse (msgs);
 }
 
 static void
-gotError( tr_peerIo * io UNUSED, short what, void * vmsgs )
+gotError (tr_peerIo * io UNUSED, short what, void * vmsgs)
 {
-    if( what & BEV_EVENT_TIMEOUT )
-        dbgmsg( vmsgs, "libevent got a timeout, what=%hd", what );
-    if( what & ( BEV_EVENT_EOF | BEV_EVENT_ERROR ) )
-        dbgmsg( vmsgs, "libevent got an error! what=%hd, errno=%d (%s)",
-               what, errno, tr_strerror( errno ) );
-    fireError( vmsgs, ENOTCONN );
+    if (what & BEV_EVENT_TIMEOUT)
+        dbgmsg (vmsgs, "libevent got a timeout, what=%hd", what);
+    if (what & (BEV_EVENT_EOF | BEV_EVENT_ERROR))
+        dbgmsg (vmsgs, "libevent got an error! what=%hd, errno=%d (%s)",
+               what, errno, tr_strerror (errno));
+    fireError (vmsgs, ENOTCONN);
 }
 
 static void
-sendBitfield( tr_peermsgs * msgs )
+sendBitfield (tr_peermsgs * msgs)
 {
     void * bytes;
     size_t byte_count = 0;
     struct evbuffer * out = msgs->outMessages;
 
-    assert( tr_torrentHasMetadata( msgs->torrent ) );
+    assert (tr_torrentHasMetadata (msgs->torrent));
 
-    bytes = tr_cpCreatePieceBitfield( &msgs->torrent->completion, &byte_count );
-    evbuffer_add_uint32( out, sizeof( uint8_t ) + byte_count );
-    evbuffer_add_uint8 ( out, BT_BITFIELD );
-    evbuffer_add       ( out, bytes, byte_count );
-    dbgmsg( msgs, "sending bitfield... outMessage size is now %zu", evbuffer_get_length( out ) );
-    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
+    bytes = tr_cpCreatePieceBitfield (&msgs->torrent->completion, &byte_count);
+    evbuffer_add_uint32 (out, sizeof (uint8_t) + byte_count);
+    evbuffer_add_uint8 (out, BT_BITFIELD);
+    evbuffer_add     (out, bytes, byte_count);
+    dbgmsg (msgs, "sending bitfield... outMessage size is now %zu", evbuffer_get_length (out));
+    pokeBatchPeriod (msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS);
 
-    tr_free( bytes );
+    tr_free (bytes);
 }
 
 static void
-tellPeerWhatWeHave( tr_peermsgs * msgs )
+tellPeerWhatWeHave (tr_peermsgs * msgs)
 {
-    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
+    const bool fext = tr_peerIoSupportsFEXT (msgs->peer->io);
 
-    if( fext && tr_cpHasAll( &msgs->torrent->completion ) )
+    if (fext && tr_cpHasAll (&msgs->torrent->completion))
     {
-        protocolSendHaveAll( msgs );
+        protocolSendHaveAll (msgs);
     }
-    else if( fext && tr_cpHasNone( &msgs->torrent->completion ) )
+    else if (fext && tr_cpHasNone (&msgs->torrent->completion))
     {
-        protocolSendHaveNone( msgs );
+        protocolSendHaveNone (msgs);
     }
-    else if( !tr_cpHasNone( &msgs->torrent->completion ) )
+    else if (!tr_cpHasNone (&msgs->torrent->completion))
     {
-        sendBitfield( msgs );
+        sendBitfield (msgs);
     }
 }
 
@@ -2041,12 +2043,12 @@ typedef struct
 PexDiffs;
 
 static void
-pexAddedCb( void * vpex, void * userData )
+pexAddedCb (void * vpex, void * userData)
 {
     PexDiffs * diffs = userData;
     tr_pex *   pex = vpex;
 
-    if( diffs->addedCount < MAX_PEX_ADDED )
+    if (diffs->addedCount < MAX_PEX_ADDED)
     {
         diffs->added[diffs->addedCount++] = *pex;
         diffs->elements[diffs->elementCount++] = *pex;
@@ -2054,19 +2056,19 @@ pexAddedCb( void * vpex, void * userData )
 }
 
 static inline void
-pexDroppedCb( void * vpex, void * userData )
+pexDroppedCb (void * vpex, void * userData)
 {
     PexDiffs * diffs = userData;
     tr_pex *   pex = vpex;
 
-    if( diffs->droppedCount < MAX_PEX_DROPPED )
+    if (diffs->droppedCount < MAX_PEX_DROPPED)
     {
         diffs->dropped[diffs->droppedCount++] = *pex;
     }
 }
 
 static inline void
-pexElementCb( void * vpex, void * userData )
+pexElementCb (void * vpex, void * userData)
 {
     PexDiffs * diffs = userData;
     tr_pex * pex = vpex;
@@ -2074,7 +2076,7 @@ pexElementCb( void * vpex, void * userData )
     diffs->elements[diffs->elementCount++] = *pex;
 }
 
-typedef void ( tr_set_func )( void * element, void * userData );
+typedef void (tr_set_func)(void * element, void * userData);
 
 /**
  * @brief find the differences and commonalities in two sorted sets
@@ -2090,50 +2092,50 @@ typedef void ( tr_set_func )( void * element, void * userData );
  * @param userData user data passed along to in_a, in_b, and in_both
  */
 static void
-tr_set_compare( const void * va, size_t aCount,
+tr_set_compare (const void * va, size_t aCount,
                 const void * vb, size_t bCount,
-                int compare( const void * a, const void * b ),
+                int compare (const void * a, const void * b),
                 size_t elementSize,
                 tr_set_func in_a_cb,
                 tr_set_func in_b_cb,
                 tr_set_func in_both_cb,
-                void * userData )
+                void * userData)
 {
     const uint8_t * a = va;
     const uint8_t * b = vb;
     const uint8_t * aend = a + elementSize * aCount;
     const uint8_t * bend = b + elementSize * bCount;
 
-    while( a != aend || b != bend )
+    while (a != aend || b != bend)
     {
-        if( a == aend )
+        if (a == aend)
         {
-            ( *in_b_cb )( (void*)b, userData );
+          (*in_b_cb)((void*)b, userData);
             b += elementSize;
         }
-        else if( b == bend )
+        else if (b == bend)
         {
-            ( *in_a_cb )( (void*)a, userData );
+          (*in_a_cb)((void*)a, userData);
             a += elementSize;
         }
         else
         {
-            const int val = ( *compare )( a, b );
+            const int val = (*compare)(a, b);
 
-            if( !val )
+            if (!val)
             {
-                ( *in_both_cb )( (void*)a, userData );
+              (*in_both_cb)((void*)a, userData);
                 a += elementSize;
                 b += elementSize;
             }
-            else if( val < 0 )
+            else if (val < 0)
             {
-                ( *in_a_cb )( (void*)a, userData );
+              (*in_a_cb)((void*)a, userData);
                 a += elementSize;
             }
-            else if( val > 0 )
+            else if (val > 0)
             {
-                ( *in_b_cb )( (void*)b, userData );
+              (*in_b_cb)((void*)b, userData);
                 b += elementSize;
             }
         }
@@ -2142,51 +2144,51 @@ tr_set_compare( const void * va, size_t aCount,
 
 
 static void
-sendPex( tr_peermsgs * msgs )
+sendPex (tr_peermsgs * msgs)
 {
-    if( msgs->peerSupportsPex && tr_torrentAllowsPex( msgs->torrent ) )
+    if (msgs->peerSupportsPex && tr_torrentAllowsPex (msgs->torrent))
     {
         PexDiffs diffs;
         PexDiffs diffs6;
         tr_pex * newPex = NULL;
         tr_pex * newPex6 = NULL;
-        const int newCount = tr_peerMgrGetPeers( msgs->torrent, &newPex, TR_AF_INET, TR_PEERS_CONNECTED, MAX_PEX_PEER_COUNT );
-        const int newCount6 = tr_peerMgrGetPeers( msgs->torrent, &newPex6, TR_AF_INET6, TR_PEERS_CONNECTED, MAX_PEX_PEER_COUNT );
+        const int newCount = tr_peerMgrGetPeers (msgs->torrent, &newPex, TR_AF_INET, TR_PEERS_CONNECTED, MAX_PEX_PEER_COUNT);
+        const int newCount6 = tr_peerMgrGetPeers (msgs->torrent, &newPex6, TR_AF_INET6, TR_PEERS_CONNECTED, MAX_PEX_PEER_COUNT);
 
         /* build the diffs */
-        diffs.added = tr_new( tr_pex, newCount );
+        diffs.added = tr_new (tr_pex, newCount);
         diffs.addedCount = 0;
-        diffs.dropped = tr_new( tr_pex, msgs->pexCount );
+        diffs.dropped = tr_new (tr_pex, msgs->pexCount);
         diffs.droppedCount = 0;
-        diffs.elements = tr_new( tr_pex, newCount + msgs->pexCount );
+        diffs.elements = tr_new (tr_pex, newCount + msgs->pexCount);
         diffs.elementCount = 0;
-        tr_set_compare( msgs->pex, msgs->pexCount,
+        tr_set_compare (msgs->pex, msgs->pexCount,
                         newPex, newCount,
-                        tr_pexCompare, sizeof( tr_pex ),
-                        pexDroppedCb, pexAddedCb, pexElementCb, &diffs );
-        diffs6.added = tr_new( tr_pex, newCount6 );
+                        tr_pexCompare, sizeof (tr_pex),
+                        pexDroppedCb, pexAddedCb, pexElementCb, &diffs);
+        diffs6.added = tr_new (tr_pex, newCount6);
         diffs6.addedCount = 0;
-        diffs6.dropped = tr_new( tr_pex, msgs->pexCount6 );
+        diffs6.dropped = tr_new (tr_pex, msgs->pexCount6);
         diffs6.droppedCount = 0;
-        diffs6.elements = tr_new( tr_pex, newCount6 + msgs->pexCount6 );
+        diffs6.elements = tr_new (tr_pex, newCount6 + msgs->pexCount6);
         diffs6.elementCount = 0;
-        tr_set_compare( msgs->pex6, msgs->pexCount6,
+        tr_set_compare (msgs->pex6, msgs->pexCount6,
                         newPex6, newCount6,
-                        tr_pexCompare, sizeof( tr_pex ),
-                        pexDroppedCb, pexAddedCb, pexElementCb, &diffs6 );
-        dbgmsg(
+                        tr_pexCompare, sizeof (tr_pex),
+                        pexDroppedCb, pexAddedCb, pexElementCb, &diffs6);
+        dbgmsg (
             msgs,
             "pex: old peer count %d+%d, new peer count %d+%d, "
             "added %d+%d, removed %d+%d",
             msgs->pexCount, msgs->pexCount6, newCount, newCount6,
             diffs.addedCount, diffs6.addedCount,
-            diffs.droppedCount, diffs6.droppedCount );
+            diffs.droppedCount, diffs6.droppedCount);
 
-        if( !diffs.addedCount && !diffs.droppedCount && !diffs6.addedCount &&
-            !diffs6.droppedCount )
+        if (!diffs.addedCount && !diffs.droppedCount && !diffs6.addedCount &&
+            !diffs6.droppedCount)
         {
-            tr_free( diffs.elements );
-            tr_free( diffs6.elements );
+            tr_free (diffs.elements);
+            tr_free (diffs6.elements);
         }
         else
         {
@@ -2197,126 +2199,126 @@ sendPex( tr_peermsgs * msgs )
             struct evbuffer * out = msgs->outMessages;
 
             /* update peer */
-            tr_free( msgs->pex );
+            tr_free (msgs->pex);
             msgs->pex = diffs.elements;
             msgs->pexCount = diffs.elementCount;
-            tr_free( msgs->pex6 );
+            tr_free (msgs->pex6);
             msgs->pex6 = diffs6.elements;
             msgs->pexCount6 = diffs6.elementCount;
 
             /* build the pex payload */
-            tr_bencInitDict( &val, 3 ); /* ipv6 support: left as 3:
+            tr_bencInitDict (&val, 3); /* ipv6 support: left as 3:
                                          * speed vs. likelihood? */
 
-            if( diffs.addedCount > 0)
+            if (diffs.addedCount > 0)
             {
                 /* "added" */
-                tmp = walk = tr_new( uint8_t, diffs.addedCount * 6 );
-                for( i = 0; i < diffs.addedCount; ++i ) {
-                    memcpy( walk, &diffs.added[i].addr.addr, 4 ); walk += 4;
-                    memcpy( walk, &diffs.added[i].port, 2 ); walk += 2;
+                tmp = walk = tr_new (uint8_t, diffs.addedCount * 6);
+                for (i = 0; i < diffs.addedCount; ++i) {
+                    memcpy (walk, &diffs.added[i].addr.addr, 4); walk += 4;
+                    memcpy (walk, &diffs.added[i].port, 2); walk += 2;
                 }
-                assert( ( walk - tmp ) == diffs.addedCount * 6 );
-                tr_bencDictAddRaw( &val, "added", tmp, walk - tmp );
-                tr_free( tmp );
+                assert ((walk - tmp) == diffs.addedCount * 6);
+                tr_bencDictAddRaw (&val, "added", tmp, walk - tmp);
+                tr_free (tmp);
 
                 /* "added.f"
                  * unset each holepunch flag because we don't support it. */
-                tmp = walk = tr_new( uint8_t, diffs.addedCount );
-                for( i = 0; i < diffs.addedCount; ++i )
+                tmp = walk = tr_new (uint8_t, diffs.addedCount);
+                for (i = 0; i < diffs.addedCount; ++i)
                     *walk++ = diffs.added[i].flags & ~ADDED_F_HOLEPUNCH;
-                assert( ( walk - tmp ) == diffs.addedCount );
-                tr_bencDictAddRaw( &val, "added.f", tmp, walk - tmp );
-                tr_free( tmp );
+                assert ((walk - tmp) == diffs.addedCount);
+                tr_bencDictAddRaw (&val, "added.f", tmp, walk - tmp);
+                tr_free (tmp);
             }
 
-            if( diffs.droppedCount > 0 )
+            if (diffs.droppedCount > 0)
             {
                 /* "dropped" */
-                tmp = walk = tr_new( uint8_t, diffs.droppedCount * 6 );
-                for( i = 0; i < diffs.droppedCount; ++i ) {
-                    memcpy( walk, &diffs.dropped[i].addr.addr, 4 ); walk += 4;
-                    memcpy( walk, &diffs.dropped[i].port, 2 ); walk += 2;
+                tmp = walk = tr_new (uint8_t, diffs.droppedCount * 6);
+                for (i = 0; i < diffs.droppedCount; ++i) {
+                    memcpy (walk, &diffs.dropped[i].addr.addr, 4); walk += 4;
+                    memcpy (walk, &diffs.dropped[i].port, 2); walk += 2;
                 }
-                assert( ( walk - tmp ) == diffs.droppedCount * 6 );
-                tr_bencDictAddRaw( &val, "dropped", tmp, walk - tmp );
-                tr_free( tmp );
+                assert ((walk - tmp) == diffs.droppedCount * 6);
+                tr_bencDictAddRaw (&val, "dropped", tmp, walk - tmp);
+                tr_free (tmp);
             }
 
-            if( diffs6.addedCount > 0 )
+            if (diffs6.addedCount > 0)
             {
                 /* "added6" */
-                tmp = walk = tr_new( uint8_t, diffs6.addedCount * 18 );
-                for( i = 0; i < diffs6.addedCount; ++i ) {
-                    memcpy( walk, &diffs6.added[i].addr.addr.addr6.s6_addr, 16 );
+                tmp = walk = tr_new (uint8_t, diffs6.addedCount * 18);
+                for (i = 0; i < diffs6.addedCount; ++i) {
+                    memcpy (walk, &diffs6.added[i].addr.addr.addr6.s6_addr, 16);
                     walk += 16;
-                    memcpy( walk, &diffs6.added[i].port, 2 );
+                    memcpy (walk, &diffs6.added[i].port, 2);
                     walk += 2;
                 }
-                assert( ( walk - tmp ) == diffs6.addedCount * 18 );
-                tr_bencDictAddRaw( &val, "added6", tmp, walk - tmp );
-                tr_free( tmp );
+                assert ((walk - tmp) == diffs6.addedCount * 18);
+                tr_bencDictAddRaw (&val, "added6", tmp, walk - tmp);
+                tr_free (tmp);
 
                 /* "added6.f"
                  * unset each holepunch flag because we don't support it. */
-                tmp = walk = tr_new( uint8_t, diffs6.addedCount );
-                for( i = 0; i < diffs6.addedCount; ++i )
+                tmp = walk = tr_new (uint8_t, diffs6.addedCount);
+                for (i = 0; i < diffs6.addedCount; ++i)
                     *walk++ = diffs6.added[i].flags & ~ADDED_F_HOLEPUNCH;
-                assert( ( walk - tmp ) == diffs6.addedCount );
-                tr_bencDictAddRaw( &val, "added6.f", tmp, walk - tmp );
-                tr_free( tmp );
+                assert ((walk - tmp) == diffs6.addedCount);
+                tr_bencDictAddRaw (&val, "added6.f", tmp, walk - tmp);
+                tr_free (tmp);
             }
 
-            if( diffs6.droppedCount > 0 )
+            if (diffs6.droppedCount > 0)
             {
                 /* "dropped6" */
-                tmp = walk = tr_new( uint8_t, diffs6.droppedCount * 18 );
-                for( i = 0; i < diffs6.droppedCount; ++i ) {
-                    memcpy( walk, &diffs6.dropped[i].addr.addr.addr6.s6_addr, 16 );
+                tmp = walk = tr_new (uint8_t, diffs6.droppedCount * 18);
+                for (i = 0; i < diffs6.droppedCount; ++i) {
+                    memcpy (walk, &diffs6.dropped[i].addr.addr.addr6.s6_addr, 16);
                     walk += 16;
-                    memcpy( walk, &diffs6.dropped[i].port, 2 );
+                    memcpy (walk, &diffs6.dropped[i].port, 2);
                     walk += 2;
                 }
-                assert( ( walk - tmp ) == diffs6.droppedCount * 18);
-                tr_bencDictAddRaw( &val, "dropped6", tmp, walk - tmp );
-                tr_free( tmp );
+                assert ((walk - tmp) == diffs6.droppedCount * 18);
+                tr_bencDictAddRaw (&val, "dropped6", tmp, walk - tmp);
+                tr_free (tmp);
             }
 
             /* write the pex message */
-            payload = tr_bencToBuf( &val, TR_FMT_BENC );
-            evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + evbuffer_get_length( payload ) );
-            evbuffer_add_uint8 ( out, BT_LTEP );
-            evbuffer_add_uint8 ( out, msgs->ut_pex_id );
-            evbuffer_add_buffer( out, payload );
-            pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
-            dbgmsg( msgs, "sending a pex message; outMessage size is now %zu", evbuffer_get_length( out ) );
-            dbgOutMessageLen( msgs );
-
-            evbuffer_free( payload );
-            tr_bencFree( &val );
+            payload = tr_bencToBuf (&val, TR_FMT_BENC);
+            evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload));
+            evbuffer_add_uint8 (out, BT_LTEP);
+            evbuffer_add_uint8 (out, msgs->ut_pex_id);
+            evbuffer_add_buffer (out, payload);
+            pokeBatchPeriod (msgs, HIGH_PRIORITY_INTERVAL_SECS);
+            dbgmsg (msgs, "sending a pex message; outMessage size is now %zu", evbuffer_get_length (out));
+            dbgOutMessageLen (msgs);
+
+            evbuffer_free (payload);
+            tr_bencFree (&val);
         }
 
         /* cleanup */
-        tr_free( diffs.added );
-        tr_free( diffs.dropped );
-        tr_free( newPex );
-        tr_free( diffs6.added );
-        tr_free( diffs6.dropped );
-        tr_free( newPex6 );
-
-        /*msgs->clientSentPexAt = tr_time( );*/
+        tr_free (diffs.added);
+        tr_free (diffs.dropped);
+        tr_free (newPex);
+        tr_free (diffs6.added);
+        tr_free (diffs6.dropped);
+        tr_free (newPex6);
+
+        /*msgs->clientSentPexAt = tr_time ();*/
     }
 }
 
 static void
-pexPulse( int foo UNUSED, short bar UNUSED, void * vmsgs )
+pexPulse (int foo UNUSED, short bar UNUSED, void * vmsgs)
 {
     struct tr_peermsgs * msgs = vmsgs;
 
-    sendPex( msgs );
+    sendPex (msgs);
 
-    assert( msgs->pexTimer != NULL );
-    tr_timerAdd( msgs->pexTimer, PEX_INTERVAL_SECS, 0 );
+    assert (msgs->pexTimer != NULL);
+    tr_timerAdd (msgs->pexTimer, PEX_INTERVAL_SECS, 0);
 }
 
 /**
@@ -2324,17 +2326,17 @@ pexPulse( int foo UNUSED, short bar UNUSED, void * vmsgs )
 **/
 
 tr_peermsgs*
-tr_peerMsgsNew( struct tr_torrent    * torrent,
+tr_peerMsgsNew (struct tr_torrent    * torrent,
                 struct tr_peer       * peer,
                 tr_peer_callback     * callback,
-                void                 * callbackData )
+                void                 * callbackData)
 {
     tr_peermsgs * m;
 
-    assert( peer );
-    assert( peer->io );
+    assert (peer);
+    assert (peer->io);
 
-    m = tr_new0( tr_peermsgs, 1 );
+    m = tr_new0 (tr_peermsgs, 1);
     m->callback = callback;
     m->callbackData = callbackData;
     m->peer = peer;
@@ -2344,58 +2346,58 @@ tr_peerMsgsNew( struct tr_torrent    * torrent,
     m->peer->clientIsInterested = 0;
     m->peer->peerIsInterested = 0;
     m->state = AWAITING_BT_LENGTH;
-    m->outMessages = evbuffer_new( );
+    m->outMessages = evbuffer_new ();
     m->outMessagesBatchedAt = 0;
     m->outMessagesBatchPeriod = LOW_PRIORITY_INTERVAL_SECS;
     peer->msgs = m;
 
-    if( tr_torrentAllowsPex( torrent ) ) {
-        m->pexTimer = evtimer_new( torrent->session->event_base, pexPulse, m );
-        tr_timerAdd( m->pexTimer, PEX_INTERVAL_SECS, 0 );
+    if (tr_torrentAllowsPex (torrent)) {
+        m->pexTimer = evtimer_new (torrent->session->event_base, pexPulse, m);
+        tr_timerAdd (m->pexTimer, PEX_INTERVAL_SECS, 0);
     }
 
-    if( tr_peerIoSupportsUTP( peer->io ) ) {
-        const tr_address * addr = tr_peerIoGetAddress( peer->io, NULL );
-        tr_peerMgrSetUtpSupported( torrent, addr );
-        tr_peerMgrSetUtpFailed( torrent, addr, false );
+    if (tr_peerIoSupportsUTP (peer->io)) {
+        const tr_address * addr = tr_peerIoGetAddress (peer->io, NULL);
+        tr_peerMgrSetUtpSupported (torrent, addr);
+        tr_peerMgrSetUtpFailed (torrent, addr, false);
     }
 
-    if( tr_peerIoSupportsLTEP( peer->io ) )
-        sendLtepHandshake( m );
+    if (tr_peerIoSupportsLTEP (peer->io))
+        sendLtepHandshake (m);
 
-    tellPeerWhatWeHave( m );
+    tellPeerWhatWeHave (m);
 
-    if( tr_dhtEnabled( torrent->session ) && tr_peerIoSupportsDHT( peer->io ))
+    if (tr_dhtEnabled (torrent->session) && tr_peerIoSupportsDHT (peer->io))
     {
         /* Only send PORT over IPv6 when the IPv6 DHT is running (BEP-32). */
-        const struct tr_address *addr = tr_peerIoGetAddress( peer->io, NULL );
-        if( addr->type == TR_AF_INET || tr_globalIPv6() ) {
-            protocolSendPort( m, tr_dhtPort( torrent->session ) );
+        const struct tr_address *addr = tr_peerIoGetAddress (peer->io, NULL);
+        if (addr->type == TR_AF_INET || tr_globalIPv6 ()) {
+            protocolSendPort (m, tr_dhtPort (torrent->session));
         }
     }
 
-    tr_peerIoSetIOFuncs( m->peer->io, canRead, didWrite, gotError, m );
-    updateDesiredRequestCount( m );
+    tr_peerIoSetIOFuncs (m->peer->io, canRead, didWrite, gotError, m);
+    updateDesiredRequestCount (m);
 
     return m;
 }
 
 void
-tr_peerMsgsFree( tr_peermsgs* msgs )
+tr_peerMsgsFree (tr_peermsgs* msgs)
 {
-    if( msgs )
+    if (msgs)
     {
-        if( msgs->pexTimer != NULL )
-            event_free( msgs->pexTimer );
+        if (msgs->pexTimer != NULL)
+            event_free (msgs->pexTimer);
 
-        if( msgs->incoming.block != NULL )
-            evbuffer_free( msgs->incoming.block );
+        if (msgs->incoming.block != NULL)
+            evbuffer_free (msgs->incoming.block);
 
-        evbuffer_free( msgs->outMessages );
-        tr_free( msgs->pex6 );
-        tr_free( msgs->pex );
+        evbuffer_free (msgs->outMessages);
+        tr_free (msgs->pex6);
+        tr_free (msgs->pex);
 
-        memset( msgs, ~0, sizeof( tr_peermsgs ) );
-        tr_free( msgs );
+        memset (msgs, ~0, sizeof (tr_peermsgs));
+        tr_free (msgs);
     }
 }
diff --git a/libtransmission/peer-msgs.h b/libtransmission/peer-msgs.h
index 29dc5f6f2..100b15e60 100644
--- a/libtransmission/peer-msgs.h
+++ b/libtransmission/peer-msgs.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -32,32 +32,32 @@ struct tr_torrent;
 
 typedef struct tr_peermsgs tr_peermsgs;
 
-tr_peermsgs* tr_peerMsgsNew( struct tr_torrent    * torrent,
+tr_peermsgs* tr_peerMsgsNew (struct tr_torrent    * torrent,
                              struct tr_peer       * peer,
                              tr_peer_callback     * callback,
-                             void                 * callback_data );
+                             void                 * callback_data);
 
-void         tr_peerMsgsSetChoke( tr_peermsgs *, bool peerIsChoked );
+void         tr_peerMsgsSetChoke (tr_peermsgs *, bool peerIsChoked);
 
-int          tr_peerMsgsIsReadingBlock( const tr_peermsgs * msgs, tr_block_index_t block );
+int          tr_peerMsgsIsReadingBlock (const tr_peermsgs * msgs, tr_block_index_t block);
 
-void         tr_peerMsgsSetInterested( tr_peermsgs *, bool clientIsInterested );
+void         tr_peerMsgsSetInterested (tr_peermsgs *, bool clientIsInterested);
 
-void         tr_peerMsgsHave( tr_peermsgs * msgs,
-                              uint32_t      pieceIndex );
+void         tr_peerMsgsHave (tr_peermsgs * msgs,
+                              uint32_t      pieceIndex);
 
-void         tr_peerMsgsPulse( tr_peermsgs * msgs );
+void         tr_peerMsgsPulse (tr_peermsgs * msgs);
 
-void         tr_peerMsgsCancel( tr_peermsgs * msgs,
-                                tr_block_index_t block );
+void         tr_peerMsgsCancel (tr_peermsgs * msgs,
+                                tr_block_index_t block);
 
-void         tr_peerMsgsFree( tr_peermsgs* );
+void         tr_peerMsgsFree (tr_peermsgs*);
 
-size_t       tr_generateAllowedSet( tr_piece_index_t         * setmePieces,
+size_t       tr_generateAllowedSet (tr_piece_index_t         * setmePieces,
                                     size_t                     desiredSetSize,
                                     size_t                     pieceCount,
                                     const uint8_t            * infohash,
-                                    const struct tr_address  * addr );
+                                    const struct tr_address  * addr);
 
 
 /* @} */
diff --git a/libtransmission/platform.c b/libtransmission/platform.c
index 093309b8a..50f6b7bb9 100644
--- a/libtransmission/platform.c
+++ b/libtransmission/platform.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -68,40 +68,40 @@ typedef pthread_t tr_thread_id;
 #endif
 
 static tr_thread_id
-tr_getCurrentThread( void )
+tr_getCurrentThread (void)
 {
 #ifdef WIN32
-    return GetCurrentThreadId( );
+  return GetCurrentThreadId ();
 #else
-    return pthread_self( );
+  return pthread_self ();
 #endif
 }
 
 static bool
-tr_areThreadsEqual( tr_thread_id a, tr_thread_id b )
+tr_areThreadsEqual (tr_thread_id a, tr_thread_id b)
 {
 #ifdef WIN32
-    return a == b;
+  return a == b;
 #else
-    return pthread_equal( a, b ) != 0;
+  return pthread_equal (a, b) != 0;
 #endif
 }
 
 /** @brief portability wrapper around OS-dependent threads */
 struct tr_thread
 {
-    void            ( * func )( void * );
-    void *          arg;
-    tr_thread_id    thread;
+  void          (* func)(void *);
+  void           * arg;
+  tr_thread_id     thread;
 #ifdef WIN32
-    HANDLE          thread_handle;
+  HANDLE           thread_handle;
 #endif
 };
 
 bool
-tr_amInThread( const tr_thread * t )
+tr_amInThread (const tr_thread * t)
 {
-    return tr_areThreadsEqual( tr_getCurrentThread( ), t->thread );
+  return tr_areThreadsEqual (tr_getCurrentThread (), t->thread);
 }
 
 #ifdef WIN32
@@ -111,43 +111,39 @@ tr_amInThread( const tr_thread * t )
 #endif
 
 static ThreadFuncReturnType
-ThreadFunc( void * _t )
+ThreadFunc (void * _t)
 {
-    tr_thread * t = _t;
+  tr_thread * t = _t;
 
-    t->func( t->arg );
+  t->func (t->arg);
 
-    tr_free( t );
+  tr_free (t);
 #ifdef WIN32
-    _endthreadex( 0 );
-    return 0;
+  _endthreadex (0);
+  return 0;
 #endif
 }
 
 tr_thread *
-tr_threadNew( void   ( *func )(void *),
-              void * arg )
+tr_threadNew (void (*func)(void *), void * arg)
 {
-    tr_thread * t = tr_new0( tr_thread, 1 );
+  tr_thread * t = tr_new0 (tr_thread, 1);
 
-    t->func = func;
-    t->arg  = arg;
+  t->func = func;
+  t->arg  = arg;
 
 #ifdef WIN32
-    {
-        unsigned int id;
-        t->thread_handle =
-            (HANDLE) _beginthreadex( NULL, 0, &ThreadFunc, t, 0,
-                                     &id );
-        t->thread = (DWORD) id;
-    }
+  {
+    unsigned int id;
+    t->thread_handle = (HANDLE) _beginthreadex (NULL, 0, &ThreadFunc, t, 0, &id);
+    t->thread = (DWORD) id;
+  }
 #else
-    pthread_create( &t->thread, NULL, (void*(*)(void*))ThreadFunc, t );
-    pthread_detach( t->thread );
-
+  pthread_create (&t->thread, NULL, (void* (*)(void*))ThreadFunc, t);
+  pthread_detach (t->thread);
 #endif
 
-    return t;
+  return t;
 }
 
 /***
@@ -157,78 +153,78 @@ tr_threadNew( void   ( *func )(void *),
 /** @brief portability wrapper around OS-dependent thread mutexes */
 struct tr_lock
 {
-    int                 depth;
+  int                 depth;
 #ifdef WIN32
-    CRITICAL_SECTION    lock;
-    DWORD               lockThread;
+  CRITICAL_SECTION    lock;
+  DWORD               lockThread;
 #else
-    pthread_mutex_t     lock;
-    pthread_t           lockThread;
+  pthread_mutex_t     lock;
+  pthread_t           lockThread;
 #endif
 };
 
 tr_lock*
-tr_lockNew( void )
+tr_lockNew (void)
 {
-    tr_lock *           l = tr_new0( tr_lock, 1 );
+  tr_lock * l = tr_new0 (tr_lock, 1);
 
 #ifdef WIN32
-    InitializeCriticalSection( &l->lock ); /* supports recursion */
+  InitializeCriticalSection (&l->lock); /* supports recursion */
 #else
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init( &attr );
-    pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
-    pthread_mutex_init( &l->lock, &attr );
+  pthread_mutexattr_t attr;
+  pthread_mutexattr_init (&attr);
+  pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
+  pthread_mutex_init (&l->lock, &attr);
 #endif
 
-    return l;
+  return l;
 }
 
 void
-tr_lockFree( tr_lock * l )
+tr_lockFree (tr_lock * l)
 {
 #ifdef WIN32
-    DeleteCriticalSection( &l->lock );
+    DeleteCriticalSection (&l->lock);
 #else
-    pthread_mutex_destroy( &l->lock );
+    pthread_mutex_destroy (&l->lock);
 #endif
-    tr_free( l );
+    tr_free (l);
 }
 
 void
-tr_lockLock( tr_lock * l )
+tr_lockLock (tr_lock * l)
 {
 #ifdef WIN32
-    EnterCriticalSection( &l->lock );
+  EnterCriticalSection (&l->lock);
 #else
-    pthread_mutex_lock( &l->lock );
+  pthread_mutex_lock (&l->lock);
 #endif
-    assert( l->depth >= 0 );
-    if( l->depth )
-        assert( tr_areThreadsEqual( l->lockThread, tr_getCurrentThread( ) ) );
-    l->lockThread = tr_getCurrentThread( );
-    ++l->depth;
+
+  assert (l->depth >= 0);
+  assert (!l->depth || tr_areThreadsEqual (l->lockThread, tr_getCurrentThread ()));
+  l->lockThread = tr_getCurrentThread ();
+  ++l->depth;
 }
 
 int
-tr_lockHave( const tr_lock * l )
+tr_lockHave (const tr_lock * l)
 {
-    return ( l->depth > 0 )
-           && ( tr_areThreadsEqual( l->lockThread, tr_getCurrentThread( ) ) );
+  return (l->depth > 0) &&
+         (tr_areThreadsEqual (l->lockThread, tr_getCurrentThread ()));
 }
 
 void
-tr_lockUnlock( tr_lock * l )
+tr_lockUnlock (tr_lock * l)
 {
-    assert( l->depth > 0 );
-    assert( tr_areThreadsEqual( l->lockThread, tr_getCurrentThread( ) ) );
+  assert (l->depth > 0);
+  assert (tr_areThreadsEqual (l->lockThread, tr_getCurrentThread ()));
 
-    --l->depth;
-    assert( l->depth >= 0 );
+  --l->depth;
+  assert (l->depth >= 0);
 #ifdef WIN32
-    LeaveCriticalSection( &l->lock );
+  LeaveCriticalSection (&l->lock);
 #else
-    pthread_mutex_unlock( &l->lock );
+  pthread_mutex_unlock (&l->lock);
 #endif
 }
 
@@ -241,64 +237,64 @@ tr_lockUnlock( tr_lock * l )
 #endif
 
 static const char *
-getHomeDir( void )
+getHomeDir (void)
 {
-    static char * home = NULL;
+  static char * home = NULL;
 
-    if( !home )
+  if (!home)
     {
-        home = tr_strdup( getenv( "HOME" ) );
+      home = tr_strdup (getenv ("HOME"));
 
-        if( !home )
+      if (!home)
         {
 #ifdef WIN32
-            char appdata[MAX_PATH]; /* SHGetFolderPath() requires MAX_PATH */
-            *appdata = '\0';
-            SHGetFolderPath( NULL, CSIDL_PERSONAL, NULL, 0, appdata );
-            home = tr_strdup( appdata );
+          char appdata[MAX_PATH]; /* SHGetFolderPath () requires MAX_PATH */
+          *appdata = '\0';
+          SHGetFolderPath (NULL, CSIDL_PERSONAL, NULL, 0, appdata);
+          home = tr_strdup (appdata);
 #else
-            struct passwd * pw = getpwuid( getuid( ) );
-            if( pw )
-                home = tr_strdup( pw->pw_dir );
-            endpwent( );
+          struct passwd * pw = getpwuid (getuid ());
+          if (pw)
+            home = tr_strdup (pw->pw_dir);
+          endpwent ();
 #endif
         }
 
-        if( !home )
-            home = tr_strdup( "" );
+      if (!home)
+        home = tr_strdup ("");
     }
 
-    return home;
+  return home;
 }
 
 static const char *
-getOldConfigDir( void )
+getOldConfigDir (void)
 {
-    static char * path = NULL;
+  static char * path = NULL;
 
-    if( !path )
+  if (!path)
     {
 #ifdef SYS_DARWIN
-        path = tr_buildPath( getHomeDir( ), "Library",
-                              "Application Support",
-                              "Transmission", NULL );
-#elif defined( WIN32 )
-        char appdata[MAX_PATH]; /* SHGetFolderPath() requires MAX_PATH */
-        SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, appdata );
-        path = tr_buildPath( appdata, "Transmission", NULL );
-#elif defined( __HAIKU__ )
-        char buf[TR_PATH_MAX];
-        find_directory( B_USER_SETTINGS_DIRECTORY, -1, true, buf, sizeof(buf) );
-        path = tr_buildPath( buf, "Transmission", NULL );
+      path = tr_buildPath (getHomeDir (), "Library",
+                           "Application Support",
+                           "Transmission", NULL);
+#elif defined (WIN32)
+      char appdata[MAX_PATH]; /* SHGetFolderPath () requires MAX_PATH */
+      SHGetFolderPath (NULL, CSIDL_APPDATA, NULL, 0, appdata);
+      path = tr_buildPath (appdata, "Transmission", NULL);
+#elif defined (__HAIKU__)
+      char buf[TR_PATH_MAX];
+      find_directory (B_USER_SETTINGS_DIRECTORY, -1, true, buf, sizeof (buf));
+      path = tr_buildPath (buf, "Transmission", NULL);
 #else
-        path = tr_buildPath( getHomeDir( ), ".transmission", NULL );
+      path = tr_buildPath (getHomeDir (), ".transmission", NULL);
 #endif
     }
 
-    return path;
+  return path;
 }
 
-#if defined(SYS_DARWIN) || defined(WIN32)
+#if defined (SYS_DARWIN) || defined (WIN32)
  #define RESUME_SUBDIR  "Resume"
  #define TORRENT_SUBDIR "Torrents"
 #else
@@ -307,64 +303,63 @@ getOldConfigDir( void )
 #endif
 
 static const char *
-getOldTorrentsDir( void )
+getOldTorrentsDir (void)
 {
-    static char * path = NULL;
+  static char * path = NULL;
 
-    if( !path )
-        path = tr_buildPath( getOldConfigDir( ), TORRENT_SUBDIR, NULL );
+  if (!path)
+    path = tr_buildPath (getOldConfigDir (), TORRENT_SUBDIR, NULL);
 
-    return path;
+  return path;
 }
 
 static const char *
-getOldCacheDir( void )
+getOldCacheDir (void)
 {
-    static char * path = NULL;
+  static char * path = NULL;
 
-    if( !path )
+  if (!path)
     {
-#if defined( WIN32 )
-        path = tr_buildPath( getOldConfigDir( ), "Cache", NULL );
-#elif defined( SYS_DARWIN )
-        path = tr_buildPath( getHomeDir( ), "Library", "Caches", "Transmission", NULL );
+#if defined (WIN32)
+      path = tr_buildPath (getOldConfigDir (), "Cache", NULL);
+#elif defined (SYS_DARWIN)
+      path = tr_buildPath (getHomeDir (), "Library", "Caches", "Transmission", NULL);
 #else
-        path = tr_buildPath( getOldConfigDir( ), "cache", NULL );
+      path = tr_buildPath (getOldConfigDir (), "cache", NULL);
 #endif
     }
 
-    return path;
+  return path;
 }
 
 static void
-moveFiles( const char * oldDir,
-           const char * newDir )
+moveFiles (const char * oldDir, const char * newDir)
 {
-    if( oldDir && newDir && strcmp( oldDir, newDir ) )
+  if (oldDir && newDir && strcmp (oldDir, newDir))
     {
-        DIR * dirh = opendir( oldDir );
-        if( dirh )
+      DIR * dirh = opendir (oldDir);
+      if (dirh)
         {
-            int             count = 0;
-            struct dirent * dirp;
-            while( ( dirp = readdir( dirh ) ) )
+          int count = 0;
+          struct dirent * dirp;
+          while ((dirp = readdir (dirh)))
             {
-                const char * name = dirp->d_name;
-                if( name && strcmp( name, "." ) && strcmp( name, ".." ) )
+              const char * name = dirp->d_name;
+              if (name && strcmp (name, ".") && strcmp (name, ".."))
                 {
-                    char * o = tr_buildPath( oldDir, name, NULL );
-                    char * n = tr_buildPath( newDir, name, NULL );
-                    rename( o, n );
-                    ++count;
-                    tr_free( n );
-                    tr_free( o );
+                  char * o = tr_buildPath (oldDir, name, NULL);
+                  char * n = tr_buildPath (newDir, name, NULL);
+                  rename (o, n);
+                  ++count;
+                  tr_free (n);
+                  tr_free (o);
                 }
             }
 
-            if( count )
-                tr_inf( _( "Migrated %1$d files from \"%2$s\" to \"%3$s\"" ),
-                        count, oldDir, newDir );
-            closedir( dirh );
+          if (count)
+            tr_inf (_ ("Migrated %1$d files from \"%2$s\" to \"%3$s\""), count, oldDir, newDir);
+
+          closedir (dirh);
         }
     }
 }
@@ -375,156 +370,156 @@ moveFiles( const char * oldDir,
  * to $HOME/.config/$appname as per the XDG directory spec.
  */
 static void
-migrateFiles( const tr_session * session )
+migrateFiles (const tr_session * session)
 {
-    static int migrated = false;
-    const bool should_migrate = strstr( getOldConfigDir(), ".transmission" ) != NULL;
+  static int migrated = false;
+  const bool should_migrate = strstr (getOldConfigDir (), ".transmission") != NULL;
 
-    if( !migrated && should_migrate )
+  if (!migrated && should_migrate)
     {
-        const char * oldDir;
-        const char * newDir;
-        migrated = true;
+      const char * oldDir;
+      const char * newDir;
+
+      migrated = true;
 
-        oldDir = getOldTorrentsDir( );
-        newDir = tr_getTorrentDir( session );
-        moveFiles( oldDir, newDir );
+      oldDir = getOldTorrentsDir ();
+      newDir = tr_getTorrentDir (session);
+      moveFiles (oldDir, newDir);
 
-        oldDir = getOldCacheDir( );
-        newDir = tr_getResumeDir( session );
-        moveFiles( oldDir, newDir );
+      oldDir = getOldCacheDir ();
+      newDir = tr_getResumeDir (session);
+      moveFiles (oldDir, newDir);
     }
 }
 
 void
-tr_setConfigDir( tr_session * session, const char * configDir )
+tr_setConfigDir (tr_session * session, const char * configDir)
 {
-    char * path;
+  char * path;
 
-    session->configDir = tr_strdup( configDir );
+  session->configDir = tr_strdup (configDir);
 
-    path = tr_buildPath( configDir, RESUME_SUBDIR, NULL );
-    tr_mkdirp( path, 0777 );
-    session->resumeDir = path;
+  path = tr_buildPath (configDir, RESUME_SUBDIR, NULL);
+  tr_mkdirp (path, 0777);
+  session->resumeDir = path;
 
-    path = tr_buildPath( configDir, TORRENT_SUBDIR, NULL );
-    tr_mkdirp( path, 0777 );
-    session->torrentDir = path;
+  path = tr_buildPath (configDir, TORRENT_SUBDIR, NULL);
+  tr_mkdirp (path, 0777);
+  session->torrentDir = path;
 
-    migrateFiles( session );
+  migrateFiles (session);
 }
 
 const char *
-tr_sessionGetConfigDir( const tr_session * session )
+tr_sessionGetConfigDir (const tr_session * session)
 {
-    return session->configDir;
+  return session->configDir;
 }
 
 const char *
-tr_getTorrentDir( const tr_session * session )
+tr_getTorrentDir (const tr_session * session)
 {
-    return session->torrentDir;
+  return session->torrentDir;
 }
 
 const char *
-tr_getResumeDir( const tr_session * session )
+tr_getResumeDir (const tr_session * session)
 {
-    return session->resumeDir;
+  return session->resumeDir;
 }
 
 const char*
-tr_getDefaultConfigDir( const char * appname )
+tr_getDefaultConfigDir (const char * appname)
 {
-    static char * s = NULL;
+  static char * s = NULL;
 
-    if( !appname || !*appname )
-        appname = "Transmission";
+  if (!appname || !*appname)
+    appname = "Transmission";
 
-    if( !s )
+  if (!s)
     {
-        if( ( s = getenv( "TRANSMISSION_HOME" ) ) )
+      if ((s = getenv ("TRANSMISSION_HOME")))
         {
-            s = tr_strdup( s );
+          s = tr_strdup (s);
         }
         else
         {
 #ifdef SYS_DARWIN
-            s = tr_buildPath( getHomeDir( ), "Library", "Application Support",
-                              appname, NULL );
-#elif defined( WIN32 )
-            char appdata[TR_PATH_MAX]; /* SHGetFolderPath() requires MAX_PATH */
-            SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, appdata );
-            s = tr_buildPath( appdata, appname, NULL );
-#elif defined( __HAIKU__ )
-            char buf[TR_PATH_MAX];
-            find_directory( B_USER_SETTINGS_DIRECTORY, -1, true, buf, sizeof(buf) );
-            s = tr_buildPath( buf, appname, NULL );
+          s = tr_buildPath (getHomeDir (), "Library", "Application Support", appname, NULL);
+#elif defined (WIN32)
+          char appdata[TR_PATH_MAX]; /* SHGetFolderPath () requires MAX_PATH */
+          SHGetFolderPath (NULL, CSIDL_APPDATA, NULL, 0, appdata);
+          s = tr_buildPath (appdata, appname, NULL);
+#elif defined (__HAIKU__)
+          char buf[TR_PATH_MAX];
+          find_directory (B_USER_SETTINGS_DIRECTORY, -1, true, buf, sizeof (buf));
+          s = tr_buildPath (buf, appname, NULL);
 #else
-            if( ( s = getenv( "XDG_CONFIG_HOME" ) ) )
-                s = tr_buildPath( s, appname, NULL );
-            else
-                s = tr_buildPath( getHomeDir( ), ".config", appname, NULL );
+          if ((s = getenv ("XDG_CONFIG_HOME")))
+            s = tr_buildPath (s, appname, NULL);
+          else
+            s = tr_buildPath (getHomeDir (), ".config", appname, NULL);
 #endif
         }
     }
 
-    return s;
+  return s;
 }
 
 const char*
-tr_getDefaultDownloadDir( void )
+tr_getDefaultDownloadDir (void)
 {
-    static char * user_dir = NULL;
+  static char * user_dir = NULL;
 
-    if( user_dir == NULL )
+  if (user_dir == NULL)
     {
-        const char * config_home;
-        char * config_file;
-        char * content;
-        size_t content_len;
-
-        /* figure out where to look for user-dirs.dirs */
-        config_home = getenv( "XDG_CONFIG_HOME" );
-        if( config_home && *config_home )
-            config_file = tr_buildPath( config_home, "user-dirs.dirs", NULL );
-        else
-            config_file = tr_buildPath( getHomeDir( ), ".config", "user-dirs.dirs", NULL );
-
-        /* read in user-dirs.dirs and look for the download dir entry */
-        content = (char *) tr_loadFile( config_file, &content_len );
-        if( content && content_len>0 )
+      const char * config_home;
+      char * config_file;
+      char * content;
+      size_t content_len;
+
+      /* figure out where to look for user-dirs.dirs */
+      config_home = getenv ("XDG_CONFIG_HOME");
+      if (config_home && *config_home)
+        config_file = tr_buildPath (config_home, "user-dirs.dirs", NULL);
+      else
+        config_file = tr_buildPath (getHomeDir (), ".config", "user-dirs.dirs", NULL);
+
+      /* read in user-dirs.dirs and look for the download dir entry */
+      content = (char *) tr_loadFile (config_file, &content_len);
+      if (content && content_len>0)
         {
-            const char * key = "XDG_DOWNLOAD_DIR=\"";
-            char * line = strstr( content, key );
-            if( line != NULL )
+          const char * key = "XDG_DOWNLOAD_DIR=\"";
+          char * line = strstr (content, key);
+          if (line != NULL)
             {
-                char * value = line + strlen( key );
-                char * end = strchr( value, '"' );
+              char * value = line + strlen (key);
+              char * end = strchr (value, '"');
 
-                if( end )
+              if (end)
                 {
-                    *end = '\0';
+                  *end = '\0';
 
-                    if( !memcmp( value, "$HOME/", 6 ) )
-                        user_dir = tr_buildPath( getHomeDir( ), value+6, NULL );
-                    else
-                        user_dir = tr_strdup( value );
+                  if (!memcmp (value, "$HOME/", 6))
+                    user_dir = tr_buildPath (getHomeDir (), value+6, NULL);
+                  else
+                    user_dir = tr_strdup (value);
                 }
             }
         }
 
-        if( user_dir == NULL )
+      if (user_dir == NULL)
 #ifdef __HAIKU__
-            user_dir = tr_buildPath( getHomeDir( ), "Desktop", NULL );
+        user_dir = tr_buildPath (getHomeDir (), "Desktop", NULL);
 #else
-            user_dir = tr_buildPath( getHomeDir( ), "Downloads", NULL );
+        user_dir = tr_buildPath (getHomeDir (), "Downloads", NULL);
 #endif
 
-        tr_free( content );
-        tr_free( config_file );
+      tr_free (content);
+      tr_free (config_file);
     }
 
-    return user_dir;
+  return user_dir;
 }
 
 /***
@@ -532,156 +527,171 @@ tr_getDefaultDownloadDir( void )
 ***/
 
 static int
-isWebClientDir( const char * path )
-{
-    struct stat sb;
-    char * tmp = tr_buildPath( path, "index.html", NULL );
-    const int ret = !stat( tmp, &sb );
-    tr_inf( _( "Searching for web interface file \"%s\"" ), tmp );
-    tr_free( tmp );
-    return ret;
+isWebClientDir (const char * path)
+{
+  struct stat sb;
+  char * tmp = tr_buildPath (path, "index.html", NULL);
+  const int ret = !stat (tmp, &sb);
+  tr_inf (_ ("Searching for web interface file \"%s\""), tmp);
+  tr_free (tmp);
+
+  return ret;
 }
 
 const char *
-tr_getWebClientDir( const tr_session * session UNUSED )
+tr_getWebClientDir (const tr_session * session UNUSED)
 {
-    static char * s = NULL;
+  static char * s = NULL;
 
-    if( !s )
+  if (!s)
     {
-        if( ( s = getenv( "CLUTCH_HOME" ) ) )
+      if ((s = getenv ("CLUTCH_HOME")))
         {
-            s = tr_strdup( s );
+          s = tr_strdup (s);
         }
-        else if( ( s = getenv( "TRANSMISSION_WEB_HOME" ) ) )
+      else if ((s = getenv ("TRANSMISSION_WEB_HOME")))
         {
-            s = tr_strdup( s );
+          s = tr_strdup (s);
         }
-        else
+      else
         {
 
 #ifdef SYS_DARWIN /* on Mac, look in the Application Support folder first, then in the app bundle. */
 
-            /* Look in the Application Support folder */
-            s = tr_buildPath( tr_sessionGetConfigDir( session ), "web", NULL );
+          /* Look in the Application Support folder */
+          s = tr_buildPath (tr_sessionGetConfigDir (session), "web", NULL);
 
-            if( !isWebClientDir( s ) ) {
-                tr_free( s );
+          if (!isWebClientDir (s))
+            {
+              tr_free (s);
 
-                CFURLRef appURL = CFBundleCopyBundleURL( CFBundleGetMainBundle( ) );
-                CFStringRef appRef = CFURLCopyFileSystemPath( appURL,
-                                                              kCFURLPOSIXPathStyle );
-                const CFIndex appStringLength = CFStringGetMaximumSizeOfFileSystemRepresentation(appRef);
+              CFURLRef appURL = CFBundleCopyBundleURL (CFBundleGetMainBundle ());
+              CFStringRef appRef = CFURLCopyFileSystemPath (appURL,
+                                                            kCFURLPOSIXPathStyle);
+              const CFIndex appStringLength = CFStringGetMaximumSizeOfFileSystemRepresentation (appRef);
 
-                char * appString = tr_malloc( appStringLength );
-                const bool success = CFStringGetFileSystemRepresentation( appRef, appString, appStringLength );
-                assert( success );
+              char * appString = tr_malloc (appStringLength);
+              const bool success = CFStringGetFileSystemRepresentation (appRef, appString, appStringLength);
+              assert (success);
 
-                CFRelease( appURL );
-                CFRelease( appRef );
+              CFRelease (appURL);
+              CFRelease (appRef);
 
-                /* Fallback to the app bundle */
-                s = tr_buildPath( appString, "Contents", "Resources", "web", NULL );
-                if( !isWebClientDir( s ) ) {
-                    tr_free( s );
-                    s = NULL;
+              /* Fallback to the app bundle */
+              s = tr_buildPath (appString, "Contents", "Resources", "web", NULL);
+              if (!isWebClientDir (s))
+                {
+                  tr_free (s);
+                  s = NULL;
                 }
 
-                tr_free( appString );
+              tr_free (appString);
             }
 
-#elif defined( WIN32 )
+#elif defined (WIN32)
 
-            /* SHGetFolderPath explicitly requires MAX_PATH length */
-            char dir[MAX_PATH];
+          /* SHGetFolderPath explicitly requires MAX_PATH length */
+          char dir[MAX_PATH];
 
-            /* Generally, Web interface should be stored in a Web subdir of
-             * calling executable dir. */
+          /* Generally, Web interface should be stored in a Web subdir of
+           * calling executable dir. */
 
-            if( s == NULL ) {
-                /* First, we should check personal AppData/Transmission/Web */
-                SHGetFolderPath( NULL, CSIDL_COMMON_APPDATA, NULL, 0, dir );
-                s = tr_buildPath( dir, "Transmission", "Web", NULL );
-                if( !isWebClientDir( s ) ) {
-                    tr_free( s );
-                    s = NULL;
+          if (s == NULL) /* check personal AppData/Transmission/Web */
+            {
+              SHGetFolderPath (NULL, CSIDL_COMMON_APPDATA, NULL, 0, dir);
+              s = tr_buildPath (dir, "Transmission", "Web", NULL);
+              if (!isWebClientDir (s))
+                {
+                  tr_free (s);
+                  s = NULL;
                 }
             }
 
-            if( s == NULL ) {
-                /* check personal AppData */
-                SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, dir );
-                s = tr_buildPath( dir, "Transmission", "Web", NULL );
-                if( !isWebClientDir( s ) ) {
-                    tr_free( s );
-                    s = NULL;
+          if (s == NULL) /* check personal AppData */
+            {
+              SHGetFolderPath (NULL, CSIDL_APPDATA, NULL, 0, dir);
+              s = tr_buildPath (dir, "Transmission", "Web", NULL);
+              if (!isWebClientDir (s))
+                {
+                  tr_free (s);
+                  s = NULL;
                 }
             }
 
-            if( s == NULL) {
-                /* check calling module place */
-                GetModuleFileName( GetModuleHandle( NULL ), dir, sizeof( dir ) );
-                s = tr_buildPath( dirname( dir ), "Web", NULL );
-                if( !isWebClientDir( s ) ) {
-                    tr_free( s );
+            if (s == NULL) /* check calling module place */
+              {
+                GetModuleFileName (GetModuleHandle (NULL), dir, sizeof (dir));
+                s = tr_buildPath (dirname (dir), "Web", NULL);
+                if (!isWebClientDir (s))
+                  {
+                    tr_free (s);
                     s = NULL;
-                }
+                  }
             }
 
 #else /* everyone else, follow the XDG spec */
 
-            tr_list *candidates = NULL, *l;
-            const char * tmp;
+          tr_list *candidates = NULL, *l;
+          const char * tmp;
 
-            /* XDG_DATA_HOME should be the first in the list of candidates */
-            tmp = getenv( "XDG_DATA_HOME" );
-            if( tmp && *tmp )
-                tr_list_append( &candidates, tr_strdup( tmp ) );
-            else {
-                char * dhome = tr_buildPath( getHomeDir( ), ".local", "share", NULL );
-                tr_list_append( &candidates, dhome );
+          /* XDG_DATA_HOME should be the first in the list of candidates */
+          tmp = getenv ("XDG_DATA_HOME");
+          if (tmp && *tmp)
+            {
+              tr_list_append (&candidates, tr_strdup (tmp));
             }
-
-            /* XDG_DATA_DIRS are the backup directories */
+          else
             {
-                const char * pkg = PACKAGE_DATA_DIR;
-                const char * xdg = getenv( "XDG_DATA_DIRS" );
-                const char * fallback = "/usr/local/share:/usr/share";
-                char * buf = tr_strdup_printf( "%s:%s:%s", (pkg?pkg:""), (xdg?xdg:""), fallback );
-                tmp = buf;
-                while( tmp && *tmp ) {
-                    const char * end = strchr( tmp, ':' );
-                    if( end ) {
-                        if( ( end - tmp ) > 1 )
-                            tr_list_append( &candidates, tr_strndup( tmp, end - tmp ) );
-                        tmp = end + 1;
-                    } else if( tmp && *tmp ) {
-                        tr_list_append( &candidates, tr_strdup( tmp ) );
-                        break;
-                    }
-                }
-                tr_free( buf );
+              char * dhome = tr_buildPath (getHomeDir (), ".local", "share", NULL);
+              tr_list_append (&candidates, dhome);
             }
 
-            /* walk through the candidates & look for a match */
-            for( l=candidates; l; l=l->next ) {
-                char * path = tr_buildPath( l->data, "transmission", "web", NULL );
-                const int found = isWebClientDir( path );
-                if( found ) {
-                    s = path;
+          /* XDG_DATA_DIRS are the backup directories */
+          {
+            const char * pkg = PACKAGE_DATA_DIR;
+            const char * xdg = getenv ("XDG_DATA_DIRS");
+            const char * fallback = "/usr/local/share:/usr/share";
+            char * buf = tr_strdup_printf ("%s:%s:%s", (pkg?pkg:""), (xdg?xdg:""), fallback);
+            tmp = buf;
+            while (tmp && *tmp)
+              {
+                const char * end = strchr (tmp, ':');
+                if (end)
+                  {
+                    if ((end - tmp) > 1)
+                      tr_list_append (&candidates, tr_strndup (tmp, end - tmp));
+                    tmp = end + 1;
+                  }
+                else if (tmp && *tmp)
+                  {
+                    tr_list_append (&candidates, tr_strdup (tmp));
                     break;
+                  }
+              }
+            tr_free (buf);
+          }
+
+          /* walk through the candidates & look for a match */
+          for (l=candidates; l; l=l->next)
+            {
+              char * path = tr_buildPath (l->data, "transmission", "web", NULL);
+              const int found = isWebClientDir (path);
+              if (found)
+                {
+                  s = path;
+                  break;
                 }
-                tr_free( path );
+              tr_free (path);
             }
 
-            tr_list_free( &candidates, tr_free );
+          tr_list_free (&candidates, tr_free);
 
 #endif
 
         }
     }
 
-    return s;
+  return s;
 }
 
 /***
@@ -689,19 +699,19 @@ tr_getWebClientDir( const tr_session * session UNUSED )
 ***/
 
 int64_t
-tr_getFreeSpace( const char * path )
+tr_getFreeSpace (const char * path)
 {
 #ifdef WIN32
-    uint64_t freeBytesAvailable = 0;
-    return GetDiskFreeSpaceEx( path, &freeBytesAvailable, NULL, NULL)
-        ? (int64_t)freeBytesAvailable
-        : -1;
-#elif defined(HAVE_STATVFS)
-    struct statvfs buf;
-    return statvfs( path, &buf ) ? -1 : (int64_t)buf.f_bavail * (int64_t)buf.f_frsize;
+  uint64_t freeBytesAvailable = 0;
+  return GetDiskFreeSpaceEx (path, &freeBytesAvailable, NULL, NULL)
+    ? (int64_t)freeBytesAvailable
+    : -1;
+#elif defined (HAVE_STATVFS)
+  struct statvfs buf;
+  return statvfs (path, &buf) ? -1 : (int64_t)buf.f_bavail * (int64_t)buf.f_frsize;
 #else
-    #warning FIXME: not implemented
-    return -1;
+  #warning FIXME: not implemented
+  return -1;
 #endif
 }
 
@@ -712,119 +722,118 @@ tr_getFreeSpace( const char * path )
 #ifdef WIN32
 
 /* The following mmap functions are by Joerg Walter, and were taken from
- * his paper at: http://www.genesys-e.de/jwalter/mix4win.htm
- */
+ * his paper at: http://www.genesys-e.de/jwalter/mix4win.htm */
 
-#if defined(_MSC_VER)
-__declspec( align( 4 ) ) static LONG volatile g_sl;
+#if defined (_MSC_VER)
+__declspec (align (4)) static LONG volatile g_sl;
 #else
-static LONG volatile g_sl __attribute__ ( ( aligned ( 4 ) ) );
+static LONG volatile g_sl __attribute__ ((aligned (4)));
 #endif
 
 /* Wait for spin lock */
 static int
-slwait( LONG volatile *sl )
+slwait (LONG volatile *sl)
 {
-    while( InterlockedCompareExchange ( sl, 1, 0 ) != 0 )
-        Sleep ( 0 );
+  while (InterlockedCompareExchange (sl, 1, 0) != 0)
+    Sleep (0);
 
-    return 0;
+  return 0;
 }
 
 /* Release spin lock */
 static int
-slrelease( LONG volatile *sl )
+slrelease (LONG volatile *sl)
 {
-    InterlockedExchange ( sl, 0 );
-    return 0;
+  InterlockedExchange (sl, 0);
+  return 0;
 }
 
 /* getpagesize for windows */
 static long
-getpagesize( void )
+getpagesize (void)
 {
-    static long g_pagesize = 0;
+  static long g_pagesize = 0;
 
-    if( !g_pagesize )
+  if (!g_pagesize)
     {
-        SYSTEM_INFO system_info;
-        GetSystemInfo ( &system_info );
-        g_pagesize = system_info.dwPageSize;
+      SYSTEM_INFO system_info;
+      GetSystemInfo (&system_info);
+      g_pagesize = system_info.dwPageSize;
     }
-    return g_pagesize;
+
+  return g_pagesize;
 }
 
 static long
-getregionsize( void )
+getregionsize (void)
 {
-    static long g_regionsize = 0;
+  static long g_regionsize = 0;
 
-    if( !g_regionsize )
+  if (!g_regionsize)
     {
-        SYSTEM_INFO system_info;
-        GetSystemInfo ( &system_info );
-        g_regionsize = system_info.dwAllocationGranularity;
+      SYSTEM_INFO system_info;
+      GetSystemInfo (&system_info);
+      g_regionsize = system_info.dwAllocationGranularity;
     }
-    return g_regionsize;
+
+  return g_regionsize;
 }
 
 void *
-mmap( void *ptr,
-      long  size,
-      long  prot,
-      long  type,
-      long  handle,
-      long  arg )
-{
-    static long g_pagesize;
-    static long g_regionsize;
-
-    /* Wait for spin lock */
-    slwait ( &g_sl );
-    /* First time initialization */
-    if( !g_pagesize )
-        g_pagesize = getpagesize ( );
-    if( !g_regionsize )
-        g_regionsize = getregionsize ( );
-    /* Allocate this */
-    ptr = VirtualAlloc ( ptr, size,
-                         MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
-                         PAGE_READWRITE );
-    if( !ptr )
+mmap (void *ptr, long  size, long  prot, long  type, long  handle, long  arg)
+{
+  static long g_pagesize;
+  static long g_regionsize;
+
+  /* Wait for spin lock */
+  slwait (&g_sl);
+
+  /* First time initialization */
+  if (!g_pagesize)
+    g_pagesize = getpagesize ();
+  if (!g_regionsize)
+    g_regionsize = getregionsize ();
+
+  /* Allocate this */
+  ptr = VirtualAlloc (ptr, size, MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE);
+  if (!ptr)
     {
-        ptr = (void *) -1;
-        goto mmap_exit;
+      ptr = (void *) -1;
+      goto mmap_exit;
     }
+
 mmap_exit:
-    /* Release spin lock */
-    slrelease ( &g_sl );
-    return ptr;
+  /* Release spin lock */
+  slrelease (&g_sl);
+  return ptr;
 }
 
 long
-munmap( void *ptr,
-        long  size )
-{
-    static long g_pagesize;
-    static long g_regionsize;
-    int         rc = -1;
-
-    /* Wait for spin lock */
-    slwait ( &g_sl );
-    /* First time initialization */
-    if( !g_pagesize )
-        g_pagesize = getpagesize ( );
-    if( !g_regionsize )
-        g_regionsize = getregionsize ( );
-    /* Free this */
-    if( !VirtualFree ( ptr, 0,
-                       MEM_RELEASE ) )
-        goto munmap_exit;
-    rc = 0;
+munmap (void *ptr, long size)
+{
+  static long g_pagesize;
+  static long g_regionsize;
+  int rc = -1;
+
+  /* Wait for spin lock */
+  slwait (&g_sl);
+
+  /* First time initialization */
+  if (!g_pagesize)
+    g_pagesize = getpagesize ();
+  if (!g_regionsize)
+    g_regionsize = getregionsize ();
+
+  /* Free this */
+  if (!VirtualFree (ptr, 0, MEM_RELEASE))
+    goto munmap_exit;
+
+  rc = 0;
+
 munmap_exit:
-    /* Release spin lock */
-    slrelease ( &g_sl );
-    return rc;
+  /* Release spin lock */
+  slrelease (&g_sl);
+  return rc;
 }
 
 #endif
diff --git a/libtransmission/platform.h b/libtransmission/platform.h
index 7e1571778..9e0e26834 100644
--- a/libtransmission/platform.h
+++ b/libtransmission/platform.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -26,24 +26,24 @@
  */
 
 /**
- * @brief invoked by tr_sessionInit() to set up the locations of the resume, torrent, and clutch directories.
- * @see tr_getResumeDir()
- * @see tr_getTorrentDir()
- * @see tr_getWebClientDir()
+ * @brief invoked by tr_sessionInit () to set up the locations of the resume, torrent, and clutch directories.
+ * @see tr_getResumeDir ()
+ * @see tr_getTorrentDir ()
+ * @see tr_getWebClientDir ()
  */
-void tr_setConfigDir( tr_session * session, const char * configDir );
+void tr_setConfigDir (tr_session * session, const char * configDir);
 
 /** @brief return the directory where .resume files are stored */
-const char * tr_getResumeDir( const tr_session * );
+const char * tr_getResumeDir (const tr_session *);
 
 /** @brief return the directory where .torrent files are stored */
-const char * tr_getTorrentDir( const tr_session * );
+const char * tr_getTorrentDir (const tr_session *);
 
 /** @brief return the directory where the Web Client's web ui files are kept */
-const char * tr_getWebClientDir( const tr_session * );
+const char * tr_getWebClientDir (const tr_session *);
 
 /** @brief return the number of bytes available for use in the specified path, or -1 on error */
-int64_t tr_getFreeSpace( const char * path );
+int64_t tr_getFreeSpace (const char * path);
 
 
 /** @} */
@@ -57,11 +57,11 @@ int64_t tr_getFreeSpace( const char * path );
 typedef struct tr_thread tr_thread;
 
 /** @brief Instantiate a new process thread */
-tr_thread* tr_threadNew( void ( *func )(void *), void * arg );
+tr_thread* tr_threadNew (void (*func)(void *), void * arg);
 
 /** @brief Return nonzero if this function is being called from `thread'
     @param thread the thread being tested */
-bool tr_amInThread( const tr_thread * );
+bool tr_amInThread (const tr_thread *);
 
 /***
 ****
@@ -70,24 +70,24 @@ bool tr_amInThread( const tr_thread * );
 typedef struct tr_lock tr_lock;
 
 /** @brief Create a new thread mutex object */
-tr_lock * tr_lockNew( void );
+tr_lock * tr_lockNew (void);
 
 /** @brief Destroy a thread mutex object */
-void tr_lockFree( tr_lock * );
+void tr_lockFree (tr_lock *);
 
 /** @brief Attempt to lock a thread mutex object */
-void tr_lockLock( tr_lock * );
+void tr_lockLock (tr_lock *);
 
 /** @brief Unlock a thread mutex object */
-void tr_lockUnlock( tr_lock * );
+void tr_lockUnlock (tr_lock *);
 
 /** @brief return nonzero if the specified lock is locked */
-int tr_lockHave( const tr_lock * );
+int tr_lockHave (const tr_lock *);
 
 #ifdef WIN32
-void * mmap( void *ptr, long  size, long  prot, long  type, long  handle, long  arg );
+void * mmap (void *ptr, long  size, long  prot, long  type, long  handle, long  arg);
 
-long munmap( void *ptr, long  size );
+long munmap (void *ptr, long  size);
 #endif
 
 /* @} */
diff --git a/libtransmission/port-forwarding.c b/libtransmission/port-forwarding.c
index 81ed049cf..e6cfb5592 100644
--- a/libtransmission/port-forwarding.c
+++ b/libtransmission/port-forwarding.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -28,7 +28,7 @@
 #include "utils.h"
 
 static const char *
-getKey( void ) { return _( "Port Forwarding" ); }
+getKey (void) { return _ ("Port Forwarding"); }
 
 struct tr_shared
 {
@@ -51,20 +51,20 @@ struct tr_shared
 ***/
 
 static const char*
-getNatStateStr( int state )
+getNatStateStr (int state)
 {
-    switch( state )
+    switch (state)
     {
-        case TR_PORT_MAPPING:   return _( "Starting" );
-        case TR_PORT_MAPPED:    return _( "Forwarded" );
-        case TR_PORT_UNMAPPING: return _( "Stopping" );
-        case TR_PORT_UNMAPPED:  return _( "Not forwarded" );
+        case TR_PORT_MAPPING:   return _ ("Starting");
+        case TR_PORT_MAPPED:    return _ ("Forwarded");
+        case TR_PORT_UNMAPPING: return _ ("Stopping");
+        case TR_PORT_UNMAPPED:  return _ ("Not forwarded");
         default:                return "???";
     }
 }
 
 static void
-natPulse( tr_shared * s, bool do_check )
+natPulse (tr_shared * s, bool do_check)
 {
     const tr_port private_peer_port = s->session->private_peer_port;
     const int is_enabled = s->isEnabled && !s->isShuttingDown;
@@ -72,34 +72,34 @@ natPulse( tr_shared * s, bool do_check )
     int oldStatus;
     int newStatus;
 
-    if( s->natpmp == NULL )
-        s->natpmp = tr_natpmpInit( );
-    if( s->upnp == NULL )
-        s->upnp = tr_upnpInit( );
+    if (s->natpmp == NULL)
+        s->natpmp = tr_natpmpInit ();
+    if (s->upnp == NULL)
+        s->upnp = tr_upnpInit ();
 
-    oldStatus = tr_sharedTraversalStatus( s );
+    oldStatus = tr_sharedTraversalStatus (s);
 
-    s->natpmpStatus = tr_natpmpPulse( s->natpmp, private_peer_port, is_enabled, &public_peer_port );
-    if( s->natpmpStatus == TR_PORT_MAPPED )
+    s->natpmpStatus = tr_natpmpPulse (s->natpmp, private_peer_port, is_enabled, &public_peer_port);
+    if (s->natpmpStatus == TR_PORT_MAPPED)
         s->session->public_peer_port = public_peer_port;
 
-    s->upnpStatus = tr_upnpPulse( s->upnp, private_peer_port, is_enabled, do_check );
+    s->upnpStatus = tr_upnpPulse (s->upnp, private_peer_port, is_enabled, do_check);
 
-    newStatus = tr_sharedTraversalStatus( s );
+    newStatus = tr_sharedTraversalStatus (s);
 
-    if( newStatus != oldStatus )
-        tr_ninf( getKey( ), _( "State changed from \"%1$s\" to \"%2$s\"" ),
-                getNatStateStr( oldStatus ),
-                getNatStateStr( newStatus ) );
+    if (newStatus != oldStatus)
+        tr_ninf (getKey (), _ ("State changed from \"%1$s\" to \"%2$s\""),
+                getNatStateStr (oldStatus),
+                getNatStateStr (newStatus));
 }
 
 static void
-set_evtimer_from_status( tr_shared * s )
+set_evtimer_from_status (tr_shared * s)
 {
     int sec=0, msec=0;
 
     /* when to wake up again */
-    switch( tr_sharedTraversalStatus( s ) )
+    switch (tr_sharedTraversalStatus (s))
     {
         case TR_PORT_MAPPED:
             /* if we're mapped, everything is fine... check back in 20 minutes
@@ -119,24 +119,24 @@ set_evtimer_from_status( tr_shared * s )
             break;
     }
 
-    if( s->timer != NULL )
-        tr_timerAdd( s->timer, sec, msec );
+    if (s->timer != NULL)
+        tr_timerAdd (s->timer, sec, msec);
 }
 
 static void
-onTimer( int fd UNUSED, short what UNUSED, void * vshared )
+onTimer (int fd UNUSED, short what UNUSED, void * vshared)
 {
     tr_shared * s = vshared;
 
-    assert( s );
-    assert( s->timer );
+    assert (s);
+    assert (s->timer);
 
     /* do something */
-    natPulse( s, s->doPortCheck );
+    natPulse (s, s->doPortCheck);
     s->doPortCheck = false;
 
     /* set up the timer for the next pulse */
-    set_evtimer_from_status( s );
+    set_evtimer_from_status (s);
 }
 
 /***
@@ -144,9 +144,9 @@ onTimer( int fd UNUSED, short what UNUSED, void * vshared )
 ***/
 
 tr_shared *
-tr_sharedInit( tr_session  * session )
+tr_sharedInit (tr_session  * session)
 {
-    tr_shared * s = tr_new0( tr_shared, 1 );
+    tr_shared * s = tr_new0 (tr_shared, 1);
 
     s->session      = session;
     s->isEnabled    = false;
@@ -154,11 +154,11 @@ tr_sharedInit( tr_session  * session )
     s->natpmpStatus = TR_PORT_UNMAPPED;
 
 #if 0
-    if( isEnabled )
+    if (isEnabled)
     {
-        s->timer = tr_new0( struct event, 1 );
-        evtimer_set( s->timer, onTimer, s );
-        tr_timerAdd( s->timer, 0, 333000 );
+        s->timer = tr_new0 (struct event, 1);
+        evtimer_set (s->timer, onTimer, s);
+        tr_timerAdd (s->timer, 0, 333000);
     }
 #endif
 
@@ -166,80 +166,80 @@ tr_sharedInit( tr_session  * session )
 }
 
 static void
-stop_timer( tr_shared * s )
+stop_timer (tr_shared * s)
 {
-    if( s->timer != NULL )
+    if (s->timer != NULL)
     {
-        event_free( s->timer );
+        event_free (s->timer);
         s->timer = NULL;
     }
 }
 
 static void
-stop_forwarding( tr_shared * s )
+stop_forwarding (tr_shared * s)
 {
-    tr_ninf( getKey( ), "%s", _( "Stopped" ) );
-    natPulse( s, false );
+    tr_ninf (getKey (), "%s", _ ("Stopped"));
+    natPulse (s, false);
 
-    tr_natpmpClose( s->natpmp );
+    tr_natpmpClose (s->natpmp);
     s->natpmp = NULL;
     s->natpmpStatus = TR_PORT_UNMAPPED;
 
-    tr_upnpClose( s->upnp );
+    tr_upnpClose (s->upnp);
     s->upnp = NULL;
     s->upnpStatus = TR_PORT_UNMAPPED;
 
-    stop_timer( s );
+    stop_timer (s);
 }
 
 void
-tr_sharedClose( tr_session * session )
+tr_sharedClose (tr_session * session)
 {
     tr_shared * s = session->shared;
 
     s->isShuttingDown = true;
-    stop_forwarding( s );
+    stop_forwarding (s);
     s->session->shared = NULL;
-    tr_free( s );
+    tr_free (s);
 }
 
 static void
-start_timer( tr_shared * s )
+start_timer (tr_shared * s)
 {
-    s->timer = evtimer_new( s->session->event_base, onTimer, s );
-    set_evtimer_from_status( s );
+    s->timer = evtimer_new (s->session->event_base, onTimer, s);
+    set_evtimer_from_status (s);
 }
 
 void
-tr_sharedTraversalEnable( tr_shared * s, bool isEnabled )
+tr_sharedTraversalEnable (tr_shared * s, bool isEnabled)
 {
-    if(( s->isEnabled = isEnabled ))
-        start_timer( s );
+    if ((s->isEnabled = isEnabled))
+        start_timer (s);
     else
-        stop_forwarding( s );
+        stop_forwarding (s);
 }
 
 void
-tr_sharedPortChanged( tr_session * session )
+tr_sharedPortChanged (tr_session * session)
 {
     tr_shared * s = session->shared;
 
-    if( s->isEnabled )
+    if (s->isEnabled)
     {
-        stop_timer( s );
-        natPulse( s, false );
-        start_timer( s );
+        stop_timer (s);
+        natPulse (s, false);
+        start_timer (s);
     }
 }
 
 bool
-tr_sharedTraversalIsEnabled( const tr_shared * s )
+tr_sharedTraversalIsEnabled (const tr_shared * s)
 {
     return s->isEnabled;
 }
 
 int
-tr_sharedTraversalStatus( const tr_shared * s )
+tr_sharedTraversalStatus (const tr_shared * s)
 {
-    return MAX( s->natpmpStatus, s->upnpStatus );
+    return MAX (s->natpmpStatus, s->upnpStatus);
 }
diff --git a/libtransmission/port-forwarding.h b/libtransmission/port-forwarding.h
index f73b07c55..b313d145a 100644
--- a/libtransmission/port-forwarding.h
+++ b/libtransmission/port-forwarding.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -28,19 +28,19 @@ struct tr_bindsockets;
 
 typedef struct tr_shared tr_shared;
 
-tr_shared* tr_sharedInit( tr_session* );
+tr_shared* tr_sharedInit (tr_session*);
 
-void       tr_sharedClose( tr_session * );
+void       tr_sharedClose (tr_session *);
 
-void       tr_sharedPortChanged( tr_session * );
+void       tr_sharedPortChanged (tr_session *);
 
-void       tr_sharedTraversalEnable( tr_shared *, bool isEnabled );
+void       tr_sharedTraversalEnable (tr_shared *, bool isEnabled);
 
-tr_port    tr_sharedGetPeerPort( const tr_shared * s );
+tr_port    tr_sharedGetPeerPort (const tr_shared * s);
 
-bool       tr_sharedTraversalIsEnabled( const tr_shared * s );
+bool       tr_sharedTraversalIsEnabled (const tr_shared * s);
 
-int        tr_sharedTraversalStatus( const tr_shared * );
+int        tr_sharedTraversalStatus (const tr_shared *);
 
 /** @} */
 #endif
diff --git a/libtransmission/ptrarray.c b/libtransmission/ptrarray.c
index c84084071..ffd716f85 100644
--- a/libtransmission/ptrarray.c
+++ b/libtransmission/ptrarray.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,7 +11,7 @@
  */
 
 #include <assert.h>
-#include <stdlib.h> /* tr_renew() -> realloc() */
+#include <stdlib.h> /* tr_renew () -> realloc () */
 #include <string.h> /* memmove */
 
 #include "ptrarray.h"
@@ -22,58 +22,58 @@
 const tr_ptrArray TR_PTR_ARRAY_INIT = { NULL, 0, 0 };
 
 void
-tr_ptrArrayDestruct( tr_ptrArray * p, PtrArrayForeachFunc func )
+tr_ptrArrayDestruct (tr_ptrArray * p, PtrArrayForeachFunc func)
 {
-    assert( p );
-    assert( p->items || !p->n_items );
+    assert (p);
+    assert (p->items || !p->n_items);
 
-    if( func )
-        tr_ptrArrayForeach( p, func );
+    if (func)
+        tr_ptrArrayForeach (p, func);
 
-    tr_free( p->items );
+    tr_free (p->items);
 
-    memset( p, ~0, sizeof( tr_ptrArray ) );
+    memset (p, ~0, sizeof (tr_ptrArray));
 }
 
 void
-tr_ptrArrayForeach( tr_ptrArray *       t,
-                    PtrArrayForeachFunc func )
+tr_ptrArrayForeach (tr_ptrArray *       t,
+                    PtrArrayForeachFunc func)
 {
     int i;
 
-    assert( t );
-    assert( t->items || !t->n_items );
-    assert( func );
+    assert (t);
+    assert (t->items || !t->n_items);
+    assert (func);
 
-    for( i = 0; i < t->n_items; ++i )
-        func( t->items[i] );
+    for (i = 0; i < t->n_items; ++i)
+        func (t->items[i]);
 }
 
 void**
-tr_ptrArrayPeek( tr_ptrArray * t,
-                 int *         size )
+tr_ptrArrayPeek (tr_ptrArray * t,
+                 int *         size)
 {
     *size = t->n_items;
     return t->items;
 }
 
 int
-tr_ptrArrayInsert( tr_ptrArray * t,
+tr_ptrArrayInsert (tr_ptrArray * t,
                    void        * ptr,
-                   int           pos )
+                   int           pos)
 {
-    if( t->n_items >= t->n_alloc )
+    if (t->n_items >= t->n_alloc)
     {
-        t->n_alloc = MAX( FLOOR, t->n_alloc * 2 );
-        t->items = tr_renew( void*, t->items, t->n_alloc );
+        t->n_alloc = MAX (FLOOR, t->n_alloc * 2);
+        t->items = tr_renew (void*, t->items, t->n_alloc);
     }
 
-    if( pos < 0 || pos > t->n_items )
+    if (pos < 0 || pos > t->n_items)
         pos = t->n_items;
     else
-        memmove( t->items + pos + 1,
+        memmove (t->items + pos + 1,
                  t->items + pos,
-                 sizeof( void* ) * ( t->n_items - pos ) );
+                 sizeof (void*) * (t->n_items - pos));
 
     t->items[pos] = ptr;
     t->n_items++;
@@ -81,31 +81,31 @@ tr_ptrArrayInsert( tr_ptrArray * t,
 }
 
 void*
-tr_ptrArrayPop( tr_ptrArray* t )
+tr_ptrArrayPop (tr_ptrArray* t)
 {
     void * ret = NULL;
 
-    if( t->n_items )
+    if (t->n_items)
         ret = t->items[--t->n_items];
 
     return ret;
 }
 
 void
-tr_ptrArrayErase( tr_ptrArray * t,
+tr_ptrArrayErase (tr_ptrArray * t,
                   int           begin,
-                  int           end )
+                  int           end)
 {
-    assert( begin >= 0 );
-    if( end < 0 ) end = t->n_items;
-    assert( begin < end );
-    assert( end <= t->n_items );
+    assert (begin >= 0);
+    if (end < 0) end = t->n_items;
+    assert (begin < end);
+    assert (end <= t->n_items);
 
-    memmove( t->items + begin,
+    memmove (t->items + begin,
              t->items + end,
-             sizeof( void* ) * ( t->n_items - end ) );
+             sizeof (void*) * (t->n_items - end));
 
-    t->n_items -= ( end - begin );
+    t->n_items -= (end - begin);
 }
 
 /**
@@ -113,15 +113,15 @@ tr_ptrArrayErase( tr_ptrArray * t,
 **/
 
 int
-tr_ptrArrayLowerBound( const tr_ptrArray  * t,
+tr_ptrArrayLowerBound (const tr_ptrArray  * t,
                        const void         * ptr,
-                       int                  compare( const void *, const void * ),
-                       bool               * exact_match )
+                       int                  compare (const void *, const void *),
+                       bool               * exact_match)
 {
     int pos = -1;
     bool match = false;
 
-    if( t->n_items == 0 )
+    if (t->n_items == 0)
     {
         pos = 0;
     }
@@ -130,22 +130,22 @@ tr_ptrArrayLowerBound( const tr_ptrArray  * t,
         int first = 0;
         int last = t->n_items - 1;
 
-        for( ;; )
+        for (;;)
         {
             const int half = (last - first) / 2;
-            const int c = compare( t->items[first + half], ptr );
+            const int c = compare (t->items[first + half], ptr);
 
-            if( c < 0 ) {
+            if (c < 0) {
                 const int new_first = first + half + 1;
-                if( new_first > last ) {
+                if (new_first > last) {
                     pos = new_first;
                     break;
                 }
                 first = new_first;
             }
-            else if( c > 0 ) {
+            else if (c > 0) {
                 const int new_last = first + half - 1;
-                if( new_last < first ) {
+                if (new_last < first) {
                     pos = first;
                     break;
                 }
@@ -159,67 +159,67 @@ tr_ptrArrayLowerBound( const tr_ptrArray  * t,
         }
     }
 
-    if( exact_match )
+    if (exact_match)
         *exact_match = match;
     return pos;
 }
 
 static void
-assertSortedAndUnique( const tr_ptrArray * t UNUSED,
-                       int compare(const void*, const void*) UNUSED )
+assertSortedAndUnique (const tr_ptrArray * t UNUSED,
+                       int compare (const void*, const void*) UNUSED)
 {
 #ifndef NDEBUG
     int i;
 
-    for( i = 0; i < t->n_items - 2; ++i )
-        assert( compare( t->items[i], t->items[i + 1] ) < 0 );
+    for (i = 0; i < t->n_items - 2; ++i)
+        assert (compare (t->items[i], t->items[i + 1]) < 0);
 #endif
 }
 
 int
-tr_ptrArrayInsertSorted( tr_ptrArray * t,
+tr_ptrArrayInsertSorted (tr_ptrArray * t,
                          void *        ptr,
-                         int           compare(const void*, const void*) )
+                         int           compare (const void*, const void*))
 {
     int pos;
     int ret;
 
-    assertSortedAndUnique( t, compare );
+    assertSortedAndUnique (t, compare);
 
-    pos = tr_ptrArrayLowerBound( t, ptr, compare, NULL );
-    ret = tr_ptrArrayInsert( t, ptr, pos );
+    pos = tr_ptrArrayLowerBound (t, ptr, compare, NULL);
+    ret = tr_ptrArrayInsert (t, ptr, pos);
 
-    assertSortedAndUnique( t, compare );
+    assertSortedAndUnique (t, compare);
     return ret;
 }
 
 void*
-tr_ptrArrayFindSorted( tr_ptrArray * t,
+tr_ptrArrayFindSorted (tr_ptrArray * t,
                        const void *  ptr,
-                       int           compare(const void*, const void*) )
+                       int           compare (const void*, const void*))
 {
     bool match = false;
-    const int pos = tr_ptrArrayLowerBound( t, ptr, compare, &match );
+    const int pos = tr_ptrArrayLowerBound (t, ptr, compare, &match);
     return match ? t->items[pos] : NULL;
 }
 
 void*
-tr_ptrArrayRemoveSorted( tr_ptrArray * t,
+tr_ptrArrayRemoveSorted (tr_ptrArray * t,
                          const void  * ptr,
-                         int           compare(const void*, const void*) )
+                         int           compare (const void*, const void*))
 {
     bool match;
     void * ret = NULL;
-    const int pos = tr_ptrArrayLowerBound( t, ptr, compare, &match );
-    assertSortedAndUnique( t, compare );
+    const int pos = tr_ptrArrayLowerBound (t, ptr, compare, &match);
+    assertSortedAndUnique (t, compare);
 
-    if( match )
+    if (match)
     {
         ret = t->items[pos];
-        assert( compare( ret, ptr ) == 0 );
-        tr_ptrArrayErase( t, pos, pos + 1 );
+        assert (compare (ret, ptr) == 0);
+        tr_ptrArrayErase (t, pos, pos + 1);
     }
-    assertSortedAndUnique( t, compare );
-    assert( ( ret == NULL ) || ( compare( ret, ptr ) == 0 ) );
+    assertSortedAndUnique (t, compare);
+    assert ((ret == NULL) || (compare (ret, ptr) == 0));
     return ret;
 }
diff --git a/libtransmission/ptrarray.h b/libtransmission/ptrarray.h
index f85e7e7d7..aa7e8614f 100644
--- a/libtransmission/ptrarray.h
+++ b/libtransmission/ptrarray.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -37,106 +37,106 @@ typedef struct tr_ptrArray
 }
 tr_ptrArray;
 
-typedef void ( *PtrArrayForeachFunc )( void * );
+typedef void (*PtrArrayForeachFunc)(void *);
 
 extern const tr_ptrArray TR_PTR_ARRAY_INIT;
 
 /** @brief Destructor to free a tr_ptrArray's internal memory */
-void tr_ptrArrayDestruct( tr_ptrArray*, PtrArrayForeachFunc func );
+void tr_ptrArrayDestruct (tr_ptrArray*, PtrArrayForeachFunc func);
 
 /** @brief Iterate through each item in a tr_ptrArray */
-void tr_ptrArrayForeach( tr_ptrArray         * array,
-                         PtrArrayForeachFunc   func );
+void tr_ptrArrayForeach (tr_ptrArray         * array,
+                         PtrArrayForeachFunc   func);
 
 /** @brief Return the nth item in a tr_ptrArray
     @return the nth item in a tr_ptrArray */
 static inline void*
-tr_ptrArrayNth( tr_ptrArray * array, int i )
+tr_ptrArrayNth (tr_ptrArray * array, int i)
 {
-    assert( array );
-    assert( i >= 0 );
-    assert( i < array->n_items );
+    assert (array);
+    assert (i >= 0);
+    assert (i < array->n_items);
 
     return array->items[i];
 }
 
 /** @brief Remove the last item from the array and return it
     @return the pointer that's been removed from the array
-    @see tr_ptrArrayBack() */
-void* tr_ptrArrayPop( tr_ptrArray * array );
+    @see tr_ptrArrayBack () */
+void* tr_ptrArrayPop (tr_ptrArray * array);
 
 /** @brief Return the last item in a tr_ptrArray
     @return the last item in a tr_ptrArray, or NULL if the array is empty
-    @see tr_ptrArrayPop() */
-static inline void* tr_ptrArrayBack( tr_ptrArray * array )
+    @see tr_ptrArrayPop () */
+static inline void* tr_ptrArrayBack (tr_ptrArray * array)
 {
-    return array->n_items > 0 ? tr_ptrArrayNth( array, array->n_items - 1 )
+    return array->n_items > 0 ? tr_ptrArrayNth (array, array->n_items - 1)
                               : NULL;
 }
 
-void tr_ptrArrayErase( tr_ptrArray * t, int begin, int end );
+void tr_ptrArrayErase (tr_ptrArray * t, int begin, int end);
 
-static inline void tr_ptrArrayRemove( tr_ptrArray * t, int pos )
+static inline void tr_ptrArrayRemove (tr_ptrArray * t, int pos)
 {
-    tr_ptrArrayErase( t, pos, pos+1 );
+    tr_ptrArrayErase (t, pos, pos+1);
 }
 
 /** @brief Peek at the array pointer and its size, for easy iteration */
-void** tr_ptrArrayPeek( tr_ptrArray * array, int * size );
+void** tr_ptrArrayPeek (tr_ptrArray * array, int * size);
 
-static inline void  tr_ptrArrayClear( tr_ptrArray * a ) { a->n_items = 0; }
+static inline void  tr_ptrArrayClear (tr_ptrArray * a) { a->n_items = 0; }
 
 /** @brief Insert a pointer into the array at the specified position
     @return the index of the stored pointer */
-int tr_ptrArrayInsert( tr_ptrArray * array, void * insertMe, int pos );
+int tr_ptrArrayInsert (tr_ptrArray * array, void * insertMe, int pos);
 
 /** @brief Append a pointer into the array */
-static inline int tr_ptrArrayAppend( tr_ptrArray * array, void * appendMe )
+static inline int tr_ptrArrayAppend (tr_ptrArray * array, void * appendMe)
 {
-    return tr_ptrArrayInsert( array, appendMe, -1 );
+    return tr_ptrArrayInsert (array, appendMe, -1);
 }
 
-static inline void** tr_ptrArrayBase( const tr_ptrArray * a )
+static inline void** tr_ptrArrayBase (const tr_ptrArray * a)
 {
     return a->items;
 }
 
 /** @brief Return the number of items in the array
     @return the number of items in the array */
-static inline int tr_ptrArraySize( const tr_ptrArray *  a )
+static inline int tr_ptrArraySize (const tr_ptrArray *  a)
 {
     return a->n_items;
 }
 
 /** @brief Return True if the array has no pointers
     @return True if the array has no pointers */
-static inline bool tr_ptrArrayEmpty( const tr_ptrArray * a )
+static inline bool tr_ptrArrayEmpty (const tr_ptrArray * a)
 {
-    return tr_ptrArraySize(a) == 0;
+    return tr_ptrArraySize (a) == 0;
 }
 
-int tr_ptrArrayLowerBound( const tr_ptrArray * array,
+int tr_ptrArrayLowerBound (const tr_ptrArray * array,
                            const void * key,
-                           int compare( const void * arrayItem, const void * key ),
-                           bool * exact_match );
+                           int compare (const void * arrayItem, const void * key),
+                           bool * exact_match);
 
 /** @brief Insert a pointer into the array at the position determined by the sort function
     @return the index of the stored pointer */
-int tr_ptrArrayInsertSorted( tr_ptrArray * array,
+int tr_ptrArrayInsertSorted (tr_ptrArray * array,
                              void        * value,
-                             int compare(const void*, const void*) );
+                             int compare (const void*, const void*));
 
 /** @brief Remove a pointer from an array sorted by the specified sort function
     @return the matching pointer, or NULL if no match was found */
-void* tr_ptrArrayRemoveSorted( tr_ptrArray * array,
+void* tr_ptrArrayRemoveSorted (tr_ptrArray * array,
                                const void  * value,
-                               int compare(const void*, const void*) );
+                               int compare (const void*, const void*));
 
 /** @brief Find a pointer from an array sorted by the specified sort function
     @return the matching pointer, or NULL if no match was found */
-void* tr_ptrArrayFindSorted( tr_ptrArray * array,
+void* tr_ptrArrayFindSorted (tr_ptrArray * array,
                              const void  * key,
-                             int compare(const void*, const void*) );
+                             int compare (const void*, const void*));
 
 /* @} */
 #endif
diff --git a/libtransmission/resume.c b/libtransmission/resume.c
index a87951596..0cf08cf35 100644
--- a/libtransmission/resume.c
+++ b/libtransmission/resume.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -17,9 +17,9 @@
 #include "transmission.h"
 #include "bencode.h"
 #include "completion.h"
-#include "metainfo.h" /* tr_metainfoGetBasename() */
+#include "metainfo.h" /* tr_metainfoGetBasename () */
 #include "peer-mgr.h" /* pex */
-#include "platform.h" /* tr_getResumeDir() */
+#include "platform.h" /* tr_getResumeDir () */
 #include "resume.h"
 #include "session.h"
 #include "torrent.h"
@@ -74,12 +74,12 @@ enum
 };
 
 static char*
-getResumeFilename( const tr_torrent * tor )
+getResumeFilename (const tr_torrent * tor)
 {
-    char * base = tr_metainfoGetBasename( tr_torrentInfo( tor ) );
-    char * filename = tr_strdup_printf( "%s" TR_PATH_DELIMITER_STR "%s.resume",
-                                        tr_getResumeDir( tor->session ), base );
-    tr_free( base );
+    char * base = tr_metainfoGetBasename (tr_torrentInfo (tor));
+    char * filename = tr_strdup_printf ("%s" TR_PATH_DELIMITER_STR "%s.resume",
+                                        tr_getResumeDir (tor->session), base);
+    tr_free (base);
     return filename;
 }
 
@@ -88,37 +88,37 @@ getResumeFilename( const tr_torrent * tor )
 ***/
 
 static void
-savePeers( tr_benc * dict, const tr_torrent * tor )
+savePeers (tr_benc * dict, const tr_torrent * tor)
 {
     int count;
     tr_pex * pex;
 
-    count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS );
-    if( count > 0 )
-        tr_bencDictAddRaw( dict, KEY_PEERS, pex, sizeof( tr_pex ) * count );
-    tr_free( pex );
+    count = tr_peerMgrGetPeers ((tr_torrent*) tor, &pex, TR_AF_INET, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS);
+    if (count > 0)
+        tr_bencDictAddRaw (dict, KEY_PEERS, pex, sizeof (tr_pex) * count);
+    tr_free (pex);
 
-    count = tr_peerMgrGetPeers( (tr_torrent*) tor, &pex, TR_AF_INET6, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS );
-    if( count > 0 )
-        tr_bencDictAddRaw( dict, KEY_PEERS6, pex, sizeof( tr_pex ) * count );
+    count = tr_peerMgrGetPeers ((tr_torrent*) tor, &pex, TR_AF_INET6, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS);
+    if (count > 0)
+        tr_bencDictAddRaw (dict, KEY_PEERS6, pex, sizeof (tr_pex) * count);
 
-    tr_free( pex );
+    tr_free (pex);
 }
 
 static int
-addPeers( tr_torrent * tor, const uint8_t * buf, int buflen )
+addPeers (tr_torrent * tor, const uint8_t * buf, int buflen)
 {
     int i;
     int numAdded = 0;
-    const int count = buflen / sizeof( tr_pex );
+    const int count = buflen / sizeof (tr_pex);
 
-    for( i=0; i<count && numAdded<MAX_REMEMBERED_PEERS; ++i )
+    for (i=0; i<count && numAdded<MAX_REMEMBERED_PEERS; ++i)
     {
         tr_pex pex;
-        memcpy( &pex, buf + ( i * sizeof( tr_pex ) ), sizeof( tr_pex ) );
-        if( tr_isPex( &pex ) )
+        memcpy (&pex, buf + (i * sizeof (tr_pex)), sizeof (tr_pex));
+        if (tr_isPex (&pex))
         {
-            tr_peerMgrAddPex( tor, TR_PEER_FROM_RESUME, &pex, -1 );
+            tr_peerMgrAddPex (tor, TR_PEER_FROM_RESUME, &pex, -1);
             ++numAdded;
         }
     }
@@ -128,23 +128,23 @@ addPeers( tr_torrent * tor, const uint8_t * buf, int buflen )
 
 
 static uint64_t
-loadPeers( tr_benc * dict, tr_torrent * tor )
+loadPeers (tr_benc * dict, tr_torrent * tor)
 {
     uint64_t        ret = 0;
     const uint8_t * str;
     size_t          len;
 
-    if( tr_bencDictFindRaw( dict, KEY_PEERS, &str, &len ) )
+    if (tr_bencDictFindRaw (dict, KEY_PEERS, &str, &len))
     {
-        const int numAdded = addPeers( tor, str, len );
-        tr_tordbg( tor, "Loaded %d IPv4 peers from resume file", numAdded );
+        const int numAdded = addPeers (tor, str, len);
+        tr_tordbg (tor, "Loaded %d IPv4 peers from resume file", numAdded);
         ret = TR_FR_PEERS;
     }
 
-    if( tr_bencDictFindRaw( dict, KEY_PEERS6, &str, &len ) )
+    if (tr_bencDictFindRaw (dict, KEY_PEERS6, &str, &len))
     {
-        const int numAdded = addPeers( tor, str, len );
-        tr_tordbg( tor, "Loaded %d IPv6 peers from resume file", numAdded );
+        const int numAdded = addPeers (tor, str, len);
+        tr_tordbg (tor, "Loaded %d IPv6 peers from resume file", numAdded);
         ret = TR_FR_PEERS;
     }
 
@@ -156,65 +156,65 @@ loadPeers( tr_benc * dict, tr_torrent * tor )
 ***/
 
 static void
-saveDND( tr_benc * dict, const tr_torrent * tor )
+saveDND (tr_benc * dict, const tr_torrent * tor)
 {
     tr_benc * list;
     tr_file_index_t i;
-    const tr_info * const inf = tr_torrentInfo( tor );
+    const tr_info * const inf = tr_torrentInfo (tor);
     const tr_file_index_t n = inf->fileCount;
 
-    list = tr_bencDictAddList( dict, KEY_DND, n );
-    for( i=0; i<n; ++i )
-        tr_bencListAddInt( list, inf->files[i].dnd ? 1 : 0 );
+    list = tr_bencDictAddList (dict, KEY_DND, n);
+    for (i=0; i<n; ++i)
+        tr_bencListAddInt (list, inf->files[i].dnd ? 1 : 0);
 }
 
 static uint64_t
-loadDND( tr_benc * dict, tr_torrent * tor )
+loadDND (tr_benc * dict, tr_torrent * tor)
 {
     uint64_t ret = 0;
     tr_benc * list = NULL;
     const tr_file_index_t n = tor->info.fileCount;
 
-    if( tr_bencDictFindList( dict, KEY_DND, &list )
-      && ( tr_bencListSize( list ) == n ) )
+    if (tr_bencDictFindList (dict, KEY_DND, &list)
+      && (tr_bencListSize (list) == n))
     {
         int64_t           tmp;
-        tr_file_index_t * dl = tr_new( tr_file_index_t, n );
-        tr_file_index_t * dnd = tr_new( tr_file_index_t, n );
+        tr_file_index_t * dl = tr_new (tr_file_index_t, n);
+        tr_file_index_t * dnd = tr_new (tr_file_index_t, n);
         tr_file_index_t   i, dlCount = 0, dndCount = 0;
 
-        for( i=0; i<n; ++i )
+        for (i=0; i<n; ++i)
         {
-            if( tr_bencGetInt( tr_bencListChild( list, i ), &tmp ) && tmp )
+            if (tr_bencGetInt (tr_bencListChild (list, i), &tmp) && tmp)
                 dnd[dndCount++] = i;
             else
                 dl[dlCount++] = i;
         }
 
-        if( dndCount )
+        if (dndCount)
         {
-            tr_torrentInitFileDLs ( tor, dnd, dndCount, false );
-            tr_tordbg( tor, "Resume file found %d files listed as dnd",
-                       dndCount );
+            tr_torrentInitFileDLs (tor, dnd, dndCount, false);
+            tr_tordbg (tor, "Resume file found %d files listed as dnd",
+                       dndCount);
         }
-        if( dlCount )
+        if (dlCount)
         {
-            tr_torrentInitFileDLs ( tor, dl, dlCount, true );
-            tr_tordbg( tor,
+            tr_torrentInitFileDLs (tor, dl, dlCount, true);
+            tr_tordbg (tor,
                        "Resume file found %d files marked for download",
-                       dlCount );
+                       dlCount);
         }
 
-        tr_free( dnd );
-        tr_free( dl );
+        tr_free (dnd);
+        tr_free (dl);
         ret = TR_FR_DND;
     }
     else
     {
-        tr_tordbg(
+        tr_tordbg (
             tor,
             "Couldn't load DND flags. DND list (%p) has %zu children; torrent has %d files",
-            list, tr_bencListSize( list ), (int)n );
+            list, tr_bencListSize (list), (int)n);
     }
 
     return ret;
@@ -225,33 +225,33 @@ loadDND( tr_benc * dict, tr_torrent * tor )
 ***/
 
 static void
-saveFilePriorities( tr_benc * dict, const tr_torrent * tor )
+saveFilePriorities (tr_benc * dict, const tr_torrent * tor)
 {
     tr_benc * list;
     tr_file_index_t i;
-    const tr_info * const inf = tr_torrentInfo( tor );
+    const tr_info * const inf = tr_torrentInfo (tor);
     const tr_file_index_t n = inf->fileCount;
 
-    list = tr_bencDictAddList( dict, KEY_FILE_PRIORITIES, n );
-    for( i = 0; i < n; ++i )
-        tr_bencListAddInt( list, inf->files[i].priority );
+    list = tr_bencDictAddList (dict, KEY_FILE_PRIORITIES, n);
+    for (i = 0; i < n; ++i)
+        tr_bencListAddInt (list, inf->files[i].priority);
 }
 
 static uint64_t
-loadFilePriorities( tr_benc * dict, tr_torrent * tor )
+loadFilePriorities (tr_benc * dict, tr_torrent * tor)
 {
     tr_benc * list;
     uint64_t ret = 0;
     const tr_file_index_t n = tor->info.fileCount;
 
-    if( tr_bencDictFindList( dict, KEY_FILE_PRIORITIES, &list )
-      && ( tr_bencListSize( list ) == n ) )
+    if (tr_bencDictFindList (dict, KEY_FILE_PRIORITIES, &list)
+      && (tr_bencListSize (list) == n))
     {
         int64_t priority;
         tr_file_index_t i;
-        for( i = 0; i < n; ++i )
-            if( tr_bencGetInt( tr_bencListChild( list, i ), &priority ) )
-                tr_torrentInitFilePriority( tor, i, priority );
+        for (i = 0; i < n; ++i)
+            if (tr_bencGetInt (tr_bencListChild (list, i), &priority))
+                tr_torrentInitFilePriority (tor, i, priority);
         ret = TR_FR_FILE_PRIORITIES;
     }
 
@@ -263,53 +263,53 @@ loadFilePriorities( tr_benc * dict, tr_torrent * tor )
 ***/
 
 static void
-saveSingleSpeedLimit( tr_benc * d, const tr_torrent * tor, tr_direction dir )
+saveSingleSpeedLimit (tr_benc * d, const tr_torrent * tor, tr_direction dir)
 {
-    tr_bencDictReserve( d, 3 );
-    tr_bencDictAddInt( d, KEY_SPEED_Bps, tr_torrentGetSpeedLimit_Bps( tor, dir ) );
-    tr_bencDictAddBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits( tor ) );
-    tr_bencDictAddBool( d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit( tor, dir ) );
+    tr_bencDictReserve (d, 3);
+    tr_bencDictAddInt (d, KEY_SPEED_Bps, tr_torrentGetSpeedLimit_Bps (tor, dir));
+    tr_bencDictAddBool (d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits (tor));
+    tr_bencDictAddBool (d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit (tor, dir));
 }
 
 static void
-saveSpeedLimits( tr_benc * dict, const tr_torrent * tor )
+saveSpeedLimits (tr_benc * dict, const tr_torrent * tor)
 {
-    saveSingleSpeedLimit( tr_bencDictAddDict( dict, KEY_SPEEDLIMIT_DOWN, 0 ), tor, TR_DOWN );
-    saveSingleSpeedLimit( tr_bencDictAddDict( dict, KEY_SPEEDLIMIT_UP, 0 ), tor, TR_UP );
+    saveSingleSpeedLimit (tr_bencDictAddDict (dict, KEY_SPEEDLIMIT_DOWN, 0), tor, TR_DOWN);
+    saveSingleSpeedLimit (tr_bencDictAddDict (dict, KEY_SPEEDLIMIT_UP, 0), tor, TR_UP);
 }
 
 static void
-saveRatioLimits( tr_benc * dict, const tr_torrent * tor )
+saveRatioLimits (tr_benc * dict, const tr_torrent * tor)
 {
-    tr_benc * d = tr_bencDictAddDict( dict, KEY_RATIOLIMIT, 2 );
-    tr_bencDictAddReal( d, KEY_RATIOLIMIT_RATIO, tr_torrentGetRatioLimit( tor ) );
-    tr_bencDictAddInt( d, KEY_RATIOLIMIT_MODE, tr_torrentGetRatioMode( tor ) );
+    tr_benc * d = tr_bencDictAddDict (dict, KEY_RATIOLIMIT, 2);
+    tr_bencDictAddReal (d, KEY_RATIOLIMIT_RATIO, tr_torrentGetRatioLimit (tor));
+    tr_bencDictAddInt (d, KEY_RATIOLIMIT_MODE, tr_torrentGetRatioMode (tor));
 }
 
 static void
-saveIdleLimits( tr_benc * dict, const tr_torrent * tor )
+saveIdleLimits (tr_benc * dict, const tr_torrent * tor)
 {
-    tr_benc * d = tr_bencDictAddDict( dict, KEY_IDLELIMIT, 2 );
-    tr_bencDictAddInt( d, KEY_IDLELIMIT_MINS, tr_torrentGetIdleLimit( tor ) );
-    tr_bencDictAddInt( d, KEY_IDLELIMIT_MODE, tr_torrentGetIdleMode( tor ) );
+    tr_benc * d = tr_bencDictAddDict (dict, KEY_IDLELIMIT, 2);
+    tr_bencDictAddInt (d, KEY_IDLELIMIT_MINS, tr_torrentGetIdleLimit (tor));
+    tr_bencDictAddInt (d, KEY_IDLELIMIT_MODE, tr_torrentGetIdleMode (tor));
 }
 
 static void
-loadSingleSpeedLimit( tr_benc * d, tr_direction dir, tr_torrent * tor )
+loadSingleSpeedLimit (tr_benc * d, tr_direction dir, tr_torrent * tor)
 {
     int64_t i;
     bool boolVal;
 
-    if( tr_bencDictFindInt( d, KEY_SPEED_Bps, &i ) )
-        tr_torrentSetSpeedLimit_Bps( tor, dir, i );
-    else if( tr_bencDictFindInt( d, KEY_SPEED_KiBps, &i ) )
-        tr_torrentSetSpeedLimit_Bps( tor, dir, i*1024 );
+    if (tr_bencDictFindInt (d, KEY_SPEED_Bps, &i))
+        tr_torrentSetSpeedLimit_Bps (tor, dir, i);
+    else if (tr_bencDictFindInt (d, KEY_SPEED_KiBps, &i))
+        tr_torrentSetSpeedLimit_Bps (tor, dir, i*1024);
 
-    if( tr_bencDictFindBool( d, KEY_USE_SPEED_LIMIT, &boolVal ) )
-        tr_torrentUseSpeedLimit( tor, dir, boolVal );
+    if (tr_bencDictFindBool (d, KEY_USE_SPEED_LIMIT, &boolVal))
+        tr_torrentUseSpeedLimit (tor, dir, boolVal);
 
-    if( tr_bencDictFindBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal ) )
-        tr_torrentUseSessionLimits( tor, boolVal );
+    if (tr_bencDictFindBool (d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal))
+        tr_torrentUseSessionLimits (tor, boolVal);
 }
 
 enum old_speed_modes
@@ -319,39 +319,39 @@ enum old_speed_modes
 };
 
 static uint64_t
-loadSpeedLimits( tr_benc * dict, tr_torrent * tor )
+loadSpeedLimits (tr_benc * dict, tr_torrent * tor)
 {
     tr_benc * d;
     uint64_t ret = 0;
 
 
-    if( tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_UP, &d ) )
+    if (tr_bencDictFindDict (dict, KEY_SPEEDLIMIT_UP, &d))
     {
-        loadSingleSpeedLimit( d, TR_UP, tor );
+        loadSingleSpeedLimit (d, TR_UP, tor);
         ret = TR_FR_SPEEDLIMIT;
     }
-    if( tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_DOWN, &d ) )
+    if (tr_bencDictFindDict (dict, KEY_SPEEDLIMIT_DOWN, &d))
     {
-        loadSingleSpeedLimit( d, TR_DOWN, tor );
+        loadSingleSpeedLimit (d, TR_DOWN, tor);
         ret = TR_FR_SPEEDLIMIT;
     }
 
     /* older speedlimit structure */
-    if( !ret && tr_bencDictFindDict( dict, KEY_SPEEDLIMIT_OLD, &d ) )
+    if (!ret && tr_bencDictFindDict (dict, KEY_SPEEDLIMIT_OLD, &d))
     {
 
         int64_t i;
-        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_SPEED, &i ) )
-            tr_torrentSetSpeedLimit_Bps( tor, TR_DOWN, i*1024 );
-        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_DOWN_MODE, &i ) ) {
-            tr_torrentUseSpeedLimit( tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE );
-            tr_torrentUseSessionLimits( tor, i==TR_SPEEDLIMIT_GLOBAL );
+        if (tr_bencDictFindInt (d, KEY_SPEEDLIMIT_DOWN_SPEED, &i))
+            tr_torrentSetSpeedLimit_Bps (tor, TR_DOWN, i*1024);
+        if (tr_bencDictFindInt (d, KEY_SPEEDLIMIT_DOWN_MODE, &i)) {
+            tr_torrentUseSpeedLimit (tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE);
+            tr_torrentUseSessionLimits (tor, i==TR_SPEEDLIMIT_GLOBAL);
          }
-        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_SPEED, &i ) )
-            tr_torrentSetSpeedLimit_Bps( tor, TR_UP, i*1024 );
-        if( tr_bencDictFindInt( d, KEY_SPEEDLIMIT_UP_MODE, &i ) ) {
-            tr_torrentUseSpeedLimit( tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE );
-            tr_torrentUseSessionLimits( tor, i==TR_SPEEDLIMIT_GLOBAL );
+        if (tr_bencDictFindInt (d, KEY_SPEEDLIMIT_UP_SPEED, &i))
+            tr_torrentSetSpeedLimit_Bps (tor, TR_UP, i*1024);
+        if (tr_bencDictFindInt (d, KEY_SPEEDLIMIT_UP_MODE, &i)) {
+            tr_torrentUseSpeedLimit (tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE);
+            tr_torrentUseSessionLimits (tor, i==TR_SPEEDLIMIT_GLOBAL);
         }
         ret = TR_FR_SPEEDLIMIT;
     }
@@ -360,19 +360,19 @@ loadSpeedLimits( tr_benc * dict, tr_torrent * tor )
 }
 
 static uint64_t
-loadRatioLimits( tr_benc * dict, tr_torrent * tor )
+loadRatioLimits (tr_benc * dict, tr_torrent * tor)
 {
     tr_benc * d;
     uint64_t ret = 0;
 
-    if( tr_bencDictFindDict( dict, KEY_RATIOLIMIT, &d ) )
+    if (tr_bencDictFindDict (dict, KEY_RATIOLIMIT, &d))
     {
         int64_t i;
         double dratio;
-        if( tr_bencDictFindReal( d, KEY_RATIOLIMIT_RATIO, &dratio ) )
-            tr_torrentSetRatioLimit( tor, dratio );
-        if( tr_bencDictFindInt( d, KEY_RATIOLIMIT_MODE, &i ) )
-            tr_torrentSetRatioMode( tor, i );
+        if (tr_bencDictFindReal (d, KEY_RATIOLIMIT_RATIO, &dratio))
+            tr_torrentSetRatioLimit (tor, dratio);
+        if (tr_bencDictFindInt (d, KEY_RATIOLIMIT_MODE, &i))
+            tr_torrentSetRatioMode (tor, i);
       ret = TR_FR_RATIOLIMIT;
     }
 
@@ -380,19 +380,19 @@ loadRatioLimits( tr_benc * dict, tr_torrent * tor )
 }
 
 static uint64_t
-loadIdleLimits( tr_benc * dict, tr_torrent * tor )
+loadIdleLimits (tr_benc * dict, tr_torrent * tor)
 {
     tr_benc * d;
     uint64_t ret = 0;
 
-    if( tr_bencDictFindDict( dict, KEY_IDLELIMIT, &d ) )
+    if (tr_bencDictFindDict (dict, KEY_IDLELIMIT, &d))
     {
         int64_t i;
         int64_t imin;
-        if( tr_bencDictFindInt( d, KEY_IDLELIMIT_MINS, &imin ) )
-            tr_torrentSetIdleLimit( tor, imin );
-        if( tr_bencDictFindInt( d, KEY_IDLELIMIT_MODE, &i ) )
-            tr_torrentSetIdleMode( tor, i );
+        if (tr_bencDictFindInt (d, KEY_IDLELIMIT_MINS, &imin))
+            tr_torrentSetIdleLimit (tor, imin);
+        if (tr_bencDictFindInt (d, KEY_IDLELIMIT_MODE, &i))
+            tr_torrentSetIdleMode (tor, i);
       ret = TR_FR_IDLELIMIT;
     }
 
@@ -403,52 +403,52 @@ loadIdleLimits( tr_benc * dict, tr_torrent * tor )
 ***/
 
 static void
-bitfieldToBenc( const tr_bitfield * b, tr_benc * benc )
+bitfieldToBenc (const tr_bitfield * b, tr_benc * benc)
 {
-    if( tr_bitfieldHasAll( b ) )
-        tr_bencInitStr( benc, "all", 3 );
-    else if( tr_bitfieldHasNone( b ) )
-        tr_bencInitStr( benc, "none", 4 );
+    if (tr_bitfieldHasAll (b))
+        tr_bencInitStr (benc, "all", 3);
+    else if (tr_bitfieldHasNone (b))
+        tr_bencInitStr (benc, "none", 4);
     else {
         size_t byte_count = 0;
-        uint8_t * raw = tr_bitfieldGetRaw( b, &byte_count );
-        tr_bencInitRaw( benc, raw, byte_count );
-        tr_free( raw );
+        uint8_t * raw = tr_bitfieldGetRaw (b, &byte_count);
+        tr_bencInitRaw (benc, raw, byte_count);
+        tr_free (raw);
     }
 }
 
 
 static void
-saveProgress( tr_benc * dict, tr_torrent * tor )
+saveProgress (tr_benc * dict, tr_torrent * tor)
 {
     tr_benc * l;
     tr_benc * prog;
     tr_file_index_t fi;
-    const tr_info * inf = tr_torrentInfo( tor );
-    const time_t now = tr_time( );
+    const tr_info * inf = tr_torrentInfo (tor);
+    const time_t now = tr_time ();
 
-    prog = tr_bencDictAddDict( dict, KEY_PROGRESS, 3 );
+    prog = tr_bencDictAddDict (dict, KEY_PROGRESS, 3);
 
     /* add the file/piece check timestamps... */
-    l = tr_bencDictAddList( prog, KEY_PROGRESS_CHECKTIME, inf->fileCount );
-    for( fi=0; fi<inf->fileCount; ++fi )
+    l = tr_bencDictAddList (prog, KEY_PROGRESS_CHECKTIME, inf->fileCount);
+    for (fi=0; fi<inf->fileCount; ++fi)
     {
         const tr_piece * p;
         const tr_piece * pend;
         time_t oldest_nonzero = now;
         time_t newest = 0;
         bool has_zero = false;
-        const time_t mtime = tr_torrentGetFileMTime( tor, fi );
+        const time_t mtime = tr_torrentGetFileMTime (tor, fi);
         const tr_file * f = &inf->files[fi];
 
         /* get the oldest and newest nonzero timestamps for pieces in this file */
-        for( p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]; p!=pend; ++p )
+        for (p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]; p!=pend; ++p)
         {
-            if( !p->timeChecked )
+            if (!p->timeChecked)
                 has_zero = true;
-            else if( oldest_nonzero > p->timeChecked )
+            else if (oldest_nonzero > p->timeChecked)
                 oldest_nonzero = p->timeChecked;
-            if( newest < p->timeChecked )
+            if (newest < p->timeChecked)
                 newest = p->timeChecked;
         }
 
@@ -461,40 +461,40 @@ saveProgress( tr_benc * dict, tr_torrent * tor )
            only a single timestamp is saved for the file if *all* or *none*
            of the pieces were tested more recently than the file's mtime. */
 
-        if( !has_zero && ( mtime <= oldest_nonzero ) ) /* all checked */
-            tr_bencListAddInt( l, oldest_nonzero );
-        else if( newest < mtime ) /* none checked */
-            tr_bencListAddInt( l, newest );
+        if (!has_zero && (mtime <= oldest_nonzero)) /* all checked */
+            tr_bencListAddInt (l, oldest_nonzero);
+        else if (newest < mtime) /* none checked */
+            tr_bencListAddInt (l, newest);
         else { /* some are checked, some aren't... so list piece by piece */
             const int offset = oldest_nonzero - 1;
-            tr_benc * ll = tr_bencListAddList( l, 2 + f->lastPiece - f->firstPiece );
-            tr_bencListAddInt( ll, offset );
-            for( p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]+1; p!=pend; ++p )
-                tr_bencListAddInt( ll, p->timeChecked ? p->timeChecked - offset : 0 );
+            tr_benc * ll = tr_bencListAddList (l, 2 + f->lastPiece - f->firstPiece);
+            tr_bencListAddInt (ll, offset);
+            for (p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]+1; p!=pend; ++p)
+                tr_bencListAddInt (ll, p->timeChecked ? p->timeChecked - offset : 0);
         }
     }
 
     /* add the progress */
-    if( tor->completeness == TR_SEED )
-        tr_bencDictAddStr( prog, KEY_PROGRESS_HAVE, "all" );
+    if (tor->completeness == TR_SEED)
+        tr_bencDictAddStr (prog, KEY_PROGRESS_HAVE, "all");
 
     /* add the blocks bitfield */
-    bitfieldToBenc( &tor->completion.blockBitfield,
-                    tr_bencDictAdd( prog, KEY_PROGRESS_BLOCKS ) );
+    bitfieldToBenc (&tor->completion.blockBitfield,
+                    tr_bencDictAdd (prog, KEY_PROGRESS_BLOCKS));
 }
 
 static uint64_t
-loadProgress( tr_benc * dict, tr_torrent * tor )
+loadProgress (tr_benc * dict, tr_torrent * tor)
 {
     size_t i, n;
     uint64_t ret = 0;
     tr_benc * prog;
-    const tr_info * inf = tr_torrentInfo( tor );
+    const tr_info * inf = tr_torrentInfo (tor);
 
-    for( i=0, n=inf->pieceCount; i<n; ++i )
+    for (i=0, n=inf->pieceCount; i<n; ++i)
         inf->pieces[i].timeChecked = 0;
 
-    if( tr_bencDictFindDict( dict, KEY_PROGRESS, &prog ) )
+    if (tr_bencDictFindDict (dict, KEY_PROGRESS, &prog))
     {
         const char * err;
         const char * str;
@@ -504,7 +504,7 @@ loadProgress( tr_benc * dict, tr_torrent * tor )
         tr_benc * b;
         struct tr_bitfield blocks = TR_BITFIELD_INIT;
 
-        if( tr_bencDictFindList( prog, KEY_PROGRESS_CHECKTIME, &l ) )
+        if (tr_bencDictFindList (prog, KEY_PROGRESS_CHECKTIME, &l))
         {
             /* per-piece timestamps were added in 2.20.
 
@@ -519,38 +519,38 @@ loadProgress( tr_benc * dict, tr_torrent * tor )
 
             tr_file_index_t fi;
 
-            for( fi=0; fi<inf->fileCount; ++fi )
+            for (fi=0; fi<inf->fileCount; ++fi)
             {
-                tr_benc * b = tr_bencListChild( l, fi );
+                tr_benc * b = tr_bencListChild (l, fi);
                 const tr_file * f = &inf->files[fi];
                 tr_piece * p = &inf->pieces[f->firstPiece];
                 const tr_piece * pend = &inf->pieces[f->lastPiece]+1;
 
-                if( tr_bencIsInt( b ) )
+                if (tr_bencIsInt (b))
                 {
                     int64_t t;
-                    tr_bencGetInt( b, &t );
-                    for( ; p!=pend; ++p )
+                    tr_bencGetInt (b, &t);
+                    for (; p!=pend; ++p)
                         p->timeChecked = (time_t)t;
                 }
-                else if( tr_bencIsList( b ) )
+                else if (tr_bencIsList (b))
                 {
                     int i = 0;
                     int64_t offset = 0;
                     const int pieces = f->lastPiece + 1 - f->firstPiece;
 
-                    tr_bencGetInt( tr_bencListChild( b, 0 ), &offset );
+                    tr_bencGetInt (tr_bencListChild (b, 0), &offset);
 
-                    for( i=0; i<pieces; ++i )
+                    for (i=0; i<pieces; ++i)
                     {
                         int64_t t = 0;
-                        tr_bencGetInt( tr_bencListChild( b, i+1 ), &t );
+                        tr_bencGetInt (tr_bencListChild (b, i+1), &t);
                         inf->pieces[f->firstPiece+i].timeChecked = (time_t)(t ? t + offset : 0);
                     }
                 }
             }
         }
-        else if( tr_bencDictFindList( prog, KEY_PROGRESS_MTIMES, &l ) )
+        else if (tr_bencDictFindList (prog, KEY_PROGRESS_MTIMES, &l))
         {
             tr_file_index_t fi;
 
@@ -558,60 +558,60 @@ loadProgress( tr_benc * dict, tr_torrent * tor )
                When loading the .resume file, a torrent's file would be flagged
                as untested if its stored mtime didn't match its real mtime. */
 
-            for( fi=0; fi<inf->fileCount; ++fi )
+            for (fi=0; fi<inf->fileCount; ++fi)
             {
                 int64_t t;
 
-                if( tr_bencGetInt( tr_bencListChild( l, fi ), &t ) )
+                if (tr_bencGetInt (tr_bencListChild (l, fi), &t))
                 {
                     const tr_file * f = &inf->files[fi];
                     tr_piece * p = &inf->pieces[f->firstPiece];
                     const tr_piece * pend = &inf->pieces[f->lastPiece];
-                    const time_t mtime = tr_torrentGetFileMTime( tor, fi );
+                    const time_t mtime = tr_torrentGetFileMTime (tor, fi);
                     const time_t timeChecked = mtime==t ? mtime : 0;
 
-                    for( ; p!=pend; ++p )
+                    for (; p!=pend; ++p)
                         p->timeChecked = timeChecked;
                 }
             }
         }
 
         err = NULL;
-        tr_bitfieldConstruct( &blocks, tor->blockCount );
+        tr_bitfieldConstruct (&blocks, tor->blockCount);
 
-        if(( b = tr_bencDictFind( prog, KEY_PROGRESS_BLOCKS )))
+        if ((b = tr_bencDictFind (prog, KEY_PROGRESS_BLOCKS)))
         {
             size_t buflen;
             const uint8_t * buf;
 
-            if( !tr_bencGetRaw( b, &buf, &buflen ) )
+            if (!tr_bencGetRaw (b, &buf, &buflen))
                 err = "Invalid value for \"blocks\"";
-            else if( ( buflen == 3 ) && !memcmp( buf, "all", 3 ) )
-                tr_bitfieldSetHasAll( &blocks );
-            else if( ( buflen == 4 ) && !memcmp( buf, "none", 4 ) )
-                tr_bitfieldSetHasNone( &blocks );
+            else if ((buflen == 3) && !memcmp (buf, "all", 3))
+                tr_bitfieldSetHasAll (&blocks);
+            else if ((buflen == 4) && !memcmp (buf, "none", 4))
+                tr_bitfieldSetHasNone (&blocks);
             else
-                tr_bitfieldSetRaw( &blocks, buf, buflen, true );
+                tr_bitfieldSetRaw (&blocks, buf, buflen, true);
         }
-        else if( tr_bencDictFindStr( prog, KEY_PROGRESS_HAVE, &str ) )
+        else if (tr_bencDictFindStr (prog, KEY_PROGRESS_HAVE, &str))
         {
-            if( !strcmp( str, "all" ) )
-                tr_bitfieldSetHasAll( &blocks );
+            if (!strcmp (str, "all"))
+                tr_bitfieldSetHasAll (&blocks);
             else
                 err = "Invalid value for HAVE";
         }
-        else if( tr_bencDictFindRaw( prog, KEY_PROGRESS_BITFIELD, &raw, &rawlen ) )
+        else if (tr_bencDictFindRaw (prog, KEY_PROGRESS_BITFIELD, &raw, &rawlen))
         {
-            tr_bitfieldSetRaw( &blocks, raw, rawlen, true );
+            tr_bitfieldSetRaw (&blocks, raw, rawlen, true);
         }
         else err = "Couldn't find 'pieces' or 'have' or 'bitfield'";
 
-        if( err != NULL )
-            tr_tordbg( tor, "Torrent needs to be verified - %s", err );
+        if (err != NULL)
+            tr_tordbg (tor, "Torrent needs to be verified - %s", err);
         else
-            tr_cpBlockInit( &tor->completion, &blocks );
+            tr_cpBlockInit (&tor->completion, &blocks);
 
-        tr_bitfieldDestruct( &blocks );
+        tr_bitfieldDestruct (&blocks);
         ret = TR_FR_PROGRESS;
     }
 
@@ -623,51 +623,51 @@ loadProgress( tr_benc * dict, tr_torrent * tor )
 ***/
 
 void
-tr_torrentSaveResume( tr_torrent * tor )
+tr_torrentSaveResume (tr_torrent * tor)
 {
     int err;
     tr_benc top;
     char * filename;
 
-    if( !tr_isTorrent( tor ) )
+    if (!tr_isTorrent (tor))
         return;
 
-    tr_bencInitDict( &top, 50 ); /* arbitrary "big enough" number */
-    tr_bencDictAddInt( &top, KEY_TIME_SEEDING, tor->secondsSeeding );
-    tr_bencDictAddInt( &top, KEY_TIME_DOWNLOADING, tor->secondsDownloading );
-    tr_bencDictAddInt( &top, KEY_ACTIVITY_DATE, tor->activityDate );
-    tr_bencDictAddInt( &top, KEY_ADDED_DATE, tor->addedDate );
-    tr_bencDictAddInt( &top, KEY_CORRUPT, tor->corruptPrev + tor->corruptCur );
-    tr_bencDictAddInt( &top, KEY_DONE_DATE, tor->doneDate );
-    tr_bencDictAddStr( &top, KEY_DOWNLOAD_DIR, tor->downloadDir );
-    if( tor->incompleteDir != NULL )
-        tr_bencDictAddStr( &top, KEY_INCOMPLETE_DIR, tor->incompleteDir );
-    tr_bencDictAddInt( &top, KEY_DOWNLOADED, tor->downloadedPrev + tor->downloadedCur );
-    tr_bencDictAddInt( &top, KEY_UPLOADED, tor->uploadedPrev + tor->uploadedCur );
-    tr_bencDictAddInt( &top, KEY_MAX_PEERS, tor->maxConnectedPeers );
-    tr_bencDictAddInt( &top, KEY_BANDWIDTH_PRIORITY, tr_torrentGetPriority( tor ) );
-    tr_bencDictAddBool( &top, KEY_PAUSED, !tor->isRunning );
-    savePeers( &top, tor );
-    if( tr_torrentHasMetadata( tor ) )
+    tr_bencInitDict (&top, 50); /* arbitrary "big enough" number */
+    tr_bencDictAddInt (&top, KEY_TIME_SEEDING, tor->secondsSeeding);
+    tr_bencDictAddInt (&top, KEY_TIME_DOWNLOADING, tor->secondsDownloading);
+    tr_bencDictAddInt (&top, KEY_ACTIVITY_DATE, tor->activityDate);
+    tr_bencDictAddInt (&top, KEY_ADDED_DATE, tor->addedDate);
+    tr_bencDictAddInt (&top, KEY_CORRUPT, tor->corruptPrev + tor->corruptCur);
+    tr_bencDictAddInt (&top, KEY_DONE_DATE, tor->doneDate);
+    tr_bencDictAddStr (&top, KEY_DOWNLOAD_DIR, tor->downloadDir);
+    if (tor->incompleteDir != NULL)
+        tr_bencDictAddStr (&top, KEY_INCOMPLETE_DIR, tor->incompleteDir);
+    tr_bencDictAddInt (&top, KEY_DOWNLOADED, tor->downloadedPrev + tor->downloadedCur);
+    tr_bencDictAddInt (&top, KEY_UPLOADED, tor->uploadedPrev + tor->uploadedCur);
+    tr_bencDictAddInt (&top, KEY_MAX_PEERS, tor->maxConnectedPeers);
+    tr_bencDictAddInt (&top, KEY_BANDWIDTH_PRIORITY, tr_torrentGetPriority (tor));
+    tr_bencDictAddBool (&top, KEY_PAUSED, !tor->isRunning);
+    savePeers (&top, tor);
+    if (tr_torrentHasMetadata (tor))
     {
-        saveFilePriorities( &top, tor );
-        saveDND( &top, tor );
-        saveProgress( &top, tor );
+        saveFilePriorities (&top, tor);
+        saveDND (&top, tor);
+        saveProgress (&top, tor);
     }
-    saveSpeedLimits( &top, tor );
-    saveRatioLimits( &top, tor );
-    saveIdleLimits( &top, tor );
+    saveSpeedLimits (&top, tor);
+    saveRatioLimits (&top, tor);
+    saveIdleLimits (&top, tor);
 
-    filename = getResumeFilename( tor );
-    if(( err = tr_bencToFile( &top, TR_FMT_BENC, filename )))
-        tr_torrentSetLocalError( tor, "Unable to save resume file: %s", tr_strerror( err ) );
-    tr_free( filename );
+    filename = getResumeFilename (tor);
+    if ((err = tr_bencToFile (&top, TR_FMT_BENC, filename)))
+        tr_torrentSetLocalError (tor, "Unable to save resume file: %s", tr_strerror (err));
+    tr_free (filename);
 
-    tr_bencFree( &top );
+    tr_bencFree (&top);
 }
 
 static uint64_t
-loadFromFile( tr_torrent * tor, uint64_t fieldsToLoad )
+loadFromFile (tr_torrent * tor, uint64_t fieldsToLoad)
 {
     int64_t  i;
     const char * str;
@@ -677,174 +677,174 @@ loadFromFile( tr_torrent * tor, uint64_t fieldsToLoad )
     uint64_t fieldsLoaded = 0;
     const bool wasDirty = tor->isDirty;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    filename = getResumeFilename( tor );
+    filename = getResumeFilename (tor);
 
-    if( tr_bencLoadFile( &top, TR_FMT_BENC, filename ) )
+    if (tr_bencLoadFile (&top, TR_FMT_BENC, filename))
     {
-        tr_tordbg( tor, "Couldn't read \"%s\"", filename );
+        tr_tordbg (tor, "Couldn't read \"%s\"", filename);
 
-        tr_free( filename );
+        tr_free (filename);
         return fieldsLoaded;
     }
 
-    tr_tordbg( tor, "Read resume file \"%s\"", filename );
+    tr_tordbg (tor, "Read resume file \"%s\"", filename);
 
-    if( ( fieldsToLoad & TR_FR_CORRUPT )
-      && tr_bencDictFindInt( &top, KEY_CORRUPT, &i ) )
+    if ((fieldsToLoad & TR_FR_CORRUPT)
+      && tr_bencDictFindInt (&top, KEY_CORRUPT, &i))
     {
         tor->corruptPrev = i;
         fieldsLoaded |= TR_FR_CORRUPT;
     }
 
-    if( ( fieldsToLoad & ( TR_FR_PROGRESS | TR_FR_DOWNLOAD_DIR ) )
-      && ( tr_bencDictFindStr( &top, KEY_DOWNLOAD_DIR, &str ) )
-      && ( str && *str ) )
+    if ((fieldsToLoad & (TR_FR_PROGRESS | TR_FR_DOWNLOAD_DIR))
+      && (tr_bencDictFindStr (&top, KEY_DOWNLOAD_DIR, &str))
+      && (str && *str))
     {
-        tr_free( tor->downloadDir );
-        tor->downloadDir = tr_strdup( str );
+        tr_free (tor->downloadDir);
+        tor->downloadDir = tr_strdup (str);
         fieldsLoaded |= TR_FR_DOWNLOAD_DIR;
     }
 
-    if( ( fieldsToLoad & ( TR_FR_PROGRESS | TR_FR_INCOMPLETE_DIR ) )
-      && ( tr_bencDictFindStr( &top, KEY_INCOMPLETE_DIR, &str ) )
-      && ( str && *str ) )
+    if ((fieldsToLoad & (TR_FR_PROGRESS | TR_FR_INCOMPLETE_DIR))
+      && (tr_bencDictFindStr (&top, KEY_INCOMPLETE_DIR, &str))
+      && (str && *str))
     {
-        tr_free( tor->incompleteDir );
-        tor->incompleteDir = tr_strdup( str );
+        tr_free (tor->incompleteDir);
+        tor->incompleteDir = tr_strdup (str);
         fieldsLoaded |= TR_FR_INCOMPLETE_DIR;
     }
 
-    if( ( fieldsToLoad & TR_FR_DOWNLOADED )
-      && tr_bencDictFindInt( &top, KEY_DOWNLOADED, &i ) )
+    if ((fieldsToLoad & TR_FR_DOWNLOADED)
+      && tr_bencDictFindInt (&top, KEY_DOWNLOADED, &i))
     {
         tor->downloadedPrev = i;
         fieldsLoaded |= TR_FR_DOWNLOADED;
     }
 
-    if( ( fieldsToLoad & TR_FR_UPLOADED )
-      && tr_bencDictFindInt( &top, KEY_UPLOADED, &i ) )
+    if ((fieldsToLoad & TR_FR_UPLOADED)
+      && tr_bencDictFindInt (&top, KEY_UPLOADED, &i))
     {
         tor->uploadedPrev = i;
         fieldsLoaded |= TR_FR_UPLOADED;
     }
 
-    if( ( fieldsToLoad & TR_FR_MAX_PEERS )
-      && tr_bencDictFindInt( &top, KEY_MAX_PEERS, &i ) )
+    if ((fieldsToLoad & TR_FR_MAX_PEERS)
+      && tr_bencDictFindInt (&top, KEY_MAX_PEERS, &i))
     {
         tor->maxConnectedPeers = i;
         fieldsLoaded |= TR_FR_MAX_PEERS;
     }
 
-    if( ( fieldsToLoad & TR_FR_RUN )
-      && tr_bencDictFindBool( &top, KEY_PAUSED, &boolVal ) )
+    if ((fieldsToLoad & TR_FR_RUN)
+      && tr_bencDictFindBool (&top, KEY_PAUSED, &boolVal))
     {
         tor->isRunning = !boolVal;
         fieldsLoaded |= TR_FR_RUN;
     }
 
-    if( ( fieldsToLoad & TR_FR_ADDED_DATE )
-      && tr_bencDictFindInt( &top, KEY_ADDED_DATE, &i ) )
+    if ((fieldsToLoad & TR_FR_ADDED_DATE)
+      && tr_bencDictFindInt (&top, KEY_ADDED_DATE, &i))
     {
         tor->addedDate = i;
         fieldsLoaded |= TR_FR_ADDED_DATE;
     }
 
-    if( ( fieldsToLoad & TR_FR_DONE_DATE )
-      && tr_bencDictFindInt( &top, KEY_DONE_DATE, &i ) )
+    if ((fieldsToLoad & TR_FR_DONE_DATE)
+      && tr_bencDictFindInt (&top, KEY_DONE_DATE, &i))
     {
         tor->doneDate = i;
         fieldsLoaded |= TR_FR_DONE_DATE;
     }
 
-    if( ( fieldsToLoad & TR_FR_ACTIVITY_DATE )
-      && tr_bencDictFindInt( &top, KEY_ACTIVITY_DATE, &i ) )
+    if ((fieldsToLoad & TR_FR_ACTIVITY_DATE)
+      && tr_bencDictFindInt (&top, KEY_ACTIVITY_DATE, &i))
     {
-        tr_torrentSetActivityDate( tor, i );
+        tr_torrentSetActivityDate (tor, i);
         fieldsLoaded |= TR_FR_ACTIVITY_DATE;
     }
 
-    if( ( fieldsToLoad & TR_FR_TIME_SEEDING )
-      && tr_bencDictFindInt( &top, KEY_TIME_SEEDING, &i ) )
+    if ((fieldsToLoad & TR_FR_TIME_SEEDING)
+      && tr_bencDictFindInt (&top, KEY_TIME_SEEDING, &i))
     {
         tor->secondsSeeding = i;
         fieldsLoaded |= TR_FR_TIME_SEEDING;
     }
 
-    if( ( fieldsToLoad & TR_FR_TIME_DOWNLOADING )
-      && tr_bencDictFindInt( &top, KEY_TIME_DOWNLOADING, &i ) )
+    if ((fieldsToLoad & TR_FR_TIME_DOWNLOADING)
+      && tr_bencDictFindInt (&top, KEY_TIME_DOWNLOADING, &i))
     {
         tor->secondsDownloading = i;
         fieldsLoaded |= TR_FR_TIME_DOWNLOADING;
     }
 
-    if( ( fieldsToLoad & TR_FR_BANDWIDTH_PRIORITY )
-      && tr_bencDictFindInt( &top, KEY_BANDWIDTH_PRIORITY, &i )
-      && tr_isPriority( i ) )
+    if ((fieldsToLoad & TR_FR_BANDWIDTH_PRIORITY)
+      && tr_bencDictFindInt (&top, KEY_BANDWIDTH_PRIORITY, &i)
+      && tr_isPriority (i))
     {
-        tr_torrentSetPriority( tor, i );
+        tr_torrentSetPriority (tor, i);
         fieldsLoaded |= TR_FR_BANDWIDTH_PRIORITY;
     }
 
-    if( fieldsToLoad & TR_FR_PEERS )
-        fieldsLoaded |= loadPeers( &top, tor );
+    if (fieldsToLoad & TR_FR_PEERS)
+        fieldsLoaded |= loadPeers (&top, tor);
 
-    if( fieldsToLoad & TR_FR_FILE_PRIORITIES )
-        fieldsLoaded |= loadFilePriorities( &top, tor );
+    if (fieldsToLoad & TR_FR_FILE_PRIORITIES)
+        fieldsLoaded |= loadFilePriorities (&top, tor);
 
-    if( fieldsToLoad & TR_FR_PROGRESS )
-        fieldsLoaded |= loadProgress( &top, tor );
+    if (fieldsToLoad & TR_FR_PROGRESS)
+        fieldsLoaded |= loadProgress (&top, tor);
 
-    if( fieldsToLoad & TR_FR_DND )
-        fieldsLoaded |= loadDND( &top, tor );
+    if (fieldsToLoad & TR_FR_DND)
+        fieldsLoaded |= loadDND (&top, tor);
 
-    if( fieldsToLoad & TR_FR_SPEEDLIMIT )
-        fieldsLoaded |= loadSpeedLimits( &top, tor );
+    if (fieldsToLoad & TR_FR_SPEEDLIMIT)
+        fieldsLoaded |= loadSpeedLimits (&top, tor);
 
-    if( fieldsToLoad & TR_FR_RATIOLIMIT )
-        fieldsLoaded |= loadRatioLimits( &top, tor );
+    if (fieldsToLoad & TR_FR_RATIOLIMIT)
+        fieldsLoaded |= loadRatioLimits (&top, tor);
 
-    if( fieldsToLoad & TR_FR_IDLELIMIT )
-        fieldsLoaded |= loadIdleLimits( &top, tor );
+    if (fieldsToLoad & TR_FR_IDLELIMIT)
+        fieldsLoaded |= loadIdleLimits (&top, tor);
 
     /* loading the resume file triggers of a lot of changes,
      * but none of them needs to trigger a re-saving of the
      * same resume information... */
     tor->isDirty = wasDirty;
 
-    tr_bencFree( &top );
-    tr_free( filename );
+    tr_bencFree (&top);
+    tr_free (filename);
     return fieldsLoaded;
 }
 
 static uint64_t
-setFromCtor( tr_torrent * tor, uint64_t fields, const tr_ctor * ctor, int mode )
+setFromCtor (tr_torrent * tor, uint64_t fields, const tr_ctor * ctor, int mode)
 {
     uint64_t ret = 0;
 
-    if( fields & TR_FR_RUN )
+    if (fields & TR_FR_RUN)
     {
         bool isPaused;
-        if( !tr_ctorGetPaused( ctor, mode, &isPaused ) )
+        if (!tr_ctorGetPaused (ctor, mode, &isPaused))
         {
             tor->isRunning = !isPaused;
             ret |= TR_FR_RUN;
         }
     }
 
-    if( fields & TR_FR_MAX_PEERS )
-        if( !tr_ctorGetPeerLimit( ctor, mode, &tor->maxConnectedPeers ) )
+    if (fields & TR_FR_MAX_PEERS)
+        if (!tr_ctorGetPeerLimit (ctor, mode, &tor->maxConnectedPeers))
             ret |= TR_FR_MAX_PEERS;
 
-    if( fields & TR_FR_DOWNLOAD_DIR )
+    if (fields & TR_FR_DOWNLOAD_DIR)
     {
         const char * path;
-        if( !tr_ctorGetDownloadDir( ctor, mode, &path ) && path && *path )
+        if (!tr_ctorGetDownloadDir (ctor, mode, &path) && path && *path)
         {
             ret |= TR_FR_DOWNLOAD_DIR;
-            tr_free( tor->downloadDir );
-            tor->downloadDir = tr_strdup( path );
+            tr_free (tor->downloadDir);
+            tor->downloadDir = tr_strdup (path);
         }
     }
 
@@ -852,39 +852,39 @@ setFromCtor( tr_torrent * tor, uint64_t fields, const tr_ctor * ctor, int mode )
 }
 
 static uint64_t
-useManditoryFields( tr_torrent * tor, uint64_t fields, const tr_ctor * ctor )
+useManditoryFields (tr_torrent * tor, uint64_t fields, const tr_ctor * ctor)
 {
-    return setFromCtor( tor, fields, ctor, TR_FORCE );
+    return setFromCtor (tor, fields, ctor, TR_FORCE);
 }
 
 static uint64_t
-useFallbackFields( tr_torrent * tor, uint64_t fields, const tr_ctor * ctor )
+useFallbackFields (tr_torrent * tor, uint64_t fields, const tr_ctor * ctor)
 {
-    return setFromCtor( tor, fields, ctor, TR_FALLBACK );
+    return setFromCtor (tor, fields, ctor, TR_FALLBACK);
 }
 
 uint64_t
-tr_torrentLoadResume( tr_torrent *    tor,
+tr_torrentLoadResume (tr_torrent *    tor,
                       uint64_t        fieldsToLoad,
-                      const tr_ctor * ctor )
+                      const tr_ctor * ctor)
 {
     uint64_t ret = 0;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    ret |= useManditoryFields( tor, fieldsToLoad, ctor );
+    ret |= useManditoryFields (tor, fieldsToLoad, ctor);
     fieldsToLoad &= ~ret;
-    ret |= loadFromFile( tor, fieldsToLoad );
+    ret |= loadFromFile (tor, fieldsToLoad);
     fieldsToLoad &= ~ret;
-    ret |= useFallbackFields( tor, fieldsToLoad, ctor );
+    ret |= useFallbackFields (tor, fieldsToLoad, ctor);
 
     return ret;
 }
 
 void
-tr_torrentRemoveResume( const tr_torrent * tor )
+tr_torrentRemoveResume (const tr_torrent * tor)
 {
-    char * filename = getResumeFilename( tor );
-    unlink( filename );
-    tr_free( filename );
+    char * filename = getResumeFilename (tor);
+    unlink (filename);
+    tr_free (filename);
 }
diff --git a/libtransmission/resume.h b/libtransmission/resume.h
index ff6e9302c..075c4ee1f 100644
--- a/libtransmission/resume.h
+++ b/libtransmission/resume.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -19,37 +19,37 @@
 
 enum
 {
-    TR_FR_DOWNLOADED          = ( 1 << 0 ),
-    TR_FR_UPLOADED            = ( 1 << 1 ),
-    TR_FR_CORRUPT             = ( 1 << 2 ),
-    TR_FR_PEERS               = ( 1 << 3 ),
-    TR_FR_PROGRESS            = ( 1 << 4 ),
-    TR_FR_DND                 = ( 1 << 5 ),
-    TR_FR_FILE_PRIORITIES     = ( 1 << 6 ),
-    TR_FR_BANDWIDTH_PRIORITY  = ( 1 << 7 ),
-    TR_FR_SPEEDLIMIT          = ( 1 << 8 ),
-    TR_FR_RUN                 = ( 1 << 9 ),
-    TR_FR_DOWNLOAD_DIR        = ( 1 << 10 ),
-    TR_FR_INCOMPLETE_DIR      = ( 1 << 11 ),
-    TR_FR_MAX_PEERS           = ( 1 << 12 ),
-    TR_FR_ADDED_DATE          = ( 1 << 13 ),
-    TR_FR_DONE_DATE           = ( 1 << 14 ),
-    TR_FR_ACTIVITY_DATE       = ( 1 << 15 ),
-    TR_FR_RATIOLIMIT          = ( 1 << 16 ),
-    TR_FR_IDLELIMIT           = ( 1 << 17 ),
-    TR_FR_TIME_SEEDING        = ( 1 << 18 ),
-    TR_FR_TIME_DOWNLOADING    = ( 1 << 19 )
+    TR_FR_DOWNLOADED          = (1 << 0),
+    TR_FR_UPLOADED            = (1 << 1),
+    TR_FR_CORRUPT             = (1 << 2),
+    TR_FR_PEERS               = (1 << 3),
+    TR_FR_PROGRESS            = (1 << 4),
+    TR_FR_DND                 = (1 << 5),
+    TR_FR_FILE_PRIORITIES     = (1 << 6),
+    TR_FR_BANDWIDTH_PRIORITY  = (1 << 7),
+    TR_FR_SPEEDLIMIT          = (1 << 8),
+    TR_FR_RUN                 = (1 << 9),
+    TR_FR_DOWNLOAD_DIR        = (1 << 10),
+    TR_FR_INCOMPLETE_DIR      = (1 << 11),
+    TR_FR_MAX_PEERS           = (1 << 12),
+    TR_FR_ADDED_DATE          = (1 << 13),
+    TR_FR_DONE_DATE           = (1 << 14),
+    TR_FR_ACTIVITY_DATE       = (1 << 15),
+    TR_FR_RATIOLIMIT          = (1 << 16),
+    TR_FR_IDLELIMIT           = (1 << 17),
+    TR_FR_TIME_SEEDING        = (1 << 18),
+    TR_FR_TIME_DOWNLOADING    = (1 << 19)
 };
 
 /**
  * Returns a bitwise-or'ed set of the loaded resume data
  */
-uint64_t tr_torrentLoadResume( tr_torrent *    tor,
+uint64_t tr_torrentLoadResume (tr_torrent *    tor,
                                uint64_t        fieldsToLoad,
-                               const tr_ctor * ctor );
+                               const tr_ctor * ctor);
 
-void     tr_torrentSaveResume( tr_torrent * tor );
+void     tr_torrentSaveResume (tr_torrent * tor);
 
-void     tr_torrentRemoveResume( const tr_torrent * tor );
+void     tr_torrentRemoveResume (const tr_torrent * tor);
 
 #endif
diff --git a/libtransmission/rpc-server.c b/libtransmission/rpc-server.c
index 0e913b2b7..288efbfb6 100644
--- a/libtransmission/rpc-server.c
+++ b/libtransmission/rpc-server.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -28,11 +28,11 @@
 
 #include "transmission.h"
 #include "bencode.h"
-#include "crypto.h" /* tr_cryptoRandBuf(), tr_ssha1_matches() */
+#include "crypto.h" /* tr_cryptoRandBuf (), tr_ssha1_matches () */
 #include "fdlimit.h"
 #include "list.h"
 #include "net.h"
-#include "platform.h" /* tr_getWebClientDir() */
+#include "platform.h" /* tr_getWebClientDir () */
 #include "ptrarray.h"
 #include "rpcimpl.h"
 #include "rpc-server.h"
@@ -50,7 +50,7 @@
 
 #define MY_NAME "RPC Server"
 #define MY_REALM "Transmission"
-#define TR_N_ELEMENTS( ary ) ( sizeof( ary ) / sizeof( *ary ) )
+#define TR_N_ELEMENTS(ary) (sizeof (ary) / sizeof (*ary))
 
 struct tr_rpc_server
 {
@@ -76,11 +76,11 @@ struct tr_rpc_server
 #endif
 };
 
-#define dbgmsg( ... ) \
+#define dbgmsg(...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, MY_NAME, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, MY_NAME, __VA_ARGS__); \
+    } while (0)
 
 
 /***
@@ -88,24 +88,24 @@ struct tr_rpc_server
 ***/
 
 static char*
-get_current_session_id( struct tr_rpc_server * server )
+get_current_session_id (struct tr_rpc_server * server)
 {
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    if( !server->sessionId || ( now >= server->sessionIdExpiresAt ) )
+    if (!server->sessionId || (now >= server->sessionIdExpiresAt))
     {
         int i;
         const int n = 48;
         const char * pool = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-        const size_t pool_size = strlen( pool );
-        unsigned char * buf = tr_new( unsigned char, n+1 );
+        const size_t pool_size = strlen (pool);
+        unsigned char * buf = tr_new (unsigned char, n+1);
 
-        tr_cryptoRandBuf( buf, n );
-        for( i=0; i<n; ++i )
+        tr_cryptoRandBuf (buf, n);
+        for (i=0; i<n; ++i)
             buf[i] = pool[ buf[i] % pool_size ];
         buf[n] = '\0';
 
-        tr_free( server->sessionId );
+        tr_free (server->sessionId);
         server->sessionId = (char*) buf;
         server->sessionIdExpiresAt = now + (60*60); /* expire in an hour */
     }
@@ -119,19 +119,19 @@ get_current_session_id( struct tr_rpc_server * server )
 **/
 
 static void
-send_simple_response( struct evhttp_request * req,
+send_simple_response (struct evhttp_request * req,
                       int                     code,
-                      const char *            text )
+                      const char *            text)
 {
-    const char *      code_text = tr_webGetResponseStr( code );
-    struct evbuffer * body = evbuffer_new( );
+    const char *      code_text = tr_webGetResponseStr (code);
+    struct evbuffer * body = evbuffer_new ();
 
-    evbuffer_add_printf( body, "<h1>%d: %s</h1>", code, code_text );
-    if( text )
-        evbuffer_add_printf( body, "%s", text );
-    evhttp_send_reply( req, code, code_text, body );
+    evbuffer_add_printf (body, "<h1>%d: %s</h1>", code, code_text);
+    if (text)
+        evbuffer_add_printf (body, "%s", text);
+    evhttp_send_reply (req, code, code_text, body);
 
-    evbuffer_free( body );
+    evbuffer_free (body);
 }
 
 struct tr_mimepart
@@ -143,65 +143,65 @@ struct tr_mimepart
 };
 
 static void
-tr_mimepart_free( struct tr_mimepart * p )
+tr_mimepart_free (struct tr_mimepart * p)
 {
-    tr_free( p->body );
-    tr_free( p->headers );
-    tr_free( p );
+    tr_free (p->body);
+    tr_free (p->headers);
+    tr_free (p);
 }
 
 static void
-extract_parts_from_multipart( const struct evkeyvalq * headers,
+extract_parts_from_multipart (const struct evkeyvalq * headers,
                               struct evbuffer * body,
-                              tr_ptrArray * setme_parts )
+                              tr_ptrArray * setme_parts)
 {
-    const char * content_type = evhttp_find_header( headers, "Content-Type" );
-    const char * in = (const char*) evbuffer_pullup( body, -1 );
-    size_t inlen = evbuffer_get_length( body );
+    const char * content_type = evhttp_find_header (headers, "Content-Type");
+    const char * in = (const char*) evbuffer_pullup (body, -1);
+    size_t inlen = evbuffer_get_length (body);
 
     const char * boundary_key = "boundary=";
-    const char * boundary_key_begin = content_type ? strstr( content_type, boundary_key ) : NULL;
-    const char * boundary_val = boundary_key_begin ? boundary_key_begin + strlen( boundary_key ) : "arglebargle";
-    char * boundary = tr_strdup_printf( "--%s", boundary_val );
-    const size_t boundary_len = strlen( boundary );
+    const char * boundary_key_begin = content_type ? strstr (content_type, boundary_key) : NULL;
+    const char * boundary_val = boundary_key_begin ? boundary_key_begin + strlen (boundary_key) : "arglebargle";
+    char * boundary = tr_strdup_printf ("--%s", boundary_val);
+    const size_t boundary_len = strlen (boundary);
 
-    const char * delim = tr_memmem( in, inlen, boundary, boundary_len );
-    while( delim )
+    const char * delim = tr_memmem (in, inlen, boundary, boundary_len);
+    while (delim)
     {
         size_t part_len;
         const char * part = delim + boundary_len;
 
-        inlen -= ( part - in );
+        inlen -= (part - in);
         in = part;
 
-        delim = tr_memmem( in, inlen, boundary, boundary_len );
-        part_len = delim ? (size_t)( delim - part ) : inlen;
+        delim = tr_memmem (in, inlen, boundary, boundary_len);
+        part_len = delim ? (size_t)(delim - part) : inlen;
 
-        if( part_len )
+        if (part_len)
         {
-            const char * rnrn = tr_memmem( part, part_len, "\r\n\r\n", 4 );
-            if( rnrn )
+            const char * rnrn = tr_memmem (part, part_len, "\r\n\r\n", 4);
+            if (rnrn)
             {
-                struct tr_mimepart * p = tr_new( struct tr_mimepart, 1 );
+                struct tr_mimepart * p = tr_new (struct tr_mimepart, 1);
                 p->headers_len = rnrn - part;
-                p->headers = tr_strndup( part, p->headers_len );
+                p->headers = tr_strndup (part, p->headers_len);
                 p->body_len = (part+part_len) - (rnrn + 4);
-                p->body = tr_strndup( rnrn+4, p->body_len );
-                tr_ptrArrayAppend( setme_parts, p );
+                p->body = tr_strndup (rnrn+4, p->body_len);
+                tr_ptrArrayAppend (setme_parts, p);
             }
         }
     }
 
-    tr_free( boundary );
+    tr_free (boundary);
 }
 
 static void
-handle_upload( struct evhttp_request * req,
-               struct tr_rpc_server *  server )
+handle_upload (struct evhttp_request * req,
+               struct tr_rpc_server *  server)
 {
-    if( req->type != EVHTTP_REQ_POST )
+    if (req->type != EVHTTP_REQ_POST)
     {
-        send_simple_response( req, 405, NULL );
+        send_simple_response (req, 405, NULL);
     }
     else
     {
@@ -210,93 +210,93 @@ handle_upload( struct evhttp_request * req,
         bool hasSessionId = false;
         tr_ptrArray parts = TR_PTR_ARRAY_INIT;
 
-        const char * query = strchr( req->uri, '?' );
-        const bool paused = query && strstr( query + 1, "paused=true" );
+        const char * query = strchr (req->uri, '?');
+        const bool paused = query && strstr (query + 1, "paused=true");
 
-        extract_parts_from_multipart( req->input_headers, req->input_buffer, &parts );
-        n = tr_ptrArraySize( &parts );
+        extract_parts_from_multipart (req->input_headers, req->input_buffer, &parts);
+        n = tr_ptrArraySize (&parts);
 
         /* first look for the session id */
-        for( i=0; i<n; ++i ) {
-            struct tr_mimepart * p = tr_ptrArrayNth( &parts, i );
-            if( tr_memmem( p->headers, p->headers_len, TR_RPC_SESSION_ID_HEADER, strlen( TR_RPC_SESSION_ID_HEADER ) ) )
+        for (i=0; i<n; ++i) {
+            struct tr_mimepart * p = tr_ptrArrayNth (&parts, i);
+            if (tr_memmem (p->headers, p->headers_len, TR_RPC_SESSION_ID_HEADER, strlen (TR_RPC_SESSION_ID_HEADER)))
                 break;
         }
-        if( i<n ) {
-            const struct tr_mimepart * p = tr_ptrArrayNth( &parts, i );
-            const char * ours = get_current_session_id( server );
-            const int ourlen = strlen( ours );
-            hasSessionId = ourlen<=p->body_len && !memcmp( p->body, ours, ourlen );
+        if (i<n) {
+            const struct tr_mimepart * p = tr_ptrArrayNth (&parts, i);
+            const char * ours = get_current_session_id (server);
+            const int ourlen = strlen (ours);
+            hasSessionId = ourlen<=p->body_len && !memcmp (p->body, ours, ourlen);
         }
 
-        if( !hasSessionId )
+        if (!hasSessionId)
         {
             int code = 409;
-            const char * codetext = tr_webGetResponseStr( code );
-            struct evbuffer * body = evbuffer_new( );
-            evbuffer_add_printf( body, "%s", "{ \"success\": false, \"msg\": \"Bad Session-Id\" }" );;
-            evhttp_send_reply( req, code, codetext, body );
-            evbuffer_free( body );
+            const char * codetext = tr_webGetResponseStr (code);
+            struct evbuffer * body = evbuffer_new ();
+            evbuffer_add_printf (body, "%s", "{ \"success\": false, \"msg\": \"Bad Session-Id\" }");;
+            evhttp_send_reply (req, code, codetext, body);
+            evbuffer_free (body);
         }
-        else for( i=0; i<n; ++i )
+        else for (i=0; i<n; ++i)
         {
-            struct tr_mimepart * p = tr_ptrArrayNth( &parts, i );
+            struct tr_mimepart * p = tr_ptrArrayNth (&parts, i);
             int body_len = p->body_len;
             tr_benc top, *args;
             tr_benc test;
             bool have_source = false;
             char * body = p->body;
 
-            if( body_len >= 2 && !memcmp( &body[body_len - 2], "\r\n", 2 ) )
+            if (body_len >= 2 && !memcmp (&body[body_len - 2], "\r\n", 2))
                 body_len -= 2;
 
-            tr_bencInitDict( &top, 2 );
-            tr_bencDictAddStr( &top, "method", "torrent-add" );
-            args = tr_bencDictAddDict( &top, "arguments", 2 );
-            tr_bencDictAddBool( args, "paused", paused );
+            tr_bencInitDict (&top, 2);
+            tr_bencDictAddStr (&top, "method", "torrent-add");
+            args = tr_bencDictAddDict (&top, "arguments", 2);
+            tr_bencDictAddBool (args, "paused", paused);
 
-            if( tr_urlIsValid( body, body_len ) )
+            if (tr_urlIsValid (body, body_len))
             {
-                tr_bencDictAddRaw( args, "filename", body, body_len );
+                tr_bencDictAddRaw (args, "filename", body, body_len);
                 have_source = true;
             }
-            else if( !tr_bencLoad( body, body_len, &test, NULL ) )
+            else if (!tr_bencLoad (body, body_len, &test, NULL))
             {
-                char * b64 = tr_base64_encode( body, body_len, NULL );
-                tr_bencDictAddStr( args, "metainfo", b64 );
-                tr_free( b64 );
+                char * b64 = tr_base64_encode (body, body_len, NULL);
+                tr_bencDictAddStr (args, "metainfo", b64);
+                tr_free (b64);
                 have_source = true;
             }
 
-            if( have_source )
+            if (have_source)
             {
-                struct evbuffer * json = tr_bencToBuf( &top, TR_FMT_JSON );
-                tr_rpc_request_exec_json( server->session,
-                                          evbuffer_pullup( json, -1 ),
-                                          evbuffer_get_length( json ),
-                                          NULL, NULL );
-                evbuffer_free( json );
+                struct evbuffer * json = tr_bencToBuf (&top, TR_FMT_JSON);
+                tr_rpc_request_exec_json (server->session,
+                                          evbuffer_pullup (json, -1),
+                                          evbuffer_get_length (json),
+                                          NULL, NULL);
+                evbuffer_free (json);
             }
 
-            tr_bencFree( &top );
+            tr_bencFree (&top);
         }
 
-        tr_ptrArrayDestruct( &parts, (PtrArrayForeachFunc)tr_mimepart_free );
+        tr_ptrArrayDestruct (&parts, (PtrArrayForeachFunc)tr_mimepart_free);
 
         /* send "success" response */
         {
             int code = HTTP_OK;
-            const char * codetext = tr_webGetResponseStr( code );
-            struct evbuffer * body = evbuffer_new( );
-            evbuffer_add_printf( body, "%s", "{ \"success\": true, \"msg\": \"Torrent Added\" }" );;
-            evhttp_send_reply( req, code, codetext, body );
-            evbuffer_free( body );
+            const char * codetext = tr_webGetResponseStr (code);
+            struct evbuffer * body = evbuffer_new ();
+            evbuffer_add_printf (body, "%s", "{ \"success\": true, \"msg\": \"Torrent Added\" }");;
+            evhttp_send_reply (req, code, codetext, body);
+            evbuffer_free (body);
         }
     }
 }
 
 static const char*
-mimetype_guess( const char * path )
+mimetype_guess (const char * path)
 {
     unsigned int i;
 
@@ -313,38 +313,38 @@ mimetype_guess( const char * path )
         { "js",   "application/javascript"    },
         { "png",  "image/png"                 }
     };
-    const char * dot = strrchr( path, '.' );
+    const char * dot = strrchr (path, '.');
 
-    for( i = 0; dot && i < TR_N_ELEMENTS( types ); ++i )
-        if( !strcmp( dot + 1, types[i].suffix ) )
+    for (i = 0; dot && i < TR_N_ELEMENTS (types); ++i)
+        if (!strcmp (dot + 1, types[i].suffix))
             return types[i].mime_type;
 
     return "application/octet-stream";
 }
 
 static void
-add_response( struct evhttp_request * req, struct tr_rpc_server * server,
-              struct evbuffer * out, struct evbuffer * content )
+add_response (struct evhttp_request * req, struct tr_rpc_server * server,
+              struct evbuffer * out, struct evbuffer * content)
 {
 #ifndef HAVE_ZLIB
-    evbuffer_add_buffer( out, content );
+    evbuffer_add_buffer (out, content);
 #else
     const char * key = "Accept-Encoding";
-    const char * encoding = evhttp_find_header( req->input_headers, key );
-    const int do_compress = encoding && strstr( encoding, "gzip" );
+    const char * encoding = evhttp_find_header (req->input_headers, key);
+    const int do_compress = encoding && strstr (encoding, "gzip");
 
-    if( !do_compress )
+    if (!do_compress)
     {
-        evbuffer_add_buffer( out, content );
+        evbuffer_add_buffer (out, content);
     }
     else
     {
         int state;
         struct evbuffer_iovec iovec[1];
-        void * content_ptr = evbuffer_pullup( content, -1 );
-        const size_t content_len = evbuffer_get_length( content );
+        void * content_ptr = evbuffer_pullup (content, -1);
+        const size_t content_len = evbuffer_get_length (content);
 
-        if( !server->isStreamInitialized )
+        if (!server->isStreamInitialized)
         {
             int compressionLevel;
 
@@ -360,70 +360,70 @@ add_response( struct evhttp_request * req, struct tr_rpc_server * server,
 #else
             compressionLevel = Z_BEST_COMPRESSION;
 #endif
-            deflateInit2( &server->stream, compressionLevel, Z_DEFLATED, 15+16, 8, Z_DEFAULT_STRATEGY );
+            deflateInit2 (&server->stream, compressionLevel, Z_DEFLATED, 15+16, 8, Z_DEFAULT_STRATEGY);
         }
 
         server->stream.next_in = content_ptr;
         server->stream.avail_in = content_len;
 
-        /* allocate space for the raw data and call deflate() just once --
+        /* allocate space for the raw data and call deflate () just once --
          * we won't use the deflated data if it's longer than the raw data,
-         * so it's okay to let deflate() run out of output buffer space */
-        evbuffer_reserve_space( out, content_len, iovec, 1 );
+         * so it's okay to let deflate () run out of output buffer space */
+        evbuffer_reserve_space (out, content_len, iovec, 1);
         server->stream.next_out = iovec[0].iov_base;
         server->stream.avail_out = iovec[0].iov_len;
-        state = deflate( &server->stream, Z_FINISH );
+        state = deflate (&server->stream, Z_FINISH);
 
-        if( state == Z_STREAM_END )
+        if (state == Z_STREAM_END)
         {
             iovec[0].iov_len -= server->stream.avail_out;
 
 #if 0
-            fprintf( stderr, "compressed response is %.2f of original (raw==%zu bytes; compressed==%zu)\n",
-                             (double)evbuffer_get_length(out)/content_len,
-                             content_len, evbuffer_get_length(out) );
+            fprintf (stderr, "compressed response is %.2f of original (raw==%zu bytes; compressed==%zu)\n",
+                           (double)evbuffer_get_length (out)/content_len,
+                             content_len, evbuffer_get_length (out));
 #endif
-            evhttp_add_header( req->output_headers,
-                               "Content-Encoding", "gzip" );
+            evhttp_add_header (req->output_headers,
+                               "Content-Encoding", "gzip");
         }
         else
         {
-            memcpy( iovec[0].iov_base, content_ptr, content_len );
+            memcpy (iovec[0].iov_base, content_ptr, content_len);
             iovec[0].iov_len = content_len;
         }
 
-        evbuffer_commit_space( out, iovec, 1 );
-        deflateReset( &server->stream );
+        evbuffer_commit_space (out, iovec, 1);
+        deflateReset (&server->stream);
     }
 #endif
 }
 
 static void
-add_time_header( struct evkeyvalq * headers, const char * key, time_t value )
+add_time_header (struct evkeyvalq * headers, const char * key, time_t value)
 {
     /* According to RFC 2616 this must follow RFC 1123's date format,
        so use gmtime instead of localtime... */
     char buf[128];
-    struct tm tm = *gmtime( &value );
-    strftime( buf, sizeof( buf ), "%a, %d %b %Y %H:%M:%S GMT", &tm );
-    evhttp_add_header( headers, key, buf );
+    struct tm tm = *gmtime (&value);
+    strftime (buf, sizeof (buf), "%a, %d %b %Y %H:%M:%S GMT", &tm);
+    evhttp_add_header (headers, key, buf);
 }
 
 static void
-evbuffer_ref_cleanup_tr_free( const void * data UNUSED, size_t datalen UNUSED, void * extra )
+evbuffer_ref_cleanup_tr_free (const void * data UNUSED, size_t datalen UNUSED, void * extra)
 {
-    tr_free( extra );
+    tr_free (extra);
 }
 
 static void
-serve_file( struct evhttp_request * req,
+serve_file (struct evhttp_request * req,
             struct tr_rpc_server *  server,
-            const char *            filename )
+            const char *            filename)
 {
-    if( req->type != EVHTTP_REQ_GET )
+    if (req->type != EVHTTP_REQ_GET)
     {
-        evhttp_add_header( req->output_headers, "Allow", "GET" );
-        send_simple_response( req, 405, NULL );
+        evhttp_add_header (req->output_headers, "Allow", "GET");
+        send_simple_response (req, 405, NULL);
     }
     else
     {
@@ -434,45 +434,45 @@ serve_file( struct evhttp_request * req,
 
         errno = 0;
         file_len = 0;
-        file = tr_loadFile( filename, &file_len );
-        content = evbuffer_new( );
-        evbuffer_add_reference( content, file, file_len, evbuffer_ref_cleanup_tr_free, file );
+        file = tr_loadFile (filename, &file_len);
+        content = evbuffer_new ();
+        evbuffer_add_reference (content, file, file_len, evbuffer_ref_cleanup_tr_free, file);
 
-        if( errno )
+        if (errno)
         {
-            char * tmp = tr_strdup_printf( "%s (%s)", filename, tr_strerror( errno ) );
-            send_simple_response( req, HTTP_NOTFOUND, tmp );
-            tr_free( tmp );
+            char * tmp = tr_strdup_printf ("%s (%s)", filename, tr_strerror (errno));
+            send_simple_response (req, HTTP_NOTFOUND, tmp);
+            tr_free (tmp);
         }
         else
         {
             struct evbuffer * out;
-            const time_t now = tr_time( );
+            const time_t now = tr_time ();
 
             errno = error;
-            out = evbuffer_new( );
-            evhttp_add_header( req->output_headers, "Content-Type", mimetype_guess( filename ) );
-            add_time_header( req->output_headers, "Date", now );
-            add_time_header( req->output_headers, "Expires", now+(24*60*60) );
-            add_response( req, server, out, content );
-            evhttp_send_reply( req, HTTP_OK, "OK", out );
-
-            evbuffer_free( out );
+            out = evbuffer_new ();
+            evhttp_add_header (req->output_headers, "Content-Type", mimetype_guess (filename));
+            add_time_header (req->output_headers, "Date", now);
+            add_time_header (req->output_headers, "Expires", now+ (24*60*60));
+            add_response (req, server, out, content);
+            evhttp_send_reply (req, HTTP_OK, "OK", out);
+
+            evbuffer_free (out);
         }
 
-        evbuffer_free( content );
+        evbuffer_free (content);
     }
 }
 
 static void
-handle_web_client( struct evhttp_request * req,
-                   struct tr_rpc_server *  server )
+handle_web_client (struct evhttp_request * req,
+                   struct tr_rpc_server *  server)
 {
-    const char * webClientDir = tr_getWebClientDir( server->session );
+    const char * webClientDir = tr_getWebClientDir (server->session);
 
-    if( !webClientDir || !*webClientDir )
+    if (!webClientDir || !*webClientDir)
     {
-        send_simple_response( req, HTTP_NOTFOUND,
+        send_simple_response (req, HTTP_NOTFOUND,
             "<p>Couldn't find Transmission's web interface files!</p>"
             "<p>Users: to tell Transmission where to look, "
             "set the TRANSMISSION_WEB_HOME environment "
@@ -480,32 +480,32 @@ handle_web_client( struct evhttp_request * req,
             "index.html is located.</p>"
             "<p>Package Builders: to set a custom default at compile time, "
             "#define PACKAGE_DATA_DIR in libtransmission/platform.c "
-            "or tweak tr_getClutchDir() by hand.</p>" );
+            "or tweak tr_getClutchDir () by hand.</p>");
     }
     else
     {
         char * pch;
         char * subpath;
 
-        subpath = tr_strdup( req->uri + strlen( server->url ) + 4 );
-        if(( pch = strchr( subpath, '?' )))
+        subpath = tr_strdup (req->uri + strlen (server->url) + 4);
+        if ((pch = strchr (subpath, '?')))
             *pch = '\0';
 
-        if( strstr( subpath, ".." ) )
+        if (strstr (subpath, ".."))
         {
-            send_simple_response( req, HTTP_NOTFOUND, "<p>Tsk, tsk.</p>" );
+            send_simple_response (req, HTTP_NOTFOUND, "<p>Tsk, tsk.</p>");
         }
         else
         {
-            char * filename = tr_strdup_printf( "%s%s%s",
+            char * filename = tr_strdup_printf ("%s%s%s",
                                  webClientDir,
                                  TR_PATH_DELIMITER_STR,
-                                 subpath && *subpath ? subpath : "index.html" );
-            serve_file( req, server, filename );
-            tr_free( filename );
+                                 subpath && *subpath ? subpath : "index.html");
+            serve_file (req, server, filename);
+            tr_free (filename);
         }
 
-        tr_free( subpath );
+        tr_free (subpath);
     }
 }
 
@@ -516,136 +516,136 @@ struct rpc_response_data
 };
 
 static void
-rpc_response_func( tr_session      * session UNUSED,
+rpc_response_func (tr_session      * session UNUSED,
                    struct evbuffer * response,
-                   void            * user_data )
+                   void            * user_data)
 {
     struct rpc_response_data * data = user_data;
-    struct evbuffer * buf = evbuffer_new( );
+    struct evbuffer * buf = evbuffer_new ();
 
-    add_response( data->req, data->server, buf, response );
-    evhttp_add_header( data->req->output_headers,
-                           "Content-Type", "application/json; charset=UTF-8" );
-    evhttp_send_reply( data->req, HTTP_OK, "OK", buf );
+    add_response (data->req, data->server, buf, response);
+    evhttp_add_header (data->req->output_headers,
+                           "Content-Type", "application/json; charset=UTF-8");
+    evhttp_send_reply (data->req, HTTP_OK, "OK", buf);
 
-    evbuffer_free( buf );
-    tr_free( data );
+    evbuffer_free (buf);
+    tr_free (data);
 }
 
 
 static void
-handle_rpc( struct evhttp_request * req,
-            struct tr_rpc_server  * server )
+handle_rpc (struct evhttp_request * req,
+            struct tr_rpc_server  * server)
 {
-    struct rpc_response_data * data = tr_new0( struct rpc_response_data, 1 );
+    struct rpc_response_data * data = tr_new0 (struct rpc_response_data, 1);
 
     data->req = req;
     data->server = server;
 
-    if( req->type == EVHTTP_REQ_GET )
+    if (req->type == EVHTTP_REQ_GET)
     {
         const char * q;
-        if( ( q = strchr( req->uri, '?' ) ) )
-            tr_rpc_request_exec_uri( server->session, q+1, -1, rpc_response_func, data );
+        if ((q = strchr (req->uri, '?')))
+            tr_rpc_request_exec_uri (server->session, q+1, -1, rpc_response_func, data);
     }
-    else if( req->type == EVHTTP_REQ_POST )
+    else if (req->type == EVHTTP_REQ_POST)
     {
-        tr_rpc_request_exec_json( server->session,
-                                  evbuffer_pullup( req->input_buffer, -1 ),
-                                  evbuffer_get_length( req->input_buffer ),
-                                  rpc_response_func, data );
+        tr_rpc_request_exec_json (server->session,
+                                  evbuffer_pullup (req->input_buffer, -1),
+                                  evbuffer_get_length (req->input_buffer),
+                                  rpc_response_func, data);
     }
 
 }
 
 static bool
-isAddressAllowed( const tr_rpc_server * server,
-                  const char *          address )
+isAddressAllowed (const tr_rpc_server * server,
+                  const char *          address)
 {
     tr_list * l;
 
-    if( !server->isWhitelistEnabled )
+    if (!server->isWhitelistEnabled)
         return true;
 
-    for( l=server->whitelist; l!=NULL; l=l->next )
-        if( tr_wildmat( address, l->data ) )
+    for (l=server->whitelist; l!=NULL; l=l->next)
+        if (tr_wildmat (address, l->data))
             return true;
 
     return false;
 }
 
 static bool
-test_session_id( struct tr_rpc_server * server, struct evhttp_request * req )
+test_session_id (struct tr_rpc_server * server, struct evhttp_request * req)
 {
-    const char * ours = get_current_session_id( server );
-    const char * theirs = evhttp_find_header( req->input_headers, TR_RPC_SESSION_ID_HEADER );
-    const bool success =  theirs && !strcmp( theirs, ours );
+    const char * ours = get_current_session_id (server);
+    const char * theirs = evhttp_find_header (req->input_headers, TR_RPC_SESSION_ID_HEADER);
+    const bool success =  theirs && !strcmp (theirs, ours);
     return success;
 }
 
 static void
-handle_request( struct evhttp_request * req, void * arg )
+handle_request (struct evhttp_request * req, void * arg)
 {
     struct tr_rpc_server * server = arg;
 
-    if( req && req->evcon )
+    if (req && req->evcon)
     {
         const char * auth;
         char * user = NULL;
         char * pass = NULL;
 
-        evhttp_add_header( req->output_headers, "Server", MY_REALM );
+        evhttp_add_header (req->output_headers, "Server", MY_REALM);
 
-        auth = evhttp_find_header( req->input_headers, "Authorization" );
-        if( auth && !evutil_ascii_strncasecmp( auth, "basic ", 6 ) )
+        auth = evhttp_find_header (req->input_headers, "Authorization");
+        if (auth && !evutil_ascii_strncasecmp (auth, "basic ", 6))
         {
             int    plen;
-            char * p = tr_base64_decode( auth + 6, 0, &plen );
-            if( p && plen && ( ( pass = strchr( p, ':' ) ) ) )
+            char * p = tr_base64_decode (auth + 6, 0, &plen);
+            if (p && plen && ((pass = strchr (p, ':'))))
             {
                 user = p;
                 *pass++ = '\0';
             }
         }
 
-        if( !isAddressAllowed( server, req->remote_host ) )
+        if (!isAddressAllowed (server, req->remote_host))
         {
-            send_simple_response( req, 403,
+            send_simple_response (req, 403,
                 "<p>Unauthorized IP Address.</p>"
                 "<p>Either disable the IP address whitelist or add your address to it.</p>"
                 "<p>If you're editing settings.json, see the 'rpc-whitelist' and 'rpc-whitelist-enabled' entries.</p>"
-                "<p>If you're still using ACLs, use a whitelist instead. See the transmission-daemon manpage for details.</p>" );
+                "<p>If you're still using ACLs, use a whitelist instead. See the transmission-daemon manpage for details.</p>");
         }
-        else if( server->isPasswordEnabled
-                 && ( !pass || !user || strcmp( server->username, user )
-                                     || !tr_ssha1_matches( server->password,
-                                                           pass ) ) )
+        else if (server->isPasswordEnabled
+                 && (!pass || !user || strcmp (server->username, user)
+                                     || !tr_ssha1_matches (server->password,
+                                                           pass)))
         {
-            evhttp_add_header( req->output_headers,
+            evhttp_add_header (req->output_headers,
                                "WWW-Authenticate",
-                               "Basic realm=\"" MY_REALM "\"" );
-            send_simple_response( req, 401, "Unauthorized User" );
+                               "Basic realm=\"" MY_REALM "\"");
+            send_simple_response (req, 401, "Unauthorized User");
         }
-        else if( strncmp( req->uri, server->url, strlen( server->url ) ) )
+        else if (strncmp (req->uri, server->url, strlen (server->url)))
         {
-            char * location = tr_strdup_printf( "%sweb/", server->url );
-            evhttp_add_header( req->output_headers, "Location", location );
-            send_simple_response( req, HTTP_MOVEPERM, NULL );
-            tr_free( location );
+            char * location = tr_strdup_printf ("%sweb/", server->url);
+            evhttp_add_header (req->output_headers, "Location", location);
+            send_simple_response (req, HTTP_MOVEPERM, NULL);
+            tr_free (location);
         }
-        else if( !strncmp( req->uri + strlen( server->url ), "web/", 4 ) )
+        else if (!strncmp (req->uri + strlen (server->url), "web/", 4))
         {
-            handle_web_client( req, server );
+            handle_web_client (req, server);
         }
-        else if( !strncmp( req->uri + strlen( server->url ), "upload", 6 ) )
+        else if (!strncmp (req->uri + strlen (server->url), "upload", 6))
         {
-            handle_upload( req, server );
+            handle_upload (req, server);
         }
 #ifdef REQUIRE_SESSION_ID
-        else if( !test_session_id( server, req ) )
+        else if (!test_session_id (server, req))
         {
-            const char * sessionId = get_current_session_id( server );
-            char * tmp = tr_strdup_printf(
+            const char * sessionId = get_current_session_id (server);
+            char * tmp = tr_strdup_printf (
                 "<p>Your request had an invalid session-id header.</p>"
                 "<p>To fix this, follow these steps:"
                 "<ol><li> When reading a response, get its X-Transmission-Session-Id header and remember it"
@@ -656,173 +656,173 @@ handle_request( struct evhttp_request * req, void * arg )
                 "<a href=\"http://en.wikipedia.org/wiki/Cross-site_request_forgery\">CSRF</a> "
                 "attacks.</p>"
                 "<p><code>%s: %s</code></p>",
-                TR_RPC_SESSION_ID_HEADER, sessionId );
-            evhttp_add_header( req->output_headers, TR_RPC_SESSION_ID_HEADER, sessionId );
-            send_simple_response( req, 409, tmp );
-            tr_free( tmp );
+                TR_RPC_SESSION_ID_HEADER, sessionId);
+            evhttp_add_header (req->output_headers, TR_RPC_SESSION_ID_HEADER, sessionId);
+            send_simple_response (req, 409, tmp);
+            tr_free (tmp);
         }
 #endif
-        else if( !strncmp( req->uri + strlen( server->url ), "rpc", 3 ) )
+        else if (!strncmp (req->uri + strlen (server->url), "rpc", 3))
         {
-            handle_rpc( req, server );
+            handle_rpc (req, server);
         }
         else
         {
-            send_simple_response( req, HTTP_NOTFOUND, req->uri );
+            send_simple_response (req, HTTP_NOTFOUND, req->uri);
         }
 
-        tr_free( user );
+        tr_free (user);
     }
 }
 
 static void
-startServer( void * vserver )
+startServer (void * vserver)
 {
     tr_rpc_server * server  = vserver;
     tr_address addr;
 
-    if( !server->httpd )
+    if (!server->httpd)
     {
         addr.type = TR_AF_INET;
         addr.addr.addr4 = server->bindAddress;
-        server->httpd = evhttp_new( server->session->event_base );
-        evhttp_bind_socket( server->httpd, tr_address_to_string( &addr ), server->port );
-        evhttp_set_gencb( server->httpd, handle_request, server );
+        server->httpd = evhttp_new (server->session->event_base);
+        evhttp_bind_socket (server->httpd, tr_address_to_string (&addr), server->port);
+        evhttp_set_gencb (server->httpd, handle_request, server);
 
     }
 }
 
 static void
-stopServer( tr_rpc_server * server )
+stopServer (tr_rpc_server * server)
 {
-    if( server->httpd )
+    if (server->httpd)
     {
-        evhttp_free( server->httpd );
+        evhttp_free (server->httpd);
         server->httpd = NULL;
     }
 }
 
 static void
-onEnabledChanged( void * vserver )
+onEnabledChanged (void * vserver)
 {
     tr_rpc_server * server = vserver;
 
-    if( !server->isEnabled )
-        stopServer( server );
+    if (!server->isEnabled)
+        stopServer (server);
     else
-        startServer( server );
+        startServer (server);
 }
 
 void
-tr_rpcSetEnabled( tr_rpc_server * server,
-                  bool            isEnabled )
+tr_rpcSetEnabled (tr_rpc_server * server,
+                  bool            isEnabled)
 {
     server->isEnabled = isEnabled;
 
-    tr_runInEventThread( server->session, onEnabledChanged, server );
+    tr_runInEventThread (server->session, onEnabledChanged, server);
 }
 
 bool
-tr_rpcIsEnabled( const tr_rpc_server * server )
+tr_rpcIsEnabled (const tr_rpc_server * server)
 {
     return server->isEnabled;
 }
 
 static void
-restartServer( void * vserver )
+restartServer (void * vserver)
 {
     tr_rpc_server * server = vserver;
 
-    if( server->isEnabled )
+    if (server->isEnabled)
     {
-        stopServer( server );
-        startServer( server );
+        stopServer (server);
+        startServer (server);
     }
 }
 
 void
-tr_rpcSetPort( tr_rpc_server * server,
-               tr_port         port )
+tr_rpcSetPort (tr_rpc_server * server,
+               tr_port         port)
 {
-    assert( server != NULL );
+    assert (server != NULL);
 
-    if( server->port != port )
+    if (server->port != port)
     {
         server->port = port;
 
-        if( server->isEnabled )
-            tr_runInEventThread( server->session, restartServer, server );
+        if (server->isEnabled)
+            tr_runInEventThread (server->session, restartServer, server);
     }
 }
 
 tr_port
-tr_rpcGetPort( const tr_rpc_server * server )
+tr_rpcGetPort (const tr_rpc_server * server)
 {
     return server->port;
 }
 
 void
-tr_rpcSetUrl( tr_rpc_server * server, const char * url )
+tr_rpcSetUrl (tr_rpc_server * server, const char * url)
 {
     char * tmp = server->url;
-    server->url = tr_strdup( url );
-    dbgmsg( "setting our URL to [%s]", server->url );
-    tr_free( tmp );
+    server->url = tr_strdup (url);
+    dbgmsg ("setting our URL to [%s]", server->url);
+    tr_free (tmp);
 }
 
 const char*
-tr_rpcGetUrl( const tr_rpc_server * server )
+tr_rpcGetUrl (const tr_rpc_server * server)
 {
     return server->url ? server->url : "";
 }
 
 void
-tr_rpcSetWhitelist( tr_rpc_server * server, const char * whitelistStr )
+tr_rpcSetWhitelist (tr_rpc_server * server, const char * whitelistStr)
 {
     void * tmp;
     const char * walk;
 
     /* keep the string */
     tmp = server->whitelistStr;
-    server->whitelistStr = tr_strdup( whitelistStr );
-    tr_free( tmp );
+    server->whitelistStr = tr_strdup (whitelistStr);
+    tr_free (tmp);
 
     /* clear out the old whitelist entries */
-    while(( tmp = tr_list_pop_front( &server->whitelist )))
-        tr_free( tmp );
+    while ((tmp = tr_list_pop_front (&server->whitelist)))
+        tr_free (tmp);
 
     /* build the new whitelist entries */
-    for( walk=whitelistStr; walk && *walk; ) {
+    for (walk=whitelistStr; walk && *walk;) {
         const char * delimiters = " ,;";
-        const size_t len = strcspn( walk, delimiters );
-        char * token = tr_strndup( walk, len );
-        tr_list_append( &server->whitelist, token );
-        if( strcspn( token, "+-" ) < len )
-            tr_ninf( MY_NAME, "Adding address to whitelist: %s (And it has a '+' or '-'!  Are you using an old ACL by mistake?)", token );
+        const size_t len = strcspn (walk, delimiters);
+        char * token = tr_strndup (walk, len);
+        tr_list_append (&server->whitelist, token);
+        if (strcspn (token, "+-") < len)
+            tr_ninf (MY_NAME, "Adding address to whitelist: %s (And it has a '+' or '-'!  Are you using an old ACL by mistake?)", token);
         else
-            tr_ninf( MY_NAME, "Adding address to whitelist: %s", token );
+            tr_ninf (MY_NAME, "Adding address to whitelist: %s", token);
 
-        if( walk[len]=='\0' )
+        if (walk[len]=='\0')
             break;
         walk += len + 1;
     }
 }
 
 const char*
-tr_rpcGetWhitelist( const tr_rpc_server * server )
+tr_rpcGetWhitelist (const tr_rpc_server * server)
 {
     return server->whitelistStr ? server->whitelistStr : "";
 }
 
 void
-tr_rpcSetWhitelistEnabled( tr_rpc_server  * server,
-                           bool             isEnabled )
+tr_rpcSetWhitelistEnabled (tr_rpc_server  * server,
+                           bool             isEnabled)
 {
     server->isWhitelistEnabled = isEnabled != 0;
 }
 
 bool
-tr_rpcGetWhitelistEnabled( const tr_rpc_server * server )
+tr_rpcGetWhitelistEnabled (const tr_rpc_server * server)
 {
     return server->isWhitelistEnabled;
 }
@@ -832,58 +832,58 @@ tr_rpcGetWhitelistEnabled( const tr_rpc_server * server )
 ****/
 
 void
-tr_rpcSetUsername( tr_rpc_server * server, const char * username )
+tr_rpcSetUsername (tr_rpc_server * server, const char * username)
 {
     char * tmp = server->username;
-    server->username = tr_strdup( username );
-    dbgmsg( "setting our Username to [%s]", server->username );
-    tr_free( tmp );
+    server->username = tr_strdup (username);
+    dbgmsg ("setting our Username to [%s]", server->username);
+    tr_free (tmp);
 }
 
 const char*
-tr_rpcGetUsername( const tr_rpc_server * server )
+tr_rpcGetUsername (const tr_rpc_server * server)
 {
     return server->username ? server->username : "";
 }
 
 void
-tr_rpcSetPassword( tr_rpc_server * server,
-                   const char *    password )
+tr_rpcSetPassword (tr_rpc_server * server,
+                   const char *    password)
 {
-    tr_free( server->password );
-    if( *password != '{' )
-        server->password = tr_ssha1( password );
+    tr_free (server->password);
+    if (*password != '{')
+        server->password = tr_ssha1 (password);
     else
-        server->password = strdup( password );
-    dbgmsg( "setting our Password to [%s]", server->password );
+        server->password = strdup (password);
+    dbgmsg ("setting our Password to [%s]", server->password);
 }
 
 const char*
-tr_rpcGetPassword( const tr_rpc_server * server )
+tr_rpcGetPassword (const tr_rpc_server * server)
 {
     return server->password ? server->password : "" ;
 }
 
 void
-tr_rpcSetPasswordEnabled( tr_rpc_server * server, bool isEnabled )
+tr_rpcSetPasswordEnabled (tr_rpc_server * server, bool isEnabled)
 {
     server->isPasswordEnabled = isEnabled;
-    dbgmsg( "setting 'password enabled' to %d", (int)isEnabled );
+    dbgmsg ("setting 'password enabled' to %d", (int)isEnabled);
 }
 
 bool
-tr_rpcIsPasswordEnabled( const tr_rpc_server * server )
+tr_rpcIsPasswordEnabled (const tr_rpc_server * server)
 {
     return server->isPasswordEnabled;
 }
 
 const char *
-tr_rpcGetBindAddress( const tr_rpc_server * server )
+tr_rpcGetBindAddress (const tr_rpc_server * server)
 {
     tr_address addr;
     addr.type = TR_AF_INET;
     addr.addr.addr4 = server->bindAddress;
-    return tr_address_to_string( &addr );
+    return tr_address_to_string (&addr);
 }
 
 /****
@@ -891,35 +891,35 @@ tr_rpcGetBindAddress( const tr_rpc_server * server )
 ****/
 
 static void
-closeServer( void * vserver )
+closeServer (void * vserver)
 {
     void * tmp;
     tr_rpc_server * s = vserver;
 
-    stopServer( s );
-    while(( tmp = tr_list_pop_front( &s->whitelist )))
-        tr_free( tmp );
+    stopServer (s);
+    while ((tmp = tr_list_pop_front (&s->whitelist)))
+        tr_free (tmp);
 #ifdef HAVE_ZLIB
-    if( s->isStreamInitialized )
-        deflateEnd( &s->stream );
+    if (s->isStreamInitialized)
+        deflateEnd (&s->stream);
 #endif
-    tr_free( s->url );
-    tr_free( s->sessionId );
-    tr_free( s->whitelistStr );
-    tr_free( s->username );
-    tr_free( s->password );
-    tr_free( s );
+    tr_free (s->url);
+    tr_free (s->sessionId);
+    tr_free (s->whitelistStr);
+    tr_free (s->username);
+    tr_free (s->password);
+    tr_free (s);
 }
 
 void
-tr_rpcClose( tr_rpc_server ** ps )
+tr_rpcClose (tr_rpc_server ** ps)
 {
-    tr_runInEventThread( ( *ps )->session, closeServer, *ps );
+    tr_runInEventThread ((*ps)->session, closeServer, *ps);
     *ps = NULL;
 }
 
 tr_rpc_server *
-tr_rpcInit( tr_session  * session, tr_benc * settings )
+tr_rpcInit (tr_session  * session, tr_benc * settings)
 {
     tr_rpc_server * s;
     bool boolVal;
@@ -928,80 +928,80 @@ tr_rpcInit( tr_session  * session, tr_benc * settings )
     const char * key;
     tr_address address;
 
-    s = tr_new0( tr_rpc_server, 1 );
+    s = tr_new0 (tr_rpc_server, 1);
     s->session = session;
 
     key = TR_PREFS_KEY_RPC_ENABLED;
-    if( !tr_bencDictFindBool( settings, key, &boolVal ) )
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindBool (settings, key, &boolVal))
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
     else
         s->isEnabled = boolVal;
 
     key = TR_PREFS_KEY_RPC_PORT;
-    if( !tr_bencDictFindInt( settings, key, &i ) )
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindInt (settings, key, &i))
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
     else
         s->port = i;
 
     key = TR_PREFS_KEY_RPC_URL;
-    if( !tr_bencDictFindStr( settings, TR_PREFS_KEY_RPC_URL, &str ) )
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindStr (settings, TR_PREFS_KEY_RPC_URL, &str))
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
     else
-        s->url = tr_strdup( str );
+        s->url = tr_strdup (str);
 
     key = TR_PREFS_KEY_RPC_WHITELIST_ENABLED;
-    if( !tr_bencDictFindBool( settings, key, &boolVal ) )
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindBool (settings, key, &boolVal))
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
     else
-        tr_rpcSetWhitelistEnabled( s, boolVal );
+        tr_rpcSetWhitelistEnabled (s, boolVal);
 
     key = TR_PREFS_KEY_RPC_AUTH_REQUIRED;
-    if( !tr_bencDictFindBool( settings, key, &boolVal ) )
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindBool (settings, key, &boolVal))
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
     else
-        tr_rpcSetPasswordEnabled( s, boolVal );
+        tr_rpcSetPasswordEnabled (s, boolVal);
 
     key = TR_PREFS_KEY_RPC_WHITELIST;
-    if( !tr_bencDictFindStr( settings, key, &str ) && str )
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindStr (settings, key, &str) && str)
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
     else
-        tr_rpcSetWhitelist( s, str );
+        tr_rpcSetWhitelist (s, str);
 
     key = TR_PREFS_KEY_RPC_USERNAME;
-    if( !tr_bencDictFindStr( settings, key, &str ) )
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindStr (settings, key, &str))
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
     else
-        tr_rpcSetUsername( s, str );
+        tr_rpcSetUsername (s, str);
 
     key = TR_PREFS_KEY_RPC_PASSWORD;
-    if( !tr_bencDictFindStr( settings, key, &str ) )
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindStr (settings, key, &str))
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
     else
-        tr_rpcSetPassword( s, str );
+        tr_rpcSetPassword (s, str);
 
     key = TR_PREFS_KEY_RPC_BIND_ADDRESS;
-    if( !tr_bencDictFindStr( settings, TR_PREFS_KEY_RPC_BIND_ADDRESS, &str ) ) {
-        tr_nerr( MY_NAME, _( "Couldn't find settings key \"%s\"" ), key );
+    if (!tr_bencDictFindStr (settings, TR_PREFS_KEY_RPC_BIND_ADDRESS, &str)) {
+        tr_nerr (MY_NAME, _ ("Couldn't find settings key \"%s\""), key);
         address = tr_inaddr_any;
-    } else if( !tr_address_from_string( &address, str ) ) {
-        tr_nerr( MY_NAME, _( "%s is not a valid address" ), str );
+    } else if (!tr_address_from_string (&address, str)) {
+        tr_nerr (MY_NAME, _ ("%s is not a valid address"), str);
         address = tr_inaddr_any;
-    } else if( address.type != TR_AF_INET ) {
-        tr_nerr( MY_NAME, _( "%s is not an IPv4 address. RPC listeners must be IPv4" ), str );
+    } else if (address.type != TR_AF_INET) {
+        tr_nerr (MY_NAME, _ ("%s is not an IPv4 address. RPC listeners must be IPv4"), str);
         address = tr_inaddr_any;
     }
     s->bindAddress = address.addr.addr4;
 
-    if( s->isEnabled )
+    if (s->isEnabled)
     {
-        tr_ninf( MY_NAME, _( "Serving RPC and Web requests on port 127.0.0.1:%d%s" ), (int) s->port, s->url );
-        tr_runInEventThread( session, startServer, s );
+        tr_ninf (MY_NAME, _ ("Serving RPC and Web requests on port 127.0.0.1:%d%s"), (int) s->port, s->url);
+        tr_runInEventThread (session, startServer, s);
 
-        if( s->isWhitelistEnabled )
-            tr_ninf( MY_NAME, "%s", _( "Whitelist enabled" ) );
+        if (s->isWhitelistEnabled)
+            tr_ninf (MY_NAME, "%s", _ ("Whitelist enabled"));
 
-        if( s->isPasswordEnabled )
-            tr_ninf( MY_NAME, "%s", _( "Password required" ) );
+        if (s->isPasswordEnabled)
+            tr_ninf (MY_NAME, "%s", _ ("Password required"));
     }
 
     return s;
diff --git a/libtransmission/rpc-server.h b/libtransmission/rpc-server.h
index f85687930..cb9c6f8d9 100644
--- a/libtransmission/rpc-server.h
+++ b/libtransmission/rpc-server.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -19,51 +19,51 @@
 
 typedef struct tr_rpc_server tr_rpc_server;
 
-tr_rpc_server * tr_rpcInit( tr_session  * session,
-                            tr_benc  * settings );
+tr_rpc_server * tr_rpcInit (tr_session  * session,
+                            tr_benc  * settings);
 
-void            tr_rpcClose( tr_rpc_server ** freeme );
+void            tr_rpcClose (tr_rpc_server ** freeme);
 
-void            tr_rpcSetEnabled( tr_rpc_server * server, bool isEnabled );
+void            tr_rpcSetEnabled (tr_rpc_server * server, bool isEnabled);
 
-bool            tr_rpcIsEnabled( const tr_rpc_server * server );
+bool            tr_rpcIsEnabled (const tr_rpc_server * server);
 
-void            tr_rpcSetPort( tr_rpc_server * server, tr_port port );
+void            tr_rpcSetPort (tr_rpc_server * server, tr_port port);
 
-tr_port         tr_rpcGetPort( const tr_rpc_server * server );
+tr_port         tr_rpcGetPort (const tr_rpc_server * server);
 
-void            tr_rpcSetUrl( tr_rpc_server * server, const char * url );
+void            tr_rpcSetUrl (tr_rpc_server * server, const char * url);
 
-const char *    tr_rpcGetUrl( const tr_rpc_server * server );
+const char *    tr_rpcGetUrl (const tr_rpc_server * server);
 
-int             tr_rpcSetTest( const tr_rpc_server   * server,
+int             tr_rpcSetTest (const tr_rpc_server   * server,
                                const char            * whitelist,
-                               char                 ** allocme_errmsg );
+                               char                 ** allocme_errmsg);
 
-void            tr_rpcSetWhitelistEnabled( tr_rpc_server  * server,
-                                           bool             isEnabled );
+void            tr_rpcSetWhitelistEnabled (tr_rpc_server  * server,
+                                           bool             isEnabled);
 
-bool            tr_rpcGetWhitelistEnabled( const tr_rpc_server * server );
+bool            tr_rpcGetWhitelistEnabled (const tr_rpc_server * server);
 
-void            tr_rpcSetWhitelist( tr_rpc_server * server,
-                                    const char *    whitelist );
+void            tr_rpcSetWhitelist (tr_rpc_server * server,
+                                    const char *    whitelist);
 
-const char*     tr_rpcGetWhitelist( const tr_rpc_server * server );
+const char*     tr_rpcGetWhitelist (const tr_rpc_server * server);
 
-void            tr_rpcSetPassword( tr_rpc_server * server,
-                                   const char *    password );
+void            tr_rpcSetPassword (tr_rpc_server * server,
+                                   const char *    password);
 
-const char*     tr_rpcGetPassword( const tr_rpc_server * server );
+const char*     tr_rpcGetPassword (const tr_rpc_server * server);
 
-void            tr_rpcSetUsername( tr_rpc_server * server,
-                                   const char *    username );
+void            tr_rpcSetUsername (tr_rpc_server * server,
+                                   const char *    username);
 
-const char*     tr_rpcGetUsername( const tr_rpc_server * server );
+const char*     tr_rpcGetUsername (const tr_rpc_server * server);
 
-void            tr_rpcSetPasswordEnabled( tr_rpc_server * server, bool isEnabled );
+void            tr_rpcSetPasswordEnabled (tr_rpc_server * server, bool isEnabled);
 
-bool            tr_rpcIsPasswordEnabled( const tr_rpc_server * session );
+bool            tr_rpcIsPasswordEnabled (const tr_rpc_server * session);
 
-const char*     tr_rpcGetBindAddress( const tr_rpc_server * server );
+const char*     tr_rpcGetBindAddress (const tr_rpc_server * server);
 
 #endif
diff --git a/libtransmission/rpc-test.c b/libtransmission/rpc-test.c
index 27fc96ff7..2f7c80761 100644
--- a/libtransmission/rpc-test.c
+++ b/libtransmission/rpc-test.c
@@ -7,53 +7,53 @@
 #include "libtransmission-test.h"
 
 static int
-test_list( void )
+test_list (void)
 {
     int64_t      i;
     const char * str;
     tr_benc      top;
 
-    tr_rpc_parse_list_str( &top, "12", -1 );
-    check( tr_bencIsInt( &top ) );
-    check( tr_bencGetInt( &top, &i ) );
-    check_int_eq ( 12, i );
-    tr_bencFree( &top );
-
-    tr_rpc_parse_list_str( &top, "12", 1 );
-    check( tr_bencIsInt( &top ) );
-    check( tr_bencGetInt( &top, &i ) );
-    check_int_eq ( 1, i );
-    tr_bencFree( &top );
-
-    tr_rpc_parse_list_str( &top, "6,7", -1 );
-    check( tr_bencIsList( &top ) );
-    check( tr_bencListSize( &top ) == 2 );
-    check( tr_bencGetInt( tr_bencListChild( &top, 0 ), &i ) );
-    check_int_eq ( 6, i );
-    check( tr_bencGetInt( tr_bencListChild( &top, 1 ), &i ) );
-    check_int_eq ( 7, i );
-    tr_bencFree( &top );
-
-    tr_rpc_parse_list_str( &top, "asdf", -1 );
-    check( tr_bencIsString( &top ) );
-    check( tr_bencGetStr( &top, &str ) );
-    check_streq( "asdf", str );
-    tr_bencFree( &top );
-
-    tr_rpc_parse_list_str( &top, "1,3-5", -1 );
-    check( tr_bencIsList( &top ) );
-    check( tr_bencListSize( &top ) == 4 );
-    check( tr_bencGetInt( tr_bencListChild( &top, 0 ), &i ) );
-    check_int_eq( 1, i );
-    check( tr_bencGetInt( tr_bencListChild( &top, 1 ), &i ) );
-    check_int_eq( 3, i );
-    check( tr_bencGetInt( tr_bencListChild( &top, 2 ), &i ) );
-    check_int_eq( 4, i );
-    check( tr_bencGetInt( tr_bencListChild( &top, 3 ), &i ) );
-    check_int_eq( 5, i );
-    tr_bencFree( &top );
+    tr_rpc_parse_list_str (&top, "12", -1);
+    check (tr_bencIsInt (&top));
+    check (tr_bencGetInt (&top, &i));
+    check_int_eq (12, i);
+    tr_bencFree (&top);
+
+    tr_rpc_parse_list_str (&top, "12", 1);
+    check (tr_bencIsInt (&top));
+    check (tr_bencGetInt (&top, &i));
+    check_int_eq (1, i);
+    tr_bencFree (&top);
+
+    tr_rpc_parse_list_str (&top, "6,7", -1);
+    check (tr_bencIsList (&top));
+    check (tr_bencListSize (&top) == 2);
+    check (tr_bencGetInt (tr_bencListChild (&top, 0), &i));
+    check_int_eq (6, i);
+    check (tr_bencGetInt (tr_bencListChild (&top, 1), &i));
+    check_int_eq (7, i);
+    tr_bencFree (&top);
+
+    tr_rpc_parse_list_str (&top, "asdf", -1);
+    check (tr_bencIsString (&top));
+    check (tr_bencGetStr (&top, &str));
+    check_streq ("asdf", str);
+    tr_bencFree (&top);
+
+    tr_rpc_parse_list_str (&top, "1,3-5", -1);
+    check (tr_bencIsList (&top));
+    check (tr_bencListSize (&top) == 4);
+    check (tr_bencGetInt (tr_bencListChild (&top, 0), &i));
+    check_int_eq (1, i);
+    check (tr_bencGetInt (tr_bencListChild (&top, 1), &i));
+    check_int_eq (3, i);
+    check (tr_bencGetInt (tr_bencListChild (&top, 2), &i));
+    check_int_eq (4, i);
+    check (tr_bencGetInt (tr_bencListChild (&top, 3), &i));
+    check_int_eq (5, i);
+    tr_bencFree (&top);
 
     return 0;
 }
 
-MAIN_SINGLE_TEST(test_list)
+MAIN_SINGLE_TEST (test_list)
diff --git a/libtransmission/rpcimpl.c b/libtransmission/rpcimpl.c
index 34ec3b72d..06857f49e 100644
--- a/libtransmission/rpcimpl.c
+++ b/libtransmission/rpcimpl.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -40,20 +40,20 @@
 
 #define RECENTLY_ACTIVE_SECONDS 60
 
-#define TR_N_ELEMENTS( ary ) ( sizeof( ary ) / sizeof( *ary ) )
+#define TR_N_ELEMENTS(ary)(sizeof (ary) / sizeof (*ary))
 
 #if 0
 #define dbgmsg(fmt, ...) \
     do { \
-        fprintf( stderr, "%s:%d"#fmt, __FILE__, __LINE__, __VA_ARGS__ ); \
-        fprintf( stderr, "\n" ); \
-    } while( 0 )
+        fprintf (stderr, "%s:%d"#fmt, __FILE__, __LINE__, __VA_ARGS__); \
+        fprintf (stderr, "\n"); \
+    } while (0)
 #else
-#define dbgmsg( ... ) \
+#define dbgmsg(...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, "RPC", __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, "RPC", __VA_ARGS__); \
+    } while (0)
 #endif
 
 
@@ -62,15 +62,15 @@
 ***/
 
 static tr_rpc_callback_status
-notify( tr_session * session,
+notify (tr_session * session,
         int          type,
-        tr_torrent * tor )
+        tr_torrent * tor)
 {
     tr_rpc_callback_status status = 0;
 
-    if( session->rpc_func )
-        status = session->rpc_func( session, type, tor,
-                                    session->rpc_func_user_data );
+    if (session->rpc_func)
+        status = session->rpc_func (session, type, tor,
+                                    session->rpc_func_user_data);
 
     return status;
 }
@@ -92,21 +92,21 @@ struct tr_rpc_idle_data
 };
 
 static void
-tr_idle_function_done( struct tr_rpc_idle_data * data, const char * result )
+tr_idle_function_done (struct tr_rpc_idle_data * data, const char * result)
 {
     struct evbuffer * buf;
 
-    if( result == NULL )
+    if (result == NULL)
         result = "success";
-    tr_bencDictAddStr( data->response, "result", result );
+    tr_bencDictAddStr (data->response, "result", result);
 
-    buf = tr_bencToBuf( data->response, TR_FMT_JSON_LEAN );
-    (*data->callback)( data->session, buf, data->callback_user_data );
-    evbuffer_free( buf );
+    buf = tr_bencToBuf (data->response, TR_FMT_JSON_LEAN);
+  (*data->callback)(data->session, buf, data->callback_user_data);
+    evbuffer_free (buf);
 
-    tr_bencFree( data->response );
-    tr_free( data->response );
-    tr_free( data );
+    tr_bencFree (data->response);
+    tr_free (data->response);
+    tr_free (data);
 }
 
 /***
@@ -114,9 +114,9 @@ tr_idle_function_done( struct tr_rpc_idle_data * data, const char * result )
 ***/
 
 static tr_torrent **
-getTorrents( tr_session * session,
+getTorrents (tr_session * session,
              tr_benc    * args,
-             int        * setmeCount )
+             int        * setmeCount)
 {
     int           torrentCount = 0;
     int64_t       id;
@@ -124,61 +124,61 @@ getTorrents( tr_session * session,
     tr_benc *     ids;
     const char * str;
 
-    if( tr_bencDictFindList( args, "ids", &ids ) )
+    if (tr_bencDictFindList (args, "ids", &ids))
     {
         int       i;
-        const int n = tr_bencListSize( ids );
+        const int n = tr_bencListSize (ids);
 
-        torrents = tr_new0( tr_torrent *, n );
+        torrents = tr_new0 (tr_torrent *, n);
 
-        for( i = 0; i < n; ++i )
+        for (i = 0; i < n; ++i)
         {
             tr_torrent * tor = NULL;
-            tr_benc *    node = tr_bencListChild( ids, i );
+            tr_benc *    node = tr_bencListChild (ids, i);
             const char * str;
-            if( tr_bencGetInt( node, &id ) )
-                tor = tr_torrentFindFromId( session, id );
-            else if( tr_bencGetStr( node, &str ) )
-                tor = tr_torrentFindFromHashString( session, str );
-            if( tor )
+            if (tr_bencGetInt (node, &id))
+                tor = tr_torrentFindFromId (session, id);
+            else if (tr_bencGetStr (node, &str))
+                tor = tr_torrentFindFromHashString (session, str);
+            if (tor)
                 torrents[torrentCount++] = tor;
         }
     }
-    else if( tr_bencDictFindInt( args, "ids", &id )
-           || tr_bencDictFindInt( args, "id", &id ) )
+    else if (tr_bencDictFindInt (args, "ids", &id)
+           || tr_bencDictFindInt (args, "id", &id))
     {
         tr_torrent * tor;
-        torrents = tr_new0( tr_torrent *, 1 );
-        if( ( tor = tr_torrentFindFromId( session, id ) ) )
+        torrents = tr_new0 (tr_torrent *, 1);
+        if ((tor = tr_torrentFindFromId (session, id)))
             torrents[torrentCount++] = tor;
     }
-    else if( tr_bencDictFindStr( args, "ids", &str ) )
+    else if (tr_bencDictFindStr (args, "ids", &str))
     {
-        if( !strcmp( str, "recently-active" ) )
+        if (!strcmp (str, "recently-active"))
         {
             tr_torrent * tor = NULL;
-            const time_t now = tr_time( );
+            const time_t now = tr_time ();
             const time_t window = RECENTLY_ACTIVE_SECONDS;
-            const int n = tr_sessionCountTorrents( session );
-            torrents = tr_new0( tr_torrent *, n );
-            while( ( tor = tr_torrentNext( session, tor ) ) )
-                if( tor->anyDate >= now - window )
+            const int n = tr_sessionCountTorrents (session);
+            torrents = tr_new0 (tr_torrent *, n);
+            while ((tor = tr_torrentNext (session, tor)))
+                if (tor->anyDate >= now - window)
                     torrents[torrentCount++] = tor;
         }
         else
         {
             tr_torrent * tor;
-            torrents = tr_new0( tr_torrent *, 1 );
-            if(( tor = tr_torrentFindFromHashString( session, str )))
+            torrents = tr_new0 (tr_torrent *, 1);
+            if ((tor = tr_torrentFindFromHashString (session, str)))
                 torrents[torrentCount++] = tor;
         }
     }
     else /* all of them */
     {
         tr_torrent * tor = NULL;
-        const int n = tr_sessionCountTorrents( session );
-        torrents = tr_new0( tr_torrent *, n );
-        while( ( tor = tr_torrentNext( session, tor ) ) )
+        const int n = tr_sessionCountTorrents (session);
+        torrents = tr_new0 (tr_torrent *, n);
+        while ((tor = tr_torrentNext (session, tor)))
             torrents[torrentCount++] = tor;
     }
 
@@ -187,217 +187,217 @@ getTorrents( tr_session * session,
 }
 
 static void
-notifyBatchQueueChange( tr_session * session, tr_torrent ** torrents, int n )
+notifyBatchQueueChange (tr_session * session, tr_torrent ** torrents, int n)
 {
     int i;
-    for( i=0; i<n; ++i )
-        notify( session, TR_RPC_TORRENT_CHANGED, torrents[i] );
-    notify( session, TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED, NULL );
+    for (i=0; i<n; ++i)
+        notify (session, TR_RPC_TORRENT_CHANGED, torrents[i]);
+    notify (session, TR_RPC_SESSION_QUEUE_POSITIONS_CHANGED, NULL);
 }
 
 static const char*
-queueMoveTop( tr_session               * session,
+queueMoveTop (tr_session               * session,
               tr_benc                  * args_in,
               tr_benc                  * args_out UNUSED,
-              struct tr_rpc_idle_data  * idle_data UNUSED )
+              struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int n;
-    tr_torrent ** torrents = getTorrents( session, args_in, &n );
-    tr_torrentsQueueMoveTop( torrents, n );
-    notifyBatchQueueChange( session, torrents, n );
-    tr_free( torrents );
+    tr_torrent ** torrents = getTorrents (session, args_in, &n);
+    tr_torrentsQueueMoveTop (torrents, n);
+    notifyBatchQueueChange (session, torrents, n);
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-queueMoveUp( tr_session               * session,
+queueMoveUp (tr_session               * session,
              tr_benc                  * args_in,
              tr_benc                  * args_out UNUSED,
-             struct tr_rpc_idle_data  * idle_data UNUSED )
+             struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int n;
-    tr_torrent ** torrents = getTorrents( session, args_in, &n );
-    tr_torrentsQueueMoveUp( torrents, n );
-    notifyBatchQueueChange( session, torrents, n );
-    tr_free( torrents );
+    tr_torrent ** torrents = getTorrents (session, args_in, &n);
+    tr_torrentsQueueMoveUp (torrents, n);
+    notifyBatchQueueChange (session, torrents, n);
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-queueMoveDown( tr_session               * session,
+queueMoveDown (tr_session               * session,
                tr_benc                  * args_in,
                tr_benc                  * args_out UNUSED,
-               struct tr_rpc_idle_data  * idle_data UNUSED )
+               struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int n;
-    tr_torrent ** torrents = getTorrents( session, args_in, &n );
-    tr_torrentsQueueMoveDown( torrents, n );
-    notifyBatchQueueChange( session, torrents, n );
-    tr_free( torrents );
+    tr_torrent ** torrents = getTorrents (session, args_in, &n);
+    tr_torrentsQueueMoveDown (torrents, n);
+    notifyBatchQueueChange (session, torrents, n);
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-queueMoveBottom( tr_session               * session,
+queueMoveBottom (tr_session               * session,
                  tr_benc                  * args_in,
                  tr_benc                  * args_out UNUSED,
-                 struct tr_rpc_idle_data  * idle_data UNUSED )
+                 struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int n;
-    tr_torrent ** torrents = getTorrents( session, args_in, &n );
-    tr_torrentsQueueMoveBottom( torrents, n );
-    notifyBatchQueueChange( session, torrents, n );
-    tr_free( torrents );
+    tr_torrent ** torrents = getTorrents (session, args_in, &n);
+    tr_torrentsQueueMoveBottom (torrents, n);
+    notifyBatchQueueChange (session, torrents, n);
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-torrentStart( tr_session               * session,
+torrentStart (tr_session               * session,
               tr_benc                  * args_in,
               tr_benc                  * args_out UNUSED,
-              struct tr_rpc_idle_data  * idle_data UNUSED )
+              struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    for( i = 0; i < torrentCount; ++i )
+    for (i = 0; i < torrentCount; ++i)
     {
         tr_torrent * tor = torrents[i];
-        if( !tor->isRunning )
+        if (!tor->isRunning)
         {
-            tr_torrentStart( tor );
-            notify( session, TR_RPC_TORRENT_STARTED, tor );
+            tr_torrentStart (tor);
+            notify (session, TR_RPC_TORRENT_STARTED, tor);
         }
     }
-    tr_free( torrents );
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-torrentStartNow( tr_session               * session,
+torrentStartNow (tr_session               * session,
                  tr_benc                  * args_in,
                  tr_benc                  * args_out UNUSED,
-                 struct tr_rpc_idle_data  * idle_data UNUSED )
+                 struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    for( i = 0; i < torrentCount; ++i )
+    for (i = 0; i < torrentCount; ++i)
     {
         tr_torrent * tor = torrents[i];
-        if( !tor->isRunning )
+        if (!tor->isRunning)
         {
-            tr_torrentStartNow( tor );
-            notify( session, TR_RPC_TORRENT_STARTED, tor );
+            tr_torrentStartNow (tor);
+            notify (session, TR_RPC_TORRENT_STARTED, tor);
         }
     }
-    tr_free( torrents );
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-torrentStop( tr_session               * session,
+torrentStop (tr_session               * session,
              tr_benc                  * args_in,
              tr_benc                  * args_out UNUSED,
-             struct tr_rpc_idle_data  * idle_data UNUSED )
+             struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    for( i = 0; i < torrentCount; ++i )
+    for (i = 0; i < torrentCount; ++i)
     {
         tr_torrent * tor = torrents[i];
 
-        if( tor->isRunning || tr_torrentIsQueued( tor ) )
+        if (tor->isRunning || tr_torrentIsQueued (tor))
         {
             tor->isStopping = true;
-            notify( session, TR_RPC_TORRENT_STOPPED, tor );
+            notify (session, TR_RPC_TORRENT_STOPPED, tor);
         }
     }
-    tr_free( torrents );
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-torrentRemove( tr_session               * session,
+torrentRemove (tr_session               * session,
                tr_benc                  * args_in,
                tr_benc                  * args_out UNUSED,
-               struct tr_rpc_idle_data  * idle_data UNUSED )
+               struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int i;
     int torrentCount;
     tr_rpc_callback_type type;
     bool deleteFlag = false;
-    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    tr_bencDictFindBool( args_in, "delete-local-data", &deleteFlag );
+    tr_bencDictFindBool (args_in, "delete-local-data", &deleteFlag);
     type = deleteFlag ? TR_RPC_TORRENT_TRASHING
                       : TR_RPC_TORRENT_REMOVING;
 
-    for( i=0; i<torrentCount; ++i )
+    for (i=0; i<torrentCount; ++i)
     {
         tr_torrent * tor = torrents[i];
-        const tr_rpc_callback_status status = notify( session, type, tor );
-        if( !( status & TR_RPC_NOREMOVE ) )
-            tr_torrentRemove( tor, deleteFlag, NULL );
+        const tr_rpc_callback_status status = notify (session, type, tor);
+        if (! (status & TR_RPC_NOREMOVE))
+            tr_torrentRemove (tor, deleteFlag, NULL);
     }
 
-    tr_free( torrents );
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-torrentReannounce( tr_session               * session,
+torrentReannounce (tr_session               * session,
                    tr_benc                  * args_in,
                    tr_benc                  * args_out UNUSED,
-                   struct tr_rpc_idle_data  * idle_data UNUSED )
+                   struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int i, torrentCount;
-    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    for( i=0; i<torrentCount; ++i )
+    for (i=0; i<torrentCount; ++i)
     {
         tr_torrent * tor = torrents[i];
-        if( tr_torrentCanManualUpdate( tor ) )
+        if (tr_torrentCanManualUpdate (tor))
         {
-            tr_torrentManualUpdate( tor );
-            notify( session, TR_RPC_TORRENT_CHANGED, tor );
+            tr_torrentManualUpdate (tor);
+            notify (session, TR_RPC_TORRENT_CHANGED, tor);
         }
     }
 
-    tr_free( torrents );
+    tr_free (torrents);
     return NULL;
 }
 
 static const char*
-torrentVerify( tr_session               * session,
+torrentVerify (tr_session               * session,
                tr_benc                  * args_in,
                tr_benc                  * args_out UNUSED,
-               struct tr_rpc_idle_data  * idle_data UNUSED )
+               struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    for( i = 0; i < torrentCount; ++i )
+    for (i = 0; i < torrentCount; ++i)
     {
         tr_torrent * tor = torrents[i];
-        tr_torrentVerify( tor );
-        notify( session, TR_RPC_TORRENT_CHANGED, tor );
+        tr_torrentVerify (tor);
+        notify (session, TR_RPC_TORRENT_CHANGED, tor);
     }
 
-    tr_free( torrents );
+    tr_free (torrents);
     return NULL;
 }
 
@@ -406,389 +406,389 @@ torrentVerify( tr_session               * session,
 ***/
 
 static void
-addFileStats( const tr_torrent * tor, tr_benc * list )
+addFileStats (const tr_torrent * tor, tr_benc * list)
 {
     tr_file_index_t i;
     tr_file_index_t n;
-    const tr_info * info = tr_torrentInfo( tor );
-    tr_file_stat * files = tr_torrentFiles( tor, &n );
+    const tr_info * info = tr_torrentInfo (tor);
+    tr_file_stat * files = tr_torrentFiles (tor, &n);
 
-    for( i = 0; i < info->fileCount; ++i )
+    for (i = 0; i < info->fileCount; ++i)
     {
         const tr_file * file = &info->files[i];
-        tr_benc * d = tr_bencListAddDict( list, 3 );
-        tr_bencDictAddInt( d, "bytesCompleted", files[i].bytesCompleted );
-        tr_bencDictAddInt( d, "priority", file->priority );
-        tr_bencDictAddBool( d, "wanted", !file->dnd );
+        tr_benc * d = tr_bencListAddDict (list, 3);
+        tr_bencDictAddInt (d, "bytesCompleted", files[i].bytesCompleted);
+        tr_bencDictAddInt (d, "priority", file->priority);
+        tr_bencDictAddBool (d, "wanted", !file->dnd);
     }
 
-    tr_torrentFilesFree( files, n );
+    tr_torrentFilesFree (files, n);
 }
 
 static void
-addFiles( const tr_torrent * tor,
-          tr_benc *          list )
+addFiles (const tr_torrent * tor,
+          tr_benc *          list)
 {
     tr_file_index_t i;
     tr_file_index_t n;
-    const tr_info * info = tr_torrentInfo( tor );
-    tr_file_stat *  files = tr_torrentFiles( tor, &n );
+    const tr_info * info = tr_torrentInfo (tor);
+    tr_file_stat *  files = tr_torrentFiles (tor, &n);
 
-    for( i = 0; i < info->fileCount; ++i )
+    for (i = 0; i < info->fileCount; ++i)
     {
         const tr_file * file = &info->files[i];
-        tr_benc *       d = tr_bencListAddDict( list, 3 );
-        tr_bencDictAddInt( d, "bytesCompleted", files[i].bytesCompleted );
-        tr_bencDictAddInt( d, "length", file->length );
-        tr_bencDictAddStr( d, "name", file->name );
+        tr_benc *       d = tr_bencListAddDict (list, 3);
+        tr_bencDictAddInt (d, "bytesCompleted", files[i].bytesCompleted);
+        tr_bencDictAddInt (d, "length", file->length);
+        tr_bencDictAddStr (d, "name", file->name);
     }
 
-    tr_torrentFilesFree( files, n );
+    tr_torrentFilesFree (files, n);
 }
 
 static void
-addWebseeds( const tr_info * info,
-             tr_benc *       webseeds )
+addWebseeds (const tr_info * info,
+             tr_benc *       webseeds)
 {
     int i;
 
-    for( i = 0; i < info->webseedCount; ++i )
-        tr_bencListAddStr( webseeds, info->webseeds[i] );
+    for (i = 0; i < info->webseedCount; ++i)
+        tr_bencListAddStr (webseeds, info->webseeds[i]);
 }
 
 static void
-addTrackers( const tr_info * info,
-             tr_benc *       trackers )
+addTrackers (const tr_info * info,
+             tr_benc *       trackers)
 {
     int i;
 
-    for( i = 0; i < info->trackerCount; ++i )
+    for (i = 0; i < info->trackerCount; ++i)
     {
         const tr_tracker_info * t = &info->trackers[i];
-        tr_benc *               d = tr_bencListAddDict( trackers, 4 );
-        tr_bencDictAddStr( d, "announce", t->announce );
-        tr_bencDictAddInt( d, "id", t->id );
-        tr_bencDictAddStr( d, "scrape", t->scrape );
-        tr_bencDictAddInt( d, "tier", t->tier );
+        tr_benc *               d = tr_bencListAddDict (trackers, 4);
+        tr_bencDictAddStr (d, "announce", t->announce);
+        tr_bencDictAddInt (d, "id", t->id);
+        tr_bencDictAddStr (d, "scrape", t->scrape);
+        tr_bencDictAddInt (d, "tier", t->tier);
     }
 }
 
 static void
-addTrackerStats( const tr_tracker_stat * st, int n, tr_benc * list )
+addTrackerStats (const tr_tracker_stat * st, int n, tr_benc * list)
 {
     int i;
 
-    for( i=0; i<n; ++i )
+    for (i=0; i<n; ++i)
     {
         const tr_tracker_stat * s = &st[i];
-        tr_benc * d = tr_bencListAddDict( list, 26 );
-        tr_bencDictAddStr ( d, "announce", s->announce );
-        tr_bencDictAddInt ( d, "announceState", s->announceState );
-        tr_bencDictAddInt ( d, "downloadCount", s->downloadCount );
-        tr_bencDictAddBool( d, "hasAnnounced", s->hasAnnounced );
-        tr_bencDictAddBool( d, "hasScraped", s->hasScraped );
-        tr_bencDictAddStr ( d, "host", s->host );
-        tr_bencDictAddInt ( d, "id", s->id );
-        tr_bencDictAddBool( d, "isBackup", s->isBackup );
-        tr_bencDictAddInt ( d, "lastAnnouncePeerCount", s->lastAnnouncePeerCount );
-        tr_bencDictAddStr ( d, "lastAnnounceResult", s->lastAnnounceResult );
-        tr_bencDictAddInt ( d, "lastAnnounceStartTime", s->lastAnnounceStartTime );
-        tr_bencDictAddBool( d, "lastAnnounceSucceeded", s->lastAnnounceSucceeded );
-        tr_bencDictAddInt ( d, "lastAnnounceTime", s->lastAnnounceTime );
-        tr_bencDictAddBool( d, "lastAnnounceTimedOut", s->lastAnnounceTimedOut );
-        tr_bencDictAddStr ( d, "lastScrapeResult", s->lastScrapeResult );
-        tr_bencDictAddInt ( d, "lastScrapeStartTime", s->lastScrapeStartTime );
-        tr_bencDictAddBool( d, "lastScrapeSucceeded", s->lastScrapeSucceeded );
-        tr_bencDictAddInt ( d, "lastScrapeTime", s->lastScrapeTime );
-        tr_bencDictAddInt ( d, "lastScrapeTimedOut", s->lastScrapeTimedOut );
-        tr_bencDictAddInt ( d, "leecherCount", s->leecherCount );
-        tr_bencDictAddInt ( d, "nextAnnounceTime", s->nextAnnounceTime );
-        tr_bencDictAddInt ( d, "nextScrapeTime", s->nextScrapeTime );
-        tr_bencDictAddStr ( d, "scrape", s->scrape );
-        tr_bencDictAddInt ( d, "scrapeState", s->scrapeState );
-        tr_bencDictAddInt ( d, "seederCount", s->seederCount );
-        tr_bencDictAddInt ( d, "tier", s->tier );
+        tr_benc * d = tr_bencListAddDict (list, 26);
+        tr_bencDictAddStr (d, "announce", s->announce);
+        tr_bencDictAddInt (d, "announceState", s->announceState);
+        tr_bencDictAddInt (d, "downloadCount", s->downloadCount);
+        tr_bencDictAddBool (d, "hasAnnounced", s->hasAnnounced);
+        tr_bencDictAddBool (d, "hasScraped", s->hasScraped);
+        tr_bencDictAddStr (d, "host", s->host);
+        tr_bencDictAddInt (d, "id", s->id);
+        tr_bencDictAddBool (d, "isBackup", s->isBackup);
+        tr_bencDictAddInt (d, "lastAnnouncePeerCount", s->lastAnnouncePeerCount);
+        tr_bencDictAddStr (d, "lastAnnounceResult", s->lastAnnounceResult);
+        tr_bencDictAddInt (d, "lastAnnounceStartTime", s->lastAnnounceStartTime);
+        tr_bencDictAddBool (d, "lastAnnounceSucceeded", s->lastAnnounceSucceeded);
+        tr_bencDictAddInt (d, "lastAnnounceTime", s->lastAnnounceTime);
+        tr_bencDictAddBool (d, "lastAnnounceTimedOut", s->lastAnnounceTimedOut);
+        tr_bencDictAddStr (d, "lastScrapeResult", s->lastScrapeResult);
+        tr_bencDictAddInt (d, "lastScrapeStartTime", s->lastScrapeStartTime);
+        tr_bencDictAddBool (d, "lastScrapeSucceeded", s->lastScrapeSucceeded);
+        tr_bencDictAddInt (d, "lastScrapeTime", s->lastScrapeTime);
+        tr_bencDictAddInt (d, "lastScrapeTimedOut", s->lastScrapeTimedOut);
+        tr_bencDictAddInt (d, "leecherCount", s->leecherCount);
+        tr_bencDictAddInt (d, "nextAnnounceTime", s->nextAnnounceTime);
+        tr_bencDictAddInt (d, "nextScrapeTime", s->nextScrapeTime);
+        tr_bencDictAddStr (d, "scrape", s->scrape);
+        tr_bencDictAddInt (d, "scrapeState", s->scrapeState);
+        tr_bencDictAddInt (d, "seederCount", s->seederCount);
+        tr_bencDictAddInt (d, "tier", s->tier);
     }
 }
 
 static void
-addPeers( const tr_torrent * tor,
-          tr_benc *          list )
+addPeers (const tr_torrent * tor,
+          tr_benc *          list)
 {
     int            i;
     int            peerCount;
-    tr_peer_stat * peers = tr_torrentPeers( tor, &peerCount );
+    tr_peer_stat * peers = tr_torrentPeers (tor, &peerCount);
 
-    tr_bencInitList( list, peerCount );
+    tr_bencInitList (list, peerCount);
 
-    for( i = 0; i < peerCount; ++i )
+    for (i = 0; i < peerCount; ++i)
     {
-        tr_benc *            d = tr_bencListAddDict( list, 16 );
+        tr_benc *            d = tr_bencListAddDict (list, 16);
         const tr_peer_stat * peer = peers + i;
-        tr_bencDictAddStr ( d, "address", peer->addr );
-        tr_bencDictAddStr ( d, "clientName", peer->client );
-        tr_bencDictAddBool( d, "clientIsChoked", peer->clientIsChoked );
-        tr_bencDictAddBool( d, "clientIsInterested", peer->clientIsInterested );
-        tr_bencDictAddStr ( d, "flagStr", peer->flagStr );
-        tr_bencDictAddBool( d, "isDownloadingFrom", peer->isDownloadingFrom );
-        tr_bencDictAddBool( d, "isEncrypted", peer->isEncrypted );
-        tr_bencDictAddBool( d, "isIncoming", peer->isIncoming );
-        tr_bencDictAddBool( d, "isUploadingTo", peer->isUploadingTo );
-        tr_bencDictAddBool( d, "isUTP", peer->isUTP );
-        tr_bencDictAddBool( d, "peerIsChoked", peer->peerIsChoked );
-        tr_bencDictAddBool( d, "peerIsInterested", peer->peerIsInterested );
-        tr_bencDictAddInt ( d, "port", peer->port );
-        tr_bencDictAddReal( d, "progress", peer->progress );
-        tr_bencDictAddInt ( d, "rateToClient", toSpeedBytes( peer->rateToClient_KBps ) );
-        tr_bencDictAddInt ( d, "rateToPeer", toSpeedBytes( peer->rateToPeer_KBps ) );
+        tr_bencDictAddStr (d, "address", peer->addr);
+        tr_bencDictAddStr (d, "clientName", peer->client);
+        tr_bencDictAddBool (d, "clientIsChoked", peer->clientIsChoked);
+        tr_bencDictAddBool (d, "clientIsInterested", peer->clientIsInterested);
+        tr_bencDictAddStr (d, "flagStr", peer->flagStr);
+        tr_bencDictAddBool (d, "isDownloadingFrom", peer->isDownloadingFrom);
+        tr_bencDictAddBool (d, "isEncrypted", peer->isEncrypted);
+        tr_bencDictAddBool (d, "isIncoming", peer->isIncoming);
+        tr_bencDictAddBool (d, "isUploadingTo", peer->isUploadingTo);
+        tr_bencDictAddBool (d, "isUTP", peer->isUTP);
+        tr_bencDictAddBool (d, "peerIsChoked", peer->peerIsChoked);
+        tr_bencDictAddBool (d, "peerIsInterested", peer->peerIsInterested);
+        tr_bencDictAddInt (d, "port", peer->port);
+        tr_bencDictAddReal (d, "progress", peer->progress);
+        tr_bencDictAddInt (d, "rateToClient", toSpeedBytes (peer->rateToClient_KBps));
+        tr_bencDictAddInt (d, "rateToPeer", toSpeedBytes (peer->rateToPeer_KBps));
     }
 
-    tr_torrentPeersFree( peers, peerCount );
+    tr_torrentPeersFree (peers, peerCount);
 }
 
-/* faster-than-strcmp() optimization. This is kind of clumsy,
-   but addField() was in the profiler's top 10 list, and this
+/* faster-than-strcmp () optimization. This is kind of clumsy,
+   but addField () was in the profiler's top 10 list, and this
    makes it 4x faster... */
-#define tr_streq(a,alen,b) ((alen+1==sizeof(b)) && !memcmp(a,b,alen))
+#define tr_streq(a,alen,b)((alen+1==sizeof (b)) && !memcmp (a,b,alen))
 
 static void
-addField( const tr_torrent * const tor,
+addField (const tr_torrent * const tor,
           const tr_info    * const inf,
           const tr_stat    * const st,
           tr_benc          * const d,
-          const char       * const key )
+          const char       * const key)
 {
-    const size_t keylen = strlen( key );
-
-    if( tr_streq( key, keylen, "activityDate" ) )
-        tr_bencDictAddInt( d, key, st->activityDate );
-    else if( tr_streq( key, keylen, "addedDate" ) )
-        tr_bencDictAddInt( d, key, st->addedDate );
-    else if( tr_streq( key, keylen, "bandwidthPriority" ) )
-        tr_bencDictAddInt( d, key, tr_torrentGetPriority( tor ) );
-    else if( tr_streq( key, keylen, "comment" ) )
-        tr_bencDictAddStr( d, key, inf->comment ? inf->comment : "" );
-    else if( tr_streq( key, keylen, "corruptEver" ) )
-        tr_bencDictAddInt( d, key, st->corruptEver );
-    else if( tr_streq( key, keylen, "creator" ) )
-        tr_bencDictAddStr( d, key, inf->creator ? inf->creator : "" );
-    else if( tr_streq( key, keylen, "dateCreated" ) )
-        tr_bencDictAddInt( d, key, inf->dateCreated );
-    else if( tr_streq( key, keylen, "desiredAvailable" ) )
-        tr_bencDictAddInt( d, key, st->desiredAvailable );
-    else if( tr_streq( key, keylen, "doneDate" ) )
-        tr_bencDictAddInt( d, key, st->doneDate );
-    else if( tr_streq( key, keylen, "downloadDir" ) )
-        tr_bencDictAddStr( d, key, tr_torrentGetDownloadDir( tor ) );
-    else if( tr_streq( key, keylen, "downloadedEver" ) )
-        tr_bencDictAddInt( d, key, st->downloadedEver );
-    else if( tr_streq( key, keylen, "downloadLimit" ) )
-        tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit_KBps( tor, TR_DOWN ) );
-    else if( tr_streq( key, keylen, "downloadLimited" ) )
-        tr_bencDictAddBool( d, key, tr_torrentUsesSpeedLimit( tor, TR_DOWN ) );
-    else if( tr_streq( key, keylen, "error" ) )
-        tr_bencDictAddInt( d, key, st->error );
-    else if( tr_streq( key, keylen, "errorString" ) )
-        tr_bencDictAddStr( d, key, st->errorString );
-    else if( tr_streq( key, keylen, "eta" ) )
-        tr_bencDictAddInt( d, key, st->eta );
-    else if( tr_streq( key, keylen, "files" ) )
-        addFiles( tor, tr_bencDictAddList( d, key, inf->fileCount ) );
-    else if( tr_streq( key, keylen, "fileStats" ) )
-        addFileStats( tor, tr_bencDictAddList( d, key, inf->fileCount ) );
-    else if( tr_streq( key, keylen, "hashString" ) )
-        tr_bencDictAddStr( d, key, tor->info.hashString );
-    else if( tr_streq( key, keylen, "haveUnchecked" ) )
-        tr_bencDictAddInt( d, key, st->haveUnchecked );
-    else if( tr_streq( key, keylen, "haveValid" ) )
-        tr_bencDictAddInt( d, key, st->haveValid );
-    else if( tr_streq( key, keylen, "honorsSessionLimits" ) )
-        tr_bencDictAddBool( d, key, tr_torrentUsesSessionLimits( tor ) );
-    else if( tr_streq( key, keylen, "id" ) )
-        tr_bencDictAddInt( d, key, st->id );
-    else if( tr_streq( key, keylen, "isFinished" ) )
-        tr_bencDictAddBool( d, key, st->finished );
-    else if( tr_streq( key, keylen, "isPrivate" ) )
-        tr_bencDictAddBool( d, key, tr_torrentIsPrivate( tor ) );
-    else if( tr_streq( key, keylen, "isStalled" ) )
-        tr_bencDictAddBool( d, key, st->isStalled );
-    else if( tr_streq( key, keylen, "leftUntilDone" ) )
-        tr_bencDictAddInt( d, key, st->leftUntilDone );
-    else if( tr_streq( key, keylen, "manualAnnounceTime" ) )
-        tr_bencDictAddInt( d, key, st->manualAnnounceTime );
-    else if( tr_streq( key, keylen, "maxConnectedPeers" ) )
-        tr_bencDictAddInt( d, key,  tr_torrentGetPeerLimit( tor ) );
-    else if( tr_streq( key, keylen, "magnetLink" ) ) {
-        char * str = tr_torrentGetMagnetLink( tor );
-        tr_bencDictAddStr( d, key, str );
-        tr_free( str );
+    const size_t keylen = strlen (key);
+
+    if (tr_streq (key, keylen, "activityDate"))
+        tr_bencDictAddInt (d, key, st->activityDate);
+    else if (tr_streq (key, keylen, "addedDate"))
+        tr_bencDictAddInt (d, key, st->addedDate);
+    else if (tr_streq (key, keylen, "bandwidthPriority"))
+        tr_bencDictAddInt (d, key, tr_torrentGetPriority (tor));
+    else if (tr_streq (key, keylen, "comment"))
+        tr_bencDictAddStr (d, key, inf->comment ? inf->comment : "");
+    else if (tr_streq (key, keylen, "corruptEver"))
+        tr_bencDictAddInt (d, key, st->corruptEver);
+    else if (tr_streq (key, keylen, "creator"))
+        tr_bencDictAddStr (d, key, inf->creator ? inf->creator : "");
+    else if (tr_streq (key, keylen, "dateCreated"))
+        tr_bencDictAddInt (d, key, inf->dateCreated);
+    else if (tr_streq (key, keylen, "desiredAvailable"))
+        tr_bencDictAddInt (d, key, st->desiredAvailable);
+    else if (tr_streq (key, keylen, "doneDate"))
+        tr_bencDictAddInt (d, key, st->doneDate);
+    else if (tr_streq (key, keylen, "downloadDir"))
+        tr_bencDictAddStr (d, key, tr_torrentGetDownloadDir (tor));
+    else if (tr_streq (key, keylen, "downloadedEver"))
+        tr_bencDictAddInt (d, key, st->downloadedEver);
+    else if (tr_streq (key, keylen, "downloadLimit"))
+        tr_bencDictAddInt (d, key, tr_torrentGetSpeedLimit_KBps (tor, TR_DOWN));
+    else if (tr_streq (key, keylen, "downloadLimited"))
+        tr_bencDictAddBool (d, key, tr_torrentUsesSpeedLimit (tor, TR_DOWN));
+    else if (tr_streq (key, keylen, "error"))
+        tr_bencDictAddInt (d, key, st->error);
+    else if (tr_streq (key, keylen, "errorString"))
+        tr_bencDictAddStr (d, key, st->errorString);
+    else if (tr_streq (key, keylen, "eta"))
+        tr_bencDictAddInt (d, key, st->eta);
+    else if (tr_streq (key, keylen, "files"))
+        addFiles (tor, tr_bencDictAddList (d, key, inf->fileCount));
+    else if (tr_streq (key, keylen, "fileStats"))
+        addFileStats (tor, tr_bencDictAddList (d, key, inf->fileCount));
+    else if (tr_streq (key, keylen, "hashString"))
+        tr_bencDictAddStr (d, key, tor->info.hashString);
+    else if (tr_streq (key, keylen, "haveUnchecked"))
+        tr_bencDictAddInt (d, key, st->haveUnchecked);
+    else if (tr_streq (key, keylen, "haveValid"))
+        tr_bencDictAddInt (d, key, st->haveValid);
+    else if (tr_streq (key, keylen, "honorsSessionLimits"))
+        tr_bencDictAddBool (d, key, tr_torrentUsesSessionLimits (tor));
+    else if (tr_streq (key, keylen, "id"))
+        tr_bencDictAddInt (d, key, st->id);
+    else if (tr_streq (key, keylen, "isFinished"))
+        tr_bencDictAddBool (d, key, st->finished);
+    else if (tr_streq (key, keylen, "isPrivate"))
+        tr_bencDictAddBool (d, key, tr_torrentIsPrivate (tor));
+    else if (tr_streq (key, keylen, "isStalled"))
+        tr_bencDictAddBool (d, key, st->isStalled);
+    else if (tr_streq (key, keylen, "leftUntilDone"))
+        tr_bencDictAddInt (d, key, st->leftUntilDone);
+    else if (tr_streq (key, keylen, "manualAnnounceTime"))
+        tr_bencDictAddInt (d, key, st->manualAnnounceTime);
+    else if (tr_streq (key, keylen, "maxConnectedPeers"))
+        tr_bencDictAddInt (d, key,  tr_torrentGetPeerLimit (tor));
+    else if (tr_streq (key, keylen, "magnetLink")) {
+        char * str = tr_torrentGetMagnetLink (tor);
+        tr_bencDictAddStr (d, key, str);
+        tr_free (str);
     }
-    else if( tr_streq( key, keylen, "metadataPercentComplete" ) )
-        tr_bencDictAddReal( d, key, st->metadataPercentComplete );
-    else if( tr_streq( key, keylen, "name" ) )
-        tr_bencDictAddStr( d, key, tr_torrentName( tor ) );
-    else if( tr_streq( key, keylen, "percentDone" ) )
-        tr_bencDictAddReal( d, key, st->percentDone );
-    else if( tr_streq( key, keylen, "peer-limit" ) )
-        tr_bencDictAddInt( d, key, tr_torrentGetPeerLimit( tor ) );
-    else if( tr_streq( key, keylen, "peers" ) )
-        addPeers( tor, tr_bencDictAdd( d, key ) );
-    else if( tr_streq( key, keylen, "peersConnected" ) )
-        tr_bencDictAddInt( d, key, st->peersConnected );
-    else if( tr_streq( key, keylen, "peersFrom" ) )
+    else if (tr_streq (key, keylen, "metadataPercentComplete"))
+        tr_bencDictAddReal (d, key, st->metadataPercentComplete);
+    else if (tr_streq (key, keylen, "name"))
+        tr_bencDictAddStr (d, key, tr_torrentName (tor));
+    else if (tr_streq (key, keylen, "percentDone"))
+        tr_bencDictAddReal (d, key, st->percentDone);
+    else if (tr_streq (key, keylen, "peer-limit"))
+        tr_bencDictAddInt (d, key, tr_torrentGetPeerLimit (tor));
+    else if (tr_streq (key, keylen, "peers"))
+        addPeers (tor, tr_bencDictAdd (d, key));
+    else if (tr_streq (key, keylen, "peersConnected"))
+        tr_bencDictAddInt (d, key, st->peersConnected);
+    else if (tr_streq (key, keylen, "peersFrom"))
     {
-        tr_benc *   tmp = tr_bencDictAddDict( d, key, 7 );
+        tr_benc *   tmp = tr_bencDictAddDict (d, key, 7);
         const int * f = st->peersFrom;
-        tr_bencDictAddInt( tmp, "fromCache",    f[TR_PEER_FROM_RESUME] );
-        tr_bencDictAddInt( tmp, "fromDht",      f[TR_PEER_FROM_DHT] );
-        tr_bencDictAddInt( tmp, "fromIncoming", f[TR_PEER_FROM_INCOMING] );
-        tr_bencDictAddInt( tmp, "fromLpd",      f[TR_PEER_FROM_LPD] );
-        tr_bencDictAddInt( tmp, "fromLtep",     f[TR_PEER_FROM_LTEP] );
-        tr_bencDictAddInt( tmp, "fromPex",      f[TR_PEER_FROM_PEX] );
-        tr_bencDictAddInt( tmp, "fromTracker",  f[TR_PEER_FROM_TRACKER] );
+        tr_bencDictAddInt (tmp, "fromCache",    f[TR_PEER_FROM_RESUME]);
+        tr_bencDictAddInt (tmp, "fromDht",      f[TR_PEER_FROM_DHT]);
+        tr_bencDictAddInt (tmp, "fromIncoming", f[TR_PEER_FROM_INCOMING]);
+        tr_bencDictAddInt (tmp, "fromLpd",      f[TR_PEER_FROM_LPD]);
+        tr_bencDictAddInt (tmp, "fromLtep",     f[TR_PEER_FROM_LTEP]);
+        tr_bencDictAddInt (tmp, "fromPex",      f[TR_PEER_FROM_PEX]);
+        tr_bencDictAddInt (tmp, "fromTracker",  f[TR_PEER_FROM_TRACKER]);
     }
-    else if( tr_streq( key, keylen, "peersGettingFromUs" ) )
-        tr_bencDictAddInt( d, key, st->peersGettingFromUs );
-    else if( tr_streq( key, keylen, "peersSendingToUs" ) )
-        tr_bencDictAddInt( d, key, st->peersSendingToUs );
-    else if( tr_streq( key, keylen, "pieces" ) ) {
-        if (tr_torrentHasMetadata( tor ) ) {
+    else if (tr_streq (key, keylen, "peersGettingFromUs"))
+        tr_bencDictAddInt (d, key, st->peersGettingFromUs);
+    else if (tr_streq (key, keylen, "peersSendingToUs"))
+        tr_bencDictAddInt (d, key, st->peersSendingToUs);
+    else if (tr_streq (key, keylen, "pieces")) {
+        if (tr_torrentHasMetadata (tor)) {
             size_t byte_count = 0;
-            void * bytes = tr_cpCreatePieceBitfield( &tor->completion, &byte_count );
-            char * str = tr_base64_encode( bytes, byte_count, NULL );
-            tr_bencDictAddStr( d, key, str!=NULL ? str : "" );
-            tr_free( str );
-            tr_free( bytes );
+            void * bytes = tr_cpCreatePieceBitfield (&tor->completion, &byte_count);
+            char * str = tr_base64_encode (bytes, byte_count, NULL);
+            tr_bencDictAddStr (d, key, str!=NULL ? str : "");
+            tr_free (str);
+            tr_free (bytes);
         } else {
-            tr_bencDictAddStr( d, key, "" );
+            tr_bencDictAddStr (d, key, "");
         }
     }
-    else if( tr_streq( key, keylen, "pieceCount" ) )
-        tr_bencDictAddInt( d, key, inf->pieceCount );
-    else if( tr_streq( key, keylen, "pieceSize" ) )
-        tr_bencDictAddInt( d, key, inf->pieceSize );
-    else if( tr_streq( key, keylen, "priorities" ) )
+    else if (tr_streq (key, keylen, "pieceCount"))
+        tr_bencDictAddInt (d, key, inf->pieceCount);
+    else if (tr_streq (key, keylen, "pieceSize"))
+        tr_bencDictAddInt (d, key, inf->pieceSize);
+    else if (tr_streq (key, keylen, "priorities"))
     {
         tr_file_index_t i;
-        tr_benc *       p = tr_bencDictAddList( d, key, inf->fileCount );
-        for( i = 0; i < inf->fileCount; ++i )
-            tr_bencListAddInt( p, inf->files[i].priority );
+        tr_benc *       p = tr_bencDictAddList (d, key, inf->fileCount);
+        for (i = 0; i < inf->fileCount; ++i)
+            tr_bencListAddInt (p, inf->files[i].priority);
     }
-    else if( tr_streq( key, keylen, "queuePosition" ) )
-        tr_bencDictAddInt( d, key, st->queuePosition );
-    else if( tr_streq( key, keylen, "rateDownload" ) )
-        tr_bencDictAddInt( d, key, toSpeedBytes( st->pieceDownloadSpeed_KBps ) );
-    else if( tr_streq( key, keylen, "rateUpload" ) )
-        tr_bencDictAddInt( d, key, toSpeedBytes( st->pieceUploadSpeed_KBps ) );
-    else if( tr_streq( key, keylen, "recheckProgress" ) )
-        tr_bencDictAddReal( d, key, st->recheckProgress );
-    else if( tr_streq( key, keylen, "seedIdleLimit" ) )
-        tr_bencDictAddInt( d, key, tr_torrentGetIdleLimit( tor ) );
-    else if( tr_streq( key, keylen, "seedIdleMode" ) )
-        tr_bencDictAddInt( d, key, tr_torrentGetIdleMode( tor ) );
-    else if( tr_streq( key, keylen, "seedRatioLimit" ) )
-        tr_bencDictAddReal( d, key, tr_torrentGetRatioLimit( tor ) );
-    else if( tr_streq( key, keylen, "seedRatioMode" ) )
-        tr_bencDictAddInt( d, key, tr_torrentGetRatioMode( tor ) );
-    else if( tr_streq( key, keylen, "sizeWhenDone" ) )
-        tr_bencDictAddInt( d, key, st->sizeWhenDone );
-    else if( tr_streq( key, keylen, "startDate" ) )
-        tr_bencDictAddInt( d, key, st->startDate );
-    else if( tr_streq( key, keylen, "status" ) )
-        tr_bencDictAddInt( d, key, st->activity );
-    else if( tr_streq( key, keylen, "secondsDownloading" ) )
-        tr_bencDictAddInt( d, key, st->secondsDownloading );
-    else if( tr_streq( key, keylen, "secondsSeeding" ) )
-        tr_bencDictAddInt( d, key, st->secondsSeeding );
-    else if( tr_streq( key, keylen, "trackers" ) )
-        addTrackers( inf, tr_bencDictAddList( d, key, inf->trackerCount ) );
-    else if( tr_streq( key, keylen, "trackerStats" ) ) {
+    else if (tr_streq (key, keylen, "queuePosition"))
+        tr_bencDictAddInt (d, key, st->queuePosition);
+    else if (tr_streq (key, keylen, "rateDownload"))
+        tr_bencDictAddInt (d, key, toSpeedBytes (st->pieceDownloadSpeed_KBps));
+    else if (tr_streq (key, keylen, "rateUpload"))
+        tr_bencDictAddInt (d, key, toSpeedBytes (st->pieceUploadSpeed_KBps));
+    else if (tr_streq (key, keylen, "recheckProgress"))
+        tr_bencDictAddReal (d, key, st->recheckProgress);
+    else if (tr_streq (key, keylen, "seedIdleLimit"))
+        tr_bencDictAddInt (d, key, tr_torrentGetIdleLimit (tor));
+    else if (tr_streq (key, keylen, "seedIdleMode"))
+        tr_bencDictAddInt (d, key, tr_torrentGetIdleMode (tor));
+    else if (tr_streq (key, keylen, "seedRatioLimit"))
+        tr_bencDictAddReal (d, key, tr_torrentGetRatioLimit (tor));
+    else if (tr_streq (key, keylen, "seedRatioMode"))
+        tr_bencDictAddInt (d, key, tr_torrentGetRatioMode (tor));
+    else if (tr_streq (key, keylen, "sizeWhenDone"))
+        tr_bencDictAddInt (d, key, st->sizeWhenDone);
+    else if (tr_streq (key, keylen, "startDate"))
+        tr_bencDictAddInt (d, key, st->startDate);
+    else if (tr_streq (key, keylen, "status"))
+        tr_bencDictAddInt (d, key, st->activity);
+    else if (tr_streq (key, keylen, "secondsDownloading"))
+        tr_bencDictAddInt (d, key, st->secondsDownloading);
+    else if (tr_streq (key, keylen, "secondsSeeding"))
+        tr_bencDictAddInt (d, key, st->secondsSeeding);
+    else if (tr_streq (key, keylen, "trackers"))
+        addTrackers (inf, tr_bencDictAddList (d, key, inf->trackerCount));
+    else if (tr_streq (key, keylen, "trackerStats")) {
         int n;
-        tr_tracker_stat * s = tr_torrentTrackers( tor, &n );
-        addTrackerStats( s, n, tr_bencDictAddList( d, key, n ) );
-        tr_torrentTrackersFree( s, n );
+        tr_tracker_stat * s = tr_torrentTrackers (tor, &n);
+        addTrackerStats (s, n, tr_bencDictAddList (d, key, n));
+        tr_torrentTrackersFree (s, n);
     }
-    else if( tr_streq( key, keylen, "torrentFile" ) )
-        tr_bencDictAddStr( d, key, inf->torrent );
-    else if( tr_streq( key, keylen, "totalSize" ) )
-        tr_bencDictAddInt( d, key, inf->totalSize );
-    else if( tr_streq( key, keylen, "uploadedEver" ) )
-        tr_bencDictAddInt( d, key, st->uploadedEver );
-    else if( tr_streq( key, keylen, "uploadLimit" ) )
-        tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit_KBps( tor, TR_UP ) );
-    else if( tr_streq( key, keylen, "uploadLimited" ) )
-        tr_bencDictAddBool( d, key, tr_torrentUsesSpeedLimit( tor, TR_UP ) );
-    else if( tr_streq( key, keylen, "uploadRatio" ) )
-        tr_bencDictAddReal( d, key, st->ratio );
-    else if( tr_streq( key, keylen, "wanted" ) )
+    else if (tr_streq (key, keylen, "torrentFile"))
+        tr_bencDictAddStr (d, key, inf->torrent);
+    else if (tr_streq (key, keylen, "totalSize"))
+        tr_bencDictAddInt (d, key, inf->totalSize);
+    else if (tr_streq (key, keylen, "uploadedEver"))
+        tr_bencDictAddInt (d, key, st->uploadedEver);
+    else if (tr_streq (key, keylen, "uploadLimit"))
+        tr_bencDictAddInt (d, key, tr_torrentGetSpeedLimit_KBps (tor, TR_UP));
+    else if (tr_streq (key, keylen, "uploadLimited"))
+        tr_bencDictAddBool (d, key, tr_torrentUsesSpeedLimit (tor, TR_UP));
+    else if (tr_streq (key, keylen, "uploadRatio"))
+        tr_bencDictAddReal (d, key, st->ratio);
+    else if (tr_streq (key, keylen, "wanted"))
     {
         tr_file_index_t i;
-        tr_benc *       w = tr_bencDictAddList( d, key, inf->fileCount );
-        for( i = 0; i < inf->fileCount; ++i )
-            tr_bencListAddInt( w, inf->files[i].dnd ? 0 : 1 );
+        tr_benc *       w = tr_bencDictAddList (d, key, inf->fileCount);
+        for (i = 0; i < inf->fileCount; ++i)
+            tr_bencListAddInt (w, inf->files[i].dnd ? 0 : 1);
     }
-    else if( tr_streq( key, keylen, "webseeds" ) )
-        addWebseeds( inf, tr_bencDictAddList( d, key, inf->webseedCount ) );
-    else if( tr_streq( key, keylen, "webseedsSendingToUs" ) )
-        tr_bencDictAddInt( d, key, st->webseedsSendingToUs );
+    else if (tr_streq (key, keylen, "webseeds"))
+        addWebseeds (inf, tr_bencDictAddList (d, key, inf->webseedCount));
+    else if (tr_streq (key, keylen, "webseedsSendingToUs"))
+        tr_bencDictAddInt (d, key, st->webseedsSendingToUs);
 }
 
 static void
-addInfo( const tr_torrent * tor, tr_benc * d, tr_benc * fields )
+addInfo (const tr_torrent * tor, tr_benc * d, tr_benc * fields)
 {
     const char * str;
-    const int n = tr_bencListSize( fields );
+    const int n = tr_bencListSize (fields);
 
-    tr_bencInitDict( d, n );
+    tr_bencInitDict (d, n);
 
-    if( n > 0 )
+    if (n > 0)
     {
         int i;
-        const tr_info const * inf = tr_torrentInfo( tor );
-        const tr_stat const * st = tr_torrentStat( (tr_torrent*)tor );
+        const tr_info const * inf = tr_torrentInfo (tor);
+        const tr_stat const * st = tr_torrentStat ((tr_torrent*)tor);
 
-        for( i=0; i<n; ++i )
-            if( tr_bencGetStr( tr_bencListChild( fields, i ), &str ) )
-                addField( tor, inf, st, d, str );
+        for (i=0; i<n; ++i)
+            if (tr_bencGetStr (tr_bencListChild (fields, i), &str))
+                addField (tor, inf, st, d, str);
     }
 }
 
 static const char*
-torrentGet( tr_session               * session,
+torrentGet (tr_session               * session,
             tr_benc                  * args_in,
             tr_benc                  * args_out,
-            struct tr_rpc_idle_data  * idle_data UNUSED )
+            struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int           i, torrentCount;
-    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
-    tr_benc *     list = tr_bencDictAddList( args_out, "torrents", torrentCount );
+    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
+    tr_benc *     list = tr_bencDictAddList (args_out, "torrents", torrentCount);
     tr_benc *     fields;
     const char *  msg = NULL;
     const char *  strVal;
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    if( tr_bencDictFindStr( args_in, "ids", &strVal ) && !strcmp( strVal, "recently-active" ) ) {
+    if (tr_bencDictFindStr (args_in, "ids", &strVal) && !strcmp (strVal, "recently-active")) {
         int n = 0;
         tr_benc * d;
-        const time_t now = tr_time( );
+        const time_t now = tr_time ();
         const int interval = RECENTLY_ACTIVE_SECONDS;
-        tr_benc * removed_out = tr_bencDictAddList( args_out, "removed", 0 );
-        while(( d = tr_bencListChild( &session->removedTorrents, n++ ))) {
+        tr_benc * removed_out = tr_bencDictAddList (args_out, "removed", 0);
+        while ((d = tr_bencListChild (&session->removedTorrents, n++))) {
             int64_t intVal;
-            if( tr_bencDictFindInt( d, "date", &intVal ) && ( intVal >= now - interval ) ) {
-                tr_bencDictFindInt( d, "id", &intVal );
-                tr_bencListAddInt( removed_out, intVal );
+            if (tr_bencDictFindInt (d, "date", &intVal) && (intVal >= now - interval)) {
+                tr_bencDictFindInt (d, "id", &intVal);
+                tr_bencListAddInt (removed_out, intVal);
             }
         }
     }
 
-    if( !tr_bencDictFindList( args_in, "fields", &fields ) )
+    if (!tr_bencDictFindList (args_in, "fields", &fields))
         msg = "no fields specified";
-    else for( i = 0; i < torrentCount; ++i )
-        addInfo( torrents[i], tr_bencListAdd( list ), fields );
+    else for (i = 0; i < torrentCount; ++i)
+        addInfo (torrents[i], tr_bencListAdd (list), fields);
 
-    tr_free( torrents );
+    tr_free (torrents);
     return msg;
 }
 
@@ -797,22 +797,22 @@ torrentGet( tr_session               * session,
 ***/
 
 static const char*
-setFilePriorities( tr_torrent * tor,
+setFilePriorities (tr_torrent * tor,
                    int          priority,
-                   tr_benc *    list )
+                   tr_benc *    list)
 {
     int i;
     int64_t tmp;
     int fileCount = 0;
-    const int n = tr_bencListSize( list );
+    const int n = tr_bencListSize (list);
     const char * errmsg = NULL;
-    tr_file_index_t * files = tr_new0( tr_file_index_t, tor->info.fileCount );
+    tr_file_index_t * files = tr_new0 (tr_file_index_t, tor->info.fileCount);
 
-    if( n )
+    if (n)
     {
-        for( i = 0; i < n; ++i ) {
-            if( tr_bencGetInt( tr_bencListChild( list, i ), &tmp ) ) {
-                if( 0 <= tmp && tmp < tor->info.fileCount ) {
+        for (i = 0; i < n; ++i) {
+            if (tr_bencGetInt (tr_bencListChild (list, i), &tmp)) {
+                if (0 <= tmp && tmp < tor->info.fileCount) {
                     files[fileCount++] = tmp;
                 } else {
                     errmsg = "file index out of range";
@@ -823,34 +823,34 @@ setFilePriorities( tr_torrent * tor,
     else /* if empty set, apply to all */
     {
         tr_file_index_t t;
-        for( t = 0; t < tor->info.fileCount; ++t )
+        for (t = 0; t < tor->info.fileCount; ++t)
             files[fileCount++] = t;
     }
 
-    if( fileCount )
-        tr_torrentSetFilePriorities( tor, files, fileCount, priority );
+    if (fileCount)
+        tr_torrentSetFilePriorities (tor, files, fileCount, priority);
 
-    tr_free( files );
+    tr_free (files);
     return errmsg;
 }
 
 static const char*
-setFileDLs( tr_torrent * tor,
+setFileDLs (tr_torrent * tor,
             int          do_download,
-            tr_benc *    list )
+            tr_benc *    list)
 {
     int i;
     int64_t tmp;
     int fileCount = 0;
-    const int n = tr_bencListSize( list );
+    const int n = tr_bencListSize (list);
     const char * errmsg = NULL;
-    tr_file_index_t * files = tr_new0( tr_file_index_t, tor->info.fileCount );
+    tr_file_index_t * files = tr_new0 (tr_file_index_t, tor->info.fileCount);
 
-    if( n ) /* if argument list, process them */
+    if (n) /* if argument list, process them */
     {
-        for( i = 0; i < n; ++i ) {
-            if( tr_bencGetInt( tr_bencListChild( list, i ), &tmp ) ) {
-                if( 0 <= tmp && tmp < tor->info.fileCount ) {
+        for (i = 0; i < n; ++i) {
+            if (tr_bencGetInt (tr_bencListChild (list, i), &tmp)) {
+                if (0 <= tmp && tmp < tor->info.fileCount) {
                     files[fileCount++] = tmp;
                 } else {
                     errmsg = "file index out of range";
@@ -861,29 +861,29 @@ setFileDLs( tr_torrent * tor,
     else /* if empty set, apply to all */
     {
         tr_file_index_t t;
-        for( t = 0; t < tor->info.fileCount; ++t )
+        for (t = 0; t < tor->info.fileCount; ++t)
             files[fileCount++] = t;
     }
 
-    if( fileCount )
-        tr_torrentSetFileDLs( tor, files, fileCount, do_download );
+    if (fileCount)
+        tr_torrentSetFileDLs (tor, files, fileCount, do_download);
 
-    tr_free( files );
+    tr_free (files);
     return errmsg;
 }
 
 static bool
-findAnnounceUrl( const tr_tracker_info * t, int n, const char * url, int * pos )
+findAnnounceUrl (const tr_tracker_info * t, int n, const char * url, int * pos)
 {
     int i;
     bool found = false;
 
-    for( i=0; i<n; ++i )
+    for (i=0; i<n; ++i)
     {
-        if( !strcmp( t[i].announce, url ) )
+        if (!strcmp (t[i].announce, url))
         {
             found = true;
-            if( pos ) *pos = i;
+            if (pos) *pos = i;
             break;
         }
     }
@@ -892,34 +892,34 @@ findAnnounceUrl( const tr_tracker_info * t, int n, const char * url, int * pos )
 }
 
 static int
-copyTrackers( tr_tracker_info * tgt, const tr_tracker_info * src, int n )
+copyTrackers (tr_tracker_info * tgt, const tr_tracker_info * src, int n)
 {
     int i;
     int maxTier = -1;
 
-    for( i=0; i<n; ++i )
+    for (i=0; i<n; ++i)
     {
         tgt[i].tier = src[i].tier;
-        tgt[i].announce = tr_strdup( src[i].announce );
-        maxTier = MAX( maxTier, src[i].tier );
+        tgt[i].announce = tr_strdup (src[i].announce);
+        maxTier = MAX (maxTier, src[i].tier);
     }
 
     return maxTier;
 }
 
 static void
-freeTrackers( tr_tracker_info * trackers, int n )
+freeTrackers (tr_tracker_info * trackers, int n)
 {
     int i;
 
-    for( i=0; i<n; ++i )
-        tr_free( trackers[i].announce );
+    for (i=0; i<n; ++i)
+        tr_free (trackers[i].announce);
 
-    tr_free( trackers );
+    tr_free (trackers);
 }
 
 static const char*
-addTrackerUrls( tr_torrent * tor, tr_benc * urls )
+addTrackerUrls (tr_torrent * tor, tr_benc * urls)
 {
     int i;
     int n;
@@ -927,88 +927,88 @@ addTrackerUrls( tr_torrent * tor, tr_benc * urls )
     tr_benc * val;
     tr_tracker_info * trackers;
     bool changed = false;
-    const tr_info * inf = tr_torrentInfo( tor );
+    const tr_info * inf = tr_torrentInfo (tor);
     const char * errmsg = NULL;
 
     /* make a working copy of the existing announce list */
     n = inf->trackerCount;
-    trackers = tr_new0( tr_tracker_info, n + tr_bencListSize( urls ) );
-    tier = copyTrackers( trackers, inf->trackers, n );
+    trackers = tr_new0 (tr_tracker_info, n + tr_bencListSize (urls));
+    tier = copyTrackers (trackers, inf->trackers, n);
 
     /* and add the new ones */
     i = 0;
-    while(( val = tr_bencListChild( urls, i++ ) ))
+    while ((val = tr_bencListChild (urls, i++)))
     {
         const char * announce = NULL;
 
-        if(    tr_bencGetStr( val, &announce )
-            && tr_urlIsValidTracker( announce )
-            && !findAnnounceUrl( trackers, n, announce, NULL ) )
+        if ( tr_bencGetStr (val, &announce)
+            && tr_urlIsValidTracker (announce)
+            && !findAnnounceUrl (trackers, n, announce, NULL))
         {
             trackers[n].tier = ++tier; /* add a new tier */
-            trackers[n].announce = tr_strdup( announce );
+            trackers[n].announce = tr_strdup (announce);
             ++n;
             changed = true;
         }
     }
 
-    if( !changed )
+    if (!changed)
         errmsg = "invalid argument";
-    else if( !tr_torrentSetAnnounceList( tor, trackers, n ) )
+    else if (!tr_torrentSetAnnounceList (tor, trackers, n))
         errmsg = "error setting announce list";
 
-    freeTrackers( trackers, n );
+    freeTrackers (trackers, n);
     return errmsg;
 }
 
 static const char*
-replaceTrackers( tr_torrent * tor, tr_benc * urls )
+replaceTrackers (tr_torrent * tor, tr_benc * urls)
 {
     int i;
     tr_benc * pair[2];
     tr_tracker_info * trackers;
     bool changed = false;
-    const tr_info * inf = tr_torrentInfo( tor );
+    const tr_info * inf = tr_torrentInfo (tor);
     const int n = inf->trackerCount;
     const char * errmsg = NULL;
 
     /* make a working copy of the existing announce list */
-    trackers = tr_new0( tr_tracker_info, n );
-    copyTrackers( trackers, inf->trackers, n );
+    trackers = tr_new0 (tr_tracker_info, n);
+    copyTrackers (trackers, inf->trackers, n);
 
     /* make the substitutions... */
     i = 0;
-    while(((pair[0] = tr_bencListChild(urls,i))) &&
-          ((pair[1] = tr_bencListChild(urls,i+1))))
+    while (((pair[0] = tr_bencListChild (urls,i))) &&
+        ((pair[1] = tr_bencListChild (urls,i+1))))
     {
         int64_t pos;
         const char * newval;
 
-        if(    tr_bencGetInt( pair[0], &pos )
-            && tr_bencGetStr( pair[1], &newval )
-            && tr_urlIsValidTracker( newval )
+        if ( tr_bencGetInt (pair[0], &pos)
+            && tr_bencGetStr (pair[1], &newval)
+            && tr_urlIsValidTracker (newval)
             && pos < n
-            && pos >= 0 )
+            && pos >= 0)
         {
-            tr_free( trackers[pos].announce );
-            trackers[pos].announce = tr_strdup( newval );
+            tr_free (trackers[pos].announce);
+            trackers[pos].announce = tr_strdup (newval);
             changed = true;
         }
 
         i += 2;
     }
 
-    if( !changed )
+    if (!changed)
         errmsg = "invalid argument";
-    else if( !tr_torrentSetAnnounceList( tor, trackers, n ) )
+    else if (!tr_torrentSetAnnounceList (tor, trackers, n))
         errmsg = "error setting announce list";
 
-    freeTrackers( trackers, n );
+    freeTrackers (trackers, n);
     return errmsg;
 }
 
 static const char*
-removeTrackers( tr_torrent * tor, tr_benc * ids )
+removeTrackers (tr_torrent * tor, tr_benc * ids)
 {
     int i;
     int n;
@@ -1018,62 +1018,62 @@ removeTrackers( tr_torrent * tor, tr_benc * ids )
     tr_benc * val;
     tr_tracker_info * trackers;
     bool changed = false;
-    const tr_info * inf = tr_torrentInfo( tor );
+    const tr_info * inf = tr_torrentInfo (tor);
     const char * errmsg = NULL;
 
     /* make a working copy of the existing announce list */
     n = inf->trackerCount;
-    tids = tr_new0( int, n );
-    trackers = tr_new0( tr_tracker_info, n );
-    copyTrackers( trackers, inf->trackers, n );
+    tids = tr_new0 (int, n);
+    trackers = tr_new0 (tr_tracker_info, n);
+    copyTrackers (trackers, inf->trackers, n);
 
     /* remove the ones specified in the urls list */
     i = 0;
-    while(( val = tr_bencListChild( ids, i++ )))
+    while ((val = tr_bencListChild (ids, i++)))
     {
         int64_t pos;
 
-        if(    tr_bencGetInt( val, &pos )
+        if ( tr_bencGetInt (val, &pos)
             && pos < n
-            && pos >= 0 )
+            && pos >= 0)
             tids[t++] = pos;
     }
 
     /* sort trackerIds and remove from largest to smallest so there is no need to recacluate array indicies */
-    qsort( tids, t, sizeof(int), compareInt );
-    while( t-- )
+    qsort (tids, t, sizeof (int), compareInt);
+    while (t--)
     {
         /* check for duplicates */
-        if( tids[t] == dup )
+        if (tids[t] == dup)
             continue;
-        tr_removeElementFromArray( trackers, tids[t], sizeof( tr_tracker_info ), n-- );
+        tr_removeElementFromArray (trackers, tids[t], sizeof (tr_tracker_info), n--);
         dup = tids[t];
         changed = true;
     }
 
-    if( !changed )
+    if (!changed)
         errmsg = "invalid argument";
-    else if( !tr_torrentSetAnnounceList( tor, trackers, n ) )
+    else if (!tr_torrentSetAnnounceList (tor, trackers, n))
         errmsg = "error setting announce list";
 
-    freeTrackers( trackers, n );
-    tr_free( tids );
+    freeTrackers (trackers, n);
+    tr_free (tids);
     return errmsg;
 }
 
 static const char*
-torrentSet( tr_session               * session,
+torrentSet (tr_session               * session,
             tr_benc                  * args_in,
             tr_benc                  * args_out UNUSED,
-            struct tr_rpc_idle_data  * idle_data UNUSED )
+            struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     const char * errmsg = NULL;
     int i, torrentCount;
-    tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+    tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    for( i = 0; i < torrentCount; ++i )
+    for (i = 0; i < torrentCount; ++i)
     {
         int64_t      tmp;
         double       d;
@@ -1082,66 +1082,66 @@ torrentSet( tr_session               * session,
         bool         boolVal;
         tr_torrent * tor = torrents[i];
 
-        if( tr_bencDictFindInt( args_in, "bandwidthPriority", &tmp ) )
-            if( tr_isPriority( tmp ) )
-                tr_torrentSetPriority( tor, tmp );
-        if( !errmsg && tr_bencDictFindList( args_in, "files-unwanted", &files ) )
-            errmsg = setFileDLs( tor, false, files );
-        if( !errmsg && tr_bencDictFindList( args_in, "files-wanted", &files ) )
-            errmsg = setFileDLs( tor, true, files );
-        if( tr_bencDictFindInt( args_in, "peer-limit", &tmp ) )
-            tr_torrentSetPeerLimit( tor, tmp );
-        if( !errmsg &&  tr_bencDictFindList( args_in, "priority-high", &files ) )
-            errmsg = setFilePriorities( tor, TR_PRI_HIGH, files );
-        if( !errmsg && tr_bencDictFindList( args_in, "priority-low", &files ) )
-            errmsg = setFilePriorities( tor, TR_PRI_LOW, files );
-        if( !errmsg && tr_bencDictFindList( args_in, "priority-normal", &files ) )
-            errmsg = setFilePriorities( tor, TR_PRI_NORMAL, files );
-        if( tr_bencDictFindInt( args_in, "downloadLimit", &tmp ) )
-            tr_torrentSetSpeedLimit_KBps( tor, TR_DOWN, tmp );
-        if( tr_bencDictFindBool( args_in, "downloadLimited", &boolVal ) )
-            tr_torrentUseSpeedLimit( tor, TR_DOWN, boolVal );
-        if( tr_bencDictFindBool( args_in, "honorsSessionLimits", &boolVal ) )
-            tr_torrentUseSessionLimits( tor, boolVal );
-        if( tr_bencDictFindInt( args_in, "uploadLimit", &tmp ) )
-            tr_torrentSetSpeedLimit_KBps( tor, TR_UP, tmp );
-        if( tr_bencDictFindBool( args_in, "uploadLimited", &boolVal ) )
-            tr_torrentUseSpeedLimit( tor, TR_UP, boolVal );
-        if( tr_bencDictFindInt( args_in, "seedIdleLimit", &tmp ) )
-            tr_torrentSetIdleLimit( tor, tmp );
-        if( tr_bencDictFindInt( args_in, "seedIdleMode", &tmp ) )
-            tr_torrentSetIdleMode( tor, tmp );
-        if( tr_bencDictFindReal( args_in, "seedRatioLimit", &d ) )
-            tr_torrentSetRatioLimit( tor, d );
-        if( tr_bencDictFindInt( args_in, "seedRatioMode", &tmp ) )
-            tr_torrentSetRatioMode( tor, tmp );
-        if( tr_bencDictFindInt( args_in, "queuePosition", &tmp ) )
-            tr_torrentSetQueuePosition( tor, tmp );
-        if( !errmsg && tr_bencDictFindList( args_in, "trackerAdd", &trackers ) )
-            errmsg = addTrackerUrls( tor, trackers );
-        if( !errmsg && tr_bencDictFindList( args_in, "trackerRemove", &trackers ) )
-            errmsg = removeTrackers( tor, trackers );
-        if( !errmsg && tr_bencDictFindList( args_in, "trackerReplace", &trackers ) )
-            errmsg = replaceTrackers( tor, trackers );
-        notify( session, TR_RPC_TORRENT_CHANGED, tor );
+        if (tr_bencDictFindInt (args_in, "bandwidthPriority", &tmp))
+            if (tr_isPriority (tmp))
+                tr_torrentSetPriority (tor, tmp);
+        if (!errmsg && tr_bencDictFindList (args_in, "files-unwanted", &files))
+            errmsg = setFileDLs (tor, false, files);
+        if (!errmsg && tr_bencDictFindList (args_in, "files-wanted", &files))
+            errmsg = setFileDLs (tor, true, files);
+        if (tr_bencDictFindInt (args_in, "peer-limit", &tmp))
+            tr_torrentSetPeerLimit (tor, tmp);
+        if (!errmsg &&  tr_bencDictFindList (args_in, "priority-high", &files))
+            errmsg = setFilePriorities (tor, TR_PRI_HIGH, files);
+        if (!errmsg && tr_bencDictFindList (args_in, "priority-low", &files))
+            errmsg = setFilePriorities (tor, TR_PRI_LOW, files);
+        if (!errmsg && tr_bencDictFindList (args_in, "priority-normal", &files))
+            errmsg = setFilePriorities (tor, TR_PRI_NORMAL, files);
+        if (tr_bencDictFindInt (args_in, "downloadLimit", &tmp))
+            tr_torrentSetSpeedLimit_KBps (tor, TR_DOWN, tmp);
+        if (tr_bencDictFindBool (args_in, "downloadLimited", &boolVal))
+            tr_torrentUseSpeedLimit (tor, TR_DOWN, boolVal);
+        if (tr_bencDictFindBool (args_in, "honorsSessionLimits", &boolVal))
+            tr_torrentUseSessionLimits (tor, boolVal);
+        if (tr_bencDictFindInt (args_in, "uploadLimit", &tmp))
+            tr_torrentSetSpeedLimit_KBps (tor, TR_UP, tmp);
+        if (tr_bencDictFindBool (args_in, "uploadLimited", &boolVal))
+            tr_torrentUseSpeedLimit (tor, TR_UP, boolVal);
+        if (tr_bencDictFindInt (args_in, "seedIdleLimit", &tmp))
+            tr_torrentSetIdleLimit (tor, tmp);
+        if (tr_bencDictFindInt (args_in, "seedIdleMode", &tmp))
+            tr_torrentSetIdleMode (tor, tmp);
+        if (tr_bencDictFindReal (args_in, "seedRatioLimit", &d))
+            tr_torrentSetRatioLimit (tor, d);
+        if (tr_bencDictFindInt (args_in, "seedRatioMode", &tmp))
+            tr_torrentSetRatioMode (tor, tmp);
+        if (tr_bencDictFindInt (args_in, "queuePosition", &tmp))
+            tr_torrentSetQueuePosition (tor, tmp);
+        if (!errmsg && tr_bencDictFindList (args_in, "trackerAdd", &trackers))
+            errmsg = addTrackerUrls (tor, trackers);
+        if (!errmsg && tr_bencDictFindList (args_in, "trackerRemove", &trackers))
+            errmsg = removeTrackers (tor, trackers);
+        if (!errmsg && tr_bencDictFindList (args_in, "trackerReplace", &trackers))
+            errmsg = replaceTrackers (tor, trackers);
+        notify (session, TR_RPC_TORRENT_CHANGED, tor);
     }
 
-    tr_free( torrents );
+    tr_free (torrents);
     return errmsg;
 }
 
 static const char*
-torrentSetLocation( tr_session               * session,
+torrentSetLocation (tr_session               * session,
                     tr_benc                  * args_in,
                     tr_benc                  * args_out UNUSED,
-                    struct tr_rpc_idle_data  * idle_data UNUSED )
+                    struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     const char * errmsg = NULL;
     const char * location = NULL;
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    if( !tr_bencDictFindStr( args_in, "location", &location ) )
+    if (!tr_bencDictFindStr (args_in, "location", &location))
     {
         errmsg = "no location";
     }
@@ -1149,18 +1149,18 @@ torrentSetLocation( tr_session               * session,
     {
         bool move = false;
         int i, torrentCount;
-        tr_torrent ** torrents = getTorrents( session, args_in, &torrentCount );
+        tr_torrent ** torrents = getTorrents (session, args_in, &torrentCount);
 
-        tr_bencDictFindBool( args_in, "move", &move );
+        tr_bencDictFindBool (args_in, "move", &move);
 
-        for( i=0; i<torrentCount; ++i )
+        for (i=0; i<torrentCount; ++i)
         {
             tr_torrent * tor = torrents[i];
-            tr_torrentSetLocation( tor, location, move, NULL, NULL );
-            notify( session, TR_RPC_TORRENT_MOVED, tor );
+            tr_torrentSetLocation (tor, location, move, NULL, NULL);
+            notify (session, TR_RPC_TORRENT_MOVED, tor);
         }
 
-        tr_free( torrents );
+        tr_free (torrents);
     }
 
     return errmsg;
@@ -1171,42 +1171,42 @@ torrentSetLocation( tr_session               * session,
 ***/
 
 static void
-portTested( tr_session       * session UNUSED,
+portTested (tr_session       * session UNUSED,
             bool               did_connect UNUSED,
             bool               did_timeout UNUSED,
             long               response_code,
             const void       * response,
             size_t             response_byte_count,
-            void             * user_data )
+            void             * user_data)
 {
     char result[1024];
     struct tr_rpc_idle_data * data = user_data;
 
-    if( response_code != 200 )
+    if (response_code != 200)
     {
-        tr_snprintf( result, sizeof( result ), "portTested: http error %ld: %s",
-                     response_code, tr_webGetResponseStr( response_code ) );
+        tr_snprintf (result, sizeof (result), "portTested: http error %ld: %s",
+                     response_code, tr_webGetResponseStr (response_code));
     }
     else /* success */
     {
-        const bool isOpen = response_byte_count && *(char*)response == '1';
-        tr_bencDictAddBool( data->args_out, "port-is-open", isOpen );
-        tr_snprintf( result, sizeof( result ), "success" );
+        const bool isOpen = response_byte_count && * (char*)response == '1';
+        tr_bencDictAddBool (data->args_out, "port-is-open", isOpen);
+        tr_snprintf (result, sizeof (result), "success");
     }
 
-    tr_idle_function_done( data, result );
+    tr_idle_function_done (data, result);
 }
 
 static const char*
-portTest( tr_session               * session,
+portTest (tr_session               * session,
           tr_benc                  * args_in UNUSED,
           tr_benc                  * args_out UNUSED,
-          struct tr_rpc_idle_data  * idle_data )
+          struct tr_rpc_idle_data  * idle_data)
 {
-    const int port = tr_sessionGetPeerPort( session );
-    char * url = tr_strdup_printf( "http://portcheck.transmissionbt.com/%d", port );
-    tr_webRun( session, url, NULL, NULL, portTested, idle_data );
-    tr_free( url );
+    const int port = tr_sessionGetPeerPort (session);
+    char * url = tr_strdup_printf ("http://portcheck.transmissionbt.com/%d", port);
+    tr_webRun (session, url, NULL, NULL, portTested, idle_data);
+    tr_free (url);
     return NULL;
 }
 
@@ -1215,23 +1215,23 @@ portTest( tr_session               * session,
 ***/
 
 static void
-gotNewBlocklist( tr_session       * session,
+gotNewBlocklist (tr_session       * session,
                  bool               did_connect UNUSED,
                  bool               did_timeout UNUSED,
                  long               response_code,
                  const void       * response,
                  size_t             response_byte_count,
-                 void             * user_data )
+                 void             * user_data)
 {
     char result[1024];
     struct tr_rpc_idle_data * data = user_data;
 
     *result = '\0';
 
-    if( response_code != 200 )
+    if (response_code != 200)
     {
-        tr_snprintf( result, sizeof( result ), "gotNewBlocklist: http error %ld: %s",
-                     response_code, tr_webGetResponseStr( response_code ) );
+        tr_snprintf (result, sizeof (result), "gotNewBlocklist: http error %ld: %s",
+                     response_code, tr_webGetResponseStr (response_code));
     }
     else /* successfully fetched the blocklist... */
     {
@@ -1239,12 +1239,12 @@ gotNewBlocklist( tr_session       * session,
         int err;
         char * filename;
         z_stream stream;
-        const char * configDir = tr_sessionGetConfigDir( session );
+        const char * configDir = tr_sessionGetConfigDir (session);
         const size_t buflen = 1024 * 128; /* 128 KiB buffer */
-        uint8_t * buf = tr_valloc( buflen );
+        uint8_t * buf = tr_valloc (buflen);
 
         /* this is an odd Magic Number required by zlib to enable gz support.
-           See zlib's inflateInit2() documentation for a full description */
+           See zlib's inflateInit2 () documentation for a full description */
         const int windowBits = 15 + 32;
 
         stream.zalloc = (alloc_func) Z_NULL;
@@ -1252,64 +1252,64 @@ gotNewBlocklist( tr_session       * session,
         stream.opaque = (voidpf) Z_NULL;
         stream.next_in = (void*) response;
         stream.avail_in = response_byte_count;
-        inflateInit2( &stream, windowBits );
+        inflateInit2 (&stream, windowBits);
 
-        filename = tr_buildPath( configDir, "blocklist.tmp", NULL );
-        fd = tr_open_file_for_writing( filename );
-        if( fd < 0 )
-            tr_snprintf( result, sizeof( result ), _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( errno ) );
+        filename = tr_buildPath (configDir, "blocklist.tmp", NULL);
+        fd = tr_open_file_for_writing (filename);
+        if (fd < 0)
+            tr_snprintf (result, sizeof (result), _ ("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
 
-        for( ;; )
+        for (;;)
         {
             stream.next_out = (void*) buf;
             stream.avail_out = buflen;
-            err = inflate( &stream, Z_NO_FLUSH );
+            err = inflate (&stream, Z_NO_FLUSH);
 
-            if( stream.avail_out < buflen ) {
-                const int e = write( fd, buf, buflen - stream.avail_out );
-                if( e < 0 ) {
-                    tr_snprintf( result, sizeof( result ), _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( errno ) );
+            if (stream.avail_out < buflen) {
+                const int e = write (fd, buf, buflen - stream.avail_out);
+                if (e < 0) {
+                    tr_snprintf (result, sizeof (result), _ ("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
                     break;
                 }
             }
 
-            if( err != Z_OK ) {
-                if( ( err != Z_STREAM_END ) && ( err != Z_DATA_ERROR ) )
-                    tr_snprintf( result, sizeof( result ), _( "Error uncompressing blocklist: %s (%d)" ), zError( err ), err );
+            if (err != Z_OK) {
+                if ((err != Z_STREAM_END) && (err != Z_DATA_ERROR))
+                    tr_snprintf (result, sizeof (result), _ ("Error uncompressing blocklist: %s (%d)"), zError (err), err);
                 break;
             }
         }
 
-        inflateEnd( &stream );
+        inflateEnd (&stream);
 
-        if( err == Z_DATA_ERROR ) /* couldn't inflate it... it's probably already uncompressed */
-            if( write( fd, response, response_byte_count ) < 0 )
-                tr_snprintf( result, sizeof( result ), _( "Couldn't save file \"%1$s\": %2$s" ), filename, tr_strerror( errno ) );
+        if (err == Z_DATA_ERROR) /* couldn't inflate it... it's probably already uncompressed */
+            if (write (fd, response, response_byte_count) < 0)
+                tr_snprintf (result, sizeof (result), _ ("Couldn't save file \"%1$s\": %2$s"), filename, tr_strerror (errno));
 
-        if( *result )
-            tr_err( "%s", result );
+        if (*result)
+            tr_err ("%s", result);
         else {
             /* feed it to the session and give the client a response */
-            const int rule_count = tr_blocklistSetContent( session, filename );
-            tr_bencDictAddInt( data->args_out, "blocklist-size", rule_count );
-            tr_snprintf( result, sizeof( result ), "success" );
+            const int rule_count = tr_blocklistSetContent (session, filename);
+            tr_bencDictAddInt (data->args_out, "blocklist-size", rule_count);
+            tr_snprintf (result, sizeof (result), "success");
         }
 
-        unlink( filename );
-        tr_free( filename );
-        tr_free( buf );
+        unlink (filename);
+        tr_free (filename);
+        tr_free (buf);
     }
 
-    tr_idle_function_done( data, result );
+    tr_idle_function_done (data, result);
 }
 
 static const char*
-blocklistUpdate( tr_session               * session,
+blocklistUpdate (tr_session               * session,
                  tr_benc                  * args_in UNUSED,
                  tr_benc                  * args_out UNUSED,
-                 struct tr_rpc_idle_data  * idle_data )
+                 struct tr_rpc_idle_data  * idle_data)
 {
-    tr_webRun( session, session->blocklist_url, NULL, NULL, gotNewBlocklist, idle_data );
+    tr_webRun (session, session->blocklist_url, NULL, NULL, gotNewBlocklist, idle_data);
     return NULL;
 }
 
@@ -1318,35 +1318,35 @@ blocklistUpdate( tr_session               * session,
 ***/
 
 static void
-addTorrentImpl( struct tr_rpc_idle_data * data, tr_ctor * ctor )
+addTorrentImpl (struct tr_rpc_idle_data * data, tr_ctor * ctor)
 {
     int err = 0;
     const char * result = NULL;
-    tr_torrent * tor = tr_torrentNew( ctor, &err );
+    tr_torrent * tor = tr_torrentNew (ctor, &err);
 
-    tr_ctorFree( ctor );
+    tr_ctorFree (ctor);
 
-    if( tor )
+    if (tor)
     {
         tr_benc fields;
-        tr_bencInitList( &fields, 3 );
-        tr_bencListAddStr( &fields, "id" );
-        tr_bencListAddStr( &fields, "name" );
-        tr_bencListAddStr( &fields, "hashString" );
-        addInfo( tor, tr_bencDictAdd( data->args_out, "torrent-added" ), &fields );
-        notify( data->session, TR_RPC_TORRENT_ADDED, tor );
-        tr_bencFree( &fields );
+        tr_bencInitList (&fields, 3);
+        tr_bencListAddStr (&fields, "id");
+        tr_bencListAddStr (&fields, "name");
+        tr_bencListAddStr (&fields, "hashString");
+        addInfo (tor, tr_bencDictAdd (data->args_out, "torrent-added"), &fields);
+        notify (data->session, TR_RPC_TORRENT_ADDED, tor);
+        tr_bencFree (&fields);
     }
-    else if( err == TR_PARSE_DUPLICATE )
+    else if (err == TR_PARSE_DUPLICATE)
     {
         result = "duplicate torrent";
     }
-    else if( err == TR_PARSE_ERR )
+    else if (err == TR_PARSE_ERR)
     {
         result = "invalid or corrupt torrent file";
     }
 
-    tr_idle_function_done( data, result );
+    tr_idle_function_done (data, result);
 }
 
 
@@ -1357,57 +1357,57 @@ struct add_torrent_idle_data
 };
 
 static void
-gotMetadataFromURL( tr_session       * session UNUSED,
+gotMetadataFromURL (tr_session       * session UNUSED,
                     bool               did_connect UNUSED,
                     bool               did_timeout UNUSED,
                     long               response_code,
                     const void       * response,
                     size_t             response_byte_count,
-                    void             * user_data )
+                    void             * user_data)
 {
     struct add_torrent_idle_data * data = user_data;
 
-    dbgmsg( "torrentAdd: HTTP response code was %ld (%s); response length was %zu bytes",
-            response_code, tr_webGetResponseStr( response_code ), response_byte_count );
+    dbgmsg ("torrentAdd: HTTP response code was %ld (%s); response length was %zu bytes",
+            response_code, tr_webGetResponseStr (response_code), response_byte_count);
 
-    if( response_code==200 || response_code==221 ) /* http or ftp success.. */
+    if (response_code==200 || response_code==221) /* http or ftp success.. */
     {
-        tr_ctorSetMetainfo( data->ctor, response, response_byte_count );
-        addTorrentImpl( data->data, data->ctor );
+        tr_ctorSetMetainfo (data->ctor, response, response_byte_count);
+        addTorrentImpl (data->data, data->ctor);
     }
     else
     {
         char result[1024];
-        tr_snprintf( result, sizeof( result ), "gotMetadataFromURL: http error %ld: %s",
-                     response_code, tr_webGetResponseStr( response_code ) );
-        tr_idle_function_done( data->data, result );
+        tr_snprintf (result, sizeof (result), "gotMetadataFromURL: http error %ld: %s",
+                     response_code, tr_webGetResponseStr (response_code));
+        tr_idle_function_done (data->data, result);
     }
 
-    tr_free( data );
+    tr_free (data);
 }
 
 static bool
-isCurlURL( const char * filename )
+isCurlURL (const char * filename)
 {
-    if( filename == NULL )
+    if (filename == NULL)
         return false;
 
-    return !strncmp( filename, "ftp://", 6 ) ||
-           !strncmp( filename, "http://", 7 ) ||
-           !strncmp( filename, "https://", 8 );
+    return !strncmp (filename, "ftp://", 6) ||
+           !strncmp (filename, "http://", 7) ||
+           !strncmp (filename, "https://", 8);
 }
 
 static tr_file_index_t*
-fileListFromList( tr_benc * list, tr_file_index_t * setmeCount )
+fileListFromList (tr_benc * list, tr_file_index_t * setmeCount)
 {
     size_t i;
-    const size_t childCount = tr_bencListSize( list );
+    const size_t childCount = tr_bencListSize (list);
     tr_file_index_t n = 0;
-    tr_file_index_t * files = tr_new0( tr_file_index_t, childCount );
+    tr_file_index_t * files = tr_new0 (tr_file_index_t, childCount);
 
-    for( i=0; i<childCount; ++i ) {
+    for (i=0; i<childCount; ++i) {
         int64_t intVal;
-        if( tr_bencGetInt( tr_bencListChild( list, i ), &intVal ) )
+        if (tr_bencGetInt (tr_bencListChild (list, i), &intVal))
             files[n++] = (tr_file_index_t)intVal;
     }
 
@@ -1416,19 +1416,19 @@ fileListFromList( tr_benc * list, tr_file_index_t * setmeCount )
 }
 
 static const char*
-torrentAdd( tr_session               * session,
+torrentAdd (tr_session               * session,
             tr_benc                  * args_in,
             tr_benc                  * args_out UNUSED,
-            struct tr_rpc_idle_data  * idle_data )
+            struct tr_rpc_idle_data  * idle_data)
 {
     const char * filename = NULL;
     const char * metainfo_base64 = NULL;
 
-    assert( idle_data != NULL );
+    assert (idle_data != NULL);
 
-    tr_bencDictFindStr( args_in, "filename", &filename );
-    tr_bencDictFindStr( args_in, "metainfo", &metainfo_base64 );
-    if( !filename && !metainfo_base64 )
+    tr_bencDictFindStr (args_in, "filename", &filename);
+    tr_bencDictFindStr (args_in, "metainfo", &metainfo_base64);
+    if (!filename && !metainfo_base64)
         return "no filename or metainfo specified";
     else
     {
@@ -1437,88 +1437,88 @@ torrentAdd( tr_session               * session,
         tr_benc    * l;
         const char * str;
         const char * cookies = NULL;
-        tr_ctor    * ctor = tr_ctorNew( session );
+        tr_ctor    * ctor = tr_ctorNew (session);
 
         /* set the optional arguments */
 
-        tr_bencDictFindStr( args_in, "cookies", &cookies );
+        tr_bencDictFindStr (args_in, "cookies", &cookies);
 
-        if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
-            tr_ctorSetDownloadDir( ctor, TR_FORCE, str );
+        if (tr_bencDictFindStr (args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str))
+            tr_ctorSetDownloadDir (ctor, TR_FORCE, str);
 
-        if( tr_bencDictFindBool( args_in, "paused", &boolVal ) )
-            tr_ctorSetPaused( ctor, TR_FORCE, boolVal );
+        if (tr_bencDictFindBool (args_in, "paused", &boolVal))
+            tr_ctorSetPaused (ctor, TR_FORCE, boolVal);
 
-        if( tr_bencDictFindInt( args_in, "peer-limit", &i ) )
-            tr_ctorSetPeerLimit( ctor, TR_FORCE, i );
+        if (tr_bencDictFindInt (args_in, "peer-limit", &i))
+            tr_ctorSetPeerLimit (ctor, TR_FORCE, i);
 
-        if( tr_bencDictFindInt( args_in, "bandwidthPriority", &i ) )
-            tr_ctorSetBandwidthPriority( ctor, i );
+        if (tr_bencDictFindInt (args_in, "bandwidthPriority", &i))
+            tr_ctorSetBandwidthPriority (ctor, i);
 
-        if( tr_bencDictFindList( args_in, "files-unwanted", &l ) ) {
+        if (tr_bencDictFindList (args_in, "files-unwanted", &l)) {
             tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList( l, &fileCount );
-            tr_ctorSetFilesWanted( ctor, files, fileCount, false );
-            tr_free( files );
+            tr_file_index_t * files = fileListFromList (l, &fileCount);
+            tr_ctorSetFilesWanted (ctor, files, fileCount, false);
+            tr_free (files);
         }
-        if( tr_bencDictFindList( args_in, "files-wanted", &l ) ) {
+        if (tr_bencDictFindList (args_in, "files-wanted", &l)) {
             tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList( l, &fileCount );
-            tr_ctorSetFilesWanted( ctor, files, fileCount, true );
-            tr_free( files );
+            tr_file_index_t * files = fileListFromList (l, &fileCount);
+            tr_ctorSetFilesWanted (ctor, files, fileCount, true);
+            tr_free (files);
         }
 
-        if( tr_bencDictFindList( args_in, "priority-low", &l ) ) {
+        if (tr_bencDictFindList (args_in, "priority-low", &l)) {
             tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList( l, &fileCount );
-            tr_ctorSetFilePriorities( ctor, files, fileCount, TR_PRI_LOW );
-            tr_free( files );
+            tr_file_index_t * files = fileListFromList (l, &fileCount);
+            tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_LOW);
+            tr_free (files);
         }
-        if( tr_bencDictFindList( args_in, "priority-normal", &l ) ) {
+        if (tr_bencDictFindList (args_in, "priority-normal", &l)) {
             tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList( l, &fileCount );
-            tr_ctorSetFilePriorities( ctor, files, fileCount, TR_PRI_NORMAL );
-            tr_free( files );
+            tr_file_index_t * files = fileListFromList (l, &fileCount);
+            tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_NORMAL);
+            tr_free (files);
         }
-        if( tr_bencDictFindList( args_in, "priority-high", &l ) ) {
+        if (tr_bencDictFindList (args_in, "priority-high", &l)) {
             tr_file_index_t fileCount;
-            tr_file_index_t * files = fileListFromList( l, &fileCount );
-            tr_ctorSetFilePriorities( ctor, files, fileCount, TR_PRI_HIGH );
-            tr_free( files );
+            tr_file_index_t * files = fileListFromList (l, &fileCount);
+            tr_ctorSetFilePriorities (ctor, files, fileCount, TR_PRI_HIGH);
+            tr_free (files);
         }
 
-        dbgmsg( "torrentAdd: filename is \"%s\"", filename ? filename : "(null)" );
+        dbgmsg ("torrentAdd: filename is \"%s\"", filename ? filename : " (null)");
 
-        if( isCurlURL( filename ) )
+        if (isCurlURL (filename))
         {
-            struct add_torrent_idle_data * d = tr_new0( struct add_torrent_idle_data, 1 );
+            struct add_torrent_idle_data * d = tr_new0 (struct add_torrent_idle_data, 1);
             d->data = idle_data;
             d->ctor = ctor;
-            tr_webRun( session, filename, NULL, cookies, gotMetadataFromURL, d );
+            tr_webRun (session, filename, NULL, cookies, gotMetadataFromURL, d);
         }
         else
         {
-            char * fname = tr_strstrip( tr_strdup( filename ) );
+            char * fname = tr_strstrip (tr_strdup (filename));
 
-            if( fname == NULL )
+            if (fname == NULL)
             {
                 int len;
-                char * metainfo = tr_base64_decode( metainfo_base64, -1, &len );
-                tr_ctorSetMetainfo( ctor, (uint8_t*)metainfo, len );
-                tr_free( metainfo );
+                char * metainfo = tr_base64_decode (metainfo_base64, -1, &len);
+                tr_ctorSetMetainfo (ctor, (uint8_t*)metainfo, len);
+                tr_free (metainfo);
             }
-            else if( !strncmp( fname, "magnet:?", 8 ) )
+            else if (!strncmp (fname, "magnet:?", 8))
             {
-                tr_ctorSetMetainfoFromMagnetLink( ctor, fname );
+                tr_ctorSetMetainfoFromMagnetLink (ctor, fname);
             }
             else
             {
-                tr_ctorSetMetainfoFromFile( ctor, fname );
+                tr_ctorSetMetainfoFromFile (ctor, fname);
             }
 
-            addTorrentImpl( idle_data, ctor );
+            addTorrentImpl (idle_data, ctor);
 
-            tr_free( fname );
+            tr_free (fname);
         }
 
     }
@@ -1531,119 +1531,119 @@ torrentAdd( tr_session               * session,
 ***/
 
 static const char*
-sessionSet( tr_session               * session,
+sessionSet (tr_session               * session,
             tr_benc                  * args_in,
             tr_benc                  * args_out UNUSED,
-            struct tr_rpc_idle_data  * idle_data UNUSED )
+            struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int64_t      i;
     double       d;
     bool         boolVal;
     const char * str;
 
-    assert( idle_data == NULL );
-
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i ) )
-        tr_sessionSetCacheLimit_MB( session, i );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &i ) )
-        tr_sessionSetAltSpeed_KBps( session, TR_UP, i );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &i ) )
-        tr_sessionSetAltSpeed_KBps( session, TR_DOWN, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal ) )
-        tr_sessionUseAltSpeed( session, boolVal );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i ) )
-        tr_sessionSetAltSpeedBegin( session, i );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i ) )
-        tr_sessionSetAltSpeedEnd( session, i );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &i ) )
-        tr_sessionSetAltSpeedDay( session, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal ) )
-        tr_sessionUseAltSpeedTime( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal ) )
-        tr_blocklistSetEnabled( session, boolVal );
-    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_BLOCKLIST_URL, &str ) )
-        tr_blocklistSetURL( session, str );
-    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
-        tr_sessionSetDownloadDir( session, str );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_QUEUE_STALLED_MINUTES, &i ) )
-        tr_sessionSetQueueStalledMinutes( session, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_QUEUE_STALLED_ENABLED, &boolVal ) )
-        tr_sessionSetQueueStalledEnabled( session, boolVal );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, &i ) )
-        tr_sessionSetQueueSize( session, TR_DOWN, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED, &boolVal ) )
-        tr_sessionSetQueueEnabled ( session, TR_DOWN, boolVal );
-    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_INCOMPLETE_DIR, &str ) )
-        tr_sessionSetIncompleteDir( session, str );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, &boolVal ) )
-        tr_sessionSetIncompleteDirEnabled( session, boolVal );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i ) )
-        tr_sessionSetPeerLimit( session, i );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i ) )
-        tr_sessionSetPeerLimitPerTorrent( session, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_PEX_ENABLED, &boolVal ) )
-        tr_sessionSetPexEnabled( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_DHT_ENABLED, &boolVal ) )
-        tr_sessionSetDHTEnabled( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_UTP_ENABLED, &boolVal ) )
-        tr_sessionSetUTPEnabled( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_LPD_ENABLED, &boolVal ) )
-        tr_sessionSetLPDEnabled( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, &boolVal ) )
-        tr_sessionSetPeerPortRandomOnStart( session, boolVal );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_PORT, &i ) )
-        tr_sessionSetPeerPort( session, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_PORT_FORWARDING, &boolVal ) )
-        tr_sessionSetPortForwardingEnabled( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_RENAME_PARTIAL_FILES, &boolVal ) )
-        tr_sessionSetIncompleteFileNamingEnabled( session, boolVal );
-    if( tr_bencDictFindReal( args_in, "seedRatioLimit", &d ) )
-        tr_sessionSetRatioLimit( session, d );
-    if( tr_bencDictFindBool( args_in, "seedRatioLimited", &boolVal ) )
-        tr_sessionSetRatioLimited( session, boolVal );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_IDLE_LIMIT, &i ) )
-        tr_sessionSetIdleLimit( session, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, &boolVal ) )
-        tr_sessionSetIdleLimited( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_START, &boolVal ) )
-        tr_sessionSetPaused( session, !boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_SEED_QUEUE_ENABLED, &boolVal ) )
-        tr_sessionSetQueueEnabled ( session, TR_UP, boolVal );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_SEED_QUEUE_SIZE, &i ) )
-        tr_sessionSetQueueSize( session, TR_UP, i );
-    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, &str ) )
-        tr_sessionSetTorrentDoneScript( session, str );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, &boolVal ) )
-        tr_sessionSetTorrentDoneScriptEnabled( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal ) )
-        tr_sessionSetDeleteSource( session, boolVal );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_DSPEED_KBps, &i ) )
-        tr_sessionSetSpeedLimit_KBps( session, TR_DOWN, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal ) )
-        tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
-    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_USPEED_KBps, &i ) )
-        tr_sessionSetSpeedLimit_KBps( session, TR_UP, i );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_USPEED_ENABLED, &boolVal ) )
-        tr_sessionLimitSpeed( session, TR_UP, boolVal );
-    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_ENCRYPTION, &str ) ) {
-        if( !strcmp( str, "required" ) )
-            tr_sessionSetEncryption( session, TR_ENCRYPTION_REQUIRED );
-        else if( !strcmp( str, "tolerated" ) )
-            tr_sessionSetEncryption( session, TR_CLEAR_PREFERRED );
+    assert (idle_data == NULL);
+
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i))
+        tr_sessionSetCacheLimit_MB (session, i);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &i))
+        tr_sessionSetAltSpeed_KBps (session, TR_UP, i);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &i))
+        tr_sessionSetAltSpeed_KBps (session, TR_DOWN, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal))
+        tr_sessionUseAltSpeed (session, boolVal);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i))
+        tr_sessionSetAltSpeedBegin (session, i);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i))
+        tr_sessionSetAltSpeedEnd (session, i);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &i))
+        tr_sessionSetAltSpeedDay (session, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal))
+        tr_sessionUseAltSpeedTime (session, boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal))
+        tr_blocklistSetEnabled (session, boolVal);
+    if (tr_bencDictFindStr (args_in, TR_PREFS_KEY_BLOCKLIST_URL, &str))
+        tr_blocklistSetURL (session, str);
+    if (tr_bencDictFindStr (args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str))
+        tr_sessionSetDownloadDir (session, str);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_QUEUE_STALLED_MINUTES, &i))
+        tr_sessionSetQueueStalledMinutes (session, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_QUEUE_STALLED_ENABLED, &boolVal))
+        tr_sessionSetQueueStalledEnabled (session, boolVal);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, &i))
+        tr_sessionSetQueueSize (session, TR_DOWN, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED, &boolVal))
+        tr_sessionSetQueueEnabled (session, TR_DOWN, boolVal);
+    if (tr_bencDictFindStr (args_in, TR_PREFS_KEY_INCOMPLETE_DIR, &str))
+        tr_sessionSetIncompleteDir (session, str);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, &boolVal))
+        tr_sessionSetIncompleteDirEnabled (session, boolVal);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i))
+        tr_sessionSetPeerLimit (session, i);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i))
+        tr_sessionSetPeerLimitPerTorrent (session, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_PEX_ENABLED, &boolVal))
+        tr_sessionSetPexEnabled (session, boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_DHT_ENABLED, &boolVal))
+        tr_sessionSetDHTEnabled (session, boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_UTP_ENABLED, &boolVal))
+        tr_sessionSetUTPEnabled (session, boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_LPD_ENABLED, &boolVal))
+        tr_sessionSetLPDEnabled (session, boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, &boolVal))
+        tr_sessionSetPeerPortRandomOnStart (session, boolVal);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_PEER_PORT, &i))
+        tr_sessionSetPeerPort (session, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_PORT_FORWARDING, &boolVal))
+        tr_sessionSetPortForwardingEnabled (session, boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_RENAME_PARTIAL_FILES, &boolVal))
+        tr_sessionSetIncompleteFileNamingEnabled (session, boolVal);
+    if (tr_bencDictFindReal (args_in, "seedRatioLimit", &d))
+        tr_sessionSetRatioLimit (session, d);
+    if (tr_bencDictFindBool (args_in, "seedRatioLimited", &boolVal))
+        tr_sessionSetRatioLimited (session, boolVal);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_IDLE_LIMIT, &i))
+        tr_sessionSetIdleLimit (session, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, &boolVal))
+        tr_sessionSetIdleLimited (session, boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_START, &boolVal))
+        tr_sessionSetPaused (session, !boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_SEED_QUEUE_ENABLED, &boolVal))
+        tr_sessionSetQueueEnabled (session, TR_UP, boolVal);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_SEED_QUEUE_SIZE, &i))
+        tr_sessionSetQueueSize (session, TR_UP, i);
+    if (tr_bencDictFindStr (args_in, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, &str))
+        tr_sessionSetTorrentDoneScript (session, str);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, &boolVal))
+        tr_sessionSetTorrentDoneScriptEnabled (session, boolVal);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal))
+        tr_sessionSetDeleteSource (session, boolVal);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_DSPEED_KBps, &i))
+        tr_sessionSetSpeedLimit_KBps (session, TR_DOWN, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal))
+        tr_sessionLimitSpeed (session, TR_DOWN, boolVal);
+    if (tr_bencDictFindInt (args_in, TR_PREFS_KEY_USPEED_KBps, &i))
+        tr_sessionSetSpeedLimit_KBps (session, TR_UP, i);
+    if (tr_bencDictFindBool (args_in, TR_PREFS_KEY_USPEED_ENABLED, &boolVal))
+        tr_sessionLimitSpeed (session, TR_UP, boolVal);
+    if (tr_bencDictFindStr (args_in, TR_PREFS_KEY_ENCRYPTION, &str)) {
+        if (!strcmp (str, "required"))
+            tr_sessionSetEncryption (session, TR_ENCRYPTION_REQUIRED);
+        else if (!strcmp (str, "tolerated"))
+            tr_sessionSetEncryption (session, TR_CLEAR_PREFERRED);
         else
-            tr_sessionSetEncryption( session, TR_ENCRYPTION_PREFERRED );
+            tr_sessionSetEncryption (session, TR_ENCRYPTION_PREFERRED);
     }
 
-    notify( session, TR_RPC_SESSION_CHANGED, NULL );
+    notify (session, TR_RPC_SESSION_CHANGED, NULL);
 
     return NULL;
 }
 
 static const char*
-sessionStats( tr_session               * session,
+sessionStats (tr_session               * session,
               tr_benc                  * args_in UNUSED,
               tr_benc                  * args_out,
-              struct tr_rpc_idle_data  * idle_data UNUSED )
+              struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     int running = 0;
     int total = 0;
@@ -1652,104 +1652,104 @@ sessionStats( tr_session               * session,
     tr_session_stats cumulativeStats = { 0.0f, 0, 0, 0, 0, 0 };
     tr_torrent * tor = NULL;
 
-    assert( idle_data == NULL );
+    assert (idle_data == NULL);
 
-    while(( tor = tr_torrentNext( session, tor ))) {
+    while ((tor = tr_torrentNext (session, tor))) {
         ++total;
-        if( tor->isRunning )
+        if (tor->isRunning)
             ++running;
     }
 
-    tr_sessionGetStats( session, &currentStats );
-    tr_sessionGetCumulativeStats( session, &cumulativeStats );
-
-    tr_bencDictAddInt ( args_out, "activeTorrentCount", running );
-    tr_bencDictAddReal( args_out, "downloadSpeed", tr_sessionGetPieceSpeed_Bps( session, TR_DOWN ) );
-    tr_bencDictAddInt ( args_out, "pausedTorrentCount", total - running );
-    tr_bencDictAddInt ( args_out, "torrentCount", total );
-    tr_bencDictAddReal( args_out, "uploadSpeed", tr_sessionGetPieceSpeed_Bps( session, TR_UP ) );
-
-    d = tr_bencDictAddDict( args_out, "cumulative-stats", 5 );
-    tr_bencDictAddInt( d, "downloadedBytes", cumulativeStats.downloadedBytes );
-    tr_bencDictAddInt( d, "filesAdded", cumulativeStats.filesAdded );
-    tr_bencDictAddInt( d, "secondsActive", cumulativeStats.secondsActive );
-    tr_bencDictAddInt( d, "sessionCount", cumulativeStats.sessionCount );
-    tr_bencDictAddInt( d, "uploadedBytes", cumulativeStats.uploadedBytes );
-
-    d = tr_bencDictAddDict( args_out, "current-stats", 5 );
-    tr_bencDictAddInt( d, "downloadedBytes", currentStats.downloadedBytes );
-    tr_bencDictAddInt( d, "filesAdded", currentStats.filesAdded );
-    tr_bencDictAddInt( d, "secondsActive", currentStats.secondsActive );
-    tr_bencDictAddInt( d, "sessionCount", currentStats.sessionCount );
-    tr_bencDictAddInt( d, "uploadedBytes", currentStats.uploadedBytes );
+    tr_sessionGetStats (session, &currentStats);
+    tr_sessionGetCumulativeStats (session, &cumulativeStats);
+
+    tr_bencDictAddInt (args_out, "activeTorrentCount", running);
+    tr_bencDictAddReal (args_out, "downloadSpeed", tr_sessionGetPieceSpeed_Bps (session, TR_DOWN));
+    tr_bencDictAddInt (args_out, "pausedTorrentCount", total - running);
+    tr_bencDictAddInt (args_out, "torrentCount", total);
+    tr_bencDictAddReal (args_out, "uploadSpeed", tr_sessionGetPieceSpeed_Bps (session, TR_UP));
+
+    d = tr_bencDictAddDict (args_out, "cumulative-stats", 5);
+    tr_bencDictAddInt (d, "downloadedBytes", cumulativeStats.downloadedBytes);
+    tr_bencDictAddInt (d, "filesAdded", cumulativeStats.filesAdded);
+    tr_bencDictAddInt (d, "secondsActive", cumulativeStats.secondsActive);
+    tr_bencDictAddInt (d, "sessionCount", cumulativeStats.sessionCount);
+    tr_bencDictAddInt (d, "uploadedBytes", cumulativeStats.uploadedBytes);
+
+    d = tr_bencDictAddDict (args_out, "current-stats", 5);
+    tr_bencDictAddInt (d, "downloadedBytes", currentStats.downloadedBytes);
+    tr_bencDictAddInt (d, "filesAdded", currentStats.filesAdded);
+    tr_bencDictAddInt (d, "secondsActive", currentStats.secondsActive);
+    tr_bencDictAddInt (d, "sessionCount", currentStats.sessionCount);
+    tr_bencDictAddInt (d, "uploadedBytes", currentStats.uploadedBytes);
 
     return NULL;
 }
 
 static const char*
-sessionGet( tr_session               * s,
+sessionGet (tr_session               * s,
             tr_benc                  * args_in UNUSED,
             tr_benc                  * args_out,
-            struct tr_rpc_idle_data  * idle_data UNUSED )
+            struct tr_rpc_idle_data  * idle_data UNUSED)
 {
     const char * str;
     tr_benc * d = args_out;
 
-    assert( idle_data == NULL );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP_KBps, tr_sessionGetAltSpeed_KBps(s,TR_UP) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, tr_sessionGetAltSpeed_KBps(s,TR_DOWN) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed(s) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin(s) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,tr_sessionGetAltSpeedEnd(s) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,tr_sessionGetAltSpeedDay(s) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime(s) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_BLOCKLIST_URL, tr_blocklistGetURL( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, tr_sessionGetCacheLimit_MB( s ) );
-    tr_bencDictAddInt ( d, "blocklist-size", tr_blocklistGetRuleCount( s ) );
-    tr_bencDictAddStr ( d, "config-dir", tr_sessionGetConfigDir( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED, tr_sessionGetQueueEnabled( s, TR_DOWN ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, tr_sessionGetQueueSize( s, TR_DOWN ) );
-    tr_bencDictAddInt ( d, "download-dir-free-space",  tr_sessionGetDownloadDirFreeSpace( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, tr_sessionGetPeerLimitPerTorrent( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR, tr_sessionGetIncompleteDir( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, tr_sessionIsIncompleteDirEnabled( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_UTP_ENABLED, tr_sessionIsUTPEnabled( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED, tr_sessionIsDHTEnabled( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED, tr_sessionIsLPDEnabled( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, tr_sessionGetPeerPortRandomOnStart( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RENAME_PARTIAL_FILES, tr_sessionIsIncompleteFileNamingEnabled( s ) );
-    tr_bencDictAddInt ( d, "rpc-version", RPC_VERSION );
-    tr_bencDictAddInt ( d, "rpc-version-minimum", RPC_VERSION_MIN );
-    tr_bencDictAddReal( d, "seedRatioLimit", tr_sessionGetRatioLimit( s ) );
-    tr_bencDictAddBool( d, "seedRatioLimited", tr_sessionIsRatioLimited( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_IDLE_LIMIT, tr_sessionGetIdleLimit( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, tr_sessionIsIdleLimited( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_SEED_QUEUE_ENABLED, tr_sessionGetQueueEnabled( s, TR_UP ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_SEED_QUEUE_SIZE, tr_sessionGetQueueSize( s, TR_UP ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_START, !tr_sessionGetPaused( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_TRASH_ORIGINAL, tr_sessionGetDeleteSource( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED_KBps, tr_sessionGetSpeedLimit_KBps( s, TR_UP ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_UP ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_KBps, tr_sessionGetSpeedLimit_KBps( s, TR_DOWN ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_DOWN ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, tr_sessionGetTorrentDoneScript( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, tr_sessionIsTorrentDoneScriptEnabled( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES, tr_sessionGetQueueStalledMinutes( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED, tr_sessionGetQueueStalledEnabled( s ) );
-    tr_formatter_get_units( tr_bencDictAddDict( d, "units", 0 ) );
-    tr_bencDictAddStr ( d, "version", LONG_VERSION_STRING );
-    switch( tr_sessionGetEncryption( s ) ) {
+    assert (idle_data == NULL);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_UP_KBps, tr_sessionGetAltSpeed_KBps (s,TR_UP));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, tr_sessionGetAltSpeed_KBps (s,TR_DOWN));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_END,tr_sessionGetAltSpeedEnd (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,tr_sessionGetAltSpeedDay (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_BLOCKLIST_URL, tr_blocklistGetURL (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, tr_sessionGetCacheLimit_MB (s));
+    tr_bencDictAddInt (d, "blocklist-size", tr_blocklistGetRuleCount (s));
+    tr_bencDictAddStr (d, "config-dir", tr_sessionGetConfigDir (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED, tr_sessionGetQueueEnabled (s, TR_DOWN));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, tr_sessionGetQueueSize (s, TR_DOWN));
+    tr_bencDictAddInt (d, "download-dir-free-space",  tr_sessionGetDownloadDirFreeSpace (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, tr_sessionGetPeerLimitPerTorrent (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_INCOMPLETE_DIR, tr_sessionGetIncompleteDir (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, tr_sessionIsIncompleteDirEnabled (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PEX_ENABLED, tr_sessionIsPexEnabled (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_UTP_ENABLED, tr_sessionIsUTPEnabled (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DHT_ENABLED, tr_sessionIsDHTEnabled (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_LPD_ENABLED, tr_sessionIsLPDEnabled (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, tr_sessionGetPeerPortRandomOnStart (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RENAME_PARTIAL_FILES, tr_sessionIsIncompleteFileNamingEnabled (s));
+    tr_bencDictAddInt (d, "rpc-version", RPC_VERSION);
+    tr_bencDictAddInt (d, "rpc-version-minimum", RPC_VERSION_MIN);
+    tr_bencDictAddReal (d, "seedRatioLimit", tr_sessionGetRatioLimit (s));
+    tr_bencDictAddBool (d, "seedRatioLimited", tr_sessionIsRatioLimited (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_IDLE_LIMIT, tr_sessionGetIdleLimit (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, tr_sessionIsIdleLimited (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_SEED_QUEUE_ENABLED, tr_sessionGetQueueEnabled (s, TR_UP));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_SEED_QUEUE_SIZE, tr_sessionGetQueueSize (s, TR_UP));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_START, !tr_sessionGetPaused (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_TRASH_ORIGINAL, tr_sessionGetDeleteSource (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_USPEED_KBps, tr_sessionGetSpeedLimit_KBps (s, TR_UP));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, tr_sessionIsSpeedLimited (s, TR_UP));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps, tr_sessionGetSpeedLimit_KBps (s, TR_DOWN));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimited (s, TR_DOWN));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, tr_sessionGetTorrentDoneScript (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, tr_sessionIsTorrentDoneScriptEnabled (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES, tr_sessionGetQueueStalledMinutes (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED, tr_sessionGetQueueStalledEnabled (s));
+    tr_formatter_get_units (tr_bencDictAddDict (d, "units", 0));
+    tr_bencDictAddStr (d, "version", LONG_VERSION_STRING);
+    switch (tr_sessionGetEncryption (s)) {
         case TR_CLEAR_PREFERRED: str = "tolerated"; break;
         case TR_ENCRYPTION_REQUIRED: str = "required"; break;
         default: str = "preferred"; break;
     }
-    tr_bencDictAddStr( d, TR_PREFS_KEY_ENCRYPTION, str );
+    tr_bencDictAddStr (d, TR_PREFS_KEY_ENCRYPTION, str);
 
     return NULL;
 }
@@ -1759,12 +1759,12 @@ sessionGet( tr_session               * s,
 ***/
 
 static const char*
-sessionClose( tr_session               * session,
+sessionClose (tr_session               * session,
               tr_benc                  * args_in UNUSED,
               tr_benc                  * args_out UNUSED,
-              struct tr_rpc_idle_data  * idle_data UNUSED )
+              struct tr_rpc_idle_data  * idle_data UNUSED)
 {
-    notify( session, TR_RPC_SESSION_CLOSE, NULL );
+    notify (session, TR_RPC_SESSION_CLOSE, NULL);
     return NULL;
 }
 
@@ -1772,7 +1772,7 @@ sessionClose( tr_session               * session,
 ****
 ***/
 
-typedef const char* ( *handler )( tr_session*, tr_benc*, tr_benc*, struct tr_rpc_idle_data * );
+typedef const char* (*handler)(tr_session*, tr_benc*, tr_benc*, struct tr_rpc_idle_data *);
 
 static struct method
 {
@@ -1805,113 +1805,113 @@ methods[] =
 };
 
 static void
-noop_response_callback( tr_session       * session UNUSED,
+noop_response_callback (tr_session       * session UNUSED,
                         struct evbuffer  * response UNUSED,
-                        void             * user_data UNUSED )
+                        void             * user_data UNUSED)
 {
 }
 
 static void
-request_exec( tr_session             * session,
+request_exec (tr_session             * session,
               tr_benc                * request,
               tr_rpc_response_func     callback,
-              void                   * callback_user_data )
+              void                   * callback_user_data)
 {
     int i;
     const char * str;
-    tr_benc * args_in = tr_bencDictFind( request, "arguments" );
+    tr_benc * args_in = tr_bencDictFind (request, "arguments");
     const char * result = NULL;
 
-    if( callback == NULL )
+    if (callback == NULL)
         callback = noop_response_callback;
 
     /* parse the request */
-    if( !tr_bencDictFindStr( request, "method", &str ) )
+    if (!tr_bencDictFindStr (request, "method", &str))
         result = "no method name";
     else {
-        const int n = TR_N_ELEMENTS( methods );
-        for( i = 0; i < n; ++i )
-            if( !strcmp( str, methods[i].name ) )
+        const int n = TR_N_ELEMENTS (methods);
+        for (i = 0; i < n; ++i)
+            if (!strcmp (str, methods[i].name))
                 break;
-        if( i ==n )
+        if (i ==n)
             result = "method name not recognized";
     }
 
     /* if we couldn't figure out which method to use, return an error */
-    if( result != NULL )
+    if (result != NULL)
     {
         int64_t tag;
         tr_benc response;
         struct evbuffer * buf;
 
-        tr_bencInitDict( &response, 3 );
-        tr_bencDictAddDict( &response, "arguments", 0 );
-        tr_bencDictAddStr( &response, "result", result );
-        if( tr_bencDictFindInt( request, "tag", &tag ) )
-            tr_bencDictAddInt( &response, "tag", tag );
+        tr_bencInitDict (&response, 3);
+        tr_bencDictAddDict (&response, "arguments", 0);
+        tr_bencDictAddStr (&response, "result", result);
+        if (tr_bencDictFindInt (request, "tag", &tag))
+            tr_bencDictAddInt (&response, "tag", tag);
 
-        buf = tr_bencToBuf( &response, TR_FMT_JSON_LEAN );
-        (*callback)( session, buf, callback_user_data );
-        evbuffer_free( buf );
+        buf = tr_bencToBuf (&response, TR_FMT_JSON_LEAN);
+      (*callback)(session, buf, callback_user_data);
+        evbuffer_free (buf);
 
-        tr_bencFree( &response );
+        tr_bencFree (&response);
     }
-    else if( methods[i].immediate )
+    else if (methods[i].immediate)
     {
         int64_t tag;
         tr_benc response;
         tr_benc * args_out;
         struct evbuffer * buf;
 
-        tr_bencInitDict( &response, 3 );
-        args_out = tr_bencDictAddDict( &response, "arguments", 0 );
-        result = (*methods[i].func)( session, args_in, args_out, NULL );
-        if( result == NULL )
+        tr_bencInitDict (&response, 3);
+        args_out = tr_bencDictAddDict (&response, "arguments", 0);
+        result = (*methods[i].func)(session, args_in, args_out, NULL);
+        if (result == NULL)
             result = "success";
-        tr_bencDictAddStr( &response, "result", result );
-        if( tr_bencDictFindInt( request, "tag", &tag ) )
-            tr_bencDictAddInt( &response, "tag", tag );
+        tr_bencDictAddStr (&response, "result", result);
+        if (tr_bencDictFindInt (request, "tag", &tag))
+            tr_bencDictAddInt (&response, "tag", tag);
 
-        buf = tr_bencToBuf( &response, TR_FMT_JSON_LEAN );
-        (*callback)( session, buf, callback_user_data );
-        evbuffer_free( buf );
+        buf = tr_bencToBuf (&response, TR_FMT_JSON_LEAN);
+      (*callback)(session, buf, callback_user_data);
+        evbuffer_free (buf);
 
-        tr_bencFree( &response );
+        tr_bencFree (&response);
     }
     else
     {
         int64_t tag;
-        struct tr_rpc_idle_data * data = tr_new0( struct tr_rpc_idle_data, 1 );
+        struct tr_rpc_idle_data * data = tr_new0 (struct tr_rpc_idle_data, 1);
         data->session = session;
-        data->response = tr_new0( tr_benc, 1 );
-        tr_bencInitDict( data->response, 3 );
-        if( tr_bencDictFindInt( request, "tag", &tag ) )
-            tr_bencDictAddInt( data->response, "tag", tag );
-        data->args_out = tr_bencDictAddDict( data->response, "arguments", 0 );
+        data->response = tr_new0 (tr_benc, 1);
+        tr_bencInitDict (data->response, 3);
+        if (tr_bencDictFindInt (request, "tag", &tag))
+            tr_bencDictAddInt (data->response, "tag", tag);
+        data->args_out = tr_bencDictAddDict (data->response, "arguments", 0);
         data->callback = callback;
         data->callback_user_data = callback_user_data;
-        (*methods[i].func)( session, args_in, data->args_out, data );
+      (*methods[i].func)(session, args_in, data->args_out, data);
     }
 }
 
 void
-tr_rpc_request_exec_json( tr_session            * session,
+tr_rpc_request_exec_json (tr_session            * session,
                           const void            * request_json,
                           int                     request_len,
                           tr_rpc_response_func    callback,
-                          void                  * callback_user_data )
+                          void                  * callback_user_data)
 {
     tr_benc top;
     int have_content;
 
-    if( request_len < 0 )
-        request_len = strlen( request_json );
+    if (request_len < 0)
+        request_len = strlen (request_json);
 
-    have_content = !tr_jsonParse( "rpc", request_json, request_len, &top, NULL );
-    request_exec( session, have_content ? &top : NULL, callback, callback_user_data );
+    have_content = !tr_jsonParse ("rpc", request_json, request_len, &top, NULL);
+    request_exec (session, have_content ? &top : NULL, callback, callback_user_data);
 
-    if( have_content )
-        tr_bencFree( &top );
+    if (have_content)
+        tr_bencFree (&top);
 }
 
 /**
@@ -1924,66 +1924,66 @@ tr_rpc_request_exec_json( tr_session            * session,
  * - all other values are strings
  */
 void
-tr_rpc_parse_list_str( tr_benc     * setme,
+tr_rpc_parse_list_str (tr_benc     * setme,
                        const char  * str,
-                       int           len )
+                       int           len)
 
 {
     int valueCount;
-    int * values = tr_parseNumberRange( str, len, &valueCount );
+    int * values = tr_parseNumberRange (str, len, &valueCount);
 
-    if( valueCount == 0 )
-        tr_bencInitStr( setme, str, len );
-    else if( valueCount == 1 )
-        tr_bencInitInt( setme, values[0] );
+    if (valueCount == 0)
+        tr_bencInitStr (setme, str, len);
+    else if (valueCount == 1)
+        tr_bencInitInt (setme, values[0]);
     else {
         int i;
-        tr_bencInitList( setme, valueCount );
-        for( i=0; i<valueCount; ++i )
-            tr_bencListAddInt( setme, values[i] );
+        tr_bencInitList (setme, valueCount);
+        for (i=0; i<valueCount; ++i)
+            tr_bencListAddInt (setme, values[i]);
     }
 
-    tr_free( values );
+    tr_free (values);
 }
 
 void
-tr_rpc_request_exec_uri( tr_session           * session,
+tr_rpc_request_exec_uri (tr_session           * session,
                          const void           * request_uri,
                          int                    request_len,
                          tr_rpc_response_func   callback,
-                         void                 * callback_user_data )
+                         void                 * callback_user_data)
 {
     tr_benc      top, * args;
-    char *       request = tr_strndup( request_uri, request_len );
+    char *       request = tr_strndup (request_uri, request_len);
     const char * pch;
 
-    tr_bencInitDict( &top, 3 );
-    args = tr_bencDictAddDict( &top, "arguments", 0 );
+    tr_bencInitDict (&top, 3);
+    args = tr_bencDictAddDict (&top, "arguments", 0);
 
-    pch = strchr( request, '?' );
-    if( !pch ) pch = request;
-    while( pch )
+    pch = strchr (request, '?');
+    if (!pch) pch = request;
+    while (pch)
     {
-        const char * delim = strchr( pch, '=' );
-        const char * next = strchr( pch, '&' );
-        if( delim )
+        const char * delim = strchr (pch, '=');
+        const char * next = strchr (pch, '&');
+        if (delim)
         {
-            char *    key = tr_strndup( pch, delim - pch );
-            int       isArg = strcmp( key, "method" ) && strcmp( key, "tag" );
+            char *    key = tr_strndup (pch, delim - pch);
+            int       isArg = strcmp (key, "method") && strcmp (key, "tag");
             tr_benc * parent = isArg ? args : &top;
-            tr_rpc_parse_list_str( tr_bencDictAdd( parent, key ),
+            tr_rpc_parse_list_str (tr_bencDictAdd (parent, key),
                                   delim + 1,
                                   next ? (size_t)(
                                        next -
-                                      ( delim + 1 ) ) : strlen( delim + 1 ) );
-            tr_free( key );
+                                    (delim + 1)) : strlen (delim + 1));
+            tr_free (key);
         }
         pch = next ? next + 1 : NULL;
     }
 
-    request_exec( session, &top, callback, callback_user_data );
+    request_exec (session, &top, callback, callback_user_data);
 
     /* cleanup */
-    tr_bencFree( &top );
-    tr_free( request );
+    tr_bencFree (&top);
+    tr_free (request);
 }
diff --git a/libtransmission/rpcimpl.h b/libtransmission/rpcimpl.h
index 7041482ce..ec83bf373 100644
--- a/libtransmission/rpcimpl.h
+++ b/libtransmission/rpcimpl.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -24,27 +24,27 @@ extern "C" {
 struct tr_benc;
 struct evbuffer;
 
-/* FIXME(libevent2): make "response" an evbuffer and remove response_len */
-typedef void( *tr_rpc_response_func )( tr_session      * session,
+/* FIXME (libevent2): make "response" an evbuffer and remove response_len */
+typedef void (*tr_rpc_response_func)(tr_session      * session,
                                        struct evbuffer * response,
-                                       void            * user_data );
+                                       void            * user_data);
 /* http://www.json.org/ */
-void tr_rpc_request_exec_json( tr_session            * session,
+void tr_rpc_request_exec_json (tr_session            * session,
                                const void            * request_json,
                                int                     request_len,
                                tr_rpc_response_func    callback,
-                               void                  * callback_user_data );
+                               void                  * callback_user_data);
 
 /* see the RPC spec's "Request URI Notation" section */
-void tr_rpc_request_exec_uri( tr_session           * session,
+void tr_rpc_request_exec_uri (tr_session           * session,
                               const void           * request_uri,
                               int                    request_len,
                               tr_rpc_response_func   callback,
-                              void                 * callback_user_data );
+                              void                 * callback_user_data);
 
-void tr_rpc_parse_list_str( struct tr_benc * setme,
+void tr_rpc_parse_list_str (struct tr_benc * setme,
                             const char     * list_str,
-                            int              list_str_len );
+                            int              list_str_len);
 
 #ifdef __cplusplus
 }
diff --git a/libtransmission/session.c b/libtransmission/session.c
index c13503262..0d857cb67 100644
--- a/libtransmission/session.c
+++ b/libtransmission/session.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -16,12 +16,12 @@
 #include <string.h> /* memcpy */
 
 #include <signal.h>
-#include <sys/types.h> /* stat(), umask() */
-#include <sys/stat.h> /* stat(), umask() */
+#include <sys/types.h> /* stat (), umask () */
+#include <sys/stat.h> /* stat (), umask () */
 #include <unistd.h> /* stat */
 #include <dirent.h> /* opendir */
 
-#include <event2/dns.h> /* evdns_base_free() */
+#include <event2/dns.h> /* evdns_base_free () */
 #include <event2/event.h>
 
 #include <libutp/utp.h>
@@ -39,13 +39,13 @@
 #include "net.h"
 #include "peer-io.h"
 #include "peer-mgr.h"
-#include "platform.h" /* tr_lock, tr_getTorrentDir(), tr_getFreeSpace() */
+#include "platform.h" /* tr_lock, tr_getTorrentDir (), tr_getFreeSpace () */
 #include "port-forwarding.h"
 #include "rpc-server.h"
 #include "session.h"
 #include "stats.h"
 #include "torrent.h"
-#include "tr-dht.h" /* tr_dhtUpkeep() */
+#include "tr-dht.h" /* tr_dhtUpkeep () */
 #include "tr-udp.h"
 #include "tr-utp.h"
 #include "tr-lpd.h"
@@ -68,16 +68,18 @@ enum
 };
 
 
-#define dbgmsg( ... ) \
-    do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
-    } while( 0 )
+#define dbgmsg(...) \
+  do \
+    { \
+      if (tr_deepLoggingIsActive ()) \
+        tr_deepLog (__FILE__, __LINE__, NULL, __VA_ARGS__); \
+    } \
+  while (0)
 
 static tr_port
-getRandomPort( tr_session * s )
+getRandomPort (tr_session * s)
 {
-    return tr_cryptoWeakRandInt( s->randomPortHigh - s->randomPortLow + 1) + s->randomPortLow;
+    return tr_cryptoWeakRandInt (s->randomPortHigh - s->randomPortLow + 1) + s->randomPortLow;
 }
 
 /* Generate a peer id : "-TRxyzb-" + 12 random alphanumeric
@@ -85,7 +87,7 @@ getRandomPort( tr_session * s )
    minor version number, z is the maintenance number, and b
    designates beta (Azureus-style) */
 void
-tr_peerIdInit( uint8_t * buf )
+tr_peerIdInit (uint8_t * buf)
 {
     int          i;
     int          val;
@@ -93,16 +95,16 @@ tr_peerIdInit( uint8_t * buf )
     const char * pool = "0123456789abcdefghijklmnopqrstuvwxyz";
     const int    base = 36;
 
-    memcpy( buf, PEERID_PREFIX, 8 );
+    memcpy (buf, PEERID_PREFIX, 8);
 
-    tr_cryptoRandBuf( buf+8, 11 );
-    for( i=8; i<19; ++i ) {
+    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;
+    val = total % base ? base - (total % base) : 0;
     buf[19] = pool[val];
     buf[20] = '\0';
 }
@@ -112,21 +114,21 @@ tr_peerIdInit( uint8_t * buf )
 ***/
 
 tr_encryption_mode
-tr_sessionGetEncryption( tr_session * session )
+tr_sessionGetEncryption (tr_session * session)
 {
-    assert( session );
+    assert (session);
 
     return session->encryptionMode;
 }
 
 void
-tr_sessionSetEncryption( tr_session *       session,
-                         tr_encryption_mode mode )
+tr_sessionSetEncryption (tr_session *       session,
+                         tr_encryption_mode mode)
 {
-    assert( session );
-    assert( mode == TR_ENCRYPTION_PREFERRED
+    assert (session);
+    assert (mode == TR_ENCRYPTION_PREFERRED
           || mode == TR_ENCRYPTION_REQUIRED
-          || mode == TR_CLEAR_PREFERRED );
+          || mode == TR_CLEAR_PREFERRED);
 
     session->encryptionMode = mode;
 }
@@ -144,83 +146,83 @@ struct tr_bindinfo
 
 
 static void
-close_bindinfo( struct tr_bindinfo * b )
+close_bindinfo (struct tr_bindinfo * b)
 {
-    if( ( b != NULL ) && ( b->socket >=0 ) )
+    if ((b != NULL) && (b->socket >=0))
     {
-        event_free( b->ev );
+        event_free (b->ev);
         b->ev = NULL;
-        tr_netCloseSocket( b->socket );
+        tr_netCloseSocket (b->socket);
     }
 }
 
 static void
-close_incoming_peer_port( tr_session * session )
+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);
 }
 
 static void
-free_incoming_peer_port( tr_session * session )
+free_incoming_peer_port (tr_session * session)
 {
-    close_bindinfo( session->public_ipv4 );
-    tr_free( session->public_ipv4 );
+    close_bindinfo (session->public_ipv4);
+    tr_free (session->public_ipv4);
     session->public_ipv4 = NULL;
 
-    close_bindinfo( session->public_ipv6 );
-    tr_free( session->public_ipv6 );
+    close_bindinfo (session->public_ipv6);
+    tr_free (session->public_ipv6);
     session->public_ipv6 = NULL;
 }
 
 static void
-accept_incoming_peer( int fd, short what UNUSED, void * vsession )
+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_deepLog( __FILE__, __LINE__, NULL, "new incoming connection %d (%s)",
-                   clientSocket, tr_peerIoAddrStr( &clientAddr, clientPort ) );
-        tr_peerMgrAddIncoming( session->peerMgr, &clientAddr, clientPort,
-                               clientSocket, NULL );
+    clientSocket = tr_netAccept (session, fd, &clientAddr, &clientPort);
+    if (clientSocket > 0) {
+        tr_deepLog (__FILE__, __LINE__, NULL, "new incoming connection %d (%s)",
+                   clientSocket, tr_peerIoAddrStr (&clientAddr, clientPort));
+        tr_peerMgrAddIncoming (session->peerMgr, &clientAddr, clientPort,
+                               clientSocket, NULL);
     }
 }
 
 static void
-open_incoming_peer_port( tr_session * session )
+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 );
+    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 ) ) {
+    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 );
+        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);
         }
     }
 }
 
 const tr_address*
-tr_sessionGetPublicAddress( const tr_session * session, int tr_af_type, bool * is_default_value )
+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 )
+    switch (tr_af_type)
     {
         case TR_AF_INET:
             bindinfo = session->public_ipv4;
@@ -238,8 +240,8 @@ tr_sessionGetPublicAddress( const tr_session * session, int tr_af_type, bool * i
             break;
     }
 
-    if( is_default_value && bindinfo )
-        *is_default_value = !tr_strcmp0( default_value, tr_address_to_string( &bindinfo->addr ) );
+    if (is_default_value && bindinfo)
+        *is_default_value = !tr_strcmp0 (default_value, tr_address_to_string (&bindinfo->addr));
 
     return bindinfo ? &bindinfo->addr : NULL;
 }
@@ -255,194 +257,194 @@ tr_sessionGetPublicAddress( const tr_session * session, int tr_af_type, bool * i
 #endif
 
 static int
-parse_tos( const char *str )
+parse_tos (const char *str)
 {
     char *p;
     int value;
 
-    if( !evutil_ascii_strcasecmp( str, "" ) )
+    if (!evutil_ascii_strcasecmp (str, ""))
         return 0;
-    if( !evutil_ascii_strcasecmp( str, "default" ) )
+    if (!evutil_ascii_strcasecmp (str, "default"))
         return 0;
 
-    if( !evutil_ascii_strcasecmp( str, "lowcost" ) )
+    if (!evutil_ascii_strcasecmp (str, "lowcost"))
         return 0x10;
-    if( !evutil_ascii_strcasecmp( str, "mincost" ) )
+    if (!evutil_ascii_strcasecmp (str, "mincost"))
         return 0x10;
 
-    if( !evutil_ascii_strcasecmp( str, "throughput" ) )
+    if (!evutil_ascii_strcasecmp (str, "throughput"))
         return 0x08;
-    if( !evutil_ascii_strcasecmp( str, "reliability" ) )
+    if (!evutil_ascii_strcasecmp (str, "reliability"))
         return 0x04;
-    if( !evutil_ascii_strcasecmp( str, "lowdelay" ) )
+    if (!evutil_ascii_strcasecmp (str, "lowdelay"))
         return 0x02;
 
-    value = strtol( str, &p, 0 );
-    if( !p || ( p == str ) )
+    value = strtol (str, &p, 0);
+    if (!p || (p == str))
         return 0;
 
     return value;
 }
 
 static const char *
-format_tos(int value)
+format_tos (int value)
 {
     static char buf[8];
-    switch(value) {
+    switch (value) {
     case 0: return "default";
     case 0x10: return "lowcost";
     case 0x08: return "throughput";
     case 0x04: return "reliability";
     case 0x02: return "lowdelay";
     default:
-        snprintf(buf, 8, "%d", value);
+        snprintf (buf, 8, "%d", value);
         return buf;
     }
 }
 
 void
-tr_sessionGetDefaultSettings( tr_benc * d )
-{
-    assert( tr_bencIsDict( d ) );
-
-    tr_bencDictReserve( d, 60 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,               false );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_BLOCKLIST_URL,                   "http://www.example.com/blocklist" );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,               DEFAULT_CACHE_SIZE_MB );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,                     true );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_UTP_ENABLED,                     true );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED,                     false );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,                    tr_getDefaultDownloadDir( ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_KBps,                     100 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,                  false );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,                      TR_DEFAULT_ENCRYPTION );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_IDLE_LIMIT,                      30 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,              false );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR,                  tr_getDefaultDownloadDir( ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,          false );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL,                        TR_MSG_INF );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE,             5 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED,          true );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,               atoi( TR_DEFAULT_PEER_LIMIT_GLOBAL_STR ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,              atoi( TR_DEFAULT_PEER_LIMIT_TORRENT_STR ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT,                       atoi( TR_DEFAULT_PEER_PORT_STR ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START,       false );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,            49152 );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,           65535 );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_PEER_SOCKET_TOS,                 TR_DEFAULT_PEER_SOCKET_TOS_STR );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED,                     true );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING,                 true );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PREALLOCATION,                   TR_PREALLOCATE_SPARSE );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PREFETCH_ENABLED,                DEFAULT_PREFETCH_ENABLED );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED,           true );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES,           30 );
-    tr_bencDictAddReal( d, TR_PREFS_KEY_RATIO,                           2.0 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RATIO_ENABLED,                   false );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RENAME_PARTIAL_FILES,            true );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,               false );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_BIND_ADDRESS,                "0.0.0.0" );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_ENABLED,                     false );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_PASSWORD,                    "" );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_USERNAME,                    "" );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_WHITELIST,                   TR_DEFAULT_RPC_WHITELIST );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,           true );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_RPC_PORT,                        atoi( TR_DEFAULT_RPC_PORT_STR ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_URL,                         TR_DEFAULT_RPC_URL_STR );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS,          true );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME,    "" );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED,     false );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_SEED_QUEUE_SIZE,                 10 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_SEED_QUEUE_ENABLED,              false );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,               false );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP_KBps,               50 ); /* half the regular */
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps,             50 ); /* half the regular */
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,            540 ); /* 9am */
-    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,          false );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,              1020 ); /* 5pm */
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,              TR_SCHED_ALL );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED_KBps,                     100 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED,                  false );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_UMASK,                           022 );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT,        14 );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,               TR_DEFAULT_BIND_ADDRESS_IPV4 );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,               TR_DEFAULT_BIND_ADDRESS_IPV6 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_START,                           true );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_TRASH_ORIGINAL,                  false );
+tr_sessionGetDefaultSettings (tr_benc * d)
+{
+    assert (tr_bencIsDict (d));
+
+    tr_bencDictReserve (d, 60);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED,               false);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_BLOCKLIST_URL,                   "http://www.example.com/blocklist");
+    tr_bencDictAddInt (d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,               DEFAULT_CACHE_SIZE_MB);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DHT_ENABLED,                     true);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_UTP_ENABLED,                     true);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_LPD_ENABLED,                     false);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR,                    tr_getDefaultDownloadDir ());
+    tr_bencDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps,                     100);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED,                  false);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION,                      TR_DEFAULT_ENCRYPTION);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_IDLE_LIMIT,                      30);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,              false);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_INCOMPLETE_DIR,                  tr_getDefaultDownloadDir ());
+    tr_bencDictAddBool (d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,          false);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_MSGLEVEL,                        TR_MSG_INF);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE,             5);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED,          true);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,               atoi (TR_DEFAULT_PEER_LIMIT_GLOBAL_STR));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,              atoi (TR_DEFAULT_PEER_LIMIT_TORRENT_STR));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT,                       atoi (TR_DEFAULT_PEER_PORT_STR));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START,       false);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,            49152);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,           65535);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_PEER_SOCKET_TOS,                 TR_DEFAULT_PEER_SOCKET_TOS_STR);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PEX_ENABLED,                     true);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING,                 true);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PREALLOCATION,                   TR_PREALLOCATE_SPARSE);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PREFETCH_ENABLED,                DEFAULT_PREFETCH_ENABLED);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED,           true);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES,           30);
+    tr_bencDictAddReal (d, TR_PREFS_KEY_RATIO,                           2.0);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RATIO_ENABLED,                   false);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RENAME_PARTIAL_FILES,            true);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,               false);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_BIND_ADDRESS,                "0.0.0.0");
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_ENABLED,                     false);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_PASSWORD,                    "");
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_USERNAME,                    "");
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_WHITELIST,                   TR_DEFAULT_RPC_WHITELIST);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,           true);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_RPC_PORT,                        atoi (TR_DEFAULT_RPC_PORT_STR));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_URL,                         TR_DEFAULT_RPC_URL_STR);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS,          true);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME,    "");
+    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED,     false);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_SEED_QUEUE_SIZE,                 10);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_SEED_QUEUE_ENABLED,              false);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_ENABLED,               false);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_UP_KBps,               50); /* half the regular */
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps,             50); /* half the regular */
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,            540); /* 9am */
+    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,          false);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_END,              1020); /* 5pm */
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,              TR_SCHED_ALL);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_USPEED_KBps,                     100);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED,                  false);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_UMASK,                           022);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT,        14);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,               TR_DEFAULT_BIND_ADDRESS_IPV4);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,               TR_DEFAULT_BIND_ADDRESS_IPV6);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_START,                           true);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_TRASH_ORIGINAL,                  false);
 }
 
 void
-tr_sessionGetSettings( tr_session * s, struct tr_benc * d )
-{
-    assert( tr_bencIsDict( d ) );
-
-    tr_bencDictReserve( d, 60 );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,                tr_blocklistIsEnabled( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_BLOCKLIST_URL,                    tr_blocklistGetURL( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,                tr_sessionGetCacheLimit_MB( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,                      s->isDHTEnabled );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_UTP_ENABLED,                      s->isUTPEnabled );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED,                      s->isLPDEnabled );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,                     s->downloadDir );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE,              tr_sessionGetQueueSize( s, TR_DOWN ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED,           tr_sessionGetQueueEnabled( s, TR_DOWN ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_KBps,                      tr_sessionGetSpeedLimit_KBps( s, TR_DOWN ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,                   tr_sessionIsSpeedLimited( s, TR_DOWN ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,                       s->encryptionMode );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_IDLE_LIMIT,                       tr_sessionGetIdleLimit( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,               tr_sessionIsIdleLimited( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR,                   tr_sessionGetIncompleteDir( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,           tr_sessionIsIncompleteDirEnabled( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL,                         tr_getMessageLevel( ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,                s->peerLimit );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,               s->peerLimitPerTorrent );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT,                        tr_sessionGetPeerPort( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START,        s->isPortRandom );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,             s->randomPortLow );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,            s->randomPortHigh );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_PEER_SOCKET_TOS,                  format_tos(s->peerSocketTOS) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_PEER_CONGESTION_ALGORITHM,        s->peer_congestion_algorithm );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED,                      s->isPexEnabled );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING,                  tr_sessionIsPortForwardingEnabled( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PREALLOCATION,                    s->preallocationMode );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_PREFETCH_ENABLED,                 s->isPrefetchEnabled );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED,            tr_sessionGetQueueStalledEnabled( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES,            tr_sessionGetQueueStalledMinutes( s ) );
-    tr_bencDictAddReal( d, TR_PREFS_KEY_RATIO,                            s->desiredRatio );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RATIO_ENABLED,                    s->isRatioLimited );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RENAME_PARTIAL_FILES,             tr_sessionIsIncompleteFileNamingEnabled( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,                tr_sessionIsRPCPasswordEnabled( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_BIND_ADDRESS,                 tr_sessionGetRPCBindAddress( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_ENABLED,                      tr_sessionIsRPCEnabled( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_PASSWORD,                     tr_sessionGetRPCPassword( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_RPC_PORT,                         tr_sessionGetRPCPort( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_URL,                          tr_sessionGetRPCUrl( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_USERNAME,                     tr_sessionGetRPCUsername( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_WHITELIST,                    tr_sessionGetRPCWhitelist( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,            tr_sessionGetRPCWhitelistEnabled( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS,           s->scrapePausedTorrents );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED,      tr_sessionIsTorrentDoneScriptEnabled( s ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME,     tr_sessionGetTorrentDoneScript( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_SEED_QUEUE_SIZE,                  tr_sessionGetQueueSize( s, TR_UP ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_SEED_QUEUE_ENABLED,               tr_sessionGetQueueEnabled( s, TR_UP ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,                tr_sessionUsesAltSpeed( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP_KBps,                tr_sessionGetAltSpeed_KBps( s, TR_UP ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps,              tr_sessionGetAltSpeed_KBps( s, TR_DOWN ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,             tr_sessionGetAltSpeedBegin( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,           tr_sessionUsesAltSpeedTime( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,               tr_sessionGetAltSpeedEnd( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,               tr_sessionGetAltSpeedDay( s ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED_KBps,                      tr_sessionGetSpeedLimit_KBps( s, TR_UP ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED,                   tr_sessionIsSpeedLimited( s, TR_UP ) );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_UMASK,                            s->umask );
-    tr_bencDictAddInt ( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT,         s->uploadSlotsPerTorrent );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,                tr_address_to_string( &s->public_ipv4->addr ) );
-    tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,                tr_address_to_string( &s->public_ipv6->addr ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_START,                            !tr_sessionGetPaused( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_TRASH_ORIGINAL,                   tr_sessionGetDeleteSource( s ) );
+tr_sessionGetSettings (tr_session * s, struct tr_benc * d)
+{
+    assert (tr_bencIsDict (d));
+
+    tr_bencDictReserve (d, 60);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED,                tr_blocklistIsEnabled (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_BLOCKLIST_URL,                    tr_blocklistGetURL (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,                tr_sessionGetCacheLimit_MB (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DHT_ENABLED,                      s->isDHTEnabled);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_UTP_ENABLED,                      s->isUTPEnabled);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_LPD_ENABLED,                      s->isLPDEnabled);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR,                     s->downloadDir);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE,              tr_sessionGetQueueSize (s, TR_DOWN));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED,           tr_sessionGetQueueEnabled (s, TR_DOWN));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps,                      tr_sessionGetSpeedLimit_KBps (s, TR_DOWN));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED,                   tr_sessionIsSpeedLimited (s, TR_DOWN));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION,                       s->encryptionMode);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_IDLE_LIMIT,                       tr_sessionGetIdleLimit (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,               tr_sessionIsIdleLimited (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_INCOMPLETE_DIR,                   tr_sessionGetIncompleteDir (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,           tr_sessionIsIncompleteDirEnabled (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_MSGLEVEL,                         tr_getMessageLevel ());
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,                s->peerLimit);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,               s->peerLimitPerTorrent);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT,                        tr_sessionGetPeerPort (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START,        s->isPortRandom);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,             s->randomPortLow);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,            s->randomPortHigh);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_PEER_SOCKET_TOS,                  format_tos (s->peerSocketTOS));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_PEER_CONGESTION_ALGORITHM,        s->peer_congestion_algorithm);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PEX_ENABLED,                      s->isPexEnabled);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING,                  tr_sessionIsPortForwardingEnabled (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PREALLOCATION,                    s->preallocationMode);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_PREFETCH_ENABLED,                 s->isPrefetchEnabled);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED,            tr_sessionGetQueueStalledEnabled (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES,            tr_sessionGetQueueStalledMinutes (s));
+    tr_bencDictAddReal (d, TR_PREFS_KEY_RATIO,                            s->desiredRatio);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RATIO_ENABLED,                    s->isRatioLimited);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RENAME_PARTIAL_FILES,             tr_sessionIsIncompleteFileNamingEnabled (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,                tr_sessionIsRPCPasswordEnabled (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_BIND_ADDRESS,                 tr_sessionGetRPCBindAddress (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_ENABLED,                      tr_sessionIsRPCEnabled (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_PASSWORD,                     tr_sessionGetRPCPassword (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_RPC_PORT,                         tr_sessionGetRPCPort (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_URL,                          tr_sessionGetRPCUrl (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_USERNAME,                     tr_sessionGetRPCUsername (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_WHITELIST,                    tr_sessionGetRPCWhitelist (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,            tr_sessionGetRPCWhitelistEnabled (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS,           s->scrapePausedTorrents);
+    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED,      tr_sessionIsTorrentDoneScriptEnabled (s));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME,     tr_sessionGetTorrentDoneScript (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_SEED_QUEUE_SIZE,                  tr_sessionGetQueueSize (s, TR_UP));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_SEED_QUEUE_ENABLED,               tr_sessionGetQueueEnabled (s, TR_UP));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_ENABLED,                tr_sessionUsesAltSpeed (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_UP_KBps,                tr_sessionGetAltSpeed_KBps (s, TR_UP));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps,              tr_sessionGetAltSpeed_KBps (s, TR_DOWN));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,             tr_sessionGetAltSpeedBegin (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,           tr_sessionUsesAltSpeedTime (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_END,               tr_sessionGetAltSpeedEnd (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,               tr_sessionGetAltSpeedDay (s));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_USPEED_KBps,                      tr_sessionGetSpeedLimit_KBps (s, TR_UP));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED,                   tr_sessionIsSpeedLimited (s, TR_UP));
+    tr_bencDictAddInt (d, TR_PREFS_KEY_UMASK,                            s->umask);
+    tr_bencDictAddInt (d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT,         s->uploadSlotsPerTorrent);
+    tr_bencDictAddStr (d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,                tr_address_to_string (&s->public_ipv4->addr));
+    tr_bencDictAddStr (d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,                tr_address_to_string (&s->public_ipv6->addr));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_START,                            !tr_sessionGetPaused (s));
+    tr_bencDictAddBool (d, TR_PREFS_KEY_TRASH_ORIGINAL,                   tr_sessionGetDeleteSource (s));
 }
 
 bool
-tr_sessionLoadSettings( tr_benc * d, const char * configDir, const char * appName )
+tr_sessionLoadSettings (tr_benc * d, const char * configDir, const char * appName)
 {
     int err = 0;
     char * filename;
@@ -451,75 +453,75 @@ tr_sessionLoadSettings( tr_benc * d, const char * configDir, const char * appNam
     tr_benc tmp;
     bool success = false;
 
-    assert( tr_bencIsDict( d ) );
+    assert (tr_bencIsDict (d));
 
     /* initializing the defaults: caller may have passed in some app-level defaults.
      * preserve those and use the session defaults to fill in any missing gaps. */
-    tr_bencInitDict( &sessionDefaults, 0 );
-    tr_sessionGetDefaultSettings( &sessionDefaults );
-    tr_bencMergeDicts( &sessionDefaults, d );
+    tr_bencInitDict (&sessionDefaults, 0);
+    tr_sessionGetDefaultSettings (&sessionDefaults);
+    tr_bencMergeDicts (&sessionDefaults, d);
     tmp = *d; *d = sessionDefaults; sessionDefaults = tmp;
 
     /* if caller didn't specify a config dir, use the default */
-    if( !configDir || !*configDir )
-        configDir = tr_getDefaultConfigDir( appName );
+    if (!configDir || !*configDir)
+        configDir = tr_getDefaultConfigDir (appName);
 
     /* file settings override the defaults */
-    filename = tr_buildPath( configDir, "settings.json", NULL );
-    err = tr_bencLoadFile( &fileSettings, TR_FMT_JSON, filename );
-    if( !err ) {
-        tr_bencMergeDicts( d, &fileSettings );
-        tr_bencFree( &fileSettings );
+    filename = tr_buildPath (configDir, "settings.json", NULL);
+    err = tr_bencLoadFile (&fileSettings, TR_FMT_JSON, filename);
+    if (!err) {
+        tr_bencMergeDicts (d, &fileSettings);
+        tr_bencFree (&fileSettings);
     }
 
     /* cleanup */
-    tr_bencFree( &sessionDefaults );
-    tr_free( filename );
+    tr_bencFree (&sessionDefaults);
+    tr_free (filename);
     success = (err==0) || (err==ENOENT);
     return success;
 }
 
 void
-tr_sessionSaveSettings( tr_session    * session,
+tr_sessionSaveSettings (tr_session    * session,
                         const char    * configDir,
-                        const tr_benc * clientSettings )
+                        const tr_benc * clientSettings)
 {
     tr_benc settings;
-    char * filename = tr_buildPath( configDir, "settings.json", NULL );
+    char * filename = tr_buildPath (configDir, "settings.json", NULL);
 
-    assert( tr_bencIsDict( clientSettings ) );
+    assert (tr_bencIsDict (clientSettings));
 
-    tr_bencInitDict( &settings, 0 );
+    tr_bencInitDict (&settings, 0);
 
     /* the existing file settings are the fallback values */
     {
         tr_benc fileSettings;
-        const int err = tr_bencLoadFile( &fileSettings, TR_FMT_JSON, filename );
-        if( !err )
+        const int err = tr_bencLoadFile (&fileSettings, TR_FMT_JSON, filename);
+        if (!err)
         {
-            tr_bencMergeDicts( &settings, &fileSettings );
-            tr_bencFree( &fileSettings );
+            tr_bencMergeDicts (&settings, &fileSettings);
+            tr_bencFree (&fileSettings);
         }
     }
 
     /* the client's settings override the file settings */
-    tr_bencMergeDicts( &settings, clientSettings );
+    tr_bencMergeDicts (&settings, clientSettings);
 
     /* the session's true values override the file & client settings */
     {
         tr_benc sessionSettings;
-        tr_bencInitDict( &sessionSettings, 0 );
-        tr_sessionGetSettings( session, &sessionSettings );
-        tr_bencMergeDicts( &settings, &sessionSettings );
-        tr_bencFree( &sessionSettings );
+        tr_bencInitDict (&sessionSettings, 0);
+        tr_sessionGetSettings (session, &sessionSettings);
+        tr_bencMergeDicts (&settings, &sessionSettings);
+        tr_bencFree (&sessionSettings);
     }
 
     /* save the result */
-    tr_bencToFile( &settings, TR_FMT_JSON, filename );
+    tr_bencToFile (&settings, TR_FMT_JSON, filename);
 
     /* cleanup */
-    tr_free( filename );
-    tr_bencFree( &settings );
+    tr_free (filename);
+    tr_bencFree (&settings);
 }
 
 /***
@@ -532,27 +534,27 @@ tr_sessionSaveSettings( tr_session    * session,
  * in the case of a crash, unclean shutdown, clumsy user, etc.
  */
 static void
-onSaveTimer( int foo UNUSED, short bar UNUSED, void * vsession )
+onSaveTimer (int foo UNUSED, short bar UNUSED, void * vsession)
 {
     tr_torrent * tor = NULL;
     tr_session * session = vsession;
 
-    if( tr_cacheFlushDone( session->cache ) )
-        tr_err( "Error while flushing completed pieces from cache" );
+    if (tr_cacheFlushDone (session->cache))
+        tr_err ("Error while flushing completed pieces from cache");
 
-    while(( tor = tr_torrentNext( session, tor )))
-        tr_torrentSave( tor );
+    while ((tor = tr_torrentNext (session, tor)))
+        tr_torrentSave (tor);
 
-    tr_statsSaveDirty( session );
+    tr_statsSaveDirty (session);
 
-    tr_timerAdd( session->saveTimer, SAVE_INTERVAL_SECS, 0 );
+    tr_timerAdd (session->saveTimer, SAVE_INTERVAL_SECS, 0);
 }
 
 /***
 ****
 ***/
 
-static void tr_sessionInitImpl( void * );
+static void tr_sessionInitImpl (void *);
 
 struct init_data
 {
@@ -564,39 +566,39 @@ struct init_data
 };
 
 tr_session *
-tr_sessionInit( const char  * tag,
+tr_sessionInit (const char  * tag,
                 const char  * configDir,
                 bool          messageQueuingEnabled,
-                tr_benc     * clientSettings )
+                tr_benc     * clientSettings)
 {
     int64_t i;
     tr_session * session;
     struct init_data data;
 
-    assert( tr_bencIsDict( clientSettings ) );
+    assert (tr_bencIsDict (clientSettings));
 
-    tr_timeUpdate( time( NULL ) );
+    tr_timeUpdate (time (NULL));
 
     /* initialize the bare skeleton of the session object */
-    session = tr_new0( tr_session, 1 );
+    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->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_peerIdInit( session->peer_id );
-    tr_bencInitList( &session->removedTorrents, 0 );
+    tr_bandwidthConstruct (&session->bandwidth, session, NULL);
+    tr_peerIdInit (session->peer_id);
+    tr_bencInitList (&session->removedTorrents, 0);
 
     /* nice to start logging at the very beginning */
-    if( tr_bencDictFindInt( clientSettings, TR_PREFS_KEY_MSGLEVEL, &i ) )
-        tr_setMessageLevel( i );
+    if (tr_bencDictFindInt (clientSettings, TR_PREFS_KEY_MSGLEVEL, &i))
+        tr_setMessageLevel (i);
 
     /* start the libtransmission thread */
-    tr_netInit( ); /* must go before tr_eventInit */
-    tr_eventInit( session );
-    assert( session->events != NULL );
+    tr_netInit (); /* must go before tr_eventInit */
+    tr_eventInit (session);
+    assert (session->events != NULL);
 
     /* run the rest in the libtransmission thread */
     data.done = false;
@@ -604,17 +606,17 @@ tr_sessionInit( const char  * tag,
     data.configDir = configDir;
     data.messageQueuingEnabled = messageQueuingEnabled;
     data.clientSettings = clientSettings;
-    tr_runInEventThread( session, tr_sessionInitImpl, &data );
-    while( !data.done )
-        tr_wait_msec( 100 );
+    tr_runInEventThread (session, tr_sessionInitImpl, &data);
+    while (!data.done)
+        tr_wait_msec (100);
 
     return session;
 }
 
-static void turtleCheckClock( tr_session * s, struct tr_turtle_info * t );
+static void turtleCheckClock (tr_session * s, struct tr_turtle_info * t);
 
 static void
-onNowTimer( int foo UNUSED, short bar UNUSED, void * vsession )
+onNowTimer (int foo UNUSED, short bar UNUSED, void * vsession)
 {
     int usec;
     const int min = 100;
@@ -622,25 +624,25 @@ onNowTimer( int foo UNUSED, short bar UNUSED, void * vsession )
     struct timeval tv;
     tr_torrent * tor = NULL;
     tr_session * session = vsession;
-    const time_t now = time( NULL );
+    const time_t now = time (NULL);
 
-    assert( tr_isSession( session ) );
-    assert( session->nowTimer != NULL );
+    assert (tr_isSession (session));
+    assert (session->nowTimer != NULL);
 
     /**
     ***  tr_session things to do once per second
     **/
 
-    tr_timeUpdate( now );
+    tr_timeUpdate (now);
 
-    tr_dhtUpkeep( session );
+    tr_dhtUpkeep (session);
 
-    if( session->turtle.isClockEnabled )
-        turtleCheckClock( session, &session->turtle );
+    if (session->turtle.isClockEnabled)
+        turtleCheckClock (session, &session->turtle);
 
-    while(( tor = tr_torrentNext( session, tor ))) {
-        if( tor->isRunning ) {
-            if( tr_torrentIsSeed( tor ) )
+    while ((tor = tr_torrentNext (session, tor))) {
+        if (tor->isRunning) {
+            if (tr_torrentIsSeed (tor))
                 ++tor->secondsSeeding;
             else
                 ++tor->secondsDownloading;
@@ -652,94 +654,94 @@ onNowTimer( int foo UNUSED, short bar UNUSED, void * vsession )
     **/
 
     /* schedule the next timer for right after the next second begins */
-    gettimeofday( &tv, NULL );
+    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 ); */
+    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); */
 }
 
-static void loadBlocklists( tr_session * session );
+static void loadBlocklists (tr_session * session);
 
 static void
-tr_sessionInitImpl( void * vdata )
+tr_sessionInitImpl (void * vdata)
 {
     tr_benc settings;
     struct init_data * data = vdata;
     tr_benc * clientSettings = data->clientSettings;
     tr_session * session = data->session;
 
-    assert( tr_amInEventThread( session ) );
-    assert( tr_bencIsDict( clientSettings ) );
+    assert (tr_amInEventThread (session));
+    assert (tr_bencIsDict (clientSettings));
 
-    dbgmsg( "tr_sessionInit: the session's top-level bandwidth object is %p",
-            &session->bandwidth );
+    dbgmsg ("tr_sessionInit: the session's top-level bandwidth object is %p",
+            &session->bandwidth);
 
-    tr_bencInitDict( &settings, 0 );
-    tr_sessionGetDefaultSettings( &settings );
-    tr_bencMergeDicts( &settings, clientSettings );
+    tr_bencInitDict (&settings, 0);
+    tr_sessionGetDefaultSettings (&settings);
+    tr_bencMergeDicts (&settings, clientSettings);
 
-    assert( session->event_base != NULL );
-    session->nowTimer = evtimer_new( session->event_base, onNowTimer, session );
-    onNowTimer( 0, 0, session );
+    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 );
+    signal (SIGPIPE, SIG_IGN);
 #endif
 
-    tr_setMessageQueuing( data->messageQueuingEnabled );
+    tr_setMessageQueuing (data->messageQueuingEnabled);
 
-    tr_setConfigDir( session, data->configDir );
+    tr_setConfigDir (session, data->configDir);
 
-    session->peerMgr = tr_peerMgrNew( session );
+    session->peerMgr = tr_peerMgrNew (session);
 
-    session->shared = tr_sharedInit( session );
+    session->shared = tr_sharedInit (session);
 
     /**
     ***  Blocklist
     **/
 
     {
-        char * filename = tr_buildPath( session->configDir, "blocklists", NULL );
-        tr_mkdirp( filename, 0777 );
-        tr_free( filename );
-        loadBlocklists( session );
+        char * filename = tr_buildPath (session->configDir, "blocklists", NULL);
+        tr_mkdirp (filename, 0777);
+        tr_free (filename);
+        loadBlocklists (session);
     }
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    session->saveTimer = evtimer_new( session->event_base, onSaveTimer, session );
-    tr_timerAdd( session->saveTimer, SAVE_INTERVAL_SECS, 0 );
+    session->saveTimer = evtimer_new (session->event_base, onSaveTimer, session);
+    tr_timerAdd (session->saveTimer, SAVE_INTERVAL_SECS, 0);
 
-    tr_announcerInit( session );
+    tr_announcerInit (session);
 
     /* first %s is the application name
        second %s is the version number */
-    tr_inf( _( "%s %s started" ), TR_NAME, LONG_VERSION_STRING );
+    tr_inf (_ ("%s %s started"), TR_NAME, LONG_VERSION_STRING);
 
-    tr_statsInit( session );
+    tr_statsInit (session);
 
-    tr_webInit( session );
+    tr_webInit (session);
 
-    tr_sessionSet( session, &settings );
+    tr_sessionSet (session, &settings);
 
-    tr_udpInit( session );
+    tr_udpInit (session);
 
-    if( session->isLPDEnabled )
-        tr_lpdInit( session, &session->public_ipv4->addr );
+    if (session->isLPDEnabled)
+        tr_lpdInit (session, &session->public_ipv4->addr);
 
     /* cleanup */
-    tr_bencFree( &settings );
+    tr_bencFree (&settings);
     data->done = true;
 }
 
-static void turtleBootstrap( tr_session *, struct tr_turtle_info * );
-static void setPeerPort( tr_session * session, tr_port port );
+static void turtleBootstrap (tr_session *, struct tr_turtle_info *);
+static void setPeerPort (tr_session * session, tr_port port);
 
 static void
-sessionSetImpl( void * vdata )
+sessionSetImpl (void * vdata)
 {
     int64_t i;
     double  d;
@@ -751,180 +753,180 @@ sessionSetImpl( void * vdata )
     tr_benc * settings = data->clientSettings;
     struct tr_turtle_info * turtle = &session->turtle;
 
-    assert( tr_isSession( session ) );
-    assert( tr_bencIsDict( settings ) );
-    assert( tr_amInEventThread( session ) );
+    assert (tr_isSession (session));
+    assert (tr_bencIsDict (settings));
+    assert (tr_amInEventThread (session));
 
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_MSGLEVEL, &i ) )
-        tr_setMessageLevel( i );
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_MSGLEVEL, &i))
+        tr_setMessageLevel (i);
 
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_UMASK, &i ) ) {
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_UMASK, &i)) {
         session->umask = (mode_t)i;
-        umask( session->umask );
+        umask (session->umask);
     }
 
     /* misc features */
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i ) )
-        tr_sessionSetCacheLimit_MB( session, i );
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i ) )
-        tr_sessionSetPeerLimitPerTorrent( session, i );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PEX_ENABLED, &boolVal ) )
-        tr_sessionSetPexEnabled( session, boolVal );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_DHT_ENABLED, &boolVal ) )
-        tr_sessionSetDHTEnabled( session, boolVal );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_UTP_ENABLED, &boolVal ) )
-        tr_sessionSetUTPEnabled( session, boolVal );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_LPD_ENABLED, &boolVal ) )
-        tr_sessionSetLPDEnabled( session, boolVal );
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ENCRYPTION, &i ) )
-        tr_sessionSetEncryption( session, i );
-    if( tr_bencDictFindStr( settings, TR_PREFS_KEY_PEER_SOCKET_TOS, &str ) )
-        session->peerSocketTOS = parse_tos( str );
-    if( tr_bencDictFindStr( settings, TR_PREFS_KEY_PEER_CONGESTION_ALGORITHM, &str ) )
-        session->peer_congestion_algorithm = tr_strdup(str);
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i))
+        tr_sessionSetCacheLimit_MB (session, i);
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i))
+        tr_sessionSetPeerLimitPerTorrent (session, i);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_PEX_ENABLED, &boolVal))
+        tr_sessionSetPexEnabled (session, boolVal);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_DHT_ENABLED, &boolVal))
+        tr_sessionSetDHTEnabled (session, boolVal);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_UTP_ENABLED, &boolVal))
+        tr_sessionSetUTPEnabled (session, boolVal);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_LPD_ENABLED, &boolVal))
+        tr_sessionSetLPDEnabled (session, boolVal);
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ENCRYPTION, &i))
+        tr_sessionSetEncryption (session, i);
+    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_PEER_SOCKET_TOS, &str))
+        session->peerSocketTOS = parse_tos (str);
+    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_PEER_CONGESTION_ALGORITHM, &str))
+        session->peer_congestion_algorithm = tr_strdup (str);
     else
-        session->peer_congestion_algorithm = tr_strdup("");
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal ) )
-        tr_blocklistSetEnabled( session, boolVal );
-    if( tr_bencDictFindStr( settings, TR_PREFS_KEY_BLOCKLIST_URL, &str ) )
-        tr_blocklistSetURL( session, str );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_START, &boolVal ) )
-        tr_sessionSetPaused( session, !boolVal );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal) )
-        tr_sessionSetDeleteSource( session, boolVal );
+        session->peer_congestion_algorithm = tr_strdup ("");
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal))
+        tr_blocklistSetEnabled (session, boolVal);
+    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_BLOCKLIST_URL, &str))
+        tr_blocklistSetURL (session, str);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_START, &boolVal))
+        tr_sessionSetPaused (session, !boolVal);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal))
+        tr_sessionSetDeleteSource (session, boolVal);
 
     /* torrent queues */
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_QUEUE_STALLED_MINUTES, &i ) )
-        tr_sessionSetQueueStalledMinutes( session, i );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_QUEUE_STALLED_ENABLED, &boolVal ) )
-        tr_sessionSetQueueStalledEnabled( session, boolVal );
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, &i ) )
-        tr_sessionSetQueueSize( session, TR_DOWN, i );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED, &boolVal ) )
-        tr_sessionSetQueueEnabled( session, TR_DOWN, boolVal );
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_SEED_QUEUE_SIZE, &i ) )
-        tr_sessionSetQueueSize( session, TR_UP, i );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_SEED_QUEUE_ENABLED, &boolVal ) )
-        tr_sessionSetQueueEnabled( session, TR_UP, boolVal );
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_QUEUE_STALLED_MINUTES, &i))
+        tr_sessionSetQueueStalledMinutes (session, i);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_QUEUE_STALLED_ENABLED, &boolVal))
+        tr_sessionSetQueueStalledEnabled (session, boolVal);
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, &i))
+        tr_sessionSetQueueSize (session, TR_DOWN, i);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED, &boolVal))
+        tr_sessionSetQueueEnabled (session, TR_DOWN, boolVal);
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_SEED_QUEUE_SIZE, &i))
+        tr_sessionSetQueueSize (session, TR_UP, i);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_SEED_QUEUE_ENABLED, &boolVal))
+        tr_sessionSetQueueEnabled (session, TR_UP, boolVal);
 
     /* files and directories */
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PREFETCH_ENABLED, &boolVal ) )
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_PREFETCH_ENABLED, &boolVal))
         session->isPrefetchEnabled = boolVal;
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_PREALLOCATION, &i ) )
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PREALLOCATION, &i))
         session->preallocationMode = i;
-    if( tr_bencDictFindStr( settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
-        tr_sessionSetDownloadDir( session, str );
-    if( tr_bencDictFindStr( settings, TR_PREFS_KEY_INCOMPLETE_DIR, &str ) )
-        tr_sessionSetIncompleteDir( session, str );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, &boolVal ) )
-        tr_sessionSetIncompleteDirEnabled( session, boolVal );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_RENAME_PARTIAL_FILES, &boolVal ) )
-        tr_sessionSetIncompleteFileNamingEnabled( session, boolVal );
+    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str))
+        tr_sessionSetDownloadDir (session, str);
+    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_INCOMPLETE_DIR, &str))
+        tr_sessionSetIncompleteDir (session, str);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, &boolVal))
+        tr_sessionSetIncompleteDirEnabled (session, boolVal);
+    if (tr_bencDictFindBool (settings, TR_PREFS_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 );
+    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 );
+    free_incoming_peer_port (session);
 
     str = TR_PREFS_KEY_BIND_ADDRESS_IPV4;
-    tr_bencDictFindStr( settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, &str );
-    if( !tr_address_from_string( &b.addr, str ) || ( b.addr.type != TR_AF_INET ) )
+    tr_bencDictFindStr (settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, &str);
+    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 ) );
+    session->public_ipv4 = tr_memdup (&b, sizeof (struct tr_bindinfo));
 
     str = TR_PREFS_KEY_BIND_ADDRESS_IPV6;
-    tr_bencDictFindStr( settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, &str );
-    if( !tr_address_from_string( &b.addr, str ) || ( b.addr.type != TR_AF_INET6 ) )
+    tr_bencDictFindStr (settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, &str);
+    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 ) );
+    session->public_ipv6 = tr_memdup (&b, sizeof (struct tr_bindinfo));
 
     /* incoming peer port */
-    if( tr_bencDictFindInt ( settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i ) )
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i))
         session->randomPortLow = i;
-    if( tr_bencDictFindInt ( settings, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, &i ) )
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, &i))
         session->randomPortHigh = i;
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, &boolVal ) )
-        tr_sessionSetPeerPortRandomOnStart( session, boolVal );
-    if( !tr_bencDictFindInt( settings, TR_PREFS_KEY_PEER_PORT, &i ) )
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, &boolVal))
+        tr_sessionSetPeerPortRandomOnStart (session, boolVal);
+    if (!tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_PORT, &i))
         i = session->private_peer_port;
-    setPeerPort( session, boolVal ? getRandomPort( session ) : i );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PORT_FORWARDING, &boolVal ) )
-        tr_sessionSetPortForwardingEnabled( session, boolVal );
+    setPeerPort (session, boolVal ? getRandomPort (session) : i);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_PORT_FORWARDING, &boolVal))
+        tr_sessionSetPortForwardingEnabled (session, boolVal);
 
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i ) )
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i))
         session->peerLimit = i;
 
     /**
     **/
 
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, &i ) )
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, &i))
         session->uploadSlotsPerTorrent = i;
 
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_USPEED_KBps, &i ) )
-        tr_sessionSetSpeedLimit_KBps( session, TR_UP, i );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_USPEED_ENABLED, &boolVal ) )
-        tr_sessionLimitSpeed( session, TR_UP, boolVal );
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_USPEED_KBps, &i))
+        tr_sessionSetSpeedLimit_KBps (session, TR_UP, i);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_USPEED_ENABLED, &boolVal))
+        tr_sessionLimitSpeed (session, TR_UP, boolVal);
 
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_DSPEED_KBps, &i ) )
-        tr_sessionSetSpeedLimit_KBps( session, TR_DOWN, i );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal ) )
-        tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_DSPEED_KBps, &i))
+        tr_sessionSetSpeedLimit_KBps (session, TR_DOWN, i);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal))
+        tr_sessionLimitSpeed (session, TR_DOWN, boolVal);
 
-    if( tr_bencDictFindReal( settings, TR_PREFS_KEY_RATIO, &d ) )
-        tr_sessionSetRatioLimit( session, d );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_RATIO_ENABLED, &boolVal ) )
-        tr_sessionSetRatioLimited( session, boolVal );
+    if (tr_bencDictFindReal (settings, TR_PREFS_KEY_RATIO, &d))
+        tr_sessionSetRatioLimit (session, d);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_RATIO_ENABLED, &boolVal))
+        tr_sessionSetRatioLimited (session, boolVal);
 
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_IDLE_LIMIT, &i ) )
-        tr_sessionSetIdleLimit( session, i );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, &boolVal ) )
-        tr_sessionSetIdleLimited( session, boolVal );
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_IDLE_LIMIT, &i))
+        tr_sessionSetIdleLimit (session, i);
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, &boolVal))
+        tr_sessionSetIdleLimited (session, boolVal);
 
     /**
     ***  Turtle Mode
     **/
 
     /* update the turtle mode's fields */
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &i ) )
-        turtle->speedLimit_Bps[TR_UP] = toSpeedBytes( i );
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &i ) )
-        turtle->speedLimit_Bps[TR_DOWN] = toSpeedBytes( i );
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i ) )
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &i))
+        turtle->speedLimit_Bps[TR_UP] = toSpeedBytes (i);
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &i))
+        turtle->speedLimit_Bps[TR_DOWN] = toSpeedBytes (i);
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i))
         turtle->beginMinute = i;
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i ) )
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i))
         turtle->endMinute = i;
-    if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &i ) )
+    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &i))
         turtle->days = i;
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal ) )
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal))
         turtle->isClockEnabled = boolVal;
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal ) )
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal))
         turtle->isEnabled = boolVal;
-    turtleBootstrap( session, turtle );
+    turtleBootstrap (session, turtle);
 
     /**
     ***  Scripts
     **/
 
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, &boolVal ) )
-        tr_sessionSetTorrentDoneScriptEnabled( session, boolVal );
-    if( tr_bencDictFindStr( settings, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, &str ) )
-        tr_sessionSetTorrentDoneScript( session, str );
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, &boolVal))
+        tr_sessionSetTorrentDoneScriptEnabled (session, boolVal);
+    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, &str))
+        tr_sessionSetTorrentDoneScript (session, str);
 
 
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS, &boolVal ) )
+    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS, &boolVal))
         session->scrapePausedTorrents = boolVal;
 
     data->done = true;
 }
 
 void
-tr_sessionSet( tr_session * session, struct tr_benc  * settings )
+tr_sessionSet (tr_session * session, struct tr_benc  * settings)
 {
     struct init_data data;
     data.done = false;
@@ -932,9 +934,9 @@ tr_sessionSet( tr_session * session, struct tr_benc  * settings )
     data.clientSettings = settings;
 
     /* run the rest in the libtransmission thread */
-    tr_runInEventThread( session, sessionSetImpl, &data );
-    while( !data.done )
-        tr_wait_msec( 100 );
+    tr_runInEventThread (session, sessionSetImpl, &data);
+    while (!data.done)
+        tr_wait_msec (100);
 }
 
 /***
@@ -942,31 +944,31 @@ tr_sessionSet( tr_session * session, struct tr_benc  * settings )
 ***/
 
 void
-tr_sessionSetDownloadDir( tr_session * session, const char * dir )
+tr_sessionSetDownloadDir (tr_session * session, const char * dir)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    if( session->downloadDir != dir )
+    if (session->downloadDir != dir)
     {
-        tr_free( session->downloadDir );
-        session->downloadDir = tr_strdup( dir );
+        tr_free (session->downloadDir);
+        session->downloadDir = tr_strdup (dir);
     }
 }
 
 const char *
-tr_sessionGetDownloadDir( const tr_session * session )
+tr_sessionGetDownloadDir (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->downloadDir;
 }
 
 int64_t
-tr_sessionGetDownloadDirFreeSpace( const tr_session * session )
+tr_sessionGetDownloadDirFreeSpace (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_getFreeSpace( session->downloadDir );
+    return tr_getFreeSpace (session->downloadDir);
 }
 
 /***
@@ -974,18 +976,18 @@ tr_sessionGetDownloadDirFreeSpace( const tr_session * session )
 ***/
 
 void
-tr_sessionSetIncompleteFileNamingEnabled( tr_session * session, bool b )
+tr_sessionSetIncompleteFileNamingEnabled (tr_session * session, bool b)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isBool( b ) );
+    assert (tr_isSession (session));
+    assert (tr_isBool (b));
 
     session->isIncompleteFileNamingEnabled = b;
 }
 
 bool
-tr_sessionIsIncompleteFileNamingEnabled( const tr_session * session )
+tr_sessionIsIncompleteFileNamingEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isIncompleteFileNamingEnabled;
 }
@@ -996,39 +998,39 @@ tr_sessionIsIncompleteFileNamingEnabled( const tr_session * session )
 
 
 void
-tr_sessionSetIncompleteDir( tr_session * session, const char * dir )
+tr_sessionSetIncompleteDir (tr_session * session, const char * dir)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    if( session->incompleteDir != dir )
+    if (session->incompleteDir != dir)
     {
-        tr_free( session->incompleteDir );
+        tr_free (session->incompleteDir);
 
-        session->incompleteDir = tr_strdup( dir );
+        session->incompleteDir = tr_strdup (dir);
     }
 }
 
 const char*
-tr_sessionGetIncompleteDir( const tr_session * session )
+tr_sessionGetIncompleteDir (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->incompleteDir;
 }
 
 void
-tr_sessionSetIncompleteDirEnabled( tr_session * session, bool b )
+tr_sessionSetIncompleteDirEnabled (tr_session * session, bool b)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isBool( b ) );
+    assert (tr_isSession (session));
+    assert (tr_isBool (b));
 
     session->isIncompleteDirEnabled = b;
 }
 
 bool
-tr_sessionIsIncompleteDirEnabled( const tr_session * session )
+tr_sessionIsIncompleteDirEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isIncompleteDirEnabled;
 }
@@ -1038,25 +1040,25 @@ tr_sessionIsIncompleteDirEnabled( const tr_session * session )
 ***/
 
 void
-tr_sessionLock( tr_session * session )
+tr_sessionLock (tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_lockLock( session->lock );
+    tr_lockLock (session->lock);
 }
 
 void
-tr_sessionUnlock( tr_session * session )
+tr_sessionUnlock (tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_lockUnlock( session->lock );
+    tr_lockUnlock (session->lock);
 }
 
 bool
-tr_sessionIsLocked( const tr_session * session )
+tr_sessionIsLocked (const tr_session * session)
 {
-    return tr_isSession( session ) && tr_lockHave( session->lock );
+    return tr_isSession (session) && tr_lockHave (session->lock);
 }
 
 /***********************************************************************
@@ -1066,76 +1068,76 @@ tr_sessionIsLocked( const tr_session * session )
  **********************************************************************/
 
 static void
-peerPortChanged( void * session )
+peerPortChanged (void * session)
 {
     tr_torrent * tor = NULL;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    close_incoming_peer_port( session );
-    open_incoming_peer_port( session );
-    tr_sharedPortChanged( session );
+    close_incoming_peer_port (session);
+    open_incoming_peer_port (session);
+    tr_sharedPortChanged (session);
 
-    while(( tor = tr_torrentNext( session, tor )))
-        tr_torrentChangeMyPort( tor );
+    while ((tor = tr_torrentNext (session, tor)))
+        tr_torrentChangeMyPort (tor);
 }
 
 static void
-setPeerPort( tr_session * session, tr_port port )
+setPeerPort (tr_session * session, tr_port port)
 {
     session->private_peer_port = port;
     session->public_peer_port = port;
 
-    tr_runInEventThread( session, peerPortChanged, session );
+    tr_runInEventThread (session, peerPortChanged, session);
 }
 
 void
-tr_sessionSetPeerPort( tr_session * session, tr_port port )
+tr_sessionSetPeerPort (tr_session * session, tr_port port)
 {
-    if( tr_isSession( session ) && ( session->private_peer_port != port ) )
+    if (tr_isSession (session) && (session->private_peer_port != port))
     {
-        setPeerPort( session, port );
+        setPeerPort (session, port);
     }
 }
 
 tr_port
-tr_sessionGetPeerPort( const tr_session * session )
+tr_sessionGetPeerPort (const tr_session * session)
 {
-    return tr_isSession( session ) ? session->private_peer_port : 0;
+    return tr_isSession (session) ? session->private_peer_port : 0;
 }
 
 tr_port
-tr_sessionSetPeerPortRandom( tr_session * session )
+tr_sessionSetPeerPortRandom (tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_sessionSetPeerPort( session, getRandomPort( session ) );
+    tr_sessionSetPeerPort (session, getRandomPort (session));
     return session->private_peer_port;
 }
 
 void
-tr_sessionSetPeerPortRandomOnStart( tr_session * session,
-                                    bool random )
+tr_sessionSetPeerPortRandomOnStart (tr_session * session,
+                                    bool random)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->isPortRandom = random;
 }
 
 bool
-tr_sessionGetPeerPortRandomOnStart( tr_session * session )
+tr_sessionGetPeerPortRandomOnStart (tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isPortRandom;
 }
 
 tr_port_forwarding
-tr_sessionGetPortForwarding( const tr_session * session )
+tr_sessionGetPortForwarding (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_sharedTraversalStatus( session->shared );
+    return tr_sharedTraversalStatus (session->shared);
 }
 
 /***
@@ -1143,33 +1145,33 @@ tr_sessionGetPortForwarding( const tr_session * session )
 ***/
 
 void
-tr_sessionSetRatioLimited( tr_session * session, bool isLimited )
+tr_sessionSetRatioLimited (tr_session * session, bool isLimited)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->isRatioLimited = isLimited;
 }
 
 void
-tr_sessionSetRatioLimit( tr_session * session, double desiredRatio )
+tr_sessionSetRatioLimit (tr_session * session, double desiredRatio)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->desiredRatio = desiredRatio;
 }
 
 bool
-tr_sessionIsRatioLimited( const tr_session  * session )
+tr_sessionIsRatioLimited (const tr_session  * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isRatioLimited;
 }
 
 double
-tr_sessionGetRatioLimit( const tr_session * session )
+tr_sessionGetRatioLimit (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->desiredRatio;
 }
@@ -1179,33 +1181,33 @@ tr_sessionGetRatioLimit( const tr_session * session )
 ***/
 
 void
-tr_sessionSetIdleLimited( tr_session * session, bool isLimited )
+tr_sessionSetIdleLimited (tr_session * session, bool isLimited)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->isIdleLimited = isLimited;
 }
 
 void
-tr_sessionSetIdleLimit( tr_session * session, uint16_t idleMinutes )
+tr_sessionSetIdleLimit (tr_session * session, uint16_t idleMinutes)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->idleLimitMinutes = idleMinutes;
 }
 
 bool
-tr_sessionIsIdleLimited( const tr_session  * session )
+tr_sessionIsIdleLimited (const tr_session  * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isIdleLimited;
 }
 
 uint16_t
-tr_sessionGetIdleLimit( const tr_session * session )
+tr_sessionGetIdleLimit (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->idleLimitMinutes;
 }
@@ -1217,43 +1219,43 @@ tr_sessionGetIdleLimit( const tr_session * session )
 ***/
 
 bool
-tr_sessionGetActiveSpeedLimit_Bps( const tr_session * session, tr_direction dir, unsigned int * setme_Bps )
+tr_sessionGetActiveSpeedLimit_Bps (const tr_session * session, tr_direction dir, unsigned int * setme_Bps)
 {
     int isLimited = true;
 
-    if( !tr_isSession( session ) )
+    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 );
+    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
-tr_sessionGetActiveSpeedLimit_KBps( const tr_session  * session,
+tr_sessionGetActiveSpeedLimit_KBps (const tr_session  * session,
                                     tr_direction        dir,
-                                    double            * setme_KBps )
+                                    double            * setme_KBps)
 {
     unsigned int Bps = 0;
-    const bool is_active = tr_sessionGetActiveSpeedLimit_Bps( session, dir, &Bps );
-    *setme_KBps = toSpeedKBps( Bps );
+    const bool is_active = tr_sessionGetActiveSpeedLimit_Bps (session, dir, &Bps);
+    *setme_KBps = toSpeedKBps (Bps);
     return is_active;
 }
 
 static void
-updateBandwidth( tr_session * session, tr_direction dir )
+updateBandwidth (tr_session * session, tr_direction dir)
 {
     unsigned int limit_Bps = 0;
-    const bool isLimited = tr_sessionGetActiveSpeedLimit_Bps( session, dir, &limit_Bps );
+    const bool isLimited = tr_sessionGetActiveSpeedLimit_Bps (session, dir, &limit_Bps);
     const bool zeroCase = isLimited && !limit_Bps;
 
-    tr_bandwidthSetLimited( &session->bandwidth, dir, isLimited && !zeroCase );
+    tr_bandwidthSetLimited (&session->bandwidth, dir, isLimited && !zeroCase);
 
-    tr_bandwidthSetDesiredSpeed_Bps( &session->bandwidth, dir, limit_Bps );
+    tr_bandwidthSetDesiredSpeed_Bps (&session->bandwidth, dir, limit_Bps);
 }
 
 enum
@@ -1264,59 +1266,59 @@ enum
 };
 
 static void
-turtleUpdateTable( struct tr_turtle_info * t )
+turtleUpdateTable (struct tr_turtle_info * t)
 {
     int day;
     tr_bitfield * b = &t->minutes;
 
-    tr_bitfieldSetHasNone( b );
+    tr_bitfieldSetHasNone (b);
 
-    for( day=0; day<7; ++day )
+    for (day=0; day<7; ++day)
     {
-        if( t->days & (1<<day) )
+        if (t->days & (1<<day))
         {
             int i;
             const time_t begin = t->beginMinute;
             time_t end = t->endMinute;
 
-            if( end <= begin )
+            if (end <= begin)
                 end += MINUTES_PER_DAY;
 
-            for( i=begin; i<end; ++i )
-                tr_bitfieldAdd( b, (i+day*MINUTES_PER_DAY) % MINUTES_PER_WEEK );
+            for (i=begin; i<end; ++i)
+                tr_bitfieldAdd (b, (i+day*MINUTES_PER_DAY) % MINUTES_PER_WEEK);
         }
     }
 }
 
 static void
-altSpeedToggled( void * vsession )
+altSpeedToggled (void * vsession)
 {
     tr_session * session = vsession;
     struct tr_turtle_info * t = &session->turtle;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    updateBandwidth( session, TR_UP );
-    updateBandwidth( session, TR_DOWN );
+    updateBandwidth (session, TR_UP);
+    updateBandwidth (session, TR_DOWN);
 
-    if( t->callback != NULL )
-        (*t->callback)( session, t->isEnabled, t->changedByUser, t->callbackUserData );
+    if (t->callback != NULL)
+      (*t->callback)(session, t->isEnabled, t->changedByUser, t->callbackUserData);
 }
 
 static void
-useAltSpeed( tr_session * s, struct tr_turtle_info * t,
-             bool enabled, bool byUser )
+useAltSpeed (tr_session * s, struct tr_turtle_info * t,
+             bool enabled, bool byUser)
 {
-    assert( tr_isSession( s ) );
-    assert( t != NULL );
-    assert( tr_isBool( enabled ) );
-    assert( tr_isBool( byUser ) );
+    assert (tr_isSession (s));
+    assert (t != NULL);
+    assert (tr_isBool (enabled));
+    assert (tr_isBool (byUser));
 
-    if( t->isEnabled != enabled )
+    if (t->isEnabled != enabled)
     {
         t->isEnabled = enabled;
         t->changedByUser = byUser;
-        tr_runInEventThread( s, altSpeedToggled, s );
+        tr_runInEventThread (s, altSpeedToggled, s);
     }
 }
 
@@ -1324,47 +1326,47 @@ useAltSpeed( tr_session * s, struct tr_turtle_info * t,
  * @return whether turtle should be on/off according to the scheduler
  */
 static bool
-getInTurtleTime( const struct tr_turtle_info * t )
+getInTurtleTime (const struct tr_turtle_info * t)
 {
     struct tm tm;
     size_t minute_of_the_week;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    tr_localtime_r( &now, &tm );
+    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? */
+    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 );
+    return tr_bitfieldHas (&t->minutes, minute_of_the_week);
 }
 
 static inline tr_auto_switch_state_t
-autoSwitchState( bool enabled )
+autoSwitchState (bool enabled)
 {
     return enabled ? TR_AUTO_SWITCH_ON : TR_AUTO_SWITCH_OFF;
 }
 
 static void
-turtleCheckClock( tr_session * s, struct tr_turtle_info * t )
+turtleCheckClock (tr_session * s, struct tr_turtle_info * t)
 {
     bool enabled;
     bool alreadySwitched;
     tr_auto_switch_state_t newAutoTurtleState;
 
-    assert( t->isClockEnabled );
+    assert (t->isClockEnabled);
 
-    enabled = getInTurtleTime( t );
-    newAutoTurtleState = autoSwitchState( enabled );
-    alreadySwitched = ( t->autoTurtleState == newAutoTurtleState );
+    enabled = getInTurtleTime (t);
+    newAutoTurtleState = autoSwitchState (enabled);
+    alreadySwitched = (t->autoTurtleState == newAutoTurtleState);
 
-    if( !alreadySwitched )
+    if (!alreadySwitched)
     {
-        tr_inf( "Time to turn %s turtle mode!", (enabled?"on":"off") );
+        tr_inf ("Time to turn %s turtle mode!", (enabled?"on":"off"));
         t->autoTurtleState = newAutoTurtleState;
-        useAltSpeed( s, t, enabled, false );
+        useAltSpeed (s, t, enabled, false);
     }
 }
 
@@ -1372,22 +1374,22 @@ turtleCheckClock( tr_session * s, struct tr_turtle_info * t )
  * It initializes the implementation fields
  * and turns on turtle mode if the clock settings say to. */
 static void
-turtleBootstrap( tr_session * session, struct tr_turtle_info * turtle )
+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 );
+    tr_bitfieldConstruct (&turtle->minutes, MINUTES_PER_WEEK);
 
-    turtleUpdateTable( turtle );
+    turtleUpdateTable (turtle);
 
-    if( turtle->isClockEnabled )
+    if (turtle->isClockEnabled)
     {
-        turtle->isEnabled = getInTurtleTime( turtle );
-        turtle->autoTurtleState = autoSwitchState( turtle->isEnabled );
+        turtle->isEnabled = getInTurtleTime (turtle);
+        turtle->autoTurtleState = autoSwitchState (turtle->isEnabled);
     }
 
-    altSpeedToggled( session );
+    altSpeedToggled (session);
 
 }
 
@@ -1396,52 +1398,52 @@ turtleBootstrap( tr_session * session, struct tr_turtle_info * turtle )
 ***/
 
 void
-tr_sessionSetSpeedLimit_Bps( tr_session * s, tr_direction d, unsigned int Bps )
+tr_sessionSetSpeedLimit_Bps (tr_session * s, tr_direction d, unsigned int Bps)
 {
-    assert( tr_isSession( s ) );
-    assert( tr_isDirection( d ) );
+    assert (tr_isSession (s));
+    assert (tr_isDirection (d));
 
     s->speedLimit_Bps[d] = Bps;
 
-    updateBandwidth( s, d );
+    updateBandwidth (s, d);
 }
 void
-tr_sessionSetSpeedLimit_KBps( tr_session * s, tr_direction d, unsigned int KBps )
+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));
 }
 
 unsigned int
-tr_sessionGetSpeedLimit_Bps( const tr_session * s, tr_direction d )
+tr_sessionGetSpeedLimit_Bps (const tr_session * s, tr_direction d)
 {
-    assert( tr_isSession( s ) );
-    assert( tr_isDirection( d ) );
+    assert (tr_isSession (s));
+    assert (tr_isDirection (d));
 
     return s->speedLimit_Bps[d];
 }
 unsigned int
-tr_sessionGetSpeedLimit_KBps( const tr_session * s, tr_direction d )
+tr_sessionGetSpeedLimit_KBps (const tr_session * s, tr_direction d)
 {
-    return toSpeedKBps( tr_sessionGetSpeedLimit_Bps( s, d ) );
+    return toSpeedKBps (tr_sessionGetSpeedLimit_Bps (s, d));
 }
 
 void
-tr_sessionLimitSpeed( tr_session * s, tr_direction d, bool b )
+tr_sessionLimitSpeed (tr_session * s, tr_direction d, bool b)
 {
-    assert( tr_isSession( s ) );
-    assert( tr_isDirection( d ) );
-    assert( tr_isBool( b ) );
+    assert (tr_isSession (s));
+    assert (tr_isDirection (d));
+    assert (tr_isBool (b));
 
     s->speedLimitEnabled[d] = b;
 
-    updateBandwidth( s, d );
+    updateBandwidth (s, d);
 }
 
 bool
-tr_sessionIsSpeedLimited( const tr_session * s, tr_direction d )
+tr_sessionIsSpeedLimited (const tr_session * s, tr_direction d)
 {
-    assert( tr_isSession( s ) );
-    assert( tr_isDirection( d ) );
+    assert (tr_isSession (s));
+    assert (tr_isDirection (d));
 
     return s->speedLimitEnabled[d];
 }
@@ -1451,163 +1453,163 @@ tr_sessionIsSpeedLimited( const tr_session * s, tr_direction d )
 ***/
 
 void
-tr_sessionSetAltSpeed_Bps( tr_session * s, tr_direction d, unsigned int Bps )
+tr_sessionSetAltSpeed_Bps (tr_session * s, tr_direction d, unsigned int Bps)
 {
-    assert( tr_isSession( s ) );
-    assert( tr_isDirection( d ) );
+    assert (tr_isSession (s));
+    assert (tr_isDirection (d));
 
     s->turtle.speedLimit_Bps[d] = Bps;
 
-    updateBandwidth( s, d );
+    updateBandwidth (s, d);
 }
 
 void
-tr_sessionSetAltSpeed_KBps( tr_session * s, tr_direction d, unsigned int KBps )
+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));
 }
 
 unsigned int
-tr_sessionGetAltSpeed_Bps( const tr_session * s, tr_direction d )
+tr_sessionGetAltSpeed_Bps (const tr_session * s, tr_direction d)
 {
-    assert( tr_isSession( s ) );
-    assert( tr_isDirection( 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 )
+tr_sessionGetAltSpeed_KBps (const tr_session * s, tr_direction d)
 {
-    return toSpeedKBps( tr_sessionGetAltSpeed_Bps( s, d ) );
+    return toSpeedKBps (tr_sessionGetAltSpeed_Bps (s, d));
 }
 
 static void
-userPokedTheClock( tr_session * s, struct tr_turtle_info * t )
+userPokedTheClock (tr_session * s, struct tr_turtle_info * t)
 {
-    tr_dbg( "Refreshing the turtle mode clock due to user changes" );
+    tr_dbg ("Refreshing the turtle mode clock due to user changes");
 
     t->autoTurtleState = TR_AUTO_SWITCH_UNUSED;
 
-    turtleUpdateTable( t );
+    turtleUpdateTable (t);
 
-    if( t->isClockEnabled )
+    if (t->isClockEnabled)
     {
-        const bool enabled = getInTurtleTime( t );
-        useAltSpeed( s, t, enabled, true );
-        t->autoTurtleState = autoSwitchState( enabled );
+        const bool enabled = getInTurtleTime (t);
+        useAltSpeed (s, t, enabled, true);
+        t->autoTurtleState = autoSwitchState (enabled);
     }
 }
 
 void
-tr_sessionUseAltSpeedTime( tr_session * s, bool b )
+tr_sessionUseAltSpeedTime (tr_session * s, bool b)
 {
     struct tr_turtle_info * t = &s->turtle;
 
-    assert( tr_isSession( s ) );
-    assert( tr_isBool ( b ) );
+    assert (tr_isSession (s));
+    assert (tr_isBool (b));
 
-    if( t->isClockEnabled != b ) {
+    if (t->isClockEnabled != b) {
         t->isClockEnabled = b;
-        userPokedTheClock( s, t );
+        userPokedTheClock (s, t);
     }
 }
 
 bool
-tr_sessionUsesAltSpeedTime( const tr_session * s )
+tr_sessionUsesAltSpeedTime (const tr_session * s)
 {
-    assert( tr_isSession( s ) );
+    assert (tr_isSession (s));
 
     return s->turtle.isClockEnabled;
 }
 
 void
-tr_sessionSetAltSpeedBegin( tr_session * s, int minute )
+tr_sessionSetAltSpeedBegin (tr_session * s, int minute)
 {
-    assert( tr_isSession( s ) );
-    assert( 0<=minute && minute<(60*24) );
+    assert (tr_isSession (s));
+    assert (0<=minute && minute< (60*24));
 
-    if( s->turtle.beginMinute != minute ) {
+    if (s->turtle.beginMinute != minute) {
         s->turtle.beginMinute = minute;
-        userPokedTheClock( s, &s->turtle );
+        userPokedTheClock (s, &s->turtle);
     }
 }
 
 int
-tr_sessionGetAltSpeedBegin( const tr_session * s )
+tr_sessionGetAltSpeedBegin (const tr_session * s)
 {
-    assert( tr_isSession( s ) );
+    assert (tr_isSession (s));
 
     return s->turtle.beginMinute;
 }
 
 void
-tr_sessionSetAltSpeedEnd( tr_session * s, int minute )
+tr_sessionSetAltSpeedEnd (tr_session * s, int minute)
 {
-    assert( tr_isSession( s ) );
-    assert( 0<=minute && minute<(60*24) );
+    assert (tr_isSession (s));
+    assert (0<=minute && minute< (60*24));
 
-    if( s->turtle.endMinute != minute ) {
+    if (s->turtle.endMinute != minute) {
         s->turtle.endMinute = minute;
-        userPokedTheClock( s, &s->turtle );
+        userPokedTheClock (s, &s->turtle);
     }
 }
 
 int
-tr_sessionGetAltSpeedEnd( const tr_session * s )
+tr_sessionGetAltSpeedEnd (const tr_session * s)
 {
-    assert( tr_isSession( s ) );
+    assert (tr_isSession (s));
 
     return s->turtle.endMinute;
 }
 
 void
-tr_sessionSetAltSpeedDay( tr_session * s, tr_sched_day days )
+tr_sessionSetAltSpeedDay (tr_session * s, tr_sched_day days)
 {
-    assert( tr_isSession( s ) );
+    assert (tr_isSession (s));
 
-    if( s->turtle.days != days ) {
+    if (s->turtle.days != days) {
         s->turtle.days = days;
-        userPokedTheClock( s, &s->turtle );
+        userPokedTheClock (s, &s->turtle);
     }
 }
 
 tr_sched_day
-tr_sessionGetAltSpeedDay( const tr_session * s )
+tr_sessionGetAltSpeedDay (const tr_session * s)
 {
-    assert( tr_isSession( s ) );
+    assert (tr_isSession (s));
 
     return s->turtle.days;
 }
 
 void
-tr_sessionUseAltSpeed( tr_session * session, bool enabled )
+tr_sessionUseAltSpeed (tr_session * session, bool enabled)
 {
-    useAltSpeed( session, &session->turtle, enabled, true );
+    useAltSpeed (session, &session->turtle, enabled, true);
 }
 
 bool
-tr_sessionUsesAltSpeed( const tr_session * s )
+tr_sessionUsesAltSpeed (const tr_session * s)
 {
-    assert( tr_isSession( s ) );
+    assert (tr_isSession (s));
 
     return s->turtle.isEnabled;
 }
 
 void
-tr_sessionSetAltSpeedFunc( tr_session       * session,
+tr_sessionSetAltSpeedFunc (tr_session       * session,
                            tr_altSpeedFunc    func,
-                           void             * userData )
+                           void             * userData)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->turtle.callback = func;
     session->turtle.callbackUserData = userData;
 }
 
 void
-tr_sessionClearAltSpeedFunc( tr_session * session )
+tr_sessionClearAltSpeedFunc (tr_session * session)
 {
-    tr_sessionSetAltSpeedFunc( session, NULL, NULL );
+    tr_sessionSetAltSpeedFunc (session, NULL, NULL);
 }
 
 /***
@@ -1615,33 +1617,33 @@ tr_sessionClearAltSpeedFunc( tr_session * session )
 ***/
 
 void
-tr_sessionSetPeerLimit( tr_session * session, uint16_t n )
+tr_sessionSetPeerLimit (tr_session * session, uint16_t n)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->peerLimit = n;
 }
 
 uint16_t
-tr_sessionGetPeerLimit( const tr_session * session )
+tr_sessionGetPeerLimit (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->peerLimit;
 }
 
 void
-tr_sessionSetPeerLimitPerTorrent( tr_session  * session, uint16_t n )
+tr_sessionSetPeerLimitPerTorrent (tr_session  * session, uint16_t n)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->peerLimitPerTorrent = n;
 }
 
 uint16_t
-tr_sessionGetPeerLimitPerTorrent( const tr_session * session )
+tr_sessionGetPeerLimitPerTorrent (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->peerLimitPerTorrent;
 }
@@ -1651,33 +1653,33 @@ tr_sessionGetPeerLimitPerTorrent( const tr_session * session )
 ***/
 
 void
-tr_sessionSetPaused( tr_session * session, bool isPaused )
+tr_sessionSetPaused (tr_session * session, bool isPaused)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->pauseAddedTorrent = isPaused;
 }
 
 bool
-tr_sessionGetPaused( const tr_session * session )
+tr_sessionGetPaused (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->pauseAddedTorrent;
 }
 
 void
-tr_sessionSetDeleteSource( tr_session * session, bool deleteSource )
+tr_sessionSetDeleteSource (tr_session * session, bool deleteSource)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->deleteSourceTorrent = deleteSource;
 }
 
 bool
-tr_sessionGetDeleteSource( const tr_session * session )
+tr_sessionGetDeleteSource (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->deleteSourceTorrent;
 }
@@ -1687,199 +1689,199 @@ tr_sessionGetDeleteSource( const tr_session * session )
 ***/
 
 unsigned int
-tr_sessionGetPieceSpeed_Bps( const tr_session * session, tr_direction dir )
+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;
 }
 
 unsigned int
-tr_sessionGetRawSpeed_Bps( const tr_session * session, tr_direction dir )
+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 )
+tr_sessionGetRawSpeed_KBps (const tr_session * session, tr_direction dir)
 {
-    return toSpeedKBps( tr_sessionGetRawSpeed_Bps( session, dir ) );
+    return toSpeedKBps (tr_sessionGetRawSpeed_Bps (session, dir));
 }
 
 
 int
-tr_sessionCountTorrents( const tr_session * session )
+tr_sessionCountTorrents (const tr_session * session)
 {
-    return tr_isSession( session ) ? session->torrentCount : 0;
+    return tr_isSession (session) ? session->torrentCount : 0;
 }
 
 static int
-compareTorrentByCur( const void * va, const void * vb )
+compareTorrentByCur (const void * va, const void * vb)
 {
-    const tr_torrent * a = *(const tr_torrent**)va;
-    const tr_torrent * b = *(const tr_torrent**)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 )
+    if (aCur != bCur)
         return aCur > bCur ? -1 : 1; /* close the biggest torrents first */
 
     return 0;
 }
 
-static void closeBlocklists( tr_session * );
+static void closeBlocklists (tr_session *);
 
 static void
-sessionCloseImpl( void * vsession )
+sessionCloseImpl (void * vsession)
 {
     tr_session *  session = vsession;
     tr_torrent *  tor;
     int           i, n;
     tr_torrent ** torrents;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    free_incoming_peer_port( session );
+    free_incoming_peer_port (session);
 
-    if( session->isLPDEnabled )
-        tr_lpdUninit( session );
+    if (session->isLPDEnabled)
+        tr_lpdUninit (session);
 
-    tr_utpClose( session );
-    tr_dhtUninit( session );
+    tr_utpClose (session);
+    tr_dhtUninit (session);
 
-    event_free( session->saveTimer );
+    event_free (session->saveTimer);
     session->saveTimer = NULL;
 
-    event_free( session->nowTimer );
+    event_free (session->nowTimer);
     session->nowTimer = NULL;
 
-    tr_verifyClose( session );
-    tr_sharedClose( session );
-    tr_rpcClose( &session->rpcServer );
+    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 );
+    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 );
+       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_webClose (session, TR_WEB_CLOSE_WHEN_IDLE);
 
-    tr_cacheFree( session->cache );
+    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 );
+    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 );
+    evdns_base_free (session->evdns_base, 0);
     session->evdns_base = NULL;
-    tr_tracker_udp_close( session );
-    tr_udpUninit( session );
+    tr_tracker_udp_close (session);
+    tr_udpUninit (session);
 
-    tr_statsClose( session );
-    tr_peerMgrFree( session->peerMgr );
+    tr_statsClose (session);
+    tr_peerMgrFree (session->peerMgr);
 
-    closeBlocklists( session );
+    closeBlocklists (session);
 
-    tr_fdClose( session );
+    tr_fdClose (session);
 
     session->isClosed = true;
 }
 
 static int
-deadlineReached( const time_t deadline )
+deadlineReached (const time_t deadline)
 {
-    return time( NULL ) >= deadline;
+    return time (NULL) >= deadline;
 }
 
 #define SHUTDOWN_MAX_SECONDS 20
 
 void
-tr_sessionClose( tr_session * session )
+tr_sessionClose (tr_session * session)
 {
-    const time_t deadline = time( NULL ) + SHUTDOWN_MAX_SECONDS;
+    const time_t deadline = time (NULL) + SHUTDOWN_MAX_SECONDS;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    dbgmsg( "shutting down transmission session %p... now is %zu, deadline is %zu", session, (size_t)time(NULL), (size_t)deadline );
+    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 ) )
+    tr_runInEventThread (session, sessionCloseImpl, session);
+    while (!session->isClosed && !deadlineReached (deadline))
     {
-        dbgmsg( "waiting for the libtransmission thread to finish" );
-        tr_wait_msec( 100 );
+        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 ) )
+    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( 100 );
+        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 (100);
     }
 
-    tr_webClose( session, TR_WEB_CLOSE_NOW );
+    tr_webClose (session, TR_WEB_CLOSE_NOW);
 
     /* close the libtransmission thread */
-    tr_eventClose( session );
-    while( session->events != NULL )
+    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( 500 );
-        if( deadlineReached( deadline ) && !forced )
+        dbgmsg ("waiting for libtransmission thread to finish... now %zu deadline %zu", (size_t)time (NULL), (size_t)deadline);
+        tr_wait_msec (500);
+        if (deadlineReached (deadline) && !forced)
         {
-            dbgmsg( "calling event_loopbreak()" );
+            dbgmsg ("calling event_loopbreak ()");
             forced = true;
-            event_base_loopbreak( session->event_base );
+            event_base_loopbreak (session->event_base);
         }
-        if( deadlineReached( deadline+3 ) )
+        if (deadlineReached (deadline+3))
         {
-            dbgmsg( "deadline+3 reached... calling break...\n" );
+            dbgmsg ("deadline+3 reached... calling break...\n");
             break;
         }
     }
 
     /* free the session memory */
-    tr_bencFree( &session->removedTorrents );
-    tr_bandwidthDestruct( &session->bandwidth );
-    tr_bitfieldDestruct( &session->turtle.minutes );
-    tr_lockFree( session->lock );
-    if( session->metainfoLookup ) {
-        tr_bencFree( session->metainfoLookup );
-        tr_free( session->metainfoLookup );
+    tr_bencFree (&session->removedTorrents);
+    tr_bandwidthDestruct (&session->bandwidth);
+    tr_bitfieldDestruct (&session->turtle.minutes);
+    tr_lockFree (session->lock);
+    if (session->metainfoLookup) {
+        tr_bencFree (session->metainfoLookup);
+        tr_free (session->metainfoLookup);
     }
-    tr_free( session->torrentDoneScript );
-    tr_free( session->tag );
-    tr_free( session->configDir );
-    tr_free( session->resumeDir );
-    tr_free( session->torrentDir );
-    tr_free( session->downloadDir );
-    tr_free( session->incompleteDir );
-    tr_free( session->blocklist_url );
-    tr_free( session->peer_congestion_algorithm );
-    tr_free( session );
+    tr_free (session->torrentDoneScript);
+    tr_free (session->tag);
+    tr_free (session->configDir);
+    tr_free (session->resumeDir);
+    tr_free (session->torrentDir);
+    tr_free (session->downloadDir);
+    tr_free (session->incompleteDir);
+    tr_free (session->blocklist_url);
+    tr_free (session->peer_congestion_algorithm);
+    tr_free (session);
 }
 
 struct sessionLoadTorrentsData
@@ -1892,7 +1894,7 @@ struct sessionLoadTorrentsData
 };
 
 static void
-sessionLoadTorrents( void * vdata )
+sessionLoadTorrents (void * vdata)
 {
     int i;
     int n = 0;
@@ -1901,55 +1903,55 @@ sessionLoadTorrents( void * vdata )
     tr_list * l = NULL;
     tr_list * list = NULL;
     struct sessionLoadTorrentsData * data = vdata;
-    const char * dirname = tr_getTorrentDir( data->session );
+    const char * dirname = tr_getTorrentDir (data->session);
 
-    assert( tr_isSession( data->session ) );
+    assert (tr_isSession (data->session));
 
-    tr_ctorSetSave( data->ctor, false ); /* since we already have them */
+    tr_ctorSetSave (data->ctor, false); /* since we already have them */
 
-    if( !stat( dirname, &sb )
-      && S_ISDIR( sb.st_mode )
-      && ( ( odir = opendir ( dirname ) ) ) )
+    if (!stat (dirname, &sb)
+      && S_ISDIR (sb.st_mode)
+      && ((odir = opendir (dirname))))
     {
         struct dirent *d;
-        for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
+        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 )))
+                char * path = tr_buildPath (dirname, d->d_name, NULL);
+                tr_ctorSetMetainfoFromFile (data->ctor, path);
+                if ((tor = tr_torrentNew (data->ctor, NULL)))
                 {
-                    tr_list_prepend( &list, tor );
+                    tr_list_prepend (&list, tor);
                     ++n;
                 }
-                tr_free( path );
+                tr_free (path);
             }
         }
-        closedir( odir );
+        closedir (odir);
     }
 
-    data->torrents = tr_new( tr_torrent *, n );
-    for( i = 0, l = list; l != NULL; l = l->next )
+    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 );
+    assert (i == n);
 
-    tr_list_free( &list, NULL );
+    tr_list_free (&list, NULL);
 
-    if( n )
-        tr_inf( _( "Loaded %d torrents" ), n );
+    if (n)
+        tr_inf (_ ("Loaded %d torrents"), n);
 
-    if( data->setmeCount )
+    if (data->setmeCount)
         *data->setmeCount = n;
 
     data->done = true;
 }
 
 tr_torrent **
-tr_sessionLoadTorrents( tr_session * session,
+tr_sessionLoadTorrents (tr_session * session,
                         tr_ctor    * ctor,
-                        int        * setmeCount )
+                        int        * setmeCount)
 {
     struct sessionLoadTorrentsData data;
 
@@ -1959,9 +1961,9 @@ tr_sessionLoadTorrents( tr_session * session,
     data.torrents = NULL;
     data.done = false;
 
-    tr_runInEventThread( session, sessionLoadTorrents, &data );
-    while( !data.done )
-        tr_wait_msec( 100 );
+    tr_runInEventThread (session, sessionLoadTorrents, &data);
+    while (!data.done)
+        tr_wait_msec (100);
 
     return data.torrents;
 }
@@ -1971,54 +1973,54 @@ tr_sessionLoadTorrents( tr_session * session,
 ***/
 
 void
-tr_sessionSetPexEnabled( tr_session * session, bool enabled )
+tr_sessionSetPexEnabled (tr_session * session, bool enabled)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->isPexEnabled = enabled != 0;
 }
 
 bool
-tr_sessionIsPexEnabled( const tr_session * session )
+tr_sessionIsPexEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isPexEnabled;
 }
 
 bool
-tr_sessionAllowsDHT( const tr_session * session )
+tr_sessionAllowsDHT (const tr_session * session)
 {
-    return tr_sessionIsDHTEnabled( session );
+    return tr_sessionIsDHTEnabled (session);
 }
 
 bool
-tr_sessionIsDHTEnabled( const tr_session * session )
+tr_sessionIsDHTEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isDHTEnabled;
 }
 
 static void
-toggleDHTImpl(  void * data )
+toggleDHTImpl (void * data)
 {
     tr_session * session = data;
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_udpUninit( session );
+    tr_udpUninit (session);
     session->isDHTEnabled = !session->isDHTEnabled;
-    tr_udpInit( session );
+    tr_udpInit (session);
 }
 
 void
-tr_sessionSetDHTEnabled( tr_session * session, bool enabled )
+tr_sessionSetDHTEnabled (tr_session * session, bool enabled)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isBool( enabled ) );
+    assert (tr_isSession (session));
+    assert (tr_isBool (enabled));
 
-    if( ( enabled != 0 ) != ( session->isDHTEnabled != 0 ) )
-        tr_runInEventThread( session, toggleDHTImpl, session );
+    if ((enabled != 0) != (session->isDHTEnabled != 0))
+        tr_runInEventThread (session, toggleDHTImpl, session);
 }
 
 /***
@@ -2026,9 +2028,9 @@ tr_sessionSetDHTEnabled( tr_session * session, bool enabled )
 ***/
 
 bool
-tr_sessionIsUTPEnabled( const tr_session * session )
+tr_sessionIsUTPEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
 #ifdef WITH_UTP
     return session->isUTPEnabled;
@@ -2038,27 +2040,27 @@ tr_sessionIsUTPEnabled( const tr_session * session )
 }
 
 static void
-toggle_utp(  void * data )
+toggle_utp (void * data)
 {
     tr_session * session = data;
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->isUTPEnabled = !session->isUTPEnabled;
 
-    tr_udpSetSocketBuffers( session );
+    tr_udpSetSocketBuffers (session);
 
     /* But don't call tr_utpClose -- see reset_timer in tr-utp.c for an
        explanation. */
 }
 
 void
-tr_sessionSetUTPEnabled( tr_session * session, bool enabled )
+tr_sessionSetUTPEnabled (tr_session * session, bool enabled)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isBool( enabled ) );
+    assert (tr_isSession (session));
+    assert (tr_isBool (enabled));
 
-    if( ( enabled != 0 ) != ( session->isUTPEnabled != 0 ) )
-        tr_runInEventThread( session, toggle_utp, session );
+    if ((enabled != 0) != (session->isUTPEnabled != 0))
+        tr_runInEventThread (session, toggle_utp, session);
 }
 
 /***
@@ -2066,42 +2068,42 @@ tr_sessionSetUTPEnabled( tr_session * session, bool enabled )
 ***/
 
 static void
-toggleLPDImpl(  void * data )
+toggleLPDImpl (void * data)
 {
     tr_session * session = data;
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    if( session->isLPDEnabled )
-        tr_lpdUninit( session );
+    if (session->isLPDEnabled)
+        tr_lpdUninit (session);
 
     session->isLPDEnabled = !session->isLPDEnabled;
 
-    if( session->isLPDEnabled )
-        tr_lpdInit( session, &session->public_ipv4->addr );
+    if (session->isLPDEnabled)
+        tr_lpdInit (session, &session->public_ipv4->addr);
 }
 
 void
-tr_sessionSetLPDEnabled( tr_session * session, bool enabled )
+tr_sessionSetLPDEnabled (tr_session * session, bool enabled)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isBool( enabled ) );
+    assert (tr_isSession (session));
+    assert (tr_isBool (enabled));
 
-    if( ( enabled != 0 ) != ( session->isLPDEnabled != 0 ) )
-        tr_runInEventThread( session, toggleLPDImpl, session );
+    if ((enabled != 0) != (session->isLPDEnabled != 0))
+        tr_runInEventThread (session, toggleLPDImpl, session);
 }
 
 bool
-tr_sessionIsLPDEnabled( const tr_session * session )
+tr_sessionIsLPDEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isLPDEnabled;
 }
 
 bool
-tr_sessionAllowsLPD( const tr_session * session )
+tr_sessionAllowsLPD (const tr_session * session)
 {
-    return tr_sessionIsLPDEnabled( session );
+    return tr_sessionIsLPDEnabled (session);
 }
 
 /***
@@ -2109,19 +2111,19 @@ tr_sessionAllowsLPD( const tr_session * session )
 ***/
 
 void
-tr_sessionSetCacheLimit_MB( tr_session * session, int max_bytes )
+tr_sessionSetCacheLimit_MB (tr_session * session, int max_bytes)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_cacheSetLimit( session->cache, toMemBytes( max_bytes ) );
+    tr_cacheSetLimit (session->cache, toMemBytes (max_bytes));
 }
 
 int
-tr_sessionGetCacheLimit_MB( const tr_session * session )
+tr_sessionGetCacheLimit_MB (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return toMemMB( tr_cacheGetLimit( session->cache ) );
+    return toMemMB (tr_cacheGetLimit (session->cache));
 }
 
 /***
@@ -2135,29 +2137,29 @@ struct port_forwarding_data
 };
 
 static void
-setPortForwardingEnabled( void * vdata )
+setPortForwardingEnabled (void * vdata)
 {
     struct port_forwarding_data * data = vdata;
-    tr_sharedTraversalEnable( data->shared, data->enabled );
-    tr_free( data );
+    tr_sharedTraversalEnable (data->shared, data->enabled);
+    tr_free (data);
 }
 
 void
-tr_sessionSetPortForwardingEnabled( tr_session  * session, bool enabled )
+tr_sessionSetPortForwardingEnabled (tr_session  * session, bool enabled)
 {
     struct port_forwarding_data * d;
-    d = tr_new0( struct port_forwarding_data, 1 );
+    d = tr_new0 (struct port_forwarding_data, 1);
     d->shared = session->shared;
     d->enabled = enabled;
-    tr_runInEventThread( session, setPortForwardingEnabled, d );
+    tr_runInEventThread (session, setPortForwardingEnabled, d);
 }
 
 bool
-tr_sessionIsPortForwardingEnabled( const tr_session * session )
+tr_sessionIsPortForwardingEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_sharedTraversalIsEnabled( session->shared );
+    return tr_sharedTraversalIsEnabled (session->shared);
 }
 
 /***
@@ -2165,16 +2167,16 @@ tr_sessionIsPortForwardingEnabled( const tr_session * session )
 ***/
 
 static int
-tr_stringEndsWith( const char * str, const char * end )
+tr_stringEndsWith (const char * str, const char * end)
 {
-    const size_t slen = strlen( str );
-    const size_t elen = strlen( end );
+    const size_t slen = strlen (str);
+    const size_t elen = strlen (end);
 
-    return slen >= elen && !memcmp( &str[slen - elen], end, elen );
+    return slen >= elen && !memcmp (&str[slen - elen], end, elen);
 }
 
 static void
-loadBlocklists( tr_session * session )
+loadBlocklists (tr_session * session)
 {
     int         binCount = 0;
     int         newCount = 0;
@@ -2185,30 +2187,30 @@ loadBlocklists( tr_session * session )
     const bool  isEnabled = session->isBlocklistEnabled;
 
     /* walk through the directory and find blocklists */
-    dirname = tr_buildPath( session->configDir, "blocklists", NULL );
-    if( !stat( dirname,
-               &sb ) && S_ISDIR( sb.st_mode )
-      && ( ( odir = opendir( dirname ) ) ) )
+    dirname = tr_buildPath (session->configDir, "blocklists", NULL);
+    if (!stat (dirname,
+               &sb) && S_ISDIR (sb.st_mode)
+      && ((odir = opendir (dirname))))
     {
         struct dirent *d;
-        for( d = readdir( odir ); d; d = readdir( odir ) )
+        for (d = readdir (odir); d; d = readdir (odir))
         {
             char * filename;
 
-            if( !d->d_name || d->d_name[0] == '.' ) /* skip dotfiles, ., and ..
+            if (!d->d_name || d->d_name[0] == '.') /* skip dotfiles, ., and ..
                                                       */
                 continue;
 
-            filename = tr_buildPath( dirname, d->d_name, NULL );
+            filename = tr_buildPath (dirname, d->d_name, NULL);
 
-            if( tr_stringEndsWith( filename, ".bin" ) )
+            if (tr_stringEndsWith (filename, ".bin"))
             {
                 /* if we don't already have this blocklist, add it */
-                if( !tr_list_find( list, filename,
-                                   (TrListCompareFunc)strcmp ) )
+                if (!tr_list_find (list, filename,
+                                 (TrListCompareFunc)strcmp))
                 {
-                    tr_list_append( &list,
-                                   _tr_blocklistNew( filename, isEnabled ) );
+                    tr_list_append (&list,
+                                   _tr_blocklistNew (filename, isEnabled));
                     ++binCount;
                 }
             }
@@ -2217,146 +2219,146 @@ loadBlocklists( tr_session * session )
                 /* strip out the file suffix, if there is one, and add ".bin"
                   instead */
                 tr_blocklist * b;
-                const char *   dot = strrchr( d->d_name, '.' );
+                const char *   dot = strrchr (d->d_name, '.');
                 const int      len = dot ? dot - d->d_name
-                                         : (int)strlen( d->d_name );
-                char         * tmp = tr_strdup_printf(
+                                         : (int)strlen (d->d_name);
+                char         * tmp = tr_strdup_printf (
                                         "%s" TR_PATH_DELIMITER_STR "%*.*s.bin",
-                                        dirname, len, len, d->d_name );
-                b = _tr_blocklistNew( tmp, isEnabled );
-                _tr_blocklistSetContent( b, filename );
-                tr_list_append( &list, b );
+                                        dirname, len, len, d->d_name);
+                b = _tr_blocklistNew (tmp, isEnabled);
+                _tr_blocklistSetContent (b, filename);
+                tr_list_append (&list, b);
                 ++newCount;
-                tr_free( tmp );
+                tr_free (tmp);
             }
 
-            tr_free( filename );
+            tr_free (filename);
         }
 
-        closedir( odir );
+        closedir (odir);
     }
 
     session->blocklists = list;
 
-    if( binCount )
-        tr_dbg( "Found %d blocklists in \"%s\"", binCount, dirname );
-    if( newCount )
-        tr_dbg( "Found %d new blocklists in \"%s\"", newCount, dirname );
+    if (binCount)
+        tr_dbg ("Found %d blocklists in \"%s\"", binCount, dirname);
+    if (newCount)
+        tr_dbg ("Found %d new blocklists in \"%s\"", newCount, dirname);
 
-    tr_free( dirname );
+    tr_free (dirname);
 }
 
 static void
-closeBlocklists( tr_session * session )
+closeBlocklists (tr_session * session)
 {
-    tr_list_free( &session->blocklists,
-                  (TrListForeachFunc)_tr_blocklistFree );
+    tr_list_free (&session->blocklists,
+                (TrListForeachFunc)_tr_blocklistFree);
 }
 
 void
-tr_sessionReloadBlocklists( tr_session * session )
+tr_sessionReloadBlocklists (tr_session * session)
 {
-    closeBlocklists( session );
-    loadBlocklists( session );
+    closeBlocklists (session);
+    loadBlocklists (session);
 
-    tr_peerMgrOnBlocklistChanged( session->peerMgr );
+    tr_peerMgrOnBlocklistChanged (session->peerMgr);
 }
 
 int
-tr_blocklistGetRuleCount( const tr_session * session )
+tr_blocklistGetRuleCount (const tr_session * session)
 {
     int       n = 0;
     tr_list * l;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    for( l = session->blocklists; l; l = l->next )
-        n += _tr_blocklistGetRuleCount( l->data );
+    for (l = session->blocklists; l; l = l->next)
+        n += _tr_blocklistGetRuleCount (l->data);
     return n;
 }
 
 bool
-tr_blocklistIsEnabled( const tr_session * session )
+tr_blocklistIsEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isBlocklistEnabled;
 }
 
 void
-tr_blocklistSetEnabled( tr_session * session, bool isEnabled )
+tr_blocklistSetEnabled (tr_session * session, bool isEnabled)
 {
     tr_list * l;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->isBlocklistEnabled = isEnabled != 0;
 
-    for( l=session->blocklists; l!=NULL; l=l->next )
-        _tr_blocklistSetEnabled( l->data, isEnabled );
+    for (l=session->blocklists; l!=NULL; l=l->next)
+        _tr_blocklistSetEnabled (l->data, isEnabled);
 }
 
 bool
-tr_blocklistExists( const tr_session * session )
+tr_blocklistExists (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->blocklists != NULL;
 }
 
 int
-tr_blocklistSetContent( tr_session * session, const char * contentFilename )
+tr_blocklistSetContent (tr_session * session, const char * contentFilename)
 {
     tr_list * l;
     int ruleCount;
     tr_blocklist * b;
     const char * defaultName = DEFAULT_BLOCKLIST_FILENAME;
-    tr_sessionLock( session );
+    tr_sessionLock (session);
 
-    for( b = NULL, l = session->blocklists; !b && l; l = l->next )
-        if( tr_stringEndsWith( _tr_blocklistGetFilename( l->data ),
-                               defaultName ) )
+    for (b = NULL, l = session->blocklists; !b && l; l = l->next)
+        if (tr_stringEndsWith (_tr_blocklistGetFilename (l->data),
+                               defaultName))
             b = l->data;
 
-    if( !b )
+    if (!b)
     {
-        char * path = tr_buildPath( session->configDir, "blocklists", defaultName, NULL );
-        b = _tr_blocklistNew( path, session->isBlocklistEnabled );
-        tr_list_append( &session->blocklists, b );
-        tr_free( path );
+        char * path = tr_buildPath (session->configDir, "blocklists", defaultName, NULL);
+        b = _tr_blocklistNew (path, session->isBlocklistEnabled);
+        tr_list_append (&session->blocklists, b);
+        tr_free (path);
     }
 
-    ruleCount = _tr_blocklistSetContent( b, contentFilename );
-    tr_sessionUnlock( session );
+    ruleCount = _tr_blocklistSetContent (b, contentFilename);
+    tr_sessionUnlock (session);
     return ruleCount;
 }
 
 bool
-tr_sessionIsAddressBlocked( const tr_session * session,
-                            const tr_address * addr )
+tr_sessionIsAddressBlocked (const tr_session * session,
+                            const tr_address * addr)
 {
     tr_list * l;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    for( l = session->blocklists; l; l = l->next )
-        if( _tr_blocklistHasAddress( l->data, addr ) )
+    for (l = session->blocklists; l; l = l->next)
+        if (_tr_blocklistHasAddress (l->data, addr))
             return true;
     return false;
 }
 
 void
-tr_blocklistSetURL( tr_session * session, const char * url )
+tr_blocklistSetURL (tr_session * session, const char * url)
 {
-    if( session->blocklist_url != url )
+    if (session->blocklist_url != url)
     {
-        tr_free( session->blocklist_url );
-        session->blocklist_url = tr_strdup( url );
+        tr_free (session->blocklist_url);
+        session->blocklist_url = tr_strdup (url);
     }
 }
 
 const char *
-tr_blocklistGetURL ( const tr_session * session )
+tr_blocklistGetURL (const tr_session * session)
 {
     return session->blocklist_url;
 }
@@ -2367,70 +2369,70 @@ tr_blocklistGetURL ( const tr_session * session )
 ***/
 
 static void
-metainfoLookupInit( tr_session * session )
+metainfoLookupInit (tr_session * session)
 {
     struct stat  sb;
-    const char * dirname = tr_getTorrentDir( session );
+    const char * dirname = tr_getTorrentDir (session);
     DIR *        odir = NULL;
     tr_ctor *    ctor = NULL;
     tr_benc * lookup;
     int n = 0;
 
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     /* walk through the directory and find the mappings */
-    lookup = tr_new0( tr_benc, 1 );
-    tr_bencInitDict( 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 ) ) ) )
+    lookup = tr_new0 (tr_benc, 1);
+    tr_bencInitDict (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 )))
+        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 ) )
+                char * path = tr_buildPath (dirname, d->d_name, NULL);
+                tr_ctorSetMetainfoFromFile (ctor, path);
+                if (!tr_torrentParse (ctor, &inf))
                 {
                     ++n;
-                    tr_bencDictAddStr( lookup, inf.hashString, path );
+                    tr_bencDictAddStr (lookup, inf.hashString, path);
                 }
-                tr_free( path );
+                tr_free (path);
             }
         }
-        closedir( odir );
+        closedir (odir);
     }
-    tr_ctorFree( ctor );
+    tr_ctorFree (ctor);
 
     session->metainfoLookup = lookup;
-    tr_dbg( "Found %d torrents in \"%s\"", n, dirname );
+    tr_dbg ("Found %d torrents in \"%s\"", n, dirname);
 }
 
 const char*
-tr_sessionFindTorrentFile( const tr_session * session,
-                           const char       * hashString )
+tr_sessionFindTorrentFile (const tr_session * session,
+                           const char       * hashString)
 {
     const char * filename = NULL;
-    if( !session->metainfoLookup )
-        metainfoLookupInit( (tr_session*)session );
-    tr_bencDictFindStr( session->metainfoLookup, hashString, &filename );
+    if (!session->metainfoLookup)
+        metainfoLookupInit ((tr_session*)session);
+    tr_bencDictFindStr (session->metainfoLookup, hashString, &filename);
     return filename;
 }
 
 void
-tr_sessionSetTorrentFile( tr_session * session,
+tr_sessionSetTorrentFile (tr_session * session,
                           const char * hashString,
-                          const char * filename )
+                          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
+     * 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_bencDictAddStr( session->metainfoLookup, hashString, filename );
+    if (session->metainfoLookup)
+        tr_bencDictAddStr (session->metainfoLookup, hashString, filename);
 }
 
 /***
@@ -2438,156 +2440,156 @@ tr_sessionSetTorrentFile( tr_session * session,
 ***/
 
 void
-tr_sessionSetRPCEnabled( tr_session * session, bool isEnabled )
+tr_sessionSetRPCEnabled (tr_session * session, bool isEnabled)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_rpcSetEnabled( session->rpcServer, isEnabled );
+    tr_rpcSetEnabled (session->rpcServer, isEnabled);
 }
 
 bool
-tr_sessionIsRPCEnabled( const tr_session * session )
+tr_sessionIsRPCEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcIsEnabled( session->rpcServer );
+    return tr_rpcIsEnabled (session->rpcServer);
 }
 
 void
-tr_sessionSetRPCPort( tr_session * session,
-                      tr_port      port )
+tr_sessionSetRPCPort (tr_session * session,
+                      tr_port      port)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_rpcSetPort( session->rpcServer, port );
+    tr_rpcSetPort (session->rpcServer, port);
 }
 
 tr_port
-tr_sessionGetRPCPort( const tr_session * session )
+tr_sessionGetRPCPort (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcGetPort( session->rpcServer );
+    return tr_rpcGetPort (session->rpcServer);
 }
 
 void
-tr_sessionSetRPCUrl( tr_session * session,
-                     const char * url )
+tr_sessionSetRPCUrl (tr_session * session,
+                     const char * url)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_rpcSetUrl( session->rpcServer, url );
+    tr_rpcSetUrl (session->rpcServer, url);
 }
 
 const char*
-tr_sessionGetRPCUrl( const tr_session * session )
+tr_sessionGetRPCUrl (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcGetUrl( session->rpcServer );
+    return tr_rpcGetUrl (session->rpcServer);
 }
 
 void
-tr_sessionSetRPCCallback( tr_session * session,
+tr_sessionSetRPCCallback (tr_session * session,
                           tr_rpc_func  func,
-                          void *       user_data )
+                          void *       user_data)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->rpc_func = func;
     session->rpc_func_user_data = user_data;
 }
 
 void
-tr_sessionSetRPCWhitelist( tr_session * session,
-                           const char * whitelist )
+tr_sessionSetRPCWhitelist (tr_session * session,
+                           const char * whitelist)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_rpcSetWhitelist( session->rpcServer, whitelist );
+    tr_rpcSetWhitelist (session->rpcServer, whitelist);
 }
 
 const char*
-tr_sessionGetRPCWhitelist( const tr_session * session )
+tr_sessionGetRPCWhitelist (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcGetWhitelist( session->rpcServer );
+    return tr_rpcGetWhitelist (session->rpcServer);
 }
 
 void
-tr_sessionSetRPCWhitelistEnabled( tr_session * session, bool isEnabled )
+tr_sessionSetRPCWhitelistEnabled (tr_session * session, bool isEnabled)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_rpcSetWhitelistEnabled( session->rpcServer, isEnabled );
+    tr_rpcSetWhitelistEnabled (session->rpcServer, isEnabled);
 }
 
 bool
-tr_sessionGetRPCWhitelistEnabled( const tr_session * session )
+tr_sessionGetRPCWhitelistEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcGetWhitelistEnabled( session->rpcServer );
+    return tr_rpcGetWhitelistEnabled (session->rpcServer);
 }
 
 
 void
-tr_sessionSetRPCPassword( tr_session * session,
-                          const char * password )
+tr_sessionSetRPCPassword (tr_session * session,
+                          const char * password)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_rpcSetPassword( session->rpcServer, password );
+    tr_rpcSetPassword (session->rpcServer, password);
 }
 
 const char*
-tr_sessionGetRPCPassword( const tr_session * session )
+tr_sessionGetRPCPassword (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcGetPassword( session->rpcServer );
+    return tr_rpcGetPassword (session->rpcServer);
 }
 
 void
-tr_sessionSetRPCUsername( tr_session * session,
-                          const char * username )
+tr_sessionSetRPCUsername (tr_session * session,
+                          const char * username)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_rpcSetUsername( session->rpcServer, username );
+    tr_rpcSetUsername (session->rpcServer, username);
 }
 
 const char*
-tr_sessionGetRPCUsername( const tr_session * session )
+tr_sessionGetRPCUsername (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcGetUsername( session->rpcServer );
+    return tr_rpcGetUsername (session->rpcServer);
 }
 
 void
-tr_sessionSetRPCPasswordEnabled( tr_session * session, bool isEnabled )
+tr_sessionSetRPCPasswordEnabled (tr_session * session, bool isEnabled)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    tr_rpcSetPasswordEnabled( session->rpcServer, isEnabled );
+    tr_rpcSetPasswordEnabled (session->rpcServer, isEnabled);
 }
 
 bool
-tr_sessionIsRPCPasswordEnabled( const tr_session * session )
+tr_sessionIsRPCPasswordEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcIsPasswordEnabled( session->rpcServer );
+    return tr_rpcIsPasswordEnabled (session->rpcServer);
 }
 
 const char *
-tr_sessionGetRPCBindAddress( const tr_session * session )
+tr_sessionGetRPCBindAddress (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    return tr_rpcGetBindAddress( session->rpcServer );
+    return tr_rpcGetBindAddress (session->rpcServer);
 }
 
 /****
@@ -2595,39 +2597,39 @@ tr_sessionGetRPCBindAddress( const tr_session * session )
 ****/
 
 bool
-tr_sessionIsTorrentDoneScriptEnabled( const tr_session * session )
+tr_sessionIsTorrentDoneScriptEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->isTorrentDoneScriptEnabled;
 }
 
 void
-tr_sessionSetTorrentDoneScriptEnabled( tr_session * session, bool isEnabled )
+tr_sessionSetTorrentDoneScriptEnabled (tr_session * session, bool isEnabled)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isBool( isEnabled ) );
+    assert (tr_isSession (session));
+    assert (tr_isBool (isEnabled));
 
     session->isTorrentDoneScriptEnabled = isEnabled;
 }
 
 const char *
-tr_sessionGetTorrentDoneScript( const tr_session * session )
+tr_sessionGetTorrentDoneScript (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->torrentDoneScript;
 }
 
 void
-tr_sessionSetTorrentDoneScript( tr_session * session, const char * scriptFilename )
+tr_sessionSetTorrentDoneScript (tr_session * session, const char * scriptFilename)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
-    if( session->torrentDoneScript != scriptFilename )
+    if (session->torrentDoneScript != scriptFilename)
     {
-        tr_free( session->torrentDoneScript );
-        session->torrentDoneScript = tr_strdup( scriptFilename );
+        tr_free (session->torrentDoneScript);
+        session->torrentDoneScript = tr_strdup (scriptFilename);
     }
 }
 
@@ -2636,97 +2638,97 @@ tr_sessionSetTorrentDoneScript( tr_session * session, const char * scriptFilenam
 ***/
 
 void
-tr_sessionSetQueueSize( tr_session * session, tr_direction dir, int n )
+tr_sessionSetQueueSize (tr_session * session, tr_direction dir, int n)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isSession (session));
+    assert (tr_isDirection (dir));
 
     session->queueSize[dir] = n;
 }
 
 int
-tr_sessionGetQueueSize( const tr_session * session, tr_direction dir )
+tr_sessionGetQueueSize (const tr_session * session, tr_direction dir)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isSession (session));
+    assert (tr_isDirection (dir));
 
     return session->queueSize[dir];
 }
 
 void
-tr_sessionSetQueueEnabled( tr_session * session, tr_direction dir, bool is_enabled )
+tr_sessionSetQueueEnabled (tr_session * session, tr_direction dir, bool is_enabled)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isDirection( dir ) );
-    assert( tr_isBool( is_enabled ) );
+    assert (tr_isSession (session));
+    assert (tr_isDirection (dir));
+    assert (tr_isBool (is_enabled));
 
     session->queueEnabled[dir] = is_enabled;
 }
 
 bool
-tr_sessionGetQueueEnabled( const tr_session * session, tr_direction dir )
+tr_sessionGetQueueEnabled (const tr_session * session, tr_direction dir)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isSession (session));
+    assert (tr_isDirection (dir));
 
     return session->queueEnabled[dir];
 }
 
 void
-tr_sessionSetQueueStalledMinutes( tr_session * session, int minutes )
+tr_sessionSetQueueStalledMinutes (tr_session * session, int minutes)
 {
-    assert( tr_isSession( session ) );
-    assert( minutes > 0 );
+    assert (tr_isSession (session));
+    assert (minutes > 0);
 
     session->queueStalledMinutes = minutes;
 }
 
 void
-tr_sessionSetQueueStalledEnabled( tr_session * session, bool is_enabled )
+tr_sessionSetQueueStalledEnabled (tr_session * session, bool is_enabled)
 {
-    assert( tr_isSession( session ) );
-    assert( tr_isBool( is_enabled ) );
+    assert (tr_isSession (session));
+    assert (tr_isBool (is_enabled));
 
     session->stalledEnabled = is_enabled;
 }
 
 bool
-tr_sessionGetQueueStalledEnabled( const tr_session * session )
+tr_sessionGetQueueStalledEnabled (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->stalledEnabled;
 }
 
 int
-tr_sessionGetQueueStalledMinutes( const tr_session * session )
+tr_sessionGetQueueStalledMinutes (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     return session->queueStalledMinutes;
 }
 
 tr_torrent *
-tr_sessionGetNextQueuedTorrent( tr_session * session, tr_direction direction )
+tr_sessionGetNextQueuedTorrent (tr_session * session, tr_direction direction)
 {
     tr_torrent * tor = NULL;
     tr_torrent * best_tor = NULL;
     int best_position = INT_MAX;
 
-    assert( tr_isSession( session ) );
-    assert( tr_isDirection( direction ) );
+    assert (tr_isSession (session));
+    assert (tr_isDirection (direction));
 
-    while(( tor = tr_torrentNext( session, tor )))
+    while ((tor = tr_torrentNext (session, tor)))
     {
         int position;
 
-        if( !tr_torrentIsQueued( tor ) )
+        if (!tr_torrentIsQueued (tor))
             continue;
-        if( direction != tr_torrentGetQueueDirection( tor ) )
+        if (direction != tr_torrentGetQueueDirection (tor))
             continue;
 
-        position = tr_torrentGetQueuePosition( tor );
-        if( best_position > position ) {
+        position = tr_torrentGetQueuePosition (tor);
+        if (best_position > position) {
             best_position = position;
             best_tor = tor;
         }
@@ -2736,24 +2738,24 @@ tr_sessionGetNextQueuedTorrent( tr_session * session, tr_direction direction )
 }
 
 int
-tr_sessionCountQueueFreeSlots( tr_session * session, tr_direction dir )
+tr_sessionCountQueueFreeSlots (tr_session * session, tr_direction dir)
 {
     tr_torrent * tor;
     int active_count;
-    const int max = tr_sessionGetQueueSize( session, dir );
+    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 ) )
+    if (!tr_sessionGetQueueEnabled (session, dir))
         return INT_MAX;
 
     tor = NULL;
     active_count = 0;
-    while(( tor = tr_torrentNext( session, tor )))
-        if( !tr_torrentIsStalled( tor ) )
-            if( tr_torrentGetActivity( tor ) == activity )
+    while ((tor = tr_torrentNext (session, tor)))
+        if (!tr_torrentIsStalled (tor))
+            if (tr_torrentGetActivity (tor) == activity)
                 ++active_count;
 
-    if( active_count >= max )
+    if (active_count >= max)
         return 0;
 
     return max - active_count;
diff --git a/libtransmission/session.h b/libtransmission/session.h
index 022d16f80..3c5f7b631 100644
--- a/libtransmission/session.h
+++ b/libtransmission/session.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -21,7 +21,7 @@
 
 #ifndef UNUSED
  #ifdef __GNUC__
-  #define UNUSED __attribute__ ( ( unused ) )
+  #define UNUSED __attribute__ ((unused))
  #else
   #define UNUSED
  #endif
@@ -45,7 +45,7 @@ enum
   PEER_ID_LEN = 20
 };
 
-void tr_peerIdInit( uint8_t * setme );
+void tr_peerIdInit (uint8_t * setme);
 
 struct event_base;
 struct evdns_base;
@@ -57,7 +57,7 @@ struct tr_bindsockets;
 struct tr_cache;
 struct tr_fdInfo;
 
-typedef void ( tr_web_config_func )( tr_session * session, void * curl_pointer, const char * url, void * user_data );
+typedef void (tr_web_config_func)(tr_session * session, void * curl_pointer, const char * url, void * user_data);
 
 struct tr_turtle_info
 {
@@ -226,75 +226,75 @@ struct tr_session
 };
 
 static inline tr_port
-tr_sessionGetPublicPeerPort( const tr_session * session )
+tr_sessionGetPublicPeerPort (const tr_session * session)
 {
     return session->public_peer_port;
 }
 
 static inline const uint8_t*
-tr_getPeerId( tr_session * session )
+tr_getPeerId (tr_session * session)
 {
     return session->peer_id;
 }
 
-bool         tr_sessionAllowsDHT( const tr_session * session );
+bool         tr_sessionAllowsDHT (const tr_session * session);
 
-bool         tr_sessionAllowsLPD( const tr_session * session );
+bool         tr_sessionAllowsLPD (const tr_session * session);
 
-const char * tr_sessionFindTorrentFile( const tr_session * session,
-                                        const char *       hashString );
+const char * tr_sessionFindTorrentFile (const tr_session * session,
+                                        const char *       hashString);
 
-void         tr_sessionSetTorrentFile( tr_session * session,
+void         tr_sessionSetTorrentFile (tr_session * session,
                                        const char * hashString,
-                                       const char * filename );
+                                       const char * filename);
 
-bool         tr_sessionIsAddressBlocked( const tr_session        * session,
-                                         const struct tr_address * addr );
+bool         tr_sessionIsAddressBlocked (const tr_session        * session,
+                                         const struct tr_address * addr);
 
-void         tr_sessionLock( tr_session * );
+void         tr_sessionLock (tr_session *);
 
-void         tr_sessionUnlock( tr_session * );
+void         tr_sessionUnlock (tr_session *);
 
-bool         tr_sessionIsLocked( const tr_session * );
+bool         tr_sessionIsLocked (const tr_session *);
 
-const struct tr_address*  tr_sessionGetPublicAddress( const tr_session  * session,
+const struct tr_address*  tr_sessionGetPublicAddress (const tr_session  * session,
                                                       int                 tr_af_type,
-                                                      bool              * is_default_value );
+                                                      bool              * is_default_value);
 
 
-struct tr_bindsockets * tr_sessionGetBindSockets( tr_session * );
+struct tr_bindsockets * tr_sessionGetBindSockets (tr_session *);
 
-int tr_sessionCountTorrents( const tr_session * session );
+int tr_sessionCountTorrents (const tr_session * session);
 
 enum
 {
     SESSION_MAGIC_NUMBER = 3845,
 };
 
-static inline bool tr_isSession( const tr_session * session )
+static inline bool tr_isSession (const tr_session * session)
 {
-    return ( session != NULL ) && ( session->magicNumber == SESSION_MAGIC_NUMBER );
+    return (session != NULL) && (session->magicNumber == SESSION_MAGIC_NUMBER);
 }
 
-static inline bool tr_isPreallocationMode( tr_preallocation_mode m  )
+static inline bool tr_isPreallocationMode (tr_preallocation_mode m)
 {
-    return ( m == TR_PREALLOCATE_NONE )
-        || ( m == TR_PREALLOCATE_SPARSE )
-        || ( m == TR_PREALLOCATE_FULL );
+    return (m == TR_PREALLOCATE_NONE)
+        || (m == TR_PREALLOCATE_SPARSE)
+        || (m == TR_PREALLOCATE_FULL);
 }
 
-static inline bool tr_isEncryptionMode( tr_encryption_mode m )
+static inline bool tr_isEncryptionMode (tr_encryption_mode m)
 {
-    return ( m == TR_CLEAR_PREFERRED )
-        || ( m == TR_ENCRYPTION_PREFERRED )
-        || ( m == TR_ENCRYPTION_REQUIRED );
+    return (m == TR_CLEAR_PREFERRED)
+        || (m == TR_ENCRYPTION_PREFERRED)
+        || (m == TR_ENCRYPTION_REQUIRED);
 }
 
-static inline bool tr_isPriority( tr_priority_t p )
+static inline bool tr_isPriority (tr_priority_t p)
 {
-    return ( p == TR_PRI_LOW )
-        || ( p == TR_PRI_NORMAL )
-        || ( p == TR_PRI_HIGH );
+    return (p == TR_PRI_LOW)
+        || (p == TR_PRI_NORMAL)
+        || (p == TR_PRI_HIGH);
 }
 
 /***
@@ -302,34 +302,34 @@ static inline bool tr_isPriority( tr_priority_t p )
 ***/
 
 static inline unsigned int
-toSpeedBytes ( unsigned int KBps ) { return KBps * tr_speed_K; }
+toSpeedBytes (unsigned int KBps) { return KBps * tr_speed_K; }
 static inline double
-toSpeedKBps  ( unsigned int Bps )  { return Bps / (double)tr_speed_K; }
+toSpeedKBps (unsigned int Bps)  { return Bps / (double)tr_speed_K; }
 
 static inline uint64_t
-toMemBytes ( unsigned int MB ) { uint64_t B = tr_mem_K * tr_mem_K; B *= MB; return B; }
+toMemBytes (unsigned int MB) { uint64_t B = tr_mem_K * tr_mem_K; B *= MB; return B; }
 static inline int
-toMemMB    ( uint64_t B )      { return B / ( tr_mem_K * tr_mem_K ); }
+toMemMB  (uint64_t B)      { return B / (tr_mem_K * tr_mem_K); }
 
 /**
 **/
 
-unsigned int  tr_sessionGetSpeedLimit_Bps( const tr_session *, tr_direction );
-unsigned int  tr_sessionGetAltSpeed_Bps  ( const tr_session *, tr_direction );
-unsigned int  tr_sessionGetRawSpeed_Bps  ( const tr_session *, tr_direction );
-unsigned int  tr_sessionGetPieceSpeed_Bps( const tr_session *, tr_direction );
+unsigned int  tr_sessionGetSpeedLimit_Bps (const tr_session *, tr_direction);
+unsigned int  tr_sessionGetAltSpeed_Bps (const tr_session *, tr_direction);
+unsigned int  tr_sessionGetRawSpeed_Bps (const tr_session *, tr_direction);
+unsigned int  tr_sessionGetPieceSpeed_Bps (const tr_session *, tr_direction);
 
-void tr_sessionSetSpeedLimit_Bps( tr_session *, tr_direction, unsigned int Bps );
-void tr_sessionSetAltSpeed_Bps  ( tr_session *, tr_direction, unsigned int Bps );
+void tr_sessionSetSpeedLimit_Bps (tr_session *, tr_direction, unsigned int Bps);
+void tr_sessionSetAltSpeed_Bps (tr_session *, tr_direction, unsigned int Bps);
 
-bool  tr_sessionGetActiveSpeedLimit_Bps( const tr_session  * session,
+bool  tr_sessionGetActiveSpeedLimit_Bps (const tr_session  * session,
                                          tr_direction        dir,
-                                         unsigned int      * setme );
+                                         unsigned int      * setme);
 
-tr_torrent * tr_sessionGetNextQueuedSeed( tr_session * session );
-tr_torrent * tr_sessionGetNextQueuedTorrent( tr_session * session, tr_direction );
+tr_torrent * tr_sessionGetNextQueuedSeed (tr_session * session);
+tr_torrent * tr_sessionGetNextQueuedTorrent (tr_session * session, tr_direction);
 
-int tr_sessionCountQueueFreeSlots( tr_session * session, tr_direction );
+int tr_sessionCountQueueFreeSlots (tr_session * session, tr_direction);
 
 
 #endif
diff --git a/libtransmission/stats.c b/libtransmission/stats.c
index 9b1c5155e..8ef555877 100644
--- a/libtransmission/stats.c
+++ b/libtransmission/stats.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -13,7 +13,7 @@
 #include "transmission.h"
 #include "session.h"
 #include "bencode.h"
-#include "platform.h" /* tr_sessionGetConfigDir() */
+#include "platform.h" /* tr_sessionGetConfigDir () */
 #include "stats.h"
 #include "utils.h" /* tr_buildPath */
 
@@ -26,82 +26,80 @@ static const struct tr_session_stats STATS_INIT = { 0.0f, 0, 0, 0, 0, 0 };
 /** @brief Opaque, per-session data structure for bandwidth use statistics */
 struct tr_stats_handle
 {
-    tr_session_stats    single;
-    tr_session_stats    old;
-    time_t              startTime;
-    bool                isDirty;
+  tr_session_stats  single;
+  tr_session_stats  old;
+  time_t            startTime;
+  bool              isDirty;
 };
 
 static char*
-getOldFilename( const tr_session * session )
+getOldFilename (const tr_session * session)
 {
-    return tr_buildPath( tr_sessionGetConfigDir( session ), "stats.benc", NULL );
+  return tr_buildPath (tr_sessionGetConfigDir (session), "stats.benc", NULL);
 }
 
 static char*
-getFilename( const tr_session * session )
+getFilename (const tr_session * session)
 {
-    return tr_buildPath( tr_sessionGetConfigDir( session ), "stats.json", NULL );
+  return tr_buildPath (tr_sessionGetConfigDir (session), "stats.json", NULL);
 }
 
 static void
-loadCumulativeStats( const tr_session * session,
-                     tr_session_stats * setme )
+loadCumulativeStats (const tr_session * session, tr_session_stats * setme)
 {
-    tr_benc top;
-    char * filename;
-    bool loaded = false;
+  tr_benc top;
+  char * filename;
+  bool loaded = false;
 
-    filename = getFilename( session );
-    loaded = !tr_bencLoadFile( &top, TR_FMT_JSON, filename );
-    tr_free( filename );
+  filename = getFilename (session);
+  loaded = !tr_bencLoadFile (&top, TR_FMT_JSON, filename);
+  tr_free (filename);
 
-    if( !loaded )
+  if (!loaded)
     {
-        filename = getOldFilename( session );
-        loaded = !tr_bencLoadFile( &top, TR_FMT_BENC, filename );
-        tr_free( filename );
+      filename = getOldFilename (session);
+      loaded = !tr_bencLoadFile (&top, TR_FMT_BENC, filename);
+      tr_free (filename);
     }
 
-    if( loaded )
+  if (loaded)
     {
-        int64_t i;
-
-        if( tr_bencDictFindInt( &top, "downloaded-bytes", &i ) )
-            setme->downloadedBytes = (uint64_t) i;
-        if( tr_bencDictFindInt( &top, "files-added", &i ) )
-            setme->filesAdded = (uint64_t) i;
-        if( tr_bencDictFindInt( &top, "seconds-active", &i ) )
-            setme->secondsActive = (uint64_t) i;
-        if( tr_bencDictFindInt( &top, "session-count", &i ) )
-            setme->sessionCount = (uint64_t) i;
-        if( tr_bencDictFindInt( &top, "uploaded-bytes", &i ) )
-            setme->uploadedBytes = (uint64_t) i;
-
-        tr_bencFree( &top );
+      int64_t i;
+
+      if (tr_bencDictFindInt (&top, "downloaded-bytes", &i))
+        setme->downloadedBytes = (uint64_t) i;
+      if (tr_bencDictFindInt (&top, "files-added", &i))
+        setme->filesAdded = (uint64_t) i;
+      if (tr_bencDictFindInt (&top, "seconds-active", &i))
+        setme->secondsActive = (uint64_t) i;
+      if (tr_bencDictFindInt (&top, "session-count", &i))
+        setme->sessionCount = (uint64_t) i;
+      if (tr_bencDictFindInt (&top, "uploaded-bytes", &i))
+        setme->uploadedBytes = (uint64_t) i;
+
+      tr_bencFree (&top);
     }
 }
 
 static void
-saveCumulativeStats( const tr_session * session,
-                     const tr_session_stats * s )
+saveCumulativeStats (const tr_session * session, const tr_session_stats * s)
 {
-    char * filename;
-    tr_benc top;
-
-    tr_bencInitDict( &top, 5 );
-    tr_bencDictAddInt( &top, "downloaded-bytes", s->downloadedBytes );
-    tr_bencDictAddInt( &top, "files-added",      s->filesAdded );
-    tr_bencDictAddInt( &top, "seconds-active",   s->secondsActive );
-    tr_bencDictAddInt( &top, "session-count",    s->sessionCount );
-    tr_bencDictAddInt( &top, "uploaded-bytes",   s->uploadedBytes );
-
-    filename = getFilename( session );
-    tr_deepLog( __FILE__, __LINE__, NULL, "Saving stats to \"%s\"", filename );
-    tr_bencToFile( &top, TR_FMT_JSON, filename );
-
-    tr_free( filename );
-    tr_bencFree( &top );
+  char * filename;
+  tr_benc top;
+
+  tr_bencInitDict (&top, 5);
+  tr_bencDictAddInt (&top, "downloaded-bytes", s->downloadedBytes);
+  tr_bencDictAddInt (&top, "files-added",      s->filesAdded);
+  tr_bencDictAddInt (&top, "seconds-active",   s->secondsActive);
+  tr_bencDictAddInt (&top, "session-count",    s->sessionCount);
+  tr_bencDictAddInt (&top, "uploaded-bytes",   s->uploadedBytes);
+
+  filename = getFilename (session);
+  tr_deepLog (__FILE__, __LINE__, NULL, "Saving stats to \"%s\"", filename);
+  tr_bencToFile (&top, TR_FMT_JSON, filename);
+
+  tr_free (filename);
+  tr_bencFree (&top);
 }
 
 /***
@@ -109,42 +107,43 @@ saveCumulativeStats( const tr_session * session,
 ***/
 
 void
-tr_statsInit( tr_session * session )
+tr_statsInit (tr_session * session)
 {
-    struct tr_stats_handle * stats = tr_new0( struct tr_stats_handle, 1 );
+  struct tr_stats_handle * stats = tr_new0 (struct tr_stats_handle, 1);
 
-    loadCumulativeStats( session, &stats->old );
-    stats->single.sessionCount = 1;
-    stats->startTime = tr_time( );
-    session->sessionStats = stats;
+  loadCumulativeStats (session, &stats->old);
+  stats->single.sessionCount = 1;
+  stats->startTime = tr_time ();
+  session->sessionStats = stats;
 }
 
 static struct tr_stats_handle *
-getStats( const tr_session * session )
+getStats (const tr_session * session)
 {
-    return session ? session->sessionStats : NULL;
+  return session ? session->sessionStats : NULL;
 }
 
 void
-tr_statsSaveDirty( tr_session * session )
+tr_statsSaveDirty (tr_session * session)
 {
-    struct tr_stats_handle * h = getStats( session );
-    if( ( h != NULL ) && h->isDirty )
+  struct tr_stats_handle * h = getStats (session);
+
+  if ((h != NULL) && h->isDirty)
     {
-        tr_session_stats cumulative = STATS_INIT;
-        tr_sessionGetCumulativeStats( session, &cumulative );
-        saveCumulativeStats( session, &cumulative );
-        h->isDirty = false;
+      tr_session_stats cumulative = STATS_INIT;
+      tr_sessionGetCumulativeStats (session, &cumulative);
+      saveCumulativeStats (session, &cumulative);
+      h->isDirty = false;
     }
 }
 
 void
-tr_statsClose( tr_session * session )
+tr_statsClose (tr_session * session)
 {
-    tr_statsSaveDirty( session );
+  tr_statsSaveDirty (session);
 
-    tr_free( session->sessionStats );
-    session->sessionStats = NULL;
+  tr_free (session->sessionStats);
+  session->sessionStats = NULL;
 }
 
 /***
@@ -152,67 +151,66 @@ tr_statsClose( tr_session * session )
 ***/
 
 static void
-updateRatio( tr_session_stats * setme )
+updateRatio (tr_session_stats * setme)
 {
-    setme->ratio = tr_getRatio( setme->uploadedBytes,
-                                setme->downloadedBytes );
+  setme->ratio = tr_getRatio (setme->uploadedBytes, setme->downloadedBytes);
 }
 
 static void
-addStats( tr_session_stats *       setme,
+addStats (tr_session_stats       * setme,
           const tr_session_stats * a,
-          const tr_session_stats * b )
+          const tr_session_stats * b)
 {
-    setme->uploadedBytes   = a->uploadedBytes   + b->uploadedBytes;
-    setme->downloadedBytes = a->downloadedBytes + b->downloadedBytes;
-    setme->filesAdded      = a->filesAdded      + b->filesAdded;
-    setme->sessionCount    = a->sessionCount    + b->sessionCount;
-    setme->secondsActive   = a->secondsActive   + b->secondsActive;
-    updateRatio( setme );
+  setme->uploadedBytes   = a->uploadedBytes   + b->uploadedBytes;
+  setme->downloadedBytes = a->downloadedBytes + b->downloadedBytes;
+  setme->filesAdded      = a->filesAdded      + b->filesAdded;
+  setme->sessionCount    = a->sessionCount    + b->sessionCount;
+  setme->secondsActive   = a->secondsActive   + b->secondsActive;
+  updateRatio (setme);
 }
 
 void
-tr_sessionGetStats( const tr_session * session,
-                    tr_session_stats * setme )
+tr_sessionGetStats (const tr_session * session, tr_session_stats * setme)
 {
-    const struct tr_stats_handle * stats = getStats( session );
-    if( stats )
+  const struct tr_stats_handle * stats = getStats (session);
+
+  if (stats)
     {
-        *setme = stats->single;
-        setme->secondsActive = tr_time( ) - stats->startTime;
-        updateRatio( setme );
+      *setme = stats->single;
+      setme->secondsActive = tr_time () - stats->startTime;
+      updateRatio (setme);
     }
 }
 
 void
-tr_sessionGetCumulativeStats( const tr_session * session,
-                              tr_session_stats * setme )
+tr_sessionGetCumulativeStats (const tr_session * session,
+                              tr_session_stats * setme)
 {
-    const struct tr_stats_handle * stats = getStats( session );
-    tr_session_stats current = STATS_INIT;
+  const struct tr_stats_handle * stats = getStats (session);
+  tr_session_stats current = STATS_INIT;
 
-    if( stats )
+  if (stats)
     {
-        tr_sessionGetStats( session, &current );
-        addStats( setme, &stats->old, &current );
+      tr_sessionGetStats (session, &current);
+      addStats (setme, &stats->old, &current);
     }
 }
 
 void
-tr_sessionClearStats( tr_session * session )
+tr_sessionClearStats (tr_session * session)
 {
-    tr_session_stats zero;
-
-    zero.uploadedBytes = 0;
-    zero.downloadedBytes = 0;
-    zero.ratio = TR_RATIO_NA;
-    zero.filesAdded = 0;
-    zero.sessionCount = 0;
-    zero.secondsActive = 0;
-
-    session->sessionStats->isDirty = true;
-    session->sessionStats->single = session->sessionStats->old = zero;
-    session->sessionStats->startTime = tr_time( );
+  tr_session_stats zero;
+
+  zero.uploadedBytes = 0;
+  zero.downloadedBytes = 0;
+  zero.ratio = TR_RATIO_NA;
+  zero.filesAdded = 0;
+  zero.sessionCount = 0;
+  zero.secondsActive = 0;
+
+  session->sessionStats->isDirty = true;
+  session->sessionStats->single = session->sessionStats->old = zero;
+  session->sessionStats->startTime = tr_time ();
 }
 
 /**
@@ -220,37 +218,35 @@ tr_sessionClearStats( tr_session * session )
 **/
 
 void
-tr_statsAddUploaded( tr_session * session,
-                     uint32_t    bytes )
+tr_statsAddUploaded (tr_session * session, uint32_t bytes)
 {
-    struct tr_stats_handle * s;
+  struct tr_stats_handle * s;
 
-    if( ( s = getStats( session ) ) )
+  if ((s = getStats (session)))
     {
-        s->single.uploadedBytes += bytes;
-        s->isDirty = true;
+      s->single.uploadedBytes += bytes;
+      s->isDirty = true;
     }
 }
 
 void
-tr_statsAddDownloaded( tr_session * session,
-                       uint32_t     bytes )
+tr_statsAddDownloaded (tr_session * session, uint32_t bytes)
 {
-    struct tr_stats_handle * s;
+  struct tr_stats_handle * s;
 
-    if( ( s = getStats( session ) ) )
+  if ((s = getStats (session)))
     {
-        s->single.downloadedBytes += bytes;
-        s->isDirty = true;
+      s->single.downloadedBytes += bytes;
+      s->isDirty = true;
     }
 }
 
 void
-tr_statsFileCreated( tr_session * session )
+tr_statsFileCreated (tr_session * session)
 {
-    struct tr_stats_handle * s;
+  struct tr_stats_handle * s;
 
-    if( ( s = getStats( session ) ) )
-        s->single.filesAdded++;
+  if ((s = getStats (session)))
+    s->single.filesAdded++;
 }
 
diff --git a/libtransmission/stats.h b/libtransmission/stats.h
index 670f8b7cf..ee9243cb3 100644
--- a/libtransmission/stats.h
+++ b/libtransmission/stats.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,24 +11,17 @@
  */
 
 #ifndef __TRANSMISSION__
-#error only libtransmission should #include this header.
+ #error only libtransmission should #include this header.
 #endif
 
 #ifndef TR_STATS_H
 #define TR_STATS_H
 
-void tr_statsInit           ( tr_session  * session );
-
-void tr_statsClose          ( tr_session  * session );
-
-void tr_statsSaveDirty      ( tr_session  * session );
-
-void tr_statsAddUploaded    ( tr_session  * session,
-                              uint32_t      bytes );
-
-void tr_statsAddDownloaded  ( tr_session  * session,
-                              uint32_t      bytes );
-
-void tr_statsFileCreated    ( tr_session  * session );
+void tr_statsInit          (tr_session * session);
+void tr_statsClose         (tr_session * session);
+void tr_statsSaveDirty     (tr_session * session);
+void tr_statsAddUploaded   (tr_session * session, uint32_t bytes);
+void tr_statsAddDownloaded (tr_session * session, uint32_t bytes);
+void tr_statsFileCreated   (tr_session * session);
 
 #endif
diff --git a/libtransmission/test-peer-id.c b/libtransmission/test-peer-id.c
index d795998eb..6a0aec442 100644
--- a/libtransmission/test-peer-id.c
+++ b/libtransmission/test-peer-id.c
@@ -10,31 +10,31 @@
 #include "libtransmission-test.h"
 
 static int
-testPeerId( void )
+testPeerId (void)
 {
     int i;
     uint8_t peer_id[PEER_ID_LEN+1];
 
-    for( i = 0; i < 100000; ++i )
+    for (i = 0; i < 100000; ++i)
     {
         int j;
         int val = 0;
 
-        tr_peerIdInit( peer_id );
+        tr_peerIdInit (peer_id);
 
-        check( strlen( (char*)peer_id ) == PEER_ID_LEN );
-        check( !memcmp( peer_id, PEERID_PREFIX, 8 ) );
+        check (strlen ((char*)peer_id) == PEER_ID_LEN);
+        check (!memcmp (peer_id, PEERID_PREFIX, 8));
 
-        for( j = 8; j < PEER_ID_LEN; ++j )
+        for (j = 8; j < PEER_ID_LEN; ++j)
         {
             char tmp[2] = { peer_id[j], '\0' };
-            val += strtoul( tmp, NULL, 36 );
+            val += strtoul (tmp, NULL, 36);
         }
 
-        check( ( val % 36 ) == 0 );
+        check ((val % 36) == 0);
     }
 
     return 0;
 }
 
-MAIN_SINGLE_TEST(testPeerId)
+MAIN_SINGLE_TEST (testPeerId)
diff --git a/libtransmission/torrent-ctor.c b/libtransmission/torrent-ctor.c
index c0db03093..fb56c3353 100644
--- a/libtransmission/torrent-ctor.c
+++ b/libtransmission/torrent-ctor.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -14,8 +14,8 @@
 #include "transmission.h"
 #include "bencode.h"
 #include "magnet.h"
-#include "session.h" /* tr_sessionFindTorrentFile() */
-#include "torrent.h" /* tr_ctorGetSave() */
+#include "session.h" /* tr_sessionFindTorrentFile () */
+#include "torrent.h" /* tr_ctorGetSave () */
 #include "utils.h" /* tr_new0 */
 
 struct optional_args
@@ -65,123 +65,123 @@ struct tr_ctor
 ***/
 
 static void
-setSourceFile( tr_ctor *    ctor,
-               const char * sourceFile )
+setSourceFile (tr_ctor *    ctor,
+               const char * sourceFile)
 {
-    tr_free( ctor->sourceFile );
-    ctor->sourceFile = tr_strdup( sourceFile );
+    tr_free (ctor->sourceFile);
+    ctor->sourceFile = tr_strdup (sourceFile);
 }
 
 static void
-clearMetainfo( tr_ctor * ctor )
+clearMetainfo (tr_ctor * ctor)
 {
-    if( ctor->isSet_metainfo )
+    if (ctor->isSet_metainfo)
     {
         ctor->isSet_metainfo = 0;
-        tr_bencFree( &ctor->metainfo );
+        tr_bencFree (&ctor->metainfo);
     }
 
-    setSourceFile( ctor, NULL );
+    setSourceFile (ctor, NULL);
 }
 
 int
-tr_ctorSetMetainfo( tr_ctor *       ctor,
+tr_ctorSetMetainfo (tr_ctor *       ctor,
                     const uint8_t * metainfo,
-                    size_t          len )
+                    size_t          len)
 {
     int err;
 
-    clearMetainfo( ctor );
-    err = tr_bencLoad( metainfo, len, &ctor->metainfo, NULL );
+    clearMetainfo (ctor);
+    err = tr_bencLoad (metainfo, len, &ctor->metainfo, NULL);
     ctor->isSet_metainfo = !err;
     return err;
 }
 
 const char*
-tr_ctorGetSourceFile( const tr_ctor * ctor )
+tr_ctorGetSourceFile (const tr_ctor * ctor)
 {
     return ctor->sourceFile;
 }
 
 int
-tr_ctorSetMetainfoFromMagnetLink( tr_ctor * ctor, const char * magnet_link )
+tr_ctorSetMetainfoFromMagnetLink (tr_ctor * ctor, const char * magnet_link)
 {
     int err;
-    tr_magnet_info * magnet_info = tr_magnetParse( magnet_link );
+    tr_magnet_info * magnet_info = tr_magnetParse (magnet_link);
 
-    if( magnet_info == NULL )
+    if (magnet_info == NULL)
         err = -1;
     else {
         int len;
         tr_benc tmp;
         char * str;
 
-        tr_magnetCreateMetainfo( magnet_info, &tmp );
-        str = tr_bencToStr( &tmp, TR_FMT_BENC, &len );
-        err = tr_ctorSetMetainfo( ctor, (const uint8_t*)str, len );
+        tr_magnetCreateMetainfo (magnet_info, &tmp);
+        str = tr_bencToStr (&tmp, TR_FMT_BENC, &len);
+        err = tr_ctorSetMetainfo (ctor, (const uint8_t*)str, len);
 
-        tr_free( str );
-        tr_bencFree( &tmp );
-        tr_magnetFree( magnet_info );
+        tr_free (str);
+        tr_bencFree (&tmp);
+        tr_magnetFree (magnet_info);
     }
 
     return err;
 }
 
 int
-tr_ctorSetMetainfoFromFile( tr_ctor *    ctor,
-                            const char * filename )
+tr_ctorSetMetainfoFromFile (tr_ctor *    ctor,
+                            const char * filename)
 {
     uint8_t * metainfo;
     size_t    len;
     int       err;
 
-    metainfo = tr_loadFile( filename, &len );
-    if( metainfo && len )
-        err = tr_ctorSetMetainfo( ctor, metainfo, len );
+    metainfo = tr_loadFile (filename, &len);
+    if (metainfo && len)
+        err = tr_ctorSetMetainfo (ctor, metainfo, len);
     else
     {
-        clearMetainfo( ctor );
+        clearMetainfo (ctor);
         err = 1;
     }
 
-    setSourceFile( ctor, filename );
+    setSourceFile (ctor, filename);
 
     /* if no `name' field was set, then set it from the filename */
-    if( ctor->isSet_metainfo )
+    if (ctor->isSet_metainfo)
     {
         tr_benc * info;
-        if( tr_bencDictFindDict( &ctor->metainfo, "info", &info ) )
+        if (tr_bencDictFindDict (&ctor->metainfo, "info", &info))
         {
             const char * name;
-            if( !tr_bencDictFindStr( info, "name.utf-8", &name ) )
-                if( !tr_bencDictFindStr( info, "name", &name ) )
+            if (!tr_bencDictFindStr (info, "name.utf-8", &name))
+                if (!tr_bencDictFindStr (info, "name", &name))
                     name = NULL;
-            if( !name || !*name )
+            if (!name || !*name)
             {
-                char * base = tr_basename( filename );
-                tr_bencDictAddStr( info, "name", base );
-                tr_free( base );
+                char * base = tr_basename (filename);
+                tr_bencDictAddStr (info, "name", base);
+                tr_free (base);
             }
         }
     }
 
-    tr_free( metainfo );
+    tr_free (metainfo);
     return err;
 }
 
 int
-tr_ctorSetMetainfoFromHash( tr_ctor *    ctor,
-                            const char * hashString )
+tr_ctorSetMetainfoFromHash (tr_ctor *    ctor,
+                            const char * hashString)
 {
     int          err;
     const char * filename;
 
-    filename = tr_sessionFindTorrentFile( ctor->session, hashString );
-    if( !filename )
+    filename = tr_sessionFindTorrentFile (ctor->session, hashString);
+    if (!filename)
         err = EINVAL;
     else
-        err = tr_ctorSetMetainfoFromFile( ctor, filename );
+        err = tr_ctorSetMetainfoFromFile (ctor, filename);
 
     return err;
 }
@@ -191,59 +191,59 @@ tr_ctorSetMetainfoFromHash( tr_ctor *    ctor,
 ***/
 
 void
-tr_ctorSetFilePriorities( tr_ctor                * ctor,
+tr_ctorSetFilePriorities (tr_ctor                * ctor,
                           const tr_file_index_t  * files,
                           tr_file_index_t          fileCount,
-                          tr_priority_t            priority )
+                          tr_priority_t            priority)
 {
     tr_file_index_t ** myfiles;
     tr_file_index_t * mycount;
 
-    switch( priority ) {
+    switch (priority) {
         case TR_PRI_LOW: myfiles = &ctor->low; mycount = &ctor->lowSize; break;
         case TR_PRI_HIGH: myfiles = &ctor->high; mycount = &ctor->highSize; break;
         default /*TR_PRI_NORMAL*/: myfiles = &ctor->normal; mycount = &ctor->normalSize; break;
     }
 
-    tr_free( *myfiles );
-    *myfiles = tr_memdup( files, sizeof(tr_file_index_t)*fileCount );
+    tr_free (*myfiles);
+    *myfiles = tr_memdup (files, sizeof (tr_file_index_t)*fileCount);
     *mycount = fileCount;
 }
 
 void
-tr_ctorInitTorrentPriorities( const tr_ctor * ctor, tr_torrent * tor )
+tr_ctorInitTorrentPriorities (const tr_ctor * ctor, tr_torrent * tor)
 {
     tr_file_index_t i;
 
-    for( i=0; i<ctor->lowSize; ++i )
-        tr_torrentInitFilePriority( tor, ctor->low[i], TR_PRI_LOW );
-    for( i=0; i<ctor->normalSize; ++i )
-        tr_torrentInitFilePriority( tor, ctor->normal[i], TR_PRI_NORMAL );
-    for( i=0; i<ctor->highSize; ++i )
-        tr_torrentInitFilePriority( tor, ctor->high[i], TR_PRI_HIGH );
+    for (i=0; i<ctor->lowSize; ++i)
+        tr_torrentInitFilePriority (tor, ctor->low[i], TR_PRI_LOW);
+    for (i=0; i<ctor->normalSize; ++i)
+        tr_torrentInitFilePriority (tor, ctor->normal[i], TR_PRI_NORMAL);
+    for (i=0; i<ctor->highSize; ++i)
+        tr_torrentInitFilePriority (tor, ctor->high[i], TR_PRI_HIGH);
 }
 
 void
-tr_ctorSetFilesWanted( tr_ctor                * ctor,
+tr_ctorSetFilesWanted (tr_ctor                * ctor,
                        const tr_file_index_t  * files,
                        tr_file_index_t          fileCount,
-                       bool                     wanted )
+                       bool                     wanted)
 {
     tr_file_index_t ** myfiles = wanted ? &ctor->want : &ctor->notWant;
     tr_file_index_t * mycount = wanted ? &ctor->wantSize : &ctor->notWantSize;
 
-    tr_free( *myfiles );
-    *myfiles = tr_memdup( files, sizeof(tr_file_index_t)*fileCount );
+    tr_free (*myfiles);
+    *myfiles = tr_memdup (files, sizeof (tr_file_index_t)*fileCount);
     *mycount = fileCount;
 }
 
 void
-tr_ctorInitTorrentWanted( const tr_ctor * ctor, tr_torrent * tor )
+tr_ctorInitTorrentWanted (const tr_ctor * ctor, tr_torrent * tor)
 {
-    if( ctor->notWantSize )
-        tr_torrentInitFileDLs( tor, ctor->notWant, ctor->notWantSize, false );
-    if( ctor->wantSize )
-        tr_torrentInitFileDLs( tor, ctor->want, ctor->wantSize, true );
+    if (ctor->notWantSize)
+        tr_torrentInitFileDLs (tor, ctor->notWant, ctor->notWantSize, false);
+    if (ctor->wantSize)
+        tr_torrentInitFileDLs (tor, ctor->want, ctor->wantSize, true);
 }
 
 /***
@@ -251,20 +251,20 @@ tr_ctorInitTorrentWanted( const tr_ctor * ctor, tr_torrent * tor )
 ***/
 
 void
-tr_ctorSetDeleteSource( tr_ctor * ctor, bool deleteSource )
+tr_ctorSetDeleteSource (tr_ctor * ctor, bool deleteSource)
 {
     ctor->doDelete = deleteSource != 0;
     ctor->isSet_delete = 1;
 }
 
 int
-tr_ctorGetDeleteSource( const tr_ctor * ctor, bool * setme )
+tr_ctorGetDeleteSource (const tr_ctor * ctor, bool * setme)
 {
     int err = 0;
 
-    if( !ctor->isSet_delete )
+    if (!ctor->isSet_delete)
         err = 1;
-    else if( setme )
+    else if (setme)
         *setme = ctor->doDelete ? 1 : 0;
 
     return err;
@@ -275,21 +275,21 @@ tr_ctorGetDeleteSource( const tr_ctor * ctor, bool * setme )
 ***/
 
 void
-tr_ctorSetSave( tr_ctor * ctor, bool saveInOurTorrentsDir )
+tr_ctorSetSave (tr_ctor * ctor, bool saveInOurTorrentsDir)
 {
     ctor->saveInOurTorrentsDir = saveInOurTorrentsDir != 0;
 }
 
 int
-tr_ctorGetSave( const tr_ctor * ctor )
+tr_ctorGetSave (const tr_ctor * ctor)
 {
     return ctor && ctor->saveInOurTorrentsDir;
 }
 
 void
-tr_ctorSetPaused( tr_ctor *   ctor,
+tr_ctorSetPaused (tr_ctor *   ctor,
                   tr_ctorMode mode,
-                  bool        isPaused )
+                  bool        isPaused)
 {
     struct optional_args * args = &ctor->optionalArgs[mode];
 
@@ -298,9 +298,9 @@ tr_ctorSetPaused( tr_ctor *   ctor,
 }
 
 void
-tr_ctorSetPeerLimit( tr_ctor *   ctor,
+tr_ctorSetPeerLimit (tr_ctor *   ctor,
                      tr_ctorMode mode,
-                     uint16_t    peerLimit )
+                     uint16_t    peerLimit)
 {
     struct optional_args * args = &ctor->optionalArgs[mode];
 
@@ -309,83 +309,83 @@ tr_ctorSetPeerLimit( tr_ctor *   ctor,
 }
 
 void
-tr_ctorSetDownloadDir( tr_ctor *    ctor,
+tr_ctorSetDownloadDir (tr_ctor *    ctor,
                        tr_ctorMode  mode,
-                       const char * directory )
+                       const char * directory)
 {
     struct optional_args * args = &ctor->optionalArgs[mode];
 
-    tr_free( args->downloadDir );
+    tr_free (args->downloadDir);
     args->downloadDir = NULL;
     args->isSet_downloadDir = 0;
 
-    if( directory && *directory )
+    if (directory && *directory)
     {
         args->isSet_downloadDir = 1;
-        args->downloadDir = tr_strdup( directory );
+        args->downloadDir = tr_strdup (directory);
     }
 }
 
 void
-tr_ctorSetIncompleteDir( tr_ctor * ctor, const char * directory )
+tr_ctorSetIncompleteDir (tr_ctor * ctor, const char * directory)
 {
-    tr_free( ctor->incompleteDir );
-    ctor->incompleteDir = tr_strdup( directory );
+    tr_free (ctor->incompleteDir);
+    ctor->incompleteDir = tr_strdup (directory);
 }
 
 int
-tr_ctorGetPeerLimit( const tr_ctor * ctor,
+tr_ctorGetPeerLimit (const tr_ctor * ctor,
                      tr_ctorMode     mode,
-                     uint16_t *      setmeCount )
+                     uint16_t *      setmeCount)
 {
     int err = 0;
     const struct optional_args * args = &ctor->optionalArgs[mode];
 
-    if( !args->isSet_connected )
+    if (!args->isSet_connected)
         err = 1;
-    else if( setmeCount )
+    else if (setmeCount)
         *setmeCount = args->peerLimit;
 
     return err;
 }
 
 int
-tr_ctorGetPaused( const tr_ctor * ctor, tr_ctorMode mode, bool * setmeIsPaused )
+tr_ctorGetPaused (const tr_ctor * ctor, tr_ctorMode mode, bool * setmeIsPaused)
 {
     int                          err = 0;
     const struct optional_args * args = &ctor->optionalArgs[mode];
 
-    if( !args->isSet_paused )
+    if (!args->isSet_paused)
         err = 1;
-    else if( setmeIsPaused )
+    else if (setmeIsPaused)
         *setmeIsPaused = args->isPaused ? 1 : 0;
 
     return err;
 }
 
 int
-tr_ctorGetDownloadDir( const tr_ctor * ctor,
+tr_ctorGetDownloadDir (const tr_ctor * ctor,
                        tr_ctorMode     mode,
-                       const char **   setmeDownloadDir )
+                       const char **   setmeDownloadDir)
 {
     int                          err = 0;
     const struct optional_args * args = &ctor->optionalArgs[mode];
 
-    if( !args->isSet_downloadDir )
+    if (!args->isSet_downloadDir)
         err = 1;
-    else if( setmeDownloadDir )
+    else if (setmeDownloadDir)
         *setmeDownloadDir = args->downloadDir;
 
     return err;
 }
 
 int
-tr_ctorGetIncompleteDir( const tr_ctor  * ctor,
-                         const char    ** setmeIncompleteDir )
+tr_ctorGetIncompleteDir (const tr_ctor  * ctor,
+                         const char    ** setmeIncompleteDir)
 {
     int err = 0;
 
-    if( ctor->incompleteDir == NULL )
+    if (ctor->incompleteDir == NULL)
         err = 1;
     else
         *setmeIncompleteDir = ctor->incompleteDir;
@@ -394,21 +394,21 @@ tr_ctorGetIncompleteDir( const tr_ctor  * ctor,
 }
 
 int
-tr_ctorGetMetainfo( const tr_ctor *  ctor,
-                    const tr_benc ** setme )
+tr_ctorGetMetainfo (const tr_ctor *  ctor,
+                    const tr_benc ** setme)
 {
     int err = 0;
 
-    if( !ctor->isSet_metainfo )
+    if (!ctor->isSet_metainfo)
         err = 1;
-    else if( setme )
+    else if (setme)
         *setme = &ctor->metainfo;
 
     return err;
 }
 
 tr_session*
-tr_ctorGetSession( const tr_ctor * ctor )
+tr_ctorGetSession (const tr_ctor * ctor)
 {
     return (tr_session*) ctor->session;
 }
@@ -418,20 +418,20 @@ tr_ctorGetSession( const tr_ctor * ctor )
 ***/
 
 static bool
-isPriority( int i )
+isPriority (int i)
 {
     return (i==TR_PRI_LOW) || (i==TR_PRI_NORMAL) || (i==TR_PRI_HIGH);
 }
 
 void
-tr_ctorSetBandwidthPriority( tr_ctor * ctor, tr_priority_t priority )
+tr_ctorSetBandwidthPriority (tr_ctor * ctor, tr_priority_t priority)
 {
-    if( isPriority( priority ) )
+    if (isPriority (priority))
         ctor->bandwidthPriority = priority;
 }
 
 tr_priority_t
-tr_ctorGetBandwidthPriority( const tr_ctor * ctor )
+tr_ctorGetBandwidthPriority (const tr_ctor * ctor)
 {
     return ctor->bandwidthPriority;
 }
@@ -441,34 +441,34 @@ tr_ctorGetBandwidthPriority( const tr_ctor * ctor )
 ***/
 
 tr_ctor*
-tr_ctorNew( const tr_session * session )
+tr_ctorNew (const tr_session * session)
 {
-    tr_ctor * ctor = tr_new0( struct tr_ctor, 1 );
+    tr_ctor * ctor = tr_new0 (struct tr_ctor, 1);
 
     ctor->session = session;
     ctor->bandwidthPriority = TR_PRI_NORMAL;
-    if( session != NULL )
+    if (session != NULL)
     {
-        tr_ctorSetDeleteSource( ctor, tr_sessionGetDeleteSource( session ) );
-        tr_ctorSetPaused( ctor, TR_FALLBACK, tr_sessionGetPaused( session ) );
-        tr_ctorSetPeerLimit( ctor, TR_FALLBACK, session->peerLimitPerTorrent );
-        tr_ctorSetDownloadDir( ctor, TR_FALLBACK, session->downloadDir );
+        tr_ctorSetDeleteSource (ctor, tr_sessionGetDeleteSource (session));
+        tr_ctorSetPaused (ctor, TR_FALLBACK, tr_sessionGetPaused (session));
+        tr_ctorSetPeerLimit (ctor, TR_FALLBACK, session->peerLimitPerTorrent);
+        tr_ctorSetDownloadDir (ctor, TR_FALLBACK, session->downloadDir);
     }
-    tr_ctorSetSave( ctor, true );
+    tr_ctorSetSave (ctor, true);
     return ctor;
 }
 
 void
-tr_ctorFree( tr_ctor * ctor )
-{
-    clearMetainfo( ctor );
-    tr_free( ctor->optionalArgs[1].downloadDir );
-    tr_free( ctor->optionalArgs[0].downloadDir );
-    tr_free( ctor->incompleteDir );
-    tr_free( ctor->want );
-    tr_free( ctor->notWant );
-    tr_free( ctor->low );
-    tr_free( ctor->high );
-    tr_free( ctor->normal );
-    tr_free( ctor );
+tr_ctorFree (tr_ctor * ctor)
+{
+    clearMetainfo (ctor);
+    tr_free (ctor->optionalArgs[1].downloadDir);
+    tr_free (ctor->optionalArgs[0].downloadDir);
+    tr_free (ctor->incompleteDir);
+    tr_free (ctor->want);
+    tr_free (ctor->notWant);
+    tr_free (ctor->low);
+    tr_free (ctor->high);
+    tr_free (ctor->normal);
+    tr_free (ctor);
 }
diff --git a/libtransmission/torrent-magnet.c b/libtransmission/torrent-magnet.c
index 1405c2541..27c627ec7 100644
--- a/libtransmission/torrent-magnet.c
+++ b/libtransmission/torrent-magnet.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -11,14 +11,14 @@
  */
 
 #include <assert.h>
-#include <stdio.h> /* remove() */
-#include <string.h> /* memcpy(), memset(), memcmp() */
+#include <stdio.h> /* remove () */
+#include <string.h> /* memcpy (), memset (), memcmp () */
 
 #include <event2/buffer.h>
 
 #include "transmission.h"
 #include "bencode.h"
-#include "crypto.h" /* tr_sha1() */
+#include "crypto.h" /* tr_sha1 () */
 #include "magnet.h"
 #include "metainfo.h"
 #include "resume.h"
@@ -27,11 +27,13 @@
 #include "utils.h"
 #include "web.h"
 
-#define dbgmsg( tor, ... ) \
-    do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, tr_torrentName( tor ), __VA_ARGS__ ); \
-    } while( 0 )
+#define dbgmsg(tor, ...) \
+  do \
+    { \
+      if (tr_deepLoggingIsActive ()) \
+        tr_deepLog (__FILE__, __LINE__, tr_torrentName (tor), __VA_ARGS__); \
+    } \
+  while (0)
 
 /***
 ****
@@ -61,33 +63,33 @@ struct tr_incomplete_metadata
 };
 
 static void
-incompleteMetadataFree( struct tr_incomplete_metadata * m )
+incompleteMetadataFree (struct tr_incomplete_metadata * m)
 {
-    tr_free( m->metadata );
-    tr_free( m->piecesNeeded );
-    tr_free( m );
+    tr_free (m->metadata);
+    tr_free (m->piecesNeeded);
+    tr_free (m);
 }
 
 void
-tr_torrentSetMetadataSizeHint( tr_torrent * tor, int size )
+tr_torrentSetMetadataSizeHint (tr_torrent * tor, int size)
 {
-    if( !tr_torrentHasMetadata( tor ) )
+    if (!tr_torrentHasMetadata (tor))
     {
-        if( tor->incompleteMetadata == NULL )
+        if (tor->incompleteMetadata == NULL)
         {
             int i;
             struct tr_incomplete_metadata * m;
-            const int n = ( size + ( METADATA_PIECE_SIZE - 1 ) ) / METADATA_PIECE_SIZE;
-            dbgmsg( tor, "metadata is %d bytes in %d pieces", size, n );
+            const int n = (size + (METADATA_PIECE_SIZE - 1)) / METADATA_PIECE_SIZE;
+            dbgmsg (tor, "metadata is %d bytes in %d pieces", size, n);
 
-            m = tr_new( struct tr_incomplete_metadata, 1 );
+            m = tr_new (struct tr_incomplete_metadata, 1);
             m->pieceCount = n;
-            m->metadata = tr_new( uint8_t, size );
+            m->metadata = tr_new (uint8_t, size);
             m->metadata_size = size;
             m->piecesNeededCount = n;
-            m->piecesNeeded = tr_new( struct metadata_node, n );
+            m->piecesNeeded = tr_new (struct metadata_node, n);
 
-            for( i=0; i<n; ++i ) {
+            for (i=0; i<n; ++i) {
                 m->piecesNeeded[i].piece = i;
                 m->piecesNeeded[i].requestedAt = 0;
             }
@@ -98,96 +100,96 @@ tr_torrentSetMetadataSizeHint( tr_torrent * tor, int size )
 }
 
 static int
-findInfoDictOffset( const tr_torrent * tor )
+findInfoDictOffset (const tr_torrent * tor)
 {
     size_t fileLen;
     uint8_t * fileContents;
     int offset = 0;
 
     /* load the file, and find the info dict's offset inside the file */
-    if(( fileContents = tr_loadFile( tor->info.torrent, &fileLen )))
+    if ((fileContents = tr_loadFile (tor->info.torrent, &fileLen)))
     {
         tr_benc top;
 
-        if( !tr_bencParse( fileContents, fileContents + fileLen, &top, NULL ) )
+        if (!tr_bencParse (fileContents, fileContents + fileLen, &top, NULL))
         {
             tr_benc * infoDict;
 
-            if( tr_bencDictFindDict( &top, "info", &infoDict ) )
+            if (tr_bencDictFindDict (&top, "info", &infoDict))
             {
                 int infoLen;
-                char * infoContents = tr_bencToStr( infoDict, TR_FMT_BENC, &infoLen );
-                const uint8_t * i = (const uint8_t*) tr_memmem( (char*)fileContents, fileLen, infoContents, infoLen );
+                char * infoContents = tr_bencToStr (infoDict, TR_FMT_BENC, &infoLen);
+                const uint8_t * i = (const uint8_t*) tr_memmem ((char*)fileContents, fileLen, infoContents, infoLen);
                 offset = i != NULL ? i - fileContents : 0;
-                tr_free( infoContents );
+                tr_free (infoContents);
             }
 
-            tr_bencFree( &top );
+            tr_bencFree (&top);
         }
 
-        tr_free( fileContents );
+        tr_free (fileContents);
     }
 
     return offset;
 }
 
 static void
-ensureInfoDictOffsetIsCached( tr_torrent * tor )
+ensureInfoDictOffsetIsCached (tr_torrent * tor)
 {
-    assert( tr_torrentHasMetadata( tor ) );
+    assert (tr_torrentHasMetadata (tor));
 
-    if( !tor->infoDictOffsetIsCached )
+    if (!tor->infoDictOffsetIsCached)
     {
-        tor->infoDictOffset = findInfoDictOffset( tor );
+        tor->infoDictOffset = findInfoDictOffset (tor);
         tor->infoDictOffsetIsCached = true;
     }
 }
 
 void*
-tr_torrentGetMetadataPiece( tr_torrent * tor, int piece, int * len )
+tr_torrentGetMetadataPiece (tr_torrent * tor, int piece, int * len)
 {
     char * ret = NULL;
 
-    assert( tr_isTorrent( tor ) );
-    assert( piece >= 0 );
-    assert( len != NULL );
+    assert (tr_isTorrent (tor));
+    assert (piece >= 0);
+    assert (len != NULL);
 
-    if( tr_torrentHasMetadata( tor ) )
+    if (tr_torrentHasMetadata (tor))
     {
         FILE * fp;
 
-        ensureInfoDictOffsetIsCached( tor );
+        ensureInfoDictOffsetIsCached (tor);
 
-        assert( tor->infoDictLength > 0 );
-        assert( tor->infoDictOffset >= 0 );
+        assert (tor->infoDictLength > 0);
+        assert (tor->infoDictOffset >= 0);
 
-        fp = fopen( tor->info.torrent, "rb" );
-        if( fp != NULL )
+        fp = fopen (tor->info.torrent, "rb");
+        if (fp != NULL)
         {
             const int o = piece  * METADATA_PIECE_SIZE;
 
-            if( !fseek( fp, tor->infoDictOffset + o, SEEK_SET ) )
+            if (!fseek (fp, tor->infoDictOffset + o, SEEK_SET))
             {
                 const int l = o + METADATA_PIECE_SIZE <= tor->infoDictLength
                             ? METADATA_PIECE_SIZE
                             : tor->infoDictLength - o;
 
-                if( 0<l && l<=METADATA_PIECE_SIZE )
+                if (0<l && l<=METADATA_PIECE_SIZE)
                 {
-                    char * buf = tr_new( char, l );
-                    const int n = fread( buf, 1, l, fp );
-                    if( n == l )
+                    char * buf = tr_new (char, l);
+                    const int n = fread (buf, 1, l, fp);
+                    if (n == l)
                     {
                         *len = l;
                         ret = buf;
                         buf = NULL;
                     }
 
-                    tr_free( buf );
+                    tr_free (buf);
                 }
             }
 
-            fclose( fp );
+            fclose (fp);
         }
     }
 
@@ -195,42 +197,42 @@ tr_torrentGetMetadataPiece( tr_torrent * tor, int piece, int * len )
 }
 
 void
-tr_torrentSetMetadataPiece( tr_torrent  * tor, int piece, const void  * data, int len )
+tr_torrentSetMetadataPiece (tr_torrent  * tor, int piece, const void  * data, int len)
 {
     int i;
     struct tr_incomplete_metadata * m;
     const int offset = piece * METADATA_PIECE_SIZE;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    dbgmsg( tor, "got metadata piece %d", piece );
+    dbgmsg (tor, "got metadata piece %d", piece);
 
     /* are we set up to download metadata? */
     m = tor->incompleteMetadata;
-    if( m == NULL )
+    if (m == NULL)
         return;
 
     /* does this data pass the smell test? */
-    if( offset + len > m->metadata_size )
+    if (offset + len > m->metadata_size)
         return;
 
     /* do we need this piece? */
-    for( i=0; i<m->piecesNeededCount; ++i )
-        if( m->piecesNeeded[i].piece == piece )
+    for (i=0; i<m->piecesNeededCount; ++i)
+        if (m->piecesNeeded[i].piece == piece)
             break;
-    if( i==m->piecesNeededCount )
+    if (i==m->piecesNeededCount)
         return;
 
-    memcpy( m->metadata + offset, data, len );
+    memcpy (m->metadata + offset, data, len);
 
-    tr_removeElementFromArray( m->piecesNeeded, i,
-                               sizeof( struct metadata_node ),
-                               m->piecesNeededCount-- );
+    tr_removeElementFromArray (m->piecesNeeded, i,
+                               sizeof (struct metadata_node),
+                               m->piecesNeededCount--);
 
-    dbgmsg( tor, "saving metainfo piece %d... %d remain", piece, m->piecesNeededCount );
+    dbgmsg (tor, "saving metainfo piece %d... %d remain", piece, m->piecesNeededCount);
 
     /* are we done? */
-    if( m->piecesNeededCount == 0 )
+    if (m->piecesNeededCount == 0)
     {
         bool success = false;
         bool checksumPassed = false;
@@ -238,111 +240,111 @@ tr_torrentSetMetadataPiece( tr_torrent  * tor, int piece, const void  * data, in
         uint8_t sha1[SHA_DIGEST_LENGTH];
 
         /* we've got a complete set of metainfo... see if it passes the checksum test */
-        dbgmsg( tor, "metainfo piece %d was the last one", piece );
-        tr_sha1( sha1, m->metadata, m->metadata_size, NULL );
-        if(( checksumPassed = !memcmp( sha1, tor->info.hash, SHA_DIGEST_LENGTH )))
+        dbgmsg (tor, "metainfo piece %d was the last one", piece);
+        tr_sha1 (sha1, m->metadata, m->metadata_size, NULL);
+        if ((checksumPassed = !memcmp (sha1, tor->info.hash, SHA_DIGEST_LENGTH)))
         {
             /* checksum passed; now try to parse it as benc */
             tr_benc infoDict;
-            const int err = tr_bencLoad( m->metadata, m->metadata_size, &infoDict, NULL );
-            dbgmsg( tor, "err is %d", err );
-            if(( metainfoParsed = !err ))
+            const int err = tr_bencLoad (m->metadata, m->metadata_size, &infoDict, NULL);
+            dbgmsg (tor, "err is %d", err);
+            if ((metainfoParsed = !err))
             {
                 /* yay we have bencoded metainfo... merge it into our .torrent file */
                 tr_benc newMetainfo;
-                char * path = tr_strdup( tor->info.torrent );
+                char * path = tr_strdup (tor->info.torrent);
 
-                if( !tr_bencLoadFile( &newMetainfo, TR_FMT_BENC, path ) )
+                if (!tr_bencLoadFile (&newMetainfo, TR_FMT_BENC, path))
                 {
                     bool hasInfo;
                     tr_info info;
                     int infoDictLength;
 
                     /* remove any old .torrent and .resume files */
-                    remove( path );
-                    tr_torrentRemoveResume( tor );
+                    remove (path);
+                    tr_torrentRemoveResume (tor);
 
-                    dbgmsg( tor, "Saving completed metadata to \"%s\"", path );
-                    tr_bencMergeDicts( tr_bencDictAddDict( &newMetainfo, "info", 0 ), &infoDict );
+                    dbgmsg (tor, "Saving completed metadata to \"%s\"", path);
+                    tr_bencMergeDicts (tr_bencDictAddDict (&newMetainfo, "info", 0), &infoDict);
 
-                    memset( &info, 0, sizeof( tr_info ) );
-                    success = tr_metainfoParse( tor->session, &newMetainfo, &info, &hasInfo, &infoDictLength );
+                    memset (&info, 0, sizeof (tr_info));
+                    success = tr_metainfoParse (tor->session, &newMetainfo, &info, &hasInfo, &infoDictLength);
 
-                    if( success && !tr_getBlockSize( info.pieceSize ) )
+                    if (success && !tr_getBlockSize (info.pieceSize))
                     {
-                        tr_torrentSetLocalError( tor, "%s", _( "Magnet torrent's metadata is not usable" ) );
+                        tr_torrentSetLocalError (tor, "%s", _ ("Magnet torrent's metadata is not usable"));
                         success = false;
                     }
 
-                    if( success )
+                    if (success)
                     {
                         /* keep the new info */
                         tor->info = info;
                         tor->infoDictLength = infoDictLength;
 
                         /* save the new .torrent file */
-                        tr_bencToFile( &newMetainfo, TR_FMT_BENC, tor->info.torrent );
-                        tr_sessionSetTorrentFile( tor->session, tor->info.hashString, tor->info.torrent );
-                        tr_torrentGotNewInfoDict( tor );
-                        tr_torrentSetDirty( tor );
+                        tr_bencToFile (&newMetainfo, TR_FMT_BENC, tor->info.torrent);
+                        tr_sessionSetTorrentFile (tor->session, tor->info.hashString, tor->info.torrent);
+                        tr_torrentGotNewInfoDict (tor);
+                        tr_torrentSetDirty (tor);
                     }
 
-                    tr_bencFree( &newMetainfo );
+                    tr_bencFree (&newMetainfo);
                 }
 
-                tr_bencFree( &infoDict );
-                tr_free( path );
+                tr_bencFree (&infoDict);
+                tr_free (path);
             }
         }
 
-        if( success )
+        if (success)
         {
-            incompleteMetadataFree( tor->incompleteMetadata );
+            incompleteMetadataFree (tor->incompleteMetadata);
             tor->incompleteMetadata = NULL;
         }
         else /* drat. */
         {
             const int n = m->pieceCount;
-            for( i=0; i<n; ++i )
+            for (i=0; i<n; ++i)
             {
                 m->piecesNeeded[i].piece = i;
                 m->piecesNeeded[i].requestedAt = 0;
             }
             m->piecesNeededCount = n;
-            dbgmsg( tor, "metadata error; trying again. %d pieces left", n );
+            dbgmsg (tor, "metadata error; trying again. %d pieces left", n);
 
-            tr_err( "magnet status: checksum passed %d, metainfo parsed %d",
-                    (int)checksumPassed, (int)metainfoParsed );
+            tr_err ("magnet status: checksum passed %d, metainfo parsed %d",
+                  (int)checksumPassed, (int)metainfoParsed);
         }
     }
 }
 
 bool
-tr_torrentGetNextMetadataRequest( tr_torrent * tor, time_t now, int * setme_piece )
+tr_torrentGetNextMetadataRequest (tr_torrent * tor, time_t now, int * setme_piece)
 {
     bool have_request = false;
     struct tr_incomplete_metadata * m;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     m = tor->incompleteMetadata;
 
-    if( ( m != NULL )
-        && ( m->piecesNeededCount > 0 )
-        && ( m->piecesNeeded[0].requestedAt + MIN_REPEAT_INTERVAL_SECS < now ) )
+    if ((m != NULL)
+        && (m->piecesNeededCount > 0)
+        && (m->piecesNeeded[0].requestedAt + MIN_REPEAT_INTERVAL_SECS < now))
     {
         int i;
         const int piece = m->piecesNeeded[0].piece;
 
-        tr_removeElementFromArray( m->piecesNeeded, 0,
-                                   sizeof( struct metadata_node ),
-                                   m->piecesNeededCount-- );
+        tr_removeElementFromArray (m->piecesNeeded, 0,
+                                   sizeof (struct metadata_node),
+                                   m->piecesNeededCount--);
 
         i = m->piecesNeededCount++;
         m->piecesNeeded[i].piece = piece;
         m->piecesNeeded[i].requestedAt = now;
 
-        dbgmsg( tor, "next piece to request: %d", piece );
+        dbgmsg (tor, "next piece to request: %d", piece);
         *setme_piece = piece;
         have_request = true;
     }
@@ -351,15 +353,15 @@ tr_torrentGetNextMetadataRequest( tr_torrent * tor, time_t now, int * setme_piec
 }
 
 double
-tr_torrentGetMetadataPercent( const tr_torrent * tor )
+tr_torrentGetMetadataPercent (const tr_torrent * tor)
 {
     double ret;
 
-    if( tr_torrentHasMetadata( tor ) )
+    if (tr_torrentHasMetadata (tor))
         ret = 1.0;
     else {
         const struct tr_incomplete_metadata * m = tor->incompleteMetadata;
-        if( !m || !m->pieceCount )
+        if (!m || !m->pieceCount)
             ret = 0.0;
         else
             ret = (m->pieceCount - m->piecesNeededCount) / (double)m->pieceCount;
@@ -369,26 +371,26 @@ tr_torrentGetMetadataPercent( const tr_torrent * tor )
 }
 
 char*
-tr_torrentInfoGetMagnetLink( const tr_info * inf )
+tr_torrentInfoGetMagnetLink (const tr_info * inf)
 {
     int i;
     const char * name;
-    struct evbuffer * s = evbuffer_new( );
+    struct evbuffer * s = evbuffer_new ();
 
-    evbuffer_add_printf( s, "magnet:?xt=urn:btih:%s", inf->hashString );
+    evbuffer_add_printf (s, "magnet:?xt=urn:btih:%s", inf->hashString);
 
     name = inf->name;
-    if( name && *name )
+    if (name && *name)
     {
-        evbuffer_add_printf( s, "%s", "&dn=" );
-        tr_http_escape( s, name, -1, true );
+        evbuffer_add_printf (s, "%s", "&dn=");
+        tr_http_escape (s, name, -1, true);
     }
 
-    for( i=0; i<inf->trackerCount; ++i )
+    for (i=0; i<inf->trackerCount; ++i)
     {
-        evbuffer_add_printf( s, "%s", "&tr=" );
-        tr_http_escape( s, inf->trackers[i].announce, -1, true );
+        evbuffer_add_printf (s, "%s", "&tr=");
+        tr_http_escape (s, inf->trackers[i].announce, -1, true);
     }
 
-    return evbuffer_free_to_str( s );
+    return evbuffer_free_to_str (s);
 }
diff --git a/libtransmission/torrent-magnet.h b/libtransmission/torrent-magnet.h
index f6cbb979b..ed0eb5687 100644
--- a/libtransmission/torrent-magnet.h
+++ b/libtransmission/torrent-magnet.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -22,17 +22,17 @@
 enum
 {
     /* defined by BEP #9 */
-    METADATA_PIECE_SIZE = ( 1024 * 16 )
+    METADATA_PIECE_SIZE = (1024 * 16)
 };
 
-void* tr_torrentGetMetadataPiece( tr_torrent * tor, int piece, int * len );
+void* tr_torrentGetMetadataPiece (tr_torrent * tor, int piece, int * len);
 
-void tr_torrentSetMetadataPiece( tr_torrent * tor, int piece, const void * data, int len );
+void tr_torrentSetMetadataPiece (tr_torrent * tor, int piece, const void * data, int len);
 
-bool tr_torrentGetNextMetadataRequest( tr_torrent * tor, time_t now, int * setme );
+bool tr_torrentGetNextMetadataRequest (tr_torrent * tor, time_t now, int * setme);
 
-void tr_torrentSetMetadataSizeHint( tr_torrent * tor, int metadata_size );
+void tr_torrentSetMetadataSizeHint (tr_torrent * tor, int metadata_size);
 
-double tr_torrentGetMetadataPercent( const tr_torrent * tor );
+double tr_torrentGetMetadataPercent (const tr_torrent * tor);
 
 #endif
diff --git a/libtransmission/torrent.c b/libtransmission/torrent.c
index a824cc849..21f01c9e5 100644
--- a/libtransmission/torrent.c
+++ b/libtransmission/torrent.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,14 +10,14 @@
  * $Id$
  */
 
-#include <signal.h> /* signal() */
+#include <signal.h> /* signal () */
 #include <sys/types.h> /* stat */
 #include <sys/stat.h> /* stat */
 #ifndef WIN32
- #include <sys/wait.h> /* wait() */
+ #include <sys/wait.h> /* wait () */
 #else
  #include <process.h>
- #define waitpid(pid, status, options)	_cwait(status, pid, WAIT_CHILD)
+ #define waitpid(pid, status, options)	_cwait (status, pid, WAIT_CHILD)
 #endif
 #include <unistd.h> /* stat */
 #include <dirent.h>
@@ -27,9 +27,9 @@
 #include <stdarg.h>
 #include <string.h> /* memcmp */
 #include <stdlib.h> /* qsort */
-#include <stdio.h> /* remove() */
+#include <stdio.h> /* remove () */
 
-#include <event2/util.h> /* evutil_vsnprintf() */
+#include <event2/util.h> /* evutil_vsnprintf () */
 
 #include "transmission.h"
 #include "announcer.h"
@@ -40,7 +40,7 @@
 #include "crypto.h" /* for tr_sha1 */
 #include "resume.h"
 #include "fdlimit.h" /* tr_fdTorrentClose */
-#include "inout.h" /* tr_ioTestPiece() */
+#include "inout.h" /* tr_ioTestPiece () */
 #include "magnet.h"
 #include "metainfo.h"
 #include "peer-common.h" /* MAX_BLOCK_SIZE */
@@ -50,7 +50,7 @@
 #include "session.h"
 #include "torrent.h"
 #include "torrent-magnet.h"
-#include "trevent.h" /* tr_runInEventThread() */
+#include "trevent.h" /* tr_runInEventThread () */
 #include "utils.h"
 #include "verify.h"
 #include "version.h"
@@ -59,110 +59,112 @@
 ****
 ***/
 
-#define tr_deeplog_tor( tor, ... ) \
-    do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, tr_torrentName( tor ), __VA_ARGS__ ); \
-    } while( 0 )
+#define tr_deeplog_tor(tor, ...) \
+  do \
+    { \
+      if (tr_deepLoggingIsActive ()) \
+        tr_deepLog (__FILE__, __LINE__, tr_torrentName (tor), __VA_ARGS__); \
+    } \
+  while (0)
 
 /***
 ****
 ***/
 
 const char *
-tr_torrentName( const tr_torrent * tor )
+tr_torrentName (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     return tor->info.name;
 }
 
 int
-tr_torrentId( const tr_torrent * tor )
+tr_torrentId (const tr_torrent * tor)
 {
     return tor->uniqueId;
 }
 
 tr_torrent*
-tr_torrentFindFromId( tr_session * session, int id )
+tr_torrentFindFromId (tr_session * session, int id)
 {
     tr_torrent * tor = NULL;
 
-    while(( tor = tr_torrentNext( session, tor )))
-        if( tor->uniqueId == id )
+    while ((tor = tr_torrentNext (session, tor)))
+        if (tor->uniqueId == id)
             return tor;
 
     return NULL;
 }
 
 tr_torrent*
-tr_torrentFindFromHashString( tr_session *  session, const char * str )
+tr_torrentFindFromHashString (tr_session *  session, const char * str)
 {
     tr_torrent * tor = NULL;
 
-    while(( tor = tr_torrentNext( session, tor )))
-        if( !evutil_ascii_strcasecmp( str, tor->info.hashString ) )
+    while ((tor = tr_torrentNext (session, tor)))
+        if (!evutil_ascii_strcasecmp (str, tor->info.hashString))
             return tor;
 
     return NULL;
 }
 
 tr_torrent*
-tr_torrentFindFromHash( tr_session * session, const uint8_t * torrentHash )
+tr_torrentFindFromHash (tr_session * session, const uint8_t * torrentHash)
 {
     tr_torrent * tor = NULL;
 
-    while(( tor = tr_torrentNext( session, tor )))
-        if( *tor->info.hash == *torrentHash )
-            if( !memcmp( tor->info.hash, torrentHash, SHA_DIGEST_LENGTH ) )
+    while ((tor = tr_torrentNext (session, tor)))
+        if (*tor->info.hash == *torrentHash)
+            if (!memcmp (tor->info.hash, torrentHash, SHA_DIGEST_LENGTH))
                 return tor;
 
     return NULL;
 }
 
 tr_torrent*
-tr_torrentFindFromMagnetLink( tr_session * session, const char * magnet )
+tr_torrentFindFromMagnetLink (tr_session * session, const char * magnet)
 {
     tr_magnet_info * info;
     tr_torrent * tor = NULL;
 
-    if(( info = tr_magnetParse( magnet )))
+    if ((info = tr_magnetParse (magnet)))
     {
-        tor = tr_torrentFindFromHash( session, info->hash );
-        tr_magnetFree( info );
+        tor = tr_torrentFindFromHash (session, info->hash);
+        tr_magnetFree (info);
     }
 
     return tor;
 }
 
 tr_torrent*
-tr_torrentFindFromObfuscatedHash( tr_session * session,
-                                  const uint8_t * obfuscatedTorrentHash )
+tr_torrentFindFromObfuscatedHash (tr_session * session,
+                                  const uint8_t * obfuscatedTorrentHash)
 {
     tr_torrent * tor = NULL;
 
-    while(( tor = tr_torrentNext( session, tor )))
-        if( !memcmp( tor->obfuscatedHash, obfuscatedTorrentHash,
-                     SHA_DIGEST_LENGTH ) )
+    while ((tor = tr_torrentNext (session, tor)))
+        if (!memcmp (tor->obfuscatedHash, obfuscatedTorrentHash,
+                     SHA_DIGEST_LENGTH))
             return tor;
 
     return NULL;
 }
 
 bool
-tr_torrentIsPieceTransferAllowed( const tr_torrent  * tor,
-                                  tr_direction        direction )
+tr_torrentIsPieceTransferAllowed (const tr_torrent  * tor,
+                                  tr_direction        direction)
 {
     unsigned int limit;
     bool allowed = true;
 
-    if( tr_torrentUsesSpeedLimit( tor, direction ) )
-        if( tr_torrentGetSpeedLimit_Bps( tor, direction ) <= 0 )
+    if (tr_torrentUsesSpeedLimit (tor, direction))
+        if (tr_torrentGetSpeedLimit_Bps (tor, direction) <= 0)
             allowed = false;
 
-    if( tr_torrentUsesSessionLimits( tor ) )
-        if( tr_sessionGetActiveSpeedLimit_Bps( tor->session, direction, &limit ) )
-            if( limit <= 0 )
+    if (tr_torrentUsesSessionLimits (tor))
+        if (tr_sessionGetActiveSpeedLimit_Bps (tor->session, direction, &limit))
+            if (limit <= 0)
                 allowed = false;
 
     return allowed;
@@ -173,73 +175,73 @@ tr_torrentIsPieceTransferAllowed( const tr_torrent  * tor,
 ***/
 
 void
-tr_torrentSetSpeedLimit_Bps( tr_torrent * tor, tr_direction dir, unsigned int Bps )
+tr_torrentSetSpeedLimit_Bps (tr_torrent * tor, tr_direction dir, unsigned int Bps)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_isDirection (dir));
 
-    if( tr_bandwidthSetDesiredSpeed_Bps( &tor->bandwidth, dir, Bps ) )
-        tr_torrentSetDirty( tor );
+    if (tr_bandwidthSetDesiredSpeed_Bps (&tor->bandwidth, dir, Bps))
+        tr_torrentSetDirty (tor);
 }
 void
-tr_torrentSetSpeedLimit_KBps( tr_torrent * tor, tr_direction dir, unsigned int KBps )
+tr_torrentSetSpeedLimit_KBps (tr_torrent * tor, tr_direction dir, unsigned int KBps)
 {
-    tr_torrentSetSpeedLimit_Bps( tor, dir, toSpeedBytes( KBps ) );
+    tr_torrentSetSpeedLimit_Bps (tor, dir, toSpeedBytes (KBps));
 }
 
 unsigned int
-tr_torrentGetSpeedLimit_Bps( const tr_torrent * tor, tr_direction dir )
+tr_torrentGetSpeedLimit_Bps (const tr_torrent * tor, tr_direction dir)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_isDirection (dir));
 
-    return tr_bandwidthGetDesiredSpeed_Bps( &tor->bandwidth, dir );
+    return tr_bandwidthGetDesiredSpeed_Bps (&tor->bandwidth, dir);
 }
 unsigned int
-tr_torrentGetSpeedLimit_KBps( const tr_torrent * tor, tr_direction dir )
+tr_torrentGetSpeedLimit_KBps (const tr_torrent * tor, tr_direction dir)
 {
-    return toSpeedKBps( tr_torrentGetSpeedLimit_Bps( tor, dir ) );
+    return toSpeedKBps (tr_torrentGetSpeedLimit_Bps (tor, dir));
 }
 
 void
-tr_torrentUseSpeedLimit( tr_torrent * tor, tr_direction dir, bool do_use )
+tr_torrentUseSpeedLimit (tr_torrent * tor, tr_direction dir, bool do_use)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_isDirection (dir));
 
-    if( tr_bandwidthSetLimited( &tor->bandwidth, dir, do_use ) )
-        tr_torrentSetDirty( tor );
+    if (tr_bandwidthSetLimited (&tor->bandwidth, dir, do_use))
+        tr_torrentSetDirty (tor);
 }
 
 bool
-tr_torrentUsesSpeedLimit( const tr_torrent * tor, tr_direction dir )
+tr_torrentUsesSpeedLimit (const tr_torrent * tor, tr_direction dir)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_isDirection( dir ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_isDirection (dir));
 
-    return tr_bandwidthIsLimited( &tor->bandwidth, dir );
+    return tr_bandwidthIsLimited (&tor->bandwidth, dir);
 }
 
 void
-tr_torrentUseSessionLimits( tr_torrent * tor, bool doUse )
+tr_torrentUseSessionLimits (tr_torrent * tor, bool doUse)
 {
     bool changed;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    changed = tr_bandwidthHonorParentLimits( &tor->bandwidth, TR_UP, doUse );
-    changed |= tr_bandwidthHonorParentLimits( &tor->bandwidth, TR_DOWN, doUse );
+    changed = tr_bandwidthHonorParentLimits (&tor->bandwidth, TR_UP, doUse);
+    changed |= tr_bandwidthHonorParentLimits (&tor->bandwidth, TR_DOWN, doUse);
 
-    if( changed )
-        tr_torrentSetDirty( tor );
+    if (changed)
+        tr_torrentSetDirty (tor);
 }
 
 bool
-tr_torrentUsesSessionLimits( const tr_torrent * tor )
+tr_torrentUsesSessionLimits (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    return tr_bandwidthAreParentLimitsHonored( &tor->bandwidth, TR_UP );
+    return tr_bandwidthAreParentLimitsHonored (&tor->bandwidth, TR_UP);
 }
 
 /***
@@ -247,65 +249,65 @@ tr_torrentUsesSessionLimits( const tr_torrent * tor )
 ***/
 
 void
-tr_torrentSetRatioMode( tr_torrent *  tor, tr_ratiolimit mode )
+tr_torrentSetRatioMode (tr_torrent *  tor, tr_ratiolimit mode)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( mode==TR_RATIOLIMIT_GLOBAL || mode==TR_RATIOLIMIT_SINGLE || mode==TR_RATIOLIMIT_UNLIMITED  );
+    assert (tr_isTorrent (tor));
+    assert (mode==TR_RATIOLIMIT_GLOBAL || mode==TR_RATIOLIMIT_SINGLE || mode==TR_RATIOLIMIT_UNLIMITED);
 
-    if( mode != tor->ratioLimitMode )
+    if (mode != tor->ratioLimitMode)
     {
         tor->ratioLimitMode = mode;
 
-        tr_torrentSetDirty( tor );
+        tr_torrentSetDirty (tor);
     }
 }
 
 tr_ratiolimit
-tr_torrentGetRatioMode( const tr_torrent * tor )
+tr_torrentGetRatioMode (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     return tor->ratioLimitMode;
 }
 
 void
-tr_torrentSetRatioLimit( tr_torrent * tor, double desiredRatio )
+tr_torrentSetRatioLimit (tr_torrent * tor, double desiredRatio)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( (int)(desiredRatio*100.0) != (int)(tor->desiredRatio*100.0) )
+    if ((int)(desiredRatio*100.0) != (int)(tor->desiredRatio*100.0))
     {
         tor->desiredRatio = desiredRatio;
 
-        tr_torrentSetDirty( tor );
+        tr_torrentSetDirty (tor);
     }
 }
 
 double
-tr_torrentGetRatioLimit( const tr_torrent * tor )
+tr_torrentGetRatioLimit (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     return tor->desiredRatio;
 }
 
 bool
-tr_torrentGetSeedRatio( const tr_torrent * tor, double * ratio )
+tr_torrentGetSeedRatio (const tr_torrent * tor, double * ratio)
 {
     bool isLimited;
 
-    switch( tr_torrentGetRatioMode( tor ) )
+    switch (tr_torrentGetRatioMode (tor))
     {
         case TR_RATIOLIMIT_SINGLE:
             isLimited = true;
-            if( ratio )
-                *ratio = tr_torrentGetRatioLimit( tor );
+            if (ratio)
+                *ratio = tr_torrentGetRatioLimit (tor);
             break;
 
         case TR_RATIOLIMIT_GLOBAL:
-            isLimited = tr_sessionIsRatioLimited( tor->session );
-            if( isLimited && ratio )
-                *ratio = tr_sessionGetRatioLimit( tor->session );
+            isLimited = tr_sessionIsRatioLimited (tor->session);
+            if (isLimited && ratio)
+                *ratio = tr_sessionGetRatioLimit (tor->session);
             break;
 
         default: /* TR_RATIOLIMIT_UNLIMITED */
@@ -319,32 +321,32 @@ tr_torrentGetSeedRatio( const tr_torrent * tor, double * ratio )
 /* returns true if the seed ratio applies --
  * it applies if the torrent's a seed AND it has a seed ratio set */
 static bool
-tr_torrentGetSeedRatioBytes( tr_torrent  * tor,
+tr_torrentGetSeedRatioBytes (tr_torrent  * tor,
                              uint64_t    * setmeLeft,
-                             uint64_t    * setmeGoal )
+                             uint64_t    * setmeGoal)
 {
     double seedRatio;
     bool seedRatioApplies = false;
 
-    if( tr_torrentGetSeedRatio( tor, &seedRatio ) )
+    if (tr_torrentGetSeedRatio (tor, &seedRatio))
     {
         const uint64_t u = tor->uploadedCur + tor->uploadedPrev;
         const uint64_t d = tor->downloadedCur + tor->downloadedPrev;
-        const uint64_t baseline = d ? d : tr_cpSizeWhenDone( &tor->completion );
+        const uint64_t baseline = d ? d : tr_cpSizeWhenDone (&tor->completion);
         const uint64_t goal = baseline * seedRatio;
-        if( setmeLeft ) *setmeLeft = goal > u ? goal - u : 0;
-        if( setmeGoal ) *setmeGoal = goal;
-        seedRatioApplies = tr_torrentIsSeed( tor );
+        if (setmeLeft) *setmeLeft = goal > u ? goal - u : 0;
+        if (setmeGoal) *setmeGoal = goal;
+        seedRatioApplies = tr_torrentIsSeed (tor);
     }
 
     return seedRatioApplies;
 }
 
 static bool
-tr_torrentIsSeedRatioDone( tr_torrent * tor )
+tr_torrentIsSeedRatioDone (tr_torrent * tor)
 {
     uint64_t bytesLeft;
-    return tr_torrentGetSeedRatioBytes( tor, &bytesLeft, NULL ) && !bytesLeft;
+    return tr_torrentGetSeedRatioBytes (tor, &bytesLeft, NULL) && !bytesLeft;
 }
 
 /***
@@ -352,65 +354,65 @@ tr_torrentIsSeedRatioDone( tr_torrent * tor )
 ***/
 
 void
-tr_torrentSetIdleMode( tr_torrent *  tor, tr_idlelimit mode )
+tr_torrentSetIdleMode (tr_torrent *  tor, tr_idlelimit mode)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( mode==TR_IDLELIMIT_GLOBAL || mode==TR_IDLELIMIT_SINGLE || mode==TR_IDLELIMIT_UNLIMITED  );
+    assert (tr_isTorrent (tor));
+    assert (mode==TR_IDLELIMIT_GLOBAL || mode==TR_IDLELIMIT_SINGLE || mode==TR_IDLELIMIT_UNLIMITED);
 
-    if( mode != tor->idleLimitMode )
+    if (mode != tor->idleLimitMode)
     {
         tor->idleLimitMode = mode;
 
-        tr_torrentSetDirty( tor );
+        tr_torrentSetDirty (tor);
     }
 }
 
 tr_idlelimit
-tr_torrentGetIdleMode( const tr_torrent * tor )
+tr_torrentGetIdleMode (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     return tor->idleLimitMode;
 }
 
 void
-tr_torrentSetIdleLimit( tr_torrent * tor, uint16_t idleMinutes )
+tr_torrentSetIdleLimit (tr_torrent * tor, uint16_t idleMinutes)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( idleMinutes > 0 )
+    if (idleMinutes > 0)
     {
         tor->idleLimitMinutes = idleMinutes;
 
-        tr_torrentSetDirty( tor );
+        tr_torrentSetDirty (tor);
     }
 }
 
 uint16_t
-tr_torrentGetIdleLimit( const tr_torrent * tor )
+tr_torrentGetIdleLimit (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     return tor->idleLimitMinutes;
 }
 
 bool
-tr_torrentGetSeedIdle( const tr_torrent * tor, uint16_t * idleMinutes )
+tr_torrentGetSeedIdle (const tr_torrent * tor, uint16_t * idleMinutes)
 {
     bool isLimited;
 
-    switch( tr_torrentGetIdleMode( tor ) )
+    switch (tr_torrentGetIdleMode (tor))
     {
         case TR_IDLELIMIT_SINGLE:
             isLimited = true;
-            if( idleMinutes )
-                *idleMinutes = tr_torrentGetIdleLimit( tor );
+            if (idleMinutes)
+                *idleMinutes = tr_torrentGetIdleLimit (tor);
             break;
 
         case TR_IDLELIMIT_GLOBAL:
-            isLimited = tr_sessionIsIdleLimited( tor->session );
-            if( isLimited && idleMinutes )
-                *idleMinutes = tr_sessionGetIdleLimit( tor->session );
+            isLimited = tr_sessionIsIdleLimited (tor->session);
+            if (isLimited && idleMinutes)
+                *idleMinutes = tr_sessionGetIdleLimit (tor->session);
             break;
 
         default: /* TR_IDLELIMIT_UNLIMITED */
@@ -422,11 +424,11 @@ tr_torrentGetSeedIdle( const tr_torrent * tor, uint16_t * idleMinutes )
 }
 
 static bool
-tr_torrentIsSeedIdleLimitDone( tr_torrent * tor )
+tr_torrentIsSeedIdleLimitDone (tr_torrent * tor)
 {
     uint16_t idleMinutes;
-    return tr_torrentGetSeedIdle( tor, &idleMinutes )
-        && difftime(tr_time(), MAX(tor->startDate, tor->activityDate)) >= idleMinutes * 60u;
+    return tr_torrentGetSeedIdle (tor, &idleMinutes)
+        && difftime (tr_time (), MAX (tor->startDate, tor->activityDate)) >= idleMinutes * 60u;
 }
 
 /***
@@ -434,35 +436,35 @@ tr_torrentIsSeedIdleLimitDone( tr_torrent * tor )
 ***/
 
 void
-tr_torrentCheckSeedLimit( tr_torrent * tor )
+tr_torrentCheckSeedLimit (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( !tor->isRunning || !tr_torrentIsSeed( tor ) )
+    if (!tor->isRunning || !tr_torrentIsSeed (tor))
         return;
 
     /* if we're seeding and reach our seed ratio limit, stop the torrent */
-    if( tr_torrentIsSeedRatioDone( tor ) )
+    if (tr_torrentIsSeedRatioDone (tor))
     {
-        tr_torinf( tor, "Seed ratio reached; pausing torrent" );
+        tr_torinf (tor, "Seed ratio reached; pausing torrent");
 
         tor->isStopping = true;
 
         /* maybe notify the client */
-        if( tor->ratio_limit_hit_func != NULL )
-            tor->ratio_limit_hit_func( tor, tor->ratio_limit_hit_func_user_data );
+        if (tor->ratio_limit_hit_func != NULL)
+            tor->ratio_limit_hit_func (tor, tor->ratio_limit_hit_func_user_data);
     }
     /* if we're seeding and reach our inactiviy limit, stop the torrent */
-    else if( tr_torrentIsSeedIdleLimitDone( tor ) )
+    else if (tr_torrentIsSeedIdleLimitDone (tor))
     {
-        tr_torinf( tor, "Seeding idle limit reached; pausing torrent" );
+        tr_torinf (tor, "Seeding idle limit reached; pausing torrent");
 
         tor->isStopping = true;
         tor->finishedSeedingByIdle = true;
 
         /* maybe notify the client */
-        if( tor->idle_limit_hit_func != NULL )
-            tor->idle_limit_hit_func( tor, tor->idle_limit_hit_func_user_data );
+        if (tor->idle_limit_hit_func != NULL)
+            tor->idle_limit_hit_func (tor, tor->idle_limit_hit_func_user_data);
     }
 }
 
@@ -471,26 +473,26 @@ tr_torrentCheckSeedLimit( tr_torrent * tor )
 ***/
 
 void
-tr_torrentSetLocalError( tr_torrent * tor, const char * fmt, ... )
+tr_torrentSetLocalError (tr_torrent * tor, const char * fmt, ...)
 {
     va_list ap;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    va_start( ap, fmt );
+    va_start (ap, fmt);
     tor->error = TR_STAT_LOCAL_ERROR;
     tor->errorTracker[0] = '\0';
-    evutil_vsnprintf( tor->errorString, sizeof( tor->errorString ), fmt, ap );
-    va_end( ap );
+    evutil_vsnprintf (tor->errorString, sizeof (tor->errorString), fmt, ap);
+    va_end (ap);
 
-    tr_torerr( tor, "%s", tor->errorString );
+    tr_torerr (tor, "%s", tor->errorString);
 
-    if( tor->isRunning )
+    if (tor->isRunning)
         tor->isStopping = true;
 }
 
 static void
-tr_torrentClearError( tr_torrent * tor )
+tr_torrentClearError (tr_torrent * tor)
 {
     tor->error = TR_STAT_OK;
     tor->errorString[0] = '\0';
@@ -498,9 +500,9 @@ tr_torrentClearError( tr_torrent * tor )
 }
 
 static void
-onTrackerResponse( tr_torrent * tor, const tr_tracker_event * event, void * unused UNUSED )
+onTrackerResponse (tr_torrent * tor, const tr_tracker_event * event, void * unused UNUSED)
 {
-    switch( event->messageType )
+    switch (event->messageType)
     {
         case TR_TRACKER_PEERS:
         {
@@ -508,34 +510,34 @@ onTrackerResponse( tr_torrent * tor, const tr_tracker_event * event, void * unus
             const int8_t seedProbability = event->seedProbability;
             const bool allAreSeeds = seedProbability == 100;
 
-             if( allAreSeeds )
-                tr_tordbg( tor, "Got %zu seeds from tracker", event->pexCount );
+             if (allAreSeeds)
+                tr_tordbg (tor, "Got %zu seeds from tracker", event->pexCount);
             else
-                tr_tordbg( tor, "Got %zu peers from tracker", event->pexCount );
+                tr_tordbg (tor, "Got %zu peers from tracker", event->pexCount);
 
-            for( i = 0; i < event->pexCount; ++i )
-                tr_peerMgrAddPex( tor, TR_PEER_FROM_TRACKER, &event->pex[i], seedProbability );
+            for (i = 0; i < event->pexCount; ++i)
+                tr_peerMgrAddPex (tor, TR_PEER_FROM_TRACKER, &event->pex[i], seedProbability);
 
             break;
         }
 
         case TR_TRACKER_WARNING:
-            tr_torerr( tor, _( "Tracker warning: \"%s\"" ), event->text );
+            tr_torerr (tor, _ ("Tracker warning: \"%s\""), event->text);
             tor->error = TR_STAT_TRACKER_WARNING;
-            tr_strlcpy( tor->errorTracker, event->tracker, sizeof( tor->errorTracker ) );
-            tr_strlcpy( tor->errorString, event->text, sizeof( tor->errorString ) );
+            tr_strlcpy (tor->errorTracker, event->tracker, sizeof (tor->errorTracker));
+            tr_strlcpy (tor->errorString, event->text, sizeof (tor->errorString));
             break;
 
         case TR_TRACKER_ERROR:
-            tr_torerr( tor, _( "Tracker error: \"%s\"" ), event->text );
+            tr_torerr (tor, _ ("Tracker error: \"%s\""), event->text);
             tor->error = TR_STAT_TRACKER_ERROR;
-            tr_strlcpy( tor->errorTracker, event->tracker, sizeof( tor->errorTracker ) );
-            tr_strlcpy( tor->errorString, event->text, sizeof( tor->errorString ) );
+            tr_strlcpy (tor->errorTracker, event->tracker, sizeof (tor->errorTracker));
+            tr_strlcpy (tor->errorString, event->text, sizeof (tor->errorString));
             break;
 
         case TR_TRACKER_ERROR_CLEAR:
-            if( tor->error != TR_STAT_LOCAL_ERROR )
-                tr_torrentClearError( tor );
+            if (tor->error != TR_STAT_LOCAL_ERROR)
+                tr_torrentClearError (tor);
             break;
     }
 }
@@ -547,12 +549,12 @@ onTrackerResponse( tr_torrent * tor, const tr_tracker_event * event, void * unus
 ***/
 
 static tr_piece_index_t
-getBytePiece( const tr_info * info, uint64_t byteOffset )
+getBytePiece (const tr_info * info, uint64_t byteOffset)
 {
     tr_piece_index_t piece;
 
-    assert( info );
-    assert( info->pieceSize != 0 );
+    assert (info);
+    assert (info->pieceSize != 0);
 
     piece = byteOffset / info->pieceSize;
 
@@ -564,64 +566,64 @@ getBytePiece( const tr_info * info, uint64_t byteOffset )
 }
 
 static void
-initFilePieces( tr_info *       info,
-                tr_file_index_t fileIndex )
+initFilePieces (tr_info *       info,
+                tr_file_index_t fileIndex)
 {
     tr_file * file;
     uint64_t  firstByte, lastByte;
 
-    assert( info );
-    assert( fileIndex < info->fileCount );
+    assert (info);
+    assert (fileIndex < info->fileCount);
 
     file = &info->files[fileIndex];
     firstByte = file->offset;
-    lastByte = firstByte + ( file->length ? file->length - 1 : 0 );
-    file->firstPiece = getBytePiece( info, firstByte );
-    file->lastPiece = getBytePiece( info, lastByte );
+    lastByte = firstByte + (file->length ? file->length - 1 : 0);
+    file->firstPiece = getBytePiece (info, firstByte);
+    file->lastPiece = getBytePiece (info, lastByte);
 }
 
 static int
-pieceHasFile( tr_piece_index_t piece,
-              const tr_file *  file )
+pieceHasFile (tr_piece_index_t piece,
+              const tr_file *  file)
 {
-    return ( file->firstPiece <= piece ) && ( piece <= file->lastPiece );
+    return (file->firstPiece <= piece) && (piece <= file->lastPiece);
 }
 
 static tr_priority_t
-calculatePiecePriority( const tr_torrent * tor,
+calculatePiecePriority (const tr_torrent * tor,
                         tr_piece_index_t   piece,
-                        int                fileHint )
+                        int                fileHint)
 {
     tr_file_index_t i;
     tr_priority_t priority = TR_PRI_LOW;
 
     /* find the first file that has data in this piece */
-    if( fileHint >= 0 ) {
+    if (fileHint >= 0) {
         i = fileHint;
-        while( i > 0 && pieceHasFile( piece, &tor->info.files[i - 1] ) )
+        while (i > 0 && pieceHasFile (piece, &tor->info.files[i - 1]))
             --i;
     } else {
-        for( i = 0; i < tor->info.fileCount; ++i )
-            if( pieceHasFile( piece, &tor->info.files[i] ) )
+        for (i = 0; i < tor->info.fileCount; ++i)
+            if (pieceHasFile (piece, &tor->info.files[i]))
                 break;
     }
 
     /* the piece's priority is the max of the priorities
      * of all the files in that piece */
-    for( ; i < tor->info.fileCount; ++i )
+    for (; i < tor->info.fileCount; ++i)
     {
         const tr_file * file = &tor->info.files[i];
 
-        if( !pieceHasFile( piece, file ) )
+        if (!pieceHasFile (piece, file))
             break;
 
-        priority = MAX( priority, file->priority );
+        priority = MAX (priority, file->priority);
 
         /* when dealing with multimedia files, getting the first and
            last pieces can sometimes allow you to preview it a bit
            before it's fully downloaded... */
-        if( file->priority >= TR_PRI_NORMAL )
-            if( file->firstPiece == piece || file->lastPiece == piece )
+        if (file->priority >= TR_PRI_NORMAL)
+            if (file->firstPiece == piece || file->lastPiece == piece)
                 priority = TR_PRI_HIGH;
     }
 
@@ -629,7 +631,7 @@ calculatePiecePriority( const tr_torrent * tor,
 }
 
 static void
-tr_torrentInitFilePieces( tr_torrent * tor )
+tr_torrentInitFilePieces (tr_torrent * tor)
 {
     int * firstFiles;
     tr_file_index_t f;
@@ -638,42 +640,42 @@ tr_torrentInitFilePieces( tr_torrent * tor )
     tr_info * inf = &tor->info;
 
     /* assign the file offsets */
-    for( f=0; f<inf->fileCount; ++f ) {
+    for (f=0; f<inf->fileCount; ++f) {
         inf->files[f].offset = offset;
         offset += inf->files[f].length;
-        initFilePieces( inf, f );
+        initFilePieces (inf, f);
     }
 
     /* build the array of first-file hints to give calculatePiecePriority */
-    firstFiles = tr_new( int, inf->pieceCount );
-    for( p=f=0; p<inf->pieceCount; ++p ) {
-        while( inf->files[f].lastPiece < p )
+    firstFiles = tr_new (int, inf->pieceCount);
+    for (p=f=0; p<inf->pieceCount; ++p) {
+        while (inf->files[f].lastPiece < p)
             ++f;
         firstFiles[p] = f;
     }
 
 #if 0
     /* test to confirm the first-file hints are correct */
-    for( p=0; p<inf->pieceCount; ++p ) {
+    for (p=0; p<inf->pieceCount; ++p) {
         f = firstFiles[p];
-        assert( inf->files[f].firstPiece <= p );
-        assert( inf->files[f].lastPiece >= p );
-        if( f > 0 )
-            assert( inf->files[f-1].lastPiece < p );
-        for( f=0; f<inf->fileCount; ++f )
-            if( pieceHasFile( p, &inf->files[f] ) )
+        assert (inf->files[f].firstPiece <= p);
+        assert (inf->files[f].lastPiece >= p);
+        if (f > 0)
+            assert (inf->files[f-1].lastPiece < p);
+        for (f=0; f<inf->fileCount; ++f)
+            if (pieceHasFile (p, &inf->files[f]))
                 break;
-        assert( (int)f == firstFiles[p] );
+        assert ((int)f == firstFiles[p]);
     }
 #endif
 
-    for( p=0; p<inf->pieceCount; ++p )
-        inf->pieces[p].priority = calculatePiecePriority( tor, p, firstFiles[p] );
+    for (p=0; p<inf->pieceCount; ++p)
+        inf->pieces[p].priority = calculatePiecePriority (tor, p, firstFiles[p]);
 
-    tr_free( firstFiles );
+    tr_free (firstFiles);
 }
 
-static void torrentStart( tr_torrent * tor, bool bypass_queue );
+static void torrentStart (tr_torrent * tor, bool bypass_queue);
 
 /**
  * Decide on a block size. Constraints:
@@ -681,42 +683,42 @@ static void torrentStart( tr_torrent * tor, bool bypass_queue );
  * (2) pieceSize must be a multiple of block size
  */
 uint32_t
-tr_getBlockSize( uint32_t pieceSize )
+tr_getBlockSize (uint32_t pieceSize)
 {
     uint32_t b = pieceSize;
 
-    while( b > MAX_BLOCK_SIZE )
+    while (b > MAX_BLOCK_SIZE)
         b /= 2u;
 
-    if( !b || ( pieceSize % b ) ) /* not cleanly divisible */
+    if (!b || (pieceSize % b)) /* not cleanly divisible */
         return 0;
     return b;
 }
 
-static void refreshCurrentDir( tr_torrent * tor );
+static void refreshCurrentDir (tr_torrent * tor);
 
 static void
-torrentInitFromInfo( tr_torrent * tor )
+torrentInitFromInfo (tr_torrent * tor)
 {
     uint64_t t;
     tr_info * info = &tor->info;
 
-    tor->blockSize = tr_getBlockSize( info->pieceSize );
+    tor->blockSize = tr_getBlockSize (info->pieceSize);
 
-    if( info->pieceSize )
+    if (info->pieceSize)
         tor->lastPieceSize = (uint32_t)(info->totalSize % info->pieceSize);
 
-    if( !tor->lastPieceSize )
+    if (!tor->lastPieceSize)
         tor->lastPieceSize = info->pieceSize;
 
-    if( tor->blockSize )
+    if (tor->blockSize)
         tor->lastBlockSize = info->totalSize % tor->blockSize;
 
-    if( !tor->lastBlockSize )
+    if (!tor->lastBlockSize)
         tor->lastBlockSize = tor->blockSize;
 
     tor->blockCount = tor->blockSize
-        ? ( info->totalSize + tor->blockSize - 1 ) / tor->blockSize
+        ? (info->totalSize + tor->blockSize - 1) / tor->blockSize
         : 0;
 
     tor->blockCountInPiece = tor->blockSize
@@ -724,72 +726,72 @@ torrentInitFromInfo( tr_torrent * tor )
         : 0;
 
     tor->blockCountInLastPiece = tor->blockSize
-        ? ( tor->lastPieceSize + tor->blockSize - 1 ) / tor->blockSize
+        ? (tor->lastPieceSize + tor->blockSize - 1) / tor->blockSize
         : 0;
 
     /* check our work */
-    if( tor->blockSize != 0 )
-        assert( ( info->pieceSize % tor->blockSize ) == 0 );
+    if (tor->blockSize != 0)
+        assert ((info->pieceSize % tor->blockSize) == 0);
     t = info->pieceCount - 1;
     t *= info->pieceSize;
     t += tor->lastPieceSize;
-    assert( t == info->totalSize );
+    assert (t == info->totalSize);
     t = tor->blockCount - 1;
     t *= tor->blockSize;
     t += tor->lastBlockSize;
-    assert( t == info->totalSize );
+    assert (t == info->totalSize);
     t = info->pieceCount - 1;
     t *= tor->blockCountInPiece;
     t += tor->blockCountInLastPiece;
-    assert( t == (uint64_t)tor->blockCount );
+    assert (t == (uint64_t)tor->blockCount);
 
-    tr_cpConstruct( &tor->completion, tor );
+    tr_cpConstruct (&tor->completion, tor);
 
-    tr_torrentInitFilePieces( tor );
+    tr_torrentInitFilePieces (tor);
 
-    tor->completeness = tr_cpGetStatus( &tor->completion );
+    tor->completeness = tr_cpGetStatus (&tor->completion);
 }
 
-static void tr_torrentFireMetadataCompleted( tr_torrent * tor );
+static void tr_torrentFireMetadataCompleted (tr_torrent * tor);
 
 void
-tr_torrentGotNewInfoDict( tr_torrent * tor )
+tr_torrentGotNewInfoDict (tr_torrent * tor)
 {
-    torrentInitFromInfo( tor );
+    torrentInitFromInfo (tor);
 
-    tr_peerMgrOnTorrentGotMetainfo( tor );
+    tr_peerMgrOnTorrentGotMetainfo (tor);
 
-    tr_torrentFireMetadataCompleted( tor );
+    tr_torrentFireMetadataCompleted (tor);
 }
 
 static bool
-hasAnyLocalData( const tr_torrent * tor )
+hasAnyLocalData (const tr_torrent * tor)
 {
     tr_file_index_t i;
 
-    for( i=0; i<tor->info.fileCount; ++i )
-        if( tr_torrentFindFile2( tor, i, NULL, NULL, NULL ) )
+    for (i=0; i<tor->info.fileCount; ++i)
+        if (tr_torrentFindFile2 (tor, i, NULL, NULL, NULL))
             return true;
 
     return false;
 }
 
 static bool
-setLocalErrorIfFilesDisappeared( tr_torrent * tor )
+setLocalErrorIfFilesDisappeared (tr_torrent * tor)
 {
-    const bool disappeared = ( tr_cpHaveTotal( &tor->completion ) > 0 ) && !hasAnyLocalData( tor );
+    const bool disappeared = (tr_cpHaveTotal (&tor->completion) > 0) && !hasAnyLocalData (tor);
 
-    if( disappeared )
+    if (disappeared)
     {
-        tr_deeplog_tor( tor, "%s", "[LAZY] uh oh, the files disappeared" );
-        tr_torrentSetLocalError( tor, "%s", _( "No data found! Ensure your drives are connected or use \"Set Location\". To re-download, remove the torrent and re-add it." ) );
+        tr_deeplog_tor (tor, "%s", "[LAZY] uh oh, the files disappeared");
+        tr_torrentSetLocalError (tor, "%s", _ ("No data found! Ensure your drives are connected or use \"Set Location\". To re-download, remove the torrent and re-add it."));
     }
 
     return disappeared;
 }
 
 static void
-torrentInit( tr_torrent * tor, const tr_ctor * ctor )
+torrentInit (tr_torrent * tor, const tr_ctor * ctor)
 {
     int doStart;
     uint64_t loaded;
@@ -797,174 +799,174 @@ torrentInit( tr_torrent * tor, const tr_ctor * ctor )
     bool isNewTorrent;
     struct stat st;
     static int nextUniqueId = 1;
-    tr_session * session = tr_ctorGetSession( ctor );
+    tr_session * session = tr_ctorGetSession (ctor);
 
-    assert( session != NULL );
+    assert (session != NULL);
 
-    tr_sessionLock( session );
+    tr_sessionLock (session);
 
     tor->session   = session;
     tor->uniqueId = nextUniqueId++;
     tor->magicNumber = TORRENT_MAGIC_NUMBER;
     tor->queuePosition = session->torrentCount;
 
-    tr_peerIdInit( tor->peer_id );
+    tr_peerIdInit (tor->peer_id);
 
-    tr_sha1( tor->obfuscatedHash, "req2", 4,
+    tr_sha1 (tor->obfuscatedHash, "req2", 4,
              tor->info.hash, SHA_DIGEST_LENGTH,
-             NULL );
+             NULL);
 
-    if( !tr_ctorGetDownloadDir( ctor, TR_FORCE, &dir ) ||
-        !tr_ctorGetDownloadDir( ctor, TR_FALLBACK, &dir ) )
-            tor->downloadDir = tr_strdup( dir );
+    if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &dir) ||
+        !tr_ctorGetDownloadDir (ctor, TR_FALLBACK, &dir))
+            tor->downloadDir = tr_strdup (dir);
 
-    if( tr_ctorGetIncompleteDir( ctor, &dir ) )
-        dir = tr_sessionGetIncompleteDir( session );
-    if( tr_sessionIsIncompleteDirEnabled( session ) )
-        tor->incompleteDir = tr_strdup( dir );
+    if (tr_ctorGetIncompleteDir (ctor, &dir))
+        dir = tr_sessionGetIncompleteDir (session);
+    if (tr_sessionIsIncompleteDirEnabled (session))
+        tor->incompleteDir = tr_strdup (dir);
 
-    tr_bandwidthConstruct( &tor->bandwidth, session, &session->bandwidth );
+    tr_bandwidthConstruct (&tor->bandwidth, session, &session->bandwidth);
 
-    tor->bandwidth.priority = tr_ctorGetBandwidthPriority( ctor );
+    tor->bandwidth.priority = tr_ctorGetBandwidthPriority (ctor);
 
     tor->error = TR_STAT_OK;
 
     tor->finishedSeedingByIdle = false;
 
-    tr_peerMgrAddTorrent( session->peerMgr, tor );
+    tr_peerMgrAddTorrent (session->peerMgr, tor);
 
-    assert( !tor->downloadedCur );
-    assert( !tor->uploadedCur );
+    assert (!tor->downloadedCur);
+    assert (!tor->uploadedCur);
 
-    tr_torrentSetAddedDate( tor, tr_time( ) ); /* this is a default value to be
+    tr_torrentSetAddedDate (tor, tr_time ()); /* this is a default value to be
                                                   overwritten by the resume file */
 
-    torrentInitFromInfo( tor );
-    loaded = tr_torrentLoadResume( tor, ~0, ctor );
-    tor->completeness = tr_cpGetStatus( &tor->completion );
-    setLocalErrorIfFilesDisappeared( tor );
+    torrentInitFromInfo (tor);
+    loaded = tr_torrentLoadResume (tor, ~0, ctor);
+    tor->completeness = tr_cpGetStatus (&tor->completion);
+    setLocalErrorIfFilesDisappeared (tor);
 
-    tr_ctorInitTorrentPriorities( ctor, tor );
-    tr_ctorInitTorrentWanted( ctor, tor );
+    tr_ctorInitTorrentPriorities (ctor, tor);
+    tr_ctorInitTorrentWanted (ctor, tor);
 
-    refreshCurrentDir( tor );
+    refreshCurrentDir (tor);
 
     doStart = tor->isRunning;
     tor->isRunning = 0;
 
-    if( !( loaded & TR_FR_SPEEDLIMIT ) )
+    if (! (loaded & TR_FR_SPEEDLIMIT))
     {
-        tr_torrentUseSpeedLimit( tor, TR_UP, false );
-        tr_torrentSetSpeedLimit_Bps( tor, TR_UP, tr_sessionGetSpeedLimit_Bps( tor->session, TR_UP ) );
-        tr_torrentUseSpeedLimit( tor, TR_DOWN, false );
-        tr_torrentSetSpeedLimit_Bps( tor, TR_DOWN, tr_sessionGetSpeedLimit_Bps( tor->session, TR_DOWN ) );
-        tr_torrentUseSessionLimits( tor, true );
+        tr_torrentUseSpeedLimit (tor, TR_UP, false);
+        tr_torrentSetSpeedLimit_Bps (tor, TR_UP, tr_sessionGetSpeedLimit_Bps (tor->session, TR_UP));
+        tr_torrentUseSpeedLimit (tor, TR_DOWN, false);
+        tr_torrentSetSpeedLimit_Bps (tor, TR_DOWN, tr_sessionGetSpeedLimit_Bps (tor->session, TR_DOWN));
+        tr_torrentUseSessionLimits (tor, true);
     }
 
-    if( !( loaded & TR_FR_RATIOLIMIT ) )
+    if (! (loaded & TR_FR_RATIOLIMIT))
     {
-        tr_torrentSetRatioMode( tor, TR_RATIOLIMIT_GLOBAL );
-        tr_torrentSetRatioLimit( tor, tr_sessionGetRatioLimit( tor->session ) );
+        tr_torrentSetRatioMode (tor, TR_RATIOLIMIT_GLOBAL);
+        tr_torrentSetRatioLimit (tor, tr_sessionGetRatioLimit (tor->session));
     }
 
-    if( !( loaded & TR_FR_IDLELIMIT ) )
+    if (! (loaded & TR_FR_IDLELIMIT))
     {
-        tr_torrentSetIdleMode( tor, TR_IDLELIMIT_GLOBAL );
-        tr_torrentSetIdleLimit( tor, tr_sessionGetIdleLimit( tor->session ) );
+        tr_torrentSetIdleMode (tor, TR_IDLELIMIT_GLOBAL);
+        tr_torrentSetIdleLimit (tor, tr_sessionGetIdleLimit (tor->session));
     }
 
     /* add the torrent to tr_session.torrentList */
     session->torrentCount++;
-    if( session->torrentList == NULL )
+    if (session->torrentList == NULL)
         session->torrentList = tor;
     else {
         tr_torrent * it = session->torrentList;
-        while( it->next != NULL )
+        while (it->next != NULL)
             it = it->next;
         it->next = tor;
     }
 
     /* if we don't have a local .torrent file already, assume the torrent is new */
-    isNewTorrent = stat( tor->info.torrent, &st );
+    isNewTorrent = stat (tor->info.torrent, &st);
 
     /* maybe save our own copy of the metainfo */
-    if( tr_ctorGetSave( ctor ) )
+    if (tr_ctorGetSave (ctor))
     {
         const tr_benc * val;
-        if( !tr_ctorGetMetainfo( ctor, &val ) )
+        if (!tr_ctorGetMetainfo (ctor, &val))
         {
             const char * path = tor->info.torrent;
-            const int err = tr_bencToFile( val, TR_FMT_BENC, path );
-            if( err )
-                tr_torrentSetLocalError( tor, "Unable to save torrent file: %s", tr_strerror( err ) );
-            tr_sessionSetTorrentFile( tor->session, tor->info.hashString, path );
+            const int err = tr_bencToFile (val, TR_FMT_BENC, path);
+            if (err)
+                tr_torrentSetLocalError (tor, "Unable to save torrent file: %s", tr_strerror (err));
+            tr_sessionSetTorrentFile (tor->session, tor->info.hashString, path);
         }
     }
 
-    tor->tiers = tr_announcerAddTorrent( tor, onTrackerResponse, NULL );
+    tor->tiers = tr_announcerAddTorrent (tor, onTrackerResponse, NULL);
 
-    if( isNewTorrent )
+    if (isNewTorrent)
     {
         tor->startAfterVerify = doStart;
-        tr_torrentVerify( tor );
+        tr_torrentVerify (tor);
     }
-    else if( doStart )
+    else if (doStart)
     {
-        tr_torrentStart( tor );
+        tr_torrentStart (tor);
     }
 
-    tr_sessionUnlock( session );
+    tr_sessionUnlock (session);
 }
 
 static tr_parse_result
-torrentParseImpl( const tr_ctor * ctor, tr_info * setmeInfo,
-                  bool * setmeHasInfo, int * dictLength )
+torrentParseImpl (const tr_ctor * ctor, tr_info * setmeInfo,
+                  bool * setmeHasInfo, int * dictLength)
 {
     int             doFree;
     bool            didParse;
     bool            hasInfo = false;
     tr_info         tmp;
     const tr_benc * metainfo;
-    tr_session    * session = tr_ctorGetSession( ctor );
+    tr_session    * session = tr_ctorGetSession (ctor);
     tr_parse_result result = TR_PARSE_OK;
 
-    if( setmeInfo == NULL )
+    if (setmeInfo == NULL)
         setmeInfo = &tmp;
-    memset( setmeInfo, 0, sizeof( tr_info ) );
+    memset (setmeInfo, 0, sizeof (tr_info));
 
-    if( tr_ctorGetMetainfo( ctor, &metainfo ) )
+    if (tr_ctorGetMetainfo (ctor, &metainfo))
         return TR_PARSE_ERR;
 
-    didParse = tr_metainfoParse( session, metainfo, setmeInfo,
-                                 &hasInfo, dictLength );
-    doFree = didParse && ( setmeInfo == &tmp );
+    didParse = tr_metainfoParse (session, metainfo, setmeInfo,
+                                 &hasInfo, dictLength);
+    doFree = didParse && (setmeInfo == &tmp);
 
-    if( !didParse )
+    if (!didParse)
         result = TR_PARSE_ERR;
 
-    if( didParse && hasInfo && !tr_getBlockSize( setmeInfo->pieceSize ) )
+    if (didParse && hasInfo && !tr_getBlockSize (setmeInfo->pieceSize))
         result = TR_PARSE_ERR;
 
-    if( didParse && session && tr_torrentExists( session, setmeInfo->hash ) )
+    if (didParse && session && tr_torrentExists (session, setmeInfo->hash))
         result = TR_PARSE_DUPLICATE;
 
-    if( doFree )
-        tr_metainfoFree( setmeInfo );
+    if (doFree)
+        tr_metainfoFree (setmeInfo);
 
-    if( setmeHasInfo != NULL )
+    if (setmeHasInfo != NULL)
         *setmeHasInfo = hasInfo;
 
     return result;
 }
 
 tr_parse_result
-tr_torrentParse( const tr_ctor * ctor, tr_info * setmeInfo )
+tr_torrentParse (const tr_ctor * ctor, tr_info * setmeInfo)
 {
-    return torrentParseImpl( ctor, setmeInfo, NULL, NULL );
+    return torrentParseImpl (ctor, setmeInfo, NULL, NULL);
 }
 
 tr_torrent *
-tr_torrentNew( const tr_ctor * ctor, int * setmeError )
+tr_torrentNew (const tr_ctor * ctor, int * setmeError)
 {
     int len;
     bool hasInfo;
@@ -972,24 +974,24 @@ tr_torrentNew( const tr_ctor * ctor, int * setmeError )
     tr_parse_result r;
     tr_torrent * tor = NULL;
 
-    assert( ctor != NULL );
-    assert( tr_isSession( tr_ctorGetSession( ctor ) ) );
+    assert (ctor != NULL);
+    assert (tr_isSession (tr_ctorGetSession (ctor)));
 
-    r = torrentParseImpl( ctor, &tmpInfo, &hasInfo, &len );
-    if( r == TR_PARSE_OK )
+    r = torrentParseImpl (ctor, &tmpInfo, &hasInfo, &len);
+    if (r == TR_PARSE_OK)
     {
-        tor = tr_new0( tr_torrent, 1 );
+        tor = tr_new0 (tr_torrent, 1);
         tor->info = tmpInfo;
-        if( hasInfo )
+        if (hasInfo)
             tor->infoDictLength = len;
-        torrentInit( tor, ctor );
+        torrentInit (tor, ctor);
     }
     else
     {
-        if( r == TR_PARSE_DUPLICATE )
-            tr_metainfoFree( &tmpInfo );
+        if (r == TR_PARSE_DUPLICATE)
+            tr_metainfoFree (&tmpInfo);
 
-        if( setmeError )
+        if (setmeError)
             *setmeError = r;
     }
 
@@ -1001,118 +1003,118 @@ tr_torrentNew( const tr_ctor * ctor, int * setmeError )
 **/
 
 void
-tr_torrentSetDownloadDir( tr_torrent * tor, const char * path )
+tr_torrentSetDownloadDir (tr_torrent * tor, const char * path)
 {
-    assert( tr_isTorrent( tor  ) );
+    assert (tr_isTorrent (tor));
 
-    if( !path || !tor->downloadDir || strcmp( path, tor->downloadDir ) )
+    if (!path || !tor->downloadDir || strcmp (path, tor->downloadDir))
     {
-        tr_free( tor->downloadDir );
-        tor->downloadDir = tr_strdup( path );
-        tr_torrentSetDirty( tor );
+        tr_free (tor->downloadDir);
+        tor->downloadDir = tr_strdup (path);
+        tr_torrentSetDirty (tor);
     }
 
-    refreshCurrentDir( tor );
+    refreshCurrentDir (tor);
 }
 
 const char*
-tr_torrentGetDownloadDir( const tr_torrent * tor )
+tr_torrentGetDownloadDir (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor  ) );
+    assert (tr_isTorrent (tor));
 
     return tor->downloadDir;
 }
 
 const char *
-tr_torrentGetCurrentDir( const tr_torrent * tor )
+tr_torrentGetCurrentDir (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor  ) );
+    assert (tr_isTorrent (tor));
 
     return tor->currentDir;
 }
 
 
 void
-tr_torrentChangeMyPort( tr_torrent * tor )
+tr_torrentChangeMyPort (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor  ) );
+    assert (tr_isTorrent (tor));
 
-    if( tor->isRunning )
-        tr_announcerChangeMyPort( tor );
+    if (tor->isRunning)
+        tr_announcerChangeMyPort (tor);
 }
 
 static inline void
-tr_torrentManualUpdateImpl( void * vtor )
+tr_torrentManualUpdateImpl (void * vtor)
 {
     tr_torrent * tor = vtor;
 
-    assert( tr_isTorrent( tor  ) );
+    assert (tr_isTorrent (tor));
 
-    if( tor->isRunning )
-        tr_announcerManualAnnounce( tor );
+    if (tor->isRunning)
+        tr_announcerManualAnnounce (tor);
 }
 
 void
-tr_torrentManualUpdate( tr_torrent * tor )
+tr_torrentManualUpdate (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor  ) );
+    assert (tr_isTorrent (tor));
 
-    tr_runInEventThread( tor->session, tr_torrentManualUpdateImpl, tor );
+    tr_runInEventThread (tor->session, tr_torrentManualUpdateImpl, tor);
 }
 
 bool
-tr_torrentCanManualUpdate( const tr_torrent * tor )
+tr_torrentCanManualUpdate (const tr_torrent * tor)
 {
-    return ( tr_isTorrent( tor  ) )
-        && ( tor->isRunning )
-        && ( tr_announcerCanManualAnnounce( tor ) );
+    return (tr_isTorrent (tor))
+        && (tor->isRunning)
+        && (tr_announcerCanManualAnnounce (tor));
 }
 
 const tr_info *
-tr_torrentInfo( const tr_torrent * tor )
+tr_torrentInfo (const tr_torrent * tor)
 {
-    return tr_isTorrent( tor ) ? &tor->info : NULL;
+    return tr_isTorrent (tor) ? &tor->info : NULL;
 }
 
 const tr_stat *
-tr_torrentStatCached( tr_torrent * tor )
+tr_torrentStatCached (tr_torrent * tor)
 {
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    return tr_isTorrent( tor ) && ( now == tor->lastStatTime )
+    return tr_isTorrent (tor) && (now == tor->lastStatTime)
          ? &tor->stats
-         : tr_torrentStat( tor );
+         : tr_torrentStat (tor);
 }
 
 void
-tr_torrentSetVerifyState( tr_torrent * tor, tr_verify_state state )
+tr_torrentSetVerifyState (tr_torrent * tor, tr_verify_state state)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( state==TR_VERIFY_NONE || state==TR_VERIFY_WAIT || state==TR_VERIFY_NOW );
+    assert (tr_isTorrent (tor));
+    assert (state==TR_VERIFY_NONE || state==TR_VERIFY_WAIT || state==TR_VERIFY_NOW);
 
     tor->verifyState = state;
-    tor->anyDate = tr_time( );
+    tor->anyDate = tr_time ();
 }
 
 static tr_torrent_activity
-torrentGetActivity( const tr_torrent * tor )
+torrentGetActivity (const tr_torrent * tor)
 {
-    const bool is_seed = tr_torrentIsSeed( tor );
-    assert( tr_isTorrent( tor ) );
+    const bool is_seed = tr_torrentIsSeed (tor);
+    assert (tr_isTorrent (tor));
 
-    if( tor->verifyState == TR_VERIFY_NOW )
+    if (tor->verifyState == TR_VERIFY_NOW)
         return TR_STATUS_CHECK;
 
-    if( tor->verifyState == TR_VERIFY_WAIT )
+    if (tor->verifyState == TR_VERIFY_WAIT)
         return TR_STATUS_CHECK_WAIT;
 
-    if( tor->isRunning )
+    if (tor->isRunning)
         return is_seed ? TR_STATUS_SEED : TR_STATUS_DOWNLOAD;
 
-    if( tr_torrentIsQueued( tor ) ) {
-        if( is_seed && tr_sessionGetQueueEnabled( tor->session, TR_UP ) )
+    if (tr_torrentIsQueued (tor)) {
+        if (is_seed && tr_sessionGetQueueEnabled (tor->session, TR_UP))
             return TR_STATUS_SEED_WAIT;
-        if( !is_seed && tr_sessionGetQueueEnabled( tor->session, TR_DOWN ) )
+        if (!is_seed && tr_sessionGetQueueEnabled (tor->session, TR_DOWN))
             return TR_STATUS_DOWNLOAD_WAIT;
     }
 
@@ -1120,22 +1122,22 @@ torrentGetActivity( const tr_torrent * tor )
 }
 
 tr_torrent_activity
-tr_torrentGetActivity( tr_torrent * tor )
+tr_torrentGetActivity (tr_torrent * tor)
 {
     /* FIXME: is this call still needed? */
-    tr_torrentRecheckCompleteness( tor );
+    tr_torrentRecheckCompleteness (tor);
 
-    return torrentGetActivity( tor );
+    return torrentGetActivity (tor);
 }
 
 static time_t
-torrentGetIdleSecs( const tr_torrent * tor )
+torrentGetIdleSecs (const tr_torrent * tor)
 {
     int idle_secs;
-    const tr_torrent_activity activity = torrentGetActivity( tor );
+    const tr_torrent_activity activity = torrentGetActivity (tor);
 
     if ((activity == TR_STATUS_DOWNLOAD || activity == TR_STATUS_SEED) && tor->startDate != 0)
-        idle_secs = difftime(tr_time(), MAX(tor->startDate, tor->activityDate));
+        idle_secs = difftime (tr_time (), MAX (tor->startDate, tor->activityDate));
     else
         idle_secs = -1;
 
@@ -1143,27 +1145,27 @@ torrentGetIdleSecs( const tr_torrent * tor )
 }
 
 bool
-tr_torrentIsStalled( const tr_torrent * tor )
+tr_torrentIsStalled (const tr_torrent * tor)
 {
-    return tr_sessionGetQueueStalledEnabled( tor->session )
-        && ( torrentGetIdleSecs( tor ) > ( tr_sessionGetQueueStalledMinutes( tor->session ) * 60 ) );
+    return tr_sessionGetQueueStalledEnabled (tor->session)
+        && (torrentGetIdleSecs (tor) > (tr_sessionGetQueueStalledMinutes (tor->session) * 60));
 }
 
 
 static double
-getVerifyProgress( const tr_torrent * tor )
+getVerifyProgress (const tr_torrent * tor)
 {
     double d = 0;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( tr_torrentHasMetadata( tor ) )
+    if (tr_torrentHasMetadata (tor))
     {
         tr_piece_index_t i, n;
         tr_piece_index_t checked = 0;
 
-        for( i=0, n=tor->info.pieceCount; i!=n; ++i )
-            if( tor->info.pieces[i].timeChecked )
+        for (i=0, n=tor->info.pieceCount; i!=n; ++i)
+            if (tor->info.pieces[i].timeChecked)
                 ++checked;
 
         d = checked / (double)tor->info.pieceCount;
@@ -1173,7 +1175,7 @@ getVerifyProgress( const tr_torrent * tor )
 }
 
 const tr_stat *
-tr_torrentStat( tr_torrent * tor )
+tr_torrentStat (tr_torrent * tor)
 {
     tr_stat *               s;
     uint64_t                now;
@@ -1182,66 +1184,66 @@ tr_torrentStat( tr_torrent * tor )
     bool                    seedRatioApplies;
     uint16_t                seedIdleMinutes;
 
-    if( !tor )
+    if (!tor)
         return NULL;
 
-    assert( tr_isTorrent( tor ) );
-    tr_torrentLock( tor );
+    assert (tr_isTorrent (tor));
+    tr_torrentLock (tor);
 
-    tor->lastStatTime = tr_time( );
+    tor->lastStatTime = tr_time ();
 
     s = &tor->stats;
     s->id = tor->uniqueId;
-    s->activity = tr_torrentGetActivity( tor );
+    s->activity = tr_torrentGetActivity (tor);
     s->error = tor->error;
     s->queuePosition = tor->queuePosition;
-    s->isStalled = tr_torrentIsStalled( tor );
-    tr_strlcpy( s->errorString, tor->errorString, sizeof( s->errorString ) );
+    s->isStalled = tr_torrentIsStalled (tor);
+    tr_strlcpy (s->errorString, tor->errorString, sizeof (s->errorString));
 
-    s->manualAnnounceTime = tr_announcerNextManualAnnounce( tor );
+    s->manualAnnounceTime = tr_announcerNextManualAnnounce (tor);
 
-    tr_peerMgrTorrentStats( tor,
+    tr_peerMgrTorrentStats (tor,
                             &s->peersConnected,
                             &s->webseedsSendingToUs,
                             &s->peersSendingToUs,
                             &s->peersGettingFromUs,
-                            s->peersFrom );
+                            s->peersFrom);
 
-    now = tr_time_msec( );
-    s->rawUploadSpeed_KBps     = toSpeedKBps( tr_bandwidthGetRawSpeed_Bps  ( &tor->bandwidth, now, TR_UP ) );
-    s->pieceUploadSpeed_KBps   = toSpeedKBps( tr_bandwidthGetPieceSpeed_Bps( &tor->bandwidth, now, TR_UP ) );
-    s->rawDownloadSpeed_KBps   = toSpeedKBps( tr_bandwidthGetRawSpeed_Bps  ( &tor->bandwidth, now, TR_DOWN ) );
-    s->pieceDownloadSpeed_KBps = toSpeedKBps( tr_bandwidthGetPieceSpeed_Bps( &tor->bandwidth, now, TR_DOWN ) );
+    now = tr_time_msec ();
+    s->rawUploadSpeed_KBps     = toSpeedKBps (tr_bandwidthGetRawSpeed_Bps (&tor->bandwidth, now, TR_UP));
+    s->pieceUploadSpeed_KBps   = toSpeedKBps (tr_bandwidthGetPieceSpeed_Bps (&tor->bandwidth, now, TR_UP));
+    s->rawDownloadSpeed_KBps   = toSpeedKBps (tr_bandwidthGetRawSpeed_Bps (&tor->bandwidth, now, TR_DOWN));
+    s->pieceDownloadSpeed_KBps = toSpeedKBps (tr_bandwidthGetPieceSpeed_Bps (&tor->bandwidth, now, TR_DOWN));
 
-    s->percentComplete = tr_cpPercentComplete ( &tor->completion );
-    s->metadataPercentComplete = tr_torrentGetMetadataPercent( tor );
+    s->percentComplete = tr_cpPercentComplete (&tor->completion);
+    s->metadataPercentComplete = tr_torrentGetMetadataPercent (tor);
 
-    s->percentDone         = tr_cpPercentDone  ( &tor->completion );
-    s->leftUntilDone       = tr_cpLeftUntilDone( &tor->completion );
-    s->sizeWhenDone        = tr_cpSizeWhenDone ( &tor->completion );
-    s->recheckProgress     = s->activity == TR_STATUS_CHECK ? getVerifyProgress( tor ) : 0;
+    s->percentDone         = tr_cpPercentDone (&tor->completion);
+    s->leftUntilDone       = tr_cpLeftUntilDone (&tor->completion);
+    s->sizeWhenDone        = tr_cpSizeWhenDone (&tor->completion);
+    s->recheckProgress     = s->activity == TR_STATUS_CHECK ? getVerifyProgress (tor) : 0;
     s->activityDate        = tor->activityDate;
     s->addedDate           = tor->addedDate;
     s->doneDate            = tor->doneDate;
     s->startDate           = tor->startDate;
     s->secondsSeeding      = tor->secondsSeeding;
     s->secondsDownloading  = tor->secondsDownloading;
-    s->idleSecs            = torrentGetIdleSecs( tor );
+    s->idleSecs            = torrentGetIdleSecs (tor);
 
     s->corruptEver      = tor->corruptCur    + tor->corruptPrev;
     s->downloadedEver   = tor->downloadedCur + tor->downloadedPrev;
     s->uploadedEver     = tor->uploadedCur   + tor->uploadedPrev;
-    s->haveValid        = tr_cpHaveValid( &tor->completion );
-    s->haveUnchecked    = tr_cpHaveTotal( &tor->completion ) - s->haveValid;
-    s->desiredAvailable = tr_peerMgrGetDesiredAvailable( tor );
+    s->haveValid        = tr_cpHaveValid (&tor->completion);
+    s->haveUnchecked    = tr_cpHaveTotal (&tor->completion) - s->haveValid;
+    s->desiredAvailable = tr_peerMgrGetDesiredAvailable (tor);
 
-    s->ratio = tr_getRatio( s->uploadedEver,
-                            s->downloadedEver ? s->downloadedEver : s->haveValid );
+    s->ratio = tr_getRatio (s->uploadedEver,
+                            s->downloadedEver ? s->downloadedEver : s->haveValid);
 
-    seedRatioApplies = tr_torrentGetSeedRatioBytes( tor, &seedRatioBytesLeft,
-                                                         &seedRatioBytesGoal );
+    seedRatioApplies = tr_torrentGetSeedRatioBytes (tor, &seedRatioBytesLeft,
+                                                         &seedRatioBytesGoal);
 
-    switch( s->activity )
+    switch (s->activity)
     {
         /* etaXLSpeed exists because if we use the piece speed directly,
          * brief fluctuations cause the ETA to jump all over the place.
@@ -1249,40 +1251,40 @@ tr_torrentStat( tr_torrent * tor )
          * to dampen the effect of fluctuations */
 
         case TR_STATUS_DOWNLOAD:
-            if( ( tor->etaDLSpeedCalculatedAt + 800 ) < now ) {
-                tor->etaDLSpeed_KBps = ( ( tor->etaDLSpeedCalculatedAt + 4000 ) < now )
+            if ((tor->etaDLSpeedCalculatedAt + 800) < now) {
+                tor->etaDLSpeed_KBps = ((tor->etaDLSpeedCalculatedAt + 4000) < now)
                     ? s->pieceDownloadSpeed_KBps /* if no recent previous speed, no need to smooth */
                     : ((tor->etaDLSpeed_KBps*4.0) + s->pieceDownloadSpeed_KBps)/5.0; /* smooth across 5 readings */
                 tor->etaDLSpeedCalculatedAt = now;
             }
 
-            if( s->leftUntilDone > s->desiredAvailable )
+            if (s->leftUntilDone > s->desiredAvailable)
                 s->eta = TR_ETA_NOT_AVAIL;
-            else if( tor->etaDLSpeed_KBps < 1 )
+            else if (tor->etaDLSpeed_KBps < 1)
                 s->eta = TR_ETA_UNKNOWN;
             else
-                s->eta = s->leftUntilDone / toSpeedBytes(tor->etaDLSpeed_KBps);
+                s->eta = s->leftUntilDone / toSpeedBytes (tor->etaDLSpeed_KBps);
 
             s->etaIdle = TR_ETA_NOT_AVAIL;
             break;
 
         case TR_STATUS_SEED: {
-            if( !seedRatioApplies )
+            if (!seedRatioApplies)
                 s->eta = TR_ETA_NOT_AVAIL;
             else {
-                if( ( tor->etaULSpeedCalculatedAt + 800 ) < now ) {
-                    tor->etaULSpeed_KBps = ( ( tor->etaULSpeedCalculatedAt + 4000 ) < now )
+                if ((tor->etaULSpeedCalculatedAt + 800) < now) {
+                    tor->etaULSpeed_KBps = ((tor->etaULSpeedCalculatedAt + 4000) < now)
                         ? s->pieceUploadSpeed_KBps /* if no recent previous speed, no need to smooth */
                         : ((tor->etaULSpeed_KBps*4.0) + s->pieceUploadSpeed_KBps)/5.0; /* smooth across 5 readings */
                     tor->etaULSpeedCalculatedAt = now;
                 }
-                if( tor->etaULSpeed_KBps < 1 )
+                if (tor->etaULSpeed_KBps < 1)
                     s->eta = TR_ETA_UNKNOWN;
                 else
-                    s->eta = seedRatioBytesLeft / toSpeedBytes(tor->etaULSpeed_KBps);
+                    s->eta = seedRatioBytesLeft / toSpeedBytes (tor->etaULSpeed_KBps);
             }
 
-            if( tor->etaULSpeed_KBps < 1 && tr_torrentGetSeedIdle( tor, &seedIdleMinutes ) )
+            if (tor->etaULSpeed_KBps < 1 && tr_torrentGetSeedIdle (tor, &seedIdleMinutes))
                 s->etaIdle = seedIdleMinutes * 60 - s->idleSecs;
             else
                 s->etaIdle = TR_ETA_NOT_AVAIL;
@@ -1299,19 +1301,19 @@ tr_torrentStat( tr_torrent * tor )
      * when the user hits "uncheck all" prior to starting the torrent... */
     s->finished = tor->finishedSeedingByIdle || (seedRatioApplies && !seedRatioBytesLeft && s->haveValid);
 
-    if( !seedRatioApplies || s->finished )
+    if (!seedRatioApplies || s->finished)
         s->seedRatioPercentDone = 1;
-    else if( !seedRatioBytesGoal ) /* impossible? safeguard for div by zero */
+    else if (!seedRatioBytesGoal) /* impossible? safeguard for div by zero */
         s->seedRatioPercentDone = 0;
     else
         s->seedRatioPercentDone = (double)(seedRatioBytesGoal - seedRatioBytesLeft) / seedRatioBytesGoal;
 
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 
     /* test some of the constraints */
-    assert( s->sizeWhenDone <= tor->info.totalSize );
-    assert( s->leftUntilDone <= s->sizeWhenDone );
-    assert( s->desiredAvailable <= s->leftUntilDone );
+    assert (s->sizeWhenDone <= tor->info.totalSize);
+    assert (s->leftUntilDone <= s->sizeWhenDone);
+    assert (s->desiredAvailable <= s->leftUntilDone);
     return s;
 }
 
@@ -1320,38 +1322,38 @@ tr_torrentStat( tr_torrent * tor )
 ***/
 
 static uint64_t
-fileBytesCompleted( const tr_torrent * tor, tr_file_index_t index )
+fileBytesCompleted (const tr_torrent * tor, tr_file_index_t index)
 {
     uint64_t total = 0;
     const tr_file * f = &tor->info.files[index];
 
-    if( f->length )
+    if (f->length)
     {
         tr_block_index_t first;
         tr_block_index_t last;
-        tr_torGetFileBlockRange( tor, index, &first, &last );
+        tr_torGetFileBlockRange (tor, index, &first, &last);
 
-        if( first == last )
+        if (first == last)
         {
-            if( tr_cpBlockIsComplete( &tor->completion, first ) )
+            if (tr_cpBlockIsComplete (&tor->completion, first))
                 total = f->length;
         }
         else
         {
             /* the first block */
-            if( tr_cpBlockIsComplete( &tor->completion, first ) )
-                total += tor->blockSize - ( f->offset % tor->blockSize );
+            if (tr_cpBlockIsComplete (&tor->completion, first))
+                total += tor->blockSize - (f->offset % tor->blockSize);
 
             /* the middle blocks */
-            if( first + 1 < last ) {
-                uint64_t u = tr_bitfieldCountRange( &tor->completion.blockBitfield, first+1, last );
+            if (first + 1 < last) {
+                uint64_t u = tr_bitfieldCountRange (&tor->completion.blockBitfield, first+1, last);
                 u *= tor->blockSize;
                 total += u;
             }
 
             /* the last block */
-            if( tr_cpBlockIsComplete( &tor->completion, last ) )
-                total += ( f->offset + f->length ) - ( (uint64_t)tor->blockSize * last );
+            if (tr_cpBlockIsComplete (&tor->completion, last))
+                total += (f->offset + f->length) - ((uint64_t)tor->blockSize * last);
         }
     }
 
@@ -1359,34 +1361,34 @@ fileBytesCompleted( const tr_torrent * tor, tr_file_index_t index )
 }
 
 tr_file_stat *
-tr_torrentFiles( const tr_torrent * tor,
-                 tr_file_index_t *  fileCount )
+tr_torrentFiles (const tr_torrent * tor,
+                 tr_file_index_t *  fileCount)
 {
     tr_file_index_t       i;
     const tr_file_index_t n = tor->info.fileCount;
-    tr_file_stat *        files = tr_new0( tr_file_stat, n );
+    tr_file_stat *        files = tr_new0 (tr_file_stat, n);
     tr_file_stat *        walk = files;
     const bool            isSeed = tor->completeness == TR_SEED;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    for( i=0; i<n; ++i, ++walk ) {
-        const uint64_t b = isSeed ? tor->info.files[i].length : fileBytesCompleted( tor, i );
+    for (i=0; i<n; ++i, ++walk) {
+        const uint64_t b = isSeed ? tor->info.files[i].length : fileBytesCompleted (tor, i);
         walk->bytesCompleted = b;
-        walk->progress = tor->info.files[i].length > 0 ? ( (float)b / tor->info.files[i].length ) : 1.0f;
+        walk->progress = tor->info.files[i].length > 0 ? ((float)b / tor->info.files[i].length) : 1.0f;
     }
 
-    if( fileCount )
+    if (fileCount)
         *fileCount = n;
 
     return files;
 }
 
 void
-tr_torrentFilesFree( tr_file_stat *            files,
-                     tr_file_index_t fileCount UNUSED )
+tr_torrentFilesFree (tr_file_stat *            files,
+                     tr_file_index_t fileCount UNUSED)
 {
-    tr_free( files );
+    tr_free (files);
 }
 
 /***
@@ -1394,89 +1396,89 @@ tr_torrentFilesFree( tr_file_stat *            files,
 ***/
 
 double*
-tr_torrentWebSpeeds_KBps( const tr_torrent * tor )
+tr_torrentWebSpeeds_KBps (const tr_torrent * tor)
 {
     double * ret = NULL;
 
-    if( tr_isTorrent( tor ) )
+    if (tr_isTorrent (tor))
     {
-        tr_torrentLock( tor );
-        ret = tr_peerMgrWebSpeeds_KBps( tor );
-        tr_torrentUnlock( tor );
+        tr_torrentLock (tor);
+        ret = tr_peerMgrWebSpeeds_KBps (tor);
+        tr_torrentUnlock (tor);
     }
 
     return ret;
 }
 
 tr_peer_stat *
-tr_torrentPeers( const tr_torrent * tor, int * peerCount )
+tr_torrentPeers (const tr_torrent * tor, int * peerCount)
 {
     tr_peer_stat * ret = NULL;
 
-    if( tr_isTorrent( tor ) )
+    if (tr_isTorrent (tor))
     {
-        tr_torrentLock( tor );
-        ret = tr_peerMgrPeerStats( tor, peerCount );
-        tr_torrentUnlock( tor );
+        tr_torrentLock (tor);
+        ret = tr_peerMgrPeerStats (tor, peerCount);
+        tr_torrentUnlock (tor);
     }
 
     return ret;
 }
 
 void
-tr_torrentPeersFree( tr_peer_stat * peers, int peerCount UNUSED )
+tr_torrentPeersFree (tr_peer_stat * peers, int peerCount UNUSED)
 {
-    tr_free( peers );
+    tr_free (peers);
 }
 
 tr_tracker_stat *
-tr_torrentTrackers( const tr_torrent * torrent, int * setmeTrackerCount )
+tr_torrentTrackers (const tr_torrent * torrent, int * setmeTrackerCount)
 {
     tr_tracker_stat * ret = NULL;
 
-    if( tr_isTorrent( torrent ) )
+    if (tr_isTorrent (torrent))
     {
-        tr_torrentLock( torrent );
-        ret = tr_announcerStats( torrent, setmeTrackerCount );
-        tr_torrentUnlock( torrent );
+        tr_torrentLock (torrent);
+        ret = tr_announcerStats (torrent, setmeTrackerCount);
+        tr_torrentUnlock (torrent);
     }
 
     return ret;
 }
 
 void
-tr_torrentTrackersFree( tr_tracker_stat * trackers, int trackerCount )
+tr_torrentTrackersFree (tr_tracker_stat * trackers, int trackerCount)
 {
-    tr_announcerStatsFree( trackers, trackerCount );
+    tr_announcerStatsFree (trackers, trackerCount);
 }
 
 void
-tr_torrentAvailability( const tr_torrent * tor, int8_t * tab, int size )
+tr_torrentAvailability (const tr_torrent * tor, int8_t * tab, int size)
 {
-    if( tr_isTorrent( tor ) && ( tab != NULL ) && ( size > 0 ) )
+    if (tr_isTorrent (tor) && (tab != NULL) && (size > 0))
     {
-        tr_torrentLock( tor );
-        tr_peerMgrTorrentAvailability( tor, tab, size );
-        tr_torrentUnlock( tor );
+        tr_torrentLock (tor);
+        tr_peerMgrTorrentAvailability (tor, tab, size);
+        tr_torrentUnlock (tor);
     }
 }
 
 void
-tr_torrentAmountFinished( const tr_torrent * tor,
+tr_torrentAmountFinished (const tr_torrent * tor,
                           float *            tab,
-                          int                size )
+                          int                size)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_torrentLock( tor );
-    tr_cpGetAmountDone( &tor->completion, tab, size );
-    tr_torrentUnlock( tor );
+    tr_torrentLock (tor);
+    tr_cpGetAmountDone (&tor->completion, tab, size);
+    tr_torrentUnlock (tor);
 }
 
 static void
-tr_torrentResetTransferStats( tr_torrent * tor )
+tr_torrentResetTransferStats (tr_torrent * tor)
 {
-    tr_torrentLock( tor );
+    tr_torrentLock (tor);
 
     tor->downloadedPrev += tor->downloadedCur;
     tor->downloadedCur   = 0;
@@ -1485,23 +1487,23 @@ tr_torrentResetTransferStats( tr_torrent * tor )
     tor->corruptPrev    += tor->corruptCur;
     tor->corruptCur      = 0;
 
-    tr_torrentSetDirty( tor );
+    tr_torrentSetDirty (tor);
 
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 }
 
 void
-tr_torrentSetHasPiece( tr_torrent *     tor,
+tr_torrentSetHasPiece (tr_torrent *     tor,
                        tr_piece_index_t pieceIndex,
-                       bool             has )
+                       bool             has)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( pieceIndex < tor->info.pieceCount );
+    assert (tr_isTorrent (tor));
+    assert (pieceIndex < tor->info.pieceCount);
 
-    if( has )
-        tr_cpPieceAdd( &tor->completion, pieceIndex );
+    if (has)
+        tr_cpPieceAdd (&tor->completion, pieceIndex);
     else
-        tr_cpPieceRem( &tor->completion, pieceIndex );
+        tr_cpPieceRem (&tor->completion, pieceIndex);
 }
 
 /***
@@ -1509,132 +1511,132 @@ tr_torrentSetHasPiece( tr_torrent *     tor,
 ***/
 
 #ifndef NDEBUG
-static bool queueIsSequenced( tr_session * );
+static bool queueIsSequenced (tr_session *);
 #endif
 
 static void
-freeTorrent( tr_torrent * tor )
+freeTorrent (tr_torrent * tor)
 {
     tr_torrent * t;
     tr_session *  session = tor->session;
     tr_info *    inf = &tor->info;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    assert( !tor->isRunning );
+    assert (!tor->isRunning);
 
-    tr_sessionLock( session );
+    tr_sessionLock (session);
 
-    tr_peerMgrRemoveTorrent( tor );
+    tr_peerMgrRemoveTorrent (tor);
 
-    tr_announcerRemoveTorrent( session->announcer, tor );
+    tr_announcerRemoveTorrent (session->announcer, tor);
 
-    tr_cpDestruct( &tor->completion );
+    tr_cpDestruct (&tor->completion);
 
-    tr_free( tor->downloadDir );
-    tr_free( tor->incompleteDir );
+    tr_free (tor->downloadDir);
+    tr_free (tor->incompleteDir);
 
-    if( tor == session->torrentList )
+    if (tor == session->torrentList)
         session->torrentList = tor->next;
-    else for( t = session->torrentList; t != NULL; t = t->next ) {
-        if( t->next == tor ) {
+    else for (t = session->torrentList; t != NULL; t = t->next) {
+        if (t->next == tor) {
             t->next = tor->next;
             break;
         }
     }
 
     /* decrement the torrent count */
-    assert( session->torrentCount >= 1 );
+    assert (session->torrentCount >= 1);
     session->torrentCount--;
 
     /* resequence the queue positions */
     t = NULL;
-    while(( t = tr_torrentNext( session, t ))) {
-        if( t->queuePosition > tor->queuePosition ) {
+    while ((t = tr_torrentNext (session, t))) {
+        if (t->queuePosition > tor->queuePosition) {
             t->queuePosition--;
             t->anyDate = now;
         }
     }
-    assert( queueIsSequenced( session ) );
+    assert (queueIsSequenced (session));
 
-    tr_bandwidthDestruct( &tor->bandwidth );
+    tr_bandwidthDestruct (&tor->bandwidth);
 
-    tr_metainfoFree( inf );
-    memset( tor, ~0, sizeof( tr_torrent ) );
-    tr_free( tor );
+    tr_metainfoFree (inf);
+    memset (tor, ~0, sizeof (tr_torrent));
+    tr_free (tor);
 
-    tr_sessionUnlock( session );
+    tr_sessionUnlock (session);
 }
 
 /**
 ***  Start/Stop Callback
 **/
 
-static void torrentSetQueued( tr_torrent * tor, bool queued );
+static void torrentSetQueued (tr_torrent * tor, bool queued);
 
 static void
-torrentStartImpl( void * vtor )
+torrentStartImpl (void * vtor)
 {
     time_t now;
     tr_torrent * tor = vtor;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_sessionLock( tor->session );
+    tr_sessionLock (tor->session);
 
-    tr_torrentRecheckCompleteness( tor );
-    torrentSetQueued( tor, false );
+    tr_torrentRecheckCompleteness (tor);
+    torrentSetQueued (tor, false);
 
-    now = tr_time( );
+    now = tr_time ();
     tor->isRunning = true;
-    tor->completeness = tr_cpGetStatus( &tor->completion );
+    tor->completeness = tr_cpGetStatus (&tor->completion);
     tor->startDate = tor->anyDate = now;
-    tr_torrentClearError( tor );
+    tr_torrentClearError (tor);
     tor->finishedSeedingByIdle = false;
 
-    tr_torrentResetTransferStats( tor );
-    tr_announcerTorrentStarted( tor );
-    tor->dhtAnnounceAt = now + tr_cryptoWeakRandInt( 20 );
-    tor->dhtAnnounce6At = now + tr_cryptoWeakRandInt( 20 );
+    tr_torrentResetTransferStats (tor);
+    tr_announcerTorrentStarted (tor);
+    tor->dhtAnnounceAt = now + tr_cryptoWeakRandInt (20);
+    tor->dhtAnnounce6At = now + tr_cryptoWeakRandInt (20);
     tor->lpdAnnounceAt = now;
-    tr_peerMgrStartTorrent( tor );
+    tr_peerMgrStartTorrent (tor);
 
-    tr_sessionUnlock( tor->session );
+    tr_sessionUnlock (tor->session);
 }
 
 uint64_t
-tr_torrentGetCurrentSizeOnDisk( const tr_torrent * tor )
+tr_torrentGetCurrentSizeOnDisk (const tr_torrent * tor)
 {
     tr_file_index_t i;
     uint64_t byte_count = 0;
     const tr_file_index_t n = tor->info.fileCount;
 
-    for( i=0; i<n; ++i )
+    for (i=0; i<n; ++i)
     {
         struct stat sb;
-        char * filename = tr_torrentFindFile( tor, i );
+        char * filename = tr_torrentFindFile (tor, i);
 
         sb.st_size = 0;
-        if( filename && !stat( filename, &sb ) )
+        if (filename && !stat (filename, &sb))
             byte_count += sb.st_size;
 
-        tr_free( filename );
+        tr_free (filename);
     }
 
     return byte_count;
 }
 
 static bool
-torrentShouldQueue( const tr_torrent * tor )
+torrentShouldQueue (const tr_torrent * tor)
 {
-    const tr_direction dir = tr_torrentGetQueueDirection( tor );
+    const tr_direction dir = tr_torrentGetQueueDirection (tor);
 
-    return tr_sessionCountQueueFreeSlots( tor->session, dir ) == 0;
+    return tr_sessionCountQueueFreeSlots (tor->session, dir) == 0;
 }
 
 static void
-torrentStart( tr_torrent * tor, bool bypass_queue )
+torrentStart (tr_torrent * tor, bool bypass_queue)
 {
-    switch( torrentGetActivity( tor ) )
+    switch (torrentGetActivity (tor))
     {
         case TR_STATUS_SEED:
         case TR_STATUS_DOWNLOAD:
@@ -1643,7 +1645,7 @@ torrentStart( tr_torrent * tor, bool bypass_queue )
 
         case TR_STATUS_SEED_WAIT:
         case TR_STATUS_DOWNLOAD_WAIT:
-            if( !bypass_queue )
+            if (!bypass_queue)
                 return; /* already queued */
             break;
 
@@ -1656,24 +1658,24 @@ torrentStart( tr_torrent * tor, bool bypass_queue )
             break;
 
         case TR_STATUS_STOPPED:
-            if( !bypass_queue && torrentShouldQueue( tor ) ) {
-                torrentSetQueued( tor, true );
+            if (!bypass_queue && torrentShouldQueue (tor)) {
+                torrentSetQueued (tor, true);
                 return;
             }
             break;
     }
 
     /* don't allow the torrent to be started if the files disappeared */
-    if( setLocalErrorIfFilesDisappeared( tor ) )
+    if (setLocalErrorIfFilesDisappeared (tor))
         return;
 
     /* otherwise, start it now... */
-    tr_sessionLock( tor->session );
+    tr_sessionLock (tor->session);
 
     /* allow finished torrents to be resumed */
-    if( tr_torrentIsSeedRatioDone( tor ) ) {
-        tr_torinf( tor, _( "Restarted manually -- disabling its seed ratio" ) );
-        tr_torrentSetRatioMode( tor, TR_RATIOLIMIT_UNLIMITED );
+    if (tr_torrentIsSeedRatioDone (tor)) {
+        tr_torinf (tor, _ ("Restarted manually -- disabling its seed ratio"));
+        tr_torrentSetRatioMode (tor, TR_RATIOLIMIT_UNLIMITED);
     }
 
     /* corresponds to the peer_id sent as a tracker request parameter.
@@ -1681,176 +1683,176 @@ torrentStart( tr_torrent * tor, bool bypass_queue )
      * closed and opened again without quitting Transmission ...
      * change the peerid. It would help sometimes if a stopped event
      * was missed to ensure that we didn't think someone was cheating. */
-    tr_peerIdInit( tor->peer_id );
+    tr_peerIdInit (tor->peer_id);
     tor->isRunning = 1;
-    tr_torrentSetDirty( tor );
-    tr_runInEventThread( tor->session, torrentStartImpl, tor );
+    tr_torrentSetDirty (tor);
+    tr_runInEventThread (tor->session, torrentStartImpl, tor);
 
-    tr_sessionUnlock( tor->session );
+    tr_sessionUnlock (tor->session);
 }
 
 void
-tr_torrentStart( tr_torrent * tor )
+tr_torrentStart (tr_torrent * tor)
 {
-    if( tr_isTorrent( tor ) )
-        torrentStart( tor, false );
+    if (tr_isTorrent (tor))
+        torrentStart (tor, false);
 }
 
 void
-tr_torrentStartNow( tr_torrent * tor )
+tr_torrentStartNow (tr_torrent * tor)
 {
-    if( tr_isTorrent( tor ) )
-        torrentStart( tor, true );
+    if (tr_isTorrent (tor))
+        torrentStart (tor, true);
 }
 
 static void
-torrentRecheckDoneImpl( void * vtor )
+torrentRecheckDoneImpl (void * vtor)
 {
     tr_torrent * tor = vtor;
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_torrentRecheckCompleteness( tor );
+    tr_torrentRecheckCompleteness (tor);
 
-    if( tor->startAfterVerify ) {
+    if (tor->startAfterVerify) {
         tor->startAfterVerify = false;
-        torrentStart( tor, false );
+        torrentStart (tor, false);
     }
 }
 
 static void
-torrentRecheckDoneCB( tr_torrent * tor )
+torrentRecheckDoneCB (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_runInEventThread( tor->session, torrentRecheckDoneImpl, tor );
+    tr_runInEventThread (tor->session, torrentRecheckDoneImpl, tor);
 }
 
 static void
-verifyTorrent( void * vtor )
+verifyTorrent (void * vtor)
 {
     bool startAfter;
     tr_torrent * tor = vtor;
 
-    tr_sessionLock( tor->session );
+    tr_sessionLock (tor->session);
 
     /* if the torrent's already being verified, stop it */
-    tr_verifyRemove( tor );
+    tr_verifyRemove (tor);
 
     startAfter = (tor->isRunning || tor->startAfterVerify) && !tor->isStopping;
 
-    if( tor->isRunning )
-        tr_torrentStop( tor );
+    if (tor->isRunning)
+        tr_torrentStop (tor);
 
     tor->startAfterVerify = startAfter;
 
-    if( setLocalErrorIfFilesDisappeared( tor ) )
+    if (setLocalErrorIfFilesDisappeared (tor))
         tor->startAfterVerify = false;
     else
-        tr_verifyAdd( tor, torrentRecheckDoneCB );
+        tr_verifyAdd (tor, torrentRecheckDoneCB);
 
-    tr_sessionUnlock( tor->session );
+    tr_sessionUnlock (tor->session);
 }
 
 void
-tr_torrentVerify( tr_torrent * tor )
+tr_torrentVerify (tr_torrent * tor)
 {
-    if( tr_isTorrent( tor ) )
-        tr_runInEventThread( tor->session, verifyTorrent, tor );
+    if (tr_isTorrent (tor))
+        tr_runInEventThread (tor->session, verifyTorrent, tor);
 }
 
 void
-tr_torrentSave( tr_torrent * tor )
+tr_torrentSave (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( tor->isDirty )
+    if (tor->isDirty)
     {
         tor->isDirty = false;
-        tr_torrentSaveResume( tor );
+        tr_torrentSaveResume (tor);
     }
 }
 
 static void
-stopTorrent( void * vtor )
+stopTorrent (void * vtor)
 {
     tr_torrent * tor = vtor;
-    tr_torinf( tor, "Pausing" );
+    tr_torinf (tor, "Pausing");
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_torrentLock( tor );
+    tr_torrentLock (tor);
 
-    tr_verifyRemove( tor );
-    torrentSetQueued( tor, false );
-    tr_peerMgrStopTorrent( tor );
-    tr_announcerTorrentStopped( tor );
-    tr_cacheFlushTorrent( tor->session->cache, tor );
+    tr_verifyRemove (tor);
+    torrentSetQueued (tor, false);
+    tr_peerMgrStopTorrent (tor);
+    tr_announcerTorrentStopped (tor);
+    tr_cacheFlushTorrent (tor->session->cache, tor);
 
-    tr_fdTorrentClose( tor->session, tor->uniqueId );
+    tr_fdTorrentClose (tor->session, tor->uniqueId);
 
-    if( !tor->isDeleting )
-        tr_torrentSave( tor );
+    if (!tor->isDeleting)
+        tr_torrentSave (tor);
 
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 }
 
 void
-tr_torrentStop( tr_torrent * tor )
+tr_torrentStop (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( tr_isTorrent( tor ) )
+    if (tr_isTorrent (tor))
     {
-        tr_sessionLock( tor->session );
+        tr_sessionLock (tor->session);
 
         tor->isRunning = 0;
         tor->isStopping = 0;
-        tr_torrentSetDirty( tor );
-        tr_runInEventThread( tor->session, stopTorrent, tor );
+        tr_torrentSetDirty (tor);
+        tr_runInEventThread (tor->session, stopTorrent, tor);
 
-        tr_sessionUnlock( tor->session );
+        tr_sessionUnlock (tor->session);
     }
 }
 
 static void
-closeTorrent( void * vtor )
+closeTorrent (void * vtor)
 {
     tr_benc * d;
     tr_torrent * tor = vtor;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    d = tr_bencListAddDict( &tor->session->removedTorrents, 2 );
-    tr_bencDictAddInt( d, "id", tor->uniqueId );
-    tr_bencDictAddInt( d, "date", tr_time( ) );
+    d = tr_bencListAddDict (&tor->session->removedTorrents, 2);
+    tr_bencDictAddInt (d, "id", tor->uniqueId);
+    tr_bencDictAddInt (d, "date", tr_time ());
 
-    tr_torinf( tor, "%s", _( "Removing torrent" ) );
+    tr_torinf (tor, "%s", _ ("Removing torrent"));
 
-    stopTorrent( tor );
+    stopTorrent (tor);
 
-    if( tor->isDeleting )
+    if (tor->isDeleting)
     {
-        tr_metainfoRemoveSaved( tor->session, &tor->info );
-        tr_torrentRemoveResume( tor );
+        tr_metainfoRemoveSaved (tor->session, &tor->info);
+        tr_torrentRemoveResume (tor);
     }
 
     tor->isRunning = 0;
-    freeTorrent( tor );
+    freeTorrent (tor);
 }
 
 void
-tr_torrentFree( tr_torrent * tor )
+tr_torrentFree (tr_torrent * tor)
 {
-    if( tr_isTorrent( tor ) )
+    if (tr_isTorrent (tor))
     {
         tr_session * session = tor->session;
-        assert( tr_isSession( session ) );
-        tr_sessionLock( session );
+        assert (tr_isSession (session));
+        tr_sessionLock (session);
 
-        tr_torrentClearCompletenessCallback( tor );
-        tr_runInEventThread( session, closeTorrent, tor );
+        tr_torrentClearCompletenessCallback (tor);
+        tr_runInEventThread (session, closeTorrent, tor);
 
-        tr_sessionUnlock( session );
+        tr_sessionUnlock (session);
     }
 }
 
@@ -1861,36 +1863,36 @@ struct remove_data
     tr_fileFunc  * deleteFunc;
 };
 
-static void tr_torrentDeleteLocalData( tr_torrent *, tr_fileFunc );
+static void tr_torrentDeleteLocalData (tr_torrent *, tr_fileFunc);
 
 static void
-removeTorrent( void * vdata )
+removeTorrent (void * vdata)
 {
     struct remove_data * data = vdata;
 
-    if( data->deleteFlag )
-        tr_torrentDeleteLocalData( data->tor, data->deleteFunc );
+    if (data->deleteFlag)
+        tr_torrentDeleteLocalData (data->tor, data->deleteFunc);
 
-    tr_torrentClearCompletenessCallback( data->tor );
-    closeTorrent( data->tor );
-    tr_free( data );
+    tr_torrentClearCompletenessCallback (data->tor);
+    closeTorrent (data->tor);
+    tr_free (data);
 }
 
 void
-tr_torrentRemove( tr_torrent   * tor,
+tr_torrentRemove (tr_torrent   * tor,
                   bool           deleteFlag,
-                  tr_fileFunc    deleteFunc )
+                  tr_fileFunc    deleteFunc)
 {
     struct remove_data * data;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
     tor->isDeleting = 1;
 
-    data = tr_new0( struct remove_data, 1 );
+    data = tr_new0 (struct remove_data, 1);
     data->tor = tor;
     data->deleteFlag = deleteFlag;
     data->deleteFunc = deleteFunc;
-    tr_runInEventThread( tor->session, removeTorrent, data );
+    tr_runInEventThread (tor->session, removeTorrent, data);
 }
 
 /**
@@ -1898,9 +1900,9 @@ tr_torrentRemove( tr_torrent   * tor,
 **/
 
 static const char *
-getCompletionString( int type )
+getCompletionString (int type)
 {
-    switch( type )
+    switch (type)
     {
         /* Translators: this is a minor point that's safe to skip over, but FYI:
            "Complete" and "Done" are specific, different terms in Transmission:
@@ -1908,187 +1910,187 @@ getCompletionString( int type )
            "Done" means we're done downloading the files we wanted, but NOT all
            that exist */
         case TR_PARTIAL_SEED:
-            return _( "Done" );
+            return _ ("Done");
 
         case TR_SEED:
-            return _( "Complete" );
+            return _ ("Complete");
 
         default:
-            return _( "Incomplete" );
+            return _ ("Incomplete");
     }
 }
 
 static void
-fireCompletenessChange( tr_torrent       * tor,
+fireCompletenessChange (tr_torrent       * tor,
                         tr_completeness    status,
-                        bool               wasRunning )
+                        bool               wasRunning)
 {
-    assert( ( status == TR_LEECH )
-         || ( status == TR_SEED )
-         || ( status == TR_PARTIAL_SEED ) );
+    assert ((status == TR_LEECH)
+         || (status == TR_SEED)
+         || (status == TR_PARTIAL_SEED));
 
-    if( tor->completeness_func )
-        tor->completeness_func( tor, status, wasRunning,
-                                tor->completeness_func_user_data );
+    if (tor->completeness_func)
+        tor->completeness_func (tor, status, wasRunning,
+                                tor->completeness_func_user_data);
 }
 
 void
-tr_torrentSetCompletenessCallback( tr_torrent                    * tor,
+tr_torrentSetCompletenessCallback (tr_torrent                    * tor,
                                    tr_torrent_completeness_func    func,
-                                   void                          * user_data )
+                                   void                          * user_data)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     tor->completeness_func = func;
     tor->completeness_func_user_data = user_data;
 }
 
 void
-tr_torrentClearCompletenessCallback( tr_torrent * torrent )
+tr_torrentClearCompletenessCallback (tr_torrent * torrent)
 {
-    tr_torrentSetCompletenessCallback( torrent, NULL, NULL );
+    tr_torrentSetCompletenessCallback (torrent, NULL, NULL);
 }
 
 void
-tr_torrentSetRatioLimitHitCallback( tr_torrent                     * tor,
+tr_torrentSetRatioLimitHitCallback (tr_torrent                     * tor,
                                     tr_torrent_ratio_limit_hit_func  func,
-                                    void                           * user_data )
+                                    void                           * user_data)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     tor->ratio_limit_hit_func = func;
     tor->ratio_limit_hit_func_user_data = user_data;
 }
 
 void
-tr_torrentClearRatioLimitHitCallback( tr_torrent * torrent )
+tr_torrentClearRatioLimitHitCallback (tr_torrent * torrent)
 {
-    tr_torrentSetRatioLimitHitCallback( torrent, NULL, NULL );
+    tr_torrentSetRatioLimitHitCallback (torrent, NULL, NULL);
 }
 
 void
-tr_torrentSetIdleLimitHitCallback( tr_torrent                    * tor,
+tr_torrentSetIdleLimitHitCallback (tr_torrent                    * tor,
                                    tr_torrent_idle_limit_hit_func  func,
-                                   void                          * user_data )
+                                   void                          * user_data)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     tor->idle_limit_hit_func = func;
     tor->idle_limit_hit_func_user_data = user_data;
 }
 
 void
-tr_torrentClearIdleLimitHitCallback( tr_torrent * torrent )
+tr_torrentClearIdleLimitHitCallback (tr_torrent * torrent)
 {
-    tr_torrentSetIdleLimitHitCallback( torrent, NULL, NULL );
+    tr_torrentSetIdleLimitHitCallback (torrent, NULL, NULL);
 }
 
 static void
-onSigCHLD( int i UNUSED )
+onSigCHLD (int i UNUSED)
 {
-    waitpid( -1, NULL, WNOHANG );
+    waitpid (-1, NULL, WNOHANG);
 }
 
 static void
-torrentCallScript( const tr_torrent * tor, const char * script )
+torrentCallScript (const tr_torrent * tor, const char * script)
 {
     char timeStr[128];
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    tr_strlcpy( timeStr, ctime( &now ), sizeof( timeStr ) );
-    *strchr( timeStr,'\n' ) = '\0';
+    tr_strlcpy (timeStr, ctime (&now), sizeof (timeStr));
+    *strchr (timeStr,'\n') = '\0';
 
-    if( script && *script )
+    if (script && *script)
     {
         int i;
-        char * cmd[] = { tr_strdup( script ), NULL };
+        char * cmd[] = { tr_strdup (script), NULL };
         char * env[] = {
-            tr_strdup_printf( "TR_APP_VERSION=%s", SHORT_VERSION_STRING ),
-            tr_strdup_printf( "TR_TIME_LOCALTIME=%s", timeStr ),
-            tr_strdup_printf( "TR_TORRENT_DIR=%s", tor->currentDir ),
-            tr_strdup_printf( "TR_TORRENT_ID=%d", tr_torrentId( tor ) ),
-            tr_strdup_printf( "TR_TORRENT_HASH=%s", tor->info.hashString ),
-            tr_strdup_printf( "TR_TORRENT_NAME=%s", tr_torrentName( tor ) ),
+            tr_strdup_printf ("TR_APP_VERSION=%s", SHORT_VERSION_STRING),
+            tr_strdup_printf ("TR_TIME_LOCALTIME=%s", timeStr),
+            tr_strdup_printf ("TR_TORRENT_DIR=%s", tor->currentDir),
+            tr_strdup_printf ("TR_TORRENT_ID=%d", tr_torrentId (tor)),
+            tr_strdup_printf ("TR_TORRENT_HASH=%s", tor->info.hashString),
+            tr_strdup_printf ("TR_TORRENT_NAME=%s", tr_torrentName (tor)),
             NULL };
 
-        tr_torinf( tor, "Calling script \"%s\"", script );
+        tr_torinf (tor, "Calling script \"%s\"", script);
 
 #ifdef WIN32
-        _spawnvpe( _P_NOWAIT, script, (const char*)cmd, env );
+        _spawnvpe (_P_NOWAIT, script, (const char*)cmd, env);
 #else
-        signal( SIGCHLD, onSigCHLD );
+        signal (SIGCHLD, onSigCHLD);
 
-        if( !fork( ) )
+        if (!fork ())
         {
             for (i=0; env[i]; ++i)
-                putenv(env[i]);
-            execvp( script, cmd );
-            _exit( 0 );
+                putenv (env[i]);
+            execvp (script, cmd);
+            _exit (0);
         }
 #endif
 
-        for( i=0; cmd[i]; ++i ) tr_free( cmd[i] );
-        for( i=0; env[i]; ++i ) tr_free( env[i] );
+        for (i=0; cmd[i]; ++i) tr_free (cmd[i]);
+        for (i=0; env[i]; ++i) tr_free (env[i]);
     }
 }
 
 void
-tr_torrentRecheckCompleteness( tr_torrent * tor )
+tr_torrentRecheckCompleteness (tr_torrent * tor)
 {
     tr_completeness completeness;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_torrentLock( tor );
+    tr_torrentLock (tor);
 
-    completeness = tr_cpGetStatus( &tor->completion );
+    completeness = tr_cpGetStatus (&tor->completion);
 
-    if( completeness != tor->completeness )
+    if (completeness != tor->completeness)
     {
         const int recentChange = tor->downloadedCur != 0;
-        const bool wasLeeching = !tr_torrentIsSeed( tor );
+        const bool wasLeeching = !tr_torrentIsSeed (tor);
         const bool wasRunning = tor->isRunning;
 
-        if( recentChange )
+        if (recentChange)
         {
-            tr_torinf( tor, _( "State changed from \"%1$s\" to \"%2$s\"" ),
-                      getCompletionString( tor->completeness ),
-                      getCompletionString( completeness ) );
+            tr_torinf (tor, _ ("State changed from \"%1$s\" to \"%2$s\""),
+                      getCompletionString (tor->completeness),
+                      getCompletionString (completeness));
         }
 
         tor->completeness = completeness;
-        tr_fdTorrentClose( tor->session, tor->uniqueId );
+        tr_fdTorrentClose (tor->session, tor->uniqueId);
 
-        if( tr_torrentIsSeed( tor ) )
+        if (tr_torrentIsSeed (tor))
         {
-            if( recentChange )
+            if (recentChange)
             {
-                tr_announcerTorrentCompleted( tor );
-                tor->doneDate = tor->anyDate = tr_time( );
+                tr_announcerTorrentCompleted (tor);
+                tor->doneDate = tor->anyDate = tr_time ();
             }
 
-            if( wasLeeching && wasRunning )
+            if (wasLeeching && wasRunning)
             {
                 /* clear interested flag on all peers */
-                tr_peerMgrClearInterest( tor );
+                tr_peerMgrClearInterest (tor);
 
                 /* if completeness was TR_LEECH then the seed limit check will have been skipped in bandwidthPulse */
-                tr_torrentCheckSeedLimit( tor );
+                tr_torrentCheckSeedLimit (tor);
             }
 
-            if( tor->currentDir == tor->incompleteDir )
-                tr_torrentSetLocation( tor, tor->downloadDir, true, NULL, NULL );
+            if (tor->currentDir == tor->incompleteDir)
+                tr_torrentSetLocation (tor, tor->downloadDir, true, NULL, NULL);
 
-            if( tr_sessionIsTorrentDoneScriptEnabled( tor->session ) )
-                torrentCallScript( tor, tr_sessionGetTorrentDoneScript( tor->session ) );
+            if (tr_sessionIsTorrentDoneScriptEnabled (tor->session))
+                torrentCallScript (tor, tr_sessionGetTorrentDoneScript (tor->session));
         }
 
-        fireCompletenessChange( tor, completeness, wasRunning );
+        fireCompletenessChange (tor, completeness, wasRunning);
 
-        tr_torrentSetDirty( tor );
+        tr_torrentSetDirty (tor);
     }
 
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 }
 
 /***
@@ -2096,20 +2098,20 @@ tr_torrentRecheckCompleteness( tr_torrent * tor )
 ***/
 
 static void
-tr_torrentFireMetadataCompleted( tr_torrent * tor )
+tr_torrentFireMetadataCompleted (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( tor->metadata_func )
-        tor->metadata_func( tor, tor->metadata_func_user_data );
+    if (tor->metadata_func)
+        tor->metadata_func (tor, tor->metadata_func_user_data);
 }
 
 void
-tr_torrentSetMetadataCallback( tr_torrent                * tor,
+tr_torrentSetMetadataCallback (tr_torrent                * tor,
                                tr_torrent_metadata_func    func,
-                               void                      * user_data )
+                               void                      * user_data)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     tor->metadata_func = func;
     tor->metadata_func_user_data = user_data;
@@ -2121,55 +2123,55 @@ tr_torrentSetMetadataCallback( tr_torrent                * tor,
 **/
 
 void
-tr_torrentInitFilePriority( tr_torrent *    tor,
+tr_torrentInitFilePriority (tr_torrent *    tor,
                             tr_file_index_t fileIndex,
-                            tr_priority_t   priority )
+                            tr_priority_t   priority)
 {
     tr_piece_index_t i;
     tr_file *        file;
 
-    assert( tr_isTorrent( tor ) );
-    assert( fileIndex < tor->info.fileCount );
-    assert( tr_isPriority( priority ) );
+    assert (tr_isTorrent (tor));
+    assert (fileIndex < tor->info.fileCount);
+    assert (tr_isPriority (priority));
 
     file = &tor->info.files[fileIndex];
     file->priority = priority;
-    for( i = file->firstPiece; i <= file->lastPiece; ++i )
-        tor->info.pieces[i].priority = calculatePiecePriority( tor, i, fileIndex );
+    for (i = file->firstPiece; i <= file->lastPiece; ++i)
+        tor->info.pieces[i].priority = calculatePiecePriority (tor, i, fileIndex);
 }
 
 void
-tr_torrentSetFilePriorities( tr_torrent             * tor,
+tr_torrentSetFilePriorities (tr_torrent             * tor,
                              const tr_file_index_t  * files,
                              tr_file_index_t          fileCount,
-                             tr_priority_t            priority )
+                             tr_priority_t            priority)
 {
     tr_file_index_t i;
-    assert( tr_isTorrent( tor ) );
-    tr_torrentLock( tor );
+    assert (tr_isTorrent (tor));
+    tr_torrentLock (tor);
 
-    for( i = 0; i < fileCount; ++i )
-        if( files[i] < tor->info.fileCount )
-            tr_torrentInitFilePriority( tor, files[i], priority );
-    tr_torrentSetDirty( tor );
-    tr_peerMgrRebuildRequests( tor );
+    for (i = 0; i < fileCount; ++i)
+        if (files[i] < tor->info.fileCount)
+            tr_torrentInitFilePriority (tor, files[i], priority);
+    tr_torrentSetDirty (tor);
+    tr_peerMgrRebuildRequests (tor);
 
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 }
 
 tr_priority_t*
-tr_torrentGetFilePriorities( const tr_torrent * tor )
+tr_torrentGetFilePriorities (const tr_torrent * tor)
 {
     tr_file_index_t i;
     tr_priority_t * p;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_torrentLock( tor );
-    p = tr_new0( tr_priority_t, tor->info.fileCount );
-    for( i = 0; i < tor->info.fileCount; ++i )
+    tr_torrentLock (tor);
+    p = tr_new0 (tr_priority_t, tor->info.fileCount);
+    for (i = 0; i < tor->info.fileCount; ++i)
         p[i] = tor->info.files[i].priority;
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 
     return p;
 }
@@ -2179,7 +2181,7 @@ tr_torrentGetFilePriorities( const tr_torrent * tor )
 **/
 
 static void
-setFileDND( tr_torrent * tor, tr_file_index_t fileIndex, int doDownload )
+setFileDND (tr_torrent * tor, tr_file_index_t fileIndex, int doDownload)
 {
     const int8_t     dnd = !doDownload;
     tr_piece_index_t firstPiece;
@@ -2196,14 +2198,14 @@ setFileDND( tr_torrent * tor, tr_file_index_t fileIndex, int doDownload )
     /* can't set the first piece to DND unless
        every file using that piece is DND */
     firstPieceDND = dnd;
-    if( fileIndex > 0 )
+    if (fileIndex > 0)
     {
-        for( i = fileIndex - 1; firstPieceDND; --i )
+        for (i = fileIndex - 1; firstPieceDND; --i)
         {
-            if( tor->info.files[i].lastPiece != firstPiece )
+            if (tor->info.files[i].lastPiece != firstPiece)
                 break;
             firstPieceDND = tor->info.files[i].dnd;
-            if( !i )
+            if (!i)
                 break;
         }
     }
@@ -2211,14 +2213,14 @@ setFileDND( tr_torrent * tor, tr_file_index_t fileIndex, int doDownload )
     /* can't set the last piece to DND unless
        every file using that piece is DND */
     lastPieceDND = dnd;
-    for( i = fileIndex + 1; lastPieceDND && i < tor->info.fileCount; ++i )
+    for (i = fileIndex + 1; lastPieceDND && i < tor->info.fileCount; ++i)
     {
-        if( tor->info.files[i].firstPiece != lastPiece )
+        if (tor->info.files[i].firstPiece != lastPiece)
             break;
         lastPieceDND = tor->info.files[i].dnd;
     }
 
-    if( firstPiece == lastPiece )
+    if (firstPiece == lastPiece)
     {
         tor->info.pieces[firstPiece].dnd = firstPieceDND && lastPieceDND;
     }
@@ -2227,46 +2229,46 @@ setFileDND( tr_torrent * tor, tr_file_index_t fileIndex, int doDownload )
         tr_piece_index_t pp;
         tor->info.pieces[firstPiece].dnd = firstPieceDND;
         tor->info.pieces[lastPiece].dnd = lastPieceDND;
-        for( pp = firstPiece + 1; pp < lastPiece; ++pp )
+        for (pp = firstPiece + 1; pp < lastPiece; ++pp)
             tor->info.pieces[pp].dnd = dnd;
     }
 }
 
 void
-tr_torrentInitFileDLs( tr_torrent             * tor,
+tr_torrentInitFileDLs (tr_torrent             * tor,
                        const tr_file_index_t  * files,
                        tr_file_index_t          fileCount,
-                       bool                     doDownload )
+                       bool                     doDownload)
 {
     tr_file_index_t i;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_torrentLock( tor );
+    tr_torrentLock (tor);
 
-    for( i=0; i<fileCount; ++i )
-        if( files[i] < tor->info.fileCount )
-            setFileDND( tor, files[i], doDownload );
+    for (i=0; i<fileCount; ++i)
+        if (files[i] < tor->info.fileCount)
+            setFileDND (tor, files[i], doDownload);
 
-    tr_cpInvalidateDND( &tor->completion );
+    tr_cpInvalidateDND (&tor->completion);
 
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 }
 
 void
-tr_torrentSetFileDLs( tr_torrent             * tor,
+tr_torrentSetFileDLs (tr_torrent             * tor,
                       const tr_file_index_t  * files,
                       tr_file_index_t          fileCount,
-                      bool                     doDownload )
+                      bool                     doDownload)
 {
-    assert( tr_isTorrent( tor ) );
-    tr_torrentLock( tor );
+    assert (tr_isTorrent (tor));
+    tr_torrentLock (tor);
 
-    tr_torrentInitFileDLs( tor, files, fileCount, doDownload );
-    tr_torrentSetDirty( tor );
-    tr_peerMgrRebuildRequests( tor );
+    tr_torrentInitFileDLs (tor, files, fileCount, doDownload);
+    tr_torrentSetDirty (tor);
+    tr_peerMgrRebuildRequests (tor);
 
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 }
 
 /***
@@ -2274,24 +2276,24 @@ tr_torrentSetFileDLs( tr_torrent             * tor,
 ***/
 
 tr_priority_t
-tr_torrentGetPriority( const tr_torrent * tor )
+tr_torrentGetPriority (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     return tor->bandwidth.priority;
 }
 
 void
-tr_torrentSetPriority( tr_torrent * tor, tr_priority_t priority )
+tr_torrentSetPriority (tr_torrent * tor, tr_priority_t priority)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_isPriority( priority ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_isPriority (priority));
 
-    if( tor->bandwidth.priority != priority )
+    if (tor->bandwidth.priority != priority)
     {
         tor->bandwidth.priority = priority;
 
-        tr_torrentSetDirty( tor );
+        tr_torrentSetDirty (tor);
     }
 }
 
@@ -2300,23 +2302,23 @@ tr_torrentSetPriority( tr_torrent * tor, tr_priority_t priority )
 ***/
 
 void
-tr_torrentSetPeerLimit( tr_torrent * tor,
-                        uint16_t     maxConnectedPeers )
+tr_torrentSetPeerLimit (tr_torrent * tor,
+                        uint16_t     maxConnectedPeers)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if ( tor->maxConnectedPeers != maxConnectedPeers )
+    if (tor->maxConnectedPeers != maxConnectedPeers)
     {
         tor->maxConnectedPeers = maxConnectedPeers;
 
-        tr_torrentSetDirty( tor );
+        tr_torrentSetDirty (tor);
     }
 }
 
 uint16_t
-tr_torrentGetPeerLimit( const tr_torrent * tor )
+tr_torrentGetPeerLimit (const tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     return tor->maxConnectedPeers;
 }
@@ -2326,74 +2328,74 @@ tr_torrentGetPeerLimit( const tr_torrent * tor )
 ***/
 
 void
-tr_torrentGetBlockLocation( const tr_torrent * tor,
+tr_torrentGetBlockLocation (const tr_torrent * tor,
                             tr_block_index_t   block,
                             tr_piece_index_t * piece,
                             uint32_t         * offset,
-                            uint32_t         * length )
+                            uint32_t         * length)
 {
     uint64_t pos = block;
     pos *= tor->blockSize;
     *piece = pos / tor->info.pieceSize;
-    *offset = pos - ( *piece * tor->info.pieceSize );
-    *length = tr_torBlockCountBytes( tor, block );
+    *offset = pos - (*piece * tor->info.pieceSize);
+    *length = tr_torBlockCountBytes (tor, block);
 }
 
 
 tr_block_index_t
-_tr_block( const tr_torrent * tor,
+_tr_block (const tr_torrent * tor,
            tr_piece_index_t   index,
-           uint32_t           offset )
+           uint32_t           offset)
 {
     tr_block_index_t ret;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     ret = index;
-    ret *= ( tor->info.pieceSize / tor->blockSize );
+    ret *= (tor->info.pieceSize / tor->blockSize);
     ret += offset / tor->blockSize;
     return ret;
 }
 
 bool
-tr_torrentReqIsValid( const tr_torrent * tor,
+tr_torrentReqIsValid (const tr_torrent * tor,
                       tr_piece_index_t   index,
                       uint32_t           offset,
-                      uint32_t           length )
+                      uint32_t           length)
 {
     int err = 0;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( index >= tor->info.pieceCount )
+    if (index >= tor->info.pieceCount)
         err = 1;
-    else if( length < 1 )
+    else if (length < 1)
         err = 2;
-    else if( ( offset + length ) > tr_torPieceCountBytes( tor, index ) )
+    else if ((offset + length) > tr_torPieceCountBytes (tor, index))
         err = 3;
-    else if( length > MAX_BLOCK_SIZE )
+    else if (length > MAX_BLOCK_SIZE)
         err = 4;
-    else if( tr_pieceOffset( tor, index, offset, length ) > tor->info.totalSize )
+    else if (tr_pieceOffset (tor, index, offset, length) > tor->info.totalSize)
         err = 5;
 
-    if( err ) tr_tordbg( tor, "index %lu offset %lu length %lu err %d\n",
-                              (unsigned long)index,
-                              (unsigned long)offset,
-                              (unsigned long)length,
-                              err );
+    if (err) tr_tordbg (tor, "index %lu offset %lu length %lu err %d\n",
+                            (unsigned long)index,
+                            (unsigned long)offset,
+                            (unsigned long)length,
+                              err);
 
     return !err;
 }
 
 uint64_t
-tr_pieceOffset( const tr_torrent * tor,
+tr_pieceOffset (const tr_torrent * tor,
                 tr_piece_index_t   index,
                 uint32_t           offset,
-                uint32_t           length )
+                uint32_t           length)
 {
     uint64_t ret;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     ret = tor->info.pieceSize;
     ret *= index;
@@ -2403,15 +2405,15 @@ tr_pieceOffset( const tr_torrent * tor,
 }
 
 void
-tr_torGetFileBlockRange( const tr_torrent        * tor,
+tr_torGetFileBlockRange (const tr_torrent        * tor,
                          const tr_file_index_t     file,
                          tr_block_index_t        * first,
-                         tr_block_index_t        * last )
+                         tr_block_index_t        * last)
 {
     const tr_file * f = &tor->info.files[file];
     uint64_t offset = f->offset;
     *first = offset / tor->blockSize;
-    if( !f->length )
+    if (!f->length)
         *last = *first;
     else {
         offset += f->length - 1;
@@ -2420,15 +2422,15 @@ tr_torGetFileBlockRange( const tr_torrent        * tor,
 }
 
 void
-tr_torGetPieceBlockRange( const tr_torrent        * tor,
+tr_torGetPieceBlockRange (const tr_torrent        * tor,
                           const tr_piece_index_t    piece,
                           tr_block_index_t        * first,
-                          tr_block_index_t        * last )
+                          tr_block_index_t        * last)
 {
     uint64_t offset = tor->info.pieceSize;
     offset *= piece;
     *first = offset / tor->blockSize;
-    offset += ( tr_torPieceCountBytes( tor, piece ) - 1 );
+    offset += (tr_torPieceCountBytes (tor, piece) - 1);
     *last = offset / tor->blockSize;
 }
 
@@ -2438,66 +2440,66 @@ tr_torGetPieceBlockRange( const tr_torrent        * tor,
 ***/
 
 void
-tr_torrentSetPieceChecked( tr_torrent * tor, tr_piece_index_t pieceIndex )
+tr_torrentSetPieceChecked (tr_torrent * tor, tr_piece_index_t pieceIndex)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( pieceIndex < tor->info.pieceCount );
+    assert (tr_isTorrent (tor));
+    assert (pieceIndex < tor->info.pieceCount);
 
-    tor->info.pieces[pieceIndex].timeChecked = tr_time( );
+    tor->info.pieces[pieceIndex].timeChecked = tr_time ();
 }
 
 void
-tr_torrentSetChecked( tr_torrent * tor, time_t when )
+tr_torrentSetChecked (tr_torrent * tor, time_t when)
 {
     tr_piece_index_t i, n;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    for( i=0, n=tor->info.pieceCount; i!=n; ++i )
+    for (i=0, n=tor->info.pieceCount; i!=n; ++i)
         tor->info.pieces[i].timeChecked = when;
 }
 
 bool
-tr_torrentCheckPiece( tr_torrent * tor, tr_piece_index_t pieceIndex )
+tr_torrentCheckPiece (tr_torrent * tor, tr_piece_index_t pieceIndex)
 {
-    const bool pass = tr_ioTestPiece( tor, pieceIndex );
+    const bool pass = tr_ioTestPiece (tor, pieceIndex);
 
-    tr_deeplog_tor( tor, "[LAZY] tr_torrentCheckPiece tested piece %zu, pass==%d", (size_t)pieceIndex, (int)pass );
-    tr_torrentSetHasPiece( tor, pieceIndex, pass );
-    tr_torrentSetPieceChecked( tor, pieceIndex );
-    tor->anyDate = tr_time( );
-    tr_torrentSetDirty( tor );
+    tr_deeplog_tor (tor, "[LAZY] tr_torrentCheckPiece tested piece %zu, pass==%d", (size_t)pieceIndex, (int)pass);
+    tr_torrentSetHasPiece (tor, pieceIndex, pass);
+    tr_torrentSetPieceChecked (tor, pieceIndex);
+    tor->anyDate = tr_time ();
+    tr_torrentSetDirty (tor);
 
     return pass;
 }
 
 time_t
-tr_torrentGetFileMTime( const tr_torrent * tor, tr_file_index_t i )
+tr_torrentGetFileMTime (const tr_torrent * tor, tr_file_index_t i)
 {
     time_t mtime = 0;
-    if( !tr_fdFileGetCachedMTime( tor->session, tor->uniqueId, i, &mtime ) )
-        tr_torrentFindFile2( tor, i, NULL, NULL, &mtime );
+    if (!tr_fdFileGetCachedMTime (tor->session, tor->uniqueId, i, &mtime))
+        tr_torrentFindFile2 (tor, i, NULL, NULL, &mtime);
     return mtime;
 }
 
 bool
-tr_torrentPieceNeedsCheck( const tr_torrent * tor, tr_piece_index_t p )
+tr_torrentPieceNeedsCheck (const tr_torrent * tor, tr_piece_index_t p)
 {
     uint64_t unused;
     tr_file_index_t f;
-    const tr_info * inf = tr_torrentInfo( tor );
+    const tr_info * inf = tr_torrentInfo (tor);
 
     /* if we've never checked this piece, then it needs to be checked */
-    if( !inf->pieces[p].timeChecked )
+    if (!inf->pieces[p].timeChecked)
         return true;
 
     /* If we think we've completed one of the files in this piece,
      * but it's been modified since we last checked it,
      * then it needs to be rechecked */
-    tr_ioFindFileLocation( tor, p, 0, &f, &unused );
-    for( ; f < inf->fileCount && pieceHasFile( p, &inf->files[f] ); ++f )
-        if( tr_cpFileIsComplete( &tor->completion, f ) )
-            if( tr_torrentGetFileMTime( tor, f ) > inf->pieces[p].timeChecked )
+    tr_ioFindFileLocation (tor, p, 0, &f, &unused);
+    for (; f < inf->fileCount && pieceHasFile (p, &inf->files[f]); ++f)
+        if (tr_cpFileIsComplete (&tor->completion, f))
+            if (tr_torrentGetFileMTime (tor, f) > inf->pieces[p].timeChecked)
                 return true;
 
     return false;
@@ -2508,13 +2510,13 @@ tr_torrentPieceNeedsCheck( const tr_torrent * tor, tr_piece_index_t p )
 ***/
 
 static int
-compareTrackerByTier( const void * va, const void * vb )
+compareTrackerByTier (const void * va, const void * vb)
 {
     const tr_tracker_info * a = va;
     const tr_tracker_info * b = vb;
 
     /* sort by tier */
-    if( a->tier != b->tier )
+    if (a->tier != b->tier)
         return a->tier - b->tier;
 
     /* get the effects of a stable sort by comparing the two elements' addresses */
@@ -2522,63 +2524,63 @@ compareTrackerByTier( const void * va, const void * vb )
 }
 
 bool
-tr_torrentSetAnnounceList( tr_torrent             * tor,
+tr_torrentSetAnnounceList (tr_torrent             * tor,
                            const tr_tracker_info  * trackers_in,
-                           int                      trackerCount )
+                           int                      trackerCount)
 {
     int i;
     tr_benc metainfo;
     bool ok = true;
     tr_tracker_info * trackers;
 
-    tr_torrentLock( tor );
+    tr_torrentLock (tor);
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     /* ensure the trackers' tiers are in ascending order */
-    trackers = tr_memdup( trackers_in, sizeof( tr_tracker_info ) * trackerCount );
-    qsort( trackers, trackerCount, sizeof( tr_tracker_info ), compareTrackerByTier );
+    trackers = tr_memdup (trackers_in, sizeof (tr_tracker_info) * trackerCount);
+    qsort (trackers, trackerCount, sizeof (tr_tracker_info), compareTrackerByTier);
 
     /* look for bad URLs */
-    for( i=0; ok && i<trackerCount; ++i )
-        if( !tr_urlIsValidTracker( trackers[i].announce ) )
+    for (i=0; ok && i<trackerCount; ++i)
+        if (!tr_urlIsValidTracker (trackers[i].announce))
             ok = false;
 
     /* save to the .torrent file */
-    if( ok && !tr_bencLoadFile( &metainfo, TR_FMT_BENC, tor->info.torrent ) )
+    if (ok && !tr_bencLoadFile (&metainfo, TR_FMT_BENC, tor->info.torrent))
     {
         bool hasInfo;
         tr_info tmpInfo;
 
         /* remove the old fields */
-        tr_bencDictRemove( &metainfo, "announce" );
-        tr_bencDictRemove( &metainfo, "announce-list" );
+        tr_bencDictRemove (&metainfo, "announce");
+        tr_bencDictRemove (&metainfo, "announce-list");
 
         /* add the new fields */
-        if( trackerCount > 0 )
+        if (trackerCount > 0)
         {
-            tr_bencDictAddStr( &metainfo, "announce", trackers[0].announce );
+            tr_bencDictAddStr (&metainfo, "announce", trackers[0].announce);
         }
-        if( trackerCount > 1 )
+        if (trackerCount > 1)
         {
             int i;
             int prevTier = -1;
             tr_benc * tier = NULL;
-            tr_benc * announceList = tr_bencDictAddList( &metainfo, "announce-list", 0 );
+            tr_benc * announceList = tr_bencDictAddList (&metainfo, "announce-list", 0);
 
-            for( i=0; i<trackerCount; ++i ) {
-                if( prevTier != trackers[i].tier ) {
+            for (i=0; i<trackerCount; ++i) {
+                if (prevTier != trackers[i].tier) {
                     prevTier = trackers[i].tier;
-                    tier = tr_bencListAddList( announceList, 0 );
+                    tier = tr_bencListAddList (announceList, 0);
                 }
-                tr_bencListAddStr( tier, trackers[i].announce );
+                tr_bencListAddStr (tier, trackers[i].announce);
             }
         }
 
         /* try to parse it back again, to make sure it's good */
-        memset( &tmpInfo, 0, sizeof( tr_info ) );
-        if( tr_metainfoParse( tor->session, &metainfo, &tmpInfo,
-                              &hasInfo, &tor->infoDictLength ) )
+        memset (&tmpInfo, 0, sizeof (tr_info));
+        if (tr_metainfoParse (tor->session, &metainfo, &tmpInfo,
+                              &hasInfo, &tor->infoDictLength))
         {
             /* it's good, so keep these new trackers and free the old ones */
 
@@ -2590,36 +2592,36 @@ tr_torrentSetAnnounceList( tr_torrent             * tor,
             tmpInfo.trackers = swap.trackers;
             tmpInfo.trackerCount = swap.trackerCount;
 
-            tr_metainfoFree( &tmpInfo );
-            tr_bencToFile( &metainfo, TR_FMT_BENC, tor->info.torrent );
+            tr_metainfoFree (&tmpInfo);
+            tr_bencToFile (&metainfo, TR_FMT_BENC, tor->info.torrent);
         }
 
         /* cleanup */
-        tr_bencFree( &metainfo );
+        tr_bencFree (&metainfo);
 
         /* if we had a tracker-related error on this torrent,
          * and that tracker's been removed,
          * then clear the error */
-        if(    ( tor->error == TR_STAT_TRACKER_WARNING )
-            || ( tor->error == TR_STAT_TRACKER_ERROR ) )
+        if ((tor->error == TR_STAT_TRACKER_WARNING)
+            || (tor->error == TR_STAT_TRACKER_ERROR))
         {
             bool clear = true;
 
-            for( i=0; clear && i<trackerCount; ++i )
-                if( !strcmp( trackers[i].announce, tor->errorTracker ) )
+            for (i=0; clear && i<trackerCount; ++i)
+                if (!strcmp (trackers[i].announce, tor->errorTracker))
                     clear = false;
 
-            if( clear )
-                tr_torrentClearError( tor );
+            if (clear)
+                tr_torrentClearError (tor);
         }
 
         /* tell the announcer to reload this torrent's tracker list */
-        tr_announcerResetTorrent( tor->session->announcer, tor );
+        tr_announcerResetTorrent (tor->session->announcer, tor);
     }
 
-    tr_torrentUnlock( tor );
+    tr_torrentUnlock (tor);
 
-    tr_free( trackers );
+    tr_free (trackers);
     return ok;
 }
 
@@ -2628,32 +2630,32 @@ tr_torrentSetAnnounceList( tr_torrent             * tor,
 **/
 
 void
-tr_torrentSetAddedDate( tr_torrent * tor,
-                        time_t       t )
+tr_torrentSetAddedDate (tr_torrent * tor,
+                        time_t       t)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     tor->addedDate = t;
-    tor->anyDate = MAX( tor->anyDate, tor->addedDate );
+    tor->anyDate = MAX (tor->anyDate, tor->addedDate);
 }
 
 void
-tr_torrentSetActivityDate( tr_torrent * tor, time_t t )
+tr_torrentSetActivityDate (tr_torrent * tor, time_t t)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     tor->activityDate = t;
-    tor->anyDate = MAX( tor->anyDate, tor->activityDate );
+    tor->anyDate = MAX (tor->anyDate, tor->activityDate);
 }
 
 void
-tr_torrentSetDoneDate( tr_torrent * tor,
-                       time_t       t )
+tr_torrentSetDoneDate (tr_torrent * tor,
+                       time_t       t)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     tor->doneDate = t;
-    tor->anyDate = MAX( tor->anyDate, tor->doneDate );
+    tor->anyDate = MAX (tor->anyDate, tor->doneDate);
 }
 
 /**
@@ -2661,29 +2663,29 @@ tr_torrentSetDoneDate( tr_torrent * tor,
 **/
 
 uint64_t
-tr_torrentGetBytesLeftToAllocate( const tr_torrent * tor )
+tr_torrentGetBytesLeftToAllocate (const tr_torrent * tor)
 {
     tr_file_index_t i;
     uint64_t bytesLeft = 0;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    for( i=0; i<tor->info.fileCount; ++i )
+    for (i=0; i<tor->info.fileCount; ++i)
     {
-        if( !tor->info.files[i].dnd )
+        if (!tor->info.files[i].dnd)
         {
             struct stat sb;
             const uint64_t length = tor->info.files[i].length;
-            char * path = tr_torrentFindFile( tor, i );
+            char * path = tr_torrentFindFile (tor, i);
 
             bytesLeft += length;
 
-            if( ( path != NULL ) && !stat( path, &sb )
-                                 && S_ISREG( sb.st_mode )
-                                 && ( (uint64_t)sb.st_size <= length ) )
+            if ((path != NULL) && !stat (path, &sb)
+                                 && S_ISREG (sb.st_mode)
+                                 && ((uint64_t)sb.st_size <= length))
                 bytesLeft -= sb.st_size;
 
-            tr_free( path );
+            tr_free (path);
         }
     }
 
@@ -2695,19 +2697,19 @@ tr_torrentGetBytesLeftToAllocate( const tr_torrent * tor )
 ****/
 
 static bool
-isJunkFile( const char * base )
+isJunkFile (const char * base)
 {
     int i;
     static const char * files[] = { ".DS_Store", "desktop.ini", "Thumbs.db" };
-    static const int file_count = sizeof(files) / sizeof(files[0]);
+    static const int file_count = sizeof (files) / sizeof (files[0]);
 
-    for( i=0; i<file_count; ++i )
-        if( !strcmp( base, files[i] ) )
+    for (i=0; i<file_count; ++i)
+        if (!strcmp (base, files[i]))
             return true;
 
 #ifdef SYS_DARWIN
     /* check for resource forks. <http://support.apple.com/kb/TA20578> */
-    if( !memcmp( base, "._", 2 ) )
+    if (!memcmp (base, "._", 2))
         return true;
 #endif
 
@@ -2715,24 +2717,24 @@ isJunkFile( const char * base )
 }
 
 static void
-removeEmptyFoldersAndJunkFiles( const char * folder )
+removeEmptyFoldersAndJunkFiles (const char * folder)
 {
     DIR * odir;
-    if(( odir = opendir( folder ))) {
+    if ((odir = opendir (folder))) {
         struct dirent * d;
-        while(( d = readdir( odir ))) {
-            if( strcmp( d->d_name, "." ) && strcmp( d->d_name, ".." ) ) {
+        while ((d = readdir (odir))) {
+            if (strcmp (d->d_name, ".") && strcmp (d->d_name, "..")) {
                 struct stat sb;
-                char * filename = tr_buildPath( folder, d->d_name, NULL );
-                if( !stat( filename, &sb ) && S_ISDIR( sb.st_mode ) )
-                    removeEmptyFoldersAndJunkFiles( filename );
-                else if( isJunkFile( d->d_name ) )
-                    remove( filename );
-                tr_free( filename );
+                char * filename = tr_buildPath (folder, d->d_name, NULL);
+                if (!stat (filename, &sb) && S_ISDIR (sb.st_mode))
+                    removeEmptyFoldersAndJunkFiles (filename);
+                else if (isJunkFile (d->d_name))
+                    remove (filename);
+                tr_free (filename);
             }
         }
-        remove( folder );
-        closedir( odir );
+        remove (folder);
+        closedir (odir);
     }
 }
 
@@ -2746,7 +2748,7 @@ removeEmptyFoldersAndJunkFiles( const char * folder )
  * 3. ...unless the other files are "junk", such as .DS_Store
  */
 static void
-deleteLocalData( tr_torrent * tor, tr_fileFunc func )
+deleteLocalData (tr_torrent * tor, tr_fileFunc func)
 {
     int i, n;
     tr_file_index_t f;
@@ -2759,41 +2761,41 @@ deleteLocalData( tr_torrent * tor, tr_fileFunc func )
     const char * const top = tor->currentDir;
 
     /* if it's a magnet link, there's nothing to move... */
-    if( !tr_torrentHasMetadata( tor ) )
+    if (!tr_torrentHasMetadata (tor))
         return;
 
     /***
     ****  Move the local data to a new tmpdir
     ***/
 
-    base = tr_strdup_printf( "%s__XXXXXX", tr_torrentName( tor ) );
-    tmpdir = tr_buildPath( top, base, NULL );
-    tr_mkdtemp( tmpdir );
-    tr_free( base );
+    base = tr_strdup_printf ("%s__XXXXXX", tr_torrentName (tor));
+    tmpdir = tr_buildPath (top, base, NULL);
+    tr_mkdtemp (tmpdir);
+    tr_free (base);
 
-    for( f=0; f<tor->info.fileCount; ++f )
+    for (f=0; f<tor->info.fileCount; ++f)
     {
-        char * filename = tr_buildPath( top, tor->info.files[f].name, NULL );
-        if( !tr_fileExists( filename, NULL ) ) {
-                char * partial = tr_torrentBuildPartial( tor, f );
-                tr_free( filename );
-                filename = tr_buildPath( top, partial, NULL );
-                tr_free( partial );
-                if( !tr_fileExists( filename, NULL ) ) {
-                        tr_free( filename );
+        char * filename = tr_buildPath (top, tor->info.files[f].name, NULL);
+        if (!tr_fileExists (filename, NULL)) {
+                char * partial = tr_torrentBuildPartial (tor, f);
+                tr_free (filename);
+                filename = tr_buildPath (top, partial, NULL);
+                tr_free (partial);
+                if (!tr_fileExists (filename, NULL)) {
+                        tr_free (filename);
                         filename = NULL;
                 }
         }
 
-        if( filename != NULL )
+        if (filename != NULL)
         {
-            char * target = tr_buildPath( tmpdir, tor->info.files[f].name, NULL );
-            char * target_dir = tr_dirname( target );
-            tr_mkdirp( target_dir, 0777 );
-            rename( filename, target );
-            tr_ptrArrayAppend( &files, target );
-            tr_free( target_dir );
-            tr_free( filename );
+            char * target = tr_buildPath (tmpdir, tor->info.files[f].name, NULL);
+            char * target_dir = tr_dirname (target);
+            tr_mkdirp (target_dir, 0777);
+            rename (filename, target);
+            tr_ptrArrayAppend (&files, target);
+            tr_free (target_dir);
+            tr_free (filename);
         }
     }
 
@@ -2802,38 +2804,38 @@ deleteLocalData( tr_torrent * tor, tr_fileFunc func )
     ****
     ****  Try deleting the top-level files & folders to preserve
     ****  the directory hierarchy in the recycle bin.
-    ****  If case that fails -- for example, rmdir() doesn't
+    ****  If case that fails -- for example, rmdir () doesn't
     ****  delete nonempty folders -- go from the bottom up too.
     ***/
 
     /* try deleting the local data's top-level files & folders */
-    if(( odir = opendir( tmpdir )))
+    if ((odir = opendir (tmpdir)))
     {
         struct dirent * d;
-        while(( d = readdir( odir )))
+        while ((d = readdir (odir)))
         {
-            if( strcmp( d->d_name, "." ) && strcmp( d->d_name, ".." ) )
+            if (strcmp (d->d_name, ".") && strcmp (d->d_name, ".."))
             {
-                char * file = tr_buildPath( tmpdir, d->d_name, NULL );
-                func( file );
-                tr_free( file );
+                char * file = tr_buildPath (tmpdir, d->d_name, NULL);
+                func (file);
+                tr_free (file);
             }
         }
-        closedir( odir );
+        closedir (odir);
     }
 
     /* go from the bottom up */
-    for( i=0, n=tr_ptrArraySize(&files); i<n; ++i )
+    for (i=0, n=tr_ptrArraySize (&files); i<n; ++i)
     {
-        char * walk = tr_strdup( tr_ptrArrayNth( &files, i ) );
-        while( tr_fileExists( walk, NULL ) && !tr_is_same_file( tmpdir, walk ) )
+        char * walk = tr_strdup (tr_ptrArrayNth (&files, i));
+        while (tr_fileExists (walk, NULL) && !tr_is_same_file (tmpdir, walk))
         {
-            char * tmp = tr_dirname( walk );
-            func( walk );
-            tr_free( walk );
+            char * tmp = tr_dirname (walk);
+            func (walk);
+            tr_free (walk);
             walk = tmp;
         }
-        tr_free( walk );
+        tr_free (walk);
     }
 
     /***
@@ -2843,50 +2845,50 @@ deleteLocalData( tr_torrent * tor, tr_fileFunc func )
     ***/
 
     /* build a list of 'top's child directories that belong to this torrent */
-    for( f=0; f<tor->info.fileCount; ++f )
+    for (f=0; f<tor->info.fileCount; ++f)
     {
         /* get the directory that this file goes in... */
-        char * filename = tr_buildPath( top, tor->info.files[f].name, NULL );
-        char * dir = tr_dirname( filename );
-        if( !tr_is_same_file( top, dir ) && strcmp( top, dir ) ) {
-            for( ;; ) {
-                char * parent = tr_dirname( dir );
-                if( tr_is_same_file( top, parent ) || !strcmp( top, parent ) ) {
-                    if( tr_ptrArrayFindSorted( &folders, dir, vstrcmp ) == NULL ) {
-                        tr_ptrArrayInsertSorted( &folders, tr_strdup( dir ), vstrcmp );
+        char * filename = tr_buildPath (top, tor->info.files[f].name, NULL);
+        char * dir = tr_dirname (filename);
+        if (!tr_is_same_file (top, dir) && strcmp (top, dir)) {
+            for (;;) {
+                char * parent = tr_dirname (dir);
+                if (tr_is_same_file (top, parent) || !strcmp (top, parent)) {
+                    if (tr_ptrArrayFindSorted (&folders, dir, vstrcmp) == NULL) {
+                        tr_ptrArrayInsertSorted (&folders, tr_strdup (dir), vstrcmp);
                     }
                     break;
                 }
-                tr_free( dir );
+                tr_free (dir);
                 dir = parent;
             }
         }
-        tr_free( dir );
-        tr_free( filename );
+        tr_free (dir);
+        tr_free (filename);
     }
-    for( i=0, n=tr_ptrArraySize(&folders); i<n; ++i )
-        removeEmptyFoldersAndJunkFiles( tr_ptrArrayNth( &folders, i ) );
+    for (i=0, n=tr_ptrArraySize (&folders); i<n; ++i)
+        removeEmptyFoldersAndJunkFiles (tr_ptrArrayNth (&folders, i));
 
     /* cleanup */
-    rmdir( tmpdir );
-    tr_free( tmpdir );
-    tr_ptrArrayDestruct( &folders, tr_free );
-    tr_ptrArrayDestruct( &files, tr_free );
+    rmdir (tmpdir);
+    tr_free (tmpdir);
+    tr_ptrArrayDestruct (&folders, tr_free);
+    tr_ptrArrayDestruct (&files, tr_free);
 }
 
 static void
-tr_torrentDeleteLocalData( tr_torrent * tor, tr_fileFunc func )
+tr_torrentDeleteLocalData (tr_torrent * tor, tr_fileFunc func)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( func == NULL )
+    if (func == NULL)
         func = remove;
 
     /* close all the files because we're about to delete them */
-    tr_cacheFlushTorrent( tor->session->cache, tor );
-    tr_fdTorrentClose( tor->session, tor->uniqueId );
+    tr_cacheFlushTorrent (tor->session->cache, tor);
+    tr_fdTorrentClose (tor->session, tor->uniqueId);
 
-    deleteLocalData( tor, func );
+    deleteLocalData (tor, func);
 }
 
 /***
@@ -2903,7 +2905,7 @@ struct LocationData
 };
 
 static void
-setLocation( void * vdata )
+setLocation (void * vdata)
 {
     bool err = false;
     struct LocationData * data = vdata;
@@ -2912,110 +2914,110 @@ setLocation( void * vdata )
     const char * location = data->location;
     double bytesHandled = 0;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    tr_dbg( "Moving \"%s\" location from currentDir \"%s\" to \"%s\"",
-            tr_torrentName(tor), tor->currentDir, location );
+    tr_dbg ("Moving \"%s\" location from currentDir \"%s\" to \"%s\"",
+            tr_torrentName (tor), tor->currentDir, location);
 
-    tr_mkdirp( location, 0777 );
+    tr_mkdirp (location, 0777);
 
-    if( !tr_is_same_file( location, tor->currentDir ) )
+    if (!tr_is_same_file (location, tor->currentDir))
     {
         tr_file_index_t i;
 
         /* bad idea to move files while they're being verified... */
-        tr_verifyRemove( tor );
+        tr_verifyRemove (tor);
 
         /* try to move the files.
          * FIXME: there are still all kinds of nasty cases, like what
          * if the target directory runs out of space halfway through... */
-        for( i=0; !err && i<tor->info.fileCount; ++i )
+        for (i=0; !err && i<tor->info.fileCount; ++i)
         {
             const tr_file * f = &tor->info.files[i];
             const char * oldbase;
             char * sub;
-            if( tr_torrentFindFile2( tor, i, &oldbase, &sub, NULL ) )
+            if (tr_torrentFindFile2 (tor, i, &oldbase, &sub, NULL))
             {
-                char * oldpath = tr_buildPath( oldbase, sub, NULL );
-                char * newpath = tr_buildPath( location, sub, NULL );
+                char * oldpath = tr_buildPath (oldbase, sub, NULL);
+                char * newpath = tr_buildPath (location, sub, NULL);
 
-                tr_dbg( "Found file #%d: %s", (int)i, oldpath );
+                tr_dbg ("Found file #%d: %s", (int)i, oldpath);
 
-                if( do_move && !tr_is_same_file( oldpath, newpath ) )
+                if (do_move && !tr_is_same_file (oldpath, newpath))
                 {
                     bool renamed = false;
                     errno = 0;
-                    tr_torinf( tor, "moving \"%s\" to \"%s\"", oldpath, newpath );
-                    if( tr_moveFile( oldpath, newpath, &renamed ) )
+                    tr_torinf (tor, "moving \"%s\" to \"%s\"", oldpath, newpath);
+                    if (tr_moveFile (oldpath, newpath, &renamed))
                     {
                         err = true;
-                        tr_torerr( tor, "error moving \"%s\" to \"%s\": %s",
-                                        oldpath, newpath, tr_strerror( errno ) );
+                        tr_torerr (tor, "error moving \"%s\" to \"%s\": %s",
+                                        oldpath, newpath, tr_strerror (errno));
                     }
                 }
 
-                tr_free( newpath );
-                tr_free( oldpath );
-                tr_free( sub );
+                tr_free (newpath);
+                tr_free (oldpath);
+                tr_free (sub);
             }
 
-            if( data->setme_progress )
+            if (data->setme_progress)
             {
                 bytesHandled += f->length;
                 *data->setme_progress = bytesHandled / tor->info.totalSize;
             }
         }
 
-        if( !err )
+        if (!err)
         {
             /* blow away the leftover subdirectories in the old location */
-            if( do_move )
-                tr_torrentDeleteLocalData( tor, remove );
+            if (do_move)
+                tr_torrentDeleteLocalData (tor, remove);
 
             /* set the new location and reverify */
-            tr_torrentSetDownloadDir( tor, location );
+            tr_torrentSetDownloadDir (tor, location);
         }
     }
 
-    if( !err && do_move )
+    if (!err && do_move)
     {
-        tr_free( tor->incompleteDir );
+        tr_free (tor->incompleteDir);
         tor->incompleteDir = NULL;
         tor->currentDir = tor->downloadDir;
     }
 
-    if( data->setme_state )
+    if (data->setme_state)
         *data->setme_state = err ? TR_LOC_ERROR : TR_LOC_DONE;
 
     /* cleanup */
-    tr_free( data->location );
-    tr_free( data );
+    tr_free (data->location);
+    tr_free (data);
 }
 
 void
-tr_torrentSetLocation( tr_torrent       * tor,
+tr_torrentSetLocation (tr_torrent       * tor,
                        const char       * location,
                        bool               move_from_old_location,
                        volatile double  * setme_progress,
-                       volatile int     * setme_state )
+                       volatile int     * setme_state)
 {
     struct LocationData * data;
 
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
-    if( setme_state )
+    if (setme_state)
         *setme_state = TR_LOC_MOVING;
-    if( setme_progress )
+    if (setme_progress)
         *setme_progress = 0;
 
     /* run this in the libtransmission thread */
-    data = tr_new( struct LocationData, 1 );
+    data = tr_new (struct LocationData, 1);
     data->tor = tor;
-    data->location = tr_strdup( location );
+    data->location = tr_strdup (location);
     data->move_from_old_location = move_from_old_location;
     data->setme_state = setme_state;
     data->setme_progress = setme_progress;
-    tr_runInEventThread( tor->session, setLocation, data );
+    tr_runInEventThread (tor->session, setLocation, data);
 }
 
 /***
@@ -3023,7 +3025,7 @@ tr_torrentSetLocation( tr_torrent       * tor,
 ***/
 
 void
-tr_torrentFileCompleted( tr_torrent * tor, tr_file_index_t fileNum )
+tr_torrentFileCompleted (tr_torrent * tor, tr_file_index_t fileNum)
 {
     char * sub;
     const char * base;
@@ -3031,34 +3033,34 @@ tr_torrentFileCompleted( tr_torrent * tor, tr_file_index_t fileNum )
     const tr_file * f = &inf->files[fileNum];
     tr_piece * p;
     const tr_piece * pend;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
     /* close the file so that we can reopen in read-only mode as needed */
-    tr_fdFileClose( tor->session, tor, fileNum );
+    tr_fdFileClose (tor->session, tor, fileNum);
 
     /* now that the file is complete and closed, we can start watching its
      * mtime timestamp for changes to know if we need to reverify pieces */
-    for( p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]; p!=pend; ++p )
+    for (p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]; p!=pend; ++p)
         p->timeChecked = now;
 
     /* if the torrent's current filename isn't the same as the one in the
      * metadata -- for example, if it had the ".part" suffix appended to
      * it until now -- then rename it to match the one in the metadata */
-    if( tr_torrentFindFile2( tor, fileNum, &base, &sub, NULL ) )
+    if (tr_torrentFindFile2 (tor, fileNum, &base, &sub, NULL))
     {
-        if( strcmp( sub, f->name ) )
+        if (strcmp (sub, f->name))
         {
-            char * oldpath = tr_buildPath( base, sub, NULL );
-            char * newpath = tr_buildPath( base, f->name, NULL );
+            char * oldpath = tr_buildPath (base, sub, NULL);
+            char * newpath = tr_buildPath (base, f->name, NULL);
 
-            if( rename( oldpath, newpath ) )
-                tr_torerr( tor, "Error moving \"%s\" to \"%s\": %s", oldpath, newpath, tr_strerror( errno ) );
+            if (rename (oldpath, newpath))
+                tr_torerr (tor, "Error moving \"%s\" to \"%s\": %s", oldpath, newpath, tr_strerror (errno));
 
-            tr_free( newpath );
-            tr_free( oldpath );
+            tr_free (newpath);
+            tr_free (oldpath);
         }
 
-        tr_free( sub );
+        tr_free (sub);
     }
 }
 
@@ -3067,78 +3069,78 @@ tr_torrentFileCompleted( tr_torrent * tor, tr_file_index_t fileNum )
 ***/
 
 bool
-tr_torrentFindFile2( const tr_torrent * tor, tr_file_index_t fileNum,
-                     const char ** base, char ** subpath, time_t * mtime )
+tr_torrentFindFile2 (const tr_torrent * tor, tr_file_index_t fileNum,
+                     const char ** base, char ** subpath, time_t * mtime)
 {
     char * part = NULL;
     const tr_file * file;
     const char * b = NULL;
     const char * s = NULL;
 
-    assert( tr_isTorrent( tor ) );
-    assert( fileNum < tor->info.fileCount );
+    assert (tr_isTorrent (tor));
+    assert (fileNum < tor->info.fileCount);
 
     file = &tor->info.files[fileNum];
 
-    if( b == NULL ) {
-        char * filename = tr_buildPath( tor->downloadDir, file->name, NULL );
-        if( tr_fileExists( filename, mtime ) ) {
+    if (b == NULL) {
+        char * filename = tr_buildPath (tor->downloadDir, file->name, NULL);
+        if (tr_fileExists (filename, mtime)) {
             b = tor->downloadDir;
             s = file->name;
         }
-        tr_free( filename );
+        tr_free (filename);
     }
 
-    if( ( b == NULL ) && ( tor->incompleteDir != NULL ) ) {
-        char * filename = tr_buildPath( tor->incompleteDir, file->name, NULL );
-        if( tr_fileExists( filename, mtime ) ) {
+    if ((b == NULL) && (tor->incompleteDir != NULL)) {
+        char * filename = tr_buildPath (tor->incompleteDir, file->name, NULL);
+        if (tr_fileExists (filename, mtime)) {
             b = tor->incompleteDir;
             s = file->name;
         }
-        tr_free( filename );
+        tr_free (filename);
     }
 
-    if( b == NULL )
-        part = tr_torrentBuildPartial( tor, fileNum );
+    if (b == NULL)
+        part = tr_torrentBuildPartial (tor, fileNum);
 
-    if( ( b == NULL ) && ( tor->incompleteDir != NULL ) ) {
-        char * filename = tr_buildPath( tor->incompleteDir, part, NULL );
-        if( tr_fileExists( filename, mtime ) ) {
+    if ((b == NULL) && (tor->incompleteDir != NULL)) {
+        char * filename = tr_buildPath (tor->incompleteDir, part, NULL);
+        if (tr_fileExists (filename, mtime)) {
             b = tor->incompleteDir;
             s = part;
         }
-        tr_free( filename );
+        tr_free (filename);
     }
 
-    if( b == NULL) {
-        char * filename = tr_buildPath( tor->downloadDir, part, NULL );
-        if( tr_fileExists( filename, mtime ) ) {
+    if (b == NULL) {
+        char * filename = tr_buildPath (tor->downloadDir, part, NULL);
+        if (tr_fileExists (filename, mtime)) {
             b = tor->downloadDir;
             s = part;
         }
-        tr_free( filename );
+        tr_free (filename);
     }
 
-    if( base != NULL )
+    if (base != NULL)
         *base = b;
-    if( subpath != NULL )
-        *subpath = tr_strdup( s );
+    if (subpath != NULL)
+        *subpath = tr_strdup (s);
 
-    tr_free( part );
+    tr_free (part);
     return b != NULL;
 }
 
 char*
-tr_torrentFindFile( const tr_torrent * tor, tr_file_index_t fileNum )
+tr_torrentFindFile (const tr_torrent * tor, tr_file_index_t fileNum)
 {
     char * subpath;
     char * ret = NULL;
     const char * base;
 
-    if( tr_torrentFindFile2( tor, fileNum, &base, &subpath, NULL ) )
+    if (tr_torrentFindFile2 (tor, fileNum, &base, &subpath, NULL))
     {
-        ret = tr_buildPath( base, subpath, NULL );
-        tr_free( subpath );
+        ret = tr_buildPath (base, subpath, NULL);
+        tr_free (subpath);
     }
 
     return ret;
@@ -3146,26 +3148,26 @@ tr_torrentFindFile( const tr_torrent * tor, tr_file_index_t fileNum )
 
 /* Decide whether we should be looking for files in downloadDir or incompleteDir. */
 static void
-refreshCurrentDir( tr_torrent * tor )
+refreshCurrentDir (tr_torrent * tor)
 {
     const char * dir = NULL;
 
-    if( tor->incompleteDir == NULL )
+    if (tor->incompleteDir == NULL)
         dir = tor->downloadDir;
-    else if( !tr_torrentHasMetadata( tor ) ) /* no files to find */
+    else if (!tr_torrentHasMetadata (tor)) /* no files to find */
         dir = tor->incompleteDir;
-    else if( !tr_torrentFindFile2( tor, 0, &dir, NULL, NULL ) )
+    else if (!tr_torrentFindFile2 (tor, 0, &dir, NULL, NULL))
         dir = tor->incompleteDir;
 
-    assert( dir != NULL );
-    assert( ( dir == tor->downloadDir ) || ( dir == tor->incompleteDir ) );
+    assert (dir != NULL);
+    assert ((dir == tor->downloadDir) || (dir == tor->incompleteDir));
     tor->currentDir = dir;
 }
 
 char*
-tr_torrentBuildPartial( const tr_torrent * tor, tr_file_index_t fileNum )
+tr_torrentBuildPartial (const tr_torrent * tor, tr_file_index_t fileNum)
 {
-    return tr_strdup_printf( "%s.part", tor->info.files[fileNum].name );
+    return tr_strdup_printf ("%s.part", tor->info.files[fileNum].name);
 }
 
 /***
@@ -3173,7 +3175,7 @@ tr_torrentBuildPartial( const tr_torrent * tor, tr_file_index_t fileNum )
 ***/
 
 static int
-compareTorrentByQueuePosition( const void * va, const void * vb )
+compareTorrentByQueuePosition (const void * va, const void * vb)
 {
     const tr_torrent * a = * (const tr_torrent **) va;
     const tr_torrent * b = * (const tr_torrent **) vb;
@@ -3183,145 +3185,145 @@ compareTorrentByQueuePosition( const void * va, const void * vb )
 
 #ifndef NDEBUG
 static bool
-queueIsSequenced( tr_session * session )
+queueIsSequenced (tr_session * session)
 {
     int i ;
     int n ;
     bool is_sequenced = true;
     tr_torrent * tor;
-    tr_torrent ** tmp = tr_new( tr_torrent *, session->torrentCount );
+    tr_torrent ** tmp = tr_new (tr_torrent *, session->torrentCount);
 
     /* get all the torrents */
     n = 0;
     tor = NULL;
-    while(( tor = tr_torrentNext( session, tor )))
+    while ((tor = tr_torrentNext (session, tor)))
         tmp[n++] = tor;
 
     /* sort them by position */
-    qsort( tmp, n, sizeof( tr_torrent * ), compareTorrentByQueuePosition );
+    qsort (tmp, n, sizeof (tr_torrent *), compareTorrentByQueuePosition);
 
 #if 0
-    fprintf( stderr, "%s", "queue: " );
-    for( i=0; i<n; ++i )
-        fprintf( stderr, "%d ", tmp[i]->queuePosition );
-    fputc( '\n', stderr );
+    fprintf (stderr, "%s", "queue: ");
+    for (i=0; i<n; ++i)
+        fprintf (stderr, "%d ", tmp[i]->queuePosition);
+    fputc ('\n', stderr);
 #endif
 
     /* test them */
-    for( i=0; is_sequenced && i<n; ++i )
-        if( tmp[i]->queuePosition != i )
+    for (i=0; is_sequenced && i<n; ++i)
+        if (tmp[i]->queuePosition != i)
             is_sequenced = false;
 
-    tr_free( tmp );
+    tr_free (tmp);
     return is_sequenced;
 }
 #endif
 
 int
-tr_torrentGetQueuePosition( const tr_torrent * tor )
+tr_torrentGetQueuePosition (const tr_torrent * tor)
 {
     return tor->queuePosition;
 }
 
 void
-tr_torrentSetQueuePosition( tr_torrent * tor, int pos )
+tr_torrentSetQueuePosition (tr_torrent * tor, int pos)
 {
     int back = -1;
     tr_torrent * walk;
     const int old_pos = tor->queuePosition;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    if( pos < 0 )
+    if (pos < 0)
         pos = 0;
 
     tor->queuePosition = -1;
 
     walk = NULL;
-    while(( walk = tr_torrentNext( tor->session, walk )))
+    while ((walk = tr_torrentNext (tor->session, walk)))
     {
-        if( old_pos < pos ) {
-            if( ( old_pos <= walk->queuePosition ) && ( walk->queuePosition <= pos ) ) {
+        if (old_pos < pos) {
+            if ((old_pos <= walk->queuePosition) && (walk->queuePosition <= pos)) {
                 walk->queuePosition--;
                 walk->anyDate = now;
             }
         }
 
-        if( old_pos > pos ) {
-            if( ( pos <= walk->queuePosition ) && ( walk->queuePosition < old_pos ) ) {
+        if (old_pos > pos) {
+            if ((pos <= walk->queuePosition) && (walk->queuePosition < old_pos)) {
                 walk->queuePosition++;
                 walk->anyDate = now;
             }
         }
 
-        if( back < walk->queuePosition )
+        if (back < walk->queuePosition)
             back = walk->queuePosition;
     }
 
-    tor->queuePosition = MIN( pos, (back+1) );
+    tor->queuePosition = MIN (pos, (back+1));
     tor->anyDate = now;
 
-    assert( queueIsSequenced( tor->session ) );
+    assert (queueIsSequenced (tor->session));
 }
 
 void
-tr_torrentsQueueMoveTop( tr_torrent ** torrents_in, int n )
+tr_torrentsQueueMoveTop (tr_torrent ** torrents_in, int n)
 {
     int i;
-    tr_torrent ** torrents = tr_memdup( torrents_in, sizeof( tr_torrent * ) * n );
-    qsort( torrents, n, sizeof( tr_torrent * ), compareTorrentByQueuePosition );
-    for( i=n-1; i>=0; --i )
-        tr_torrentSetQueuePosition( torrents[i], 0 );
-    tr_free( torrents );
+    tr_torrent ** torrents = tr_memdup (torrents_in, sizeof (tr_torrent *) * n);
+    qsort (torrents, n, sizeof (tr_torrent *), compareTorrentByQueuePosition);
+    for (i=n-1; i>=0; --i)
+        tr_torrentSetQueuePosition (torrents[i], 0);
+    tr_free (torrents);
 }
 
 void
-tr_torrentsQueueMoveUp( tr_torrent ** torrents_in, int n )
+tr_torrentsQueueMoveUp (tr_torrent ** torrents_in, int n)
 {
     int i;
-    tr_torrent ** torrents = tr_memdup( torrents_in, sizeof( tr_torrent * ) * n );
-    qsort( torrents, n, sizeof( tr_torrent * ), compareTorrentByQueuePosition );
-    for( i=0; i<n; ++i )
-        tr_torrentSetQueuePosition( torrents[i], torrents[i]->queuePosition - 1 );
-    tr_free( torrents );
+    tr_torrent ** torrents = tr_memdup (torrents_in, sizeof (tr_torrent *) * n);
+    qsort (torrents, n, sizeof (tr_torrent *), compareTorrentByQueuePosition);
+    for (i=0; i<n; ++i)
+        tr_torrentSetQueuePosition (torrents[i], torrents[i]->queuePosition - 1);
+    tr_free (torrents);
 }
 
 void
-tr_torrentsQueueMoveDown( tr_torrent ** torrents_in, int n )
+tr_torrentsQueueMoveDown (tr_torrent ** torrents_in, int n)
 {
     int i;
-    tr_torrent ** torrents = tr_memdup( torrents_in, sizeof( tr_torrent * ) * n );
-    qsort( torrents, n, sizeof( tr_torrent * ), compareTorrentByQueuePosition );
-    for( i=n-1; i>=0; --i )
-        tr_torrentSetQueuePosition( torrents[i], torrents[i]->queuePosition + 1 );
-    tr_free( torrents );
+    tr_torrent ** torrents = tr_memdup (torrents_in, sizeof (tr_torrent *) * n);
+    qsort (torrents, n, sizeof (tr_torrent *), compareTorrentByQueuePosition);
+    for (i=n-1; i>=0; --i)
+        tr_torrentSetQueuePosition (torrents[i], torrents[i]->queuePosition + 1);
+    tr_free (torrents);
 }
 
 void
-tr_torrentsQueueMoveBottom( tr_torrent ** torrents_in, int n )
+tr_torrentsQueueMoveBottom (tr_torrent ** torrents_in, int n)
 {
     int i;
-    tr_torrent ** torrents = tr_memdup( torrents_in, sizeof( tr_torrent * ) * n );
-    qsort( torrents, n, sizeof( tr_torrent * ), compareTorrentByQueuePosition );
-    for( i=0; i<n; ++i )
-        tr_torrentSetQueuePosition( torrents[i], INT_MAX );
-    tr_free( torrents );
+    tr_torrent ** torrents = tr_memdup (torrents_in, sizeof (tr_torrent *) * n);
+    qsort (torrents, n, sizeof (tr_torrent *), compareTorrentByQueuePosition);
+    for (i=0; i<n; ++i)
+        tr_torrentSetQueuePosition (torrents[i], INT_MAX);
+    tr_free (torrents);
 }
 
 static void
-torrentSetQueued( tr_torrent * tor, bool queued )
+torrentSetQueued (tr_torrent * tor, bool queued)
 {
-    assert( tr_isTorrent( tor ) );
-    assert( tr_isBool( queued ) );
+    assert (tr_isTorrent (tor));
+    assert (tr_isBool (queued));
 
-    if( tr_torrentIsQueued( tor ) != queued )
+    if (tr_torrentIsQueued (tor) != queued)
     {
         tor->isQueued = queued;
-        tor->anyDate = tr_time( );
+        tor->anyDate = tr_time ();
     }
 }
 
 void
-tr_torrentSetQueueStartCallback( tr_torrent * torrent, void (*callback)( tr_torrent *, void * ), void * user_data )
+tr_torrentSetQueueStartCallback (tr_torrent * torrent, void (*callback)(tr_torrent *, void *), void * user_data)
 {
     torrent->queue_started_callback = callback;
     torrent->queue_started_user_data = user_data;
diff --git a/libtransmission/torrent.h b/libtransmission/torrent.h
index 168e76c0e..6fef6a9a3 100644
--- a/libtransmission/torrent.h
+++ b/libtransmission/torrent.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -19,7 +19,7 @@
 
 #include "bandwidth.h" /* tr_bandwidth */
 #include "completion.h" /* tr_completion */
-#include "session.h" /* tr_sessionLock(), tr_sessionUnlock() */
+#include "session.h" /* tr_sessionLock (), tr_sessionUnlock () */
 #include "utils.h" /* TR_GNUC_PRINTF */
 
 struct tr_torrent_tiers;
@@ -29,90 +29,90 @@ struct tr_magnet_info;
 ***  Package-visible ctor API
 **/
 
-void        tr_ctorSetSave( tr_ctor * ctor,
-                            bool      saveMetadataInOurTorrentsDir );
+void        tr_ctorSetSave (tr_ctor * ctor,
+                            bool      saveMetadataInOurTorrentsDir);
 
-int         tr_ctorGetSave( const tr_ctor * ctor );
+int         tr_ctorGetSave (const tr_ctor * ctor);
 
-void        tr_ctorInitTorrentPriorities( const tr_ctor * ctor, tr_torrent * tor );
+void        tr_ctorInitTorrentPriorities (const tr_ctor * ctor, tr_torrent * tor);
 
-void        tr_ctorInitTorrentWanted( const tr_ctor * ctor, tr_torrent * tor );
+void        tr_ctorInitTorrentWanted (const tr_ctor * ctor, tr_torrent * tor);
 
 /**
 ***
 **/
 
 /* just like tr_torrentSetFileDLs but doesn't trigger a fastresume save */
-void        tr_torrentInitFileDLs( tr_torrent              * tor,
+void        tr_torrentInitFileDLs (tr_torrent              * tor,
                                    const tr_file_index_t   * files,
                                    tr_file_index_t           fileCount,
-                                   bool                      do_download );
+                                   bool                      do_download);
 
-void        tr_torrentRecheckCompleteness( tr_torrent * );
+void        tr_torrentRecheckCompleteness (tr_torrent *);
 
-void        tr_torrentSetHasPiece( tr_torrent *     tor,
+void        tr_torrentSetHasPiece (tr_torrent *     tor,
                                    tr_piece_index_t pieceIndex,
-                                   bool             has );
+                                   bool             has);
 
-void        tr_torrentChangeMyPort( tr_torrent * session );
+void        tr_torrentChangeMyPort (tr_torrent * session);
 
-tr_torrent* tr_torrentFindFromHashString( tr_session * session,
-                                          const char * hashString );
+tr_torrent* tr_torrentFindFromHashString (tr_session * session,
+                                          const char * hashString);
 
-tr_torrent* tr_torrentFindFromObfuscatedHash( tr_session    * session,
-                                              const uint8_t * hash );
+tr_torrent* tr_torrentFindFromObfuscatedHash (tr_session    * session,
+                                              const uint8_t * hash);
 
-bool        tr_torrentIsPieceTransferAllowed( const tr_torrent * torrent,
-                                              tr_direction       direction );
+bool        tr_torrentIsPieceTransferAllowed (const tr_torrent * torrent,
+                                              tr_direction       direction);
 
 
 
-#define tr_block( a, b ) _tr_block( tor, a, b )
-tr_block_index_t _tr_block( const tr_torrent * tor,
+#define tr_block(a, b) _tr_block (tor, a, b)
+tr_block_index_t _tr_block (const tr_torrent * tor,
                             tr_piece_index_t   index,
-                            uint32_t           offset );
+                            uint32_t           offset);
 
-bool             tr_torrentReqIsValid( const tr_torrent * tor,
+bool             tr_torrentReqIsValid (const tr_torrent * tor,
                                        tr_piece_index_t   index,
                                        uint32_t           offset,
-                                       uint32_t           length );
+                                       uint32_t           length);
 
-uint64_t         tr_pieceOffset( const tr_torrent * tor,
+uint64_t         tr_pieceOffset (const tr_torrent * tor,
                                  tr_piece_index_t   index,
                                  uint32_t           offset,
-                                 uint32_t           length );
+                                 uint32_t           length);
 
-void             tr_torrentGetBlockLocation( const tr_torrent * tor,
+void             tr_torrentGetBlockLocation (const tr_torrent * tor,
                                              tr_block_index_t   block,
                                              tr_piece_index_t * piece,
                                              uint32_t         * offset,
-                                             uint32_t         * length );
+                                             uint32_t         * length);
 
-void             tr_torGetFileBlockRange( const tr_torrent        * tor,
+void             tr_torGetFileBlockRange (const tr_torrent        * tor,
                                           const tr_file_index_t     file,
                                           tr_block_index_t        * first,
-                                          tr_block_index_t        * last );
+                                          tr_block_index_t        * last);
 
-void             tr_torGetPieceBlockRange( const tr_torrent        * tor,
+void             tr_torGetPieceBlockRange (const tr_torrent        * tor,
                                            const tr_piece_index_t    piece,
                                            tr_block_index_t        * first,
-                                           tr_block_index_t        * last );
+                                           tr_block_index_t        * last);
 
-void             tr_torrentInitFilePriority( tr_torrent       * tor,
+void             tr_torrentInitFilePriority (tr_torrent       * tor,
                                              tr_file_index_t    fileIndex,
-                                             tr_priority_t      priority );
+                                             tr_priority_t      priority);
 
-void             tr_torrentSetPieceChecked( tr_torrent       * tor,
-                                            tr_piece_index_t   piece );
+void             tr_torrentSetPieceChecked (tr_torrent       * tor,
+                                            tr_piece_index_t   piece);
 
-void             tr_torrentSetChecked( tr_torrent * tor, time_t when );
+void             tr_torrentSetChecked (tr_torrent * tor, time_t when);
 
-void             tr_torrentCheckSeedLimit( tr_torrent * tor );
+void             tr_torrentCheckSeedLimit (tr_torrent * tor);
 
 /** save a torrent's .resume file if it's changed since the last time it was saved */
-void             tr_torrentSave( tr_torrent * tor );
+void             tr_torrentSave (tr_torrent * tor);
 
-void             tr_torrentSetLocalError( tr_torrent * tor, const char * fmt, ... ) TR_GNUC_PRINTF( 2, 3 );
+void             tr_torrentSetLocalError (tr_torrent * tor, const char * fmt, ...) TR_GNUC_PRINTF (2, 3);
 
 
 
@@ -124,10 +124,10 @@ typedef enum
 }
 tr_verify_state;
 
-void             tr_torrentSetVerifyState( tr_torrent      * tor,
-                                           tr_verify_state   state );
+void             tr_torrentSetVerifyState (tr_torrent      * tor,
+                                           tr_verify_state   state);
 
-tr_torrent_activity tr_torrentGetActivity( tr_torrent * tor );
+tr_torrent_activity tr_torrentGetActivity (tr_torrent * tor);
 
 struct tr_incomplete_metadata;
 
@@ -237,7 +237,7 @@ struct tr_torrent
     void                            * idle_limit_hit_func_user_data;
 
     void * queue_started_user_data;
-    void ( * queue_started_callback )( tr_torrent *, void * queue_started_user_data );
+    void (* queue_started_callback)(tr_torrent *, void * queue_started_user_data);
 
     bool                       isRunning;
     bool                       isStopping;
@@ -272,21 +272,21 @@ struct tr_torrent
 };
 
 static inline tr_torrent*
-tr_torrentNext( tr_session * session, tr_torrent * current )
+tr_torrentNext (tr_session * session, tr_torrent * current)
 {
     return current ? current->next : session->torrentList;
 }
 
 /* what piece index is this block in? */
 static inline tr_piece_index_t
-tr_torBlockPiece( const tr_torrent * tor, const tr_block_index_t block )
+tr_torBlockPiece (const tr_torrent * tor, const tr_block_index_t block)
 {
     return block / tor->blockCountInPiece;
 }
 
 /* how many bytes are in this piece? */
 static inline uint32_t
-tr_torPieceCountBytes( const tr_torrent * tor, const tr_piece_index_t piece )
+tr_torPieceCountBytes (const tr_torrent * tor, const tr_piece_index_t piece)
 {
     return piece + 1 == tor->info.pieceCount ? tor->lastPieceSize
                                              : tor->info.pieceSize;
@@ -294,63 +294,63 @@ tr_torPieceCountBytes( const tr_torrent * tor, const tr_piece_index_t piece )
 
 /* how many bytes are in this block? */
 static inline uint32_t
-tr_torBlockCountBytes( const tr_torrent * tor, const tr_block_index_t block )
+tr_torBlockCountBytes (const tr_torrent * tor, const tr_block_index_t block)
 {
     return block + 1 == tor->blockCount ? tor->lastBlockSize
                                         : tor->blockSize;
 }
 
-static inline void tr_torrentLock( const tr_torrent * tor )
+static inline void tr_torrentLock (const tr_torrent * tor)
 {
-    tr_sessionLock( tor->session );
+    tr_sessionLock (tor->session);
 }
 
-static inline bool tr_torrentIsLocked( const tr_torrent * tor )
+static inline bool tr_torrentIsLocked (const tr_torrent * tor)
 {
-    return tr_sessionIsLocked( tor->session );
+    return tr_sessionIsLocked (tor->session);
 }
 
-static inline void tr_torrentUnlock( const tr_torrent * tor )
+static inline void tr_torrentUnlock (const tr_torrent * tor)
 {
-    tr_sessionUnlock( tor->session );
+    tr_sessionUnlock (tor->session);
 }
 
 static inline bool
-tr_torrentExists( const tr_session * session, const uint8_t *   torrentHash )
+tr_torrentExists (const tr_session * session, const uint8_t *   torrentHash)
 {
-    return tr_torrentFindFromHash( (tr_session*)session, torrentHash ) != NULL;
+    return tr_torrentFindFromHash ((tr_session*)session, torrentHash) != NULL;
 }
 
 static inline bool
-tr_torrentIsSeed( const tr_torrent * tor )
+tr_torrentIsSeed (const tr_torrent * tor)
 {
     return tor->completeness != TR_LEECH;
 }
 
-static inline bool tr_torrentIsPrivate( const tr_torrent * tor )
+static inline bool tr_torrentIsPrivate (const tr_torrent * tor)
 {
-    return ( tor != NULL ) && tor->info.isPrivate;
+    return (tor != NULL) && tor->info.isPrivate;
 }
 
-static inline bool tr_torrentAllowsPex( const tr_torrent * tor )
+static inline bool tr_torrentAllowsPex (const tr_torrent * tor)
 {
-    return ( tor != NULL )
-        && ( tor->session->isPexEnabled )
-        && ( !tr_torrentIsPrivate( tor ) );
+    return (tor != NULL)
+        && (tor->session->isPexEnabled)
+        && (!tr_torrentIsPrivate (tor));
 }
 
-static inline bool tr_torrentAllowsDHT( const tr_torrent * tor )
+static inline bool tr_torrentAllowsDHT (const tr_torrent * tor)
 {
-    return ( tor != NULL )
-        && ( tr_sessionAllowsDHT( tor->session ) )
-        && ( !tr_torrentIsPrivate( tor ) );
+    return (tor != NULL)
+        && (tr_sessionAllowsDHT (tor->session))
+        && (!tr_torrentIsPrivate (tor));
 }
 
-static inline bool tr_torrentAllowsLPD( const tr_torrent * tor )
+static inline bool tr_torrentAllowsLPD (const tr_torrent * tor)
 {
-    return ( tor != NULL )
-        && ( tr_sessionAllowsLPD( tor->session ) )
-        && ( !tr_torrentIsPrivate( tor ) );
+    return (tor != NULL)
+        && (tr_sessionAllowsLPD (tor->session))
+        && (!tr_torrentIsPrivate (tor));
 }
 
 /***
@@ -362,35 +362,35 @@ enum
     TORRENT_MAGIC_NUMBER = 95549
 };
 
-static inline bool tr_isTorrent( const tr_torrent * tor )
+static inline bool tr_isTorrent (const tr_torrent * tor)
 {
-    return ( tor != NULL )
-        && ( tor->magicNumber == TORRENT_MAGIC_NUMBER )
-        && ( tr_isSession( tor->session ) );
+    return (tor != NULL)
+        && (tor->magicNumber == TORRENT_MAGIC_NUMBER)
+        && (tr_isSession (tor->session));
 }
 
 /* set a flag indicating that the torrent's .resume file
  * needs to be saved when the torrent is closed */
 static inline
-void tr_torrentSetDirty( tr_torrent * tor )
+void tr_torrentSetDirty (tr_torrent * tor)
 {
-    assert( tr_isTorrent( tor ) );
+    assert (tr_isTorrent (tor));
 
     tor->isDirty = true;
 }
 
-uint32_t tr_getBlockSize( uint32_t pieceSize );
+uint32_t tr_getBlockSize (uint32_t pieceSize);
 
 /**
  * Tell the tr_torrent that one of its files has become complete
  */
-void tr_torrentFileCompleted( tr_torrent * tor, tr_file_index_t fileNo );
+void tr_torrentFileCompleted (tr_torrent * tor, tr_file_index_t fileNo);
 
 
 /**
- * @brief Like tr_torrentFindFile(), but splits the filename into base and subpath;
+ * @brief Like tr_torrentFindFile (), but splits the filename into base and subpath;
  *
- * If the file is found, "tr_buildPath( base, subpath, NULL )"
+ * If the file is found, "tr_buildPath (base, subpath, NULL)"
  * will generate the complete filename.
  *
  * @return true if the file is found, false otherwise.
@@ -400,50 +400,50 @@ void tr_torrentFileCompleted( tr_torrent * tor, tr_file_index_t fileNo );
  * @param subpath on success, this pointer is assigned a newly-allocated
  *                string holding the second half of the filename.
  */
-bool tr_torrentFindFile2( const tr_torrent *, tr_file_index_t fileNo,
-                          const char ** base, char ** subpath, time_t * mtime );
+bool tr_torrentFindFile2 (const tr_torrent *, tr_file_index_t fileNo,
+                          const char ** base, char ** subpath, time_t * mtime);
 
 
 /* Returns a newly-allocated version of the tr_file.name string
  * that's been modified to denote that it's not a complete file yet.
  * In the current implementation this is done by appending ".part"
  * a la Firefox. */
-char* tr_torrentBuildPartial( const tr_torrent *, tr_file_index_t fileNo );
+char* tr_torrentBuildPartial (const tr_torrent *, tr_file_index_t fileNo);
 
 /* for when the info dict has been fundamentally changed wrt files,
  * piece size, etc. such as in BEP 9 where peers exchange metadata */
-void tr_torrentGotNewInfoDict( tr_torrent * tor );
+void tr_torrentGotNewInfoDict (tr_torrent * tor);
 
-void tr_torrentSetSpeedLimit_Bps  ( tr_torrent *, tr_direction, unsigned int Bps );
-unsigned int tr_torrentGetSpeedLimit_Bps  ( const tr_torrent *, tr_direction );
+void tr_torrentSetSpeedLimit_Bps (tr_torrent *, tr_direction, unsigned int Bps);
+unsigned int tr_torrentGetSpeedLimit_Bps (const tr_torrent *, tr_direction);
 
 /**
  * @return true if this piece needs to be tested
  */
-bool tr_torrentPieceNeedsCheck( const tr_torrent * tor, tr_piece_index_t pieceIndex );
+bool tr_torrentPieceNeedsCheck (const tr_torrent * tor, tr_piece_index_t pieceIndex);
 
 /**
  * @brief Test a piece against its info dict checksum
  * @return true if the piece's passes the checksum test
  */
-bool tr_torrentCheckPiece( tr_torrent * tor, tr_piece_index_t pieceIndex );
+bool tr_torrentCheckPiece (tr_torrent * tor, tr_piece_index_t pieceIndex);
 
-time_t tr_torrentGetFileMTime( const tr_torrent * tor, tr_file_index_t i );
+time_t tr_torrentGetFileMTime (const tr_torrent * tor, tr_file_index_t i);
 
-uint64_t tr_torrentGetCurrentSizeOnDisk( const tr_torrent * tor );
+uint64_t tr_torrentGetCurrentSizeOnDisk (const tr_torrent * tor);
 
-bool tr_torrentIsStalled( const tr_torrent * tor );
+bool tr_torrentIsStalled (const tr_torrent * tor);
 
 static inline bool
-tr_torrentIsQueued( const tr_torrent * tor )
+tr_torrentIsQueued (const tr_torrent * tor)
 {
     return tor->isQueued;
 }
 
 static inline tr_direction
-tr_torrentGetQueueDirection( const tr_torrent * tor )
+tr_torrentGetQueueDirection (const tr_torrent * tor)
 {
-    return tr_torrentIsSeed( tor ) ? TR_UP : TR_DOWN;
+    return tr_torrentIsSeed (tor) ? TR_UP : TR_DOWN;
 }
 
 #endif
diff --git a/libtransmission/tr-dht.c b/libtransmission/tr-dht.c
index d4a8e7a7f..c076f6c0e 100644
--- a/libtransmission/tr-dht.c
+++ b/libtransmission/tr-dht.c
@@ -26,20 +26,20 @@
 /* ansi */
 #include <errno.h>
 #include <stdio.h>
-#include <string.h> /* memcpy(), memset(), memchr(), strlen() */
-#include <stdlib.h> /* atoi() */
+#include <string.h> /* memcpy (), memset (), memchr (), strlen () */
+#include <stdlib.h> /* atoi () */
 
 /* posix */
 #include <signal.h> /* sig_atomic_t */
 #include <sys/time.h>
-#include <unistd.h> /* close() */
+#include <unistd.h> /* close () */
 #ifdef WIN32
   #include <inttypes.h>
-  #define _WIN32_WINNT  0x0501	/* freeaddrinfo(),getaddrinfo(),getnameinfo() */
+  #define _WIN32_WINNT  0x0501	/* freeaddrinfo (),getaddrinfo (),getnameinfo () */
   #include <ws2tcpip.h>
 #else
   #include <sys/types.h>
-  #include <sys/socket.h> /* socket(), bind() */
+  #include <sys/socket.h> /* socket (), bind () */
   #include <netdb.h>
   #include <netinet/in.h> /* sockaddr_in */
 #endif
@@ -53,19 +53,19 @@
 #include "bencode.h"
 #include "crypto.h"
 #include "net.h"
-#include "peer-mgr.h" /* tr_peerMgrCompactToPex() */
-#include "platform.h" /* tr_threadNew() */
+#include "peer-mgr.h" /* tr_peerMgrCompactToPex () */
+#include "platform.h" /* tr_threadNew () */
 #include "session.h"
-#include "torrent.h" /* tr_torrentFindFromHash() */
+#include "torrent.h" /* tr_torrentFindFromHash () */
 #include "tr-dht.h"
-#include "trevent.h" /* tr_runInEventThread() */
+#include "trevent.h" /* tr_runInEventThread () */
 #include "utils.h"
 
 static struct event *dht_timer = NULL;
 static unsigned char myid[20];
 static tr_session *session = NULL;
 
-static void timer_callback(int s, short type, void *ignore);
+static void timer_callback (int s, short type, void *ignore);
 
 struct bootstrap_closure {
     tr_session *session;
@@ -75,191 +75,191 @@ struct bootstrap_closure {
 };
 
 static int
-bootstrap_done( tr_session *session, int af )
+bootstrap_done (tr_session *session, int af)
 {
     int status;
 
-    if(af == 0)
+    if (af == 0)
         return
-            bootstrap_done(session, AF_INET) &&
-            bootstrap_done(session, AF_INET6);
+            bootstrap_done (session, AF_INET) &&
+            bootstrap_done (session, AF_INET6);
 
-    status = tr_dhtStatus(session, af, NULL);
+    status = tr_dhtStatus (session, af, NULL);
     return status == TR_DHT_STOPPED || status >= TR_DHT_FIREWALLED;
 }
 
 static void
-nap( int roughly_sec )
+nap (int roughly_sec)
 {
     const int roughly_msec = roughly_sec * 1000;
-    const int msec = roughly_msec/2 + tr_cryptoWeakRandInt(roughly_msec);
-    tr_wait_msec( msec );
+    const int msec = roughly_msec/2 + tr_cryptoWeakRandInt (roughly_msec);
+    tr_wait_msec (msec);
 }
 
 static int
-bootstrap_af(tr_session *session)
+bootstrap_af (tr_session *session)
 {
-    if( bootstrap_done(session, AF_INET6) )
+    if (bootstrap_done (session, AF_INET6))
         return AF_INET;
-    else if ( bootstrap_done(session, AF_INET) )
+    else if (bootstrap_done (session, AF_INET))
         return AF_INET6;
     else
         return 0;
 }
 
 static void
-bootstrap_from_name( const char *name, tr_port port, int af )
+bootstrap_from_name (const char *name, tr_port port, int af)
 {
     struct addrinfo hints, *info, *infop;
     char pp[10];
     int rc;
 
-    memset(&hints, 0, sizeof(hints));
+    memset (&hints, 0, sizeof (hints));
     hints.ai_socktype = SOCK_DGRAM;
     hints.ai_family = af;
     /* No, just passing p + 1 to gai won't work. */
-    tr_snprintf(pp, sizeof(pp), "%d", (int)port);
+    tr_snprintf (pp, sizeof (pp), "%d", (int)port);
 
-    rc = getaddrinfo(name, pp, &hints, &info);
-    if(rc != 0) {
-        tr_nerr("DHT", "%s:%s: %s", name, pp, gai_strerror(rc));
+    rc = getaddrinfo (name, pp, &hints, &info);
+    if (rc != 0) {
+        tr_nerr ("DHT", "%s:%s: %s", name, pp, gai_strerror (rc));
         return;
     }
 
     infop = info;
-    while(infop) {
-        dht_ping_node(infop->ai_addr, infop->ai_addrlen);
+    while (infop) {
+        dht_ping_node (infop->ai_addr, infop->ai_addrlen);
 
-        nap(15);
+        nap (15);
 
-        if(bootstrap_done(session, af))
+        if (bootstrap_done (session, af))
             break;
         infop = infop->ai_next;
     }
-    freeaddrinfo(info);
+    freeaddrinfo (info);
 }
 
 static void
-dht_bootstrap(void *closure)
+dht_bootstrap (void *closure)
 {
     struct bootstrap_closure *cl = closure;
     int i;
     int num = cl->len / 6, num6 = cl->len6 / 18;
 
-    if(session != cl->session)
+    if (session != cl->session)
         return;
 
-    if(cl->len > 0)
-        tr_ninf( "DHT", "Bootstrapping from %d IPv4 nodes", num );
+    if (cl->len > 0)
+        tr_ninf ("DHT", "Bootstrapping from %d IPv4 nodes", num);
 
-    if(cl->len6 > 0)
-        tr_ninf( "DHT", "Bootstrapping from %d IPv6 nodes", num6 );
+    if (cl->len6 > 0)
+        tr_ninf ("DHT", "Bootstrapping from %d IPv6 nodes", num6);
 
 
-    for(i = 0; i < MAX(num, num6); i++) {
-        if( i < num && !bootstrap_done(cl->session, AF_INET) ) {
+    for (i = 0; i < MAX (num, num6); i++) {
+        if (i < num && !bootstrap_done (cl->session, AF_INET)) {
             tr_port port;
             struct tr_address addr;
 
-            memset(&addr, 0, sizeof(addr));
+            memset (&addr, 0, sizeof (addr));
             addr.type = TR_AF_INET;
-            memcpy(&addr.addr.addr4, &cl->nodes[i * 6], 4);
-            memcpy(&port, &cl->nodes[i * 6 + 4], 2);
-            port = ntohs(port);
-            tr_dhtAddNode(cl->session, &addr, port, 1);
+            memcpy (&addr.addr.addr4, &cl->nodes[i * 6], 4);
+            memcpy (&port, &cl->nodes[i * 6 + 4], 2);
+            port = ntohs (port);
+            tr_dhtAddNode (cl->session, &addr, port, 1);
         }
-        if( i < num6 && !bootstrap_done(cl->session, AF_INET6) ) {
+        if (i < num6 && !bootstrap_done (cl->session, AF_INET6)) {
             tr_port port;
             struct tr_address addr;
 
-            memset(&addr, 0, sizeof(addr));
+            memset (&addr, 0, sizeof (addr));
             addr.type = TR_AF_INET6;
-            memcpy(&addr.addr.addr6, &cl->nodes6[i * 18], 16);
-            memcpy(&port, &cl->nodes6[i * 18 + 16], 2);
-            port = ntohs(port);
-            tr_dhtAddNode(cl->session, &addr, port, 1);
+            memcpy (&addr.addr.addr6, &cl->nodes6[i * 18], 16);
+            memcpy (&port, &cl->nodes6[i * 18 + 16], 2);
+            port = ntohs (port);
+            tr_dhtAddNode (cl->session, &addr, port, 1);
         }
 
         /* Our DHT code is able to take up to 9 nodes in a row without
            dropping any. After that, it takes some time to split buckets.
            So ping the first 8 nodes quickly, then slow down. */
-        if(i < 8)
-            nap(2);
+        if (i < 8)
+            nap (2);
         else
-            nap(15);
+            nap (15);
 
-        if(bootstrap_done( session, 0 ))
+        if (bootstrap_done (session, 0))
             break;
     }
 
-    if(!bootstrap_done(cl->session, 0)) {
+    if (!bootstrap_done (cl->session, 0)) {
         char *bootstrap_file;
         FILE *f = NULL;
 
         bootstrap_file =
-            tr_buildPath(cl->session->configDir, "dht.bootstrap", NULL);
+            tr_buildPath (cl->session->configDir, "dht.bootstrap", NULL);
 
-        if(bootstrap_file)
-            f = fopen(bootstrap_file, "rb");
-        if(f != NULL) {
-            tr_ninf("DHT", "Attempting manual bootstrap");
-            for(;;) {
+        if (bootstrap_file)
+            f = fopen (bootstrap_file, "rb");
+        if (f != NULL) {
+            tr_ninf ("DHT", "Attempting manual bootstrap");
+            for (;;) {
                 char buf[201];
                 char *p;
                 int port = 0;
 
-                p = fgets(buf, 200, f);
-                if( p == NULL )
+                p = fgets (buf, 200, f);
+                if (p == NULL)
                     break;
 
-                p = memchr(buf, ' ', strlen(buf));
-                if(p != NULL)
-                    port = atoi(p + 1);
-                if(p == NULL || port <= 0 || port >= 0x10000) {
-                    tr_nerr("DHT", "Couldn't parse %s", buf);
+                p = memchr (buf, ' ', strlen (buf));
+                if (p != NULL)
+                    port = atoi (p + 1);
+                if (p == NULL || port <= 0 || port >= 0x10000) {
+                    tr_nerr ("DHT", "Couldn't parse %s", buf);
                     continue;
                 }
 
                 *p = '\0';
 
-                bootstrap_from_name( buf, port, bootstrap_af(session) );
+                bootstrap_from_name (buf, port, bootstrap_af (session));
 
-                if(bootstrap_done(cl->session, 0))
+                if (bootstrap_done (cl->session, 0))
                     break;
             }
-            fclose( f );
+            fclose (f);
         }
 
-        tr_free( bootstrap_file );
+        tr_free (bootstrap_file);
     }
 
-    if(!bootstrap_done(cl->session, 0)) {
-        for(i = 0; i < 6; i++) {
+    if (!bootstrap_done (cl->session, 0)) {
+        for (i = 0; i < 6; i++) {
             /* We don't want to abuse our bootstrap nodes, so be very
                slow.  The initial wait is to give other nodes a chance
                to contact us before we attempt to contact a bootstrap
                node, for example because we've just been restarted. */
-            nap(40);
-            if(bootstrap_done(cl->session, 0))
+            nap (40);
+            if (bootstrap_done (cl->session, 0))
                 break;
-            if(i == 0)
-                tr_ninf("DHT",
+            if (i == 0)
+                tr_ninf ("DHT",
                         "Attempting bootstrap from dht.transmissionbt.com");
-            bootstrap_from_name( "dht.transmissionbt.com", 6881,
-                                 bootstrap_af(session) );
+            bootstrap_from_name ("dht.transmissionbt.com", 6881,
+                                 bootstrap_af (session));
         }
     }
 
-    if( cl->nodes )
-        tr_free( cl->nodes );
-    if( cl->nodes6 )
-        tr_free( cl->nodes6 );
-    tr_free( closure );
-    tr_ndbg( "DHT", "Finished bootstrapping" );
+    if (cl->nodes)
+        tr_free (cl->nodes);
+    if (cl->nodes6)
+        tr_free (cl->nodes6);
+    tr_free (closure);
+    tr_ndbg ("DHT", "Finished bootstrapping");
 }
 
 int
-tr_dhtInit(tr_session *ss)
+tr_dhtInit (tr_session *ss)
 {
     tr_benc benc;
     int rc;
@@ -270,91 +270,91 @@ tr_dhtInit(tr_session *ss)
     size_t len, len6;
     struct bootstrap_closure * cl;
 
-    if( session ) /* already initialized */
+    if (session) /* already initialized */
         return -1;
 
-    tr_ndbg( "DHT", "Initializing DHT" );
+    tr_ndbg ("DHT", "Initializing DHT");
 
-    if( getenv( "TR_DHT_VERBOSE" ) != NULL )
+    if (getenv ("TR_DHT_VERBOSE") != NULL)
         dht_debug = stderr;
 
-    dat_file = tr_buildPath( ss->configDir, "dht.dat", NULL );
-    rc = tr_bencLoadFile( &benc, TR_FMT_BENC, dat_file );
-    tr_free( dat_file );
-    if(rc == 0) {
-        have_id = tr_bencDictFindRaw(&benc, "id", &raw, &len);
-        if( have_id && len==20 )
-            memcpy( myid, raw, len );
-        if( ss->udp_socket >= 0 &&
-            tr_bencDictFindRaw( &benc, "nodes", &raw, &len ) && !(len%6) ) {
-                nodes = tr_memdup( raw, len );
+    dat_file = tr_buildPath (ss->configDir, "dht.dat", NULL);
+    rc = tr_bencLoadFile (&benc, TR_FMT_BENC, dat_file);
+    tr_free (dat_file);
+    if (rc == 0) {
+        have_id = tr_bencDictFindRaw (&benc, "id", &raw, &len);
+        if (have_id && len==20)
+            memcpy (myid, raw, len);
+        if (ss->udp_socket >= 0 &&
+            tr_bencDictFindRaw (&benc, "nodes", &raw, &len) && ! (len%6)) {
+                nodes = tr_memdup (raw, len);
         }
-        if( ss->udp6_socket > 0 &&
-            tr_bencDictFindRaw( &benc, "nodes6", &raw, &len6 ) && !(len6%18) ) {
-            nodes6 = tr_memdup( raw, len6 );
+        if (ss->udp6_socket > 0 &&
+            tr_bencDictFindRaw (&benc, "nodes6", &raw, &len6) && ! (len6%18)) {
+            nodes6 = tr_memdup (raw, len6);
         }
-        tr_bencFree( &benc );
+        tr_bencFree (&benc);
     }
 
-    if(nodes == NULL)
+    if (nodes == NULL)
         len = 0;
-    if(nodes6 == NULL)
+    if (nodes6 == NULL)
         len6 = 0;
 
-    if( have_id )
-        tr_ninf( "DHT", "Reusing old id" );
+    if (have_id)
+        tr_ninf ("DHT", "Reusing old id");
     else {
         /* Note that DHT ids need to be distributed uniformly,
          * so it should be something truly random. */
-        tr_ninf( "DHT", "Generating new id" );
-        tr_cryptoRandBuf( myid, 20 );
+        tr_ninf ("DHT", "Generating new id");
+        tr_cryptoRandBuf (myid, 20);
     }
 
-    rc = dht_init( ss->udp_socket, ss->udp6_socket, myid, NULL );
-    if( rc < 0 )
+    rc = dht_init (ss->udp_socket, ss->udp6_socket, myid, NULL);
+    if (rc < 0)
         goto fail;
 
     session = ss;
 
-    cl = tr_new( struct bootstrap_closure, 1 );
+    cl = tr_new (struct bootstrap_closure, 1);
     cl->session = session;
     cl->nodes = nodes;
     cl->nodes6 = nodes6;
     cl->len = len;
     cl->len6 = len6;
-    tr_threadNew( dht_bootstrap, cl );
+    tr_threadNew (dht_bootstrap, cl);
 
-    dht_timer = evtimer_new( session->event_base, timer_callback, session );
-    tr_timerAdd( dht_timer, 0, tr_cryptoWeakRandInt( 1000000 ) );
+    dht_timer = evtimer_new (session->event_base, timer_callback, session);
+    tr_timerAdd (dht_timer, 0, tr_cryptoWeakRandInt (1000000));
 
-    tr_ndbg( "DHT", "DHT initialized" );
+    tr_ndbg ("DHT", "DHT initialized");
 
     return 1;
 
  fail:
-    tr_ndbg( "DHT", "DHT initialization failed (errno = %d)", errno );
+    tr_ndbg ("DHT", "DHT initialization failed (errno = %d)", errno);
     session = NULL;
     return -1;
 }
 
 void
-tr_dhtUninit(tr_session *ss)
+tr_dhtUninit (tr_session *ss)
 {
-    if(session != ss)
+    if (session != ss)
         return;
 
-    tr_ndbg( "DHT", "Uninitializing DHT" );
+    tr_ndbg ("DHT", "Uninitializing DHT");
 
-    if( dht_timer != NULL ) {
-        event_free( dht_timer );
+    if (dht_timer != NULL) {
+        event_free (dht_timer);
         dht_timer = NULL;
     }
 
     /* Since we only save known good nodes, avoid erasing older data if we
        don't know enough nodes. */
-    if ((tr_dhtStatus(ss, AF_INET, NULL) < TR_DHT_FIREWALLED) &&
-        (tr_dhtStatus(ss, AF_INET6, NULL) < TR_DHT_FIREWALLED)) {
-        tr_ninf( "DHT", "Not saving nodes, DHT not ready" );
+    if ((tr_dhtStatus (ss, AF_INET, NULL) < TR_DHT_FIREWALLED) &&
+      (tr_dhtStatus (ss, AF_INET6, NULL) < TR_DHT_FIREWALLED)) {
+        tr_ninf ("DHT", "Not saving nodes, DHT not ready");
     } else {
         tr_benc benc;
         struct sockaddr_in sins[300];
@@ -362,44 +362,44 @@ tr_dhtUninit(tr_session *ss)
         char compact[300 * 6], compact6[300 * 18];
         char *dat_file;
         int i, j, num = 300, num6 = 300;
-        int n = dht_get_nodes(sins, &num, sins6, &num6);
+        int n = dht_get_nodes (sins, &num, sins6, &num6);
 
-        tr_ninf( "DHT", "Saving %d (%d + %d) nodes", n, num, num6 );
+        tr_ninf ("DHT", "Saving %d (%d + %d) nodes", n, num, num6);
 
         j = 0;
-        for( i=0; i<num; ++i ) {
-            memcpy( compact + j, &sins[i].sin_addr, 4 );
-            memcpy( compact + j + 4, &sins[i].sin_port, 2 );
+        for (i=0; i<num; ++i) {
+            memcpy (compact + j, &sins[i].sin_addr, 4);
+            memcpy (compact + j + 4, &sins[i].sin_port, 2);
             j += 6;
         }
         j = 0;
-        for( i=0; i<num6; ++i ) {
-            memcpy( compact6 + j, &sins6[i].sin6_addr, 16 );
-            memcpy( compact6 + j + 16, &sins6[i].sin6_port, 2 );
+        for (i=0; i<num6; ++i) {
+            memcpy (compact6 + j, &sins6[i].sin6_addr, 16);
+            memcpy (compact6 + j + 16, &sins6[i].sin6_port, 2);
             j += 18;
         }
-        tr_bencInitDict( &benc, 3 );
-        tr_bencDictAddRaw( &benc, "id", myid, 20 );
-        if(num > 0)
-            tr_bencDictAddRaw( &benc, "nodes", compact, num * 6 );
-        if(num6 > 0)
-            tr_bencDictAddRaw( &benc, "nodes6", compact6, num6 * 18 );
-        dat_file = tr_buildPath( ss->configDir, "dht.dat", NULL );
-        tr_bencToFile( &benc, TR_FMT_BENC, dat_file );
-        tr_bencFree( &benc );
-        tr_free( dat_file );
+        tr_bencInitDict (&benc, 3);
+        tr_bencDictAddRaw (&benc, "id", myid, 20);
+        if (num > 0)
+            tr_bencDictAddRaw (&benc, "nodes", compact, num * 6);
+        if (num6 > 0)
+            tr_bencDictAddRaw (&benc, "nodes6", compact6, num6 * 18);
+        dat_file = tr_buildPath (ss->configDir, "dht.dat", NULL);
+        tr_bencToFile (&benc, TR_FMT_BENC, dat_file);
+        tr_bencFree (&benc);
+        tr_free (dat_file);
     }
 
-    dht_uninit();
-    tr_ndbg("DHT", "Done uninitializing DHT");
+    dht_uninit ();
+    tr_ndbg ("DHT", "Done uninitializing DHT");
 
     session = NULL;
 }
 
 bool
-tr_dhtEnabled( const tr_session * ss )
+tr_dhtEnabled (const tr_session * ss)
 {
-    return ss && ( ss == session );
+    return ss && (ss == session);
 }
 
 struct getstatus_closure
@@ -410,88 +410,88 @@ struct getstatus_closure
 };
 
 static void
-getstatus( void * cl )
+getstatus (void * cl)
 {
     struct getstatus_closure * closure = cl;
     int good, dubious, incoming;
 
-    dht_nodes( closure->af, &good, &dubious, NULL, &incoming );
+    dht_nodes (closure->af, &good, &dubious, NULL, &incoming);
 
     closure->count = good + dubious;
 
-    if( good < 4 || good + dubious <= 8 )
+    if (good < 4 || good + dubious <= 8)
         closure->status = TR_DHT_BROKEN;
-    else if( good < 40 )
+    else if (good < 40)
         closure->status = TR_DHT_POOR;
-    else if( incoming < 8 )
+    else if (incoming < 8)
         closure->status = TR_DHT_FIREWALLED;
     else
         closure->status = TR_DHT_GOOD;
 }
 
 int
-tr_dhtStatus( tr_session * session, int af, int * nodes_return )
+tr_dhtStatus (tr_session * session, int af, int * nodes_return)
 {
     struct getstatus_closure closure = { af, -1, -1 };
 
-    if( !tr_dhtEnabled( session ) ||
-        (af == AF_INET && session->udp_socket < 0) ||
-        (af == AF_INET6 && session->udp6_socket < 0) ) {
-        if( nodes_return )
+    if (!tr_dhtEnabled (session) ||
+      (af == AF_INET && session->udp_socket < 0) ||
+      (af == AF_INET6 && session->udp6_socket < 0)) {
+        if (nodes_return)
             *nodes_return = 0;
         return TR_DHT_STOPPED;
     }
 
-    tr_runInEventThread( session, getstatus, &closure );
-    while( closure.status < 0 )
-        tr_wait_msec( 50 /*msec*/ );
+    tr_runInEventThread (session, getstatus, &closure);
+    while (closure.status < 0)
+        tr_wait_msec (50 /*msec*/);
 
-    if( nodes_return )
+    if (nodes_return)
         *nodes_return = closure.count;
 
     return closure.status;
 }
 
 tr_port
-tr_dhtPort( tr_session *ss )
+tr_dhtPort (tr_session *ss)
 {
-    return tr_dhtEnabled( ss ) ? ss->udp_port : 0;
+    return tr_dhtEnabled (ss) ? ss->udp_port : 0;
 }
 
 int
-tr_dhtAddNode( tr_session       * ss,
+tr_dhtAddNode (tr_session       * ss,
                const tr_address * address,
                tr_port            port,
-               bool            bootstrap )
+               bool            bootstrap)
 {
     int af = address->type == TR_AF_INET ? AF_INET : AF_INET6;
 
-    if( !tr_dhtEnabled( ss ) )
+    if (!tr_dhtEnabled (ss))
         return 0;
 
     /* Since we don't want to abuse our bootstrap nodes,
      * we don't ping them if the DHT is in a good state. */
 
-    if(bootstrap) {
-        if(tr_dhtStatus(ss, af, NULL) >= TR_DHT_FIREWALLED)
+    if (bootstrap) {
+        if (tr_dhtStatus (ss, af, NULL) >= TR_DHT_FIREWALLED)
             return 0;
     }
 
-    if( address->type == TR_AF_INET ) {
+    if (address->type == TR_AF_INET) {
         struct sockaddr_in sin;
-        memset(&sin, 0, sizeof(sin));
+        memset (&sin, 0, sizeof (sin));
         sin.sin_family = AF_INET;
-        memcpy(&sin.sin_addr, &address->addr.addr4, 4);
-        sin.sin_port = htons(port);
-        dht_ping_node((struct sockaddr*)&sin, sizeof(sin));
+        memcpy (&sin.sin_addr, &address->addr.addr4, 4);
+        sin.sin_port = htons (port);
+        dht_ping_node ((struct sockaddr*)&sin, sizeof (sin));
         return 1;
-    } else if( address->type == TR_AF_INET6 ) {
+    } else if (address->type == TR_AF_INET6) {
         struct sockaddr_in6 sin6;
-        memset(&sin6, 0, sizeof(sin6));
+        memset (&sin6, 0, sizeof (sin6));
         sin6.sin6_family = AF_INET6;
-        memcpy(&sin6.sin6_addr, &address->addr.addr6, 16);
-        sin6.sin6_port = htons(port);
-        dht_ping_node((struct sockaddr*)&sin6, sizeof(sin6));
+        memcpy (&sin6.sin6_addr, &address->addr.addr6, 16);
+        sin6.sin6_port = htons (port);
+        dht_ping_node ((struct sockaddr*)&sin6, sizeof (sin6));
         return 1;
     }
 
@@ -499,9 +499,9 @@ tr_dhtAddNode( tr_session       * ss,
 }
 
 const char *
-tr_dhtPrintableStatus(int status)
+tr_dhtPrintableStatus (int status)
 {
-    switch(status) {
+    switch (status) {
     case TR_DHT_STOPPED: return "stopped";
     case TR_DHT_BROKEN: return "broken";
     case TR_DHT_POOR: return "poor";
@@ -512,38 +512,38 @@ tr_dhtPrintableStatus(int status)
 }
 
 static void
-callback( void *ignore UNUSED, int event,
-          unsigned char *info_hash, void *data, size_t data_len )
+callback (void *ignore UNUSED, int event,
+          unsigned char *info_hash, void *data, size_t data_len)
 {
-    if( event == DHT_EVENT_VALUES || event == DHT_EVENT_VALUES6 ) {
+    if (event == DHT_EVENT_VALUES || event == DHT_EVENT_VALUES6) {
         tr_torrent *tor;
-        tr_sessionLock( session );
-        tor = tr_torrentFindFromHash( session, info_hash );
-        if( tor && tr_torrentAllowsDHT( tor ))
+        tr_sessionLock (session);
+        tor = tr_torrentFindFromHash (session, info_hash);
+        if (tor && tr_torrentAllowsDHT (tor))
         {
             size_t i, n;
             tr_pex * pex;
-            if( event == DHT_EVENT_VALUES )
-                pex = tr_peerMgrCompactToPex(data, data_len, NULL, 0, &n);
+            if (event == DHT_EVENT_VALUES)
+                pex = tr_peerMgrCompactToPex (data, data_len, NULL, 0, &n);
             else
-                pex = tr_peerMgrCompact6ToPex(data, data_len, NULL, 0, &n);
-            for( i=0; i<n; ++i )
-                tr_peerMgrAddPex( tor, TR_PEER_FROM_DHT, pex+i, -1 );
-            tr_free(pex);
-            tr_tordbg(tor, "Learned %d %s peers from DHT",
-                      (int)n,
+                pex = tr_peerMgrCompact6ToPex (data, data_len, NULL, 0, &n);
+            for (i=0; i<n; ++i)
+                tr_peerMgrAddPex (tor, TR_PEER_FROM_DHT, pex+i, -1);
+            tr_free (pex);
+            tr_tordbg (tor, "Learned %d %s peers from DHT",
+                    (int)n,
                       event == DHT_EVENT_VALUES6 ? "IPv6" : "IPv4");
         }
-        tr_sessionUnlock( session );
-    } else if( event == DHT_EVENT_SEARCH_DONE ||
+        tr_sessionUnlock (session);
+    } else if (event == DHT_EVENT_SEARCH_DONE ||
                event == DHT_EVENT_SEARCH_DONE6) {
-        tr_torrent * tor = tr_torrentFindFromHash( session, info_hash );
-        if( tor ) {
-            if( event == DHT_EVENT_SEARCH_DONE ) {
-                tr_torinf(tor, "IPv4 DHT announce done");
+        tr_torrent * tor = tr_torrentFindFromHash (session, info_hash);
+        if (tor) {
+            if (event == DHT_EVENT_SEARCH_DONE) {
+                tr_torinf (tor, "IPv4 DHT announce done");
                 tor->dhtAnnounceInProgress = 0;
             } else {
-                tr_torinf(tor, "IPv6 DHT announce done");
+                tr_torinf (tor, "IPv6 DHT announce done");
                 tor->dhtAnnounce6InProgress = 0;
             }
         }
@@ -551,114 +551,114 @@ callback( void *ignore UNUSED, int event,
 }
 
 static int
-tr_dhtAnnounce(tr_torrent *tor, int af, bool announce)
+tr_dhtAnnounce (tr_torrent *tor, int af, bool announce)
 {
     int rc, status, numnodes, ret = 0;
 
-    if( !tr_torrentAllowsDHT( tor ) )
+    if (!tr_torrentAllowsDHT (tor))
         return -1;
 
-    status = tr_dhtStatus( tor->session, af, &numnodes );
+    status = tr_dhtStatus (tor->session, af, &numnodes);
 
-    if( status == TR_DHT_STOPPED ) {
+    if (status == TR_DHT_STOPPED) {
         /* Let the caller believe everything is all right. */
         return 1;
     }
 
-    if(status >= TR_DHT_POOR ) {
-        rc = dht_search( tor->info.hash,
-                         announce ? tr_sessionGetPeerPort(session) : 0,
+    if (status >= TR_DHT_POOR) {
+        rc = dht_search (tor->info.hash,
+                         announce ? tr_sessionGetPeerPort (session) : 0,
                          af, callback, NULL);
-        if( rc >= 1 ) {
-            tr_torinf(tor, "Starting %s DHT announce (%s, %d nodes)",
+        if (rc >= 1) {
+            tr_torinf (tor, "Starting %s DHT announce (%s, %d nodes)",
                       af == AF_INET6 ? "IPv6" : "IPv4",
-                      tr_dhtPrintableStatus(status), numnodes);
-            if(af == AF_INET)
+                      tr_dhtPrintableStatus (status), numnodes);
+            if (af == AF_INET)
                 tor->dhtAnnounceInProgress = true;
             else
                 tor->dhtAnnounce6InProgress = true;
             ret = 1;
         } else {
-            tr_torerr(tor, "%s DHT announce failed (%s, %d nodes): %s",
+            tr_torerr (tor, "%s DHT announce failed (%s, %d nodes): %s",
                       af == AF_INET6 ? "IPv6" : "IPv4",
-                      tr_dhtPrintableStatus(status), numnodes,
-                      tr_strerror( errno ) );
+                      tr_dhtPrintableStatus (status), numnodes,
+                      tr_strerror (errno));
         }
     } else {
-        tr_tordbg(tor, "%s DHT not ready (%s, %d nodes)",
+        tr_tordbg (tor, "%s DHT not ready (%s, %d nodes)",
                   af == AF_INET6 ? "IPv6" : "IPv4",
-                  tr_dhtPrintableStatus(status), numnodes);
+                  tr_dhtPrintableStatus (status), numnodes);
     }
 
     return ret;
 }
 
 void
-tr_dhtUpkeep( tr_session * session )
+tr_dhtUpkeep (tr_session * session)
 {
     tr_torrent * tor = NULL;
-    const time_t now = tr_time( );
+    const time_t now = tr_time ();
 
-    while(( tor = tr_torrentNext( session, tor )))
+    while ((tor = tr_torrentNext (session, tor)))
     {
-        if( !tor->isRunning || !tr_torrentAllowsDHT( tor ) )
+        if (!tor->isRunning || !tr_torrentAllowsDHT (tor))
             continue;
 
-        if( tor->dhtAnnounceAt <= now )
+        if (tor->dhtAnnounceAt <= now)
         {
-            const int rc = tr_dhtAnnounce(tor, AF_INET, 1);
+            const int rc = tr_dhtAnnounce (tor, AF_INET, 1);
 
             tor->dhtAnnounceAt = now + ((rc == 0)
-                                     ? 5 + tr_cryptoWeakRandInt( 5 )
-                                     : 25 * 60 + tr_cryptoWeakRandInt( 3*60 ));
+                                     ? 5 + tr_cryptoWeakRandInt (5)
+                                     : 25 * 60 + tr_cryptoWeakRandInt (3*60));
         }
 
-        if( tor->dhtAnnounce6At <= now )
+        if (tor->dhtAnnounce6At <= now)
         {
-            const int rc = tr_dhtAnnounce(tor, AF_INET6, 1);
+            const int rc = tr_dhtAnnounce (tor, AF_INET6, 1);
 
             tor->dhtAnnounce6At = now + ((rc == 0)
-                                      ? 5 + tr_cryptoWeakRandInt( 5 )
-                                      : 25 * 60 + tr_cryptoWeakRandInt( 3*60 ));
+                                      ? 5 + tr_cryptoWeakRandInt (5)
+                                      : 25 * 60 + tr_cryptoWeakRandInt (3*60));
         }
     }
 }
 
 void
-tr_dhtCallback(unsigned char *buf, int buflen,
+tr_dhtCallback (unsigned char *buf, int buflen,
                struct sockaddr *from, socklen_t fromlen,
-               void *sv )
+               void *sv)
 {
     time_t tosleep;
     int rc;
 
-    assert(tr_isSession(sv));
+    assert (tr_isSession (sv));
 
-    if(sv != session)
+    if (sv != session)
         return;
 
-    rc = dht_periodic( buf, buflen, from, fromlen,
+    rc = dht_periodic (buf, buflen, from, fromlen,
                        &tosleep, callback, NULL);
-    if(rc < 0) {
-        if(errno == EINTR) {
+    if (rc < 0) {
+        if (errno == EINTR) {
             tosleep = 0;
         } else {
-            tr_nerr( "DHT", "dht_periodic failed: %s", tr_strerror( errno ) );
-            if(errno == EINVAL || errno == EFAULT)
-                    abort();
+            tr_nerr ("DHT", "dht_periodic failed: %s", tr_strerror (errno));
+            if (errno == EINVAL || errno == EFAULT)
+                    abort ();
             tosleep = 1;
         }
     }
 
     /* Being slightly late is fine,
        and has the added benefit of adding some jitter. */
-    tr_timerAdd( dht_timer, tosleep, tr_cryptoWeakRandInt( 1000000 ) );
+    tr_timerAdd (dht_timer, tosleep, tr_cryptoWeakRandInt (1000000));
 }
 
 static void
-timer_callback(int s UNUSED, short type UNUSED, void *session )
+timer_callback (int s UNUSED, short type UNUSED, void *session)
 {
-    tr_dhtCallback(NULL, 0, NULL, 0, session);
+    tr_dhtCallback (NULL, 0, NULL, 0, session);
 }
 
 /* This function should return true when a node is blacklisted.  We do
@@ -668,26 +668,26 @@ timer_callback(int s UNUSED, short type UNUSED, void *session )
    redistribute it. */
 
 int
-dht_blacklisted(const struct sockaddr *sa UNUSED, int salen UNUSED)
+dht_blacklisted (const struct sockaddr *sa UNUSED, int salen UNUSED)
 {
     return 0;
 }
 
 void
-dht_hash(void *hash_return, int hash_size,
+dht_hash (void *hash_return, int hash_size,
          const void *v1, int len1,
          const void *v2, int len2,
          const void *v3, int len3)
 {
     unsigned char sha1[SHA_DIGEST_LENGTH];
-    tr_sha1( sha1, v1, len1, v2, len2, v3, len3, NULL );
-    memset( hash_return, 0, hash_size );
-    memcpy( hash_return, sha1, MIN( hash_size, SHA_DIGEST_LENGTH ) );
+    tr_sha1 (sha1, v1, len1, v2, len2, v3, len3, NULL);
+    memset (hash_return, 0, hash_size);
+    memcpy (hash_return, sha1, MIN (hash_size, SHA_DIGEST_LENGTH));
 }
 
 int
-dht_random_bytes( void * buf, size_t size )
+dht_random_bytes (void * buf, size_t size)
 {
-    tr_cryptoRandBuf( buf, size );
+    tr_cryptoRandBuf (buf, size);
     return size;
 }
diff --git a/libtransmission/tr-dht.h b/libtransmission/tr-dht.h
index 3c244ce0b..7a28e3cc6 100644
--- a/libtransmission/tr-dht.h
+++ b/libtransmission/tr-dht.h
@@ -36,14 +36,14 @@ enum
     TR_DHT_GOOD         = 4
 };
 
-int  tr_dhtInit( tr_session * );
-void tr_dhtUninit( tr_session * );
-bool tr_dhtEnabled( const tr_session * );
-tr_port tr_dhtPort ( tr_session * );
-int tr_dhtStatus( tr_session *, int af, int * setme_nodeCount );
-const char *tr_dhtPrintableStatus(int status);
-int tr_dhtAddNode( tr_session *, const tr_address *, tr_port, bool bootstrap );
-void tr_dhtUpkeep( tr_session * );
-void tr_dhtCallback(unsigned char *buf, int buflen,
+int  tr_dhtInit (tr_session *);
+void tr_dhtUninit (tr_session *);
+bool tr_dhtEnabled (const tr_session *);
+tr_port tr_dhtPort (tr_session *);
+int tr_dhtStatus (tr_session *, int af, int * setme_nodeCount);
+const char *tr_dhtPrintableStatus (int status);
+int tr_dhtAddNode (tr_session *, const tr_address *, tr_port, bool bootstrap);
+void tr_dhtUpkeep (tr_session *);
+void tr_dhtCallback (unsigned char *buf, int buflen,
                     struct sockaddr *from, socklen_t fromlen,
                     void *sv);
diff --git a/libtransmission/tr-getopt.c b/libtransmission/tr-getopt.c
index 9ea6dcec9..1734db332 100644
--- a/libtransmission/tr-getopt.c
+++ b/libtransmission/tr-getopt.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,27 +10,27 @@
  * $Id$
  */
 
-#include <ctype.h> /* isspace() */
+#include <ctype.h> /* isspace () */
 #include <stdio.h>
-#include <stdlib.h> /* exit() */
+#include <stdlib.h> /* exit () */
 #include <string.h>
 
 #include "tr-getopt.h"
 
 #ifndef MAX
- #define MAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )
+ #define MAX(a, b)(((a) > (b)) ? (a) : (b))
 #endif
 
 int tr_optind = 1;
 
 static const char*
-getArgName( const tr_option * opt )
+getArgName (const tr_option * opt)
 {
     const char * arg;
 
-    if( !opt->has_arg )
+    if (!opt->has_arg)
         arg = "";
-    else if( opt->argName )
+    else if (opt->argName)
         arg = opt->argName;
     else
         arg = "<args>";
@@ -39,75 +39,75 @@ getArgName( const tr_option * opt )
 }
 
 static int
-get_next_line_len( const char * description, int maxlen )
+get_next_line_len (const char * description, int maxlen)
 {
     int end;
-    int len = strlen( description );
+    int len = strlen (description);
 
-    if( len < maxlen )
+    if (len < maxlen)
         return len;
 
     end = maxlen < len ? maxlen : len;
-    while( ( end > 0 ) && !isspace( description[end] ) )
+    while ((end > 0) && !isspace (description[end]))
         --end;
 
     return end ? end : len;
 }
 
 static void
-getopts_usage_line( const tr_option * opt,
+getopts_usage_line (const tr_option * opt,
                     int               longWidth,
                     int               shortWidth,
-                    int               argWidth )
+                    int               argWidth)
 {
     int len;
     const char * longName   = opt->longName ? opt->longName : "";
     const char * shortName  = opt->shortName ? opt->shortName : "";
-    const char * arg        = getArgName( opt );
+    const char * arg        = getArgName (opt);
 
     const int d_indent = shortWidth + longWidth + argWidth + 7;
     const int d_width = 80 - d_indent;
     const char * d = opt->description;
 
-    printf( " %s%-*s %s%-*s %-*s ",
-            (shortName && *shortName ? "-" : " "), shortWidth, shortName,
-            (longName && *longName ? "--" : "  "), longWidth, longName,
-            argWidth, arg );
-    len = get_next_line_len( d, d_width );
-    printf( "%*.*s\n", len, len, d );
+    printf (" %s%-*s %s%-*s %-*s ",
+          (shortName && *shortName ? "-" : " "), shortWidth, shortName,
+          (longName && *longName ? "--" : "  "), longWidth, longName,
+            argWidth, arg);
+    len = get_next_line_len (d, d_width);
+    printf ("%*.*s\n", len, len, d);
 
     d += len;
-    while( isspace( *d ) ) ++d;
+    while (isspace (*d)) ++d;
 
-    while(( len = get_next_line_len( d, d_width ))) {
-        printf( "%*.*s%*.*s\n", d_indent, d_indent, "", len, len, d );
+    while ((len = get_next_line_len (d, d_width))) {
+        printf ("%*.*s%*.*s\n", d_indent, d_indent, "", len, len, d);
         d += len;
-        while( isspace( *d ) ) ++d;
+        while (isspace (*d)) ++d;
     }
 }
 
 static void
-maxWidth( const struct tr_option * o,
+maxWidth (const struct tr_option * o,
           int *                    longWidth,
           int *                    shortWidth,
-          int *                    argWidth )
+          int *                    argWidth)
 {
     const char * arg;
 
-    if( o->longName )
-        *longWidth = MAX( *longWidth, (int)strlen( o->longName ) );
+    if (o->longName)
+        *longWidth = MAX (*longWidth, (int)strlen (o->longName));
 
-    if( o->shortName )
-        *shortWidth = MAX( *shortWidth, (int)strlen( o->shortName ) );
+    if (o->shortName)
+        *shortWidth = MAX (*shortWidth, (int)strlen (o->shortName));
 
-    if( ( arg = getArgName( o ) ) )
-        *argWidth = MAX( *argWidth, (int)strlen( arg ) );
+    if ((arg = getArgName (o)))
+        *argWidth = MAX (*argWidth, (int)strlen (arg));
 }
 
 void
-tr_getopt_usage( const char *           progName,
+tr_getopt_usage (const char *           progName,
                  const char *           description,
-                 const struct tr_option opts[] )
+                 const struct tr_option opts[])
 {
     int                      longWidth = 0;
     int                      shortWidth = 0;
@@ -115,29 +115,29 @@ tr_getopt_usage( const char *           progName,
     struct tr_option         help;
     const struct tr_option * o;
 
-    for( o = opts; o->val; ++o )
-        maxWidth( o, &longWidth, &shortWidth, &argWidth );
+    for (o = opts; o->val; ++o)
+        maxWidth (o, &longWidth, &shortWidth, &argWidth);
 
     help.val = -1;
     help.longName = "help";
     help.description = "Display this help page and exit";
     help.shortName = "h";
     help.has_arg = 0;
-    maxWidth( &help, &longWidth, &shortWidth, &argWidth );
+    maxWidth (&help, &longWidth, &shortWidth, &argWidth);
 
-    if( description == NULL )
+    if (description == NULL)
         description = "Usage: %s [options]";
-    printf( description, progName );
-    printf( "\n\nOptions:\n" );
-    getopts_usage_line( &help, longWidth, shortWidth, argWidth );
-    for( o = opts; o->val; ++o )
-        getopts_usage_line( o, longWidth, shortWidth, argWidth );
+    printf (description, progName);
+    printf ("\n\nOptions:\n");
+    getopts_usage_line (&help, longWidth, shortWidth, argWidth);
+    for (o = opts; o->val; ++o)
+        getopts_usage_line (o, longWidth, shortWidth, argWidth);
 }
 
 static const tr_option *
-findOption( const tr_option * opts,
+findOption (const tr_option * opts,
             const char *      str,
-            const char **     setme_arg )
+            const char **     setme_arg)
 {
     size_t            matchlen = 0;
     const char *      arg = NULL;
@@ -145,28 +145,28 @@ findOption( const tr_option * opts,
     const tr_option * match = NULL;
 
     /* find the longest matching option */
-    for( o = opts; o->val; ++o )
+    for (o = opts; o->val; ++o)
     {
-        size_t len = o->longName ? strlen( o->longName ) : 0;
+        size_t len = o->longName ? strlen (o->longName) : 0;
 
-        if( ( matchlen < len ) && !memcmp( str, "--", 2 )
-          && !memcmp( str + 2, o->longName, len )
-          && ( str[len + 2] == '\0' || ( o->has_arg && str[len + 2] == '=' ) ) )
+        if ((matchlen < len) && !memcmp (str, "--", 2)
+          && !memcmp (str + 2, o->longName, len)
+          && (str[len + 2] == '\0' || (o->has_arg && str[len + 2] == '=')))
         {
             matchlen = len;
             match = o;
             arg = str[len + 2] == '=' ? str + len + 3 : NULL;
         }
 
-        len = o->shortName ? strlen( o->shortName ) : 0;
+        len = o->shortName ? strlen (o->shortName) : 0;
 
-        if( ( matchlen < len ) && !memcmp( str, "-", 1 )
-          && !memcmp( str + 1, o->shortName, len )
-          && ( str[len + 1] == '\0' || o->has_arg ) )
+        if ((matchlen < len) && !memcmp (str, "-", 1)
+          && !memcmp (str + 1, o->shortName, len)
+          && (str[len + 1] == '\0' || o->has_arg))
         {
             matchlen = len;
             match = o;
-            switch( str[len + 1] )
+            switch (str[len + 1])
             {
                 case '\0':
                     arg = NULL;          break;
@@ -180,18 +180,18 @@ findOption( const tr_option * opts,
         }
     }
 
-    if( setme_arg )
+    if (setme_arg)
         *setme_arg = arg;
 
     return match;
 }
 
 int
-tr_getopt( const char *      usage,
+tr_getopt (const char *      usage,
            int               argc,
            const char **     argv,
            const tr_option * opts,
-           const char **     setme_optarg )
+           const char **     setme_optarg)
 {
     int               i;
     const char *      arg = NULL;
@@ -200,31 +200,31 @@ tr_getopt( const char *      usage,
     *setme_optarg = NULL;
 
     /* handle the builtin 'help' option */
-    for( i = 1; i < argc; ++i )
+    for (i = 1; i < argc; ++i)
     {
-        if( !strcmp( argv[i], "-h" ) || !strcmp( argv[i], "--help" ) )
+        if (!strcmp (argv[i], "-h") || !strcmp (argv[i], "--help"))
         {
-            tr_getopt_usage( argv[0], usage, opts );
-            exit( 0 );
+            tr_getopt_usage (argv[0], usage, opts);
+            exit (0);
         }
     }
 
     /* out of options? */
-    if( argc == 1 || tr_optind >= argc )
+    if (argc == 1 || tr_optind >= argc)
         return TR_OPT_DONE;
 
-    o = findOption( opts, argv[tr_optind], &arg );
-    if( !o )
+    o = findOption (opts, argv[tr_optind], &arg);
+    if (!o)
     {
         /* let the user know we got an unknown option... */
         *setme_optarg = argv[tr_optind++];
         return TR_OPT_UNK;
     }
 
-    if( !o->has_arg )
+    if (!o->has_arg)
     {
         /* no argument needed for this option, so we're done */
-        if( arg )
+        if (arg)
             return TR_OPT_ERR;
         *setme_optarg = NULL;
         ++tr_optind;
@@ -232,7 +232,7 @@ tr_getopt( const char *      usage,
     }
 
     /* option needed an argument, and it was embedded in this string */
-    if( arg )
+    if (arg)
     {
         *setme_optarg = arg;
         ++tr_optind;
@@ -240,9 +240,9 @@ tr_getopt( const char *      usage,
     }
 
     /* throw an error if the option needed an argument but didn't get one */
-    if( ++tr_optind >= argc )
+    if (++tr_optind >= argc)
         return TR_OPT_ERR;
-    if( findOption( opts, argv[tr_optind], NULL ) )
+    if (findOption (opts, argv[tr_optind], NULL))
         return TR_OPT_ERR;
 
     *setme_optarg = argv[tr_optind++];
diff --git a/libtransmission/tr-getopt.h b/libtransmission/tr-getopt.h
index 440fe180f..1b1715519 100644
--- a/libtransmission/tr-getopt.h
+++ b/libtransmission/tr-getopt.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -27,12 +27,12 @@ extern int tr_optind;
 
 typedef struct tr_option
 {
-    int           val;          /* the value to return from tr_getopt() */
+    int           val;          /* the value to return from tr_getopt () */
     const char *  longName;     /* --long-form */
-    const char *  description;  /* option's description for tr_getopt_usage() */
+    const char *  description;  /* option's description for tr_getopt_usage () */
     const char *  shortName;    /* short form */
     int           has_arg;      /* 0 for no argument, 1 for argument */
-    const char *  argName;      /* argument's description for tr_getopt_usage() */
+    const char *  argName;      /* argument's description for tr_getopt_usage () */
 }
 tr_option;
 
@@ -50,19 +50,19 @@ enum
 };
 
 /**
- * @brief similar to getopt()
+ * @brief similar to getopt ()
  * @return TR_GETOPT_DONE, TR_GETOPT_ERR, TR_GETOPT_UNK, or the matching tr_option's `val' field
  */
-int  tr_getopt( const char       * summary,
+int  tr_getopt (const char       * summary,
                 int                argc,
                 const char      ** argv,
                 const tr_option  * opts,
-                const char      ** setme_optarg );
+                const char      ** setme_optarg);
 
 /** @brief prints the `Usage' help section to stdout */
-void tr_getopt_usage( const char       * appName,
+void tr_getopt_usage (const char       * appName,
                       const char       * description,
-                      const tr_option  * opts );
+                      const tr_option  * opts);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/libtransmission/tr-lpd.c b/libtransmission/tr-lpd.c
index 361e4a43f..b8e4570a8 100644
--- a/libtransmission/tr-lpd.c
+++ b/libtransmission/tr-lpd.c
@@ -23,22 +23,22 @@ THE SOFTWARE.
 /* ansi */
 #include <errno.h>
 #include <stdio.h>
-#include <string.h> /* strlen(), strncpy(), strstr(), memset() */
+#include <string.h> /* strlen (), strncpy (), strstr (), memset () */
 
 /* posix */
 #include <signal.h> /* sig_atomic_t */
 #include <sys/time.h>
-#include <unistd.h> /* close() */
-#include <ctype.h> /* toupper() */
+#include <unistd.h> /* close () */
+#include <ctype.h> /* toupper () */
 #ifdef WIN32
   #include <w32api.h>
-  #define WINDOWS  WindowsXP  /* freeaddrinfo(),getaddrinfo(),getnameinfo() */
+  #define WINDOWS  WindowsXP  /* freeaddrinfo (),getaddrinfo (),getnameinfo () */
   #include <inttypes.h>
   #include <ws2tcpip.h>
   typedef uint16_t in_port_t;			/* all missing */
 #else
   #include <sys/types.h>
-  #include <sys/socket.h> /* socket(), bind() */
+  #include <sys/socket.h> /* socket (), bind () */
   #include <netinet/in.h> /* sockaddr_in */
 #endif
 
@@ -49,9 +49,9 @@ THE SOFTWARE.
 /* libT */
 #include "transmission.h"
 #include "net.h"
-#include "peer-mgr.h" /* tr_peerMgrAddPex() */
+#include "peer-mgr.h" /* tr_peerMgrAddPex () */
 #include "session.h"
-#include "torrent.h" /* tr_torrentFindFromHash() */
+#include "torrent.h" /* tr_torrentFindFromHash () */
 #include "tr-lpd.h"
 #include "utils.h"
 #include "version.h"
@@ -66,7 +66,7 @@ THE SOFTWARE.
 * $Id$
 */
 
-static void event_callback( int, short, void* );
+static void event_callback (int, short, void*);
 
 enum {
    UPKEEP_INTERVAL_SECS = 5
@@ -159,42 +159,42 @@ static int lpd_unsolicitedMsgCounter;
 * If parameter is not NULL, the declared protocol version is returned as part of
 * the lpd_protocolVersion structure.
 */
-static const char* lpd_extractHeader( const char* s, struct lpd_protocolVersion* const ver )
+static const char* lpd_extractHeader (const char* s, struct lpd_protocolVersion* const ver)
 {
     int major = -1, minor = -1;
     size_t len;
 
-    assert( s != NULL );
-    len = strlen( s );
+    assert (s != NULL);
+    len = strlen (s);
 
     /* something might be rotten with this chunk of data */
-    if( len == 0 || len > lpd_maxDatagramLength )
+    if (len == 0 || len > lpd_maxDatagramLength)
         return NULL;
 
     /* now we can attempt to look up the BT-SEARCH header */
-    if( sscanf( s, "BT-SEARCH * HTTP/%d.%d" CRLF, &major, &minor ) != 2 )
+    if (sscanf (s, "BT-SEARCH * HTTP/%d.%d" CRLF, &major, &minor) != 2)
         return NULL;
 
-    if( major < 0 || minor < 0 )
+    if (major < 0 || minor < 0)
         return NULL;
 
     {
         /* a pair of blank lines at the end of the string, no place else */
         const char* const two_blank = CRLF CRLF CRLF;
-        const char* const end = strstr( s, two_blank );
+        const char* const end = strstr (s, two_blank);
 
-        if( end == NULL || strlen( end ) > strlen( two_blank ) )
+        if (end == NULL || strlen (end) > strlen (two_blank))
             return NULL;
     }
 
-    if( ver != NULL )
+    if (ver != NULL)
     {
         ver->major = major;
         ver->minor = minor;
     }
 
     /* separate the header, begins with CRLF */
-    return strstr( s, CRLF );
+    return strstr (s, CRLF);
 }
 
 /**
@@ -211,39 +211,39 @@ static const char* lpd_extractHeader( const char* s, struct lpd_protocolVersion*
 *   - assemble search string "\r\nName: " and locate position
 *   - copy back value from end to next "\r\n"
 */
-static int lpd_extractParam( const char* const str, const char* const name, int n, char* const val )
+static int lpd_extractParam (const char* const str, const char* const name, int n, char* const val)
 {
     /* configure maximum length of search string here */
     enum { maxLength = 30 };
     char sstr[maxLength] = { };
     const char* pos;
 
-    assert( str != NULL && name != NULL );
-    assert( val != NULL );
+    assert (str != NULL && name != NULL);
+    assert (val != NULL);
 
-    if( strlen( name ) > maxLength - strlen( CRLF ": " ) )
+    if (strlen (name) > maxLength - strlen (CRLF ": "))
         return 0;
 
     /* compose the string token to search for */
-    snprintf( sstr, maxLength, CRLF "%s: ", name );
+    snprintf (sstr, maxLength, CRLF "%s: ", name);
 
-    pos = strstr( str, sstr );
-    if( pos == NULL )
+    pos = strstr (str, sstr);
+    if (pos == NULL)
         return 0; /* search was not successful */
 
     {
-        const char* const beg = pos + strlen( sstr );
-        const char* const new_line = strstr( beg, CRLF );
+        const char* const beg = pos + strlen (sstr);
+        const char* const new_line = strstr (beg, CRLF);
 
         /* the value is delimited by the next CRLF */
         int len = new_line - beg;
 
         /* if value string hits the length limit n,
          * leave space for a trailing '\0' character */
-        if( len < n-- )
+        if (len < n--)
             n = len;
 
-        strncpy( val, beg, n );
+        strncpy (val, beg, n);
         val[n] = 0;
     }
 
@@ -254,7 +254,7 @@ static int lpd_extractParam( const char* const str, const char* const name, int
 /**
 * @} */
 
-static void on_upkeep_timer( int, short, void * );
+static void on_upkeep_timer (int, short, void *);
 
 /**
 * @brief Initializes Local Peer Discovery for this node
@@ -265,57 +265,57 @@ static void on_upkeep_timer( int, short, void * );
 * @remark Since the LPD service does not use another protocol family yet, this code is
 * IPv4 only for the time being.
 */
-int tr_lpdInit( tr_session* ss, tr_address* tr_addr UNUSED )
+int tr_lpdInit (tr_session* ss, tr_address* tr_addr UNUSED)
 {
     struct ip_mreq mcastReq;
     const int opt_on = 1, opt_off = 0;
 
-    if( session ) /* already initialized */
+    if (session) /* already initialized */
         return -1;
 
-    assert( lpd_announceInterval > 0 );
-    assert( lpd_announceScope > 0 );
+    assert (lpd_announceInterval > 0);
+    assert (lpd_announceScope > 0);
 
-    lpd_port = tr_sessionGetPeerPort( ss );
-    if( lpd_port <= 0 )
+    lpd_port = tr_sessionGetPeerPort (ss);
+    if (lpd_port <= 0)
         return -1;
 
-    tr_ndbg( "LPD", "Initialising Local Peer Discovery" );
+    tr_ndbg ("LPD", "Initialising Local Peer Discovery");
 
     /* setup datagram socket (receive) */
     {
-        lpd_socket = socket( PF_INET, SOCK_DGRAM, 0 );
-        if( lpd_socket < 0 )
+        lpd_socket = socket (PF_INET, SOCK_DGRAM, 0);
+        if (lpd_socket < 0)
             goto fail;
 
-        if( evutil_make_socket_nonblocking( lpd_socket ) < 0 )
+        if (evutil_make_socket_nonblocking (lpd_socket) < 0)
             goto fail;
 
-        if( setsockopt( lpd_socket, SOL_SOCKET, SO_REUSEADDR,
-                &opt_on, sizeof opt_on ) < 0 )
+        if (setsockopt (lpd_socket, SOL_SOCKET, SO_REUSEADDR,
+                &opt_on, sizeof opt_on) < 0)
             goto fail;
 
-        memset( &lpd_mcastAddr, 0, sizeof lpd_mcastAddr );
+        memset (&lpd_mcastAddr, 0, sizeof lpd_mcastAddr);
         lpd_mcastAddr.sin_family = AF_INET;
-        lpd_mcastAddr.sin_port = htons( lpd_mcastPort );
-        if( evutil_inet_pton( lpd_mcastAddr.sin_family, lpd_mcastGroup,
-                &lpd_mcastAddr.sin_addr ) < 0 )
+        lpd_mcastAddr.sin_port = htons (lpd_mcastPort);
+        if (evutil_inet_pton (lpd_mcastAddr.sin_family, lpd_mcastGroup,
+                &lpd_mcastAddr.sin_addr) < 0)
             goto fail;
 
-        if( bind( lpd_socket, (struct sockaddr*) &lpd_mcastAddr,
-                sizeof lpd_mcastAddr ) < 0 )
+        if (bind (lpd_socket, (struct sockaddr*) &lpd_mcastAddr,
+                sizeof lpd_mcastAddr) < 0)
             goto fail;
 
         /* we want to join that LPD multicast group */
-        memset( &mcastReq, 0, sizeof mcastReq );
+        memset (&mcastReq, 0, sizeof mcastReq);
         mcastReq.imr_multiaddr = lpd_mcastAddr.sin_addr;
-        mcastReq.imr_interface.s_addr = htonl( INADDR_ANY );
-        if( setsockopt( lpd_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
-                &mcastReq, sizeof mcastReq ) < 0 )
+        mcastReq.imr_interface.s_addr = htonl (INADDR_ANY);
+        if (setsockopt (lpd_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+                &mcastReq, sizeof mcastReq) < 0)
             goto fail;
 
-        if( setsockopt( lpd_socket, IPPROTO_IP, IP_MULTICAST_LOOP,
-                &opt_off, sizeof opt_off ) < 0 )
+        if (setsockopt (lpd_socket, IPPROTO_IP, IP_MULTICAST_LOOP,
+                &opt_off, sizeof opt_off) < 0)
             goto fail;
     }
 
@@ -323,20 +323,20 @@ int tr_lpdInit( tr_session* ss, tr_address* tr_addr UNUSED )
     {
         const unsigned char scope = lpd_announceScope;
 
-        lpd_socket2 = socket( PF_INET, SOCK_DGRAM, 0 );
-        if( lpd_socket2 < 0 )
+        lpd_socket2 = socket (PF_INET, SOCK_DGRAM, 0);
+        if (lpd_socket2 < 0)
             goto fail;
 
-        if( evutil_make_socket_nonblocking( lpd_socket2 ) < 0 )
+        if (evutil_make_socket_nonblocking (lpd_socket2) < 0)
             goto fail;
 
         /* configure outbound multicast TTL */
-        if( setsockopt( lpd_socket2, IPPROTO_IP, IP_MULTICAST_TTL,
-                &scope, sizeof scope ) < 0 )
+        if (setsockopt (lpd_socket2, IPPROTO_IP, IP_MULTICAST_TTL,
+                &scope, sizeof scope) < 0)
             goto fail;
 
-        if( setsockopt( lpd_socket2, IPPROTO_IP, IP_MULTICAST_LOOP,
-                &opt_off, sizeof opt_off ) < 0 )
+        if (setsockopt (lpd_socket2, IPPROTO_IP, IP_MULTICAST_LOOP,
+                &opt_off, sizeof opt_off) < 0)
             goto fail;
     }
 
@@ -345,24 +345,24 @@ int tr_lpdInit( tr_session* ss, tr_address* tr_addr UNUSED )
     /* Note: lpd_unsolicitedMsgCounter remains 0 until the first timeout event, thus
      * any announcement received during the initial interval will be discarded. */
 
-    lpd_event = event_new( ss->event_base, lpd_socket, EV_READ | EV_PERSIST, event_callback, NULL );
-    event_add( lpd_event, NULL );
+    lpd_event = event_new (ss->event_base, lpd_socket, EV_READ | EV_PERSIST, event_callback, NULL);
+    event_add (lpd_event, NULL);
 
-    upkeep_timer = evtimer_new( ss->event_base, on_upkeep_timer, ss );
-    tr_timerAdd( upkeep_timer, UPKEEP_INTERVAL_SECS, 0 );
+    upkeep_timer = evtimer_new (ss->event_base, on_upkeep_timer, ss);
+    tr_timerAdd (upkeep_timer, UPKEEP_INTERVAL_SECS, 0);
 
-    tr_ndbg( "LPD", "Local Peer Discovery initialised" );
+    tr_ndbg ("LPD", "Local Peer Discovery initialised");
 
     return 1;
 
     fail:
     {
         const int save = errno;
-        close( lpd_socket );
-        close( lpd_socket2 );
+        close (lpd_socket);
+        close (lpd_socket2);
         lpd_socket = lpd_socket2 = -1;
         session = NULL;
-        tr_ndbg( "LPD", "LPD initialisation failed (errno = %d)", save );
+        tr_ndbg ("LPD", "LPD initialisation failed (errno = %d)", save);
         errno = save;
     }
 
@@ -370,31 +370,31 @@ int tr_lpdInit( tr_session* ss, tr_address* tr_addr UNUSED )
     return -1;
 }
 
-void tr_lpdUninit( tr_session* ss )
+void tr_lpdUninit (tr_session* ss)
 {
-    if( session != ss )
+    if (session != ss)
         return;
 
-    tr_ndbg( "LPD", "Uninitialising Local Peer Discovery" );
+    tr_ndbg ("LPD", "Uninitialising Local Peer Discovery");
 
-    event_free( lpd_event );
+    event_free (lpd_event);
     lpd_event = NULL;
 
-    evtimer_del( upkeep_timer );
+    evtimer_del (upkeep_timer);
     upkeep_timer = NULL;
 
     /* just shut down, we won't remember any former nodes */
-    evutil_closesocket( lpd_socket );
-    evutil_closesocket( lpd_socket2 );
-    tr_ndbg( "LPD", "Done uninitialising Local Peer Discovery" );
+    evutil_closesocket (lpd_socket);
+    evutil_closesocket (lpd_socket2);
+    tr_ndbg ("LPD", "Done uninitialising Local Peer Discovery");
 
     session = NULL;
 }
 
 bool
-tr_lpdEnabled( const tr_session* ss )
+tr_lpdEnabled (const tr_session* ss)
 {
-    return ss && ( ss == session );
+    return ss && (ss == session);
 }
 
 
@@ -404,13 +404,13 @@ tr_lpdEnabled( const tr_session* ss )
 * @remark Declared inline for the compiler not to allege us of feeding unused
 * functions. In any other respect, lpd_consistencyCheck is an orphaned function.
 */
-static inline void lpd_consistencyCheck( void )
+static inline void lpd_consistencyCheck (void)
 {
     /* if the following check fails, the definition of a hash string has changed
      * without our knowledge; revise string handling in functions tr_lpdSendAnnounce
      * and tr_lpdConsiderAnnounce. However, the code is designed to function as long
      * as interfaces to the rest of the lib remain compatible with char* strings. */
-    STATIC_ASSERT( sizeof(lpd_torStaticType->info.hashString[0]) == sizeof(char) );
+    STATIC_ASSERT (sizeof (lpd_torStaticType->info.hashString[0]) == sizeof (char));
 }
 /**
 * @endcond */
@@ -432,7 +432,7 @@ static inline void lpd_consistencyCheck( void )
 * peer pool for torrent t.
 */
 bool
-tr_lpdSendAnnounce( const tr_torrent* t )
+tr_lpdSendAnnounce (const tr_torrent* t)
 {
     size_t i;
     const char fmt[] =
@@ -443,34 +443,34 @@ tr_lpdSendAnnounce( const tr_torrent* t )
         CRLF
         CRLF;
 
-    char hashString[lengthof( t->info.hashString )];
+    char hashString[lengthof (t->info.hashString)];
     char query[lpd_maxDatagramLength + 1] = { };
 
-    if( t == NULL )
+    if (t == NULL)
         return false;
 
     /* make sure the hash string is normalized, just in case */
-    for( i = 0; i < sizeof hashString; i++ )
-        hashString[i] = toupper( t->info.hashString[i] );
+    for (i = 0; i < sizeof hashString; i++)
+        hashString[i] = toupper (t->info.hashString[i]);
 
     /* prepare a zero-terminated announce message */
-    snprintf( query, lpd_maxDatagramLength + 1, fmt, 1, 1,
-        lpd_mcastGroup, lpd_mcastPort, lpd_port, hashString );
+    snprintf (query, lpd_maxDatagramLength + 1, fmt, 1, 1,
+        lpd_mcastGroup, lpd_mcastPort, lpd_port, hashString);
 
     /* actually send the query out using [lpd_socket2] */
     {
-        const int len = strlen( query );
+        const int len = strlen (query);
 
-        /* destination address info has already been set up in tr_lpdInit(),
+        /* destination address info has already been set up in tr_lpdInit (),
          * so we refrain from preparing another sockaddr_in here */
-        int res = sendto( lpd_socket2, query, len, 0,
-            (const struct sockaddr*) &lpd_mcastAddr, sizeof lpd_mcastAddr );
+        int res = sendto (lpd_socket2, query, len, 0,
+          (const struct sockaddr*) &lpd_mcastAddr, sizeof lpd_mcastAddr);
 
-        if( res != len )
+        if (res != len)
             return false;
     }
 
-    tr_tordbg( t, "LPD announce message away" );
+    tr_tordbg (t, "LPD announce message away");
 
     return true;
 }
@@ -489,12 +489,12 @@ tr_lpdSendAnnounce( const tr_torrent* t )
 * is able to extract the necessary information from the announce message. That is, if
 * return != 0, the caller may retrieve the value from the passed structure.
 */
-static int tr_lpdConsiderAnnounce( tr_pex* peer, const char* const msg )
+static int tr_lpdConsiderAnnounce (tr_pex* peer, const char* const msg)
 {
     enum
     {
         maxValueLen = 25,
-        maxHashLen = lengthof(lpd_torStaticType->info.hashString)
+        maxHashLen = lengthof (lpd_torStaticType->info.hashString)
     };
 
     struct lpd_protocolVersion ver = { -1, -1 };
@@ -502,44 +502,44 @@ static int tr_lpdConsiderAnnounce( tr_pex* peer, const char* const msg )
     char hashString[maxHashLen] = { };
     int res = 0, peerPort = 0;
 
-    if( peer != NULL && msg != NULL )
+    if (peer != NULL && msg != NULL)
     {
         tr_torrent* tor = NULL;
 
-        const char* params = lpd_extractHeader( msg, &ver );
-        if( params == NULL || ver.major != 1 ) /* allow messages of protocol v1 */
+        const char* params = lpd_extractHeader (msg, &ver);
+        if (params == NULL || ver.major != 1) /* allow messages of protocol v1 */
             return 0;
 
         /* save the effort to check Host, which seems to be optional anyway */
 
-        if( lpd_extractParam( params, "Port", maxValueLen, value ) == 0 )
+        if (lpd_extractParam (params, "Port", maxValueLen, value) == 0)
             return 0;
 
         /* determine announced peer port, refuse if value too large */
-        if( sscanf( value, "%d", &peerPort ) != 1 || peerPort > (in_port_t)-1 )
+        if (sscanf (value, "%d", &peerPort) != 1 || peerPort > (in_port_t)-1)
             return 0;
 
-        peer->port = htons( peerPort );
+        peer->port = htons (peerPort);
         res = -1; /* signal caller side-effect to peer->port via return != 0 */
 
-        if( lpd_extractParam( params, "Infohash", maxHashLen, hashString ) == 0 )
+        if (lpd_extractParam (params, "Infohash", maxHashLen, hashString) == 0)
             return res;
 
-        tor = tr_torrentFindFromHashString( session, hashString );
+        tor = tr_torrentFindFromHashString (session, hashString);
 
-        if( tr_isTorrent( tor ) && tr_torrentAllowsLPD( tor ) )
+        if (tr_isTorrent (tor) && tr_torrentAllowsLPD (tor))
         {
             /* we found a suitable peer, add it to the torrent */
-            tr_peerMgrAddPex( tor, TR_PEER_FROM_LPD, peer, -1 );
-            tr_tordbg( tor, "Learned %d local peer from LPD (%s:%u)",
-                1, tr_address_to_string( &peer->addr ), peerPort );
+            tr_peerMgrAddPex (tor, TR_PEER_FROM_LPD, peer, -1);
+            tr_tordbg (tor, "Learned %d local peer from LPD (%s:%u)",
+                1, tr_address_to_string (&peer->addr), peerPort);
 
-            /* periodic reconnectPulse() deals with the rest... */
+            /* periodic reconnectPulse () deals with the rest... */
 
             return 1;
         }
         else
-            tr_ndbg( "LPD", "Cannot serve torrent #%s", hashString );
+            tr_ndbg ("LPD", "Cannot serve torrent #%s", hashString);
     }
 
     return res;
@@ -559,26 +559,26 @@ static int tr_lpdConsiderAnnounce( tr_pex* peer, const char* const msg )
 * before. are there cases where we should? if not, should we remove the bells & whistles?
 */
 static int
-tr_lpdAnnounceMore( const time_t now, const int interval )
+tr_lpdAnnounceMore (const time_t now, const int interval)
 {
     tr_torrent* tor = NULL;
     int announcesSent = 0;
 
-    if( !tr_isSession( session ) )
+    if (!tr_isSession (session))
         return -1;
 
-    while(( tor = tr_torrentNext( session, tor ) )
-          && tr_sessionAllowsLPD( session ) )
+    while ((tor = tr_torrentNext (session, tor))
+          && tr_sessionAllowsLPD (session))
     {
-        if( tr_isTorrent( tor ) )
+        if (tr_isTorrent (tor))
         {
             int announcePrio = 0;
 
-            if( !tr_torrentAllowsLPD( tor ) )
+            if (!tr_torrentAllowsLPD (tor))
                 continue;
 
             /* issue #3208: prioritize downloads before seeds */
-            switch( tr_torrentGetActivity( tor ) )
+            switch (tr_torrentGetActivity (tor))
             {
             case TR_STATUS_DOWNLOAD:
                 announcePrio = 1;
@@ -590,9 +590,9 @@ tr_lpdAnnounceMore( const time_t now, const int interval )
                 break;
             }
 
-            if( announcePrio > 0 && tor->lpdAnnounceAt <= now )
+            if (announcePrio > 0 && tor->lpdAnnounceAt <= now)
             {
-                if( tr_lpdSendAnnounce( tor ) )
+                if (tr_lpdSendAnnounce (tor))
                     announcesSent++;
 
                 tor->lpdAnnounceAt = now +
@@ -607,9 +607,9 @@ tr_lpdAnnounceMore( const time_t now, const int interval )
     {
         const int maxAnnounceCap = interval * lpd_announceCapFactor;
 
-        if( lpd_unsolicitedMsgCounter < 0 )
-            tr_ninf( "LPD", "Dropped %d announces in the last interval (max. %d "
-                     "allowed)", -lpd_unsolicitedMsgCounter, maxAnnounceCap );
+        if (lpd_unsolicitedMsgCounter < 0)
+            tr_ninf ("LPD", "Dropped %d announces in the last interval (max. %d "
+                     "allowed)", -lpd_unsolicitedMsgCounter, maxAnnounceCap);
 
         lpd_unsolicitedMsgCounter = maxAnnounceCap;
     }
@@ -618,26 +618,26 @@ tr_lpdAnnounceMore( const time_t now, const int interval )
 }
 
 static void
-on_upkeep_timer( int foo UNUSED, short bar UNUSED, void * vsession UNUSED )
+on_upkeep_timer (int foo UNUSED, short bar UNUSED, void * vsession UNUSED)
 {
-    const time_t now = tr_time( );
-    tr_lpdAnnounceMore( now, UPKEEP_INTERVAL_SECS );
-    tr_timerAdd( upkeep_timer, UPKEEP_INTERVAL_SECS, 0 );
+    const time_t now = tr_time ();
+    tr_lpdAnnounceMore (now, UPKEEP_INTERVAL_SECS);
+    tr_timerAdd (upkeep_timer, UPKEEP_INTERVAL_SECS, 0);
 }
 
 /**
 * @brief Processing of timeout notifications and incoming data on the socket
 * @note maximum rate of read events is limited according to @a lpd_maxAnnounceCap
 * @see DoS */
-static void event_callback( int s UNUSED, short type, void* ignore UNUSED )
+static void event_callback (int s UNUSED, short type, void* ignore UNUSED)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     /* do not allow announces to be processed if LPD is disabled */
-    if( !tr_sessionAllowsLPD( session ) )
+    if (!tr_sessionAllowsLPD (session))
         return;
 
-    if( ( type & EV_READ ) != 0 )
+    if ((type & EV_READ) != 0)
     {
         struct sockaddr_in foreignAddr;
         int addrLen = sizeof foreignAddr;
@@ -646,14 +646,14 @@ static void event_callback( int s UNUSED, short type, void* ignore UNUSED )
         char foreignMsg[lpd_maxDatagramLength + 1] = { };
 
         /* process local announcement from foreign peer */
-        int res = recvfrom( lpd_socket, foreignMsg, lpd_maxDatagramLength,
-            0, (struct sockaddr*) &foreignAddr, (socklen_t*) &addrLen );
+        int res = recvfrom (lpd_socket, foreignMsg, lpd_maxDatagramLength,
+            0, (struct sockaddr*) &foreignAddr, (socklen_t*) &addrLen);
 
         /* besides, do we get flooded? then bail out! */
-        if( --lpd_unsolicitedMsgCounter < 0 )
+        if (--lpd_unsolicitedMsgCounter < 0)
             return;
 
-        if( res > 0 && res <= lpd_maxDatagramLength )
+        if (res > 0 && res <= lpd_maxDatagramLength)
         {
             struct tr_pex foreignPeer =
                 {
@@ -662,11 +662,11 @@ static void event_callback( int s UNUSED, short type, void* ignore UNUSED )
                 };
 
             foreignPeer.addr.addr.addr4 = foreignAddr.sin_addr;
-            if( tr_lpdConsiderAnnounce( &foreignPeer, foreignMsg ) != 0 )
+            if (tr_lpdConsiderAnnounce (&foreignPeer, foreignMsg) != 0)
                 return; /* OK so far, no log message */
         }
 
-        tr_ndbg( "LPD", "Discarded invalid multicast message" );
+        tr_ndbg ("LPD", "Discarded invalid multicast message");
     }
 }
 
diff --git a/libtransmission/tr-lpd.h b/libtransmission/tr-lpd.h
index 391550db3..11f524db0 100644
--- a/libtransmission/tr-lpd.h
+++ b/libtransmission/tr-lpd.h
@@ -29,10 +29,10 @@ THE SOFTWARE.
 
 /* $Id$ */
 
-int  tr_lpdInit( tr_session*, tr_address* );
-void tr_lpdUninit( tr_session* );
-bool tr_lpdEnabled( const tr_session* );
-bool tr_lpdSendAnnounce( const tr_torrent* );
+int  tr_lpdInit (tr_session*, tr_address*);
+void tr_lpdUninit (tr_session*);
+bool tr_lpdEnabled (const tr_session*);
+bool tr_lpdSendAnnounce (const tr_torrent*);
 
 /**
 * @defgroup Preproc Helper macros
@@ -40,15 +40,15 @@ bool tr_lpdSendAnnounce( const tr_torrent* );
 *
 * @def lengthof
 * @brief returns the static length of a C array type
-* @note A lower case macro name is tolerable here since this definition of lengthof()
+* @note A lower case macro name is tolerable here since this definition of lengthof ()
 * is intimately related to sizeof semantics.
 * Meaningful return values are only guaranteed for true array types. */
-#define lengthof( arr ) ( sizeof( *(arr) ) > 0 ? sizeof( arr ) / sizeof( *(arr) ) : 0 )
+#define lengthof(arr)(sizeof (* (arr)) > 0 ? sizeof (arr) / sizeof (* (arr)) : 0)
 
 /**
 * @def STATIC_ASSERT
 * @brief This helper allows to perform static checks at compile time */
-#define STATIC_ASSERT( x ) { const char static_check[( (x) ? 1 : -1 )] UNUSED; }
+#define STATIC_ASSERT(x) { const char static_check[ ((x) ? 1 : -1)] UNUSED; }
 
 /**
 * @} */
diff --git a/libtransmission/tr-udp.c b/libtransmission/tr-udp.c
index 99ee6bef7..8c343edcb 100644
--- a/libtransmission/tr-udp.c
+++ b/libtransmission/tr-udp.c
@@ -22,10 +22,10 @@ THE SOFTWARE.
 */
 
 #include <assert.h>
-#include <string.h> /* memcmp(), memcpy(), memset() */
-#include <stdlib.h> /* malloc(), free() */
+#include <string.h> /* memcmp (), memcpy (), memset () */
+#include <stdlib.h> /* malloc (), free () */
 
-#include <unistd.h> /* close() */
+#include <unistd.h> /* close () */
 
 #include <event2/event.h>
 
@@ -46,48 +46,48 @@ THE SOFTWARE.
 #define SMALL_BUFFER_SIZE (32 * 1024)
 
 static void
-set_socket_buffers(int fd, int large)
+set_socket_buffers (int fd, int large)
 {
     int size, rbuf, sbuf, rc;
-    socklen_t rbuf_len = sizeof(rbuf), sbuf_len = sizeof(sbuf);
+    socklen_t rbuf_len = sizeof (rbuf), sbuf_len = sizeof (sbuf);
 
     size = large ? RECV_BUFFER_SIZE : SMALL_BUFFER_SIZE;
-    rc = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
-    if(rc < 0)
-        tr_nerr("UDP", "Failed to set receive buffer: %s",
-                tr_strerror(errno));
+    rc = setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof (size));
+    if (rc < 0)
+        tr_nerr ("UDP", "Failed to set receive buffer: %s",
+                tr_strerror (errno));
 
     size = large ? SEND_BUFFER_SIZE : SMALL_BUFFER_SIZE;
-    rc = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
-    if(rc < 0)
-        tr_nerr("UDP", "Failed to set send buffer: %s",
-                tr_strerror(errno));
-
-    if(large) {
-        rc = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rbuf, &rbuf_len);
-        if(rc < 0)
+    rc = setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof (size));
+    if (rc < 0)
+        tr_nerr ("UDP", "Failed to set send buffer: %s",
+                tr_strerror (errno));
+
+    if (large) {
+        rc = getsockopt (fd, SOL_SOCKET, SO_RCVBUF, &rbuf, &rbuf_len);
+        if (rc < 0)
             rbuf = 0;
 
-        rc = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sbuf, &sbuf_len);
-        if(rc < 0)
+        rc = getsockopt (fd, SOL_SOCKET, SO_SNDBUF, &sbuf, &sbuf_len);
+        if (rc < 0)
             sbuf = 0;
 
-        if(rbuf < RECV_BUFFER_SIZE) {
-            tr_nerr("UDP", "Failed to set receive buffer: requested %d, got %d",
+        if (rbuf < RECV_BUFFER_SIZE) {
+            tr_nerr ("UDP", "Failed to set receive buffer: requested %d, got %d",
                     RECV_BUFFER_SIZE, rbuf);
 #ifdef __linux__
-            tr_ninf("UDP",
+            tr_ninf ("UDP",
                     "Please add the line "
                     "\"net.core.rmem_max = %d\" to /etc/sysctl.conf",
                     RECV_BUFFER_SIZE);
 #endif
         }
 
-        if(sbuf < SEND_BUFFER_SIZE) {
-            tr_nerr("UDP", "Failed to set send buffer: requested %d, got %d",
+        if (sbuf < SEND_BUFFER_SIZE) {
+            tr_nerr ("UDP", "Failed to set send buffer: requested %d, got %d",
                     SEND_BUFFER_SIZE, sbuf);
 #ifdef __linux__
-            tr_ninf("UDP",
+            tr_ninf ("UDP",
                     "Please add the line "
                     "\"net.core.wmem_max = %d\" to /etc/sysctl.conf",
                     SEND_BUFFER_SIZE);
@@ -97,13 +97,13 @@ set_socket_buffers(int fd, int large)
 }
 
 void
-tr_udpSetSocketBuffers(tr_session *session)
+tr_udpSetSocketBuffers (tr_session *session)
 {
-    bool utp = tr_sessionIsUTPEnabled(session);
-    if(session->udp_socket >= 0)
-        set_socket_buffers(session->udp_socket, utp);
-    if(session->udp6_socket >= 0)
-        set_socket_buffers(session->udp6_socket, utp);
+    bool utp = tr_sessionIsUTPEnabled (session);
+    if (session->udp_socket >= 0)
+        set_socket_buffers (session->udp_socket, utp);
+    if (session->udp6_socket >= 0)
+        set_socket_buffers (session->udp6_socket, utp);
 }
 
 
@@ -113,81 +113,81 @@ tr_udpSetSocketBuffers(tr_session *session)
    IPv6 address, if I may say so myself. */
 
 static void
-rebind_ipv6(tr_session *ss, bool force)
+rebind_ipv6 (tr_session *ss, bool force)
 {
     bool is_default;
     const struct tr_address * public_addr;
     struct sockaddr_in6 sin6;
-    const unsigned char *ipv6 = tr_globalIPv6();
+    const unsigned char *ipv6 = tr_globalIPv6 ();
     int s = -1, rc;
     int one = 1;
 
     /* We currently have no way to enable or disable IPv6 after initialisation.
        No way to fix that without some surgery to the DHT code itself. */
-    if(ipv6 == NULL || (!force && ss->udp6_socket < 0)) {
-        if(ss->udp6_bound) {
-            free(ss->udp6_bound);
+    if (ipv6 == NULL || (!force && ss->udp6_socket < 0)) {
+        if (ss->udp6_bound) {
+            free (ss->udp6_bound);
             ss->udp6_bound = NULL;
         }
         return;
     }
 
-    if(ss->udp6_bound != NULL && memcmp(ipv6, ss->udp6_bound, 16) == 0)
+    if (ss->udp6_bound != NULL && memcmp (ipv6, ss->udp6_bound, 16) == 0)
         return;
 
-    s = socket(PF_INET6, SOCK_DGRAM, 0);
-    if(s < 0)
+    s = socket (PF_INET6, SOCK_DGRAM, 0);
+    if (s < 0)
         goto fail;
 
 #ifdef IPV6_V6ONLY
         /* Since we always open an IPv4 socket on the same port, this
            shouldn't matter.  But I'm superstitious. */
-        setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one));
+        setsockopt (s, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof (one));
 #endif
 
-    memset(&sin6, 0, sizeof(sin6));
+    memset (&sin6, 0, sizeof (sin6));
     sin6.sin6_family = AF_INET6;
-    if(ipv6)
-        memcpy(&sin6.sin6_addr, ipv6, 16);
-    sin6.sin6_port = htons(ss->udp_port);
-    public_addr = tr_sessionGetPublicAddress(ss, TR_AF_INET6, &is_default);
-    if(public_addr && !is_default)
+    if (ipv6)
+        memcpy (&sin6.sin6_addr, ipv6, 16);
+    sin6.sin6_port = htons (ss->udp_port);
+    public_addr = tr_sessionGetPublicAddress (ss, TR_AF_INET6, &is_default);
+    if (public_addr && !is_default)
         sin6.sin6_addr = public_addr->addr.addr6;
 
-    rc = bind(s, (struct sockaddr*)&sin6, sizeof(sin6));
-    if(rc < 0)
+    rc = bind (s, (struct sockaddr*)&sin6, sizeof (sin6));
+    if (rc < 0)
         goto fail;
 
-    if(ss->udp6_socket < 0) {
+    if (ss->udp6_socket < 0) {
         ss->udp6_socket = s;
     } else {
-        rc = dup2(s, ss->udp6_socket);
-        if(rc < 0)
+        rc = dup2 (s, ss->udp6_socket);
+        if (rc < 0)
             goto fail;
-        close(s);
+        close (s);
     }
 
-    if(ss->udp6_bound == NULL)
-        ss->udp6_bound = malloc(16);
-    if(ss->udp6_bound)
-        memcpy(ss->udp6_bound, ipv6, 16);
+    if (ss->udp6_bound == NULL)
+        ss->udp6_bound = malloc (16);
+    if (ss->udp6_bound)
+        memcpy (ss->udp6_bound, ipv6, 16);
 
     return;
 
  fail:
     /* Something went wrong.  It's difficult to recover, so let's simply
        set things up so that we try again next time. */
-    tr_nerr("UDP", "Couldn't rebind IPv6 socket");
-    if(s >= 0)
-        close(s);
-    if(ss->udp6_bound) {
-        free(ss->udp6_bound);
+    tr_nerr ("UDP", "Couldn't rebind IPv6 socket");
+    if (s >= 0)
+        close (s);
+    if (ss->udp6_bound) {
+        free (ss->udp6_bound);
         ss->udp6_bound = NULL;
     }
 }
 
 static void
-event_callback(int s, short type UNUSED, void *sv)
+event_callback (int s, short type UNUSED, void *sv)
 {
     int rc;
     socklen_t fromlen;
@@ -195,12 +195,12 @@ event_callback(int s, short type UNUSED, void *sv)
     struct sockaddr_storage from;
     tr_session *ss = sv;
 
-    assert(tr_isSession(sv));
-    assert(type == EV_READ);
+    assert (tr_isSession (sv));
+    assert (type == EV_READ);
 
-    fromlen = sizeof(from);
-    rc = recvfrom(s, buf, 4096 - 1, 0,
-                  (struct sockaddr*)&from, &fromlen);
+    fromlen = sizeof (from);
+    rc = recvfrom (s, buf, 4096 - 1, 0,
+                (struct sockaddr*)&from, &fromlen);
 
     /* Since most packets we receive here are µTP, make quick inline
        checks for the other protocols.  The logic is as follows:
@@ -209,116 +209,116 @@ event_callback(int s, short type UNUSED, void *sv)
          is between 0 and 3;
        - the above cannot be µTP packets, since these start with a 4-bit
          version number (1). */
-    if(rc > 0) {
-        if( buf[0] == 'd' ) {
-            if( tr_sessionAllowsDHT( ss ) ) {
+    if (rc > 0) {
+        if (buf[0] == 'd') {
+            if (tr_sessionAllowsDHT (ss)) {
                 buf[rc] = '\0'; /* required by the DHT code */
-                tr_dhtCallback(buf, rc, (struct sockaddr*)&from, fromlen, sv);
+                tr_dhtCallback (buf, rc, (struct sockaddr*)&from, fromlen, sv);
             }
-        } else if( rc >= 8 &&
-                   buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] <= 3 ) {
-            rc = tau_handle_message( ss, buf, rc );
-            if( !rc )
-                tr_ndbg("UDP", "Couldn't parse UDP tracker packet.");
+        } else if (rc >= 8 &&
+                   buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] <= 3) {
+            rc = tau_handle_message (ss, buf, rc);
+            if (!rc)
+                tr_ndbg ("UDP", "Couldn't parse UDP tracker packet.");
         } else {
-            if( tr_sessionIsUTPEnabled( ss ) ) {
-                rc = tr_utpPacket(buf, rc, (struct sockaddr*)&from, fromlen, ss);
-                if( !rc )
-                    tr_ndbg("UDP", "Unexpected UDP packet");
+            if (tr_sessionIsUTPEnabled (ss)) {
+                rc = tr_utpPacket (buf, rc, (struct sockaddr*)&from, fromlen, ss);
+                if (!rc)
+                    tr_ndbg ("UDP", "Unexpected UDP packet");
             }
         }
     }
 }
 
 void
-tr_udpInit(tr_session *ss)
+tr_udpInit (tr_session *ss)
 {
     bool is_default;
     const struct tr_address * public_addr;
     struct sockaddr_in sin;
     int rc;
 
-    assert(ss->udp_socket < 0);
-    assert(ss->udp6_socket < 0);
+    assert (ss->udp_socket < 0);
+    assert (ss->udp6_socket < 0);
 
-    ss->udp_port = tr_sessionGetPeerPort(ss);
-    if(ss->udp_port <= 0)
+    ss->udp_port = tr_sessionGetPeerPort (ss);
+    if (ss->udp_port <= 0)
         return;
 
-    ss->udp_socket = socket(PF_INET, SOCK_DGRAM, 0);
-    if(ss->udp_socket < 0) {
-        tr_nerr("UDP", "Couldn't create IPv4 socket");
+    ss->udp_socket = socket (PF_INET, SOCK_DGRAM, 0);
+    if (ss->udp_socket < 0) {
+        tr_nerr ("UDP", "Couldn't create IPv4 socket");
         goto ipv6;
     }
 
-    memset(&sin, 0, sizeof(sin));
+    memset (&sin, 0, sizeof (sin));
     sin.sin_family = AF_INET;
-    public_addr = tr_sessionGetPublicAddress(ss, TR_AF_INET, &is_default);
-    if(public_addr && !is_default)
-        memcpy(&sin.sin_addr, &public_addr->addr.addr4, sizeof (struct in_addr));
-    sin.sin_port = htons(ss->udp_port);
-    rc = bind(ss->udp_socket, (struct sockaddr*)&sin, sizeof(sin));
-    if(rc < 0) {
-        tr_nerr("UDP", "Couldn't bind IPv4 socket");
-        close(ss->udp_socket);
+    public_addr = tr_sessionGetPublicAddress (ss, TR_AF_INET, &is_default);
+    if (public_addr && !is_default)
+        memcpy (&sin.sin_addr, &public_addr->addr.addr4, sizeof (struct in_addr));
+    sin.sin_port = htons (ss->udp_port);
+    rc = bind (ss->udp_socket, (struct sockaddr*)&sin, sizeof (sin));
+    if (rc < 0) {
+        tr_nerr ("UDP", "Couldn't bind IPv4 socket");
+        close (ss->udp_socket);
         ss->udp_socket = -1;
         goto ipv6;
     }
     ss->udp_event =
-        event_new(ss->event_base, ss->udp_socket, EV_READ | EV_PERSIST,
+        event_new (ss->event_base, ss->udp_socket, EV_READ | EV_PERSIST,
                   event_callback, ss);
-    if( ss->udp_event == NULL )
-        tr_nerr("UDP", "Couldn't allocate IPv4 event");
+    if (ss->udp_event == NULL)
+        tr_nerr ("UDP", "Couldn't allocate IPv4 event");
 
  ipv6:
-    if(tr_globalIPv6())
-        rebind_ipv6(ss, true);
-    if(ss->udp6_socket >= 0) {
+    if (tr_globalIPv6 ())
+        rebind_ipv6 (ss, true);
+    if (ss->udp6_socket >= 0) {
         ss->udp6_event =
-            event_new(ss->event_base, ss->udp6_socket, EV_READ | EV_PERSIST,
+            event_new (ss->event_base, ss->udp6_socket, EV_READ | EV_PERSIST,
                       event_callback, ss);
-        if(ss->udp6_event == NULL)
-            tr_nerr("UDP", "Couldn't allocate IPv6 event");
+        if (ss->udp6_event == NULL)
+            tr_nerr ("UDP", "Couldn't allocate IPv6 event");
     }
 
-    tr_udpSetSocketBuffers(ss);
+    tr_udpSetSocketBuffers (ss);
 
-    if(ss->isDHTEnabled)
-        tr_dhtInit(ss);
+    if (ss->isDHTEnabled)
+        tr_dhtInit (ss);
 
-    if(ss->udp_event)
-        event_add(ss->udp_event, NULL);
-    if(ss->udp6_event)
-        event_add(ss->udp6_event, NULL);
+    if (ss->udp_event)
+        event_add (ss->udp_event, NULL);
+    if (ss->udp6_event)
+        event_add (ss->udp6_event, NULL);
 }
 
 void
-tr_udpUninit(tr_session *ss)
+tr_udpUninit (tr_session *ss)
 {
-    tr_dhtUninit(ss);
+    tr_dhtUninit (ss);
 
-    if(ss->udp_socket >= 0) {
-        tr_netCloseSocket( ss->udp_socket );
+    if (ss->udp_socket >= 0) {
+        tr_netCloseSocket (ss->udp_socket);
         ss->udp_socket = -1;
     }
 
-    if(ss->udp_event) {
-        event_free(ss->udp_event);
+    if (ss->udp_event) {
+        event_free (ss->udp_event);
         ss->udp_event = NULL;
     }
 
-    if(ss->udp6_socket >= 0) {
-        tr_netCloseSocket( ss->udp6_socket );
+    if (ss->udp6_socket >= 0) {
+        tr_netCloseSocket (ss->udp6_socket);
         ss->udp6_socket = -1;
     }
 
-    if(ss->udp6_event) {
-        event_free(ss->udp6_event);
+    if (ss->udp6_event) {
+        event_free (ss->udp6_event);
         ss->udp6_event = NULL;
     }
 
-    if(ss->udp6_bound) {
-        free(ss->udp6_bound);
+    if (ss->udp6_bound) {
+        free (ss->udp6_bound);
         ss->udp6_bound = NULL;
     }
 }
diff --git a/libtransmission/tr-udp.h b/libtransmission/tr-udp.h
index bd34b9b4d..48936edb3 100644
--- a/libtransmission/tr-udp.h
+++ b/libtransmission/tr-udp.h
@@ -28,11 +28,11 @@ THE SOFTWARE.
  #error only libtransmission should #include this header.
 #endif
 
-void tr_udpInit( tr_session * );
-void tr_udpUninit( tr_session * );
-void tr_udpSetSocketBuffers(tr_session *);
+void tr_udpInit (tr_session *);
+void tr_udpUninit (tr_session *);
+void tr_udpSetSocketBuffers (tr_session *);
 
-bool tau_handle_message( tr_session * session,
-                         const uint8_t  * msg, size_t msglen );
+bool tau_handle_message (tr_session * session,
+                         const uint8_t  * msg, size_t msglen);
 
 #endif /* #ifndef TR_UDP_H */
diff --git a/libtransmission/tr-utp.c b/libtransmission/tr-utp.c
index 2d78e67bf..f7eb7d0f1 100644
--- a/libtransmission/tr-utp.c
+++ b/libtransmission/tr-utp.c
@@ -30,51 +30,51 @@ THE SOFTWARE.
 #include "transmission.h"
 #include "net.h"
 #include "session.h"
-#include "crypto.h" /* tr_cryptoWeakRandInt() */
+#include "crypto.h" /* tr_cryptoWeakRandInt () */
 #include "peer-mgr.h"
 #include "tr-utp.h"
 #include "utils.h"
 
 #define MY_NAME "UTP"
 
-#define dbgmsg( ... ) \
+#define dbgmsg(...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, MY_NAME, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, MY_NAME, __VA_ARGS__); \
+    } while (0)
 
 #ifndef WITH_UTP
 
 void
-UTP_Close(struct UTPSocket * socket)
+UTP_Close (struct UTPSocket * socket)
 {
-    tr_nerr( MY_NAME, "UTP_Close(%p) was called.", socket );
-    dbgmsg( "UTP_Close(%p) was called.", socket );
-    assert( 0 ); /* FIXME: this is too much for the long term, but probably needed in the short term */
+    tr_nerr (MY_NAME, "UTP_Close (%p) was called.", socket);
+    dbgmsg ("UTP_Close (%p) was called.", socket);
+    assert (0); /* FIXME: this is too much for the long term, but probably needed in the short term */
 }
 
 void
-UTP_RBDrained(struct UTPSocket *socket)
+UTP_RBDrained (struct UTPSocket *socket)
 {
-    tr_nerr( MY_NAME, "UTP_RBDrained(%p) was called.", socket );
-    dbgmsg( "UTP_RBDrained(%p) was called.", socket );
-    assert( 0 ); /* FIXME: this is too much for the long term, but probably needed in the short term */
+    tr_nerr (MY_NAME, "UTP_RBDrained (%p) was called.", socket);
+    dbgmsg ("UTP_RBDrained (%p) was called.", socket);
+    assert (0); /* FIXME: this is too much for the long term, but probably needed in the short term */
 }
 
 bool
-UTP_Write(struct UTPSocket *socket, size_t count)
+UTP_Write (struct UTPSocket *socket, size_t count)
 {
-    tr_nerr( MY_NAME, "UTP_RBDrained(%p, %zu) was called.", socket, count );
-    dbgmsg( "UTP_RBDrained(%p, %zu) was called.", socket, count );
-    assert( 0 ); /* FIXME: this is too much for the long term, but probably needed in the short term */
+    tr_nerr (MY_NAME, "UTP_RBDrained (%p, %zu) was called.", socket, count);
+    dbgmsg ("UTP_RBDrained (%p, %zu) was called.", socket, count);
+    assert (0); /* FIXME: this is too much for the long term, but probably needed in the short term */
     return false;
 }
 
-int tr_utpPacket(const unsigned char *buf UNUSED, size_t buflen UNUSED,
+int tr_utpPacket (const unsigned char *buf UNUSED, size_t buflen UNUSED,
                  const struct sockaddr *from UNUSED, socklen_t fromlen UNUSED,
                  tr_session *ss UNUSED) { return -1; }
 
-struct UTPSocket *UTP_Create(SendToProc *send_to_proc UNUSED,
+struct UTPSocket *UTP_Create (SendToProc *send_to_proc UNUSED,
                              void *send_to_userdata UNUSED,
                              const struct sockaddr *addr UNUSED,
                              socklen_t addrlen UNUSED)
@@ -83,9 +83,9 @@ struct UTPSocket *UTP_Create(SendToProc *send_to_proc UNUSED,
     return NULL;
 }
 
-void tr_utpClose( tr_session * ss UNUSED ) { }
+void tr_utpClose (tr_session * ss UNUSED) { }
 
-void tr_utpSendTo(void *closure UNUSED,
+void tr_utpSendTo (void *closure UNUSED,
                   const unsigned char *buf UNUSED, size_t buflen UNUSED,
                   const struct sockaddr *to UNUSED, socklen_t tolen UNUSED) { }
 
@@ -98,51 +98,51 @@ void tr_utpSendTo(void *closure UNUSED,
 static struct event *utp_timer = NULL;
 
 static void
-incoming(void *closure, struct UTPSocket *s)
+incoming (void *closure, struct UTPSocket *s)
 {
     tr_session *ss = closure;
     struct sockaddr_storage from_storage;
     struct sockaddr *from = (struct sockaddr*)&from_storage;
-    socklen_t fromlen = sizeof(from_storage);
+    socklen_t fromlen = sizeof (from_storage);
     tr_address addr;
     tr_port port;
 
-    if( !tr_sessionIsUTPEnabled(ss) ) {
-        UTP_Close(s);
+    if (!tr_sessionIsUTPEnabled (ss)) {
+        UTP_Close (s);
         return;
     }
 
-    UTP_GetPeerName(s, from, &fromlen);
-    if( !tr_address_from_sockaddr_storage( &addr, &port, &from_storage ) )
+    UTP_GetPeerName (s, from, &fromlen);
+    if (!tr_address_from_sockaddr_storage (&addr, &port, &from_storage))
     {
-        tr_nerr("UTP", "Unknown socket family");
-        UTP_Close(s);
+        tr_nerr ("UTP", "Unknown socket family");
+        UTP_Close (s);
         return;
     }
 
-    tr_peerMgrAddIncoming(ss->peerMgr, &addr, port, -1, s);
+    tr_peerMgrAddIncoming (ss->peerMgr, &addr, port, -1, s);
 }
 
 void
-tr_utpSendTo(void *closure, const unsigned char *buf, size_t buflen,
+tr_utpSendTo (void *closure, const unsigned char *buf, size_t buflen,
              const struct sockaddr *to, socklen_t tolen)
 {
     tr_session *ss = closure;
 
-    if(to->sa_family == AF_INET && ss->udp_socket)
-        sendto(ss->udp_socket, buf, buflen, 0, to, tolen);
-    else if(to->sa_family == AF_INET6 && ss->udp_socket)
-        sendto(ss->udp6_socket, buf, buflen, 0, to, tolen);
+    if (to->sa_family == AF_INET && ss->udp_socket)
+        sendto (ss->udp_socket, buf, buflen, 0, to, tolen);
+    else if (to->sa_family == AF_INET6 && ss->udp_socket)
+        sendto (ss->udp6_socket, buf, buflen, 0, to, tolen);
 }
 
 static void
-reset_timer(tr_session *ss)
+reset_timer (tr_session *ss)
 {
     int sec;
     int usec;
-    if( tr_sessionIsUTPEnabled( ss ) ) {
+    if (tr_sessionIsUTPEnabled (ss)) {
         sec = 0;
-        usec = UTP_INTERVAL_US / 2 + tr_cryptoWeakRandInt(UTP_INTERVAL_US);
+        usec = UTP_INTERVAL_US / 2 + tr_cryptoWeakRandInt (UTP_INTERVAL_US);
     } else {
         /* If somebody has disabled uTP, then we still want to run
            UTP_CheckTimeouts, in order to let closed sockets finish
@@ -150,42 +150,42 @@ reset_timer(tr_session *ss)
            interested in that happening in a timely manner, we might as
            well use a large timeout. */
         sec = 2;
-        usec = tr_cryptoWeakRandInt( 1000000 );
+        usec = tr_cryptoWeakRandInt (1000000);
     }
-    tr_timerAdd( utp_timer, sec, usec );
+    tr_timerAdd (utp_timer, sec, usec);
 }
 
 static void
-timer_callback(int s UNUSED, short type UNUSED, void *closure)
+timer_callback (int s UNUSED, short type UNUSED, void *closure)
 {
     tr_session *ss = closure;
-    UTP_CheckTimeouts();
-    reset_timer( ss );
+    UTP_CheckTimeouts ();
+    reset_timer (ss);
 }
 
 int
-tr_utpPacket(const unsigned char *buf, size_t buflen,
+tr_utpPacket (const unsigned char *buf, size_t buflen,
              const struct sockaddr *from, socklen_t fromlen,
              tr_session *ss)
 {
-    if( !ss->isClosed && !utp_timer )
+    if (!ss->isClosed && !utp_timer)
     {
-        utp_timer = evtimer_new( ss->event_base, timer_callback, ss );
-        if(utp_timer == NULL)
+        utp_timer = evtimer_new (ss->event_base, timer_callback, ss);
+        if (utp_timer == NULL)
             return -1;
-        reset_timer( ss );
+        reset_timer (ss);
     }
 
-    return UTP_IsIncomingUTP(incoming, tr_utpSendTo, ss,
+    return UTP_IsIncomingUTP (incoming, tr_utpSendTo, ss,
                              buf, buflen, from, fromlen);
 }
 
 void
-tr_utpClose( tr_session * session UNUSED )
+tr_utpClose (tr_session * session UNUSED)
 {
-    if( utp_timer )
+    if (utp_timer)
     {
-        evtimer_del( utp_timer );
+        evtimer_del (utp_timer);
         utp_timer = NULL;
     }
 }
diff --git a/libtransmission/tr-utp.h b/libtransmission/tr-utp.h
index c46ec407d..9f17d2589 100644
--- a/libtransmission/tr-utp.h
+++ b/libtransmission/tr-utp.h
@@ -28,13 +28,13 @@ THE SOFTWARE.
 #ifndef _TR_UTP_H_
 #define _TR_UTP_H_
 
-int tr_utpPacket(const unsigned char *buf, size_t buflen,
+int tr_utpPacket (const unsigned char *buf, size_t buflen,
                  const struct sockaddr *from, socklen_t fromlen,
                  tr_session *ss);
 
-void tr_utpClose( tr_session * );
+void tr_utpClose (tr_session *);
 
-void tr_utpSendTo(void *closure, const unsigned char *buf, size_t buflen,
+void tr_utpSendTo (void *closure, const unsigned char *buf, size_t buflen,
                   const struct sockaddr *to, socklen_t tolen);
 
 #endif /* #ifndef _TR_UTP_H_ */
diff --git a/libtransmission/transmission.h b/libtransmission/transmission.h
index 5402ea436..b91f8ae05 100644
--- a/libtransmission/transmission.h
+++ b/libtransmission/transmission.h
@@ -44,10 +44,10 @@ extern "C" {
 #include <inttypes.h> /* uintN_t */
 #include <time.h> /* time_t */
 
-#if !defined(__cplusplus)
+#if !defined (__cplusplus)
  #ifdef HAVE_STDBOOL_H
   #include <stdbool.h>
- #elif !defined(__bool_true_false_are_defined)
+ #elif !defined (__bool_true_false_are_defined)
   #define bool uint8_t
   #define true 1
   #define false 0
@@ -64,7 +64,7 @@ extern "C" {
  #define PRIu32 "lu"
 #endif
 
-#if defined(WIN32) && defined(_MSC_VER)
+#if defined (WIN32) && defined (_MSC_VER)
  #define inline __inline
 #endif
 
@@ -115,10 +115,10 @@ tr_encryption_mode;
 /**
  * @addtogroup tr_session Session
  *
- * A libtransmission session is created by calling tr_sessionInit().
+ * A libtransmission session is created by calling tr_sessionInit ().
  * libtransmission creates a thread for itself so that it can operate
  * independently of the caller's event loop. The session will continue
- * until tr_sessionClose() is called.
+ * until tr_sessionClose () is called.
  *
  * @{
  */
@@ -133,7 +133,7 @@ tr_encryption_mode;
  * -# If XDG_CONFIG_HOME is set, "${XDG_CONFIG_HOME}/${appname}" is used.
  * -# ${HOME}/.config/${appname}" is used as a last resort.
  */
-const char* tr_getDefaultConfigDir( const char * appname );
+const char* tr_getDefaultConfigDir (const char * appname);
 
 /**
  * @brief returns Transmisson's default download directory.
@@ -141,9 +141,9 @@ const char* tr_getDefaultConfigDir( const char * appname );
  * The default download directory is determined this way:
  * -# If the HOME environment variable is set, "${HOME}/Downloads" is used.
  * -# On Windows, "${CSIDL_MYDOCUMENTS}/Downloads" is used.
- * -# Otherwise, getpwuid(getuid())->pw_dir + "/Downloads" is used.
+ * -# Otherwise, getpwuid (getuid ())->pw_dir + "/Downloads" is used.
  */
-const char* tr_getDefaultDownloadDir( void );
+const char* tr_getDefaultDownloadDir (void);
 
 
 #define TR_DEFAULT_BIND_ADDRESS_IPV4        "0.0.0.0"
@@ -229,19 +229,19 @@ const char* tr_getDefaultDownloadDir( void );
  *     tr_benc settings;
  *     int64_t i;
  *
- *     tr_bencInitDict( &settings, 0 );
- *     tr_sessionGetDefaultSettings( &settings );
- *     if( tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT, &i ) )
- *         fprintf( stderr, "the default peer port is %d\n", (int)i );
- *     tr_bencFree( &settings );
+ *     tr_bencInitDict (&settings, 0);
+ *     tr_sessionGetDefaultSettings (&settings);
+ *     if (tr_bencDictFindInt (&settings, TR_PREFS_KEY_PEER_PORT, &i))
+ *         fprintf (stderr, "the default peer port is %d\n", (int)i);
+ *     tr_bencFree (&settings);
  * @endcode
  *
  * @param initme pointer to a tr_benc dictionary
- * @see tr_sessionLoadSettings()
- * @see tr_sessionInit()
- * @see tr_getDefaultConfigDir()
+ * @see tr_sessionLoadSettings ()
+ * @see tr_sessionInit ()
+ * @see tr_getDefaultConfigDir ()
  */
-void tr_sessionGetDefaultSettings( struct tr_benc * dictionary );
+void tr_sessionGetDefaultSettings (struct tr_benc * dictionary);
 
 /**
  * Add the session's current configuration settings to the benc dictionary.
@@ -250,9 +250,9 @@ void tr_sessionGetDefaultSettings( struct tr_benc * dictionary );
  *
  * @param session
  * @param dictionary
- * @see tr_sessionGetDefaultSettings()
+ * @see tr_sessionGetDefaultSettings ()
  */
-void tr_sessionGetSettings( tr_session *, struct tr_benc * dictionary );
+void tr_sessionGetSettings (tr_session *, struct tr_benc * dictionary);
 
 /**
  * Load settings from the configuration directory's settings.json file,
@@ -264,13 +264,13 @@ void tr_sessionGetSettings( tr_session *, struct tr_benc * dictionary );
  * @param configDir the configuration directory to find settings.json
  * @param appName if configDir is empty, appName is used to find the default dir.
  * @return success true if the settings were loaded, false otherwise
- * @see tr_sessionGetDefaultSettings()
- * @see tr_sessionInit()
- * @see tr_sessionSaveSettings()
+ * @see tr_sessionGetDefaultSettings ()
+ * @see tr_sessionInit ()
+ * @see tr_sessionSaveSettings ()
  */
-bool tr_sessionLoadSettings( struct tr_benc  * dictionary,
+bool tr_sessionLoadSettings (struct tr_benc  * dictionary,
                              const char      * configDir,
-                             const char      * appName );
+                             const char      * appName);
 
 /**
  * Add the session's configuration settings to the benc dictionary
@@ -280,11 +280,11 @@ bool tr_sessionLoadSettings( struct tr_benc  * dictionary,
  *
  * @param session
  * @param dictionary
- * @see tr_sessionLoadSettings()
+ * @see tr_sessionLoadSettings ()
  */
-void tr_sessionSaveSettings( tr_session           * session,
+void tr_sessionSaveSettings (tr_session           * session,
                              const char           * configDir,
-                             const struct tr_benc * dictonary );
+                             const struct tr_benc * dictonary);
 
 /**
  * @brief Initialize a libtransmission session.
@@ -295,81 +295,81 @@ void tr_sessionSaveSettings( tr_session           * session,
  *     tr_session * session;
  *     const char * configDir;
  *
- *     tr_bencInitDict( &settings, 0 );
- *     tr_sessionGetDefaultSettings( &settings );
- *     configDir = tr_getDefaultConfigDir( "Transmission" );
- *     session = tr_sessionInit( "mac", configDir, true, &settings );
+ *     tr_bencInitDict (&settings, 0);
+ *     tr_sessionGetDefaultSettings (&settings);
+ *     configDir = tr_getDefaultConfigDir ("Transmission");
+ *     session = tr_sessionInit ("mac", configDir, true, &settings);
  *
- *     tr_bencFree( &settings );
+ *     tr_bencFree (&settings);
  * @endcode
  *
  * @param tag "gtk", "macosx", "daemon", etc... this is only for pre-1.30 resume files
  * @param configDir where Transmission will look for resume files, blocklists, etc.
  * @param messageQueueingEnabled if false, messages will be dumped to stderr
  * @param settings libtransmission settings
- * @see tr_sessionGetDefaultSettings()
- * @see tr_sessionLoadSettings()
- * @see tr_getDefaultConfigDir()
+ * @see tr_sessionGetDefaultSettings ()
+ * @see tr_sessionLoadSettings ()
+ * @see tr_getDefaultConfigDir ()
  */
-tr_session * tr_sessionInit( const char     * tag,
+tr_session * tr_sessionInit (const char     * tag,
                              const char     * configDir,
                              bool             messageQueueingEnabled,
-                             struct tr_benc * settings );
+                             struct tr_benc * settings);
 
 /** @brief Update a session's settings from a benc dictionary
-           like to the one used in tr_sessionInit() */
-void tr_sessionSet( tr_session      * session,
-                    struct tr_benc  * settings );
+           like to the one used in tr_sessionInit () */
+void tr_sessionSet (tr_session      * session,
+                    struct tr_benc  * settings);
 
 /** @brief Rescan the blocklists directory and
            reload whatever blocklist files are found there */
-void tr_sessionReloadBlocklists( tr_session * session );
+void tr_sessionReloadBlocklists (tr_session * session);
 
 
 /** @brief End a libtransmission session
-    @see tr_sessionInit() */
-void tr_sessionClose( tr_session * );
+    @see tr_sessionInit () */
+void tr_sessionClose (tr_session *);
 
 /**
  * @brief Return the session's configuration directory.
  *
  * This is where transmission stores its .torrent files, .resume files,
- * blocklists, etc. It's set in tr_transmissionInit() and is immutable
+ * blocklists, etc. It's set in tr_transmissionInit () and is immutable
  * during the session.
  */
-const char * tr_sessionGetConfigDir( const tr_session * );
+const char * tr_sessionGetConfigDir (const tr_session *);
 
 /**
  * @brief Set the per-session default download folder for new torrents.
- * @see tr_sessionInit()
- * @see tr_sessionGetDownloadDir()
- * @see tr_ctorSetDownloadDir()
+ * @see tr_sessionInit ()
+ * @see tr_sessionGetDownloadDir ()
+ * @see tr_ctorSetDownloadDir ()
  */
-void tr_sessionSetDownloadDir( tr_session * session, const char * downloadDir );
+void tr_sessionSetDownloadDir (tr_session * session, const char * downloadDir);
 
 /**
  * @brief Get the default download folder for new torrents.
  *
- * This is set by tr_sessionInit() or tr_sessionSetDownloadDir(),
- * and can be overridden on a per-torrent basis by tr_ctorSetDownloadDir().
+ * This is set by tr_sessionInit () or tr_sessionSetDownloadDir (),
+ * and can be overridden on a per-torrent basis by tr_ctorSetDownloadDir ().
  */
-const char * tr_sessionGetDownloadDir( const tr_session * session );
+const char * tr_sessionGetDownloadDir (const tr_session * session);
 
 /**
  * @brief Get available disk space (in bytes) for the default download folder.
  * @return zero or positive integer on success, -1 in case of error.
  */
-int64_t tr_sessionGetDownloadDirFreeSpace( const tr_session * session );
+int64_t tr_sessionGetDownloadDirFreeSpace (const tr_session * session);
 
 /**
  * @brief Set the torrent's bandwidth priority.
  */
-void tr_ctorSetBandwidthPriority( tr_ctor * ctor, tr_priority_t priority );
+void tr_ctorSetBandwidthPriority (tr_ctor * ctor, tr_priority_t priority);
 
 /**
  * @brief Get the torrent's bandwidth priority.
  */
-tr_priority_t tr_ctorGetBandwidthPriority( const tr_ctor * ctor );
+tr_priority_t tr_ctorGetBandwidthPriority (const tr_ctor * ctor);
 
 
 /**
@@ -382,25 +382,25 @@ tr_priority_t tr_ctorGetBandwidthPriority( const tr_ctor * ctor );
  * Torrents aren't moved as a result of changing the session's incomplete dir --
  * it's applied to new torrents, not existing ones.
  *
- * tr_torrentSetLocation() overrules the incomplete dir: when a user specifies
+ * tr_torrentSetLocation () overrules the incomplete dir: when a user specifies
  * a new location, that becomes the torrent's new downloadDir and the torrent
  * is moved there immediately regardless of whether or not it's complete.
  *
- * @see tr_sessionInit()
- * @see tr_sessionGetIncompleteDir()
- * @see tr_sessionSetIncompleteDirEnabled()
- * @see tr_sessionGetIncompleteDirEnabled()
+ * @see tr_sessionInit ()
+ * @see tr_sessionGetIncompleteDir ()
+ * @see tr_sessionSetIncompleteDirEnabled ()
+ * @see tr_sessionGetIncompleteDirEnabled ()
  */
-void tr_sessionSetIncompleteDir( tr_session * session, const char * dir );
+void tr_sessionSetIncompleteDir (tr_session * session, const char * dir);
 
 /** @brief get the per-session incomplete download folder */
-const char* tr_sessionGetIncompleteDir( const tr_session * session );
+const char* tr_sessionGetIncompleteDir (const tr_session * session);
 
 /** @brief enable or disable use of the incomplete download folder */
-void tr_sessionSetIncompleteDirEnabled( tr_session * session, bool );
+void tr_sessionSetIncompleteDirEnabled (tr_session * session, bool);
 
 /** @brief get whether or not the incomplete download folder is enabled */
-bool tr_sessionIsIncompleteDirEnabled( const tr_session * session );
+bool tr_sessionIsIncompleteDirEnabled (const tr_session * session);
 
 
 /**
@@ -410,12 +410,12 @@ bool tr_sessionIsIncompleteDirEnabled( const tr_session * session );
  * This is not retroactive -- toggling this will not rename existing files.
  * It only applies to new files created by Transmission after this API call.
  *
- * @see tr_sessionIsIncompleteFileNamingEnabled()
+ * @see tr_sessionIsIncompleteFileNamingEnabled ()
  */
-void tr_sessionSetIncompleteFileNamingEnabled( tr_session * session, bool );
+void tr_sessionSetIncompleteFileNamingEnabled (tr_session * session, bool);
 
 /** @brief return true if files will end in ".part" until they're complete */
-bool tr_sessionIsIncompleteFileNamingEnabled( const tr_session * session );
+bool tr_sessionIsIncompleteFileNamingEnabled (const tr_session * session);
 
 /**
  * @brief Set whether or not RPC calls are allowed in this session.
@@ -423,27 +423,27 @@ bool tr_sessionIsIncompleteFileNamingEnabled( const tr_session * session );
  * @details If true, libtransmission will open a server socket to listen
  * for incoming http RPC requests as described in docs/rpc-spec.txt.
  *
- * This is intially set by tr_sessionInit() and can be
- * queried by tr_sessionIsRPCEnabled().
+ * This is intially set by tr_sessionInit () and can be
+ * queried by tr_sessionIsRPCEnabled ().
  */
-void tr_sessionSetRPCEnabled( tr_session  * session,
-                              bool          isEnabled );
+void tr_sessionSetRPCEnabled (tr_session  * session,
+                              bool          isEnabled);
 
 /** @brief Get whether or not RPC calls are allowed in this session.
-    @see tr_sessionInit()
-    @see tr_sessionSetRPCEnabled() */
-bool tr_sessionIsRPCEnabled( const tr_session * session );
+    @see tr_sessionInit ()
+    @see tr_sessionSetRPCEnabled () */
+bool tr_sessionIsRPCEnabled (const tr_session * session);
 
 /** @brief Specify which port to listen for RPC requests on.
-    @see tr_sessionInit()
+    @see tr_sessionInit ()
     @see tr_sessionGetRPCPort */
-void tr_sessionSetRPCPort( tr_session  * session,
-                           tr_port       port );
+void tr_sessionSetRPCPort (tr_session  * session,
+                           tr_port       port);
 
 /** @brief Get which port to listen for RPC requests on.
-    @see tr_sessionInit()
+    @see tr_sessionInit ()
     @see tr_sessionSetRPCPort */
-tr_port tr_sessionGetRPCPort( const tr_session * session );
+tr_port tr_sessionGetRPCPort (const tr_session * session);
 
 /**
  * @brief Specify which base URL to use.
@@ -453,15 +453,15 @@ tr_port tr_sessionGetRPCPort( const tr_session * session );
  *
  *  @see tr_sessionGetRPCUrl
  */
-void tr_sessionSetRPCUrl( tr_session  * session,
-                          const char * url );
+void tr_sessionSetRPCUrl (tr_session  * session,
+                          const char * url);
 
 /**
  * @brief Get the base URL.
- * @see tr_sessionInit()
+ * @see tr_sessionInit ()
  * @see tr_sessionSetRPCUrl
  */
-const char* tr_sessionGetRPCUrl( const tr_session * session );
+const char* tr_sessionGetRPCUrl (const tr_session * session);
 
 /**
  * @brief Specify a whitelist for remote RPC access
@@ -471,40 +471,40 @@ const char* tr_sessionGetRPCUrl( const tr_session * session );
  * '?' is interpreted as a single-character wildcard and
  * '*' is interprted as a multi-character wildcard.
  */
-void   tr_sessionSetRPCWhitelist( tr_session * session,
-                                  const char * whitelist );
+void   tr_sessionSetRPCWhitelist (tr_session * session,
+                                  const char * whitelist);
 
 /** @brief get the Access Control List for allowing/denying RPC requests.
     @return a comma-separated string of whitelist domains.
     @see tr_sessionInit
     @see tr_sessionSetRPCWhitelist */
-const char* tr_sessionGetRPCWhitelist( const tr_session * );
+const char* tr_sessionGetRPCWhitelist (const tr_session *);
 
-void  tr_sessionSetRPCWhitelistEnabled( tr_session * session,
-                                        bool         isEnabled );
+void  tr_sessionSetRPCWhitelistEnabled (tr_session * session,
+                                        bool         isEnabled);
 
-bool tr_sessionGetRPCWhitelistEnabled( const tr_session * session );
+bool tr_sessionGetRPCWhitelistEnabled (const tr_session * session);
 
-void  tr_sessionSetRPCPassword( tr_session * session,
-                                const char * password );
+void  tr_sessionSetRPCPassword (tr_session * session,
+                                const char * password);
 
-void  tr_sessionSetRPCUsername( tr_session * session,
-                                const char * username );
+void  tr_sessionSetRPCUsername (tr_session * session,
+                                const char * username);
 
 /** @brief get the password used to restrict RPC requests.
     @return the password string.
-    @see tr_sessionInit()
-    @see tr_sessionSetRPCPassword() */
-const char* tr_sessionGetRPCPassword( const tr_session * session );
+    @see tr_sessionInit ()
+    @see tr_sessionSetRPCPassword () */
+const char* tr_sessionGetRPCPassword (const tr_session * session);
 
-const char* tr_sessionGetRPCUsername( const tr_session * session  );
+const char* tr_sessionGetRPCUsername (const tr_session * session);
 
-void  tr_sessionSetRPCPasswordEnabled( tr_session * session,
-                                       bool         isEnabled );
+void  tr_sessionSetRPCPasswordEnabled (tr_session * session,
+                                       bool         isEnabled);
 
-bool tr_sessionIsRPCPasswordEnabled( const tr_session * session );
+bool tr_sessionIsRPCPasswordEnabled (const tr_session * session);
 
-const char* tr_sessionGetRPCBindAddress( const tr_session * session );
+const char* tr_sessionGetRPCBindAddress (const tr_session * session);
 
 
 typedef enum
@@ -531,14 +531,14 @@ typedef enum
      * removing the torrent itself. For example the client may
      * need to keep the torrent alive long enough to cleanly close
      * some resources in another thread. */
-    TR_RPC_NOREMOVE   = ( 1 << 1 )
+    TR_RPC_NOREMOVE   = (1 << 1)
 }
 tr_rpc_callback_status;
 
 typedef tr_rpc_callback_status (*tr_rpc_func)(tr_session          * session,
                                               tr_rpc_callback_type  type,
                                               struct tr_torrent   * tor_or_null,
-                                              void                * user_data );
+                                              void                * user_data);
 
 /**
  * Register to be notified whenever something is changed via RPC,
@@ -549,15 +549,15 @@ typedef tr_rpc_callback_status (*tr_rpc_func)(tr_session          * session,
  * shouldn't call libtransmission functions (to avoid deadlock),
  * and shouldn't modify client-level memory without using a mutex!
  */
-void tr_sessionSetRPCCallback( tr_session   * session,
+void tr_sessionSetRPCCallback (tr_session   * session,
                                tr_rpc_func    func,
-                               void         * user_data );
+                               void         * user_data);
 
 /**
 ***
 **/
 
-/** @brief Used by tr_sessionGetStats() and tr_sessionGetCumulativeStats() */
+/** @brief Used by tr_sessionGetStats () and tr_sessionGetCumulativeStats () */
 typedef struct tr_session_stats
 {
     float       ratio;        /* TR_RATIO_INF, TR_RATIO_NA, or total up/down */
@@ -570,14 +570,14 @@ typedef struct tr_session_stats
 tr_session_stats;
 
 /** @brief Get bandwidth use statistics for the current session */
-void tr_sessionGetStats( const tr_session * session,
-                         tr_session_stats * setme );
+void tr_sessionGetStats (const tr_session * session,
+                         tr_session_stats * setme);
 
 /** @brief Get cumulative bandwidth statistics for current and past sessions */
-void tr_sessionGetCumulativeStats( const tr_session * session,
-                                   tr_session_stats * setme );
+void tr_sessionGetCumulativeStats (const tr_session * session,
+                                   tr_session_stats * setme);
 
-void tr_sessionClearStats( tr_session * session );
+void tr_sessionClearStats (tr_session * session);
 
 /**
  * @brief Set whether or not torrents are allowed to do peer exchanges.
@@ -585,45 +585,45 @@ void tr_sessionClearStats( tr_session * session );
  * PEX is always disabled in private torrents regardless of this.
  * In public torrents, PEX is enabled by default.
  */
-void  tr_sessionSetPexEnabled( tr_session  * session, bool isEnabled );
-bool  tr_sessionIsPexEnabled( const tr_session * session );
+void  tr_sessionSetPexEnabled (tr_session  * session, bool isEnabled);
+bool  tr_sessionIsPexEnabled (const tr_session * session);
 
-bool  tr_sessionIsDHTEnabled( const tr_session * session );
-void  tr_sessionSetDHTEnabled( tr_session * session, bool );
+bool  tr_sessionIsDHTEnabled (const tr_session * session);
+void  tr_sessionSetDHTEnabled (tr_session * session, bool);
 
-bool  tr_sessionIsUTPEnabled( const tr_session * session );
-void  tr_sessionSetUTPEnabled( tr_session * session, bool );
+bool  tr_sessionIsUTPEnabled (const tr_session * session);
+void  tr_sessionSetUTPEnabled (tr_session * session, bool);
 
-bool  tr_sessionIsLPDEnabled( const tr_session * session );
-void  tr_sessionSetLPDEnabled( tr_session * session, bool enabled );
+bool  tr_sessionIsLPDEnabled (const tr_session * session);
+void  tr_sessionSetLPDEnabled (tr_session * session, bool enabled);
 
-void  tr_sessionSetCacheLimit_MB( tr_session * session, int mb );
-int   tr_sessionGetCacheLimit_MB( const tr_session * session );
+void  tr_sessionSetCacheLimit_MB (tr_session * session, int mb);
+int   tr_sessionGetCacheLimit_MB (const tr_session * session);
 
-tr_encryption_mode tr_sessionGetEncryption( tr_session * session );
-void               tr_sessionSetEncryption( tr_session * session,
-                                            tr_encryption_mode    mode );
+tr_encryption_mode tr_sessionGetEncryption (tr_session * session);
+void               tr_sessionSetEncryption (tr_session * session,
+                                            tr_encryption_mode    mode);
 
 
 /***********************************************************************
 ** Incoming Peer Connections Port
 */
 
-void  tr_sessionSetPortForwardingEnabled( tr_session  * session,
-                                          bool          enabled );
+void  tr_sessionSetPortForwardingEnabled (tr_session  * session,
+                                          bool          enabled);
 
-bool tr_sessionIsPortForwardingEnabled( const tr_session  * session );
+bool tr_sessionIsPortForwardingEnabled (const tr_session  * session);
 
-void  tr_sessionSetPeerPort( tr_session  * session,
+void  tr_sessionSetPeerPort (tr_session  * session,
                              tr_port       port);
 
-tr_port tr_sessionGetPeerPort( const tr_session * session );
+tr_port tr_sessionGetPeerPort (const tr_session * session);
 
-tr_port tr_sessionSetPeerPortRandom( tr_session  * session );
+tr_port tr_sessionSetPeerPortRandom (tr_session  * session);
 
-void  tr_sessionSetPeerPortRandomOnStart( tr_session * session, bool random );
+void  tr_sessionSetPeerPortRandomOnStart (tr_session * session, bool random);
 
-bool  tr_sessionGetPeerPortRandomOnStart( tr_session * session );
+bool  tr_sessionGetPeerPortRandomOnStart (tr_session * session);
 
 typedef enum
 {
@@ -635,7 +635,7 @@ typedef enum
 }
 tr_port_forwarding;
 
-tr_port_forwarding tr_sessionGetPortForwarding( const tr_session * session );
+tr_port_forwarding tr_sessionGetPortForwarding (const tr_session * session);
 
 typedef enum
 {
@@ -652,31 +652,31 @@ tr_direction;
 ****  Primary session speed limits
 ***/
 
-void         tr_sessionSetSpeedLimit_KBps ( tr_session *, tr_direction, unsigned int KBps );
-unsigned int tr_sessionGetSpeedLimit_KBps ( const tr_session *, tr_direction );
+void         tr_sessionSetSpeedLimit_KBps (tr_session *, tr_direction, unsigned int KBps);
+unsigned int tr_sessionGetSpeedLimit_KBps (const tr_session *, tr_direction);
 
-void  tr_sessionLimitSpeed         ( tr_session *, tr_direction, bool );
-bool  tr_sessionIsSpeedLimited     ( const tr_session *, tr_direction );
+void  tr_sessionLimitSpeed       (tr_session *, tr_direction, bool);
+bool  tr_sessionIsSpeedLimited   (const tr_session *, tr_direction);
 
 
 /***
 ****  Alternative speed limits that are used during scheduled times
 ***/
 
-void         tr_sessionSetAltSpeed_KBps   ( tr_session *, tr_direction, unsigned int Bps );
-unsigned int tr_sessionGetAltSpeed_KBps   ( const tr_session *, tr_direction );
+void         tr_sessionSetAltSpeed_KBps (tr_session *, tr_direction, unsigned int Bps);
+unsigned int tr_sessionGetAltSpeed_KBps (const tr_session *, tr_direction);
 
-void     tr_sessionUseAltSpeed        ( tr_session *, bool );
-bool     tr_sessionUsesAltSpeed       ( const tr_session * );
+void     tr_sessionUseAltSpeed      (tr_session *, bool);
+bool     tr_sessionUsesAltSpeed     (const tr_session *);
 
-void     tr_sessionUseAltSpeedTime    ( tr_session *, bool );
-bool  tr_sessionUsesAltSpeedTime      ( const tr_session * );
+void     tr_sessionUseAltSpeedTime  (tr_session *, bool);
+bool  tr_sessionUsesAltSpeedTime    (const tr_session *);
 
-void     tr_sessionSetAltSpeedBegin   ( tr_session *, int minsSinceMidnight );
-int      tr_sessionGetAltSpeedBegin   ( const tr_session * );
+void     tr_sessionSetAltSpeedBegin (tr_session *, int minsSinceMidnight);
+int      tr_sessionGetAltSpeedBegin (const tr_session *);
 
-void     tr_sessionSetAltSpeedEnd     ( tr_session *, int minsSinceMidnight );
-int      tr_sessionGetAltSpeedEnd     ( const tr_session * );
+void     tr_sessionSetAltSpeedEnd   (tr_session *, int minsSinceMidnight);
+int      tr_sessionGetAltSpeedEnd   (const tr_session *);
 
 typedef enum
 {
@@ -694,54 +694,54 @@ typedef enum
 }
 tr_sched_day;
 
-void         tr_sessionSetAltSpeedDay ( tr_session *, tr_sched_day day );
-tr_sched_day tr_sessionGetAltSpeedDay ( const tr_session * );
+void         tr_sessionSetAltSpeedDay (tr_session *, tr_sched_day day);
+tr_sched_day tr_sessionGetAltSpeedDay (const tr_session *);
 
-typedef void ( tr_altSpeedFunc )( tr_session *,
+typedef void (tr_altSpeedFunc)(tr_session *,
                                   bool active,
                                   bool userDriven,
-                                  void * );
+                                  void *);
 
-void  tr_sessionClearAltSpeedFunc  ( tr_session * );
-void  tr_sessionSetAltSpeedFunc    ( tr_session *, tr_altSpeedFunc *, void * );
+void  tr_sessionClearAltSpeedFunc (tr_session *);
+void  tr_sessionSetAltSpeedFunc  (tr_session *, tr_altSpeedFunc *, void *);
 
 
-bool  tr_sessionGetActiveSpeedLimit_KBps( const tr_session  * session,
+bool  tr_sessionGetActiveSpeedLimit_KBps (const tr_session  * session,
                                           tr_direction        dir,
-                                          double            * setme );
+                                          double            * setme);
 
 /***
 ****
 ***/
 
-double     tr_sessionGetRawSpeed_KBps  ( const tr_session *, tr_direction );
+double     tr_sessionGetRawSpeed_KBps (const tr_session *, tr_direction);
 
-void       tr_sessionSetRatioLimited  ( tr_session *, bool isLimited );
-bool       tr_sessionIsRatioLimited   ( const tr_session * );
+void       tr_sessionSetRatioLimited (tr_session *, bool isLimited);
+bool       tr_sessionIsRatioLimited (const tr_session *);
 
-void       tr_sessionSetRatioLimit    ( tr_session *, double desiredRatio );
-double     tr_sessionGetRatioLimit    ( const tr_session * );
+void       tr_sessionSetRatioLimit  (tr_session *, double desiredRatio);
+double     tr_sessionGetRatioLimit  (const tr_session *);
 
-void       tr_sessionSetIdleLimited  ( tr_session *, bool isLimited );
-bool       tr_sessionIsIdleLimited   ( const tr_session * );
+void       tr_sessionSetIdleLimited (tr_session *, bool isLimited);
+bool       tr_sessionIsIdleLimited (const tr_session *);
 
-void       tr_sessionSetIdleLimit ( tr_session *, uint16_t idleMinutes );
-uint16_t   tr_sessionGetIdleLimit ( const tr_session * );
+void       tr_sessionSetIdleLimit (tr_session *, uint16_t idleMinutes);
+uint16_t   tr_sessionGetIdleLimit (const tr_session *);
 
-void       tr_sessionSetPeerLimit( tr_session *, uint16_t maxGlobalPeers );
-uint16_t   tr_sessionGetPeerLimit( const tr_session * );
+void       tr_sessionSetPeerLimit (tr_session *, uint16_t maxGlobalPeers);
+uint16_t   tr_sessionGetPeerLimit (const tr_session *);
 
-void       tr_sessionSetPeerLimitPerTorrent( tr_session *, uint16_t maxPeers );
-uint16_t   tr_sessionGetPeerLimitPerTorrent( const tr_session * );
+void       tr_sessionSetPeerLimitPerTorrent (tr_session *, uint16_t maxPeers);
+uint16_t   tr_sessionGetPeerLimitPerTorrent (const tr_session *);
 
-void       tr_sessionSetPaused        ( tr_session *, bool isPaused );
-bool       tr_sessionGetPaused        ( const tr_session * );
+void       tr_sessionSetPaused      (tr_session *, bool isPaused);
+bool       tr_sessionGetPaused      (const tr_session *);
 
-void       tr_sessionSetDeleteSource  ( tr_session *, bool deleteSource );
-bool       tr_sessionGetDeleteSource  ( const tr_session * );
+void       tr_sessionSetDeleteSource (tr_session *, bool deleteSource);
+bool       tr_sessionGetDeleteSource (const tr_session *);
 
-tr_priority_t   tr_torrentGetPriority( const tr_torrent * );
-void            tr_torrentSetPriority( tr_torrent *, tr_priority_t );
+tr_priority_t   tr_torrentGetPriority (const tr_torrent *);
+void            tr_torrentSetPriority (tr_torrent *, tr_priority_t);
 
 /***
 ****
@@ -750,80 +750,80 @@ void            tr_torrentSetPriority( tr_torrent *, tr_priority_t );
 ****  There are independent queues for seeding (TR_UP) and leeching (TR_DOWN).
 ****
 ****  If the session already has enough non-stalled seeds/leeches when
-****  tr_torrentStart() is called, the torrent will be moved into the
+****  tr_torrentStart () is called, the torrent will be moved into the
 ****  appropriate queue and its state will be TR_STATUS_{DOWNLOAD,SEED}_WAIT.
 ****
 ****  To bypass the queue and unconditionally start the torrent use
-****  tr_torrentStartNow().
+****  tr_torrentStartNow ().
 ****
 ****  Torrents can be moved in the queue using the simple functions
 ****  tr_torrentQueueMove{Top,Up,Down,Bottom}. They can be moved to
-****  arbitrary points in the queue with tr_torrentSetQueuePosition().
+****  arbitrary points in the queue with tr_torrentSetQueuePosition ().
 ****
 ***/
 
 
-/** @brief Like tr_torrentStart(), but resumes right away regardless of the queues. */
-void tr_torrentStartNow         ( tr_torrent * );
+/** @brief Like tr_torrentStart (), but resumes right away regardless of the queues. */
+void tr_torrentStartNow       (tr_torrent *);
 
 /** @brief Return the queued torrent's position in the queue it's in. [0...n) */
-int  tr_torrentGetQueuePosition ( const tr_torrent * );
+int  tr_torrentGetQueuePosition (const tr_torrent *);
 
 /** @brief Set the queued torrent's position in the queue it's in.
  * Special cases: pos <= 0 moves to the front; pos >= queue length moves to the back */
-void tr_torrentSetQueuePosition ( tr_torrent *, int queuePosition );
+void tr_torrentSetQueuePosition (tr_torrent *, int queuePosition);
 
 /**
 **/
 
-/** @brief Convenience function for moving a batch of torrents to the front of their queue(s) */
-void tr_torrentsQueueMoveTop    ( tr_torrent ** torrents, int torrentCount );
+/** @brief Convenience function for moving a batch of torrents to the front of their queue (s) */
+void tr_torrentsQueueMoveTop  (tr_torrent ** torrents, int torrentCount);
 
-/** @brief Convenience function for moving a batch of torrents ahead one step in their queue(s) */
-void tr_torrentsQueueMoveUp     ( tr_torrent ** torrents, int torrentCount );
+/** @brief Convenience function for moving a batch of torrents ahead one step in their queue (s) */
+void tr_torrentsQueueMoveUp   (tr_torrent ** torrents, int torrentCount);
 
-/** @brief Convenience function for moving a batch of torrents back one step in their queue(s) */
-void tr_torrentsQueueMoveDown   ( tr_torrent ** torrents, int torrentCount );
+/** @brief Convenience function for moving a batch of torrents back one step in their queue (s) */
+void tr_torrentsQueueMoveDown (tr_torrent ** torrents, int torrentCount);
 
-/** @brief Convenience function for moving a batch of torrents to the back of their queue(s) */
-void tr_torrentsQueueMoveBottom ( tr_torrent ** torrents, int torrentCount );
+/** @brief Convenience function for moving a batch of torrents to the back of their queue (s) */
+void tr_torrentsQueueMoveBottom (tr_torrent ** torrents, int torrentCount);
 
 /**
 **/
 
 /** @brief Set the number of torrents allowed to download (if direction is TR_DOWN) or seed (if direction is TR_UP) at the same time */
-void tr_sessionSetQueueSize     ( tr_session *, tr_direction, int max_simultaneous_seed_torrents );
+void tr_sessionSetQueueSize   (tr_session *, tr_direction, int max_simultaneous_seed_torrents);
 
 /** @brief Return the number of torrents allowed to download (if direction is TR_DOWN) or seed (if direction is TR_UP) at the same time */
-int  tr_sessionGetQueueSize     ( const tr_session *, tr_direction );
+int  tr_sessionGetQueueSize   (const tr_session *, tr_direction);
 
 /** @brief Set whether or not to limit how many torrents can download (TR_DOWN) or seed (TR_UP) at the same time  */
-void tr_sessionSetQueueEnabled  ( tr_session *, tr_direction, bool do_limit_simultaneous_seed_torrents );
+void tr_sessionSetQueueEnabled (tr_session *, tr_direction, bool do_limit_simultaneous_seed_torrents);
 
 /** @brief Return true if we're limiting how many torrents can concurrently download (TR_DOWN) or seed (TR_UP) at the same time */
-bool tr_sessionGetQueueEnabled  ( const tr_session *, tr_direction );
+bool tr_sessionGetQueueEnabled (const tr_session *, tr_direction);
 
 /**
 **/
 
 /** @brief Consider torrent as 'stalled' when it's been inactive for N minutes.
-    Stalled torrents are left running but are not counted by tr_sessionGetQueueSize(). */
-void tr_sessionSetQueueStalledMinutes( tr_session *, int minutes );
+    Stalled torrents are left running but are not counted by tr_sessionGetQueueSize (). */
+void tr_sessionSetQueueStalledMinutes (tr_session *, int minutes);
 
 /** @return the number of minutes a torrent can be idle before being considered as stalled */
-int  tr_sessionGetQueueStalledMinutes( const tr_session * );
+int  tr_sessionGetQueueStalledMinutes (const tr_session *);
 
 /** @brief Set whether or not to count torrents idle for over N minutes as 'stalled' */
-void tr_sessionSetQueueStalledEnabled( tr_session *, bool );
+void tr_sessionSetQueueStalledEnabled (tr_session *, bool);
 
 /** @return true if we're torrents idle for over N minutes will be flagged as 'stalled' */
-bool tr_sessionGetQueueStalledEnabled( const tr_session * );
+bool tr_sessionGetQueueStalledEnabled (const tr_session *);
 
 /**
 **/
 
 /** @brief Set a callback that is invoked when the queue starts a torrent */
-void tr_torrentSetQueueStartCallback( tr_torrent * torrent, void (*callback)( tr_torrent *, void * ), void * user_data );
+void tr_torrentSetQueueStartCallback (tr_torrent * torrent, void (*callback)(tr_torrent *, void *), void * user_data);
 
 
 /***
@@ -832,25 +832,25 @@ void tr_torrentSetQueueStartCallback( tr_torrent * torrent, void (*callback)( tr
 ***/
 
 /**
- *  Load all the torrents in tr_getTorrentDir().
+ *  Load all the torrents in tr_getTorrentDir ().
  *  This can be used at startup to kickstart all the torrents
  *  from the previous session.
  */
-tr_torrent ** tr_sessionLoadTorrents( tr_session  * session,
+tr_torrent ** tr_sessionLoadTorrents (tr_session  * session,
                                       tr_ctor     * ctor,
-                                      int         * setmeCount );
+                                      int         * setmeCount);
 
 /**
 ***
 **/
 
-bool tr_sessionIsTorrentDoneScriptEnabled( const tr_session * );
+bool tr_sessionIsTorrentDoneScriptEnabled (const tr_session *);
 
-void tr_sessionSetTorrentDoneScriptEnabled( tr_session *, bool isEnabled );
+void tr_sessionSetTorrentDoneScriptEnabled (tr_session *, bool isEnabled);
 
-const char * tr_sessionGetTorrentDoneScript( const tr_session * );
+const char * tr_sessionGetTorrentDoneScript (const tr_session *);
 
-void tr_sessionSetTorrentDoneScript( tr_session *, const char * scriptFilename );
+void tr_sessionSetTorrentDoneScript (tr_session *, const char * scriptFilename);
 
 
 /** @} */
@@ -872,7 +872,7 @@ typedef enum
 }
 tr_msg_level;
 
-void tr_setMessageLevel( tr_msg_level );
+void tr_setMessageLevel (tr_msg_level);
 
 typedef struct tr_msg_list
 {
@@ -901,13 +901,13 @@ typedef struct tr_msg_list
 }
 tr_msg_list;
 
-void          tr_setMessageQueuing( bool isEnabled );
+void          tr_setMessageQueuing (bool isEnabled);
 
-bool          tr_getMessageQueuing( void );
+bool          tr_getMessageQueuing (void);
 
-tr_msg_list * tr_getQueuedMessages( void );
+tr_msg_list * tr_getQueuedMessages (void);
 
-void          tr_freeMessageList( tr_msg_list * freeme );
+void          tr_freeMessageList (tr_msg_list * freeme);
 
 /** @addtogroup Blocklists
     @{ */
@@ -928,26 +928,26 @@ void          tr_freeMessageList( tr_msg_list * freeme );
  *
  * Passing NULL for a filename will clear the blocklist.
  */
-int     tr_blocklistSetContent   ( tr_session       * session,
-                                   const char       * filename );
+int     tr_blocklistSetContent (tr_session       * session,
+                                   const char       * filename);
 
-int     tr_blocklistGetRuleCount ( const tr_session * session );
+int     tr_blocklistGetRuleCount (const tr_session * session);
 
-bool    tr_blocklistExists       ( const tr_session * session );
+bool    tr_blocklistExists     (const tr_session * session);
 
-bool    tr_blocklistIsEnabled    ( const tr_session * session );
+bool    tr_blocklistIsEnabled  (const tr_session * session);
 
-void    tr_blocklistSetEnabled   ( tr_session       * session,
-                                   bool               isEnabled );
+void    tr_blocklistSetEnabled (tr_session       * session,
+                                   bool               isEnabled);
 
 /** @brief The blocklist that ges updated when an RPC client
            invokes the "blocklist-update" method */
-void tr_blocklistSetURL         ( tr_session *, const char * url );
+void tr_blocklistSetURL       (tr_session *, const char * url);
 
-const char * tr_blocklistGetURL ( const tr_session * );
+const char * tr_blocklistGetURL (const tr_session *);
 
 /** @brief the file in the $config/blocklists/ directory that's
-           used by tr_blocklistSetContent() and "blocklist-update" */
+           used by tr_blocklistSetContent () and "blocklist-update" */
 #define DEFAULT_BLOCKLIST_FILENAME "blocklist.bin"
 
 /** @} */
@@ -961,22 +961,22 @@ const char * tr_blocklistGetURL ( const tr_session * );
     to create a tr_torrent object.
 
     To remedy this, a Torrent Constructor (struct tr_ctor) has been introduced:
-    - Simplifies the API to two functions: tr_torrentParse() and tr_torrentNew()
+    - Simplifies the API to two functions: tr_torrentParse () and tr_torrentNew ()
     - You can set the fields you want; the system sets defaults for the rest.
     - You can specify whether or not your fields should supercede resume's.
-    - We can add new features to tr_ctor without breaking tr_torrentNew()'s API.
+    - We can add new features to tr_ctor without breaking tr_torrentNew ()'s API.
 
-    All the tr_ctor{Get,Set}*() functions with a return value return
+    All the tr_ctor{Get,Set}* () functions with a return value return
     an error number, or zero if no error occurred.
 
-    You must call one of the SetMetainfo() functions before creating
+    You must call one of the SetMetainfo () functions before creating
     a torrent with a tr_ctor. The other functions are optional.
 
     You can reuse a single tr_ctor to create a batch of torrents --
-    just call one of the SetMetainfo() functions between each
-    tr_torrentNew() call.
+    just call one of the SetMetainfo () functions between each
+    tr_torrentNew () call.
 
-    Every call to tr_ctorSetMetainfo*() frees the previous metainfo.
+    Every call to tr_ctorSetMetainfo* () frees the previous metainfo.
  */
 
 typedef enum
@@ -993,43 +993,43 @@ struct tr_benc;
 
 /** @brief Create a torrent constructor object used to instantiate a tr_torrent
     @param session the tr_session. This is required if you're going to call
-                   tr_torrentNew(), but you can use NULL for tr_torrentParse().
-    @see tr_torrentNew(), tr_torrentParse() */
-tr_ctor* tr_ctorNew( const tr_session * session_or_NULL );
+                   tr_torrentNew (), but you can use NULL for tr_torrentParse ().
+    @see tr_torrentNew (), tr_torrentParse () */
+tr_ctor* tr_ctorNew (const tr_session * session_or_NULL);
 
 /** @brief Free a torrent constructor object */
-void  tr_ctorFree( tr_ctor * ctor );
+void  tr_ctorFree (tr_ctor * ctor);
 
 /** @brief Set whether or not to delete the source .torrent file
            when the torrent is added. (Default: False) */
-void  tr_ctorSetDeleteSource( tr_ctor * ctor, bool doDelete );
+void  tr_ctorSetDeleteSource (tr_ctor * ctor, bool doDelete);
 
 /** @brief Set the constructor's metainfo from a magnet link */
-int tr_ctorSetMetainfoFromMagnetLink( tr_ctor * ctor, const char * magnet );
+int tr_ctorSetMetainfoFromMagnetLink (tr_ctor * ctor, const char * magnet);
 
 /** @brief Set the constructor's metainfo from a raw benc already in memory */
-int tr_ctorSetMetainfo( tr_ctor * ctor, const uint8_t * metainfo, size_t len );
+int tr_ctorSetMetainfo (tr_ctor * ctor, const uint8_t * metainfo, size_t len);
 
 /** @brief Set the constructor's metainfo from a local .torrent file */
-int tr_ctorSetMetainfoFromFile( tr_ctor * ctor, const char * filename );
+int tr_ctorSetMetainfoFromFile (tr_ctor * ctor, const char * filename);
 
 /**
- * @brief Set the metainfo from an existing file in tr_getTorrentDir().
+ * @brief Set the metainfo from an existing file in tr_getTorrentDir ().
  *
  * This is used by the Mac client on startup to pick and choose which
  * torrents to load
  */
-int tr_ctorSetMetainfoFromHash( tr_ctor * ctor, const char * hashString );
+int tr_ctorSetMetainfoFromHash (tr_ctor * ctor, const char * hashString);
 
 /** @brief Set how many peers this torrent can connect to. (Default: 50) */
-void tr_ctorSetPeerLimit( tr_ctor * ctor, tr_ctorMode mode, uint16_t limit );
+void tr_ctorSetPeerLimit (tr_ctor * ctor, tr_ctorMode mode, uint16_t limit);
 
 /** @brief Set the download folder for the torrent being added with this ctor.
-    @see tr_ctorSetDownloadDir()
-    @see tr_sessionInit() */
-void  tr_ctorSetDownloadDir( tr_ctor      * ctor,
+    @see tr_ctorSetDownloadDir ()
+    @see tr_sessionInit () */
+void  tr_ctorSetDownloadDir (tr_ctor      * ctor,
                              tr_ctorMode    mode,
-                             const char   * directory );
+                             const char   * directory);
 
 /**
  * @brief Set the incompleteDir for this torrent.
@@ -1039,60 +1039,60 @@ void  tr_ctorSetDownloadDir( tr_ctor      * ctor,
  * its older incompleteDir settings, and that's
  * the only place where it should be used.
  */
-void tr_ctorSetIncompleteDir( tr_ctor * ctor, const char * directory );
+void tr_ctorSetIncompleteDir (tr_ctor * ctor, const char * directory);
 
 /** Set whether or not the torrent begins downloading/seeding when created.
-    (Default: not paused) */
-void        tr_ctorSetPaused( tr_ctor      * ctor,
+  (Default: not paused) */
+void        tr_ctorSetPaused (tr_ctor      * ctor,
                               tr_ctorMode    mode,
-                              bool           isPaused );
+                              bool           isPaused);
 
 /** @brief Set the priorities for files in a torrent */
-void        tr_ctorSetFilePriorities( tr_ctor                * ctor,
+void        tr_ctorSetFilePriorities (tr_ctor                * ctor,
                                       const tr_file_index_t  * files,
                                       tr_file_index_t          fileCount,
-                                      tr_priority_t            priority );
+                                      tr_priority_t            priority);
 
 /** @brief Set the download flag for files in a torrent */
-void        tr_ctorSetFilesWanted( tr_ctor                * ctor,
+void        tr_ctorSetFilesWanted (tr_ctor                * ctor,
                                    const tr_file_index_t  * fileIndices,
                                    tr_file_index_t          fileCount,
-                                   bool                     wanted );
+                                   bool                     wanted);
 
 
 /** @brief Get this peer constructor's peer limit */
-int         tr_ctorGetPeerLimit( const tr_ctor * ctor,
+int         tr_ctorGetPeerLimit (const tr_ctor * ctor,
                                  tr_ctorMode     mode,
-                                 uint16_t *      setmeCount );
+                                 uint16_t *      setmeCount);
 
 /** @brief Get the "isPaused" flag from this peer constructor */
-int         tr_ctorGetPaused( const tr_ctor * ctor,
+int         tr_ctorGetPaused (const tr_ctor * ctor,
                               tr_ctorMode     mode,
-                              bool          * setmeIsPaused );
+                              bool          * setmeIsPaused);
 
 /** @brief Get the download path from this peer constructor */
-int         tr_ctorGetDownloadDir( const tr_ctor  * ctor,
+int         tr_ctorGetDownloadDir (const tr_ctor  * ctor,
                                    tr_ctorMode      mode,
-                                   const char    ** setmeDownloadDir );
+                                   const char    ** setmeDownloadDir);
 
 /** @brief Get the incomplete directory from this peer constructor */
-int         tr_ctorGetIncompleteDir( const tr_ctor  * ctor,
-                                     const char    ** setmeIncompleteDir );
+int         tr_ctorGetIncompleteDir (const tr_ctor  * ctor,
+                                     const char    ** setmeIncompleteDir);
 
 /** @brief Get the metainfo from this peer constructor */
-int         tr_ctorGetMetainfo( const tr_ctor         * ctor,
-                                const struct tr_benc ** setme );
+int         tr_ctorGetMetainfo (const tr_ctor         * ctor,
+                                const struct tr_benc ** setme);
 
 /** @brief Get the "delete .torrent file" flag from this peer constructor */
-int         tr_ctorGetDeleteSource( const tr_ctor  * ctor,
-                                    bool           * setmeDoDelete );
+int         tr_ctorGetDeleteSource (const tr_ctor  * ctor,
+                                    bool           * setmeDoDelete);
 
 /** @brief Get the tr_session poiner from this peer constructor */
-tr_session* tr_ctorGetSession( const tr_ctor * ctor );
+tr_session* tr_ctorGetSession (const tr_ctor * ctor);
 
 /** @brief Get the .torrent file that this ctor's metainfo came from,
-           or NULL if tr_ctorSetMetainfoFromFile() wasn't used */
-const char* tr_ctorGetSourceFile( const tr_ctor * ctor );
+           or NULL if tr_ctorSetMetainfoFromFile () wasn't used */
+const char* tr_ctorGetSourceFile (const tr_ctor * ctor);
 
 typedef enum
 {
@@ -1111,31 +1111,31 @@ tr_parse_result;
  *
  * @param setme_info If parsing is successful and setme_info is non-NULL,
  *                   the parsed metainfo is stored there and sould be freed
- *                   by calling tr_metainfoFree() when no longer needed.
+ *                   by calling tr_metainfoFree () when no longer needed.
  *
  * Notes:
  *
- * 1. tr_torrentParse() won't be able to check for duplicates -- and therefore
+ * 1. tr_torrentParse () won't be able to check for duplicates -- and therefore
  *    won't return TR_PARSE_DUPLICATE -- unless ctor's "download-dir" and
  *    session variable is set.
  *
  * 2. setme_info->torrent's value can't be set unless ctor's session variable
  *    is set.
  */
-tr_parse_result  tr_torrentParse( const tr_ctor  * ctor,
-                                  tr_info        * setme_info_or_NULL );
+tr_parse_result  tr_torrentParse (const tr_ctor  * ctor,
+                                  tr_info        * setme_info_or_NULL);
 
 /** @brief free a metainfo
     @see tr_torrentParse */
-void tr_metainfoFree( tr_info * inf );
+void tr_metainfoFree (tr_info * inf);
 
 
 /** Instantiate a single torrent.
     @return 0 on success,
             TR_EINVALID if the torrent couldn't be parsed, or
             TR_EDUPLICATE if there's already a matching torrent object. */
-tr_torrent * tr_torrentNew( const tr_ctor   * ctor,
-                            int             * setmeError );
+tr_torrent * tr_torrentNew (const tr_ctor   * ctor,
+                            int             * setmeError);
 
 /** @} */
 
@@ -1147,23 +1147,23 @@ tr_torrent * tr_torrentNew( const tr_ctor   * ctor,
 /** @addtogroup tr_torrent Torrents
     @{ */
 
-/** @brief Frees memory allocated by tr_torrentNew().
+/** @brief Frees memory allocated by tr_torrentNew ().
            Running torrents are stopped first. */
-void tr_torrentFree( tr_torrent * torrent );
+void tr_torrentFree (tr_torrent * torrent);
 
-typedef int tr_fileFunc( const char * filename );
+typedef int tr_fileFunc (const char * filename);
 
 /** @brief Removes our .torrent and .resume files for
-           this torrent, then calls tr_torrentFree(). */
-void tr_torrentRemove( tr_torrent  * torrent,
+           this torrent, then calls tr_torrentFree (). */
+void tr_torrentRemove (tr_torrent  * torrent,
                        bool          removeLocalData,
-                       tr_fileFunc   removeFunc );
+                       tr_fileFunc   removeFunc);
 
 /** @brief Start a torrent */
-void tr_torrentStart( tr_torrent * torrent );
+void tr_torrentStart (tr_torrent * torrent);
 
 /** @brief Stop (pause) a torrent */
-void tr_torrentStop( tr_torrent * torrent );
+void tr_torrentStop (tr_torrent * torrent);
 
 enum
 {
@@ -1179,13 +1179,13 @@ enum
  * will be clobberred s.t. additional files being added will be saved
  * to the torrent's downloadDir.
  */
-void tr_torrentSetLocation( tr_torrent       * torrent,
+void tr_torrentSetLocation (tr_torrent       * torrent,
                             const char       * location,
                             bool               move_from_previous_location,
                             volatile double  * setme_progress,
-                            volatile int     * setme_state );
+                            volatile int     * setme_state);
 
-uint64_t tr_torrentGetBytesLeftToAllocate( const tr_torrent * torrent );
+uint64_t tr_torrentGetBytesLeftToAllocate (const tr_torrent * torrent);
 
 /**
  * @brief Returns this torrent's unique ID.
@@ -1194,32 +1194,32 @@ uint64_t tr_torrentGetBytesLeftToAllocate( const tr_torrent * torrent );
  * between sessions. If you need that, use tr_info.hash or
  * tr_info.hashString.
  */
-int tr_torrentId( const tr_torrent * torrent );
+int tr_torrentId (const tr_torrent * torrent);
 
-tr_torrent* tr_torrentFindFromId( tr_session * session, int id );
+tr_torrent* tr_torrentFindFromId (tr_session * session, int id);
 
-tr_torrent* tr_torrentFindFromHash( tr_session     * session,
-                                    const uint8_t  * hash );
+tr_torrent* tr_torrentFindFromHash (tr_session     * session,
+                                    const uint8_t  * hash);
 
-/** @brief Convenience function similar to tr_torrentFindFromHash() */
-tr_torrent* tr_torrentFindFromMagnetLink( tr_session * session,
-                                          const char * link );
+/** @brief Convenience function similar to tr_torrentFindFromHash () */
+tr_torrent* tr_torrentFindFromMagnetLink (tr_session * session,
+                                          const char * link);
 
 /**
  * @return this torrent's name.
  */
-const char* tr_torrentName( const tr_torrent * );
+const char* tr_torrentName (const tr_torrent *);
 
 /**
  * @brief find the location of a torrent's file by looking with and without
  *        the ".part" suffix, looking in downloadDir and incompleteDir, etc.
- * @return a newly-allocated string (that must be tr_freed() by the caller
+ * @return a newly-allocated string (that must be tr_freed () by the caller
  *         when done) that gives the location of this file on disk,
  *         or NULL if no file exists yet.
  * @param tor the torrent whose file we're looking for
  * @param fileNum the fileIndex, in [0...tr_info.fileCount)
  */
-char* tr_torrentFindFile( const tr_torrent * tor, tr_file_index_t fileNo );
+char* tr_torrentFindFile (const tr_torrent * tor, tr_file_index_t fileNo);
 
 
 /***
@@ -1227,14 +1227,14 @@ char* tr_torrentFindFile( const tr_torrent * tor, tr_file_index_t fileNo );
 ****
 ***/
 
-void         tr_torrentSetSpeedLimit_KBps  ( tr_torrent *, tr_direction, unsigned int KBps );
-unsigned int tr_torrentGetSpeedLimit_KBps  ( const tr_torrent *, tr_direction );
+void         tr_torrentSetSpeedLimit_KBps (tr_torrent *, tr_direction, unsigned int KBps);
+unsigned int tr_torrentGetSpeedLimit_KBps (const tr_torrent *, tr_direction);
 
-void     tr_torrentUseSpeedLimit      ( tr_torrent *, tr_direction, bool );
-bool     tr_torrentUsesSpeedLimit     ( const tr_torrent *, tr_direction );
+void     tr_torrentUseSpeedLimit    (tr_torrent *, tr_direction, bool);
+bool     tr_torrentUsesSpeedLimit   (const tr_torrent *, tr_direction);
 
-void     tr_torrentUseSessionLimits   ( tr_torrent *, bool );
-bool     tr_torrentUsesSessionLimits  ( const tr_torrent * );
+void     tr_torrentUseSessionLimits (tr_torrent *, bool);
+bool     tr_torrentUsesSessionLimits (const tr_torrent *);
 
 
 /****
@@ -1254,18 +1254,18 @@ typedef enum
 }
 tr_ratiolimit;
 
-void          tr_torrentSetRatioMode( tr_torrent         * tor,
-                                      tr_ratiolimit        mode );
+void          tr_torrentSetRatioMode (tr_torrent         * tor,
+                                      tr_ratiolimit        mode);
 
-tr_ratiolimit tr_torrentGetRatioMode( const tr_torrent   * tor );
+tr_ratiolimit tr_torrentGetRatioMode (const tr_torrent   * tor);
 
-void          tr_torrentSetRatioLimit( tr_torrent        * tor,
-                                       double              ratio );
+void          tr_torrentSetRatioLimit (tr_torrent        * tor,
+                                       double              ratio);
 
-double        tr_torrentGetRatioLimit( const tr_torrent  * tor );
+double        tr_torrentGetRatioLimit (const tr_torrent  * tor);
 
 
-bool          tr_torrentGetSeedRatio( const tr_torrent *, double * ratio );
+bool          tr_torrentGetSeedRatio (const tr_torrent *, double * ratio);
 
 
 /****
@@ -1285,26 +1285,26 @@ typedef enum
 }
 tr_idlelimit;
 
-void          tr_torrentSetIdleMode ( tr_torrent         * tor,
-                                      tr_idlelimit         mode );
+void          tr_torrentSetIdleMode (tr_torrent         * tor,
+                                      tr_idlelimit         mode);
 
-tr_idlelimit  tr_torrentGetIdleMode ( const tr_torrent   * tor );
+tr_idlelimit  tr_torrentGetIdleMode (const tr_torrent   * tor);
 
-void          tr_torrentSetIdleLimit( tr_torrent         * tor,
-                                      uint16_t             idleMinutes );
+void          tr_torrentSetIdleLimit (tr_torrent         * tor,
+                                      uint16_t             idleMinutes);
 
-uint16_t      tr_torrentGetIdleLimit( const tr_torrent   * tor );
+uint16_t      tr_torrentGetIdleLimit (const tr_torrent   * tor);
 
 
-bool          tr_torrentGetSeedIdle( const tr_torrent *, uint16_t * minutes );
+bool          tr_torrentGetSeedIdle (const tr_torrent *, uint16_t * minutes);
 
 /****
 *****  Peer Limits
 ****/
 
-void          tr_torrentSetPeerLimit( tr_torrent * tor, uint16_t peerLimit );
+void          tr_torrentSetPeerLimit (tr_torrent * tor, uint16_t peerLimit);
 
-uint16_t      tr_torrentGetPeerLimit( const tr_torrent * tor );
+uint16_t      tr_torrentGetPeerLimit (const tr_torrent * tor);
 
 /****
 *****  File Priorities
@@ -1322,35 +1322,35 @@ enum
  *
  * @param priority must be one of TR_PRI_NORMAL, _HIGH, or _LOW
  */
-void tr_torrentSetFilePriorities( tr_torrent             * torrent,
+void tr_torrentSetFilePriorities (tr_torrent             * torrent,
                                   const tr_file_index_t  * files,
                                   tr_file_index_t          fileCount,
-                                  tr_priority_t            priority );
+                                  tr_priority_t            priority);
 
 /**
  * @brief Get this torrent's file priorities.
  *
- * @return A malloc()ed array of tor->info.fileCount items,
+ * @return A malloc ()ed array of tor->info.fileCount items,
  *         each holding a TR_PRI_NORMAL, TR_PRI_HIGH, or TR_PRI_LOW.
- *         It's the caller's responsibility to free() this.
+ *         It's the caller's responsibility to free () this.
  */
-tr_priority_t*  tr_torrentGetFilePriorities( const tr_torrent * torrent );
+tr_priority_t*  tr_torrentGetFilePriorities (const tr_torrent * torrent);
 
 /** @brief Set a batch of files to be downloaded or not. */
-void tr_torrentSetFileDLs( tr_torrent             * torrent,
+void tr_torrentSetFileDLs (tr_torrent             * torrent,
                            const tr_file_index_t  * files,
                            tr_file_index_t          fileCount,
-                           bool                     do_download );
+                           bool                     do_download);
 
 
-const tr_info * tr_torrentInfo( const tr_torrent * torrent );
+const tr_info * tr_torrentInfo (const tr_torrent * torrent);
 
 /* Raw function to change the torrent's downloadDir field.
    This should only be used by libtransmission or to bootstrap
    a newly-instantiated tr_torrent object. */
-void tr_torrentSetDownloadDir( tr_torrent  * torrent, const char * path );
+void tr_torrentSetDownloadDir (tr_torrent  * torrent, const char * path);
 
-const char * tr_torrentGetDownloadDir( const tr_torrent * torrent );
+const char * tr_torrentGetDownloadDir (const tr_torrent * torrent);
 
 /**
  * Returns the root directory of where the torrent is.
@@ -1359,19 +1359,19 @@ const char * tr_torrentGetDownloadDir( const tr_torrent * torrent );
  * has an incompleteDir enabled and hasn't finished downloading
  * yet, that will be returned instead.
  */
-const char * tr_torrentGetCurrentDir( const tr_torrent * tor );
+const char * tr_torrentGetCurrentDir (const tr_torrent * tor);
 
 
-char* tr_torrentInfoGetMagnetLink( const tr_info * inf );
+char* tr_torrentInfoGetMagnetLink (const tr_info * inf);
 
 /**
  * Returns a newly-allocated string with a magnet link of the torrent.
- * Use tr_free() to free the string when done.
+ * Use tr_free () to free the string when done.
  */
 static inline
-char* tr_torrentGetMagnetLink( const tr_torrent * tor )
+char* tr_torrentGetMagnetLink (const tr_torrent * tor)
 {
-    return tr_torrentInfoGetMagnetLink( tr_torrentInfo( tor ) );
+    return tr_torrentInfoGetMagnetLink (tr_torrentInfo (tor));
 }
 
 /**
@@ -1393,7 +1393,7 @@ tr_tracker_info;
  * @brief Modify a torrent's tracker list.
  *
  * This updates both the `torrent' object's tracker list
- * and the metainfo file in tr_sessionGetConfigDir()'s torrent subdirectory.
+ * and the metainfo file in tr_sessionGetConfigDir ()'s torrent subdirectory.
  *
  * @param torrent The torrent whose tracker list is to be modified
  * @param trackers An array of trackers, sorted by tier from first to last.
@@ -1403,9 +1403,9 @@ tr_tracker_info;
  * @param trackerCount size of the `trackers' array
  */
 bool
-tr_torrentSetAnnounceList( tr_torrent             * torrent,
+tr_torrentSetAnnounceList (tr_torrent             * torrent,
                            const tr_tracker_info  * trackers,
-                           int                      trackerCount );
+                           int                      trackerCount);
 
 
 /**
@@ -1424,16 +1424,16 @@ tr_completeness;
  * @param wasRunning whether or not the torrent was running when
  *                   it changed its completeness state
  */
-typedef void ( tr_torrent_completeness_func )( tr_torrent       * torrent,
+typedef void (tr_torrent_completeness_func)(tr_torrent       * torrent,
                                                tr_completeness    completeness,
                                                bool               wasRunning,
-                                               void             * user_data );
+                                               void             * user_data);
 
-typedef void ( tr_torrent_ratio_limit_hit_func )( tr_torrent   * torrent,
-                                                  void         * user_data );
+typedef void (tr_torrent_ratio_limit_hit_func)(tr_torrent   * torrent,
+                                                  void         * user_data);
 
-typedef void ( tr_torrent_idle_limit_hit_func )( tr_torrent   * torrent,
-                                                 void         * user_data );
+typedef void (tr_torrent_idle_limit_hit_func)(tr_torrent   * torrent,
+                                                 void         * user_data);
 
 
 /**
@@ -1449,17 +1449,17 @@ typedef void ( tr_torrent_idle_limit_hit_func )( tr_torrent   * torrent,
  *
  * @see tr_completeness
  */
-void tr_torrentSetCompletenessCallback(
+void tr_torrentSetCompletenessCallback (
          tr_torrent                    * torrent,
          tr_torrent_completeness_func    func,
-         void                          * user_data );
+         void                          * user_data);
 
-void tr_torrentClearCompletenessCallback( tr_torrent * torrent );
+void tr_torrentClearCompletenessCallback (tr_torrent * torrent);
 
 
 
-typedef void ( tr_torrent_metadata_func )( tr_torrent  * torrent,
-                                           void        * user_data );
+typedef void (tr_torrent_metadata_func)(tr_torrent  * torrent,
+                                           void        * user_data);
 /**
  * Register to be notified whenever a torrent changes from
  * having incomplete metadata to having complete metadata.
@@ -1469,7 +1469,7 @@ typedef void ( tr_torrent_metadata_func )( tr_torrent  * torrent,
 void tr_torrentSetMetadataCallback (
          tr_torrent                * tor,
          tr_torrent_metadata_func     func,
-         void                      * user_data );
+         void                      * user_data);
 
 /**
  * Register to be notified whenever a torrent's ratio limit
@@ -1478,12 +1478,12 @@ void tr_torrentSetMetadataCallback (
  *
  * Has the same restrictions as tr_torrentSetCompletenessCallback
  */
-void tr_torrentSetRatioLimitHitCallback(
+void tr_torrentSetRatioLimitHitCallback (
      tr_torrent                     * torrent,
      tr_torrent_ratio_limit_hit_func  func,
-     void                           * user_data );
+     void                           * user_data);
 
-void tr_torrentClearRatioLimitHitCallback( tr_torrent * torrent );
+void tr_torrentClearRatioLimitHitCallback (tr_torrent * torrent);
 
 /**
  * Register to be notified whenever a torrent's idle limit
@@ -1492,12 +1492,12 @@ void tr_torrentClearRatioLimitHitCallback( tr_torrent * torrent );
  *
  * Has the same restrictions as tr_torrentSetCompletenessCallback
  */
-void tr_torrentSetIdleLimitHitCallback(
+void tr_torrentSetIdleLimitHitCallback (
      tr_torrent                          * torrent,
      tr_torrent_idle_limit_hit_func        func,
-     void                                * user_data );
+     void                                * user_data);
 
-void tr_torrentClearIdleLimitHitCallback( tr_torrent * torrent );
+void tr_torrentClearIdleLimitHitCallback (tr_torrent * torrent);
 
 
 /**
@@ -1505,17 +1505,17 @@ void tr_torrentClearIdleLimitHitCallback( tr_torrent * torrent );
  *
  * Trackers usually set an announce interval of 15 or 30 minutes.
  * Users can send one-time announce requests that override this
- * interval by calling tr_torrentManualUpdate().
+ * interval by calling tr_torrentManualUpdate ().
  *
- * The wait interval for tr_torrentManualUpdate() is much smaller.
+ * The wait interval for tr_torrentManualUpdate () is much smaller.
  * You can test whether or not a manual update is possible
  * (for example, to desensitize the button) by calling
- * tr_torrentCanManualUpdate().
+ * tr_torrentCanManualUpdate ().
  */
 
-void tr_torrentManualUpdate( tr_torrent * torrent );
+void tr_torrentManualUpdate (tr_torrent * torrent);
 
-bool tr_torrentCanManualUpdate( const tr_torrent * torrent );
+bool tr_torrentCanManualUpdate (const tr_torrent * torrent);
 
 /***
 ****  tr_peer_stat
@@ -1569,11 +1569,11 @@ typedef struct tr_peer_stat
 }
 tr_peer_stat;
 
-tr_peer_stat * tr_torrentPeers( const tr_torrent * torrent,
-                                int *              peerCount );
+tr_peer_stat * tr_torrentPeers (const tr_torrent * torrent,
+                                int *              peerCount);
 
-void           tr_torrentPeersFree( tr_peer_stat * peerStats,
-                                    int            peerCount );
+void           tr_torrentPeersFree (tr_peer_stat * peerStats,
+                                    int            peerCount);
 
 /***
 ****  tr_tracker_stat
@@ -1692,11 +1692,11 @@ typedef struct
 }
 tr_tracker_stat;
 
-tr_tracker_stat * tr_torrentTrackers( const tr_torrent * torrent,
-                                      int              * setmeTrackerCount );
+tr_tracker_stat * tr_torrentTrackers (const tr_torrent * torrent,
+                                      int              * setmeTrackerCount);
 
-void tr_torrentTrackersFree( tr_tracker_stat * trackerStats,
-                             int               trackerCount );
+void tr_torrentTrackersFree (tr_tracker_stat * trackerStats,
+                             int               trackerCount);
 
 
 
@@ -1708,9 +1708,9 @@ void tr_torrentTrackersFree( tr_tracker_stat * trackerStats,
  *         array index in tor->info.webseeds.
  *         To differentiate "idle" and "stalled" status, idle webseeds will
  *         return -1 instead of 0 KiB/s.
- *         NOTE: always free this array with tr_free() when you're done with it.
+ *         NOTE: always free this array with tr_free () when you're done with it.
  */
-double*  tr_torrentWebSpeeds_KBps( const tr_torrent * torrent );
+double*  tr_torrentWebSpeeds_KBps (const tr_torrent * torrent);
 
 typedef struct tr_file_stat
 {
@@ -1719,11 +1719,11 @@ typedef struct tr_file_stat
 }
 tr_file_stat;
 
-tr_file_stat * tr_torrentFiles( const tr_torrent  * torrent,
-                                tr_file_index_t   * fileCount );
+tr_file_stat * tr_torrentFiles (const tr_torrent  * torrent,
+                                tr_file_index_t   * fileCount);
 
-void tr_torrentFilesFree( tr_file_stat     * files,
-                          tr_file_index_t    fileCount );
+void tr_torrentFilesFree (tr_file_stat     * files,
+                          tr_file_index_t    fileCount);
 
 
 /***********************************************************************
@@ -1734,15 +1734,15 @@ void tr_torrentFilesFree( tr_file_stat     * files,
  * to either -1 if we have the piece, otherwise it is set to the number
  * of connected peers who have the piece.
  **********************************************************************/
-void tr_torrentAvailability( const tr_torrent  * torrent,
+void tr_torrentAvailability (const tr_torrent  * torrent,
                              int8_t            * tab,
-                             int                  size );
+                             int                  size);
 
-void tr_torrentAmountFinished( const tr_torrent  * torrent,
+void tr_torrentAmountFinished (const tr_torrent  * torrent,
                                float *             tab,
-                               int                 size );
+                               int                 size);
 
-void tr_torrentVerify( tr_torrent * torrent );
+void tr_torrentVerify (tr_torrent * torrent);
 
 /***********************************************************************
  * tr_info
@@ -1811,9 +1811,9 @@ struct tr_info
     bool               isMultifile;
 };
 
-static inline bool tr_torrentHasMetadata( const tr_torrent * tor )
+static inline bool tr_torrentHasMetadata (const tr_torrent * tor)
 {
-    return tr_torrentInfo( tor )->fileCount > 0;
+    return tr_torrentInfo (tor)->fileCount > 0;
 }
 
 /**
@@ -1862,11 +1862,11 @@ typedef enum
 }
 tr_stat_errtype;
 
-/** @brief Used by tr_torrentStat() to tell clients about a torrent's state and statistics */
+/** @brief Used by tr_torrentStat () to tell clients about a torrent's state and statistics */
 typedef struct tr_stat
 {
     /** The torrent's unique Id.
-        @see tr_torrentId() */
+        @see tr_torrentId () */
     int    id;
 
     /** What is this torrent doing right now? */
@@ -2025,7 +2025,7 @@ typedef struct tr_stat
     int queuePosition;
 
     /** True if the torrent is running, but has been idle for long enough
-        to be considered stalled.  @see tr_sessionGetQueueStalledMinutes() */
+        to be considered stalled.  @see tr_sessionGetQueueStalledMinutes () */
     bool isStalled;
 }
 tr_stat;
@@ -2033,31 +2033,31 @@ tr_stat;
 /** Return a pointer to an tr_stat structure with updated information
     on the torrent. This is typically called by the GUI clients every
     second or so to get a new snapshot of the torrent's status. */
-const tr_stat * tr_torrentStat( tr_torrent * torrent );
+const tr_stat * tr_torrentStat (tr_torrent * torrent);
 
-/** Like tr_torrentStat(), but only recalculates the statistics if it's
+/** Like tr_torrentStat (), but only recalculates the statistics if it's
     been longer than a second since they were last calculated. This can
-    reduce the CPU load if you're calling tr_torrentStat() frequently. */
-const tr_stat * tr_torrentStatCached( tr_torrent * torrent );
+    reduce the CPU load if you're calling tr_torrentStat () frequently. */
+const tr_stat * tr_torrentStatCached (tr_torrent * torrent);
 
 /** @deprecated */
-void tr_torrentSetAddedDate( tr_torrent * torrent,
-                             time_t       addedDate );
+void tr_torrentSetAddedDate (tr_torrent * torrent,
+                             time_t       addedDate);
 
 /** @deprecated */
-void tr_torrentSetActivityDate( tr_torrent * torrent,
-                                time_t       activityDate );
+void tr_torrentSetActivityDate (tr_torrent * torrent,
+                                time_t       activityDate);
 
 /** @deprecated */
-void tr_torrentSetDoneDate( tr_torrent * torrent, time_t doneDate );
+void tr_torrentSetDoneDate (tr_torrent * torrent, time_t doneDate);
 
 /** @} */
 
 /** @brief Sanity checker to test that the direction is TR_UP or TR_DOWN */
-static inline bool tr_isDirection( tr_direction d ) { return d==TR_UP || d==TR_DOWN; }
+static inline bool tr_isDirection (tr_direction d) { return d==TR_UP || d==TR_DOWN; }
 
 /** @brief Sanity checker to test that a bool is true or false */
-static inline bool tr_isBool( bool b ) { return b==1 || b==0; }
+static inline bool tr_isBool (bool b) { return b==1 || b==0; }
 
 #ifdef __cplusplus
 }
diff --git a/libtransmission/trevent.c b/libtransmission/trevent.c
index 27722a038..63b0b0913 100644
--- a/libtransmission/trevent.c
+++ b/libtransmission/trevent.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -29,75 +29,75 @@
 #include <winsock2.h>
 
 static int
-pgpipe( int handles[2] )
+pgpipe (int handles[2])
 {
     SOCKET s;
     struct sockaddr_in serv_addr;
-    int len = sizeof( serv_addr );
+    int len = sizeof (serv_addr);
 
     handles[0] = handles[1] = INVALID_SOCKET;
 
-    if ( ( s = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
+    if ((s = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
     {
-        tr_dbg("pgpipe failed to create socket: %ui", WSAGetLastError());
+        tr_dbg ("pgpipe failed to create socket: %ui", WSAGetLastError ());
         return -1;
     }
 
-    memset( &serv_addr, 0, sizeof( serv_addr ) );
+    memset (&serv_addr, 0, sizeof (serv_addr));
     serv_addr.sin_family = AF_INET;
-    serv_addr.sin_port = htons(0);
-    serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-    if (bind(s, (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR)
+    serv_addr.sin_port = htons (0);
+    serv_addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+    if (bind (s, (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR)
     {
-        tr_dbg("pgpipe failed to bind: %ui", WSAGetLastError());
-        closesocket(s);
+        tr_dbg ("pgpipe failed to bind: %ui", WSAGetLastError ());
+        closesocket (s);
         return -1;
     }
-    if (listen(s, 1) == SOCKET_ERROR)
+    if (listen (s, 1) == SOCKET_ERROR)
     {
-        tr_ndbg("event","pgpipe failed to listen: %ui", WSAGetLastError());
-        closesocket(s);
+        tr_ndbg ("event","pgpipe failed to listen: %ui", WSAGetLastError ());
+        closesocket (s);
         return -1;
     }
-    if (getsockname(s, (SOCKADDR *) & serv_addr, &len) == SOCKET_ERROR)
+    if (getsockname (s, (SOCKADDR *) & serv_addr, &len) == SOCKET_ERROR)
     {
-        tr_dbg("pgpipe failed to getsockname: %ui", WSAGetLastError());
-        closesocket(s);
+        tr_dbg ("pgpipe failed to getsockname: %ui", WSAGetLastError ());
+        closesocket (s);
         return -1;
     }
-    if ((handles[1] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+    if ((handles[1] = socket (PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
     {
-        tr_dbg("pgpipe failed to create socket 2: %ui", WSAGetLastError());
-        closesocket(s);
+        tr_dbg ("pgpipe failed to create socket 2: %ui", WSAGetLastError ());
+        closesocket (s);
         return -1;
     }
 
-    if (connect(handles[1], (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR)
+    if (connect (handles[1], (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR)
     {
-        tr_dbg("pgpipe failed to connect socket: %ui", WSAGetLastError());
-        closesocket(s);
+        tr_dbg ("pgpipe failed to connect socket: %ui", WSAGetLastError ());
+        closesocket (s);
         return -1;
     }
-    if ((handles[0] = accept(s, (SOCKADDR *) & serv_addr, &len)) == INVALID_SOCKET)
+    if ((handles[0] = accept (s, (SOCKADDR *) & serv_addr, &len)) == INVALID_SOCKET)
     {
-        tr_dbg("pgpipe failed to accept socket: %ui", WSAGetLastError());
-        closesocket(handles[1]);
+        tr_dbg ("pgpipe failed to accept socket: %ui", WSAGetLastError ());
+        closesocket (handles[1]);
         handles[1] = INVALID_SOCKET;
-        closesocket(s);
+        closesocket (s);
         return -1;
     }
-    closesocket(s);
+    closesocket (s);
     return 0;
 }
 
 static int
-piperead( int s, char *buf, int len )
+piperead (int s, char *buf, int len)
 {
-    int ret = recv(s, buf, len, 0);
+    int ret = recv (s, buf, len, 0);
 
     if (ret < 0) {
-        const int werror= WSAGetLastError();
-        switch(werror) {
+        const int werror= WSAGetLastError ();
+        switch (werror) {
           /* simplified error mapping (not valid for connect) */
             case WSAEWOULDBLOCK:
                 errno = EAGAIN;
@@ -115,18 +115,18 @@ piperead( int s, char *buf, int len )
     return ret;
 }
 
-#define pipe(a) pgpipe(a)
-#define pipewrite(a,b,c) send(a,(char*)b,c,0)
+#define pipe(a) pgpipe (a)
+#define pipewrite(a,b,c) send (a, (char*)b,c,0)
 
 #else
-#define piperead(a,b,c) read(a,b,c)
-#define pipewrite(a,b,c) write(a,b,c)
+#define piperead(a,b,c) read (a,b,c)
+#define pipewrite(a,b,c) write (a,b,c)
 #endif
 
-#include <unistd.h> /* read(), write(), pipe() */
+#include <unistd.h> /* read (), write (), pipe () */
 
 #include "transmission.h"
-#include "platform.h" /* tr_lockLock() */
+#include "platform.h" /* tr_lockLock () */
 #include "trevent.h"
 #include "utils.h"
 
@@ -148,139 +148,139 @@ tr_event_handle;
 
 struct tr_run_data
 {
-    void    ( *func )( void * );
+    void  (*func)(void *);
     void *  user_data;
 };
 
-#define dbgmsg( ... ) \
+#define dbgmsg(...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, "event", __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, "event", __VA_ARGS__); \
+    } while (0)
 
 static void
-readFromPipe( int    fd,
+readFromPipe (int    fd,
               short  eventType,
-              void * veh )
+              void * veh)
 {
     char              ch;
     int               ret;
     tr_event_handle * eh = veh;
 
-    dbgmsg( "readFromPipe: eventType is %hd", eventType );
+    dbgmsg ("readFromPipe: eventType is %hd", eventType);
 
     /* read the command type */
     ch = '\0';
     do
     {
-        ret = piperead( fd, &ch, 1 );
+        ret = piperead (fd, &ch, 1);
     }
-    while( !eh->die && ret < 0 && errno == EAGAIN );
+    while (!eh->die && ret < 0 && errno == EAGAIN);
 
-    dbgmsg( "command is [%c], ret is %d, errno is %d", ch, ret, (int)errno );
+    dbgmsg ("command is [%c], ret is %d, errno is %d", ch, ret, (int)errno);
 
-    switch( ch )
+    switch (ch)
     {
         case 'r': /* run in libevent thread */
         {
             struct tr_run_data data;
-            const size_t       nwant = sizeof( data );
-            const ssize_t      ngot = piperead( fd, &data, nwant );
-            if( !eh->die && ( ngot == (ssize_t)nwant ) )
+            const size_t       nwant = sizeof (data);
+            const ssize_t      ngot = piperead (fd, &data, nwant);
+            if (!eh->die && (ngot == (ssize_t)nwant))
             {
-                dbgmsg( "invoking function in libevent thread" );
-                ( data.func )( data.user_data );
+                dbgmsg ("invoking function in libevent thread");
+              (data.func)(data.user_data);
             }
             break;
         }
 
         case '\0': /* eof */
         {
-            dbgmsg( "pipe eof reached... removing event listener" );
-            event_free( eh->pipeEvent );
+            dbgmsg ("pipe eof reached... removing event listener");
+            event_free (eh->pipeEvent);
             break;
         }
 
         default:
         {
-            assert( 0 && "unhandled command type!" );
+            assert (0 && "unhandled command type!");
             break;
         }
     }
 }
 
 static void
-logFunc( int severity, const char * message )
+logFunc (int severity, const char * message)
 {
-    if( severity >= _EVENT_LOG_ERR )
-        tr_err( "%s", message );
+    if (severity >= _EVENT_LOG_ERR)
+        tr_err ("%s", message);
     else
-        tr_dbg( "%s", message );
+        tr_dbg ("%s", message);
 }
 
 static void
-libeventThreadFunc( void * veh )
+libeventThreadFunc (void * veh)
 {
     struct event_base * base;
     tr_event_handle * eh = veh;
 
 #ifndef WIN32
     /* Don't exit when writing on a broken socket */
-    signal( SIGPIPE, SIG_IGN );
+    signal (SIGPIPE, SIG_IGN);
 #endif
 
     /* create the libevent bases */
-    base = event_base_new( );
+    base = event_base_new ();
 
     /* set the struct's fields */
     eh->base = base;
     eh->session->event_base = base;
-    eh->session->evdns_base = evdns_base_new( base, true );
+    eh->session->evdns_base = evdns_base_new (base, true);
     eh->session->events = eh;
 
     /* listen to the pipe's read fd */
-    eh->pipeEvent = event_new( base, eh->fds[0], EV_READ | EV_PERSIST, readFromPipe, veh );
-    event_add( eh->pipeEvent, NULL );
-    event_set_log_callback( logFunc );
+    eh->pipeEvent = event_new (base, eh->fds[0], EV_READ | EV_PERSIST, readFromPipe, veh);
+    event_add (eh->pipeEvent, NULL);
+    event_set_log_callback (logFunc);
 
     /* loop until all the events are done */
-    while( !eh->die )
-        event_base_dispatch( base );
+    while (!eh->die)
+        event_base_dispatch (base);
 
     /* shut down the thread */
-    tr_lockFree( eh->lock );
-    event_base_free( base );
+    tr_lockFree (eh->lock);
+    event_base_free (base);
     eh->session->events = NULL;
-    tr_free( eh );
-    tr_dbg( "Closing libevent thread" );
+    tr_free (eh);
+    tr_dbg ("Closing libevent thread");
 }
 
 void
-tr_eventInit( tr_session * session )
+tr_eventInit (tr_session * session)
 {
     tr_event_handle * eh;
 
     session->events = NULL;
 
-    eh = tr_new0( tr_event_handle, 1 );
-    eh->lock = tr_lockNew( );
-    pipe( eh->fds );
+    eh = tr_new0 (tr_event_handle, 1);
+    eh->lock = tr_lockNew ();
+    pipe (eh->fds);
     eh->session = session;
-    eh->thread = tr_threadNew( libeventThreadFunc, eh );
+    eh->thread = tr_threadNew (libeventThreadFunc, eh);
 
     /* wait until the libevent thread is running */
-    while( session->events == NULL )
-        tr_wait_msec( 100 );
+    while (session->events == NULL)
+        tr_wait_msec (100);
 }
 
 void
-tr_eventClose( tr_session * session )
+tr_eventClose (tr_session * session)
 {
-    assert( tr_isSession( session ) );
+    assert (tr_isSession (session));
 
     session->events->die = true;
-    tr_deepLog( __FILE__, __LINE__, NULL, "closing trevent pipe" );
-    tr_netCloseSocket( session->events->fds[1] );
+    tr_deepLog (__FILE__, __LINE__, NULL, "closing trevent pipe");
+    tr_netCloseSocket (session->events->fds[1]);
 }
 
 /**
@@ -288,12 +288,12 @@ tr_eventClose( tr_session * session )
 **/
 
 bool
-tr_amInEventThread( const tr_session * session )
+tr_amInEventThread (const tr_session * session)
 {
-    assert( tr_isSession( session ) );
-    assert( session->events != NULL );
+    assert (tr_isSession (session));
+    assert (session->events != NULL);
 
-    return tr_amInThread( session->events->thread );
+    return tr_amInThread (session->events->thread);
 }
 
 /**
@@ -301,15 +301,15 @@ tr_amInEventThread( const tr_session * session )
 **/
 
 void
-tr_runInEventThread( tr_session * session,
-                     void func( void* ), void * user_data )
+tr_runInEventThread (tr_session * session,
+                     void func (void*), void * user_data)
 {
-    assert( tr_isSession( session ) );
-    assert( session->events != NULL );
+    assert (tr_isSession (session));
+    assert (session->events != NULL);
 
-    if( tr_amInThread( session->events->thread ) )
+    if (tr_amInThread (session->events->thread))
     {
-        (func)( user_data );
+      (func)(user_data);
     }
     else
     {
@@ -318,11 +318,11 @@ tr_runInEventThread( tr_session * session,
         tr_lock *          lock = session->events->lock;
         struct tr_run_data data;
 
-        tr_lockLock( lock );
-        pipewrite( fd, &ch, 1 );
+        tr_lockLock (lock);
+        pipewrite (fd, &ch, 1);
         data.func = func;
         data.user_data = user_data;
-        pipewrite( fd, &data, sizeof( data ) );
-        tr_lockUnlock( lock );
+        pipewrite (fd, &data, sizeof (data));
+        tr_lockUnlock (lock);
     }
 }
diff --git a/libtransmission/trevent.h b/libtransmission/trevent.h
index 23879295d..c501f66d0 100644
--- a/libtransmission/trevent.h
+++ b/libtransmission/trevent.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -20,12 +20,12 @@
 /**
 **/
 
-void   tr_eventInit( tr_session * );
+void   tr_eventInit (tr_session *);
 
-void   tr_eventClose( tr_session * );
+void   tr_eventClose (tr_session *);
 
-bool   tr_amInEventThread( const tr_session * );
+bool   tr_amInEventThread (const tr_session *);
 
-void   tr_runInEventThread( tr_session *, void func( void* ), void * user_data );
+void   tr_runInEventThread (tr_session *, void func (void*), void * user_data);
 
 #endif
diff --git a/libtransmission/upnp.c b/libtransmission/upnp.c
index 1ac7e8347..9483b0056 100644
--- a/libtransmission/upnp.c
+++ b/libtransmission/upnp.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -32,7 +32,7 @@
 #include "utils.h"
 
 static const char *
-getKey( void ) { return _( "Port Forwarding (UPnP)" ); }
+getKey (void) { return _ ("Port Forwarding (UPnP)"); }
 
 typedef enum
 {
@@ -60,9 +60,9 @@ struct tr_upnp
 **/
 
 tr_upnp*
-tr_upnpInit( void )
+tr_upnpInit (void)
 {
-    tr_upnp * ret = tr_new0( tr_upnp, 1 );
+    tr_upnp * ret = tr_new0 (tr_upnp, 1);
 
     ret->state = TR_UPNP_DISCOVER;
     ret->port = -1;
@@ -70,16 +70,16 @@ tr_upnpInit( void )
 }
 
 void
-tr_upnpClose( tr_upnp * handle )
+tr_upnpClose (tr_upnp * handle)
 {
-    assert( !handle->isMapped );
-    assert( ( handle->state == TR_UPNP_IDLE )
-          || ( handle->state == TR_UPNP_ERR )
-          || ( handle->state == TR_UPNP_DISCOVER ) );
-
-    if( handle->hasDiscovered )
-        FreeUPNPUrls( &handle->urls );
-    tr_free( handle );
+    assert (!handle->isMapped);
+    assert ((handle->state == TR_UPNP_IDLE)
+          || (handle->state == TR_UPNP_ERR)
+          || (handle->state == TR_UPNP_DISCOVER));
+
+    if (handle->hasDiscovered)
+        FreeUPNPUrls (&handle->urls);
+    tr_free (handle);
 }
 
 /**
@@ -87,27 +87,27 @@ tr_upnpClose( tr_upnp * handle )
 **/
 
 static struct UPNPDev *
-tr_upnpDiscover( int msec )
+tr_upnpDiscover (int msec)
 {
     int err = 0;
     struct UPNPDev * ret = NULL;
 
-#if defined(HAVE_MINIUPNP_16)
-    ret = upnpDiscover( msec, NULL, NULL, 0, 0, &err );
-#elif defined(HAVE_MINIUPNP_15)
-    ret = upnpDiscover( msec, NULL, NULL, 0 );
+#if defined (HAVE_MINIUPNP_16)
+    ret = upnpDiscover (msec, NULL, NULL, 0, 0, &err);
+#elif defined (HAVE_MINIUPNP_15)
+    ret = upnpDiscover (msec, NULL, NULL, 0);
 #else
     ret = UPNPCOMMAND_UNKNOWN_ERROR;
 #endif
 
-    if( ret != UPNPCOMMAND_SUCCESS )
-        tr_ndbg( getKey( ), "upnpDiscover failed (errno %d - %s)", err, tr_strerror( err ) );
+    if (ret != UPNPCOMMAND_SUCCESS)
+        tr_ndbg (getKey (), "upnpDiscover failed (errno %d - %s)", err, tr_strerror (err));
 
     return ret;
 }
 
 static int
-tr_upnpGetSpecificPortMappingEntry( tr_upnp * handle, const char * proto )
+tr_upnpGetSpecificPortMappingEntry (tr_upnp * handle, const char * proto)
 {
     int err;
     char intClient[16];
@@ -117,12 +117,12 @@ tr_upnpGetSpecificPortMappingEntry( tr_upnp * handle, const char * proto )
     *intClient = '\0';
     *intPort = '\0';
 
-    tr_snprintf( portStr, sizeof( portStr ), "%d", (int)handle->port );
+    tr_snprintf (portStr, sizeof (portStr), "%d", (int)handle->port);
 
-#if defined(HAVE_MINIUPNP_16)
-    err = UPNP_GetSpecificPortMappingEntry( handle->urls.controlURL, handle->data.first.servicetype, portStr, proto, intClient, intPort, NULL, NULL, NULL );
-#elif defined(HAVE_MINIUPNP_15)
-    err = UPNP_GetSpecificPortMappingEntry( handle->urls.controlURL, handle->data.first.servicetype, portStr, proto, intClient, intPort );
+#if defined (HAVE_MINIUPNP_16)
+    err = UPNP_GetSpecificPortMappingEntry (handle->urls.controlURL, handle->data.first.servicetype, portStr, proto, intClient, intPort, NULL, NULL, NULL);
+#elif defined (HAVE_MINIUPNP_15)
+    err = UPNP_GetSpecificPortMappingEntry (handle->urls.controlURL, handle->data.first.servicetype, portStr, proto, intClient, intPort);
 #else
     err = UPNPCOMMAND_UNKNOWN_ERROR;
 #endif
@@ -131,40 +131,40 @@ tr_upnpGetSpecificPortMappingEntry( tr_upnp * handle, const char * proto )
 }
 
 static int
-tr_upnpAddPortMapping( const tr_upnp * handle, const char * proto, tr_port port, const char * desc )
+tr_upnpAddPortMapping (const tr_upnp * handle, const char * proto, tr_port port, const char * desc)
 {
     int err;
     const int old_errno = errno;
     char portStr[16];
     errno = 0;
 
-    tr_snprintf( portStr, sizeof( portStr ), "%d", (int)port );
+    tr_snprintf (portStr, sizeof (portStr), "%d", (int)port);
 
-#if defined(HAVE_MINIUPNP_16)
-    err = UPNP_AddPortMapping( handle->urls.controlURL, handle->data.first.servicetype, portStr, portStr, handle->lanaddr, desc, proto, NULL, NULL );
-#elif defined(HAVE_MINIUPNP_15)
-    err = UPNP_AddPortMapping( handle->urls.controlURL, handle->data.first.servicetype, portStr, portStr, handle->lanaddr, desc, proto, NULL );
+#if defined (HAVE_MINIUPNP_16)
+    err = UPNP_AddPortMapping (handle->urls.controlURL, handle->data.first.servicetype, portStr, portStr, handle->lanaddr, desc, proto, NULL, NULL);
+#elif defined (HAVE_MINIUPNP_15)
+    err = UPNP_AddPortMapping (handle->urls.controlURL, handle->data.first.servicetype, portStr, portStr, handle->lanaddr, desc, proto, NULL);
 #else
     err = UPNPCOMMAND_UNKNOWN_ERROR;
 #endif
 
-    if( err )
-        tr_ndbg( getKey( ), "%s Port forwarding failed with error %d (errno %d - %s)", proto, err, errno, tr_strerror( errno ) );
+    if (err)
+        tr_ndbg (getKey (), "%s Port forwarding failed with error %d (errno %d - %s)", proto, err, errno, tr_strerror (errno));
 
     errno = old_errno;
     return err;
 }
 
 static void
-tr_upnpDeletePortMapping( const tr_upnp * handle, const char * proto, tr_port port )
+tr_upnpDeletePortMapping (const tr_upnp * handle, const char * proto, tr_port port)
 {
     char portStr[16];
 
-    tr_snprintf( portStr, sizeof( portStr ), "%d", (int)port );
+    tr_snprintf (portStr, sizeof (portStr), "%d", (int)port);
 
-    UPNP_DeletePortMapping( handle->urls.controlURL,
+    UPNP_DeletePortMapping (handle->urls.controlURL,
                             handle->data.first.servicetype,
-                            portStr, proto, NULL );
+                            portStr, proto, NULL);
 }
 
 /**
@@ -180,118 +180,118 @@ enum
 };
 
 int
-tr_upnpPulse( tr_upnp * handle,
+tr_upnpPulse (tr_upnp * handle,
               int       port,
               int       isEnabled,
-              int       doPortCheck )
+              int       doPortCheck)
 {
     int ret;
 
-    if( isEnabled && ( handle->state == TR_UPNP_DISCOVER ) )
+    if (isEnabled && (handle->state == TR_UPNP_DISCOVER))
     {
         struct UPNPDev * devlist;
 
-        devlist = tr_upnpDiscover( 2000 );
+        devlist = tr_upnpDiscover (2000);
 
         errno = 0;
-        if( UPNP_GetValidIGD( devlist, &handle->urls, &handle->data,
-                             handle->lanaddr, sizeof( handle->lanaddr ) ) == UPNP_IGD_VALID_CONNECTED )
+        if (UPNP_GetValidIGD (devlist, &handle->urls, &handle->data,
+                             handle->lanaddr, sizeof (handle->lanaddr)) == UPNP_IGD_VALID_CONNECTED)
         {
-            tr_ninf( getKey( ), _(
-                         "Found Internet Gateway Device \"%s\"" ),
-                     handle->urls.controlURL );
-            tr_ninf( getKey( ), _(
-                         "Local Address is \"%s\"" ), handle->lanaddr );
+            tr_ninf (getKey (), _ (
+                         "Found Internet Gateway Device \"%s\""),
+                     handle->urls.controlURL);
+            tr_ninf (getKey (), _ (
+                         "Local Address is \"%s\""), handle->lanaddr);
             handle->state = TR_UPNP_IDLE;
             handle->hasDiscovered = 1;
         }
         else
         {
             handle->state = TR_UPNP_ERR;
-            tr_ndbg(
-                 getKey( ), "UPNP_GetValidIGD failed (errno %d - %s)",
+            tr_ndbg (
+                 getKey (), "UPNP_GetValidIGD failed (errno %d - %s)",
                 errno,
-                tr_strerror( errno ) );
-            tr_ndbg(
-                getKey( ),
-                "If your router supports UPnP, please make sure UPnP is enabled!" );
+                tr_strerror (errno));
+            tr_ndbg (
+                getKey (),
+                "If your router supports UPnP, please make sure UPnP is enabled!");
         }
-        freeUPNPDevlist( devlist );
+        freeUPNPDevlist (devlist);
     }
 
-    if( handle->state == TR_UPNP_IDLE )
+    if (handle->state == TR_UPNP_IDLE)
     {
-        if( handle->isMapped && ( !isEnabled || ( handle->port != port ) ) )
+        if (handle->isMapped && (!isEnabled || (handle->port != port)))
             handle->state = TR_UPNP_UNMAP;
     }
 
-    if( isEnabled && handle->isMapped && doPortCheck )
+    if (isEnabled && handle->isMapped && doPortCheck)
     {
-        if( ( tr_upnpGetSpecificPortMappingEntry( handle, "TCP" ) != UPNPCOMMAND_SUCCESS ) ||
-            ( tr_upnpGetSpecificPortMappingEntry( handle, "UDP" ) != UPNPCOMMAND_SUCCESS ) )
+        if ((tr_upnpGetSpecificPortMappingEntry (handle, "TCP") != UPNPCOMMAND_SUCCESS) ||
+          (tr_upnpGetSpecificPortMappingEntry (handle, "UDP") != UPNPCOMMAND_SUCCESS))
         {
-            tr_ninf( getKey( ), _( "Port %d isn't forwarded" ), handle->port );
+            tr_ninf (getKey (), _ ("Port %d isn't forwarded"), handle->port);
             handle->isMapped = false;
         }
     }
 
-    if( handle->state == TR_UPNP_UNMAP )
+    if (handle->state == TR_UPNP_UNMAP)
     {
-        tr_upnpDeletePortMapping( handle, "TCP", handle->port );
-        tr_upnpDeletePortMapping( handle, "UDP", handle->port );
+        tr_upnpDeletePortMapping (handle, "TCP", handle->port);
+        tr_upnpDeletePortMapping (handle, "UDP", handle->port);
 
-        tr_ninf( getKey( ),
-                 _( "Stopping port forwarding through \"%s\", service \"%s\"" ),
-                 handle->urls.controlURL, handle->data.first.servicetype );
+        tr_ninf (getKey (),
+                 _ ("Stopping port forwarding through \"%s\", service \"%s\""),
+                 handle->urls.controlURL, handle->data.first.servicetype);
 
         handle->isMapped = 0;
         handle->state = TR_UPNP_IDLE;
         handle->port = -1;
     }
 
-    if( handle->state == TR_UPNP_IDLE )
+    if (handle->state == TR_UPNP_IDLE)
     {
-        if( isEnabled && !handle->isMapped )
+        if (isEnabled && !handle->isMapped)
             handle->state = TR_UPNP_MAP;
     }
 
-    if( handle->state == TR_UPNP_MAP )
+    if (handle->state == TR_UPNP_MAP)
     {
         int  err_tcp = -1;
         int  err_udp = -1;
         errno = 0;
 
-        if( !handle->urls.controlURL || !handle->data.first.servicetype )
+        if (!handle->urls.controlURL || !handle->data.first.servicetype)
             handle->isMapped = 0;
         else
         {
             char desc[64];
-            tr_snprintf( desc, sizeof( desc ), "%s at %d", TR_NAME, port );
+            tr_snprintf (desc, sizeof (desc), "%s at %d", TR_NAME, port);
 
-            err_tcp = tr_upnpAddPortMapping( handle, "TCP", port, desc );
-            err_udp = tr_upnpAddPortMapping( handle, "UDP", port, desc );
+            err_tcp = tr_upnpAddPortMapping (handle, "TCP", port, desc);
+            err_udp = tr_upnpAddPortMapping (handle, "UDP", port, desc);
 
             handle->isMapped = !err_tcp | !err_udp;
         }
-        tr_ninf( getKey( ),
-                 _( "Port forwarding through \"%s\", service \"%s\". (local address: %s:%d)" ),
+        tr_ninf (getKey (),
+                 _ ("Port forwarding through \"%s\", service \"%s\". (local address: %s:%d)"),
                  handle->urls.controlURL, handle->data.first.servicetype,
-                 handle->lanaddr, port );
-        if( handle->isMapped )
+                 handle->lanaddr, port);
+        if (handle->isMapped)
         {
-            tr_ninf( getKey( ), "%s", _( "Port forwarding successful!" ) );
+            tr_ninf (getKey (), "%s", _ ("Port forwarding successful!"));
             handle->port = port;
             handle->state = TR_UPNP_IDLE;
         }
         else
         {
-            tr_ndbg( getKey( ), "If your router supports UPnP, please make sure UPnP is enabled!" );
+            tr_ndbg (getKey (), "If your router supports UPnP, please make sure UPnP is enabled!");
             handle->port = -1;
             handle->state = TR_UPNP_ERR;
         }
     }
 
-    switch( handle->state )
+    switch (handle->state)
     {
         case TR_UPNP_DISCOVER:
             ret = TR_PORT_UNMAPPED; break;
diff --git a/libtransmission/upnp.h b/libtransmission/upnp.h
index 660daad43..345edbb49 100644
--- a/libtransmission/upnp.h
+++ b/libtransmission/upnp.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -24,13 +24,13 @@
 
 typedef struct tr_upnp tr_upnp;
 
-tr_upnp * tr_upnpInit( void );
+tr_upnp * tr_upnpInit (void);
 
-void      tr_upnpClose( tr_upnp * );
+void      tr_upnpClose (tr_upnp *);
 
-int       tr_upnpPulse(         tr_upnp *,
+int       tr_upnpPulse (      tr_upnp *,
                             int port,
                             int isEnabled,
-                            int doPortCheck );
+                            int doPortCheck);
 /* @} */
 #endif
diff --git a/libtransmission/utils-test.c b/libtransmission/utils-test.c
index 12ec74987..18c3d7b90 100644
--- a/libtransmission/utils-test.c
+++ b/libtransmission/utils-test.c
@@ -1,5 +1,5 @@
-#include <math.h> /* sqrt() */
-#include <string.h> /* strlen() */
+#include <math.h> /* sqrt () */
+#include <string.h> /* strlen () */
 
 #include "transmission.h"
 #include "bitfield.h"
@@ -23,29 +23,29 @@
 #include "libtransmission-test.h"
 
 static int
-test_base64( void )
+test_base64 (void)
 {
     char *in, *out;
     int   len;
 
     /* base64 */
-    out = tr_base64_encode( "YOYO!", -1, &len );
+    out = tr_base64_encode ("YOYO!", -1, &len);
     check_streq ("WU9ZTyE=", out);
     check_int_eq (8, len);
-    in = tr_base64_decode( out, -1, &len );
+    in = tr_base64_decode (out, -1, &len);
     check_streq ("YOYO!", in);
     check_int_eq (5, len);
-    tr_free( in );
-    tr_free( out );
-    out = tr_base64_encode( NULL, 0, &len );
-    check( out == NULL );
+    tr_free (in);
+    tr_free (out);
+    out = tr_base64_encode (NULL, 0, &len);
+    check (out == NULL);
     check_int_eq (0, len);
 
     return 0;
 }
 
 static int
-test_bitfield_count_range( void )
+test_bitfield_count_range (void)
 {
     int i;
     int n;
@@ -53,97 +53,97 @@ test_bitfield_count_range( void )
     int end;
     int count1;
     int count2;
-    const int bitCount = 100 + tr_cryptoWeakRandInt( 1000 );
+    const int bitCount = 100 + tr_cryptoWeakRandInt (1000);
     tr_bitfield bf;
 
     /* generate a random bitfield */
-    tr_bitfieldConstruct( &bf, bitCount );
-    for( i=0, n=tr_cryptoWeakRandInt(bitCount); i<n; ++i )
-        tr_bitfieldAdd( &bf, tr_cryptoWeakRandInt(bitCount) );
+    tr_bitfieldConstruct (&bf, bitCount);
+    for (i=0, n=tr_cryptoWeakRandInt (bitCount); i<n; ++i)
+        tr_bitfieldAdd (&bf, tr_cryptoWeakRandInt (bitCount));
 
-    begin = tr_cryptoWeakRandInt( bitCount );
+    begin = tr_cryptoWeakRandInt (bitCount);
     do {
-        end = tr_cryptoWeakRandInt( bitCount );
-    } while( end == begin );
-    if( end < begin ) {
+        end = tr_cryptoWeakRandInt (bitCount);
+    } while (end == begin);
+    if (end < begin) {
         const int tmp = begin;
         begin = end;
         end = tmp;
     }
 
     count1 = 0;
-    for( i=begin; i<end; ++i )
-        if( tr_bitfieldHas( &bf, i ) )
+    for (i=begin; i<end; ++i)
+        if (tr_bitfieldHas (&bf, i))
             ++count1;
-    count2 = tr_bitfieldCountRange( &bf, begin, end );
-    check( count1 == count2 );
+    count2 = tr_bitfieldCountRange (&bf, begin, end);
+    check (count1 == count2);
 
-    tr_bitfieldDestruct( &bf );
+    tr_bitfieldDestruct (&bf);
     return 0;
 }
 
 static int
-test_bitfields( void )
+test_bitfields (void)
 {
     unsigned int  i;
     unsigned int  bitcount = 500;
     tr_bitfield field;
 
-    tr_bitfieldConstruct( &field, bitcount );
+    tr_bitfieldConstruct (&field, bitcount);
 
     /* test tr_bitfieldAdd */
-    for( i = 0; i < bitcount; ++i )
-        if( !( i % 7 ) )
-            tr_bitfieldAdd( &field, i );
-    for( i = 0; i < bitcount; ++i )
-        check( tr_bitfieldHas( &field, i ) == ( !( i % 7 ) ) );
+    for (i = 0; i < bitcount; ++i)
+        if (! (i % 7))
+            tr_bitfieldAdd (&field, i);
+    for (i = 0; i < bitcount; ++i)
+        check (tr_bitfieldHas (&field, i) == (! (i % 7)));
 
     /* test tr_bitfieldAddRange */
-    tr_bitfieldAddRange( &field, 0, bitcount );
-    for( i = 0; i < bitcount; ++i )
-        check( tr_bitfieldHas( &field, i ) );
+    tr_bitfieldAddRange (&field, 0, bitcount);
+    for (i = 0; i < bitcount; ++i)
+        check (tr_bitfieldHas (&field, i));
 
     /* test tr_bitfieldRemRange in the middle of a boundary */
-    tr_bitfieldRemRange( &field, 4, 21 );
-    for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( &field, i ) == ( ( i < 4 ) || ( i >= 21 ) ) );
+    tr_bitfieldRemRange (&field, 4, 21);
+    for (i = 0; i < 64; ++i)
+        check (tr_bitfieldHas (&field, i) == ((i < 4) || (i >= 21)));
 
     /* test tr_bitfieldRemRange on the boundaries */
-    tr_bitfieldAddRange( &field, 0, 64 );
-    tr_bitfieldRemRange( &field, 8, 24 );
-    for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( &field, i ) == ( ( i < 8 ) || ( i >= 24 ) ) );
+    tr_bitfieldAddRange (&field, 0, 64);
+    tr_bitfieldRemRange (&field, 8, 24);
+    for (i = 0; i < 64; ++i)
+        check (tr_bitfieldHas (&field, i) == ((i < 8) || (i >= 24)));
 
     /* test tr_bitfieldRemRange when begin & end is on the same word */
-    tr_bitfieldAddRange( &field, 0, 64 );
-    tr_bitfieldRemRange( &field, 4, 5 );
-    for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( &field, i ) == ( ( i < 4 ) || ( i >= 5 ) ) );
+    tr_bitfieldAddRange (&field, 0, 64);
+    tr_bitfieldRemRange (&field, 4, 5);
+    for (i = 0; i < 64; ++i)
+        check (tr_bitfieldHas (&field, i) == ((i < 4) || (i >= 5)));
 
     /* test tr_bitfieldAddRange */
-    tr_bitfieldRemRange( &field, 0, 64 );
-    tr_bitfieldAddRange( &field, 4, 21 );
-    for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( &field, i ) == ( ( 4 <= i ) && ( i < 21 ) ) );
+    tr_bitfieldRemRange (&field, 0, 64);
+    tr_bitfieldAddRange (&field, 4, 21);
+    for (i = 0; i < 64; ++i)
+        check (tr_bitfieldHas (&field, i) == ((4 <= i) && (i < 21)));
 
     /* test tr_bitfieldAddRange on the boundaries */
-    tr_bitfieldRemRange( &field, 0, 64 );
-    tr_bitfieldAddRange( &field, 8, 24 );
-    for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( &field, i ) == ( ( 8 <= i ) && ( i < 24 ) ) );
+    tr_bitfieldRemRange (&field, 0, 64);
+    tr_bitfieldAddRange (&field, 8, 24);
+    for (i = 0; i < 64; ++i)
+        check (tr_bitfieldHas (&field, i) == ((8 <= i) && (i < 24)));
 
     /* test tr_bitfieldAddRange when begin & end is on the same word */
-    tr_bitfieldRemRange( &field, 0, 64 );
-    tr_bitfieldAddRange( &field, 4, 5 );
-    for( i = 0; i < 64; ++i )
-        check( tr_bitfieldHas( &field, i ) == ( ( 4 <= i ) && ( i < 5 ) ) );
+    tr_bitfieldRemRange (&field, 0, 64);
+    tr_bitfieldAddRange (&field, 4, 5);
+    for (i = 0; i < 64; ++i)
+        check (tr_bitfieldHas (&field, i) == ((4 <= i) && (i < 5)));
 
-    tr_bitfieldDestruct( &field );
+    tr_bitfieldDestruct (&field);
     return 0;
 }
 
 static int
-test_strip_positional_args( void )
+test_strip_positional_args (void)
 {
     const char * in;
     const char * out;
@@ -151,226 +151,226 @@ test_strip_positional_args( void )
 
     in = "Hello %1$s foo %2$.*f";
     expected = "Hello %s foo %.*f";
-    out = tr_strip_positional_args( in );
+    out = tr_strip_positional_args (in);
     check_streq (expected, out);
 
     in = "Hello %1$'d foo %2$'f";
     expected = "Hello %d foo %f";
-    out = tr_strip_positional_args( in );
+    out = tr_strip_positional_args (in);
     check_streq (expected, out);
 
     return 0;
 }
 
 static int
-test_strstrip( void )
+test_strstrip (void)
 {
     char *in, *out;
 
     /* strstrip */
-    in = tr_strdup( "   test    " );
-    out = tr_strstrip( in );
-    check( in == out );
+    in = tr_strdup ("   test    ");
+    out = tr_strstrip (in);
+    check (in == out);
     check_streq ("test", out);
-    tr_free( in );
+    tr_free (in);
 
     /* strstrip */
-    in = tr_strdup( " test test " );
-    out = tr_strstrip( in );
-    check( in == out );
+    in = tr_strdup (" test test ");
+    out = tr_strstrip (in);
+    check (in == out);
     check_streq ("test test", out);
-    tr_free( in );
+    tr_free (in);
 
     /* strstrip */
-    in = tr_strdup( "test" );
-    out = tr_strstrip( in );
-    check( in == out );
+    in = tr_strdup ("test");
+    out = tr_strstrip (in);
+    check (in == out);
     check_streq ("test", out);
-    tr_free( in );
+    tr_free (in);
 
     return 0;
 }
 
 static int
-test_buildpath( void )
+test_buildpath (void)
 {
     char * out;
 
-    out = tr_buildPath( "foo", "bar", NULL );
+    out = tr_buildPath ("foo", "bar", NULL);
     check_streq ("foo" TR_PATH_DELIMITER_STR "bar", out);
-    tr_free( out );
+    tr_free (out);
 
-    out = tr_buildPath( "", "foo", "bar", NULL );
+    out = tr_buildPath ("", "foo", "bar", NULL);
     check_streq (TR_PATH_DELIMITER_STR "foo" TR_PATH_DELIMITER_STR "bar", out);
-    tr_free( out );
+    tr_free (out);
 
     return 0;
 }
 
 static int
-test_utf8( void )
+test_utf8 (void)
 {
     const char * in;
     char * out;
 
     in = "hello world";
-    out = tr_utf8clean( in, -1 );
+    out = tr_utf8clean (in, -1);
     check_streq (in, out);
-    tr_free( out );
+    tr_free (out);
 
     in = "hello world";
-    out = tr_utf8clean( in, 5 );
+    out = tr_utf8clean (in, 5);
     check_streq ("hello", out);
-    tr_free( out );
+    tr_free (out);
 
     /* this version is not utf-8 */
     in = "Òðóäíî áûòü Áîãîì";
-    out = tr_utf8clean( in, 17 );
-    check( out != NULL );
-    check( ( strlen( out ) == 17 ) || ( strlen( out ) == 32 ) );
-    check( tr_utf8_validate( out, -1, NULL ) );
-    tr_free( out );
+    out = tr_utf8clean (in, 17);
+    check (out != NULL);
+    check ((strlen (out) == 17) || (strlen (out) == 32));
+    check (tr_utf8_validate (out, -1, NULL));
+    tr_free (out);
 
     /* same string, but utf-8 clean */
     in = "Òðóäíî áûòü Áîãîì";
-    out = tr_utf8clean( in, -1 );
-    check( out != NULL );
-    check( tr_utf8_validate( out, -1, NULL ) );
+    out = tr_utf8clean (in, -1);
+    check (out != NULL);
+    check (tr_utf8_validate (out, -1, NULL));
     check_streq (in, out);
-    tr_free( out );
+    tr_free (out);
 
     return 0;
 }
 
 static int
-test_numbers( void )
+test_numbers (void)
 {
     int i;
     int count;
     int * numbers;
 
-    numbers = tr_parseNumberRange( "1-10,13,16-19", -1, &count );
-    check_int_eq( 15, count );
-    check_int_eq( 1, numbers[0] );
-    check_int_eq( 6, numbers[5] );
-    check_int_eq( 10, numbers[9] );
-    check_int_eq( 13, numbers[10] );
-    check_int_eq( 16, numbers[11] );
-    check_int_eq( 19, numbers[14] );
-    tr_free( numbers );
-
-    numbers = tr_parseNumberRange( "1-5,3-7,2-6", -1, &count );
-    check( count == 7 );
-    check( numbers != NULL );
-    for( i=0; i<count; ++i )
+    numbers = tr_parseNumberRange ("1-10,13,16-19", -1, &count);
+    check_int_eq (15, count);
+    check_int_eq (1, numbers[0]);
+    check_int_eq (6, numbers[5]);
+    check_int_eq (10, numbers[9]);
+    check_int_eq (13, numbers[10]);
+    check_int_eq (16, numbers[11]);
+    check_int_eq (19, numbers[14]);
+    tr_free (numbers);
+
+    numbers = tr_parseNumberRange ("1-5,3-7,2-6", -1, &count);
+    check (count == 7);
+    check (numbers != NULL);
+    for (i=0; i<count; ++i)
         check_int_eq (i+1, numbers[i]);
-    tr_free( numbers );
+    tr_free (numbers);
 
-    numbers = tr_parseNumberRange( "1-Hello", -1, &count );
+    numbers = tr_parseNumberRange ("1-Hello", -1, &count);
     check_int_eq (0, count);
-    check( numbers == NULL );
+    check (numbers == NULL);
 
-    numbers = tr_parseNumberRange( "1-", -1, &count );
+    numbers = tr_parseNumberRange ("1-", -1, &count);
     check_int_eq (0, count);
-    check( numbers == NULL );
+    check (numbers == NULL);
 
-    numbers = tr_parseNumberRange( "Hello", -1, &count );
+    numbers = tr_parseNumberRange ("Hello", -1, &count);
     check_int_eq (0, count);
-    check( numbers == NULL );
+    check (numbers == NULL);
 
     return 0;
 }
 
 static int
-compareInts( const void * va, const void * vb )
+compareInts (const void * va, const void * vb)
 {
-    const int a = *(const int *)va;
-    const int b = *(const int*)vb;
+    const int a = * (const int *)va;
+    const int b = * (const int*)vb;
     return a - b;
 }
 
 static int
-test_lowerbound( void )
+test_lowerbound (void)
 {
     int i;
     const int A[] = { 1, 2, 3, 3, 3, 5, 8 };
     const int expected_pos[] = { 0, 1, 2, 5, 5, 6, 6, 6, 7, 7 };
     const int expected_exact[] = { true, true, true, false, true, false, false, true, false, false };
-    const int N = sizeof(A) / sizeof(A[0]);
+    const int N = sizeof (A) / sizeof (A[0]);
 
-    for( i=1; i<=10; ++i )
+    for (i=1; i<=10; ++i)
     {
         bool exact;
-        const int pos = tr_lowerBound( &i, A, N, sizeof(int), compareInts, &exact );
+        const int pos = tr_lowerBound (&i, A, N, sizeof (int), compareInts, &exact);
 
 #if 0
-        fprintf( stderr, "searching for %d. ", i );
-        fprintf( stderr, "result: index = %d, ", pos );
-        if( pos != N )
-            fprintf( stderr, "A[%d] == %d\n", pos, A[pos] );
+        fprintf (stderr, "searching for %d. ", i);
+        fprintf (stderr, "result: index = %d, ", pos);
+        if (pos != N)
+            fprintf (stderr, "A[%d] == %d\n", pos, A[pos]);
         else
-            fprintf( stderr, "which is off the end.\n" );
+            fprintf (stderr, "which is off the end.\n");
 #endif
-        check_int_eq( expected_pos[i-1], pos );
-        check_int_eq( expected_exact[i-1], exact );
+        check_int_eq (expected_pos[i-1], pos);
+        check_int_eq (expected_exact[i-1], exact);
     }
 
     return 0;
 }
 
 static int
-test_memmem( void )
+test_memmem (void)
 {
     char const haystack[12] = "abcabcabcabc";
     char const needle[3] = "cab";
 
-    check( tr_memmem( haystack, sizeof haystack, haystack, sizeof haystack) == haystack );
-    check( tr_memmem( haystack, sizeof haystack, needle, sizeof needle) == haystack + 2 );
-    check( tr_memmem( needle, sizeof needle, haystack, sizeof haystack) == NULL );
+    check (tr_memmem (haystack, sizeof haystack, haystack, sizeof haystack) == haystack);
+    check (tr_memmem (haystack, sizeof haystack, needle, sizeof needle) == haystack + 2);
+    check (tr_memmem (needle, sizeof needle, haystack, sizeof haystack) == NULL);
 
     return 0;
 }
 
 static int
-test_hex( void )
+test_hex (void)
 {
     char hex1[41];
     char hex2[41];
     uint8_t sha1[20];
     /*uint8_t sha2[20];*/
 
-    memcpy( hex1, "fb5ef5507427b17e04b69cef31fa3379b456735a", 41 );
-    tr_hex_to_sha1( sha1, hex1 );
-    tr_sha1_to_hex( hex2, sha1 );
+    memcpy (hex1, "fb5ef5507427b17e04b69cef31fa3379b456735a", 41);
+    tr_hex_to_sha1 (sha1, hex1);
+    tr_sha1_to_hex (hex2, sha1);
     check_streq (hex1, hex2);
 
     return 0;
 }
 
 static int
-test_array( void )
+test_array (void)
 {
     int i;
     int array[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-    int n = sizeof( array ) / sizeof( array[0] );
+    int n = sizeof (array) / sizeof (array[0]);
 
-    tr_removeElementFromArray( array, 5u, sizeof( int ), n-- );
-    for( i=0; i<n; ++i )
-        check_int_eq( ( i<5 ? i : i+1 ), array[i] );
+    tr_removeElementFromArray (array, 5u, sizeof (int), n--);
+    for (i=0; i<n; ++i)
+        check_int_eq ((i<5 ? i : i+1), array[i]);
 
-    tr_removeElementFromArray( array, 0u, sizeof( int ), n-- );
-    for( i=0; i<n; ++i )
-        check_int_eq( ( i<4 ? i+1 : i+2 ), array[i] );
+    tr_removeElementFromArray (array, 0u, sizeof (int), n--);
+    for (i=0; i<n; ++i)
+        check_int_eq ((i<4 ? i+1 : i+2), array[i]);
 
-    tr_removeElementFromArray( array, n-1, sizeof( int ), n ); n--;
-    for( i=0; i<n; ++i )
-        check_int_eq( ( i<4 ? i+1 : i+2 ), array[i] );
+    tr_removeElementFromArray (array, n-1, sizeof (int), n); n--;
+    for (i=0; i<n; ++i)
+        check_int_eq ((i<4 ? i+1 : i+2), array[i]);
 
     return 0;
 }
 
 static int
-test_url( void )
+test_url (void)
 {
     int port;
     char * scheme;
@@ -380,87 +380,87 @@ test_url( void )
     const char * url;
 
     url = "http://1";
-    check( !tr_urlParse( url, -1, &scheme, &host, &port, &path ) );
+    check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
     check_streq ("http", scheme);
     check_streq ("1", host);
     check_streq ("/", path);
     check_int_eq (80, port);
-    tr_free( scheme );
-    tr_free( path );
-    tr_free( host );
+    tr_free (scheme);
+    tr_free (path);
+    tr_free (host);
 
     url = "http://www.some-tracker.org/some/path";
-    check( !tr_urlParse( url, -1, &scheme, &host, &port, &path ) );
+    check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
     check_streq ("http", scheme);
     check_streq ("www.some-tracker.org", host);
     check_streq ("/some/path", path);
     check_int_eq (80, port);
-    tr_free( scheme );
-    tr_free( path );
-    tr_free( host );
+    tr_free (scheme);
+    tr_free (path);
+    tr_free (host);
 
     url = "http://www.some-tracker.org:80/some/path";
-    check( !tr_urlParse( url, -1, &scheme, &host, &port, &path ) );
+    check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
     check_streq ("http", scheme);
     check_streq ("www.some-tracker.org", host);
     check_streq ("/some/path", path);
     check_int_eq (80, port);
-    tr_free( scheme );
-    tr_free( path );
-    tr_free( host );
+    tr_free (scheme);
+    tr_free (path);
+    tr_free (host);
 
     url = "http%3A%2F%2Fwww.example.com%2F~user%2F%3Ftest%3D1%26test1%3D2";
-    str = tr_http_unescape( url, strlen( url ) );
+    str = tr_http_unescape (url, strlen (url));
     check_streq ("http://www.example.com/~user/?test=1&test1=2", str);
-    tr_free( str );
+    tr_free (str);
 
     return 0;
 }
 
 static int
-test_truncd( void )
+test_truncd (void)
 {
     char buf[32];
-    const double nan = sqrt( -1 );
+    const double nan = sqrt (-1);
 
-    tr_snprintf( buf, sizeof( buf ), "%.2f%%", 99.999 );
-    check_streq("100.00%", buf);
+    tr_snprintf (buf, sizeof (buf), "%.2f%%", 99.999);
+    check_streq ("100.00%", buf);
 
-    tr_snprintf( buf, sizeof( buf ), "%.2f%%", tr_truncd( 99.999, 2 ) );
-    check_streq("99.99%", buf);
+    tr_snprintf (buf, sizeof (buf), "%.2f%%", tr_truncd (99.999, 2));
+    check_streq ("99.99%", buf);
 
-    tr_snprintf( buf, sizeof( buf ), "%.4f", tr_truncd( 403650.656250, 4 ) );
-    check_streq("403650.6562", buf);
+    tr_snprintf (buf, sizeof (buf), "%.4f", tr_truncd (403650.656250, 4));
+    check_streq ("403650.6562", buf);
 
-    tr_snprintf( buf, sizeof( buf ), "%.2f", tr_truncd( 2.15, 2 ) );
-    check_streq( "2.15", buf );
+    tr_snprintf (buf, sizeof (buf), "%.2f", tr_truncd (2.15, 2));
+    check_streq ("2.15", buf);
 
-    tr_snprintf( buf, sizeof( buf ), "%.2f", tr_truncd( 2.05, 2 ) );
-    check_streq( "2.05", buf );
+    tr_snprintf (buf, sizeof (buf), "%.2f", tr_truncd (2.05, 2));
+    check_streq ("2.05", buf);
 
-    tr_snprintf( buf, sizeof( buf ), "%.2f", tr_truncd( 3.3333, 2 ) );
-    check_streq( "3.33", buf );
+    tr_snprintf (buf, sizeof (buf), "%.2f", tr_truncd (3.3333, 2));
+    check_streq ("3.33", buf);
 
-    tr_snprintf( buf, sizeof( buf ), "%.0f", tr_truncd( 3.3333, 0 ) );
-    check_streq( "3", buf );
+    tr_snprintf (buf, sizeof (buf), "%.0f", tr_truncd (3.3333, 0));
+    check_streq ("3", buf);
 
-    tr_snprintf( buf, sizeof( buf ), "%.2f", tr_truncd( nan, 2 ) );
-    check( strstr( buf, "nan" ) != NULL );
+    tr_snprintf (buf, sizeof (buf), "%.2f", tr_truncd (nan, 2));
+    check (strstr (buf, "nan") != NULL);
 
     return 0;
 }
 
 static int
-test_cryptoRand( void )
+test_cryptoRand (void)
 {
     int i;
 
-    /* test that tr_cryptoRandInt() stays in-bounds */
-    for( i = 0; i < 100000; ++i )
+    /* test that tr_cryptoRandInt () stays in-bounds */
+    for (i = 0; i < 100000; ++i)
     {
-        const int val = tr_cryptoRandInt( 100 );
-        check( val >= 0 );
-        check( val < 100 );
+        const int val = tr_cryptoRandInt (100);
+        check (val >= 0);
+        check (val < 100);
     }
 
     return 0;
@@ -475,7 +475,7 @@ struct blah
 };
 
 int
-main( void )
+main (void)
 {
     const testFunc tests[] = {
 	test_base64, test_hex, test_lowerbound, test_strip_positional_args,
@@ -485,17 +485,17 @@ main( void )
     int   ret;
     int   l;
 
-    if( (ret = runTests(tests, NUM_TESTS(tests))) )
+    if ((ret = runTests (tests, NUM_TESTS (tests))))
 	return ret;
 
     /* simple bitfield tests */
-    for( l = 0; l < NUM_LOOPS; ++l )
-        if( ( ret = test_bitfields( ) ) )
+    for (l = 0; l < NUM_LOOPS; ++l)
+        if ((ret = test_bitfields ()))
             return ret;
 
     /* bitfield count range */
-    for( l=0; l<10000; ++l )
-        if(( ret = test_bitfield_count_range( )))
+    for (l=0; l<10000; ++l)
+        if ((ret = test_bitfield_count_range ()))
             return ret;
 
     return 0;
diff --git a/libtransmission/utils.c b/libtransmission/utils.c
index 4a37b6ef1..4930e90e3 100644
--- a/libtransmission/utils.c
+++ b/libtransmission/utils.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -14,7 +14,7 @@
  #define _GNU_SOURCE /* glibc's string.h needs this to pick up memmem */
 #endif
 
-#if defined(SYS_DARWIN)
+#if defined (SYS_DARWIN)
  #define HAVE_GETPAGESIZE
  #define HAVE_ICONV_OPEN
  #define HAVE_MKDTEMP
@@ -22,34 +22,34 @@
 #endif
 
 #include <assert.h>
-#include <ctype.h> /* isdigit(), isalpha(), tolower() */
+#include <ctype.h> /* isdigit (), isalpha (), tolower () */
 #include <errno.h>
 #include <float.h> /* DBL_EPSILON */
-#include <locale.h> /* localeconv() */
-#include <math.h> /* pow(), fabs(), floor() */
+#include <locale.h> /* localeconv () */
+#include <math.h> /* pow (), fabs (), floor () */
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h> /* strerror(), memset(), memmem() */
-#include <time.h> /* nanosleep() */
+#include <string.h> /* strerror (), memset (), memmem () */
+#include <time.h> /* nanosleep () */
 
 #ifdef HAVE_ICONV_OPEN
  #include <iconv.h>
 #endif
-#include <libgen.h> /* basename() */
+#include <libgen.h> /* basename () */
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <unistd.h> /* stat(), getcwd(), getpagesize(), unlink() */
+#include <unistd.h> /* stat (), getcwd (), getpagesize (), unlink () */
 
 #include <event2/buffer.h>
 #include <event2/event.h>
 
 #ifdef WIN32
  #include <w32api.h>
- #define WINVER WindowsXP /* freeaddrinfo(), getaddrinfo(), getnameinfo() */
- #include <direct.h> /* _getcwd() */
- #include <windows.h> /* Sleep() */
+ #define WINVER WindowsXP /* freeaddrinfo (), getaddrinfo (), getnameinfo () */
+ #include <direct.h> /* _getcwd () */
+ #include <windows.h> /* Sleep () */
 #endif
 
 #include "transmission.h"
@@ -58,7 +58,7 @@
 #include "ConvertUTF.h"
 #include "list.h"
 #include "utils.h"
-#include "platform.h" /* tr_lockLock(), TR_PATH_MAX */
+#include "platform.h" /* tr_lockLock (), TR_PATH_MAX */
 #include "version.h"
 
 
@@ -72,8 +72,8 @@ static int            messageQueueCount = 0;
 
 #ifndef WIN32
     /* make null versions of these win32 functions */
-    static inline int IsDebuggerPresent( void ) { return false; }
-    static inline void OutputDebugString( const void * unused UNUSED ) { }
+    static inline int IsDebuggerPresent (void) { return false; }
+    static inline void OutputDebugString (const void * unused UNUSED) { }
 #endif
 
 /***
@@ -81,29 +81,29 @@ static int            messageQueueCount = 0;
 ***/
 
 static tr_lock*
-getMessageLock( void )
+getMessageLock (void)
 {
     static tr_lock * l = NULL;
 
-    if( !l )
-        l = tr_lockNew( );
+    if (!l)
+        l = tr_lockNew ();
 
     return l;
 }
 
 void*
-tr_getLog( void )
+tr_getLog (void)
 {
     static bool initialized = false;
     static FILE * file = NULL;
 
-    if( !initialized )
+    if (!initialized)
     {
-        const char * str = getenv( "TR_DEBUG_FD" );
+        const char * str = getenv ("TR_DEBUG_FD");
         int          fd = 0;
-        if( str && *str )
-            fd = atoi( str );
-        switch( fd )
+        if (str && *str)
+            fd = atoi (str);
+        switch (fd)
         {
             case 1:
                 file = stdout; break;
@@ -121,28 +121,28 @@ tr_getLog( void )
 }
 
 void
-tr_setMessageLevel( tr_msg_level level )
+tr_setMessageLevel (tr_msg_level level)
 {
     __tr_message_level = level;
 }
 
 void
-tr_setMessageQueuing( bool enabled )
+tr_setMessageQueuing (bool enabled)
 {
     messageQueuing = enabled;
 }
 
 bool
-tr_getMessageQueuing( void )
+tr_getMessageQueuing (void)
 {
     return messageQueuing != 0;
 }
 
 tr_msg_list *
-tr_getQueuedMessages( void )
+tr_getQueuedMessages (void)
 {
     tr_msg_list * ret;
-    tr_lockLock( getMessageLock( ) );
+    tr_lockLock (getMessageLock ());
 
     ret = messageQueue;
     messageQueue = NULL;
@@ -150,21 +150,21 @@ tr_getQueuedMessages( void )
 
     messageQueueCount = 0;
 
-    tr_lockUnlock( getMessageLock( ) );
+    tr_lockUnlock (getMessageLock ());
     return ret;
 }
 
 void
-tr_freeMessageList( tr_msg_list * list )
+tr_freeMessageList (tr_msg_list * list)
 {
     tr_msg_list * next;
 
-    while( NULL != list )
+    while (NULL != list)
     {
         next = list->next;
-        free( list->message );
-        free( list->name );
-        free( list );
+        free (list->message);
+        free (list->name);
+        free (list);
         list = next;
     }
 }
@@ -174,20 +174,20 @@ tr_freeMessageList( tr_msg_list * list )
 **/
 
 struct tm *
-tr_localtime_r( const time_t *_clock, struct tm *_result )
+tr_localtime_r (const time_t *_clock, struct tm *_result)
 {
 #ifdef HAVE_LOCALTIME_R
-    return localtime_r( _clock, _result );
+    return localtime_r (_clock, _result);
 #else
-    struct tm *p = localtime( _clock );
-    if( p )
-        *(_result) = *p;
+    struct tm *p = localtime (_clock);
+    if (p)
+        * (_result) = *p;
     return p;
 #endif
 }
 
 char*
-tr_getLogTimeStr( char * buf, int buflen )
+tr_getLogTimeStr (char * buf, int buflen)
 {
     char           tmp[64];
     struct tm      now_tm;
@@ -195,60 +195,60 @@ tr_getLogTimeStr( char * buf, int buflen )
     time_t         seconds;
     int            milliseconds;
 
-    gettimeofday( &tv, NULL );
+    gettimeofday (&tv, NULL);
 
     seconds = tv.tv_sec;
-    tr_localtime_r( &seconds, &now_tm );
-    strftime( tmp, sizeof( tmp ), "%H:%M:%S", &now_tm );
+    tr_localtime_r (&seconds, &now_tm);
+    strftime (tmp, sizeof (tmp), "%H:%M:%S", &now_tm);
     milliseconds = tv.tv_usec / 1000;
-    tr_snprintf( buf, buflen, "%s.%03d", tmp, milliseconds );
+    tr_snprintf (buf, buflen, "%s.%03d", tmp, milliseconds);
 
     return buf;
 }
 
 bool
-tr_deepLoggingIsActive( void )
+tr_deepLoggingIsActive (void)
 {
     static int8_t deepLoggingIsActive = -1;
 
-    if( deepLoggingIsActive < 0 )
-        deepLoggingIsActive = IsDebuggerPresent() || (tr_getLog()!=NULL);
+    if (deepLoggingIsActive < 0)
+        deepLoggingIsActive = IsDebuggerPresent () || (tr_getLog ()!=NULL);
 
     return deepLoggingIsActive != 0;
 }
 
 void
-tr_deepLog( const char  * file,
+tr_deepLog (const char  * file,
             int           line,
             const char  * name,
             const char  * fmt,
-            ... )
+            ...)
 {
-    FILE * fp = tr_getLog( );
-    if( fp || IsDebuggerPresent( ) )
+    FILE * fp = tr_getLog ();
+    if (fp || IsDebuggerPresent ())
     {
         va_list           args;
         char              timestr[64];
-        struct evbuffer * buf = evbuffer_new( );
-        char *            base = tr_basename( file );
+        struct evbuffer * buf = evbuffer_new ();
+        char *            base = tr_basename (file);
         char *            message;
 
-        evbuffer_add_printf( buf, "[%s] ",
-                            tr_getLogTimeStr( timestr, sizeof( timestr ) ) );
-        if( name )
-            evbuffer_add_printf( buf, "%s ", name );
-        va_start( args, fmt );
-        evbuffer_add_vprintf( buf, fmt, args );
-        va_end( args );
-        evbuffer_add_printf( buf, " (%s:%d)\n", base, line );
-        /* FIXME(libevent2) ifdef this out for nonwindows platforms */
-        message = evbuffer_free_to_str( buf );
-        OutputDebugString( message );
-        if( fp )
-            fputs( message, fp );
-
-        tr_free( message );
-        tr_free( base );
+        evbuffer_add_printf (buf, "[%s] ",
+                            tr_getLogTimeStr (timestr, sizeof (timestr)));
+        if (name)
+            evbuffer_add_printf (buf, "%s ", name);
+        va_start (args, fmt);
+        evbuffer_add_vprintf (buf, fmt, args);
+        va_end (args);
+        evbuffer_add_printf (buf, " (%s:%d)\n", base, line);
+        /* FIXME (libevent2) ifdef this out for nonwindows platforms */
+        message = evbuffer_free_to_str (buf);
+        OutputDebugString (message);
+        if (fp)
+            fputs (message, fp);
+
+        tr_free (message);
+        tr_free (base);
     }
 }
 
@@ -257,51 +257,51 @@ tr_deepLog( const char  * file,
 ***/
 
 void
-tr_msg( const char * file, int line,
+tr_msg (const char * file, int line,
         tr_msg_level level,
         const char * name,
-        const char * fmt, ... )
+        const char * fmt, ...)
 {
     const int err = errno; /* message logging shouldn't affect errno */
     char buf[1024];
     va_list ap;
-    tr_lockLock( getMessageLock( ) );
+    tr_lockLock (getMessageLock ());
 
     /* build the text message */
     *buf = '\0';
-    va_start( ap, fmt );
-    evutil_vsnprintf( buf, sizeof( buf ), fmt, ap );
-    va_end( ap );
+    va_start (ap, fmt);
+    evutil_vsnprintf (buf, sizeof (buf), fmt, ap);
+    va_end (ap);
 
-    OutputDebugString( buf );
+    OutputDebugString (buf);
 
-    if( *buf )
+    if (*buf)
     {
-        if( messageQueuing )
+        if (messageQueuing)
         {
             tr_msg_list * newmsg;
-            newmsg = tr_new0( tr_msg_list, 1 );
+            newmsg = tr_new0 (tr_msg_list, 1);
             newmsg->level = level;
-            newmsg->when = tr_time( );
-            newmsg->message = tr_strdup( buf );
+            newmsg->when = tr_time ();
+            newmsg->message = tr_strdup (buf);
             newmsg->file = file;
             newmsg->line = line;
-            newmsg->name = tr_strdup( name );
+            newmsg->name = tr_strdup (name);
 
             *messageQueueTail = newmsg;
             messageQueueTail = &newmsg->next;
             ++messageQueueCount;
 
-            if( messageQueueCount > TR_MAX_MSG_LOG )
+            if (messageQueueCount > TR_MAX_MSG_LOG)
             {
                 tr_msg_list * old = messageQueue;
                 messageQueue = old->next;
                 old->next = NULL;
-                tr_freeMessageList(old);
+                tr_freeMessageList (old);
 
                 --messageQueueCount;
 
-                assert( messageQueueCount == TR_MAX_MSG_LOG );
+                assert (messageQueueCount == TR_MAX_MSG_LOG);
             }
         }
         else
@@ -309,21 +309,21 @@ tr_msg( const char * file, int line,
             char timestr[64];
             FILE * fp;
 
-            fp = tr_getLog( );
-            if( fp == NULL )
+            fp = tr_getLog ();
+            if (fp == NULL)
                 fp = stderr;
 
-            tr_getLogTimeStr( timestr, sizeof( timestr ) );
+            tr_getLogTimeStr (timestr, sizeof (timestr));
 
-            if( name )
-                fprintf( fp, "[%s] %s: %s\n", timestr, name, buf );
+            if (name)
+                fprintf (fp, "[%s] %s: %s\n", timestr, name, buf);
             else
-                fprintf( fp, "[%s] %s\n", timestr, buf );
-            fflush( fp );
+                fprintf (fp, "[%s] %s\n", timestr, buf);
+            fflush (fp);
         }
     }
 
-    tr_lockUnlock( getMessageLock( ) );
+    tr_lockUnlock (getMessageLock ());
     errno = err;
 }
 
@@ -332,28 +332,28 @@ tr_msg( const char * file, int line,
 ***/
 
 void*
-tr_malloc( size_t size )
+tr_malloc (size_t size)
 {
-    return size ? malloc( size ) : NULL;
+    return size ? malloc (size) : NULL;
 }
 
 void*
-tr_malloc0( size_t size )
+tr_malloc0 (size_t size)
 {
-    return size ? calloc( 1, size ) : NULL;
+    return size ? calloc (1, size) : NULL;
 }
 
 void
-tr_free( void * p )
+tr_free (void * p)
 {
-    if( p != NULL )
-        free( p );
+    if (p != NULL)
+        free (p);
 }
 
 void*
-tr_memdup( const void * src, size_t byteCount )
+tr_memdup (const void * src, size_t byteCount)
 {
-    return memcpy( tr_malloc( byteCount ), src, byteCount );
+    return memcpy (tr_malloc (byteCount), src, byteCount);
 }
 
 /***
@@ -361,40 +361,40 @@ tr_memdup( const void * src, size_t byteCount )
 ***/
 
 const char*
-tr_strip_positional_args( const char* str )
+tr_strip_positional_args (const char* str)
 {
     const char * in = str;
     static size_t bufsize = 0;
     static char * buf = NULL;
-    const size_t  len = str ? strlen( str ) : 0;
+    const size_t  len = str ? strlen (str) : 0;
     char *        out;
 
-    if( !buf || ( bufsize < len ) )
+    if (!buf || (bufsize < len))
     {
         bufsize = len * 2 + 1;
-        buf = tr_renew( char, buf, bufsize );
+        buf = tr_renew (char, buf, bufsize);
     }
 
-    for( out = buf; str && *str; ++str )
+    for (out = buf; str && *str; ++str)
     {
         *out++ = *str;
 
-        if( ( *str == '%' ) && isdigit( str[1] ) )
+        if ((*str == '%') && isdigit (str[1]))
         {
             const char * tmp = str + 1;
-            while( isdigit( *tmp ) )
+            while (isdigit (*tmp))
                 ++tmp;
-            if( *tmp == '$' )
+            if (*tmp == '$')
                 str = tmp[1]=='\'' ? tmp+1 : tmp;
         }
 
-        if( ( *str == '%' ) && ( str[1] == '\'' ) )
+        if ((*str == '%') && (str[1] == '\''))
             str = str + 1;
 
     }
     *out = '\0';
 
-    return !in || strcmp( buf, in ) ? buf : in;
+    return !in || strcmp (buf, in) ? buf : in;
 }
 
 /**
@@ -402,25 +402,25 @@ tr_strip_positional_args( const char* str )
 **/
 
 void
-tr_timerAdd( struct event * timer, int seconds, int microseconds )
+tr_timerAdd (struct event * timer, int seconds, int microseconds)
 {
     struct timeval tv;
     tv.tv_sec = seconds;
     tv.tv_usec = microseconds;
 
-    assert( tv.tv_sec >= 0 );
-    assert( tv.tv_usec >= 0 );
-    assert( tv.tv_usec < 1000000 );
+    assert (tv.tv_sec >= 0);
+    assert (tv.tv_usec >= 0);
+    assert (tv.tv_usec < 1000000);
 
-    evtimer_add( timer, &tv );
+    evtimer_add (timer, &tv);
 }
 
 void
-tr_timerAddMsec( struct event * timer, int msec )
+tr_timerAddMsec (struct event * timer, int msec)
 {
     const int seconds =  msec / 1000;
     const int usec = (msec%1000) * 1000;
-    tr_timerAdd( timer, seconds, usec );
+    tr_timerAdd (timer, seconds, usec);
 }
 
 /**
@@ -428,168 +428,168 @@ tr_timerAddMsec( struct event * timer, int msec )
 **/
 
 uint8_t *
-tr_loadFile( const char * path,
-             size_t *     size )
+tr_loadFile (const char * path,
+             size_t *     size)
 {
     uint8_t * buf;
     struct stat  sb;
     int fd;
     ssize_t n;
-    const char * const err_fmt = _( "Couldn't read \"%1$s\": %2$s" );
+    const char * const err_fmt = _ ("Couldn't read \"%1$s\": %2$s");
 
     /* try to stat the file */
     errno = 0;
-    if( stat( path, &sb ) )
+    if (stat (path, &sb))
     {
         const int err = errno;
-        tr_dbg( err_fmt, path, tr_strerror( errno ) );
+        tr_dbg (err_fmt, path, tr_strerror (errno));
         errno = err;
         return NULL;
     }
 
-    if( ( sb.st_mode & S_IFMT ) != S_IFREG )
+    if ((sb.st_mode & S_IFMT) != S_IFREG)
     {
-        tr_err( err_fmt, path, _( "Not a regular file" ) );
+        tr_err (err_fmt, path, _ ("Not a regular file"));
         errno = EISDIR;
         return NULL;
     }
 
     /* Load the torrent file into our buffer */
-    fd = tr_open_file_for_scanning( path );
-    if( fd < 0 )
+    fd = tr_open_file_for_scanning (path);
+    if (fd < 0)
     {
         const int err = errno;
-        tr_err( err_fmt, path, tr_strerror( errno ) );
+        tr_err (err_fmt, path, tr_strerror (errno));
         errno = err;
         return NULL;
     }
-    buf = tr_malloc( sb.st_size + 1 );
-    if( !buf )
+    buf = tr_malloc (sb.st_size + 1);
+    if (!buf)
     {
         const int err = errno;
-        tr_err( err_fmt, path, _( "Memory allocation failed" ) );
-        tr_close_file( fd );
+        tr_err (err_fmt, path, _ ("Memory allocation failed"));
+        tr_close_file (fd);
         errno = err;
         return NULL;
     }
-    n = read( fd, buf, (size_t)sb.st_size );
-    if( n == -1 )
+    n = read (fd, buf, (size_t)sb.st_size);
+    if (n == -1)
     {
         const int err = errno;
-        tr_err( err_fmt, path, tr_strerror( errno ) );
-        tr_close_file( fd );
-        free( buf );
+        tr_err (err_fmt, path, tr_strerror (errno));
+        tr_close_file (fd);
+        free (buf);
         errno = err;
         return NULL;
     }
 
-    tr_close_file( fd );
+    tr_close_file (fd);
     buf[ sb.st_size ] = '\0';
     *size = sb.st_size;
     return buf;
 }
 
 char*
-tr_basename( const char * path )
+tr_basename (const char * path)
 {
-    char * tmp = tr_strdup( path );
-    char * ret = tr_strdup( basename( tmp ) );
-    tr_free( tmp );
+    char * tmp = tr_strdup (path);
+    char * ret = tr_strdup (basename (tmp));
+    tr_free (tmp);
     return ret;
 }
 
 char*
-tr_dirname( const char * path )
+tr_dirname (const char * path)
 {
-    char * tmp = tr_strdup( path );
-    char * ret = tr_strdup( dirname( tmp ) );
-    tr_free( tmp );
+    char * tmp = tr_strdup (path);
+    char * ret = tr_strdup (dirname (tmp));
+    tr_free (tmp);
     return ret;
 }
 
 char*
-tr_mkdtemp( char * template )
+tr_mkdtemp (char * template)
 {
 #ifdef HAVE_MKDTEMP
-    return mkdtemp( template );
+    return mkdtemp (template);
 #else
-    if( !mktemp( template ) || mkdir( template, 0700 ) )
+    if (!mktemp (template) || mkdir (template, 0700))
         return NULL;
     return template;
 #endif
 }
 
 /**
- * @brief Portability wrapper for mkdir()
+ * @brief Portability wrapper for mkdir ()
  *
- * A portability wrapper around mkdir().
+ * A portability wrapper around mkdir ().
  * On WIN32, the `permissions' argument is unused.
  *
  * @return zero on success, or -1 if an error occurred
  * (in which case errno is set appropriately).
  */
 static int
-tr_mkdir( const char * path, int permissions UNUSED)
+tr_mkdir (const char * path, int permissions UNUSED)
 {
 #ifdef WIN32
-    if( path && isalpha( path[0] ) && path[1] == ':' && !path[2] )
+    if (path && isalpha (path[0]) && path[1] == ':' && !path[2])
         return 0;
-    return mkdir( path );
+    return mkdir (path);
 #else
-    return mkdir( path, permissions );
+    return mkdir (path, permissions);
 #endif
 }
 
 int
-tr_mkdirp( const char * path_in,
-           int          permissions )
+tr_mkdirp (const char * path_in,
+           int          permissions)
 {
-    char *      path = tr_strdup( path_in );
+    char *      path = tr_strdup (path_in);
     char *      p, * pp;
     struct stat sb;
     int         done;
 
     /* walk past the root */
     p = path;
-    while( *p == TR_PATH_DELIMITER )
+    while (*p == TR_PATH_DELIMITER)
         ++p;
 
     pp = p;
     done = 0;
-    while( ( p =
-                strchr( pp, TR_PATH_DELIMITER ) ) || ( p = strchr( pp, '\0' ) ) )
+    while ((p =
+                strchr (pp, TR_PATH_DELIMITER)) || (p = strchr (pp, '\0')))
     {
-        if( !*p )
+        if (!*p)
             done = 1;
         else
             *p = '\0';
 
-        if( stat( path, &sb ) )
+        if (stat (path, &sb))
         {
             /* Folder doesn't exist yet */
-            if( tr_mkdir( path, permissions ) )
+            if (tr_mkdir (path, permissions))
             {
                 const int err = errno;
-                tr_err( _(
-                           "Couldn't create \"%1$s\": %2$s" ), path,
-                       tr_strerror( err ) );
-                tr_free( path );
+                tr_err (_ (
+                           "Couldn't create \"%1$s\": %2$s"), path,
+                       tr_strerror (err));
+                tr_free (path);
                 errno = err;
                 return -1;
             }
         }
-        else if( ( sb.st_mode & S_IFMT ) != S_IFDIR )
+        else if ((sb.st_mode & S_IFMT) != S_IFDIR)
         {
             /* Node exists but isn't a folder */
-            char * buf = tr_strdup_printf( _( "File \"%s\" is in the way" ), path );
-            tr_err( _( "Couldn't create \"%1$s\": %2$s" ), path_in, buf );
-            tr_free( buf );
-            tr_free( path );
+            char * buf = tr_strdup_printf (_ ("File \"%s\" is in the way"), path);
+            tr_err (_ ("Couldn't create \"%1$s\": %2$s"), path_in, buf);
+            tr_free (buf);
+            tr_free (path);
             errno = ENOTDIR;
             return -1;
         }
 
-        if( done )
+        if (done)
             break;
 
         *p = TR_PATH_DELIMITER;
@@ -597,12 +597,12 @@ tr_mkdirp( const char * path_in,
         pp = p;
     }
 
-    tr_free( path );
+    tr_free (path);
     return 0;
 }
 
 char*
-tr_buildPath( const char *first_element, ... )
+tr_buildPath (const char *first_element, ...)
 {
     size_t bufLen = 0;
     const char * element;
@@ -611,51 +611,51 @@ tr_buildPath( const char *first_element, ... )
     va_list vl;
 
     /* pass 1: allocate enough space for the string */
-    va_start( vl, first_element );
+    va_start (vl, first_element);
     element = first_element;
-    while( element ) {
-        bufLen += strlen( element ) + 1;
-        element = va_arg( vl, const char* );
+    while (element) {
+        bufLen += strlen (element) + 1;
+        element = va_arg (vl, const char*);
     }
-    pch = buf = tr_new( char, bufLen );
-    va_end( vl );
+    pch = buf = tr_new (char, bufLen);
+    va_end (vl);
 
     /* pass 2: build the string piece by piece */
-    va_start( vl, first_element );
+    va_start (vl, first_element);
     element = first_element;
-    while( element ) {
-        const size_t elementLen = strlen( element );
-        memcpy( pch, element, elementLen );
+    while (element) {
+        const size_t elementLen = strlen (element);
+        memcpy (pch, element, elementLen);
         pch += elementLen;
         *pch++ = TR_PATH_DELIMITER;
-        element = va_arg( vl, const char* );
+        element = va_arg (vl, const char*);
     }
-    va_end( vl );
+    va_end (vl);
 
     /* terminate the string. if nonempty, eat the unwanted trailing slash */
-    if( pch != buf )
+    if (pch != buf)
         --pch;
     *pch++ = '\0';
 
     /* sanity checks & return */
-    assert( pch - buf == (off_t)bufLen );
+    assert (pch - buf == (off_t)bufLen);
     return buf;
 }
 
 #ifdef SYS_DARWIN
- #define TR_STAT_MTIME(sb) ((sb).st_mtimespec.tv_sec)
+ #define TR_STAT_MTIME(sb)((sb).st_mtimespec.tv_sec)
 #else
- #define TR_STAT_MTIME(sb) ((sb).st_mtime)
+ #define TR_STAT_MTIME(sb)((sb).st_mtime)
 #endif
 
 bool
-tr_fileExists( const char * filename, time_t * mtime )
+tr_fileExists (const char * filename, time_t * mtime)
 {
     struct stat sb;
-    const bool ok = !stat( filename, &sb );
+    const bool ok = !stat (filename, &sb);
 
-    if( ok && ( mtime != NULL ) )
-        *mtime = TR_STAT_MTIME( sb );
+    if (ok && (mtime != NULL))
+        *mtime = TR_STAT_MTIME (sb);
 
     return ok;
 }
@@ -665,35 +665,35 @@ tr_fileExists( const char * filename, time_t * mtime )
 ****/
 
 char*
-evbuffer_free_to_str( struct evbuffer * buf )
+evbuffer_free_to_str (struct evbuffer * buf)
 {
-    const size_t n = evbuffer_get_length( buf );
-    char * ret = tr_new( char, n + 1 );
-    evbuffer_copyout( buf, ret, n );
-    evbuffer_free( buf );
+    const size_t n = evbuffer_get_length (buf);
+    char * ret = tr_new (char, n + 1);
+    evbuffer_copyout (buf, ret, n);
+    evbuffer_free (buf);
     ret[n] = '\0';
     return ret;
 }
 
 char*
-tr_strdup( const void * in )
+tr_strdup (const void * in)
 {
-    return tr_strndup( in, in ? (int)strlen((const char *)in) : 0 );
+    return tr_strndup (in, in ? (int)strlen ((const char *)in) : 0);
 }
 
 char*
-tr_strndup( const void * in, int len )
+tr_strndup (const void * in, int len)
 {
     char * out = NULL;
 
-    if( len < 0 )
+    if (len < 0)
     {
-        out = tr_strdup( in );
+        out = tr_strdup (in);
     }
-    else if( in )
+    else if (in)
     {
-        out = tr_malloc( len + 1 );
-        memcpy( out, in, len );
+        out = tr_malloc (len + 1);
+        memcpy (out, in, len);
         out[len] = '\0';
     }
 
@@ -701,63 +701,63 @@ tr_strndup( const void * in, int len )
 }
 
 const char*
-tr_memmem( const char * haystack, size_t haystacklen,
-           const char * needle, size_t needlelen )
+tr_memmem (const char * haystack, size_t haystacklen,
+           const char * needle, size_t needlelen)
 {
 #ifdef HAVE_MEMMEM
-    return memmem( haystack, haystacklen, needle, needlelen );
+    return memmem (haystack, haystacklen, needle, needlelen);
 #else
     size_t i;
-    if( !needlelen )
+    if (!needlelen)
         return haystack;
-    if( needlelen > haystacklen || !haystack || !needle )
+    if (needlelen > haystacklen || !haystack || !needle)
         return NULL;
-    for( i=0; i<=haystacklen-needlelen; ++i )
-        if( !memcmp( haystack+i, needle, needlelen ) )
+    for (i=0; i<=haystacklen-needlelen; ++i)
+        if (!memcmp (haystack+i, needle, needlelen))
             return haystack+i;
     return NULL;
 #endif
 }
 
 char*
-tr_strdup_printf( const char * fmt, ... )
+tr_strdup_printf (const char * fmt, ...)
 {
     va_list ap;
     char * ret;
     size_t len;
     char statbuf[2048];
 
-    va_start( ap, fmt );
-    len = evutil_vsnprintf( statbuf, sizeof( statbuf ), fmt, ap );
-    va_end( ap );
-    if( len < sizeof( statbuf ) )
-        ret = tr_strndup( statbuf, len );
+    va_start (ap, fmt);
+    len = evutil_vsnprintf (statbuf, sizeof (statbuf), fmt, ap);
+    va_end (ap);
+    if (len < sizeof (statbuf))
+        ret = tr_strndup (statbuf, len);
     else {
-        ret = tr_new( char, len + 1 );
-        va_start( ap, fmt );
-        evutil_vsnprintf( ret, len + 1, fmt, ap );
-        va_end( ap );
+        ret = tr_new (char, len + 1);
+        va_start (ap, fmt);
+        evutil_vsnprintf (ret, len + 1, fmt, ap);
+        va_end (ap);
     }
 
     return ret;
 }
 
 const char*
-tr_strerror( int i )
+tr_strerror (int i)
 {
-    const char * ret = strerror( i );
+    const char * ret = strerror (i);
 
-    if( ret == NULL )
+    if (ret == NULL)
         ret = "Unknown Error";
     return ret;
 }
 
 int
-tr_strcmp0( const char * str1, const char * str2 )
+tr_strcmp0 (const char * str1, const char * str2)
 {
-    if( str1 && str2 ) return strcmp( str1, str2 );
-    if( str1 ) return 1;
-    if( str2 ) return -1;
+    if (str1 && str2) return strcmp (str1, str2);
+    if (str1) return 1;
+    if (str2) return -1;
     return 0;
 }
 
@@ -767,10 +767,10 @@ tr_strcmp0( const char * str1, const char * str2 )
 
 /* https://bugs.launchpad.net/percona-patches/+bug/526863/+attachment/1160199/+files/solaris_10_fix.patch */
 char*
-tr_strsep( char ** str, const char * delims )
+tr_strsep (char ** str, const char * delims)
 {
 #ifdef HAVE_STRSEP
-    return strsep( str, delims );
+    return strsep (str, delims);
 #else
     char *token;
 
@@ -781,12 +781,12 @@ tr_strsep( char ** str, const char * delims )
 
     token = *str;
     while (**str != '\0') {
-        if (strchr(delims, **str) != NULL) {
+        if (strchr (delims, **str) != NULL) {
             **str = '\0';
-            (*str)++;
+          (*str)++;
             return token;
         }
-        (*str)++;
+      (*str)++;
     }
 
     /* There is not another token */
@@ -797,21 +797,21 @@ tr_strsep( char ** str, const char * delims )
 }
 
 char*
-tr_strstrip( char * str )
+tr_strstrip (char * str)
 {
-    if( str != NULL )
+    if (str != NULL)
     {
         size_t pos;
-        size_t len = strlen( str );
+        size_t len = strlen (str);
 
-        while( len && isspace( str[len - 1] ) )
+        while (len && isspace (str[len - 1]))
             --len;
 
-        for( pos = 0; pos < len && isspace( str[pos] ); )
+        for (pos = 0; pos < len && isspace (str[pos]);)
             ++pos;
 
         len -= pos;
-        memmove( str, str + pos, len );
+        memmove (str, str + pos, len);
         str[len] = '\0';
     }
 
@@ -819,22 +819,22 @@ tr_strstrip( char * str )
 }
 
 bool
-tr_str_has_suffix( const char *str, const char *suffix )
+tr_str_has_suffix (const char *str, const char *suffix)
 {
     size_t str_len;
     size_t suffix_len;
 
-    if( !str )
+    if (!str)
         return false;
-    if( !suffix )
+    if (!suffix)
         return true;
 
-    str_len = strlen( str );
-    suffix_len = strlen( suffix );
-    if( str_len < suffix_len )
+    str_len = strlen (str);
+    suffix_len = strlen (suffix);
+    if (str_len < suffix_len)
         return false;
 
-    return !evutil_ascii_strncasecmp( str + str_len - suffix_len, suffix, suffix_len );
+    return !evutil_ascii_strncasecmp (str + str_len - suffix_len, suffix, suffix_len);
 }
 
 /****
@@ -842,24 +842,24 @@ tr_str_has_suffix( const char *str, const char *suffix )
 ****/
 
 uint64_t
-tr_time_msec( void )
+tr_time_msec (void)
 {
     struct timeval tv;
 
-    gettimeofday( &tv, NULL );
-    return (uint64_t) tv.tv_sec * 1000 + ( tv.tv_usec / 1000 );
+    gettimeofday (&tv, NULL);
+    return (uint64_t) tv.tv_sec * 1000 + (tv.tv_usec / 1000);
 }
 
 void
-tr_wait_msec( long int msec )
+tr_wait_msec (long int msec)
 {
 #ifdef WIN32
-    Sleep( (DWORD)msec );
+    Sleep ((DWORD)msec);
 #else
     struct timespec ts;
     ts.tv_sec = msec / 1000;
-    ts.tv_nsec = ( msec % 1000 ) * 1000000;
-    nanosleep( &ts, NULL );
+    ts.tv_nsec = (msec % 1000) * 1000000;
+    nanosleep (&ts, NULL);
 #endif
 }
 
@@ -868,51 +868,51 @@ tr_wait_msec( long int msec )
 ***/
 
 int
-tr_snprintf( char * buf, size_t buflen, const char * fmt, ... )
+tr_snprintf (char * buf, size_t buflen, const char * fmt, ...)
 {
     int     len;
     va_list args;
 
-    va_start( args, fmt );
-    len = evutil_vsnprintf( buf, buflen, fmt, args );
-    va_end( args );
+    va_start (args, fmt);
+    len = evutil_vsnprintf (buf, buflen, fmt, args);
+    va_end (args);
     return len;
 }
 
 /*
  * Copy src to string dst of size siz. At most siz-1 characters
  * will be copied. Always NUL terminates (unless siz == 0).
- * Returns strlen(src); if retval >= siz, truncation occurred.
+ * Returns strlen (src); if retval >= siz, truncation occurred.
  */
 size_t
-tr_strlcpy( char * dst, const void * src, size_t siz )
+tr_strlcpy (char * dst, const void * src, size_t siz)
 {
 #ifdef HAVE_STRLCPY
-    return strlcpy( dst, src, siz );
+    return strlcpy (dst, src, siz);
 #else
     char *      d = dst;
     const char *s = src;
     size_t      n = siz;
 
-    assert( s );
-    assert( d );
+    assert (s);
+    assert (d);
 
     /* Copy as many bytes as will fit */
-    if( n != 0 )
+    if (n != 0)
     {
-        while( --n != 0 )
+        while (--n != 0)
         {
-            if( ( *d++ = *s++ ) == '\0' )
+            if ((*d++ = *s++) == '\0')
                 break;
         }
     }
 
     /* Not enough room in dst, add NUL and traverse rest of src */
-    if( n == 0 )
+    if (n == 0)
     {
-        if( siz != 0 )
+        if (siz != 0)
             *d = '\0'; /* NUL-terminate dst */
-        while( *s++ )
+        while (*s++)
             ;
     }
 
@@ -925,13 +925,13 @@ tr_strlcpy( char * dst, const void * src, size_t siz )
 ***/
 
 double
-tr_getRatio( uint64_t numerator, uint64_t denominator )
+tr_getRatio (uint64_t numerator, uint64_t denominator)
 {
     double ratio;
 
-    if( denominator > 0 )
+    if (denominator > 0)
         ratio = numerator / (double)denominator;
-    else if( numerator > 0 )
+    else if (numerator > 0)
         ratio = TR_RATIO_INF;
     else
         ratio = TR_RATIO_NA;
@@ -940,12 +940,12 @@ tr_getRatio( uint64_t numerator, uint64_t denominator )
 }
 
 void
-tr_sha1_to_hex( char * out, const uint8_t * sha1 )
+tr_sha1_to_hex (char * out, const uint8_t * sha1)
 {
     int i;
     static const char hex[] = "0123456789abcdef";
 
-    for( i=0; i<20; ++i )
+    for (i=0; i<20; ++i)
     {
         const unsigned int val = *sha1++;
         *out++ = hex[val >> 4];
@@ -956,16 +956,16 @@ tr_sha1_to_hex( char * out, const uint8_t * sha1 )
 }
 
 void
-tr_hex_to_sha1( uint8_t * out, const char * in )
+tr_hex_to_sha1 (uint8_t * out, const char * in)
 {
     int i;
     static const char hex[] = "0123456789abcdef";
 
-    for( i=0; i<20; ++i )
+    for (i=0; i<20; ++i)
     {
-        const int hi = strchr( hex, tolower( *in++ ) ) - hex;
-        const int lo = strchr( hex, tolower( *in++ ) ) - hex;
-        *out++ = (uint8_t)( (hi<<4) | lo );
+        const int hi = strchr (hex, tolower (*in++)) - hex;
+        const int lo = strchr (hex, tolower (*in++)) - hex;
+        *out++ = (uint8_t)((hi<<4) | lo);
     }
 }
 
@@ -974,7 +974,7 @@ tr_hex_to_sha1( uint8_t * out, const char * in )
 ***/
 
 static bool
-isValidURLChars( const char * url, int url_len )
+isValidURLChars (const char * url, int url_len)
 {
     const char * c;
     const char * end;
@@ -982,16 +982,16 @@ isValidURLChars( const char * url, int url_len )
         "abcdefghijklmnopqrstuvwxyz" /* lowalpha */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ" /* upalpha */
         "0123456789"                 /* digit */
-        "-_.!~*'()"                  /* mark */
+        "-_.!~*' ()"                  /* mark */
         ";/?:@&=+$,"                 /* reserved */
         "<>#%<\""                    /* delims */
         "{}|\\^[]`";                 /* unwise */
 
-    if( url == NULL )
+    if (url == NULL)
         return false;
 
-    for( c=url, end=c+url_len; c && *c && c!=end; ++c )
-        if( !strchr( rfc2396_valid_chars, *c ) )
+    for (c=url, end=c+url_len; c && *c && c!=end; ++c)
+        if (!strchr (rfc2396_valid_chars, *c))
             return false;
 
     return true;
@@ -999,21 +999,21 @@ isValidURLChars( const char * url, int url_len )
 
 /** @brief return true if the URL is a http or https or UDP one that Transmission understands */
 bool
-tr_urlIsValidTracker( const char * url )
+tr_urlIsValidTracker (const char * url)
 {
     bool valid;
 
-    if( url == NULL )
+    if (url == NULL)
     {
         valid = false;
     }
     else
     {
-        const int len = strlen( url );
+        const int len = strlen (url);
 
-        valid = isValidURLChars( url, len )
-            && !tr_urlParse( url, len, NULL, NULL, NULL, NULL )
-            && ( !memcmp(url,"http://",7) || !memcmp(url,"https://",8) || !memcmp(url,"udp://",6) );
+        valid = isValidURLChars (url, len)
+            && !tr_urlParse (url, len, NULL, NULL, NULL, NULL)
+            && (!memcmp (url,"http://",7) || !memcmp (url,"https://",8) || !memcmp (url,"udp://",6));
     }
 
     return valid;
@@ -1021,41 +1021,41 @@ tr_urlIsValidTracker( const char * url )
 
 /** @brief return true if the URL is a http or https or ftp or sftp one that Transmission understands */
 bool
-tr_urlIsValid( const char * url, int url_len )
+tr_urlIsValid (const char * url, int url_len)
 {
     bool valid;
 
-    if( url == NULL )
+    if (url == NULL)
     {
         valid = false;
     }
     else
     {
-        if( url_len < 0 )
-            url_len = strlen( url );
+        if (url_len < 0)
+            url_len = strlen (url);
 
-        valid = isValidURLChars( url, url_len )
-            && !tr_urlParse( url, url_len, NULL, NULL, NULL, NULL )
-            && ( !memcmp(url,"http://",7) || !memcmp(url,"https://",8) || !memcmp(url,"ftp://",6) || !memcmp(url,"sftp://",7) );
+        valid = isValidURLChars (url, url_len)
+            && !tr_urlParse (url, url_len, NULL, NULL, NULL, NULL)
+            && (!memcmp (url,"http://",7) || !memcmp (url,"https://",8) || !memcmp (url,"ftp://",6) || !memcmp (url,"sftp://",7));
     }
 
     return valid;
 }
 
 bool
-tr_addressIsIP( const char * str )
+tr_addressIsIP (const char * str)
 {
     tr_address tmp;
-    return tr_address_from_string( &tmp, str );
+    return tr_address_from_string (&tmp, str);
 }
 
 int
-tr_urlParse( const char * url_in,
+tr_urlParse (const char * url_in,
              int          len,
              char **      setme_protocol,
              char **      setme_host,
              int *        setme_port,
-             char **      setme_path )
+             char **      setme_path)
 {
     int          err;
     int          port = 0;
@@ -1068,60 +1068,60 @@ tr_urlParse( const char * url_in,
     const char * protocol = NULL;
     const char * path = NULL;
 
-    tmp = tr_strndup( url_in, len );
-    if( ( pch = strstr( tmp, "://" ) ) )
+    tmp = tr_strndup (url_in, len);
+    if ((pch = strstr (tmp, "://")))
     {
         *pch = '\0';
         protocol = tmp;
         protocol_len = pch - protocol;
         pch += 3;
-/*fprintf( stderr, "protocol is [%s]... what's left is [%s]\n", protocol, pch);*/
-        if( ( n = strcspn( pch, ":/" ) ) )
+/*fprintf (stderr, "protocol is [%s]... what's left is [%s]\n", protocol, pch);*/
+        if ((n = strcspn (pch, ":/")))
         {
             const int havePort = pch[n] == ':';
             host = pch;
             host_len = n;
             pch += n;
-            if( pch && *pch )
+            if (pch && *pch)
                 *pch++ = '\0';
-/*fprintf( stderr, "host is [%s]... what's left is [%s]\n", host, pch );*/
-            if( havePort )
+/*fprintf (stderr, "host is [%s]... what's left is [%s]\n", host, pch);*/
+            if (havePort)
             {
                 char * end;
-                port = strtol( pch, &end, 10 );
+                port = strtol (pch, &end, 10);
                 pch = end;
-/*fprintf( stderr, "port is [%d]... what's left is [%s]\n", port, pch );*/
+/*fprintf (stderr, "port is [%d]... what's left is [%s]\n", port, pch);*/
             }
             path = pch;
-/*fprintf( stderr, "path is [%s]\n", path );*/
+/*fprintf (stderr, "path is [%s]\n", path);*/
         }
     }
 
     err = !host || !path || !protocol;
 
-    if( !err && !port )
+    if (!err && !port)
     {
-        if( !strcmp( protocol, "udp" ) ) port = 80;
-        else if( !strcmp( protocol, "ftp" ) ) port = 21;
-        else if( !strcmp( protocol, "sftp" ) ) port = 22;
-        else if( !strcmp( protocol, "http" ) ) port = 80;
-        else if( !strcmp( protocol, "https" ) ) port = 443;
+        if (!strcmp (protocol, "udp")) port = 80;
+        else if (!strcmp (protocol, "ftp")) port = 21;
+        else if (!strcmp (protocol, "sftp")) port = 22;
+        else if (!strcmp (protocol, "http")) port = 80;
+        else if (!strcmp (protocol, "https")) port = 443;
     }
 
-    if( !err )
+    if (!err)
     {
-        if( setme_protocol ) *setme_protocol = tr_strndup( protocol, protocol_len );
-
-        if( setme_host ){ ( (char*)host )[-3] = ':'; *setme_host =
-                              tr_strndup( host, host_len ); }
-        if( setme_path ){ if( !*path ) *setme_path = tr_strdup( "/" );
-                          else if( path[0] == '/' ) *setme_path = tr_strdup( path );
-                          else { ( (char*)path )[-1] = '/'; *setme_path = tr_strdup( path - 1 ); } }
-        if( setme_port ) *setme_port = port;
+        if (setme_protocol) *setme_protocol = tr_strndup (protocol, protocol_len);
+
+        if (setme_host){ ((char*)host)[-3] = ':'; *setme_host =
+                              tr_strndup (host, host_len); }
+        if (setme_path){ if (!*path) *setme_path = tr_strdup ("/");
+                          else if (path[0] == '/') *setme_path = tr_strdup (path);
+                          else { ((char*)path)[-1] = '/'; *setme_path = tr_strdup (path - 1); } }
+        if (setme_port) *setme_port = port;
     }
 
 
-    tr_free( tmp );
+    tr_free (tmp);
     return err;
 }
 
@@ -1133,71 +1133,71 @@ tr_urlParse( const char * url_in,
 #include <openssl/buffer.h>
 
 char *
-tr_base64_encode( const void * input, int length, int * setme_len )
+tr_base64_encode (const void * input, int length, int * setme_len)
 {
     int retlen = 0;
     char * ret = NULL;
 
-    if( input != NULL )
+    if (input != NULL)
     {
         BIO * b64;
         BIO * bmem;
         BUF_MEM * bptr;
 
-        if( length < 1 )
-            length = (int)strlen( input );
-
-        bmem = BIO_new( BIO_s_mem( ) );
-        b64 = BIO_new( BIO_f_base64( ) );
-        BIO_set_flags( b64, BIO_FLAGS_BASE64_NO_NL );
-        b64 = BIO_push( b64, bmem );
-        BIO_write( b64, input, length );
-        (void) BIO_flush( b64 );
-        BIO_get_mem_ptr( b64, &bptr );
-        ret = tr_strndup( bptr->data, bptr->length );
+        if (length < 1)
+            length = (int)strlen (input);
+
+        bmem = BIO_new (BIO_s_mem ());
+        b64 = BIO_new (BIO_f_base64 ());
+        BIO_set_flags (b64, BIO_FLAGS_BASE64_NO_NL);
+        b64 = BIO_push (b64, bmem);
+        BIO_write (b64, input, length);
+      (void) BIO_flush (b64);
+        BIO_get_mem_ptr (b64, &bptr);
+        ret = tr_strndup (bptr->data, bptr->length);
         retlen = bptr->length;
-        BIO_free_all( b64 );
+        BIO_free_all (b64);
     }
 
-    if( setme_len )
+    if (setme_len)
         *setme_len = retlen;
 
     return ret;
 }
 
 char *
-tr_base64_decode( const void * input,
+tr_base64_decode (const void * input,
                   int          length,
-                  int *        setme_len )
+                  int *        setme_len)
 {
     char * ret;
     BIO *  b64;
     BIO *  bmem;
     int    retlen;
 
-    if( length < 1 )
-        length = strlen( input );
+    if (length < 1)
+        length = strlen (input);
 
-    ret = tr_new0( char, length );
-    b64 = BIO_new( BIO_f_base64( ) );
-    bmem = BIO_new_mem_buf( (unsigned char*)input, length );
-    bmem = BIO_push( b64, bmem );
-    retlen = BIO_read( bmem, ret, length );
-    if( !retlen )
+    ret = tr_new0 (char, length);
+    b64 = BIO_new (BIO_f_base64 ());
+    bmem = BIO_new_mem_buf ((unsigned char*)input, length);
+    bmem = BIO_push (b64, bmem);
+    retlen = BIO_read (bmem, ret, length);
+    if (!retlen)
     {
         /* try again, but with the BIO_FLAGS_BASE64_NO_NL flag */
-        BIO_free_all( bmem );
-        b64 = BIO_new( BIO_f_base64( ) );
-        BIO_set_flags( b64, BIO_FLAGS_BASE64_NO_NL );
-        bmem = BIO_new_mem_buf( (unsigned char*)input, length );
-        bmem = BIO_push( b64, bmem );
-        retlen = BIO_read( bmem, ret, length );
+        BIO_free_all (bmem);
+        b64 = BIO_new (BIO_f_base64 ());
+        BIO_set_flags (b64, BIO_FLAGS_BASE64_NO_NL);
+        bmem = BIO_new_mem_buf ((unsigned char*)input, length);
+        bmem = BIO_push (b64, bmem);
+        retlen = BIO_read (bmem, ret, length);
     }
 
-    if( setme_len )
+    if (setme_len)
         *setme_len = retlen;
 
-    BIO_free_all( bmem );
+    BIO_free_all (bmem);
     return ret;
 }
 
@@ -1206,38 +1206,38 @@ tr_base64_decode( const void * input,
 ***/
 
 void
-tr_removeElementFromArray( void         * array,
+tr_removeElementFromArray (void         * array,
                            unsigned int   index_to_remove,
                            size_t         sizeof_element,
-                           size_t         nmemb )
+                           size_t         nmemb)
 {
     char * a = array;
 
-    memmove( a + sizeof_element * index_to_remove,
-             a + sizeof_element * ( index_to_remove  + 1 ),
-             sizeof_element * ( --nmemb - index_to_remove ) );
+    memmove (a + sizeof_element * index_to_remove,
+             a + sizeof_element * (index_to_remove  + 1),
+             sizeof_element * (--nmemb - index_to_remove));
 }
 
 int
-tr_lowerBound( const void * key,
+tr_lowerBound (const void * key,
                const void * base,
                size_t       nmemb,
                size_t       size,
-               int       (* compar)(const void* key, const void* arrayMember),
-               bool       * exact_match )
+               int     (* compar)(const void* key, const void* arrayMember),
+               bool       * exact_match)
 {
     size_t first = 0;
     const char * cbase = base;
     bool exact = false;
 
-    while( nmemb != 0 )
+    while (nmemb != 0)
     {
         const size_t half = nmemb / 2;
         const size_t middle = first + half;
-        const int c = compar( key, cbase + size*middle );
+        const int c = compar (key, cbase + size*middle);
 
-        if( c <= 0 ) {
-            if( c == 0 )
+        if (c <= 0) {
+            if (c == 0)
                 exact = true;
             nmemb = half;
         } else {
@@ -1256,40 +1256,40 @@ tr_lowerBound( const void * key,
 ***/
 
 static char*
-strip_non_utf8( const char * in, size_t inlen )
+strip_non_utf8 (const char * in, size_t inlen)
 {
     const char * end;
     const char zero = '\0';
-    struct evbuffer * buf = evbuffer_new( );
+    struct evbuffer * buf = evbuffer_new ();
 
-    while( !tr_utf8_validate( in, inlen, &end ) )
+    while (!tr_utf8_validate (in, inlen, &end))
     {
         const int good_len = end - in;
 
-        evbuffer_add( buf, in, good_len );
-        inlen -= ( good_len + 1 );
-        in += ( good_len + 1 );
-        evbuffer_add( buf, "?", 1 );
+        evbuffer_add (buf, in, good_len);
+        inlen -= (good_len + 1);
+        in += (good_len + 1);
+        evbuffer_add (buf, "?", 1);
     }
 
-    evbuffer_add( buf, in, inlen );
-    evbuffer_add( buf, &zero, 1 );
-    return evbuffer_free_to_str( buf );
+    evbuffer_add (buf, in, inlen);
+    evbuffer_add (buf, &zero, 1);
+    return evbuffer_free_to_str (buf);
 }
 
 static char*
-to_utf8( const char * in, size_t inlen )
+to_utf8 (const char * in, size_t inlen)
 {
     char * ret = NULL;
 
 #ifdef HAVE_ICONV_OPEN
     int i;
     const char * encodings[] = { "CURRENT", "ISO-8859-15" };
-    const int encoding_count = sizeof(encodings) / sizeof(encodings[1]);
+    const int encoding_count = sizeof (encodings) / sizeof (encodings[1]);
     const size_t buflen = inlen*4 + 10;
-    char * out = tr_new( char, buflen );
+    char * out = tr_new (char, buflen);
 
-    for( i=0; !ret && i<encoding_count; ++i )
+    for (i=0; !ret && i<encoding_count; ++i)
     {
         char * inbuf = (char*) in;
         char * outbuf = out;
@@ -1297,38 +1297,38 @@ to_utf8( const char * in, size_t inlen )
         size_t outbytesleft = buflen;
         const char * test_encoding = encodings[i];
 
-        iconv_t cd = iconv_open( "UTF-8", test_encoding );
-        if( cd != (iconv_t)-1 ) {
-            if( iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft ) != (size_t)-1 )
-                ret = tr_strndup( out, buflen-outbytesleft );
-            iconv_close( cd );
+        iconv_t cd = iconv_open ("UTF-8", test_encoding);
+        if (cd != (iconv_t)-1) {
+            if (iconv (cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft) != (size_t)-1)
+                ret = tr_strndup (out, buflen-outbytesleft);
+            iconv_close (cd);
         }
     }
 
-    tr_free( out );
+    tr_free (out);
 #endif
 
-    if( ret == NULL )
-        ret = strip_non_utf8( in, inlen );
+    if (ret == NULL)
+        ret = strip_non_utf8 (in, inlen);
 
     return ret;
 }
 
 char*
-tr_utf8clean( const char * str, int max_len )
+tr_utf8clean (const char * str, int max_len)
 {
     char * ret;
     const char * end;
 
-    if( max_len < 0 )
-        max_len = (int) strlen( str );
+    if (max_len < 0)
+        max_len = (int) strlen (str);
 
-    if( tr_utf8_validate( str, max_len, &end  ) )
-        ret = tr_strndup( str, max_len );
+    if (tr_utf8_validate (str, max_len, &end))
+        ret = tr_strndup (str, max_len);
     else
-        ret = to_utf8( str, max_len );
+        ret = to_utf8 (str, max_len);
 
-    assert( tr_utf8_validate( ret, -1, NULL ) );
+    assert (tr_utf8_validate (ret, -1, NULL));
     return ret;
 }
 
@@ -1347,44 +1347,44 @@ struct number_range
  * Anything else is an error and will return failure.
  */
 static bool
-parseNumberSection( const char * str, int len, struct number_range * setme )
+parseNumberSection (const char * str, int len, struct number_range * setme)
 {
     long a, b;
     bool success;
     char * end;
     const int error = errno;
-    char * tmp = tr_strndup( str, len );
+    char * tmp = tr_strndup (str, len);
 
     errno = 0;
-    a = b = strtol( tmp, &end, 10 );
-    if( errno || ( end == tmp ) ) {
+    a = b = strtol (tmp, &end, 10);
+    if (errno || (end == tmp)) {
         success = false;
-    } else if( *end != '-' ) {
+    } else if (*end != '-') {
         success = true;
     } else {
         const char * pch = end + 1;
-        b = strtol( pch, &end, 10 );
-        if( errno || ( pch == end ) )
+        b = strtol (pch, &end, 10);
+        if (errno || (pch == end))
             success = false;
-        else if( *end ) /* trailing data */
+        else if (*end) /* trailing data */
             success = false;
         else
             success = true;
     }
-    tr_free( tmp );
+    tr_free (tmp);
 
-    setme->low = MIN( a, b );
-    setme->high = MAX( a, b );
+    setme->low = MIN (a, b);
+    setme->high = MAX (a, b);
 
     errno = error;
     return success;
 }
 
 int
-compareInt( const void * va, const void * vb )
+compareInt (const void * va, const void * vb)
 {
-    const int a = *(const int *)va;
-    const int b = *(const int *)vb;
+    const int a = * (const int *)va;
+    const int b = * (const int *)vb;
     return a - b;
 }
 
@@ -1392,35 +1392,35 @@ compareInt( const void * va, const void * vb )
  * Given a string like "1-4" or "1-4,6,9,14-51", this allocates and returns an
  * array of setmeCount ints of all the values in the array.
  * For example, "5-8" will return [ 5, 6, 7, 8 ] and setmeCount will be 4.
- * It's the caller's responsibility to call tr_free() on the returned array.
+ * It's the caller's responsibility to call tr_free () on the returned array.
  * If a fragment of the string can't be parsed, NULL is returned.
  */
 int*
-tr_parseNumberRange( const char * str_in, int len, int * setmeCount )
+tr_parseNumberRange (const char * str_in, int len, int * setmeCount)
 {
     int n = 0;
     int * uniq = NULL;
-    char * str = tr_strndup( str_in, len );
+    char * str = tr_strndup (str_in, len);
     const char * walk;
     tr_list * ranges = NULL;
     bool success = true;
 
     walk = str;
-    while( walk && *walk && success ) {
+    while (walk && *walk && success) {
         struct number_range range;
-        const char * pch = strchr( walk, ',' );
-        if( pch ) {
-            success = parseNumberSection( walk, pch-walk, &range );
+        const char * pch = strchr (walk, ',');
+        if (pch) {
+            success = parseNumberSection (walk, pch-walk, &range);
             walk = pch + 1;
         } else {
-            success = parseNumberSection( walk, strlen( walk ), &range );
-            walk += strlen( walk );
+            success = parseNumberSection (walk, strlen (walk), &range);
+            walk += strlen (walk);
         }
-        if( success )
-            tr_list_append( &ranges, tr_memdup( &range, sizeof( struct number_range ) ) );
+        if (success)
+            tr_list_append (&ranges, tr_memdup (&range, sizeof (struct number_range)));
     }
 
-    if( !success )
+    if (!success)
     {
         *setmeCount = 0;
         uniq = NULL;
@@ -1434,32 +1434,32 @@ tr_parseNumberRange( const char * str_in, int len, int * setmeCount )
 
         /* build a sorted number array */
         n = n2 = 0;
-        for( l=ranges; l!=NULL; l=l->next ) {
+        for (l=ranges; l!=NULL; l=l->next) {
             const struct number_range * r = l->data;
             n += r->high + 1 - r->low;
         }
-        sorted = tr_new( int, n );
-        for( l=ranges; l!=NULL; l=l->next ) {
+        sorted = tr_new (int, n);
+        for (l=ranges; l!=NULL; l=l->next) {
             const struct number_range * r = l->data;
             int i;
-            for( i=r->low; i<=r->high; ++i )
+            for (i=r->low; i<=r->high; ++i)
                 sorted[n2++] = i;
         }
-        qsort( sorted, n, sizeof( int ), compareInt );
-        assert( n == n2 );
+        qsort (sorted, n, sizeof (int), compareInt);
+        assert (n == n2);
 
         /* remove duplicates */
-        uniq = tr_new( int, n );
-        for( i=n=0; i<n2; ++i )
-            if( !n || uniq[n-1] != sorted[i] )
+        uniq = tr_new (int, n);
+        for (i=n=0; i<n2; ++i)
+            if (!n || uniq[n-1] != sorted[i])
                 uniq[n++] = sorted[i];
 
-        tr_free( sorted );
+        tr_free (sorted);
     }
 
     /* cleanup */
-    tr_list_free( &ranges, tr_free );
-    tr_free( str );
+    tr_list_free (&ranges, tr_free);
+    tr_free (str);
 
     /* return the result */
     *setmeCount = n;
@@ -1471,46 +1471,46 @@ tr_parseNumberRange( const char * str_in, int len, int * setmeCount )
 ***/
 
 double
-tr_truncd( double x, int precision )
+tr_truncd (double x, int precision)
 {
     char * pt;
     char buf[128];
-    const int max_precision = (int) log10( 1.0 / DBL_EPSILON ) - 1;
-    tr_snprintf( buf, sizeof( buf ), "%.*f", max_precision, x );
-    if(( pt = strstr( buf, localeconv()->decimal_point )))
+    const int max_precision = (int) log10 (1.0 / DBL_EPSILON) - 1;
+    tr_snprintf (buf, sizeof (buf), "%.*f", max_precision, x);
+    if ((pt = strstr (buf, localeconv ()->decimal_point)))
         pt[precision ? precision+1 : 0] = '\0';
-    return atof(buf);
+    return atof (buf);
 }
 
 /* return a truncated double as a string */
 static char*
-tr_strtruncd( char * buf, double x, int precision, size_t buflen )
+tr_strtruncd (char * buf, double x, int precision, size_t buflen)
 {
-    tr_snprintf( buf, buflen, "%.*f", precision, tr_truncd( x, precision ) );
+    tr_snprintf (buf, buflen, "%.*f", precision, tr_truncd (x, precision));
     return buf;
 }
 
 char*
-tr_strpercent( char * buf, double x, size_t buflen )
+tr_strpercent (char * buf, double x, size_t buflen)
 {
-    if( x < 10.0 )
-        tr_strtruncd( buf, x, 2, buflen );
-    else if( x < 100.0 )
-        tr_strtruncd( buf, x, 1, buflen );
+    if (x < 10.0)
+        tr_strtruncd (buf, x, 2, buflen);
+    else if (x < 100.0)
+        tr_strtruncd (buf, x, 1, buflen);
     else
-        tr_strtruncd( buf, x, 0, buflen );
+        tr_strtruncd (buf, x, 0, buflen);
     return buf;
 }
 
 char*
-tr_strratio( char * buf, size_t buflen, double ratio, const char * infinity )
+tr_strratio (char * buf, size_t buflen, double ratio, const char * infinity)
 {
-    if( (int)ratio == TR_RATIO_NA )
-        tr_strlcpy( buf, _( "None" ), buflen );
-    else if( (int)ratio == TR_RATIO_INF )
-        tr_strlcpy( buf, infinity, buflen );
+    if ((int)ratio == TR_RATIO_NA)
+        tr_strlcpy (buf, _ ("None"), buflen);
+    else if ((int)ratio == TR_RATIO_INF)
+        tr_strlcpy (buf, infinity, buflen);
     else
-        tr_strpercent( buf, ratio, buflen );
+        tr_strpercent (buf, ratio, buflen);
     return buf;
 }
 
@@ -1519,7 +1519,7 @@ tr_strratio( char * buf, size_t buflen, double ratio, const char * infinity )
 ***/
 
 int
-tr_moveFile( const char * oldpath, const char * newpath, bool * renamed )
+tr_moveFile (const char * oldpath, const char * newpath, bool * renamed)
 {
     int in;
     int out;
@@ -1529,12 +1529,12 @@ tr_moveFile( const char * oldpath, const char * newpath, bool * renamed )
     const size_t buflen = 1024 * 128; /* 128 KiB buffer */
 
     /* make sure the old file exists */
-    if( stat( oldpath, &st ) ) {
+    if (stat (oldpath, &st)) {
         const int err = errno;
         errno = err;
         return -1;
     }
-    if( !S_ISREG( st.st_mode ) ) {
+    if (!S_ISREG (st.st_mode)) {
         errno = ENOENT;
         return -1;
     }
@@ -1542,59 +1542,59 @@ tr_moveFile( const char * oldpath, const char * newpath, bool * renamed )
 
     /* make sure the target directory exists */
     {
-        char * newdir = tr_dirname( newpath );
-        int i = tr_mkdirp( newdir, 0777 );
-        tr_free( newdir );
-        if( i )
+        char * newdir = tr_dirname (newpath);
+        int i = tr_mkdirp (newdir, 0777);
+        tr_free (newdir);
+        if (i)
             return i;
     }
 
     /* they might be on the same filesystem... */
     {
-        const int i = rename( oldpath, newpath );
-        if( renamed != NULL )
+        const int i = rename (oldpath, newpath);
+        if (renamed != NULL)
             *renamed = i == 0;
-        if( !i )
+        if (!i)
             return 0;
     }
 
     /* copy the file */
-    in = tr_open_file_for_scanning( oldpath );
-    out = tr_open_file_for_writing( newpath );
-    buf = tr_valloc( buflen );
-    while( bytesLeft > 0 )
+    in = tr_open_file_for_scanning (oldpath);
+    out = tr_open_file_for_writing (newpath);
+    buf = tr_valloc (buflen);
+    while (bytesLeft > 0)
     {
         ssize_t bytesWritten;
-        const off_t bytesThisPass = MIN( bytesLeft, (off_t)buflen );
-        const int numRead = read( in, buf, bytesThisPass );
-        if( numRead < 0 )
+        const off_t bytesThisPass = MIN (bytesLeft, (off_t)buflen);
+        const int numRead = read (in, buf, bytesThisPass);
+        if (numRead < 0)
             break;
-        bytesWritten = write( out, buf, numRead );
-        if( bytesWritten < 0 )
+        bytesWritten = write (out, buf, numRead);
+        if (bytesWritten < 0)
             break;
         bytesLeft -= bytesWritten;
     }
 
     /* cleanup */
-    tr_free( buf );
-    tr_close_file( out );
-    tr_close_file( in );
-    if( bytesLeft != 0 )
+    tr_free (buf);
+    tr_close_file (out);
+    tr_close_file (in);
+    if (bytesLeft != 0)
         return -1;
 
-    unlink( oldpath );
+    unlink (oldpath);
     return 0;
 }
 
 bool
-tr_is_same_file( const char * filename1, const char * filename2 )
+tr_is_same_file (const char * filename1, const char * filename2)
 {
     struct stat sb1, sb2;
 
-    return !stat( filename1, &sb1 )
-        && !stat( filename2, &sb2 )
-        && ( sb1.st_dev == sb2.st_dev )
-        && ( sb1.st_ino == sb2.st_ino );
+    return !stat (filename1, &sb1)
+        && !stat (filename2, &sb2)
+        && (sb1.st_dev == sb2.st_dev)
+        && (sb1.st_ino == sb2.st_ino);
 }
 
 /***
@@ -1602,49 +1602,49 @@ tr_is_same_file( const char * filename1, const char * filename2 )
 ***/
 
 void*
-tr_valloc( size_t bufLen )
+tr_valloc (size_t bufLen)
 {
     size_t allocLen;
     void * buf = NULL;
     static size_t pageSize = 0;
 
-    if( !pageSize ) {
+    if (!pageSize) {
 #ifdef HAVE_GETPAGESIZE
-        pageSize = (size_t) getpagesize();
+        pageSize = (size_t) getpagesize ();
 #else /* guess */
         pageSize = 4096;
 #endif
     }
 
     allocLen = pageSize;
-    while( allocLen < bufLen )
+    while (allocLen < bufLen)
         allocLen += pageSize;
 
 #ifdef HAVE_POSIX_MEMALIGN
-    if( !buf )
-        if( posix_memalign( &buf, pageSize, allocLen ) )
+    if (!buf)
+        if (posix_memalign (&buf, pageSize, allocLen))
             buf = NULL; /* just retry with valloc/malloc */
 #endif
 #ifdef HAVE_VALLOC
-    if( !buf )
-        buf = valloc( allocLen );
+    if (!buf)
+        buf = valloc (allocLen);
 #endif
-    if( !buf )
-        buf = tr_malloc( allocLen );
+    if (!buf)
+        buf = tr_malloc (allocLen);
 
     return buf;
 }
 
 char *
-tr_realpath( const char * path, char * resolved_path )
+tr_realpath (const char * path, char * resolved_path)
 {
 #ifdef WIN32
     /* From a message to the Mingw-msys list, Jun 2, 2005 by Mark Junker. */
-    if( GetFullPathNameA( path, TR_PATH_MAX, resolved_path, NULL ) == 0 )
+    if (GetFullPathNameA (path, TR_PATH_MAX, resolved_path, NULL) == 0)
         return NULL;
     return resolved_path;
 #else
-    return realpath( path, resolved_path );
+    return realpath (path, resolved_path);
 #endif
 }
 
@@ -1653,31 +1653,31 @@ tr_realpath( const char * path, char * resolved_path )
 ***/
 
 uint64_t
-tr_htonll( uint64_t x )
+tr_htonll (uint64_t x)
 {
 #ifdef HAVE_HTONLL
-    return htonll( x );
+    return htonll (x);
 #else
     /* fallback code by bdonlan at
      * http://stackoverflow.com/questions/809902/64-bit-ntohl-in-c/875505#875505 */
     union { uint32_t lx[2]; uint64_t llx; } u;
-    u.lx[0] = htonl(x >> 32);
-    u.lx[1] = htonl(x & 0xFFFFFFFFULL);
+    u.lx[0] = htonl (x >> 32);
+    u.lx[1] = htonl (x & 0xFFFFFFFFULL);
     return u.llx;
 #endif
 }
 
 uint64_t
-tr_ntohll( uint64_t x )
+tr_ntohll (uint64_t x)
 {
 #ifdef HAVE_NTOHLL
-    return ntohll( x );
+    return ntohll (x);
 #else
     /* fallback code by bdonlan at
      * http://stackoverflow.com/questions/809902/64-bit-ntohl-in-c/875505#875505 */
     union { uint32_t lx[2]; uint64_t llx; } u;
     u.llx = x;
-    return ((uint64_t)ntohl(u.lx[0]) << 32) | (uint64_t)ntohl(u.lx[1]);
+    return ((uint64_t)ntohl (u.lx[0]) << 32) | (uint64_t)ntohl (u.lx[1]);
 #endif
 }
 
@@ -1701,68 +1701,68 @@ struct formatter_units
 enum { TR_FMT_KB, TR_FMT_MB, TR_FMT_GB, TR_FMT_TB };
 
 static void
-formatter_init( struct formatter_units * units,
+formatter_init (struct formatter_units * units,
                 unsigned int kilo,
                 const char * kb, const char * mb,
-                const char * gb, const char * tb )
+                const char * gb, const char * tb)
 {
     uint64_t value = kilo;
-    units->units[TR_FMT_KB].name = tr_strdup( kb );
+    units->units[TR_FMT_KB].name = tr_strdup (kb);
     units->units[TR_FMT_KB].value = value;
 
     value *= kilo;
-    units->units[TR_FMT_MB].name = tr_strdup( mb );
+    units->units[TR_FMT_MB].name = tr_strdup (mb);
     units->units[TR_FMT_MB].value = value;
 
     value *= kilo;
-    units->units[TR_FMT_GB].name = tr_strdup( gb );
+    units->units[TR_FMT_GB].name = tr_strdup (gb);
     units->units[TR_FMT_GB].value = value;
 
     value *= kilo;
-    units->units[TR_FMT_TB].name = tr_strdup( tb );
+    units->units[TR_FMT_TB].name = tr_strdup (tb);
     units->units[TR_FMT_TB].value = value;
 }
 
 static char*
-formatter_get_size_str( const struct formatter_units * u,
-                        char * buf, int64_t bytes, size_t buflen )
+formatter_get_size_str (const struct formatter_units * u,
+                        char * buf, int64_t bytes, size_t buflen)
 {
     int precision;
     double value;
     const char * units;
     const struct formatter_unit * unit;
 
-         if( bytes < u->units[1].value ) unit = &u->units[0];
-    else if( bytes < u->units[2].value ) unit = &u->units[1];
-    else if( bytes < u->units[3].value ) unit = &u->units[2];
+         if (bytes < u->units[1].value) unit = &u->units[0];
+    else if (bytes < u->units[2].value) unit = &u->units[1];
+    else if (bytes < u->units[3].value) unit = &u->units[2];
     else                                 unit = &u->units[3];
 
     value = (double)bytes / unit->value;
     units = unit->name;
-    if( unit->value == 1 )
+    if (unit->value == 1)
         precision = 0;
-    else if( value < 100 )
+    else if (value < 100)
         precision = 2;
     else
         precision = 1;
-    tr_snprintf( buf, buflen, "%.*f %s", precision, value, units );
+    tr_snprintf (buf, buflen, "%.*f %s", precision, value, units);
     return buf;
 }
 
 static struct formatter_units size_units;
 
 void
-tr_formatter_size_init( unsigned int kilo,
+tr_formatter_size_init (unsigned int kilo,
                         const char * kb, const char * mb,
-                        const char * gb, const char * tb )
+                        const char * gb, const char * tb)
 {
-    formatter_init( &size_units, kilo, kb, mb, gb, tb );
+    formatter_init (&size_units, kilo, kb, mb, gb, tb);
 }
 
 char*
-tr_formatter_size_B( char * buf, int64_t bytes, size_t buflen )
+tr_formatter_size_B (char * buf, int64_t bytes, size_t buflen)
 {
-    return formatter_get_size_str( &size_units, buf, bytes, buflen );
+    return formatter_get_size_str (&size_units, buf, bytes, buflen);
 }
 
 static struct formatter_units speed_units;
@@ -1770,31 +1770,31 @@ static struct formatter_units speed_units;
 unsigned int tr_speed_K = 0u;
 
 void
-tr_formatter_speed_init( unsigned int kilo,
+tr_formatter_speed_init (unsigned int kilo,
                          const char * kb, const char * mb,
-                         const char * gb, const char * tb )
+                         const char * gb, const char * tb)
 {
     tr_speed_K = kilo;
-    formatter_init( &speed_units, kilo, kb, mb, gb, tb );
+    formatter_init (&speed_units, kilo, kb, mb, gb, tb);
 }
 
 char*
-tr_formatter_speed_KBps( char * buf, double KBps, size_t buflen )
+tr_formatter_speed_KBps (char * buf, double KBps, size_t buflen)
 {
     const double K = speed_units.units[TR_FMT_KB].value;
     double speed = KBps;
 
-    if( speed <= 999.95 ) /* 0.0 KB to 999.9 KB */
-        tr_snprintf( buf, buflen, "%d %s", (int)speed, speed_units.units[TR_FMT_KB].name );
+    if (speed <= 999.95) /* 0.0 KB to 999.9 KB */
+        tr_snprintf (buf, buflen, "%d %s", (int)speed, speed_units.units[TR_FMT_KB].name);
     else {
         speed /= K;
-        if( speed <= 99.995 ) /* 0.98 MB to 99.99 MB */
-            tr_snprintf( buf, buflen, "%.2f %s", speed, speed_units.units[TR_FMT_MB].name );
+        if (speed <= 99.995) /* 0.98 MB to 99.99 MB */
+            tr_snprintf (buf, buflen, "%.2f %s", speed, speed_units.units[TR_FMT_MB].name);
         else if (speed <= 999.95) /* 100.0 MB to 999.9 MB */
-            tr_snprintf( buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_MB].name );
+            tr_snprintf (buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_MB].name);
         else {
             speed /= K;
-            tr_snprintf( buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_GB].name );
+            tr_snprintf (buf, buflen, "%.1f %s", speed, speed_units.units[TR_FMT_GB].name);
         }
     }
 
@@ -1806,38 +1806,38 @@ static struct formatter_units mem_units;
 unsigned int tr_mem_K = 0u;
 
 void
-tr_formatter_mem_init( unsigned int kilo,
+tr_formatter_mem_init (unsigned int kilo,
                        const char * kb, const char * mb,
-                       const char * gb, const char * tb )
+                       const char * gb, const char * tb)
 {
     tr_mem_K = kilo;
-    formatter_init( &mem_units, kilo, kb, mb, gb, tb );
+    formatter_init (&mem_units, kilo, kb, mb, gb, tb);
 }
 
 char*
-tr_formatter_mem_B( char * buf, int64_t bytes_per_second, size_t buflen )
+tr_formatter_mem_B (char * buf, int64_t bytes_per_second, size_t buflen)
 {
-    return formatter_get_size_str( &mem_units, buf, bytes_per_second, buflen );
+    return formatter_get_size_str (&mem_units, buf, bytes_per_second, buflen);
 }
 
 void
-tr_formatter_get_units( tr_benc * d )
+tr_formatter_get_units (tr_benc * d)
 {
     int i;
     tr_benc * l;
 
-    tr_bencDictReserve( d, 6 );
+    tr_bencDictReserve (d, 6);
 
-    tr_bencDictAddInt( d, "memory-bytes", mem_units.units[TR_FMT_KB].value );
-    l = tr_bencDictAddList( d, "memory-units", 4 );
-    for( i=0; i<4; i++ ) tr_bencListAddStr( l, mem_units.units[i].name );
+    tr_bencDictAddInt (d, "memory-bytes", mem_units.units[TR_FMT_KB].value);
+    l = tr_bencDictAddList (d, "memory-units", 4);
+    for (i=0; i<4; i++) tr_bencListAddStr (l, mem_units.units[i].name);
 
-    tr_bencDictAddInt( d, "size-bytes",   size_units.units[TR_FMT_KB].value );
-    l = tr_bencDictAddList( d, "size-units", 4 );
-    for( i=0; i<4; i++ ) tr_bencListAddStr( l, size_units.units[i].name );
+    tr_bencDictAddInt (d, "size-bytes",   size_units.units[TR_FMT_KB].value);
+    l = tr_bencDictAddList (d, "size-units", 4);
+    for (i=0; i<4; i++) tr_bencListAddStr (l, size_units.units[i].name);
 
-    tr_bencDictAddInt( d, "speed-bytes",  speed_units.units[TR_FMT_KB].value );
-    l = tr_bencDictAddList( d, "speed-units", 4 );
-    for( i=0; i<4; i++ ) tr_bencListAddStr( l, speed_units.units[i].name );
+    tr_bencDictAddInt (d, "speed-bytes",  speed_units.units[TR_FMT_KB].value);
+    l = tr_bencDictAddList (d, "speed-units", 4);
+    for (i=0; i<4; i++) tr_bencListAddStr (l, speed_units.units[i].name);
 }
 
diff --git a/libtransmission/utils.h b/libtransmission/utils.h
index c5a2437f2..534c50d2a 100644
--- a/libtransmission/utils.h
+++ b/libtransmission/utils.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -32,7 +32,7 @@ extern "C" {
 
 #ifndef UNUSED
  #ifdef __GNUC__
-  #define UNUSED __attribute__ ( ( unused ) )
+  #define UNUSED __attribute__ ((unused))
  #else
   #define UNUSED
  #endif
@@ -40,32 +40,32 @@ extern "C" {
 
 #ifndef TR_GNUC_PRINTF
  #ifdef __GNUC__
-  #define TR_GNUC_PRINTF( fmt, args ) __attribute__ ( ( format ( printf, fmt, args ) ) )
+  #define TR_GNUC_PRINTF(fmt, args) __attribute__ ((format (printf, fmt, args)))
  #else
-  #define TR_GNUC_PRINTF( fmt, args )
+  #define TR_GNUC_PRINTF(fmt, args)
  #endif
 #endif
 
 #ifndef TR_GNUC_NONNULL
  #ifdef __GNUC__
-  #define TR_GNUC_NONNULL( ... ) __attribute__((nonnull (__VA_ARGS__)))
+  #define TR_GNUC_NONNULL(...) __attribute__ ((nonnull (__VA_ARGS__)))
  #else
-  #define TR_GNUC_NONNULL( ... )
+  #define TR_GNUC_NONNULL(...)
  #endif
 #endif
 
 #ifndef TR_GNUC_NULL_TERMINATED
- #if __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 3 )
-  #define TR_GNUC_NULL_TERMINATED __attribute__ ( ( __sentinel__ ) )
-  #define TR_GNUC_HOT __attribute ( ( hot ) )
+ #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
+  #define TR_GNUC_NULL_TERMINATED __attribute__ ((__sentinel__))
+  #define TR_GNUC_HOT __attribute ((hot))
  #else
   #define TR_GNUC_NULL_TERMINATED
   #define TR_GNUC_HOT
  #endif
 #endif
 
-#if __GNUC__ > 2 || ( __GNUC__ == 2 && __GNUC_MINOR__ >= 96 )
- #define TR_GNUC_MALLOC __attribute__ ( ( __malloc__ ) )
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
+ #define TR_GNUC_MALLOC __attribute__ ((__malloc__))
 #else
  #define TR_GNUC_MALLOC
 #endif
@@ -75,26 +75,26 @@ extern "C" {
 ****
 ***/
 
-const char * tr_strip_positional_args( const char * fmt );
+const char * tr_strip_positional_args (const char * fmt);
 
-#if !defined( _ )
- #if defined( HAVE_LIBINTL_H ) && !defined( SYS_DARWIN )
+#if !defined (_)
+ #if defined (HAVE_LIBINTL_H) && !defined (SYS_DARWIN)
   #include <libintl.h>
-  #define _( a ) gettext ( a )
+  #define _(a) gettext (a)
  #else
-  #define _( a ) ( a )
+  #define _(a)(a)
  #endif
 #endif
 
 /* #define DISABLE_GETTEXT */
 #ifndef DISABLE_GETTEXT
- #if defined(WIN32) || defined(TR_LIGHTWEIGHT)
+ #if defined (WIN32) || defined (TR_LIGHTWEIGHT)
    #define DISABLE_GETTEXT
  #endif
 #endif
 #ifdef DISABLE_GETTEXT
  #undef _
- #define _( a ) tr_strip_positional_args( a )
+ #define _(a) tr_strip_positional_args (a)
 #endif
 
 /****
@@ -105,103 +105,103 @@ const char * tr_strip_positional_args( const char * fmt );
 
 extern tr_msg_level __tr_message_level;
 
-static inline tr_msg_level tr_getMessageLevel( void )
+static inline tr_msg_level tr_getMessageLevel (void)
 {
     return __tr_message_level;
 }
 
-static inline bool tr_msgLoggingIsActive( tr_msg_level level )
+static inline bool tr_msgLoggingIsActive (tr_msg_level level)
 {
-    return tr_getMessageLevel() >= level;
+    return tr_getMessageLevel () >= level;
 }
 
-void tr_msg( const char * file, int line,
+void tr_msg (const char * file, int line,
              tr_msg_level level,
              const char * torrent,
-             const char * fmt, ... ) TR_GNUC_PRINTF( 5, 6 );
+             const char * fmt, ...) TR_GNUC_PRINTF (5, 6);
 
-#define tr_nerr( n, ... ) \
+#define tr_nerr(n, ...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_ERR ) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_ERR, n, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_ERR)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_ERR, n, __VA_ARGS__); \
+    } while (0)
 
-#define tr_ninf( n, ... ) \
+#define tr_ninf(n, ...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_INF) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_INF, n, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_INF)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_INF, n, __VA_ARGS__); \
+    } while (0)
 
-#define tr_ndbg( n, ... ) \
+#define tr_ndbg(n, ...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_DBG) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_DBG, n, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_DBG)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_DBG, n, __VA_ARGS__); \
+    } while (0)
 
-#define tr_torerr( tor, ... ) \
+#define tr_torerr(tor, ...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_ERR ) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_ERR, tr_torrentName( tor ), __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_ERR)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_ERR, tr_torrentName (tor), __VA_ARGS__); \
+    } while (0)
 
-#define tr_torinf( tor, ... ) \
+#define tr_torinf(tor, ...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_INF ) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_INF, tr_torrentName( tor ), __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_INF)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_INF, tr_torrentName (tor), __VA_ARGS__); \
+    } while (0)
 
-#define tr_tordbg( tor, ... ) \
+#define tr_tordbg(tor, ...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_DBG ) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_DBG, tr_torrentName( tor ), __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_DBG)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_DBG, tr_torrentName (tor), __VA_ARGS__); \
+    } while (0)
 
-#define tr_err( ... ) \
+#define tr_err(...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_ERR ) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_ERR, NULL, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_ERR)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_ERR, NULL, __VA_ARGS__); \
+    } while (0)
 
-#define tr_inf( ... ) \
+#define tr_inf(...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_INF ) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_INF, NULL, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_INF)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_INF, NULL, __VA_ARGS__); \
+    } while (0)
 
-#define tr_dbg( ... ) \
+#define tr_dbg(...) \
     do { \
-        if( tr_msgLoggingIsActive( TR_MSG_DBG ) ) \
-            tr_msg( __FILE__, __LINE__, TR_MSG_DBG, NULL, __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_msgLoggingIsActive (TR_MSG_DBG)) \
+            tr_msg (__FILE__, __LINE__, TR_MSG_DBG, NULL, __VA_ARGS__); \
+    } while (0)
 
 
 
-void* tr_getLog( void );
+void* tr_getLog (void);
 
 /** @brief return true if deep logging has been enabled by the user; false otherwise */
-bool tr_deepLoggingIsActive( void );
+bool tr_deepLoggingIsActive (void);
 
-void           tr_deepLog( const char * file,
+void           tr_deepLog (const char * file,
                            int          line,
                            const char * name,
                            const char * fmt,
-                           ... ) TR_GNUC_PRINTF( 4, 5 ) TR_GNUC_NONNULL(1,4);
+                           ...) TR_GNUC_PRINTF (4, 5) TR_GNUC_NONNULL (1,4);
 
 /** @brief set the buffer with the current time formatted for deep logging. */
-char* tr_getLogTimeStr( char * buf, int buflen ) TR_GNUC_NONNULL(1);
+char* tr_getLogTimeStr (char * buf, int buflen) TR_GNUC_NONNULL (1);
 
 
 /**
  * @brief Rich Salz's classic implementation of shell-style pattern matching for ?, \, [], and * characters.
  * @return 1 if the pattern matches, 0 if it doesn't, or -1 if an error occured
  */
-bool tr_wildmat( const char * text, const char * pattern ) TR_GNUC_NONNULL(1,2);
+bool tr_wildmat (const char * text, const char * pattern) TR_GNUC_NONNULL (1,2);
 
-/** @brief Portability wrapper for basename() that uses the system implementation if available */
-char* tr_basename( const char * path ) TR_GNUC_MALLOC;
+/** @brief Portability wrapper for basename () that uses the system implementation if available */
+char* tr_basename (const char * path) TR_GNUC_MALLOC;
 
-/** @brief Portability wrapper for dirname() that uses the system implementation if available */
-char* tr_dirname( const char * path ) TR_GNUC_MALLOC;
+/** @brief Portability wrapper for dirname () that uses the system implementation if available */
+char* tr_dirname (const char * path) TR_GNUC_MALLOC;
 
 /**
  * Like mkdir, but makes parent directories as needed.
@@ -209,59 +209,59 @@ char* tr_dirname( const char * path ) TR_GNUC_MALLOC;
  * @return zero on success, or -1 if an error occurred
  * (in which case errno is set appropriately).
  */
-int tr_mkdirp( const char * path, int permissions ) TR_GNUC_NONNULL(1);
+int tr_mkdirp (const char * path, int permissions) TR_GNUC_NONNULL (1);
 
-/** @brief Portability wrapper for mkdtemp() that uses the system implementation if available */
-char* tr_mkdtemp( char * _template );
+/** @brief Portability wrapper for mkdtemp () that uses the system implementation if available */
+char* tr_mkdtemp (char * _template);
 
 
 /**
  * @brief Loads a file and returns its contents.
  * On failure, NULL is returned and errno is set.
  */
-uint8_t* tr_loadFile( const char * filename, size_t * size ) TR_GNUC_MALLOC
-                                                             TR_GNUC_NONNULL(1);
+uint8_t* tr_loadFile (const char * filename, size_t * size) TR_GNUC_MALLOC
+                                                             TR_GNUC_NONNULL (1);
 
 
 /** @brief build a filename from a series of elements using the
            platform's correct directory separator. */
-char* tr_buildPath( const char * first_element, ... ) TR_GNUC_NULL_TERMINATED
+char* tr_buildPath (const char * first_element, ...) TR_GNUC_NULL_TERMINATED
                                                       TR_GNUC_MALLOC;
 
-bool tr_fileExists( const char * filename, time_t * mtime );
+bool tr_fileExists (const char * filename, time_t * mtime);
 
 
 struct event;
 
 /**
- * @brief Convenience wrapper around timer_add() to have a timer wake up in a number of seconds and microseconds
+ * @brief Convenience wrapper around timer_add () to have a timer wake up in a number of seconds and microseconds
  * @param timer
  * @param seconds
  * @param microseconds
  */
-void tr_timerAdd( struct event * timer, int seconds, int microseconds ) TR_GNUC_NONNULL(1);
+void tr_timerAdd (struct event * timer, int seconds, int microseconds) TR_GNUC_NONNULL (1);
 
 /**
- * @brief Convenience wrapper around timer_add() to have a timer wake up in a number of milliseconds
+ * @brief Convenience wrapper around timer_add () to have a timer wake up in a number of milliseconds
  * @param timer
  * @param milliseconds
  */
-void tr_timerAddMsec( struct event * timer, int milliseconds ) TR_GNUC_NONNULL(1);
+void tr_timerAddMsec (struct event * timer, int milliseconds) TR_GNUC_NONNULL (1);
 
 
 /** @brief return the current date in milliseconds */
-uint64_t tr_time_msec( void );
+uint64_t tr_time_msec (void);
 
 /** @brief sleep the specified number of milliseconds */
-void tr_wait_msec( long int delay_milliseconds );
+void tr_wait_msec (long int delay_milliseconds);
 
 /**
  * @brief make a copy of 'str' whose non-utf8 content has been corrected or stripped
- * @return a newly-allocated string that must be freed with tr_free()
+ * @return a newly-allocated string that must be freed with tr_free ()
  * @param str the string to make a clean copy of
  * @param len the length of the string to copy. If -1, the entire string is used.
  */
-char* tr_utf8clean( const char * str, int len ) TR_GNUC_MALLOC;
+char* tr_utf8clean (const char * str, int len) TR_GNUC_MALLOC;
 
 
 /***
@@ -271,192 +271,192 @@ char* tr_utf8clean( const char * str, int len ) TR_GNUC_MALLOC;
 /* Sometimes the system defines MAX/MIN, sometimes not.
    In the latter case, define those here since we will use them */
 #ifndef MAX
- #define MAX( a, b ) ( ( a ) > ( b ) ? ( a ) : ( b ) )
+ #define MAX(a, b)((a) > (b) ? (a) : (b))
 #endif
 #ifndef MIN
- #define MIN( a, b ) ( ( a ) > ( b ) ? ( b ) : ( a ) )
+ #define MIN(a, b)((a) > (b) ? (b) : (a))
 #endif
 
 /***
 ****
 ***/
 
-/** @brief Portability wrapper around malloc() in which `0' is a safe argument */
-void* tr_malloc( size_t size );
+/** @brief Portability wrapper around malloc () in which `0' is a safe argument */
+void* tr_malloc (size_t size);
 
-/** @brief Portability wrapper around calloc() in which `0' is a safe argument */
-void* tr_malloc0( size_t size );
+/** @brief Portability wrapper around calloc () in which `0' is a safe argument */
+void* tr_malloc0 (size_t size);
 
-/** @brief Portability wrapper around free() in which `NULL' is a safe argument */
-void tr_free( void * p );
+/** @brief Portability wrapper around free () in which `NULL' is a safe argument */
+void tr_free (void * p);
 
 /**
  * @brief make a newly-allocated copy of a chunk of memory
  * @param src the memory to copy
  * @param byteCount the number of bytes to copy
- * @return a newly-allocated copy of `src' that can be freed with tr_free()
+ * @return a newly-allocated copy of `src' that can be freed with tr_free ()
  */
-void* tr_memdup( const void * src, size_t byteCount );
+void* tr_memdup (const void * src, size_t byteCount);
 
-#define tr_new( struct_type, n_structs )           \
-    ( (struct_type *) tr_malloc ( sizeof ( struct_type ) * ( ( size_t) ( n_structs ) ) ) )
+#define tr_new(struct_type, n_structs)           \
+  ((struct_type *) tr_malloc (sizeof (struct_type) * ((size_t)(n_structs))))
 
-#define tr_new0( struct_type, n_structs )          \
-    ( (struct_type *) tr_malloc0 ( sizeof ( struct_type ) * ( ( size_t) ( n_structs ) ) ) )
+#define tr_new0(struct_type, n_structs)          \
+  ((struct_type *) tr_malloc0 (sizeof (struct_type) * ((size_t)(n_structs))))
 
-#define tr_renew( struct_type, mem, n_structs )    \
-    ( (struct_type *) realloc ( ( mem ), sizeof ( struct_type ) * ( ( size_t) ( n_structs ) ) ) )
+#define tr_renew(struct_type, mem, n_structs)    \
+  ((struct_type *) realloc ((mem), sizeof (struct_type) * ((size_t)(n_structs))))
 
-void* tr_valloc( size_t bufLen );
+void* tr_valloc (size_t bufLen);
 
 /**
  * @brief make a newly-allocated copy of a substring
  * @param in is a void* so that callers can pass in both signed & unsigned without a cast
- * @param len length of the substring to copy. if a length less than zero is passed in, strlen( len ) is used
- * @return a newly-allocated copy of `in' that can be freed with tr_free()
+ * @param len length of the substring to copy. if a length less than zero is passed in, strlen (len) is used
+ * @return a newly-allocated copy of `in' that can be freed with tr_free ()
  */
-char* tr_strndup( const void * in, int len ) TR_GNUC_MALLOC;
+char* tr_strndup (const void * in, int len) TR_GNUC_MALLOC;
 
 /**
  * @brief make a newly-allocated copy of a string
  * @param in is a void* so that callers can pass in both signed & unsigned without a cast
- * @return a newly-allocated copy of `in' that can be freed with tr_free()
+ * @return a newly-allocated copy of `in' that can be freed with tr_free ()
  */
-char* tr_strdup( const void * in );
+char* tr_strdup (const void * in);
 
 /**
- * @brief like strcmp() but gracefully handles NULL strings
+ * @brief like strcmp () but gracefully handles NULL strings
  */
-int tr_strcmp0( const char * str1, const char * str2 );
+int tr_strcmp0 (const char * str1, const char * str2);
 
 
 
 struct evbuffer;
 
-char* evbuffer_free_to_str( struct evbuffer * buf );
+char* evbuffer_free_to_str (struct evbuffer * buf);
 
-/** @brief similar to bsearch() but returns the index of the lower bound */
-int tr_lowerBound( const void * key,
+/** @brief similar to bsearch () but returns the index of the lower bound */
+int tr_lowerBound (const void * key,
                    const void * base,
                    size_t       nmemb,
                    size_t       size,
-                   int       (* compar)(const void* key, const void* arrayMember),
-                   bool       * exact_match ) TR_GNUC_HOT TR_GNUC_NONNULL(1,5,6);
+                   int     (* compar)(const void* key, const void* arrayMember),
+                   bool       * exact_match) TR_GNUC_HOT TR_GNUC_NONNULL (1,5,6);
 
 
 /**
- * @brief sprintf() a string into a newly-allocated buffer large enough to hold it
- * @return a newly-allocated string that can be freed with tr_free()
+ * @brief sprintf () a string into a newly-allocated buffer large enough to hold it
+ * @return a newly-allocated string that can be freed with tr_free ()
  */
-char* tr_strdup_printf( const char * fmt, ... ) TR_GNUC_PRINTF( 1, 2 )
+char* tr_strdup_printf (const char * fmt, ...) TR_GNUC_PRINTF (1, 2)
                                                 TR_GNUC_MALLOC;
 
 /**
  * @brief Translate a block of bytes into base64
- * @return a newly-allocated string that can be freed with tr_free()
+ * @return a newly-allocated string that can be freed with tr_free ()
  */
-char* tr_base64_encode( const void * input,
+char* tr_base64_encode (const void * input,
                         int          inlen,
-                        int        * outlen ) TR_GNUC_MALLOC;
+                        int        * outlen) TR_GNUC_MALLOC;
 
 /**
  * @brief Translate a block of bytes from base64 into raw form
- * @return a newly-allocated string that can be freed with tr_free()
+ * @return a newly-allocated string that can be freed with tr_free ()
  */
-char* tr_base64_decode( const void * input,
+char* tr_base64_decode (const void * input,
                         int          inlen,
-                        int        * outlen ) TR_GNUC_MALLOC;
+                        int        * outlen) TR_GNUC_MALLOC;
 
-/** @brief Portability wrapper for strlcpy() that uses the system implementation if available */
-size_t tr_strlcpy( char * dst, const void * src, size_t siz );
+/** @brief Portability wrapper for strlcpy () that uses the system implementation if available */
+size_t tr_strlcpy (char * dst, const void * src, size_t siz);
 
-/** @brief Portability wrapper for snprintf() that uses the system implementation if available */
-int tr_snprintf( char * buf, size_t buflen,
-                 const char * fmt, ... ) TR_GNUC_PRINTF( 3, 4 ) TR_GNUC_NONNULL(1,3);
+/** @brief Portability wrapper for snprintf () that uses the system implementation if available */
+int tr_snprintf (char * buf, size_t buflen,
+                 const char * fmt, ...) TR_GNUC_PRINTF (3, 4) TR_GNUC_NONNULL (1,3);
 
-/** @brief Convenience wrapper around strerorr() guaranteed to not return NULL
+/** @brief Convenience wrapper around strerorr () guaranteed to not return NULL
     @param errno */
-const char* tr_strerror( int );
+const char* tr_strerror (int);
 
 /** @brief strips leading and trailing whitspace from a string
     @return the stripped string */
-char* tr_strstrip( char * str );
+char* tr_strstrip (char * str);
 
 /** @brief Returns true if the string ends with the specified case-insensitive suffix */
-bool tr_str_has_suffix( const char *str, const char *suffix );
+bool tr_str_has_suffix (const char *str, const char *suffix);
 
 
-/** @brief Portability wrapper for memmem() that uses the system implementation if available */
-const char* tr_memmem( const char * haystack, size_t haystack_len,
-                       const char * needle, size_t needle_len );
+/** @brief Portability wrapper for memmem () that uses the system implementation if available */
+const char* tr_memmem (const char * haystack, size_t haystack_len,
+                       const char * needle, size_t needle_len);
 
-/** @brief Portability wrapper for strsep() that uses the system implementation if available */
-char* tr_strsep( char ** str, const char * delim );
+/** @brief Portability wrapper for strsep () that uses the system implementation if available */
+char* tr_strsep (char ** str, const char * delim);
 
 /***
 ****
 ***/
 
-int compareInt( const void * va, const void * vb );
+int compareInt (const void * va, const void * vb);
 
-void tr_sha1_to_hex( char * out, const uint8_t * sha1 ) TR_GNUC_NONNULL(1,2);
+void tr_sha1_to_hex (char * out, const uint8_t * sha1) TR_GNUC_NONNULL (1,2);
 
-void tr_hex_to_sha1( uint8_t * out, const char * hex ) TR_GNUC_NONNULL(1,2);
+void tr_hex_to_sha1 (uint8_t * out, const char * hex) TR_GNUC_NONNULL (1,2);
 
 /** @brief convenience function to determine if an address is an IP address (IPv4 or IPv6) */
-bool tr_addressIsIP( const char * address );
+bool tr_addressIsIP (const char * address);
 
 /** @brief return true if the url is a http or https url that Transmission understands */
-bool tr_urlIsValidTracker( const char * url ) TR_GNUC_NONNULL(1);
+bool tr_urlIsValidTracker (const char * url) TR_GNUC_NONNULL (1);
 
 /** @brief return true if the url is a [ http, https, ftp, ftps ] url that Transmission understands */
-bool tr_urlIsValid( const char * url, int url_len ) TR_GNUC_NONNULL(1);
+bool tr_urlIsValid (const char * url, int url_len) TR_GNUC_NONNULL (1);
 
 /** @brief parse a URL into its component parts
     @return zero on success or an error number if an error occurred */
-int  tr_urlParse( const char * url,
+int  tr_urlParse (const char * url,
                   int          url_len,
                   char      ** setme_scheme,
                   char      ** setme_host,
                   int        * setme_port,
-                  char      ** setme_path ) TR_GNUC_NONNULL(1);
+                  char      ** setme_path) TR_GNUC_NONNULL (1);
 
 
 /** @brief return TR_RATIO_NA, TR_RATIO_INF, or a number in [0..1]
     @return TR_RATIO_NA, TR_RATIO_INF, or a number in [0..1] */
-double tr_getRatio( uint64_t numerator, uint64_t denominator );
+double tr_getRatio (uint64_t numerator, uint64_t denominator);
 
 /**
  * @brief Given a string like "1-4" or "1-4,6,9,14-51", this returns a
  *        newly-allocated array of all the integers in the set.
- * @return a newly-allocated array of integers that must be freed with tr_free(),
+ * @return a newly-allocated array of integers that must be freed with tr_free (),
  *         or NULL if a fragment of the string can't be parsed.
  *
  * For example, "5-8" will return [ 5, 6, 7, 8 ] and setmeCount will be 4.
  */
-int* tr_parseNumberRange( const char * str,
+int* tr_parseNumberRange (const char * str,
                           int str_len,
-                          int * setmeCount ) TR_GNUC_MALLOC TR_GNUC_NONNULL(1);
+                          int * setmeCount) TR_GNUC_MALLOC TR_GNUC_NONNULL (1);
 
 
 /**
  * @brief truncate a double value at a given number of decimal places.
  *
- * this can be used to prevent a printf() call from rounding up:
+ * this can be used to prevent a printf () call from rounding up:
  * call with the decimal_places argument equal to the number of
- * decimal places in the printf()'s precision:
+ * decimal places in the printf ()'s precision:
  *
- * - printf("%.2f%%",           99.999    ) ==> "100.00%"
+ * - printf ("%.2f%%",           99.999  ) ==> "100.00%"
  *
- * - printf("%.2f%%", tr_truncd(99.999, 2)) ==>  "99.99%"
+ * - printf ("%.2f%%", tr_truncd (99.999, 2)) ==>  "99.99%"
  *             ^                        ^
  *             |   These should match   |
  *             +------------------------+
  */
-double tr_truncd( double x, int decimal_places );
+double tr_truncd (double x, int decimal_places);
 
 /* return a percent formatted string of either x.xx, xx.x or xxx */
-char* tr_strpercent( char * buf, double x, size_t buflen );
+char* tr_strpercent (char * buf, double x, size_t buflen);
 
 /**
  * @param buf the buffer to write the string to
@@ -464,37 +464,37 @@ char* tr_strpercent( char * buf, double x, size_t buflen );
  * @param ratio the ratio to convert to a string
  * @param the string represntation of "infinity"
  */
-char* tr_strratio( char * buf, size_t buflen, double ratio, const char * infinity ) TR_GNUC_NONNULL(1,4);
+char* tr_strratio (char * buf, size_t buflen, double ratio, const char * infinity) TR_GNUC_NONNULL (1,4);
 
-/** @brief Portability wrapper for localtime_r() that uses the system implementation if available */
-struct tm * tr_localtime_r( const time_t *_clock, struct tm *_result );
+/** @brief Portability wrapper for localtime_r () that uses the system implementation if available */
+struct tm * tr_localtime_r (const time_t *_clock, struct tm *_result);
 
 
 /**
  * @brief move a file
  * @return 0 on success; otherwise, return -1 and set errno
  */
-int tr_moveFile( const char * oldpath, const char * newpath,
-                 bool * renamed ) TR_GNUC_NONNULL(1,2);
+int tr_moveFile (const char * oldpath, const char * newpath,
+                 bool * renamed) TR_GNUC_NONNULL (1,2);
 
 /** @brief Test to see if the two filenames point to the same file. */
-bool tr_is_same_file( const char * filename1, const char * filename2 );
+bool tr_is_same_file (const char * filename1, const char * filename2);
 
 /** @brief convenience function to remove an item from an array */
-void tr_removeElementFromArray( void         * array,
+void tr_removeElementFromArray (void         * array,
                                 unsigned int   index_to_remove,
                                 size_t         sizeof_element,
-                                size_t         nmemb );
+                                size_t         nmemb);
 
 /***
 ****
 ***/
 
-/** @brief Private libtransmission variable that's visible only for inlining in tr_time() */
+/** @brief Private libtransmission variable that's visible only for inlining in tr_time () */
 extern time_t __tr_current_time;
 
 /**
- * @brief very inexpensive form of time(NULL)
+ * @brief very inexpensive form of time (NULL)
  * @return the current epoch time in seconds
  *
  * This function returns a second counter that is updated once per second.
@@ -503,10 +503,10 @@ extern time_t __tr_current_time;
  * to always be accurate. However, it is *much* faster when 100% accuracy
  * isn't needed
  */
-static inline time_t tr_time( void ) { return __tr_current_time; }
+static inline time_t tr_time (void) { return __tr_current_time; }
 
-/** @brief Private libtransmission function to update tr_time()'s counter */
-static inline void tr_timeUpdate( time_t now ) { __tr_current_time = now; }
+/** @brief Private libtransmission function to update tr_time ()'s counter */
+static inline void tr_timeUpdate (time_t now) { __tr_current_time = now; }
 
 #ifdef WIN32
  #include <windef.h> /* MAX_PATH */
@@ -520,48 +520,48 @@ static inline void tr_timeUpdate( time_t now ) { __tr_current_time = now; }
  #endif
 #endif
 
-/** @brief Portability wrapper for realpath() that uses the system implementation if available.
+/** @brief Portability wrapper for realpath () that uses the system implementation if available.
     @param resolved_path should be TR_PATH_MAX or larger */
-char* tr_realpath( const char *path, char * resolved_path );
+char* tr_realpath (const char *path, char * resolved_path);
 
-/** @brief Portability wrapper for htonll() that uses the system implementation if available */
-uint64_t tr_htonll( uint64_t );
+/** @brief Portability wrapper for htonll () that uses the system implementation if available */
+uint64_t tr_htonll (uint64_t);
 
-/** @brief Portability wrapper for htonll() that uses the system implementation if available */
-uint64_t tr_ntohll( uint64_t );
+/** @brief Portability wrapper for htonll () that uses the system implementation if available */
+uint64_t tr_ntohll (uint64_t);
 
 /***
 ****
 ***/
 
-/* example: tr_formatter_size_init( 1024, _("KiB"), _("MiB"), _("GiB"), _("TiB") ); */
+/* example: tr_formatter_size_init (1024, _ ("KiB"), _ ("MiB"), _ ("GiB"), _ ("TiB")); */
 
-void tr_formatter_size_init( unsigned int kilo, const char * kb, const char * mb,
-                                                const char * gb, const char * tb );
+void tr_formatter_size_init (unsigned int kilo, const char * kb, const char * mb,
+                                                const char * gb, const char * tb);
 
-void tr_formatter_speed_init( unsigned int kilo, const char * kb, const char * mb,
-                                                 const char * gb, const char * tb );
+void tr_formatter_speed_init (unsigned int kilo, const char * kb, const char * mb,
+                                                 const char * gb, const char * tb);
 
-void tr_formatter_mem_init( unsigned int kilo, const char * kb, const char * mb,
-                                               const char * gb, const char * tb );
+void tr_formatter_mem_init (unsigned int kilo, const char * kb, const char * mb,
+                                               const char * gb, const char * tb);
 
 extern unsigned int tr_speed_K;
 extern unsigned int tr_mem_K;
 extern unsigned int tr_size_K;
 
 /* format a speed from KBps into a user-readable string. */
-char* tr_formatter_speed_KBps( char * buf, double KBps, size_t buflen );
+char* tr_formatter_speed_KBps (char * buf, double KBps, size_t buflen);
 
 /* format a memory size from bytes into a user-readable string. */
-char* tr_formatter_mem_B( char * buf, int64_t bytes, size_t buflen );
+char* tr_formatter_mem_B (char * buf, int64_t bytes, size_t buflen);
 
 /* format a memory size from MB into a user-readable string. */
-static inline char* tr_formatter_mem_MB( char * buf, double MBps, size_t buflen ) { return tr_formatter_mem_B( buf, MBps * tr_mem_K * tr_mem_K, buflen ); }
+static inline char* tr_formatter_mem_MB (char * buf, double MBps, size_t buflen) { return tr_formatter_mem_B (buf, MBps * tr_mem_K * tr_mem_K, buflen); }
 
 /* format a file size from bytes into a user-readable string. */
-char* tr_formatter_size_B( char * buf, int64_t bytes, size_t buflen );
+char* tr_formatter_size_B (char * buf, int64_t bytes, size_t buflen);
 
-void tr_formatter_get_units( struct tr_benc * dict );
+void tr_formatter_get_units (struct tr_benc * dict);
 
 /***
 ****
diff --git a/libtransmission/verify.c b/libtransmission/verify.c
index 8d1076ed1..cbac9e786 100644
--- a/libtransmission/verify.c
+++ b/libtransmission/verify.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,12 +10,12 @@
  * $Id$
  */
 
-#include <string.h> /* memcmp() */
-#include <stdlib.h> /* free() */
+#include <string.h> /* memcmp () */
+#include <stdlib.h> /* free () */
 
 #ifdef HAVE_POSIX_FADVISE
  #define _XOPEN_SOURCE 600
- #include <fcntl.h> /* posix_fadvise() */
+ #include <fcntl.h> /* posix_fadvise () */
 #endif
 
 #include <openssl/sha.h>
@@ -24,9 +24,9 @@
 #include "completion.h"
 #include "fdlimit.h"
 #include "list.h"
-#include "platform.h" /* tr_lock() */
+#include "platform.h" /* tr_lock () */
 #include "torrent.h"
-#include "utils.h" /* tr_valloc(), tr_free() */
+#include "utils.h" /* tr_valloc (), tr_free () */
 #include "verify.h"
 
 /***
@@ -35,126 +35,135 @@
 
 enum
 {
-    MSEC_TO_SLEEP_PER_SECOND_DURING_VERIFY = 100
+  MSEC_TO_SLEEP_PER_SECOND_DURING_VERIFY = 100
 };
 
 static bool
-verifyTorrent( tr_torrent * tor, bool * stopFlag )
+verifyTorrent (tr_torrent * tor, bool * stopFlag)
 {
-    time_t end;
-    SHA_CTX sha;
-    int fd = -1;
-    int64_t filePos = 0;
-    bool changed = 0;
-    bool hadPiece = 0;
-    time_t lastSleptAt = 0;
-    uint32_t piecePos = 0;
-    tr_file_index_t fileIndex = 0;
-    tr_file_index_t prevFileIndex = !fileIndex;
-    tr_piece_index_t pieceIndex = 0;
-    const time_t begin = tr_time( );
-    const size_t buflen = 1024 * 128; /* 128 KiB buffer */
-    uint8_t * buffer = tr_valloc( buflen );
-
-    SHA1_Init( &sha );
-
-    tr_tordbg( tor, "%s", "verifying torrent..." );
-    tr_torrentSetChecked( tor, 0 );
-    while( !*stopFlag && ( pieceIndex < tor->info.pieceCount ) )
+  time_t end;
+  SHA_CTX sha;
+  int fd = -1;
+  int64_t filePos = 0;
+  bool changed = 0;
+  bool hadPiece = 0;
+  time_t lastSleptAt = 0;
+  uint32_t piecePos = 0;
+  tr_file_index_t fileIndex = 0;
+  tr_file_index_t prevFileIndex = !fileIndex;
+  tr_piece_index_t pieceIndex = 0;
+  const time_t begin = tr_time ();
+  const size_t buflen = 1024 * 128; /* 128 KiB buffer */
+  uint8_t * buffer = tr_valloc (buflen);
+
+  SHA1_Init (&sha);
+
+  tr_tordbg (tor, "%s", "verifying torrent...");
+  tr_torrentSetChecked (tor, 0);
+  while (!*stopFlag && (pieceIndex < tor->info.pieceCount))
     {
-        uint32_t leftInPiece;
-        uint32_t bytesThisPass;
-        uint64_t leftInFile;
-        const tr_file * file = &tor->info.files[fileIndex];
+      uint32_t leftInPiece;
+      uint32_t bytesThisPass;
+      uint64_t leftInFile;
+      const tr_file * file = &tor->info.files[fileIndex];
 
-        /* if we're starting a new piece... */
-        if( piecePos == 0 )
-            hadPiece = tr_cpPieceIsComplete( &tor->completion, pieceIndex );
+      /* if we're starting a new piece... */
+      if (piecePos == 0)
+        hadPiece = tr_cpPieceIsComplete (&tor->completion, pieceIndex);
 
-        /* if we're starting a new file... */
-        if( !filePos && (fd<0) && (fileIndex!=prevFileIndex) )
+      /* if we're starting a new file... */
+      if (!filePos && (fd<0) && (fileIndex!=prevFileIndex))
         {
-            char * filename = tr_torrentFindFile( tor, fileIndex );
-            fd = filename == NULL ? -1 : tr_open_file_for_scanning( filename );
-            tr_free( filename );
-            prevFileIndex = fileIndex;
+          char * filename = tr_torrentFindFile (tor, fileIndex);
+          fd = filename == NULL ? -1 : tr_open_file_for_scanning (filename);
+          tr_free (filename);
+          prevFileIndex = fileIndex;
         }
 
-        /* figure out how much we can read this pass */
-        leftInPiece = tr_torPieceCountBytes( tor, pieceIndex ) - piecePos;
-        leftInFile = file->length - filePos;
-        bytesThisPass = MIN( leftInFile, leftInPiece );
-        bytesThisPass = MIN( bytesThisPass, buflen );
-
-        /* read a bit */
-        if( fd >= 0 ) {
-            const ssize_t numRead = tr_pread( fd, buffer, bytesThisPass, filePos );
-            if( numRead > 0 ) {
-                bytesThisPass = (uint32_t)numRead;
-                SHA1_Update( &sha, buffer, bytesThisPass );
+      /* figure out how much we can read this pass */
+      leftInPiece = tr_torPieceCountBytes (tor, pieceIndex) - piecePos;
+      leftInFile = file->length - filePos;
+      bytesThisPass = MIN (leftInFile, leftInPiece);
+      bytesThisPass = MIN (bytesThisPass, buflen);
+
+      /* read a bit */
+      if (fd >= 0)
+        {
+          const ssize_t numRead = tr_pread (fd, buffer, bytesThisPass, filePos);
+          if (numRead > 0)
+            {
+              bytesThisPass = (uint32_t)numRead;
+              SHA1_Update (&sha, buffer, bytesThisPass);
 #if defined HAVE_POSIX_FADVISE && defined POSIX_FADV_DONTNEED
-                posix_fadvise( fd, filePos, bytesThisPass, POSIX_FADV_DONTNEED );
+              posix_fadvise (fd, filePos, bytesThisPass, POSIX_FADV_DONTNEED);
 #endif
             }
         }
 
-        /* move our offsets */
-        leftInPiece -= bytesThisPass;
-        leftInFile -= bytesThisPass;
-        piecePos += bytesThisPass;
-        filePos += bytesThisPass;
+      /* move our offsets */
+      leftInPiece -= bytesThisPass;
+      leftInFile -= bytesThisPass;
+      piecePos += bytesThisPass;
+      filePos += bytesThisPass;
 
-        /* if we're finishing a piece... */
-        if( leftInPiece == 0 )
+      /* if we're finishing a piece... */
+      if (leftInPiece == 0)
         {
-            time_t now;
-            bool hasPiece;
-            uint8_t hash[SHA_DIGEST_LENGTH];
+          time_t now;
+          bool hasPiece;
+          uint8_t hash[SHA_DIGEST_LENGTH];
 
-            SHA1_Final( hash, &sha );
-            hasPiece = !memcmp( hash, tor->info.pieces[pieceIndex].hash, SHA_DIGEST_LENGTH );
+          SHA1_Final (hash, &sha);
+          hasPiece = !memcmp (hash, tor->info.pieces[pieceIndex].hash, SHA_DIGEST_LENGTH);
 
-            if( hasPiece || hadPiece ) {
-                tr_torrentSetHasPiece( tor, pieceIndex, hasPiece );
-                changed |= hasPiece != hadPiece;
+          if (hasPiece || hadPiece)
+            {
+              tr_torrentSetHasPiece (tor, pieceIndex, hasPiece);
+              changed |= hasPiece != hadPiece;
             }
-            tr_torrentSetPieceChecked( tor, pieceIndex );
-            now = tr_time( );
-            tor->anyDate = now;
-
-            /* sleeping even just a few msec per second goes a long
-             * way towards reducing IO load... */
-            if( lastSleptAt != now ) {
-                lastSleptAt = now;
-                tr_wait_msec( MSEC_TO_SLEEP_PER_SECOND_DURING_VERIFY );
+
+          tr_torrentSetPieceChecked (tor, pieceIndex);
+          now = tr_time ();
+          tor->anyDate = now;
+
+          /* sleeping even just a few msec per second goes a long
+           * way towards reducing IO load... */
+          if (lastSleptAt != now)
+            {
+              lastSleptAt = now;
+              tr_wait_msec (MSEC_TO_SLEEP_PER_SECOND_DURING_VERIFY);
             }
 
-            SHA1_Init( &sha );
-            ++pieceIndex;
-            piecePos = 0;
+          SHA1_Init (&sha);
+          pieceIndex++;
+          piecePos = 0;
         }
 
-        /* if we're finishing a file... */
-        if( leftInFile == 0 )
+      /* if we're finishing a file... */
+      if (leftInFile == 0)
         {
-            if( fd >= 0 ) { tr_close_file( fd ); fd = -1; }
-            ++fileIndex;
-            filePos = 0;
+          if (fd >= 0)
+            {
+              tr_close_file (fd);
+              fd = -1;
+            }
+          fileIndex++;
+          filePos = 0;
         }
     }
 
-    /* cleanup */
-    if( fd >= 0 )
-        tr_close_file( fd );
-    free( buffer );
+  /* cleanup */
+  if (fd >= 0)
+    tr_close_file (fd);
+  free (buffer);
 
-    /* stopwatch */
-    end = tr_time( );
-    tr_tordbg( tor, "Verification is done. It took %d seconds to verify %"PRIu64" bytes (%"PRIu64" bytes per second)",
-               (int)(end-begin), tor->info.totalSize,
-               (uint64_t)(tor->info.totalSize/(1+(end-begin))) );
+  /* stopwatch */
+  end = tr_time ();
+  tr_tordbg (tor, "Verification is done. It took %d seconds to verify %"PRIu64" bytes (%"PRIu64" bytes per second)",
+             (int)(end-begin), tor->info.totalSize,
+             (uint64_t)(tor->info.totalSize/ (1+ (end-begin))));
 
-    return changed;
+  return changed;
 }
 
 /***
@@ -163,18 +172,18 @@ verifyTorrent( tr_torrent * tor, bool * stopFlag )
 
 struct verify_node
 {
-    tr_torrent *         torrent;
-    tr_verify_done_cb    verify_done_cb;
-    uint64_t             current_size;
+  tr_torrent *         torrent;
+  tr_verify_done_cb    verify_done_cb;
+  uint64_t             current_size;
 };
 
 static void
-fireCheckDone( tr_torrent * tor, tr_verify_done_cb verify_done_cb )
+fireCheckDone (tr_torrent * tor, tr_verify_done_cb verify_done_cb)
 {
-    assert( tr_isTorrent( tor ) );
+  assert (tr_isTorrent (tor));
 
-    if( verify_done_cb )
-        verify_done_cb( tor );
+  if (verify_done_cb)
+    verify_done_cb (tor);
 }
 
 static struct verify_node currentNode;
@@ -183,137 +192,143 @@ static tr_thread * verifyThread = NULL;
 static bool stopCurrent = false;
 
 static tr_lock*
-getVerifyLock( void )
+getVerifyLock (void)
 {
-    static tr_lock * lock = NULL;
-    if( lock == NULL )
-        lock = tr_lockNew( );
-    return lock;
+  static tr_lock * lock = NULL;
+
+  if (lock == NULL)
+    lock = tr_lockNew ();
+
+  return lock;
 }
 
 static void
-verifyThreadFunc( void * unused UNUSED )
+verifyThreadFunc (void * unused UNUSED)
 {
-    for( ;; )
+  for (;;)
     {
-        int changed = 0;
-        tr_torrent * tor;
-        struct verify_node * node;
-
-        tr_lockLock( getVerifyLock( ) );
-        stopCurrent = false;
-        node = (struct verify_node*) verifyList ? verifyList->data : NULL;
-        if( node == NULL )
+      int changed = 0;
+      tr_torrent * tor;
+      struct verify_node * node;
+
+      tr_lockLock (getVerifyLock ());
+      stopCurrent = false;
+      node = (struct verify_node*) verifyList ? verifyList->data : NULL;
+      if (node == NULL)
         {
-            currentNode.torrent = NULL;
-            break;
+          currentNode.torrent = NULL;
+          break;
         }
 
-        currentNode = *node;
-        tor = currentNode.torrent;
-        tr_list_remove_data( &verifyList, node );
-        tr_free( node );
-        tr_lockUnlock( getVerifyLock( ) );
+      currentNode = *node;
+      tor = currentNode.torrent;
+      tr_list_remove_data (&verifyList, node);
+      tr_free (node);
+      tr_lockUnlock (getVerifyLock ());
 
-        tr_torinf( tor, "%s", _( "Verifying torrent" ) );
-        tr_torrentSetVerifyState( tor, TR_VERIFY_NOW );
-        changed = verifyTorrent( tor, &stopCurrent );
-        tr_torrentSetVerifyState( tor, TR_VERIFY_NONE );
-        assert( tr_isTorrent( tor ) );
+      tr_torinf (tor, "%s", _ ("Verifying torrent"));
+      tr_torrentSetVerifyState (tor, TR_VERIFY_NOW);
+      changed = verifyTorrent (tor, &stopCurrent);
+      tr_torrentSetVerifyState (tor, TR_VERIFY_NONE);
+      assert (tr_isTorrent (tor));
 
-        if( !stopCurrent )
+      if (!stopCurrent)
         {
-            if( changed )
-                tr_torrentSetDirty( tor );
-            fireCheckDone( tor, currentNode.verify_done_cb );
+          if (changed)
+            tr_torrentSetDirty (tor);
+          fireCheckDone (tor, currentNode.verify_done_cb);
         }
     }
 
-    verifyThread = NULL;
-    tr_lockUnlock( getVerifyLock( ) );
+  verifyThread = NULL;
+  tr_lockUnlock (getVerifyLock ());
 }
 
 static int
-compareVerifyByPriorityAndSize( const void * va, const void * vb )
+compareVerifyByPriorityAndSize (const void * va, const void * vb)
 {
-    const struct verify_node * a = va;
-    const struct verify_node * b = vb;
-
-    /* higher priority comes before lower priority */
-    const tr_priority_t pa = tr_torrentGetPriority( a->torrent );
-    const tr_priority_t pb = tr_torrentGetPriority( b->torrent );
-    if( pa != pb )
-        return pa > pb ? -1 : 1;
-
-    /* smaller torrents come before larger ones because they verify faster */
-    if( a->current_size < b->current_size ) return -1;
-    if( a->current_size > b->current_size ) return  1;
-    return 0;
+  const struct verify_node * a = va;
+  const struct verify_node * b = vb;
+
+  /* higher priority comes before lower priority */
+  const tr_priority_t pa = tr_torrentGetPriority (a->torrent);
+  const tr_priority_t pb = tr_torrentGetPriority (b->torrent);
+  if (pa != pb)
+    return pa > pb ? -1 : 1;
+
+  /* smaller torrents come before larger ones because they verify faster */
+  if (a->current_size < b->current_size)
+    return -1;
+  if (a->current_size > b->current_size)
+    return  1;
+  return 0;
 }
 
 void
-tr_verifyAdd( tr_torrent * tor, tr_verify_done_cb verify_done_cb )
+tr_verifyAdd (tr_torrent * tor, tr_verify_done_cb verify_done_cb)
 {
-    struct verify_node * node;
-
-    assert( tr_isTorrent( tor ) );
-    tr_torinf( tor, "%s", _( "Queued for verification" ) );
-
-    node = tr_new( struct verify_node, 1 );
-    node->torrent = tor;
-    node->verify_done_cb = verify_done_cb;
-    node->current_size = tr_torrentGetCurrentSizeOnDisk( tor );
-
-    tr_lockLock( getVerifyLock( ) );
-    tr_torrentSetVerifyState( tor, TR_VERIFY_WAIT );
-    tr_list_insert_sorted( &verifyList, node, compareVerifyByPriorityAndSize );
-    if( verifyThread == NULL )
-        verifyThread = tr_threadNew( verifyThreadFunc, NULL );
-    tr_lockUnlock( getVerifyLock( ) );
+  struct verify_node * node;
+
+  assert (tr_isTorrent (tor));
+  tr_torinf (tor, "%s", _ ("Queued for verification"));
+
+  node = tr_new (struct verify_node, 1);
+  node->torrent = tor;
+  node->verify_done_cb = verify_done_cb;
+  node->current_size = tr_torrentGetCurrentSizeOnDisk (tor);
+
+  tr_lockLock (getVerifyLock ());
+  tr_torrentSetVerifyState (tor, TR_VERIFY_WAIT);
+  tr_list_insert_sorted (&verifyList, node, compareVerifyByPriorityAndSize);
+  if (verifyThread == NULL)
+    verifyThread = tr_threadNew (verifyThreadFunc, NULL);
+  tr_lockUnlock (getVerifyLock ());
 }
 
 static int
-compareVerifyByTorrent( const void * va, const void * vb )
+compareVerifyByTorrent (const void * va, const void * vb)
 {
-    const struct verify_node * a = va;
-    const tr_torrent * b = vb;
-    return a->torrent - b;
+  const struct verify_node * a = va;
+  const tr_torrent * b = vb;
+  return a->torrent - b;
 }
 
 void
-tr_verifyRemove( tr_torrent * tor )
+tr_verifyRemove (tr_torrent * tor)
 {
-    tr_lock * lock = getVerifyLock( );
-    tr_lockLock( lock );
+  tr_lock * lock = getVerifyLock ();
+  tr_lockLock (lock);
 
-    assert( tr_isTorrent( tor ) );
+  assert (tr_isTorrent (tor));
 
-    if( tor == currentNode.torrent )
+  if (tor == currentNode.torrent)
     {
-        stopCurrent = true;
-        while( stopCurrent )
+      stopCurrent = true;
+
+      while (stopCurrent)
         {
-            tr_lockUnlock( lock );
-            tr_wait_msec( 100 );
-            tr_lockLock( lock );
+          tr_lockUnlock (lock);
+          tr_wait_msec (100);
+          tr_lockLock (lock);
         }
     }
-    else
+  else
     {
-        tr_free( tr_list_remove( &verifyList, tor, compareVerifyByTorrent ) );
-        tr_torrentSetVerifyState( tor, TR_VERIFY_NONE );
+      tr_free (tr_list_remove (&verifyList, tor, compareVerifyByTorrent));
+      tr_torrentSetVerifyState (tor, TR_VERIFY_NONE);
     }
 
-    tr_lockUnlock( lock );
+  tr_lockUnlock (lock);
 }
 
 void
-tr_verifyClose( tr_session * session UNUSED )
+tr_verifyClose (tr_session * session UNUSED)
 {
-    tr_lockLock( getVerifyLock( ) );
+  tr_lockLock (getVerifyLock ());
 
-    stopCurrent = true;
-    tr_list_free( &verifyList, tr_free );
+  stopCurrent = true;
+  tr_list_free (&verifyList, tr_free);
 
-    tr_lockUnlock( getVerifyLock( ) );
+  tr_lockUnlock (getVerifyLock ());
 }
+
diff --git a/libtransmission/verify.h b/libtransmission/verify.h
index ddffedfda..35bdbaa7a 100644
--- a/libtransmission/verify.h
+++ b/libtransmission/verify.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -22,14 +22,14 @@
  * @{
  */
 
-typedef void ( *tr_verify_done_cb )( tr_torrent * tor );
+typedef void (*tr_verify_done_cb)(tr_torrent * tor);
 
-void tr_verifyAdd( tr_torrent *      tor,
-                   tr_verify_done_cb recheck_done_cb );
+void tr_verifyAdd (tr_torrent *      tor,
+                   tr_verify_done_cb recheck_done_cb);
 
-void tr_verifyRemove( tr_torrent * tor );
+void tr_verifyRemove (tr_torrent * tor);
 
-void tr_verifyClose( tr_session * );
+void tr_verifyClose (tr_session *);
 
 /* @} */
 
diff --git a/libtransmission/web.c b/libtransmission/web.c
index afbf7d19e..b328180d4 100644
--- a/libtransmission/web.c
+++ b/libtransmission/web.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,8 +10,8 @@
  * $Id$
  */
 
-#include <string.h> /* strlen(), strstr() */
-#include <stdlib.h> /* getenv() */
+#include <string.h> /* strlen (), strstr () */
+#include <stdlib.h> /* getenv () */
 
 #ifdef WIN32
   #include <ws2tcpip.h>
@@ -27,7 +27,7 @@
 #include "net.h" /* tr_address */
 #include "platform.h" /* mutex */
 #include "session.h"
-#include "trevent.h" /* tr_runInEventThread() */
+#include "trevent.h" /* tr_runInEventThread () */
 #include "utils.h"
 #include "version.h" /* User-Agent */
 #include "web.h"
@@ -44,15 +44,15 @@ enum
 #if 0
 #define dbgmsg(...) \
     do { \
-        fprintf( stderr, __VA_ARGS__ ); \
-        fprintf( stderr, "\n" ); \
-    } while( 0 )
+        fprintf (stderr, __VA_ARGS__); \
+        fprintf (stderr, "\n"); \
+    } while (0)
 #else
-#define dbgmsg( ... ) \
+#define dbgmsg(...) \
     do { \
-        if( tr_deepLoggingIsActive( ) ) \
-            tr_deepLog( __FILE__, __LINE__, "web", __VA_ARGS__ ); \
-    } while( 0 )
+        if (tr_deepLoggingIsActive ()) \
+            tr_deepLog (__FILE__, __LINE__, "web", __VA_ARGS__); \
+    } while (0)
 #endif
 
 /***
@@ -78,14 +78,14 @@ struct tr_web_task
 };
 
 static void
-task_free( struct tr_web_task * task )
+task_free (struct tr_web_task * task)
 {
-    if( task->freebuf )
-        evbuffer_free( task->freebuf );
-    tr_free( task->cookies );
-    tr_free( task->range );
-    tr_free( task->url );
-    tr_free( task );
+    if (task->freebuf)
+        evbuffer_free (task->freebuf);
+    tr_free (task->cookies);
+    tr_free (task->range);
+    tr_free (task->url);
+    tr_free (task);
 }
 
 /***
@@ -108,30 +108,30 @@ struct tr_web
 ***/
 
 static size_t
-writeFunc( void * ptr, size_t size, size_t nmemb, void * vtask )
+writeFunc (void * ptr, size_t size, size_t nmemb, void * vtask)
 {
     const size_t byteCount = size * nmemb;
     struct tr_web_task * task = vtask;
-    evbuffer_add( task->response, ptr, byteCount );
-    dbgmsg( "wrote %zu bytes to task %p's buffer", byteCount, task );
+    evbuffer_add (task->response, ptr, byteCount);
+    dbgmsg ("wrote %zu bytes to task %p's buffer", byteCount, task);
     return byteCount;
 }
 
 #ifdef USE_LIBCURL_SOCKOPT
 static int
-sockoptfunction( void * vtask, curl_socket_t fd, curlsocktype purpose UNUSED )
+sockoptfunction (void * vtask, curl_socket_t fd, curlsocktype purpose UNUSED)
 {
     struct tr_web_task * task = vtask;
-    const bool isScrape = strstr( task->url, "scrape" ) != NULL;
-    const bool isAnnounce = strstr( task->url, "announce" ) != NULL;
+    const bool isScrape = strstr (task->url, "scrape") != NULL;
+    const bool isAnnounce = strstr (task->url, "announce") != NULL;
 
     /* announce and scrape requests have tiny payloads. */
-    if( isScrape || isAnnounce )
+    if (isScrape || isAnnounce)
     {
         const int sndbuf = 1024;
         const int rcvbuf = isScrape ? 2048 : 3072;
-        setsockopt( fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf) );
-        setsockopt( fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf) );
+        setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof (sndbuf));
+        setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof (rcvbuf));
     }
 
     /* return nonzero if this function encountered an error */
@@ -140,64 +140,64 @@ sockoptfunction( void * vtask, curl_socket_t fd, curlsocktype purpose UNUSED )
 #endif
 
 static long
-getTimeoutFromURL( const struct tr_web_task * task )
+getTimeoutFromURL (const struct tr_web_task * task)
 {
     long timeout;
     const tr_session * session = task->session;
 
-    if( !session || session->isClosed ) timeout = 20L;
-    else if( strstr( task->url, "scrape" ) != NULL ) timeout = 30L;
-    else if( strstr( task->url, "announce" ) != NULL ) timeout = 90L;
+    if (!session || session->isClosed) timeout = 20L;
+    else if (strstr (task->url, "scrape") != NULL) timeout = 30L;
+    else if (strstr (task->url, "announce") != NULL) timeout = 90L;
     else timeout = 240L;
 
     return timeout;
 }
 
 static CURL *
-createEasy( tr_session * s, struct tr_web * web, struct tr_web_task * task )
+createEasy (tr_session * s, struct tr_web * web, struct tr_web_task * task)
 {
     bool is_default_value;
     const tr_address * addr;
-    CURL * e = task->curl_easy = curl_easy_init( );
+    CURL * e = task->curl_easy = curl_easy_init ();
 
-    task->timeout_secs = getTimeoutFromURL( task );
+    task->timeout_secs = getTimeoutFromURL (task);
 
-    curl_easy_setopt( e, CURLOPT_AUTOREFERER, 1L );
-    curl_easy_setopt( e, CURLOPT_COOKIEFILE, web->cookie_filename );
-    curl_easy_setopt( e, CURLOPT_ENCODING, "gzip;q=1.0, deflate, identity" );
-    curl_easy_setopt( e, CURLOPT_FOLLOWLOCATION, 1L );
-    curl_easy_setopt( e, CURLOPT_MAXREDIRS, -1L );
-    curl_easy_setopt( e, CURLOPT_NOSIGNAL, 1L );
-    curl_easy_setopt( e, CURLOPT_PRIVATE, task );
+    curl_easy_setopt (e, CURLOPT_AUTOREFERER, 1L);
+    curl_easy_setopt (e, CURLOPT_COOKIEFILE, web->cookie_filename);
+    curl_easy_setopt (e, CURLOPT_ENCODING, "gzip;q=1.0, deflate, identity");
+    curl_easy_setopt (e, CURLOPT_FOLLOWLOCATION, 1L);
+    curl_easy_setopt (e, CURLOPT_MAXREDIRS, -1L);
+    curl_easy_setopt (e, CURLOPT_NOSIGNAL, 1L);
+    curl_easy_setopt (e, CURLOPT_PRIVATE, task);
 #ifdef USE_LIBCURL_SOCKOPT
-    curl_easy_setopt( e, CURLOPT_SOCKOPTFUNCTION, sockoptfunction );
-    curl_easy_setopt( e, CURLOPT_SOCKOPTDATA, task );
+    curl_easy_setopt (e, CURLOPT_SOCKOPTFUNCTION, sockoptfunction);
+    curl_easy_setopt (e, CURLOPT_SOCKOPTDATA, task);
 #endif
-    if( web->curl_ssl_verify )
-        curl_easy_setopt( e, CURLOPT_CAINFO, web->curl_ca_bundle );
+    if (web->curl_ssl_verify)
+        curl_easy_setopt (e, CURLOPT_CAINFO, web->curl_ca_bundle);
     else {
-        curl_easy_setopt( e, CURLOPT_SSL_VERIFYHOST, 0L );
-        curl_easy_setopt( e, CURLOPT_SSL_VERIFYPEER, 0L );
+        curl_easy_setopt (e, CURLOPT_SSL_VERIFYHOST, 0L);
+        curl_easy_setopt (e, CURLOPT_SSL_VERIFYPEER, 0L);
     }
-    curl_easy_setopt( e, CURLOPT_TIMEOUT, task->timeout_secs );
-    curl_easy_setopt( e, CURLOPT_URL, task->url );
-    curl_easy_setopt( e, CURLOPT_USERAGENT, TR_NAME "/" SHORT_VERSION_STRING );
-    curl_easy_setopt( e, CURLOPT_VERBOSE, (long)(web->curl_verbose?1:0) );
-    curl_easy_setopt( e, CURLOPT_WRITEDATA, task );
-    curl_easy_setopt( e, CURLOPT_WRITEFUNCTION, writeFunc );
-
-    if((( addr = tr_sessionGetPublicAddress( s, TR_AF_INET, &is_default_value ))) && !is_default_value )
-        curl_easy_setopt( e, CURLOPT_INTERFACE, tr_address_to_string( addr ) );
-    else if ((( addr = tr_sessionGetPublicAddress( s, TR_AF_INET6, &is_default_value ))) && !is_default_value )
-        curl_easy_setopt( e, CURLOPT_INTERFACE, tr_address_to_string( addr ) );
-
-    if( task->cookies != NULL )
-        curl_easy_setopt( e, CURLOPT_COOKIE, task->cookies );
-
-    if( task->range != NULL ) {
-        curl_easy_setopt( e, CURLOPT_RANGE, task->range );
+    curl_easy_setopt (e, CURLOPT_TIMEOUT, task->timeout_secs);
+    curl_easy_setopt (e, CURLOPT_URL, task->url);
+    curl_easy_setopt (e, CURLOPT_USERAGENT, TR_NAME "/" SHORT_VERSION_STRING);
+    curl_easy_setopt (e, CURLOPT_VERBOSE, (long)(web->curl_verbose?1:0));
+    curl_easy_setopt (e, CURLOPT_WRITEDATA, task);
+    curl_easy_setopt (e, CURLOPT_WRITEFUNCTION, writeFunc);
+
+    if (((addr = tr_sessionGetPublicAddress (s, TR_AF_INET, &is_default_value))) && !is_default_value)
+        curl_easy_setopt (e, CURLOPT_INTERFACE, tr_address_to_string (addr));
+    else if (((addr = tr_sessionGetPublicAddress (s, TR_AF_INET6, &is_default_value))) && !is_default_value)
+        curl_easy_setopt (e, CURLOPT_INTERFACE, tr_address_to_string (addr));
+
+    if (task->cookies != NULL)
+        curl_easy_setopt (e, CURLOPT_COOKIE, task->cookies);
+
+    if (task->range != NULL) {
+        curl_easy_setopt (e, CURLOPT_RANGE, task->range);
         /* don't bother asking the server to compress webseed fragments */
-        curl_easy_setopt( e, CURLOPT_ENCODING, "identity" );
+        curl_easy_setopt (e, CURLOPT_ENCODING, "identity");
     }
 
     return e;
@@ -208,21 +208,21 @@ createEasy( tr_session * s, struct tr_web * web, struct tr_web_task * task )
 ***/
 
 static void
-task_finish_func( void * vtask )
+task_finish_func (void * vtask)
 {
     struct tr_web_task * task = vtask;
-    dbgmsg( "finished web task %p; got %ld", task, task->code );
+    dbgmsg ("finished web task %p; got %ld", task, task->code);
 
-    if( task->done_func != NULL )
-        task->done_func( task->session,
+    if (task->done_func != NULL)
+        task->done_func (task->session,
                          task->did_connect,
                          task->did_timeout,
                          task->code,
-                         evbuffer_pullup( task->response, -1 ),
-                         evbuffer_get_length( task->response ),
-                         task->done_func_user_data );
+                         evbuffer_pullup (task->response, -1),
+                         evbuffer_get_length (task->response),
+                         task->done_func_user_data);
 
-    task_free( task );
+    task_free (task);
 }
 
 /****
@@ -230,53 +230,53 @@ task_finish_func( void * vtask )
 ****/
 
 struct tr_web_task *
-tr_webRun( tr_session         * session,
+tr_webRun (tr_session         * session,
            const char         * url,
            const char         * range,
            const char         * cookies,
            tr_web_done_func     done_func,
-           void               * done_func_user_data )
+           void               * done_func_user_data)
 {
-    return tr_webRunWithBuffer( session, url, range, cookies,
+    return tr_webRunWithBuffer (session, url, range, cookies,
                                 done_func, done_func_user_data,
-                                NULL );
+                                NULL);
 }
 
 struct tr_web_task *
-tr_webRunWithBuffer( tr_session         * session,
+tr_webRunWithBuffer (tr_session         * session,
                      const char         * url,
                      const char         * range,
                      const char         * cookies,
                      tr_web_done_func     done_func,
                      void               * done_func_user_data,
-                     struct evbuffer    * buffer )
+                     struct evbuffer    * buffer)
 {
     struct tr_web * web = session->web;
 
-    if( web != NULL )
+    if (web != NULL)
     {
-        struct tr_web_task * task = tr_new0( struct tr_web_task, 1 );
+        struct tr_web_task * task = tr_new0 (struct tr_web_task, 1);
 
         task->session = session;
-        task->url = tr_strdup( url );
-        task->range = tr_strdup( range );
-        task->cookies = tr_strdup( cookies);
+        task->url = tr_strdup (url);
+        task->range = tr_strdup (range);
+        task->cookies = tr_strdup (cookies);
         task->done_func = done_func;
         task->done_func_user_data = done_func_user_data;
-        task->response = buffer ? buffer : evbuffer_new( );
+        task->response = buffer ? buffer : evbuffer_new ();
         task->freebuf = buffer ? NULL : task->response;
 
-        tr_lockLock( web->taskLock );
+        tr_lockLock (web->taskLock);
         task->next = web->tasks;
         web->tasks = task;
-        tr_lockUnlock( web->taskLock );
+        tr_lockUnlock (web->taskLock);
         return task;
     }
     return NULL;
 }
 
 /**
- * Portability wrapper for select().
+ * Portability wrapper for select ().
  *
  * http://msdn.microsoft.com/en-us/library/ms740141%28VS.85%29.aspx
  * On win32, any two of the parameters, readfds, writefds, or exceptfds,
@@ -284,32 +284,32 @@ tr_webRunWithBuffer( tr_session         * session,
  * descriptor set must contain at least one handle to a socket.
  */
 static void
-tr_select( int nfds,
+tr_select (int nfds,
            fd_set * r_fd_set, fd_set * w_fd_set, fd_set * c_fd_set,
-           struct timeval  * t )
+           struct timeval  * t)
 {
 #ifdef WIN32
-    if( !r_fd_set->fd_count && !w_fd_set->fd_count && !c_fd_set->fd_count )
+    if (!r_fd_set->fd_count && !w_fd_set->fd_count && !c_fd_set->fd_count)
     {
         const long int msec = t->tv_sec*1000 + t->tv_usec/1000;
-        tr_wait_msec( msec );
+        tr_wait_msec (msec);
     }
-    else if( select( 0, r_fd_set->fd_count ? r_fd_set : NULL,
+    else if (select (0, r_fd_set->fd_count ? r_fd_set : NULL,
                         w_fd_set->fd_count ? w_fd_set : NULL,
-                        c_fd_set->fd_count ? c_fd_set : NULL, t ) < 0 )
+                        c_fd_set->fd_count ? c_fd_set : NULL, t) < 0)
     {
         char errstr[512];
-        const int e = EVUTIL_SOCKET_ERROR( );
-        tr_net_strerror( errstr, sizeof( errstr ), e );
-        dbgmsg( "Error: select (%d) %s", e, errstr );
+        const int e = EVUTIL_SOCKET_ERROR ();
+        tr_net_strerror (errstr, sizeof (errstr), e);
+        dbgmsg ("Error: select (%d) %s", e, errstr);
     }
 #else
-    select( nfds, r_fd_set, w_fd_set, c_fd_set, t );
+    select (nfds, r_fd_set, w_fd_set, c_fd_set, t);
 #endif
 }
 
 static void
-tr_webThreadFunc( void * vsession )
+tr_webThreadFunc (void * vsession)
 {
     CURLM * multi;
     struct tr_web * web;
@@ -319,63 +319,63 @@ tr_webThreadFunc( void * vsession )
 
     /* try to enable ssl for https support; but if that fails,
      * try a plain vanilla init */
-    if( curl_global_init( CURL_GLOBAL_SSL ) )
-        curl_global_init( 0 );
+    if (curl_global_init (CURL_GLOBAL_SSL))
+        curl_global_init (0);
 
-    web = tr_new0( struct tr_web, 1 );
+    web = tr_new0 (struct tr_web, 1);
     web->close_mode = ~0;
-    web->taskLock = tr_lockNew( );
+    web->taskLock = tr_lockNew ();
     web->tasks = NULL;
-    web->curl_verbose = getenv( "TR_CURL_VERBOSE" ) != NULL;
-    web->curl_ssl_verify = getenv( "TR_CURL_SSL_VERIFY" ) != NULL;
-    web->curl_ca_bundle = getenv( "CURL_CA_BUNDLE" );
-    if( web->curl_ssl_verify ) {
-        tr_ninf( "web", "will verify tracker certs using envvar CURL_CA_BUNDLE: %s",
-                  web->curl_ca_bundle == NULL ? "none" : web->curl_ca_bundle );
-        tr_ninf( "web", "NB: this only works if you built against libcurl with openssl or gnutls, NOT nss" );
-        tr_ninf( "web", "NB: invalid certs will show up as 'Could not connect to tracker' like many other errors" );
+    web->curl_verbose = getenv ("TR_CURL_VERBOSE") != NULL;
+    web->curl_ssl_verify = getenv ("TR_CURL_SSL_VERIFY") != NULL;
+    web->curl_ca_bundle = getenv ("CURL_CA_BUNDLE");
+    if (web->curl_ssl_verify) {
+        tr_ninf ("web", "will verify tracker certs using envvar CURL_CA_BUNDLE: %s",
+                  web->curl_ca_bundle == NULL ? "none" : web->curl_ca_bundle);
+        tr_ninf ("web", "NB: this only works if you built against libcurl with openssl or gnutls, NOT nss");
+        tr_ninf ("web", "NB: invalid certs will show up as 'Could not connect to tracker' like many other errors");
     }
-    web->cookie_filename = tr_buildPath( session->configDir, "cookies.txt", NULL );
+    web->cookie_filename = tr_buildPath (session->configDir, "cookies.txt", NULL);
 
-    multi = curl_multi_init( );
+    multi = curl_multi_init ();
     session->web = web;
 
-    for( ;; )
+    for (;;)
     {
         long msec;
         int unused;
         CURLMsg * msg;
         CURLMcode mcode;
 
-        if( web->close_mode == TR_WEB_CLOSE_NOW )
+        if (web->close_mode == TR_WEB_CLOSE_NOW)
             break;
-        if( ( web->close_mode == TR_WEB_CLOSE_WHEN_IDLE ) && ( web->tasks == NULL ) )
+        if ((web->close_mode == TR_WEB_CLOSE_WHEN_IDLE) && (web->tasks == NULL))
             break;
 
         /* add tasks from the queue */
-        tr_lockLock( web->taskLock );
-        while( web->tasks != NULL )
+        tr_lockLock (web->taskLock);
+        while (web->tasks != NULL)
         {
             /* pop the task */
             task = web->tasks;
             web->tasks = task->next;
             task->next = NULL;
 
-            dbgmsg( "adding task to curl: [%s]", task->url );
-            curl_multi_add_handle( multi, createEasy( session, web, task ));
-            /*fprintf( stderr, "adding a task.. taskCount is now %d\n", taskCount );*/
+            dbgmsg ("adding task to curl: [%s]", task->url);
+            curl_multi_add_handle (multi, createEasy (session, web, task));
+            /*fprintf (stderr, "adding a task.. taskCount is now %d\n", taskCount);*/
             ++taskCount;
         }
-        tr_lockUnlock( web->taskLock );
+        tr_lockUnlock (web->taskLock);
 
-        /* maybe wait a little while before calling curl_multi_perform() */
+        /* maybe wait a little while before calling curl_multi_perform () */
         msec = 0;
-        curl_multi_timeout( multi, &msec );
-        if( msec < 0 )
+        curl_multi_timeout (multi, &msec);
+        if (msec < 0)
             msec = THREADFUNC_MAX_SLEEP_MSEC;
-        if( session->isClosed )
-            msec = 100; /* on shutdown, call perform() more frequently */
-        if( msec > 0 )
+        if (session->isClosed)
+            msec = 100; /* on shutdown, call perform () more frequently */
+        if (msec > 0)
         {
             int usec;
             int max_fd;
@@ -383,44 +383,44 @@ tr_webThreadFunc( void * vsession )
             fd_set r_fd_set, w_fd_set, c_fd_set;
 
             max_fd = 0;
-            FD_ZERO( &r_fd_set );
-            FD_ZERO( &w_fd_set );
-            FD_ZERO( &c_fd_set );
-            curl_multi_fdset( multi, &r_fd_set, &w_fd_set, &c_fd_set, &max_fd );
+            FD_ZERO (&r_fd_set);
+            FD_ZERO (&w_fd_set);
+            FD_ZERO (&c_fd_set);
+            curl_multi_fdset (multi, &r_fd_set, &w_fd_set, &c_fd_set, &max_fd);
 
-            if( msec > THREADFUNC_MAX_SLEEP_MSEC )
+            if (msec > THREADFUNC_MAX_SLEEP_MSEC)
                 msec = THREADFUNC_MAX_SLEEP_MSEC;
 
             usec = msec * 1000;
             t.tv_sec =  usec / 1000000;
             t.tv_usec = usec % 1000000;
-            tr_select( max_fd+1, &r_fd_set, &w_fd_set, &c_fd_set, &t );
+            tr_select (max_fd+1, &r_fd_set, &w_fd_set, &c_fd_set, &t);
         }
 
-        /* call curl_multi_perform() */
+        /* call curl_multi_perform () */
         do {
-            mcode = curl_multi_perform( multi, &unused );
-        } while( mcode == CURLM_CALL_MULTI_PERFORM );
+            mcode = curl_multi_perform (multi, &unused);
+        } while (mcode == CURLM_CALL_MULTI_PERFORM);
 
         /* pump completed tasks from the multi */
-        while(( msg = curl_multi_info_read( multi, &unused )))
+        while ((msg = curl_multi_info_read (multi, &unused)))
         {
-            if(( msg->msg == CURLMSG_DONE ) && ( msg->easy_handle != NULL ))
+            if ((msg->msg == CURLMSG_DONE) && (msg->easy_handle != NULL))
             {
                 double total_time;
                 struct tr_web_task * task;
                 long req_bytes_sent;
                 CURL * e = msg->easy_handle;
-                curl_easy_getinfo( e, CURLINFO_PRIVATE, (void*)&task );
-                curl_easy_getinfo( e, CURLINFO_RESPONSE_CODE, &task->code );
-                curl_easy_getinfo( e, CURLINFO_REQUEST_SIZE, &req_bytes_sent );
-                curl_easy_getinfo( e, CURLINFO_TOTAL_TIME, &total_time );
+                curl_easy_getinfo (e, CURLINFO_PRIVATE, (void*)&task);
+                curl_easy_getinfo (e, CURLINFO_RESPONSE_CODE, &task->code);
+                curl_easy_getinfo (e, CURLINFO_REQUEST_SIZE, &req_bytes_sent);
+                curl_easy_getinfo (e, CURLINFO_TOTAL_TIME, &total_time);
                 task->did_connect = task->code>0 || req_bytes_sent>0;
-                task->did_timeout = !task->code && ( total_time >= task->timeout_secs );
-                curl_multi_remove_handle( multi, e );
-                curl_easy_cleanup( e );
-/*fprintf( stderr, "removing a completed task.. taskCount is now %d (response code: %d, response len: %d)\n", taskCount, (int)task->code, (int)evbuffer_get_length(task->response) );*/
-                tr_runInEventThread( task->session, task_finish_func, task );
+                task->did_timeout = !task->code && (total_time >= task->timeout_secs);
+                curl_multi_remove_handle (multi, e);
+                curl_easy_cleanup (e);
+/*fprintf (stderr, "removing a completed task.. taskCount is now %d (response code: %d, response len: %d)\n", taskCount, (int)task->code, (int)evbuffer_get_length (task->response));*/
+                tr_runInEventThread (task->session, task_finish_func, task);
                 --taskCount;
             }
         }
@@ -428,44 +428,44 @@ tr_webThreadFunc( void * vsession )
 
     /* Discard any remaining tasks.
      * This is rare, but can happen on shutdown with unresponsive trackers. */
-    while( web->tasks != NULL ) {
+    while (web->tasks != NULL) {
         task = web->tasks;
         web->tasks = task->next;
-        dbgmsg( "Discarding task \"%s\"", task->url );
-        task_free( task );
+        dbgmsg ("Discarding task \"%s\"", task->url);
+        task_free (task);
     }
 
     /* cleanup */
-    curl_multi_cleanup( multi );
-    tr_lockFree( web->taskLock );
-    tr_free( web->cookie_filename );
-    tr_free( web );
+    curl_multi_cleanup (multi);
+    tr_lockFree (web->taskLock);
+    tr_free (web->cookie_filename);
+    tr_free (web);
     session->web = NULL;
 }
 
 void
-tr_webInit( tr_session * session )
+tr_webInit (tr_session * session)
 {
-    tr_threadNew( tr_webThreadFunc, session );
+    tr_threadNew (tr_webThreadFunc, session);
 }
 
 void
-tr_webClose( tr_session * session, tr_web_close_mode close_mode )
+tr_webClose (tr_session * session, tr_web_close_mode close_mode)
 {
-    if( session->web != NULL )
+    if (session->web != NULL)
     {
         session->web->close_mode = close_mode;
 
-        if( close_mode == TR_WEB_CLOSE_NOW )
-            while( session->web != NULL )
-                tr_wait_msec( 100 );
+        if (close_mode == TR_WEB_CLOSE_NOW)
+            while (session->web != NULL)
+                tr_wait_msec (100);
     }
 }
 
 void
-tr_webGetTaskInfo( struct tr_web_task * task, tr_web_task_info info, void * dst )
+tr_webGetTaskInfo (struct tr_web_task * task, tr_web_task_info info, void * dst)
 {
-    curl_easy_getinfo( task->curl_easy, (CURLINFO) info, dst );
+    curl_easy_getinfo (task->curl_easy, (CURLINFO) info, dst);
 }
 
 /*****
@@ -474,9 +474,9 @@ tr_webGetTaskInfo( struct tr_web_task * task, tr_web_task_info info, void * dst
 *****/
 
 const char *
-tr_webGetResponseStr( long code )
+tr_webGetResponseStr (long code)
 {
-    switch( code )
+    switch (code)
     {
         case   0: return "No Response";
         case 101: return "Switching Protocols";
@@ -493,7 +493,7 @@ tr_webGetResponseStr( long code )
         case 303: return "See Other";
         case 304: return "Not Modified";
         case 305: return "Use Proxy";
-        case 306: return "(Unused)";
+        case 306: return " (Unused)";
         case 307: return "Temporary Redirect";
         case 400: return "Bad Request";
         case 401: return "Unauthorized";
@@ -524,43 +524,43 @@ tr_webGetResponseStr( long code )
 }
 
 void
-tr_http_escape( struct evbuffer  * out,
-                const char * str, int len, bool escape_slashes )
+tr_http_escape (struct evbuffer  * out,
+                const char * str, int len, bool escape_slashes)
 {
     const char * end;
 
-    if( ( len < 0 ) && ( str != NULL ) )
-        len = strlen( str );
-
-    for( end=str+len; str && str!=end; ++str ) {
-        if(    ( *str == ',' )
-            || ( *str == '-' )
-            || ( *str == '.' )
-            || ( ( '0' <= *str ) && ( *str <= '9' ) )
-            || ( ( 'A' <= *str ) && ( *str <= 'Z' ) )
-            || ( ( 'a' <= *str ) && ( *str <= 'z' ) )
-            || ( ( *str == '/' ) && ( !escape_slashes ) ) )
-            evbuffer_add_printf( out, "%c", *str );
+    if ((len < 0) && (str != NULL))
+        len = strlen (str);
+
+    for (end=str+len; str && str!=end; ++str) {
+        if ((*str == ',')
+            || (*str == '-')
+            || (*str == '.')
+            || (('0' <= *str) && (*str <= '9'))
+            || (('A' <= *str) && (*str <= 'Z'))
+            || (('a' <= *str) && (*str <= 'z'))
+            || ((*str == '/') && (!escape_slashes)))
+            evbuffer_add_printf (out, "%c", *str);
         else
-            evbuffer_add_printf( out, "%%%02X", (unsigned)(*str&0xFF) );
+            evbuffer_add_printf (out, "%%%02X", (unsigned)(*str&0xFF));
     }
 }
 
 char *
-tr_http_unescape( const char * str, int len )
+tr_http_unescape (const char * str, int len)
 {
-    char * tmp = curl_unescape( str, len );
-    char * ret = tr_strdup( tmp );
-    curl_free( tmp );
+    char * tmp = curl_unescape (str, len);
+    char * ret = tr_strdup (tmp);
+    curl_free (tmp);
     return ret;
 }
 
 static int
-is_rfc2396_alnum( uint8_t ch )
+is_rfc2396_alnum (uint8_t ch)
 {
-    return ( '0' <= ch && ch <= '9' )
-        || ( 'A' <= ch && ch <= 'Z' )
-        || ( 'a' <= ch && ch <= 'z' )
+    return ('0' <= ch && ch <= '9')
+        || ('A' <= ch && ch <= 'Z')
+        || ('a' <= ch && ch <= 'z')
         || ch == '.'
         || ch == '-'
         || ch == '_'
@@ -568,16 +568,16 @@ is_rfc2396_alnum( uint8_t ch )
 }
 
 void
-tr_http_escape_sha1( char * out, const uint8_t * sha1_digest )
+tr_http_escape_sha1 (char * out, const uint8_t * sha1_digest)
 {
     const uint8_t * in = sha1_digest;
     const uint8_t * end = in + SHA_DIGEST_LENGTH;
 
-    while( in != end )
-        if( is_rfc2396_alnum( *in ) )
+    while (in != end)
+        if (is_rfc2396_alnum (*in))
             *out++ = (char) *in++;
         else
-            out += tr_snprintf( out, 4, "%%%02x", (unsigned int)*in++ );
+            out += tr_snprintf (out, 4, "%%%02x", (unsigned int)*in++);
 
     *out = '\0';
 }
diff --git a/libtransmission/web.h b/libtransmission/web.h
index bd8e3e19e..9d1d8288d 100644
--- a/libtransmission/web.h
+++ b/libtransmission/web.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -30,7 +30,7 @@ typedef enum
 }
 tr_web_task_info;
 
-void tr_webInit( tr_session * session );
+void tr_webInit (tr_session * session);
 
 typedef enum
 {
@@ -39,42 +39,42 @@ typedef enum
 }
 tr_web_close_mode;
 
-void tr_webClose( tr_session * session, tr_web_close_mode close_mode );
+void tr_webClose (tr_session * session, tr_web_close_mode close_mode);
 
-typedef void ( tr_web_done_func )( tr_session       * session,
+typedef void (tr_web_done_func)(tr_session       * session,
                                    bool               timeout_flag,
                                    bool               did_connect_flag,
                                    long               response_code,
                                    const void       * response,
                                    size_t             response_byte_count,
-                                   void             * user_data );
+                                   void             * user_data);
 
-const char * tr_webGetResponseStr( long response_code );
+const char * tr_webGetResponseStr (long response_code);
 
-struct tr_web_task * tr_webRun( tr_session        * session,
+struct tr_web_task * tr_webRun (tr_session        * session,
                                 const char        * url,
                                 const char        * range,
                                 const char        * cookies,
                                 tr_web_done_func    done_func,
-                                void              * done_func_user_data );
+                                void              * done_func_user_data);
 
 struct evbuffer;
 
-struct tr_web_task * tr_webRunWithBuffer( tr_session         * session,
+struct tr_web_task * tr_webRunWithBuffer (tr_session         * session,
                                           const char         * url,
                                           const char         * range,
                                           const char         * cookies,
                                           tr_web_done_func     done_func,
                                           void               * done_func_user_data,
-                                          struct evbuffer    * buffer );
+                                          struct evbuffer    * buffer);
 
-void tr_webGetTaskInfo( struct tr_web_task * task, tr_web_task_info info, void * dst );
+void tr_webGetTaskInfo (struct tr_web_task * task, tr_web_task_info info, void * dst);
 
-void tr_http_escape( struct evbuffer *out, const char *str, int len, bool escape_slashes );
+void tr_http_escape (struct evbuffer *out, const char *str, int len, bool escape_slashes);
 
-void tr_http_escape_sha1( char * out, const uint8_t * sha1_digest );
+void tr_http_escape_sha1 (char * out, const uint8_t * sha1_digest);
 
-char* tr_http_unescape( const char * str, int len );
+char* tr_http_unescape (const char * str, int len);
 
 #ifdef __cplusplus
 }
diff --git a/libtransmission/webseed.c b/libtransmission/webseed.c
index 82c2474a4..a246a6e51 100644
--- a/libtransmission/webseed.c
+++ b/libtransmission/webseed.c
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -10,7 +10,7 @@
  * $Id$
  */
 
-#include <string.h> /* strlen() */
+#include <string.h> /* strlen () */
 
 #include <event2/buffer.h>
 #include <event2/event.h>
@@ -18,11 +18,11 @@
 #include "transmission.h"
 #include "bandwidth.h"
 #include "cache.h"
-#include "inout.h" /* tr_ioFindFileLocation() */
+#include "inout.h" /* tr_ioFindFileLocation () */
 #include "list.h"
 #include "peer-mgr.h"
 #include "torrent.h"
-#include "trevent.h" /* tr_runInEventThread() */
+#include "trevent.h" /* tr_runInEventThread () */
 #include "utils.h"
 #include "web.h"
 #include "webseed.h"
@@ -74,28 +74,28 @@ enum
 };
 
 static void
-webseed_free( struct tr_webseed * w )
+webseed_free (struct tr_webseed * w)
 {
-    tr_torrent * tor = tr_torrentFindFromId( w->session, w->torrent_id );
-    const tr_info * inf = tr_torrentInfo( tor );
+    tr_torrent * tor = tr_torrentFindFromId (w->session, w->torrent_id);
+    const tr_info * inf = tr_torrentInfo (tor);
     tr_file_index_t i;
 
     /* if we have an array of file URLs, free it */
-    if( w->file_urls != NULL ) {
-        for( i=0; i<inf->fileCount; ++i )
-            tr_free( w->file_urls[i] );
-        tr_free( w->file_urls );
+    if (w->file_urls != NULL) {
+        for (i=0; i<inf->fileCount; ++i)
+            tr_free (w->file_urls[i]);
+        tr_free (w->file_urls);
     }
 
     /* webseed destruct */
-    event_free( w->timer );
-    tr_bandwidthDestruct( &w->bandwidth );
-    tr_free( w->base_url );
+    event_free (w->timer);
+    tr_bandwidthDestruct (&w->bandwidth);
+    tr_free (w->base_url);
 
     /* parent class destruct */
-    tr_peerDestruct( tor, &w->parent );
+    tr_peerDestruct (tor, &w->parent);
 
-    tr_free( w );
+    tr_free (w);
 }
 
 /***
@@ -103,52 +103,52 @@ webseed_free( struct tr_webseed * w )
 ***/
 
 static void
-publish( tr_webseed * w, tr_peer_event * e )
+publish (tr_webseed * w, tr_peer_event * e)
 {
-    if( w->callback != NULL )
-        w->callback( &w->parent, e, w->callback_data );
+    if (w->callback != NULL)
+        w->callback (&w->parent, e, w->callback_data);
 }
 
 static void
-fire_client_got_rejs( tr_torrent * tor, tr_webseed * w,
-                      tr_block_index_t block, tr_block_index_t count )
+fire_client_got_rejs (tr_torrent * tor, tr_webseed * w,
+                      tr_block_index_t block, tr_block_index_t count)
 {
     tr_block_index_t i;
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_REJ;
-    tr_torrentGetBlockLocation( tor, block, &e.pieceIndex, &e.offset, &e.length );
-    for( i = 1; i <= count; i++ ) {
-        if( i == count )
-            e.length = tr_torBlockCountBytes( tor, block + count - 1 );
-        publish( w, &e );
+    tr_torrentGetBlockLocation (tor, block, &e.pieceIndex, &e.offset, &e.length);
+    for (i = 1; i <= count; i++) {
+        if (i == count)
+            e.length = tr_torBlockCountBytes (tor, block + count - 1);
+        publish (w, &e);
         e.offset += e.length;
     }
 }
 
 static void
-fire_client_got_blocks( tr_torrent * tor, tr_webseed * w,
-                        tr_block_index_t block, tr_block_index_t count )
+fire_client_got_blocks (tr_torrent * tor, tr_webseed * w,
+                        tr_block_index_t block, tr_block_index_t count)
 {
     tr_block_index_t i;
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_BLOCK;
-    tr_torrentGetBlockLocation( tor, block, &e.pieceIndex, &e.offset, &e.length );
-    for( i = 1; i <= count; i++ ) {
-        if( i == count )
-            e.length = tr_torBlockCountBytes( tor, block + count - 1 );
-        publish( w, &e );
+    tr_torrentGetBlockLocation (tor, block, &e.pieceIndex, &e.offset, &e.length);
+    for (i = 1; i <= count; i++) {
+        if (i == count)
+            e.length = tr_torBlockCountBytes (tor, block + count - 1);
+        publish (w, &e);
         e.offset += e.length;
     }
 }
 
 static void
-fire_client_got_data( tr_webseed * w, uint32_t length )
+fire_client_got_data (tr_webseed * w, uint32_t length)
 {
     tr_peer_event e = TR_PEER_EVENT_INIT;
     e.eventType = TR_PEER_CLIENT_GOT_DATA;
     e.length = length;
     e.wasPieceData = true;
-    publish( w, &e );
+    publish (w, &e);
 }
 
 /***
@@ -166,34 +166,34 @@ struct write_block_data
 };
 
 static void
-write_block_func( void * vdata )
+write_block_func (void * vdata)
 {
     struct write_block_data * data = vdata;
     struct tr_webseed * w = data->webseed;
     struct evbuffer * buf = data->content;
     struct tr_torrent * tor;
 
-    tor = tr_torrentFindFromId( w->session, w->torrent_id );
-    if( tor )
+    tor = tr_torrentFindFromId (w->session, w->torrent_id);
+    if (tor)
     {
         const uint32_t block_size = tor->blockSize;
-        uint32_t len = evbuffer_get_length( buf );
+        uint32_t len = evbuffer_get_length (buf);
         const uint32_t offset_end = data->block_offset + len;
         tr_cache * cache = w->session->cache;
         const tr_piece_index_t piece = data->piece_index;
 
-        while( len > 0 )
+        while (len > 0)
         {
-            const uint32_t bytes_this_pass = MIN( len, block_size );
-            tr_cacheWriteBlock( cache, tor, piece, offset_end - len, bytes_this_pass, buf );
+            const uint32_t bytes_this_pass = MIN (len, block_size);
+            tr_cacheWriteBlock (cache, tor, piece, offset_end - len, bytes_this_pass, buf);
             len -= bytes_this_pass;
         }
 
-        fire_client_got_blocks( tor, w, data->block_index, data->count );
+        fire_client_got_blocks (tor, w, data->block_index, data->count);
     }
 
-    evbuffer_free( buf );
-    tr_free( data );
+    evbuffer_free (buf);
+    tr_free (data);
 }
 
 /***
@@ -209,25 +209,25 @@ struct connection_succeeded_data
 };
 
 static void
-connection_succeeded( void * vdata )
+connection_succeeded (void * vdata)
 {
     tr_torrent * tor;
     struct connection_succeeded_data * data = vdata;
     struct tr_webseed * w = data->webseed;
 
-    if( ++w->active_transfers >= w->retry_challenge && w->retry_challenge )
+    if (++w->active_transfers >= w->retry_challenge && w->retry_challenge)
         /* the server seems to be accepting more connections now */
         w->consecutive_failures = w->retry_tickcount = w->retry_challenge = 0;
 
-    if( data->real_url &&
-        (tor = tr_torrentFindFromId( w->session, w->torrent_id )))
+    if (data->real_url &&
+      (tor = tr_torrentFindFromId (w->session, w->torrent_id)))
     {
         uint64_t file_offset;
         tr_file_index_t file_index;
 
-        tr_ioFindFileLocation( tor, data->piece_index, data->piece_offset,
-                               &file_index, &file_offset );
-        tr_free( w->file_urls[file_index] );
+        tr_ioFindFileLocation (tor, data->piece_index, data->piece_offset,
+                               &file_index, &file_offset);
+        tr_free (w->file_urls[file_index]);
         w->file_urls[file_index] = data->real_url;
     }
 }
@@ -237,41 +237,41 @@ connection_succeeded( void * vdata )
 ***/
 
 static void
-on_content_changed( struct evbuffer                * buf,
+on_content_changed (struct evbuffer                * buf,
                     const struct evbuffer_cb_info  * info,
-                    void                           * vtask )
+                    void                           * vtask)
 {
     uint32_t len;
     const size_t n_added = info->n_added;
     struct tr_webseed_task * task = vtask;
     struct tr_webseed * w = task->webseed;
 
-    if( n_added <= 0 )
+    if (n_added <= 0)
         return;
 
-    if( !w->is_stopping )
+    if (!w->is_stopping)
     {
-        tr_bandwidthUsed( &w->bandwidth, TR_DOWN, n_added, true, tr_time_msec( ) );
-        fire_client_got_data( w, n_added );
+        tr_bandwidthUsed (&w->bandwidth, TR_DOWN, n_added, true, tr_time_msec ());
+        fire_client_got_data (w, n_added);
     }
 
-    len = evbuffer_get_length( buf );
+    len = evbuffer_get_length (buf);
 
-    if( !task->response_code )
+    if (!task->response_code)
     {
-        tr_webGetTaskInfo( task->web_task, TR_WEB_GET_CODE, &task->response_code );
+        tr_webGetTaskInfo (task->web_task, TR_WEB_GET_CODE, &task->response_code);
 
-        if( task->response_code == 206 )
+        if (task->response_code == 206)
         {
             const char * url;
             struct connection_succeeded_data * data;
 
             url = NULL;
-            tr_webGetTaskInfo( task->web_task, TR_WEB_GET_REAL_URL, &url );
+            tr_webGetTaskInfo (task->web_task, TR_WEB_GET_REAL_URL, &url);
 
-            data = tr_new( struct connection_succeeded_data, 1 );
+            data = tr_new (struct connection_succeeded_data, 1);
             data->webseed = w;
-            data->real_url = tr_strdup( url );
+            data->real_url = tr_strdup (url);
             data->piece_index = task->piece_index;
             data->piece_offset = task->piece_offset
                                + (task->blocks_done * task->block_size)
@@ -279,11 +279,11 @@ on_content_changed( struct evbuffer                * buf,
 
             /* processing this uses a tr_torrent pointer,
                so push the work to the libevent thread... */
-            tr_runInEventThread( w->session, connection_succeeded, data );
+            tr_runInEventThread (w->session, connection_succeeded, data);
         }
     }
 
-    if( ( task->response_code == 206 ) && ( len >= task->block_size ) )
+    if ((task->response_code == 206) && (len >= task->block_size))
     {
         /* once we've got at least one full block, save it */
 
@@ -291,43 +291,43 @@ on_content_changed( struct evbuffer                * buf,
         const uint32_t block_size = task->block_size;
         const tr_block_index_t completed = len / block_size;
 
-        data = tr_new( struct write_block_data, 1 );
+        data = tr_new (struct write_block_data, 1);
         data->webseed = task->webseed;
         data->piece_index = task->piece_index;
         data->block_index = task->block + task->blocks_done;
         data->count = completed;
         data->block_offset = task->piece_offset + task->blocks_done * block_size;
-        data->content = evbuffer_new( );
+        data->content = evbuffer_new ();
 
         /* we don't use locking on this evbuffer so we must copy out the data
         that will be needed when writing the block in a different thread */
-        evbuffer_remove_buffer( task->content, data->content,
-                                block_size * completed );
+        evbuffer_remove_buffer (task->content, data->content,
+                                block_size * completed);
 
-        tr_runInEventThread( w->session, write_block_func, data );
+        tr_runInEventThread (w->session, write_block_func, data);
         task->blocks_done += completed;
     }
 }
 
-static void task_request_next_chunk( struct tr_webseed_task * task );
+static void task_request_next_chunk (struct tr_webseed_task * task);
 
 static bool
-webseed_has_tasks( const tr_webseed * w )
+webseed_has_tasks (const tr_webseed * w)
 {
     return w->tasks != NULL;
 }
 
 
 static void
-on_idle( tr_webseed * w )
+on_idle (tr_webseed * w)
 {
-    tr_torrent * tor = tr_torrentFindFromId( w->session, w->torrent_id );
-    int want, running_tasks = tr_list_size( w->tasks );
+    tr_torrent * tor = tr_torrentFindFromId (w->session, w->torrent_id);
+    int want, running_tasks = tr_list_size (w->tasks);
 
-    if( w->consecutive_failures >= MAX_CONSECUTIVE_FAILURES ) {
+    if (w->consecutive_failures >= MAX_CONSECUTIVE_FAILURES) {
         want = w->idle_connections;
 
-        if( w->retry_tickcount >= FAILURE_RETRY_INTERVAL ) {
+        if (w->retry_tickcount >= FAILURE_RETRY_INTERVAL) {
             /* some time has passed since our connection attempts failed. try again */
             ++want;
             /* if this challenge is fulfilled we will reset consecutive_failures */
@@ -339,196 +339,196 @@ on_idle( tr_webseed * w )
         w->retry_challenge = running_tasks + w->idle_connections + 1;
     }
 
-    if( w->is_stopping && !webseed_has_tasks( w ) )
+    if (w->is_stopping && !webseed_has_tasks (w))
     {
-        webseed_free( w );
+        webseed_free (w);
     }
-    else if( !w->is_stopping && tor
+    else if (!w->is_stopping && tor
                              && tor->isRunning
-                             && !tr_torrentIsSeed( tor )
-                             && want )
+                             && !tr_torrentIsSeed (tor)
+                             && want)
     {
         int i;
         int got = 0;
         tr_block_index_t * blocks = NULL;
 
-        blocks = tr_new( tr_block_index_t, want*2 );
-        tr_peerMgrGetNextRequests( tor, &w->parent, want, blocks, &got, true );
+        blocks = tr_new (tr_block_index_t, want*2);
+        tr_peerMgrGetNextRequests (tor, &w->parent, want, blocks, &got, true);
 
-        w->idle_connections -= MIN( w->idle_connections, got );
-        if( w->retry_tickcount >= FAILURE_RETRY_INTERVAL && got == want )
+        w->idle_connections -= MIN (w->idle_connections, got);
+        if (w->retry_tickcount >= FAILURE_RETRY_INTERVAL && got == want)
             w->retry_tickcount = 0;
 
-        for( i=0; i<got; ++i )
+        for (i=0; i<got; ++i)
         {
             const tr_block_index_t b = blocks[i*2];
             const tr_block_index_t be = blocks[i*2+1];
-            struct tr_webseed_task * task = tr_new( struct tr_webseed_task, 1 );
+            struct tr_webseed_task * task = tr_new (struct tr_webseed_task, 1);
             task->webseed = w;
             task->block = b;
-            task->piece_index = tr_torBlockPiece( tor, b );
-            task->piece_offset = ( tor->blockSize * b )
-                                - ( tor->info.pieceSize * task->piece_index );
-            task->length = (be - b) * tor->blockSize + tr_torBlockCountBytes( tor, be );
+            task->piece_index = tr_torBlockPiece (tor, b);
+            task->piece_offset = (tor->blockSize * b)
+                                - (tor->info.pieceSize * task->piece_index);
+            task->length = (be - b) * tor->blockSize + tr_torBlockCountBytes (tor, be);
             task->blocks_done = 0;
             task->response_code = 0;
             task->block_size = tor->blockSize;
-            task->content = evbuffer_new( );
-            evbuffer_add_cb( task->content, on_content_changed, task );
-            tr_list_append( &w->tasks, task );
-            task_request_next_chunk( task );
+            task->content = evbuffer_new ();
+            evbuffer_add_cb (task->content, on_content_changed, task);
+            tr_list_append (&w->tasks, task);
+            task_request_next_chunk (task);
         }
 
-        tr_free( blocks );
+        tr_free (blocks);
     }
 }
 
 
 static void
-web_response_func( tr_session    * session,
+web_response_func (tr_session    * session,
                    bool            did_connect UNUSED,
                    bool            did_timeout UNUSED,
                    long            response_code,
                    const void    * response UNUSED,
                    size_t          response_byte_count UNUSED,
-                   void          * vtask )
+                   void          * vtask)
 {
     struct tr_webseed_task * t = vtask;
     tr_webseed * w = t->webseed;
-    tr_torrent * tor = tr_torrentFindFromId( session, w->torrent_id );
-    const int success = ( response_code == 206 );
+    tr_torrent * tor = tr_torrentFindFromId (session, w->torrent_id);
+    const int success = (response_code == 206);
 
-    if( tor )
+    if (tor)
     {
         /* active_transfers was only increased if the connection was successful */
-        if( t->response_code == 206 )
+        if (t->response_code == 206)
             --w->active_transfers;
 
-        if( !success )
+        if (!success)
         {
             const tr_block_index_t blocks_remain = (t->length + tor->blockSize - 1)
                                                    / tor->blockSize - t->blocks_done;
 
-            if( blocks_remain )
-                fire_client_got_rejs( tor, w, t->block + t->blocks_done, blocks_remain );
+            if (blocks_remain)
+                fire_client_got_rejs (tor, w, t->block + t->blocks_done, blocks_remain);
 
-            if( t->blocks_done )
+            if (t->blocks_done)
                 ++w->idle_connections;
-            else if( ++w->consecutive_failures >= MAX_CONSECUTIVE_FAILURES && !w->retry_tickcount )
+            else if (++w->consecutive_failures >= MAX_CONSECUTIVE_FAILURES && !w->retry_tickcount)
                 /* now wait a while until retrying to establish a connection */
                 ++w->retry_tickcount;
 
-            tr_list_remove_data( &w->tasks, t );
-            evbuffer_free( t->content );
-            tr_free( t );
+            tr_list_remove_data (&w->tasks, t);
+            evbuffer_free (t->content);
+            tr_free (t);
         }
         else
         {
             const uint32_t bytes_done = t->blocks_done * tor->blockSize;
-            const uint32_t buf_len = evbuffer_get_length( t->content );
+            const uint32_t buf_len = evbuffer_get_length (t->content);
 
-            if( bytes_done + buf_len < t->length )
+            if (bytes_done + buf_len < t->length)
             {
                 /* request finished successfully but there's still data missing. that
                 means we've reached the end of a file and need to request the next one */
                 t->response_code = 0;
-                task_request_next_chunk( t );
+                task_request_next_chunk (t);
             }
             else
             {
-                if( buf_len ) {
-                    /* on_content_changed() will not write a block if it is smaller than
+                if (buf_len) {
+                    /* on_content_changed () will not write a block if it is smaller than
                     the torrent's block size, i.e. the torrent's very last block */
-                    tr_cacheWriteBlock( session->cache, tor,
+                    tr_cacheWriteBlock (session->cache, tor,
                                         t->piece_index, t->piece_offset + bytes_done,
-                                        buf_len, t->content );
+                                        buf_len, t->content);
 
-                    fire_client_got_blocks( tor, t->webseed,
-                                            t->block + t->blocks_done, 1 );
+                    fire_client_got_blocks (tor, t->webseed,
+                                            t->block + t->blocks_done, 1);
                 }
 
                 ++w->idle_connections;
 
-                tr_list_remove_data( &w->tasks, t );
-                evbuffer_free( t->content );
-                tr_free( t );
+                tr_list_remove_data (&w->tasks, t);
+                evbuffer_free (t->content);
+                tr_free (t);
 
-                on_idle( w );
+                on_idle (w);
             }
         }
     }
 }
 
 static struct evbuffer *
-make_url( tr_webseed * w, const tr_file * file )
+make_url (tr_webseed * w, const tr_file * file)
 {
-    struct evbuffer * buf = evbuffer_new( );
+    struct evbuffer * buf = evbuffer_new ();
 
-    evbuffer_add( buf, w->base_url, w->base_url_len );
+    evbuffer_add (buf, w->base_url, w->base_url_len);
 
     /* if url ends with a '/', add the torrent name */
-    if( w->base_url[w->base_url_len - 1] == '/' && file->name )
-        tr_http_escape( buf, file->name, strlen(file->name), false );
+    if (w->base_url[w->base_url_len - 1] == '/' && file->name)
+        tr_http_escape (buf, file->name, strlen (file->name), false);
 
     return buf;
 }
 
 static void
-task_request_next_chunk( struct tr_webseed_task * t )
+task_request_next_chunk (struct tr_webseed_task * t)
 {
     tr_webseed * w = t->webseed;
-    tr_torrent * tor = tr_torrentFindFromId( w->session, w->torrent_id );
-    if( tor != NULL )
+    tr_torrent * tor = tr_torrentFindFromId (w->session, w->torrent_id);
+    if (tor != NULL)
     {
         char range[64];
         char ** urls = t->webseed->file_urls;
 
-        const tr_info * inf = tr_torrentInfo( tor );
+        const tr_info * inf = tr_torrentInfo (tor);
         const uint64_t remain = t->length - t->blocks_done * tor->blockSize
-                                - evbuffer_get_length( t->content );
+                                - evbuffer_get_length (t->content);
 
-        const uint64_t total_offset = tr_pieceOffset( tor, t->piece_index,
+        const uint64_t total_offset = tr_pieceOffset (tor, t->piece_index,
                                                            t->piece_offset,
-                                                           t->length - remain );
+                                                           t->length - remain);
         const tr_piece_index_t step_piece = total_offset / inf->pieceSize;
         const uint64_t step_piece_offset
-                               = total_offset - ( inf->pieceSize * step_piece );
+                               = total_offset - (inf->pieceSize * step_piece);
 
         tr_file_index_t file_index;
         const tr_file * file;
         uint64_t file_offset;
         uint64_t this_pass;
 
-        tr_ioFindFileLocation( tor, step_piece, step_piece_offset,
-                                    &file_index, &file_offset );
+        tr_ioFindFileLocation (tor, step_piece, step_piece_offset,
+                                    &file_index, &file_offset);
         file = &inf->files[file_index];
-        this_pass = MIN( remain, file->length - file_offset );
+        this_pass = MIN (remain, file->length - file_offset);
 
-        if( !urls[file_index] )
-            urls[file_index] = evbuffer_free_to_str( make_url( t->webseed, file ) );
+        if (!urls[file_index])
+            urls[file_index] = evbuffer_free_to_str (make_url (t->webseed, file));
 
-        tr_snprintf( range, sizeof range, "%"PRIu64"-%"PRIu64,
-                     file_offset, file_offset + this_pass - 1 );
-        t->web_task = tr_webRunWithBuffer( w->session, urls[file_index],
-                                           range, NULL, web_response_func, t, t->content );
+        tr_snprintf (range, sizeof range, "%"PRIu64"-%"PRIu64,
+                     file_offset, file_offset + this_pass - 1);
+        t->web_task = tr_webRunWithBuffer (w->session, urls[file_index],
+                                           range, NULL, web_response_func, t, t->content);
     }
 }
 
 bool
-tr_webseedGetSpeed_Bps( const tr_webseed * w,
+tr_webseedGetSpeed_Bps (const tr_webseed * w,
                         uint64_t           now,
-                        unsigned int     * setme_Bps )
+                        unsigned int     * setme_Bps)
 {
-    const bool is_active = webseed_has_tasks( w );
-    *setme_Bps = is_active ? tr_bandwidthGetPieceSpeed_Bps( &w->bandwidth, now, TR_DOWN ) : 0;
+    const bool is_active = webseed_has_tasks (w);
+    *setme_Bps = is_active ? tr_bandwidthGetPieceSpeed_Bps (&w->bandwidth, now, TR_DOWN) : 0;
     return is_active;
 }
 
 bool
-tr_webseedIsActive( const tr_webseed * w )
+tr_webseedIsActive (const tr_webseed * w)
 {
     unsigned int Bps = 0;
-    return tr_webseedGetSpeed_Bps( w, tr_time_msec(), &Bps ) && ( Bps > 0 );
+    return tr_webseedGetSpeed_Bps (w, tr_time_msec (), &Bps) && (Bps > 0);
 }
 
 /***
@@ -536,55 +536,55 @@ tr_webseedIsActive( const tr_webseed * w )
 ***/
 
 static void
-webseed_timer_func( evutil_socket_t foo UNUSED, short bar UNUSED, void * vw )
+webseed_timer_func (evutil_socket_t foo UNUSED, short bar UNUSED, void * vw)
 {
     tr_webseed * w = vw;
-    if( w->retry_tickcount )
+    if (w->retry_tickcount)
         ++w->retry_tickcount;
-    on_idle( w );
-    tr_timerAddMsec( w->timer, TR_IDLE_TIMER_MSEC );
+    on_idle (w);
+    tr_timerAddMsec (w->timer, TR_IDLE_TIMER_MSEC);
 }
 
 tr_webseed*
-tr_webseedNew( struct tr_torrent  * tor,
+tr_webseedNew (struct tr_torrent  * tor,
                const char         * url,
                tr_peer_callback   * callback,
-               void               * callback_data )
+               void               * callback_data)
 {
-    tr_webseed * w = tr_new0( tr_webseed, 1 );
+    tr_webseed * w = tr_new0 (tr_webseed, 1);
     tr_peer * peer = &w->parent;
-    const tr_info * inf = tr_torrentInfo( tor );
+    const tr_info * inf = tr_torrentInfo (tor);
 
     /* construct parent class */
-    tr_peerConstruct( peer );
+    tr_peerConstruct (peer);
     peer->peerIsChoked = true;
-    peer->clientIsInterested = !tr_torrentIsSeed( tor );
-    peer->client = tr_strdup( "webseed" );
-    tr_bitfieldSetHasAll( &peer->have );
-    tr_peerUpdateProgress( tor, peer );
+    peer->clientIsInterested = !tr_torrentIsSeed (tor);
+    peer->client = tr_strdup ("webseed");
+    tr_bitfieldSetHasAll (&peer->have);
+    tr_peerUpdateProgress (tor, peer);
 
-    w->torrent_id = tr_torrentId( tor );
+    w->torrent_id = tr_torrentId (tor);
     w->session = tor->session;
-    w->base_url_len = strlen( url );
-    w->base_url = tr_strndup( url, w->base_url_len );
+    w->base_url_len = strlen (url);
+    w->base_url = tr_strndup (url, w->base_url_len);
     w->callback = callback;
     w->callback_data = callback_data;
-    w->file_urls = tr_new0( char *, inf->fileCount );
-    //tr_rcConstruct( &w->download_rate );
-    tr_bandwidthConstruct( &w->bandwidth, tor->session, &tor->bandwidth );
-    w->timer = evtimer_new( w->session->event_base, webseed_timer_func, w );
-    tr_timerAddMsec( w->timer, TR_IDLE_TIMER_MSEC );
+    w->file_urls = tr_new0 (char *, inf->fileCount);
+    //tr_rcConstruct (&w->download_rate);
+    tr_bandwidthConstruct (&w->bandwidth, tor->session, &tor->bandwidth);
+    w->timer = evtimer_new (w->session->event_base, webseed_timer_func, w);
+    tr_timerAddMsec (w->timer, TR_IDLE_TIMER_MSEC);
     return w;
 }
 
 void
-tr_webseedFree( tr_webseed * w )
+tr_webseedFree (tr_webseed * w)
 {
-    if( w )
+    if (w)
     {
-        if( webseed_has_tasks( w ) )
+        if (webseed_has_tasks (w))
             w->is_stopping = true;
         else
-            webseed_free( w );
+            webseed_free (w);
     }
 }
diff --git a/libtransmission/webseed.h b/libtransmission/webseed.h
index 4ad071dc6..47485da96 100644
--- a/libtransmission/webseed.h
+++ b/libtransmission/webseed.h
@@ -2,7 +2,7 @@
  * This file Copyright (C) Mnemosyne LLC
  *
  * This file is licensed by the GPL version 2. Works owned by the
- * Transmission project are granted a special exemption to clause 2(b)
+ * Transmission project are granted a special exemption to clause 2 (b)
  * so that the bulk of its code can remain under the MIT license.
  * This exemption does not extend to derived works not owned by
  * the Transmission project.
@@ -21,20 +21,20 @@ typedef struct tr_webseed tr_webseed;
 
 #include "peer-common.h"
 
-tr_webseed* tr_webseedNew( struct tr_torrent * torrent,
+tr_webseed* tr_webseedNew (struct tr_torrent * torrent,
                            const char        * url,
                            tr_peer_callback  * callback,
-                           void              * callback_data );
+                           void              * callback_data);
 
-void        tr_webseedFree( tr_webseed * );
+void        tr_webseedFree (tr_webseed *);
 
 /** @return true if a request is being processed, or false if idle */
-bool        tr_webseedGetSpeed_Bps( const tr_webseed * w,
+bool        tr_webseedGetSpeed_Bps (const tr_webseed * w,
                                     uint64_t           now,
-                                    unsigned int     * setme_Bps );
+                                    unsigned int     * setme_Bps);
 
 /** @return true if a request is being processed, or false if idle */
-bool        tr_webseedIsActive( const tr_webseed * w );
+bool        tr_webseedIsActive (const tr_webseed * w);
 
 
 #endif
diff --git a/libtransmission/wildmat.c b/libtransmission/wildmat.c
index 55ca1dc27..0b7d1558f 100644
--- a/libtransmission/wildmat.c
+++ b/libtransmission/wildmat.c
@@ -46,7 +46,7 @@
 #define NEGATE_CLASS		'^'
     /* Is "*" a common pattern? */
 #define OPTIMIZE_JUST_STAR
-    /* Do tar(1) matching rules, which ignore a trailing slash? */
+    /* Do tar (1) matching rules, which ignore a trailing slash? */
 #undef MATCH_TAR_PATTERN
 
 
@@ -54,13 +54,13 @@
 **  Match text and p, return true, false, or ABORT.
 */
 static int
-DoMatch( const char * text, const char * p )
+DoMatch (const char * text, const char * p)
 {
     register int	last;
     register int	matched;
     register int	reverse;
 
-    for ( ; *p; text++, p++) {
+    for (; *p; text++, p++) {
 	if (*text == '\0' && *p != '*')
 	    return ABORT;
 	switch (*p) {
@@ -83,7 +83,7 @@ DoMatch( const char * text, const char * p )
 		/* Trailing star matches everything. */
 		return true;
 	    while (*text)
-		if ((matched = DoMatch(text++, p)) != false)
+		if ((matched = DoMatch (text++, p)) != false)
 		    return matched;
 	    return ABORT;
 	case '[':
@@ -111,10 +111,10 @@ DoMatch( const char * text, const char * p )
 
 /* User-level routine. returns whether or not 'text' and 'p' matched */
 bool
-tr_wildmat(const char * text, const char * p )
+tr_wildmat (const char * text, const char * p)
 {
     if (p[0] == '*' && p[1] == '\0')
 	return true;
 
-    return DoMatch(text, p) == true;
+    return DoMatch (text, p) == true;
 }
diff --git a/utils/create.c b/utils/create.c
index 409d7fa3e..9ce7217d1 100644
--- a/utils/create.c
+++ b/utils/create.c
@@ -11,9 +11,9 @@
  */
 
 #include <errno.h>
-#include <stdio.h> /* fprintf() */
+#include <stdio.h> /* fprintf () */
 #include <stdlib.h> /* EXIT_FAILURE */
-#include <unistd.h> /* getcwd() */
+#include <unistd.h> /* getcwd () */
 
 #include <libtransmission/transmission.h>
 #include <libtransmission/makemeta.h>
@@ -43,127 +43,166 @@ static tr_option options[] =
 };
 
 static const char *
-getUsage( void )
+getUsage (void)
 {
-    return "Usage: " MY_NAME " [options] <file|directory>";
+  return "Usage: " MY_NAME " [options] <file|directory>";
 }
 
 static int
-parseCommandLine( int argc, const char ** argv )
+parseCommandLine (int argc, const char ** argv)
 {
-    int c;
-    const char * optarg;
+  int c;
+  const char * optarg;
 
-    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
+  while ((c = tr_getopt (getUsage (), argc, argv, options, &optarg)))
     {
-        switch( c )
+      switch (c)
         {
-            case 'V': showVersion = true; break;
-            case 'p': isPrivate = true; break;
-            case 'o': outfile = optarg; break;
-            case 'c': comment = optarg; break;
-            case 't': if( trackerCount + 1 < MAX_TRACKERS ) {
-                          trackers[trackerCount].tier = trackerCount;
-                          trackers[trackerCount].announce = (char*) optarg;
-                          ++trackerCount;
-                      }
-                      break;
-            case TR_OPT_UNK: infile = optarg; break;
-            default: return 1;
+          case 'V':
+            showVersion = true;
+            break;
+
+          case 'p':
+            isPrivate = true;
+            break;
+
+          case 'o':
+            outfile = optarg;
+            break;
+
+          case 'c':
+            comment = optarg;
+            break;
+
+          case 't':
+            if (trackerCount + 1 < MAX_TRACKERS)
+              {
+                trackers[trackerCount].tier = trackerCount;
+                trackers[trackerCount].announce = (char*) optarg;
+                  ++trackerCount;
+              }
+            break;
+
+          case TR_OPT_UNK:
+            infile = optarg;
+            break;
+
+          default:
+            return 1;
         }
     }
 
-    return 0;
+  return 0;
 }
 
 static char*
-tr_getcwd( void )
+tr_getcwd (void)
 {
-    char * result;
-    char buf[2048];
+  char * result;
+  char buf[2048];
+
 #ifdef WIN32
-    result = _getcwd( buf, sizeof( buf ) );
+  result = _getcwd (buf, sizeof (buf));
 #else
-    result = getcwd( buf, sizeof( buf ) );
+  result = getcwd (buf, sizeof (buf));
 #endif
-    if( result == NULL )
+
+  if (result == NULL)
     {
-        fprintf( stderr, "getcwd error: \"%s\"", tr_strerror( errno ) );
-        *buf = '\0';
+      fprintf (stderr, "getcwd error: \"%s\"", tr_strerror (errno));
+      *buf = '\0';
     }
-    return tr_strdup( buf );
+
+  return tr_strdup (buf);
 }
 
 int
-main( int argc, char * argv[] )
+main (int argc, char * argv[])
 {
-    char * out2 = NULL;
-    tr_metainfo_builder * b = NULL;
+  char * out2 = NULL;
+  tr_metainfo_builder * b = NULL;
 
-    tr_setMessageLevel( TR_MSG_ERR );
+  tr_setMessageLevel (TR_MSG_ERR);
 
-    if( parseCommandLine( argc, (const char**)argv ) )
-        return EXIT_FAILURE;
+  if (parseCommandLine (argc, (const char**)argv))
+    return EXIT_FAILURE;
 
-    if( showVersion ) {
-        fprintf( stderr, MY_NAME" "LONG_VERSION_STRING"\n" );
-        return 0;
+  if (showVersion)
+    {
+      fprintf (stderr, MY_NAME" "LONG_VERSION_STRING"\n");
+      return EXIT_SUCCESS;
     }
 
-    if( !infile )
+  if (!infile)
     {
-        fprintf( stderr, "ERROR: No input file or directory specified.\n" );
-        tr_getopt_usage( MY_NAME, getUsage( ), options );
-        fprintf( stderr, "\n" );
-        return EXIT_FAILURE;
+      fprintf (stderr, "ERROR: No input file or directory specified.\n");
+      tr_getopt_usage (MY_NAME, getUsage (), options);
+      fprintf (stderr, "\n");
+      return EXIT_FAILURE;
     }
 
-    if( outfile == NULL )
+  if (outfile == NULL)
     {
-        char * base = tr_basename( infile );
-        char * end = tr_strdup_printf( "%s.torrent", base );
-        char * cwd = tr_getcwd( );
-        outfile = out2 = tr_buildPath( cwd, end, NULL );
-        tr_free( cwd );
-        tr_free( end );
-        tr_free( base );
+      char * base = tr_basename (infile);
+      char * end = tr_strdup_printf ("%s.torrent", base);
+      char * cwd = tr_getcwd ();
+      outfile = out2 = tr_buildPath (cwd, end, NULL);
+      tr_free (cwd);
+      tr_free (end);
+      tr_free (base);
     }
 
-    if( !trackerCount )
+  if (!trackerCount)
     {
-        if( isPrivate )
+      if (isPrivate)
         {
-            fprintf( stderr, "ERROR: no trackers specified for a private torrent\n" );
-            return EXIT_FAILURE;
+          fprintf (stderr, "ERROR: no trackers specified for a private torrent\n");
+          return EXIT_FAILURE;
         }
         else
         {
-            printf( "WARNING: no trackers specified\n" );
+          printf ("WARNING: no trackers specified\n");
         }
     }
 
-    printf( "Creating torrent \"%s\" ...", outfile );
-    fflush( stdout );
+  printf ("Creating torrent \"%s\" ...", outfile);
+  fflush (stdout);
 
-    b = tr_metaInfoBuilderCreate( infile );
-    tr_makeMetaInfo( b, outfile, trackers, trackerCount, comment, isPrivate );
-    while( !b->isDone ) {
-        tr_wait_msec( 500 );
-        putc( '.', stdout );
-        fflush( stdout );
+  b = tr_metaInfoBuilderCreate (infile);
+  tr_makeMetaInfo (b, outfile, trackers, trackerCount, comment, isPrivate);
+  while (!b->isDone)
+    {
+      tr_wait_msec (500);
+      putc ('.', stdout);
+      fflush (stdout);
     }
 
-    putc( ' ', stdout );
-    switch( b->result ) {
-        case TR_MAKEMETA_OK:        printf( "done!" ); break;
-        case TR_MAKEMETA_URL:       printf( "bad announce URL: \"%s\"", b->errfile ); break;
-        case TR_MAKEMETA_IO_READ:   printf( "error reading \"%s\": %s", b->errfile, tr_strerror(b->my_errno) ); break;
-        case TR_MAKEMETA_IO_WRITE:  printf( "error writing \"%s\": %s", b->errfile, tr_strerror(b->my_errno) ); break;
-        case TR_MAKEMETA_CANCELLED: printf( "cancelled" ); break;
+  putc (' ', stdout);
+  switch (b->result)
+    {
+      case TR_MAKEMETA_OK:
+        printf ("done!");
+        break;
+
+      case TR_MAKEMETA_URL:
+        printf ("bad announce URL: \"%s\"", b->errfile);
+        break;
+
+      case TR_MAKEMETA_IO_READ:
+        printf ("error reading \"%s\": %s", b->errfile, tr_strerror (b->my_errno));
+        break;
+
+      case TR_MAKEMETA_IO_WRITE:
+        printf ("error writing \"%s\": %s", b->errfile, tr_strerror (b->my_errno));
+        break;
+
+      case TR_MAKEMETA_CANCELLED:
+        printf ("cancelled");
+        break;
     }
-    putc( '\n', stdout );
+  putc ('\n', stdout);
 
-    tr_metaInfoBuilderFree( b );
-    tr_free( out2 );
-    return 0;
+  tr_metaInfoBuilderFree (b);
+  tr_free (out2);
+  return EXIT_SUCCESS;
 }
diff --git a/utils/edit.c b/utils/edit.c
index 5fddb4e2d..51bc03a73 100644
--- a/utils/edit.c
+++ b/utils/edit.c
@@ -10,8 +10,8 @@
  * $Id$
  */
 
-#include <stdio.h> /* fprintf() */
-#include <string.h> /* strlen(), strstr(), strcmp() */
+#include <stdio.h> /* fprintf () */
+#include <string.h> /* strlen (), strstr (), strcmp () */
 #include <stdlib.h> /* EXIT_FAILURE */
 
 #include <event2/buffer.h>
@@ -41,300 +41,321 @@ static tr_option options[] =
 };
 
 static const char *
-getUsage( void )
+getUsage (void)
 {
-    return "Usage: " MY_NAME " [options] torrent-file(s)";
+  return "Usage: " MY_NAME " [options] torrent-file (s)";
 }
 
 static int
-parseCommandLine( int argc, const char ** argv )
+parseCommandLine (int argc, const char ** argv)
 {
-    int c;
-    const char * optarg;
+  int c;
+  const char * optarg;
 
-    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
+  while ((c = tr_getopt (getUsage (), argc, argv, options, &optarg)))
     {
-        switch( c )
+      switch (c)
         {
-            case 'a': add = optarg;
-                      break;
-            case 'd': deleteme = optarg;
-                      break;
-            case 'r': replace[0] = optarg;
-                      c = tr_getopt( getUsage( ), argc, argv, options, &optarg );
-                      if( c != TR_OPT_UNK ) return 1;
-                      replace[1] = optarg;
-                      break;
-            case 'V': showVersion = true;
-                      break;
-            case TR_OPT_UNK: files[fileCount++] = optarg; break;
-            default: return 1;
+          case 'a':
+            add = optarg;
+            break;
+
+          case 'd':
+            deleteme = optarg;
+            break;
+
+          case 'r':
+            replace[0] = optarg;
+            c = tr_getopt (getUsage (), argc, argv, options, &optarg);
+            if (c != TR_OPT_UNK)
+              return 1;
+            replace[1] = optarg;
+            break;
+
+          case 'V':
+            showVersion = true;
+            break;
+
+          case TR_OPT_UNK:
+            files[fileCount++] = optarg;
+            break;
+
+          default:
+            return 1;
         }
     }
 
-    return 0;
+  return 0;
 }
 
 static bool
-removeURL( tr_benc * metainfo, const char * url )
+removeURL (tr_benc * metainfo, const char * url)
 {
-    const char * str;
-    tr_benc * announce_list;
-    bool changed = false;
+  const char * str;
+  tr_benc * announce_list;
+  bool changed = false;
 
-    if( tr_bencDictFindStr( metainfo, "announce", &str ) && !strcmp( str, url ) )
+  if (tr_bencDictFindStr (metainfo, "announce", &str) && !strcmp (str, url))
     {
-        printf( "\tRemoved \"%s\" from \"announce\"\n", str );
-        tr_bencDictRemove( metainfo, "announce" );
-        changed = true;
+      printf ("\tRemoved \"%s\" from \"announce\"\n", str);
+      tr_bencDictRemove (metainfo, "announce");
+      changed = true;
     }
 
-    if( tr_bencDictFindList( metainfo, "announce-list", &announce_list ) )
+  if (tr_bencDictFindList (metainfo, "announce-list", &announce_list))
     {
-        tr_benc * tier;
-        int tierIndex = 0;
-        while(( tier = tr_bencListChild( announce_list, tierIndex )))
+      tr_benc * tier;
+      int tierIndex = 0;
+      while ((tier = tr_bencListChild (announce_list, tierIndex)))
         {
-            tr_benc * node;
-            int nodeIndex = 0;
-            while(( node = tr_bencListChild( tier, nodeIndex )))
+          tr_benc * node;
+          int nodeIndex = 0;
+          while ((node = tr_bencListChild (tier, nodeIndex)))
             {
-                if( tr_bencGetStr( node, &str ) && !strcmp( str, url ) )
+              if (tr_bencGetStr (node, &str) && !strcmp (str, url))
                 {
-                    printf( "\tRemoved \"%s\" from \"announce-list\" tier #%d\n", str, (tierIndex+1) );
-                    tr_bencListRemove( tier, nodeIndex );
-                    changed = true;
+                  printf ("\tRemoved \"%s\" from \"announce-list\" tier #%d\n", str, (tierIndex+1));
+                  tr_bencListRemove (tier, nodeIndex);
+                  changed = true;
                 }
-                else ++nodeIndex;
+              else ++nodeIndex;
             }
 
-            if( tr_bencListSize( tier ) == 0 )
+          if (tr_bencListSize (tier) == 0)
             {
-                printf( "\tNo URLs left in tier #%d... removing tier\n", (tierIndex+1) );
-                tr_bencListRemove( announce_list, tierIndex );
+              printf ("\tNo URLs left in tier #%d... removing tier\n", (tierIndex+1));
+              tr_bencListRemove (announce_list, tierIndex);
+            }
+          else
+            {
+              ++tierIndex;
             }
-            else ++tierIndex;
         }
 
-        if( tr_bencListSize( announce_list ) == 0 )
+      if (tr_bencListSize (announce_list) == 0)
         {
-            printf( "\tNo tiers left... removing announce-list\n" );
-            tr_bencDictRemove( metainfo, "announce-list" );
+          printf ("\tNo tiers left... removing announce-list\n");
+          tr_bencDictRemove (metainfo, "announce-list");
         }
     }
 
-    /* if we removed the "announce" field and there's still another track left,
-     * use it as the "announce" field */
-    if( changed && !tr_bencDictFindStr( metainfo, "announce", &str ) )
+  /* if we removed the "announce" field and there's still another track left,
+   * use it as the "announce" field */
+  if (changed && !tr_bencDictFindStr (metainfo, "announce", &str))
     {
-        tr_benc * tier;
-        tr_benc * node;
-
-        if(( tier = tr_bencListChild( announce_list, 0 ))) {
-            if(( node = tr_bencListChild( tier, 0 ))) {
-                if( tr_bencGetStr( node, &str ) ) {
-                    tr_bencDictAddStr( metainfo, "announce", str );
-                    printf( "\tAdded \"%s\" to announce\n", str );
+      tr_benc * tier;
+      tr_benc * node;
+
+      if ((tier = tr_bencListChild (announce_list, 0)))
+        {
+          if ((node = tr_bencListChild (tier, 0)))
+            {
+              if (tr_bencGetStr (node, &str))
+                {
+                  tr_bencDictAddStr (metainfo, "announce", str);
+                  printf ("\tAdded \"%s\" to announce\n", str);
                 }
             }
         }
     }
 
-    return changed;
+  return changed;
 }
 
 static char*
-replaceSubstr( const char * str, const char * in, const char * out )
+replaceSubstr (const char * str, const char * in, const char * out)
 {
-    char * walk;
-    struct evbuffer * buf = evbuffer_new( );
-    const size_t inlen = strlen( in );
-    const size_t outlen = strlen( out );
+  char * walk;
+  struct evbuffer * buf = evbuffer_new ();
+  const size_t inlen = strlen (in);
+  const size_t outlen = strlen (out);
 
-    while(( walk = strstr( str, in )))
+  while ((walk = strstr (str, in)))
     {
-        evbuffer_add( buf, str, walk-str );
-        evbuffer_add( buf, out, outlen );
-        str = walk + inlen;
+      evbuffer_add (buf, str, walk-str);
+      evbuffer_add (buf, out, outlen);
+      str = walk + inlen;
     }
 
-    evbuffer_add( buf, str, strlen( str ) );
+  evbuffer_add (buf, str, strlen (str));
 
-    return evbuffer_free_to_str( buf );
+  return evbuffer_free_to_str (buf);
 }
 
 static bool
-replaceURL( tr_benc * metainfo, const char * in, const char * out )
+replaceURL (tr_benc * metainfo, const char * in, const char * out)
 {
-    const char * str;
-    tr_benc * announce_list;
-    bool changed = false;
+  const char * str;
+  tr_benc * announce_list;
+  bool changed = false;
 
-    if( tr_bencDictFindStr( metainfo, "announce", &str ) && strstr( str, in ) )
+  if (tr_bencDictFindStr (metainfo, "announce", &str) && strstr (str, in))
     {
-        char * newstr = replaceSubstr( str, in, out );
-        printf( "\tReplaced in \"announce\": \"%s\" --> \"%s\"\n", str, newstr );
-        tr_bencDictAddStr( metainfo, "announce", newstr );
-        tr_free( newstr );
-        changed = true;
+      char * newstr = replaceSubstr (str, in, out);
+      printf ("\tReplaced in \"announce\": \"%s\" --> \"%s\"\n", str, newstr);
+      tr_bencDictAddStr (metainfo, "announce", newstr);
+      tr_free (newstr);
+      changed = true;
     }
 
-    if( tr_bencDictFindList( metainfo, "announce-list", &announce_list ) )
+  if (tr_bencDictFindList (metainfo, "announce-list", &announce_list))
     {
-        tr_benc * tier;
-        int tierCount = 0;
-        while(( tier = tr_bencListChild( announce_list, tierCount++ )))
+      tr_benc * tier;
+      int tierCount = 0;
+      while ((tier = tr_bencListChild (announce_list, tierCount++)))
         {
-            tr_benc * node;
-            int nodeCount = 0;
-            while(( node = tr_bencListChild( tier, nodeCount++ )))
+          tr_benc * node;
+          int nodeCount = 0;
+          while ((node = tr_bencListChild (tier, nodeCount++)))
             {
-                if( tr_bencGetStr( node, &str ) && strstr( str, in ) )
+              if (tr_bencGetStr (node, &str) && strstr (str, in))
                 {
-                    char * newstr = replaceSubstr( str, in, out );
-                    printf( "\tReplaced in \"announce-list\" tier %d: \"%s\" --> \"%s\"\n", tierCount, str, newstr );
-                    tr_bencFree( node );
-                    tr_bencInitStr( node, newstr, -1 );
-                    tr_free( newstr );
-                    changed = true;
+                  char * newstr = replaceSubstr (str, in, out);
+                  printf ("\tReplaced in \"announce-list\" tier %d: \"%s\" --> \"%s\"\n", tierCount, str, newstr);
+                  tr_bencFree (node);
+                  tr_bencInitStr (node, newstr, -1);
+                  tr_free (newstr);
+                  changed = true;
                 }
             }
         }
     }
 
-    return changed;
+  return changed;
 }
 
 static bool
-announce_list_has_url( tr_benc * announce_list, const char * url )
+announce_list_has_url (tr_benc * announce_list, const char * url)
 {
-    tr_benc * tier;
-    int tierCount = 0;
-    while(( tier = tr_bencListChild( announce_list, tierCount++ ))) {
-        tr_benc * node;
-        const char * str;
-        int nodeCount = 0;
-        while(( node = tr_bencListChild( tier, nodeCount++ )))
-            if( tr_bencGetStr( node, &str ) && !strcmp( str, url ) )
-                return true;
+  tr_benc * tier;
+  int tierCount = 0;
+  while ((tier = tr_bencListChild (announce_list, tierCount++)))
+    {
+      tr_benc * node;
+      const char * str;
+      int nodeCount = 0;
+      while ((node = tr_bencListChild (tier, nodeCount++)))
+        if (tr_bencGetStr (node, &str) && !strcmp (str, url))
+          return true;
     }
-    return false;
+
+  return false;
 }
 
 static bool
-addURL( tr_benc * metainfo, const char * url )
+addURL (tr_benc * metainfo, const char * url)
 {
-    const char * announce = NULL;
-    tr_benc * announce_list = NULL;
-    bool changed = false;
-    const bool had_announce = tr_bencDictFindStr( metainfo, "announce", &announce );
-    const bool had_announce_list = tr_bencDictFindList( metainfo, "announce-list", &announce_list );
+  const char * announce = NULL;
+  tr_benc * announce_list = NULL;
+  bool changed = false;
+  const bool had_announce = tr_bencDictFindStr (metainfo, "announce", &announce);
+  const bool had_announce_list = tr_bencDictFindList (metainfo, "announce-list", &announce_list);
 
-    if( !had_announce && !had_announce_list )
+  if (!had_announce && !had_announce_list)
     {
-        /* this new tracker is the only one, so add it to "announce"... */
-        printf( "\tAdded \"%s\" in \"announce\"\n", url );
-        tr_bencDictAddStr( metainfo, "announce", url );
-        changed = true;
+      /* this new tracker is the only one, so add it to "announce"... */
+      printf ("\tAdded \"%s\" in \"announce\"\n", url);
+      tr_bencDictAddStr (metainfo, "announce", url);
+      changed = true;
     }
-    else
+  else
     {
-        if( !had_announce_list )
+      if (!had_announce_list)
         {
-            announce_list = tr_bencDictAddList( metainfo, "announce-list", 2 );
+          announce_list = tr_bencDictAddList (metainfo, "announce-list", 2);
 
-            if( had_announce )
+          if (had_announce)
             {
-                /* we're moving from an 'announce' to an 'announce-list',
-                 * so copy the old announce URL to the list */
-                tr_benc * tier = tr_bencListAddList( announce_list, 1 );
-                tr_bencListAddStr( tier, announce );
-                changed = true;
+              /* we're moving from an 'announce' to an 'announce-list',
+               * so copy the old announce URL to the list */
+              tr_benc * tier = tr_bencListAddList (announce_list, 1);
+              tr_bencListAddStr (tier, announce);
+              changed = true;
             }
         }
 
-        /* If the user-specified URL isn't in the announce list yet, add it */
-        if( !announce_list_has_url( announce_list, url ) )
+      /* If the user-specified URL isn't in the announce list yet, add it */
+      if (!announce_list_has_url (announce_list, url))
         {
-            tr_benc * tier = tr_bencListAddList( announce_list, 1 );
-            tr_bencListAddStr( tier, url );
-            printf( "\tAdded \"%s\" to \"announce-list\" tier %zu\n", url, tr_bencListSize( announce_list ) );
-            changed = true;
+          tr_benc * tier = tr_bencListAddList (announce_list, 1);
+          tr_bencListAddStr (tier, url);
+          printf ("\tAdded \"%s\" to \"announce-list\" tier %zu\n", url, tr_bencListSize (announce_list));
+          changed = true;
         }
     }
 
-    return changed;
+  return changed;
 }
 
 int
-main( int argc, char * argv[] )
+main (int argc, char * argv[])
 {
-    int i;
-    int changedCount = 0;
+  int i;
+  int changedCount = 0;
 
-    files = tr_new0( const char*, argc );
+  files = tr_new0 (const char*, argc);
 
-    tr_setMessageLevel( TR_MSG_ERR );
+  tr_setMessageLevel (TR_MSG_ERR);
 
-    if( parseCommandLine( argc, (const char**)argv ) )
-        return EXIT_FAILURE;
+  if (parseCommandLine (argc, (const char**)argv))
+    return EXIT_FAILURE;
 
-    if( showVersion )
+  if (showVersion)
     {
-        fprintf( stderr, MY_NAME" "LONG_VERSION_STRING"\n" );
-        return 0;
+      fprintf (stderr, MY_NAME" "LONG_VERSION_STRING"\n");
+      return EXIT_SUCCESS;
     }
 
-    if( fileCount < 1 )
+  if (fileCount < 1)
     {
-        fprintf( stderr, "ERROR: No torrent files specified.\n" );
-        tr_getopt_usage( MY_NAME, getUsage( ), options );
-        fprintf( stderr, "\n" );
-        return EXIT_FAILURE;
+      fprintf (stderr, "ERROR: No torrent files specified.\n");
+      tr_getopt_usage (MY_NAME, getUsage (), options);
+      fprintf (stderr, "\n");
+      return EXIT_FAILURE;
     }
 
-    if( !add && !deleteme && !replace[0] )
+  if (!add && !deleteme && !replace[0])
     {
-        fprintf( stderr, "ERROR: Must specify -a, -d or -r\n" );
-        tr_getopt_usage( MY_NAME, getUsage( ), options );
-        fprintf( stderr, "\n" );
-        return EXIT_FAILURE;
+      fprintf (stderr, "ERROR: Must specify -a, -d or -r\n");
+      tr_getopt_usage (MY_NAME, getUsage (), options);
+      fprintf (stderr, "\n");
+      return EXIT_FAILURE;
     }
 
-    for( i=0; i<fileCount; ++i )
+  for (i=0; i<fileCount; ++i)
     {
-        tr_benc top;
-        bool changed = false;
-        const char * filename = files[i];
+      tr_benc top;
+      bool changed = false;
+      const char * filename = files[i];
 
-        printf( "%s\n", filename );
+      printf ("%s\n", filename);
 
-        if( tr_bencLoadFile( &top, TR_FMT_BENC, filename ) )
+      if (tr_bencLoadFile (&top, TR_FMT_BENC, filename))
         {
-            printf( "\tError reading file\n" );
-            continue;
+          printf ("\tError reading file\n");
+          continue;
         }
 
-        if( deleteme != NULL )
-            changed |= removeURL( &top, deleteme );
+      if (deleteme != NULL)
+        changed |= removeURL (&top, deleteme);
 
-        if( add != NULL )
-            changed = addURL( &top, add );
+      if (add != NULL)
+        changed = addURL (&top, add);
 
-        if( replace[0] && replace[1] )
-            changed |= replaceURL( &top, replace[0], replace[1] );
+      if (replace[0] && replace[1])
+        changed |= replaceURL (&top, replace[0], replace[1]);
 
-        if( changed )
+      if (changed)
         {
-            ++changedCount;
-            tr_bencToFile( &top, TR_FMT_BENC, filename );
+          ++changedCount;
+          tr_bencToFile (&top, TR_FMT_BENC, filename);
         }
 
-        tr_bencFree( &top );
+      tr_bencFree (&top);
     }
 
-    printf( "Changed %d files\n", changedCount );
+  printf ("Changed %d files\n", changedCount);
 
-    tr_free( files );
-    return 0;
+  tr_free (files);
+  return EXIT_SUCCESS;
 }
diff --git a/utils/show.c b/utils/show.c
index dd75e19d4..57e937f4e 100644
--- a/utils/show.c
+++ b/utils/show.c
@@ -10,9 +10,9 @@
  * $Id$
  */
 
-#include <stdio.h> /* fprintf() */
-#include <string.h> /* strcmp(), strchr(), memcmp() */
-#include <stdlib.h> /* getenv(), qsort() */
+#include <stdio.h> /* fprintf () */
+#include <string.h> /* strcmp (), strchr (), memcmp () */
+#include <stdlib.h> /* getenv (), qsort () */
 #include <time.h>
 
 #define CURL_DISABLE_TYPECHECK /* otherwise -Wunreachable-code goes insane */
@@ -24,7 +24,7 @@
 #include <libtransmission/bencode.h>
 #include <libtransmission/tr-getopt.h>
 #include <libtransmission/utils.h>
-#include <libtransmission/web.h> /* tr_webGetResponseStr() */
+#include <libtransmission/web.h> /* tr_webGetResponseStr () */
 #include <libtransmission/version.h>
 
 #define MY_NAME "transmission-show"
@@ -59,9 +59,9 @@ static tr_option options[] =
 };
 
 static const char *
-getUsage( void )
+getUsage (void)
 {
-    return "Usage: " MY_NAME " [options] <.torrent file>";
+  return "Usage: " MY_NAME " [options] <.torrent file>";
 }
 
 static bool magnetFlag = false;
@@ -70,20 +70,33 @@ static bool showVersion = false;
 const char * filename = NULL;
 
 static int
-parseCommandLine( int argc, const char ** argv )
+parseCommandLine (int argc, const char ** argv)
 {
-    int c;
-    const char * optarg;
+  int c;
+  const char * optarg;
 
-    while(( c = tr_getopt( getUsage( ), argc, argv, options, &optarg )))
+  while ((c = tr_getopt (getUsage (), argc, argv, options, &optarg)))
     {
-        switch( c )
+      switch (c)
         {
-            case 'm': magnetFlag = true; break;
-            case 's': scrapeFlag = true; break;
-            case 'V': showVersion = true; break;
-            case TR_OPT_UNK: filename = optarg; break;
-            default: return 1;
+          case 'm':
+            magnetFlag = true;
+            break;
+
+          case 's':
+            scrapeFlag = true;
+            break;
+
+          case 'V':
+            showVersion = true;
+            break;
+
+          case TR_OPT_UNK:
+            filename = optarg;
+            break;
+
+          default:
+            return 1;
         }
     }
 
@@ -91,263 +104,266 @@ parseCommandLine( int argc, const char ** argv )
 }
 
 static void
-doShowMagnet( const tr_info * inf )
+doShowMagnet (const tr_info * inf)
 {
-    char * str = tr_torrentInfoGetMagnetLink( inf );
-    printf( "%s", str );
-    tr_free( str );
+  char * str = tr_torrentInfoGetMagnetLink (inf);
+  printf ("%s", str);
+  tr_free (str);
 }
 
 static int
-compare_files_by_name( const void * va, const void * vb )
+compare_files_by_name (const void * va, const void * vb)
 {
-    const tr_file * a = *(const tr_file**)va;
-    const tr_file * b = *(const tr_file**)vb;
-    return strcmp( a->name, b->name );
+  const tr_file * a = * (const tr_file**)va;
+  const tr_file * b = * (const tr_file**)vb;
+  return strcmp (a->name, b->name);
 }
 
 static void
-showInfo( const tr_info * inf )
+showInfo (const tr_info * inf)
 {
-    int i;
-    char buf[128];
-    tr_file ** files;
-    int prevTier = -1;
-
-    /**
-    ***  General Info
-    **/
-
-    printf( "GENERAL\n\n" );
-    printf( "  Name: %s\n", inf->name );
-    printf( "  Hash: %s\n", inf->hashString );
-    printf( "  Created by: %s\n", inf->creator ? inf->creator : "Unknown" );
-    if( !inf->dateCreated )
-        printf( "  Created on: Unknown\n" );
-    else {
-        struct tm tm = *localtime( &inf->dateCreated );
-        printf( "  Created on: %s", asctime( &tm ) );
+  int i;
+  char buf[128];
+  tr_file ** files;
+  int prevTier = -1;
+
+  /**
+  ***  General Info
+  **/
+
+  printf ("GENERAL\n\n");
+  printf ("  Name: %s\n", inf->name);
+  printf ("  Hash: %s\n", inf->hashString);
+  printf ("  Created by: %s\n", inf->creator ? inf->creator : "Unknown");
+  if (!inf->dateCreated)
+    {
+      printf ("  Created on: Unknown\n");
+    }
+  else
+    {
+      struct tm tm = *localtime (&inf->dateCreated);
+      printf ("  Created on: %s", asctime (&tm));
     }
-    if( inf->comment && *inf->comment )
-        printf( "  Comment: %s\n", inf->comment );
-    printf( "  Piece Count: %d\n", inf->pieceCount );
-    printf( "  Piece Size: %s\n", tr_formatter_mem_B( buf, inf->pieceSize, sizeof( buf ) ) );
-    printf( "  Total Size: %s\n", tr_formatter_size_B( buf, inf->totalSize, sizeof( buf ) ) );
-    printf( "  Privacy: %s\n", inf->isPrivate ? "Private torrent" : "Public torrent" );
-
-    /**
-    ***  Trackers
-    **/
-
-    printf( "\nTRACKERS\n" );
-    for( i=0; i<inf->trackerCount; ++i )
+  if (inf->comment && *inf->comment)
+    printf ("  Comment: %s\n", inf->comment);
+  printf ("  Piece Count: %d\n", inf->pieceCount);
+  printf ("  Piece Size: %s\n", tr_formatter_mem_B (buf, inf->pieceSize, sizeof (buf)));
+  printf ("  Total Size: %s\n", tr_formatter_size_B (buf, inf->totalSize, sizeof (buf)));
+  printf ("  Privacy: %s\n", inf->isPrivate ? "Private torrent" : "Public torrent");
+
+  /**
+  ***  Trackers
+  **/
+
+  printf ("\nTRACKERS\n");
+  for (i=0; i<inf->trackerCount; ++i)
     {
-        if( prevTier != inf->trackers[i].tier )
+      if (prevTier != inf->trackers[i].tier)
         {
-            prevTier = inf->trackers[i].tier;
-            printf( "\n  Tier #%d\n", prevTier + 1 );
+          prevTier = inf->trackers[i].tier;
+          printf ("\n  Tier #%d\n", prevTier + 1);
         }
 
-        printf( "  %s\n", inf->trackers[i].announce );
+      printf ("  %s\n", inf->trackers[i].announce);
     }
 
-    /**
-    ***
-    **/
+  /**
+  ***
+  **/
 
-    if( inf->webseedCount > 0 )
+  if (inf->webseedCount > 0)
     {
-        printf( "\nWEBSEEDS\n\n" );
+      printf ("\nWEBSEEDS\n\n");
 
-        for( i=0; i<inf->webseedCount; ++i )
-            printf( "  %s\n", inf->webseeds[i] );
+      for (i=0; i<inf->webseedCount; ++i)
+        printf ("  %s\n", inf->webseeds[i]);
     }
 
-    /**
-    ***  Files
-    **/
-
-    printf( "\nFILES\n\n" );
-    files = tr_new( tr_file*, inf->fileCount );
-    for( i=0; i<(int)inf->fileCount; ++i )
-        files[i] = &inf->files[i];
-    qsort( files, inf->fileCount, sizeof(tr_file*), compare_files_by_name );
-    for( i=0; i<(int)inf->fileCount; ++i )
-        printf( "  %s (%s)\n", files[i]->name, tr_formatter_size_B( buf, files[i]->length, sizeof( buf ) ) );
-    tr_free( files );
+  /**
+  ***  Files
+  **/
+
+  printf ("\nFILES\n\n");
+  files = tr_new (tr_file*, inf->fileCount);
+  for (i=0; i< (int)inf->fileCount; ++i)
+    files[i] = &inf->files[i];
+  qsort (files, inf->fileCount, sizeof (tr_file*), compare_files_by_name);
+  for (i=0; i< (int)inf->fileCount; ++i)
+    printf ("  %s (%s)\n", files[i]->name, tr_formatter_size_B (buf, files[i]->length, sizeof (buf)));
+  tr_free (files);
 }
 
 static size_t
-writeFunc( void * ptr, size_t size, size_t nmemb, void * buf )
+writeFunc (void * ptr, size_t size, size_t nmemb, void * buf)
 {
-    const size_t byteCount = size * nmemb;
-    evbuffer_add( buf, ptr, byteCount );
-    return byteCount;
+  const size_t byteCount = size * nmemb;
+  evbuffer_add (buf, ptr, byteCount);
+  return byteCount;
 }
 
 static CURL*
-tr_curl_easy_init( struct evbuffer * writebuf )
+tr_curl_easy_init (struct evbuffer * writebuf)
 {
-    CURL * curl = curl_easy_init( );
-    curl_easy_setopt( curl, CURLOPT_USERAGENT, MY_NAME "/" LONG_VERSION_STRING );
-    curl_easy_setopt( curl, CURLOPT_WRITEFUNCTION, writeFunc );
-    curl_easy_setopt( curl, CURLOPT_WRITEDATA, writebuf );
-    curl_easy_setopt( curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY );
-    curl_easy_setopt( curl, CURLOPT_VERBOSE, getenv( "TR_CURL_VERBOSE" ) != NULL );
-    curl_easy_setopt( curl, CURLOPT_ENCODING, "" );
-    return curl;
+  CURL * curl = curl_easy_init ();
+  curl_easy_setopt (curl, CURLOPT_USERAGENT, MY_NAME "/" LONG_VERSION_STRING);
+  curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, writeFunc);
+  curl_easy_setopt (curl, CURLOPT_WRITEDATA, writebuf);
+  curl_easy_setopt (curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
+  curl_easy_setopt (curl, CURLOPT_VERBOSE, getenv ("TR_CURL_VERBOSE") != NULL);
+  curl_easy_setopt (curl, CURLOPT_ENCODING, "");
+  return curl;
 }
 
 static void
-doScrape( const tr_info * inf )
+doScrape (const tr_info * inf)
 {
-    int i;
+  int i;
 
-    for( i=0; i<inf->trackerCount; ++i )
+  for (i=0; i<inf->trackerCount; ++i)
     {
-        CURL * curl;
-        CURLcode res;
-        struct evbuffer * buf;
-        const char * scrape = inf->trackers[i].scrape;
-        char * url;
-        char escaped[SHA_DIGEST_LENGTH*3 + 1];
+      CURL * curl;
+      CURLcode res;
+      struct evbuffer * buf;
+      const char * scrape = inf->trackers[i].scrape;
+      char * url;
+      char escaped[SHA_DIGEST_LENGTH*3 + 1];
 
-        if( scrape == NULL )
-            continue;
+      if (scrape == NULL)
+        continue;
 
-        tr_http_escape_sha1( escaped, inf->hash );
+      tr_http_escape_sha1 (escaped, inf->hash);
 
-        url = tr_strdup_printf( "%s%cinfo_hash=%s",
-                                scrape,
-                                strchr( scrape, '?' ) ? '&' : '?',
-                                escaped );
+      url = tr_strdup_printf ("%s%cinfo_hash=%s",
+                              scrape,
+                              strchr (scrape, '?') ? '&' : '?',
+                              escaped);
 
-        printf( "%s ... ", url );
-        fflush( stdout );
+      printf ("%s ... ", url);
+      fflush (stdout);
 
-        buf = evbuffer_new( );
-        curl = tr_curl_easy_init( buf );
-        curl_easy_setopt( curl, CURLOPT_URL, url );
-        curl_easy_setopt( curl, CURLOPT_TIMEOUT, TIMEOUT_SECS );
+      buf = evbuffer_new ();
+      curl = tr_curl_easy_init (buf);
+      curl_easy_setopt (curl, CURLOPT_URL, url);
+      curl_easy_setopt (curl, CURLOPT_TIMEOUT, TIMEOUT_SECS);
 
-        if(( res = curl_easy_perform( curl )))
+      if ((res = curl_easy_perform (curl)))
         {
-            printf( "error: %s\n", curl_easy_strerror( res ) );
+          printf ("error: %s\n", curl_easy_strerror (res));
         }
-        else
+      else
         {
-            long response;
-            curl_easy_getinfo( curl, CURLINFO_RESPONSE_CODE, &response );
-            if( response != 200 )
+          long response;
+          curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &response);
+          if (response != 200)
             {
-                printf( "error: unexpected response %ld \"%s\"\n",
-                        response,
-                        tr_webGetResponseStr( response ) );
+              printf ("error: unexpected response %ld \"%s\"\n",
+                      response,
+                      tr_webGetResponseStr (response));
             }
-            else /* HTTP OK */
+          else /* HTTP OK */
             {
-                tr_benc top;
-                tr_benc * files;
-                bool matched = false;
-                const char * begin = (const char*) evbuffer_pullup( buf, -1 );
-                const char * end = begin + evbuffer_get_length( buf );
+              tr_benc top;
+              tr_benc * files;
+              bool matched = false;
+              const char * begin = (const char*) evbuffer_pullup (buf, -1);
+              const char * end = begin + evbuffer_get_length (buf);
 
-                if( !tr_bencParse( begin, end, &top, NULL ) )
+              if (!tr_bencParse (begin, end, &top, NULL))
                 {
-                    if( tr_bencDictFindDict( &top, "files", &files ) )
+                  if (tr_bencDictFindDict (&top, "files", &files))
                     {
-                        int i = 0;
-                        tr_benc * val;
-                        const char * key;
+                      int i = 0;
+                      tr_benc * val;
+                      const char * key;
 
-                        while( tr_bencDictChild( files, i++, &key, &val ))
+                      while (tr_bencDictChild (files, i++, &key, &val))
                         {
-                            if( !memcmp( inf->hash, key, SHA_DIGEST_LENGTH ) )
+                          if (!memcmp (inf->hash, key, SHA_DIGEST_LENGTH))
                             {
-                                int64_t seeders = -1;
-                                int64_t leechers = -1;
-                                tr_bencDictFindInt( val, "complete", &seeders );
-                                tr_bencDictFindInt( val, "incomplete", &leechers );
-                                printf( "%d seeders, %d leechers\n", (int)seeders, (int)leechers );
-                                matched = true;
+                              int64_t seeders = -1;
+                              int64_t leechers = -1;
+                              tr_bencDictFindInt (val, "complete", &seeders);
+                              tr_bencDictFindInt (val, "incomplete", &leechers);
+                              printf ("%d seeders, %d leechers\n", (int)seeders, (int)leechers);
+                              matched = true;
                             }
                         }
                     }
 
-                    tr_bencFree( &top );
+                  tr_bencFree (&top);
                 }
 
-                if( !matched )
-                    printf( "no match\n" );
+              if (!matched)
+                printf ("no match\n");
             }
         }
 
-        curl_easy_cleanup( curl );
-        evbuffer_free( buf );
-        tr_free( url );
+      curl_easy_cleanup (curl);
+      evbuffer_free (buf);
+      tr_free (url);
     }
 }
 
 int
-main( int argc, char * argv[] )
+main (int argc, char * argv[])
 {
-    int err;
-    tr_info inf;
-    tr_ctor * ctor;
+  int err;
+  tr_info inf;
+  tr_ctor * ctor;
 
-    tr_setMessageLevel( TR_MSG_ERR );
-    tr_formatter_mem_init  ( MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR );
-    tr_formatter_size_init ( DISK_K, DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR );
-    tr_formatter_speed_init ( SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR );
+  tr_setMessageLevel (TR_MSG_ERR);
+  tr_formatter_mem_init (MEM_K, MEM_K_STR, MEM_M_STR, MEM_G_STR, MEM_T_STR);
+  tr_formatter_size_init (DISK_K, DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR);
+  tr_formatter_speed_init (SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR);
 
-    if( parseCommandLine( argc, (const char**)argv ) )
-        return EXIT_FAILURE;
+  if (parseCommandLine (argc, (const char**)argv))
+    return EXIT_FAILURE;
 
-    if( showVersion )
+  if (showVersion)
     {
-        fprintf( stderr, MY_NAME" "LONG_VERSION_STRING"\n" );
-        return 0;
+      fprintf (stderr, MY_NAME" "LONG_VERSION_STRING"\n");
+      return EXIT_SUCCESS;
     }
 
-    /* make sure the user specified a filename */
-    if( !filename )
+  /* make sure the user specified a filename */
+  if (!filename)
     {
-        fprintf( stderr, "ERROR: No .torrent file specified.\n" );
-        tr_getopt_usage( MY_NAME, getUsage( ), options );
-        fprintf( stderr, "\n" );
-        return EXIT_FAILURE;
+      fprintf (stderr, "ERROR: No .torrent file specified.\n");
+      tr_getopt_usage (MY_NAME, getUsage (), options);
+      fprintf (stderr, "\n");
+      return EXIT_FAILURE;
     }
 
-    /* try to parse the .torrent file */
-    ctor = tr_ctorNew( NULL );
-    tr_ctorSetMetainfoFromFile( ctor, filename );
-    err = tr_torrentParse( ctor, &inf );
-    tr_ctorFree( ctor );
-    if( err )
+  /* try to parse the .torrent file */
+  ctor = tr_ctorNew (NULL);
+  tr_ctorSetMetainfoFromFile (ctor, filename);
+  err = tr_torrentParse (ctor, &inf);
+  tr_ctorFree (ctor);
+  if (err)
     {
-        fprintf( stderr, "Error parsing .torrent file \"%s\"\n", filename );
-        return 1;
+      fprintf (stderr, "Error parsing .torrent file \"%s\"\n", filename);
+      return EXIT_FAILURE;
     }
 
-    if( magnetFlag )
+  if (magnetFlag)
     {
-        doShowMagnet( &inf );
+      doShowMagnet (&inf);
     }
-    else
+  else
     {
-        printf( "Name: %s\n", inf.name );
-        printf( "File: %s\n", filename );
-        printf( "\n" );
-        fflush( stdout );
-
-        if( scrapeFlag )
-            doScrape( &inf );
-        else
-            showInfo( &inf );
+      printf ("Name: %s\n", inf.name);
+      printf ("File: %s\n", filename);
+      printf ("\n");
+      fflush (stdout);
+
+      if (scrapeFlag)
+        doScrape (&inf);
+      else
+        showInfo (&inf);
     }
 
-    /* cleanup */
-    putc( '\n', stdout );
-    tr_metainfoFree( &inf );
-    return 0;
+  /* cleanup */
+  putc ('\n', stdout);
+  tr_metainfoFree (&inf);
+  return EXIT_SUCCESS;
 }
-- 
2.40.0