mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

(trunk) use tr_bencDict{Find,Add}Bool() where appropriate

This commit is contained in:
Charles Kerr 2009-03-29 23:05:32 +00:00
parent c71462e279
commit f4557fab8e
11 changed files with 336 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
cli/cli.c
View File

@ -491,16 +491,16 @@ parseCommandLine( tr_benc * d, int argc, const char ** argv )
case 'a':
announce = optarg; break;
case 'b': tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, 1 );
case 'b': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, TRUE );
break;
case 'B': tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, 0 );
case 'B': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
break;
case 'c': comment = optarg;
break;
case 'd': tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED, atoi( optarg ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, 1 );
case 'd': tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED, atoi( optarg ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, TRUE );
break;
case 'D': tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, 0 );
case 'D': tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, FALSE );
break;
case 'f': finishCall = optarg;
break;
@ -508,9 +508,9 @@ parseCommandLine( tr_benc * d, int argc, const char ** argv )
break;
case 'i': showInfo = 1;
break;
case 'm': tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, 1 );
case 'm': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
break;
case 'M': tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, 0 );
case 'M': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, FALSE );
break;
case 'n': sourceFile = optarg; break;
case 'p': tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, atoi( optarg ) );
@ -522,9 +522,9 @@ parseCommandLine( tr_benc * d, int argc, const char ** argv )
case 't': tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi( optarg ) );
break;
case 'u': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, atoi( optarg ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 1 );
tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, TRUE );
break;
case 'U': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 0 );
case 'U': tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, FALSE );
break;
case 'v': verify = 1;
break;

29
daemon/daemon.c
View File

