source: trunk/libtransmission/session.c @ 7711

Last change on this file since 7711 was 7711, checked in by charles, 12 years ago

(trunk libT) fix an r7707 bug in tr_sessionGetActiveTorrentCount()

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