Changeset 8108


Ignore:
Timestamp:
Mar 29, 2009, 11:05:32 PM (13 years ago)
Author:
charles
Message:

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

Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/cli.c

    r7650 r8108  
    492492                announce = optarg; break;
    493493
    494             case 'b': tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, 1 );
    495                       break;
    496             case 'B': tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, 0 );
     494            case 'b': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, TRUE );
     495                      break;
     496            case 'B': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
    497497                      break;
    498498            case 'c': comment = optarg;
    499499                      break;
    500             case 'd': tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED, atoi( optarg ) );
    501                       tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, 1 );
    502                       break;
    503             case 'D': tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED, 0 );
     500            case 'd': tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED, atoi( optarg ) );
     501                      tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, TRUE );
     502                      break;
     503            case 'D': tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, FALSE );
    504504                      break;
    505505            case 'f': finishCall = optarg;
     
    509509            case 'i': showInfo = 1;
    510510                      break;
    511             case 'm': tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, 1 );
    512                       break;
    513             case 'M': tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, 0 );
     511            case 'm': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
     512                      break;
     513            case 'M': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, FALSE );
    514514                      break;
    515515            case 'n': sourceFile = optarg; break;
     
    523523                      break;
    524524            case 'u': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED, atoi( optarg ) );
    525                       tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 1 );
    526                       break;
    527             case 'U': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED, 0 );
     525                      tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, TRUE );
     526                      break;
     527            case 'U': tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, FALSE );
    528528                      break;
    529529            case 'v': verify = 1;
  • trunk/daemon/daemon.c

    r7979 r8108  
    202202{
    203203    int c;
    204     int64_t i;
    205204    const char * optarg;
    206205    tr_benc settings;
     206    tr_bool boolVal;
    207207    tr_bool foreground = FALSE;
    208208    tr_bool dumpSettings = FALSE;
     
    222222    configDir = getConfigDir( argc, (const char**)argv );
    223223    tr_sessionLoadSettings( &settings, configDir, MY_NAME );
    224     tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_ENABLED, 1 );
     224    tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, TRUE );
    225225
    226226    /* overwrite settings from the comamndline */
     
    229229        switch( c ) {
    230230            case 'a': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_WHITELIST, optarg );
    231                       tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, 1 );
    232                       break;
    233             case 'b': tr_bencDictAddInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, 1 );
    234                       break;
    235             case 'B': tr_bencDictAddInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, 0 );
     231                      tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, TRUE );
     232                      break;
     233            case 'b': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, TRUE );
     234                      break;
     235            case 'B': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
    236236                      break;
    237237            case 'c': tr_bencDictAddStr( &settings, PREF_KEY_DIR_WATCH, optarg );
    238                       tr_bencDictAddInt( &settings, PREF_KEY_DIR_WATCH_ENABLED, 1 );
    239                       break;
    240             case 'C': tr_bencDictAddInt( &settings, PREF_KEY_DIR_WATCH_ENABLED, 0 );
     238                      tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, TRUE );
     239                      break;
     240            case 'C': tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
    241241                      break;
    242242            case 'd': dumpSettings = TRUE;
     
    251251            case 'p': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_PORT, atoi( optarg ) );
    252252                      break;
    253             case 't': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, 1 );
    254                       break;
    255             case 'T': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, 0 );
     253            case 't': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, TRUE );
     254                      break;
     255            case 'T': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, FALSE );
    256256                      break;
    257257            case 'u': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_USERNAME, optarg );
     
    263263            case 'P': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_PORT, atoi( optarg ) );
    264264                      break;
    265             case 'm': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, 1 );
    266                       break;
    267             case 'M': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, 0 );
     265            case 'm': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
     266                      break;
     267            case 'M': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, FALSE );
    268268                      break;
    269269            case 'L': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi( optarg ) );
     
    302302    mySession = tr_sessionInit( "daemon", configDir, FALSE, &settings );
    303303
    304     if( tr_bencDictFindInt( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &i ) && i!=0 )
     304    if( tr_bencDictFindBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal ) && boolVal )
    305305        tr_ninf( MY_NAME, "requiring authentication" );
    306306
    307307    /* maybe add a watchdir */
    308308    {
    309         int64_t doWatch;
    310309        const char * dir;
    311310
    312         if( tr_bencDictFindInt( &settings, PREF_KEY_DIR_WATCH_ENABLED, &doWatch )
    313             && doWatch
     311        if( tr_bencDictFindBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal )
     312            && boolVal
    314313            && tr_bencDictFindStr( &settings, PREF_KEY_DIR_WATCH, &dir )
    315314            && dir
  • trunk/daemon/remote.c

    r8095 r8108  
    346346                tr_bencDictAddStr( &top, "method", "session-set" );
    347347                tr_bencDictAddInt( args, "speed-limit-down", numarg( optarg ) );
    348                 tr_bencDictAddInt( args, "speed-limit-down-enabled", 1 );
     348                tr_bencDictAddBool( args, "speed-limit-down-enabled", TRUE );
    349349                break;
    350350
    351351            case 'D':
    352352                tr_bencDictAddStr( &top, "method", "session-set" );
    353                 tr_bencDictAddInt( args, "speed-limit-down-enabled", 0 );
     353                tr_bencDictAddBool( args, "speed-limit-down-enabled", FALSE );
    354354                break;
    355355
     
    397397            case 'm':
    398398                tr_bencDictAddStr( &top, "method", "session-set" );
    399                 tr_bencDictAddInt( args, "port-forwarding-enabled", 1 );
     399                tr_bencDictAddBool( args, "port-forwarding-enabled", TRUE );
    400400                break;
    401401
    402402            case 'M':
    403403                tr_bencDictAddStr( &top, "method", "session-set" );
    404                 tr_bencDictAddInt( args, "port-forwarding-enabled", 0 );
     404                tr_bencDictAddBool( args, "port-forwarding-enabled", FALSE );
    405405                break;
    406406
     
    428428                tr_bencDictAddStr( &top, "method", "torrent-remove" );
    429429                addIdArg( args, id );
    430                 tr_bencDictAddInt( args, "delete-local-data", 1 );
     430                tr_bencDictAddBool( args, "delete-local-data", TRUE );
    431431                break;
    432432
     
    449449                tr_bencDictAddStr( &top, "method", "session-set" );
    450450                tr_bencDictAddInt( args, "speed-limit-up", numarg( optarg ) );
    451                 tr_bencDictAddInt( args, "speed-limit-up-enabled", 1 );
     451                tr_bencDictAddBool( args, "speed-limit-up-enabled", TRUE );
    452452                break;
    453453
    454454            case 'U':
    455455                tr_bencDictAddStr( &top, "method", "session-set" );
    456                 tr_bencDictAddInt( args, "speed-limit-up-enabled", 0 );
     456                tr_bencDictAddBool( args, "speed-limit-up-enabled", FALSE );
    457457                break;
    458458
     
    477477            case 'x':
    478478                tr_bencDictAddStr( &top, "method", "session-set" );
    479                 tr_bencDictAddInt( args, TR_PREFS_KEY_PEX_ENABLED, 1 );
     479                tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, TRUE );
    480480                break;
    481481
    482482            case 'X':
    483483                tr_bencDictAddStr( &top, "method", "session-set" );
    484                 tr_bencDictAddInt( args, TR_PREFS_KEY_PEX_ENABLED, 0 );
     484                tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, FALSE );
    485485                break;
    486486
     
    544544            case 950:
    545545                tr_bencDictAddStr( &top, "method", "torrent-set" );
    546                 tr_bencDictAddDouble( args, "ratio-limit", atof(optarg) );
     546                tr_bencDictAddReal( args, "ratio-limit", atof(optarg) );
    547547                tr_bencDictAddInt( args, "ratio-limit-mode", TR_RATIOLIMIT_SINGLE );
    548548                addIdArg( args, id );
     
    563563            case 953:
    564564                tr_bencDictAddStr( &top, "method", "session-set" );
    565                 tr_bencDictAddDouble( args, "ratio-limit", atof(optarg) );
    566                 tr_bencDictAddInt( args, "ratio-limit-enabled", 1 );
     565                tr_bencDictAddReal( args, "ratio-limit", atof(optarg) );
     566                tr_bencDictAddBool( args, "ratio-limit-enabled", TRUE );
    567567                break;
    568568
    569569            case 954:
    570570                tr_bencDictAddStr( &top, "method", "session-set" );
    571                 tr_bencDictAddInt( args, "ratio-limit-enabled", 0 );
     571                tr_bencDictAddBool( args, "ratio-limit-enabled", FALSE );
    572572                break;
    573573
     
    596596/* [host:port] or [host] or [port] */
    597597static void
    598 getHostAndPort( int *   argc,
    599                 char ** argv,
    600                 char ** host,
    601                 int *   port )
     598getHostAndPort( int * argc, char ** argv, char ** host, int * port )
    602599{
    603600    if( *argv[1] != '-' )
     
    733730                             : "Verifying";
    734731            double percent;
    735             if( tr_bencDictFindDouble( t, "recheckProgress", &percent ) )
     732            if( tr_bencDictFindReal( t, "recheckProgress", &percent ) )
    736733                tr_snprintf( buf, buflen, "%s (%.0f%%)", str, percent*100.0 );
    737734            else
     
    788785        const char * str;
    789786        int64_t      i;
     787        tr_bool      boolVal;
    790788
    791789        printf( "VERSION\n" );
     
    803801        if( tr_bencDictFindInt( args, "port", &i ) )
    804802            printf( "  Listenport: %" PRId64 "\n", i );
    805         if( tr_bencDictFindInt( args, "port-forwarding-enabled", &i ) )
    806             printf( "  Portforwarding enabled: %s\n", ( i ? "Yes" : "No" ) );
    807         if( tr_bencDictFindInt( args, "pex-allowed", &i ) )
    808             printf( "  Peer exchange allowed: %s\n", ( i ? "Yes" : "No" ) );
     803        if( tr_bencDictFindBool( args, "port-forwarding-enabled", &boolVal ) )
     804            printf( "  Portforwarding enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
     805        if( tr_bencDictFindBool( args, "pex-allowed", &boolVal ) )
     806            printf( "  Peer exchange allowed: %s\n", ( boolVal ? "Yes" : "No" ) );
    809807        if( tr_bencDictFindStr( args,  "encryption", &str ) )
    810808            printf( "  Encryption: %s\n", str );
     
    814812        if( tr_bencDictFindInt( args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &i ) )
    815813            printf( "  Peer limit: %" PRId64 "\n", i );
    816         if( tr_bencDictFindInt( args, "speed-limit-down-enabled", &i ) )
    817             printf( "  Downloadlimit enabled: %s\n", ( i ? "Yes" : "No" ) );
     814        if( tr_bencDictFindBool( args, "speed-limit-down-enabled", &boolVal ) )
     815            printf( "  Downloadlimit enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
    818816        if( tr_bencDictFindInt( args, "speed-limit-down", &i ) )
    819817            printf( "  Downloadlimit: %6" PRId64 " KB/sec\n", i );
    820         if( tr_bencDictFindInt( args, "speed-limit-up-enabled", &i ) )
    821             printf( "  Uploadlimit enabled:   %s\n", ( i ? "Yes" : "No" ) );
     818        if( tr_bencDictFindBool( args, "speed-limit-up-enabled", &boolVal ) )
     819            printf( "  Uploadlimit enabled:   %s\n", ( boolVal ? "Yes" : "No" ) );
    822820        if( tr_bencDictFindInt( args, "speed-limit-up", &i ) )
    823821            printf( "  Uploadlimit:   %6" PRId64 " KB/sec\n", i );
     
    846844            int64_t      i, j, k;
    847845            tr_bool      isStopped;
     846            tr_bool      boolVal;
    848847
    849848            isStopped = tr_bencDictFindInt( t, "status", &i ) && (i==TR_STATUS_STOPPED);
     
    990989                printf( "  Date created: %s", ctime( &tt ) );
    991990            }
    992             if( tr_bencDictFindInt( t, "isPrivate", &i ) )
    993                 printf( "  Public torrent: %s\n", ( i ? "No" : "Yes" ) );
     991            if( tr_bencDictFindBool( t, "isPrivate", &boolVal ) )
     992                printf( "  Public torrent: %s\n", ( boolVal ? "No" : "Yes" ) );
    994993            if( tr_bencDictFindStr( t, "comment", &str ) && str && *str )
    995994                printf( "  Comment: %s\n", str );
     
    11051104        if( tr_bencDictFindStr( d, "address", &address )
    11061105          && tr_bencDictFindStr( d, "clientName", &client )
    1107           && tr_bencDictFindDouble( d, "progress", &progress )
     1106          && tr_bencDictFindReal( d, "progress", &progress )
    11081107          && tr_bencDictFindStr( d, "flagStr", &flagstr )
    11091108          && tr_bencDictFindInt( d, "rateToClient", &rateToClient )
     
    11721171              && tr_bencDictFindInt( d, "sizeWhenDone", &sizeWhenDone )
    11731172              && tr_bencDictFindInt( d, "status", &status )
    1174               && tr_bencDictFindDouble( d, "uploadRatio", &ratio ) )
     1173              && tr_bencDictFindReal( d, "uploadRatio", &ratio ) )
    11751174            {
    11761175                char etaStr[16];
  • trunk/gtk/conf.c

    r8088 r8108  
    164164    if( !str ) str = tr_getDefaultDownloadDir( );
    165165    tr_bencDictAddStr( d, PREF_KEY_DIR_WATCH, str );
    166     tr_bencDictAddInt( d, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
     166    tr_bencDictAddBool( d, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
    167167#endif
    168168
    169     tr_bencDictAddInt( d, PREF_KEY_INHIBIT_HIBERNATION, FALSE );
    170     tr_bencDictAddInt( d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
     169    tr_bencDictAddBool( d, PREF_KEY_INHIBIT_HIBERNATION, FALSE );
     170    tr_bencDictAddBool( d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE );
    171171
    172172    tr_bencDictAddStr( d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir( ) );
    173173
    174     tr_bencDictAddInt( d, PREF_KEY_TOOLBAR, TRUE );
    175     tr_bencDictAddInt( d, PREF_KEY_FILTERBAR, TRUE );
    176     tr_bencDictAddInt( d, PREF_KEY_STATUSBAR, TRUE );
    177     tr_bencDictAddInt( d, PREF_KEY_SHOW_TRAY_ICON, FALSE );
    178     tr_bencDictAddInt( d, PREF_KEY_SHOW_DESKTOP_NOTIFICATION, TRUE );
     174    tr_bencDictAddBool( d, PREF_KEY_TOOLBAR, TRUE );
     175    tr_bencDictAddBool( d, PREF_KEY_FILTERBAR, TRUE );
     176    tr_bencDictAddBool( d, PREF_KEY_STATUSBAR, TRUE );
     177    tr_bencDictAddBool( d, PREF_KEY_SHOW_TRAY_ICON, FALSE );
     178    tr_bencDictAddBool( d, PREF_KEY_SHOW_DESKTOP_NOTIFICATION, TRUE );
    179179    tr_bencDictAddStr( d, PREF_KEY_STATUSBAR_STATS, "total-ratio" );
    180180
    181     tr_bencDictAddInt( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
     181    tr_bencDictAddBool( d, PREF_KEY_OPTIONS_PROMPT, TRUE );
    182182
    183183    tr_bencDictAddInt( d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500 );
     
    194194    tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, str );
    195195
    196     tr_bencDictAddInt( d, PREF_KEY_ASKQUIT, TRUE );
     196    tr_bencDictAddBool( d, PREF_KEY_ASKQUIT, TRUE );
    197197
    198198    tr_bencDictAddStr( d, PREF_KEY_SORT_MODE, "sort-by-name" );
    199     tr_bencDictAddInt( d, PREF_KEY_SORT_REVERSED, FALSE );
    200     tr_bencDictAddInt( d, PREF_KEY_MINIMAL_VIEW, FALSE );
    201 
    202     tr_bencDictAddInt( d, PREF_KEY_START, TRUE );
    203     tr_bencDictAddInt( d, PREF_KEY_TRASH_ORIGINAL, FALSE );
     199    tr_bencDictAddBool( d, PREF_KEY_SORT_REVERSED, FALSE );
     200    tr_bencDictAddBool( d, PREF_KEY_MINIMAL_VIEW, FALSE );
     201
     202    tr_bencDictAddBool( d, PREF_KEY_START, TRUE );
     203    tr_bencDictAddBool( d, PREF_KEY_TRASH_ORIGINAL, FALSE );
    204204}
    205205
     
    259259    double d = 0.0;
    260260
    261     tr_bencDictFindDouble( getPrefs( ), key, &d );
     261    tr_bencDictFindReal( getPrefs( ), key, &d );
    262262    return d;
    263263}
     
    267267                 double       value )
    268268{
    269     tr_bencDictAddDouble( getPrefs( ), key, value );
     269    tr_bencDictAddReal( getPrefs( ), key, value );
    270270}
    271271
  • trunk/libtransmission/bencode-test.c

    r7783 r8108  
    453453}
    454454
     455static int
     456testBool( void )
     457{
     458    tr_benc top;
     459    int64_t intVal;
     460    tr_bool boolVal;
     461
     462    tr_bencInitDict( &top, 0 );
     463
     464    tr_bencDictAddBool( &top, "key1", FALSE );
     465    tr_bencDictAddBool( &top, "key2", 0 );
     466    tr_bencDictAddInt ( &top, "key3", TRUE );
     467    tr_bencDictAddInt ( &top, "key4", 1 );
     468    check( tr_bencDictFindBool( &top, "key1", &boolVal ) )
     469    check( !boolVal )
     470    check( tr_bencDictFindBool( &top, "key2", &boolVal ) )
     471    check( !boolVal )
     472    check( tr_bencDictFindBool( &top, "key3", &boolVal ) )
     473    check( boolVal )
     474    check( tr_bencDictFindBool( &top, "key4", &boolVal ) )
     475    check( boolVal )
     476    check( tr_bencDictFindInt( &top, "key1", &intVal ) )
     477    check( !intVal)
     478    check( tr_bencDictFindInt( &top, "key2", &intVal ) )
     479    check( !intVal )
     480    check( tr_bencDictFindInt( &top, "key3", &intVal ) )
     481    check( intVal )
     482    check( tr_bencDictFindInt( &top, "key4", &intVal ) )
     483    check( intVal )
     484
     485    return 0;
     486}
     487
    455488int
    456489main( void )
     
    471504
    472505    if(( i = testMerge( )))
     506        return i;
     507
     508    if(( i = testBool( )))
    473509        return i;
    474510
  • trunk/libtransmission/bencode.c

    r8105 r8108  
    449449tr_bencDictFindBool( tr_benc * dict, const char * key, tr_bool * setme )
    450450{
    451     int64_t i = 0;
     451    int64_t i = -1;
    452452    const tr_bool found = tr_bencDictFindInt( dict, key, &i );
    453     *setme = i!=0;
     453    if( found ) {
     454        assert( i==0 || i==1 );
     455        *setme = i!=0;
     456    }
    454457    return found;
    455458}
    456459
    457460tr_bool
    458 tr_bencDictFindDouble( tr_benc * dict, const char * key, double * setme )
     461tr_bencDictFindReal( tr_benc * dict, const char * key, double * setme )
    459462{
    460463    const char * str;
     
    743746
    744747tr_benc*
    745 tr_bencDictAddDouble( tr_benc *    dict,
    746                       const char * key,
    747                       double       d )
     748tr_bencDictAddReal( tr_benc * dict, const char * key, double d )
    748749{
    749750    char buf[128];
  • trunk/libtransmission/bencode.h

    r8105 r8108  
    127127tr_benc * tr_bencDictAdd( tr_benc *, const char * key );
    128128
    129 tr_benc * tr_bencDictAddDouble( tr_benc *, const char * key, double );
     129tr_benc * tr_bencDictAddReal( tr_benc *, const char * key, double );
    130130
    131131tr_benc * tr_bencDictAddInt( tr_benc *, const char * key, int64_t );
     
    150150tr_bool   tr_bencDictFindInt( tr_benc *, const char * key, int64_t * setme );
    151151
    152 tr_bool   tr_bencDictFindDouble( tr_benc *, const char * key, double * setme );
     152tr_bool   tr_bencDictFindReal( tr_benc *, const char * key, double * setme );
    153153
    154154tr_bool   tr_bencDictFindBool( tr_benc *, const char * key, tr_bool * setme );
  • trunk/libtransmission/resume.c

    r8097 r8108  
    253253    tr_bencDictReserve( d, 3 );
    254254    tr_bencDictAddInt( d, KEY_SPEED, tr_torrentGetSpeedLimit( tor, dir ) );
    255     tr_bencDictAddInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits( tor ) );
    256     tr_bencDictAddInt( d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit( tor, dir ) );
     255    tr_bencDictAddBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits( tor ) );
     256    tr_bencDictAddBool( d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit( tor, dir ) );
    257257}
    258258
     
    267267saveRatioLimits( tr_benc * dict, const tr_torrent * tor )
    268268{
    269     tr_benc * d = tr_bencDictAddDict( dict, KEY_RATIOLIMIT, 4 );
    270 
    271     tr_bencDictAddDouble( d, KEY_RATIOLIMIT_RATIO,
    272                       tr_torrentGetRatioLimit( tor ) );
    273     tr_bencDictAddInt( d, KEY_RATIOLIMIT_MODE,
    274                       tr_torrentGetRatioMode( tor ) );
     269    tr_benc * d = tr_bencDictAddDict( dict, KEY_RATIOLIMIT, 2 );
     270    tr_bencDictAddReal( d, KEY_RATIOLIMIT_RATIO, tr_torrentGetRatioLimit( tor ) );
     271    tr_bencDictAddInt( d, KEY_RATIOLIMIT_MODE, tr_torrentGetRatioMode( tor ) );
    275272}
    276273
     
    279276{
    280277    int64_t i;
     278    tr_bool boolVal;
     279
    281280    if( tr_bencDictFindInt( d, KEY_SPEED, &i ) )
    282281        tr_torrentSetSpeedLimit( tor, dir, i );
    283     if( tr_bencDictFindInt( d, KEY_USE_SPEED_LIMIT, &i ) )
    284         tr_torrentUseSpeedLimit( tor, dir, i!=0 );
    285     if( tr_bencDictFindInt( d, KEY_USE_GLOBAL_SPEED_LIMIT, &i ) )
    286         tr_torrentUseSessionLimits( tor, i!=0 );
     282
     283    if( tr_bencDictFindBool( d, KEY_USE_SPEED_LIMIT, &boolVal ) )
     284        tr_torrentUseSpeedLimit( tor, dir, boolVal );
     285
     286    if( tr_bencDictFindBool( d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal ) )
     287        tr_torrentUseSessionLimits( tor, boolVal );
    287288}
    288289
     
    344345        int64_t i;
    345346        double dratio;
    346           if( tr_bencDictFindDouble( d, KEY_RATIOLIMIT_RATIO, &dratio ) )
     347        if( tr_bencDictFindReal( d, KEY_RATIOLIMIT_RATIO, &dratio ) )
    347348            tr_torrentSetRatioLimit( tor, dratio );
    348349        if( tr_bencDictFindInt( d, KEY_RATIOLIMIT_MODE, &i ) )
     
    502503    tr_bencDictAddInt( &top, KEY_MAX_PEERS,
    503504                       tor->maxConnectedPeers );
    504     tr_bencDictAddInt( &top, KEY_PAUSED,
    505                        tor->isRunning ? 0 : 1 );
     505    tr_bencDictAddBool( &top, KEY_PAUSED, tor->isRunning!=0 );
    506506    savePeers( &top, tor );
    507507    savePriorities( &top, tor );
     
    527527    char *       filename;
    528528    tr_benc      top;
     529    tr_bool      boolVal;
    529530
    530531    filename = getResumeFilename( tor );
     
    587588
    588589    if( ( fieldsToLoad & TR_FR_RUN )
    589       && tr_bencDictFindInt( &top, KEY_PAUSED, &i ) )
    590     {
    591         tor->isRunning = i ? 0 : 1;
     590      && tr_bencDictFindBool( &top, KEY_PAUSED, &boolVal ) )
     591    {
     592        tor->isRunning = !boolVal;
    592593        fieldsLoaded |= TR_FR_RUN;
    593594    }
  • trunk/libtransmission/rpc-server.c

    r8081 r8108  
    173173                        b64 = tr_base64_encode( body, body_len, NULL );
    174174                        tr_bencDictAddStr( args, "metainfo", b64 );
    175                         tr_bencDictAddInt( args, "paused", paused );
     175                        tr_bencDictAddBool( args, "paused", paused );
    176176                        tr_bencSaveAsJSON( &top, json );
    177177                        tr_rpc_request_exec_json( server->session,
     
    737737    tr_rpc_server * s;
    738738    tr_bool found;
     739    tr_bool boolVal;
    739740    int64_t i;
    740741    const char *str;
     
    743744    s->session = session;
    744745
    745     found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_ENABLED, &i );
     746    found = tr_bencDictFindBool( settings, TR_PREFS_KEY_RPC_ENABLED, &boolVal );
    746747    assert( found );
    747     s->isEnabled = i != 0;
     748    s->isEnabled = boolVal;
    748749
    749750    found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_PORT, &i );
     
    751752    s->port = i;
    752753
    753     found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, &i );
     754    found = tr_bencDictFindBool( settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, &boolVal );
    754755    assert( found );
    755     s->isWhitelistEnabled = i != 0;
    756 
    757     found = tr_bencDictFindInt( settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &i );
     756    s->isWhitelistEnabled = boolVal;
     757
     758    found = tr_bencDictFindBool( settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal );
    758759    assert( found );
    759     s->isPasswordEnabled = i != 0;
     760    s->isPasswordEnabled = boolVal;
    760761
    761762    found = tr_bencDictFindStr( settings, TR_PREFS_KEY_RPC_WHITELIST, &str );
  • trunk/libtransmission/rpcimpl.c

    r8105 r8108  
    227227        tr_torrent * tor = torrents[i];
    228228        const tr_rpc_callback_status status = notify( session, TR_RPC_TORRENT_REMOVING, tor );
    229         int64_t deleteFlag;
    230         if( tr_bencDictFindInt( args_in, "delete-local-data", &deleteFlag ) && deleteFlag )
     229        tr_bool deleteFlag;
     230        if( tr_bencDictFindBool( args_in, "delete-local-data", &deleteFlag ) && deleteFlag )
    231231            tr_torrentDeleteLocalData( tor, NULL );
    232232        if( !( status & TR_RPC_NOREMOVE ) )
     
    350350        tr_benc *            d = tr_bencListAddDict( list, 14 );
    351351        const tr_peer_stat * peer = peers + i;
    352         tr_bencDictAddStr( d, "address", peer->addr );
    353         tr_bencDictAddStr( d, "clientName", peer->client );
    354         tr_bencDictAddInt( d, "clientIsChoked", peer->clientIsChoked );
    355         tr_bencDictAddInt( d, "clientIsInterested",
    356                            peer->clientIsInterested );
    357         tr_bencDictAddStr( d, "flagStr", peer->flagStr );
    358         tr_bencDictAddInt( d, "isDownloadingFrom", peer->isDownloadingFrom );
    359         tr_bencDictAddInt( d, "isEncrypted", peer->isEncrypted );
    360         tr_bencDictAddInt( d, "isIncoming", peer->isIncoming );
    361         tr_bencDictAddInt( d, "isUploadingTo", peer->isUploadingTo );
    362         tr_bencDictAddInt( d, "peerIsChoked", peer->peerIsChoked );
    363         tr_bencDictAddInt( d, "peerIsInterested", peer->peerIsInterested );
    364         tr_bencDictAddInt( d, "port", peer->port );
    365         tr_bencDictAddDouble( d, "progress", peer->progress );
    366         tr_bencDictAddInt( d, "rateToClient",
    367                           (int)( peer->rateToClient * 1024.0 ) );
    368         tr_bencDictAddInt( d, "rateToPeer",
    369                           (int)( peer->rateToPeer * 1024.0 ) );
     352        tr_bencDictAddStr ( d, "address", peer->addr );
     353        tr_bencDictAddStr ( d, "clientName", peer->client );
     354        tr_bencDictAddBool( d, "clientIsChoked", peer->clientIsChoked );
     355        tr_bencDictAddBool( d, "clientIsInterested", peer->clientIsInterested );
     356        tr_bencDictAddStr ( d, "flagStr", peer->flagStr );
     357        tr_bencDictAddBool( d, "isDownloadingFrom", peer->isDownloadingFrom );
     358        tr_bencDictAddBool( d, "isEncrypted", peer->isEncrypted );
     359        tr_bencDictAddBool( d, "isIncoming", peer->isIncoming );
     360        tr_bencDictAddBool( d, "isUploadingTo", peer->isUploadingTo );
     361        tr_bencDictAddBool( d, "peerIsChoked", peer->peerIsChoked );
     362        tr_bencDictAddBool( d, "peerIsInterested", peer->peerIsInterested );
     363        tr_bencDictAddInt ( d, "port", peer->port );
     364        tr_bencDictAddReal( d, "progress", peer->progress );
     365        tr_bencDictAddInt ( d, "rateToClient", (int)( peer->rateToClient * 1024.0 ) );
     366        tr_bencDictAddInt ( d, "rateToPeer", (int)( peer->rateToPeer * 1024.0 ) );
    370367    }
    371368
     
    410407        tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit( tor, TR_DOWN ) );
    411408    else if( !strcmp( key, "downloadLimited" ) )
    412         tr_bencDictAddInt( d, key, tr_torrentUsesSpeedLimit( tor, TR_DOWN ) );
     409        tr_bencDictAddBool( d, key, tr_torrentUsesSpeedLimit( tor, TR_DOWN ) );
    413410    else if( !strcmp( key, "error" ) )
    414411        tr_bencDictAddInt( d, key, st->error );
     
    426423        tr_bencDictAddInt( d, key, st->haveValid );
    427424    else if( !strcmp( key, "honorsSessionLimits" ) )
    428         tr_bencDictAddInt( d, key, tr_torrentUsesSessionLimits( tor ) );
     425        tr_bencDictAddBool( d, key, tr_torrentUsesSessionLimits( tor ) );
    429426    else if( !strcmp( key, "id" ) )
    430427        tr_bencDictAddInt( d, key, st->id );
    431428    else if( !strcmp( key, "isPrivate" ) )
    432         tr_bencDictAddInt( d, key, tr_torrentIsPrivate( tor ) );
     429        tr_bencDictAddBool( d, key, tr_torrentIsPrivate( tor ) );
    433430    else if( !strcmp( key, "lastAnnounceTime" ) )
    434431        tr_bencDictAddInt( d, key, st->lastAnnounceTime );
     
    492489        tr_bencDictAddInt( d, key, (int)( st->pieceUploadSpeed * 1024 ) );
    493490    else if( !strcmp( key, "ratio" ) )
    494         tr_bencDictAddDouble( d, key, st->ratio );
     491        tr_bencDictAddReal( d, key, st->ratio );
    495492    else if( !strcmp( key, "recheckProgress" ) )
    496         tr_bencDictAddDouble( d, key, st->recheckProgress );
     493        tr_bencDictAddReal( d, key, st->recheckProgress );
    497494    else if( !strcmp( key, "scrapeResponse" ) )
    498495        tr_bencDictAddStr( d, key, st->scrapeResponse );
     
    502499        tr_bencDictAddInt( d, key, st->seeders );
    503500    else if( !strcmp( key, "seedRatioLimit" ) )
    504         tr_bencDictAddDouble( d, key, tr_torrentGetRatioLimit( tor ) );
     501        tr_bencDictAddReal( d, key, tr_torrentGetRatioLimit( tor ) );
    505502    else if( !strcmp( key, "seedRatioMode" ) )
    506503        tr_bencDictAddInt( d, key, tr_torrentGetRatioMode( tor ) );
     
    522519        tr_bencDictAddInt( d, key, st->uploadedEver );
    523520    else if( !strcmp( key, "uploadRatio" ) )
    524         tr_bencDictAddDouble( d, key, tr_getRatio( st->uploadedEver, st->downloadedEver ) );
     521        tr_bencDictAddReal( d, key, tr_getRatio( st->uploadedEver, st->downloadedEver ) );
    525522    else if( !strcmp( key, "uploadLimit" ) )
    526523        tr_bencDictAddInt( d, key, tr_torrentGetSpeedLimit( tor, TR_UP ) );
    527524    else if( !strcmp( key, "uploadLimited" ) )
    528         tr_bencDictAddInt( d, key, tr_torrentUsesSpeedLimit( tor, TR_UP ) );
     525        tr_bencDictAddBool( d, key, tr_torrentUsesSpeedLimit( tor, TR_UP ) );
    529526    else if( !strcmp( key, "wanted" ) )
    530527    {
     
    676673        double       d;
    677674        tr_benc *    files;
     675        tr_bool      boolVal;
    678676        tr_torrent * tor = torrents[i];
    679677
     
    692690        if( tr_bencDictFindInt( args_in, "downloadLimit", &tmp ) )
    693691            tr_torrentSetSpeedLimit( tor, TR_DOWN, tmp );
    694         if( tr_bencDictFindInt( args_in, "downloadLimited", &tmp ) )
    695             tr_torrentUseSpeedLimit( tor, TR_DOWN, tmp!=0 );
    696         if( tr_bencDictFindInt( args_in, "honorsSessionLimits", &tmp ) )
    697             tr_torrentUseSessionLimits( tor, tmp!=0 );
     692        if( tr_bencDictFindBool( args_in, "downloadLimited", &boolVal ) )
     693            tr_torrentUseSpeedLimit( tor, TR_DOWN, boolVal );
     694        if( tr_bencDictFindBool( args_in, "honorsSessionLimits", &boolVal ) )
     695            tr_torrentUseSessionLimits( tor, boolVal );
    698696        if( tr_bencDictFindInt( args_in, "uploadLimit", &tmp ) )
    699697            tr_torrentSetSpeedLimit( tor, TR_UP, tmp );
    700         if( tr_bencDictFindInt( args_in, "uploadLimited", &tmp ) )
    701             tr_torrentUseSpeedLimit( tor, TR_UP, tmp!=0 );
    702         if( tr_bencDictFindDouble( args_in, "ratio-limit", &d ) )
     698        if( tr_bencDictFindBool( args_in, "uploadLimited", &boolVal ) )
     699            tr_torrentUseSpeedLimit( tor, TR_UP, boolVal );
     700        if( tr_bencDictFindReal( args_in, "ratio-limit", &d ) )
    703701            tr_torrentSetRatioLimit( tor, d );
    704702        if( tr_bencDictFindInt( args_in, "ratio-limit-mode", &tmp ) )
    705703            tr_torrentSetRatioMode( tor, tmp );
    706         if( tr_bencDictFindDouble( args_in, "seedRatioLimit", &d ) )
     704        if( tr_bencDictFindReal( args_in, "seedRatioLimit", &d ) )
    707705            tr_torrentSetRatioLimit( tor, d );
    708706        if( tr_bencDictFindInt( args_in, "seedRatioMode", &tmp ) )
     
    815813    {
    816814        int64_t      i;
     815        tr_bool      boolVal;
    817816        const char * str;
    818817        tr_ctor    * ctor = tr_ctorNew( session );
     
    821820        if( tr_bencDictFindStr( args_in, "download-dir", &str ) )
    822821            tr_ctorSetDownloadDir( ctor, TR_FORCE, str );
    823         if( tr_bencDictFindInt( args_in, "paused", &i ) )
    824             tr_ctorSetPaused( ctor, TR_FORCE, i );
     822        if( tr_bencDictFindBool( args_in, "paused", &boolVal ) )
     823            tr_ctorSetPaused( ctor, TR_FORCE, boolVal );
    825824        if( tr_bencDictFindInt( args_in, "peer-limit", &i ) )
    826825            tr_ctorSetPeerLimit( ctor, TR_FORCE, i );
     
    863862            struct tr_rpc_idle_data  * idle_data )
    864863{
    865     tr_bool      b;
    866864    int64_t      i;
    867865    double       d;
     866    tr_bool      boolVal;
    868867    const char * str;
    869868
     
    874873    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_DOWN, &i ) )
    875874        tr_sessionSetAltSpeed( session, TR_DOWN, i );
    876     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_ENABLED, &i ) )
    877         tr_sessionUseAltSpeed( session, i!=0 );
     875    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal ) )
     876        tr_sessionUseAltSpeed( session, boolVal );
    878877    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &i ) )
    879878        tr_sessionSetAltSpeedBegin( session, i );
    880879    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_END, &i ) )
    881880        tr_sessionSetAltSpeedEnd( session, i );
    882     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &i ) )
    883         tr_sessionUseAltSpeedTime( session, i!=0 );
    884     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i ) )
    885         tr_blocklistSetEnabled( session, i!=0 );
     881    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal ) )
     882        tr_sessionUseAltSpeedTime( session, boolVal );
     883    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal ) )
     884        tr_blocklistSetEnabled( session, boolVal );
    886885    if( tr_bencDictFindStr( args_in, TR_PREFS_KEY_DOWNLOAD_DIR, &str ) )
    887886        tr_sessionSetDownloadDir( session, str );
     
    890889    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_LIMIT_TORRENT, &i ) )
    891890        tr_sessionSetPeerLimitPerTorrent( session, i );
    892     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEX_ENABLED, &i ) )
    893         tr_sessionSetPexEnabled( session, i );
     891    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_PEX_ENABLED, &boolVal ) )
     892        tr_sessionSetPexEnabled( session, boolVal );
    894893    if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PEER_PORT, &i ) )
    895894        tr_sessionSetPeerPort( session, i );
    896     if( tr_bencDictFindInt( args_in, TR_PREFS_KEY_PORT_FORWARDING, &i ) )
    897         tr_sessionSetPortForwardingEnabled( session, i );
    898     if( tr_bencDictFindDouble( args_in, "seedRatioLimit", &d ) )
     895    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_PORT_FORWARDING, &boolVal ) )
     896        tr_sessionSetPortForwardingEnabled( session, boolVal );
     897    if( tr_bencDictFindReal( args_in, "seedRatioLimit", &d ) )
    899898        tr_sessionSetRatioLimit( session, d );
    900     if( tr_bencDictFindBool( args_in, "seedRatioLimited", &b ) )
    901         tr_sessionSetRatioLimited( session, b );
     899    if( tr_bencDictFindBool( args_in, "seedRatioLimited", &boolVal ) )
     900        tr_sessionSetRatioLimited( session, boolVal );
    902901    if( tr_bencDictFindInt( args_in, "speed-limit-down", &i ) )
    903902        tr_sessionSetSpeedLimit( session, TR_DOWN, i );
    904     if( tr_bencDictFindInt( args_in, "speed-limit-down-enabled", &i ) )
    905         tr_sessionLimitSpeed( session, TR_DOWN, i!=0 );
     903    if( tr_bencDictFindBool( args_in, "speed-limit-down-enabled", &boolVal ) )
     904        tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
    906905    if( tr_bencDictFindInt( args_in, "speed-limit-up", &i ) )
    907906        tr_sessionSetSpeedLimit( session, TR_UP, i );
    908     if( tr_bencDictFindInt( args_in, "speed-limit-up-enabled", &i ) )
    909         tr_sessionLimitSpeed( session, TR_UP, i!=0 );
    910     if( tr_bencDictFindDouble( args_in, "ratio-limit", &d ) )
     907    if( tr_bencDictFindBool( args_in, "speed-limit-up-enabled", &boolVal ) )
     908        tr_sessionLimitSpeed( session, TR_UP, boolVal );
     909    if( tr_bencDictFindReal( args_in, "ratio-limit", &d ) )
    911910        tr_sessionSetRatioLimit( session, d );
    912     if( tr_bencDictFindInt( args_in, "ratio-limit-enabled", &i ) )
    913         tr_sessionSetRatioLimited( session, i!=0 );
    914     if( tr_bencDictFindStr( args_in, "encryption", &str ) )
    915     {
     911    if( tr_bencDictFindBool( args_in, "ratio-limit-enabled", &boolVal ) )
     912        tr_sessionSetRatioLimited( session, boolVal );
     913    if( tr_bencDictFindStr( args_in, "encryption", &str ) ) {
    916914        if( !strcmp( str, "required" ) )
    917915            tr_sessionSetEncryption( session, TR_ENCRYPTION_REQUIRED );
     
    984982
    985983    assert( idle_data == NULL );
    986     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed(s,TR_UP) );
    987     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed(s,TR_DOWN) );
    988     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed(s) );
    989     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin(s) );
    990     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,tr_sessionGetAltSpeedEnd(s) );
    991     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime(s) );
    992     tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
    993     tr_bencDictAddInt( d, "blocklist-size", tr_blocklistGetRuleCount( s ) );
    994     tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
    995     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
    996     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, tr_sessionGetPeerLimitPerTorrent( s ) );
    997     tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
    998     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
    999     tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
    1000     tr_bencDictAddInt( d, "rpc-version", 4 );
    1001     tr_bencDictAddInt( d, "rpc-version-minimum", 1 );
    1002     tr_bencDictAddDouble( d, "seedRatioLimit", tr_sessionGetRatioLimit( s ) );
     984    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP, tr_sessionGetAltSpeed(s,TR_UP) );
     985    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN, tr_sessionGetAltSpeed(s,TR_DOWN) );
     986    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed(s) );
     987    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, tr_sessionGetAltSpeedBegin(s) );
     988    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,tr_sessionGetAltSpeedEnd(s) );
     989    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, tr_sessionUsesAltSpeedTime(s) );
     990    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, tr_blocklistIsEnabled( s ) );
     991    tr_bencDictAddInt ( d, "blocklist-size", tr_blocklistGetRuleCount( s ) );
     992    tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
     993    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, tr_sessionGetPeerLimit( s ) );
     994    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT, tr_sessionGetPeerLimitPerTorrent( s ) );
     995    tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
     996    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
     997    tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
     998    tr_bencDictAddInt ( d, "rpc-version", 4 );
     999    tr_bencDictAddInt ( d, "rpc-version-minimum", 1 );
     1000    tr_bencDictAddReal( d, "seedRatioLimit", tr_sessionGetRatioLimit( s ) );
    10031001    tr_bencDictAddBool( d, "seedRatioLimited", tr_sessionIsRatioLimited( s ) );
    1004     tr_bencDictAddInt( d, "speed-limit-up", tr_sessionGetSpeedLimit( s, TR_UP ) );
    1005     tr_bencDictAddInt( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimited( s, TR_UP ) );
    1006     tr_bencDictAddInt( d, "speed-limit-down", tr_sessionGetSpeedLimit( s, TR_DOWN ) );
    1007     tr_bencDictAddInt( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimited( s, TR_DOWN ) );
    1008     tr_bencDictAddDouble( d, "ratio-limit", tr_sessionGetRatioLimit( s ) );
    1009     tr_bencDictAddInt( d, "ratio-limit-enabled", tr_sessionIsRatioLimited( s ) );
    1010     tr_bencDictAddStr( d, "version", LONG_VERSION_STRING );
     1002    tr_bencDictAddInt ( d, "speed-limit-up", tr_sessionGetSpeedLimit( s, TR_UP ) );
     1003    tr_bencDictAddBool( d, "speed-limit-up-enabled", tr_sessionIsSpeedLimited( s, TR_UP ) );
     1004    tr_bencDictAddInt ( d, "speed-limit-down", tr_sessionGetSpeedLimit( s, TR_DOWN ) );
     1005    tr_bencDictAddBool( d, "speed-limit-down-enabled", tr_sessionIsSpeedLimited( s, TR_DOWN ) );
     1006    tr_bencDictAddReal( d, "ratio-limit", tr_sessionGetRatioLimit( s ) );
     1007    tr_bencDictAddBool( d, "ratio-limit-enabled", tr_sessionIsRatioLimited( s ) );
     1008    tr_bencDictAddStr ( d, "version", LONG_VERSION_STRING );
    10111009    switch( tr_sessionGetEncryption( s ) ) {
    10121010        case TR_CLEAR_PREFERRED: str = "tolerated"; break;
  • trunk/libtransmission/session.c

    r8104 r8108  
    233233
    234234#ifdef TR_EMBEDDED
    235  #define TR_DEFAULT_ENCRYPTION              TR_CLEAR_PREFERRED
     235 #define TR_DEFAULT_ENCRYPTION   TR_CLEAR_PREFERRED
    236236#else
    237  #define TR_DEFAULT_ENCRYPTION              TR_ENCRYPTION_PREFERRED
     237 #define TR_DEFAULT_ENCRYPTION   TR_ENCRYPTION_PREFERRED
    238238#endif
    239239
     
    244244
    245245    tr_bencDictReserve( d, 35 );
    246     tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        FALSE );
    247     tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,             tr_getDefaultDownloadDir( ) );
    248     tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED,                   100 );
    249     tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED,           0 );
    250     tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION,               TR_DEFAULT_ENCRYPTION );
    251     tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD,            TRUE );
    252     tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL,                 TR_MSG_INF );
    253     tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT,          atoi( TR_DEFAULT_OPEN_FILE_LIMIT_STR ) );
    254     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        atoi( TR_DEFAULT_PEER_LIMIT_GLOBAL_STR ) );
    255     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       atoi( TR_DEFAULT_PEER_LIMIT_TORRENT_STR ) );
    256     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT,                atoi( TR_DEFAULT_PEER_PORT_STR ) );
    257     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, FALSE );
    258     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     1024 );
    259     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    65535 );
    260     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          atoi( TR_DEFAULT_PEER_SOCKET_TOS_STR ) );
    261     tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              TRUE );
    262     tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          TRUE );
    263     tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION,            TR_PREALLOCATE_SPARSE );
    264     tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    "" );
    265     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       FALSE );
    266     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED,            FALSE );
    267     tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD,           "" );
    268     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT,               80 );
    269     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE,               TR_PROXY_HTTP );
    270     tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME,           "" );
    271     tr_bencDictAddDouble( d, TR_PREFS_KEY_RATIO,                 2.0 );
    272     tr_bencDictAddInt( d, TR_PREFS_KEY_RATIO_ENABLED,            FALSE );
    273     tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        FALSE );
    274     tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED,              TRUE );
    275     tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD,             "" );
    276     tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME,             "" );
    277     tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST,            TR_DEFAULT_RPC_WHITELIST );
    278     tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    TRUE );
    279     tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,                 atoi( TR_DEFAULT_RPC_PORT_STR ) );
    280     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,        FALSE );
    281     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP,             50 ); /* half the regular */
    282     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN,           50 ); /* half the regular */
    283     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,     540 ); /* 9am */
    284     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,   FALSE );
    285     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,       1020 ); /* 5pm */
    286     tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   100 );
    287     tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           0 );
    288     tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, 14 );
     246    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        FALSE );
     247    tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,             tr_getDefaultDownloadDir( ) );
     248    tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED,                   100 );
     249    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,           FALSE );
     250    tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,               TR_DEFAULT_ENCRYPTION );
     251    tr_bencDictAddBool( d, TR_PREFS_KEY_LAZY_BITFIELD,            TRUE );
     252    tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL,                 TR_MSG_INF );
     253    tr_bencDictAddInt ( d, TR_PREFS_KEY_OPEN_FILE_LIMIT,          atoi( TR_DEFAULT_OPEN_FILE_LIMIT_STR ) );
     254    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        atoi( TR_DEFAULT_PEER_LIMIT_GLOBAL_STR ) );
     255    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       atoi( TR_DEFAULT_PEER_LIMIT_TORRENT_STR ) );
     256    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT,                atoi( TR_DEFAULT_PEER_PORT_STR ) );
     257    tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, FALSE );
     258    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     1024 );
     259    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    65535 );
     260    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          atoi( TR_DEFAULT_PEER_SOCKET_TOS_STR ) );
     261    tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED,              TRUE );
     262    tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING,          TRUE );
     263    tr_bencDictAddInt ( d, TR_PREFS_KEY_PREALLOCATION,            TR_PREALLOCATE_SPARSE );
     264    tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY,                    "" );
     265    tr_bencDictAddBool( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       FALSE );
     266    tr_bencDictAddBool( d, TR_PREFS_KEY_PROXY_ENABLED,            FALSE );
     267    tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY_PASSWORD,           "" );
     268    tr_bencDictAddInt ( d, TR_PREFS_KEY_PROXY_PORT,               80 );
     269    tr_bencDictAddInt ( d, TR_PREFS_KEY_PROXY_TYPE,               TR_PROXY_HTTP );
     270    tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY_USERNAME,           "" );
     271    tr_bencDictAddReal( d, TR_PREFS_KEY_RATIO,                    2.0 );
     272    tr_bencDictAddBool( d, TR_PREFS_KEY_RATIO_ENABLED,            FALSE );
     273    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        FALSE );
     274    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_ENABLED,              TRUE );
     275    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_PASSWORD,             "" );
     276    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_USERNAME,             "" );
     277    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_WHITELIST,            TR_DEFAULT_RPC_WHITELIST );
     278    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    TRUE );
     279    tr_bencDictAddInt ( d, TR_PREFS_KEY_RPC_PORT,                 atoi( TR_DEFAULT_RPC_PORT_STR ) );
     280    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,        FALSE );
     281    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP,             50 ); /* half the regular */
     282    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN,           50 ); /* half the regular */
     283    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,     540 ); /* 9am */
     284    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,   FALSE );
     285    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,       1020 ); /* 5pm */
     286    tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED,                   100 );
     287    tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED,           FALSE );
     288    tr_bencDictAddInt ( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, 14 );
    289289}
    290290
     
    298298
    299299    tr_bencDictReserve( d, 30 );
    300     tr_bencDictAddInt( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        tr_blocklistIsEnabled( s ) );
    301     tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR,             s->downloadDir );
    302     tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED,                   tr_sessionGetSpeedLimit( s, TR_DOWN ) );
    303     tr_bencDictAddInt( d, TR_PREFS_KEY_DSPEED_ENABLED,           tr_sessionIsSpeedLimited( s, TR_DOWN ) );
    304     tr_bencDictAddInt( d, TR_PREFS_KEY_ENCRYPTION,               s->encryptionMode );
    305     tr_bencDictAddInt( d, TR_PREFS_KEY_LAZY_BITFIELD,            s->useLazyBitfield );
    306     tr_bencDictAddInt( d, TR_PREFS_KEY_MSGLEVEL,                 tr_getMessageLevel( ) );
    307     tr_bencDictAddInt( d, TR_PREFS_KEY_OPEN_FILE_LIMIT,          s->openFileLimit );
    308     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        tr_sessionGetPeerLimit( s ) );
    309     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       s->peerLimitPerTorrent );
    310     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT,                tr_sessionGetPeerPort( s ) );
    311     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, s->isPortRandom );
    312     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     s->randomPortLow );
    313     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    s->randomPortHigh );
    314     tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          s->peerSocketTOS );
    315     tr_bencDictAddInt( d, TR_PREFS_KEY_PEX_ENABLED,              s->isPexEnabled );
    316     tr_bencDictAddInt( d, TR_PREFS_KEY_PORT_FORWARDING,          tr_sessionIsPortForwardingEnabled( s ) );
    317     tr_bencDictAddInt( d, TR_PREFS_KEY_PREALLOCATION,            s->preallocationMode );
    318     tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY,                    s->proxy );
    319     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       s->isProxyAuthEnabled );
    320     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_ENABLED,            s->isProxyEnabled );
    321     tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_PASSWORD,           s->proxyPassword );
    322     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_PORT,               s->proxyPort );
    323     tr_bencDictAddInt( d, TR_PREFS_KEY_PROXY_TYPE,               s->proxyType );
    324     tr_bencDictAddStr( d, TR_PREFS_KEY_PROXY_USERNAME,           s->proxyUsername );
    325     tr_bencDictAddDouble( d, TR_PREFS_KEY_RATIO,                 s->desiredRatio );
    326     tr_bencDictAddInt( d, TR_PREFS_KEY_RATIO_ENABLED,            s->isRatioLimited );
    327     tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        tr_sessionIsRPCPasswordEnabled( s ) );
    328     tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_ENABLED,              tr_sessionIsRPCEnabled( s ) );
    329     tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_PASSWORD,             freeme[n++] = tr_sessionGetRPCPassword( s ) );
    330     tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_PORT,                 tr_sessionGetRPCPort( s ) );
    331     tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_USERNAME,             freeme[n++] = tr_sessionGetRPCUsername( s ) );
    332     tr_bencDictAddStr( d, TR_PREFS_KEY_RPC_WHITELIST,            freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
    333     tr_bencDictAddInt( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    tr_sessionGetRPCWhitelistEnabled( s ) );
    334     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,        tr_sessionUsesAltSpeed( s ) );
    335     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_UP,             tr_sessionGetAltSpeed( s, TR_UP ) );
    336     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_DOWN,           tr_sessionGetAltSpeed( s, TR_DOWN ) );
    337     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,     tr_sessionGetAltSpeedBegin( s ) );
    338     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,   tr_sessionUsesAltSpeedTime( s ) );
    339     tr_bencDictAddInt( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,       tr_sessionGetAltSpeedEnd( s ) );
    340     tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED,                   tr_sessionGetSpeedLimit( s, TR_UP ) );
    341     tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_ENABLED,           tr_sessionIsSpeedLimited( s, TR_UP ) );
    342     tr_bencDictAddInt( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, s->uploadSlotsPerTorrent );
     300    tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        tr_blocklistIsEnabled( s ) );
     301    tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,             s->downloadDir );
     302    tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED,                   tr_sessionGetSpeedLimit( s, TR_DOWN ) );
     303    tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED,           tr_sessionIsSpeedLimited( s, TR_DOWN ) );
     304    tr_bencDictAddInt ( d, TR_PREFS_KEY_ENCRYPTION,               s->encryptionMode );
     305    tr_bencDictAddBool( d, TR_PREFS_KEY_LAZY_BITFIELD,            s->useLazyBitfield );
     306    tr_bencDictAddInt ( d, TR_PREFS_KEY_MSGLEVEL,                 tr_getMessageLevel( ) );
     307    tr_bencDictAddInt ( d, TR_PREFS_KEY_OPEN_FILE_LIMIT,          s->openFileLimit );
     308    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_GLOBAL,        tr_sessionGetPeerLimit( s ) );
     309    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_LIMIT_TORRENT,       s->peerLimitPerTorrent );
     310    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT,                tr_sessionGetPeerPort( s ) );
     311    tr_bencDictAddBool( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, s->isPortRandom );
     312    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW,     s->randomPortLow );
     313    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_HIGH,    s->randomPortHigh );
     314    tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_SOCKET_TOS,          s->peerSocketTOS );
     315    tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED,              s->isPexEnabled );
     316    tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING,          tr_sessionIsPortForwardingEnabled( s ) );
     317    tr_bencDictAddInt ( d, TR_PREFS_KEY_PREALLOCATION,            s->preallocationMode );
     318    tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY,                    s->proxy );
     319    tr_bencDictAddBool( d, TR_PREFS_KEY_PROXY_AUTH_ENABLED,       s->isProxyAuthEnabled );
     320    tr_bencDictAddBool( d, TR_PREFS_KEY_PROXY_ENABLED,            s->isProxyEnabled );
     321    tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY_PASSWORD,           s->proxyPassword );
     322    tr_bencDictAddInt ( d, TR_PREFS_KEY_PROXY_PORT,               s->proxyPort );
     323    tr_bencDictAddInt ( d, TR_PREFS_KEY_PROXY_TYPE,               s->proxyType );
     324    tr_bencDictAddStr ( d, TR_PREFS_KEY_PROXY_USERNAME,           s->proxyUsername );
     325    tr_bencDictAddReal( d, TR_PREFS_KEY_RATIO,                    s->desiredRatio );
     326    tr_bencDictAddBool( d, TR_PREFS_KEY_RATIO_ENABLED,            s->isRatioLimited );
     327    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_AUTH_REQUIRED,        tr_sessionIsRPCPasswordEnabled( s ) );
     328    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_ENABLED,              tr_sessionIsRPCEnabled( s ) );
     329    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_PASSWORD,             freeme[n++] = tr_sessionGetRPCPassword( s ) );
     330    tr_bencDictAddInt ( d, TR_PREFS_KEY_RPC_PORT,                 tr_sessionGetRPCPort( s ) );
     331    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_USERNAME,             freeme[n++] = tr_sessionGetRPCUsername( s ) );
     332    tr_bencDictAddStr ( d, TR_PREFS_KEY_RPC_WHITELIST,            freeme[n++] = tr_sessionGetRPCWhitelist( s ) );
     333    tr_bencDictAddBool( d, TR_PREFS_KEY_RPC_WHITELIST_ENABLED,    tr_sessionGetRPCWhitelistEnabled( s ) );
     334    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_ENABLED,        tr_sessionUsesAltSpeed( s ) );
     335    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_UP,             tr_sessionGetAltSpeed( s, TR_UP ) );
     336    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_DOWN,           tr_sessionGetAltSpeed( s, TR_DOWN ) );
     337    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN,     tr_sessionGetAltSpeedBegin( s ) );
     338    tr_bencDictAddBool( d, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED,   tr_sessionUsesAltSpeedTime( s ) );
     339    tr_bencDictAddInt ( d, TR_PREFS_KEY_ALT_SPEED_TIME_END,       tr_sessionGetAltSpeedEnd( s ) );
     340    tr_bencDictAddInt ( d, TR_PREFS_KEY_USPEED,                   tr_sessionGetSpeedLimit( s, TR_UP ) );
     341    tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED,           tr_sessionIsSpeedLimited( s, TR_UP ) );
     342    tr_bencDictAddInt ( d, TR_PREFS_KEY_UPLOAD_SLOTS_PER_TORRENT, s->uploadSlotsPerTorrent );
    343343
    344344    for( i=0; i<n; ++i )
     
    479479    tr_bool useAltSpeedTime;
    480480    tr_bool found;
     481    tr_bool boolVal;
    481482    const char * str;
    482483    tr_benc settings;
     
    510511
    511512
    512     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEX_ENABLED, &i );
    513     assert( found );
    514     session->isPexEnabled = i != 0;
     513    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PEX_ENABLED, &boolVal );
     514    assert( found );
     515    session->isPexEnabled = boolVal;
    515516
    516517    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ENCRYPTION, &i );
     
    532533    session->downloadDir = tr_strdup( str );
    533534
    534     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_ENABLED, &i );
    535     assert( found );
    536     session->isProxyEnabled = i != 0;
     535    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PROXY_ENABLED, &boolVal );
     536    assert( found );
     537    session->isProxyEnabled = boolVal;
    537538
    538539    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY, &str );
     
    548549    session->proxyType = i;
    549550
    550     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PROXY_AUTH_ENABLED, &i );
    551     assert( found );
    552     session->isProxyAuthEnabled = i != 0;
     551    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PROXY_AUTH_ENABLED, &boolVal );
     552    assert( found );
     553    session->isProxyAuthEnabled = boolVal;
    553554
    554555    found = tr_bencDictFindStr( &settings, TR_PREFS_KEY_PROXY_USERNAME, &str );
     
    570571    session->peerMgr = tr_peerMgrNew( session );
    571572
    572     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_LAZY_BITFIELD, &i );
    573     assert( found );
    574     session->useLazyBitfield = i != 0;
     573    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_LAZY_BITFIELD, &boolVal );
     574    assert( found );
     575    session->useLazyBitfield = boolVal;
    575576
    576577    /* Initialize rate and file descripts controls */
     
    587588    **/
    588589
    589     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, &i );
    590     assert( found );
    591     session->isPortRandom = i != 0;
     590    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_ENABLED, &boolVal );
     591    assert( found );
     592    session->isPortRandom = boolVal;
    592593
    593594    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT_RANDOM_LOW, &i );
     
    599600    session->randomPortHigh = i;
    600601
    601     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_PORT_FORWARDING, &i )
     602    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, &boolVal )
    602603         && tr_bencDictFindInt( &settings, TR_PREFS_KEY_PEER_PORT, &j );
    603604    assert( found );
    604605    session->peerPort = session->isPortRandom ? getRandomPort( session ) : j;
    605     session->shared = tr_sharedInit( session, i, session->peerPort );
     606    session->shared = tr_sharedInit( session, boolVal, session->peerPort );
    606607    session->isPortSet = session->isPortRandom || j>0;
    607608
     
    614615
    615616    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED, &i )
    616          && tr_bencDictFindInt( &settings, TR_PREFS_KEY_USPEED_ENABLED, &j );
     617         && tr_bencDictFindBool( &settings, TR_PREFS_KEY_USPEED_ENABLED, &boolVal );
    617618    assert( found );
    618619    tr_sessionSetSpeedLimit( session, TR_UP, i );
    619     tr_sessionLimitSpeed( session, TR_UP, j!=0 );
     620    tr_sessionLimitSpeed( session, TR_UP, boolVal );
    620621
    621622    found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED, &i )
    622          && tr_bencDictFindInt( &settings, TR_PREFS_KEY_DSPEED_ENABLED, &j );
     623         && tr_bencDictFindBool( &settings, TR_PREFS_KEY_DSPEED_ENABLED, &boolVal );
    623624    assert( found );
    624625    tr_sessionSetSpeedLimit( session, TR_DOWN, i );
    625     tr_sessionLimitSpeed( session, TR_DOWN, j!=0 );
    626 
    627     found = tr_bencDictFindDouble( &settings, TR_PREFS_KEY_RATIO, &d )
    628          && tr_bencDictFindInt( &settings, TR_PREFS_KEY_RATIO_ENABLED, &j );
     626    tr_sessionLimitSpeed( session, TR_DOWN, boolVal );
     627
     628    found = tr_bencDictFindReal( &settings, TR_PREFS_KEY_RATIO, &d )
     629         && tr_bencDictFindBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, &boolVal );
    629630    assert( found );
    630631    tr_sessionSetRatioLimit( session, d );
    631     tr_sessionSetRatioLimited( session, j );
     632    tr_sessionSetRatioLimited( session, boolVal );
    632633
    633634    /**
     
    651652    session->altSpeedTimeEnd = i;
    652653
    653     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &i );
    654     assert( found );
    655     useAltSpeedTime = i!=0;
     654    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &boolVal );
     655    assert( found );
     656    useAltSpeedTime = boolVal;
    656657    tr_sessionUseAltSpeedTime( session, useAltSpeedTime );
    657658
    658659    if( !useAltSpeedTime )
    659660    {
    660         found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &i );
     661        found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_ALT_SPEED_ENABLED, &boolVal );
    661662        assert( found );
    662         tr_sessionUseAltSpeed( session, i!=0 );
     663        tr_sessionUseAltSpeed( session, boolVal );
    663664    }
    664665    else
     
    672673    tr_mkdirp( filename, 0777 );
    673674    tr_free( filename );
    674     found = tr_bencDictFindInt( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &i );
    675     assert( found );
    676     session->isBlocklistEnabled = i;
     675    found = tr_bencDictFindBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, &boolVal );
     676    assert( found );
     677    session->isBlocklistEnabled = boolVal;
    677678    loadBlocklists( session );
    678679
Note: See TracChangeset for help on using the changeset viewer.