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

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

(trunk libT) backport latest changes to 1.5x -- (1) all of libT (2) more stats in daemon (3) compiler warning in gtk

  • Property svn:keywords set to Date Rev Author Id
File size: 43.0 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 7813 2009-01-29 18:18:24Z 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
362tr_session *
363tr_sessionInit( const char  * tag,
364                const char  * configDir,
365                tr_bool       messageQueuingEnabled,
366                tr_benc     * clientSettings )
367{
368    int64_t i;
369    int64_t j;
370    tr_bool found;
371    const char * str;
372    tr_benc settings;
373    tr_session * session;
374    char * filename;
375
376    assert( tr_bencIsDict( clientSettings ) );
377
378    session = tr_new0( tr_session, 1 );
379    session->bandwidth = tr_bandwidthNew( session, NULL );
380    session->lock = tr_lockNew( );
381    session->tag = tr_strdup( tag );
382    session->magicNumber = SESSION_MAGIC_NUMBER;
383
384    dbgmsg( "tr_sessionInit: the session's top-level bandwidth object is %p", session->bandwidth );
385
386    tr_bencInitDict( &settings, 0 );
387    tr_sessionGetDefaultSettings( &settings );
388    tr_bencMergeDicts( &settings, clientSettings );
389
390#ifndef WIN32
391    /* Don't exit when writing on a broken socket */
392    signal( SIGPIPE, SIG_IGN );
393#endif
394
395    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i ); 
396    assert( found ); 
397    session->peerLimitPerTorrent = i; 
398 
399    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_MSGLEVEL, &i ); 
400    assert( found ); 
401    tr_setMessageLevel( i ); 
402    tr_setMessageQueuing( messageQueuingEnabled ); 
403 
404 
405    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEX_ENABLED, &i ); 
406    assert( found ); 
407    session->isPexEnabled = i != 0; 
408 
409    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ENCRYPTION, &i ); 
410    assert( found ); 
411    assert( tr_isEncryptionMode( i ) );
412    session->encryptionMode = i; 
413
414    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PREALLOCATION, &i );
415    assert( found );
416    assert( tr_isPreallocationMode( i ) );
417    session->preallocationMode = i;
418 
419    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_SOCKET_TOS, &i ); 
420    assert( found ); 
421    session->peerSocketTOS = i; 
422 
423    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str ); 
424    assert( found ); 
425    session->downloadDir = tr_strdup( str ); 
426 
427    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_ENABLED, &i ); 
428    assert( found ); 
429    session->isProxyEnabled = i != 0; 
430 
431    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY, &str ); 
432    assert( found ); 
433    session->proxy = tr_strdup( str ); 
434 
435    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_PORT, &i ); 
436    assert( found ); 
437    session->proxyPort = i; 
438 
439    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_TYPE, &i ); 
440    assert( found ); 
441    session->proxyType = i; 
442 
443    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_AUTH_ENABLED, &i ); 
444    assert( found ); 
445    session->isProxyAuthEnabled = i != 0; 
446 
447    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY_USERNAME, &str ); 
448    assert( found ); 
449    session->proxyUsername = tr_strdup( str ); 
450 
451    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY_PASSWORD, &str ); 
452    assert( found ); 
453    session->proxyPassword = tr_strdup( str ); 
454 
455    session->so_sndbuf = 1500 * 3; /* 3x MTU for most ethernet/wireless */ 
456    session->so_rcvbuf = 8192; 
457 
458    tr_setConfigDir( session, configDir ); 
459
460    tr_netInit( ); /* must go before tr_eventInit */
461    tr_eventInit( session );
462    assert( session->events != NULL );
463
464    session->peerMgr = tr_peerMgrNew( session );
465
466    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_LAZY_BITFIELD, &i ); 
467    assert( found ); 
468    session->useLazyBitfield = i != 0; 
469
470    /* Initialize rate and file descripts controls */
471
472    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_OPEN_FILE_LIMIT, &i ); 
473    assert( found ); 
474    session->openFileLimit = i;
475    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &j ); 
476    assert( found ); 
477    tr_fdInit( session->openFileLimit, j );
478
479    /**
480    *** random port
481    **/ 
482 
483    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, &i ); 
484    assert( found ); 
485    session->isPortRandom = i != 0; 
486 
487    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i ); 
488    assert( found ); 
489    session->randomPortLow = i; 
490 
491    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, &i ); 
492    assert( found ); 
493    session->randomPortHigh = i; 
494 
495    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, &i ) 
496         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT, &j ); 
497    assert( found ); 
498    session->peerPort = session->isPortRandom ? getRandomPort( session ) : j; 
499    session->shared = tr_sharedInit( session, i, session->peerPort ); 
500    session->isPortSet = session->isPortRandom || j>0; 
501
502    /**
503    **/ 
504
505    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, &i );
506    assert( found );
507    session->uploadSlotsPerTorrent = i;
508 
509    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED, &i )
510         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED_ENABLED, &j );
511    assert( found ); 
512    tr_sessionSetSpeedLimit( session, TR_UP, i );
513    tr_sessionSetSpeedLimitEnabled( session, TR_UP, j );
514 
515    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED, &i )
516         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED_ENABLED, &j );
517    assert( found ); 
518    tr_sessionSetSpeedLimit( session, TR_DOWN, i );
519    tr_sessionSetSpeedLimitEnabled( session, TR_DOWN, j );
520
521    /* initialize the blocklist */
522    filename = tr_buildPath( session->configDir, "blocklists", NULL );
523    tr_mkdirp( filename, 0777 );
524    tr_free( filename );
525    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i ); 
526    assert( found ); 
527    session->isBlocklistEnabled = i; 
528    loadBlocklists( session ); 
529
530    session->rpcServer = tr_rpcInit( session, &settings ); 
531
532    tr_bencFree( &settings );
533
534    session->isWaiting = TRUE;
535    tr_runInEventThread( session, tr_sessionInitImpl, session );
536    while( session->isWaiting )
537        tr_wait( 100 );
538
539    return session;
540}
541static void
542tr_sessionInitImpl( void * vsession )
543{
544    tr_session * session = vsession;
545
546    assert( tr_isSession( session ) );
547 
548    /* first %s is the application name
549       second %s is the version number */
550    tr_inf( _( "%s %s started" ), TR_NAME, LONG_VERSION_STRING );
551
552    tr_statsInit( session );
553    session->web = tr_webInit( session ); 
554    metainfoLookupRescan( session );
555    session->isWaiting = FALSE;
556}
557
558/***
559****
560***/
561
562void
563tr_sessionSetDownloadDir( tr_session * session, const char * dir )
564{
565    assert( tr_isSession( session ) );
566
567    if( session->downloadDir != dir )
568    {
569        tr_free( session->downloadDir );
570        session->downloadDir = tr_strdup( dir );
571    }
572}
573
574const char *
575tr_sessionGetDownloadDir( const tr_session * session )
576{
577    assert( tr_isSession( session ) );
578
579    return session->downloadDir;
580}
581
582/***
583****
584***/
585
586void
587tr_globalLock( tr_session * session )
588{
589    assert( tr_isSession( session ) );
590
591    tr_lockLock( session->lock );
592}
593
594void
595tr_globalUnlock( tr_session * session )
596{
597    assert( tr_isSession( session ) );
598
599    tr_lockUnlock( session->lock );
600}
601
602tr_bool
603tr_globalIsLocked( const tr_session * session )
604{
605    return tr_isSession( session ) && tr_lockHave( session->lock );
606}
607
608/***********************************************************************
609 * tr_setBindPort
610 ***********************************************************************
611 *
612 **********************************************************************/
613
614struct bind_port_data
615{
616    tr_session * session;
617    tr_port      port;
618};
619
620static void
621tr_setBindPortImpl( void * vdata )
622{
623    struct bind_port_data * data = vdata;
624    tr_session * session = data->session;
625    const tr_port port = data->port;
626
627    session->isPortSet = 1;
628    tr_sharedSetPort( session->shared, port );
629
630    tr_free( data );
631}
632
633static void
634setPortImpl( tr_session * session, tr_port port )
635{
636    struct bind_port_data * data;
637
638    assert( tr_isSession( session ) );
639
640    data = tr_new( struct bind_port_data, 1 );
641    data->session = session;
642    data->port = port;
643    tr_runInEventThread( session, tr_setBindPortImpl, data );
644}
645
646void
647tr_sessionSetPeerPort( tr_session * session,
648                       tr_port      port )
649{
650    assert( tr_isSession( session ) );
651
652    session->isPortRandom = FALSE;
653    session->peerPort = port;
654    setPortImpl( session, session->peerPort );
655}
656
657tr_port
658tr_sessionSetPeerPortRandom( tr_session * session )
659{
660    assert( tr_isSession( session ) );
661
662    session->isPortRandom = TRUE;
663    session->peerPort = getRandomPort( session );
664    setPortImpl( session, session->peerPort );
665    return session->peerPort;
666}
667
668tr_port
669tr_sessionGetPeerPort( const tr_session * session )
670{
671    assert( tr_isSession( session ) );
672
673    return session->peerPort;
674}
675
676tr_port_forwarding
677tr_sessionGetPortForwarding( const tr_session * session )
678{
679    assert( tr_isSession( session ) );
680
681    return tr_sharedTraversalStatus( session->shared );
682}
683
684/***
685****
686***/
687
688static void
689updateBandwidth( tr_session * session, tr_direction dir )
690{
691    tr_bool zeroCase;
692
693    assert( tr_isSession( session ) );
694
695    zeroCase = session->speedLimit[dir] < 1 && session->isSpeedLimited[dir];
696
697    tr_bandwidthSetLimited( session->bandwidth, dir, session->isSpeedLimited[dir] && !zeroCase );
698
699    tr_bandwidthSetDesiredSpeed( session->bandwidth, dir, session->speedLimit[dir] );
700}
701
702void
703tr_sessionSetSpeedLimitEnabled( tr_session      * session,
704                                tr_direction      dir,
705                                tr_bool           isLimited )
706{
707    assert( tr_isSession( session ) );
708    assert( tr_isDirection( dir ) );
709
710    session->isSpeedLimited[dir] = isLimited;
711    updateBandwidth( session, dir );
712}
713
714void
715tr_sessionSetSpeedLimit( tr_session    * session,
716                         tr_direction    dir,
717                         int             desiredSpeed )
718{
719    assert( tr_isSession( session ) );
720    assert( tr_isDirection( dir ) );
721
722    session->speedLimit[dir] = desiredSpeed;
723    updateBandwidth( session, dir );
724}
725
726tr_bool
727tr_sessionIsSpeedLimitEnabled( const tr_session  * session,
728                               tr_direction        dir )
729{
730    assert( tr_isSession( session ) );
731    assert( tr_isDirection( dir ) );
732
733    return session->isSpeedLimited[dir];
734}
735
736int
737tr_sessionGetSpeedLimit( const tr_session  * session,
738                         tr_direction        dir )
739{
740    assert( tr_isSession( session ) );
741    assert( tr_isDirection( dir ) );
742
743    return session->speedLimit[dir];
744}
745
746/***
747****
748***/
749
750void
751tr_sessionSetPeerLimit( tr_session * session,
752                        uint16_t     maxGlobalPeers )
753{
754    assert( tr_isSession( session ) );
755
756    tr_fdSetPeerLimit( maxGlobalPeers );
757}
758
759uint16_t
760tr_sessionGetPeerLimit( const tr_session * session )
761{
762    assert( tr_isSession( session ) );
763
764    return tr_fdGetPeerLimit( );
765}
766
767void
768tr_sessionSetPeerLimitPerTorrent( tr_session  * session, uint16_t n )
769{
770    assert( tr_isSession( session ) );
771
772    session->peerLimitPerTorrent = n;
773}
774
775uint16_t
776tr_sessionGetPeerLimitPerTorrent( const tr_session * session )
777{
778    assert( tr_isSession( session ) );
779
780    return session->peerLimitPerTorrent;
781}
782
783/***
784****
785***/
786
787double
788tr_sessionGetPieceSpeed( const tr_session * session, tr_direction dir )
789{
790    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
791}
792
793double
794tr_sessionGetRawSpeed( const tr_session * session, tr_direction dir )
795{
796    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
797}
798
799int
800tr_sessionCountTorrents( const tr_session * session )
801{
802    return tr_isSession( session ) ? session->torrentCount : 0;
803}
804
805static int
806compareTorrentByCur( const void * va, const void * vb )
807{
808    const tr_torrent * a = *(const tr_torrent**)va;
809    const tr_torrent * b = *(const tr_torrent**)vb;
810    const uint64_t     aCur = a->downloadedCur + a->uploadedCur;
811    const uint64_t     bCur = b->downloadedCur + b->uploadedCur;
812
813    if( aCur != bCur )
814        return aCur > bCur ? -1 : 1; /* close the biggest torrents first */
815
816    return 0;
817}
818
819static void
820tr_closeAllConnections( void * vsession )
821{
822    tr_session *  session = vsession;
823    tr_torrent *  tor;
824    int           i, n;
825    tr_torrent ** torrents;
826
827    assert( tr_isSession( session ) );
828
829    tr_statsClose( session );
830    tr_sharedShuttingDown( session->shared );
831    tr_rpcClose( &session->rpcServer );
832
833    /* close the torrents.  get the most active ones first so that
834     * if we can't get them all closed in a reasonable amount of time,
835     * at least we get the most important ones first. */
836    tor = NULL;
837    n = session->torrentCount;
838    torrents = tr_new( tr_torrent *, session->torrentCount );
839    for( i = 0; i < n; ++i )
840        torrents[i] = tor = tr_torrentNext( session, tor );
841    qsort( torrents, n, sizeof( tr_torrent* ), compareTorrentByCur );
842    for( i = 0; i < n; ++i )
843        tr_torrentFree( torrents[i] );
844    tr_free( torrents );
845
846    tr_peerMgrFree( session->peerMgr );
847
848    tr_trackerSessionClose( session );
849    tr_list_free( &session->blocklists,
850                  (TrListForeachFunc)_tr_blocklistFree );
851    tr_webClose( &session->web );
852
853    session->isClosed = TRUE;
854}
855
856static int
857deadlineReached( const uint64_t deadline )
858{
859    return tr_date( ) >= deadline;
860}
861
862#define SHUTDOWN_MAX_SECONDS 30
863
864void
865tr_sessionClose( tr_session * session )
866{
867    int            i;
868    const int      maxwait_msec = SHUTDOWN_MAX_SECONDS * 1000;
869    const uint64_t deadline = tr_date( ) + maxwait_msec;
870
871    assert( tr_isSession( session ) );
872
873    dbgmsg( "shutting down transmission session %p", session );
874
875    /* close the session */
876    tr_runInEventThread( session, tr_closeAllConnections, session );
877    while( !session->isClosed && !deadlineReached( deadline ) )
878    {
879        dbgmsg(
880            "waiting for the shutdown commands to run in the main thread" );
881        tr_wait( 100 );
882    }
883
884    /* "shared" and "tracker" have live sockets,
885     * so we need to keep the transmission thread alive
886     * for a bit while they tell the router & tracker
887     * that we're closing now */
888    while( ( session->shared
889           || session->tracker ) && !deadlineReached( deadline ) )
890    {
891        dbgmsg( "waiting on port unmap (%p) or tracker (%p)",
892                session->shared, session->tracker );
893        tr_wait( 100 );
894    }
895
896    tr_fdClose( );
897
898    /* close the libtransmission thread */
899    tr_eventClose( session );
900    while( session->events && !deadlineReached( deadline ) )
901    {
902        dbgmsg( "waiting for the libevent thread to shutdown cleanly" );
903        tr_wait( 100 );
904    }
905
906    /* free the session memory */
907    tr_bandwidthFree( session->bandwidth );
908    tr_lockFree( session->lock );
909    for( i = 0; i < session->metainfoLookupCount; ++i )
910        tr_free( session->metainfoLookup[i].filename );
911    tr_free( session->metainfoLookup );
912    tr_free( session->tag );
913    tr_free( session->configDir );
914    tr_free( session->resumeDir );
915    tr_free( session->torrentDir );
916    tr_free( session->downloadDir );
917    tr_free( session->proxy );
918    tr_free( session->proxyUsername );
919    tr_free( session->proxyPassword );
920    tr_free( session );
921}
922
923tr_torrent **
924tr_sessionLoadTorrents( tr_session * session,
925                        tr_ctor    * ctor,
926                        int        * setmeCount )
927{
928    int           i, n = 0;
929    struct stat   sb;
930    DIR *         odir = NULL;
931    const char *  dirname = tr_getTorrentDir( session );
932    tr_torrent ** torrents;
933    tr_list *     l = NULL, *list = NULL;
934
935    assert( tr_isSession( session ) );
936
937    tr_ctorSetSave( ctor, FALSE ); /* since we already have them */
938
939    if( !stat( dirname, &sb )
940      && S_ISDIR( sb.st_mode )
941      && ( ( odir = opendir ( dirname ) ) ) )
942    {
943        struct dirent *d;
944        for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
945        {
946            if( d->d_name && d->d_name[0] != '.' ) /* skip dotfiles, ., and ..
947                                                     */
948            {
949                tr_torrent * tor;
950                char * path = tr_buildPath( dirname, d->d_name, NULL );
951                tr_ctorSetMetainfoFromFile( ctor, path );
952                if(( tor = tr_torrentNew( session, ctor, NULL )))
953                {
954                    tr_list_append( &list, tor );
955                    ++n;
956                }
957                tr_free( path );
958            }
959        }
960        closedir( odir );
961    }
962
963    torrents = tr_new( tr_torrent *, n );
964    for( i = 0, l = list; l != NULL; l = l->next )
965        torrents[i++] = (tr_torrent*) l->data;
966    assert( i == n );
967
968    tr_list_free( &list, NULL );
969
970    if( n )
971        tr_inf( _( "Loaded %d torrents" ), n );
972
973    if( setmeCount )
974        *setmeCount = n;
975    return torrents;
976}
977
978/***
979****
980***/
981
982void
983tr_sessionSetPexEnabled( tr_session * session,
984                         tr_bool      enabled )
985{
986    assert( tr_isSession( session ) );
987
988    session->isPexEnabled = enabled != 0;
989}
990
991tr_bool
992tr_sessionIsPexEnabled( const tr_session * session )
993{
994    assert( tr_isSession( session ) );
995
996    return session->isPexEnabled;
997}
998
999/***
1000****
1001***/
1002
1003void
1004tr_sessionSetLazyBitfieldEnabled( tr_session * session,
1005                                  tr_bool      enabled )
1006{
1007    assert( tr_isSession( session ) );
1008
1009    session->useLazyBitfield = enabled != 0;
1010}
1011
1012tr_bool
1013tr_sessionIsLazyBitfieldEnabled( const tr_session * session )
1014{
1015    assert( tr_isSession( session ) );
1016
1017    return session->useLazyBitfield;
1018}
1019
1020/***
1021****
1022***/
1023
1024void
1025tr_sessionSetPortForwardingEnabled( tr_session  * session,
1026                                    tr_bool       enabled )
1027{
1028    assert( tr_isSession( session ) );
1029
1030    tr_globalLock( session );
1031    tr_sharedTraversalEnable( session->shared, enabled );
1032    tr_globalUnlock( session );
1033}
1034
1035tr_bool
1036tr_sessionIsPortForwardingEnabled( const tr_session * session )
1037{
1038    assert( tr_isSession( session ) );
1039
1040    return tr_sharedTraversalIsEnabled( session->shared );
1041}
1042
1043/***
1044****
1045***/
1046
1047int
1048tr_blocklistGetRuleCount( const tr_session * session )
1049{
1050    int       n = 0;
1051    tr_list * l;
1052
1053    assert( tr_isSession( session ) );
1054
1055    for( l = session->blocklists; l; l = l->next )
1056        n += _tr_blocklistGetRuleCount( l->data );
1057    return n;
1058}
1059
1060tr_bool
1061tr_blocklistIsEnabled( const tr_session * session )
1062{
1063    assert( tr_isSession( session ) );
1064
1065    return session->isBlocklistEnabled;
1066}
1067
1068void
1069tr_blocklistSetEnabled( tr_session * session,
1070                        tr_bool      isEnabled )
1071{
1072    tr_list * l;
1073
1074    assert( tr_isSession( session ) );
1075
1076    session->isBlocklistEnabled = isEnabled != 0;
1077
1078    for( l=session->blocklists; l!=NULL; l=l->next )
1079        _tr_blocklistSetEnabled( l->data, isEnabled );
1080}
1081
1082tr_bool
1083tr_blocklistExists( const tr_session * session )
1084{
1085    assert( tr_isSession( session ) );
1086
1087    return session->blocklists != NULL;
1088}
1089
1090int
1091tr_blocklistSetContent( tr_session * session,
1092                        const char * contentFilename )
1093{
1094    tr_list *      l;
1095    tr_blocklist * b;
1096    const char *   defaultName = "level1.bin";
1097
1098    assert( tr_isSession( session ) );
1099
1100    for( b = NULL, l = session->blocklists; !b && l; l = l->next )
1101        if( tr_stringEndsWith( _tr_blocklistGetFilename( l->data ),
1102                               defaultName ) )
1103            b = l->data;
1104
1105    if( !b )
1106    {
1107        char * path = tr_buildPath( session->configDir, "blocklists", defaultName, NULL );
1108        b = _tr_blocklistNew( path, session->isBlocklistEnabled );
1109        tr_list_append( &session->blocklists, b );
1110        tr_free( path );
1111    }
1112
1113    return _tr_blocklistSetContent( b, contentFilename );
1114}
1115
1116tr_bool
1117tr_sessionIsAddressBlocked( const tr_session * session,
1118                            const tr_address * addr )
1119{
1120    tr_list * l;
1121
1122    assert( tr_isSession( session ) );
1123
1124    for( l = session->blocklists; l; l = l->next )
1125        if( _tr_blocklistHasAddress( l->data, addr ) )
1126            return TRUE;
1127    return FALSE;
1128}
1129
1130/***
1131****
1132***/
1133
1134static int
1135compareLookupEntries( const void * va, const void * vb )
1136{
1137    const struct tr_metainfo_lookup * a = va;
1138    const struct tr_metainfo_lookup * b = vb;
1139
1140    return strcmp( a->hashString, b->hashString );
1141}
1142
1143static void
1144metainfoLookupResort( tr_session * session )
1145{
1146    assert( tr_isSession( session ) );
1147
1148    qsort( session->metainfoLookup,
1149           session->metainfoLookupCount,
1150           sizeof( struct tr_metainfo_lookup ),
1151           compareLookupEntries );
1152}
1153
1154static int
1155compareHashStringToLookupEntry( const void * va, const void * vb )
1156{
1157    const char *                      a = va;
1158    const struct tr_metainfo_lookup * b = vb;
1159
1160    return strcmp( a, b->hashString );
1161}
1162
1163const char*
1164tr_sessionFindTorrentFile( const tr_session * session,
1165                           const char       * hashStr )
1166{
1167    struct tr_metainfo_lookup * l = bsearch( hashStr,
1168                                             session->metainfoLookup,
1169                                             session->metainfoLookupCount,
1170                                             sizeof( struct tr_metainfo_lookup ),
1171                                             compareHashStringToLookupEntry );
1172
1173    return l ? l->filename : NULL;
1174}
1175
1176static void
1177metainfoLookupRescan( tr_session * session )
1178{
1179    int          i;
1180    int          n;
1181    struct stat  sb;
1182    const char * dirname = tr_getTorrentDir( session );
1183    DIR *        odir = NULL;
1184    tr_ctor *    ctor = NULL;
1185    tr_list *    list = NULL;
1186
1187    assert( tr_isSession( session ) );
1188
1189    /* walk through the directory and find the mappings */
1190    ctor = tr_ctorNew( session );
1191    tr_ctorSetSave( ctor, FALSE ); /* since we already have them */
1192    if( !stat( dirname, &sb ) && S_ISDIR( sb.st_mode ) && ( ( odir = opendir( dirname ) ) ) )
1193    {
1194        struct dirent *d;
1195        for( d = readdir( odir ); d != NULL; d = readdir( odir ) )
1196        {
1197            if( d->d_name && d->d_name[0] != '.' ) /* skip dotfiles, ., and ..
1198                                                     */
1199            {
1200                tr_info inf;
1201                char * path = tr_buildPath( dirname, d->d_name, NULL );
1202                tr_ctorSetMetainfoFromFile( ctor, path );
1203                if( !tr_torrentParse( session, ctor, &inf ) )
1204                {
1205                    tr_list_append( &list, tr_strdup( inf.hashString ) );
1206                    tr_list_append( &list, tr_strdup( path ) );
1207                    tr_metainfoFree( &inf );
1208                }
1209                tr_free( path );
1210            }
1211        }
1212        closedir( odir );
1213    }
1214    tr_ctorFree( ctor );
1215
1216    n = tr_list_size( list ) / 2;
1217    session->metainfoLookup = tr_new0( struct tr_metainfo_lookup, n );
1218    session->metainfoLookupCount = n;
1219    for( i = 0; i < n; ++i )
1220    {
1221        char * hashString = tr_list_pop_front( &list );
1222        char * filename = tr_list_pop_front( &list );
1223
1224        memcpy( session->metainfoLookup[i].hashString, hashString,
1225                2 * SHA_DIGEST_LENGTH + 1 );
1226        tr_free( hashString );
1227        session->metainfoLookup[i].filename = filename;
1228    }
1229
1230    metainfoLookupResort( session );
1231    tr_dbg( "Found %d torrents in \"%s\"", n, dirname );
1232}
1233
1234void
1235tr_sessionSetTorrentFile( tr_session * session,
1236                          const char * hashString,
1237                          const char * filename )
1238{
1239    struct tr_metainfo_lookup * l = bsearch( hashString,
1240                                             session->metainfoLookup,
1241                                             session->metainfoLookupCount,
1242                                             sizeof( struct tr_metainfo_lookup ),
1243                                             compareHashStringToLookupEntry );
1244
1245    if( l )
1246    {
1247        if( l->filename != filename )
1248        {
1249            tr_free( l->filename );
1250            l->filename = tr_strdup( filename );
1251        }
1252    }
1253    else
1254    {
1255        const int n = session->metainfoLookupCount++;
1256        struct tr_metainfo_lookup * node;
1257        session->metainfoLookup = tr_renew( struct tr_metainfo_lookup,
1258                                            session->metainfoLookup,
1259                                            session->metainfoLookupCount );
1260        node = session->metainfoLookup + n;
1261        memcpy( node->hashString, hashString, 2 * SHA_DIGEST_LENGTH + 1 );
1262        node->filename = tr_strdup( filename );
1263        metainfoLookupResort( session );
1264    }
1265}
1266
1267tr_torrent*
1268tr_torrentNext( tr_session * session,
1269                tr_torrent * tor )
1270{
1271    assert( tr_isSession( session ) );
1272
1273    return tor ? tor->next : session->torrentList;
1274}
1275
1276/***
1277****
1278***/
1279
1280void
1281tr_sessionSetRPCEnabled( tr_session * session,
1282                         tr_bool      isEnabled )
1283{
1284    assert( tr_isSession( session ) );
1285
1286    tr_rpcSetEnabled( session->rpcServer, isEnabled );
1287}
1288
1289tr_bool
1290tr_sessionIsRPCEnabled( const tr_session * session )
1291{
1292    assert( tr_isSession( session ) );
1293
1294    return tr_rpcIsEnabled( session->rpcServer );
1295}
1296
1297void
1298tr_sessionSetRPCPort( tr_session * session,
1299                      tr_port      port )
1300{
1301    assert( tr_isSession( session ) );
1302
1303    tr_rpcSetPort( session->rpcServer, port );
1304}
1305
1306tr_port
1307tr_sessionGetRPCPort( const tr_session * session )
1308{
1309    assert( tr_isSession( session ) );
1310
1311    return tr_rpcGetPort( session->rpcServer );
1312}
1313
1314void
1315tr_sessionSetRPCCallback( tr_session * session,
1316                          tr_rpc_func  func,
1317                          void *       user_data )
1318{
1319    assert( tr_isSession( session ) );
1320
1321    session->rpc_func = func;
1322    session->rpc_func_user_data = user_data;
1323}
1324
1325void
1326tr_sessionSetRPCWhitelist( tr_session * session,
1327                           const char * whitelist )
1328{
1329    assert( tr_isSession( session ) );
1330
1331    tr_rpcSetWhitelist( session->rpcServer, whitelist );
1332}
1333
1334char*
1335tr_sessionGetRPCWhitelist( const tr_session * session )
1336{
1337    assert( tr_isSession( session ) );
1338
1339    return tr_rpcGetWhitelist( session->rpcServer );
1340}
1341
1342void
1343tr_sessionSetRPCWhitelistEnabled( tr_session * session,
1344                                  tr_bool      isEnabled )
1345{
1346    assert( tr_isSession( session ) );
1347
1348    tr_rpcSetWhitelistEnabled( session->rpcServer, isEnabled );
1349}
1350
1351tr_bool
1352tr_sessionGetRPCWhitelistEnabled( const tr_session * session )
1353{
1354    assert( tr_isSession( session ) );
1355
1356    return tr_rpcGetWhitelistEnabled( session->rpcServer );
1357}
1358
1359
1360void
1361tr_sessionSetRPCPassword( tr_session * session,
1362                          const char * password )
1363{
1364    assert( tr_isSession( session ) );
1365
1366    tr_rpcSetPassword( session->rpcServer, password );
1367}
1368
1369char*
1370tr_sessionGetRPCPassword( const tr_session * session )
1371{
1372    assert( tr_isSession( session ) );
1373
1374    return tr_rpcGetPassword( session->rpcServer );
1375}
1376
1377void
1378tr_sessionSetRPCUsername( tr_session * session,
1379                          const char * username )
1380{
1381    assert( tr_isSession( session ) );
1382
1383    tr_rpcSetUsername( session->rpcServer, username );
1384}
1385
1386char*
1387tr_sessionGetRPCUsername( const tr_session * session )
1388{
1389    assert( tr_isSession( session ) );
1390
1391    return tr_rpcGetUsername( session->rpcServer );
1392}
1393
1394void
1395tr_sessionSetRPCPasswordEnabled( tr_session * session,
1396                                 tr_bool      isEnabled )
1397{
1398    assert( tr_isSession( session ) );
1399
1400    tr_rpcSetPasswordEnabled( session->rpcServer, isEnabled );
1401}
1402
1403tr_bool
1404tr_sessionIsRPCPasswordEnabled( const tr_session * session )
1405{
1406    assert( tr_isSession( session ) );
1407
1408    return tr_rpcIsPasswordEnabled( session->rpcServer );
1409}
1410
1411/***
1412****
1413***/
1414
1415tr_bool
1416tr_sessionIsProxyEnabled( const tr_session * session )
1417{
1418    assert( tr_isSession( session ) );
1419
1420    return session->isProxyEnabled;
1421}
1422
1423void
1424tr_sessionSetProxyEnabled( tr_session * session,
1425                           tr_bool      isEnabled )
1426{
1427    assert( tr_isSession( session ) );
1428
1429    session->isProxyEnabled = isEnabled != 0;
1430}
1431
1432tr_proxy_type
1433tr_sessionGetProxyType( const tr_session * session )
1434{
1435    assert( tr_isSession( session ) );
1436
1437    return session->proxyType;
1438}
1439
1440void
1441tr_sessionSetProxyType( tr_session *  session,
1442                        tr_proxy_type type )
1443{
1444    assert( tr_isSession( session ) );
1445
1446    session->proxyType = type;
1447}
1448
1449const char*
1450tr_sessionGetProxy( const tr_session * session )
1451{
1452    assert( tr_isSession( session ) );
1453
1454    return session->proxy;
1455}
1456
1457tr_port
1458tr_sessionGetProxyPort( const tr_session * session )
1459{
1460    assert( tr_isSession( session ) );
1461
1462    return session->proxyPort;
1463}
1464
1465void
1466tr_sessionSetProxy( tr_session * session,
1467                    const char * proxy )
1468{
1469    assert( tr_isSession( session ) );
1470
1471    if( proxy != session->proxy )
1472    {
1473        tr_free( session->proxy );
1474        session->proxy = tr_strdup( proxy );
1475    }
1476}
1477
1478void
1479tr_sessionSetProxyPort( tr_session * session,
1480                        tr_port      port )
1481{
1482    assert( tr_isSession( session ) );
1483
1484    session->proxyPort = port;
1485}
1486
1487tr_bool
1488tr_sessionIsProxyAuthEnabled( const tr_session * session )
1489{
1490    assert( tr_isSession( session ) );
1491
1492    return session->isProxyAuthEnabled;
1493}
1494
1495void
1496tr_sessionSetProxyAuthEnabled( tr_session * session,
1497                               tr_bool      isEnabled )
1498{
1499    assert( tr_isSession( session ) );
1500
1501    session->isProxyAuthEnabled = isEnabled != 0;
1502}
1503
1504const char*
1505tr_sessionGetProxyUsername( const tr_session * session )
1506{
1507    assert( tr_isSession( session ) );
1508
1509    return session->proxyUsername;
1510}
1511
1512void
1513tr_sessionSetProxyUsername( tr_session * session,
1514                            const char * username )
1515{
1516    assert( tr_isSession( session ) );
1517
1518    if( username != session->proxyUsername )
1519    {
1520        tr_free( session->proxyUsername );
1521        session->proxyUsername = tr_strdup( username );
1522    }
1523}
1524
1525const char*
1526tr_sessionGetProxyPassword( const tr_session * session )
1527{
1528    assert( tr_isSession( session ) );
1529
1530    return session->proxyPassword;
1531}
1532
1533void
1534tr_sessionSetProxyPassword( tr_session * session,
1535                            const char * password )
1536{
1537    assert( tr_isSession( session ) );
1538
1539    if( password != session->proxyPassword )
1540    {
1541        tr_free( session->proxyPassword );
1542        session->proxyPassword = tr_strdup( password );
1543    }
1544}
1545
1546int
1547tr_sessionGetActiveTorrentCount( tr_session * session )
1548{
1549    int ret = 0;
1550    tr_torrent * tor = NULL;
1551
1552    assert( tr_isSession( session ) );
1553
1554    while(( tor = tr_torrentNext( session, tor )))
1555        if( tr_torrentGetActivity( tor ) != TR_STATUS_STOPPED )
1556            ++ret;
1557   
1558    return ret;
1559}
Note: See TracBrowser for help on using the repository browser.