Changeset 12204


Ignore:
Timestamp:
Mar 22, 2011, 3:19:54 PM (11 years ago)
Author:
jordan
Message:

(trunk) #4138 "use stdbool.h instead of tr_bool" -- done.

Location:
trunk
Files:
100 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/cli.c

    r12168 r12204  
    6868#define MY_READABLE_NAME "transmission-cli"
    6969
    70 static tr_bool showVersion = FALSE;
    71 static tr_bool verify                = 0;
     70static bool showVersion              = false;
     71static bool verify                   = 0;
    7272static sig_atomic_t gotsig           = 0;
    7373static sig_atomic_t manualUpdate     = 0;
     
    128128}
    129129
    130 static tr_bool waitingOnWeb;
     130static bool waitingOnWeb;
    131131
    132132static void
    133133onTorrentFileDownloaded( tr_session   * session UNUSED,
    134                          tr_bool        did_connect UNUSED,
    135                          tr_bool        did_timeout UNUSED,
     134                         bool           did_connect UNUSED,
     135                         bool           did_timeout UNUSED,
    136136                         long           response_code UNUSED,
    137137                         const void   * response,
     
    140140{
    141141    tr_ctorSetMetainfo( ctor, response, response_byte_count );
    142     waitingOnWeb = FALSE;
     142    waitingOnWeb = false;
    143143}
    144144
     
    259259    }
    260260
    261     h = tr_sessionInit( "cli", configDir, FALSE, &settings );
     261    h = tr_sessionInit( "cli", configDir, false, &settings );
    262262
    263263    ctor = tr_ctorNew( h );
    264264
    265265    fileContents = tr_loadFile( torrentPath, &fileLength );
    266     tr_ctorSetPaused( ctor, TR_FORCE, FALSE );
     266    tr_ctorSetPaused( ctor, TR_FORCE, false );
    267267    if( fileContents != NULL ) {
    268268        tr_ctorSetMetainfo( ctor, fileContents, fileLength );
     
    271271    } else if( !memcmp( torrentPath, "http", 4 ) ) {
    272272        tr_webRun( h, torrentPath, NULL, NULL, onTorrentFileDownloaded, ctor );
    273         waitingOnWeb = TRUE;
     273        waitingOnWeb = true;
    274274        while( waitingOnWeb ) tr_wait_msec( 1000 );
    275275    } else {
     
    370370        switch( c )
    371371        {
    372             case 'b': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, TRUE );
    373                       break;
    374             case 'B': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
     372            case 'b': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, true );
     373                      break;
     374            case 'B': tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED, false );
    375375                      break;
    376376            case 'd': tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED_KBps, atoi( optarg ) );
    377                       tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, TRUE );
    378                       break;
    379             case 'D': tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, FALSE );
     377                      tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, true );
     378                      break;
     379            case 'D': tr_bencDictAddBool( d, TR_PREFS_KEY_DSPEED_ENABLED, false );
    380380                      break;
    381381            case 'f': tr_bencDictAddStr( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg );
    382                       tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, TRUE );
     382                      tr_bencDictAddBool( d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true );
    383383                      break;
    384384            case 'g': /* handled above */
    385385                      break;
    386             case 'm': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
    387                       break;
    388             case 'M': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, FALSE );
     386            case 'm': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, true );
     387                      break;
     388            case 'M': tr_bencDictAddBool( d, TR_PREFS_KEY_PORT_FORWARDING, false );
    389389                      break;
    390390            case 'p': tr_bencDictAddInt( d, TR_PREFS_KEY_PEER_PORT, atoi( optarg ) );
     
    393393                      break;
    394394            case 'u': tr_bencDictAddInt( d, TR_PREFS_KEY_USPEED_KBps, atoi( optarg ) );
    395                       tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, TRUE );
    396                       break;
    397             case 'U': tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, FALSE );
    398                       break;
    399             case 'v': verify = TRUE;
    400                       break;
    401             case 'V': showVersion = TRUE;
     395                      tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, true );
     396                      break;
     397            case 'U': tr_bencDictAddBool( d, TR_PREFS_KEY_USPEED_ENABLED, false );
     398                      break;
     399            case 'v': verify = true;
     400                      break;
     401            case 'V': showVersion = true;
    402402                      break;
    403403            case 'w': tr_bencDictAddStr( d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg );
  • trunk/configure.ac

    r12151 r12204  
    109109AC_HEADER_TIME
    110110
     111AC_CHECK_HEADERS([stdbool.h])
    111112AC_CHECK_FUNCS([iconv_open pread pwrite lrintf strlcpy daemon dirname basename strcasecmp localtime_r fallocate64 posix_fallocate memmem strsep strtold syslog valloc getpagesize posix_memalign statvfs htonll ntohll])
    112113AC_PROG_INSTALL
  • trunk/daemon/daemon.c

    r12000 r12204  
    5959#define SPEED_T_STR "TiB/s"
    6060
    61 static tr_bool paused = FALSE;
    62 static tr_bool closing = FALSE;
     61static bool paused = false;
     62static bool closing = false;
    6363static tr_session * mySession = NULL;
    6464
     
    145145            tr_inf( "Reloading settings from \"%s\"", configDir );
    146146            tr_bencInitDict( &settings, 0 );
    147             tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, TRUE );
     147            tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, true );
    148148            tr_sessionLoadSettings( &settings, configDir, MY_NAME );
    149149            tr_sessionSet( mySession, &settings );
     
    154154
    155155        default:
    156             closing = TRUE;
     156            closing = true;
    157157            break;
    158158    }
     
    244244        else
    245245        {
    246             tr_bool trash = FALSE;
     246            bool trash = false;
    247247            int test = tr_ctorGetDeleteSource( ctor, &trash );
    248248
     
    322322{
    323323    if( type == TR_RPC_SESSION_CLOSE )
    324         closing = TRUE;
     324        closing = true;
    325325    return TR_RPC_OK;
    326326}
     
    332332    const char * optarg;
    333333    tr_benc settings;
    334     tr_bool boolVal;
    335     tr_bool loaded;
    336     tr_bool foreground = FALSE;
    337     tr_bool dumpSettings = FALSE;
     334    bool boolVal;
     335    bool loaded;
     336    bool foreground = false;
     337    bool dumpSettings = false;
    338338    const char * configDir = NULL;
    339339    const char * pid_filename;
    340340    dtr_watchdir * watchdir = NULL;
    341341    FILE * logfile = NULL;
    342     tr_bool pidfile_created = FALSE;
     342    bool pidfile_created = false;
    343343
    344344    signal( SIGINT, gotsig );
     
    350350    /* load settings from defaults + config file */
    351351    tr_bencInitDict( &settings, 0 );
    352     tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, TRUE );
     352    tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_ENABLED, true );
    353353    configDir = getConfigDir( argc, (const char**)argv );
    354354    loaded = tr_sessionLoadSettings( &settings, configDir, MY_NAME );
     
    359359        switch( c ) {
    360360            case 'a': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_WHITELIST, optarg );
    361                       tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, TRUE );
    362                       break;
    363             case 'b': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, TRUE );
    364                       break;
    365             case 'B': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, FALSE );
     361                      tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, true );
     362                      break;
     363            case 'b': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, true );
     364                      break;
     365            case 'B': tr_bencDictAddBool( &settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, false );
    366366                      break;
    367367            case 'c': tr_bencDictAddStr( &settings, PREF_KEY_DIR_WATCH, optarg );
    368                       tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, TRUE );
    369                       break;
    370             case 'C': tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, FALSE );
     368                      tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, true );
     369                      break;
     370            case 'C': tr_bencDictAddBool( &settings, PREF_KEY_DIR_WATCH_ENABLED, false );
    371371                      break;
    372372            case 941: tr_bencDictAddStr( &settings, TR_PREFS_KEY_INCOMPLETE_DIR, optarg );
    373                       tr_bencDictAddBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, TRUE );
    374                       break;
    375             case 942: tr_bencDictAddBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, FALSE );
    376                       break;
    377             case 'd': dumpSettings = TRUE;
     373                      tr_bencDictAddBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true );
     374                      break;
     375            case 942: tr_bencDictAddBool( &settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false );
     376                      break;
     377            case 'd': dumpSettings = true;
    378378                      break;
    379379            case 'e': logfile = fopen( optarg, "a+" );
     
    381381                          fprintf( stderr, "Couldn't open \"%s\": %s\n", optarg, tr_strerror( errno ) );
    382382                      break;
    383             case 'f': foreground = TRUE;
     383            case 'f': foreground = true;
    384384                      break;
    385385            case 'g': /* handled above */
     
    388388                      fprintf(stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING);
    389389                      exit( 0 );
    390             case 'o': tr_bencDictAddBool( &settings, TR_PREFS_KEY_DHT_ENABLED, TRUE );
    391                       break;
    392             case 'O': tr_bencDictAddBool( &settings, TR_PREFS_KEY_DHT_ENABLED, FALSE );
     390            case 'o': tr_bencDictAddBool( &settings, TR_PREFS_KEY_DHT_ENABLED, true );
     391                      break;
     392            case 'O': tr_bencDictAddBool( &settings, TR_PREFS_KEY_DHT_ENABLED, false );
    393393                      break;
    394394            case 'p': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_PORT, atoi( optarg ) );
    395395                      break;
    396             case 't': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, TRUE );
    397                       break;
    398             case 'T': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, FALSE );
     396            case 't': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, true );
     397                      break;
     398            case 'T': tr_bencDictAddBool( &settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, false );
    399399                      break;
    400400            case 'u': tr_bencDictAddStr( &settings, TR_PREFS_KEY_RPC_USERNAME, optarg );
     
    406406            case 'P': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_PORT, atoi( optarg ) );
    407407                      break;
    408             case 'm': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
    409                       break;
    410             case 'M': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, FALSE );
     408            case 'm': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, true );
     409                      break;
     410            case 'M': tr_bencDictAddBool( &settings, TR_PREFS_KEY_PORT_FORWARDING, false );
    411411                      break;
    412412            case 'L': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi( optarg ) );
     
    414414            case 'l': tr_bencDictAddInt( &settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi( optarg ) );
    415415                      break;
    416             case 800: paused = TRUE;
     416            case 800: paused = true;
    417417                      break;
    418418            case 910: tr_bencDictAddInt( &settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED );
     
    429429                      break;
    430430            case 953: tr_bencDictAddReal( &settings, TR_PREFS_KEY_RATIO, atof(optarg) );
    431                       tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, TRUE );
    432                       break;
    433             case 954: tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, FALSE );
     431                      tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, true );
     432                      break;
     433            case 954: tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, false );
    434434                      break;
    435435            case 'x': tr_bencDictAddStr( &settings, PREF_KEY_PIDFILE, optarg );
    436436                      break;
    437             case 'y': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, TRUE );
    438                       break;
    439             case 'Y': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, FALSE );
     437            case 'y': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, true );
     438                      break;
     439            case 'Y': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, false );
    440440                      break;
    441441            case 810: tr_bencDictAddInt( &settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_ERR );
     
    467467    }
    468468
    469     if( !foreground && tr_daemon( TRUE, FALSE ) < 0 )
     469    if( !foreground && tr_daemon( true, false ) < 0 )
    470470    {
    471471        char buf[256];
     
    479479    tr_formatter_size_init( DISK_K, DISK_K_STR, DISK_M_STR, DISK_G_STR, DISK_T_STR );
    480480    tr_formatter_speed_init( SPEED_K, SPEED_K_STR, SPEED_M_STR, SPEED_G_STR, SPEED_T_STR );
    481     mySession = tr_sessionInit( "daemon", configDir, TRUE, &settings );
     481    mySession = tr_sessionInit( "daemon", configDir, true, &settings );
    482482    tr_sessionSetRPCCallback( mySession, on_rpc_callback, NULL );
    483483    tr_ninf( NULL, "Using settings from \"%s\"", configDir );
     
    494494            fclose( fp );
    495495            tr_inf( "Saved pidfile \"%s\"", pid_filename );
    496             pidfile_created = TRUE;
     496            pidfile_created = true;
    497497        }
    498498        else
     
    523523        tr_ctor * ctor = tr_ctorNew( mySession );
    524524        if( paused )
    525             tr_ctorSetPaused( ctor, TR_FORCE, TRUE );
     525            tr_ctorSetPaused( ctor, TR_FORCE, true );
    526526        torrents = tr_sessionLoadTorrents( mySession, ctor, NULL );
    527527        tr_free( torrents );
  • trunk/daemon/remote.c

    r12113 r12204  
    486486}
    487487
    488 static tr_bool debug = 0;
     488static bool debug = 0;
    489489static char * auth = NULL;
    490490static char * netrc = NULL;
     
    553553    {
    554554        const char * pch;
    555         tr_bool isList = strchr(id,',') || strchr(id,'-');
    556         tr_bool isNum = TRUE;
     555        bool isList = strchr(id,',') || strchr(id,'-');
     556        bool isNum = true;
    557557        for( pch=id; isNum && *pch; ++pch )
    558558            if( !isdigit( *pch ) )
    559                 isNum = FALSE;
     559                isNum = false;
    560560        if( isNum || isList )
    561561            tr_rpc_parse_list_str( tr_bencDictAdd( args, "ids" ), id, strlen( id ) );
     
    569569{
    570570    int time;
    571     tr_bool success = FALSE;
     571    bool success = false;
    572572
    573573    if( arg && ( strlen( arg ) == 4 ) )
     
    581581        {
    582582            time = min + ( hour * 60 );
    583             success = TRUE;
     583            success = true;
    584584        }
    585585    }
     
    759759{
    760760    int64_t status;
    761     tr_bool boolVal;
     761    bool boolVal;
    762762
    763763    if( !tr_bencDictFindInt( t, "status", &status ) )
     
    836836            char         buf2[512];
    837837            int64_t      i, j, k;
    838             tr_bool      boolVal;
     838            bool      boolVal;
    839839            double       d;
    840840
     
    12071207    if( ( tr_bencDictFindDict( top, "arguments", &args ) ) )
    12081208    {
    1209         tr_bool      boolVal;
     1209        bool      boolVal;
    12101210
    12111211        if( tr_bencDictFindBool( args, "port-is-open", &boolVal ) )
     
    13051305    {
    13061306        int64_t downloadCount;
    1307         tr_bool hasAnnounced;
    1308         tr_bool hasScraped;
     1307        bool hasAnnounced;
     1308        bool hasScraped;
    13091309        const char * host;
    13101310        int64_t id;
    1311         tr_bool isBackup;
     1311        bool isBackup;
    13121312        int64_t lastAnnouncePeerCount;
    13131313        const char * lastAnnounceResult;
    13141314        int64_t lastAnnounceStartTime;
    1315         tr_bool lastAnnounceSucceeded;
     1315        bool lastAnnounceSucceeded;
    13161316        int64_t lastAnnounceTime;
    1317         tr_bool lastAnnounceTimedOut;
     1317        bool lastAnnounceTimedOut;
    13181318        const char * lastScrapeResult;
    1319         tr_bool lastScrapeSucceeded;
     1319        bool lastScrapeSucceeded;
    13201320        int64_t lastScrapeStartTime;
    13211321        int64_t lastScrapeTime;
    1322         tr_bool lastScrapeTimedOut;
     1322        bool lastScrapeTimedOut;
    13231323        int64_t leecherCount;
    13241324        int64_t nextAnnounceTime;
     
    14601460        int64_t i;
    14611461        char buf[64];
    1462         tr_bool boolVal;
     1462        bool boolVal;
    14631463        const char * str;
    14641464
     
    14961496
    14971497        {
    1498             tr_bool altEnabled, altTimeEnabled, upEnabled, downEnabled, seedRatioLimited;
     1498            bool altEnabled, altTimeEnabled, upEnabled, downEnabled, seedRatioLimited;
    14991499            int64_t altDown, altUp, altBegin, altEnd, altDay, upLimit, downLimit, peerLimit;
    15001500            double seedRatioLimit;
     
    18441844
    18451845                case 'b': /* debug */
    1846                     debug = TRUE;
     1846                    debug = true;
    18471847                    break;
    18481848
     
    19531953            {
    19541954                case 800: tr_bencDictAddStr( args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg );
    1955                           tr_bencDictAddBool( args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, TRUE );
    1956                           break;
    1957                 case 801: tr_bencDictAddBool( args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, FALSE );
    1958                           break;
    1959                 case 970: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, TRUE );
    1960                           break;
    1961                 case 971: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, FALSE );
     1955                          tr_bencDictAddBool( args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true );
     1956                          break;
     1957                case 801: tr_bencDictAddBool( args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, false );
     1958                          break;
     1959                case 970: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, true );
     1960                          break;
     1961                case 971: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_ENABLED, false );
    19621962                          break;
    19631963                case 972: tr_bencDictAddInt( args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, numarg( optarg ) );
     
    19651965                case 973: tr_bencDictAddInt( args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, numarg( optarg ) );
    19661966                          break;
    1967                 case 974: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, TRUE );
    1968                           break;
    1969                 case 975: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, FALSE );
     1967                case 974: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, true );
     1968                          break;
     1969                case 975: tr_bencDictAddBool( args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, false );
    19701970                          break;
    19711971                case 976: addTime( args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, optarg );
     
    19761976                          break;
    19771977                case 'c': tr_bencDictAddStr( args, TR_PREFS_KEY_INCOMPLETE_DIR, optarg );
    1978                           tr_bencDictAddBool( args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, TRUE );
    1979                           break;
    1980                 case 'C': tr_bencDictAddBool( args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, FALSE );
     1978                          tr_bencDictAddBool( args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true );
     1979                          break;
     1980                case 'C': tr_bencDictAddBool( args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false );
    19811981                          break;
    19821982                case 'e': tr_bencDictAddInt( args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, atoi(optarg) );
     
    19881988                case 912: tr_bencDictAddStr( args, TR_PREFS_KEY_ENCRYPTION, "tolerated" );
    19891989                          break;
    1990                 case 'm': tr_bencDictAddBool( args, TR_PREFS_KEY_PORT_FORWARDING, TRUE );
    1991                           break;
    1992                 case 'M': tr_bencDictAddBool( args, TR_PREFS_KEY_PORT_FORWARDING, FALSE );
    1993                           break;
    1994                 case 'o': tr_bencDictAddBool( args, TR_PREFS_KEY_DHT_ENABLED, TRUE );
    1995                           break;
    1996                 case 'O': tr_bencDictAddBool( args, TR_PREFS_KEY_DHT_ENABLED, FALSE );
    1997                           break;
    1998                 case 830: tr_bencDictAddBool( args, TR_PREFS_KEY_UTP_ENABLED, TRUE );
    1999                           break;
    2000                 case 831: tr_bencDictAddBool( args, TR_PREFS_KEY_UTP_ENABLED, FALSE );
     1990                case 'm': tr_bencDictAddBool( args, TR_PREFS_KEY_PORT_FORWARDING, true );
     1991                          break;
     1992                case 'M': tr_bencDictAddBool( args, TR_PREFS_KEY_PORT_FORWARDING, false );
     1993                          break;
     1994                case 'o': tr_bencDictAddBool( args, TR_PREFS_KEY_DHT_ENABLED, true );
     1995                          break;
     1996                case 'O': tr_bencDictAddBool( args, TR_PREFS_KEY_DHT_ENABLED, false );
     1997                          break;
     1998                case 830: tr_bencDictAddBool( args, TR_PREFS_KEY_UTP_ENABLED, true );
     1999                          break;
     2000                case 831: tr_bencDictAddBool( args, TR_PREFS_KEY_UTP_ENABLED, false );
    20012001                          break;
    20022002                case 'p': tr_bencDictAddInt( args, TR_PREFS_KEY_PEER_PORT, numarg( optarg ) );
    20032003                          break;
    2004                 case 'P': tr_bencDictAddBool( args, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, TRUE);
    2005                           break;
    2006                 case 'x': tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, TRUE );
    2007                           break;
    2008                 case 'X': tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, FALSE );
    2009                           break;
    2010                 case 'y': tr_bencDictAddBool( args, TR_PREFS_KEY_LPD_ENABLED, TRUE );
    2011                           break;
    2012                 case 'Y': tr_bencDictAddBool( args, TR_PREFS_KEY_LPD_ENABLED, FALSE );
     2004                case 'P': tr_bencDictAddBool( args, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, true);
     2005                          break;
     2006                case 'x': tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, true );
     2007                          break;
     2008                case 'X': tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, false );
     2009                          break;
     2010                case 'y': tr_bencDictAddBool( args, TR_PREFS_KEY_LPD_ENABLED, true );
     2011                          break;
     2012                case 'Y': tr_bencDictAddBool( args, TR_PREFS_KEY_LPD_ENABLED, false );
    20132013                          break;
    20142014                case 953: tr_bencDictAddReal( args, "seedRatioLimit", atof(optarg) );
    2015                           tr_bencDictAddBool( args, "seedRatioLimited", TRUE );
    2016                           break;
    2017                 case 954: tr_bencDictAddBool( args, "seedRatioLimited", FALSE );
    2018                           break;
    2019                 case 990: tr_bencDictAddBool( args, TR_PREFS_KEY_START, FALSE );
    2020                           break;
    2021                 case 991: tr_bencDictAddBool( args, TR_PREFS_KEY_START, TRUE );
    2022                           break;
    2023                 case 992: tr_bencDictAddBool( args, TR_PREFS_KEY_TRASH_ORIGINAL, TRUE );
    2024                           break;
    2025                 case 993: tr_bencDictAddBool( args, TR_PREFS_KEY_TRASH_ORIGINAL, FALSE );
     2015                          tr_bencDictAddBool( args, "seedRatioLimited", true );
     2016                          break;
     2017                case 954: tr_bencDictAddBool( args, "seedRatioLimited", false );
     2018                          break;
     2019                case 990: tr_bencDictAddBool( args, TR_PREFS_KEY_START, false );
     2020                          break;
     2021                case 991: tr_bencDictAddBool( args, TR_PREFS_KEY_START, true );
     2022                          break;
     2023                case 992: tr_bencDictAddBool( args, TR_PREFS_KEY_TRASH_ORIGINAL, true );
     2024                          break;
     2025                case 993: tr_bencDictAddBool( args, TR_PREFS_KEY_TRASH_ORIGINAL, false );
    20262026                          break;
    20272027                default:  assert( "unhandled value" && 0 );
     
    20432043                case 'd': if( targs ) {
    20442044                              tr_bencDictAddInt( targs, "downloadLimit", numarg( optarg ) );
    2045                               tr_bencDictAddBool( targs, "downloadLimited", TRUE );
     2045                              tr_bencDictAddBool( targs, "downloadLimited", true );
    20462046                          } else {
    20472047                              tr_bencDictAddInt( sargs, TR_PREFS_KEY_DSPEED_KBps, numarg( optarg ) );
    2048                               tr_bencDictAddBool( sargs, TR_PREFS_KEY_DSPEED_ENABLED, TRUE );
     2048                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_DSPEED_ENABLED, true );
    20492049                          }
    20502050                          break;
    20512051                case 'D': if( targs )
    2052                               tr_bencDictAddBool( targs, "downloadLimited", FALSE );
     2052                              tr_bencDictAddBool( targs, "downloadLimited", false );
    20532053                          else
    2054                               tr_bencDictAddBool( sargs, TR_PREFS_KEY_DSPEED_ENABLED, FALSE );
     2054                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_DSPEED_ENABLED, false );
    20552055                          break;
    20562056                case 'u': if( targs ) {
    20572057                              tr_bencDictAddInt( targs, "uploadLimit", numarg( optarg ) );
    2058                               tr_bencDictAddBool( targs, "uploadLimited", TRUE );
     2058                              tr_bencDictAddBool( targs, "uploadLimited", true );
    20592059                          } else {
    20602060                              tr_bencDictAddInt( sargs, TR_PREFS_KEY_USPEED_KBps, numarg( optarg ) );
    2061                               tr_bencDictAddBool( sargs, TR_PREFS_KEY_USPEED_ENABLED, TRUE );
     2061                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_USPEED_ENABLED, true );
    20622062                          }
    20632063                          break;
    20642064                case 'U': if( targs )
    2065                               tr_bencDictAddBool( targs, "uploadLimited", FALSE );
     2065                              tr_bencDictAddBool( targs, "uploadLimited", false );
    20662066                          else
    2067                               tr_bencDictAddBool( sargs, TR_PREFS_KEY_USPEED_ENABLED, FALSE );
     2067                              tr_bencDictAddBool( sargs, TR_PREFS_KEY_USPEED_ENABLED, false );
    20682068                          break;
    20692069                case 930: if( targs )
     
    20912091                case 952: tr_bencDictAddInt( args, "seedRatioMode", TR_RATIOLIMIT_UNLIMITED );
    20922092                          break;
    2093                 case 984: tr_bencDictAddBool( args, "honorsSessionLimits", TRUE );
    2094                           break;
    2095                 case 985: tr_bencDictAddBool( args, "honorsSessionLimits", FALSE );
     2093                case 984: tr_bencDictAddBool( args, "honorsSessionLimits", true );
     2094                          break;
     2095                case 985: tr_bencDictAddBool( args, "honorsSessionLimits", false );
    20962096                          break;
    20972097                default:  assert( "unhandled value" && 0 );
     
    21472147                args = tr_bencDictAddDict( top, ARGUMENTS, 3 );
    21482148                tr_bencDictAddStr( args, "location", optarg );
    2149                 tr_bencDictAddBool( args, "move", FALSE );
     2149                tr_bencDictAddBool( args, "move", false );
    21502150                addIdArg( args, id );
    21512151                status |= flush( rpcurl, &top );
     
    21672167            {
    21682168                if( tadd )
    2169                     tr_bencDictAddBool( tr_bencDictFind( tadd, "arguments" ), "paused", FALSE );
     2169                    tr_bencDictAddBool( tr_bencDictFind( tadd, "arguments" ), "paused", false );
    21702170                else {
    21712171                    tr_benc * top = tr_new0( tr_benc, 1 );
     
    21802180            {
    21812181                if( tadd )
    2182                     tr_bencDictAddBool( tr_bencDictFind( tadd, "arguments" ), "paused", TRUE );
     2182                    tr_bencDictAddBool( tr_bencDictFind( tadd, "arguments" ), "paused", true );
    21832183                else {
    21842184                    tr_benc * top = tr_new0( tr_benc, 1 );
     
    22792279                args = tr_bencDictAddDict( top, ARGUMENTS, 3 );
    22802280                tr_bencDictAddStr( args, "location", optarg );
    2281                 tr_bencDictAddBool( args, "move", TRUE );
     2281                tr_bencDictAddBool( args, "move", true );
    22822282                addIdArg( args, id );
    22832283                status |= flush( rpcurl, &top );
  • trunk/gtk/conf.c

    r12068 r12204  
    269269gtr_pref_flag_get( const char * key )
    270270{
    271     tr_bool boolVal;
     271    bool boolVal;
    272272    tr_bencDictFindBool( getPrefs( ), key, &boolVal );
    273273    return boolVal != 0;
  • trunk/gtk/details.c

    r12169 r12204  
    183183    /* honor_limits_check */
    184184    if( n ) {
    185         const tr_bool baseline = tr_torrentUsesSessionLimits( torrents[0] );
     185        const bool baseline = tr_torrentUsesSessionLimits( torrents[0] );
    186186        int i;
    187187        for( i=1; i<n; ++i )
     
    195195    /* down_limited_check */
    196196    if( n ) {
    197         const tr_bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_DOWN );
     197        const bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_DOWN );
    198198        int i;
    199199        for( i=1; i<n; ++i )
     
    219219    /* up_limited_check */
    220220    if( n ) {
    221         const tr_bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_UP );
     221        const bool baseline = tr_torrentUsesSpeedLimit( torrents[0], TR_UP );
    222222        int i;
    223223        for( i=1; i<n; ++i )
     
    551551
    552552static const char *
    553 activityString( int activity, tr_bool finished )
     553activityString( int activity, bool finished )
    554554{
    555555    switch( activity )
     
    620620        str = no_torrent;
    621621    else {
    622         const tr_bool baseline = infos[0]->isPrivate;
     622        const bool baseline = infos[0]->isPrivate;
    623623        for( i=1; i<n; ++i )
    624624            if( baseline != infos[i]->isPrivate )
     
    700700    else {
    701701        const tr_torrent_activity activity = stats[0]->activity;
    702         tr_bool allFinished = stats[0]->finished;
     702        bool allFinished = stats[0]->finished;
    703703        for( i=1; i<n; ++i ) {
    704704            if( activity != stats[i]->activity )
     
    15101510    int i;
    15111511    int n = 0;
    1512     const tr_bool more = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
     1512    const bool more = gtr_pref_flag_get( PREF_KEY_SHOW_MORE_PEER_INFO );
    15131513    int view_columns[32];
    15141514    GtkTreeViewColumn * c;
  • trunk/gtk/favicon.c

    r12168 r12204  
    8282}
    8383
    84 static void favicon_web_done_cb( tr_session*, tr_bool, tr_bool, long, const void*, size_t, void* );
     84static void favicon_web_done_cb( tr_session*, bool, bool, long, const void*, size_t, void* );
    8585
    8686static gboolean
     
    130130static void
    131131favicon_web_done_cb( tr_session    * session UNUSED,
    132                      tr_bool         did_connect UNUSED,
    133                      tr_bool         did_timeout UNUSED,
     132                     bool            did_connect UNUSED,
     133                     bool            did_timeout UNUSED,
    134134                     long            code UNUSED,
    135135                     const void    * data,
  • trunk/gtk/main.c

    r12090 r12204  
    505505            for( i=0; tr_bencDictChild( &tmp, i, &key, &newval ); ++i )
    506506            {
    507                 tr_bool changed;
     507                bool changed;
    508508                tr_benc * oldval = tr_bencDictFind( oldvals, key );
    509509                if( !oldval )
    510                     changed = TRUE;
     510                    changed = true;
    511511                else {
    512512                    char * a = tr_bencToStr( oldval, TR_FMT_BENC, NULL );
  • trunk/gtk/open-dialog.c

    r12068 r12204  
    264264    GtkWidget *      source_chooser;
    265265    struct OpenData * data;
    266     uint8_t          flag;
     266    bool             flag;
    267267    GSList *         list;
    268268    GSList *         walk;
  • trunk/gtk/relocate.c

    r12068 r12204  
    2828{
    2929    int done;
    30     tr_bool do_move;
     30    bool do_move;
    3131    TrCore * core;
    3232    GSList * torrent_ids;
  • trunk/gtk/tr-core.c

    r12168 r12204  
    349349***/
    350350
    351 static tr_bool
     351static bool
    352352core_is_busy( TrCore * core )
    353353{
     
    358358core_add_to_busy( TrCore * core, int addMe )
    359359{
    360     const tr_bool wasBusy = core_is_busy( core );
     360    const bool wasBusy = core_is_busy( core );
    361361
    362362    core->priv->busy_count += addMe;
     
    878878on_torrent_completeness_changed( tr_torrent       * tor,
    879879                                 tr_completeness    completeness,
    880                                  tr_bool            was_running,
     880                                 bool               was_running,
    881881                                 void             * gcore )
    882882{
     
    972972    int errcode = 0;
    973973    tr_torrent * tor;
    974     uint8_t do_trash = FALSE;
     974    bool do_trash = false;
    975975    tr_session * session = gtr_core_session( core );
    976976
     
    11091109    char * url;
    11101110
    1111     tr_bool did_connect;
    1112     tr_bool did_timeout;
     1111    bool did_connect;
     1112    bool did_timeout;
    11131113    long response_code;
    11141114};
     
    11441144static void
    11451145on_url_done( tr_session   * session,
    1146              tr_bool        did_connect,
    1147              tr_bool        did_timeout,
     1146             bool           did_connect,
     1147             bool           did_timeout,
    11481148             long           response_code,
    11491149             const void   * response,
     
    13541354    int oldActivePeerCount, newActivePeerCount;
    13551355    int oldError, newError;
    1356     tr_bool oldFinished, newFinished;
     1356    bool oldFinished, newFinished;
    13571357    tr_priority_t oldPriority, newPriority;
    13581358    char * oldCollatedName, * newCollatedName;
     
    17181718{
    17191719    tr_benc * args;
    1720     tr_bool is_open = FALSE;
     1720    bool is_open = FALSE;
    17211721
    17221722    if( tr_bencDictFindDict( response, "arguments", &args ) )
  • trunk/gtk/tr-prefs.c

    r12068 r12204  
    426426onBlocklistUpdated( TrCore * core, int n, gpointer gdata )
    427427{
    428     const tr_bool success = n >= 0;
     428    const bool success = n >= 0;
    429429    const int count = n >=0 ? n : tr_blocklistGetRuleCount( gtr_core_session( core ) );
    430430    const char * s = gtr_ngettext( "Blocklist has %'d rule.", "Blocklist has %'d rules.", count );
  • trunk/gtk/tr-window.c

    r12068 r12204  
    349349
    350350static void
    351 onAltSpeedToggled( tr_session * s UNUSED, tr_bool isEnabled UNUSED, tr_bool byUser UNUSED, void * p )
     351onAltSpeedToggled( tr_session * s UNUSED, bool isEnabled UNUSED, bool byUser UNUSED, void * p )
    352352{
    353353    gtr_idle_add( onAltSpeedToggledIdle, p );
  • trunk/libtransmission/announcer-common.h

    r12184 r12204  
    7474{
    7575    /* whether or not we managed to connect to the tracker */
    76     tr_bool did_connect;
     76    bool did_connect;
    7777
    7878    /* whether or not the scrape timed out */
    79     tr_bool did_timeout;
     79    bool did_timeout;
    8080
    8181    /* how many info hashes are in the 'rows' field */
     
    129129{
    130130    tr_announce_event event;
    131     tr_bool partial_seed;
     131    bool partial_seed;
    132132
    133133    /* the port we listen for incoming peers on */
     
    179179
    180180    /* whether or not we managed to connect to the tracker */
    181     tr_bool did_connect;
     181    bool did_connect;
    182182
    183183    /* whether or not the scrape timed out */
    184     tr_bool did_timeout;
     184    bool did_timeout;
    185185
    186186    /* preferred interval between announces.
  • trunk/libtransmission/announcer-http.c

    r12177 r12204  
    114114        evutil_inet_ntop( AF_INET6, ipv6, ipv6_readable, INET6_ADDRSTRLEN );
    115115        evbuffer_add_printf( buf, "&ipv6=");
    116         tr_http_escape( buf, ipv6_readable, -1, TRUE );
     116        tr_http_escape( buf, ipv6_readable, -1, true );
    117117    }
    118118
     
    187187static void
    188188on_announce_done( tr_session   * session,
    189                   tr_bool        did_connect,
    190                   tr_bool        did_timeout,
     189                  bool           did_connect,
     190                  bool           did_timeout,
    191191                  long           response_code,
    192192                  const void   * msg,
     
    329329static void
    330330on_scrape_done( tr_session   * session,
    331                 tr_bool        did_connect,
    332                 tr_bool        did_timeout,
     331                bool           did_connect,
     332                bool           did_timeout,
    333333                long           response_code,
    334334                const void   * msg,
  • trunk/libtransmission/announcer-udp.c

    r12189 r12204  
    121121tau_action_t;
    122122
    123 static tr_bool
     123static bool
    124124is_tau_response_message( int action, int msglen )
    125125{
     
    128128    if( action == TAU_ACTION_SCRAPE   ) return msglen >= 20;
    129129    if( action == TAU_ACTION_ERROR    ) return msglen >= 8;
    130     return FALSE;
     130    return false;
    131131}
    132132
     
    212212tau_scrape_request_fail( tr_session                 * session,
    213213                         struct tau_scrape_request  * request,
    214                          tr_bool                      did_connect,
    215                          tr_bool                      did_timeout,
     214                         bool                         did_connect,
     215                         bool                         did_timeout,
    216216                         const char                 * errmsg )
    217217{
     
    228228                     struct evbuffer            * buf )
    229229{
    230     request->response.did_connect = TRUE;
    231     request->response.did_timeout = FALSE;
     230    request->response.did_connect = true;
     231    request->response.did_timeout = false;
    232232
    233233    if( action == TAU_ACTION_SCRAPE )
     
    259259            errmsg = tr_strdup( _( "Unknown error" ) );
    260260
    261         tau_scrape_request_fail( session, request, TRUE, FALSE, errmsg );
     261        tau_scrape_request_fail( session, request, true, false, errmsg );
    262262        tr_free( errmsg );
    263263    }
     
    367367tau_announce_request_fail( tr_session                   * session,
    368368                           struct tau_announce_request  * request,
    369                            tr_bool                        did_connect,
    370                            tr_bool                        did_timeout,
     369                           bool                           did_connect,
     370                           bool                           did_timeout,
    371371                           const char                   * errmsg )
    372372{
     
    383383                     struct evbuffer              * buf )
    384384{
    385     request->response.did_connect = TRUE;
    386     request->response.did_timeout = FALSE;
     385    request->response.did_connect = true;
     386    request->response.did_timeout = false;
    387387
    388388    if( ( action == TAU_ACTION_ANNOUNCE )
     
    409409            errmsg = tr_strdup( _( "Unknown error" ) );
    410410
    411         tau_announce_request_fail( session, request, TRUE, FALSE, errmsg );
     411        tau_announce_request_fail( session, request, true, false, errmsg );
    412412        tr_free( errmsg );
    413413    }
     
    428428    int port;
    429429
    430     tr_bool is_asking_dns;
     430    bool is_asking_dns;
    431431    struct evutil_addrinfo * addr;
    432432    time_t addr_expiration_time;
     
    459459static void
    460460tau_tracker_fail_all( struct tau_tracker  * tracker,
    461                       tr_bool               did_connect,
    462                       tr_bool               did_timeout,
     461                      bool                  did_connect,
     462                      bool                  did_timeout,
    463463                      const char          * errmsg )
    464464{
     
    490490    struct tau_tracker * tracker = vtracker;
    491491
    492     tracker->is_asking_dns = FALSE;
     492    tracker->is_asking_dns = false;
    493493
    494494    if ( errcode )
     
    497497                                          evdns_err_to_string( errcode ) );
    498498        dbgmsg( tracker->key, "%s", errmsg );
    499         tau_tracker_fail_all( tracker, FALSE, FALSE, errmsg );
     499        tau_tracker_fail_all( tracker, false, false, errmsg );
    500500        tr_free( errmsg );
    501501    }
     
    598598
    599599        dbgmsg( tracker->key, "%s", errmsg );
    600         tau_tracker_fail_all( tracker, TRUE, FALSE, errmsg );
     600        tau_tracker_fail_all( tracker, true, false, errmsg );
    601601        tr_free( errmsg );
    602602    }
     
    611611    tr_ptrArray * reqs;
    612612    const time_t now = time( NULL );
    613     const tr_bool cancel_all = tracker->close_at && ( tracker->close_at <= now );
     613    const bool cancel_all = tracker->close_at && ( tracker->close_at <= now );
    614614
    615615
     
    623623        if( cancel_all || ( req->created_at + TAU_REQUEST_TTL < now ) ) {
    624624            dbgmsg( tracker->key, "timeout announce req %p", req );
    625             tau_announce_request_fail( tracker->session, req, FALSE, TRUE, NULL );
     625            tau_announce_request_fail( tracker->session, req, false, true, NULL );
    626626            tau_announce_request_free( req );
    627627            tr_ptrArrayRemove( reqs, i );
     
    636636        if( cancel_all || ( req->created_at + TAU_REQUEST_TTL < now ) ) {
    637637            dbgmsg( tracker->key, "timeout scrape req %p", req );
    638             tau_scrape_request_fail( tracker->session, req, FALSE, TRUE, NULL );
     638            tau_scrape_request_fail( tracker->session, req, false, true, NULL );
    639639            tau_scrape_request_free( req );
    640640            tr_ptrArrayRemove( reqs, i );
     
    645645}
    646646
    647 static tr_bool
     647static bool
    648648tau_tracker_is_empty( const struct tau_tracker * tracker )
    649649{
     
    677677        hints.ai_socktype = SOCK_DGRAM;
    678678        hints.ai_protocol = IPPROTO_UDP;
    679         tracker->is_asking_dns = TRUE;
     679        tracker->is_asking_dns = true;
    680680        dbgmsg( tracker->host, "Trying a new DNS lookup" );     
    681681        evdns_getaddrinfo( tracker->session->evdns_base,
     
    804804}
    805805
    806 tr_bool
     806bool
    807807tr_tracker_udp_is_empty( const tr_session * session )
    808808{
     
    814814        for( i=0, n=tr_ptrArraySize(&tau->trackers); i<n; ++i )
    815815            if( !tau_tracker_is_empty( tr_ptrArrayNth( &tau->trackers, i ) ) )
    816                 return FALSE;
    817 
    818     return TRUE;
     816                return false;
     817
     818    return true;
    819819}
    820820
     
    857857/* @brief process an incoming udp message if it's a tracker response.
    858858 * @return true if msg was a tracker response; false otherwise */
    859 tr_bool
     859bool
    860860tau_handle_message( tr_session * session, const uint8_t * msg, size_t msglen )
    861861{
     
    870870
    871871    if( !session || !session->announcer_udp )
    872         return FALSE;
     872        return false;
    873873    if( msglen < (sizeof(uint32_t)*2) )
    874         return FALSE;
     874        return false;
    875875
    876876    /* extract the action_id and see if it makes sense */
     
    880880    if( !is_tau_response_message( action_id, msglen ) ) {
    881881        evbuffer_free( buf );
    882         return FALSE;
     882        return false;
    883883    }
    884884
     
    900900            on_tracker_connection_response( tracker, action_id, buf );
    901901            evbuffer_free( buf );
    902             return TRUE;
     902            return true;
    903903        }
    904904
     
    913913                tau_announce_request_free( req );
    914914                evbuffer_free( buf );
    915                 return TRUE;
     915                return true;
    916916            }
    917917        }
     
    927927                tau_scrape_request_free( req );
    928928                evbuffer_free( buf );
    929                 return TRUE;
     929                return true;
    930930            }
    931931        }
     
    934934    /* no match... */
    935935    evbuffer_free( buf );
    936     return FALSE;
     936    return false;
    937937}
    938938
  • trunk/libtransmission/announcer.c

    r12190 r12204  
    129129tr_announcer;
    130130
    131 tr_bool
     131bool
    132132tr_announcerHasBacklog( const struct tr_announcer * announcer )
    133133{
     
    265265    time_t lastScrapeStartTime;
    266266    time_t lastScrapeTime;
    267     tr_bool lastScrapeSucceeded;
    268     tr_bool lastScrapeTimedOut;
     267    bool lastScrapeSucceeded;
     268    bool lastScrapeTimedOut;
    269269
    270270    time_t announceAt;
     
    272272    time_t lastAnnounceStartTime;
    273273    time_t lastAnnounceTime;
    274     tr_bool lastAnnounceSucceeded;
    275     tr_bool lastAnnounceTimedOut;
     274    bool lastAnnounceSucceeded;
     275    bool lastAnnounceTimedOut;
    276276
    277277    tr_announce_event * announce_events;
     
    288288    int lastAnnouncePeerCount;
    289289
    290     tr_bool isRunning;
    291     tr_bool isAnnouncing;
    292     tr_bool isScraping;
    293     tr_bool wasCopied;
     290    bool isRunning;
     291    bool isAnnouncing;
     292    bool isScraping;
     293    bool wasCopied;
    294294
    295295    char lastAnnounceStr[128];
     
    353353    tier->announceIntervalSec = DEFAULT_ANNOUNCE_INTERVAL_SEC;
    354354    tier->announceMinIntervalSec = DEFAULT_ANNOUNCE_MIN_INTERVAL_SEC;
    355     tier->isAnnouncing = FALSE;
    356     tier->isScraping = FALSE;
     355    tier->isAnnouncing = false;
     356    tier->isScraping = false;
    357357    tier->lastAnnounceStartTime = 0;
    358358    tier->lastScrapeStartTime = 0;
     
    559559            char * host;
    560560            char * path;
    561             tr_bool is_duplicate = FALSE;
     561            bool is_duplicate = false;
    562562            tr_urlParse( input[i].announce, -1, &scheme, &host, &port, &path );
    563563
     
    678678***/
    679679
    680 static tr_bool
     680static bool
    681681tierCanManualAnnounce( const tr_tier * tier )
    682682{
     
    684684}
    685685
    686 tr_bool
     686bool
    687687tr_announcerCanManualAnnounce( const tr_torrent * tor )
    688688{
     
    695695
    696696    if( !tor->isRunning )
    697         return FALSE;
     697        return false;
    698698
    699699    /* return true if any tier can manual announce */
     
    702702    for( i=0; i<n; ++i )
    703703        if( tierCanManualAnnounce( tiers[i] ) )
    704             return TRUE;
    705 
    706     return FALSE;
     704            return true;
     705
     706    return false;
    707707}
    708708
     
    777777         * dump everything leading up to it except "completed" */
    778778        if( e == TR_ANNOUNCE_EVENT_STOPPED ) {
    779             tr_bool has_completed = FALSE;
     779            bool has_completed = false;
    780780            const tr_announce_event c = TR_ANNOUNCE_EVENT_COMPLETED;
    781781            for( i=0; !has_completed && i<tier->announce_event_count; ++i )
     
    964964
    965965    /** If the request succeeds, the value for tier's "isRunning" flag */
    966     tr_bool isRunningOnSuccess;
     966    bool isRunningOnSuccess;
    967967};
    968968
     
    10361036        tier->lastAnnounceTime = now;
    10371037        tier->lastAnnounceTimedOut = response->did_timeout;
    1038         tier->lastAnnounceSucceeded = FALSE;
    1039         tier->isAnnouncing = FALSE;
     1038        tier->lastAnnounceSucceeded = false;
     1039        tier->isAnnouncing = false;
    10401040        tier->manualAnnounceAllowedAt = now + tier->announceMinIntervalSec;
    10411041
     
    10571057            int i;
    10581058            const char * str;
    1059             const tr_bool isStopped = event == TR_ANNOUNCE_EVENT_STOPPED;
     1059            const bool isStopped = event == TR_ANNOUNCE_EVENT_STOPPED;
    10601060
    10611061            publishErrorClear( tier );
     
    11031103            tier->scrapeAt = now + tier->scrapeIntervalSec;
    11041104            tier->lastScrapeTime = now;
    1105             tier->lastScrapeSucceeded = TRUE;
    1106             tier->lastAnnounceSucceeded = TRUE;
     1105            tier->lastScrapeSucceeded = true;
     1106            tier->lastAnnounceSucceeded = true;
    11071107            tier->lastAnnouncePeerCount = response->pex_count
    11081108                                        + response->pex6_count;
     
    11721172    data->event = announce_event;
    11731173
    1174     tier->isAnnouncing = TRUE;
     1174    tier->isAnnouncing = true;
    11751175    tier->lastAnnounceStartTime = now;
    11761176    --announcer->slotsAvailable;
     
    12051205    interval = getRetryInterval( tier->currentTracker );
    12061206    dbgmsg( tier, "Retrying scrape in %d seconds.", interval );
    1207     tier->lastScrapeSucceeded = FALSE;
     1207    tier->lastScrapeSucceeded = false;
    12081208    tier->scrapeAt = tr_time() + interval;
    12091209}
     
    12641264                              response->errmsg ? response->errmsg : "none" );
    12651265
    1266                 tier->isScraping = FALSE;
     1266                tier->isScraping = false;
    12671267                tier->lastScrapeTime = now;
    1268                 tier->lastScrapeSucceeded = FALSE;
     1268                tier->lastScrapeSucceeded = false;
    12691269                tier->lastScrapeTimedOut = response->did_timeout;
    12701270
     
    12851285                    tr_tracker * tracker;
    12861286
    1287                     tier->lastScrapeSucceeded = TRUE;
     1287                    tier->lastScrapeSucceeded = true;
    12881288                    tier->scrapeIntervalSec = MAX( DEFAULT_SCRAPE_INTERVAL_SEC,
    12891289                                                   response->min_request_interval );
     
    13541354
    13551355            memcpy( req->info_hash[req->info_hash_count++], hash, SHA_DIGEST_LENGTH );
    1356             tier->isScraping = TRUE;
     1356            tier->isScraping = true;
    13571357            tier->lastScrapeStartTime = now;
    13581358            break;
     
    13671367
    13681368            memcpy( req->info_hash[req->info_hash_count++], hash, SHA_DIGEST_LENGTH );
    1369             tier->isScraping = TRUE;
     1369            tier->isScraping = true;
    13701370            tier->lastScrapeStartTime = now;
    13711371        }
     
    13921392}
    13931393
    1394 static tr_bool
     1394static bool
    13951395tierNeedsToAnnounce( const tr_tier * tier, const time_t now )
    13961396{
     
    14021402}
    14031403
    1404 static tr_bool
     1404static bool
    14051405tierNeedsToScrape( const tr_tier * tier, const time_t now )
    14061406{
     
    14861486    tr_announcer * announcer = vannouncer;
    14871487    tr_session * session = announcer->session;
    1488     const tr_bool is_closing = session->isClosed;
     1488    const bool is_closing = session->isClosed;
    14891489    const time_t now = tr_time( );
    14901490
     
    17071707                    t->currentTracker = item;
    17081708                    t->currentTrackerIndex = k;
    1709                     t->wasCopied = TRUE;
     1709                    t->wasCopied = true;
    17101710                    trackerItemCopyAttributes( item, o->currentTracker );
    17111711                    dbgmsg( t, "attributes copied to tier %d, tracker %d"
  • trunk/libtransmission/announcer.h

    r12184 r12204  
    7777                                                  void                * cbdata );
    7878
    79 tr_bool tr_announcerHasBacklog( const struct tr_announcer * );
     79bool tr_announcerHasBacklog( const struct tr_announcer * );
    8080
    8181void tr_announcerResetTorrent( struct tr_announcer*, tr_torrent* );
     
    8686void tr_announcerChangeMyPort( tr_torrent * );
    8787
    88 tr_bool tr_announcerCanManualAnnounce( const tr_torrent * );
     88bool tr_announcerCanManualAnnounce( const tr_torrent * );
    8989
    9090void tr_announcerManualAnnounce( tr_torrent * );
     
    113113void tr_tracker_udp_close( tr_session * session );
    114114
    115 tr_bool tr_tracker_udp_is_empty( const tr_session * session );
     115bool tr_tracker_udp_is_empty( const tr_session * session );
    116116
    117117
  • trunk/libtransmission/bandwidth.c

    r12177 r12204  
    104104    b->children = TR_PTR_ARRAY_INIT;
    105105    b->magicNumber = BANDWIDTH_MAGIC_NUMBER;
    106     b->band[TR_UP].honorParentLimits = TRUE;
    107     b->band[TR_DOWN].honorParentLimits = TRUE;
     106    b->band[TR_UP].honorParentLimits = true;
     107    b->band[TR_DOWN].honorParentLimits = true;
    108108    tr_bandwidthSetParent( b, parent );
    109109    return b;
     
    388388                  tr_direction    dir,
    389389                  size_t          byteCount,
    390                   tr_bool         isPieceData,
     390                  bool         isPieceData,
    391391                  uint64_t        now )
    392392{
  • trunk/libtransmission/bandwidth.h

    r12170 r12204  
    5656struct tr_band
    5757{
    58     tr_bool isLimited;
    59     tr_bool honorParentLimits;
     58    bool isLimited;
     59    bool honorParentLimits;
    6060    unsigned int bytesLeft;
    6161    unsigned int desiredSpeed_Bps;
     
    142142
    143143/** @brief test to see if the pointer refers to a live bandwidth object */
    144 static inline tr_bool tr_isBandwidth( const tr_bandwidth  * b )
     144static inline bool tr_isBandwidth( const tr_bandwidth  * b )
    145145{
    146146    return ( b != NULL ) && ( b->magicNumber == BANDWIDTH_MAGIC_NUMBER );
     
    156156 * @see tr_bandwidthGetDesiredSpeed
    157157 */
    158 static inline tr_bool tr_bandwidthSetDesiredSpeed_Bps( tr_bandwidth        * bandwidth,
    159                                                        tr_direction          dir,
    160                                                        unsigned int          desiredSpeed )
     158static inline bool tr_bandwidthSetDesiredSpeed_Bps( tr_bandwidth        * bandwidth,
     159                                                    tr_direction          dir,
     160                                                    unsigned int          desiredSpeed )
    161161{
    162162    unsigned int * value = &bandwidth->band[dir].desiredSpeed_Bps;
    163     const tr_bool didChange = desiredSpeed != *value;
     163    const bool didChange = desiredSpeed != *value;
    164164    *value = desiredSpeed;
    165165    return didChange;
     
    179179 * @brief Set whether or not this bandwidth should throttle its peer-io's speeds
    180180 */
    181 static inline tr_bool tr_bandwidthSetLimited( tr_bandwidth        * bandwidth,
    182                                                  tr_direction          dir,
    183                                                  tr_bool               isLimited )
    184 {
    185     tr_bool * value = &bandwidth->band[dir].isLimited;
    186     const tr_bool didChange = isLimited != *value;
     181static inline bool tr_bandwidthSetLimited( tr_bandwidth  * bandwidth,
     182                                           tr_direction    dir,
     183                                           bool            isLimited )
     184{
     185    bool * value = &bandwidth->band[dir].isLimited;
     186    const bool didChange = isLimited != *value;
    187187    *value = isLimited;
    188188    return didChange;
     
    192192 * @return nonzero if this bandwidth throttles its peer-ios speeds
    193193 */
    194 static inline tr_bool tr_bandwidthIsLimited( const tr_bandwidth  * bandwidth,
    195                                                 tr_direction          dir )
     194static inline bool tr_bandwidthIsLimited( const tr_bandwidth  * bandwidth,
     195                                          tr_direction          dir )
    196196{
    197197    return bandwidth->band[dir].isLimited;
     
    233233                                        tr_direction          direction,
    234234                                        size_t                byteCount,
    235                                         tr_bool               isPieceData,
     235                                        bool                  isPieceData,
    236236                                        uint64_t              now );
    237237
     
    249249 * in that particular case we want to ignore the global speed limit...
    250250 */
    251 static inline tr_bool tr_bandwidthHonorParentLimits ( tr_bandwidth        * bandwidth,
    252                                                          tr_direction          direction,
    253                                                          tr_bool               isEnabled )
    254 {
    255     tr_bool * value = &bandwidth->band[direction].honorParentLimits;
    256     const tr_bool didChange = isEnabled != *value;
     251static inline bool tr_bandwidthHonorParentLimits ( tr_bandwidth   * bandwidth,
     252                                                   tr_direction     direction,
     253                                                   bool             isEnabled )
     254{
     255    bool * value = &bandwidth->band[direction].honorParentLimits;
     256    const bool didChange = isEnabled != *value;
    257257    *value = isEnabled;
    258258    return didChange;
    259259}
    260260
    261 static inline tr_bool tr_bandwidthAreParentLimitsHonored( tr_bandwidth  * bandwidth,
    262                                                              tr_direction    direction )
     261static inline bool tr_bandwidthAreParentLimitsHonored( tr_bandwidth  * bandwidth,
     262                                                       tr_direction    direction )
    263263{
    264264    assert( tr_isBandwidth( bandwidth ) );
  • trunk/libtransmission/bencode-test.c

    r11548 r12204  
    236236    tr_bencFree( &val );
    237237
    238     if( ( err = testString( "llleee", TRUE ) ) )
    239         return err;
    240     if( ( err = testString( "d3:cow3:moo4:spam4:eggse", TRUE ) ) )
    241         return err;
    242     if( ( err = testString( "d4:spaml1:a1:bee", TRUE ) ) )
     238    if( ( err = testString( "llleee", true ) ) )
     239        return err;
     240    if( ( err = testString( "d3:cow3:moo4:spam4:eggse", true ) ) )
     241        return err;
     242    if( ( err = testString( "d4:spaml1:a1:bee", true ) ) )
    243243        return err;
    244244    if( ( err =
    245245             testString( "d5:greenli1ei2ei3ee4:spamd1:ai123e3:keyi214eee",
    246                          TRUE ) ) )
     246                         true ) ) )
    247247        return err;
    248248    if( ( err =
    249249             testString(
    250250                 "d9:publisher3:bob17:publisher-webpage15:www.example.com18:publisher.location4:homee",
    251                  TRUE ) ) )
     251                 true ) ) )
    252252        return err;
    253253    if( ( err =
    254254             testString(
    255255                 "d8:completei1e8:intervali1800e12:min intervali1800e5:peers0:e",
    256                  TRUE ) ) )
    257         return err;
    258     if( ( err = testString( "d1:ai0e1:be", FALSE ) ) ) /* odd number of children
     256                 true ) ) )
     257        return err;
     258    if( ( err = testString( "d1:ai0e1:be", false ) ) ) /* odd number of children
    259259                                                         */
    260260        return err;
    261     if( ( err = testString( "", FALSE ) ) )
    262         return err;
    263     if( ( err = testString( " ", FALSE ) ) )
     261    if( ( err = testString( "", false ) ) )
     262        return err;
     263    if( ( err = testString( " ", false ) ) )
    264264        return err;
    265265
     
    459459    tr_benc top;
    460460    int64_t intVal;
    461     tr_bool boolVal;
     461    bool boolVal;
    462462
    463463    tr_bencInitDict( &top, 0 );
    464464
    465     tr_bencDictAddBool( &top, "key1", FALSE );
     465    tr_bencDictAddBool( &top, "key1", false );
    466466    tr_bencDictAddBool( &top, "key2", 0 );
    467     tr_bencDictAddInt ( &top, "key3", TRUE );
     467    tr_bencDictAddInt ( &top, "key3", true );
    468468    tr_bencDictAddInt ( &top, "key4", 1 );
    469469    check( tr_bencDictFindBool( &top, "key1", &boolVal ) )
     
    496496    const char * strVal;
    497497    double realVal;
    498     tr_bool boolVal;
     498    bool boolVal;
    499499    int len;
    500500    char * benc;
     
    502502
    503503    tr_bencInitDict( &top, 0 );
    504     tr_bencDictAddBool( &top, "this-is-a-bool", TRUE );
     504    tr_bencDictAddBool( &top, "this-is-a-bool", true );
    505505    tr_bencDictAddInt( &top, "this-is-an-int", 1234 );
    506506    tr_bencDictAddReal( &top, "this-is-a-real", 0.5 );
     
    515515    check( intVal == 1234 )
    516516    check( tr_bencDictFindBool( &top, "this-is-a-bool", &boolVal ) )
    517     check( boolVal == TRUE )
     517    check( boolVal == true )
    518518    check( tr_bencDictFindStr( &top, "this-is-a-string", &strVal ) )
    519519    check( !strcmp( strVal, "this-is-a-string" ) )
  • trunk/libtransmission/bencode.c

    r12177 r12204  
    4949**/
    5050
    51 static tr_bool
     51static bool
    5252isContainer( const tr_benc * val )
    5353{
     
    5555}
    5656
    57 static tr_bool
     57static bool
    5858isSomething( const tr_benc * val )
    5959{
     
    405405}
    406406
    407 static tr_bool
     407static bool
    408408tr_bencDictFindType( tr_benc * dict, const char * key, int type, tr_benc ** setme )
    409409{
     
    447447}
    448448
    449 tr_bool
     449bool
    450450tr_bencGetInt( const tr_benc * val,
    451451               int64_t *       setme )
    452452{
    453     tr_bool success = FALSE;
     453    bool success = false;
    454454
    455455    if( !success && (( success = tr_bencIsInt( val ))))
     
    466466}
    467467
    468 tr_bool
     468bool
    469469tr_bencGetStr( const tr_benc * val, const char ** setme )
    470470{
    471     const tr_bool success = tr_bencIsString( val );
     471    const bool success = tr_bencIsString( val );
    472472
    473473    if( success )
     
    477477}
    478478
    479 tr_bool
     479bool
    480480tr_bencGetRaw( const tr_benc * val, const uint8_t ** setme_raw, size_t * setme_len )
    481481{
    482     const tr_bool success = tr_bencIsString( val );
     482    const bool success = tr_bencIsString( val );
    483483
    484484    if( success ) {
     
    490490}
    491491
    492 tr_bool
    493 tr_bencGetBool( const tr_benc * val, tr_bool * setme )
     492bool
     493tr_bencGetBool( const tr_benc * val, bool * setme )
    494494{
    495495    const char * str;
    496     tr_bool success = FALSE;
     496    bool success = false;
    497497
    498498    if(( success = tr_bencIsBool( val )))
     
    510510}
    511511
    512 tr_bool
     512bool
    513513tr_bencGetReal( const tr_benc * val, double * setme )
    514514{
    515     tr_bool success = FALSE;
     515    bool success = false;
    516516
    517517    if( !success && (( success = tr_bencIsReal( val ))))
     
    541541}
    542542
    543 tr_bool
     543bool
    544544tr_bencDictFindInt( tr_benc * dict, const char * key, int64_t * setme )
    545545{
     
    547547}
    548548
    549 tr_bool
    550 tr_bencDictFindBool( tr_benc * dict, const char * key, tr_bool * setme )
     549bool
     550tr_bencDictFindBool( tr_benc * dict, const char * key, bool * setme )
    551551{
    552552    return tr_bencGetBool( tr_bencDictFind( dict, key ), setme );
    553553}
    554554
    555 tr_bool
     555bool
    556556tr_bencDictFindReal( tr_benc * dict, const char * key, double * setme )
    557557{
     
    559559}
    560560
    561 tr_bool
     561bool
    562562tr_bencDictFindStr( tr_benc *  dict, const char *  key, const char ** setme )
    563563{
     
    565565}
    566566
    567 tr_bool
     567bool
    568568tr_bencDictFindList( tr_benc * dict, const char * key, tr_benc ** setme )
    569569{
     
    571571}
    572572
    573 tr_bool
     573bool
    574574tr_bencDictFindDict( tr_benc * dict, const char * key, tr_benc ** setme )
    575575{
     
    577577}
    578578
    579 tr_bool
     579bool
    580580tr_bencDictFindRaw( tr_benc * dict, const char * key, const uint8_t  ** setme_raw, size_t * setme_len )
    581581{
     
    706706
    707707tr_benc *
    708 tr_bencListAddBool( tr_benc * list, tr_bool val )
     708tr_bencListAddBool( tr_benc * list, bool val )
    709709{
    710710    tr_benc * node = tr_bencListAdd( list );
     
    800800
    801801tr_benc*
    802 tr_bencDictAddBool( tr_benc * dict, const char * key, tr_bool val )
     802tr_bencDictAddBool( tr_benc * dict, const char * key, bool val )
    803803{
    804804    tr_benc * child = dictFindOrAdd( dict, key, TR_TYPE_BOOL );
     
    943943
    944944static void
    945 nodeInitDict( struct SaveNode * node, const tr_benc * val, tr_bool sort_dicts )
     945nodeInitDict( struct SaveNode * node, const tr_benc * val, bool sort_dicts )
    946946{
    947947    const int n = val->val.l.count;
     
    10071007
    10081008static void
    1009 nodeInit( struct SaveNode * node, const tr_benc * val, tr_bool sort_dicts )
     1009nodeInit( struct SaveNode * node, const tr_benc * val, bool sort_dicts )
    10101010{
    10111011    static const struct SaveNode INIT_NODE = { NULL, 0, 0, 0, NULL };
     
    10391039          const struct WalkFuncs * walkFuncs,
    10401040          void                   * user_data,
    1041           tr_bool                  sort_dicts )
     1041          bool                     sort_dicts )
    10421042{
    10431043    int stackSize = 0;
     
    10551055        {
    10561056            val = node->val;
    1057             node->valIsVisited = TRUE;
     1057            node->valIsVisited = true;
    10581058        }
    10591059        else if( node->childIndex < node->childCount )
     
    12261226{
    12271227    if( isSomething( val ) )
    1228         bencWalk( val, &freeWalkFuncs, NULL, FALSE );
     1228        bencWalk( val, &freeWalkFuncs, NULL, false );
    12291229}
    12301230
     
    12441244struct jsonWalk
    12451245{
    1246     tr_bool doIndent;
     1246    bool doIndent;
    12471247    tr_list * parents;
    12481248    struct evbuffer *  out;
     
    12781278                    evbuffer_add( data->out, ": ", data->doIndent ? 2 : 1 );
    12791279                else {
    1280                     const tr_bool isLast = parentState->childIndex == parentState->childCount;
     1280                    const bool isLast = parentState->childIndex == parentState->childCount;
    12811281                    if( !isLast ) {
    12821282                        evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
     
    12891289            case TR_TYPE_LIST:
    12901290            {
    1291                 const tr_bool isLast = ++parentState->childIndex == parentState->childCount;
     1291                const bool isLast = ++parentState->childIndex == parentState->childCount;
    12921292                if( !isLast ) {
    12931293                    evbuffer_add( data->out, ", ", data->doIndent ? 2 : 1 );
     
    14471447{
    14481448    struct jsonWalk * data = vdata;
    1449     int               emptyContainer = FALSE;
     1449    int               emptyContainer = false;
    14501450
    14511451    jsonPopParent( data );
     
    14811481       if( tr_bencIsBool( val ) )
    14821482       {
    1483            tr_bool boolVal = 0;
     1483           bool boolVal = 0;
    14841484           tr_bencGetBool( val, &boolVal );
    14851485           tr_bencListAddBool( target, boolVal );
     
    15271527}
    15281528
    1529 tr_bool
     1529bool
    15301530tr_bencDictChild( tr_benc * dict, size_t n, const char ** key, tr_benc ** val )
    15311531{
    1532     tr_bool success = 0;
     1532    bool success = 0;
    15331533
    15341534    assert( tr_bencIsDict( dict ) );
     
    15641564            if( tr_bencIsBool( val ) )
    15651565            {
    1566                 tr_bool boolVal;
     1566                bool boolVal;
    15671567                tr_bencGetBool( val, &boolVal );
    15681568                tr_bencDictAddBool( target, key, boolVal );
     
    16161616    {
    16171617        case TR_FMT_BENC:
    1618             bencWalk( top, &saveFuncs, buf, TRUE );
     1618            bencWalk( top, &saveFuncs, buf, true );
    16191619            break;
    16201620
     
    16251625            data.out = buf;
    16261626            data.parents = NULL;
    1627             bencWalk( top, &jsonWalkFuncs, &data, TRUE );
     1627            bencWalk( top, &jsonWalkFuncs, &data, true );
    16281628            if( evbuffer_get_length( buf ) )
    16291629                evbuffer_add_printf( buf, "\n" );
  • trunk/libtransmission/bencode.h

    r12012 r12204  
    139139tr_benc * tr_bencListAdd( tr_benc * );
    140140
    141 tr_benc * tr_bencListAddBool( tr_benc *, tr_bool val );
     141tr_benc * tr_bencListAddBool( tr_benc *, bool val );
    142142
    143143tr_benc * tr_bencListAddInt( tr_benc *, int64_t val );
     
    173173tr_benc * tr_bencDictAddInt( tr_benc *, const char * key, int64_t );
    174174
    175 tr_benc * tr_bencDictAddBool( tr_benc *, const char * key, tr_bool );
     175tr_benc * tr_bencDictAddBool( tr_benc *, const char * key, bool );
    176176
    177177tr_benc * tr_bencDictAddStr( tr_benc *, const char * key, const char * );
     
    184184                             const void * raw, size_t rawlen );
    185185
    186 tr_bool   tr_bencDictChild( tr_benc *, size_t i, const char ** key, tr_benc ** val );
     186bool      tr_bencDictChild( tr_benc *, size_t i, const char ** key, tr_benc ** val );
    187187
    188188tr_benc*  tr_bencDictFind( tr_benc *, const char * key );
    189189
    190 tr_bool   tr_bencDictFindList( tr_benc *, const char * key, tr_benc ** setme );
    191 
    192 tr_bool   tr_bencDictFindDict( tr_benc *, const char * key, tr_benc ** setme );
    193 
    194 tr_bool   tr_bencDictFindInt( tr_benc *, const char * key, int64_t * setme );
    195 
    196 tr_bool   tr_bencDictFindReal( tr_benc *, const char * key, double * setme );
    197 
    198 tr_bool   tr_bencDictFindBool( tr_benc *, const char * key, tr_bool * setme );
    199 
    200 tr_bool   tr_bencDictFindStr( tr_benc *, const char * key, const char ** setme );
    201 
    202 tr_bool   tr_bencDictFindRaw( tr_benc *, const char * key,
     190bool      tr_bencDictFindList( tr_benc *, const char * key, tr_benc ** setme );
     191
     192bool      tr_bencDictFindDict( tr_benc *, const char * key, tr_benc ** setme );
     193
     194bool      tr_bencDictFindInt( tr_benc *, const char * key, int64_t * setme );
     195
     196bool      tr_bencDictFindReal( tr_benc *, const char * key, double * setme );
     197
     198bool      tr_bencDictFindBool( tr_benc *, const char * key, bool * setme );
     199
     200bool      tr_bencDictFindStr( tr_benc *, const char * key, const char ** setme );
     201
     202bool      tr_bencDictFindRaw( tr_benc *, const char * key,
    203203                              const uint8_t ** setme_raw, size_t * setme_len );
    204204
     
    208208
    209209/** @brief Get an int64_t from a variant object
    210     @return TRUE if successful, or FALSE if the variant could not be represented as an int64_t  */
    211 tr_bool   tr_bencGetInt( const tr_benc * val, int64_t * setme );
     210    @return true if successful, or false if the variant could not be represented as an int64_t  */
     211bool      tr_bencGetInt( const tr_benc * val, int64_t * setme );
    212212
    213213/** @brief Get an string from a variant object
    214     @return TRUE if successful, or FALSE if the variant could not be represented as a string  */
    215 tr_bool   tr_bencGetStr( const tr_benc * val, const char ** setme );
     214    @return true if successful, or false if the variant could not be represented as a string  */
     215bool      tr_bencGetStr( const tr_benc * val, const char ** setme );
    216216
    217217/** @brief Get a raw byte array from a variant object
    218     @return TRUE if successful, or FALSE if the variant could not be represented as a raw byte array */
    219 tr_bool   tr_bencGetRaw( const tr_benc * val, const uint8_t  ** setme_raw, size_t * setme_len );
     218    @return true if successful, or false if the variant could not be represented as a raw byte array */
     219bool      tr_bencGetRaw( const tr_benc * val, const uint8_t  ** setme_raw, size_t * setme_len );
    220220
    221221/** @brief Get a boolean from a variant object
    222     @return TRUE if successful, or FALSE if the variant could not be represented as a boolean  */
    223 tr_bool   tr_bencGetBool( const tr_benc * val, tr_bool * setme );
     222    @return true if successful, or false if the variant could not be represented as a boolean  */
     223bool      tr_bencGetBool( const tr_benc * val, bool * setme );
    224224
    225225/** @brief Get a floating-point number from a variant object
    226     @return TRUE if successful, or FALSE if the variant could not be represented as a floating-point number  */
    227 tr_bool   tr_bencGetReal( const tr_benc * val, double * setme );
    228 
    229 static inline tr_bool tr_bencIsType  ( const tr_benc * b, int type ) { return ( b != NULL ) && ( b->type == type ); }
    230 
    231 static inline tr_bool tr_bencIsInt   ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_INT ); }
    232 static inline tr_bool tr_bencIsDict  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_DICT ); }
    233 static inline tr_bool tr_bencIsList  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_LIST ); }
    234 static inline tr_bool tr_bencIsString( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_STR ); }
    235 static inline tr_bool tr_bencIsBool  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_BOOL ); }
    236 static inline tr_bool tr_bencIsReal  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_REAL ); }
     226    @return true if successful, or false if the variant could not be represented as a floating-point number  */
     227bool      tr_bencGetReal( const tr_benc * val, double * setme );
     228
     229static inline bool tr_bencIsType  ( const tr_benc * b, int type ) { return ( b != NULL ) && ( b->type == type ); }
     230
     231static inline bool tr_bencIsInt   ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_INT ); }
     232static inline bool tr_bencIsDict  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_DICT ); }
     233static inline bool tr_bencIsList  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_LIST ); }
     234static inline bool tr_bencIsString( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_STR ); }
     235static inline bool tr_bencIsBool  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_BOOL ); }
     236static inline bool tr_bencIsReal  ( const tr_benc * b ) { return tr_bencIsType( b, TR_TYPE_REAL ); }
    237237
    238238/** @brief Private function that's exposed here only for unit tests */
  • trunk/libtransmission/bitfield.h

    r12012 r12204  
    6161    need to call tr_bitfieldTestFast() first before you
    6262    start looping. */
    63 static inline tr_bool tr_bitfieldHasFast( const tr_bitfield * b, const size_t nth )
     63static inline bool tr_bitfieldHasFast( const tr_bitfield * b, const size_t nth )
    6464{
    6565    return ( b->bits[nth>>3u] << ( nth & 7u ) & 0x80 ) != 0;
     
    6767
    6868/** @param high the highest nth bit you're going to access */
    69 static inline tr_bool tr_bitfieldTestFast( const tr_bitfield * b, const size_t high )
     69static inline bool tr_bitfieldTestFast( const tr_bitfield * b, const size_t high )
    7070{
    7171    return ( b != NULL )
     
    7474}
    7575
    76 static inline tr_bool tr_bitfieldHas( const tr_bitfield * b, size_t nth )
     76static inline bool tr_bitfieldHas( const tr_bitfield * b, size_t nth )
    7777{
    7878    return tr_bitfieldTestFast( b, nth ) && tr_bitfieldHasFast( b, nth );
  • trunk/libtransmission/bitset.c

    r12177 r12204  
    1919#include "utils.h"
    2020
    21 const tr_bitset TR_BITSET_INIT = { FALSE, FALSE, { NULL, 0, 0 } };
     21const tr_bitset TR_BITSET_INIT = { false, false, { NULL, 0, 0 } };
    2222
    2323void
     
    4040    tr_free( b->bitfield.bits );
    4141    b->bitfield.bits = NULL;
    42     b->haveAll = FALSE;
    43     b->haveNone = FALSE;
     42    b->haveAll = false;
     43    b->haveNone = false;
    4444}
    4545
     
    4848{
    4949    tr_bitsetClear( b );
    50     b->haveAll = TRUE;
     50    b->haveAll = true;
    5151}
    5252
     
    5555{
    5656    tr_bitsetClear( b );
    57     b->haveNone = TRUE;
     57    b->haveNone = true;
    5858}
    5959
     
    9292        return;
    9393
    94     b->haveNone = FALSE;
     94    b->haveNone = false;
    9595
    9696    /* do we need to resize the bitfield to accomodate this bit? */
     
    115115        return;
    116116
    117     b->haveAll = FALSE;
     117    b->haveAll = false;
    118118
    119119    if( !b->bitfield.bits )
     
    132132        return;
    133133
    134     b->haveAll = FALSE;
     134    b->haveAll = false;
    135135    if( !b->bitfield.bits )
    136136    {
     
    146146***/
    147147
    148 tr_bool
     148bool
    149149tr_bitsetHas( const tr_bitset * b, const size_t nth )
    150150{
    151     if( b->haveAll ) return TRUE;
    152     if( b->haveNone ) return FALSE;
    153     if( nth >= b->bitfield.bitCount ) return FALSE;
     151    if( b->haveAll ) return true;
     152    if( b->haveNone ) return false;
     153    if( nth >= b->bitfield.bitCount ) return false;
    154154    return tr_bitfieldHas( &b->bitfield, nth );
    155155}
     
    185185***/
    186186
    187 tr_bool
     187bool
    188188tr_bitsetFromBenc( tr_bitset * b, tr_benc * benc )
    189189{
    190190    size_t buflen;
    191191    const uint8_t * buf;
    192     tr_bool handled = FALSE;
     192    bool handled = false;
    193193
    194194    if( tr_bencGetRaw( benc, &buf, &buflen ) )
     
    197197        {
    198198            tr_bitsetSetHaveAll( b );
    199             handled = TRUE;
     199            handled = true;
    200200        }
    201201        else if( ( buflen == 4 ) && !memcmp( buf, "none", 4 ) )
    202202        {
    203203            tr_bitsetSetHaveNone( b );
    204             handled = TRUE;
     204            handled = true;
    205205        }
    206206        else
    207207        {
    208             b->haveAll = FALSE;
    209             b->haveNone = FALSE;
     208            b->haveAll = false;
     209            b->haveNone = false;
    210210            tr_free( b->bitfield.bits );
    211211            b->bitfield.bits = tr_memdup( buf, buflen );
    212212            b->bitfield.byteCount = buflen;
    213213            b->bitfield.bitCount = buflen * 8;
    214             handled = TRUE;
     214            handled = true;
    215215        }
    216216    }
  • trunk/libtransmission/bitset.h

    r12109 r12204  
    2424typedef struct tr_bitset
    2525{
    26     tr_bool haveAll;
    27     tr_bool haveNone;
     26    bool haveAll;
     27    bool haveNone;
    2828    tr_bitfield bitfield;
    2929}
     
    4545
    4646struct tr_benc;
    47 tr_bool tr_bitsetFromBenc( tr_bitset * bitset, struct tr_benc * benc );
     47bool tr_bitsetFromBenc( tr_bitset * bitset, struct tr_benc * benc );
    4848void tr_bitsetToBenc( const tr_bitset * bitset, struct tr_benc * benc );
    4949
     
    5454double tr_bitsetPercent( const tr_bitset * b );
    5555
    56 tr_bool tr_bitsetHas( const tr_bitset * b, const size_t nth );
     56bool tr_bitsetHas( const tr_bitset * b, const size_t nth );
    5757size_t tr_bitsetCountRange( const tr_bitset * b, const size_t begin, const size_t end );
    5858
  • trunk/libtransmission/blocklist-test.c

    r7783 r12204  
    6666    remove( tmpfile_bin );
    6767
    68     b = _tr_blocklistNew( tmpfile_bin, TRUE );
     68    b = _tr_blocklistNew( tmpfile_bin, true );
    6969    createTestBlocklist( tmpfile_txt );
    7070    _tr_blocklistSetContent( b, tmpfile_txt );
  • trunk/libtransmission/blocklist.c

    r11888 r12204  
    5555struct tr_blocklist
    5656{
    57     tr_bool                isEnabled;
     57    bool                   isEnabled;
    5858    int                    fd;
    5959    size_t                 ruleCount;
     
    148148
    149149tr_blocklist *
    150 _tr_blocklistNew( const char * filename, tr_bool isEnabled )
     150_tr_blocklistNew( const char * filename, bool isEnabled )
    151151{
    152152    tr_blocklist * b;
     
    236236 * http://en.wikipedia.org/wiki/PeerGuardian#P2P_plaintext_format
    237237 */
    238 static tr_bool
     238static bool
    239239parseLine1( const char * line, struct tr_ipv4_range * range )
    240240{
     
    247247    walk = strrchr( line, ':' );
    248248    if( !walk )
    249         return FALSE;
     249        return false;
    250250    ++walk; /* walk past the colon */
    251251
     
    253253                &b[0], &b[1], &b[2], &b[3],
    254254                &e[0], &e[1], &e[2], &e[3] ) != 8 )
    255         return FALSE;
     255        return false;
    256256
    257257    tr_snprintf( str, sizeof( str ), "%d.%d.%d.%d", b[0], b[1], b[2], b[3] );
    258258    if( tr_pton( str, &addr ) == NULL )
    259         return FALSE;
     259        return false;
    260260    range->begin = ntohl( addr.addr.addr4.s_addr );
    261261
    262262    tr_snprintf( str, sizeof( str ), "%d.%d.%d.%d", e[0], e[1], e[2], e[3] );
    263263    if( tr_pton( str, &addr ) == NULL )
    264         return FALSE;
     264        return false;
    265265    range->end = ntohl( addr.addr.addr4.s_addr );
    266266
    267     return TRUE;
     267    return true;
    268268}
    269269
     
    272272 * http://wiki.phoenixlabs.org/wiki/DAT_Format
    273273 */
    274 static tr_bool
     274static bool
    275275parseLine2( const char * line, struct tr_ipv4_range * range )
    276276{
     
    285285                &b[0], &b[1], &b[2], &b[3],
    286286                &unk ) != 9 )
    287         return FALSE;
     287        return false;
    288288
    289289    tr_snprintf( str, sizeof(str), "%d.%d.%d.%d", a[0], a[1], a[2], a[3] );
    290290    if( tr_pton( str, &addr ) == NULL )
    291         return FALSE;
     291        return false;
    292292    range->begin = ntohl( addr.addr.addr4.s_addr );
    293293
    294294    tr_snprintf( str, sizeof(str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3] );
    295295    if( tr_pton( str, &addr ) == NULL )
    296         return FALSE;
     296        return false;
    297297    range->end = ntohl( addr.addr.addr4.s_addr );
    298298
    299     return TRUE;
     299    return true;
    300300}
    301301
  • trunk/libtransmission/blocklist.h

    r11709 r12204  
    2222
    2323tr_blocklist* _tr_blocklistNew         ( const char              * filename,
    24                                          tr_bool                   isEnabled );
     24                                         bool                   isEnabled );
    2525
    2626int           _tr_blocklistExists      ( const tr_blocklist      * b );
  • trunk/libtransmission/cache.c

    r12177 r12204  
    7171  int       rank;
    7272  time_t    last_block_time;
    73   tr_bool   is_multi_piece;
    74   tr_bool   is_piece_done;
     73  bool      is_multi_piece;
     74  bool      is_piece_done;
    7575  unsigned  len;
    7676};
     
    9999        info->last_block_time = b->time;
    100100        info->is_piece_done = tr_cpPieceIsComplete( &b->tor->completion, b->piece );
    101         info->is_multi_piece = b->piece != blocks[pos]->piece ? TRUE : FALSE;
     101        info->is_multi_piece = b->piece != blocks[pos]->piece ? true : false;
    102102        info->len = i - pos;
    103103        info->pos = pos;
  • trunk/libtransmission/clients.c

    r11709 r12204  
    126126    else if( !memcmp( id, "FUTB", 4 )) mod = "(Solidox Mod) ";
    127127    else if( !memcmp( id, "xUTB", 4 )) mod = "(Mod 2) ";
    128     else return FALSE;
     128    else return false;
    129129
    130130    is_bitlord = !memcmp( id+6, "LORD", 4 );
     
    142142        tr_snprintf( buf, buflen, "%s%s%d.%02d", name, mod, major, minor );
    143143
    144     return TRUE;
     144    return true;
    145145}
    146146
  • trunk/libtransmission/completion.c

    r12177 r12204  
    2929    cp->completeBlocks = NULL;
    3030    cp->sizeNow = 0;
    31     cp->sizeWhenDoneIsDirty = TRUE;
    32     cp->blocksWantedIsDirty = TRUE;
    33     cp->haveValidIsDirty = TRUE;
     31    cp->sizeWhenDoneIsDirty = true;
     32    cp->blocksWantedIsDirty = true;
     33    cp->haveValidIsDirty = true;
    3434}
    3535
     
    5656***/
    5757
    58 static inline tr_bool
     58static inline bool
    5959isSeed( const tr_completion * cp )
    6060{
     
    9494tr_cpInvalidateDND( tr_completion * cp )
    9595{
    96     cp->sizeWhenDoneIsDirty = TRUE;
    97     cp->blocksWantedIsDirty = TRUE;
     96    cp->sizeWhenDoneIsDirty = true;
     97    cp->blocksWantedIsDirty = true;
    9898}
    9999
     
    125125        cp->blocksWantedLazy = wanted;
    126126        cp->blocksWantedCompleteLazy = complete;
    127         cp->blocksWantedIsDirty = FALSE;
     127        cp->blocksWantedIsDirty = false;
    128128    }
    129129
     
    148148        cp->blocksWantedCompleteLazy -= complete_blocks[piece];
    149149
    150     cp->sizeWhenDoneIsDirty = TRUE;
    151     cp->haveValidIsDirty = TRUE;
     150    cp->sizeWhenDoneIsDirty = true;
     151    cp->haveValidIsDirty = true;
    152152    complete_blocks[piece] = 0;
    153153    tr_bitsetRemRange( &cp->blockBitset, first, last+1 );
     
    184184            cp->blocksWantedCompleteLazy++;
    185185
    186         cp->sizeWhenDoneIsDirty = TRUE;
    187         cp->haveValidIsDirty = TRUE;
    188     }
    189 }
    190 
    191 
    192 tr_bool
     186        cp->sizeWhenDoneIsDirty = true;
     187        cp->haveValidIsDirty = true;
     188    }
     189}
     190
     191
     192bool
    193193tr_cpBlockBitsetInit( tr_completion * cp, const tr_bitset * blocks )
    194194{
    195     tr_bool success = FALSE;
     195    bool success = false;
    196196    tr_torrent * tor = cp->tor;
    197197
     
    204204        cp->sizeNow = tor->info.totalSize;
    205205
    206         success = TRUE;
     206        success = true;
    207207    }
    208208    else if( blocks->haveNone )
    209209    {
    210210        /* already reset... */
    211         success = TRUE;
     211        success = true;
    212212    }
    213213    else
     
    237237                cp->sizeNow = 0;
    238238            } else {
    239                 cp->blockBitset.haveAll = cp->blockBitset.haveNone = FALSE;
     239                cp->blockBitset.haveAll = cp->blockBitset.haveNone = false;
    240240                cp->sizeNow = tr_bitfieldCountRange( tgt, 0, tor->blockCount-1 );
    241241                cp->sizeNow *= tor->blockSize;
     
    275275                size += tr_torPieceCountBytes( tor, i );
    276276
    277         cp->haveValidIsDirty = FALSE;
     277        cp->haveValidIsDirty = false;
    278278        cp->haveValidLazy = size;
    279279    }
     
    297297                size += tr_torPieceCountBytes( tor, i );
    298298
    299         cp->sizeWhenDoneIsDirty = FALSE;
     299        cp->sizeWhenDoneIsDirty = false;
    300300        cp->sizeWhenDoneLazy = size;
    301301    }
     
    309309    int i;
    310310    const float interval = cp->tor->info.pieceCount / (float)tabCount;
    311     const tr_bool seed = isSeed( cp );
     311    const bool seed = isSeed( cp );
    312312
    313313    for( i=0; i<tabCount; ++i ) {
     
    330330}
    331331
    332 tr_bool
     332bool
    333333tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t i )
    334334{
     
    336336
    337337    if( cp->tor->info.files[i].length == 0 )
    338         return TRUE;
     338        return true;
    339339
    340340    tr_torGetFileBlockRange( cp->tor, i, &f, &l );
  • trunk/libtransmission/completion.h

    r12012 r12204  
    2626typedef struct tr_completion
    2727{
    28     tr_bool  sizeWhenDoneIsDirty;
    29     tr_bool  blocksWantedIsDirty;
    30     tr_bool  haveValidIsDirty;
     28    bool  sizeWhenDoneIsDirty;
     29    bool  blocksWantedIsDirty;
     30    bool  haveValidIsDirty;
    3131
    3232    tr_torrent *    tor;
     
    128128int tr_cpMissingBlocksInPiece( const tr_completion * cp, tr_piece_index_t i );
    129129
    130 static inline tr_bool
     130static inline bool
    131131tr_cpPieceIsComplete( const tr_completion * cp, tr_piece_index_t i )
    132132{
     
    134134}
    135135
    136 void   tr_cpPieceAdd( tr_completion * cp, tr_piece_index_t i );
     136void tr_cpPieceAdd( tr_completion * cp, tr_piece_index_t i );
    137137
    138 void   tr_cpPieceRem( tr_completion * cp, tr_piece_index_t i );
     138void tr_cpPieceRem( tr_completion * cp, tr_piece_index_t i );
    139139
    140 tr_bool tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t );
     140bool tr_cpFileIsComplete( const tr_completion * cp, tr_file_index_t );
    141141
    142142/**
     
    144144**/
    145145
    146 static inline tr_bool
     146static inline bool
    147147tr_cpBlockIsComplete( const tr_completion * cp, tr_block_index_t i )
    148148{
     
    152152void tr_cpBlockAdd( tr_completion * cp, tr_block_index_t i );
    153153
    154 tr_bool tr_cpBlockBitsetInit( tr_completion * cp, const tr_bitset * blocks );
     154bool tr_cpBlockBitsetInit( tr_completion * cp, const tr_bitset * blocks );
    155155
    156156/***
  • trunk/libtransmission/crypto.c

    r11717 r12204  
    8484    RC4_KEY         enc_key;
    8585    uint8_t         torrentHash[SHA_DIGEST_LENGTH];
    86     tr_bool         isIncoming;
    87     tr_bool         torrentHashIsSet;
    88     tr_bool         mySecretIsSet;
     86    bool            isIncoming;
     87    bool            torrentHashIsSet;
     88    bool            mySecretIsSet;
    8989    uint8_t         myPublicKey[KEY_LEN];
    9090    uint8_t         mySecret[KEY_LEN];
     
    336336tr_cryptoWeakRandInt( int upperBound )
    337337{
    338     static tr_bool init = FALSE;
     338    static bool init = false;
    339339
    340340    assert( upperBound > 0 );
     
    343343    {
    344344        srand( tr_time_msec( ) );
    345         init = TRUE;
     345        init = true;
    346346    }
    347347
     
    389389}
    390390
    391 tr_bool
     391bool
    392392tr_ssha1_matches( const char * source, const char * pass )
    393393{
     
    396396    char * hashed;
    397397    uint8_t buf[SHA_DIGEST_LENGTH];
    398     tr_bool result;
     398    bool result;
    399399
    400400    /* extract the salt */
     
    411411    hashed[0] = '{';
    412412
    413     result = strcmp( source, hashed ) == 0 ? TRUE : FALSE;
     413    result = strcmp( source, hashed ) == 0 ? true : false;
    414414
    415415    tr_free( hashed );
  • trunk/libtransmission/crypto.h

    r11709 r12204  
    102102
    103103/** @brief Validate a test password against the a ssha1 password */
    104 tr_bool tr_ssha1_matches( const char * ssha1, const char * pass );
     104bool tr_ssha1_matches( const char * ssha1, const char * pass );
    105105
    106106/* @} */
  • trunk/libtransmission/fdlimit.c

    r12104 r12204  
    8181
    8282
    83 static tr_bool
     83static bool
    8484preallocate_file_sparse( int fd, uint64_t length )
    8585{
    8686    const char zero = '\0';
    87     tr_bool success = 0;
     87    bool success = 0;
    8888
    8989    if( !length )
    90         success = TRUE;
     90        success = true;
    9191
    9292#ifdef HAVE_FALLOCATE64
     
    103103}
    104104
    105 static tr_bool
     105static bool
    106106preallocate_file_full( const char * filename, uint64_t length )
    107107{
    108     tr_bool success = 0;
     108    bool success = 0;
    109109
    110110#ifdef WIN32
     
    164164            uint8_t buf[ 4096 ];
    165165            memset( buf, 0, sizeof( buf ) );
    166             success = TRUE;
     166            success = true;
    167167            while ( success && ( length > 0 ) )
    168168            {
     
    320320struct tr_cached_file
    321321{
    322     tr_bool          is_writable;
     322    bool             is_writable;
    323323    int              fd;
    324324    int              torrent_id;
     
    327327};
    328328
    329 static inline tr_bool
     329static inline bool
    330330cached_file_is_open( const struct tr_cached_file * o )
    331331{
     
    353353                  const char             * existing_dir,
    354354                  const char             * filename,
    355                   tr_bool                  writable,
     355                  bool                     writable,
    356356                  tr_preallocation_mode    allocation,
    357357                  uint64_t                 file_size )
     
    359359    int flags;
    360360    struct stat sb;
    361     tr_bool alreadyExisted;
     361    bool alreadyExisted;
    362362
    363363    /* confirm that existing_dir, if specified, exists on the disk */
     
    553553
    554554int
    555 tr_fdFileGetCached( tr_session * s, int torrent_id, tr_file_index_t i, tr_bool writable )
     555tr_fdFileGetCached( tr_session * s, int torrent_id, tr_file_index_t i, bool writable )
    556556{
    557557    struct tr_cached_file * o = fileset_lookup( get_fileset( s ), torrent_id, i );
     
    577577                   const char             * existing_dir,
    578578                   const char             * filename,
    579                    tr_bool                  writable,
     579                   bool                     writable,
    580580                   tr_preallocation_mode    allocation,
    581581                   uint64_t                 file_size )
     
    637637    if( s >= 0 )
    638638    {
    639         static tr_bool buf_logged = FALSE;
     639        static bool buf_logged = false;
    640640        if( !buf_logged )
    641641        {
    642642            int i;
    643643            socklen_t size = sizeof( int );
    644             buf_logged = TRUE;
     644            buf_logged = true;
    645645            getsockopt( s, SOL_SOCKET, SO_SNDBUF, &i, &size );
    646646            tr_dbg( "SO_SNDBUF size is %d", i );
  • trunk/libtransmission/fdlimit.h

    r12076 r12204  
    7373                        const char             * existing_dir,
    7474                        const char             * filename,
    75                         tr_bool                  do_write,
     75                        bool                  do_write,
    7676                        tr_preallocation_mode    preallocation_mode,
    7777                        uint64_t                 preallocation_file_size );
     
    8080                        int                      torrent_id,
    8181                        tr_file_index_t          file_num,
    82                         tr_bool                  doWrite );
     82                        bool                  doWrite );
    8383
    8484/**
  • trunk/libtransmission/handshake.c

    r12136 r12204  
    103103struct tr_handshake
    104104{
    105     tr_bool               haveReadAnythingFromPeer;
    106     tr_bool               havePeerID;
    107     tr_bool               haveSentBitTorrentHandshake;
     105    bool                  haveReadAnythingFromPeer;
     106    bool                  havePeerID;
     107    bool                  haveSentBitTorrentHandshake;
    108108    tr_peerIo *           io;
    109109    tr_crypto *           crypto;
     
    243243
    244244static int tr_handshakeDone( tr_handshake * handshake,
    245                              tr_bool        isConnected );
     245                             bool           isConnected );
    246246
    247247enum
     
    294294
    295295    /* peer id */
    296     handshake->havePeerID = TRUE;
     296    handshake->havePeerID = true;
    297297    dbgmsg( handshake, "peer-id is [%*.*s]", PEER_ID_LEN, PEER_ID_LEN, peer_id );
    298298
     
    346346    /* send it */
    347347    setReadState( handshake, AWAITING_YB );
    348     tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, FALSE );
     348    tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, false );
    349349}
    350350
     
    431431    }
    432432
    433     handshake->haveReadAnythingFromPeer = TRUE;
     433    handshake->haveReadAnythingFromPeer = true;
    434434
    435435    /* compute the secret */
     
    470470        uint8_t vc[VC_LENGTH] = { 0, 0, 0, 0, 0, 0, 0, 0 };
    471471
    472         tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
     472        tr_peerIoWriteBuf( handshake->io, outbuf, false );
    473473        tr_cryptoEncryptInit( handshake->crypto );
    474474        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
     
    493493    tr_cryptoDecryptInit( handshake->crypto );
    494494    setReadState( handshake, AWAITING_VC );
    495     tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
     495    tr_peerIoWriteBuf( handshake->io, outbuf, false );
    496496
    497497    /* cleanup */
     
    552552        dbgmsg( handshake,
    553553                "peer selected an encryption option we didn't provide" );
    554         return tr_handshakeDone( handshake, FALSE );
     554        return tr_handshakeDone( handshake, false );
    555555    }
    556556
     
    561561    {
    562562        dbgmsg( handshake, "encryption handshake: pad_d_len is too long" );
    563         return tr_handshakeDone( handshake, FALSE );
     563        return tr_handshakeDone( handshake, false );
    564564    }
    565565
     
    613613        return READ_LATER;
    614614
    615     handshake->haveReadAnythingFromPeer = TRUE;
     615    handshake->haveReadAnythingFromPeer = true;
    616616
    617617    pstrlen = evbuffer_pullup( inbuf, 1 )[0]; /* peek, don't read. We may be
     
    626626            dbgmsg( handshake,
    627627                    "peer is unencrypted, and we're disallowing that" );
    628             return tr_handshakeDone( handshake, FALSE );
     628            return tr_handshakeDone( handshake, false );
    629629        }
    630630    }
     
    646646            dbgmsg( handshake,
    647647                    "I think peer has sent us a corrupt handshake..." );
    648             return tr_handshakeDone( handshake, FALSE );
     648            return tr_handshakeDone( handshake, false );
    649649        }
    650650    }
     
    659659    {
    660660        tr_free( pstr );
    661         return tr_handshakeDone( handshake, FALSE );
     661        return tr_handshakeDone( handshake, false );
    662662    }
    663663    tr_free( pstr );
     
    683683        {
    684684            dbgmsg( handshake, "peer is trying to connect to us for a torrent we don't have." );
    685             return tr_handshakeDone( handshake, FALSE );
     685            return tr_handshakeDone( handshake, false );
    686686        }
    687687        else
     
    698698        {
    699699            dbgmsg( handshake, "peer returned the wrong hash. wtf?" );
    700             return tr_handshakeDone( handshake, FALSE );
     700            return tr_handshakeDone( handshake, false );
    701701        }
    702702    }
     
    710710        uint8_t msg[HANDSHAKE_SIZE];
    711711        buildHandshakeMessage( handshake, msg );
    712         tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
     712        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), false );
    713713        handshake->haveSentBitTorrentHandshake = 1;
    714714    }
     
    722722            struct evbuffer * inbuf )
    723723{
    724     tr_bool peerIsGood;
     724    bool peerIsGood;
    725725    char client[128];
    726726    tr_torrent * tor;
     
    734734    tr_peerIoReadBytes( handshake->io, inbuf, peer_id, PEER_ID_LEN );
    735735    tr_peerIoSetPeersId( handshake->io, peer_id );
    736     handshake->havePeerID = TRUE;
     736    handshake->havePeerID = true;
    737737    tr_clientForId( client, sizeof( client ), peer_id );
    738738    dbgmsg( handshake, "peer-id is [%s] ... isIncoming is %d", client,
     
    778778
    779779    setReadState( handshake, AWAITING_PAD_A );
    780     tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, FALSE );
     780    tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, false );
    781781    return READ_NOW;
    782782}
     
    842842    if(( tor = tr_torrentFindFromObfuscatedHash( handshake->session, obfuscatedTorrentHash )))
    843843    {
    844         const tr_bool clientIsSeed = tr_torrentIsSeed( tor );
    845         const tr_bool peerIsSeed = tr_peerMgrPeerIsSeed( tor, tr_peerIoGetAddress( handshake->io, NULL ) );
     844        const bool clientIsSeed = tr_torrentIsSeed( tor );
     845        const bool peerIsSeed = tr_peerMgrPeerIsSeed( tor, tr_peerIoGetAddress( handshake->io, NULL ) );
    846846        dbgmsg( handshake, "got INCOMING connection's encrypted handshake for torrent [%s]",
    847847                tr_torrentName( tor ) );
     
    851851        {
    852852            dbgmsg( handshake, "another seed tried to reconnect to us!" );
    853             return tr_handshakeDone( handshake, FALSE );
     853            return tr_handshakeDone( handshake, false );
    854854        }
    855855    }
     
    857857    {
    858858        dbgmsg( handshake, "can't find that torrent..." );
    859         return tr_handshakeDone( handshake, FALSE );
     859        return tr_handshakeDone( handshake, false );
    860860    }
    861861
     
    935935        dbgmsg( handshake, "peer didn't offer an encryption mode we like." );
    936936        evbuffer_free( outbuf );
    937         return tr_handshakeDone( handshake, FALSE );
     937        return tr_handshakeDone( handshake, false );
    938938    }
    939939
     
    950950    if( crypto_select == CRYPTO_PROVIDE_PLAINTEXT )
    951951    {
    952         tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
     952        tr_peerIoWriteBuf( handshake->io, outbuf, false );
    953953        tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
    954954    }
     
    965965
    966966    /* send it out */
    967     tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
     967    tr_peerIoWriteBuf( handshake->io, outbuf, false );
    968968    evbuffer_free( outbuf );
    969969
     
    989989    dbgmsg( handshake, "parseHandshake returned %d", i );
    990990    if( i != HANDSHAKE_OK )
    991         return tr_handshakeDone( handshake, FALSE );
     991        return tr_handshakeDone( handshake, false );
    992992
    993993    /* we've completed the BT handshake... pass the work on to peer-msgs */
    994     return tr_handshakeDone( handshake, TRUE );
     994    return tr_handshakeDone( handshake, true );
    995995}
    996996
     
    10071007    struct evbuffer * inbuf = tr_peerIoGetReadBuffer( io );
    10081008    ReadState         ret;
    1009     tr_bool           readyForMore = TRUE;
     1009    bool              readyForMore = true;
    10101010
    10111011    assert( tr_isPeerIo( io ) );
     
    10621062
    10631063        if( ret != READ_NOW )
    1064             readyForMore = FALSE;
     1064            readyForMore = false;
    10651065        else if( handshake->state == AWAITING_PAD_C )
    10661066            readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_c_len;
     
    10741074}
    10751075
    1076 static tr_bool
    1077 fireDoneFunc( tr_handshake * handshake, tr_bool isConnected )
     1076static bool
     1077fireDoneFunc( tr_handshake * handshake, bool isConnected )
    10781078{
    10791079    const uint8_t * peer_id = isConnected && handshake->havePeerID
    10801080                            ? tr_peerIoGetPeersId( handshake->io )
    10811081                            : NULL;
    1082     const tr_bool success = ( *handshake->doneCB )( handshake,
    1083                                                     handshake->io,
    1084                                                     handshake->haveReadAnythingFromPeer,
    1085                                                     isConnected,
    1086                                                     peer_id,
    1087                                                     handshake->doneUserData );
     1082    const bool success = ( *handshake->doneCB )( handshake,
     1083                                                 handshake->io,
     1084                                                 handshake->haveReadAnythingFromPeer,
     1085                                                 isConnected,
     1086                                                 peer_id,
     1087                                                 handshake->doneUserData );
    10881088
    10891089    return success;
     
    11011101
    11021102static int
    1103 tr_handshakeDone( tr_handshake * handshake,
    1104                   tr_bool        isOK )
    1105 {
    1106     tr_bool success;
     1103tr_handshakeDone( tr_handshake * handshake, bool isOK )
     1104{
     1105    bool success;
    11071106
    11081107    dbgmsg( handshake, "handshakeDone: %s", isOK ? "connected" : "aborting" );
     
    11201119{
    11211120    if( handshake != NULL )
    1122         tr_handshakeDone( handshake, FALSE );
     1121        tr_handshakeDone( handshake, false );
    11231122}
    11241123
     
    11431142            tr_peerMgrSetUtpFailed( tor,
    11441143                                    tr_peerIoGetAddress( io, NULL ),
    1145                                     TRUE );
     1144                                    true );
    11461145            tr_torrentUnlock( tor );
    11471146        }
     
    11521151            handshake->haveSentBitTorrentHandshake = 1;
    11531152            setReadState( handshake, AWAITING_HANDSHAKE );
    1154             tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
     1153            tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), false );
    11551154        }
    11561155    }
     
    11701169        handshake->haveSentBitTorrentHandshake = 1;
    11711170        setReadState( handshake, AWAITING_HANDSHAKE );
    1172         tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
     1171        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), false );
    11731172    }
    11741173    else
     
    11761175        dbgmsg( handshake, "libevent got an error what==%d, errno=%d (%s)",
    11771176               (int)what, errno, tr_strerror( errno ) );
    1178         tr_handshakeDone( handshake, FALSE );
     1177        tr_handshakeDone( handshake, false );
    11791178    }
    11801179}
     
    12241223        handshake->haveSentBitTorrentHandshake = 1;
    12251224        setReadState( handshake, AWAITING_HANDSHAKE );
    1226         tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
     1225        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), false );
    12271226    }
    12281227
  • trunk/libtransmission/handshake.h

    r11709 r12204  
    3131
    3232/* returns true on success, false on error */
    33 typedef tr_bool ( *handshakeDoneCB )( struct tr_handshake * handshake,
    34                                       struct tr_peerIo *    io,
    35                                       tr_bool               readAnythingFromPeer,
    36                                       tr_bool               isConnected,
    37                                       const uint8_t *      peerId,
    38                                       void *                userData );
     33typedef bool ( *handshakeDoneCB )( struct tr_handshake * handshake,
     34                                   struct tr_peerIo    * io,
     35                                   bool                  readAnythingFromPeer,
     36                                   bool                  isConnected,
     37                                   const uint8_t       * peerId,
     38                                   void                * userData );
    3939
    4040/** @brief instantiate a new handshake */
  • trunk/libtransmission/inout.c

    r12175 r12204  
    4949    int fd;
    5050    int err = 0;
    51     const tr_bool doWrite = ioMode >= TR_IO_WRITE;
     51    const bool doWrite = ioMode >= TR_IO_WRITE;
    5252    const tr_info * const info = &tor->info;
    5353    const tr_file * const file = &info->files[fileIndex];
     
    264264****/
    265265
    266 static tr_bool
    267 recalculateHash( tr_torrent       * tor,
    268                  tr_piece_index_t   pieceIndex,
    269                  uint8_t          * setme )
     266static bool
     267recalculateHash( tr_torrent * tor, tr_piece_index_t pieceIndex, uint8_t * setme )
    270268{
    271269    size_t   bytesLeft;
    272270    uint32_t offset = 0;
    273     tr_bool  success = TRUE;
     271    bool  success = true;
    274272    const size_t buflen = tor->blockSize;
    275273    void * buffer = tr_valloc( buflen );
     
    305303}
    306304
    307 tr_bool
     305bool
    308306tr_ioTestPiece( tr_torrent * tor, tr_piece_index_t piece )
    309307{
  • trunk/libtransmission/inout.h

    r12076 r12204  
    5454 * @brief Test to see if the piece matches its metainfo's SHA1 checksum.
    5555 */
    56 tr_bool tr_ioTestPiece( tr_torrent       * tor,
    57                         tr_piece_index_t   piece );
     56bool tr_ioTestPiece( tr_torrent       * tor,
     57                     tr_piece_index_t   piece );
    5858
    5959
  • trunk/libtransmission/json.c

    r11881 r12204  
    2727struct json_benc_data
    2828{
    29     tr_bool        hasContent;
     29    bool        hasContent;
    3030    tr_benc      * top;
    3131    tr_ptrArray    stack;
     
    6969    {
    7070        case JSON_T_ARRAY_BEGIN:
    71             data->hasContent = TRUE;
     71            data->hasContent = true;
    7272            node = getNode( data );
    7373            tr_bencInitList( node, 0 );
     
    8080
    8181        case JSON_T_OBJECT_BEGIN:
    82             data->hasContent = TRUE;
     82            data->hasContent = true;
    8383            node = getNode( data );
    8484            tr_bencInitDict( node, 0 );
     
    9191
    9292        case JSON_T_FLOAT:
    93             data->hasContent = TRUE;
     93            data->hasContent = true;
    9494            tr_bencInitReal( getNode( data ), value->vu.float_value );
    9595            break;
    9696
    9797        case JSON_T_NULL:
    98             data->hasContent = TRUE;
     98            data->hasContent = true;
    9999            tr_bencInitStr( getNode( data ), "", 0 );
    100100            break;
    101101
    102102        case JSON_T_INTEGER:
    103             data->hasContent = TRUE;
     103            data->hasContent = true;
    104104            tr_bencInitInt( getNode( data ), value->vu.integer_value );
    105105            break;
    106106
    107107        case JSON_T_TRUE:
    108             data->hasContent = TRUE;
     108            data->hasContent = true;
    109109            tr_bencInitBool( getNode( data ), 1 );
    110110            break;
    111111
    112112        case JSON_T_FALSE:
    113             data->hasContent = TRUE;
     113            data->hasContent = true;
    114114            tr_bencInitBool( getNode( data ), 0 );
    115115            break;
    116116
    117117        case JSON_T_STRING:
    118             data->hasContent = TRUE;
     118            data->hasContent = true;
    119119            tr_bencInitStr( getNode( data ),
    120120                            value->vu.str.value,
     
    123123
    124124        case JSON_T_KEY:
    125             data->hasContent = TRUE;
     125            data->hasContent = true;
    126126            assert( !data->key );
    127127            data->key = tr_strdup( value->vu.str.value );
     
    153153    config.depth = -1;
    154154
    155     data.hasContent = FALSE;
     155    data.hasContent = false;
    156156    data.key = NULL;
    157157    data.top = setme_benc;
  • trunk/libtransmission/magnet.c

    r12177 r12204  
    100100tr_magnetParse( const char * uri )
    101101{
    102     tr_bool got_checksum = FALSE;
     102    bool got_checksum = false;
    103103    int trCount = 0;
    104104    int wsCount = 0;
     
    142142                if( hashlen == 40 ) {
    143143                    tr_hex_to_sha1( sha1, hash );
    144                     got_checksum = TRUE;
     144                    got_checksum = true;
    145145                }
    146146                else if( hashlen == 32 ) {
    147147                    base32_to_sha1( sha1, hash, hashlen );
    148                     got_checksum = TRUE;
     148                    got_checksum = true;
    149149                }
    150150            }
  • trunk/libtransmission/makemeta.c

    r12148 r12204  
    382382        builder->my_errno = ENOENT;
    383383        builder->result = TR_MAKEMETA_IO_READ;
    384         builder->isDone = TRUE;
     384        builder->isDone = true;
    385385    }
    386386
  • trunk/libtransmission/metainfo.c

    r12127 r12204  
    140140***/
    141141
    142 static tr_bool
     142static bool
    143143path_is_suspicious( const char * path )
    144144{
     
    147147}
    148148
    149 static tr_bool
     149static bool
    150150getfile( char ** setme, const char * root, tr_benc * path )
    151151{
    152     tr_bool success = FALSE;
     152    bool success = false;
    153153
    154154    if( tr_bencIsList( path ) )
     
    174174        tr_free( tmp );
    175175        /* fprintf( stderr, "[%s]\n", *setme ); */
    176         success = TRUE;
     176        success = true;
    177177    }
    178178
     
    181181        tr_free( *setme );
    182182        *setme = NULL;
    183         success = FALSE;
     183        success = false;
    184184    }
    185185
     
    300300            tr_benc * tier = tr_bencListChild( tiers, i );
    301301            const int tierSize = tr_bencListSize( tier );
    302             tr_bool anyAdded = FALSE;
     302            bool anyAdded = false;
    303303            for( j = 0; j < tierSize; ++j )
    304304            {
     
    314314                        t->id = trackerCount;
    315315
    316                         anyAdded = TRUE;
     316                        anyAdded = true;
    317317                        ++trackerCount;
    318318                    }
     
    387387tr_metainfoParseImpl( const tr_session  * session,
    388388                      tr_info           * inf,
    389                       tr_bool           * hasInfoDict,
     389                      bool              * hasInfoDict,
    390390                      int               * infoDictLength,
    391391                      const tr_benc     * meta_in )
     
    398398    tr_benc *       infoDict = NULL;
    399399    tr_benc *       meta = (tr_benc *) meta_in;
    400     tr_bool         b;
    401     tr_bool         isMagnet = FALSE;
     400    bool            b;
     401    bool            isMagnet = false;
    402402
    403403    /* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
     
    412412        if( tr_bencDictFindDict( meta, "magnet-info", &d ) )
    413413        {
    414             isMagnet = TRUE;
     414            isMagnet = true;
    415415
    416416            /* get the info-hash */
     
    531531}
    532532
    533 tr_bool
     533bool
    534534tr_metainfoParse( const tr_session * session,
    535535                  const tr_benc    * meta_in,
    536536                  tr_info          * inf,
    537                   tr_bool          * hasInfoDict,
     537                  bool             * hasInfoDict,
    538538                  int              * infoDictLength )
    539539{
     
    543543                                                infoDictLength,
    544544                                                meta_in );
    545     const tr_bool success = badTag == NULL;
     545    const bool success = badTag == NULL;
    546546
    547547    if( badTag )
  • trunk/libtransmission/metainfo.h

    r11709 r12204  
    2222struct tr_benc;
    2323
    24 tr_bool  tr_metainfoParse( const tr_session     * session,
    25                            const struct tr_benc * benc,
    26                            tr_info              * setmeInfo,
    27                            tr_bool              * setmeHasInfoDict,
    28                            int                  * setmeInfoDictLength );
     24bool  tr_metainfoParse( const tr_session     * session,
     25                        const struct tr_benc * benc,
     26                        tr_info              * setmeInfo,
     27                        bool                 * setmeHasInfoDict,
     28                        int                  * setmeInfoDictLength );
    2929
    3030void tr_metainfoRemoveSaved( const tr_session * session,
  • trunk/libtransmission/natpmp.c

    r11709 r12204  
    4545struct tr_natpmp
    4646{
    47     tr_bool           has_discovered;
    48     tr_bool           is_mapped;
     47    bool              has_discovered;
     48    bool              is_mapped;
    4949
    5050    tr_port           public_port;
     
    113113
    114114int
    115 tr_natpmpPulse( struct tr_natpmp * nat, tr_port private_port, tr_bool is_enabled, tr_port * public_port )
     115tr_natpmpPulse( struct tr_natpmp * nat, tr_port private_port, bool is_enabled, tr_port * public_port )
    116116{
    117117    int ret;
     
    124124        logVal( "sendpublicaddressrequest", val );
    125125        nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_PUB;
    126         nat->has_discovered = TRUE;
     126        nat->has_discovered = true;
    127127        setCommandTime( nat );
    128128    }
     
    178178                nat->public_port = 0;
    179179                nat->state = TR_NATPMP_IDLE;
    180                 nat->is_mapped = FALSE;
     180                nat->is_mapped = false;
    181181            }
    182182        }
     
    212212        {
    213213            nat->state = TR_NATPMP_IDLE;
    214             nat->is_mapped = TRUE;
     214            nat->is_mapped = true;
    215215            nat->renew_time = tr_time( ) + ( resp.pnu.newportmapping.lifetime / 2 );
    216216            nat->private_port = resp.pnu.newportmapping.privateport;
  • trunk/libtransmission/natpmp.h

    r11709 r12204  
    2929void tr_natpmpClose( tr_natpmp * );
    3030
    31 int tr_natpmpPulse( tr_natpmp *, tr_port port, tr_bool isEnabled, tr_port * public_port );
     31int tr_natpmpPulse( tr_natpmp *, tr_port port, bool isEnabled, tr_port * public_port );
    3232
    3333/* @} */
  • trunk/libtransmission/net.c

    r12156 r12204  
    6868tr_netInit( void )
    6969{
    70     static int initialized = FALSE;
     70    static int initialized = false;
    7171
    7272    if( !initialized )
     
    7676        WSAStartup( MAKEWORD( 2, 2 ), &wsaData );
    7777#endif
    78         initialized = TRUE;
     78        initialized = true;
    7979    }
    8080}
     
    181181}
    182182
    183 tr_bool
     183bool
    184184tr_ssToAddr( tr_address * setme_addr,
    185185             tr_port    * setme_port,
     
    192192        setme_addr->addr.addr4.s_addr = sin->sin_addr.s_addr;
    193193        *setme_port = sin->sin_port;
    194         return TRUE;
     194        return true;
    195195    }
    196196
     
    201201        setme_addr->addr.addr6 = sin6->sin6_addr;
    202202        *setme_port = sin6->sin6_port;
    203         return TRUE;
    204     }
    205 
    206     return FALSE;
     203        return true;
     204    }
     205
     206    return false;
    207207}
    208208
     
    241241                      const tr_address  * addr,
    242242                      tr_port             port,
    243                       tr_bool             clientIsSeed )
     243                      bool                clientIsSeed )
    244244{
    245245    static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
     
    313313                         const tr_address  * addr,
    314314                         tr_port             port,
    315                          tr_bool             clientIsSeed UNUSED )
     315                         bool                clientIsSeed UNUSED )
    316316{
    317317    struct sockaddr_storage ss;
     
    324324
    325325static int
    326 tr_netBindTCPImpl( const tr_address * addr, tr_port port, tr_bool suppressMsgs, int * errOut )
     326tr_netBindTCPImpl( const tr_address * addr, tr_port port, bool suppressMsgs, int * errOut )
    327327{
    328328    static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
     
    397397
    398398int
    399 tr_netBindTCP( const tr_address * addr, tr_port port, tr_bool suppressMsgs )
     399tr_netBindTCP( const tr_address * addr, tr_port port, bool suppressMsgs )
    400400{
    401401    int unused;
     
    403403}
    404404
    405 tr_bool
     405bool
    406406tr_net_hasIPv6( tr_port port )
    407407{
    408     static tr_bool result = FALSE;
    409     static tr_bool alreadyDone = FALSE;
     408    static bool result = false;
     409    static bool alreadyDone = false;
    410410
    411411    if( !alreadyDone )
    412412    {
    413413        int err;
    414         int fd = tr_netBindTCPImpl( &tr_in6addr_any, port, TRUE, &err );
     414        int fd = tr_netBindTCPImpl( &tr_in6addr_any, port, true, &err );
    415415        if( fd >= 0 || err != EAFNOSUPPORT ) /* we support ipv6 */
    416             result = TRUE;
     416            result = true;
    417417        if( fd >= 0 )
    418418            tr_netCloseSocket( fd );
    419         alreadyDone = TRUE;
     419        alreadyDone = true;
    420420    }
    421421
     
    603603***/
    604604
    605 static tr_bool
     605static bool
    606606isIPv4MappedAddress( const tr_address * addr )
    607607{
     
    609609}
    610610
    611 static tr_bool
     611static bool
    612612isIPv6LinkLocalAddress( const tr_address * addr )
    613613{
     
    618618/* isMartianAddr was written by Juliusz Chroboczek,
    619619   and is covered under the same license as third-party/dht/dht.c. */
    620 static tr_bool
     620static bool
    621621isMartianAddr( const struct tr_address * a )
    622622{
     
    651651
    652652        default:
    653             return TRUE;
    654     }
    655 }
    656 
    657 tr_bool
     653            return true;
     654    }
     655}
     656
     657bool
    658658tr_isValidPeerAddress( const tr_address * addr, tr_port port )
    659659{
  • trunk/libtransmission/net.h

    r12147 r12204  
    8080extern const tr_address tr_in6addr_any;
    8181
    82 tr_bool tr_ssToAddr( tr_address * setme_addr,
    83                      tr_port    * setme_port,
    84                      const struct sockaddr_storage * from );
     82bool tr_ssToAddr( tr_address * setme_addr,
     83                  tr_port    * setme_port,
     84                  const struct sockaddr_storage * from );
    8585
    8686const char *tr_ntop( const tr_address * src,
     
    9393                         const tr_address * b);
    9494
    95 tr_bool tr_isValidPeerAddress( const tr_address * addr, tr_port port );
     95bool tr_isValidPeerAddress( const tr_address * addr, tr_port port );
    9696
    97 static inline tr_bool tr_isAddress( const tr_address * a ) { return ( a != NULL ) && ( a->type==TR_AF_INET || a->type==TR_AF_INET6 ); }
     97static inline bool tr_isAddress( const tr_address * a ) { return ( a != NULL ) && ( a->type==TR_AF_INET || a->type==TR_AF_INET6 ); }
    9898
    99 tr_bool tr_net_hasIPv6( tr_port );
     99bool tr_net_hasIPv6( tr_port );
    100100
    101101/***********************************************************************
     
    105105                           const tr_address * addr,
    106106                           tr_port            port,
    107                            tr_bool            clientIsSeed );
     107                           bool               clientIsSeed );
    108108
    109109struct UTPSocket *
     
    111111                         const tr_address  * addr,
    112112                         tr_port             port,
    113                          tr_bool             clientIsSeed);
     113                         bool                clientIsSeed);
    114114
    115115int  tr_netBindTCP( const tr_address * addr,
    116116                    tr_port            port,
    117                     tr_bool            suppressMsgs );
     117                    bool               suppressMsgs );
    118118
    119119int  tr_netAccept( tr_session * session,
  • trunk/libtransmission/peer-common.h

    r12022 r12204  
    7575    uint32_t              length;       /* for GOT_BLOCK + GOT_DATA */
    7676    int                   err;          /* errno for GOT_ERROR */
    77     tr_bool               wasPieceData; /* for GOT_DATA */
     77    bool                  wasPieceData; /* for GOT_DATA */
    7878    tr_port               port;         /* for GOT_PORT */
    7979}
  • trunk/libtransmission/peer-io.c

    r12170 r12204  
    8787struct tr_datatype
    8888{
    89     tr_bool  isPieceData;
    90     size_t   length;
     89    bool    isPieceData;
     90    size_t  length;
    9191};
    9292
     
    112112
    113113        if( overhead > 0 )
    114             tr_bandwidthUsed( &io->bandwidth, TR_UP, overhead, FALSE, now );
     114            tr_bandwidthUsed( &io->bandwidth, TR_UP, overhead, false, now );
    115115
    116116        if( io->didWrite )
     
    132132canReadWrapper( tr_peerIo * io )
    133133{
    134     tr_bool err = 0;
    135     tr_bool done = 0;
     134    bool err = 0;
     135    bool done = 0;
    136136    tr_session * session;
    137137
     
    160160            {
    161161                if( piece )
    162                     tr_bandwidthUsed( &io->bandwidth, TR_DOWN, piece, TRUE, now );
     162                    tr_bandwidthUsed( &io->bandwidth, TR_DOWN, piece, true, now );
    163163
    164164                if( used != piece )
    165                     tr_bandwidthUsed( &io->bandwidth, TR_DOWN, used - piece, FALSE, now );
     165                    tr_bandwidthUsed( &io->bandwidth, TR_DOWN, used - piece, false, now );
    166166            }
    167167
    168168            if( overhead > 0 )
    169                 tr_bandwidthUsed( &io->bandwidth, TR_UP, overhead, FALSE, now );
     169                tr_bandwidthUsed( &io->bandwidth, TR_UP, overhead, false, now );
    170170
    171171            switch( ret )
     
    221221    /* if we don't have any bandwidth left, stop reading */
    222222    if( howmuch < 1 ) {
    223         tr_peerIoSetEnabled( io, dir, FALSE );
     223        tr_peerIoSetEnabled( io, dir, false );
    224224        return;
    225225    }
     
    231231    if( res > 0 )
    232232    {
    233         tr_peerIoSetEnabled( io, dir, TRUE );
     233        tr_peerIoSetEnabled( io, dir, true );
    234234
    235235        /* Invoke the user callback - must always be called last */
     
    245245        else if( res == -1 ) {
    246246            if( e == EAGAIN || e == EINTR ) {
    247                 tr_peerIoSetEnabled( io, dir, TRUE );
     247                tr_peerIoSetEnabled( io, dir, true );
    248248                return;
    249249            }
     
    297297    /* if we don't have any bandwidth left, stop writing */
    298298    if( howmuch < 1 ) {
    299         tr_peerIoSetEnabled( io, dir, FALSE );
     299        tr_peerIoSetEnabled( io, dir, false );
    300300        return;
    301301    }
     
    318318
    319319    if( evbuffer_get_length( io->outbuf ) )
    320         tr_peerIoSetEnabled( io, dir, TRUE );
     320        tr_peerIoSetEnabled( io, dir, true );
    321321
    322322    didWriteWrapper( io, res );
     
    325325 reschedule:
    326326    if( evbuffer_get_length( io->outbuf ) )
    327         tr_peerIoSetEnabled( io, dir, TRUE );
     327        tr_peerIoSetEnabled( io, dir, true );
    328328    return;
    329329
     
    371371    }
    372372
    373     tr_peerIoSetEnabled( io, TR_DOWN, TRUE );
     373    tr_peerIoSetEnabled( io, TR_DOWN, true );
    374374    canReadWrapper( io );
    375375}
     
    413413    if( state == UTP_STATE_CONNECT ) {
    414414        dbgmsg( io, "utp_on_state_change -- changed to connected" );
    415         io->utpSupported = TRUE;
     415        io->utpSupported = true;
    416416    } else if( state == UTP_STATE_WRITABLE ) {
    417417        dbgmsg( io, "utp_on_state_change -- changed to writable" );
     
    450450
    451451    tr_bandwidthUsed( &io->bandwidth, send ? TR_UP : TR_DOWN,
    452                       count, FALSE, tr_time_msec() );
     452                      count, false, tr_time_msec() );
    453453}
    454454
     
    525525              tr_port            port,
    526526              const uint8_t    * torrentHash,
    527               tr_bool            isIncoming,
    528               tr_bool            isSeed,
     527              bool               isIncoming,
     528              bool               isSeed,
    529529              int                socket,
    530530              struct UTPSocket * utp_socket)
     
    600600    assert( tr_isAddress( addr ) );
    601601
    602     return tr_peerIoNew( session, parent, addr, port, NULL, TRUE, FALSE,
     602    return tr_peerIoNew( session, parent, addr, port, NULL, true, false,
    603603                         fd, utp_socket );
    604604}
     
    610610                      tr_port             port,
    611611                      const uint8_t     * torrentHash,
    612                       tr_bool             isSeed,
    613                       tr_bool             utp )
     612                      bool                isSeed,
     613                      bool                utp )
    614614{
    615615    int fd = -1;
     
    632632
    633633    return tr_peerIoNew( session, parent, addr, port,
    634                          torrentHash, FALSE, isSeed, fd, utp_socket );
     634                         torrentHash, false, isSeed, fd, utp_socket );
    635635}
    636636
     
    699699tr_peerIoSetEnabled( tr_peerIo    * io,
    700700                     tr_direction   dir,
    701                      tr_bool        isEnabled )
     701                     bool           isEnabled )
    702702{
    703703    const short event = dir == TR_UP ? EV_WRITE : EV_READ;
     
    842842{
    843843    tr_peerIoSetIOFuncs( io, NULL, NULL, NULL, NULL );
    844     tr_peerIoSetEnabled( io, TR_UP, FALSE );
    845     tr_peerIoSetEnabled( io, TR_DOWN, FALSE );
     844    tr_peerIoSetEnabled( io, TR_UP, false );
     845    tr_peerIoSetEnabled( io, TR_DOWN, false );
    846846}
    847847
     
    974974
    975975static void
    976 addDatatype( tr_peerIo * io, size_t byteCount, tr_bool isPieceData )
     976addDatatype( tr_peerIo * io, size_t byteCount, bool isPieceData )
    977977{
    978978    struct tr_datatype * d;
     
    10121012
    10131013void
    1014 tr_peerIoWriteBuf( tr_peerIo * io, struct evbuffer * buf, tr_bool isPieceData )
     1014tr_peerIoWriteBuf( tr_peerIo * io, struct evbuffer * buf, bool isPieceData )
    10151015{
    10161016    const size_t byteCount = evbuffer_get_length( buf );
     
    10211021
    10221022void
    1023 tr_peerIoWriteBytes( tr_peerIo * io, const void * bytes, size_t byteCount, tr_bool isPieceData )
     1023tr_peerIoWriteBytes( tr_peerIo * io, const void * bytes, size_t byteCount, bool isPieceData )
    10241024{
    10251025    struct evbuffer * buf = evbuffer_new( );
  • trunk/libtransmission/peer-io.h

    r12170 r12204  
    6666typedef struct tr_peerIo
    6767{
    68     tr_bool               isEncrypted;
    69     tr_bool               isIncoming;
    70     tr_bool               peerIdIsSet;
    71     tr_bool               extendedProtocolSupported;
    72     tr_bool               fastExtensionSupported;
    73     tr_bool               dhtSupported;
    74     tr_bool               utpSupported;
     68    bool                  isEncrypted;
     69    bool                  isIncoming;
     70    bool                  peerIdIsSet;
     71    bool                  extendedProtocolSupported;
     72    bool                  fastExtensionSupported;
     73    bool                  dhtSupported;
     74    bool                  utpSupported;
    7575
    7676    tr_priority_t         priority;
     
    8181
    8282    uint32_t              encryptionMode;
    83     tr_bool               isSeed;
     83    bool                  isSeed;
    8484
    8585    tr_port               port;
     
    122122                                  tr_port                   port,
    123123                                  const  uint8_t          * torrentHash,
    124                                   tr_bool                   isSeed,
    125                                   tr_bool                   utp );
     124                                  bool                      isSeed,
     125                                  bool                      utp );
    126126
    127127
     
    147147#define PEER_IO_MAGIC_NUMBER 206745
    148148
    149 static inline tr_bool
     149static inline bool
    150150tr_isPeerIo( const tr_peerIo * io )
    151151{
     
    161161**/
    162162
    163 static inline void tr_peerIoEnableFEXT( tr_peerIo * io, tr_bool flag )
     163static inline void tr_peerIoEnableFEXT( tr_peerIo * io, bool flag )
    164164{
    165165    io->fastExtensionSupported = flag;
    166166}
    167 static inline tr_bool tr_peerIoSupportsFEXT( const tr_peerIo * io )
     167static inline bool tr_peerIoSupportsFEXT( const tr_peerIo * io )
    168168{
    169169    return io->fastExtensionSupported;
    170170}
    171171
    172 static inline void tr_peerIoEnableLTEP( tr_peerIo * io, tr_bool flag )
     172static inline void tr_peerIoEnableLTEP( tr_peerIo * io, bool flag )
    173173{
    174174    io->extendedProtocolSupported = flag;
    175175}
    176 static inline tr_bool tr_peerIoSupportsLTEP( const tr_peerIo * io )
     176static inline bool tr_peerIoSupportsLTEP( const tr_peerIo * io )
    177177{
    178178    return io->extendedProtocolSupported;
    179179}
    180180
    181 static inline void tr_peerIoEnableDHT( tr_peerIo * io, tr_bool flag )
     181static inline void tr_peerIoEnableDHT( tr_peerIo * io, bool flag )
    182182{
    183183    io->dhtSupported = flag;
    184184}
    185 static inline tr_bool tr_peerIoSupportsDHT( const tr_peerIo * io )
     185static inline bool tr_peerIoSupportsDHT( const tr_peerIo * io )
    186186{
    187187    return io->dhtSupported;
    188188}
    189189
    190 static inline tr_bool tr_peerIoSupportsUTP( const tr_peerIo * io )
     190static inline bool tr_peerIoSupportsUTP( const tr_peerIo * io )
    191191{
    192192    return io->dhtSupported;
     
    222222int                  tr_peerIoReconnect( tr_peerIo * io );
    223223
    224 static inline tr_bool tr_peerIoIsIncoming( const tr_peerIo * io )
     224static inline bool tr_peerIoIsIncoming( const tr_peerIo * io )
    225225{
    226226    return io->isIncoming;
     
    267267                                  const void        * writeme,
    268268                                  size_t              writemeLen,
    269                                   tr_bool             isPieceData );
     269                                  bool                isPieceData );
    270270
    271271void    tr_peerIoWriteBuf       ( tr_peerIo         * io,
    272272                                  struct evbuffer   * buf,
    273                                   tr_bool             isPieceData );
     273                                  bool                isPieceData );
    274274
    275275/**
     
    292292void tr_peerIoSetEncryption( tr_peerIo * io, uint32_t encryptionMode );
    293293
    294 static inline tr_bool
     294static inline bool
    295295tr_peerIoIsEncrypted( const tr_peerIo * io )
    296296{
     
    362362                                  int                   isPieceData );
    363363
    364 static inline tr_bool
     364static inline bool
    365365tr_peerIoHasBandwidthLeft( const tr_peerIo * io, tr_direction dir )
    366366{
     
    380380void      tr_peerIoSetEnabled( tr_peerIo    * io,
    381381                               tr_direction   dir,
    382                                tr_bool        isEnabled );
     382                               bool           isEnabled );
    383383
    384384int       tr_peerIoFlush( tr_peerIo     * io,
  • trunk/libtransmission/peer-mgr.c

    r12199 r12204  
    100100};
    101101
    102 const tr_peer_event TR_PEER_EVENT_INIT = { 0, 0, NULL, 0, 0, 0, FALSE, 0 };
     102const tr_peer_event TR_PEER_EVENT_INIT = { 0, 0, NULL, 0, 0, 0, false, 0 };
    103103
    104104/**
     
    122122    uint8_t     flags2;             /* flags that aren't defined in added_f */
    123123    int8_t      seedProbability;    /* how likely is this to be a seed... [0..100] or -1 for unknown */
    124     int8_t      blocklisted;        /* -1 for unknown, TRUE for blocklisted, FALSE for not blocklisted */
     124    int8_t      blocklisted;        /* -1 for unknown, true for blocklisted, false for not blocklisted */
    125125
    126126    tr_port     port;
    127     tr_bool     utp_failed;         /* We recently failed to connect over uTP */
     127    bool        utp_failed;         /* We recently failed to connect over uTP */
    128128    uint16_t    numFails;
    129129    time_t      time;               /* when the peer's connection status last changed */
     
    143143#define tr_isAtom(a) (TRUE)
    144144#else
    145 static tr_bool
     145static bool
    146146tr_isAtom( const struct peer_atom * atom )
    147147{
     
    194194    int                        optimisticUnchokeTimeScaler;
    195195
    196     tr_bool                    isRunning;
    197     tr_bool                    needsCompletenessCheck;
     196    bool                       isRunning;
     197    bool                       needsCompletenessCheck;
    198198
    199199    struct block_request     * requests;
     
    359359}
    360360
    361 static tr_bool
     361static bool
    362362peerIsInUse( const Torrent * ct, const struct peer_atom * atom )
    363363{
     
    451451}
    452452
    453 static tr_bool
     453static bool
    454454replicationExists( const Torrent * t )
    455455{
     
    590590{
    591591    if( !tr_torrentHasMetadata( tor ) )
    592         return TRUE;
     592        return true;
    593593
    594594    return peer->clientIsInterested && !peer->clientIsChoked;
     
    625625}
    626626
    627 static tr_bool
     627static bool
    628628isAtomBlocklisted( tr_session * session, struct peer_atom * atom )
    629629{
     
    654654}
    655655
    656 static inline tr_bool
     656static inline bool
    657657atomIsSeed( const struct peer_atom * atom )
    658658{
     
    672672
    673673
    674 tr_bool
     674bool
    675675tr_peerMgrPeerIsSeed( const tr_torrent  * tor,
    676676                      const tr_address  * addr )
    677677{
    678     tr_bool isSeed = FALSE;
     678    bool isSeed = false;
    679679    const Torrent * t = tor->torrentPeers;
    680680    const struct peer_atom * atom = getExistingAtom( t, addr );
     
    696696
    697697void
    698 tr_peerMgrSetUtpFailed( tr_torrent *tor, const tr_address *addr, tr_bool failed )
     698tr_peerMgrSetUtpFailed( tr_torrent *tor, const tr_address *addr, bool failed )
    699699{
    700700    struct peer_atom * atom = getExistingAtom( tor->torrentPeers, addr );
     
    762762    /* insert the request to our array... */
    763763    {
    764         tr_bool exact;
     764        bool exact;
    765765        const int pos = tr_lowerBound( &key, t->requests, t->requestCount,
    766766                                       sizeof( struct block_request ),
     
    804804                      tr_ptrArray * peerArr )
    805805{
    806     tr_bool exact;
     806    bool exact;
    807807    int i, pos;
    808808    struct block_request key;
     
    11451145{
    11461146    int pos;
    1147     tr_bool isSorted = TRUE;
     1147    bool isSorted = true;
    11481148
    11491149    if( p == NULL )
     
    11541154    setComparePieceByWeightTorrent( t );
    11551155    if( isSorted && ( pos > 0 ) && ( comparePieceByWeight( p-1, p ) > 0 ) )
    1156         isSorted = FALSE;
     1156        isSorted = false;
    11571157    if( isSorted && ( pos < t->pieceCount - 1 ) && ( comparePieceByWeight( p, p+1 ) > 0 ) )
    1158         isSorted = FALSE;
     1158        isSorted = false;
    11591159
    11601160    if( t->pieceSortState != PIECES_SORTED_BY_WEIGHT )
    11611161    {
    11621162       pieceListSort( t, PIECES_SORTED_BY_WEIGHT);
    1163        isSorted = TRUE;
     1163       isSorted = true;
    11641164    }
    11651165
     
    11671167    if( !isSorted )
    11681168    {
    1169         tr_bool exact;
     1169        bool exact;
    11701170        const struct weighted_piece tmp = *p;
    11711171
     
    14131413        while( --i >= 0 )
    14141414        {
    1415             tr_bool exact;
     1415            bool exact;
    14161416
    14171417            /* relative position! */
     
    14351435}
    14361436
    1437 tr_bool
     1437bool
    14381438tr_peerMgrDidPeerRequest( const tr_torrent  * tor,
    14391439                          const tr_peer     * peer,
     
    16921692
    16931693        case TR_PEER_CLIENT_GOT_SUGGEST:
    1694             peerSuggestedPiece( t, peer, e->pieceIndex, FALSE );
     1694            peerSuggestedPiece( t, peer, e->pieceIndex, false );
    16951695            break;
    16961696
    16971697        case TR_PEER_CLIENT_GOT_ALLOWED_FAST:
    1698             peerSuggestedPiece( t, peer, e->pieceIndex, TRUE );
     1698            peerSuggestedPiece( t, peer, e->pieceIndex, true );
    16991699            break;
    17001700
     
    17451745            }
    17461746
    1747             tr_ptrArrayDestruct( &peerArr, FALSE );
     1747            tr_ptrArrayDestruct( &peerArr, false );
    17481748
    17491749            tr_historyAdd( &peer->blocksSentToClient, tr_time( ), 1 );
     
    17651765                {
    17661766                    const tr_piece_index_t p = e->pieceIndex;
    1767                     const tr_bool ok = tr_torrentCheckPiece( tor, p );
     1767                    const bool ok = tr_torrentCheckPiece( tor, p );
    17681768
    17691769                    tordbg( t, "[LAZY] checked just-completed piece %zu", (size_t)p );
     
    18181818                }
    18191819
    1820                 t->needsCompletenessCheck = TRUE;
     1820                t->needsCompletenessCheck = true;
    18211821            }
    18221822            break;
     
    19181918
    19191919/* FIXME: this is kind of a mess. */
    1920 static tr_bool
     1920static bool
    19211921myHandshakeDoneCB( tr_handshake  * handshake,
    19221922                   tr_peerIo     * io,
    1923                    tr_bool         readAnythingFromPeer,
    1924                    tr_bool         isConnected,
     1923                   bool            readAnythingFromPeer,
     1924                   bool            isConnected,
    19251925                   const uint8_t * peer_id,
    19261926                   void          * vmanager )
    19271927{
    1928     tr_bool            ok = isConnected;
    1929     tr_bool            success = FALSE;
     1928    bool               ok = isConnected;
     1929    bool               success = false;
    19301930    tr_port            port;
    19311931    const tr_address * addr;
     
    20312031                tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t );
    20322032
    2033                 success = TRUE;
     2033                success = true;
    20342034            }
    20352035        }
     
    22492249{
    22502250    if( peer->encryption_preference == ENCRYPTION_PREFERENCE_YES )
    2251         return TRUE;
     2251        return true;
    22522252
    22532253    if( peer->encryption_preference == ENCRYPTION_PREFERENCE_NO )
    2254         return FALSE;
     2254        return false;
    22552255
    22562256    return tr_peerIoIsEncrypted( peer->io );
     
    23942394    ensureMgrTimersExist( t->manager );
    23952395
    2396     t->isRunning = TRUE;
     2396    t->isRunning = true;
    23972397    t->maxPeers = t->tor->maxConnectedPeers;
    23982398    t->pieceSortState = PIECES_UNSORTED;
     
    24062406    int i, n;
    24072407
    2408     t->isRunning = FALSE;
     2408    t->isRunning = false;
    24092409
    24102410    replicationFree( t );
     
    25072507        const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &tor->torrentPeers->peers );
    25082508        const float interval = tor->info.pieceCount / (float)tabCount;
    2509         const tr_bool isSeed = tr_cpGetStatus( &tor->completion ) == TR_SEED;
     2509        const bool isSeed = tr_cpGetStatus( &tor->completion ) == TR_SEED;
    25102510
    25112511        for( i=0; i<tabCount; ++i )
     
    26272627}
    26282628
    2629 static tr_bool
     2629static bool
    26302630peerIsSeed( const tr_peer * peer )
    26312631{
    26322632    if( peer->progress >= 1.0 )
    2633         return TRUE;
     2633        return true;
    26342634
    26352635    if( peer->atom && atomIsSeed( peer->atom ) )
    2636         return TRUE;
    2637 
    2638     return FALSE;
     2636        return true;
     2637
     2638    return false;
    26392639}
    26402640
     
    27262726    {
    27272727        const tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
    2728         tr_peerMsgsSetInterested( peer->msgs, FALSE );
     2728        tr_peerMsgsSetInterested( peer->msgs, false );
    27292729    }
    27302730}
    27312731
    27322732/* do we still want this piece and does the peer have it? */
    2733 static tr_bool
     2733static bool
    27342734isPieceInteresting( const tr_torrent * tor, const tr_peer * peer, tr_piece_index_t index )
    27352735{
     
    27402740
    27412741/* does this peer have any pieces that we want? */
    2742 static tr_bool
     2742static bool
    27432743isPeerInteresting( const tr_torrent * tor, const tr_peer * peer )
    27442744{
     
    27462746
    27472747    if ( tr_torrentIsSeed( tor ) )
    2748         return FALSE;
     2748        return false;
    27492749
    27502750    if( !tr_torrentIsPieceTransferAllowed( tor, TR_PEER_TO_CLIENT ) )
    2751         return FALSE;
     2751        return false;
    27522752
    27532753    for( i=0, n=tor->info.pieceCount; i<n; ++i )
    27542754        if( isPieceInteresting( tor, peer, i ) )
    2755             return TRUE;
    2756 
    2757     return FALSE;
     2755            return true;
     2756
     2757    return false;
    27582758}
    27592759
     
    28582858            if( !isPeerInteresting( t->tor, peer ) )
    28592859            {
    2860                 tr_peerMsgsSetInterested( peer->msgs, FALSE );
     2860                tr_peerMsgsSetInterested( peer->msgs, false );
    28612861            }
    28622862            else
     
    28892889     * Now it's time to update our `interest' flags. */
    28902890    for( i=0; i<goodCount; ++i ) {
    2891         const tr_bool b = t->interestedCount < maxPeers;
     2891        const bool b = t->interestedCount < maxPeers;
    28922892        tr_peerMsgsSetInterested( good[i]->msgs, b );
    28932893        if( b )
     
    28952895    }
    28962896    for( i=0; i<untestedCount; ++i ) {
    2897         const tr_bool b = t->interestedCount < maxPeers;
     2897        const bool b = t->interestedCount < maxPeers;
    28982898        tr_peerMsgsSetInterested( untested[i]->msgs, b );
    28992899        if( b )
     
    29012901    }
    29022902    for( i=0; i<badCount; ++i ) {
    2903         const tr_bool b = t->interestedCount < maxPeers;
     2903        const bool b = t->interestedCount < maxPeers;
    29042904        tr_peerMsgsSetInterested( bad[i]->msgs, b );
    29052905        if( b )
     
    29212921struct ChokeData
    29222922{
    2923     tr_bool         isInterested;
    2924     tr_bool         wasChoked;
    2925     tr_bool         isChoked;
     2923    bool            isInterested;
     2924    bool            wasChoked;
     2925    bool            isChoked;
    29262926    int             rate;
    29272927    int             salt;
     
    29772977}
    29782978
    2979 static inline tr_bool
     2979static inline bool
    29802980isBandwidthMaxedOut( const tr_bandwidth * b,
    29812981                     const uint64_t now_msec, tr_direction dir )
    29822982{
    29832983    if( !tr_bandwidthIsLimited( b, dir ) )
    2984         return FALSE;
     2984        return false;
    29852985    else {
    29862986        const int got = tr_bandwidthGetPieceSpeed_Bps( b, now_msec, dir );
     
    29992999    const tr_session * session = t->manager->session;
    30003000    const int chokeAll = !tr_torrentIsPieceTransferAllowed( t->tor, TR_CLIENT_TO_PEER );
    3001     const tr_bool isMaxedOut = isBandwidthMaxedOut( t->tor->bandwidth, now, TR_UP );
     3001    const bool isMaxedOut = isBandwidthMaxedOut( t->tor->bandwidth, now, TR_UP );
    30023002
    30033003    assert( torrentIsLocked( t ) );
     
    30183018        if( peerIsSeed( peer ) ) /* choke seeds and partial seeds */
    30193019        {
    3020             tr_peerMsgsSetChoke( peer->msgs, TRUE );
     3020            tr_peerMsgsSetChoke( peer->msgs, true );
    30213021        }
    30223022        else if( chokeAll ) /* choke everyone if we're not uploading */
    30233023        {
    3024             tr_peerMsgsSetChoke( peer->msgs, TRUE );
     3024            tr_peerMsgsSetChoke( peer->msgs, true );
    30253025        }
    30263026        else if( peer != t->optimistic )
     
    30323032            n->rate         = getRate( t->tor, atom, now );
    30333033            n->salt         = tr_cryptoWeakRandInt( INT_MAX );
    3034             n->isChoked     = TRUE;
     3034            n->isChoked     = true;
    30353035        }
    30363036    }
     
    30553055    unchokedInterested = 0;
    30563056    for( i=0; i<size && unchokedInterested<session->uploadSlotsPerTorrent; ++i ) {
    3057         choke[i].isChoked = isMaxedOut ? choke[i].wasChoked : FALSE;
     3057        choke[i].isChoked = isMaxedOut ? choke[i].wasChoked : false;
    30583058        if( choke[i].isInterested )
    30593059            ++unchokedInterested;
     
    30823082        {
    30833083            c = tr_ptrArrayNth( &randPool, tr_cryptoWeakRandInt( n ));
    3084             c->isChoked = FALSE;
     3084            c->isChoked = false;
    30853085            t->optimistic = c->peer;
    30863086            t->optimisticUnchokeTimeScaler = OPTIMISTIC_UNCHOKE_MULTIPLIER;
     
    31243124***/
    31253125
    3126 static tr_bool
     3126static bool
    31273127shouldPeerBeClosed( const Torrent    * t,
    31283128                    const tr_peer    * peer,
     
    31383138        tordbg( t, "purging peer %s because its doPurge flag is set",
    31393139                tr_atomAddrStr( atom ) );
    3140         return TRUE;
     3140        return true;
    31413141    }
    31423142
     
    31623162            tordbg( t, "purging peer %s because it's been %d secs since we shared anything",
    31633163                       tr_atomAddrStr( atom ), idleTime );
    3164             return TRUE;
     3164            return true;
    31653165        }
    31663166    }
    31673167
    3168     return FALSE;
     3168    return false;
    31693169}
    31703170
     
    32913291    time_t time;
    32923292    int speed;
    3293     tr_bool doPurge;
     3293    bool doPurge;
    32943294};
    32953295
     
    35063506    while(( tor = tr_torrentNext( mgr->session, tor ))) {
    35073507        if( tor->torrentPeers->needsCompletenessCheck ) {
    3508             tor->torrentPeers->needsCompletenessCheck  = FALSE;
     3508            tor->torrentPeers->needsCompletenessCheck  = false;
    35093509            tr_torrentRecheckCompleteness( tor );
    35103510        }
     
    36463646
    36473647/* is this atom someone that we'd want to initiate a connection to? */
    3648 static tr_bool
     3648static bool
    36493649isPeerCandidate( const tr_torrent * tor, struct peer_atom * atom, const time_t now )
    36503650{
    36513651    /* not if we're both seeds */
    36523652    if( tr_torrentIsSeed( tor ) && atomIsSeed( atom ) )
    3653         return FALSE;
     3653        return false;
    36543654
    36553655    /* not if we've already got a connection to them... */
    36563656    if( peerIsInUse( tor->torrentPeers, atom ) )
    3657         return FALSE;
     3657        return false;
    36583658
    36593659    /* not if we just tried them already */
    36603660    if( ( now - atom->time ) < getReconnectIntervalSecs( atom, now ) )
    3661         return FALSE;
     3661        return false;
    36623662
    36633663    /* not if they're blocklisted */
    36643664    if( isAtomBlocklisted( tor->session, atom ) )
    3665         return FALSE;
     3665        return false;
    36663666
    36673667    /* not if they're banned... */
    36683668    if( atom->flags2 & MYFLAG_BANNED )
    3669         return FALSE;
    3670 
    3671     return TRUE;
     3669        return false;
     3670
     3671    return true;
    36723672}
    36733673
     
    36793679};
    36803680
    3681 static tr_bool
     3681static bool
    36823682torrentWasRecentlyStarted( const tr_torrent * tor )
    36833683{
     
    36993699    uint64_t i;
    37003700    uint64_t score = 0;
    3701     const tr_bool failed = atom->lastConnectionAt < atom->lastConnectionAttemptAt;
     3701    const bool failed = atom->lastConnectionAt < atom->lastConnectionAttemptAt;
    37023702
    37033703    /* prefer peers we've connected to, or never tried, over peers we failed to connect to. */
     
    38343834    tr_peerIo * io;
    38353835    const time_t now = tr_time( );
    3836     tr_bool utp = tr_sessionIsUTPEnabled(mgr->session) && !atom->utp_failed;
     3836    bool utp = tr_sessionIsUTPEnabled(mgr->session) && !atom->utp_failed;
    38373837
    38383838    if( atom->fromFirst == TR_PEER_FROM_PEX )
  • trunk/libtransmission/peer-mgr.h

    r12111 r12204  
    9090typedef struct tr_peer
    9191{
    92     tr_bool                  peerIsChoked;
    93     tr_bool                  peerIsInterested;
    94     tr_bool                  clientIsChoked;
    95     tr_bool                  clientIsInterested;
    96     tr_bool                  doPurge;
     92    bool                     peerIsChoked;
     93    bool                     peerIsInterested;
     94    bool                     clientIsChoked;
     95    bool                     clientIsInterested;
     96    bool                     doPurge;
    9797
    9898    /* number of bad pieces they've contributed to */
     
    137137
    138138
    139 static inline tr_bool
     139static inline bool
    140140tr_isPex( const tr_pex * pex )
    141141{
     
    151151void tr_peerMgrFree( tr_peerMgr * manager );
    152152
    153 tr_bool tr_peerMgrPeerIsSeed( const tr_torrent * tor,
     153bool tr_peerMgrPeerIsSeed( const tr_torrent * tor,
    154154                              const tr_address * addr );
    155155
     
    159159void tr_peerMgrSetUtpFailed( tr_torrent *tor,
    160160                             const tr_address *addr,
    161                              tr_bool failed );
     161                             bool failed );
    162162
    163163void tr_peerMgrGetNextRequests( tr_torrent          * torrent,
     
    167167                                int                 * numgot );
    168168
    169 tr_bool tr_peerMgrDidPeerRequest( const tr_torrent  * torrent,
    170                                   const tr_peer     * peer,
    171                                   tr_block_index_t    block );
     169bool tr_peerMgrDidPeerRequest( const tr_torrent  * torrent,
     170                               const tr_peer     * peer,
     171                               tr_block_index_t    block );
    172172
    173173void tr_peerMgrRebuildRequests( tr_torrent * torrent );
  • trunk/libtransmission/peer-msgs.c

    r12111 r12204  
    157157struct tr_peermsgs
    158158{
    159     tr_bool         peerSupportsPex;
    160     tr_bool         peerSupportsMetadataXfer;
    161     tr_bool         clientSentLtepHandshake;
    162     tr_bool         peerSentLtepHandshake;
    163 
    164     /*tr_bool         haveFastSet;*/
     159    bool            peerSupportsPex;
     160    bool            peerSupportsMetadataXfer;
     161    bool            clientSentLtepHandshake;
     162    bool            peerSentLtepHandshake;
     163
     164    /*bool          haveFastSet;*/
    165165
    166166    int             desiredRequestCount;
     
    559559
    560560static void
    561 firePeerGotData( tr_peermsgs * msgs, uint32_t length, tr_bool wasPieceData )
     561firePeerGotData( tr_peermsgs * msgs, uint32_t length, bool wasPieceData )
    562562{
    563563    tr_peer_event e = TR_PEER_EVENT_INIT;
     
    633633updateFastSet( tr_peermsgs * msgs UNUSED )
    634634{
    635     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
     635    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
    636636    const int peerIsNeedy = msgs->peer->progress < 0.10;
    637637
     
    659659
    660660static void
    661 sendInterest( tr_peermsgs * msgs, tr_bool clientIsInterested )
     661sendInterest( tr_peermsgs * msgs, bool clientIsInterested )
    662662{
    663663    struct evbuffer * out = msgs->outMessages;
     
    690690}
    691691
    692 static tr_bool
     692static bool
    693693popNextMetadataRequest( tr_peermsgs * msgs, int * piece )
    694694{
    695695    if( msgs->peerAskedForMetadataCount == 0 )
    696         return FALSE;
     696        return false;
    697697
    698698    *piece = msgs->peerAskedForMetadata[0];
     
    701701                               msgs->peerAskedForMetadataCount-- );
    702702
    703     return TRUE;
    704 }
    705 
    706 static tr_bool
     703    return true;
     704}
     705
     706static bool
    707707popNextRequest( tr_peermsgs * msgs, struct peer_request * setme )
    708708{
    709709    if( msgs->peer->pendingReqsToClient == 0 )
    710         return FALSE;
     710        return false;
    711711
    712712    *setme = msgs->peerAskedFor[0];
     
    715715                               msgs->peer->pendingReqsToClient-- );
    716716
    717     return TRUE;
     717    return true;
    718718}
    719719
     
    770770**/
    771771
    772 static tr_bool
     772static bool
    773773reqIsValid( const tr_peermsgs * peer,
    774774            uint32_t            index,
     
    779779}
    780780
    781 static tr_bool
     781static bool
    782782requestIsValid( const tr_peermsgs * msgs, const struct peer_request * req )
    783783{
     
    804804    char * buf;
    805805    int len;
    806     tr_bool allow_pex;
    807     tr_bool allow_metadata_xfer;
     806    bool allow_pex;
     807    bool allow_metadata_xfer;
    808808    struct evbuffer * out = msgs->outMessages;
    809809    const unsigned char * ipv6 = tr_globalIPv6();
     
    913913            tr_peerMgrSetUtpFailed( msgs->torrent,
    914914                                    tr_peerIoGetAddress( msgs->peer->io, NULL ),
    915                                     FALSE );
     915                                    false );
    916916        }
    917917    }
     
    12191219peerMadeRequest( tr_peermsgs * msgs, const struct peer_request * req )
    12201220{
    1221     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
     1221    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
    12221222    const int reqIsValid = requestIsValid( msgs, req );
    12231223    const int clientHasPiece = reqIsValid && tr_cpPieceIsComplete( &msgs->torrent->completion, req->index );
    12241224    const int peerIsChoked = msgs->peer->peerIsChoked;
    12251225
    1226     int allow = FALSE;
     1226    int allow = false;
    12271227
    12281228    if( !reqIsValid )
     
    12351235        dbgmsg( msgs, "rejecting request ... reqq is full" );
    12361236    else
    1237         allow = TRUE;
     1237        allow = true;
    12381238
    12391239    if( allow ) {
     
    12451245}
    12461246
    1247 static tr_bool
     1247static bool
    12481248messageLengthIsCorrect( const tr_peermsgs * msg, uint8_t id, uint32_t len )
    12491249{
     
    12671267                return len == ( msg->torrent->info.pieceCount + 7u ) / 8u + 1u;
    12681268            /* we don't know the piece count yet,
    1269                so we can only guess whether to send TRUE or FALSE */
     1269               so we can only guess whether to send true or false */
    12701270            if( msg->metadata_size_hint > 0 )
    12711271                return len <= msg->metadata_size_hint;
    1272             return TRUE;
     1272            return true;
    12731273
    12741274        case BT_REQUEST:
     
    12871287
    12881288        default:
    1289             return FALSE;
     1289            return false;
    12901290    }
    12911291}
     
    13391339        buf = NULL;
    13401340
    1341         fireClientGotData( msgs, n, TRUE );
     1341        fireClientGotData( msgs, n, true );
    13421342        *setme_piece_bytes_read += n;
    13431343        dbgmsg( msgs, "got %zu bytes for block %u:%u->%u ... %d remain",
     
    13701370    const size_t  startBufLen = evbuffer_get_length( inbuf );
    13711371#endif
    1372     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
     1372    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
    13731373
    13741374    --msglen; /* id length */
     
    16701670    /* log the raw data that was read */
    16711671    if( ( ret != READ_ERR ) && ( evbuffer_get_length( in ) != inlen ) )
    1672         fireClientGotData( msgs, inlen - evbuffer_get_length( in ), FALSE );
     1672        fireClientGotData( msgs, inlen - evbuffer_get_length( in ), false );
    16731673
    16741674    return ret;
     
    16791679{
    16801680    if( msgs->state != AWAITING_BT_PIECE )
    1681         return FALSE;
     1681        return false;
    16821682
    16831683    return block == _tr_block( msgs->torrent,
     
    18041804    size_t bytesWritten = 0;
    18051805    struct peer_request req;
    1806     const tr_bool haveMessages = evbuffer_get_length( msgs->outMessages ) != 0;
    1807     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
     1806    const bool haveMessages = evbuffer_get_length( msgs->outMessages ) != 0;
     1807    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
    18081808
    18091809    /**
     
    18211821        /* flush the protocol messages */
    18221822        dbgmsg( msgs, "flushing outMessages... to %p (length is %zu)", msgs->peer->io, len );
    1823         tr_peerIoWriteBuf( msgs->peer->io, msgs->outMessages, FALSE );
     1823        tr_peerIoWriteBuf( msgs->peer->io, msgs->outMessages, false );
    18241824        msgs->clientSentAnythingAt = now;
    18251825        msgs->outMessagesBatchedAt = 0;
     
    18371837        char * data;
    18381838        int dataLen;
    1839         tr_bool ok = FALSE;
     1839        bool ok = false;
    18401840
    18411841        data = tr_torrentGetMetadataPiece( msgs->torrent, piece, &dataLen );
     
    18671867            tr_free( data );
    18681868
    1869             ok = TRUE;
     1869            ok = true;
    18701870        }
    18711871
     
    19411941                dbgmsg( msgs, "sending block %u:%u->%u", req.index, req.offset, req.length );
    19421942                assert( n == msglen );
    1943                 tr_peerIoWriteBuf( msgs->peer->io, out, TRUE );
     1943                tr_peerIoWriteBuf( msgs->peer->io, out, true );
    19441944                bytesWritten += n;
    19451945                msgs->clientSentAnythingAt = now;
     
    19961996            break;
    19971997
    1998     return TRUE; /* loop forever */
     1998    return true; /* loop forever */
    19991999}
    20002000
     
    20352035tellPeerWhatWeHave( tr_peermsgs * msgs )
    20362036{
    2037     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
     2037    const bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
    20382038
    20392039    if( fext && ( tr_cpBlockBitset( &msgs->torrent->completion )->haveAll ) )
     
    23202320        const tr_address * addr = tr_peerIoGetAddress( peer->io, NULL );
    23212321        tr_peerMgrSetUtpSupported( torrent, addr );
    2322         tr_peerMgrSetUtpFailed( torrent, addr, FALSE );
     2322        tr_peerMgrSetUtpFailed( torrent, addr, false );
    23232323    }
    23242324
  • trunk/libtransmission/platform.c

    r11785 r12204  
    7878}
    7979
    80 static tr_bool
     80static bool
    8181tr_areThreadsEqual( tr_thread_id a, tr_thread_id b )
    8282{
     
    9999};
    100100
    101 tr_bool
     101bool
    102102tr_amInThread( const tr_thread * t )
    103103{
     
    378378migrateFiles( const tr_session * session )
    379379{
    380     static int migrated = FALSE;
    381     const tr_bool should_migrate = strstr( getOldConfigDir(), ".transmission" ) != NULL;
     380    static int migrated = false;
     381    const bool should_migrate = strstr( getOldConfigDir(), ".transmission" ) != NULL;
    382382
    383383    if( !migrated && should_migrate )
     
    385385        const char * oldDir;
    386386        const char * newDir;
    387         migrated = TRUE;
     387        migrated = true;
    388388
    389389        oldDir = getOldTorrentsDir( );
     
    576576
    577577                char * appString = tr_malloc( appLength + 1 );
    578                 tr_bool success = CFStringGetCString( appRef,
     578                bool success = CFStringGetCString( appRef,
    579579                                              appString,
    580580                                              appLength + 1,
  • trunk/libtransmission/platform.h

    r11709 r12204  
    7474/** @brief Return nonzero if this function is being called from `thread'
    7575    @param thread the thread being tested */
    76 tr_bool tr_amInThread( const tr_thread * );
     76bool tr_amInThread( const tr_thread * );
    7777
    7878/***
  • trunk/libtransmission/port-forwarding.c

    r11709 r12204  
    3535struct tr_shared
    3636{
    37     tr_bool               isEnabled;
    38     tr_bool               isShuttingDown;
    39     tr_bool               doPortCheck;
     37    bool               isEnabled;
     38    bool               isShuttingDown;
     39    bool               doPortCheck;
    4040
    4141    tr_port_forwarding    natpmpStatus;
     
    6767
    6868static void
    69 natPulse( tr_shared * s, tr_bool do_check )
     69natPulse( tr_shared * s, bool do_check )
    7070{
    7171    const tr_port private_peer_port = s->session->private_peer_port;
     
    107107            /* if we're mapped, everything is fine... check back in 20 minutes
    108108             * to renew the port forwarding if it's expired */
    109             s->doPortCheck = TRUE;
     109            s->doPortCheck = true;
    110110            sec = 60 * 20;
    111111            break;
     
    136136    /* do something */
    137137    natPulse( s, s->doPortCheck );
    138     s->doPortCheck = FALSE;
     138    s->doPortCheck = false;
    139139
    140140    /* set up the timer for the next pulse */
     
    152152
    153153    s->session      = session;
    154     s->isEnabled    = FALSE;
     154    s->isEnabled    = false;
    155155    s->upnpStatus   = TR_PORT_UNMAPPED;
    156156    s->natpmpStatus = TR_PORT_UNMAPPED;
     
    182182{
    183183    tr_ninf( getKey( ), "%s", _( "Stopped" ) );
    184     natPulse( s, FALSE );
     184    natPulse( s, false );
    185185
    186186    tr_natpmpClose( s->natpmp );
     
    200200    tr_shared * s = session->shared;
    201201
    202     s->isShuttingDown = TRUE;
     202    s->isShuttingDown = true;
    203203    stop_forwarding( s );
    204204    s->session->shared = NULL;
     
    214214
    215215void
    216 tr_sharedTraversalEnable( tr_shared * s, tr_bool isEnabled )
     216tr_sharedTraversalEnable( tr_shared * s, bool isEnabled )
    217217{
    218218    if(( s->isEnabled = isEnabled ))
     
    230230    {
    231231        stop_timer( s );
    232         natPulse( s, FALSE );
     232        natPulse( s, false );
    233233        start_timer( s );
    234234    }
    235235}
    236236
    237 tr_bool
     237bool
    238238tr_sharedTraversalIsEnabled( const tr_shared * s )
    239239{
  • trunk/libtransmission/port-forwarding.h

    r11709 r12204  
    3636void       tr_sharedPortChanged( tr_session * );
    3737
    38 void       tr_sharedTraversalEnable( tr_shared *, tr_bool isEnabled );
     38void       tr_sharedTraversalEnable( tr_shared *, bool isEnabled );
    3939
    4040tr_port    tr_sharedGetPeerPort( const tr_shared * s );
    4141
    42 tr_bool    tr_sharedTraversalIsEnabled( const tr_shared * s );
     42bool       tr_sharedTraversalIsEnabled( const tr_shared * s );
    4343
    4444int        tr_sharedTraversalStatus( const tr_shared * );
  • trunk/libtransmission/ptrarray.c

    r12161 r12204  
    118118                       int                 compare( const void *,
    119119                                                    const void * ),
    120                        tr_bool *                    exact_match )
     120                       bool *                    exact_match )
    121121{
    122122    int len = t->n_items;
     
    136136        {
    137137            if( exact_match )
    138                 *exact_match = TRUE;
     138                *exact_match = true;
    139139            return middle;
    140140            break;
     
    147147
    148148    if( exact_match )
    149         *exact_match = FALSE;
     149        *exact_match = false;
    150150
    151151    return first;