source: branches/1.5x/libtransmission/session.c @ 7897

Last change on this file since 7897 was 7897, checked in by charles, 13 years ago

(1.5x libT) backport the tr_sessionInit() changes from trunk to fix #1827: Race Condition in tr_sessionInit()

  • Property svn:keywords set to Date Rev Author Id
File size: 43.7 KB
Line 
1/*
2 * This file Copyright (C) 2008-2009 Charles Kerr <charles@transmissionbt.com>
3 *
4 * 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)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: session.c 7897 2009-02-18 02:11:15Z charles $
11 */
12
13#include <assert.h>
14#include <stdlib.h>
15#include <string.h> /* memcpy */
16
17#include <signal.h>
18#include <sys/types.h> /* stat */
19#include <sys/stat.h> /* stat */
20#include <unistd.h> /* stat */
21#include <dirent.h> /* opendir */
22
23#include "transmission.h"
24#include "session.h"
25#include "bandwidth.h"
26#include "bencode.h"
27#include "blocklist.h"
28#include "fdlimit.h"
29#include "list.h"
30#include "metainfo.h" /* tr_metainfoFree */
31#include "net.h"
32#include "peer-mgr.h"
33#include "platform.h" /* tr_lock */
34#include "port-forwarding.h"
35#include "rpc-server.h"
36#include "stats.h"
37#include "torrent.h"
38#include "tracker.h"
39#include "trevent.h"
40#include "utils.h"
41#include "web.h"
42#include "crypto.h"
43
44#define dbgmsg( ... ) \
45    do { \
46        if( tr_deepLoggingIsActive( ) ) \
47            tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
48    } while( 0 )
49
50static tr_port
51getRandomPort( tr_session * s )
52{
53    return tr_cryptoWeakRandInt( s->randomPortHigh - s->randomPortLow + 1) + s->randomPortLow;
54}
55
56/* Generate a peer id : "-TRxyzb-" + 12 random alphanumeric
57   characters, where x is the major version number, y is the
58   minor version number, z is the maintenance number, and b
59   designates beta (Azureus-style) */
60uint8_t*
61tr_peerIdNew( void )
62{
63    int          i;
64    int          val;
65    int          total = 0;
66    uint8_t *    buf = tr_new( uint8_t, 21 );
67    const char * pool = "0123456789abcdefghijklmnopqrstuvwxyz";
68    const int    base = 36;
69
70    memcpy( buf, PEERID_PREFIX, 8 );
71
72    for( i = 8; i < 19; ++i )
73    {
74        val = tr_cryptoRandInt( base );
75        total += val;
76        buf[i] = pool[val];
77    }
78
79    val = total % base ? base - ( total % base ) : 0;
80    buf[19] = pool[val];
81    buf[20] = '\0';
82
83    return buf;
84}
85
86const uint8_t*
87tr_getPeerId( void )
88{
89    static uint8_t * id = NULL;
90
91    if( id == NULL )
92        id = tr_peerIdNew( );
93    return id;
94}
95
96/***
97****
98***/
99
100tr_encryption_mode
101tr_sessionGetEncryption( tr_session * session )
102{
103    assert( session );
104
105    return session->encryptionMode;
106}
107
108void
109tr_sessionSetEncryption( tr_session *       session,
110                         tr_encryption_mode mode )
111{
112    assert( session );
113    assert( mode == TR_ENCRYPTION_PREFERRED
114          || mode == TR_ENCRYPTION_REQUIRED
115          || mode == TR_CLEAR_PREFERRED );
116
117    session->encryptionMode = mode;
118}
119
120/***
121****
122***/
123
124static int
125tr_stringEndsWith( const char * str,
126                   const char * end )
127{
128    const size_t slen = strlen( str );
129    const size_t elen = strlen( end );
130
131    return slen >= elen && !memcmp( &str[slen - elen], end, elen );
132}
133
134static void
135loadBlocklists( tr_session * session )
136{
137    int         binCount = 0;
138    int         newCount = 0;
139    struct stat sb;
140    char      * dirname;
141    DIR *       odir = NULL;
142    tr_list *   list = NULL;
143    const tr_bool   isEnabled = session->isBlocklistEnabled;
144
145    /* walk through the directory and find blocklists */
146    dirname = tr_buildPath( session->configDir, "blocklists", NULL );
147    if( !stat( dirname,
148               &sb ) && S_ISDIR( sb.st_mode )
149      && ( ( odir = opendir( dirname ) ) ) )
150    {
151        struct dirent *d;
152        for( d = readdir( odir ); d; d = readdir( odir ) )
153        {
154            char * filename;
155
156            if( !d->d_name || d->d_name[0] == '.' ) /* skip dotfiles, ., and ..
157                                                      */
158                continue;
159
160            filename = tr_buildPath( dirname, d->d_name, NULL );
161
162            if( tr_stringEndsWith( filename, ".bin" ) )
163            {
164                /* if we don't already have this blocklist, add it */
165                if( !tr_list_find( list, filename,
166                                   (TrListCompareFunc)strcmp ) )
167                {
168                    tr_list_append( &list,
169                                   _tr_blocklistNew( filename, isEnabled ) );
170                    ++binCount;
171                }
172            }
173            else
174            {
175                /* strip out the file suffix, if there is one, and add ".bin"
176                  instead */
177                tr_blocklist * b;
178                const char *   dot = strrchr( d->d_name, '.' );
179                const int      len = dot ? dot - d->d_name
180                                         : (int)strlen( d->d_name );
181                char         * tmp = tr_strdup_printf(
182                                        "%s" TR_PATH_DELIMITER_STR "%*.*s.bin",
183                                        dirname, len, len, d->d_name );
184                b = _tr_blocklistNew( tmp, isEnabled );
185                _tr_blocklistSetContent( b, filename );
186                tr_list_append( &list, b );
187                ++newCount;
188                tr_free( tmp );
189            }
190
191            tr_free( filename );
192        }
193
194        closedir( odir );
195    }
196
197    session->blocklists = list;
198
199    if( binCount )
200        tr_dbg( "Found %d blocklists in \"%s\"", binCount, dirname );
201    if( newCount )
202        tr_dbg( "Found %d new blocklists in \"%s\"", newCount, dirname );
203
204    tr_free( dirname );
205}
206
207/***
208****
209***/
210
211#ifdef TR_EMBEDDED
212 #define TR_DEFAULT_ENCRYPTION              TR_CLEAR_PREFERRED
213#else
214 #define TR_DEFAULT_ENCRYPTION              TR_ENCRYPTION_PREFERRED
215#endif
216
217void
218tr_sessionGetDefaultSettings( tr_benc * d )
219{
220    assert( tr_bencIsDict( d ) );
221
222    tr_bencDictReserve( d, 30 );
223    tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        FALSE );
224    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,             tr_getDefaultDownloadDir( ) );
225    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED,                   100 );
226    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED,           0 );
227    tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION,               TR_DEFAULT_ENCRYPTION );
228    tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD,            TRUE );
229    tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL,                 TR_MSG_INF );
230    tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT,          atoi( TR_DEFAULT_OPEN_FILE_LIMIT_STR ) );
231    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        atoi( TR_DEFAULT_PEER_LIMIT_GLOBAL_STR ) );
232    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       atoi( TR_DEFAULT_PEER_LIMIT_TORRENT_STR ) );
233    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT,                atoi( TR_DEFAULT_PEER_PORT_STR ) );
234    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, FALSE );
235    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     1024 );
236    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    65535 );
237    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          atoi( TR_DEFAULT_PEER_SOCKET_TOS_STR ) );
238    tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              TRUE );
239    tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          TRUE );
240    tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION,            TR_PREALLOCATE_SPARSE );
241    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    "" );
242    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       FALSE );
243    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED,            FALSE );
244    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD,           "" );
245    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT,               80 );
246    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE,               TR_PROXY_HTTP );
247    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME,           "" );
248    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        FALSE );
249    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED,              TRUE );
250    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD,             "" );
251    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME,             "" );
252    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST,            TR_DEFAULT_RPC_WHITELIST );
253    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    TRUE );
254    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,                 atoi( TR_DEFAULT_RPC_PORT_STR ) );
255    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   100 );
256    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           0 );
257    tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, 14 );
258}
259
260void
261tr_sessionGetSettings( tr_session * s, struct tr_benc * d )
262{
263    int i, n=0;
264    char * freeme[16];
265
266    assert( tr_bencIsDict( d ) );
267
268    tr_bencDictReserve( d, 30 );
269    tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        tr_blocklistIsEnabled( s ) );
270    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,             s->downloadDir );
271    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED,                   tr_sessionGetSpeedLimit( s, TR_DOWN ) );
272    tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED,           tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
273    tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION,               s->encryptionMode );
274    tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD,            s->useLazyBitfield );
275    tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL,                 tr_getMessageLevel( ) );
276    tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT,          s->openFileLimit );
277    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        tr_sessionGetPeerLimit( s ) );
278    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       s->peerLimitPerTorrent );
279    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT,                tr_sessionGetPeerPort( s ) );
280    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, s->isPortRandom );
281    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     s->randomPortLow );
282    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    s->randomPortHigh );
283    tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          s->peerSocketTOS );
284    tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              s->isPexEnabled );
285    tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          tr_sessionIsPortForwardingEnabled( s ) );
286    tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION,            s->preallocationMode );
287    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    s->proxy );
288    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       s->isProxyAuthEnabled );
289    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED,            s->isProxyEnabled );
290    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD,           s->proxyPassword );
291    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT,               s->proxyPort );
292    tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE,               s->proxyType );
293    tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME,           s->proxyUsername );
294    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        tr_sessionIsRPCPasswordEnabled( s ) );
295    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED,              tr_sessionIsRPCEnabled( s ) );
296    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD,             freeme[n++] = tr_sessionGetRPCPassword( s ) );
297    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,                 tr_sessionGetRPCPort( s ) );
298    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME,             freeme[n++] = tr_sessionGetRPCUsername( s ) );
299    tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST,            freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
300    tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    tr_sessionGetRPCWhitelistEnabled( s ) );
301    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   tr_sessionGetSpeedLimit( s, TR_UP ) );
302    tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
303    tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, s->uploadSlotsPerTorrent );
304
305    for( i=0; i<n; ++i )
306        tr_free( freeme[i] );
307}
308
309void
310tr_sessionLoadSettings( tr_benc * d, const char * configDir, const char * appName )
311{
312    char * filename;
313    tr_benc fileSettings;
314
315    assert( tr_bencIsDict( d ) );
316
317    /* get the defaults */
318    tr_sessionGetDefaultSettings( d );
319
320    /* if caller didn't specify a config dir, use the default */
321    if( !configDir || !*configDir )
322        configDir = tr_getDefaultConfigDir( appName );
323
324    /* file settings override the defaults */
325    filename = tr_buildPath( configDir, "settings.json", NULL );
326    if( !tr_bencLoadJSONFile( filename, &fileSettings ) ) {
327        tr_bencMergeDicts( d, &fileSettings );
328        tr_bencFree( &fileSettings );
329    }
330
331    /* cleanup */
332    tr_free( filename );
333}
334
335void
336tr_sessionSaveSettings( tr_session * session, const char * configDir, tr_benc * settings )
337{
338    tr_benc fileSettings;
339    char * filename;
340
341    assert( tr_bencIsDict( settings ) );
342 
343    filename = tr_buildPath( configDir, "settings.json", NULL );
344
345    tr_sessionGetSettings( session, settings );
346
347    if( tr_bencLoadJSONFile( filename, &fileSettings ) ) {
348        tr_bencSaveJSONFile( filename, settings );
349    } else {
350        tr_bencMergeDicts( &fileSettings, settings );
351        tr_bencSaveJSONFile( filename, &fileSettings );
352        tr_bencFree( &fileSettings );
353    }
354
355    tr_inf( "Saved \"%s\"", filename );
356    tr_free( filename );
357}
358
359static void metainfoLookupRescan( tr_session * );
360static void tr_sessionInitImpl( void * );
361
362struct init_data
363{
364    tr_session  * session;
365    const char  * configDir;
366    tr_bool       messageQueuingEnabled;
367    tr_benc     * clientSettings;
368};
369
370tr_session *
371tr_sessionInit( const char  * tag,
372                const char  * configDir,
373                tr_bool       messageQueuingEnabled,
374                tr_benc     * clientSettings )
375{
376    tr_session * session;
377    struct init_data data;
378
379    assert( tr_bencIsDict( clientSettings ) );
380
381    /* initialize the bare skeleton of the session object */
382    session = tr_new0( tr_session, 1 );
383    session->bandwidth = tr_bandwidthNew( session, NULL );
384    session->lock = tr_lockNew( );
385    session->tag = tr_strdup( tag );
386    session->magicNumber = SESSION_MAGIC_NUMBER;
387
388    /* start the libtransmission thread */
389    tr_netInit( ); /* must go before tr_eventInit */
390    tr_eventInit( session );
391    assert( session->events != NULL );
392
393    /* run the rest in the libtransmission thread */
394    session->isWaiting = TRUE;
395    data.session = session;
396    data.configDir = configDir;
397    data.messageQueuingEnabled = messageQueuingEnabled;
398    data.clientSettings = clientSettings;
399    tr_runInEventThread( session, tr_sessionInitImpl, &data );
400    while( session->isWaiting )
401        tr_wait( 100 );
402
403    return session;
404}
405
406static void
407tr_sessionInitImpl( void * vdata )
408{
409    int64_t i;
410    int64_t j;
411    tr_bool found;
412    const char * str;
413    tr_benc settings;
414    char * filename;
415    struct init_data * data = vdata;
416    tr_benc * clientSettings = data->clientSettings;
417    tr_session * session = data->session;
418
419    assert( tr_amInEventThread( session ) );
420    assert( tr_bencIsDict( clientSettings ) );
421
422    dbgmsg( "tr_sessionInit: the session's top-level bandwidth object is %p", session->bandwidth );
423
424    tr_bencInitDict( &settings, 0 );
425    tr_sessionGetDefaultSettings( &settings );
426    tr_bencMergeDicts( &settings, clientSettings );
427
428#ifndef WIN32
429    /* Don't exit when writing on a broken socket */
430    signal( SIGPIPE, SIG_IGN );
431#endif
432
433    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i );
434    assert( found );
435    session->peerLimitPerTorrent = i;
436
437    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_MSGLEVEL, &i );
438    assert( found );
439    tr_setMessageLevel( i );
440    tr_setMessageQueuing( data->messageQueuingEnabled );
441
442
443    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEX_ENABLED, &i );
444    assert( found );
445    session->isPexEnabled = i != 0;
446
447    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ENCRYPTION, &i );
448    assert( found );
449    assert( tr_isEncryptionMode( i ) );
450    session->encryptionMode = i;
451
452    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PREALLOCATION, &i );
453    assert( found );
454    assert( tr_isPreallocationMode( i ) );
455    session->preallocationMode = i;
456
457    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_SOCKET_TOS, &i );
458    assert( found );
459    session->peerSocketTOS = i;
460
461    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str );
462    assert( found );
463    session->downloadDir = tr_strdup( str );
464
465    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_ENABLED, &i );
466    assert( found );
467    session->isProxyEnabled = i != 0;
468
469    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY, &str );
470    assert( found );
471    session->proxy = tr_strdup( str );
472
473    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_PORT, &i );
474    assert( found );
475    session->proxyPort = i;
476
477    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_TYPE, &i );
478    assert( found );
479    session->proxyType = i;
480
481    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_AUTH_ENABLED, &i );
482    assert( found );
483    session->isProxyAuthEnabled = i != 0;
484
485    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY_USERNAME, &str );
486    assert( found );
487    session->proxyUsername = tr_strdup( str );
488
489    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY_PASSWORD, &str );
490    assert( found );
491    session->proxyPassword = tr_strdup( str );
492
493    session->so_sndbuf = 1500 * 3; /* 3x MTU for most ethernet/wireless */
494    session->so_rcvbuf = 8192;
495
496    tr_setConfigDir( session, data->configDir );
497
498    tr_trackerSessionInit( session );
499    assert( session->tracker != NULL );
500
501    session->peerMgr = tr_peerMgrNew( session );
502
503    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_LAZY_BITFIELD, &i );
504    assert( found );
505    session->useLazyBitfield = i != 0;
506
507    /* Initialize rate and file descripts controls */
508
509    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_OPEN_FILE_LIMIT, &i );
510    assert( found );
511    session->openFileLimit = i;
512    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &j );
513    assert( found );
514    tr_fdInit( session->openFileLimit, j );
515
516    /**
517    *** random port
518    **/
519
520    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, &i );
521    assert( found );
522    session->isPortRandom = i != 0;
523
524    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i );
525    assert( found );
526    session->randomPortLow = i;
527
528    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, &i );
529    assert( found );
530    session->randomPortHigh = i;
531
532    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, &i )
533         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT, &j );
534    assert( found );
535    session->peerPort = session->isPortRandom ? getRandomPort( session ) : j;
536    session->shared = tr_sharedInit( session, i, session->peerPort );
537    session->isPortSet = session->isPortRandom || j>0;
538
539    /**
540    **/
541
542    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, &i );
543    assert( found );
544    session->uploadSlotsPerTorrent = i;
545
546    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED, &i )
547         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED_ENABLED, &j );
548    assert( found );
549    tr_sessionSetSpeedLimit( session, TR_UP, i );
550    tr_sessionSetSpeedLimitEnabled( session, TR_UP, j );
551
552    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED, &i )
553         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED_ENABLED, &j );
554    assert( found );
555    tr_sessionSetSpeedLimit( session, TR_DOWN, i );
556    tr_sessionSetSpeedLimitEnabled( session, TR_DOWN, j );
557
558    /* initialize the blocklist */
559    filename = tr_buildPath( session->configDir, "blocklists", NULL );
560    tr_mkdirp( filename, 0777 );
561    tr_free( filename );
562    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i );
563    assert( found );
564    session->isBlocklistEnabled = i;
565    loadBlocklists( session );
566
567    session->rpcServer = tr_rpcInit( session, &settings );
568
569    tr_bencFree( &settings );
570
571    assert( tr_isSession( session ) );
572
573    /* first %s is the application name
574       second %s is the version number */
575    tr_inf( _( "%s %s started" ), TR_NAME, LONG_VERSION_STRING );
576
577    tr_statsInit( session );
578    session->web = tr_webInit( session );
579    metainfoLookupRescan( session );
580    session->isWaiting = FALSE;
581    dbgmsg( "returning session %p; session->tracker is %p", session, session->tracker );
582}
583
584/***
585****
586***/
587
588void
589tr_sessionSetDownloadDir( tr_session * session, const char * dir )
590{
591    assert( tr_isSession( session ) );
592
593    if( session->downloadDir != dir )
594    {
595        tr_free( session->downloadDir );
596        session->downloadDir = tr_strdup( dir );
597    }
598}
599
600const char *
601tr_sessionGetDownloadDir( const tr_session * session )
602{
603    assert( tr_isSession( session ) );
604
605    return session->downloadDir;
606}
607
608/***
609****
610***/
611
612void
613tr_globalLock( tr_session * session )
614{
615    assert( tr_isSession( session ) );
616
617    tr_lockLock( session->lock );
618}
619
620void
621tr_globalUnlock( tr_session * session )
622{
623    assert( tr_isSession( session ) );
624
625    tr_lockUnlock( session->lock );
626}
627
628tr_bool
629tr_globalIsLocked( const tr_session * session )
630{
631    return tr_isSession( session ) && tr_lockHave( session->lock );
632}
633
634/***********************************************************************
635 * tr_setBindPort
636 ***********************************************************************
637 *
638 **********************************************************************/
639
640struct bind_port_data
641{
642    tr_session * session;
643    tr_port      port;
644};
645
646static void
647tr_setBindPortImpl( void * vdata )
648{
649    struct bind_port_data * data = vdata;
650    tr_session * session = data->session;
651    const tr_port port = data->port;
652
653    session->isPortSet = 1;
654    tr_sharedSetPort( session->shared, port );
655
656    tr_free( data );
657}
658
659static void
660setPortImpl( tr_session * session, tr_port port )
661{
662    struct bind_port_data * data;
663
664    assert( tr_isSession( session ) );
665
666    data = tr_new( struct bind_port_data, 1 );
667    data->session = session;
668    data->port = port;
669    tr_runInEventThread( session, tr_setBindPortImpl, data );
670}
671
672void
673tr_sessionSetPeerPort( tr_session * session,
674                       tr_port      port )
675{
676    assert( tr_isSession( session ) );
677
678    session->isPortRandom = FALSE;
679    session->peerPort = port;
680    setPortImpl( session, session->peerPort );
681}
682
683tr_port
684tr_sessionSetPeerPortRandom( tr_session * session )
685{
686    assert( tr_isSession( session ) );
687
688    session->isPortRandom = TRUE;
689    session->peerPort = getRandomPort( session );
690    setPortImpl( session, session->peerPort );
691    return session->peerPort;
692}
693
694tr_port
695tr_sessionGetPeerPort( const tr_session * session )
696{
697    assert( tr_isSession( session ) );
698
699    return session->peerPort;
700}
701
702tr_port_forwarding
703tr_sessionGetPortForwarding( const tr_session * session )
704{
705    assert( tr_isSession( session ) );
706
707    return tr_sharedTraversalStatus( session->shared );
708}
709
710/***
711****
712***/
713
714static void
715updateBandwidth( tr_session * session, tr_direction dir )
716{
717    tr_bool zeroCase;
718
719    assert( tr_isSession( session ) );
720
721    zeroCase = session->speedLimit[dir] < 1 && session->isSpeedLimited[dir];
722
723    tr_bandwidthSetLimited( session->bandwidth, dir, session->isSpeedLimited[dir] && !zeroCase );
724
725    tr_bandwidthSetDesiredSpeed( session->bandwidth, dir, session->speedLimit[dir] );
726}
727
728void
729tr_sessionSetSpeedLimitEnabled( tr_session      * session,
730                                tr_direction      dir,
731                                tr_bool           isLimited )
732{
733    assert( tr_isSession( session ) );
734    assert( tr_isDirection( dir ) );
735
736    session->isSpeedLimited[dir] = isLimited;
737    updateBandwidth( session, dir );
738}
739
740void
741tr_sessionSetSpeedLimit( tr_session    * session,
742                         tr_direction    dir,
743                         int             desiredSpeed )
744{
745    assert( tr_isSession( session ) );
746    assert( tr_isDirection( dir ) );
747
748    session->speedLimit[dir] = desiredSpeed;
749    updateBandwidth( session, dir );
750}
751
752tr_bool
753tr_sessionIsSpeedLimitEnabled( const tr_session  * session,
754                               tr_direction        dir )
755{
756    assert( tr_isSession( session ) );
757    assert( tr_isDirection( dir ) );
758
759    return session->isSpeedLimited[dir];
760}
761
762int
763tr_sessionGetSpeedLimit( const tr_session  * session,
764                         tr_direction        dir )
765{
766    assert( tr_isSession( session ) );
767    assert( tr_isDirection( dir ) );
768
769    return session->speedLimit[dir];
770}
771
772/***
773****
774***/
775
776void
777tr_sessionSetPeerLimit( tr_session * session,
778                        uint16_t     maxGlobalPeers )
779{
780    assert( tr_isSession( session ) );
781
782    tr_fdSetPeerLimit( maxGlobalPeers );
783}
784
785uint16_t
786tr_sessionGetPeerLimit( const tr_session * session )
787{
788    assert( tr_isSession( session ) );
789
790    return tr_fdGetPeerLimit( );
791}
792
793void
794tr_sessionSetPeerLimitPerTorrent( tr_session  * session, uint16_t n )
795{
796    assert( tr_isSession( session ) );
797
798    session->peerLimitPerTorrent = n;
799}
800
801uint16_t
802tr_sessionGetPeerLimitPerTorrent( const tr_session * session )
803{
804    assert( tr_isSession( session ) );
805
806    return session->peerLimitPerTorrent;
807}
808
809/***
810****
811***/
812
813double
814tr_sessionGetPieceSpeed( const tr_session * session, tr_direction dir )
815{
816    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
817}
818
819double
820tr_sessionGetRawSpeed( const tr_session * session, tr_direction dir )
821{
822    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
823}
824
825int
826tr_sessionCountTorrents( const tr_session * session )
827{
828    return tr_isSession( session ) ? session->torrentCount : 0;
829}
830
831static int
832compareTorrentByCur( const void * va, const void * vb )
833{
834    const tr_torrent * a = *(const tr_torrent**)va;
835    const tr_torrent * b = *(const tr_torrent**)vb;
836    const uint64_t     aCur = a->downloadedCur + a->uploadedCur;
837    const uint64_t     bCur = b->downloadedCur + b->uploadedCur;
838
839    if( aCur != bCur )
840        return aCur > bCur ? -1 : 1; /* close the biggest torrents first */
841
842    return 0;
843}
844
845static void
846tr_closeAllConnections( void * vsession )
847{
848    tr_session *  session = vsession;
849    tr_torrent *  tor;
850    int           i, n;
851    tr_torrent ** torrents;
852
853    assert( tr_isSession( session ) );
854
855    tr_statsClose( session );
856    tr_sharedShuttingDown( session->shared );
857    tr_rpcClose( &session->rpcServer );
858
859    /* close the torrents.  get the most active ones first so that
860     * if we can't get them all closed in a reasonable amount of time,
861     * at least we get the most important ones first. */
862    tor = NULL;
863    n = session->torrentCount;
864    torrents = tr_new( tr_torrent *, session->torrentCount );
865    for( i = 0; i < n; ++i )
866        torrents[i] = tor = tr_torrentNext( session, tor );
867    qsort( torrents, n, sizeof( tr_torrent* ), compareTorrentByCur );
868    for( i = 0; i < n; ++i )
869        tr_torrentFree( torrents[i] );
870    tr_free( torrents );
871
872    tr_peerMgrFree( session->peerMgr );
873
874    tr_trackerSessionClose( session );
875    tr_list_free( &session->blocklists,
876                  (TrListForeachFunc)_tr_blocklistFree );
877    tr_webClose( &session->web );
878
879    session->isClosed = TRUE;
880}
881
882static int
883deadlineReached( const uint64_t deadline )
884{
885    return tr_date( ) >= deadline;
886}
887
888#define SHUTDOWN_MAX_SECONDS 30
889
890void
891tr_sessionClose( tr_session * session )
892{
893    int            i;
894    const int      maxwait_msec = SHUTDOWN_MAX_SECONDS * 1000;
895    const uint64_t deadline = tr_date( ) + maxwait_msec;
896
897    assert( tr_isSession( session ) );
898
899    dbgmsg( "shutting down transmission session %p", session );
900
901    /* close the session */
902    tr_runInEventThread( session, tr_closeAllConnections, session );
903    while( !session->isClosed && !deadlineReached( deadline ) )
904    {
905        dbgmsg(
906            "waiting for the shutdown commands to run in the main thread" );
907        tr_wait( 100 );
908    }
909
910    /* "shared" and "tracker" have live sockets,
911     * so we need to keep the transmission thread alive
912     * for a bit while they tell the router & tracker
913     * that we're closing now */
914    while( ( session->shared
915           || session->tracker ) && !deadlineReached( deadline ) )
916    {
917        dbgmsg( "waiting on port unmap (%p) or tracker (%p)",
918                session->shared, session->tracker );
919        tr_wait( 100 );
920    }
921
922    tr_fdClose( );
923
924    /* close the libtransmission thread */
925    tr_eventClose( session );
926    while( session->events && !deadlineReached( deadline ) )
927    {
928        dbgmsg( "waiting for the libevent thread to shutdown cleanly" );
929        tr_wait( 100 );
930    }
931
932    /* free the session memory */
933    tr_bandwidthFree( session->bandwidth );
934    tr_lockFree( session->lock );
935    for( i = 0; i < session->metainfoLookupCount; ++i )
936        tr_free( session->metainfoLookup[i].filename );
937    tr_free( session->metainfoLookup );
938    tr_free( session->tag );
939    tr_free( session->configDir );
940    tr_free( session->resumeDir );
941    tr_free( session->torrentDir );
942    tr_free( session->downloadDir );
943    tr_free( session->proxy );
944    tr_free( session->proxyUsername );
945    tr_free( session->proxyPassword );
946    tr_free( session );
947}
948
949tr_torrent **
950tr_sessionLoadTorrents( tr_session * session,
951                        tr_ctor    * ctor,
952                        int        * setmeCount )
953{
954    int           i, n = 0;
955    struct stat   sb;
956    DIR *         odir = NULL;
957    const char *  dirname = tr_getTorrentDir( session );
958    tr_torrent ** torrents;
959    tr_list *     l = NULL, *list = NULL;
960
961    assert( tr_isSession( session ) );
962
963    tr_ctorSetSave( ctor, FALSE ); /* since we already have them */
964
965    if( !stat( dirname, &sb )
966      && S_ISDIR( sb.st_mode )
967      && ( ( odir = opendir ( dirname ) ) ) )
968    {
969        struct dirent *d;
970        for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
971        {
972            if( d->d_name && d->d_name[0] != '.' ) /* skip dotfiles, ., and ..
973                                                     */
974            {
975                tr_torrent * tor;
976                char * path = tr_buildPath( dirname, d->d_name, NULL );
977                tr_ctorSetMetainfoFromFile( ctor, path );
978                if(( tor = tr_torrentNew( session, ctor, NULL )))
979                {
980                    tr_list_append( &list, tor );
981                    ++n;
982                }
983                tr_free( path );
984            }
985        }
986        closedir( odir );
987    }
988
989    torrents = tr_new( tr_torrent *, n );
990    for( i = 0, l = list; l != NULL; l = l->next )
991        torrents[i++] = (tr_torrent*) l->data;
992    assert( i == n );
993
994    tr_list_free( &list, NULL );
995
996    if( n )
997        tr_inf( _( "Loaded %d torrents" ), n );
998
999    if( setmeCount )
1000        *setmeCount = n;
1001    return torrents;
1002}
1003
1004/***
1005****
1006***/
1007
1008void
1009tr_sessionSetPexEnabled( tr_session * session,
1010                         tr_bool      enabled )
1011{
1012    assert( tr_isSession( session ) );
1013
1014    session->isPexEnabled = enabled != 0;
1015}
1016
1017tr_bool
1018tr_sessionIsPexEnabled( const tr_session * session )
1019{
1020    assert( tr_isSession( session ) );
1021
1022    return session->isPexEnabled;
1023}
1024
1025/***
1026****
1027***/
1028
1029void
1030tr_sessionSetLazyBitfieldEnabled( tr_session * session,
1031                                  tr_bool      enabled )
1032{
1033    assert( tr_isSession( session ) );
1034
1035    session->useLazyBitfield = enabled != 0;
1036}
1037
1038tr_bool
1039tr_sessionIsLazyBitfieldEnabled( const tr_session * session )
1040{
1041    assert( tr_isSession( session ) );
1042
1043    return session->useLazyBitfield;
1044}
1045
1046/***
1047****
1048***/
1049
1050void
1051tr_sessionSetPortForwardingEnabled( tr_session  * session,
1052                                    tr_bool       enabled )
1053{
1054    assert( tr_isSession( session ) );
1055
1056    tr_globalLock( session );
1057    tr_sharedTraversalEnable( session->shared, enabled );
1058    tr_globalUnlock( session );
1059}
1060
1061tr_bool
1062tr_sessionIsPortForwardingEnabled( const tr_session * session )
1063{
1064    assert( tr_isSession( session ) );
1065
1066    return tr_sharedTraversalIsEnabled( session->shared );
1067}
1068
1069/***
1070****
1071***/
1072
1073int
1074tr_blocklistGetRuleCount( const tr_session * session )
1075{
1076    int       n = 0;
1077    tr_list * l;
1078
1079    assert( tr_isSession( session ) );
1080
1081    for( l = session->blocklists; l; l = l->next )
1082        n += _tr_blocklistGetRuleCount( l->data );
1083    return n;
1084}
1085
1086tr_bool
1087tr_blocklistIsEnabled( const tr_session * session )
1088{
1089    assert( tr_isSession( session ) );
1090
1091    return session->isBlocklistEnabled;
1092}
1093
1094void
1095tr_blocklistSetEnabled( tr_session * session,
1096                        tr_bool      isEnabled )
1097{
1098    tr_list * l;
1099
1100    assert( tr_isSession( session ) );
1101
1102    session->isBlocklistEnabled = isEnabled != 0;
1103
1104    for( l=session->blocklists; l!=NULL; l=l->next )
1105        _tr_blocklistSetEnabled( l->data, isEnabled );
1106}
1107
1108tr_bool
1109tr_blocklistExists( const tr_session * session )
1110{
1111    assert( tr_isSession( session ) );
1112
1113    return session->blocklists != NULL;
1114}
1115
1116int
1117tr_blocklistSetContent( tr_session * session,
1118                        const char * contentFilename )
1119{
1120    tr_list *      l;
1121    tr_blocklist * b;
1122    const char *   defaultName = "level1.bin";
1123
1124    assert( tr_isSession( session ) );
1125
1126    for( b = NULL, l = session->blocklists; !b && l; l = l->next )
1127        if( tr_stringEndsWith( _tr_blocklistGetFilename( l->data ),
1128                               defaultName ) )
1129            b = l->data;
1130
1131    if( !b )
1132    {
1133        char * path = tr_buildPath( session->configDir, "blocklists", defaultName, NULL );
1134        b = _tr_blocklistNew( path, session->isBlocklistEnabled );
1135        tr_list_append( &session->blocklists, b );
1136        tr_free( path );
1137    }
1138
1139    return _tr_blocklistSetContent( b, contentFilename );
1140}
1141
1142tr_bool
1143tr_sessionIsAddressBlocked( const tr_session * session,
1144                            const tr_address * addr )
1145{
1146    tr_list * l;
1147
1148    assert( tr_isSession( session ) );
1149
1150    for( l = session->blocklists; l; l = l->next )
1151        if( _tr_blocklistHasAddress( l->data, addr ) )
1152            return TRUE;
1153    return FALSE;
1154}
1155
1156/***
1157****
1158***/
1159
1160static int
1161compareLookupEntries( const void * va, const void * vb )
1162{
1163    const struct tr_metainfo_lookup * a = va;
1164    const struct tr_metainfo_lookup * b = vb;
1165
1166    return strcmp( a->hashString, b->hashString );
1167}
1168
1169static void
1170metainfoLookupResort( tr_session * session )
1171{
1172    assert( tr_isSession( session ) );
1173
1174    qsort( session->metainfoLookup,
1175           session->metainfoLookupCount,
1176           sizeof( struct tr_metainfo_lookup ),
1177           compareLookupEntries );
1178}
1179
1180static int
1181compareHashStringToLookupEntry( const void * va, const void * vb )
1182{
1183    const char *                      a = va;
1184    const struct tr_metainfo_lookup * b = vb;
1185
1186    return strcmp( a, b->hashString );
1187}
1188
1189const char*
1190tr_sessionFindTorrentFile( const tr_session * session,
1191                           const char       * hashStr )
1192{
1193    struct tr_metainfo_lookup * l = bsearch( hashStr,
1194                                             session->metainfoLookup,
1195                                             session->metainfoLookupCount,
1196                                             sizeof( struct tr_metainfo_lookup ),
1197                                             compareHashStringToLookupEntry );
1198
1199    return l ? l->filename : NULL;
1200}
1201
1202static void
1203metainfoLookupRescan( tr_session * session )
1204{
1205    int          i;
1206    int          n;
1207    struct stat  sb;
1208    const char * dirname = tr_getTorrentDir( session );
1209    DIR *        odir = NULL;
1210    tr_ctor *    ctor = NULL;
1211    tr_list *    list = NULL;
1212
1213    assert( tr_isSession( session ) );
1214
1215    /* walk through the directory and find the mappings */
1216    ctor = tr_ctorNew( session );
1217    tr_ctorSetSave( ctor, FALSE ); /* since we already have them */
1218    if( !stat( dirname, &sb ) && S_ISDIR( sb.st_mode ) && ( ( odir = opendir( dirname ) ) ) )
1219    {
1220        struct dirent *d;
1221        for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
1222        {
1223            if( d->d_name && d->d_name[0] != '.' ) /* skip dotfiles, ., and ..
1224                                                     */
1225            {
1226                tr_info inf;
1227                char * path = tr_buildPath( dirname, d->d_name, NULL );
1228                tr_ctorSetMetainfoFromFile( ctor, path );
1229                if( !tr_torrentParse( session, ctor, &inf ) )
1230                {
1231                    tr_list_append( &list, tr_strdup( inf.hashString ) );
1232                    tr_list_append( &list, tr_strdup( path ) );
1233                    tr_metainfoFree( &inf );
1234                }
1235                tr_free( path );
1236            }
1237        }
1238        closedir( odir );
1239    }
1240    tr_ctorFree( ctor );
1241
1242    n = tr_list_size( list ) / 2;
1243    session->metainfoLookup = tr_new0( struct tr_metainfo_lookup, n );
1244    session->metainfoLookupCount = n;
1245    for( i = 0; i < n; ++i )
1246    {
1247        char * hashString = tr_list_pop_front( &list );
1248        char * filename = tr_list_pop_front( &list );
1249
1250        memcpy( session->metainfoLookup[i].hashString, hashString,
1251                2 * SHA_DIGEST_LENGTH + 1 );
1252        tr_free( hashString );
1253        session->metainfoLookup[i].filename = filename;
1254    }
1255
1256    metainfoLookupResort( session );
1257    tr_dbg( "Found %d torrents in \"%s\"", n, dirname );
1258}
1259
1260void
1261tr_sessionSetTorrentFile( tr_session * session,
1262                          const char * hashString,
1263                          const char * filename )
1264{
1265    struct tr_metainfo_lookup * l = bsearch( hashString,
1266                                             session->metainfoLookup,
1267                                             session->metainfoLookupCount,
1268                                             sizeof( struct tr_metainfo_lookup ),
1269                                             compareHashStringToLookupEntry );
1270
1271    if( l )
1272    {
1273        if( l->filename != filename )
1274        {
1275            tr_free( l->filename );
1276            l->filename = tr_strdup( filename );
1277        }
1278    }
1279    else
1280    {
1281        const int n = session->metainfoLookupCount++;
1282        struct tr_metainfo_lookup * node;
1283        session->metainfoLookup = tr_renew( struct tr_metainfo_lookup,
1284                                            session->metainfoLookup,
1285                                            session->metainfoLookupCount );
1286        node = session->metainfoLookup + n;
1287        memcpy( node->hashString, hashString, 2 * SHA_DIGEST_LENGTH + 1 );
1288        node->filename = tr_strdup( filename );
1289        metainfoLookupResort( session );
1290    }
1291}
1292
1293tr_torrent*
1294tr_torrentNext( tr_session * session,
1295                tr_torrent * tor )
1296{
1297    assert( tr_isSession( session ) );
1298
1299    return tor ? tor->next : session->torrentList;
1300}
1301
1302/***
1303****
1304***/
1305
1306void
1307tr_sessionSetRPCEnabled( tr_session * session,
1308                         tr_bool      isEnabled )
1309{
1310    assert( tr_isSession( session ) );
1311
1312    tr_rpcSetEnabled( session->rpcServer, isEnabled );
1313}
1314
1315tr_bool
1316tr_sessionIsRPCEnabled( const tr_session * session )
1317{
1318    assert( tr_isSession( session ) );
1319
1320    return tr_rpcIsEnabled( session->rpcServer );
1321}
1322
1323void
1324tr_sessionSetRPCPort( tr_session * session,
1325                      tr_port      port )
1326{
1327    assert( tr_isSession( session ) );
1328
1329    tr_rpcSetPort( session->rpcServer, port );
1330}
1331
1332tr_port
1333tr_sessionGetRPCPort( const tr_session * session )
1334{
1335    assert( tr_isSession( session ) );
1336
1337    return tr_rpcGetPort( session->rpcServer );
1338}
1339
1340void
1341tr_sessionSetRPCCallback( tr_session * session,
1342                          tr_rpc_func  func,
1343                          void *       user_data )
1344{
1345    assert( tr_isSession( session ) );
1346
1347    session->rpc_func = func;
1348    session->rpc_func_user_data = user_data;
1349}
1350
1351void
1352tr_sessionSetRPCWhitelist( tr_session * session,
1353                           const char * whitelist )
1354{
1355    assert( tr_isSession( session ) );
1356
1357    tr_rpcSetWhitelist( session->rpcServer, whitelist );
1358}
1359
1360char*
1361tr_sessionGetRPCWhitelist( const tr_session * session )
1362{
1363    assert( tr_isSession( session ) );
1364
1365    return tr_rpcGetWhitelist( session->rpcServer );
1366}
1367
1368void
1369tr_sessionSetRPCWhitelistEnabled( tr_session * session,
1370                                  tr_bool      isEnabled )
1371{
1372    assert( tr_isSession( session ) );
1373
1374    tr_rpcSetWhitelistEnabled( session->rpcServer, isEnabled );
1375}
1376
1377tr_bool
1378tr_sessionGetRPCWhitelistEnabled( const tr_session * session )
1379{
1380    assert( tr_isSession( session ) );
1381
1382    return tr_rpcGetWhitelistEnabled( session->rpcServer );
1383}
1384
1385
1386void
1387tr_sessionSetRPCPassword( tr_session * session,
1388                          const char * password )
1389{
1390    assert( tr_isSession( session ) );
1391
1392    tr_rpcSetPassword( session->rpcServer, password );
1393}
1394
1395char*
1396tr_sessionGetRPCPassword( const tr_session * session )
1397{
1398    assert( tr_isSession( session ) );
1399
1400    return tr_rpcGetPassword( session->rpcServer );
1401}
1402
1403void
1404tr_sessionSetRPCUsername( tr_session * session,
1405                          const char * username )
1406{
1407    assert( tr_isSession( session ) );
1408
1409    tr_rpcSetUsername( session->rpcServer, username );
1410}
1411
1412char*
1413tr_sessionGetRPCUsername( const tr_session * session )
1414{
1415    assert( tr_isSession( session ) );
1416
1417    return tr_rpcGetUsername( session->rpcServer );
1418}
1419
1420void
1421tr_sessionSetRPCPasswordEnabled( tr_session * session,
1422                                 tr_bool      isEnabled )
1423{
1424    assert( tr_isSession( session ) );
1425
1426    tr_rpcSetPasswordEnabled( session->rpcServer, isEnabled );
1427}
1428
1429tr_bool
1430tr_sessionIsRPCPasswordEnabled( const tr_session * session )
1431{
1432    assert( tr_isSession( session ) );
1433
1434    return tr_rpcIsPasswordEnabled( session->rpcServer );
1435}
1436
1437/***
1438****
1439***/
1440
1441tr_bool
1442tr_sessionIsProxyEnabled( const tr_session * session )
1443{
1444    assert( tr_isSession( session ) );
1445
1446    return session->isProxyEnabled;
1447}
1448
1449void
1450tr_sessionSetProxyEnabled( tr_session * session,
1451                           tr_bool      isEnabled )
1452{
1453    assert( tr_isSession( session ) );
1454
1455    session->isProxyEnabled = isEnabled != 0;
1456}
1457
1458tr_proxy_type
1459tr_sessionGetProxyType( const tr_session * session )
1460{
1461    assert( tr_isSession( session ) );
1462
1463    return session->proxyType;
1464}
1465
1466void
1467tr_sessionSetProxyType( tr_session *  session,
1468                        tr_proxy_type type )
1469{
1470    assert( tr_isSession( session ) );
1471
1472    session->proxyType = type;
1473}
1474
1475const char*
1476tr_sessionGetProxy( const tr_session * session )
1477{
1478    assert( tr_isSession( session ) );
1479
1480    return session->proxy;
1481}
1482
1483tr_port
1484tr_sessionGetProxyPort( const tr_session * session )
1485{
1486    assert( tr_isSession( session ) );
1487
1488    return session->proxyPort;
1489}
1490
1491void
1492tr_sessionSetProxy( tr_session * session,
1493                    const char * proxy )
1494{
1495    assert( tr_isSession( session ) );
1496
1497    if( proxy != session->proxy )
1498    {
1499        tr_free( session->proxy );
1500        session->proxy = tr_strdup( proxy );
1501    }
1502}
1503
1504void
1505tr_sessionSetProxyPort( tr_session * session,
1506                        tr_port      port )
1507{
1508    assert( tr_isSession( session ) );
1509
1510    session->proxyPort = port;
1511}
1512
1513tr_bool
1514tr_sessionIsProxyAuthEnabled( const tr_session * session )
1515{
1516    assert( tr_isSession( session ) );
1517
1518    return session->isProxyAuthEnabled;
1519}
1520
1521void
1522tr_sessionSetProxyAuthEnabled( tr_session * session,
1523                               tr_bool      isEnabled )
1524{
1525    assert( tr_isSession( session ) );
1526
1527    session->isProxyAuthEnabled = isEnabled != 0;
1528}
1529
1530const char*
1531tr_sessionGetProxyUsername( const tr_session * session )
1532{
1533    assert( tr_isSession( session ) );
1534
1535    return session->proxyUsername;
1536}
1537
1538void
1539tr_sessionSetProxyUsername( tr_session * session,
1540                            const char * username )
1541{
1542    assert( tr_isSession( session ) );
1543
1544    if( username != session->proxyUsername )
1545    {
1546        tr_free( session->proxyUsername );
1547        session->proxyUsername = tr_strdup( username );
1548    }
1549}
1550
1551const char*
1552tr_sessionGetProxyPassword( const tr_session * session )
1553{
1554    assert( tr_isSession( session ) );
1555
1556    return session->proxyPassword;
1557}
1558
1559void
1560tr_sessionSetProxyPassword( tr_session * session,
1561                            const char * password )
1562{
1563    assert( tr_isSession( session ) );
1564
1565    if( password != session->proxyPassword )
1566    {
1567        tr_free( session->proxyPassword );
1568        session->proxyPassword = tr_strdup( password );
1569    }
1570}
1571
1572int
1573tr_sessionGetActiveTorrentCount( tr_session * session )
1574{
1575    int ret = 0;
1576    tr_torrent * tor = NULL;
1577
1578    assert( tr_isSession( session ) );
1579
1580    while(( tor = tr_torrentNext( session, tor )))
1581        if( tr_torrentGetActivity( tor ) != TR_STATUS_STOPPED )
1582            ++ret;
1583
1584    return ret;
1585}
Note: See TracBrowser for help on using the repository browser.