Ignore:
Timestamp:
Dec 5, 2012, 5:29:46 PM (9 years ago)
Author:
jordan
Message:

Follow more common whitespace style conventions in the C code (libtransmission, daemon, utils, cli, gtk).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/session.c

    r13502 r13625  
    33 *
    44 * This file is licensed by the GPL version 2. Works owned by the
    5  * Transmission project are granted a special exemption to clause 2(b)
     5 * Transmission project are granted a special exemption to clause 2 (b)
    66 * so that the bulk of its code can remain under the MIT license.
    77 * This exemption does not extend to derived works not owned by
     
    1717
    1818#include <signal.h>
    19 #include <sys/types.h> /* stat(), umask() */
    20 #include <sys/stat.h> /* stat(), umask() */
     19#include <sys/types.h> /* stat (), umask () */
     20#include <sys/stat.h> /* stat (), umask () */
    2121#include <unistd.h> /* stat */
    2222#include <dirent.h> /* opendir */
    2323
    24 #include <event2/dns.h> /* evdns_base_free() */
     24#include <event2/dns.h> /* evdns_base_free () */
    2525#include <event2/event.h>
    2626
     
    4040#include "peer-io.h"
    4141#include "peer-mgr.h"
    42 #include "platform.h" /* tr_lock, tr_getTorrentDir(), tr_getFreeSpace() */
     42#include "platform.h" /* tr_lock, tr_getTorrentDir (), tr_getFreeSpace () */
    4343#include "port-forwarding.h"
    4444#include "rpc-server.h"
     
    4646#include "stats.h"
    4747#include "torrent.h"
    48 #include "tr-dht.h" /* tr_dhtUpkeep() */
     48#include "tr-dht.h" /* tr_dhtUpkeep () */
    4949#include "tr-udp.h"
    5050#include "tr-utp.h"
     
    6969
    7070
    71 #define dbgmsg( ... ) \
    72     do { \
    73         if( tr_deepLoggingIsActive( ) ) \
    74             tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
    75     } while( 0 )
     71#define dbgmsg(...) \
     72  do \
     73    { \
     74      if (tr_deepLoggingIsActive ()) \
     75        tr_deepLog (__FILE__, __LINE__, NULL, __VA_ARGS__); \
     76    } \
     77  while (0)
    7678
    7779static tr_port
    78 getRandomPort( tr_session * s )
    79 {
    80     return tr_cryptoWeakRandInt( s->randomPortHigh - s->randomPortLow + 1) + s->randomPortLow;
     80getRandomPort (tr_session * s)
     81{
     82    return tr_cryptoWeakRandInt (s->randomPortHigh - s->randomPortLow + 1) + s->randomPortLow;
    8183}
    8284
     
    8688   designates beta (Azureus-style) */
    8789void
    88 tr_peerIdInit( uint8_t * buf )
     90tr_peerIdInit (uint8_t * buf)
    8991{
    9092    int          i;
     
    9496    const int    base = 36;
    9597
    96     memcpy( buf, PEERID_PREFIX, 8 );
    97 
    98     tr_cryptoRandBuf( buf+8, 11 );
    99     for( i=8; i<19; ++i ) {
     98    memcpy (buf, PEERID_PREFIX, 8);
     99
     100    tr_cryptoRandBuf (buf+8, 11);
     101    for (i=8; i<19; ++i) {
    100102        val = buf[i] % base;
    101103        total += val;
     
    103105    }
    104106
    105     val = total % base ? base - ( total % base ) : 0;
     107    val = total % base ? base - (total % base) : 0;
    106108    buf[19] = pool[val];
    107109    buf[20] = '\0';
     
    113115
    114116tr_encryption_mode
    115 tr_sessionGetEncryption( tr_session * session )
    116 {
    117     assert( session );
     117tr_sessionGetEncryption (tr_session * session)
     118{
     119    assert (session);
    118120
    119121    return session->encryptionMode;
     
    121123
    122124void
    123 tr_sessionSetEncryption( tr_session *       session,
    124                          tr_encryption_mode mode )
    125 {
    126     assert( session );
    127     assert( mode == TR_ENCRYPTION_PREFERRED
     125tr_sessionSetEncryption (tr_session *       session,
     126                         tr_encryption_mode mode)
     127{
     128    assert (session);
     129    assert (mode == TR_ENCRYPTION_PREFERRED
    128130          || mode == TR_ENCRYPTION_REQUIRED
    129           || mode == TR_CLEAR_PREFERRED );
     131          || mode == TR_CLEAR_PREFERRED);
    130132
    131133    session->encryptionMode = mode;
     
    145147
    146148static void
    147 close_bindinfo( struct tr_bindinfo * b )
    148 {
    149     if( ( b != NULL ) && ( b->socket >=0 ) )
     149close_bindinfo (struct tr_bindinfo * b)
     150{
     151    if ((b != NULL) && (b->socket >=0))
    150152    {
    151         event_free( b->ev );
     153        event_free (b->ev);
    152154        b->ev = NULL;
    153         tr_netCloseSocket( b->socket );
     155        tr_netCloseSocket (b->socket);
    154156    }
    155157}
    156158
    157159static void
    158 close_incoming_peer_port( tr_session * session )
    159 {
    160     close_bindinfo( session->public_ipv4 );
    161     close_bindinfo( session->public_ipv6 );
     160close_incoming_peer_port (tr_session * session)
     161{
     162    close_bindinfo (session->public_ipv4);
     163    close_bindinfo (session->public_ipv6);
    162164}
    163165
    164166static void
    165 free_incoming_peer_port( tr_session * session )
    166 {
    167     close_bindinfo( session->public_ipv4 );
    168     tr_free( session->public_ipv4 );
     167free_incoming_peer_port (tr_session * session)
     168{
     169    close_bindinfo (session->public_ipv4);
     170    tr_free (session->public_ipv4);
    169171    session->public_ipv4 = NULL;
    170172
    171     close_bindinfo( session->public_ipv6 );
    172     tr_free( session->public_ipv6 );
     173    close_bindinfo (session->public_ipv6);
     174    tr_free (session->public_ipv6);
    173175    session->public_ipv6 = NULL;
    174176}
    175177
    176178static void
    177 accept_incoming_peer( int fd, short what UNUSED, void * vsession )
     179accept_incoming_peer (int fd, short what UNUSED, void * vsession)
    178180{
    179181    int clientSocket;
     
    182184    tr_session * session = vsession;
    183185
    184     clientSocket = tr_netAccept( session, fd, &clientAddr, &clientPort );
    185     if( clientSocket > 0 ) {
    186         tr_deepLog( __FILE__, __LINE__, NULL, "new incoming connection %d (%s)",
    187                    clientSocket, tr_peerIoAddrStr( &clientAddr, clientPort ) );
    188         tr_peerMgrAddIncoming( session->peerMgr, &clientAddr, clientPort,
    189                                clientSocket, NULL );
     186    clientSocket = tr_netAccept (session, fd, &clientAddr, &clientPort);
     187    if (clientSocket > 0) {
     188        tr_deepLog (__FILE__, __LINE__, NULL, "new incoming connection %d (%s)",
     189                   clientSocket, tr_peerIoAddrStr (&clientAddr, clientPort));
     190        tr_peerMgrAddIncoming (session->peerMgr, &clientAddr, clientPort,
     191                               clientSocket, NULL);
    190192    }
    191193}
    192194
    193195static void
    194 open_incoming_peer_port( tr_session * session )
     196open_incoming_peer_port (tr_session * session)
    195197{
    196198    struct tr_bindinfo * b;
     
    198200    /* bind an ipv4 port to listen for incoming peers... */
    199201    b = session->public_ipv4;
    200     b->socket = tr_netBindTCP( &b->addr, session->private_peer_port, false );
    201     if( b->socket >= 0 ) {
    202         b->ev = event_new( session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session );
    203         event_add( b->ev, NULL );
     202    b->socket = tr_netBindTCP (&b->addr, session->private_peer_port, false);
     203    if (b->socket >= 0) {
     204        b->ev = event_new (session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session);
     205        event_add (b->ev, NULL);
    204206    }
    205207
    206208    /* and do the exact same thing for ipv6, if it's supported... */
    207     if( tr_net_hasIPv6( session->private_peer_port ) ) {
     209    if (tr_net_hasIPv6 (session->private_peer_port)) {
    208210        b = session->public_ipv6;
    209         b->socket = tr_netBindTCP( &b->addr, session->private_peer_port, false );
    210         if( b->socket >= 0 ) {
    211             b->ev = event_new( session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session );
    212             event_add( b->ev, NULL );
     211        b->socket = tr_netBindTCP (&b->addr, session->private_peer_port, false);
     212        if (b->socket >= 0) {
     213            b->ev = event_new (session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session);
     214            event_add (b->ev, NULL);
    213215        }
    214216    }
     
    216218
    217219const tr_address*
    218 tr_sessionGetPublicAddress( const tr_session * session, int tr_af_type, bool * is_default_value )
     220tr_sessionGetPublicAddress (const tr_session * session, int tr_af_type, bool * is_default_value)
    219221{
    220222    const char * default_value;
    221223    const struct tr_bindinfo * bindinfo;
    222224
    223     switch( tr_af_type )
     225    switch (tr_af_type)
    224226    {
    225227        case TR_AF_INET:
     
    239241    }
    240242
    241     if( is_default_value && bindinfo )
    242         *is_default_value = !tr_strcmp0( default_value, tr_address_to_string( &bindinfo->addr ) );
     243    if (is_default_value && bindinfo)
     244        *is_default_value = !tr_strcmp0 (default_value, tr_address_to_string (&bindinfo->addr));
    243245
    244246    return bindinfo ? &bindinfo->addr : NULL;
     
    256258
    257259static int
    258 parse_tos( const char *str )
     260parse_tos (const char *str)
    259261{
    260262    char *p;
    261263    int value;
    262264
    263     if( !evutil_ascii_strcasecmp( str, "" ) )
     265    if (!evutil_ascii_strcasecmp (str, ""))
    264266        return 0;
    265     if( !evutil_ascii_strcasecmp( str, "default" ) )
     267    if (!evutil_ascii_strcasecmp (str, "default"))
    266268        return 0;
    267269
    268     if( !evutil_ascii_strcasecmp( str, "lowcost" ) )
     270    if (!evutil_ascii_strcasecmp (str, "lowcost"))
    269271        return 0x10;
    270     if( !evutil_ascii_strcasecmp( str, "mincost" ) )
     272    if (!evutil_ascii_strcasecmp (str, "mincost"))
    271273        return 0x10;
    272274
    273     if( !evutil_ascii_strcasecmp( str, "throughput" ) )
     275    if (!evutil_ascii_strcasecmp (str, "throughput"))
    274276        return 0x08;
    275     if( !evutil_ascii_strcasecmp( str, "reliability" ) )
     277    if (!evutil_ascii_strcasecmp (str, "reliability"))
    276278        return 0x04;
    277     if( !evutil_ascii_strcasecmp( str, "lowdelay" ) )
     279    if (!evutil_ascii_strcasecmp (str, "lowdelay"))
    278280        return 0x02;
    279281
    280     value = strtol( str, &p, 0 );
    281     if( !p || ( p == str ) )
     282    value = strtol (str, &p, 0);
     283    if (!p || (p == str))
    282284        return 0;
    283285
     
    286288
    287289static const char *
    288 format_tos(int value)
     290format_tos (int value)
    289291{
    290292    static char buf[8];
    291     switch(value) {
     293    switch (value) {
    292294    case 0: return "default";
    293295    case 0x10: return "lowcost";
     
    296298    case 0x02: return "lowdelay";
    297299    default:
    298         snprintf(buf, 8, "%d", value);
     300        snprintf (buf, 8, "%d", value);
    299301        return buf;
    300302    }
     
    302304
    303305void
    304 tr_sessionGetDefaultSettings( tr_benc * d )
    305 {
    306     assert( tr_bencIsDict( d ) );
    307 
    308     tr_bencDictReserve( d, 60 );
    309     tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,               false );
    310     tr_bencDictAddStr ( d, TR_PREFS_KEY_BLOCKLIST_URL,                   "http://www.example.com/blocklist" );
    311     tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,               DEFAULT_CACHE_SIZE_MB );
    312     tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,                     true );
    313     tr_bencDictAddBool( d, TR_PREFS_KEY_UTP_ENABLED,                     true );
    314     tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED,                     false );
    315     tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,                    tr_getDefaultDownloadDir( ) );
    316     tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_KBps,                     100 );
    317     tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,                  false );
    318     tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,                      TR_DEFAULT_ENCRYPTION );
    319     tr_bencDictAddInt ( d, TR_PREFS_KEY_IDLE_LIMIT,                      30 );
    320     tr_bencDictAddBool( d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,              false );
    321     tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR,                  tr_getDefaultDownloadDir( ) );
    322     tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,          false );
    323     tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL,                        TR_MSG_INF );
    324     tr_bencDictAddInt ( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE,             5 );
    325     tr_bencDictAddBool( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED,          true );
    326     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,               atoi( TR_DEFAULT_PEER_LIMIT_GLOBAL_STR ) );
    327     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,              atoi( TR_DEFAULT_PEER_LIMIT_TORRENT_STR ) );
    328     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT,                       atoi( TR_DEFAULT_PEER_PORT_STR ) );
    329     tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START,       false );
    330     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,            49152 );
    331     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,           65535 );
    332     tr_bencDictAddStr ( d, TR_PREFS_KEY_PEER_SOCKET_TOS,                 TR_DEFAULT_PEER_SOCKET_TOS_STR );
    333     tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED,                     true );
    334     tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING,                 true );
    335     tr_bencDictAddInt ( d, TR_PREFS_KEY_PREALLOCATION,                   TR_PREALLOCATE_SPARSE );
    336     tr_bencDictAddBool( d, TR_PREFS_KEY_PREFETCH_ENABLED,                DEFAULT_PREFETCH_ENABLED );
    337     tr_bencDictAddBool( d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED,           true );
    338     tr_bencDictAddInt ( d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES,           30 );
    339     tr_bencDictAddReal( d, TR_PREFS_KEY_RATIO,                           2.0 );
    340     tr_bencDictAddBool( d, TR_PREFS_KEY_RATIO_ENABLED,                   false );
    341     tr_bencDictAddBool( d, TR_PREFS_KEY_RENAME_PARTIAL_FILES,            true );
    342     tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,               false );
    343     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_BIND_ADDRESS,                "0.0.0.0" );
    344     tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_ENABLED,                     false );
    345     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_PASSWORD,                    "" );
    346     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_USERNAME,                    "" );
    347     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_WHITELIST,                   TR_DEFAULT_RPC_WHITELIST );
    348     tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,           true );
    349     tr_bencDictAddInt ( d, TR_PREFS_KEY_RPC_PORT,                        atoi( TR_DEFAULT_RPC_PORT_STR ) );
    350     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_URL,                         TR_DEFAULT_RPC_URL_STR );
    351     tr_bencDictAddBool( d, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS,          true );
    352     tr_bencDictAddStr ( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME,    "" );
    353     tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED,     false );
    354     tr_bencDictAddInt ( d, TR_PREFS_KEY_SEED_QUEUE_SIZE,                 10 );
    355     tr_bencDictAddBool( d, TR_PREFS_KEY_SEED_QUEUE_ENABLED,              false );
    356     tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,               false );
    357     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP_KBps,               50 ); /* half the regular */
    358     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps,             50 ); /* half the regular */
    359     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,            540 ); /* 9am */
    360     tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,          false );
    361     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,              1020 ); /* 5pm */
    362     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,              TR_SCHED_ALL );
    363     tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED_KBps,                     100 );
    364     tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED,                  false );
    365     tr_bencDictAddInt ( d, TR_PREFS_KEY_UMASK,                           022 );
    366     tr_bencDictAddInt ( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT,        14 );
    367     tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,               TR_DEFAULT_BIND_ADDRESS_IPV4 );
    368     tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,               TR_DEFAULT_BIND_ADDRESS_IPV6 );
    369     tr_bencDictAddBool( d, TR_PREFS_KEY_START,                           true );
    370     tr_bencDictAddBool( d, TR_PREFS_KEY_TRASH_ORIGINAL,                  false );
    371 }
    372 
    373 void
    374 tr_sessionGetSettings( tr_session * s, struct tr_benc * d )
    375 {
    376     assert( tr_bencIsDict( d ) );
    377 
    378     tr_bencDictReserve( d, 60 );
    379     tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,                tr_blocklistIsEnabled( s ) );
    380     tr_bencDictAddStr ( d, TR_PREFS_KEY_BLOCKLIST_URL,                    tr_blocklistGetURL( s ) );
    381     tr_bencDictAddInt ( d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,                tr_sessionGetCacheLimit_MB( s ) );
    382     tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,                      s->isDHTEnabled );
    383     tr_bencDictAddBool( d, TR_PREFS_KEY_UTP_ENABLED,                      s->isUTPEnabled );
    384     tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED,                      s->isLPDEnabled );
    385     tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,                     s->downloadDir );
    386     tr_bencDictAddInt ( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE,              tr_sessionGetQueueSize( s, TR_DOWN ) );
    387     tr_bencDictAddBool( d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED,           tr_sessionGetQueueEnabled( s, TR_DOWN ) );
    388     tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_KBps,                      tr_sessionGetSpeedLimit_KBps( s, TR_DOWN ) );
    389     tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,                   tr_sessionIsSpeedLimited( s, TR_DOWN ) );
    390     tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,                       s->encryptionMode );
    391     tr_bencDictAddInt ( d, TR_PREFS_KEY_IDLE_LIMIT,                       tr_sessionGetIdleLimit( s ) );
    392     tr_bencDictAddBool( d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,               tr_sessionIsIdleLimited( s ) );
    393     tr_bencDictAddStr ( d, TR_PREFS_KEY_INCOMPLETE_DIR,                   tr_sessionGetIncompleteDir( s ) );
    394     tr_bencDictAddBool( d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,           tr_sessionIsIncompleteDirEnabled( s ) );
    395     tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL,                         tr_getMessageLevel( ) );
    396     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,                s->peerLimit );
    397     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,               s->peerLimitPerTorrent );
    398     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT,                        tr_sessionGetPeerPort( s ) );
    399     tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START,        s->isPortRandom );
    400     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,             s->randomPortLow );
    401     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,            s->randomPortHigh );
    402     tr_bencDictAddStr ( d, TR_PREFS_KEY_PEER_SOCKET_TOS,                  format_tos(s->peerSocketTOS) );
    403     tr_bencDictAddStr ( d, TR_PREFS_KEY_PEER_CONGESTION_ALGORITHM,        s->peer_congestion_algorithm );
    404     tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED,                      s->isPexEnabled );
    405     tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING,                  tr_sessionIsPortForwardingEnabled( s ) );
    406     tr_bencDictAddInt ( d, TR_PREFS_KEY_PREALLOCATION,                    s->preallocationMode );
    407     tr_bencDictAddInt ( d, TR_PREFS_KEY_PREFETCH_ENABLED,                 s->isPrefetchEnabled );
    408     tr_bencDictAddBool( d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED,            tr_sessionGetQueueStalledEnabled( s ) );
    409     tr_bencDictAddInt ( d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES,            tr_sessionGetQueueStalledMinutes( s ) );
    410     tr_bencDictAddReal( d, TR_PREFS_KEY_RATIO,                            s->desiredRatio );
    411     tr_bencDictAddBool( d, TR_PREFS_KEY_RATIO_ENABLED,                    s->isRatioLimited );
    412     tr_bencDictAddBool( d, TR_PREFS_KEY_RENAME_PARTIAL_FILES,             tr_sessionIsIncompleteFileNamingEnabled( s ) );
    413     tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,                tr_sessionIsRPCPasswordEnabled( s ) );
    414     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_BIND_ADDRESS,                 tr_sessionGetRPCBindAddress( s ) );
    415     tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_ENABLED,                      tr_sessionIsRPCEnabled( s ) );
    416     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_PASSWORD,                     tr_sessionGetRPCPassword( s ) );
    417     tr_bencDictAddInt ( d, TR_PREFS_KEY_RPC_PORT,                         tr_sessionGetRPCPort( s ) );
    418     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_URL,                          tr_sessionGetRPCUrl( s ) );
    419     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_USERNAME,                     tr_sessionGetRPCUsername( s ) );
    420     tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_WHITELIST,                    tr_sessionGetRPCWhitelist( s ) );
    421     tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,            tr_sessionGetRPCWhitelistEnabled( s ) );
    422     tr_bencDictAddBool( d, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS,           s->scrapePausedTorrents );
    423     tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED,      tr_sessionIsTorrentDoneScriptEnabled( s ) );
    424     tr_bencDictAddStr ( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME,     tr_sessionGetTorrentDoneScript( s ) );
    425     tr_bencDictAddInt ( d, TR_PREFS_KEY_SEED_QUEUE_SIZE,                  tr_sessionGetQueueSize( s, TR_UP ) );
    426     tr_bencDictAddBool( d, TR_PREFS_KEY_SEED_QUEUE_ENABLED,               tr_sessionGetQueueEnabled( s, TR_UP ) );
    427     tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,                tr_sessionUsesAltSpeed( s ) );
    428     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP_KBps,                tr_sessionGetAltSpeed_KBps( s, TR_UP ) );
    429     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps,              tr_sessionGetAltSpeed_KBps( s, TR_DOWN ) );
    430     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,             tr_sessionGetAltSpeedBegin( s ) );
    431     tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,           tr_sessionUsesAltSpeedTime( s ) );
    432     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,               tr_sessionGetAltSpeedEnd( s ) );
    433     tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,               tr_sessionGetAltSpeedDay( s ) );
    434     tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED_KBps,                      tr_sessionGetSpeedLimit_KBps( s, TR_UP ) );
    435     tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED,                   tr_sessionIsSpeedLimited( s, TR_UP ) );
    436     tr_bencDictAddInt ( d, TR_PREFS_KEY_UMASK,                            s->umask );
    437     tr_bencDictAddInt ( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT,         s->uploadSlotsPerTorrent );
    438     tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,                tr_address_to_string( &s->public_ipv4->addr ) );
    439     tr_bencDictAddStr ( d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,                tr_address_to_string( &s->public_ipv6->addr ) );
    440     tr_bencDictAddBool( d, TR_PREFS_KEY_START,                            !tr_sessionGetPaused( s ) );
    441     tr_bencDictAddBool( d, TR_PREFS_KEY_TRASH_ORIGINAL,                   tr_sessionGetDeleteSource( s ) );
    442 }
    443 
    444 bool
    445 tr_sessionLoadSettings( tr_benc * d, const char * configDir, const char * appName )
     306tr_sessionGetDefaultSettings (tr_benc * d)
     307{
     308    assert (tr_bencIsDict (d));
     309
     310    tr_bencDictReserve (d, 60);
     311    tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED,               false);
     312    tr_bencDictAddStr (d, TR_PREFS_KEY_BLOCKLIST_URL,                   "http://www.example.com/blocklist");
     313    tr_bencDictAddInt (d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,               DEFAULT_CACHE_SIZE_MB);
     314    tr_bencDictAddBool (d, TR_PREFS_KEY_DHT_ENABLED,                     true);
     315    tr_bencDictAddBool (d, TR_PREFS_KEY_UTP_ENABLED,                     true);
     316    tr_bencDictAddBool (d, TR_PREFS_KEY_LPD_ENABLED,                     false);
     317    tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR,                    tr_getDefaultDownloadDir ());
     318    tr_bencDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps,                     100);
     319    tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED,                  false);
     320    tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION,                      TR_DEFAULT_ENCRYPTION);
     321    tr_bencDictAddInt (d, TR_PREFS_KEY_IDLE_LIMIT,                      30);
     322    tr_bencDictAddBool (d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,              false);
     323    tr_bencDictAddStr (d, TR_PREFS_KEY_INCOMPLETE_DIR,                  tr_getDefaultDownloadDir ());
     324    tr_bencDictAddBool (d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,          false);
     325    tr_bencDictAddInt (d, TR_PREFS_KEY_MSGLEVEL,                        TR_MSG_INF);
     326    tr_bencDictAddInt (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE,             5);
     327    tr_bencDictAddBool (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED,          true);
     328    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,               atoi (TR_DEFAULT_PEER_LIMIT_GLOBAL_STR));
     329    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,              atoi (TR_DEFAULT_PEER_LIMIT_TORRENT_STR));
     330    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT,                       atoi (TR_DEFAULT_PEER_PORT_STR));
     331    tr_bencDictAddBool (d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START,       false);
     332    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,            49152);
     333    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,           65535);
     334    tr_bencDictAddStr (d, TR_PREFS_KEY_PEER_SOCKET_TOS,                 TR_DEFAULT_PEER_SOCKET_TOS_STR);
     335    tr_bencDictAddBool (d, TR_PREFS_KEY_PEX_ENABLED,                     true);
     336    tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING,                 true);
     337    tr_bencDictAddInt (d, TR_PREFS_KEY_PREALLOCATION,                   TR_PREALLOCATE_SPARSE);
     338    tr_bencDictAddBool (d, TR_PREFS_KEY_PREFETCH_ENABLED,                DEFAULT_PREFETCH_ENABLED);
     339    tr_bencDictAddBool (d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED,           true);
     340    tr_bencDictAddInt (d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES,           30);
     341    tr_bencDictAddReal (d, TR_PREFS_KEY_RATIO,                           2.0);
     342    tr_bencDictAddBool (d, TR_PREFS_KEY_RATIO_ENABLED,                   false);
     343    tr_bencDictAddBool (d, TR_PREFS_KEY_RENAME_PARTIAL_FILES,            true);
     344    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,               false);
     345    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_BIND_ADDRESS,                "0.0.0.0");
     346    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_ENABLED,                     false);
     347    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_PASSWORD,                    "");
     348    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_USERNAME,                    "");
     349    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_WHITELIST,                   TR_DEFAULT_RPC_WHITELIST);
     350    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,           true);
     351    tr_bencDictAddInt (d, TR_PREFS_KEY_RPC_PORT,                        atoi (TR_DEFAULT_RPC_PORT_STR));
     352    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_URL,                         TR_DEFAULT_RPC_URL_STR);
     353    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS,          true);
     354    tr_bencDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME,    "");
     355    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED,     false);
     356    tr_bencDictAddInt (d, TR_PREFS_KEY_SEED_QUEUE_SIZE,                 10);
     357    tr_bencDictAddBool (d, TR_PREFS_KEY_SEED_QUEUE_ENABLED,              false);
     358    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_ENABLED,               false);
     359    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_UP_KBps,               50); /* half the regular */
     360    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps,             50); /* half the regular */
     361    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,            540); /* 9am */
     362    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,          false);
     363    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_END,              1020); /* 5pm */
     364    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,              TR_SCHED_ALL);
     365    tr_bencDictAddInt (d, TR_PREFS_KEY_USPEED_KBps,                     100);
     366    tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED,                  false);
     367    tr_bencDictAddInt (d, TR_PREFS_KEY_UMASK,                           022);
     368    tr_bencDictAddInt (d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT,        14);
     369    tr_bencDictAddStr (d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,               TR_DEFAULT_BIND_ADDRESS_IPV4);
     370    tr_bencDictAddStr (d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,               TR_DEFAULT_BIND_ADDRESS_IPV6);
     371    tr_bencDictAddBool (d, TR_PREFS_KEY_START,                           true);
     372    tr_bencDictAddBool (d, TR_PREFS_KEY_TRASH_ORIGINAL,                  false);
     373}
     374
     375void
     376tr_sessionGetSettings (tr_session * s, struct tr_benc * d)
     377{
     378    assert (tr_bencIsDict (d));
     379
     380    tr_bencDictReserve (d, 60);
     381    tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED,                tr_blocklistIsEnabled (s));
     382    tr_bencDictAddStr (d, TR_PREFS_KEY_BLOCKLIST_URL,                    tr_blocklistGetURL (s));
     383    tr_bencDictAddInt (d, TR_PREFS_KEY_MAX_CACHE_SIZE_MB,                tr_sessionGetCacheLimit_MB (s));
     384    tr_bencDictAddBool (d, TR_PREFS_KEY_DHT_ENABLED,                      s->isDHTEnabled);
     385    tr_bencDictAddBool (d, TR_PREFS_KEY_UTP_ENABLED,                      s->isUTPEnabled);
     386    tr_bencDictAddBool (d, TR_PREFS_KEY_LPD_ENABLED,                      s->isLPDEnabled);
     387    tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR,                     s->downloadDir);
     388    tr_bencDictAddInt (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE,              tr_sessionGetQueueSize (s, TR_DOWN));
     389    tr_bencDictAddBool (d, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED,           tr_sessionGetQueueEnabled (s, TR_DOWN));
     390    tr_bencDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps,                      tr_sessionGetSpeedLimit_KBps (s, TR_DOWN));
     391    tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED,                   tr_sessionIsSpeedLimited (s, TR_DOWN));
     392    tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION,                       s->encryptionMode);
     393    tr_bencDictAddInt (d, TR_PREFS_KEY_IDLE_LIMIT,                       tr_sessionGetIdleLimit (s));
     394    tr_bencDictAddBool (d, TR_PREFS_KEY_IDLE_LIMIT_ENABLED,               tr_sessionIsIdleLimited (s));
     395    tr_bencDictAddStr (d, TR_PREFS_KEY_INCOMPLETE_DIR,                   tr_sessionGetIncompleteDir (s));
     396    tr_bencDictAddBool (d, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED,           tr_sessionIsIncompleteDirEnabled (s));
     397    tr_bencDictAddInt (d, TR_PREFS_KEY_MSGLEVEL,                         tr_getMessageLevel ());
     398    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,                s->peerLimit);
     399    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,               s->peerLimitPerTorrent);
     400    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT,                        tr_sessionGetPeerPort (s));
     401    tr_bencDictAddBool (d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START,        s->isPortRandom);
     402    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,             s->randomPortLow);
     403    tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,            s->randomPortHigh);
     404    tr_bencDictAddStr (d, TR_PREFS_KEY_PEER_SOCKET_TOS,                  format_tos (s->peerSocketTOS));
     405    tr_bencDictAddStr (d, TR_PREFS_KEY_PEER_CONGESTION_ALGORITHM,        s->peer_congestion_algorithm);
     406    tr_bencDictAddBool (d, TR_PREFS_KEY_PEX_ENABLED,                      s->isPexEnabled);
     407    tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING,                  tr_sessionIsPortForwardingEnabled (s));
     408    tr_bencDictAddInt (d, TR_PREFS_KEY_PREALLOCATION,                    s->preallocationMode);
     409    tr_bencDictAddInt (d, TR_PREFS_KEY_PREFETCH_ENABLED,                 s->isPrefetchEnabled);
     410    tr_bencDictAddBool (d, TR_PREFS_KEY_QUEUE_STALLED_ENABLED,            tr_sessionGetQueueStalledEnabled (s));
     411    tr_bencDictAddInt (d, TR_PREFS_KEY_QUEUE_STALLED_MINUTES,            tr_sessionGetQueueStalledMinutes (s));
     412    tr_bencDictAddReal (d, TR_PREFS_KEY_RATIO,                            s->desiredRatio);
     413    tr_bencDictAddBool (d, TR_PREFS_KEY_RATIO_ENABLED,                    s->isRatioLimited);
     414    tr_bencDictAddBool (d, TR_PREFS_KEY_RENAME_PARTIAL_FILES,             tr_sessionIsIncompleteFileNamingEnabled (s));
     415    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,                tr_sessionIsRPCPasswordEnabled (s));
     416    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_BIND_ADDRESS,                 tr_sessionGetRPCBindAddress (s));
     417    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_ENABLED,                      tr_sessionIsRPCEnabled (s));
     418    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_PASSWORD,                     tr_sessionGetRPCPassword (s));
     419    tr_bencDictAddInt (d, TR_PREFS_KEY_RPC_PORT,                         tr_sessionGetRPCPort (s));
     420    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_URL,                          tr_sessionGetRPCUrl (s));
     421    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_USERNAME,                     tr_sessionGetRPCUsername (s));
     422    tr_bencDictAddStr (d, TR_PREFS_KEY_RPC_WHITELIST,                    tr_sessionGetRPCWhitelist (s));
     423    tr_bencDictAddBool (d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,            tr_sessionGetRPCWhitelistEnabled (s));
     424    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS,           s->scrapePausedTorrents);
     425    tr_bencDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED,      tr_sessionIsTorrentDoneScriptEnabled (s));
     426    tr_bencDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME,     tr_sessionGetTorrentDoneScript (s));
     427    tr_bencDictAddInt (d, TR_PREFS_KEY_SEED_QUEUE_SIZE,                  tr_sessionGetQueueSize (s, TR_UP));
     428    tr_bencDictAddBool (d, TR_PREFS_KEY_SEED_QUEUE_ENABLED,               tr_sessionGetQueueEnabled (s, TR_UP));
     429    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_ENABLED,                tr_sessionUsesAltSpeed (s));
     430    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_UP_KBps,                tr_sessionGetAltSpeed_KBps (s, TR_UP));
     431    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps,              tr_sessionGetAltSpeed_KBps (s, TR_DOWN));
     432    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,             tr_sessionGetAltSpeedBegin (s));
     433    tr_bencDictAddBool (d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,           tr_sessionUsesAltSpeedTime (s));
     434    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_END,               tr_sessionGetAltSpeedEnd (s));
     435    tr_bencDictAddInt (d, TR_PREFS_KEY_ALT_SPEED_TIME_DAY,               tr_sessionGetAltSpeedDay (s));
     436    tr_bencDictAddInt (d, TR_PREFS_KEY_USPEED_KBps,                      tr_sessionGetSpeedLimit_KBps (s, TR_UP));
     437    tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED,                   tr_sessionIsSpeedLimited (s, TR_UP));
     438    tr_bencDictAddInt (d, TR_PREFS_KEY_UMASK,                            s->umask);
     439    tr_bencDictAddInt (d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT,         s->uploadSlotsPerTorrent);
     440    tr_bencDictAddStr (d, TR_PREFS_KEY_BIND_ADDRESS_IPV4,                tr_address_to_string (&s->public_ipv4->addr));
     441    tr_bencDictAddStr (d, TR_PREFS_KEY_BIND_ADDRESS_IPV6,                tr_address_to_string (&s->public_ipv6->addr));
     442    tr_bencDictAddBool (d, TR_PREFS_KEY_START,                            !tr_sessionGetPaused (s));
     443    tr_bencDictAddBool (d, TR_PREFS_KEY_TRASH_ORIGINAL,                   tr_sessionGetDeleteSource (s));
     444}
     445
     446bool
     447tr_sessionLoadSettings (tr_benc * d, const char * configDir, const char * appName)
    446448{
    447449    int err = 0;
     
    452454    bool success = false;
    453455
    454     assert( tr_bencIsDict( d ) );
     456    assert (tr_bencIsDict (d));
    455457
    456458    /* initializing the defaults: caller may have passed in some app-level defaults.
    457459     * preserve those and use the session defaults to fill in any missing gaps. */
    458     tr_bencInitDict( &sessionDefaults, 0 );
    459     tr_sessionGetDefaultSettings( &sessionDefaults );
    460     tr_bencMergeDicts( &sessionDefaults, d );
     460    tr_bencInitDict (&sessionDefaults, 0);
     461    tr_sessionGetDefaultSettings (&sessionDefaults);
     462    tr_bencMergeDicts (&sessionDefaults, d);
    461463    tmp = *d; *d = sessionDefaults; sessionDefaults = tmp;
    462464
    463465    /* if caller didn't specify a config dir, use the default */
    464     if( !configDir || !*configDir )
    465         configDir = tr_getDefaultConfigDir( appName );
     466    if (!configDir || !*configDir)
     467        configDir = tr_getDefaultConfigDir (appName);
    466468
    467469    /* file settings override the defaults */
    468     filename = tr_buildPath( configDir, "settings.json", NULL );
    469     err = tr_bencLoadFile( &fileSettings, TR_FMT_JSON, filename );
    470     if( !err ) {
    471         tr_bencMergeDicts( d, &fileSettings );
    472         tr_bencFree( &fileSettings );
     470    filename = tr_buildPath (configDir, "settings.json", NULL);
     471    err = tr_bencLoadFile (&fileSettings, TR_FMT_JSON, filename);
     472    if (!err) {
     473        tr_bencMergeDicts (d, &fileSettings);
     474        tr_bencFree (&fileSettings);
    473475    }
    474476
    475477    /* cleanup */
    476     tr_bencFree( &sessionDefaults );
    477     tr_free( filename );
     478    tr_bencFree (&sessionDefaults);
     479    tr_free (filename);
    478480    success = (err==0) || (err==ENOENT);
    479481    return success;
     
    481483
    482484void
    483 tr_sessionSaveSettings( tr_session    * session,
     485tr_sessionSaveSettings (tr_session    * session,
    484486                        const char    * configDir,
    485                         const tr_benc * clientSettings )
     487                        const tr_benc * clientSettings)
    486488{
    487489    tr_benc settings;
    488     char * filename = tr_buildPath( configDir, "settings.json", NULL );
    489 
    490     assert( tr_bencIsDict( clientSettings ) );
    491 
    492     tr_bencInitDict( &settings, 0 );
     490    char * filename = tr_buildPath (configDir, "settings.json", NULL);
     491
     492    assert (tr_bencIsDict (clientSettings));
     493
     494    tr_bencInitDict (&settings, 0);
    493495
    494496    /* the existing file settings are the fallback values */
    495497    {
    496498        tr_benc fileSettings;
    497         const int err = tr_bencLoadFile( &fileSettings, TR_FMT_JSON, filename );
    498         if( !err )
     499        const int err = tr_bencLoadFile (&fileSettings, TR_FMT_JSON, filename);
     500        if (!err)
    499501        {
    500             tr_bencMergeDicts( &settings, &fileSettings );
    501             tr_bencFree( &fileSettings );
     502            tr_bencMergeDicts (&settings, &fileSettings);
     503            tr_bencFree (&fileSettings);
    502504        }
    503505    }
    504506
    505507    /* the client's settings override the file settings */
    506     tr_bencMergeDicts( &settings, clientSettings );
     508    tr_bencMergeDicts (&settings, clientSettings);
    507509
    508510    /* the session's true values override the file & client settings */
    509511    {
    510512        tr_benc sessionSettings;
    511         tr_bencInitDict( &sessionSettings, 0 );
    512         tr_sessionGetSettings( session, &sessionSettings );
    513         tr_bencMergeDicts( &settings, &sessionSettings );
    514         tr_bencFree( &sessionSettings );
     513        tr_bencInitDict (&sessionSettings, 0);
     514        tr_sessionGetSettings (session, &sessionSettings);
     515        tr_bencMergeDicts (&settings, &sessionSettings);
     516        tr_bencFree (&sessionSettings);
    515517    }
    516518
    517519    /* save the result */
    518     tr_bencToFile( &settings, TR_FMT_JSON, filename );
     520    tr_bencToFile (&settings, TR_FMT_JSON, filename);
    519521
    520522    /* cleanup */
    521     tr_free( filename );
    522     tr_bencFree( &settings );
     523    tr_free (filename);
     524    tr_bencFree (&settings);
    523525}
    524526
     
    533535 */
    534536static void
    535 onSaveTimer( int foo UNUSED, short bar UNUSED, void * vsession )
     537onSaveTimer (int foo UNUSED, short bar UNUSED, void * vsession)
    536538{
    537539    tr_torrent * tor = NULL;
    538540    tr_session * session = vsession;
    539541
    540     if( tr_cacheFlushDone( session->cache ) )
    541         tr_err( "Error while flushing completed pieces from cache" );
    542 
    543     while(( tor = tr_torrentNext( session, tor )))
    544         tr_torrentSave( tor );
    545 
    546     tr_statsSaveDirty( session );
    547 
    548     tr_timerAdd( session->saveTimer, SAVE_INTERVAL_SECS, 0 );
     542    if (tr_cacheFlushDone (session->cache))
     543        tr_err ("Error while flushing completed pieces from cache");
     544
     545    while ((tor = tr_torrentNext (session, tor)))
     546        tr_torrentSave (tor);
     547
     548    tr_statsSaveDirty (session);
     549
     550    tr_timerAdd (session->saveTimer, SAVE_INTERVAL_SECS, 0);
    549551}
    550552
     
    553555***/
    554556
    555 static void tr_sessionInitImpl( void * );
     557static void tr_sessionInitImpl (void *);
    556558
    557559struct init_data
     
    565567
    566568tr_session *
    567 tr_sessionInit( const char  * tag,
     569tr_sessionInit (const char  * tag,
    568570                const char  * configDir,
    569571                bool          messageQueuingEnabled,
    570                 tr_benc     * clientSettings )
     572                tr_benc     * clientSettings)
    571573{
    572574    int64_t i;
     
    574576    struct init_data data;
    575577
    576     assert( tr_bencIsDict( clientSettings ) );
    577 
    578     tr_timeUpdate( time( NULL ) );
     578    assert (tr_bencIsDict (clientSettings));
     579
     580    tr_timeUpdate (time (NULL));
    579581
    580582    /* initialize the bare skeleton of the session object */
    581     session = tr_new0( tr_session, 1 );
     583    session = tr_new0 (tr_session, 1);
    582584    session->udp_socket = -1;
    583585    session->udp6_socket = -1;
    584     session->lock = tr_lockNew( );
    585     session->cache = tr_cacheNew( 1024*1024*2 );
    586     session->tag = tr_strdup( tag );
     586    session->lock = tr_lockNew ();
     587    session->cache = tr_cacheNew (1024*1024*2);
     588    session->tag = tr_strdup (tag);
    587589    session->magicNumber = SESSION_MAGIC_NUMBER;
    588     tr_bandwidthConstruct( &session->bandwidth, session, NULL );
    589     tr_peerIdInit( session->peer_id );
    590     tr_bencInitList( &session->removedTorrents, 0 );
     590    tr_bandwidthConstruct (&session->bandwidth, session, NULL);
     591    tr_peerIdInit (session->peer_id);
     592    tr_bencInitList (&session->removedTorrents, 0);
    591593
    592594    /* nice to start logging at the very beginning */
    593     if( tr_bencDictFindInt( clientSettings, TR_PREFS_KEY_MSGLEVEL, &i ) )
    594         tr_setMessageLevel( i );
     595    if (tr_bencDictFindInt (clientSettings, TR_PREFS_KEY_MSGLEVEL, &i))
     596        tr_setMessageLevel (i);
    595597
    596598    /* start the libtransmission thread */
    597     tr_netInit( ); /* must go before tr_eventInit */
    598     tr_eventInit( session );
    599     assert( session->events != NULL );
     599    tr_netInit (); /* must go before tr_eventInit */
     600    tr_eventInit (session);
     601    assert (session->events != NULL);
    600602
    601603    /* run the rest in the libtransmission thread */
     
    605607    data.messageQueuingEnabled = messageQueuingEnabled;
    606608    data.clientSettings = clientSettings;
    607     tr_runInEventThread( session, tr_sessionInitImpl, &data );
    608     while( !data.done )
    609         tr_wait_msec( 100 );
     609    tr_runInEventThread (session, tr_sessionInitImpl, &data);
     610    while (!data.done)
     611        tr_wait_msec (100);
    610612
    611613    return session;
    612614}
    613615
    614 static void turtleCheckClock( tr_session * s, struct tr_turtle_info * t );
     616static void turtleCheckClock (tr_session * s, struct tr_turtle_info * t);
    615617
    616618static void
    617 onNowTimer( int foo UNUSED, short bar UNUSED, void * vsession )
     619onNowTimer (int foo UNUSED, short bar UNUSED, void * vsession)
    618620{
    619621    int usec;
     
    623625    tr_torrent * tor = NULL;
    624626    tr_session * session = vsession;
    625     const time_t now = time( NULL );
    626 
    627     assert( tr_isSession( session ) );
    628     assert( session->nowTimer != NULL );
     627    const time_t now = time (NULL);
     628
     629    assert (tr_isSession (session));
     630    assert (session->nowTimer != NULL);
    629631
    630632    /**
     
    632634    **/
    633635
    634     tr_timeUpdate( now );
    635 
    636     tr_dhtUpkeep( session );
    637 
    638     if( session->turtle.isClockEnabled )
    639         turtleCheckClock( session, &session->turtle );
    640 
    641     while(( tor = tr_torrentNext( session, tor ))) {
    642         if( tor->isRunning ) {
    643             if( tr_torrentIsSeed( tor ) )
     636    tr_timeUpdate (now);
     637
     638    tr_dhtUpkeep (session);
     639
     640    if (session->turtle.isClockEnabled)
     641        turtleCheckClock (session, &session->turtle);
     642
     643    while ((tor = tr_torrentNext (session, tor))) {
     644        if (tor->isRunning) {
     645            if (tr_torrentIsSeed (tor))
    644646                ++tor->secondsSeeding;
    645647            else
     
    653655
    654656    /* schedule the next timer for right after the next second begins */
    655     gettimeofday( &tv, NULL );
     657    gettimeofday (&tv, NULL);
    656658    usec = 1000000 - tv.tv_usec;
    657     if( usec > max ) usec = max;
    658     if( usec < min ) usec = min;
    659     tr_timerAdd( session->nowTimer, 0, usec );
    660     /* fprintf( stderr, "time %zu sec, %zu microsec\n", (size_t)tr_time(), (size_t)tv.tv_usec ); */
    661 }
    662 
    663 static void loadBlocklists( tr_session * session );
     659    if (usec > max) usec = max;
     660    if (usec < min) usec = min;
     661    tr_timerAdd (session->nowTimer, 0, usec);
     662    /* fprintf (stderr, "time %zu sec, %zu microsec\n", (size_t)tr_time (), (size_t)tv.tv_usec); */
     663}
     664
     665static void loadBlocklists (tr_session * session);
    664666
    665667static void
    666 tr_sessionInitImpl( void * vdata )
     668tr_sessionInitImpl (void * vdata)
    667669{
    668670    tr_benc settings;
     
    671673    tr_session * session = data->session;
    672674
    673     assert( tr_amInEventThread( session ) );
    674     assert( tr_bencIsDict( clientSettings ) );
    675 
    676     dbgmsg( "tr_sessionInit: the session's top-level bandwidth object is %p",
    677             &session->bandwidth );
    678 
    679     tr_bencInitDict( &settings, 0 );
    680     tr_sessionGetDefaultSettings( &settings );
    681     tr_bencMergeDicts( &settings, clientSettings );
    682 
    683     assert( session->event_base != NULL );
    684     session->nowTimer = evtimer_new( session->event_base, onNowTimer, session );
    685     onNowTimer( 0, 0, session );
     675    assert (tr_amInEventThread (session));
     676    assert (tr_bencIsDict (clientSettings));
     677
     678    dbgmsg ("tr_sessionInit: the session's top-level bandwidth object is %p",
     679            &session->bandwidth);
     680
     681    tr_bencInitDict (&settings, 0);
     682    tr_sessionGetDefaultSettings (&settings);
     683    tr_bencMergeDicts (&settings, clientSettings);
     684
     685    assert (session->event_base != NULL);
     686    session->nowTimer = evtimer_new (session->event_base, onNowTimer, session);
     687    onNowTimer (0, 0, session);
    686688
    687689#ifndef WIN32
    688690    /* Don't exit when writing on a broken socket */
    689     signal( SIGPIPE, SIG_IGN );
     691    signal (SIGPIPE, SIG_IGN);
    690692#endif
    691693
    692     tr_setMessageQueuing( data->messageQueuingEnabled );
    693 
    694     tr_setConfigDir( session, data->configDir );
    695 
    696     session->peerMgr = tr_peerMgrNew( session );
    697 
    698     session->shared = tr_sharedInit( session );
     694    tr_setMessageQueuing (data->messageQueuingEnabled);
     695
     696    tr_setConfigDir (session, data->configDir);
     697
     698    session->peerMgr = tr_peerMgrNew (session);
     699
     700    session->shared = tr_sharedInit (session);
    699701
    700702    /**
     
    703705
    704706    {
    705         char * filename = tr_buildPath( session->configDir, "blocklists", NULL );
    706         tr_mkdirp( filename, 0777 );
    707         tr_free( filename );
    708         loadBlocklists( session );
    709     }
    710 
    711     assert( tr_isSession( session ) );
    712 
    713     session->saveTimer = evtimer_new( session->event_base, onSaveTimer, session );
    714     tr_timerAdd( session->saveTimer, SAVE_INTERVAL_SECS, 0 );
    715 
    716     tr_announcerInit( session );
     707        char * filename = tr_buildPath (session->configDir, "blocklists", NULL);
     708        tr_mkdirp (filename, 0777);
     709        tr_free (filename);
     710        loadBlocklists (session);
     711    }
     712
     713    assert (tr_isSession (session));
     714
     715    session->saveTimer = evtimer_new (session->event_base, onSaveTimer, session);
     716    tr_timerAdd (session->saveTimer, SAVE_INTERVAL_SECS, 0);
     717
     718    tr_announcerInit (session);
    717719
    718720    /* first %s is the application name
    719721       second %s is the version number */
    720     tr_inf( _( "%s %s started" ), TR_NAME, LONG_VERSION_STRING );
    721 
    722     tr_statsInit( session );
    723 
    724     tr_webInit( session );
    725 
    726     tr_sessionSet( session, &settings );
    727 
    728     tr_udpInit( session );
    729 
    730     if( session->isLPDEnabled )
    731         tr_lpdInit( session, &session->public_ipv4->addr );
     722    tr_inf (_ ("%s %s started"), TR_NAME, LONG_VERSION_STRING);
     723
     724    tr_statsInit (session);
     725
     726    tr_webInit (session);
     727
     728    tr_sessionSet (session, &settings);
     729
     730    tr_udpInit (session);
     731
     732    if (session->isLPDEnabled)
     733        tr_lpdInit (session, &session->public_ipv4->addr);
    732734
    733735    /* cleanup */
    734     tr_bencFree( &settings );
     736    tr_bencFree (&settings);
    735737    data->done = true;
    736738}
    737739
    738 static void turtleBootstrap( tr_session *, struct tr_turtle_info * );
    739 static void setPeerPort( tr_session * session, tr_port port );
     740static void turtleBootstrap (tr_session *, struct tr_turtle_info *);
     741static void setPeerPort (tr_session * session, tr_port port);
    740742
    741743static void
    742 sessionSetImpl( void * vdata )
     744sessionSetImpl (void * vdata)
    743745{
    744746    int64_t i;
     
    752754    struct tr_turtle_info * turtle = &session->turtle;
    753755
    754     assert( tr_isSession( session ) );
    755     assert( tr_bencIsDict( settings ) );
    756     assert( tr_amInEventThread( session ) );
    757 
    758     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_MSGLEVEL, &i ) )
    759         tr_setMessageLevel( i );
    760 
    761     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_UMASK, &i ) ) {
     756    assert (tr_isSession (session));
     757    assert (tr_bencIsDict (settings));
     758    assert (tr_amInEventThread (session));
     759
     760    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_MSGLEVEL, &i))
     761        tr_setMessageLevel (i);
     762
     763    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_UMASK, &i)) {
    762764        session->umask = (mode_t)i;
    763         umask( session->umask );
     765        umask (session->umask);
    764766    }
    765767
    766768    /* misc features */
    767     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i ) )
    768         tr_sessionSetCacheLimit_MB( session, i );
    769     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i ) )
    770         tr_sessionSetPeerLimitPerTorrent( session, i );
    771     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PEX_ENABLED, &boolVal ) )
    772         tr_sessionSetPexEnabled( session, boolVal );
    773     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_DHT_ENABLED, &boolVal ) )
    774         tr_sessionSetDHTEnabled( session, boolVal );
    775     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_UTP_ENABLED, &boolVal ) )
    776         tr_sessionSetUTPEnabled( session, boolVal );
    777     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_LPD_ENABLED, &boolVal ) )
    778         tr_sessionSetLPDEnabled( session, boolVal );
    779     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ENCRYPTION, &i ) )
    780         tr_sessionSetEncryption( session, i );
    781     if( tr_bencDictFindStr( settings, TR_PREFS_KEY_PEER_SOCKET_TOS, &str ) )
    782         session->peerSocketTOS = parse_tos( str );
    783     if( tr_bencDictFindStr( settings, TR_PREFS_KEY_PEER_CONGESTION_ALGORITHM, &str ) )
    784         session->peer_congestion_algorithm = tr_strdup(str);
     769    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i))
     770        tr_sessionSetCacheLimit_MB (session, i);
     771    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i))
     772        tr_sessionSetPeerLimitPerTorrent (session, i);
     773    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_PEX_ENABLED, &boolVal))
     774        tr_sessionSetPexEnabled (session, boolVal);
     775    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_DHT_ENABLED, &boolVal))
     776        tr_sessionSetDHTEnabled (session, boolVal);
     777    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_UTP_ENABLED, &boolVal))
     778        tr_sessionSetUTPEnabled (session, boolVal);
     779    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_LPD_ENABLED, &boolVal))
     780        tr_sessionSetLPDEnabled (session, boolVal);
     781    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ENCRYPTION, &i))
     782        tr_sessionSetEncryption (session, i);
     783    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_PEER_SOCKET_TOS, &str))
     784        session->peerSocketTOS = parse_tos (str);
     785    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_PEER_CONGESTION_ALGORITHM, &str))
     786        session->peer_congestion_algorithm = tr_strdup (str);
    785787    else
    786         session->peer_congestion_algorithm = tr_strdup("");
    787     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal ) )
    788         tr_blocklistSetEnabled( session, boolVal );
    789     if( tr_bencDictFindStr( settings, TR_PREFS_KEY_BLOCKLIST_URL, &str ) )
    790         tr_blocklistSetURL( session, str );
    791     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_START, &boolVal ) )
    792         tr_sessionSetPaused( session, !boolVal );
    793     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal) )
    794         tr_sessionSetDeleteSource( session, boolVal );
     788        session->peer_congestion_algorithm = tr_strdup ("");
     789    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal))
     790        tr_blocklistSetEnabled (session, boolVal);
     791    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_BLOCKLIST_URL, &str))
     792        tr_blocklistSetURL (session, str);
     793    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_START, &boolVal))
     794        tr_sessionSetPaused (session, !boolVal);
     795    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal))
     796        tr_sessionSetDeleteSource (session, boolVal);
    795797
    796798    /* torrent queues */
    797     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_QUEUE_STALLED_MINUTES, &i ) )
    798         tr_sessionSetQueueStalledMinutes( session, i );
    799     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_QUEUE_STALLED_ENABLED, &boolVal ) )
    800         tr_sessionSetQueueStalledEnabled( session, boolVal );
    801     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, &i ) )
    802         tr_sessionSetQueueSize( session, TR_DOWN, i );
    803     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED, &boolVal ) )
    804         tr_sessionSetQueueEnabled( session, TR_DOWN, boolVal );
    805     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_SEED_QUEUE_SIZE, &i ) )
    806         tr_sessionSetQueueSize( session, TR_UP, i );
    807     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_SEED_QUEUE_ENABLED, &boolVal ) )
    808         tr_sessionSetQueueEnabled( session, TR_UP, boolVal );
     799    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_QUEUE_STALLED_MINUTES, &i))
     800        tr_sessionSetQueueStalledMinutes (session, i);
     801    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_QUEUE_STALLED_ENABLED, &boolVal))
     802        tr_sessionSetQueueStalledEnabled (session, boolVal);
     803    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, &i))
     804        tr_sessionSetQueueSize (session, TR_DOWN, i);
     805    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_DOWNLOAD_QUEUE_ENABLED, &boolVal))
     806        tr_sessionSetQueueEnabled (session, TR_DOWN, boolVal);
     807    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_SEED_QUEUE_SIZE, &i))
     808        tr_sessionSetQueueSize (session, TR_UP, i);
     809    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_SEED_QUEUE_ENABLED, &boolVal))
     810        tr_sessionSetQueueEnabled (session, TR_UP, boolVal);
    809811
    810812    /* files and directories */
    811     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PREFETCH_ENABLED, &boolVal ) )
     813    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_PREFETCH_ENABLED, &boolVal))
    812814        session->isPrefetchEnabled = boolVal;
    813     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_PREALLOCATION, &i ) )
     815    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PREALLOCATION, &i))
    814816        session->preallocationMode = i;
    815     if( tr_bencDictFindStr( settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
    816         tr_sessionSetDownloadDir( session, str );
    817     if( tr_bencDictFindStr( settings, TR_PREFS_KEY_INCOMPLETE_DIR, &str ) )
    818         tr_sessionSetIncompleteDir( session, str );
    819     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, &boolVal ) )
    820         tr_sessionSetIncompleteDirEnabled( session, boolVal );
    821     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_RENAME_PARTIAL_FILES, &boolVal ) )
    822         tr_sessionSetIncompleteFileNamingEnabled( session, boolVal );
     817    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str))
     818        tr_sessionSetDownloadDir (session, str);
     819    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_INCOMPLETE_DIR, &str))
     820        tr_sessionSetIncompleteDir (session, str);
     821    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, &boolVal))
     822        tr_sessionSetIncompleteDirEnabled (session, boolVal);
     823    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_RENAME_PARTIAL_FILES, &boolVal))
     824        tr_sessionSetIncompleteFileNamingEnabled (session, boolVal);
    823825
    824826    /* rpc server */
    825     if( session->rpcServer != NULL ) /* close the old one */
    826         tr_rpcClose( &session->rpcServer );
    827     session->rpcServer = tr_rpcInit( session, settings );
     827    if (session->rpcServer != NULL) /* close the old one */
     828        tr_rpcClose (&session->rpcServer);
     829    session->rpcServer = tr_rpcInit (session, settings);
    828830
    829831    /* public addresses */
    830832
    831     free_incoming_peer_port( session );
     833    free_incoming_peer_port (session);
    832834
    833835    str = TR_PREFS_KEY_BIND_ADDRESS_IPV4;
    834     tr_bencDictFindStr( settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, &str );
    835     if( !tr_address_from_string( &b.addr, str ) || ( b.addr.type != TR_AF_INET ) )
     836    tr_bencDictFindStr (settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, &str);
     837    if (!tr_address_from_string (&b.addr, str) || (b.addr.type != TR_AF_INET))
    836838        b.addr = tr_inaddr_any;
    837839    b.socket = -1;
    838     session->public_ipv4 = tr_memdup( &b, sizeof( struct tr_bindinfo ) );
     840    session->public_ipv4 = tr_memdup (&b, sizeof (struct tr_bindinfo));
    839841
    840842    str = TR_PREFS_KEY_BIND_ADDRESS_IPV6;
    841     tr_bencDictFindStr( settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, &str );
    842     if( !tr_address_from_string( &b.addr, str ) || ( b.addr.type != TR_AF_INET6 ) )
     843    tr_bencDictFindStr (settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, &str);
     844    if (!tr_address_from_string (&b.addr, str) || (b.addr.type != TR_AF_INET6))
    843845        b.addr = tr_in6addr_any;
    844846    b.socket = -1;
    845     session->public_ipv6 = tr_memdup( &b, sizeof( struct tr_bindinfo ) );
     847    session->public_ipv6 = tr_memdup (&b, sizeof (struct tr_bindinfo));
    846848
    847849    /* incoming peer port */
    848     if( tr_bencDictFindInt ( settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i ) )
     850    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i))
    849851        session->randomPortLow = i;
    850     if( tr_bencDictFindInt ( settings, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, &i ) )
     852    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, &i))
    851853        session->randomPortHigh = i;
    852     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, &boolVal ) )
    853         tr_sessionSetPeerPortRandomOnStart( session, boolVal );
    854     if( !tr_bencDictFindInt( settings, TR_PREFS_KEY_PEER_PORT, &i ) )
     854    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, &boolVal))
     855        tr_sessionSetPeerPortRandomOnStart (session, boolVal);
     856    if (!tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_PORT, &i))
    855857        i = session->private_peer_port;
    856     setPeerPort( session, boolVal ? getRandomPort( session ) : i );
    857     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_PORT_FORWARDING, &boolVal ) )
    858         tr_sessionSetPortForwardingEnabled( session, boolVal );
    859 
    860     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i ) )
     858    setPeerPort (session, boolVal ? getRandomPort (session) : i);
     859    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_PORT_FORWARDING, &boolVal))
     860        tr_sessionSetPortForwardingEnabled (session, boolVal);
     861
     862    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i))
    861863        session->peerLimit = i;
    862864
     
    864866    **/
    865867
    866     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, &i ) )
     868    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, &i))
    867869        session->uploadSlotsPerTorrent = i;
    868870
    869     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_USPEED_KBps, &i ) )
    870         tr_sessionSetSpeedLimit_KBps( session, TR_UP, i );
    871     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_USPEED_ENABLED, &boolVal ) )
    872         tr_sessionLimitSpeed( session, TR_UP, boolVal );
    873 
    874     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_DSPEED_KBps, &i ) )
    875         tr_sessionSetSpeedLimit_KBps( session, TR_DOWN, i );
    876     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal ) )
    877         tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
    878 
    879     if( tr_bencDictFindReal( settings, TR_PREFS_KEY_RATIO, &d ) )
    880         tr_sessionSetRatioLimit( session, d );
    881     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_RATIO_ENABLED, &boolVal ) )
    882         tr_sessionSetRatioLimited( session, boolVal );
    883 
    884     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_IDLE_LIMIT, &i ) )
    885         tr_sessionSetIdleLimit( session, i );
    886     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, &boolVal ) )
    887         tr_sessionSetIdleLimited( session, boolVal );
     871    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_USPEED_KBps, &i))
     872        tr_sessionSetSpeedLimit_KBps (session, TR_UP, i);
     873    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_USPEED_ENABLED, &boolVal))
     874        tr_sessionLimitSpeed (session, TR_UP, boolVal);
     875
     876    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_DSPEED_KBps, &i))
     877        tr_sessionSetSpeedLimit_KBps (session, TR_DOWN, i);
     878    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal))
     879        tr_sessionLimitSpeed (session, TR_DOWN, boolVal);
     880
     881    if (tr_bencDictFindReal (settings, TR_PREFS_KEY_RATIO, &d))
     882        tr_sessionSetRatioLimit (session, d);
     883    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_RATIO_ENABLED, &boolVal))
     884        tr_sessionSetRatioLimited (session, boolVal);
     885
     886    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_IDLE_LIMIT, &i))
     887        tr_sessionSetIdleLimit (session, i);
     888    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, &boolVal))
     889        tr_sessionSetIdleLimited (session, boolVal);
    888890
    889891    /**
     
    892894
    893895    /* update the turtle mode's fields */
    894     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &i ) )
    895         turtle->speedLimit_Bps[TR_UP] = toSpeedBytes( i );
    896     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &i ) )
    897         turtle->speedLimit_Bps[TR_DOWN] = toSpeedBytes( i );
    898     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i ) )
     896    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &i))
     897        turtle->speedLimit_Bps[TR_UP] = toSpeedBytes (i);
     898    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &i))
     899        turtle->speedLimit_Bps[TR_DOWN] = toSpeedBytes (i);
     900    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i))
    899901        turtle->beginMinute = i;
    900     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i ) )
     902    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i))
    901903        turtle->endMinute = i;
    902     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &i ) )
     904    if (tr_bencDictFindInt (settings, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &i))
    903905        turtle->days = i;
    904     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal ) )
     906    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal))
    905907        turtle->isClockEnabled = boolVal;
    906     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal ) )
     908    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal))
    907909        turtle->isEnabled = boolVal;
    908     turtleBootstrap( session, turtle );
     910    turtleBootstrap (session, turtle);
    909911
    910912    /**
     
    912914    **/
    913915
    914     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, &boolVal ) )
    915         tr_sessionSetTorrentDoneScriptEnabled( session, boolVal );
    916     if( tr_bencDictFindStr( settings, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, &str ) )
    917         tr_sessionSetTorrentDoneScript( session, str );
    918 
    919 
    920     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS, &boolVal ) )
     916    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, &boolVal))
     917        tr_sessionSetTorrentDoneScriptEnabled (session, boolVal);
     918    if (tr_bencDictFindStr (settings, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, &str))
     919        tr_sessionSetTorrentDoneScript (session, str);
     920
     921
     922    if (tr_bencDictFindBool (settings, TR_PREFS_KEY_SCRAPE_PAUSED_TORRENTS, &boolVal))
    921923        session->scrapePausedTorrents = boolVal;
    922924
     
    925927
    926928void
    927 tr_sessionSet( tr_session * session, struct tr_benc  * settings )
     929tr_sessionSet (tr_session * session, struct tr_benc  * settings)
    928930{
    929931    struct init_data data;
     
    933935
    934936    /* run the rest in the libtransmission thread */
    935     tr_runInEventThread( session, sessionSetImpl, &data );
    936     while( !data.done )
    937         tr_wait_msec( 100 );
     937    tr_runInEventThread (session, sessionSetImpl, &data);
     938    while (!data.done)
     939        tr_wait_msec (100);
    938940}
    939941
     
    943945
    944946void
    945 tr_sessionSetDownloadDir( tr_session * session, const char * dir )
    946 {
    947     assert( tr_isSession( session ) );
    948 
    949     if( session->downloadDir != dir )
     947tr_sessionSetDownloadDir (tr_session * session, const char * dir)
     948{
     949    assert (tr_isSession (session));
     950
     951    if (session->downloadDir != dir)
    950952    {
    951         tr_free( session->downloadDir );
    952         session->downloadDir = tr_strdup( dir );
     953        tr_free (session->downloadDir);
     954        session->downloadDir = tr_strdup (dir);
    953955    }
    954956}
    955957
    956958const char *
    957 tr_sessionGetDownloadDir( const tr_session * session )
    958 {
    959     assert( tr_isSession( session ) );
     959tr_sessionGetDownloadDir (const tr_session * session)
     960{
     961    assert (tr_isSession (session));
    960962
    961963    return session->downloadDir;
     
    963965
    964966int64_t
    965 tr_sessionGetDownloadDirFreeSpace( const tr_session * session )
    966 {
    967     assert( tr_isSession( session ) );
    968 
    969     return tr_getFreeSpace( session->downloadDir );
     967tr_sessionGetDownloadDirFreeSpace (const tr_session * session)
     968{
     969    assert (tr_isSession (session));
     970
     971    return tr_getFreeSpace (session->downloadDir);
    970972}
    971973
     
    975977
    976978void
    977 tr_sessionSetIncompleteFileNamingEnabled( tr_session * session, bool b )
    978 {
    979     assert( tr_isSession( session ) );
    980     assert( tr_isBool( b ) );
     979tr_sessionSetIncompleteFileNamingEnabled (tr_session * session, bool b)
     980{
     981    assert (tr_isSession (session));
     982    assert (tr_isBool (b));
    981983
    982984    session->isIncompleteFileNamingEnabled = b;
     
    984986
    985987bool
    986 tr_sessionIsIncompleteFileNamingEnabled( const tr_session * session )
    987 {
    988     assert( tr_isSession( session ) );
     988tr_sessionIsIncompleteFileNamingEnabled (const tr_session * session)
     989{
     990    assert (tr_isSession (session));
    989991
    990992    return session->isIncompleteFileNamingEnabled;
     
    997999
    9981000void
    999 tr_sessionSetIncompleteDir( tr_session * session, const char * dir )
    1000 {
    1001     assert( tr_isSession( session ) );
    1002 
    1003     if( session->incompleteDir != dir )
     1001tr_sessionSetIncompleteDir (tr_session * session, const char * dir)
     1002{
     1003    assert (tr_isSession (session));
     1004
     1005    if (session->incompleteDir != dir)
    10041006    {
    1005         tr_free( session->incompleteDir );
    1006 
    1007         session->incompleteDir = tr_strdup( dir );
     1007        tr_free (session->incompleteDir);
     1008
     1009        session->incompleteDir = tr_strdup (dir);
    10081010    }
    10091011}
    10101012
    10111013const char*
    1012 tr_sessionGetIncompleteDir( const tr_session * session )
    1013 {
    1014     assert( tr_isSession( session ) );
     1014tr_sessionGetIncompleteDir (const tr_session * session)
     1015{
     1016    assert (tr_isSession (session));
    10151017
    10161018    return session->incompleteDir;
     
    10181020
    10191021void
    1020 tr_sessionSetIncompleteDirEnabled( tr_session * session, bool b )
    1021 {
    1022     assert( tr_isSession( session ) );
    1023     assert( tr_isBool( b ) );
     1022tr_sessionSetIncompleteDirEnabled (tr_session * session, bool b)
     1023{
     1024    assert (tr_isSession (session));
     1025    assert (tr_isBool (b));
    10241026
    10251027    session->isIncompleteDirEnabled = b;
     
    10271029
    10281030bool
    1029 tr_sessionIsIncompleteDirEnabled( const tr_session * session )
    1030 {
    1031     assert( tr_isSession( session ) );
     1031tr_sessionIsIncompleteDirEnabled (const tr_session * session)
     1032{
     1033    assert (tr_isSession (session));
    10321034
    10331035    return session->isIncompleteDirEnabled;
     
    10391041
    10401042void
    1041 tr_sessionLock( tr_session * session )
    1042 {
    1043     assert( tr_isSession( session ) );
    1044 
    1045     tr_lockLock( session->lock );
    1046 }
    1047 
    1048 void
    1049 tr_sessionUnlock( tr_session * session )
    1050 {
    1051     assert( tr_isSession( session ) );
    1052 
    1053     tr_lockUnlock( session->lock );
    1054 }
    1055 
    1056 bool
    1057 tr_sessionIsLocked( const tr_session * session )
    1058 {
    1059     return tr_isSession( session ) && tr_lockHave( session->lock );
     1043tr_sessionLock (tr_session * session)
     1044{
     1045    assert (tr_isSession (session));
     1046
     1047    tr_lockLock (session->lock);
     1048}
     1049
     1050void
     1051tr_sessionUnlock (tr_session * session)
     1052{
     1053    assert (tr_isSession (session));
     1054
     1055    tr_lockUnlock (session->lock);
     1056}
     1057
     1058bool
     1059tr_sessionIsLocked (const tr_session * session)
     1060{
     1061    return tr_isSession (session) && tr_lockHave (session->lock);
    10601062}
    10611063
     
    10671069
    10681070static void
    1069 peerPortChanged( void * session )
     1071peerPortChanged (void * session)
    10701072{
    10711073    tr_torrent * tor = NULL;
    10721074
    1073     assert( tr_isSession( session ) );
    1074 
    1075     close_incoming_peer_port( session );
    1076     open_incoming_peer_port( session );
    1077     tr_sharedPortChanged( session );
    1078 
    1079     while(( tor = tr_torrentNext( session, tor )))
    1080         tr_torrentChangeMyPort( tor );
     1075    assert (tr_isSession (session));
     1076
     1077    close_incoming_peer_port (session);
     1078    open_incoming_peer_port (session);
     1079    tr_sharedPortChanged (session);
     1080
     1081    while ((tor = tr_torrentNext (session, tor)))
     1082        tr_torrentChangeMyPort (tor);
    10811083}
    10821084
    10831085static void
    1084 setPeerPort( tr_session * session, tr_port port )
     1086setPeerPort (tr_session * session, tr_port port)
    10851087{
    10861088    session->private_peer_port = port;
    10871089    session->public_peer_port = port;
    10881090
    1089     tr_runInEventThread( session, peerPortChanged, session );
    1090 }
    1091 
    1092 void
    1093 tr_sessionSetPeerPort( tr_session * session, tr_port port )
    1094 {
    1095     if( tr_isSession( session ) && ( session->private_peer_port != port ) )
     1091    tr_runInEventThread (session, peerPortChanged, session);
     1092}
     1093
     1094void
     1095tr_sessionSetPeerPort (tr_session * session, tr_port port)
     1096{
     1097    if (tr_isSession (session) && (session->private_peer_port != port))
    10961098    {
    1097         setPeerPort( session, port );
     1099        setPeerPort (session, port);
    10981100    }
    10991101}
    11001102
    11011103tr_port
    1102 tr_sessionGetPeerPort( const tr_session * session )
    1103 {
    1104     return tr_isSession( session ) ? session->private_peer_port : 0;
     1104tr_sessionGetPeerPort (const tr_session * session)
     1105{
     1106    return tr_isSession (session) ? session->private_peer_port : 0;
    11051107}
    11061108
    11071109tr_port
    1108 tr_sessionSetPeerPortRandom( tr_session * session )
    1109 {
    1110     assert( tr_isSession( session ) );
    1111 
    1112     tr_sessionSetPeerPort( session, getRandomPort( session ) );
     1110tr_sessionSetPeerPortRandom (tr_session * session)
     1111{
     1112    assert (tr_isSession (session));
     1113
     1114    tr_sessionSetPeerPort (session, getRandomPort (session));
    11131115    return session->private_peer_port;
    11141116}
    11151117
    11161118void
    1117 tr_sessionSetPeerPortRandomOnStart( tr_session * session,
    1118                                     bool random )
    1119 {
    1120     assert( tr_isSession( session ) );
     1119tr_sessionSetPeerPortRandomOnStart (tr_session * session,
     1120                                    bool random)
     1121{
     1122    assert (tr_isSession (session));
    11211123
    11221124    session->isPortRandom = random;
     
    11241126
    11251127bool
    1126 tr_sessionGetPeerPortRandomOnStart( tr_session * session )
    1127 {
    1128     assert( tr_isSession( session ) );
     1128tr_sessionGetPeerPortRandomOnStart (tr_session * session)
     1129{
     1130    assert (tr_isSession (session));
    11291131
    11301132    return session->isPortRandom;
     
    11321134
    11331135tr_port_forwarding
    1134 tr_sessionGetPortForwarding( const tr_session * session )
    1135 {
    1136     assert( tr_isSession( session ) );
    1137 
    1138     return tr_sharedTraversalStatus( session->shared );
     1136tr_sessionGetPortForwarding (const tr_session * session)
     1137{
     1138    assert (tr_isSession (session));
     1139
     1140    return tr_sharedTraversalStatus (session->shared);
    11391141}
    11401142
     
    11441146
    11451147void
    1146 tr_sessionSetRatioLimited( tr_session * session, bool isLimited )
    1147 {
    1148     assert( tr_isSession( session ) );
     1148tr_sessionSetRatioLimited (tr_session * session, bool isLimited)
     1149{
     1150    assert (tr_isSession (session));
    11491151
    11501152    session->isRatioLimited = isLimited;
     
    11521154
    11531155void
    1154 tr_sessionSetRatioLimit( tr_session * session, double desiredRatio )
    1155 {
    1156     assert( tr_isSession( session ) );
     1156tr_sessionSetRatioLimit (tr_session * session, double desiredRatio)
     1157{
     1158    assert (tr_isSession (session));
    11571159
    11581160    session->desiredRatio = desiredRatio;
     
    11601162
    11611163bool
    1162 tr_sessionIsRatioLimited( const tr_session  * session )
    1163 {
    1164     assert( tr_isSession( session ) );
     1164tr_sessionIsRatioLimited (const tr_session  * session)
     1165{
     1166    assert (tr_isSession (session));
    11651167
    11661168    return session->isRatioLimited;
     
    11681170
    11691171double
    1170 tr_sessionGetRatioLimit( const tr_session * session )
    1171 {
    1172     assert( tr_isSession( session ) );
     1172tr_sessionGetRatioLimit (const tr_session * session)
     1173{
     1174    assert (tr_isSession (session));
    11731175
    11741176    return session->desiredRatio;
     
    11801182
    11811183void
    1182 tr_sessionSetIdleLimited( tr_session * session, bool isLimited )
    1183 {
    1184     assert( tr_isSession( session ) );
     1184tr_sessionSetIdleLimited (tr_session * session, bool isLimited)
     1185{
     1186    assert (tr_isSession (session));
    11851187
    11861188    session->isIdleLimited = isLimited;
     
    11881190
    11891191void
    1190 tr_sessionSetIdleLimit( tr_session * session, uint16_t idleMinutes )
    1191 {
    1192     assert( tr_isSession( session ) );
     1192tr_sessionSetIdleLimit (tr_session * session, uint16_t idleMinutes)
     1193{
     1194    assert (tr_isSession (session));
    11931195
    11941196    session->idleLimitMinutes = idleMinutes;
     
    11961198
    11971199bool
    1198 tr_sessionIsIdleLimited( const tr_session  * session )
    1199 {
    1200     assert( tr_isSession( session ) );
     1200tr_sessionIsIdleLimited (const tr_session  * session)
     1201{
     1202    assert (tr_isSession (session));
    12011203
    12021204    return session->isIdleLimited;
     
    12041206
    12051207uint16_t
    1206 tr_sessionGetIdleLimit( const tr_session * session )
    1207 {
    1208     assert( tr_isSession( session ) );
     1208tr_sessionGetIdleLimit (const tr_session * session)
     1209{
     1210    assert (tr_isSession (session));
    12091211
    12101212    return session->idleLimitMinutes;
     
    12181220
    12191221bool
    1220 tr_sessionGetActiveSpeedLimit_Bps( const tr_session * session, tr_direction dir, unsigned int * setme_Bps )
     1222tr_sessionGetActiveSpeedLimit_Bps (const tr_session * session, tr_direction dir, unsigned int * setme_Bps)
    12211223{
    12221224    int isLimited = true;
    12231225
    1224     if( !tr_isSession( session ) )
     1226    if (!tr_isSession (session))
    12251227        return false;
    12261228
    1227     if( tr_sessionUsesAltSpeed( session ) )
    1228         *setme_Bps = tr_sessionGetAltSpeed_Bps( session, dir );
    1229     else if( tr_sessionIsSpeedLimited( session, dir ) )
    1230         *setme_Bps = tr_sessionGetSpeedLimit_Bps( session, dir );
     1229    if (tr_sessionUsesAltSpeed (session))
     1230        *setme_Bps = tr_sessionGetAltSpeed_Bps (session, dir);
     1231    else if (tr_sessionIsSpeedLimited (session, dir))
     1232        *setme_Bps = tr_sessionGetSpeedLimit_Bps (session, dir);
    12311233    else
    12321234        isLimited = false;
     
    12351237}
    12361238bool
    1237 tr_sessionGetActiveSpeedLimit_KBps( const tr_session  * session,
     1239tr_sessionGetActiveSpeedLimit_KBps (const tr_session  * session,
    12381240                                    tr_direction        dir,
    1239                                     double            * setme_KBps )
     1241                                    double            * setme_KBps)
    12401242{
    12411243    unsigned int Bps = 0;
    1242     const bool is_active = tr_sessionGetActiveSpeedLimit_Bps( session, dir, &Bps );
    1243     *setme_KBps = toSpeedKBps( Bps );
     1244    const bool is_active = tr_sessionGetActiveSpeedLimit_Bps (session, dir, &Bps);
     1245    *setme_KBps = toSpeedKBps (Bps);
    12441246    return is_active;
    12451247}
    12461248
    12471249static void
    1248 updateBandwidth( tr_session * session, tr_direction dir )
     1250updateBandwidth (tr_session * session, tr_direction dir)
    12491251{
    12501252    unsigned int limit_Bps = 0;
    1251     const bool isLimited = tr_sessionGetActiveSpeedLimit_Bps( session, dir, &limit_Bps );
     1253    const bool isLimited = tr_sessionGetActiveSpeedLimit_Bps (session, dir, &limit_Bps);
    12521254    const bool zeroCase = isLimited && !limit_Bps;
    12531255
    1254     tr_bandwidthSetLimited( &session->bandwidth, dir, isLimited && !zeroCase );
    1255 
    1256     tr_bandwidthSetDesiredSpeed_Bps( &session->bandwidth, dir, limit_Bps );
     1256    tr_bandwidthSetLimited (&session->bandwidth, dir, isLimited && !zeroCase);
     1257
     1258    tr_bandwidthSetDesiredSpeed_Bps (&session->bandwidth, dir, limit_Bps);
    12571259}
    12581260
     
    12651267
    12661268static void
    1267 turtleUpdateTable( struct tr_turtle_info * t )
     1269turtleUpdateTable (struct tr_turtle_info * t)
    12681270{
    12691271    int day;
    12701272    tr_bitfield * b = &t->minutes;
    12711273
    1272     tr_bitfieldSetHasNone( b );
    1273 
    1274     for( day=0; day<7; ++day )
     1274    tr_bitfieldSetHasNone (b);
     1275
     1276    for (day=0; day<7; ++day)
    12751277    {
    1276         if( t->days & (1<<day) )
     1278        if (t->days & (1<<day))
    12771279        {
    12781280            int i;
     
    12801282            time_t end = t->endMinute;
    12811283
    1282             if( end <= begin )
     1284            if (end <= begin)
    12831285                end += MINUTES_PER_DAY;
    12841286
    1285             for( i=begin; i<end; ++i )
    1286                 tr_bitfieldAdd( b, (i+day*MINUTES_PER_DAY) % MINUTES_PER_WEEK );
     1287            for (i=begin; i<end; ++i)
     1288                tr_bitfieldAdd (b, (i+day*MINUTES_PER_DAY) % MINUTES_PER_WEEK);
    12871289        }
    12881290    }
     
    12901292
    12911293static void
    1292 altSpeedToggled( void * vsession )
     1294altSpeedToggled (void * vsession)
    12931295{
    12941296    tr_session * session = vsession;
    12951297    struct tr_turtle_info * t = &session->turtle;
    12961298
    1297     assert( tr_isSession( session ) );
    1298 
    1299     updateBandwidth( session, TR_UP );
    1300     updateBandwidth( session, TR_DOWN );
    1301 
    1302     if( t->callback != NULL )
    1303         (*t->callback)( session, t->isEnabled, t->changedByUser, t->callbackUserData );
     1299    assert (tr_isSession (session));
     1300
     1301    updateBandwidth (session, TR_UP);
     1302    updateBandwidth (session, TR_DOWN);
     1303
     1304    if (t->callback != NULL)
     1305      (*t->callback)(session, t->isEnabled, t->changedByUser, t->callbackUserData);
    13041306}
    13051307
    13061308static void
    1307 useAltSpeed( tr_session * s, struct tr_turtle_info * t,
    1308              bool enabled, bool byUser )
    1309 {
    1310     assert( tr_isSession( s ) );
    1311     assert( t != NULL );
    1312     assert( tr_isBool( enabled ) );
    1313     assert( tr_isBool( byUser ) );
    1314 
    1315     if( t->isEnabled != enabled )
     1309useAltSpeed (tr_session * s, struct tr_turtle_info * t,
     1310             bool enabled, bool byUser)
     1311{
     1312    assert (tr_isSession (s));
     1313    assert (t != NULL);
     1314    assert (tr_isBool (enabled));
     1315    assert (tr_isBool (byUser));
     1316
     1317    if (t->isEnabled != enabled)
    13161318    {
    13171319        t->isEnabled = enabled;
    13181320        t->changedByUser = byUser;
    1319         tr_runInEventThread( s, altSpeedToggled, s );
     1321        tr_runInEventThread (s, altSpeedToggled, s);
    13201322    }
    13211323}
     
    13251327 */
    13261328static bool
    1327 getInTurtleTime( const struct tr_turtle_info * t )
     1329getInTurtleTime (const struct tr_turtle_info * t)
    13281330{
    13291331    struct tm tm;
    13301332    size_t minute_of_the_week;
    1331     const time_t now = tr_time( );
    1332 
    1333     tr_localtime_r( &now, &tm );
     1333    const time_t now = tr_time ();
     1334
     1335    tr_localtime_r (&now, &tm);
    13341336
    13351337    minute_of_the_week = tm.tm_wday * MINUTES_PER_DAY
    13361338                       + tm.tm_hour * MINUTES_PER_HOUR
    13371339                       + tm.tm_min;
    1338     if( minute_of_the_week >= MINUTES_PER_WEEK ) /* leap minutes? */
     1340    if (minute_of_the_week >= MINUTES_PER_WEEK) /* leap minutes? */
    13391341        minute_of_the_week = MINUTES_PER_WEEK - 1;
    13401342
    1341     return tr_bitfieldHas( &t->minutes, minute_of_the_week );
     1343    return tr_bitfieldHas (&t->minutes, minute_of_the_week);
    13421344}
    13431345
    13441346static inline tr_auto_switch_state_t
    1345 autoSwitchState( bool enabled )
     1347autoSwitchState (bool enabled)
    13461348{
    13471349    return enabled ? TR_AUTO_SWITCH_ON : TR_AUTO_SWITCH_OFF;
     
    13491351
    13501352static void
    1351 turtleCheckClock( tr_session * s, struct tr_turtle_info * t )
     1353turtleCheckClock (tr_session * s, struct tr_turtle_info * t)
    13521354{
    13531355    bool enabled;
     
    13551357    tr_auto_switch_state_t newAutoTurtleState;
    13561358
    1357     assert( t->isClockEnabled );
    1358 
    1359     enabled = getInTurtleTime( t );
    1360     newAutoTurtleState = autoSwitchState( enabled );
    1361     alreadySwitched = ( t->autoTurtleState == newAutoTurtleState );
    1362 
    1363     if( !alreadySwitched )
     1359    assert (t->isClockEnabled);
     1360
     1361    enabled = getInTurtleTime (t);
     1362    newAutoTurtleState = autoSwitchState (enabled);
     1363    alreadySwitched = (t->autoTurtleState == newAutoTurtleState);
     1364
     1365    if (!alreadySwitched)
    13641366    {
    1365         tr_inf( "Time to turn %s turtle mode!", (enabled?"on":"off") );
     1367        tr_inf ("Time to turn %s turtle mode!", (enabled?"on":"off"));
    13661368        t->autoTurtleState = newAutoTurtleState;
    1367         useAltSpeed( s, t, enabled, false );
     1369        useAltSpeed (s, t, enabled, false);
    13681370    }
    13691371}
     
    13731375 * and turns on turtle mode if the clock settings say to. */
    13741376static void
    1375 turtleBootstrap( tr_session * session, struct tr_turtle_info * turtle )
     1377turtleBootstrap (tr_session * session, struct tr_turtle_info * turtle)
    13761378{
    13771379    turtle->changedByUser = false;
    13781380    turtle->autoTurtleState = TR_AUTO_SWITCH_UNUSED;
    13791381
    1380     tr_bitfieldConstruct( &turtle->minutes, MINUTES_PER_WEEK );
    1381 
    1382     turtleUpdateTable( turtle );
    1383 
    1384     if( turtle->isClockEnabled )
     1382    tr_bitfieldConstruct (&turtle->minutes, MINUTES_PER_WEEK);
     1383
     1384    turtleUpdateTable (turtle);
     1385
     1386    if (turtle->isClockEnabled)
    13851387    {
    1386         turtle->isEnabled = getInTurtleTime( turtle );
    1387         turtle->autoTurtleState = autoSwitchState( turtle->isEnabled );
    1388     }
    1389 
    1390     altSpeedToggled( session );
     1388        turtle->isEnabled = getInTurtleTime (turtle);
     1389        turtle->autoTurtleState = autoSwitchState (turtle->isEnabled);
     1390    }
     1391
     1392    altSpeedToggled (session);
    13911393
    13921394}
     
    13971399
    13981400void
    1399 tr_sessionSetSpeedLimit_Bps( tr_session * s, tr_direction d, unsigned int Bps )
    1400 {
    1401     assert( tr_isSession( s ) );
    1402     assert( tr_isDirection( d ) );
     1401tr_sessionSetSpeedLimit_Bps (tr_session * s, tr_direction d, unsigned int Bps)
     1402{
     1403    assert (tr_isSession (s));
     1404    assert (tr_isDirection (d));
    14031405
    14041406    s->speedLimit_Bps[d] = Bps;
    14051407
    1406     updateBandwidth( s, d );
    1407 }
    1408 void
    1409 tr_sessionSetSpeedLimit_KBps( tr_session * s, tr_direction d, unsigned int KBps )
    1410 {
    1411     tr_sessionSetSpeedLimit_Bps( s, d, toSpeedBytes( KBps ) );
     1408    updateBandwidth (s, d);
     1409}
     1410void
     1411tr_sessionSetSpeedLimit_KBps (tr_session * s, tr_direction d, unsigned int KBps)
     1412{
     1413    tr_sessionSetSpeedLimit_Bps (s, d, toSpeedBytes (KBps));
    14121414}
    14131415
    14141416unsigned int
    1415 tr_sessionGetSpeedLimit_Bps( const tr_session * s, tr_direction d )
    1416 {
    1417     assert( tr_isSession( s ) );
    1418     assert( tr_isDirection( d ) );
     1417tr_sessionGetSpeedLimit_Bps (const tr_session * s, tr_direction d)
     1418{
     1419    assert (tr_isSession (s));
     1420    assert (tr_isDirection (d));
    14191421
    14201422    return s->speedLimit_Bps[d];
    14211423}
    14221424unsigned int
    1423 tr_sessionGetSpeedLimit_KBps( const tr_session * s, tr_direction d )
    1424 {
    1425     return toSpeedKBps( tr_sessionGetSpeedLimit_Bps( s, d ) );
    1426 }
    1427 
    1428 void
    1429 tr_sessionLimitSpeed( tr_session * s, tr_direction d, bool b )
    1430 {
    1431     assert( tr_isSession( s ) );
    1432     assert( tr_isDirection( d ) );
    1433     assert( tr_isBool( b ) );
     1425tr_sessionGetSpeedLimit_KBps (const tr_session * s, tr_direction d)
     1426{
     1427    return toSpeedKBps (tr_sessionGetSpeedLimit_Bps (s, d));
     1428}
     1429
     1430void
     1431tr_sessionLimitSpeed (tr_session * s, tr_direction d, bool b)
     1432{
     1433    assert (tr_isSession (s));
     1434    assert (tr_isDirection (d));
     1435    assert (tr_isBool (b));
    14341436
    14351437    s->speedLimitEnabled[d] = b;
    14361438
    1437     updateBandwidth( s, d );
    1438 }
    1439 
    1440 bool
    1441 tr_sessionIsSpeedLimited( const tr_session * s, tr_direction d )
    1442 {
    1443     assert( tr_isSession( s ) );
    1444     assert( tr_isDirection( d ) );
     1439    updateBandwidth (s, d);
     1440}
     1441
     1442bool
     1443tr_sessionIsSpeedLimited (const tr_session * s, tr_direction d)
     1444{
     1445    assert (tr_isSession (s));
     1446    assert (tr_isDirection (d));
    14451447
    14461448    return s->speedLimitEnabled[d];
     
    14521454
    14531455void
    1454 tr_sessionSetAltSpeed_Bps( tr_session * s, tr_direction d, unsigned int Bps )
    1455 {
    1456     assert( tr_isSession( s ) );
    1457     assert( tr_isDirection( d ) );
     1456tr_sessionSetAltSpeed_Bps (tr_session * s, tr_direction d, unsigned int Bps)
     1457{
     1458    assert (tr_isSession (s));
     1459    assert (tr_isDirection (d));
    14581460
    14591461    s->turtle.speedLimit_Bps[d] = Bps;
    14601462
    1461     updateBandwidth( s, d );
    1462 }
    1463 
    1464 void
    1465 tr_sessionSetAltSpeed_KBps( tr_session * s, tr_direction d, unsigned int KBps )
    1466 {
    1467     tr_sessionSetAltSpeed_Bps( s, d, toSpeedBytes( KBps ) );
     1463    updateBandwidth (s, d);
     1464}
     1465
     1466void
     1467tr_sessionSetAltSpeed_KBps (tr_session * s, tr_direction d, unsigned int KBps)
     1468{
     1469    tr_sessionSetAltSpeed_Bps (s, d, toSpeedBytes (KBps));
    14681470}
    14691471
    14701472unsigned int
    1471 tr_sessionGetAltSpeed_Bps( const tr_session * s, tr_direction d )
    1472 {
    1473     assert( tr_isSession( s ) );
    1474     assert( tr_isDirection( d ) );
     1473tr_sessionGetAltSpeed_Bps (const tr_session * s, tr_direction d)
     1474{
     1475    assert (tr_isSession (s));
     1476    assert (tr_isDirection (d));
    14751477
    14761478    return s->turtle.speedLimit_Bps[d];
    14771479}
    14781480unsigned int
    1479 tr_sessionGetAltSpeed_KBps( const tr_session * s, tr_direction d )
    1480 {
    1481     return toSpeedKBps( tr_sessionGetAltSpeed_Bps( s, d ) );
     1481tr_sessionGetAltSpeed_KBps (const tr_session * s, tr_direction d)
     1482{
     1483    return toSpeedKBps (tr_sessionGetAltSpeed_Bps (s, d));
    14821484}
    14831485
    14841486static void
    1485 userPokedTheClock( tr_session * s, struct tr_turtle_info * t )
    1486 {
    1487     tr_dbg( "Refreshing the turtle mode clock due to user changes" );
     1487userPokedTheClock (tr_session * s, struct tr_turtle_info * t)
     1488{
     1489    tr_dbg ("Refreshing the turtle mode clock due to user changes");
    14881490
    14891491    t->autoTurtleState = TR_AUTO_SWITCH_UNUSED;
    14901492
    1491     turtleUpdateTable( t );
    1492 
    1493     if( t->isClockEnabled )
     1493    turtleUpdateTable (t);
     1494
     1495    if (t->isClockEnabled)
    14941496    {
    1495         const bool enabled = getInTurtleTime( t );
    1496         useAltSpeed( s, t, enabled, true );
    1497         t->autoTurtleState = autoSwitchState( enabled );
    1498     }
    1499 }
    1500 
    1501 void
    1502 tr_sessionUseAltSpeedTime( tr_session * s, bool b )
     1497        const bool enabled = getInTurtleTime (t);
     1498        useAltSpeed (s, t, enabled, true);
     1499        t->autoTurtleState = autoSwitchState (enabled);
     1500    }
     1501}
     1502
     1503void
     1504tr_sessionUseAltSpeedTime (tr_session * s, bool b)
    15031505{
    15041506    struct tr_turtle_info * t = &s->turtle;
    15051507
    1506     assert( tr_isSession( s ) );
    1507     assert( tr_isBool ( b ) );
    1508 
    1509     if( t->isClockEnabled != b ) {
     1508    assert (tr_isSession (s));
     1509    assert (tr_isBool (b));
     1510
     1511    if (t->isClockEnabled != b) {
    15101512        t->isClockEnabled = b;
    1511         userPokedTheClock( s, t );
    1512     }
    1513 }
    1514 
    1515 bool
    1516 tr_sessionUsesAltSpeedTime( const tr_session * s )
    1517 {
    1518     assert( tr_isSession( s ) );
     1513        userPokedTheClock (s, t);
     1514    }
     1515}
     1516
     1517bool
     1518tr_sessionUsesAltSpeedTime (const tr_session * s)
     1519{
     1520    assert (tr_isSession (s));
    15191521
    15201522    return s->turtle.isClockEnabled;
     
    15221524
    15231525void
    1524 tr_sessionSetAltSpeedBegin( tr_session * s, int minute )
    1525 {
    1526     assert( tr_isSession( s ) );
    1527     assert( 0<=minute && minute<(60*24) );
    1528 
    1529     if( s->turtle.beginMinute != minute ) {
     1526tr_sessionSetAltSpeedBegin (tr_session * s, int minute)
     1527{
     1528    assert (tr_isSession (s));
     1529    assert (0<=minute && minute< (60*24));
     1530
     1531    if (s->turtle.beginMinute != minute) {
    15301532        s->turtle.beginMinute = minute;
    1531         userPokedTheClock( s, &s->turtle );
     1533        userPokedTheClock (s, &s->turtle);
    15321534    }
    15331535}
    15341536
    15351537int
    1536 tr_sessionGetAltSpeedBegin( const tr_session * s )
    1537 {
    1538     assert( tr_isSession( s ) );
     1538tr_sessionGetAltSpeedBegin (const tr_session * s)
     1539{
     1540    assert (tr_isSession (s));
    15391541
    15401542    return s->turtle.beginMinute;
     
    15421544
    15431545void
    1544 tr_sessionSetAltSpeedEnd( tr_session * s, int minute )
    1545 {
    1546     assert( tr_isSession( s ) );
    1547     assert( 0<=minute && minute<(60*24) );
    1548 
    1549     if( s->turtle.endMinute != minute ) {
     1546tr_sessionSetAltSpeedEnd (tr_session * s, int minute)
     1547{
     1548    assert (tr_isSession (s));
     1549    assert (0<=minute && minute< (60*24));
     1550
     1551    if (s->turtle.endMinute != minute) {
    15501552        s->turtle.endMinute = minute;
    1551         userPokedTheClock( s, &s->turtle );
     1553        userPokedTheClock (s, &s->turtle);
    15521554    }
    15531555}
    15541556
    15551557int
    1556 tr_sessionGetAltSpeedEnd( const tr_session * s )
    1557 {
    1558     assert( tr_isSession( s ) );
     1558tr_sessionGetAltSpeedEnd (const tr_session * s)
     1559{
     1560    assert (tr_isSession (s));
    15591561
    15601562    return s->turtle.endMinute;
     
    15621564
    15631565void
    1564 tr_sessionSetAltSpeedDay( tr_session * s, tr_sched_day days )
    1565 {
    1566     assert( tr_isSession( s ) );
    1567 
    1568     if( s->turtle.days != days ) {
     1566tr_sessionSetAltSpeedDay (tr_session * s, tr_sched_day days)
     1567{
     1568    assert (tr_isSession (s));
     1569
     1570    if (s->turtle.days != days) {
    15691571        s->turtle.days = days;
    1570         userPokedTheClock( s, &s->turtle );
     1572        userPokedTheClock (s, &s->turtle);
    15711573    }
    15721574}
    15731575
    15741576tr_sched_day
    1575 tr_sessionGetAltSpeedDay( const tr_session * s )
    1576 {
    1577     assert( tr_isSession( s ) );
     1577tr_sessionGetAltSpeedDay (const tr_session * s)
     1578{
     1579    assert (tr_isSession (s));
    15781580
    15791581    return s->turtle.days;
     
    15811583
    15821584void
    1583 tr_sessionUseAltSpeed( tr_session * session, bool enabled )
    1584 {
    1585     useAltSpeed( session, &session->turtle, enabled, true );
    1586 }
    1587 
    1588 bool
    1589 tr_sessionUsesAltSpeed( const tr_session * s )
    1590 {
    1591     assert( tr_isSession( s ) );
     1585tr_sessionUseAltSpeed (tr_session * session, bool enabled)
     1586{
     1587    useAltSpeed (session, &session->turtle, enabled, true);
     1588}
     1589
     1590bool
     1591tr_sessionUsesAltSpeed (const tr_session * s)
     1592{
     1593    assert (tr_isSession (s));
    15921594
    15931595    return s->turtle.isEnabled;
     
    15951597
    15961598void
    1597 tr_sessionSetAltSpeedFunc( tr_session       * session,
     1599tr_sessionSetAltSpeedFunc (tr_session       * session,
    15981600                           tr_altSpeedFunc    func,
    1599                            void             * userData )
    1600 {
    1601     assert( tr_isSession( session ) );
     1601                           void             * userData)
     1602{
     1603    assert (tr_isSession (session));
    16021604
    16031605    session->turtle.callback = func;
     
    16061608
    16071609void
    1608 tr_sessionClearAltSpeedFunc( tr_session * session )
    1609 {
    1610     tr_sessionSetAltSpeedFunc( session, NULL, NULL );
     1610tr_sessionClearAltSpeedFunc (tr_session * session)
     1611{
     1612    tr_sessionSetAltSpeedFunc (session, NULL, NULL);
    16111613}
    16121614
     
    16161618
    16171619void
    1618 tr_sessionSetPeerLimit( tr_session * session, uint16_t n )
    1619 {
    1620     assert( tr_isSession( session ) );
     1620tr_sessionSetPeerLimit (tr_session * session, uint16_t n)
     1621{
     1622    assert (tr_isSession (session));
    16211623
    16221624    session->peerLimit = n;
     
    16241626
    16251627uint16_t
    1626 tr_sessionGetPeerLimit( const tr_session * session )
    1627 {
    1628     assert( tr_isSession( session ) );
     1628tr_sessionGetPeerLimit (const tr_session * session)
     1629{
     1630    assert (tr_isSession (session));
    16291631
    16301632    return session->peerLimit;
     
    16321634
    16331635void
    1634 tr_sessionSetPeerLimitPerTorrent( tr_session  * session, uint16_t n )
    1635 {
    1636     assert( tr_isSession( session ) );
     1636tr_sessionSetPeerLimitPerTorrent (tr_session  * session, uint16_t n)
     1637{
     1638    assert (tr_isSession (session));
    16371639
    16381640    session->peerLimitPerTorrent = n;
     
    16401642
    16411643uint16_t
    1642 tr_sessionGetPeerLimitPerTorrent( const tr_session * session )
    1643 {
    1644     assert( tr_isSession( session ) );
     1644tr_sessionGetPeerLimitPerTorrent (const tr_session * session)
     1645{
     1646    assert (tr_isSession (session));
    16451647
    16461648    return session->peerLimitPerTorrent;
     
    16521654
    16531655void
    1654 tr_sessionSetPaused( tr_session * session, bool isPaused )
    1655 {
    1656     assert( tr_isSession( session ) );
     1656tr_sessionSetPaused (tr_session * session, bool isPaused)
     1657{
     1658    assert (tr_isSession (session));
    16571659
    16581660    session->pauseAddedTorrent = isPaused;
     
    16601662
    16611663bool
    1662 tr_sessionGetPaused( const tr_session * session )
    1663 {
    1664     assert( tr_isSession( session ) );
     1664tr_sessionGetPaused (const tr_session * session)
     1665{
     1666    assert (tr_isSession (session));
    16651667
    16661668    return session->pauseAddedTorrent;
     
    16681670
    16691671void
    1670 tr_sessionSetDeleteSource( tr_session * session, bool deleteSource )
    1671 {
    1672     assert( tr_isSession( session ) );
     1672tr_sessionSetDeleteSource (tr_session * session, bool deleteSource)
     1673{
     1674    assert (tr_isSession (session));
    16731675
    16741676    session->deleteSourceTorrent = deleteSource;
     
    16761678
    16771679bool
    1678 tr_sessionGetDeleteSource( const tr_session * session )
    1679 {
    1680     assert( tr_isSession( session ) );
     1680tr_sessionGetDeleteSource (const tr_session * session)
     1681{
     1682    assert (tr_isSession (session));
    16811683
    16821684    return session->deleteSourceTorrent;
     
    16881690
    16891691unsigned int
    1690 tr_sessionGetPieceSpeed_Bps( const tr_session * session, tr_direction dir )
    1691 {
    1692     return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed_Bps( &session->bandwidth, 0, dir ) : 0;
     1692tr_sessionGetPieceSpeed_Bps (const tr_session * session, tr_direction dir)
     1693{
     1694    return tr_isSession (session) ? tr_bandwidthGetPieceSpeed_Bps (&session->bandwidth, 0, dir) : 0;
    16931695}
    16941696
    16951697unsigned int
    1696 tr_sessionGetRawSpeed_Bps( const tr_session * session, tr_direction dir )
    1697 {
    1698     return tr_isSession( session ) ? tr_bandwidthGetRawSpeed_Bps( &session->bandwidth, 0, dir ) : 0;
     1698tr_sessionGetRawSpeed_Bps (const tr_session * session, tr_direction dir)
     1699{
     1700    return tr_isSession (session) ? tr_bandwidthGetRawSpeed_Bps (&session->bandwidth, 0, dir) : 0;
    16991701}
    17001702double
    1701 tr_sessionGetRawSpeed_KBps( const tr_session * session, tr_direction dir )
    1702 {
    1703     return toSpeedKBps( tr_sessionGetRawSpeed_Bps( session, dir ) );
     1703tr_sessionGetRawSpeed_KBps (const tr_session * session, tr_direction dir)
     1704{
     1705    return toSpeedKBps (tr_sessionGetRawSpeed_Bps (session, dir));
    17041706}
    17051707
    17061708
    17071709int
    1708 tr_sessionCountTorrents( const tr_session * session )
    1709 {
    1710     return tr_isSession( session ) ? session->torrentCount : 0;
     1710tr_sessionCountTorrents (const tr_session * session)
     1711{
     1712    return tr_isSession (session) ? session->torrentCount : 0;
    17111713}
    17121714
    17131715static int
    1714 compareTorrentByCur( const void * va, const void * vb )
    1715 {
    1716     const tr_torrent * a = *(const tr_torrent**)va;
    1717     const tr_torrent * b = *(const tr_torrent**)vb;
     1716compareTorrentByCur (const void * va, const void * vb)
     1717{
     1718    const tr_torrent * a = * (const tr_torrent**)va;
     1719    const tr_torrent * b = * (const tr_torrent**)vb;
    17181720    const uint64_t     aCur = a->downloadedCur + a->uploadedCur;
    17191721    const uint64_t     bCur = b->downloadedCur + b->uploadedCur;
    17201722
    1721     if( aCur != bCur )
     1723    if (aCur != bCur)
    17221724        return aCur > bCur ? -1 : 1; /* close the biggest torrents first */
    17231725
     
    17251727}
    17261728
    1727 static void closeBlocklists( tr_session * );
     1729static void closeBlocklists (tr_session *);
    17281730
    17291731static void
    1730 sessionCloseImpl( void * vsession )
     1732sessionCloseImpl (void * vsession)
    17311733{
    17321734    tr_session *  session = vsession;
     
    17351737    tr_torrent ** torrents;
    17361738
    1737     assert( tr_isSession( session ) );
    1738 
    1739     free_incoming_peer_port( session );
    1740 
    1741     if( session->isLPDEnabled )
    1742         tr_lpdUninit( session );
    1743 
    1744     tr_utpClose( session );
    1745     tr_dhtUninit( session );
    1746 
    1747     event_free( session->saveTimer );
     1739    assert (tr_isSession (session));
     1740
     1741    free_incoming_peer_port (session);
     1742
     1743    if (session->isLPDEnabled)
     1744        tr_lpdUninit (session);
     1745
     1746    tr_utpClose (session);
     1747    tr_dhtUninit (session);
     1748
     1749    event_free (session->saveTimer);
    17481750    session->saveTimer = NULL;
    17491751
    1750     event_free( session->nowTimer );
     1752    event_free (session->nowTimer);
    17511753    session->nowTimer = NULL;
    17521754
    1753     tr_verifyClose( session );
    1754     tr_sharedClose( session );
    1755     tr_rpcClose( &session->rpcServer );
     1755    tr_verifyClose (session);
     1756    tr_sharedClose (session);
     1757    tr_rpcClose (&session->rpcServer);
    17561758
    17571759    /* Close the torrents. Get the most active ones first so that
     
    17601762    tor = NULL;
    17611763    n = session->torrentCount;
    1762     torrents = tr_new( tr_torrent *, session->torrentCount );
    1763     for( i = 0; i < n; ++i )
    1764         torrents[i] = tor = tr_torrentNext( session, tor );
    1765     qsort( torrents, n, sizeof( tr_torrent* ), compareTorrentByCur );
    1766     for( i = 0; i < n; ++i )
    1767         tr_torrentFree( torrents[i] );
    1768     tr_free( torrents );
     1764    torrents = tr_new (tr_torrent *, session->torrentCount);
     1765    for (i = 0; i < n; ++i)
     1766        torrents[i] = tor = tr_torrentNext (session, tor);
     1767    qsort (torrents, n, sizeof (tr_torrent*), compareTorrentByCur);
     1768    for (i = 0; i < n; ++i)
     1769        tr_torrentFree (torrents[i]);
     1770    tr_free (torrents);
    17691771
    17701772    /* Close the announcer *after* closing the torrents
    17711773       so that all the &event=stopped messages will be
    1772        queued to be sent by tr_announcerClose() */
    1773     tr_announcerClose( session );
     1774       queued to be sent by tr_announcerClose () */
     1775    tr_announcerClose (session);
    17741776
    17751777    /* and this goes *after* announcer close so that
    17761778       it won't be idle until the announce events are sent... */
    1777     tr_webClose( session, TR_WEB_CLOSE_WHEN_IDLE );
    1778 
    1779     tr_cacheFree( session->cache );
     1779    tr_webClose (session, TR_WEB_CLOSE_WHEN_IDLE);
     1780
     1781    tr_cacheFree (session->cache);
    17801782    session->cache = NULL;
    17811783
    17821784    /* gotta keep udp running long enough to send out all
    17831785       the &event=stopped UDP tracker messages */
    1784     while( !tr_tracker_udp_is_idle( session ) ) {
    1785         tr_tracker_udp_upkeep( session );
    1786         tr_wait_msec( 100 );
     1786    while (!tr_tracker_udp_is_idle (session)) {
     1787        tr_tracker_udp_upkeep (session);
     1788        tr_wait_msec (100);
    17871789    }
    17881790
    17891791    /* we had to wait until UDP trackers were closed before closing these: */
    1790     evdns_base_free( session->evdns_base, 0 );
     1792    evdns_base_free (session->evdns_base, 0);
    17911793    session->evdns_base = NULL;
    1792     tr_tracker_udp_close( session );
    1793     tr_udpUninit( session );
    1794 
    1795     tr_statsClose( session );
    1796     tr_peerMgrFree( session->peerMgr );
    1797 
    1798     closeBlocklists( session );
    1799 
    1800     tr_fdClose( session );
     1794    tr_tracker_udp_close (session);
     1795    tr_udpUninit (session);
     1796
     1797    tr_statsClose (session);
     1798    tr_peerMgrFree (session->peerMgr);
     1799
     1800    closeBlocklists (session);
     1801
     1802    tr_fdClose (session);
    18011803
    18021804    session->isClosed = true;
     
    18041806
    18051807static int
    1806 deadlineReached( const time_t deadline )
    1807 {
    1808     return time( NULL ) >= deadline;
     1808deadlineReached (const time_t deadline)
     1809{
     1810    return time (NULL) >= deadline;
    18091811}
    18101812
     
    18121814
    18131815void
    1814 tr_sessionClose( tr_session * session )
    1815 {
    1816     const time_t deadline = time( NULL ) + SHUTDOWN_MAX_SECONDS;
    1817 
    1818     assert( tr_isSession( session ) );
    1819 
    1820     dbgmsg( "shutting down transmission session %p... now is %zu, deadline is %zu", session, (size_t)time(NULL), (size_t)deadline );
     1816tr_sessionClose (tr_session * session)
     1817{
     1818    const time_t deadline = time (NULL) + SHUTDOWN_MAX_SECONDS;
     1819
     1820    assert (tr_isSession (session));
     1821
     1822    dbgmsg ("shutting down transmission session %p... now is %zu, deadline is %zu", session, (size_t)time (NULL), (size_t)deadline);
    18211823
    18221824    /* close the session */
    1823     tr_runInEventThread( session, sessionCloseImpl, session );
    1824     while( !session->isClosed && !deadlineReached( deadline ) )
     1825    tr_runInEventThread (session, sessionCloseImpl, session);
     1826    while (!session->isClosed && !deadlineReached (deadline))
    18251827    {
    1826         dbgmsg( "waiting for the libtransmission thread to finish" );
    1827         tr_wait_msec( 100 );
     1828        dbgmsg ("waiting for the libtransmission thread to finish");
     1829        tr_wait_msec (100);
    18281830    }
    18291831
     
    18321834     * for a bit while they tell the router & tracker
    18331835     * that we're closing now */
    1834     while( ( session->shared || session->web || session->announcer || session->announcer_udp )
    1835            && !deadlineReached( deadline ) )
     1836    while ((session->shared || session->web || session->announcer || session->announcer_udp)
     1837           && !deadlineReached (deadline))
    18361838    {
    1837         dbgmsg( "waiting on port unmap (%p) or announcer (%p)... now %zu deadline %zu",
    1838                 session->shared, session->announcer, (size_t)time(NULL), (size_t)deadline );
    1839         tr_wait_msec( 100 );
    1840     }
    1841 
    1842     tr_webClose( session, TR_WEB_CLOSE_NOW );
     1839        dbgmsg ("waiting on port unmap (%p) or announcer (%p)... now %zu deadline %zu",
     1840                session->shared, session->announcer, (size_t)time (NULL), (size_t)deadline);
     1841        tr_wait_msec (100);
     1842    }
     1843
     1844    tr_webClose (session, TR_WEB_CLOSE_NOW);
    18431845
    18441846    /* close the libtransmission thread */
    1845     tr_eventClose( session );
    1846     while( session->events != NULL )
     1847    tr_eventClose (session);
     1848    while (session->events != NULL)
    18471849    {
    18481850        static bool forced = false;
    1849         dbgmsg( "waiting for libtransmission thread to finish... now %zu deadline %zu", (size_t)time(NULL), (size_t)deadline );
    1850         tr_wait_msec( 500 );
    1851         if( deadlineReached( deadline ) && !forced )
     1851        dbgmsg ("waiting for libtransmission thread to finish... now %zu deadline %zu", (size_t)time (NULL), (size_t)deadline);
     1852        tr_wait_msec (500);
     1853        if (deadlineReached (deadline) && !forced)
    18521854        {
    1853             dbgmsg( "calling event_loopbreak()" );
     1855            dbgmsg ("calling event_loopbreak ()");
    18541856            forced = true;
    1855             event_base_loopbreak( session->event_base );
     1857            event_base_loopbreak (session->event_base);
    18561858        }
    1857         if( deadlineReached( deadline+3 ) )
     1859        if (deadlineReached (deadline+3))
    18581860        {
    1859             dbgmsg( "deadline+3 reached... calling break...\n" );
     1861            dbgmsg ("deadline+3 reached... calling break...\n");
    18601862            break;
    18611863        }
     
    18631865
    18641866    /* free the session memory */
    1865     tr_bencFree( &session->removedTorrents );
    1866     tr_bandwidthDestruct( &session->bandwidth );
    1867     tr_bitfieldDestruct( &session->turtle.minutes );
    1868     tr_lockFree( session->lock );
    1869     if( session->metainfoLookup ) {
    1870         tr_bencFree( session->metainfoLookup );
    1871         tr_free( session->metainfoLookup );
    1872     }
    1873     tr_free( session->torrentDoneScript );
    1874     tr_free( session->tag );
    1875     tr_free( session->configDir );
    1876     tr_free( session->resumeDir );
    1877     tr_free( session->torrentDir );
    1878     tr_free( session->downloadDir );
    1879     tr_free( session->incompleteDir );
    1880     tr_free( session->blocklist_url );
    1881     tr_free( session->peer_congestion_algorithm );
    1882     tr_free( session );
     1867    tr_bencFree (&session->removedTorrents);
     1868    tr_bandwidthDestruct (&session->bandwidth);
     1869    tr_bitfieldDestruct (&session->turtle.minutes);
     1870    tr_lockFree (session->lock);
     1871    if (session->metainfoLookup) {
     1872        tr_bencFree (session->metainfoLookup);
     1873        tr_free (session->metainfoLookup);
     1874    }
     1875    tr_free (session->torrentDoneScript);
     1876    tr_free (session->tag);
     1877    tr_free (session->configDir);
     1878    tr_free (session->resumeDir);
     1879    tr_free (session->torrentDir);
     1880    tr_free (session->downloadDir);
     1881    tr_free (session->incompleteDir);
     1882    tr_free (session->blocklist_url);
     1883    tr_free (session->peer_congestion_algorithm);
     1884    tr_free (session);
    18831885}
    18841886
     
    18931895
    18941896static void
    1895 sessionLoadTorrents( void * vdata )
     1897sessionLoadTorrents (void * vdata)
    18961898{
    18971899    int i;
     
    19021904    tr_list * list = NULL;
    19031905    struct sessionLoadTorrentsData * data = vdata;
    1904     const char * dirname = tr_getTorrentDir( data->session );
    1905 
    1906     assert( tr_isSession( data->session ) );
    1907 
    1908     tr_ctorSetSave( data->ctor, false ); /* since we already have them */
    1909 
    1910     if( !stat( dirname, &sb )
    1911       && S_ISDIR( sb.st_mode )
    1912       && ( ( odir = opendir ( dirname ) ) ) )
     1906    const char * dirname = tr_getTorrentDir (data->session);
     1907
     1908    assert (tr_isSession (data->session));
     1909
     1910    tr_ctorSetSave (data->ctor, false); /* since we already have them */
     1911
     1912    if (!stat (dirname, &sb)
     1913      && S_ISDIR (sb.st_mode)
     1914      && ((odir = opendir (dirname))))
    19131915    {
    19141916        struct dirent *d;
    1915         for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
     1917        for (d = readdir (odir); d != NULL; d = readdir (odir))
    19161918        {
    1917             if( tr_str_has_suffix( d->d_name, ".torrent" ) )
     1919            if (tr_str_has_suffix (d->d_name, ".torrent"))
    19181920            {
    19191921                tr_torrent * tor;
    1920                 char * path = tr_buildPath( dirname, d->d_name, NULL );
    1921                 tr_ctorSetMetainfoFromFile( data->ctor, path );
    1922                 if(( tor = tr_torrentNew( data->ctor, NULL )))
     1922                char * path = tr_buildPath (dirname, d->d_name, NULL);
     1923                tr_ctorSetMetainfoFromFile (data->ctor, path);
     1924                if ((tor = tr_torrentNew (data->ctor, NULL)))
    19231925                {
    1924                     tr_list_prepend( &list, tor );
     1926                    tr_list_prepend (&list, tor);
    19251927                    ++n;
    19261928                }
    1927                 tr_free( path );
     1929                tr_free (path);
    19281930            }
    19291931        }
    1930         closedir( odir );
    1931     }
    1932 
    1933     data->torrents = tr_new( tr_torrent *, n );
    1934     for( i = 0, l = list; l != NULL; l = l->next )
     1932        closedir (odir);
     1933    }
     1934
     1935    data->torrents = tr_new (tr_torrent *, n);
     1936    for (i = 0, l = list; l != NULL; l = l->next)
    19351937        data->torrents[i++] = (tr_torrent*) l->data;
    1936     assert( i == n );
    1937 
    1938     tr_list_free( &list, NULL );
    1939 
    1940     if( n )
    1941         tr_inf( _( "Loaded %d torrents" ), n );
    1942 
    1943     if( data->setmeCount )
     1938    assert (i == n);
     1939
     1940    tr_list_free (&list, NULL);
     1941
     1942    if (n)
     1943        tr_inf (_ ("Loaded %d torrents"), n);
     1944
     1945    if (data->setmeCount)
    19441946        *data->setmeCount = n;
    19451947
     
    19481950
    19491951tr_torrent **
    1950 tr_sessionLoadTorrents( tr_session * session,
     1952tr_sessionLoadTorrents (tr_session * session,
    19511953                        tr_ctor    * ctor,
    1952                         int        * setmeCount )
     1954                        int        * setmeCount)
    19531955{
    19541956    struct sessionLoadTorrentsData data;
     
    19601962    data.done = false;
    19611963
    1962     tr_runInEventThread( session, sessionLoadTorrents, &data );
    1963     while( !data.done )
    1964         tr_wait_msec( 100 );
     1964    tr_runInEventThread (session, sessionLoadTorrents, &data);
     1965    while (!data.done)
     1966        tr_wait_msec (100);
    19651967
    19661968    return data.torrents;
     
    19721974
    19731975void
    1974 tr_sessionSetPexEnabled( tr_session * session, bool enabled )
    1975 {
    1976     assert( tr_isSession( session ) );
     1976tr_sessionSetPexEnabled (tr_session * session, bool enabled)
     1977{
     1978    assert (tr_isSession (session));
    19771979
    19781980    session->isPexEnabled = enabled != 0;
     
    19801982
    19811983bool
    1982 tr_sessionIsPexEnabled( const tr_session * session )
    1983 {
    1984     assert( tr_isSession( session ) );
     1984tr_sessionIsPexEnabled (const tr_session * session)
     1985{
     1986    assert (tr_isSession (session));
    19851987
    19861988    return session->isPexEnabled;
     
    19881990
    19891991bool
    1990 tr_sessionAllowsDHT( const tr_session * session )
    1991 {
    1992     return tr_sessionIsDHTEnabled( session );
    1993 }
    1994 
    1995 bool
    1996 tr_sessionIsDHTEnabled( const tr_session * session )
    1997 {
    1998     assert( tr_isSession( session ) );
     1992tr_sessionAllowsDHT (const tr_session * session)
     1993{
     1994    return tr_sessionIsDHTEnabled (session);
     1995}
     1996
     1997bool
     1998tr_sessionIsDHTEnabled (const tr_session * session)
     1999{
     2000    assert (tr_isSession (session));
    19992001
    20002002    return session->isDHTEnabled;
     
    20022004
    20032005static void
    2004 toggleDHTImpl(  void * data )
     2006toggleDHTImpl (void * data)
    20052007{
    20062008    tr_session * session = data;
    2007     assert( tr_isSession( session ) );
    2008 
    2009     tr_udpUninit( session );
     2009    assert (tr_isSession (session));
     2010
     2011    tr_udpUninit (session);
    20102012    session->isDHTEnabled = !session->isDHTEnabled;
    2011     tr_udpInit( session );
    2012 }
    2013 
    2014 void
    2015 tr_sessionSetDHTEnabled( tr_session * session, bool enabled )
    2016 {
    2017     assert( tr_isSession( session ) );
    2018     assert( tr_isBool( enabled ) );
    2019 
    2020     if( ( enabled != 0 ) != ( session->isDHTEnabled != 0 ) )
    2021         tr_runInEventThread( session, toggleDHTImpl, session );
     2013    tr_udpInit (session);
     2014}
     2015
     2016void
     2017tr_sessionSetDHTEnabled (tr_session * session, bool enabled)
     2018{
     2019    assert (tr_isSession (session));
     2020    assert (tr_isBool (enabled));
     2021
     2022    if ((enabled != 0) != (session->isDHTEnabled != 0))
     2023        tr_runInEventThread (session, toggleDHTImpl, session);
    20222024}
    20232025
     
    20272029
    20282030bool
    2029 tr_sessionIsUTPEnabled( const tr_session * session )
    2030 {
    2031     assert( tr_isSession( session ) );
     2031tr_sessionIsUTPEnabled (const tr_session * session)
     2032{
     2033    assert (tr_isSession (session));
    20322034
    20332035#ifdef WITH_UTP
     
    20392041
    20402042static void
    2041 toggle_utp(  void * data )
     2043toggle_utp (void * data)
    20422044{
    20432045    tr_session * session = data;
    2044     assert( tr_isSession( session ) );
     2046    assert (tr_isSession (session));
    20452047
    20462048    session->isUTPEnabled = !session->isUTPEnabled;
    20472049
    2048     tr_udpSetSocketBuffers( session );
     2050    tr_udpSetSocketBuffers (session);
    20492051
    20502052    /* But don't call tr_utpClose -- see reset_timer in tr-utp.c for an
     
    20532055
    20542056void
    2055 tr_sessionSetUTPEnabled( tr_session * session, bool enabled )
    2056 {
    2057     assert( tr_isSession( session ) );
    2058     assert( tr_isBool( enabled ) );
    2059 
    2060     if( ( enabled != 0 ) != ( session->isUTPEnabled != 0 ) )
    2061         tr_runInEventThread( session, toggle_utp, session );
     2057tr_sessionSetUTPEnabled (tr_session * session, bool enabled)
     2058{
     2059    assert (tr_isSession (session));
     2060    assert (tr_isBool (enabled));
     2061
     2062    if ((enabled != 0) != (session->isUTPEnabled != 0))
     2063        tr_runInEventThread (session, toggle_utp, session);
    20622064}
    20632065
     
    20672069
    20682070static void
    2069 toggleLPDImpl(  void * data )
     2071toggleLPDImpl (void * data)
    20702072{
    20712073    tr_session * session = data;
    2072     assert( tr_isSession( session ) );
    2073 
    2074     if( session->isLPDEnabled )
    2075         tr_lpdUninit( session );
     2074    assert (tr_isSession (session));
     2075
     2076    if (session->isLPDEnabled)
     2077        tr_lpdUninit (session);
    20762078
    20772079    session->isLPDEnabled = !session->isLPDEnabled;
    20782080
    2079     if( session->isLPDEnabled )
    2080         tr_lpdInit( session, &session->public_ipv4->addr );
    2081 }
    2082 
    2083 void
    2084 tr_sessionSetLPDEnabled( tr_session * session, bool enabled )
    2085 {
    2086     assert( tr_isSession( session ) );
    2087     assert( tr_isBool( enabled ) );
    2088 
    2089     if( ( enabled != 0 ) != ( session->isLPDEnabled != 0 ) )
    2090         tr_runInEventThread( session, toggleLPDImpl, session );
    2091 }
    2092 
    2093 bool
    2094 tr_sessionIsLPDEnabled( const tr_session * session )
    2095 {
    2096     assert( tr_isSession( session ) );
     2081    if (session->isLPDEnabled)
     2082        tr_lpdInit (session, &session->public_ipv4->addr);
     2083}
     2084
     2085void
     2086tr_sessionSetLPDEnabled (tr_session * session, bool enabled)
     2087{
     2088    assert (tr_isSession (session));
     2089    assert (tr_isBool (enabled));
     2090
     2091    if ((enabled != 0) != (session->isLPDEnabled != 0))
     2092        tr_runInEventThread (session, toggleLPDImpl, session);
     2093}
     2094
     2095bool
     2096tr_sessionIsLPDEnabled (const tr_session * session)
     2097{
     2098    assert (tr_isSession (session));
    20972099
    20982100    return session->isLPDEnabled;
     
    21002102
    21012103bool
    2102 tr_sessionAllowsLPD( const tr_session * session )
    2103 {
    2104     return tr_sessionIsLPDEnabled( session );
     2104tr_sessionAllowsLPD (const tr_session * session)
     2105{
     2106    return tr_sessionIsLPDEnabled (session);
    21052107}
    21062108
     
    21102112
    21112113void
    2112 tr_sessionSetCacheLimit_MB( tr_session * session, int max_bytes )
    2113 {
    2114     assert( tr_isSession( session ) );
    2115 
    2116     tr_cacheSetLimit( session->cache, toMemBytes( max_bytes ) );
     2114tr_sessionSetCacheLimit_MB (tr_session * session, int max_bytes)
     2115{
     2116    assert (tr_isSession (session));
     2117
     2118    tr_cacheSetLimit (session->cache, toMemBytes (max_bytes));
    21172119}
    21182120
    21192121int
    2120 tr_sessionGetCacheLimit_MB( const tr_session * session )
    2121 {
    2122     assert( tr_isSession( session ) );
    2123 
    2124     return toMemMB( tr_cacheGetLimit( session->cache ) );
     2122tr_sessionGetCacheLimit_MB (const tr_session * session)
     2123{
     2124    assert (tr_isSession (session));
     2125
     2126    return toMemMB (tr_cacheGetLimit (session->cache));
    21252127}
    21262128
     
    21362138
    21372139static void
    2138 setPortForwardingEnabled( void * vdata )
     2140setPortForwardingEnabled (void * vdata)
    21392141{
    21402142    struct port_forwarding_data * data = vdata;
    2141     tr_sharedTraversalEnable( data->shared, data->enabled );
    2142     tr_free( data );
    2143 }
    2144 
    2145 void
    2146 tr_sessionSetPortForwardingEnabled( tr_session  * session, bool enabled )
     2143    tr_sharedTraversalEnable (data->shared, data->enabled);
     2144    tr_free (data);
     2145}
     2146
     2147void
     2148tr_sessionSetPortForwardingEnabled (tr_session  * session, bool enabled)
    21472149{
    21482150    struct port_forwarding_data * d;
    2149     d = tr_new0( struct port_forwarding_data, 1 );
     2151    d = tr_new0 (struct port_forwarding_data, 1);
    21502152    d->shared = session->shared;
    21512153    d->enabled = enabled;
    2152     tr_runInEventThread( session, setPortForwardingEnabled, d );
    2153 }
    2154 
    2155 bool
    2156 tr_sessionIsPortForwardingEnabled( const tr_session * session )
    2157 {
    2158     assert( tr_isSession( session ) );
    2159 
    2160     return tr_sharedTraversalIsEnabled( session->shared );
     2154    tr_runInEventThread (session, setPortForwardingEnabled, d);
     2155}
     2156
     2157bool
     2158tr_sessionIsPortForwardingEnabled (const tr_session * session)
     2159{
     2160    assert (tr_isSession (session));
     2161
     2162    return tr_sharedTraversalIsEnabled (session->shared);
    21612163}
    21622164
     
    21662168
    21672169static int
    2168 tr_stringEndsWith( const char * str, const char * end )
    2169 {
    2170     const size_t slen = strlen( str );
    2171     const size_t elen = strlen( end );
    2172 
    2173     return slen >= elen && !memcmp( &str[slen - elen], end, elen );
     2170tr_stringEndsWith (const char * str, const char * end)
     2171{
     2172    const size_t slen = strlen (str);
     2173    const size_t elen = strlen (end);
     2174
     2175    return slen >= elen && !memcmp (&str[slen - elen], end, elen);
    21742176}
    21752177
    21762178static void
    2177 loadBlocklists( tr_session * session )
     2179loadBlocklists (tr_session * session)
    21782180{
    21792181    int         binCount = 0;
     
    21862188
    21872189    /* walk through the directory and find blocklists */
    2188     dirname = tr_buildPath( session->configDir, "blocklists", NULL );
    2189     if( !stat( dirname,
    2190                &sb ) && S_ISDIR( sb.st_mode )
    2191       && ( ( odir = opendir( dirname ) ) ) )
     2190    dirname = tr_buildPath (session->configDir, "blocklists", NULL);
     2191    if (!stat (dirname,
     2192               &sb) && S_ISDIR (sb.st_mode)
     2193      && ((odir = opendir (dirname))))
    21922194    {
    21932195        struct dirent *d;
    2194         for( d = readdir( odir ); d; d = readdir( odir ) )
     2196        for (d = readdir (odir); d; d = readdir (odir))
    21952197        {
    21962198            char * filename;
    21972199
    2198             if( !d->d_name || d->d_name[0] == '.' ) /* skip dotfiles, ., and ..
     2200            if (!d->d_name || d->d_name[0] == '.') /* skip dotfiles, ., and ..
    21992201                                                      */
    22002202                continue;
    22012203
    2202             filename = tr_buildPath( dirname, d->d_name, NULL );
    2203 
    2204             if( tr_stringEndsWith( filename, ".bin" ) )
     2204            filename = tr_buildPath (dirname, d->d_name, NULL);
     2205
     2206            if (tr_stringEndsWith (filename, ".bin"))
    22052207            {
    22062208                /* if we don't already have this blocklist, add it */
    2207                 if( !tr_list_find( list, filename,
    2208                                    (TrListCompareFunc)strcmp ) )
     2209                if (!tr_list_find (list, filename,
     2210                                 (TrListCompareFunc)strcmp))
    22092211                {
    2210                     tr_list_append( &list,
    2211                                    _tr_blocklistNew( filename, isEnabled ) );
     2212                    tr_list_append (&list,
     2213                                   _tr_blocklistNew (filename, isEnabled));
    22122214                    ++binCount;
    22132215                }
     
    22182220                  instead */
    22192221                tr_blocklist * b;
    2220                 const char *   dot = strrchr( d->d_name, '.' );
     2222                const char *   dot = strrchr (d->d_name, '.');
    22212223                const int      len = dot ? dot - d->d_name
    2222                                          : (int)strlen( d->d_name );
    2223                 char         * tmp = tr_strdup_printf(
     2224                                         : (int)strlen (d->d_name);
     2225                char         * tmp = tr_strdup_printf (
    22242226                                        "%s" TR_PATH_DELIMITER_STR "%*.*s.bin",
    2225                                         dirname, len, len, d->d_name );
    2226                 b = _tr_blocklistNew( tmp, isEnabled );
    2227                 _tr_blocklistSetContent( b, filename );
    2228                 tr_list_append( &list, b );
     2227                                        dirname, len, len, d->d_name);
     2228                b = _tr_blocklistNew (tmp, isEnabled);
     2229                _tr_blocklistSetContent (b, filename);
     2230                tr_list_append (&list, b);
    22292231                ++newCount;
    2230                 tr_free( tmp );
     2232                tr_free (tmp);
    22312233            }
    22322234
    2233             tr_free( filename );
     2235            tr_free (filename);
    22342236        }
    22352237
    2236         closedir( odir );
     2238        closedir (odir);
    22372239    }
    22382240
    22392241    session->blocklists = list;
    22402242
    2241     if( binCount )
    2242         tr_dbg( "Found %d blocklists in \"%s\"", binCount, dirname );
    2243     if( newCount )
    2244         tr_dbg( "Found %d new blocklists in \"%s\"", newCount, dirname );
    2245 
    2246     tr_free( dirname );
     2243    if (binCount)
     2244        tr_dbg ("Found %d blocklists in \"%s\"", binCount, dirname);
     2245    if (newCount)
     2246        tr_dbg ("Found %d new blocklists in \"%s\"", newCount, dirname);
     2247
     2248    tr_free (dirname);
    22472249}
    22482250
    22492251static void
    2250 closeBlocklists( tr_session * session )
    2251 {
    2252     tr_list_free( &session->blocklists,
    2253                   (TrListForeachFunc)_tr_blocklistFree );
    2254 }
    2255 
    2256 void
    2257 tr_sessionReloadBlocklists( tr_session * session )
    2258 {
    2259     closeBlocklists( session );
    2260     loadBlocklists( session );
    2261 
    2262     tr_peerMgrOnBlocklistChanged( session->peerMgr );
     2252closeBlocklists (tr_session * session)
     2253{
     2254    tr_list_free (&session->blocklists,
     2255                (TrListForeachFunc)_tr_blocklistFree);
     2256}
     2257
     2258void
     2259tr_sessionReloadBlocklists (tr_session * session)
     2260{
     2261    closeBlocklists (session);
     2262    loadBlocklists (session);
     2263
     2264    tr_peerMgrOnBlocklistChanged (session->peerMgr);
    22632265}
    22642266
    22652267int
    2266 tr_blocklistGetRuleCount( const tr_session * session )
     2268tr_blocklistGetRuleCount (const tr_session * session)
    22672269{
    22682270    int       n = 0;
    22692271    tr_list * l;
    22702272
    2271     assert( tr_isSession( session ) );
    2272 
    2273     for( l = session->blocklists; l; l = l->next )
    2274         n += _tr_blocklistGetRuleCount( l->data );
     2273    assert (tr_isSession (session));
     2274
     2275    for (l = session->blocklists; l; l = l->next)
     2276        n += _tr_blocklistGetRuleCount (l->data);
    22752277    return n;
    22762278}
    22772279
    22782280bool
    2279 tr_blocklistIsEnabled( const tr_session * session )
    2280 {
    2281     assert( tr_isSession( session ) );
     2281tr_blocklistIsEnabled (const tr_session * session)
     2282{
     2283    assert (tr_isSession (session));
    22822284
    22832285    return session->isBlocklistEnabled;
     
    22852287
    22862288void
    2287 tr_blocklistSetEnabled( tr_session * session, bool isEnabled )
     2289tr_blocklistSetEnabled (tr_session * session, bool isEnabled)
    22882290{
    22892291    tr_list * l;
    22902292
    2291     assert( tr_isSession( session ) );
     2293    assert (tr_isSession (session));
    22922294
    22932295    session->isBlocklistEnabled = isEnabled != 0;
    22942296
    2295     for( l=session->blocklists; l!=NULL; l=l->next )
    2296         _tr_blocklistSetEnabled( l->data, isEnabled );
    2297 }
    2298 
    2299 bool
    2300 tr_blocklistExists( const tr_session * session )
    2301 {
    2302     assert( tr_isSession( session ) );
     2297    for (l=session->blocklists; l!=NULL; l=l->next)
     2298        _tr_blocklistSetEnabled (l->data, isEnabled);
     2299}
     2300
     2301bool
     2302tr_blocklistExists (const tr_session * session)
     2303{
     2304    assert (tr_isSession (session));
    23032305
    23042306    return session->blocklists != NULL;
     
    23062308
    23072309int
    2308 tr_blocklistSetContent( tr_session * session, const char * contentFilename )
     2310tr_blocklistSetContent (tr_session * session, const char * contentFilename)
    23092311{
    23102312    tr_list * l;
     
    23122314    tr_blocklist * b;
    23132315    const char * defaultName = DEFAULT_BLOCKLIST_FILENAME;
    2314     tr_sessionLock( session );
    2315 
    2316     for( b = NULL, l = session->blocklists; !b && l; l = l->next )
    2317         if( tr_stringEndsWith( _tr_blocklistGetFilename( l->data ),
    2318                                defaultName ) )
     2316    tr_sessionLock (session);
     2317
     2318    for (b = NULL, l = session->blocklists; !b && l; l = l->next)
     2319        if (tr_stringEndsWith (_tr_blocklistGetFilename (l->data),
     2320                               defaultName))
    23192321            b = l->data;
    23202322
    2321     if( !b )
     2323    if (!b)
    23222324    {
    2323         char * path = tr_buildPath( session->configDir, "blocklists", defaultName, NULL );
    2324         b = _tr_blocklistNew( path, session->isBlocklistEnabled );
    2325         tr_list_append( &session->blocklists, b );
    2326         tr_free( path );
    2327     }
    2328 
    2329     ruleCount = _tr_blocklistSetContent( b, contentFilename );
    2330     tr_sessionUnlock( session );
     2325        char * path = tr_buildPath (session->configDir, "blocklists", defaultName, NULL);
     2326        b = _tr_blocklistNew (path, session->isBlocklistEnabled);
     2327        tr_list_append (&session->blocklists, b);
     2328        tr_free (path);
     2329    }
     2330
     2331    ruleCount = _tr_blocklistSetContent (b, contentFilename);
     2332    tr_sessionUnlock (session);
    23312333    return ruleCount;
    23322334}
    23332335
    23342336bool
    2335 tr_sessionIsAddressBlocked( const tr_session * session,
    2336                             const tr_address * addr )
     2337tr_sessionIsAddressBlocked (const tr_session * session,
     2338                            const tr_address * addr)
    23372339{
    23382340    tr_list * l;
    23392341
    2340     assert( tr_isSession( session ) );
    2341 
    2342     for( l = session->blocklists; l; l = l->next )
    2343         if( _tr_blocklistHasAddress( l->data, addr ) )
     2342    assert (tr_isSession (session));
     2343
     2344    for (l = session->blocklists; l; l = l->next)
     2345        if (_tr_blocklistHasAddress (l->data, addr))
    23442346            return true;
    23452347    return false;
     
    23472349
    23482350void
    2349 tr_blocklistSetURL( tr_session * session, const char * url )
    2350 {
    2351     if( session->blocklist_url != url )
     2351tr_blocklistSetURL (tr_session * session, const char * url)
     2352{
     2353    if (session->blocklist_url != url)
    23522354    {
    2353         tr_free( session->blocklist_url );
    2354         session->blocklist_url = tr_strdup( url );
     2355        tr_free (session->blocklist_url);
     2356        session->blocklist_url = tr_strdup (url);
    23552357    }
    23562358}
    23572359
    23582360const char *
    2359 tr_blocklistGetURL ( const tr_session * session )
     2361tr_blocklistGetURL (const tr_session * session)
    23602362{
    23612363    return session->blocklist_url;
     
    23682370
    23692371static void
    2370 metainfoLookupInit( tr_session * session )
     2372metainfoLookupInit (tr_session * session)
    23712373{
    23722374    struct stat  sb;
    2373     const char * dirname = tr_getTorrentDir( session );
     2375    const char * dirname = tr_getTorrentDir (session);
    23742376    DIR *        odir = NULL;
    23752377    tr_ctor *    ctor = NULL;
     
    23772379    int n = 0;
    23782380
    2379     assert( tr_isSession( session ) );
     2381    assert (tr_isSession (session));
    23802382
    23812383    /* walk through the directory and find the mappings */
    2382     lookup = tr_new0( tr_benc, 1 );
    2383     tr_bencInitDict( lookup, 0 );
    2384     ctor = tr_ctorNew( session );
    2385     tr_ctorSetSave( ctor, false ); /* since we already have them */
    2386     if( !stat( dirname, &sb ) && S_ISDIR( sb.st_mode ) && ( ( odir = opendir( dirname ) ) ) )
     2384    lookup = tr_new0 (tr_benc, 1);
     2385    tr_bencInitDict (lookup, 0);
     2386    ctor = tr_ctorNew (session);
     2387    tr_ctorSetSave (ctor, false); /* since we already have them */
     2388    if (!stat (dirname, &sb) && S_ISDIR (sb.st_mode) && ((odir = opendir (dirname))))
    23872389    {
    23882390        struct dirent *d;
    2389         while(( d = readdir( odir )))
     2391        while ((d = readdir (odir)))
    23902392        {
    2391             if( tr_str_has_suffix( d->d_name, ".torrent" ) )
     2393            if (tr_str_has_suffix (d->d_name, ".torrent"))
    23922394            {
    23932395                tr_info inf;
    2394                 char * path = tr_buildPath( dirname, d->d_name, NULL );
    2395                 tr_ctorSetMetainfoFromFile( ctor, path );
    2396                 if( !tr_torrentParse( ctor, &inf ) )
     2396                char * path = tr_buildPath (dirname, d->d_name, NULL);
     2397                tr_ctorSetMetainfoFromFile (ctor, path);
     2398                if (!tr_torrentParse (ctor, &inf))
    23972399                {
    23982400                    ++n;
    2399                     tr_bencDictAddStr( lookup, inf.hashString, path );
     2401                    tr_bencDictAddStr (lookup, inf.hashString, path);
    24002402                }
    2401                 tr_free( path );
     2403                tr_free (path);
    24022404            }
    24032405        }
    2404         closedir( odir );
    2405     }
    2406     tr_ctorFree( ctor );
     2406        closedir (odir);
     2407    }
     2408    tr_ctorFree (ctor);
    24072409
    24082410    session->metainfoLookup = lookup;
    2409     tr_dbg( "Found %d torrents in \"%s\"", n, dirname );
     2411    tr_dbg ("Found %d torrents in \"%s\"", n, dirname);
    24102412}
    24112413
    24122414const char*
    2413 tr_sessionFindTorrentFile( const tr_session * session,
    2414                            const char       * hashString )
     2415tr_sessionFindTorrentFile (const tr_session * session,
     2416                           const char       * hashString)
    24152417{
    24162418    const char * filename = NULL;
    2417     if( !session->metainfoLookup )
    2418         metainfoLookupInit( (tr_session*)session );
    2419     tr_bencDictFindStr( session->metainfoLookup, hashString, &filename );
     2419    if (!session->metainfoLookup)
     2420        metainfoLookupInit ((tr_session*)session);
     2421    tr_bencDictFindStr (session->metainfoLookup, hashString, &filename);
    24202422    return filename;
    24212423}
    24222424
    24232425void
    2424 tr_sessionSetTorrentFile( tr_session * session,
     2426tr_sessionSetTorrentFile (tr_session * session,
    24252427                          const char * hashString,
    2426                           const char * filename )
     2428                          const char * filename)
    24272429{
    24282430    /* since we walk session->configDir/torrents/ to build the lookup table,
    2429      * and tr_sessionSetTorrentFile() is just to tell us there's a new file
     2431     * and tr_sessionSetTorrentFile () is just to tell us there's a new file
    24302432     * in that same directory, we don't need to do anything here if the
    24312433     * lookup table hasn't been built yet */
    2432     if( session->metainfoLookup )
    2433         tr_bencDictAddStr( session->metainfoLookup, hashString, filename );
     2434    if (session->metainfoLookup)
     2435        tr_bencDictAddStr (session->metainfoLookup, hashString, filename);
    24342436}
    24352437
     
    24392441
    24402442void
    2441 tr_sessionSetRPCEnabled( tr_session * session, bool isEnabled )
    2442 {
    2443     assert( tr_isSession( session ) );
    2444 
    2445     tr_rpcSetEnabled( session->rpcServer, isEnabled );
    2446 }
    2447 
    2448 bool
    2449 tr_sessionIsRPCEnabled( const tr_session * session )
    2450 {
    2451     assert( tr_isSession( session ) );
    2452 
    2453     return tr_rpcIsEnabled( session->rpcServer );
    2454 }
    2455 
    2456 void
    2457 tr_sessionSetRPCPort( tr_session * session,
    2458                       tr_port      port )
    2459 {
    2460     assert( tr_isSession( session ) );
    2461 
    2462     tr_rpcSetPort( session->rpcServer, port );
     2443tr_sessionSetRPCEnabled (tr_session * session, bool isEnabled)
     2444{
     2445    assert (tr_isSession (session));
     2446
     2447    tr_rpcSetEnabled (session->rpcServer, isEnabled);
     2448}
     2449
     2450bool
     2451tr_sessionIsRPCEnabled (const tr_session * session)
     2452{
     2453    assert (tr_isSession (session));
     2454
     2455    return tr_rpcIsEnabled (session->rpcServer);
     2456}
     2457
     2458void
     2459tr_sessionSetRPCPort (tr_session * session,
     2460                      tr_port      port)
     2461{
     2462    assert (tr_isSession (session));
     2463
     2464    tr_rpcSetPort (session->rpcServer, port);
    24632465}
    24642466
    24652467tr_port
    2466 tr_sessionGetRPCPort( const tr_session * session )
    2467 {
    2468     assert( tr_isSession( session ) );
    2469 
    2470     return tr_rpcGetPort( session->rpcServer );
    2471 }
    2472 
    2473 void
    2474 tr_sessionSetRPCUrl( tr_session * session,
    2475                      const char * url )
    2476 {
    2477     assert( tr_isSession( session ) );
    2478 
    2479     tr_rpcSetUrl( session->rpcServer, url );
     2468tr_sessionGetRPCPort (const tr_session * session)
     2469{
     2470    assert (tr_isSession (session));
     2471
     2472    return tr_rpcGetPort (session->rpcServer);
     2473}
     2474
     2475void
     2476tr_sessionSetRPCUrl (tr_session * session,
     2477                     const char * url)
     2478{
     2479    assert (tr_isSession (session));
     2480
     2481    tr_rpcSetUrl (session->rpcServer, url);
    24802482}
    24812483
    24822484const char*
    2483 tr_sessionGetRPCUrl( const tr_session * session )
    2484 {
    2485     assert( tr_isSession( session ) );
    2486 
    2487     return tr_rpcGetUrl( session->rpcServer );
    2488 }
    2489 
    2490 void
    2491 tr_sessionSetRPCCallback( tr_session * session,
     2485tr_sessionGetRPCUrl (const tr_session * session)
     2486{
     2487    assert (tr_isSession (session));
     2488
     2489    return tr_rpcGetUrl (session->rpcServer);
     2490}
     2491
     2492void
     2493tr_sessionSetRPCCallback (tr_session * session,
    24922494                          tr_rpc_func  func,
    2493                           void *       user_data )
    2494 {
    2495     assert( tr_isSession( session ) );
     2495                          void *       user_data)
     2496{
     2497    assert (tr_isSession (session));
    24962498
    24972499    session->rpc_func = func;
     
    25002502
    25012503void
    2502 tr_sessionSetRPCWhitelist( tr_session * session,
    2503                            const char * whitelist )
    2504 {
    2505     assert( tr_isSession( session ) );
    2506 
    2507     tr_rpcSetWhitelist( session->rpcServer, whitelist );
     2504tr_sessionSetRPCWhitelist (tr_session * session,
     2505                           const char * whitelist)
     2506{
     2507    assert (tr_isSession (session));
     2508
     2509    tr_rpcSetWhitelist (session->rpcServer, whitelist);
    25082510}
    25092511
    25102512const char*
    2511 tr_sessionGetRPCWhitelist( const tr_session * session )
    2512 {
    2513     assert( tr_isSession( session ) );
    2514 
    2515     return tr_rpcGetWhitelist( session->rpcServer );
    2516 }
    2517 
    2518 void
    2519 tr_sessionSetRPCWhitelistEnabled( tr_session * session, bool isEnabled )
    2520 {
    2521     assert( tr_isSession( session ) );
    2522 
    2523     tr_rpcSetWhitelistEnabled( session->rpcServer, isEnabled );
    2524 }
    2525 
    2526 bool
    2527 tr_sessionGetRPCWhitelistEnabled( const tr_session * session )
    2528 {
    2529     assert( tr_isSession( session ) );
    2530 
    2531     return tr_rpcGetWhitelistEnabled( session->rpcServer );
    2532 }
    2533 
    2534 
    2535 void
    2536 tr_sessionSetRPCPassword( tr_session * session,
    2537                           const char * password )
    2538 {
    2539     assert( tr_isSession( session ) );
    2540 
    2541     tr_rpcSetPassword( session->rpcServer, password );
     2513tr_sessionGetRPCWhitelist (const tr_session * session)
     2514{
     2515    assert (tr_isSession (session));
     2516
     2517    return tr_rpcGetWhitelist (session->rpcServer);
     2518}
     2519
     2520void
     2521tr_sessionSetRPCWhitelistEnabled (tr_session * session, bool isEnabled)
     2522{
     2523    assert (tr_isSession (session));
     2524
     2525    tr_rpcSetWhitelistEnabled (session->rpcServer, isEnabled);
     2526}
     2527
     2528bool
     2529tr_sessionGetRPCWhitelistEnabled (const tr_session * session)
     2530{
     2531    assert (tr_isSession (session));
     2532
     2533    return tr_rpcGetWhitelistEnabled (session->rpcServer);
     2534}
     2535
     2536
     2537void
     2538tr_sessionSetRPCPassword (tr_session * session,
     2539                          const char * password)
     2540{
     2541    assert (tr_isSession (session));
     2542
     2543    tr_rpcSetPassword (session->rpcServer, password);
    25422544}
    25432545
    25442546const char*
    2545 tr_sessionGetRPCPassword( const tr_session * session )
    2546 {
    2547     assert( tr_isSession( session ) );
    2548 
    2549     return tr_rpcGetPassword( session->rpcServer );
    2550 }
    2551 
    2552 void
    2553 tr_sessionSetRPCUsername( tr_session * session,
    2554                           const char * username )
    2555 {
    2556     assert( tr_isSession( session ) );
    2557 
    2558     tr_rpcSetUsername( session->rpcServer, username );
     2547tr_sessionGetRPCPassword (const tr_session * session)
     2548{
     2549    assert (tr_isSession (session));
     2550
     2551    return tr_rpcGetPassword (session->rpcServer);
     2552}
     2553
     2554void
     2555tr_sessionSetRPCUsername (tr_session * session,
     2556                          const char * username)
     2557{
     2558    assert (tr_isSession (session));
     2559
     2560    tr_rpcSetUsername (session->rpcServer, username);
    25592561}
    25602562
    25612563const char*
    2562 tr_sessionGetRPCUsername( const tr_session * session )
    2563 {
    2564     assert( tr_isSession( session ) );
    2565 
    2566     return tr_rpcGetUsername( session->rpcServer );
    2567 }
    2568 
    2569 void
    2570 tr_sessionSetRPCPasswordEnabled( tr_session * session, bool isEnabled )
    2571 {
    2572     assert( tr_isSession( session ) );
    2573 
    2574     tr_rpcSetPasswordEnabled( session->rpcServer, isEnabled );
    2575 }
    2576 
    2577 bool
    2578 tr_sessionIsRPCPasswordEnabled( const tr_session * session )
    2579 {
    2580     assert( tr_isSession( session ) );
    2581 
    2582     return tr_rpcIsPasswordEnabled( session->rpcServer );
     2564tr_sessionGetRPCUsername (const tr_session * session)
     2565{
     2566    assert (tr_isSession (session));
     2567
     2568    return tr_rpcGetUsername (session->rpcServer);
     2569}
     2570
     2571void
     2572tr_sessionSetRPCPasswordEnabled (tr_session * session, bool isEnabled)
     2573{
     2574    assert (tr_isSession (session));
     2575
     2576    tr_rpcSetPasswordEnabled (session->rpcServer, isEnabled);
     2577}
     2578
     2579bool
     2580tr_sessionIsRPCPasswordEnabled (const tr_session * session)
     2581{
     2582    assert (tr_isSession (session));
     2583
     2584    return tr_rpcIsPasswordEnabled (session->rpcServer);
    25832585}
    25842586
    25852587const char *
    2586 tr_sessionGetRPCBindAddress( const tr_session * session )
    2587 {
    2588     assert( tr_isSession( session ) );
    2589 
    2590     return tr_rpcGetBindAddress( session->rpcServer );
     2588tr_sessionGetRPCBindAddress (const tr_session * session)
     2589{
     2590    assert (tr_isSession (session));
     2591
     2592    return tr_rpcGetBindAddress (session->rpcServer);
    25912593}
    25922594
     
    25962598
    25972599bool
    2598 tr_sessionIsTorrentDoneScriptEnabled( const tr_session * session )
    2599 {
    2600     assert( tr_isSession( session ) );
     2600tr_sessionIsTorrentDoneScriptEnabled (const tr_session * session)
     2601{
     2602    assert (tr_isSession (session));
    26012603
    26022604    return session->isTorrentDoneScriptEnabled;
     
    26042606
    26052607void
    2606 tr_sessionSetTorrentDoneScriptEnabled( tr_session * session, bool isEnabled )
    2607 {
    2608     assert( tr_isSession( session ) );
    2609     assert( tr_isBool( isEnabled ) );
     2608tr_sessionSetTorrentDoneScriptEnabled (tr_session * session, bool isEnabled)
     2609{
     2610    assert (tr_isSession (session));
     2611    assert (tr_isBool (isEnabled));
    26102612
    26112613    session->isTorrentDoneScriptEnabled = isEnabled;
     
    26132615
    26142616const char *
    2615 tr_sessionGetTorrentDoneScript( const tr_session * session )
    2616 {
    2617     assert( tr_isSession( session ) );
     2617tr_sessionGetTorrentDoneScript (const tr_session * session)
     2618{
     2619    assert (tr_isSession (session));
    26182620
    26192621    return session->torrentDoneScript;
     
    26212623
    26222624void
    2623 tr_sessionSetTorrentDoneScript( tr_session * session, const char * scriptFilename )
    2624 {
    2625     assert( tr_isSession( session ) );
    2626 
    2627     if( session->torrentDoneScript != scriptFilename )
     2625tr_sessionSetTorrentDoneScript (tr_session * session, const char * scriptFilename)
     2626{
     2627    assert (tr_isSession (session));
     2628
     2629    if (session->torrentDoneScript != scriptFilename)
    26282630    {
    2629         tr_free( session->torrentDoneScript );
    2630         session->torrentDoneScript = tr_strdup( scriptFilename );
     2631        tr_free (session->torrentDoneScript);
     2632        session->torrentDoneScript = tr_strdup (scriptFilename);
    26312633    }
    26322634}
     
    26372639
    26382640void
    2639 tr_sessionSetQueueSize( tr_session * session, tr_direction dir, int n )
    2640 {
    2641     assert( tr_isSession( session ) );
    2642     assert( tr_isDirection( dir ) );
     2641tr_sessionSetQueueSize (tr_session * session, tr_direction dir, int n)
     2642{
     2643    assert (tr_isSession (session));
     2644    assert (tr_isDirection (dir));
    26432645
    26442646    session->queueSize[dir] = n;
     
    26462648
    26472649int
    2648 tr_sessionGetQueueSize( const tr_session * session, tr_direction dir )
    2649 {
    2650     assert( tr_isSession( session ) );
    2651     assert( tr_isDirection( dir ) );
     2650tr_sessionGetQueueSize (const tr_session * session, tr_direction dir)
     2651{
     2652    assert (tr_isSession (session));
     2653    assert (tr_isDirection (dir));
    26522654
    26532655    return session->queueSize[dir];
     
    26552657
    26562658void
    2657 tr_sessionSetQueueEnabled( tr_session * session, tr_direction dir, bool is_enabled )
    2658 {
    2659     assert( tr_isSession( session ) );
    2660     assert( tr_isDirection( dir ) );
    2661     assert( tr_isBool( is_enabled ) );
     2659tr_sessionSetQueueEnabled (tr_session * session, tr_direction dir, bool is_enabled)
     2660{
     2661    assert (tr_isSession (session));
     2662    assert (tr_isDirection (dir));
     2663    assert (tr_isBool (is_enabled));
    26622664
    26632665    session->queueEnabled[dir] = is_enabled;
     
    26652667
    26662668bool
    2667 tr_sessionGetQueueEnabled( const tr_session * session, tr_direction dir )
    2668 {
    2669     assert( tr_isSession( session ) );
    2670     assert( tr_isDirection( dir ) );
     2669tr_sessionGetQueueEnabled (const tr_session * session, tr_direction dir)
     2670{
     2671    assert (tr_isSession (session));
     2672    assert (tr_isDirection (dir));
    26712673
    26722674    return session->queueEnabled[dir];
     
    26742676
    26752677void
    2676 tr_sessionSetQueueStalledMinutes( tr_session * session, int minutes )
    2677 {
    2678     assert( tr_isSession( session ) );
    2679     assert( minutes > 0 );
     2678tr_sessionSetQueueStalledMinutes (tr_session * session, int minutes)
     2679{
     2680    assert (tr_isSession (session));
     2681    assert (minutes > 0);
    26802682
    26812683    session->queueStalledMinutes = minutes;
     
    26832685
    26842686void
    2685 tr_sessionSetQueueStalledEnabled( tr_session * session, bool is_enabled )
    2686 {
    2687     assert( tr_isSession( session ) );
    2688     assert( tr_isBool( is_enabled ) );
     2687tr_sessionSetQueueStalledEnabled (tr_session * session, bool is_enabled)
     2688{
     2689    assert (tr_isSession (session));
     2690    assert (tr_isBool (is_enabled));
    26892691
    26902692    session->stalledEnabled = is_enabled;
     
    26922694
    26932695bool
    2694 tr_sessionGetQueueStalledEnabled( const tr_session * session )
    2695 {
    2696     assert( tr_isSession( session ) );
     2696tr_sessionGetQueueStalledEnabled (const tr_session * session)
     2697{
     2698    assert (tr_isSession (session));
    26972699
    26982700    return session->stalledEnabled;
     
    27002702
    27012703int
    2702 tr_sessionGetQueueStalledMinutes( const tr_session * session )
    2703 {
    2704     assert( tr_isSession( session ) );
     2704tr_sessionGetQueueStalledMinutes (const tr_session * session)
     2705{
     2706    assert (tr_isSession (session));
    27052707
    27062708    return session->queueStalledMinutes;
     
    27082710
    27092711tr_torrent *
    2710 tr_sessionGetNextQueuedTorrent( tr_session * session, tr_direction direction )
     2712tr_sessionGetNextQueuedTorrent (tr_session * session, tr_direction direction)
    27112713{
    27122714    tr_torrent * tor = NULL;
     
    27142716    int best_position = INT_MAX;
    27152717
    2716     assert( tr_isSession( session ) );
    2717     assert( tr_isDirection( direction ) );
    2718 
    2719     while(( tor = tr_torrentNext( session, tor )))
     2718    assert (tr_isSession (session));
     2719    assert (tr_isDirection (direction));
     2720
     2721    while ((tor = tr_torrentNext (session, tor)))
    27202722    {
    27212723        int position;
    27222724
    2723         if( !tr_torrentIsQueued( tor ) )
     2725        if (!tr_torrentIsQueued (tor))
    27242726            continue;
    2725         if( direction != tr_torrentGetQueueDirection( tor ) )
     2727        if (direction != tr_torrentGetQueueDirection (tor))
    27262728            continue;
    27272729
    2728         position = tr_torrentGetQueuePosition( tor );
    2729         if( best_position > position ) {
     2730        position = tr_torrentGetQueuePosition (tor);
     2731        if (best_position > position) {
    27302732            best_position = position;
    27312733            best_tor = tor;
     
    27372739
    27382740int
    2739 tr_sessionCountQueueFreeSlots( tr_session * session, tr_direction dir )
     2741tr_sessionCountQueueFreeSlots (tr_session * session, tr_direction dir)
    27402742{
    27412743    tr_torrent * tor;
    27422744    int active_count;
    2743     const int max = tr_sessionGetQueueSize( session, dir );
     2745    const int max = tr_sessionGetQueueSize (session, dir);
    27442746    const tr_torrent_activity activity = dir == TR_UP ? TR_STATUS_SEED : TR_STATUS_DOWNLOAD;
    27452747
    2746     if( !tr_sessionGetQueueEnabled( session, dir ) )
     2748    if (!tr_sessionGetQueueEnabled (session, dir))
    27472749        return INT_MAX;
    27482750
    27492751    tor = NULL;
    27502752    active_count = 0;
    2751     while(( tor = tr_torrentNext( session, tor )))
    2752         if( !tr_torrentIsStalled( tor ) )
    2753             if( tr_torrentGetActivity( tor ) == activity )
     2753    while ((tor = tr_torrentNext (session, tor)))
     2754        if (!tr_torrentIsStalled (tor))
     2755            if (tr_torrentGetActivity (tor) == activity)
    27542756                ++active_count;
    27552757
    2756     if( active_count >= max )
     2758    if (active_count >= max)
    27572759        return 0;
    27582760
Note: See TracChangeset for help on using the changeset viewer.