source: trunk/libtransmission/session.c @ 8072

Last change on this file since 8072 was 8072, checked in by livings124, 13 years ago

#1276 encrypt the password to access web client interface using SHA-2

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