Changeset 7813


Ignore:
Timestamp:
Jan 29, 2009, 6:18:24 PM (12 years ago)
Author:
charles
Message:

(trunk libT) backport latest changes to 1.5x -- (1) all of libT (2) more stats in daemon (3) compiler warning in gtk

Location:
branches/1.5x
Files:
35 edited

Legend:

Unmodified
Added
Removed
  • branches/1.5x/daemon/daemon.c

    r7689 r7813  
    6767    { 'u', "username", "Set username for authentication", "u", 1, "<username>" },
    6868    { 'v', "password", "Set password for authentication", "v", 1, "<password>" },
     69    { 'V', "version", "Show version number and exit", "V", 0, NULL },
    6970    { 'w', "download-dir", "Where to save downloaded data", "w", 1, "<path>" },
    7071    { 'P', "peerport", "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")", "P", 1, "<port>" },
     
    216217            case 'g': /* handled above */
    217218                      break;
     219            case 'V': /* version */
     220                      fprintf(stderr, "Transmission %s\n", LONG_VERSION_STRING);
     221                      exit( 0 );
    218222            case 'p': tr_bencDictAddInt( &settings, TR_PREFS_KEY_RPC_PORT, atoi( optarg ) );
    219223                      break;
  • branches/1.5x/daemon/remote.c

    r7767 r7813  
    2323
    2424#include <libevent/event.h>
     25
     26#define CURL_DISABLE_TYPECHECK /* otherwise -Wunreachable-code goes insane */
    2527#include <curl/curl.h>
    2628
     
    3739#define DEFAULT_PORT atoi(TR_DEFAULT_RPC_PORT_STR)
    3840
    39 enum { TAG_LIST, TAG_DETAILS, TAG_FILES, TAG_PEERS };
     41enum { TAG_SESSION, TAG_LIST, TAG_DETAILS, TAG_FILES, TAG_PEERS };
    4042
    4143static const char*
     
    8082    { 'r', "remove",               "Remove the current torrent(s)", "r",  0, NULL },
    8183    { 'R', "remove-and-delete",    "Remove the current torrent(s) and delete local data", NULL, 0, NULL },
     84    { 920, "session",              "Print session information", NULL,  0, NULL },
    8285    { 's', "start",                "Start the current torrent(s)", "s",  0, NULL },
    8386    { 'S', "stop",                 "Stop the current torrent(s)", "S",  0, NULL },
     
    8689    { 'U', "no-uplimit",           "Don't limit the global upload speed", "U",  0, NULL },
    8790    { 'v', "verify",               "Verify the current torrent(s)", "v",  0, NULL },
     91    { 'V', "version",              "Show version number and exit", "V", 0, NULL },
    8892    { 'w', "download-dir",         "Set the default download folder", "w",  1, "<path>" },
    8993    { 'x', "pex",                  "Enable peer exchange (PEX)", "x",  0, NULL },
     
    436440                break;
    437441
     442            case 'V':
     443                fprintf(stderr, "Transmission %s\n", LONG_VERSION_STRING);
     444                exit(0);
     445                break;
     446
    438447            case 'w': {
    439448                char * path = absolutify( optarg );
     
    493502                tr_bencDictAddStr( &top, "method", "session-set" );
    494503                tr_bencDictAddStr( args, "encryption", "tolerated" );
     504                break;
     505
     506            case 920:
     507                tr_bencDictAddStr( &top, "method", "session-get" );
     508                tr_bencDictAddInt( &top, "tag", TAG_SESSION );
    495509                break;
    496510
     
    712726    }
    713727    return str;
     728}
     729
     730static void
     731printSession( tr_benc * top )
     732{
     733    tr_benc *args;
     734    if( ( tr_bencDictFindDict( top, "arguments", &args ) ) )
     735    {
     736        const char * str;
     737        int64_t      i;
     738
     739        printf( "VERSION\n" );
     740        if( tr_bencDictFindStr( args,  "version", &str ) )
     741            printf( "  Daemon version: %s\n", str );
     742        if( tr_bencDictFindInt( args, "rpc-version", &i ) )
     743            printf( "  RPC version: %" PRId64 "\n", i );
     744        if( tr_bencDictFindInt( args, "rpc-version-minimum", &i ) )
     745            printf( "  RPC minimum version: %" PRId64 "\n", i );
     746        printf( "\n" );
     747
     748        printf( "TRANSFER\n" );
     749        if( tr_bencDictFindStr( args,  "download-dir", &str ) )
     750            printf( "  Download directory: %s\n", str );
     751        if( tr_bencDictFindInt( args, "port", &i ) )
     752            printf( "  Listenport: %" PRId64 "\n", i );
     753        if( tr_bencDictFindInt( args, "port-forwarding-enabled", &i ) )
     754            printf( "  Portforwarding enabled: %s\n", ( i ? "Yes" : "No" ) );
     755        if( tr_bencDictFindInt( args, "pex-allowed", &i ) )
     756            printf( "  Peer exchange allowed: %s\n", ( i ? "Yes" : "No" ) );
     757        if( tr_bencDictFindStr( args,  "encryption", &str ) )
     758            printf( "  Encryption: %s\n", str );
     759        printf( "\n" );
     760
     761        printf( "LIMITS\n" );
     762        if( tr_bencDictFindInt( args, "peer-limit", &i ) )
     763            printf( "  Peer limit: %" PRId64 "\n", i );
     764        if( tr_bencDictFindInt( args, "speed-limit-down-enabled", &i ) )
     765            printf( "  Downloadlimit enabled: %s\n", ( i ? "Yes" : "No" ) );
     766        if( tr_bencDictFindInt( args, "speed-limit-down", &i ) )
     767            printf( "  Downloadlimit: %6" PRId64 " KB/sec\n", i );
     768        if( tr_bencDictFindInt( args, "speed-limit-up-enabled", &i ) )
     769            printf( "  Uploadlimit enabled:   %s\n", ( i ? "Yes" : "No" ) );
     770        if( tr_bencDictFindInt( args, "speed-limit-up", &i ) )
     771            printf( "  Uploadlimit:   %6" PRId64 " KB/sec\n", i );
     772               
     773    }
    714774}
    715775
     
    10871147        switch( tag )
    10881148        {
     1149            case TAG_SESSION:
     1150                printSession( &top ); break;
     1151
    10891152            case TAG_FILES:
    10901153                printFileList( &top ); break;
  • branches/1.5x/daemon/transmission-daemon.1

    r7664 r7813  
    2424.Op Fl L Ar limit
    2525.Op Fl er | ep | et
     26.Op Fl V
    2627.Op Fl w Ar download-dir
    2728.Ek
     
    9899Used for client authentication.
    99100
     101.It Fl V Fl -version
     102Show version number and exit
     103
    100104.It Fl w Fl -download-dir
    101105Where to store downloaded data.
  • branches/1.5x/daemon/transmission-remote.1

    r7767 r7813  
    3434.Op Fl u Ar number | Fl U
    3535.Op Fl v
     36.Op Fl V
    3637.Op Fl w Ar download-dir
    3738.Op Fl x | X
     
    162163.It Fl v Fl -verify
    163164Verify the current torrent(s)
     165
     166.It Fl V Fl -version
     167Show version number and exit
    164168
    165169.It Fl w Fl -download-dir Ar directory
  • branches/1.5x/gtk/blocklist.c

    r6978 r7813  
    66#include <glib/gi18n.h>
    77
     8#define CURL_DISABLE_TYPECHECK /* otherwise -Wunreachable-code goes insane */
    89#include <curl/curl.h>
    910
  • branches/1.5x/libtransmission/bandwidth.c

    r7767 r7813  
    104104    tr_bandwidthSetParent( b, NULL );
    105105    tr_ptrArrayDestruct( &b->children, NULL );
    106     b->magicNumber = 0xDEAD;
    107 
     106
     107    memset( b, ~0, sizeof( tr_bandwidth ) );
    108108    return b;
    109109}
     
    208208    for( i=0; i<peerCount; ++i )
    209209        tr_peerIoRef( peers[i] );
    210 
    211     /* Stop all peers from listening for the socket to be ready for IO.
    212      * See "Second phase of IO" lower in this function for more info. */
    213     for( i=0; i<peerCount; ++i )
    214         tr_peerIoSetEnabled( peers[i], dir, FALSE );
    215210
    216211    /* First phase of IO.  Tries to distribute bandwidth fairly to keep faster
     
    247242     * or (2) the next tr_bandwidthAllocate() call, when we start over again. */
    248243    for( i=0; i<peerCount; ++i )
    249         if( tr_peerIoHasBandwidthLeft( peers[i], dir ) )
    250             tr_peerIoSetEnabled( peers[i], dir, TRUE );
     244        tr_peerIoSetEnabled( peers[i], dir, tr_peerIoHasBandwidthLeft( peers[i], dir ) );
    251245
    252246    for( i=0; i<peerCount; ++i )
  • branches/1.5x/libtransmission/bencode-test.c

    r7664 r7813  
    1111#include "utils.h" /* tr_free */
    1212
    13 #define VERBOSE 0
     13#undef VERBOSE
    1414
    1515static int test = 0;
    1616
    17 #define check( A ) \
     17#ifdef VERBOSE
     18  #define check( A ) \
    1819    { \
    1920        ++test; \
    2021        if( A ){ \
    21             if( VERBOSE ) \
    22                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    23                          __LINE__ );\
     22            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2423        } else { \
    25             fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    26                      __LINE__ ); \
     24            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2725            return test; \
    2826        } \
    2927    }
     28#else
     29  #define check( A ) \
     30    { \
     31        ++test; \
     32        if( !( A ) ){ \
     33            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     34            return test; \
     35        } \
     36    }
     37#endif
    3038
    3139static int
  • branches/1.5x/libtransmission/blocklist-test.c

    r7664 r7813  
    77#include "utils.h"
    88
    9 #define VERBOSE 0
     9#undef VERBOSE
    1010
    11 #define check( A ) \
     11#ifdef VERBOSE
     12  #define check( A ) \
    1213    { \
    1314        ++test; \
    1415        if( A ){ \
    15             if( VERBOSE ) \
    16                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    17                          __LINE__ );\
     16            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    1817        } else { \
    19             if( VERBOSE ) \
    20                 fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    21                          __LINE__ );\
     18            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2219            return test; \
    2320        } \
    2421    }
     22#else
     23  #define check( A )\
     24    { \
     25        ++test; \
     26        if( !( A ) ){ \
     27            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     28            return test; \
     29        } \
     30    }
     31#endif
    2532
    2633static void
     
    4653{
    4754#ifndef WIN32
    48     char *         tmpfile_txt = "/tmp/transmission-blocklist-test.txt";
    49     char *         tmpfile_bin = "/tmp/transmission-blocklist-test.bin";
     55    const char *   tmpfile_txt = "/tmp/transmission-blocklist-test.txt";
     56    const char *   tmpfile_bin = "/tmp/transmission-blocklist-test.bin";
    5057#else
    51     char *         tmpfile_txt = "transmission-blocklist-test.txt";
    52     char *         tmpfile_bin = "transmission-blocklist-test.bin";
     58    const char *   tmpfile_txt = "transmission-blocklist-test.txt";
     59    const char *   tmpfile_bin = "transmission-blocklist-test.bin";
    5360#endif
    5461    struct tr_address addr;
  • branches/1.5x/libtransmission/clients-test.c

    r6822 r7813  
    55#include "clients.h"
    66
    7 #define VERBOSE 0
     7#undef VERBOSE
    88
    9 #define check( A ) \
     9#ifdef VERBOSE
     10  #define check( A ) \
    1011    { \
    1112        ++test; \
    1213        if( A ){ \
    13             if( VERBOSE ) \
    14                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    15                          __LINE__ );\
     14            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    1615        } else { \
    17             if( VERBOSE ) \
    18                 fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    19                          __LINE__ );\
     16            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2017            return test; \
    2118        } \
    2219    }
     20#else
     21  #define check( A ) \
     22    { \
     23        ++test; \
     24        if( !( A ) ){ \
     25            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     26            return test; \
     27        } \
     28    }
     29#endif
    2330
    2431#define TEST_CLIENT( A, B ) \
  • branches/1.5x/libtransmission/completion.c

    r7722 r7813  
    325325    const tr_file * file = &tor->info.files[fileIndex];
    326326    const tr_block_index_t firstBlock = file->offset / tor->blockSize;
    327     const tr_block_index_t lastBlock = ( file->offset + file->length - 1 ) / tor->blockSize;
    328 
    329     assert( tr_torBlockPiece( tor, firstBlock ) == file->firstPiece );
    330     assert( tr_torBlockPiece( tor, lastBlock ) == file->lastPiece );
     327    const tr_block_index_t lastBlock = file->length ? ( ( file->offset + file->length - 1 ) / tor->blockSize ) : firstBlock;
     328
     329    tr_assert( tr_torBlockPiece( tor, firstBlock ) == file->firstPiece,
     330               "file->offset %"PRIu64"; file->length %"PRIu64"; "
     331               "pieceSize %"PRIu32"; blockSize %"PRIu32"; "
     332               "firstBlock %"PRIu64"; lastBlock %"PRIu64,
     333               file->offset, file->length,
     334               tor->info.pieceSize, tor->blockSize,
     335               firstBlock, lastBlock );
     336
     337    tr_assert( tr_torBlockPiece( tor, lastBlock ) == file->lastPiece,
     338               "file->offset %"PRIu64"; file->length %"PRIu64"; "
     339               "pieceSize %"PRIu32"; blockSize %"PRIu32"; "
     340               "firstBlock %"PRIu64"; lastBlock %"PRIu64,
     341               file->offset, file->length,
     342               tor->info.pieceSize, tor->blockSize,
     343               firstBlock, lastBlock );
    331344
    332345    for( block=firstBlock; block<=lastBlock; ++block )
  • branches/1.5x/libtransmission/fdlimit.c

    r7767 r7813  
    2727#endif
    2828
     29#ifdef HAVE_POSIX_FADVISE
     30 #ifdef _XOPEN_SOURCE
     31  #undef _XOPEN_SOURCE
     32 #endif
     33 #define _XOPEN_SOURCE 600
     34#endif
     35
    2936#include <assert.h>
    3037#include <errno.h>
     
    4855#endif
    4956#include <unistd.h>
    50 #include <fcntl.h> /* O_LARGEFILE */
    51 
    52 #include <event.h>
     57#include <fcntl.h> /* O_LARGEFILE posix_fadvise */
     58
    5359#include <evutil.h>
    5460
     
    7480    NOFILE_BUFFER = 512, /* the process' number of open files is
    7581                            globalMaxPeers + NOFILE_BUFFER */
     82
     83    SYNC_INTERVAL = 15   /* (arbitrary number) how many seconds to go
     84                            between fsync calls for files in heavy use */
    7685};
    7786
     
    8493    int        fd;
    8594    uint64_t   date;
     95    time_t     syncAt;
    8696};
    8797
     
    232242    /* open the file */
    233243    flags = doWrite ? ( O_RDWR | O_CREAT ) : O_RDONLY;
     244#ifdef O_RANDOM
     245    flags |= O_RANDOM
     246#endif
    234247#ifdef O_LARGEFILE
    235248    flags |= O_LARGEFILE;
     
    249262    if( doWrite && !alreadyExisted && ( preallocationMode == TR_PREALLOCATE_SPARSE ) )
    250263        preallocateFileSparse( file->fd, desiredFileSize );
     264
     265#if defined( SYS_DARWIN )
     266    fcntl( file->fd, F_NOCACHE, 1 );
     267    fcntl( file->fd, F_RDAHEAD, 0 );
     268#elif defined( HAVE_POSIX_FADVISE )
     269    posix_fadvise( file->fd, 0, 0, POSIX_FADV_RANDOM );
     270#endif
    251271
    252272    tr_free( filename );
     
    372392        else
    373393        {
    374             dbgmsg(
    375                 "everything's full!  waiting for someone else to finish something" );
     394            dbgmsg( "everything's full!  waiting for someone else to finish something" );
    376395            tr_lockUnlock( gFd->lock );
    377396            tr_wait( 200 );
     
    395414        tr_strlcpy( o->filename, filename, sizeof( o->filename ) );
    396415        o->isWritable = doWrite;
     416        o->syncAt = time( NULL ) + SYNC_INTERVAL;
    397417    }
    398418
     
    422442        if( o->closeWhenDone )
    423443            TrCloseFile( i );
     444        else if( o->syncAt <= time( NULL ) ) {
     445            dbgmsg( "fsync()ing file '%s' in slot #%d", o->filename, i );
     446            fsync( o->fd );
     447#ifdef HAVE_POSIX_FADVISE
     448            /* TODO: test performance with and without this */
     449            posix_fadvise( o->fd, 0, 0, POSIX_FADV_DONTNEED );
     450#endif
     451            o->syncAt = time( NULL ) + SYNC_INTERVAL;
     452        }
    424453
    425454        break;
  • branches/1.5x/libtransmission/handshake.c

    r7771 r7813  
    229229
    230230static int tr_handshakeDone( tr_handshake * handshake,
    231                              int            isConnected );
     231                             tr_bool        isConnected );
    232232
    233233enum
     
    10791079static int
    10801080fireDoneFunc( tr_handshake * handshake,
    1081               int            isConnected )
     1081              tr_bool        isConnected )
    10821082{
    10831083    const uint8_t * peer_id = isConnected && handshake->havePeerID
     
    11051105static int
    11061106tr_handshakeDone( tr_handshake * handshake,
    1107                   int            isOK )
     1107                  tr_bool        isOK )
    11081108{
    11091109    tr_bool success;
  • branches/1.5x/libtransmission/handshake.h

    r7664 r7813  
    2727typedef tr_bool ( *handshakeDoneCB )( struct tr_handshake * handshake,
    2828                                      struct tr_peerIo *    io,
    29                                       int                   isConnected,
     29                                      tr_bool               isConnected,
    3030                                      const uint8_t *       peerId,
    3131                                      void *                userData );
  • branches/1.5x/libtransmission/json-test.c

    r7664 r7813  
    66#include "utils.h" /* tr_free */
    77
    8 #define VERBOSE 0
     8#undef VERBOSE
    99
    1010static int test = 0;
    1111
    12 #define check( A ) \
     12#ifdef VERBOSE
     13  #define check( A ) \
    1314    { \
    1415        ++test; \
    1516        if( A ){ \
    16             if( VERBOSE ) \
    17                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    18                          __LINE__ );\
     17            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    1918        } else { \
    20             fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    21                      __LINE__ ); \
     19            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2220            return test; \
    2321        } \
    2422    }
     23#else
     24  #define check( A ) \
     25    { \
     26        ++test; \
     27        if( !( A ) ){ \
     28            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     29            return test; \
     30        } \
     31    }
     32#endif
    2533
    2634#include "ConvertUTF.h"
  • branches/1.5x/libtransmission/list.c

    r7664 r7813  
    1515#include "utils.h"
    1616
    17 /***
    18 ****
    19 ***/
    20 
    21 static tr_list * _unusedNodes = NULL;
    22 
    23 static const tr_list TR_LIST_INIT = { NULL, NULL, NULL };
    24 
    2517static tr_list*
    2618node_alloc( void )
    2719{
    28     tr_list * node;
    29 
    30     if( _unusedNodes == NULL )
    31         node = tr_new( tr_list, 1 );
    32     else {
    33         node = _unusedNodes;
    34         _unusedNodes = node->next;
    35     }
    36 
    37     *node = TR_LIST_INIT;
    38     return node;
     20    return tr_new0( tr_list, 1 );
    3921}
    4022
     
    4224node_free( tr_list* node )
    4325{
    44     if( node )
    45     {
    46         *node = TR_LIST_INIT;
    47         node->next = _unusedNodes;
    48         _unusedNodes = node;
    49     }
     26    tr_free( node );
    5027}
    5128
  • branches/1.5x/libtransmission/peer-io.c

    r7771 r7813  
    171171    return ( io != NULL )
    172172        && ( io->magicNumber == MAGIC_NUMBER )
    173         && ( io->refCount > 0 )
     173        && ( io->refCount >= 0 )
    174174        && ( tr_isBandwidth( &io->bandwidth ) )
    175175        && ( tr_isAddress( &io->addr ) );
     
    192192
    193193    io->hasFinishedConnecting = TRUE;
     194    io->pendingEvents &= ~EV_READ;
    194195
    195196    curlen = EVBUFFER_LENGTH( io->inbuf );
     
    274275
    275276    io->hasFinishedConnecting = TRUE;
     277    io->pendingEvents &= ~EV_WRITE;
    276278
    277279    dbgmsg( io, "libevent says this peer is ready to write" );
     
    344346{
    345347    tr_peerIo * io;
     348
     349    assert( session != NULL );
     350    assert( session->events != NULL );
     351    assert( tr_amInEventThread( session ) );
    346352
    347353    if( socket >= 0 )
     
    420426    tr_peerIo * io = vio;
    421427
     428    assert( tr_isPeerIo( io ) );
     429    assert( tr_amInEventThread( io->session ) );
     430    assert( io->session->events != NULL );
     431
     432    dbgmsg( io, "in tr_peerIo destructor" );
    422433    event_del( &io->event_read );
    423434    event_del( &io->event_write );
     
    429440    __tr_list_destroy( &io->outbuf_datatypes, trDatatypeFree );
    430441
    431     io->magicNumber = 0xDEAD;
     442    memset( io, ~0, sizeof( tr_peerIo ) );
    432443    tr_free( io );
    433444}
     
    438449    if( io )
    439450    {
     451        dbgmsg( io, "in tr_peerIoFree" );
    440452        io->canRead = NULL;
    441453        io->didWrite = NULL;
     
    446458
    447459void
    448 tr_peerIoRef( tr_peerIo * io )
    449 {
    450     assert( tr_isPeerIo( io ) );
     460tr_peerIoRefImpl( const char * file, int line, tr_peerIo * io )
     461{
     462    assert( tr_isPeerIo( io ) );
     463
     464    dbgmsg( io, "%s:%d is incrementing the IO's refcount from %d to %d",
     465                file, line, io->refCount, io->refCount+1 );
    451466
    452467    ++io->refCount;
     
    454469
    455470void
    456 tr_peerIoUnref( tr_peerIo * io )
    457 {
    458     assert( tr_isPeerIo( io ) );
     471tr_peerIoUnrefImpl( const char * file, int line, tr_peerIo * io )
     472{
     473    assert( tr_isPeerIo( io ) );
     474
     475    dbgmsg( io, "%s:%d is decrementing the IO's refcount from %d to %d",
     476                file, line, io->refCount, io->refCount-1 );
    459477
    460478    if( !--io->refCount )
     
    463481
    464482const tr_address*
    465 tr_peerIoGetAddress( const tr_peerIo * io,
    466                            tr_port   * port )
     483tr_peerIoGetAddress( const tr_peerIo * io, tr_port   * port )
    467484{
    468485    assert( tr_isPeerIo( io ) );
     
    824841    }
    825842
    826     dbgmsg( io, "flushing peer-io, direction %d, limit %zu, bytesUsed %d", (int)dir, limit, bytesUsed );
     843    dbgmsg( io, "flushing peer-io, hasFinishedConnecting %d, direction %d, limit %zu, bytesUsed %d", (int)io->hasFinishedConnecting, (int)dir, limit, bytesUsed );
    827844    return bytesUsed;
    828845}
     
    835852event_enable( tr_peerIo * io, short event )
    836853{
    837     if( event & EV_READ )
     854    assert( tr_amInEventThread( io->session ) );
     855    assert( io->session != NULL );
     856    assert( io->session->events != NULL );
     857    assert( event_initialized( &io->event_read ) );
     858    assert( event_initialized( &io->event_write ) );
     859
     860    if( ( event & EV_READ ) && ! ( io->pendingEvents & EV_READ ) )
     861    {
     862        dbgmsg( io, "enabling libevent ready-to-read polling" );
    838863        event_add( &io->event_read, NULL );
    839 
    840     if( event & EV_WRITE )
     864        io->pendingEvents |= EV_READ;
     865    }
     866
     867    if( ( event & EV_WRITE ) && ! ( io->pendingEvents & EV_WRITE ) )
     868    {
     869        dbgmsg( io, "enabling libevent ready-to-write polling" );
    841870        event_add( &io->event_write, NULL );
     871        io->pendingEvents |= EV_WRITE;
     872    }
    842873}
    843874
     
    845876event_disable( struct tr_peerIo * io, short event )
    846877{
    847     if( event & EV_READ )
     878    assert( tr_amInEventThread( io->session ) );
     879    assert( io->session != NULL );
     880    assert( io->session->events != NULL );
     881    assert( event_initialized( &io->event_read ) );
     882    assert( event_initialized( &io->event_write ) );
     883
     884    if( ( event & EV_READ ) && ( io->pendingEvents & EV_READ ) )
     885    {
     886        dbgmsg( io, "disabling libevent ready-to-read polling" );
    848887        event_del( &io->event_read );
    849 
    850     if( event & EV_WRITE )
     888        io->pendingEvents &= ~EV_READ;
     889    }
     890
     891    if( ( event & EV_WRITE ) && ( io->pendingEvents & EV_WRITE ) )
     892    {
     893        dbgmsg( io, "disabling libevent ready-to-write polling" );
    851894        event_del( &io->event_write );
     895        io->pendingEvents &= ~EV_WRITE;
     896    }
    852897}
    853898
     
    862907    assert( tr_isPeerIo( io ) );
    863908    assert( tr_isDirection( dir ) );
     909    assert( tr_amInEventThread( io->session ) );
     910    assert( io->session->events != NULL );
    864911
    865912    if( isEnabled )
  • branches/1.5x/libtransmission/peer-io.h

    r7771 r7813  
    7070    tr_bool               hasFinishedConnecting;
    7171
     72    int                   pendingEvents;
     73
    7274    int                   magicNumber;
    7375
     
    119121                                  int                       socket );
    120122
    121 void tr_peerIoRef               ( tr_peerIo * io );
    122 
    123 void tr_peerIoUnref             ( tr_peerIo * io );
     123void tr_peerIoRefImpl           ( const char              * file,
     124                                  int                       line,
     125                                  tr_peerIo               * io );
     126
     127#define tr_peerIoRef(io) tr_peerIoRefImpl( __FILE__, __LINE__, (io) );
     128
     129void tr_peerIoUnrefImpl         ( const char              * file,
     130                                  int                       line,
     131                                  tr_peerIo               * io );
     132
     133#define tr_peerIoUnref(io) tr_peerIoUnrefImpl( __FILE__, __LINE__, (io) );
    124134
    125135tr_bool     tr_isPeerIo         ( const tr_peerIo         * io );
     
    328338
    329339static TR_INLINE void tr_peerIoSetParent( tr_peerIo            * io,
    330                                        struct tr_bandwidth  * parent )
     340                                          struct tr_bandwidth  * parent )
    331341{
    332342    assert( tr_isPeerIo( io ) );
     
    341351
    342352static TR_INLINE tr_bool tr_peerIoHasBandwidthLeft( const tr_peerIo  * io,
    343                                                  tr_direction       dir )
    344 {
    345     assert( tr_isPeerIo( io ) );
    346 
    347     return tr_bandwidthClamp( &io->bandwidth, dir, 1024 ) > 0;
     353                                                    tr_direction       dir )
     354{
     355    assert( tr_isPeerIo( io ) );
     356
     357    return !io->hasFinishedConnecting
     358        || ( tr_bandwidthClamp( &io->bandwidth, dir, 1024 ) > 0 );
    348359}
    349360
  • branches/1.5x/libtransmission/peer-mgr.c

    r7767 r7813  
    11611161myHandshakeDoneCB( tr_handshake  * handshake,
    11621162                   tr_peerIo     * io,
    1163                    int             isConnected,
     1163                   tr_bool         isConnected,
    11641164                   const uint8_t * peer_id,
    11651165                   void          * vmanager )
     
    11741174
    11751175    assert( io );
    1176     assert( isConnected == 0 || isConnected == 1 );
     1176    assert( tr_isBool( ok ) );
    11771177
    11781178    t = tr_peerIoHasTorrentHash( io )
  • branches/1.5x/libtransmission/peer-msgs-test.c

    r7664 r7813  
    55#include "utils.h"
    66
    7 #define VERBOSE 0
     7#undef VERBOSE
    88
    9 #define check( A ) \
     9#ifdef VERBOSE
     10  #define check( A ) \
    1011    { \
    1112        ++test; \
    1213        if( A ){ \
    13             if( VERBOSE ) \
    14                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    15                          __LINE__ );\
     14            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    1615        } else { \
    17             if( VERBOSE ) \
    18                 fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    19                          __LINE__ );\
     16            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2017            return test; \
    2118        } \
    2219    }
     20#else
     21  #define check( A ) \
     22    { \
     23        ++test; \
     24        if( !( A ) ){ \
     25            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     26            return test; \
     27        } \
     28    }
     29#endif
    2330
    2431int
  • branches/1.5x/libtransmission/request-list-test.c

    r7664 r7813  
    33#include "request-list.h"
    44
    5 #define VERBOSE 0
     5#undef VERBOSE
    66
    77static int test = 0;
    88
    9 #define check( A ) \
     9#ifdef VERBOSE
     10  #define check( A ) \
    1011    { \
    1112        ++test; \
    1213        if( A ){ \
    13             if( VERBOSE ) \
    14                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    15                          __LINE__ );\
     14            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    1615        } else { \
    17             fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    18                      __LINE__ ); \
     16            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    1917            return test; \
    2018        } \
    2119    }
     20#else
     21  #define check( A ) \
     22    { \
     23        ++test; \
     24        if( !( A ) ){ \
     25            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     26            return test; \
     27        } \
     28    }
     29#endif
    2230
    2331static int
  • branches/1.5x/libtransmission/rpc-test.c

    r6944 r7813  
    66#include "utils.h"
    77
    8 #define VERBOSE 0
     8#undef VERBOSE
    99
    1010static int test = 0;
    1111
    12 #define check( A ) \
     12#ifdef VERBOSE
     13  #define check( A ) \
    1314    { \
    1415        ++test; \
    1516        if( A ){ \
    16             if( VERBOSE ) \
    17                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    18                          __LINE__ );\
     17            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    1918        } else { \
    20             if( VERBOSE ) \
    21                 fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    22                          __LINE__ );\
     19            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2320            return test; \
    2421        } \
    2522    }
     23#else
     24  #define check( A ) \
     25    { \
     26        ++test; \
     27        if( !( A ) ){ \
     28            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     29            return test; \
     30        } \
     31    }
     32#endif
    2633
    2734static int
  • branches/1.5x/libtransmission/rpcimpl.c

    r7767 r7813  
    511511    tr_benc *     list = tr_bencDictAddList( args_out, "torrents", torrentCount );
    512512    tr_benc *     fields;
    513     char *        msg = NULL;
     513    const char *  msg = NULL;
    514514
    515515    assert( idle_data == NULL );
  • branches/1.5x/libtransmission/session.c

    r7722 r7813  
    358358
    359359static void metainfoLookupRescan( tr_session * );
     360static void tr_sessionInitImpl( void * );
    360361
    361362tr_session *
     
    379380    session->lock = tr_lockNew( );
    380381    session->tag = tr_strdup( tag );
     382    session->magicNumber = SESSION_MAGIC_NUMBER;
     383
    381384    dbgmsg( "tr_sessionInit: the session's top-level bandwidth object is %p", session->bandwidth );
    382385
     
    456459
    457460    tr_netInit( ); /* must go before tr_eventInit */
    458 
    459461    tr_eventInit( session );
    460     while( !session->events )
    461         tr_wait( 50 );
     462    assert( session->events != NULL );
    462463
    463464    session->peerMgr = tr_peerMgrNew( session );
     
    517518    tr_sessionSetSpeedLimit( session, TR_DOWN, i );
    518519    tr_sessionSetSpeedLimitEnabled( session, TR_DOWN, j );
    519  
    520     /* first %s is the application name
    521        second %s is the version number */
    522     tr_inf( _( "%s %s started" ), TR_NAME, LONG_VERSION_STRING );
    523520
    524521    /* initialize the blocklist */
     
    531528    loadBlocklists( session );
    532529
     530    session->rpcServer = tr_rpcInit( session, &settings );
     531
     532    tr_bencFree( &settings );
     533
     534    session->isWaiting = TRUE;
     535    tr_runInEventThread( session, tr_sessionInitImpl, session );
     536    while( session->isWaiting )
     537        tr_wait( 100 );
     538
     539    return session;
     540}
     541static void
     542tr_sessionInitImpl( void * vsession )
     543{
     544    tr_session * session = vsession;
     545
     546    assert( tr_isSession( session ) );
     547 
     548    /* first %s is the application name
     549       second %s is the version number */
     550    tr_inf( _( "%s %s started" ), TR_NAME, LONG_VERSION_STRING );
     551
    533552    tr_statsInit( session );
    534 
    535553    session->web = tr_webInit( session );
    536     session->rpcServer = tr_rpcInit( session, &settings );
    537 
    538554    metainfoLookupRescan( session );
    539 
    540     tr_bencFree( &settings );
    541     return session;
     555    session->isWaiting = FALSE;
    542556}
    543557
     
    549563tr_sessionSetDownloadDir( tr_session * session, const char * dir )
    550564{
     565    assert( tr_isSession( session ) );
     566
    551567    if( session->downloadDir != dir )
    552568    {
     
    559575tr_sessionGetDownloadDir( const tr_session * session )
    560576{
     577    assert( tr_isSession( session ) );
     578
    561579    return session->downloadDir;
    562580}
     
    569587tr_globalLock( tr_session * session )
    570588{
     589    assert( tr_isSession( session ) );
     590
    571591    tr_lockLock( session->lock );
    572592}
     
    575595tr_globalUnlock( tr_session * session )
    576596{
     597    assert( tr_isSession( session ) );
     598
    577599    tr_lockUnlock( session->lock );
    578600}
     
    581603tr_globalIsLocked( const tr_session * session )
    582604{
    583     return session && tr_lockHave( session->lock );
     605    return tr_isSession( session ) && tr_lockHave( session->lock );
    584606}
    585607
     
    612634setPortImpl( tr_session * session, tr_port port )
    613635{
    614     struct bind_port_data * data = tr_new( struct bind_port_data, 1 );
     636    struct bind_port_data * data;
     637
     638    assert( tr_isSession( session ) );
     639
     640    data = tr_new( struct bind_port_data, 1 );
    615641    data->session = session;
    616642    data->port = port;
     
    622648                       tr_port      port )
    623649{
     650    assert( tr_isSession( session ) );
     651
    624652    session->isPortRandom = FALSE;
    625653    session->peerPort = port;
     
    630658tr_sessionSetPeerPortRandom( tr_session * session )
    631659{
     660    assert( tr_isSession( session ) );
     661
    632662    session->isPortRandom = TRUE;
    633663    session->peerPort = getRandomPort( session );
     
    639669tr_sessionGetPeerPort( const tr_session * session )
    640670{
    641     assert( session );
     671    assert( tr_isSession( session ) );
    642672
    643673    return session->peerPort;
     
    647677tr_sessionGetPortForwarding( const tr_session * session )
    648678{
     679    assert( tr_isSession( session ) );
     680
    649681    return tr_sharedTraversalStatus( session->shared );
    650682}
     
    657689updateBandwidth( tr_session * session, tr_direction dir )
    658690{
    659     const tr_bool zeroCase = session->speedLimit[dir] < 1 && session->isSpeedLimited[dir];
     691    tr_bool zeroCase;
     692
     693    assert( tr_isSession( session ) );
     694
     695    zeroCase = session->speedLimit[dir] < 1 && session->isSpeedLimited[dir];
    660696
    661697    tr_bandwidthSetLimited( session->bandwidth, dir, session->isSpeedLimited[dir] && !zeroCase );
     
    669705                                tr_bool           isLimited )
    670706{
    671     assert( session );
     707    assert( tr_isSession( session ) );
    672708    assert( tr_isDirection( dir ) );
    673709
     
    681717                         int             desiredSpeed )
    682718{
    683     assert( session );
     719    assert( tr_isSession( session ) );
    684720    assert( tr_isDirection( dir ) );
    685721
     
    692728                               tr_direction        dir )
    693729{
    694     assert( session );
     730    assert( tr_isSession( session ) );
    695731    assert( tr_isDirection( dir ) );
    696732
     
    702738                         tr_direction        dir )
    703739{
    704     assert( session );
     740    assert( tr_isSession( session ) );
    705741    assert( tr_isDirection( dir ) );
    706742
     
    713749
    714750void
    715 tr_sessionSetPeerLimit( tr_session * session UNUSED,
     751tr_sessionSetPeerLimit( tr_session * session,
    716752                        uint16_t     maxGlobalPeers )
    717753{
     754    assert( tr_isSession( session ) );
     755
    718756    tr_fdSetPeerLimit( maxGlobalPeers );
    719757}
    720758
    721759uint16_t
    722 tr_sessionGetPeerLimit( const tr_session * session UNUSED )
    723 {
     760tr_sessionGetPeerLimit( const tr_session * session )
     761{
     762    assert( tr_isSession( session ) );
     763
    724764    return tr_fdGetPeerLimit( );
    725765}
     
    728768tr_sessionSetPeerLimitPerTorrent( tr_session  * session, uint16_t n )
    729769{
     770    assert( tr_isSession( session ) );
     771
    730772    session->peerLimitPerTorrent = n;
    731773}
     
    734776tr_sessionGetPeerLimitPerTorrent( const tr_session * session )
    735777{
     778    assert( tr_isSession( session ) );
     779
    736780    return session->peerLimitPerTorrent;
    737781}
     
    744788tr_sessionGetPieceSpeed( const tr_session * session, tr_direction dir )
    745789{
    746     return session ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
     790    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
    747791}
    748792
     
    750794tr_sessionGetRawSpeed( const tr_session * session, tr_direction dir )
    751795{
    752     return session ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
     796    return tr_isSession( session ) ? tr_bandwidthGetPieceSpeed( session->bandwidth, 0, dir ) : 0.0;
    753797}
    754798
     
    756800tr_sessionCountTorrents( const tr_session * session )
    757801{
    758     return session->torrentCount;
     802    return tr_isSession( session ) ? session->torrentCount : 0;
    759803}
    760804
     
    780824    int           i, n;
    781825    tr_torrent ** torrents;
     826
     827    assert( tr_isSession( session ) );
    782828
    783829    tr_statsClose( session );
     
    822868    const int      maxwait_msec = SHUTDOWN_MAX_SECONDS * 1000;
    823869    const uint64_t deadline = tr_date( ) + maxwait_msec;
     870
     871    assert( tr_isSession( session ) );
    824872
    825873    dbgmsg( "shutting down transmission session %p", session );
     
    884932    tr_torrent ** torrents;
    885933    tr_list *     l = NULL, *list = NULL;
     934
     935    assert( tr_isSession( session ) );
    886936
    887937    tr_ctorSetSave( ctor, FALSE ); /* since we already have them */
     
    934984                         tr_bool      enabled )
    935985{
     986    assert( tr_isSession( session ) );
     987
    936988    session->isPexEnabled = enabled != 0;
    937989}
     
    940992tr_sessionIsPexEnabled( const tr_session * session )
    941993{
     994    assert( tr_isSession( session ) );
     995
    942996    return session->isPexEnabled;
    943997}
     
    9511005                                  tr_bool      enabled )
    9521006{
     1007    assert( tr_isSession( session ) );
     1008
    9531009    session->useLazyBitfield = enabled != 0;
    9541010}
     
    9571013tr_sessionIsLazyBitfieldEnabled( const tr_session * session )
    9581014{
     1015    assert( tr_isSession( session ) );
     1016
    9591017    return session->useLazyBitfield;
    9601018}
     
    9681026                                    tr_bool       enabled )
    9691027{
     1028    assert( tr_isSession( session ) );
     1029
    9701030    tr_globalLock( session );
    9711031    tr_sharedTraversalEnable( session->shared, enabled );
     
    9761036tr_sessionIsPortForwardingEnabled( const tr_session * session )
    9771037{
     1038    assert( tr_isSession( session ) );
     1039
    9781040    return tr_sharedTraversalIsEnabled( session->shared );
    9791041}
     
    9891051    tr_list * l;
    9901052
     1053    assert( tr_isSession( session ) );
     1054
    9911055    for( l = session->blocklists; l; l = l->next )
    9921056        n += _tr_blocklistGetRuleCount( l->data );
     
    9971061tr_blocklistIsEnabled( const tr_session * session )
    9981062{
     1063    assert( tr_isSession( session ) );
     1064
    9991065    return session->isBlocklistEnabled;
    10001066}
     
    10061072    tr_list * l;
    10071073
     1074    assert( tr_isSession( session ) );
     1075
    10081076    session->isBlocklistEnabled = isEnabled != 0;
    10091077
     
    10151083tr_blocklistExists( const tr_session * session )
    10161084{
     1085    assert( tr_isSession( session ) );
     1086
    10171087    return session->blocklists != NULL;
    10181088}
     
    10251095    tr_blocklist * b;
    10261096    const char *   defaultName = "level1.bin";
     1097
     1098    assert( tr_isSession( session ) );
    10271099
    10281100    for( b = NULL, l = session->blocklists; !b && l; l = l->next )
     
    10481120    tr_list * l;
    10491121
     1122    assert( tr_isSession( session ) );
     1123
    10501124    for( l = session->blocklists; l; l = l->next )
    10511125        if( _tr_blocklistHasAddress( l->data, addr ) )
     
    10591133
    10601134static int
    1061 compareLookupEntries( const void * va,
    1062                       const void * vb )
     1135compareLookupEntries( const void * va, const void * vb )
    10631136{
    10641137    const struct tr_metainfo_lookup * a = va;
     
    10711144metainfoLookupResort( tr_session * session )
    10721145{
     1146    assert( tr_isSession( session ) );
     1147
    10731148    qsort( session->metainfoLookup,
    10741149           session->metainfoLookupCount,
     
    10781153
    10791154static int
    1080 compareHashStringToLookupEntry( const void * va,
    1081                                 const void * vb )
     1155compareHashStringToLookupEntry( const void * va, const void * vb )
    10821156{
    10831157    const char *                      a = va;
     
    11101184    tr_ctor *    ctor = NULL;
    11111185    tr_list *    list = NULL;
     1186
     1187    assert( tr_isSession( session ) );
    11121188
    11131189    /* walk through the directory and find the mappings */
     
    11931269                tr_torrent * tor )
    11941270{
     1271    assert( tr_isSession( session ) );
     1272
    11951273    return tor ? tor->next : session->torrentList;
    11961274}
     
    12041282                         tr_bool      isEnabled )
    12051283{
     1284    assert( tr_isSession( session ) );
     1285
    12061286    tr_rpcSetEnabled( session->rpcServer, isEnabled );
    12071287}
     
    12101290tr_sessionIsRPCEnabled( const tr_session * session )
    12111291{
     1292    assert( tr_isSession( session ) );
     1293
    12121294    return tr_rpcIsEnabled( session->rpcServer );
    12131295}
     
    12171299                      tr_port      port )
    12181300{
     1301    assert( tr_isSession( session ) );
     1302
    12191303    tr_rpcSetPort( session->rpcServer, port );
    12201304}
     
    12231307tr_sessionGetRPCPort( const tr_session * session )
    12241308{
     1309    assert( tr_isSession( session ) );
     1310
    12251311    return tr_rpcGetPort( session->rpcServer );
    12261312}
     
    12311317                          void *       user_data )
    12321318{
     1319    assert( tr_isSession( session ) );
     1320
    12331321    session->rpc_func = func;
    12341322    session->rpc_func_user_data = user_data;
     
    12391327                           const char * whitelist )
    12401328{
     1329    assert( tr_isSession( session ) );
     1330
    12411331    tr_rpcSetWhitelist( session->rpcServer, whitelist );
    12421332}
     
    12451335tr_sessionGetRPCWhitelist( const tr_session * session )
    12461336{
     1337    assert( tr_isSession( session ) );
     1338
    12471339    return tr_rpcGetWhitelist( session->rpcServer );
    12481340}
     
    12521344                                  tr_bool      isEnabled )
    12531345{
     1346    assert( tr_isSession( session ) );
     1347
    12541348    tr_rpcSetWhitelistEnabled( session->rpcServer, isEnabled );
    12551349}
     
    12581352tr_sessionGetRPCWhitelistEnabled( const tr_session * session )
    12591353{
     1354    assert( tr_isSession( session ) );
     1355
    12601356    return tr_rpcGetWhitelistEnabled( session->rpcServer );
    12611357}
     
    12661362                          const char * password )
    12671363{
     1364    assert( tr_isSession( session ) );
     1365
    12681366    tr_rpcSetPassword( session->rpcServer, password );
    12691367}
     
    12721370tr_sessionGetRPCPassword( const tr_session * session )
    12731371{
     1372    assert( tr_isSession( session ) );
     1373
    12741374    return tr_rpcGetPassword( session->rpcServer );
    12751375}
     
    12791379                          const char * username )
    12801380{
     1381    assert( tr_isSession( session ) );
     1382
    12811383    tr_rpcSetUsername( session->rpcServer, username );
    12821384}
     
    12851387tr_sessionGetRPCUsername( const tr_session * session )
    12861388{
     1389    assert( tr_isSession( session ) );
     1390
    12871391    return tr_rpcGetUsername( session->rpcServer );
    12881392}
     
    12921396                                 tr_bool      isEnabled )
    12931397{
     1398    assert( tr_isSession( session ) );
     1399
    12941400    tr_rpcSetPasswordEnabled( session->rpcServer, isEnabled );
    12951401}
     
    12981404tr_sessionIsRPCPasswordEnabled( const tr_session * session )
    12991405{
     1406    assert( tr_isSession( session ) );
     1407
    13001408    return tr_rpcIsPasswordEnabled( session->rpcServer );
    13011409}
     
    13081416tr_sessionIsProxyEnabled( const tr_session * session )
    13091417{
     1418    assert( tr_isSession( session ) );
     1419
    13101420    return session->isProxyEnabled;
    13111421}
     
    13151425                           tr_bool      isEnabled )
    13161426{
     1427    assert( tr_isSession( session ) );
     1428
    13171429    session->isProxyEnabled = isEnabled != 0;
    13181430}
     
    13211433tr_sessionGetProxyType( const tr_session * session )
    13221434{
     1435    assert( tr_isSession( session ) );
     1436
    13231437    return session->proxyType;
    13241438}
     
    13281442                        tr_proxy_type type )
    13291443{
     1444    assert( tr_isSession( session ) );
     1445
    13301446    session->proxyType = type;
    13311447}
     
    13341450tr_sessionGetProxy( const tr_session * session )
    13351451{
     1452    assert( tr_isSession( session ) );
     1453
    13361454    return session->proxy;
    13371455}
     
    13401458tr_sessionGetProxyPort( const tr_session * session )
    13411459{
     1460    assert( tr_isSession( session ) );
     1461
    13421462    return session->proxyPort;
    13431463}
     
    13471467                    const char * proxy )
    13481468{
     1469    assert( tr_isSession( session ) );
     1470
    13491471    if( proxy != session->proxy )
    13501472    {
     
    13581480                        tr_port      port )
    13591481{
     1482    assert( tr_isSession( session ) );
     1483
    13601484    session->proxyPort = port;
    13611485}
     
    13641488tr_sessionIsProxyAuthEnabled( const tr_session * session )
    13651489{
     1490    assert( tr_isSession( session ) );
     1491
    13661492    return session->isProxyAuthEnabled;
    13671493}
     
    13711497                               tr_bool      isEnabled )
    13721498{
     1499    assert( tr_isSession( session ) );
     1500
    13731501    session->isProxyAuthEnabled = isEnabled != 0;
    13741502}
     
    13771505tr_sessionGetProxyUsername( const tr_session * session )
    13781506{
     1507    assert( tr_isSession( session ) );
     1508
    13791509    return session->proxyUsername;
    13801510}
     
    13841514                            const char * username )
    13851515{
     1516    assert( tr_isSession( session ) );
     1517
    13861518    if( username != session->proxyUsername )
    13871519    {
     
    13941526tr_sessionGetProxyPassword( const tr_session * session )
    13951527{
     1528    assert( tr_isSession( session ) );
     1529
    13961530    return session->proxyPassword;
    13971531}
     
    14011535                            const char * password )
    14021536{
     1537    assert( tr_isSession( session ) );
     1538
    14031539    if( password != session->proxyPassword )
    14041540    {
     
    14131549    int ret = 0;
    14141550    tr_torrent * tor = NULL;
     1551
     1552    assert( tr_isSession( session ) );
    14151553
    14161554    while(( tor = tr_torrentNext( session, tor )))
  • branches/1.5x/libtransmission/session.h

    r7722 r7813  
    6565    tr_bool                      isProxyAuthEnabled;
    6666    tr_bool                      isClosed;
     67    tr_bool                      isWaiting;
    6768    tr_bool                      useLazyBitfield;
    6869
    6970    tr_bool                      isSpeedLimited[2];
    7071    int                          speedLimit[2];
     72    int                          magicNumber;
    7173
    7274    tr_encryption_mode           encryptionMode;
     
    147149tr_bool      tr_globalIsLocked( const tr_session * );
    148150
     151enum
     152{
     153    SESSION_MAGIC_NUMBER = 3845
     154};
     155
     156static inline tr_bool tr_isSession( const tr_session * session )
     157{
     158    return ( session != NULL ) && ( session->magicNumber == SESSION_MAGIC_NUMBER );
     159}
     160
    149161#endif
  • branches/1.5x/libtransmission/test-peer-id.c

    r7664 r7813  
    66#include "utils.h"
    77
    8 #define VERBOSE 0
     8#undef VERBOSE
    99
    10 #define check( A ) \
     10#ifdef VERBOSE
     11  #define check( A ) \
    1112    { \
    1213        ++test; \
    1314        if( A ){ \
    14             if( VERBOSE ) \
    15                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    16                          __LINE__ );\
     15            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    1716        } else { \
    18             if( VERBOSE ) \
    19                 fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    20                          __LINE__ );\
     17            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2118            return test; \
    2219        } \
    2320    }
     21#else
     22  #define check( A ) \
     23    { \
     24        ++test; \
     25        if( !( A ) ){ \
     26            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     27            return test; \
     28        } \
     29    }
     30#endif
    2431
    2532int
  • branches/1.5x/libtransmission/torrent.c

    r7776 r7813  
    447447    tor->session   = session;
    448448    tor->uniqueId = nextUniqueId++;
     449    tor->magicNumber = TORRENT_MAGIC_NUMBER;
    449450
    450451    randomizeTiers( info );
     
    634635                          const char * path )
    635636{
     637    assert( tr_isTorrent( tor  ) );
     638
    636639    if( !path || !tor->downloadDir || strcmp( path, tor->downloadDir ) )
    637640    {
     
    645648tr_torrentGetDownloadDir( const tr_torrent * tor )
    646649{
     650    assert( tr_isTorrent( tor  ) );
     651
    647652    return tor->downloadDir;
    648653}
     
    651656tr_torrentChangeMyPort( tr_torrent * tor )
    652657{
     658    assert( tr_isTorrent( tor  ) );
     659
    653660    if( tor->tracker )
    654661        tr_trackerChangeMyPort( tor->tracker );
     
    660667    tr_torrent * tor = vtor;
    661668
     669    assert( tr_isTorrent( tor  ) );
     670
    662671    if( tor->isRunning )
    663672        tr_trackerReannounce( tor->tracker );
     
    667676tr_torrentManualUpdate( tr_torrent * tor )
    668677{
     678    assert( tr_isTorrent( tor  ) );
     679
    669680    tr_runInEventThread( tor->session, tr_torrentManualUpdateImpl, tor );
    670681}
     
    673684tr_torrentCanManualUpdate( const tr_torrent * tor )
    674685{
    675     return ( tor )
    676            && ( tor->isRunning )
    677            && ( tr_trackerCanManualAnnounce( tor->tracker ) );
     686    return ( tr_isTorrent( tor  ) )
     687        && ( tor->isRunning )
     688        && ( tr_trackerCanManualAnnounce( tor->tracker ) );
    678689}
    679690
     
    681692tr_torrentInfo( const tr_torrent * tor )
    682693{
    683     return tor ? &tor->info : NULL;
     694    return tr_isTorrent( tor ) ? &tor->info : NULL;
    684695}
    685696
     
    689700    const time_t now = time( NULL );
    690701
    691     return tor && ( now == tor->lastStatTime ) ? &tor->stats
    692            : tr_torrentStat( tor );
     702    return tr_isTorrent( tor ) && ( now == tor->lastStatTime )
     703         ? &tor->stats
     704         : tr_torrentStat( tor );
    693705}
    694706
     
    696708tr_torrentGetActivity( tr_torrent * tor )
    697709{
     710    assert( tr_isTorrent( tor ) );
     711
    698712    tr_torrentRecheckCompleteness( tor );
    699713
     
    722736        return NULL;
    723737
     738    assert( tr_isTorrent( tor ) );
    724739    tr_torrentLock( tor );
    725740
     
    845860    uint64_t               haveBytes = 0;
    846861
    847     assert( tor );
     862    assert( tr_isTorrent( tor ) );
    848863    assert( fileIndex < tor->info.fileCount );
    849864    assert( file->offset + file->length <= tor->info.totalSize );
     
    888903    tr_file_stat *        walk = files;
    889904
     905    assert( tr_isTorrent( tor ) );
     906
    890907    for( i = 0; i < n; ++i, ++walk )
    891908    {
     
    915932tr_torrentWebSpeeds( const tr_torrent * tor )
    916933{
    917     return tor ? tr_peerMgrWebSpeeds( tor ) : NULL;
     934    return tr_isTorrent( tor )
     935         ? tr_peerMgrWebSpeeds( tor )
     936         : NULL;
    918937}
    919938
     
    924943    tr_peer_stat * ret = NULL;
    925944
    926     if( tor )
     945    if( tr_isTorrent( tor ) )
    927946        ret = tr_peerMgrPeerStats( tor, peerCount );
    928947
     
    950969                          int                size )
    951970{
     971    assert( tr_isTorrent( tor ) );
     972
    952973    tr_torrentLock( tor );
    953974    tr_cpGetAmountDone( &tor->completion, tab, size );
     
    958979tr_torrentResetTransferStats( tr_torrent * tor )
    959980{
     981    assert( tr_isTorrent( tor ) );
     982
    960983    tr_torrentLock( tor );
    961984
     
    975998                       tr_bool          has )
    976999{
     1000    assert( tr_isTorrent( tor ) );
     1001    assert( pieceIndex < tor->info.pieceCount );
     1002
    9771003    tr_torrentLock( tor );
    978 
    979     assert( tor );
    980     assert( pieceIndex < tor->info.pieceCount );
    9811004
    9821005    if( has )
     
    9991022    tr_info *    inf = &tor->info;
    10001023
    1001     assert( tor );
     1024    assert( tr_isTorrent( tor ) );
    10021025    assert( !tor->isRunning );
    10031026
     
    10471070{
    10481071    tr_torrent * tor = vtor;
     1072
     1073    assert( tr_isTorrent( tor ) );
    10491074
    10501075    tr_globalLock( tor->session );
     
    10651090checkAndStartCB( tr_torrent * tor )
    10661091{
     1092    assert( tr_isTorrent( tor ) );
     1093    assert( tr_isSession( tor->session ) );
     1094
    10671095    tr_runInEventThread( tor->session, checkAndStartImpl, tor );
    10681096}
     
    10721100              int          reloadProgress )
    10731101{
     1102    assert( tr_isTorrent( tor ) );
     1103
    10741104    tr_globalLock( tor->session );
    10751105
     
    10931123tr_torrentStart( tr_torrent * tor )
    10941124{
    1095     if( tor )
     1125    if( tr_isTorrent( tor ) )
    10961126        torrentStart( tor, TRUE );
    10971127}
     
    11001130torrentRecheckDoneImpl( void * vtor )
    11011131{
    1102     tr_torrentRecheckCompleteness( vtor );
     1132    tr_torrent * tor = vtor;
     1133
     1134    assert( tr_isTorrent( tor ) );
     1135    tr_torrentRecheckCompleteness( tor );
    11031136}
    11041137
     
    11061139torrentRecheckDoneCB( tr_torrent * tor )
    11071140{
     1141    assert( tr_isTorrent( tor ) );
     1142
    11081143    tr_runInEventThread( tor->session, torrentRecheckDoneImpl, tor );
    11091144}
     
    11121147tr_torrentVerify( tr_torrent * tor )
    11131148{
     1149    assert( tr_isTorrent( tor ) );
     1150
    11141151    tr_verifyRemove( tor );
    11151152
     
    11271164    tr_file_index_t i;
    11281165    struct evbuffer * buf = evbuffer_new( );
     1166
     1167    assert( tr_isTorrent( tor ) );
    11291168
    11301169    for( i=0; i<tor->info.fileCount; ++i )
     
    11451184    tr_torrent * tor = vtor;
    11461185
     1186    assert( tr_isTorrent( tor ) );
     1187
    11471188    tr_verifyRemove( tor );
    11481189    tr_peerMgrStopTorrent( tor );
     
    11551196tr_torrentStop( tr_torrent * tor )
    11561197{
    1157     if( tor )
     1198    if( tr_isTorrent( tor ) )
    11581199    {
    11591200        tr_globalLock( tor->session );
     
    11731214    tr_torrent * tor = vtor;
    11741215
     1216    assert( tr_isTorrent( tor ) );
     1217
    11751218    tr_torrentSaveResume( tor );
    11761219    tor->isRunning = 0;
     
    11871230tr_torrentFree( tr_torrent * tor )
    11881231{
    1189     if( tor )
     1232    if( tr_isTorrent( tor ) )
    11901233    {
    11911234        tr_session * session = tor->session;
     1235        assert( tr_isSession( session ) );
    11921236        tr_globalLock( session );
    11931237
     
    12021246tr_torrentRemove( tr_torrent * tor )
    12031247{
     1248    assert( tr_isTorrent( tor ) );
     1249
    12041250    tor->isDeleting = 1;
    12051251    tr_torrentFree( tor );
     
    12351281                        tr_completeness    status )
    12361282{
    1237     assert( tor );
     1283    assert( tr_isTorrent( tor ) );
    12381284    assert( ( status == TR_LEECH )
    12391285         || ( status == TR_SEED )
     
    12491295                                   void                          * user_data )
    12501296{
    1251     assert( tor );
     1297    assert( tr_isTorrent( tor ) );
     1298
    12521299    tor->completeness_func = func;
    12531300    tor->completeness_func_user_data = user_data;
     
    12641311{
    12651312    tr_completeness completeness;
     1313
     1314    assert( tr_isTorrent( tor ) );
    12661315
    12671316    tr_torrentLock( tor );
     
    13091358    tr_file *        file;
    13101359
    1311     assert( tor );
     1360    assert( tr_isTorrent( tor ) );
    13121361    assert( fileIndex < tor->info.fileCount );
    1313     assert(
    1314         priority == TR_PRI_LOW || priority == TR_PRI_NORMAL || priority ==
    1315         TR_PRI_HIGH );
     1362    assert( priority == TR_PRI_LOW || priority == TR_PRI_NORMAL || priority == TR_PRI_HIGH );
    13161363
    13171364    file = &tor->info.files[fileIndex];
     
    13301377    tr_file_index_t i;
    13311378
     1379    assert( tr_isTorrent( tor ) );
     1380
    13321381    tr_torrentLock( tor );
    13331382
     
    13441393{
    13451394    tr_priority_t ret;
     1395
     1396    assert( tr_isTorrent( tor ) );
    13461397
    13471398    tr_torrentLock( tor );
     
    13601411    tr_priority_t * p;
    13611412
     1413    assert( tr_isTorrent( tor ) );
     1414
    13621415    tr_torrentLock( tor );
    13631416    p = tr_new0( tr_priority_t, tor->info.fileCount );
     
    13791432    int doDownload;
    13801433
     1434    assert( tr_isTorrent( tor ) );
     1435
    13811436    tr_torrentLock( tor );
    13821437
     
    13981453    tr_piece_index_t lastPiece, lastPieceDND;
    13991454    tr_file_index_t  i;
     1455
     1456    assert( tr_isTorrent( tor ) );
    14001457
    14011458    file = &tor->info.files[fileIndex];
     
    14511508    tr_file_index_t i;
    14521509
     1510    assert( tr_isTorrent( tor ) );
     1511
    14531512    tr_torrentLock( tor );
    14541513
     
    14661525                      tr_bool           doDownload )
    14671526{
     1527    assert( tr_isTorrent( tor ) );
     1528
    14681529    tr_torrentLock( tor );
    14691530    tr_torrentInitFileDLs( tor, files, fileCount, doDownload );
     
    14801541                        uint16_t     maxConnectedPeers )
    14811542{
     1543    assert( tr_isTorrent( tor ) );
     1544
    14821545    tor->maxConnectedPeers = maxConnectedPeers;
    14831546}
     
    14861549tr_torrentGetPeerLimit( const tr_torrent * tor )
    14871550{
     1551    assert( tr_isTorrent( tor ) );
     1552
    14881553    return tor->maxConnectedPeers;
    14891554}
     
    14981563           uint32_t           offset )
    14991564{
    1500     const tr_info *  inf = &tor->info;
    15011565    tr_block_index_t ret;
    15021566
     1567    assert( tr_isTorrent( tor ) );
     1568
    15031569    ret = index;
    1504     ret *= ( inf->pieceSize / tor->blockSize );
     1570    ret *= ( tor->info.pieceSize / tor->blockSize );
    15051571    ret += offset / tor->blockSize;
    15061572    return ret;
     
    15141580{
    15151581    int err = 0;
     1582
     1583    assert( tr_isTorrent( tor ) );
    15161584
    15171585    if( index >= tor->info.pieceCount )
     
    15421610    uint64_t ret;
    15431611
     1612    assert( tr_isTorrent( tor ) );
     1613
    15441614    ret = tor->info.pieceSize;
    15451615    ret *= index;
     
    15581628                           tr_bool             isChecked )
    15591629{
     1630    assert( tr_isTorrent( tor ) );
     1631
    15601632    if( isChecked )
    15611633        tr_bitfieldAdd( &tor->checkedPieces, piece );
     
    15721644    const tr_piece_index_t begin = file->firstPiece;
    15731645    const tr_piece_index_t end = file->lastPiece + 1;
     1646
     1647    assert( tr_isTorrent( tor ) );
    15741648
    15751649    if( isChecked )
     
    15891663    tr_bool                isChecked = TRUE;
    15901664
     1665    assert( tr_isTorrent( tor ) );
     1666
    15911667    for( i = begin; isChecked && i < end; ++i )
    15921668        if( !tr_torrentIsPieceChecked( tor, i ) )
     
    15991675tr_torrentUncheck( tr_torrent * tor )
    16001676{
     1677    assert( tr_isTorrent( tor ) );
     1678
    16011679    tr_bitfieldRemRange ( &tor->checkedPieces, 0, tor->info.pieceCount );
    16021680}
     
    16051683tr_torrentCountUncheckedPieces( const tr_torrent * tor )
    16061684{
     1685    assert( tr_isTorrent( tor ) );
     1686
    16071687    return tor->info.pieceCount - tr_bitfieldCountTrueBits( &tor->checkedPieces );
    16081688}
     
    16151695    const size_t n = tor->info.fileCount;
    16161696    time_t *     m = tr_new0( time_t, n );
     1697
     1698    assert( tr_isTorrent( tor ) );
    16171699
    16181700    for( i = 0; i < n; ++i )
     
    16461728    tr_benc metainfo;
    16471729
     1730    assert( tr_isTorrent( tor ) );
     1731
    16481732    /* save to the .torrent file */
    16491733    if( !tr_bencLoadFile( tor->info.torrent, &metainfo ) )
     
    17021786                        time_t       t )
    17031787{
     1788    assert( tr_isTorrent( tor ) );
     1789
    17041790    tor->addedDate = t;
    17051791}
     
    17101796                           time_t       t )
    17111797{
     1798    assert( tr_isTorrent( tor ) );
     1799
    17121800    tor->activityDate = t;
    17131801}
     
    17181806                       time_t       t )
    17191807{
     1808    assert( tr_isTorrent( tor ) );
     1809
    17201810    tor->doneDate = t;
    17211811}
     
    17321822    struct stat sb;
    17331823    uint64_t bytesLeft = 0;
     1824
     1825    assert( tr_isTorrent( tor ) );
    17341826
    17351827    for( it=tor->info.files, end=it+tor->info.fileCount; it!=end; ++it )
     
    18101902    struct stat sb;
    18111903    char * buf;
     1904
     1905    assert( tr_isTorrent( tor ) );
    18121906
    18131907    buf = tr_buildPath( dir, base, NULL );
     
    18531947    char * root = tr_buildPath( tor->downloadDir, tmp, NULL );
    18541948
     1949    assert( tr_isTorrent( tor ) );
     1950
    18551951    for( f=0; f<tor->info.fileCount; ++f )
    18561952        tr_ptrArrayInsertSorted( &torrentFiles, tor->info.files[f].name, vstrcmp );
     
    18981994tr_torrentDeleteLocalData( tr_torrent * tor, tr_fileFunc fileFunc )
    18991995{
     1996    assert( tr_isTorrent( tor ) );
     1997
    19001998    if( fileFunc == NULL )
    19011999        fileFunc = remove;
  • branches/1.5x/libtransmission/torrent.h

    r7722 r7813  
    134134    struct tr_ratecontrol    swarmSpeed;
    135135
     136    int                      magicNumber;
     137
    136138    int                      error;
    137139    char                     errorString[128];
     
    278280}
    279281
     282/***
     283****
     284***/
     285
     286enum
     287{
     288    TORRENT_MAGIC_NUMBER = 95549
     289};
     290
     291static inline tr_bool tr_isTorrent( const tr_torrent * tor )
     292{
     293    return ( tor != NULL )
     294        && ( tor->magicNumber == TORRENT_MAGIC_NUMBER )
     295        && ( tr_isSession( tor->session ) );
     296}
     297
    280298#endif
  • branches/1.5x/libtransmission/tr-getopt.c

    r7664 r7813  
    88 * the Transmission project.
    99 *
    10  * $Id: tr-getopt.c 7658 2009-01-10 23:09:07Z charles $
     10 * $Id: tr-getopt.c 7783 2009-01-23 18:44:15Z charles $
    1111 */
    1212
     
    2626getArgName( const tr_option * opt )
    2727{
    28     char * arg;
     28    const char * arg;
    2929
    3030    if( !opt->has_arg )
  • branches/1.5x/libtransmission/tr-getopt.h

    r7664 r7813  
    3131{
    3232    int     val;          /* the value to return from tr_getopt() */
    33     char *  longName;     /* --long-form */
    34     char *  description;  /* option's description for tr_getopt_usage() */
    35     char *  shortName;    /* short form */
     33    const char *  longName;     /* --long-form */
     34    const char *  description;  /* option's description for tr_getopt_usage() */
     35    const char *  shortName;    /* short form */
    3636    int     has_arg;      /* 0 for no argument, 1 for argument */
    37     char *  argName;      /* argument's description for tr_getopt_usage() */
     37    const char *  argName;      /* argument's description for tr_getopt_usage() */
    3838}
    3939tr_option;
  • branches/1.5x/libtransmission/trevent.c

    r7664 r7813  
    233233{
    234234    tr_event_handle * eh = veh;
    235 
    236235    tr_dbg( "Starting libevent thread" );
    237236
     
    241240#endif
    242241
     242    eh->base = event_init( );
    243243    eh->session->events = eh;
    244244
    245245    /* listen to the pipe's read fd */
    246     event_set( &eh->pipeEvent, eh->fds[0], EV_READ | EV_PERSIST,
    247                readFromPipe,
    248                veh );
     246    event_set( &eh->pipeEvent, eh->fds[0], EV_READ | EV_PERSIST, readFromPipe, veh );
    249247    event_add( &eh->pipeEvent, NULL );
    250248    event_set_log_callback( logFunc );
     249
     250    /* loop until all the events are done */
    251251    event_dispatch( );
    252252
     253    /* shut down the thread */
    253254    tr_lockFree( eh->lock );
    254255    event_base_free( eh->base );
     
    263264    tr_event_handle * eh;
    264265
     266    session->events = NULL;
     267
    265268    eh = tr_new0( tr_event_handle, 1 );
    266269    eh->lock = tr_lockNew( );
    267270    pipe( eh->fds );
    268271    eh->session = session;
    269     eh->base = event_init( );
    270272    eh->thread = tr_threadNew( libeventThreadFunc, eh );
     273
     274    /* wait until the libevent thread is running */
     275    while( session->events == NULL )
     276        tr_wait( 100 );
    271277}
    272278
     
    274280tr_eventClose( tr_session * session )
    275281{
     282    assert( tr_isSession( session ) );
     283
    276284    session->events->die = TRUE;
    277285    tr_deepLog( __FILE__, __LINE__, NULL, "closing trevent pipe" );
     
    286294tr_amInEventThread( tr_session * session )
    287295{
    288     assert( session );
     296    assert( tr_isSession( session ) );
    289297    assert( session->events );
    290298
     
    341349    tr_timer * timer;
    342350
    343     assert( session );
    344     assert( session->events );
     351    assert( tr_isSession( session ) );
     352    assert( session->events != NULL );
    345353
    346354    timer = tr_new0( tr_timer, 1 );
     
    374382                     void func( void* ), void * user_data )
    375383{
    376     assert( session );
    377     assert( session->events );
     384    assert( tr_isSession( session ) );
     385    assert( session->events != NULL );
    378386
    379387    if( tr_amInThread( session->events->thread ) )
     
    400408tr_eventGetBase( tr_session * session )
    401409{
     410    assert( tr_isSession( session ) );
     411
    402412    return session->events->base;
    403413}
  • branches/1.5x/libtransmission/utils-test.c

    r7767 r7813  
    77#include "crypto.h"
    88
    9 #define VERBOSE 0
     9#undef VERBOSE
    1010#define NUM_LOOPS 1
    1111#define SPEED_TEST 0
    1212
    1313#if SPEED_TEST
    14  #undef VERBOSE
    15  #define VERBOSE 0
     14 #define VERBOSE
    1615 #undef NUM_LOOPS
    1716 #define NUM_LOOPS 200
     
    2019static int test = 0;
    2120
    22 #define check( A ) \
     21#ifdef VERBOSE
     22  #define check( A ) \
    2323    { \
    2424        ++test; \
    2525        if( A ){ \
    26             if( VERBOSE ) \
    27                 fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__,\
    28                          __LINE__ );\
     26            fprintf( stderr, "PASS test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    2927        } else { \
    30             fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__,\
    31                      __LINE__ ); \
     28            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
    3229            return test; \
    3330        } \
    3431    }
     32#else
     33  #define check( A ) \
     34    { \
     35        ++test; \
     36        if( !( A ) ){ \
     37            fprintf( stderr, "FAIL test #%d (%s, %d)\n", test, __FILE__, __LINE__ ); \
     38            return test; \
     39        } \
     40    }
     41#endif
    3542
    3643static int
     
    188195
    189196    /* base64 */
    190     in = "YOYO!";
    191     out = tr_base64_encode( in, -1, &len );
     197    out = tr_base64_encode( "YOYO!", -1, &len );
    192198    check( out );
    193199    check( !strcmp( out, "WU9ZTyE=\n" ) );
  • branches/1.5x/libtransmission/utils.c

    r7767 r7813  
    3737#include "utils.h"
    3838#include "platform.h"
     39#include "version.h"
    3940
    4041static tr_lock *      messageLock = NULL;
     
    192193
    193194char*
    194 tr_getLogTimeStr( char * buf,
    195                   int    buflen )
     195tr_getLogTimeStr( char * buf, int buflen )
    196196{
    197197    char           tmp[64];
     
    211211    return buf;
    212212}
     213
     214void
     215tr_assertImpl( const char * file, int line, const char * test, const char * fmt, ... )
     216{
     217    char buf[64];
     218    fprintf( stderr, "[%s] Transmission %s Assertion \"%s\" failed at %s:%d.  ",
     219                     tr_getLogTimeStr( buf, sizeof( buf ) ),
     220                      LONG_VERSION_STRING, test, file, line );
     221    if( fmt && *fmt ) {
     222        va_list args;
     223        fputc( '(', stderr );
     224        va_start( args, fmt );
     225        vfprintf( stderr, fmt, args );
     226        va_end( args );
     227        fputs( ")  ", stderr );
     228    }
     229    fputs( "Please report this bug at <http://trac.transmissionbt.com/newticket>; Thank you.\n", stderr );
     230    abort( );
     231}
     232
    213233
    214234tr_bool
  • branches/1.5x/libtransmission/utils.h

    r7767 r7813  
    104104****/
    105105
     106void tr_assertImpl( const char * file, int line, const char * test, const char * fmt, ... ) TR_GNUC_PRINTF( 4, 5 );
     107
     108#ifdef NDEBUG
     109 #define tr_assert( test, fmt, ... )
     110#else
     111 #define tr_assert( test, fmt, ... ) \
     112    do { if( ! ( test ) ) tr_assertImpl( __FILE__, __LINE__, #test, fmt, __VA_ARGS__ ); } while( 0 )
     113#endif
     114       
    106115int            tr_msgLoggingIsActive( int level );
    107116
  • branches/1.5x/libtransmission/verify.c

    r7664 r7813  
    3535
    3636static void
    37 fireCheckDone( tr_torrent *      torrent,
    38                tr_verify_done_cb verify_done_cb )
    39 {
     37fireCheckDone( tr_torrent * tor, tr_verify_done_cb verify_done_cb )
     38{
     39    assert( tr_isTorrent( tor ) );
     40
    4041    if( verify_done_cb )
    41         verify_done_cb( torrent );
     42        verify_done_cb( tor );
    4243}
    4344
    4445static struct verify_node currentNode;
    45 
    46 static tr_list *          verifyList = NULL;
    47 
    48 static tr_thread *        verifyThread = NULL;
    49 
    50 static int                stopCurrent = FALSE;
     46static tr_list * verifyList = NULL;
     47static tr_thread * verifyThread = NULL;
     48static int stopCurrent = FALSE;
    5149
    5250static tr_lock*
     
    145143
    146144        tr_torinf( tor, _( "Verifying torrent" ) );
     145        assert( tr_isTorrent( tor ) );
    147146        tor->verifyState = TR_VERIFY_NOW;
    148147        buffer = tr_new( uint8_t, tor->info.pieceSize );
     
    151150        tr_free( buffer );
    152151        tor->verifyState = TR_VERIFY_NONE;
     152        assert( tr_isTorrent( tor ) );
    153153
    154154        if( !stopCurrent )
     
    169169{
    170170    const int uncheckedCount = tr_torrentCountUncheckedPieces( tor );
     171
     172    assert( tr_isTorrent( tor ) );
    171173
    172174    if( !uncheckedCount )
     
    211213    tr_lockLock( lock );
    212214
     215    assert( tr_isTorrent( tor ) );
     216
    213217    found = ( tor == currentNode.torrent )
    214218         || ( tr_list_find( verifyList, tor, compareVerifyByTorrent ) != NULL );
     
    222226{
    223227    tr_lock * lock = getVerifyLock( );
    224 
    225228    tr_lockLock( lock );
     229
     230    assert( tr_isTorrent( tor ) );
    226231
    227232    if( tor == currentNode.torrent )
  • branches/1.5x/libtransmission/web.c

    r7741 r7813  
    1515
    1616#include <event.h>
     17
     18#define CURL_DISABLE_TYPECHECK /* otherwise -Wunreachable-code goes insane */
    1719#include <curl/curl.h>
    1820
     
    245247{
    246248    struct timeval interval;
     249
     250    assert( tr_amInEventThread( g->session ) );
     251    assert( g->session != NULL );
     252    assert( g->session->events != NULL );
     253
    247254    stop_timer( g );
    248255    dbgmsg( "adding a timeout for %ld seconds from now", g->timer_ms/1000L );
     
    356363                   | (( action & CURL_POLL_IN ) ? EV_READ : 0 )
    357364                   | (( action & CURL_POLL_OUT ) ? EV_WRITE : 0 );
     365
     366    assert( tr_amInEventThread( g->session ) );
     367    assert( g->session != NULL );
     368    assert( g->session->events != NULL );
     369
    358370    dbgmsg( "setsock: fd is %d, curl action is %d, libevent action is %d",
    359371            sockfd, action, kind );
Note: See TracChangeset for help on using the changeset viewer.