source: trunk/libtransmission/session.c @ 7368

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

(trunk libT) semantic cleanup: int -> tr_bool

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