@ -201,9 +201,9 @@ int
main( int argc, char ** argv )
{
int c;
int64_t i;
const char * optarg;
tr_benc settings;
tr_bool boolVal;
tr_bool foreground = FALSE;
tr_bool dumpSettings = FALSE;
const char * configDir = NULL;
@ -221,23 +221,23 @@ main( int argc, char ** argv )
tr_bencInitDict( &settings, 0 );
configDir = getConfigDir( argc, (const char**)argv );
tr_sessionLoadSettings( &settings, configDir, MY_NAME );
tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_ENABLED, 1 );
tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, TRUE );
/* overwrite settings from the comamndline */
tr_optind = 1;
while(( c = tr_getopt( getUsage(), argc, (const char**)argv, options, &optarg ))) {
switch( c ) {
case 'a': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_WHITELIST, optarg );
tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, 1 );
tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, TRUE );
break;
case 'b': tr_bencDictAddInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, 1 );
case 'b': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, TRUE );
break;
case 'B': tr_bencDictAddInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, 0 );
case 'B': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
break;
case 'c': tr_bencDictAddStr( &settings, PREF_KEY_DIR_WATCH, optarg );
tr_bencDictAddInt( &settings, PREF_KEY_DIR_WATCH_ENABLED, 1 );
tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, TRUE );
break;
case 'C': tr_bencDictAddInt( &settings, PREF_KEY_DIR_WATCH_ENABLED, 0 );
case 'C': tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
break;
case 'd': dumpSettings = TRUE;
break;
@ -250,9 +250,9 @@ main( int argc, char ** argv )
exit( 0 );
case 'p': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_PORT, atoi( optarg ) );
break;
case 't': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, 1 );
case 't': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, TRUE );
break;
case 'T': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, 0 );
case 'T': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, FALSE );
break;
case 'u': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_USERNAME, optarg );
break;
@ -262,9 +262,9 @@ main( int argc, char ** argv )
break;
case 'P': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_PORT, atoi( optarg ) );
break;
case 'm': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, 1 );
case 'm': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
break;
case 'M': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, 0 );
case 'M': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, FALSE );
break;
case 'L': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi( optarg ) );
break;
@ -301,16 +301,15 @@ main( int argc, char ** argv )
/* start the session */
mySession = tr_sessionInit( "daemon", configDir, FALSE, &settings );
if( tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &i ) && i!=0 )
if( tr_bencDictFindBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal ) && boolVal )
tr_ninf( MY_NAME, "requiring authentication" );
/* maybe add a watchdir */
{
int64_t doWatch;
const char * dir;
if( tr_bencDictFindInt( &settings, PREF_KEY_DIR_WATCH_ENABLED, &doWatch )
&& doWatch
if( tr_bencDictFindBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal )
&& boolVal
&& tr_bencDictFindStr( &settings, PREF_KEY_DIR_WATCH, &dir )
&& dir
&& *dir )

59
daemon/remote.c
View File

@ -345,12 +345,12 @@ readargs( int argc,
case 'd':
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, "speed-limit-down", numarg( optarg ) );
tr_bencDictAddInt( args, "speed-limit-down-enabled", 1 );
tr_bencDictAddBool( args, "speed-limit-down-enabled", TRUE );
break;
case 'D':
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, "speed-limit-down-enabled", 0 );
tr_bencDictAddBool( args, "speed-limit-down-enabled", FALSE );
break;
case 'f':
@ -396,12 +396,12 @@ readargs( int argc,
case 'm':
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, "port-forwarding-enabled", 1 );
tr_bencDictAddBool( args, "port-forwarding-enabled", TRUE );
break;
case 'M':
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, "port-forwarding-enabled", 0 );
tr_bencDictAddBool( args, "port-forwarding-enabled", FALSE );
break;
case 'n':
@ -427,7 +427,7 @@ readargs( int argc,
case 'R':
tr_bencDictAddStr( &top, "method", "torrent-remove" );
addIdArg( args, id );
tr_bencDictAddInt( args, "delete-local-data", 1 );
tr_bencDictAddBool( args, "delete-local-data", TRUE );
break;
case 's':
@ -448,12 +448,12 @@ readargs( int argc,
case 'u':
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, "speed-limit-up", numarg( optarg ) );
tr_bencDictAddInt( args, "speed-limit-up-enabled", 1 );
tr_bencDictAddBool( args, "speed-limit-up-enabled", TRUE );
break;
case 'U':
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, "speed-limit-up-enabled", 0 );
tr_bencDictAddBool( args, "speed-limit-up-enabled", FALSE );
break;
case 'v':
@ -476,12 +476,12 @@ readargs( int argc,
case 'x':
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, TR_PREFS_KEY_PEX_ENABLED, 1 );
tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, TRUE );
break;
case 'X':
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, TR_PREFS_KEY_PEX_ENABLED, 0 );
tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, FALSE );
break;
case 900:
@ -543,7 +543,7 @@ readargs( int argc,
case 950:
tr_bencDictAddStr( &top, "method", "torrent-set" );
tr_bencDictAddDouble( args, "ratio-limit", atof(optarg) );
tr_bencDictAddReal( args, "ratio-limit", atof(optarg) );
tr_bencDictAddInt( args, "ratio-limit-mode", TR_RATIOLIMIT_SINGLE );
addIdArg( args, id );
break;
@ -562,13 +562,13 @@ readargs( int argc,
case 953:
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddDouble( args, "ratio-limit", atof(optarg) );
tr_bencDictAddInt( args, "ratio-limit-enabled", 1 );
tr_bencDictAddReal( args, "ratio-limit", atof(optarg) );
tr_bencDictAddBool( args, "ratio-limit-enabled", TRUE );
break;
case 954:
tr_bencDictAddStr( &top, "method", "session-set" );
tr_bencDictAddInt( args, "ratio-limit-enabled", 0 );
tr_bencDictAddBool( args, "ratio-limit-enabled", FALSE );
break;
case TR_OPT_ERR:
@ -595,10 +595,7 @@ readargs( int argc,
/* [host:port] or [host] or [port] */
static void
getHostAndPort( int * argc,
char ** argv,
char ** host,
int * port )
getHostAndPort( int * argc, char ** argv, char ** host, int * port )
{
if( *argv[1] != '-' )
{
@ -732,7 +729,7 @@ getStatusString( tr_benc * t, char * buf, size_t buflen )
? "Will Verify"
: "Verifying";
double percent;
if( tr_bencDictFindDouble( t, "recheckProgress", &percent ) )
if( tr_bencDictFindReal( t, "recheckProgress", &percent ) )
tr_snprintf( buf, buflen, "%s (%.0f%%)", str, percent*100.0 );
else
tr_strlcpy( buf, str, buflen );
@ -787,6 +784,7 @@ printSession( tr_benc * top )
{
const char * str;
int64_t i;
tr_bool boolVal;
printf( "VERSION\n" );
if( tr_bencDictFindStr( args, "version", &str ) )
@ -802,10 +800,10 @@ printSession( tr_benc * top )
printf( " Download directory: %s\n", str );
if( tr_bencDictFindInt( args, "port", &i ) )
printf( " Listenport: %" PRId64 "\n", i );
if( tr_bencDictFindInt( args, "port-forwarding-enabled", &i ) )
printf( " Portforwarding enabled: %s\n", ( i ? "Yes" : "No" ) );
if( tr_bencDictFindInt( args, "pex-allowed", &i ) )
printf( " Peer exchange allowed: %s\n", ( i ? "Yes" : "No" ) );
if( tr_bencDictFindBool( args, "port-forwarding-enabled", &boolVal ) )
printf( " Portforwarding enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
if( tr_bencDictFindBool( args, "pex-allowed", &boolVal ) )
printf( " Peer exchange allowed: %s\n", ( boolVal ? "Yes" : "No" ) );
if( tr_bencDictFindStr( args, "encryption", &str ) )
printf( " Encryption: %s\n", str );
printf( "\n" );
@ -813,12 +811,12 @@ printSession( tr_benc * top )
printf( "LIMITS\n" );
if( tr_bencDictFindInt( args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i ) )
printf( " Peer limit: %" PRId64 "\n", i );
if( tr_bencDictFindInt( args, "speed-limit-down-enabled", &i ) )
printf( " Downloadlimit enabled: %s\n", ( i ? "Yes" : "No" ) );
if( tr_bencDictFindBool( args, "speed-limit-down-enabled", &boolVal ) )
printf( " Downloadlimit enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
if( tr_bencDictFindInt( args, "speed-limit-down", &i ) )
printf( " Downloadlimit: %6" PRId64 " KB/sec\n", i );
if( tr_bencDictFindInt( args, "speed-limit-up-enabled", &i ) )
printf( " Uploadlimit enabled: %s\n", ( i ? "Yes" : "No" ) );
if( tr_bencDictFindBool( args, "speed-limit-up-enabled", &boolVal ) )
printf( " Uploadlimit enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
if( tr_bencDictFindInt( args, "speed-limit-up", &i ) )
printf( " Uploadlimit: %6" PRId64 " KB/sec\n", i );
}
@ -845,6 +843,7 @@ printDetails( tr_benc * top )
char buf2[512];
int64_t i, j, k;
tr_bool isStopped;
tr_bool boolVal;
isStopped = tr_bencDictFindInt( t, "status", &i ) && (i==TR_STATUS_STOPPED);
@ -989,8 +988,8 @@ printDetails( tr_benc * top )
const time_t tt = i;
printf( " Date created: %s", ctime( &tt ) );
}
if( tr_bencDictFindInt( t, "isPrivate", &i ) )
printf( " Public torrent: %s\n", ( i ? "No" : "Yes" ) );
if( tr_bencDictFindBool( t, "isPrivate", &boolVal ) )
printf( " Public torrent: %s\n", ( boolVal ? "No" : "Yes" ) );
if( tr_bencDictFindStr( t, "comment", &str ) && str && *str )
printf( " Comment: %s\n", str );
if( tr_bencDictFindStr( t, "creator", &str ) && str && *str )
@ -1104,7 +1103,7 @@ printPeersImpl( tr_benc * peers )
if( tr_bencDictFindStr( d, "address", &address )
&& tr_bencDictFindStr( d, "clientName", &client )
&& tr_bencDictFindDouble( d, "progress", &progress )
&& tr_bencDictFindReal( d, "progress", &progress )
&& tr_bencDictFindStr( d, "flagStr", &flagstr )
&& tr_bencDictFindInt( d, "rateToClient", &rateToClient )
&& tr_bencDictFindInt( d, "rateToPeer", &rateToPeer ) )
@ -1171,7 +1170,7 @@ printTorrentList( tr_benc * top )
&& tr_bencDictFindInt( d, "rateUpload", &up )
&& tr_bencDictFindInt( d, "sizeWhenDone", &sizeWhenDone )
&& tr_bencDictFindInt( d, "status", &status )
&& tr_bencDictFindDouble( d, "uploadRatio", &ratio ) )
&& tr_bencDictFindReal( d, "uploadRatio", &ratio ) )
{
char etaStr[16];
char statusStr[64];

32
gtk/conf.c
View File

@ -163,22 +163,22 @@ tr_prefs_init_defaults( tr_benc * d )
if( !str ) str = g_get_user_special_dir( G_USER_DIRECTORY_DESKTOP );
if( !str ) str = tr_getDefaultDownloadDir( );
tr_bencDictAddStr( d, PREF_KEY_DIR_WATCH, str );
tr_bencDictAddInt( d, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
tr_bencDictAddBool( d, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
#endif
tr_bencDictAddInt( d, PREF_KEY_INHIBIT_HIBERNATION, FALSE );
tr_bencDictAddInt( d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
tr_bencDictAddBool( d, PREF_KEY_INHIBIT_HIBERNATION, FALSE );
tr_bencDictAddBool( d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
tr_bencDictAddStr( d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
tr_bencDictAddInt( d, PREF_KEY_TOOLBAR, TRUE );
tr_bencDictAddInt( d, PREF_KEY_FILTERBAR, TRUE );
tr_bencDictAddInt( d, PREF_KEY_STATUSBAR, TRUE );
tr_bencDictAddInt( d, PREF_KEY_SHOW_TRAY_ICON, FALSE );
tr_bencDictAddInt( d, PREF_KEY_SHOW_DESKTOP_NOTIFICATION, TRUE );
tr_bencDictAddBool( d, PREF_KEY_TOOLBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_FILTERBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_STATUSBAR, TRUE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_TRAY_ICON, FALSE );
tr_bencDictAddBool( d, PREF_KEY_SHOW_DESKTOP_NOTIFICATION, TRUE );
tr_bencDictAddStr( d, PREF_KEY_STATUSBAR_STATS, "total-ratio" );
tr_bencDictAddInt( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
tr_bencDictAddBool( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500 );
tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_WIDTH, 300 );
@ -193,14 +193,14 @@ tr_prefs_init_defaults( tr_benc * d )
if( !str ) str = tr_getDefaultDownloadDir( );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, str );
tr_bencDictAddInt( d, PREF_KEY_ASKQUIT, TRUE );
tr_bencDictAddBool( d, PREF_KEY_ASKQUIT, TRUE );
tr_bencDictAddStr( d, PREF_KEY_SORT_MODE, "sort-by-name" );
tr_bencDictAddInt( d, PREF_KEY_SORT_REVERSED, FALSE );
tr_bencDictAddInt( d, PREF_KEY_MINIMAL_VIEW, FALSE );
tr_bencDictAddBool( d, PREF_KEY_SORT_REVERSED, FALSE );
tr_bencDictAddBool( d, PREF_KEY_MINIMAL_VIEW, FALSE );
tr_bencDictAddInt( d, PREF_KEY_START, TRUE );
tr_bencDictAddInt( d, PREF_KEY_TRASH_ORIGINAL, FALSE );
tr_bencDictAddBool( d, PREF_KEY_START, TRUE );
tr_bencDictAddBool( d, PREF_KEY_TRASH_ORIGINAL, FALSE );
}
static char*
@ -258,7 +258,7 @@ pref_double_get( const char * key )
{
double d = 0.0;
tr_bencDictFindDouble( getPrefs( ), key, &d );
tr_bencDictFindReal( getPrefs( ), key, &d );
return d;
}
@ -266,7 +266,7 @@ void
pref_double_set( const char * key,
double value )
{
tr_bencDictAddDouble( getPrefs( ), key, value );
tr_bencDictAddReal( getPrefs( ), key, value );
}
/***

36
libtransmission/bencode-test.c
View File

@ -452,6 +452,39 @@ testStackSmash( int depth )
return 0;
}
static int
testBool( void )
{
tr_benc top;
int64_t intVal;
tr_bool boolVal;
tr_bencInitDict( &top, 0 );
tr_bencDictAddBool( &top, "key1", FALSE );
tr_bencDictAddBool( &top, "key2", 0 );
tr_bencDictAddInt ( &top, "key3", TRUE );
tr_bencDictAddInt ( &top, "key4", 1 );
check( tr_bencDictFindBool( &top, "key1", &boolVal ) )
check( !boolVal )
check( tr_bencDictFindBool( &top, "key2", &boolVal ) )
check( !boolVal )
check( tr_bencDictFindBool( &top, "key3", &boolVal ) )
check( boolVal )
check( tr_bencDictFindBool( &top, "key4", &boolVal ) )
check( boolVal )
check( tr_bencDictFindInt( &top, "key1", &intVal ) )
check( !intVal)
check( tr_bencDictFindInt( &top, "key2", &intVal ) )
check( !intVal )
check( tr_bencDictFindInt( &top, "key3", &intVal ) )
check( intVal )
check( tr_bencDictFindInt( &top, "key4", &intVal ) )
check( intVal )
return 0;
}
int
main( void )
{
@ -472,6 +505,9 @@ main( void )
if(( i = testMerge( )))
return i;
if(( i = testBool( )))
return i;
#ifndef WIN32
i = testStackSmash( 1000000 );
#else

13
libtransmission/bencode.c
View File

@ -448,14 +448,17 @@ tr_bencDictFindInt( tr_benc * dict, const char * key, int64_t * setme )
tr_bool
tr_bencDictFindBool( tr_benc * dict, const char * key, tr_bool * setme )
{
int64_t i = 0;
int64_t i = -1;
const tr_bool found = tr_bencDictFindInt( dict, key, &i );
*setme = i!=0;
if( found ) {
assert( i==0 || i==1 );
*setme = i!=0;
}
return found;
}
tr_bool
tr_bencDictFindDouble( tr_benc * dict, const char * key, double * setme )
tr_bencDictFindReal( tr_benc * dict, const char * key, double * setme )
{
const char * str;
const tr_bool success = tr_bencDictFindStr( dict, key, &str );
@ -742,9 +745,7 @@ tr_bencDictAddStr( tr_benc * dict, const char * key, const char * val )
}
tr_benc*
tr_bencDictAddDouble( tr_benc * dict,
const char * key,
double d )
tr_bencDictAddReal( tr_benc * dict, const char * key, double d )
{
char buf[128];
char * locale;

4
libtransmission/bencode.h
View File

@ -126,7 +126,7 @@ int tr_bencDictRemove( tr_benc *, const char * key );
tr_benc * tr_bencDictAdd( tr_benc *, const char * key );
tr_benc * tr_bencDictAddDouble( tr_benc *, const char * key, double );
tr_benc * tr_bencDictAddReal( tr_benc *, const char * key, double );
tr_benc * tr_bencDictAddInt( tr_benc *, const char * key, int64_t );
@ -149,7 +149,7 @@ tr_bool tr_bencDictFindDict( tr_benc *, const char * key, tr_benc ** setme );
tr_bool tr_bencDictFindInt( tr_benc *, const char * key, int64_t * setme );
tr_bool tr_bencDictFindDouble( tr_benc *, const char * key, double * setme );
tr_bool tr_bencDictFindReal( tr_benc *, const char * key, double * setme );
tr_bool tr_bencDictFindBool( tr_benc *, const char * key, tr_bool * setme );

35
libtransmission/resume.c
View File

@ -252,8 +252,8 @@ saveSingleSpeedLimit( tr_benc * d, const tr_torrent * tor, tr_direction dir )
{
tr_bencDictReserve( d, 3 );
tr_bencDictAddInt( d, KEY_SPEED, tr_torrentGetSpeedLimit( tor, dir ) );
tr_bencDictAddInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits( tor ) );
tr_bencDictAddInt( d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit( tor, dir ) );
tr_bencDictAddBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits( tor ) );
tr_bencDictAddBool( d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit( tor, dir ) );
}
static void
@ -266,24 +266,25 @@ saveSpeedLimits( tr_benc * dict, const tr_torrent * tor )
static void
saveRatioLimits( tr_benc * dict, const tr_torrent * tor )
{
tr_benc * d = tr_bencDictAddDict( dict, KEY_RATIOLIMIT, 4 );
tr_bencDictAddDouble( d, KEY_RATIOLIMIT_RATIO,
tr_torrentGetRatioLimit( tor ) );
tr_bencDictAddInt( d, KEY_RATIOLIMIT_MODE,
tr_torrentGetRatioMode( tor ) );
tr_benc * d = tr_bencDictAddDict( dict, KEY_RATIOLIMIT, 2 );
tr_bencDictAddReal( d, KEY_RATIOLIMIT_RATIO, tr_torrentGetRatioLimit( tor ) );
tr_bencDictAddInt( d, KEY_RATIOLIMIT_MODE, tr_torrentGetRatioMode( tor ) );
}
static void
loadSingleSpeedLimit( tr_benc * d, tr_direction dir, tr_torrent * tor )
{
int64_t i;
tr_bool boolVal;
if( tr_bencDictFindInt( d, KEY_SPEED, &i ) )
tr_torrentSetSpeedLimit( tor, dir, i );
if( tr_bencDictFindInt( d, KEY_USE_SPEED_LIMIT, &i ) )
tr_torrentUseSpeedLimit( tor, dir, i!=0 );
if( tr_bencDictFindInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, &i ) )
tr_torrentUseSessionLimits( tor, i!=0 );
if( tr_bencDictFindBool( d, KEY_USE_SPEED_LIMIT, &boolVal ) )
tr_torrentUseSpeedLimit( tor, dir, boolVal );
if( tr_bencDictFindBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal ) )
tr_torrentUseSessionLimits( tor, boolVal );
}
enum old_speed_modes
@ -343,7 +344,7 @@ loadRatioLimits( tr_benc * dict,
{
int64_t i;
double dratio;
if( tr_bencDictFindDouble( d, KEY_RATIOLIMIT_RATIO, &dratio ) )
if( tr_bencDictFindReal( d, KEY_RATIOLIMIT_RATIO, &dratio ) )
tr_torrentSetRatioLimit( tor, dratio );
if( tr_bencDictFindInt( d, KEY_RATIOLIMIT_MODE, &i ) )
tr_torrentSetRatioMode( tor, i );
@ -501,8 +502,7 @@ tr_torrentSaveResume( const tr_torrent * tor )
tor->uploadedPrev + tor->uploadedCur );
tr_bencDictAddInt( &top, KEY_MAX_PEERS,
tor->maxConnectedPeers );
tr_bencDictAddInt( &top, KEY_PAUSED,
tor->isRunning ? 0 : 1 );
tr_bencDictAddBool( &top, KEY_PAUSED, tor->isRunning!=0 );
savePeers( &top, tor );
savePriorities( &top, tor );
saveDND( &top, tor );
@ -526,6 +526,7 @@ loadFromFile( tr_torrent * tor,
uint64_t fieldsLoaded = 0;
char * filename;
tr_benc top;
tr_bool boolVal;
filename = getResumeFilename( tor );
@ -586,9 +587,9 @@ loadFromFile( tr_torrent * tor,
}
if( ( fieldsToLoad & TR_FR_RUN )
&& tr_bencDictFindInt( &top, KEY_PAUSED, &i ) )
&& tr_bencDictFindBool( &top, KEY_PAUSED, &boolVal ) )
{
tor->isRunning = i ? 0 : 1;
tor->isRunning = !boolVal;
fieldsLoaded |= TR_FR_RUN;
}

15
libtransmission/rpc-server.c
View File

@ -172,7 +172,7 @@ handle_upload( struct evhttp_request * req,
tr_bencDictAddStr( &top, "method", "torrent-add" );
b64 = tr_base64_encode( body, body_len, NULL );
tr_bencDictAddStr( args, "metainfo", b64 );
tr_bencDictAddInt( args, "paused", paused );
tr_bencDictAddBool( args, "paused", paused );
tr_bencSaveAsJSON( &top, json );
tr_rpc_request_exec_json( server->session,
EVBUFFER_DATA( json ),
@ -736,27 +736,28 @@ tr_rpcInit( tr_session * session,
{
tr_rpc_server * s;
tr_bool found;
tr_bool boolVal;
int64_t i;
const char *str;
s = tr_new0( tr_rpc_server, 1 );
s->session = session;
found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_ENABLED, &i );
found = tr_bencDictFindBool( settings, TR_PREFS_KEY_RPC_ENABLED, &boolVal );
assert( found );
s->isEnabled = i != 0;
s->isEnabled = boolVal;
found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_PORT, &i );
assert( found );
s->port = i;
found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, &i );
found = tr_bencDictFindBool( settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, &boolVal );
assert( found );
s->isWhitelistEnabled = i != 0;
s->isWhitelistEnabled = boolVal;
found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &i );
found = tr_bencDictFindBool( settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal );
assert( found );
s->isPasswordEnabled = i != 0;
s->isPasswordEnabled = boolVal;
found = tr_bencDictFindStr( settings, TR_PREFS_KEY_RPC_WHITELIST, &str );
assert( found );

168
libtransmission/rpcimpl.c
View File

@ -226,8 +226,8 @@ torrentRemove( tr_session * session,
{
tr_torrent * tor = torrents[i];
const tr_rpc_callback_status status = notify( session, TR_RPC_TORRENT_REMOVING, tor );
int64_t deleteFlag;
if( tr_bencDictFindInt( args_in, "delete-local-data", &deleteFlag ) && deleteFlag )
tr_bool deleteFlag;
if( tr_bencDictFindBool( args_in, "delete-local-data", &deleteFlag ) && deleteFlag )
tr_torrentDeleteLocalData( tor, NULL );
if( !( status & TR_RPC_NOREMOVE ) )
tr_torrentRemove( tor );
@ -349,24 +349,21 @@ addPeers( const tr_torrent * tor,
{
tr_benc * d = tr_bencListAddDict( list, 14 );
const tr_peer_stat * peer = peers + i;
tr_bencDictAddStr( d, "address", peer->addr );
tr_bencDictAddStr( d, "clientName", peer->client );
tr_bencDictAddInt( d, "clientIsChoked", peer->clientIsChoked );
tr_bencDictAddInt( d, "clientIsInterested",
peer->clientIsInterested );
tr_bencDictAddStr( d, "flagStr", peer->flagStr );
tr_bencDictAddInt( d, "isDownloadingFrom", peer->isDownloadingFrom );
tr_bencDictAddInt( d, "isEncrypted", peer->isEncrypted );
tr_bencDictAddInt( d, "isIncoming", peer->isIncoming );
tr_bencDictAddInt( d, "isUploadingTo", peer->isUploadingTo );
tr_bencDictAddInt( d, "peerIsChoked", peer->peerIsChoked );
tr_bencDictAddInt( d, "peerIsInterested", peer->peerIsInterested );
tr_bencDictAddInt( d, "port", peer->port );
tr_bencDictAddDouble( d, "progress", peer->progress );
tr_bencDictAddInt( d, "rateToClient",
(int)( peer->rateToClient * 1024.0 ) );
tr_bencDictAddInt( d, "rateToPeer",
(int)( peer->rateToPeer * 1024.0 ) );
tr_bencDictAddStr ( d, "address", peer->addr );
tr_bencDictAddStr ( d, "clientName", peer->client );
tr_bencDictAddBool( d, "clientIsChoked", peer->clientIsChoked );
tr_bencDictAddBool( d, "clientIsInterested", peer->clientIsInterested );
tr_bencDictAddStr ( d, "flagStr", peer->flagStr );
tr_bencDictAddBool( d, "isDownloadingFrom", peer->isDownloadingFrom );
tr_bencDictAddBool( d, "isEncrypted", peer->isEncrypted );
tr_bencDictAddBool( d, "isIncoming", peer->isIncoming );
tr_bencDictAddBool( d, "isUploadingTo", peer->isUploadingTo );
tr_bencDictAddBool( d, "peerIsChoked", peer->peerIsChoked );
tr_bencDictAddBool( d, "peerIsInterested", peer->peerIsInterested );
tr_bencDictAddInt ( d, "port", peer->port );
tr_bencDictAddReal( d, "progress", peer->progress );
tr_bencDictAddInt ( d, "rateToClient", (int)( peer->rateToClient * 1024.0 ) );
tr_bencDictAddInt ( d, "rateToPeer", (int)( peer->rateToPeer * 1024.0 ) );
}
tr_torrentPeersFree( peers, peerCount );
@ -409,7 +406,7 @@ addField( const tr_torrent * tor,
else if( !strcmp( key, "downloadLimit" ) )
tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit( tor, TR_DOWN ) );
else if( !strcmp( key, "downloadLimited" ) )
tr_bencDictAddInt( d, key, tr_torrentUsesSpeedLimit( tor, TR_DOWN ) );
tr_bencDictAddBool( d, key, tr_torrentUsesSpeedLimit( tor, TR_DOWN ) );
else if( !strcmp( key, "error" ) )
tr_bencDictAddInt( d, key, st->error );
else if( !strcmp( key, "errorString" ) )
@ -425,11 +422,11 @@ addField( const tr_torrent * tor,
else if( !strcmp( key, "haveValid" ) )
tr_bencDictAddInt( d, key, st->haveValid );
else if( !strcmp( key, "honorsSessionLimits" ) )
tr_bencDictAddInt( d, key, tr_torrentUsesSessionLimits( tor ) );
tr_bencDictAddBool( d, key, tr_torrentUsesSessionLimits( tor ) );
else if( !strcmp( key, "id" ) )
tr_bencDictAddInt( d, key, st->id );
else if( !strcmp( key, "isPrivate" ) )
tr_bencDictAddInt( d, key, tr_torrentIsPrivate( tor ) );
tr_bencDictAddBool( d, key, tr_torrentIsPrivate( tor ) );
else if( !strcmp( key, "lastAnnounceTime" ) )
tr_bencDictAddInt( d, key, st->lastAnnounceTime );
else if( !strcmp( key, "lastScrapeTime" ) )
@ -491,9 +488,9 @@ addField( const tr_torrent * tor,
else if( !strcmp( key, "rateUpload" ) )
tr_bencDictAddInt( d, key, (int)( st->pieceUploadSpeed * 1024 ) );
else if( !strcmp( key, "ratio" ) )
tr_bencDictAddDouble( d, key, st->ratio );
tr_bencDictAddReal( d, key, st->ratio );
else if( !strcmp( key, "recheckProgress" ) )
tr_bencDictAddDouble( d, key, st->recheckProgress );
tr_bencDictAddReal( d, key, st->recheckProgress );
else if( !strcmp( key, "scrapeResponse" ) )
tr_bencDictAddStr( d, key, st->scrapeResponse );
else if( !strcmp( key, "scrapeURL" ) )
@ -501,7 +498,7 @@ addField( const tr_torrent * tor,
else if( !strcmp( key, "seeders" ) )
tr_bencDictAddInt( d, key, st->seeders );
else if( !strcmp( key, "seedRatioLimit" ) )
tr_bencDictAddDouble( d, key, tr_torrentGetRatioLimit( tor ) );
tr_bencDictAddReal( d, key, tr_torrentGetRatioLimit( tor ) );
else if( !strcmp( key, "seedRatioMode" ) )
tr_bencDictAddInt( d, key, tr_torrentGetRatioMode( tor ) );
else if( !strcmp( key, "sizeWhenDone" ) )
@ -521,11 +518,11 @@ addField( const tr_torrent * tor,
else if( !strcmp( key, "uploadedEver" ) )
tr_bencDictAddInt( d, key, st->uploadedEver );
else if( !strcmp( key, "uploadRatio" ) )
tr_bencDictAddDouble( d, key, tr_getRatio( st->uploadedEver, st->downloadedEver ) );
tr_bencDictAddReal( d, key, tr_getRatio( st->uploadedEver, st->downloadedEver ) );
else if( !strcmp( key, "uploadLimit" ) )
tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit( tor, TR_UP ) );
else if( !strcmp( key, "uploadLimited" ) )
tr_bencDictAddInt( d, key, tr_torrentUsesSpeedLimit( tor, TR_UP ) );
tr_bencDictAddBool( d, key, tr_torrentUsesSpeedLimit( tor, TR_UP ) );
else if( !strcmp( key, "wanted" ) )
{
tr_file_index_t i;
@ -675,6 +672,7 @@ torrentSet( tr_session * session,
int64_t tmp;
double d;
tr_benc * files;
tr_bool boolVal;
tr_torrent * tor = torrents[i];
if( tr_bencDictFindList( args_in, "files-unwanted", &files ) )
@ -691,19 +689,19 @@ torrentSet( tr_session * session,
errmsg = setFilePriorities( tor, TR_PRI_NORMAL, files );
if( tr_bencDictFindInt( args_in, "downloadLimit", &tmp ) )
tr_torrentSetSpeedLimit( tor, TR_DOWN, tmp );
if( tr_bencDictFindInt( args_in, "downloadLimited", &tmp ) )
tr_torrentUseSpeedLimit( tor, TR_DOWN, tmp!=0 );
if( tr_bencDictFindInt( args_in, "honorsSessionLimits", &tmp ) )
tr_torrentUseSessionLimits( tor, tmp!=0 );
if( tr_bencDictFindBool( args_in, "downloadLimited", &boolVal ) )
tr_torrentUseSpeedLimit( tor, TR_DOWN, boolVal );
if( tr_bencDictFindBool( args_in, "honorsSessionLimits", &boolVal ) )
tr_torrentUseSessionLimits( tor, boolVal );
if( tr_bencDictFindInt( args_in, "uploadLimit", &tmp ) )
tr_torrentSetSpeedLimit( tor, TR_UP, tmp );
if( tr_bencDictFindInt( args_in, "uploadLimited", &tmp ) )
tr_torrentUseSpeedLimit( tor, TR_UP, tmp!=0 );
if( tr_bencDictFindDouble( args_in, "ratio-limit", &d ) )
if( tr_bencDictFindBool( args_in, "uploadLimited", &boolVal ) )
tr_torrentUseSpeedLimit( tor, TR_UP, boolVal );
if( tr_bencDictFindReal( args_in, "ratio-limit", &d ) )
tr_torrentSetRatioLimit( tor, d );
if( tr_bencDictFindInt( args_in, "ratio-limit-mode", &tmp ) )
tr_torrentSetRatioMode( tor, tmp );
if( tr_bencDictFindDouble( args_in, "seedRatioLimit", &d ) )
if( tr_bencDictFindReal( args_in, "seedRatioLimit", &d ) )
tr_torrentSetRatioLimit( tor, d );
if( tr_bencDictFindInt( args_in, "seedRatioMode", &tmp ) )
tr_torrentSetRatioMode( tor, tmp );
@ -814,14 +812,15 @@ torrentAdd( tr_session * session,
else
{
int64_t i;
tr_bool boolVal;
const char * str;
tr_ctor * ctor = tr_ctorNew( session );
/* set the optional arguments */
if( tr_bencDictFindStr( args_in, "download-dir", &str ) )
tr_ctorSetDownloadDir( ctor, TR_FORCE, str );
if( tr_bencDictFindInt( args_in, "paused", &i ) )
tr_ctorSetPaused( ctor, TR_FORCE, i );
if( tr_bencDictFindBool( args_in, "paused", &boolVal ) )
tr_ctorSetPaused( ctor, TR_FORCE, boolVal );
if( tr_bencDictFindInt( args_in, "peer-limit", &i ) )
tr_ctorSetPeerLimit( ctor, TR_FORCE, i );
@ -862,9 +861,9 @@ sessionSet( tr_session * session,
tr_benc * args_out UNUSED,
struct tr_rpc_idle_data * idle_data )
{
tr_bool b;
int64_t i;
double d;
tr_bool boolVal;
const char * str;
assert( idle_data == NULL );
@ -873,46 +872,45 @@ sessionSet( tr_session * session,
tr_sessionSetAltSpeed( session, TR_UP, i );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_DOWN, &i ) )
tr_sessionSetAltSpeed( session, TR_DOWN, i );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_ENABLED, &i ) )
tr_sessionUseAltSpeed( session, i!=0 );
if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal ) )
tr_sessionUseAltSpeed( session, boolVal );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i ) )
tr_sessionSetAltSpeedBegin( session, i );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i ) )
tr_sessionSetAltSpeedEnd( session, i );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &i ) )
tr_sessionUseAltSpeedTime( session, i!=0 );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i ) )
tr_blocklistSetEnabled( session, i!=0 );
if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal ) )
tr_sessionUseAltSpeedTime( session, boolVal );
if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal ) )
tr_blocklistSetEnabled( session, boolVal );
if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
tr_sessionSetDownloadDir( session, str );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i ) )
tr_sessionSetPeerLimit( session, i );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i ) )
tr_sessionSetPeerLimitPerTorrent( session, i );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEX_ENABLED, &i ) )
tr_sessionSetPexEnabled( session, i );
if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_PEX_ENABLED, &boolVal ) )
tr_sessionSetPexEnabled( session, boolVal );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_PORT, &i ) )
tr_sessionSetPeerPort( session, i );
if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PORT_FORWARDING, &i ) )
tr_sessionSetPortForwardingEnabled( session, i );
if( tr_bencDictFindDouble( args_in, "seedRatioLimit", &d ) )
if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_PORT_FORWARDING, &boolVal ) )
tr_sessionSetPortForwardingEnabled( session, boolVal );
if( tr_bencDictFindReal( args_in, "seedRatioLimit", &d ) )
tr_sessionSetRatioLimit( session, d );
if( tr_bencDictFindBool( args_in, "seedRatioLimited", &b ) )
tr_sessionSetRatioLimited( session, b );
if( tr_bencDictFindBool( args_in, "seedRatioLimited", &boolVal ) )
tr_sessionSetRatioLimited( session, boolVal );
if( tr_bencDictFindInt( args_in, "speed-limit-down", &i ) )
tr_sessionSetSpeedLimit( session, TR_DOWN, i );
if( tr_bencDictFindInt( args_in, "speed-limit-down-enabled", &i ) )
tr_sessionLimitSpeed( session, TR_DOWN, i!=0 );
if( tr_bencDictFindBool( args_in, "speed-limit-down-enabled", &boolVal ) )
tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
if( tr_bencDictFindInt( args_in, "speed-limit-up", &i ) )
tr_sessionSetSpeedLimit( session, TR_UP, i );
if( tr_bencDictFindInt( args_in, "speed-limit-up-enabled", &i ) )
tr_sessionLimitSpeed( session, TR_UP, i!=0 );
if( tr_bencDictFindDouble( args_in, "ratio-limit", &d ) )
if( tr_bencDictFindBool( args_in, "speed-limit-up-enabled", &boolVal ) )
tr_sessionLimitSpeed( session, TR_UP, boolVal );
if( tr_bencDictFindReal( args_in, "ratio-limit", &d ) )
tr_sessionSetRatioLimit( session, d );
if( tr_bencDictFindInt( args_in, "ratio-limit-enabled", &i ) )
tr_sessionSetRatioLimited( session, i!=0 );
if( tr_bencDictFindStr( args_in, "encryption", &str ) )
{
if( tr_bencDictFindBool( args_in, "ratio-limit-enabled", &boolVal ) )
tr_sessionSetRatioLimited( session, boolVal );
if( tr_bencDictFindStr( args_in, "encryption", &str ) ) {
if( !strcmp( str, "required" ) )
tr_sessionSetEncryption( session, TR_ENCRYPTION_REQUIRED );
else if( !strcmp( str, "tolerated" ) )
@ -983,31 +981,31 @@ sessionGet( tr_session * s,
tr_benc * d = args_out;
assert( idle_data == NULL );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed(s,TR_UP) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed(s,TR_DOWN) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed(s) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin(s) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,tr_sessionGetAltSpeedEnd(s) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime(s) );
tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
tr_bencDictAddInt( d, "blocklist-size", tr_blocklistGetRuleCount( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, tr_sessionGetPeerLimitPerTorrent( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
tr_bencDictAddInt( d, "rpc-version", 4 );
tr_bencDictAddInt( d, "rpc-version-minimum", 1 );
tr_bencDictAddDouble( d, "seedRatioLimit", tr_sessionGetRatioLimit( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed(s,TR_UP) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed(s,TR_DOWN) );
tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed(s) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin(s) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,tr_sessionGetAltSpeedEnd(s) );
tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime(s) );
tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
tr_bencDictAddInt ( d, "blocklist-size", tr_blocklistGetRuleCount( s ) );
tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, tr_sessionGetPeerLimitPerTorrent( s ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
tr_bencDictAddInt ( d, "rpc-version", 4 );
tr_bencDictAddInt ( d, "rpc-version-minimum", 1 );
tr_bencDictAddReal( d, "seedRatioLimit", tr_sessionGetRatioLimit( s ) );
tr_bencDictAddBool( d, "seedRatioLimited", tr_sessionIsRatioLimited( s ) );
tr_bencDictAddInt( d, "speed-limit-up", tr_sessionGetSpeedLimit( s, TR_UP ) );
tr_bencDictAddInt( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimited( s, TR_UP ) );
tr_bencDictAddInt( d, "speed-limit-down", tr_sessionGetSpeedLimit( s, TR_DOWN ) );
tr_bencDictAddInt( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimited( s, TR_DOWN ) );
tr_bencDictAddDouble( d, "ratio-limit", tr_sessionGetRatioLimit( s ) );
tr_bencDictAddInt( d, "ratio-limit-enabled", tr_sessionIsRatioLimited( s ) );
tr_bencDictAddStr( d, "version", LONG_VERSION_STRING );
tr_bencDictAddInt ( d, "speed-limit-up", tr_sessionGetSpeedLimit( s, TR_UP ) );
tr_bencDictAddBool( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimited( s, TR_UP ) );
tr_bencDictAddInt ( d, "speed-limit-down", tr_sessionGetSpeedLimit( s, TR_DOWN ) );
tr_bencDictAddBool( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimited( s, TR_DOWN ) );
tr_bencDictAddReal( d, "ratio-limit", tr_sessionGetRatioLimit( s ) );
tr_bencDictAddBool( d, "ratio-limit-enabled", tr_sessionIsRatioLimited( s ) );
tr_bencDictAddStr ( d, "version", LONG_VERSION_STRING );
switch( tr_sessionGetEncryption( s ) ) {
case TR_CLEAR_PREFERRED: str = "tolerated"; break;
case TR_ENCRYPTION_REQUIRED: str = "required"; break;

227
libtransmission/session.c
View File

@ -232,9 +232,9 @@ isAltTime( const tr_session * s )
***/
#ifdef TR_EMBEDDED
#define TR_DEFAULT_ENCRYPTION TR_CLEAR_PREFERRED
#define TR_DEFAULT_ENCRYPTION TR_CLEAR_PREFERRED
#else
#define TR_DEFAULT_ENCRYPTION TR_ENCRYPTION_PREFERRED
#define TR_DEFAULT_ENCRYPTION TR_ENCRYPTION_PREFERRED
#endif
void
@ -243,49 +243,49 @@ tr_sessionGetDefaultSettings( tr_benc * d )
assert( tr_bencIsDict( d ) );
tr_bencDictReserve( d, 35 );
tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_getDefaultDownloadDir( ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED, 100 );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, 0 );
tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, TR_DEFAULT_ENCRYPTION );
tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF );
tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT, atoi( TR_DEFAULT_OPEN_FILE_LIMIT_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi( TR_DEFAULT_PEER_LIMIT_GLOBAL_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi( TR_DEFAULT_PEER_LIMIT_TORRENT_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, atoi( TR_DEFAULT_PEER_PORT_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, 1024 );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, 65535 );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi( TR_DEFAULT_PEER_SOCKET_TOS_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION, TR_PREALLOCATE_SPARSE );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY, "" );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED, FALSE );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD, "" );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT, 80 );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE, TR_PROXY_HTTP );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME, "" );
tr_bencDictAddDouble( d, TR_PREFS_KEY_RATIO, 2.0 );
tr_bencDictAddInt( d, TR_PREFS_KEY_RATIO_ENABLED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED, TRUE );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD, "" );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME, "" );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST, TR_DEFAULT_RPC_WHITELIST );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, TRUE );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT, atoi( TR_DEFAULT_RPC_PORT_STR ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP, 50 ); /* half the regular */
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN, 50 ); /* half the regular */
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, 540 ); /* 9am */
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, FALSE );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END, 1020 ); /* 5pm */
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, 100 );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 0 );
tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, 14 );
tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_getDefaultDownloadDir( ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED, 100 );
tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, FALSE );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION, TR_DEFAULT_ENCRYPTION );
tr_bencDictAddBool( d, TR_PREFS_KEY_LAZY_BITFIELD, TRUE );
tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF );
tr_bencDictAddInt ( d, TR_PREFS_KEY_OPEN_FILE_LIMIT, atoi( TR_DEFAULT_OPEN_FILE_LIMIT_STR ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi( TR_DEFAULT_PEER_LIMIT_GLOBAL_STR ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi( TR_DEFAULT_PEER_LIMIT_TORRENT_STR ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT, atoi( TR_DEFAULT_PEER_PORT_STR ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, FALSE );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, 1024 );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, 65535 );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi( TR_DEFAULT_PEER_SOCKET_TOS_STR ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED, TRUE );
tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PREALLOCATION, TR_PREALLOCATE_SPARSE );
tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY, "" );
tr_bencDictAddBool( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED, FALSE );
tr_bencDictAddBool( d, TR_PREFS_KEY_PROXY_ENABLED, FALSE );
tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY_PASSWORD, "" );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PROXY_PORT, 80 );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PROXY_TYPE, TR_PROXY_HTTP );
tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY_USERNAME, "" );
tr_bencDictAddReal( d, TR_PREFS_KEY_RATIO, 2.0 );
tr_bencDictAddBool( d, TR_PREFS_KEY_RATIO_ENABLED, FALSE );
tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED, FALSE );
tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_ENABLED, TRUE );
tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_PASSWORD, "" );
tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_USERNAME, "" );
tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_WHITELIST, TR_DEFAULT_RPC_WHITELIST );
tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, TRUE );
tr_bencDictAddInt ( d, TR_PREFS_KEY_RPC_PORT, atoi( TR_DEFAULT_RPC_PORT_STR ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, FALSE );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP, 50 ); /* half the regular */
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN, 50 ); /* half the regular */
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, 540 ); /* 9am */
tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, FALSE );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END, 1020 ); /* 5pm */
tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED, 100 );
tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, FALSE );
tr_bencDictAddInt ( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, 14 );
}
void
@ -297,49 +297,49 @@ tr_sessionGetSettings( tr_session * s, struct tr_benc * d )
assert( tr_bencIsDict( d ) );
tr_bencDictReserve( d, 30 );
tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, s->downloadDir );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_DOWN ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION, s->encryptionMode );
tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD, s->useLazyBitfield );
tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL, tr_getMessageLevel( ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT, s->openFileLimit );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, s->peerLimitPerTorrent );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, s->isPortRandom );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, s->randomPortLow );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, s->randomPortHigh );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS, s->peerSocketTOS );
tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED, s->isPexEnabled );
tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION, s->preallocationMode );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY, s->proxy );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED, s->isProxyAuthEnabled );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED, s->isProxyEnabled );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD, s->proxyPassword );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT, s->proxyPort );
tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE, s->proxyType );
tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME, s->proxyUsername );
tr_bencDictAddDouble( d, TR_PREFS_KEY_RATIO, s->desiredRatio );
tr_bencDictAddInt( d, TR_PREFS_KEY_RATIO_ENABLED, s->isRatioLimited );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED, tr_sessionIsRPCEnabled( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD, freeme[n++] = tr_sessionGetRPCPassword( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT, tr_sessionGetRPCPort( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME, freeme[n++] = tr_sessionGetRPCUsername( s ) );
tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST, freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed( s, TR_UP ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed( s, TR_DOWN ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END, tr_sessionGetAltSpeedEnd( s ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_UP ) );
tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, s->uploadSlotsPerTorrent );
tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR, s->downloadDir );
tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_DOWN ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION, s->encryptionMode );
tr_bencDictAddBool( d, TR_PREFS_KEY_LAZY_BITFIELD, s->useLazyBitfield );
tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL, tr_getMessageLevel( ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_OPEN_FILE_LIMIT, s->openFileLimit );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, s->peerLimitPerTorrent );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, s->isPortRandom );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, s->randomPortLow );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH, s->randomPortHigh );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_SOCKET_TOS, s->peerSocketTOS );
tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED, s->isPexEnabled );
tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PREALLOCATION, s->preallocationMode );
tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY, s->proxy );
tr_bencDictAddBool( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED, s->isProxyAuthEnabled );
tr_bencDictAddBool( d, TR_PREFS_KEY_PROXY_ENABLED, s->isProxyEnabled );
tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY_PASSWORD, s->proxyPassword );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PROXY_PORT, s->proxyPort );
tr_bencDictAddInt ( d, TR_PREFS_KEY_PROXY_TYPE, s->proxyType );
tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY_USERNAME, s->proxyUsername );
tr_bencDictAddReal( d, TR_PREFS_KEY_RATIO, s->desiredRatio );
tr_bencDictAddBool( d, TR_PREFS_KEY_RATIO_ENABLED, s->isRatioLimited );
tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled( s ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_ENABLED, tr_sessionIsRPCEnabled( s ) );
tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_PASSWORD, freeme[n++] = tr_sessionGetRPCPassword( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_RPC_PORT, tr_sessionGetRPCPort( s ) );
tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_USERNAME, freeme[n++] = tr_sessionGetRPCUsername( s ) );
tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_WHITELIST, freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, tr_sessionGetRPCWhitelistEnabled( s ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed( s, TR_UP ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed( s, TR_DOWN ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin( s ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END, tr_sessionGetAltSpeedEnd( s ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, tr_sessionIsSpeedLimited( s, TR_UP ) );
tr_bencDictAddInt ( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, s->uploadSlotsPerTorrent );
for( i=0; i<n; ++i )
tr_free( freeme[i] );
@ -478,6 +478,7 @@ tr_sessionInitImpl( void * vdata )
double d;
tr_bool useAltSpeedTime;
tr_bool found;
tr_bool boolVal;
const char * str;
tr_benc settings;
char * filename;
@ -509,9 +510,9 @@ tr_sessionInitImpl( void * vdata )
tr_setMessageQueuing( data->messageQueuingEnabled );
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEX_ENABLED, &i );
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PEX_ENABLED, &boolVal );
assert( found );
session->isPexEnabled = i != 0;
session->isPexEnabled = boolVal;
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ENCRYPTION, &i );
assert( found );
@ -531,9 +532,9 @@ tr_sessionInitImpl( void * vdata )
assert( found );
session->downloadDir = tr_strdup( str );
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_ENABLED, &i );
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PROXY_ENABLED, &boolVal );
assert( found );
session->isProxyEnabled = i != 0;
session->isProxyEnabled = boolVal;
found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY, &str );
assert( found );
@ -547,9 +548,9 @@ tr_sessionInitImpl( void * vdata )
assert( found );
session->proxyType = i;
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_AUTH_ENABLED, &i );
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PROXY_AUTH_ENABLED, &boolVal );
assert( found );
session->isProxyAuthEnabled = i != 0;
session->isProxyAuthEnabled = boolVal;
found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY_USERNAME, &str );
assert( found );
@ -569,9 +570,9 @@ tr_sessionInitImpl( void * vdata )
session->peerMgr = tr_peerMgrNew( session );
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_LAZY_BITFIELD, &i );
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_LAZY_BITFIELD, &boolVal );
assert( found );
session->useLazyBitfield = i != 0;
session->useLazyBitfield = boolVal;
/* Initialize rate and file descripts controls */
@ -586,9 +587,9 @@ tr_sessionInitImpl( void * vdata )
*** random port
**/
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, &i );
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, &boolVal );
assert( found );
session->isPortRandom = i != 0;
session->isPortRandom = boolVal;
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i );
assert( found );
@ -598,11 +599,11 @@ tr_sessionInitImpl( void * vdata )
assert( found );
session->randomPortHigh = i;
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, &i )
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, &boolVal )
&& tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT, &j );
assert( found );
session->peerPort = session->isPortRandom ? getRandomPort( session ) : j;
session->shared = tr_sharedInit( session, i, session->peerPort );
session->shared = tr_sharedInit( session, boolVal, session->peerPort );
session->isPortSet = session->isPortRandom || j>0;
/**
@ -613,22 +614,22 @@ tr_sessionInitImpl( void * vdata )
session->uploadSlotsPerTorrent = i;
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED, &i )
&& tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED_ENABLED, &j );
&& tr_bencDictFindBool( &settings, TR_PREFS_KEY_USPEED_ENABLED, &boolVal );
assert( found );
tr_sessionSetSpeedLimit( session, TR_UP, i );
tr_sessionLimitSpeed( session, TR_UP, j!=0 );
tr_sessionLimitSpeed( session, TR_UP, boolVal );
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED, &i )
&& tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED_ENABLED, &j );
&& tr_bencDictFindBool( &settings, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal );
assert( found );
tr_sessionSetSpeedLimit( session, TR_DOWN, i );
tr_sessionLimitSpeed( session, TR_DOWN, j!=0 );
tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
found = tr_bencDictFindDouble( &settings, TR_PREFS_KEY_RATIO, &d )
&& tr_bencDictFindInt( &settings, TR_PREFS_KEY_RATIO_ENABLED, &j );
found = tr_bencDictFindReal( &settings, TR_PREFS_KEY_RATIO, &d )
&& tr_bencDictFindBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, &boolVal );
assert( found );
tr_sessionSetRatioLimit( session, d );
tr_sessionSetRatioLimited( session, j );
tr_sessionSetRatioLimited( session, boolVal );
/**
*** Alternate speed limits
@ -650,16 +651,16 @@ tr_sessionInitImpl( void * vdata )
assert( found );
session->altSpeedTimeEnd = i;
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &i );
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal );
assert( found );
useAltSpeedTime = i!=0;
useAltSpeedTime = boolVal;
tr_sessionUseAltSpeedTime( session, useAltSpeedTime );
if( !useAltSpeedTime )
{
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &i );
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal );
assert( found );
tr_sessionUseAltSpeed( session, i!=0 );
tr_sessionUseAltSpeed( session, boolVal );
}
else
tr_sessionUseAltSpeed( session, isAltTime( session ) );
@ -671,9 +672,9 @@ tr_sessionInitImpl( void * vdata )
filename = tr_buildPath( session->configDir, "blocklists", NULL );
tr_mkdirp( filename, 0777 );
tr_free( filename );
found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i );
found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal );
assert( found );
session->isBlocklistEnabled = i;
session->isBlocklistEnabled = boolVal;
loadBlocklists( session );
session->rpcServer = tr_rpcInit( session, &settings );