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

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

(1.5x) sync with trunk's libtransmission bugfixes & enhancements

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