Ignore:
Timestamp:
Dec 5, 2012, 5:29:46 PM (9 years ago)
Author:
jordan
Message:

Follow more common whitespace style conventions in the C code (libtransmission, daemon, utils, cli, gtk).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/peer-mgr.c

    r13549 r13625  
    33 *
    44 * This file is licensed by the GPL version 2. Works owned by the
    5  * Transmission project are granted a special exemption to clause 2(b)
     5 * Transmission project are granted a special exemption to clause 2 (b)
    66 * so that the bulk of its code can remain under the MIT license.
    77 * This exemption does not extend to derived works not owned by
     
    4545{
    4646    /* how frequently to cull old atoms */
    47     ATOM_PERIOD_MSEC = ( 60 * 1000 ),
     47    ATOM_PERIOD_MSEC = (60 * 1000),
    4848
    4949    /* how frequently to change which peers are choked */
    50     RECHOKE_PERIOD_MSEC = ( 10 * 1000 ),
     50    RECHOKE_PERIOD_MSEC = (10 * 1000),
    5151
    5252    /* an optimistically unchoked peer is immune from rechoking
    53        for this many calls to rechokeUploads(). */
     53       for this many calls to rechokeUploads (). */
    5454    OPTIMISTIC_UNCHOKE_MULTIPLIER = 4,
    5555
     
    5858
    5959    /* how frequently to age out old piece request lists */
    60     REFILL_UPKEEP_PERIOD_MSEC = ( 10 * 1000 ),
     60    REFILL_UPKEEP_PERIOD_MSEC = (10 * 1000),
    6161
    6262    /* how frequently to decide which peers live and die */
     
    6464
    6565    /* when many peers are available, keep idle ones this long */
    66     MIN_UPLOAD_IDLE_SECS = ( 60 ),
     66    MIN_UPLOAD_IDLE_SECS = (60),
    6767
    6868    /* when few peers are available, keep idle ones this long */
    69     MAX_UPLOAD_IDLE_SECS = ( 60 * 5 ),
     69    MAX_UPLOAD_IDLE_SECS = (60 * 5),
    7070
    7171    /* max number of peers to ask for per second overall.
     
    145145#else
    146146static bool
    147 tr_isAtom( const struct peer_atom * atom )
    148 {
    149     return ( atom != NULL )
    150         && ( atom->fromFirst < TR_PEER_FROM__MAX )
    151         && ( atom->fromBest < TR_PEER_FROM__MAX )
    152         && ( tr_address_is_valid( &atom->addr ) );
     147tr_isAtom (const struct peer_atom * atom)
     148{
     149    return (atom != NULL)
     150        && (atom->fromFirst < TR_PEER_FROM__MAX)
     151        && (atom->fromBest < TR_PEER_FROM__MAX)
     152        && (tr_address_is_valid (&atom->addr));
    153153}
    154154#endif
    155155
    156156static const char*
    157 tr_atomAddrStr( const struct peer_atom * atom )
    158 {
    159     return atom ? tr_peerIoAddrStr( &atom->addr, atom->port ) : "[no atom]";
     157tr_atomAddrStr (const struct peer_atom * atom)
     158{
     159    return atom ? tr_peerIoAddrStr (&atom->addr, atom->port) : "[no atom]";
    160160}
    161161
     
    235235};
    236236
    237 #define tordbg( t, ... ) \
    238     do { \
    239         if( tr_deepLoggingIsActive( ) ) \
    240             tr_deepLog( __FILE__, __LINE__, tr_torrentName( t->tor ), __VA_ARGS__ ); \
    241     } while( 0 )
    242 
    243 #define dbgmsg( ... ) \
    244     do { \
    245         if( tr_deepLoggingIsActive( ) ) \
    246             tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
    247     } while( 0 )
     237#define tordbg(t, ...) \
     238  do \
     239    { \
     240      if (tr_deepLoggingIsActive ()) \
     241        tr_deepLog (__FILE__, __LINE__, tr_torrentName (t->tor), __VA_ARGS__); \
     242    } \
     243  while (0)
     244
     245#define dbgmsg(...) \
     246  do \
     247    { \
     248      if (tr_deepLoggingIsActive ()) \
     249        tr_deepLog (__FILE__, __LINE__, NULL, __VA_ARGS__); \
     250    } \
     251  while (0)
    248252
    249253/**
     
    252256
    253257static inline void
    254 managerLock( const struct tr_peerMgr * manager )
    255 {
    256     tr_sessionLock( manager->session );
     258managerLock (const struct tr_peerMgr * manager)
     259{
     260    tr_sessionLock (manager->session);
    257261}
    258262
    259263static inline void
    260 managerUnlock( const struct tr_peerMgr * manager )
    261 {
    262     tr_sessionUnlock( manager->session );
     264managerUnlock (const struct tr_peerMgr * manager)
     265{
     266    tr_sessionUnlock (manager->session);
    263267}
    264268
    265269static inline void
    266 torrentLock( Torrent * torrent )
    267 {
    268     managerLock( torrent->manager );
     270torrentLock (Torrent * torrent)
     271{
     272    managerLock (torrent->manager);
    269273}
    270274
    271275static inline void
    272 torrentUnlock( Torrent * torrent )
    273 {
    274     managerUnlock( torrent->manager );
     276torrentUnlock (Torrent * torrent)
     277{
     278    managerUnlock (torrent->manager);
    275279}
    276280
    277281static inline int
    278 torrentIsLocked( const Torrent * t )
    279 {
    280     return tr_sessionIsLocked( t->manager->session );
     282torrentIsLocked (const Torrent * t)
     283{
     284    return tr_sessionIsLocked (t->manager->session);
    281285}
    282286
     
    286290
    287291static int
    288 handshakeCompareToAddr( const void * va, const void * vb )
     292handshakeCompareToAddr (const void * va, const void * vb)
    289293{
    290294    const tr_handshake * a = va;
    291295
    292     return tr_address_compare( tr_handshakeGetAddr( a, NULL ), vb );
     296    return tr_address_compare (tr_handshakeGetAddr (a, NULL), vb);
    293297}
    294298
    295299static int
    296 handshakeCompare( const void * a, const void * b )
    297 {
    298     return handshakeCompareToAddr( a, tr_handshakeGetAddr( b, NULL ) );
     300handshakeCompare (const void * a, const void * b)
     301{
     302    return handshakeCompareToAddr (a, tr_handshakeGetAddr (b, NULL));
    299303}
    300304
    301305static inline tr_handshake*
    302 getExistingHandshake( tr_ptrArray * handshakes, const tr_address * addr )
    303 {
    304     if( tr_ptrArrayEmpty( handshakes ) )
     306getExistingHandshake (tr_ptrArray * handshakes, const tr_address * addr)
     307{
     308    if (tr_ptrArrayEmpty (handshakes))
    305309        return NULL;
    306310
    307     return tr_ptrArrayFindSorted( handshakes, addr, handshakeCompareToAddr );
     311    return tr_ptrArrayFindSorted (handshakes, addr, handshakeCompareToAddr);
    308312}
    309313
    310314static int
    311 comparePeerAtomToAddress( const void * va, const void * vb )
     315comparePeerAtomToAddress (const void * va, const void * vb)
    312316{
    313317    const struct peer_atom * a = va;
    314318
    315     return tr_address_compare( &a->addr, vb );
     319    return tr_address_compare (&a->addr, vb);
    316320}
    317321
    318322static int
    319 compareAtomsByAddress( const void * va, const void * vb )
     323compareAtomsByAddress (const void * va, const void * vb)
    320324{
    321325    const struct peer_atom * b = vb;
    322326
    323     assert( tr_isAtom( b ) );
    324 
    325     return comparePeerAtomToAddress( va, &b->addr );
     327    assert (tr_isAtom (b));
     328
     329    return comparePeerAtomToAddress (va, &b->addr);
    326330}
    327331
     
    331335
    332336const tr_address *
    333 tr_peerAddress( const tr_peer * peer )
     337tr_peerAddress (const tr_peer * peer)
    334338{
    335339    return &peer->atom->addr;
     
    337341
    338342static Torrent*
    339 getExistingTorrent( tr_peerMgr *    manager,
    340                     const uint8_t * hash )
    341 {
    342     tr_torrent * tor = tr_torrentFindFromHash( manager->session, hash );
     343getExistingTorrent (tr_peerMgr *    manager,
     344                    const uint8_t * hash)
     345{
     346    tr_torrent * tor = tr_torrentFindFromHash (manager->session, hash);
    343347
    344348    return tor == NULL ? NULL : tor->torrentPeers;
     
    346350
    347351static int
    348 peerCompare( const void * a, const void * b )
    349 {
    350     return tr_address_compare( tr_peerAddress( a ), tr_peerAddress( b ) );
     352peerCompare (const void * a, const void * b)
     353{
     354    return tr_address_compare (tr_peerAddress (a), tr_peerAddress (b));
    351355}
    352356
    353357static struct peer_atom*
    354 getExistingAtom( const Torrent    * t,
    355                  const tr_address * addr )
     358getExistingAtom (const Torrent    * t,
     359                 const tr_address * addr)
    356360{
    357361    Torrent * tt = (Torrent*)t;
    358     assert( torrentIsLocked( t ) );
    359     return tr_ptrArrayFindSorted( &tt->pool, addr, comparePeerAtomToAddress );
     362    assert (torrentIsLocked (t));
     363    return tr_ptrArrayFindSorted (&tt->pool, addr, comparePeerAtomToAddress);
    360364}
    361365
    362366static bool
    363 peerIsInUse( const Torrent * ct, const struct peer_atom * atom )
     367peerIsInUse (const Torrent * ct, const struct peer_atom * atom)
    364368{
    365369    Torrent * t = (Torrent*) ct;
    366370
    367     assert( torrentIsLocked ( t ) );
    368 
    369     return ( atom->peer != NULL )
    370         || getExistingHandshake( &t->outgoingHandshakes, &atom->addr )
    371         || getExistingHandshake( &t->manager->incomingHandshakes, &atom->addr );
     371    assert (torrentIsLocked (t));
     372
     373    return (atom->peer != NULL)
     374        || getExistingHandshake (&t->outgoingHandshakes, &atom->addr)
     375        || getExistingHandshake (&t->manager->incomingHandshakes, &atom->addr);
    372376}
    373377
    374378void
    375 tr_peerConstruct( tr_peer * peer )
    376 {
    377     memset( peer, 0, sizeof( tr_peer ) );
     379tr_peerConstruct (tr_peer * peer)
     380{
     381    memset (peer, 0, sizeof (tr_peer));
    378382
    379383    peer->have = TR_BITFIELD_INIT;
     
    381385
    382386static tr_peer*
    383 peerNew( struct peer_atom * atom )
    384 {
    385     tr_peer * peer = tr_new( tr_peer, 1 );
    386     tr_peerConstruct( peer );
     387peerNew (struct peer_atom * atom)
     388{
     389    tr_peer * peer = tr_new (tr_peer, 1);
     390    tr_peerConstruct (peer);
    387391
    388392    peer->atom = atom;
     
    393397
    394398static tr_peer*
    395 getPeer( Torrent * torrent, struct peer_atom * atom )
     399getPeer (Torrent * torrent, struct peer_atom * atom)
    396400{
    397401    tr_peer * peer;
    398402
    399     assert( torrentIsLocked( torrent ) );
     403    assert (torrentIsLocked (torrent));
    400404
    401405    peer = atom->peer;
    402406
    403     if( peer == NULL )
    404     {
    405         peer = peerNew( atom );
    406         tr_bitfieldConstruct( &peer->have, torrent->tor->info.pieceCount );
    407         tr_bitfieldConstruct( &peer->blame, torrent->tor->blockCount );
    408         tr_ptrArrayInsertSorted( &torrent->peers, peer, peerCompare );
     407    if (peer == NULL)
     408    {
     409        peer = peerNew (atom);
     410        tr_bitfieldConstruct (&peer->have, torrent->tor->info.pieceCount);
     411        tr_bitfieldConstruct (&peer->blame, torrent->tor->blockCount);
     412        tr_ptrArrayInsertSorted (&torrent->peers, peer, peerCompare);
    409413    }
    410414
     
    412416}
    413417
    414 static void peerDeclinedAllRequests( Torrent *, const tr_peer * );
     418static void peerDeclinedAllRequests (Torrent *, const tr_peer *);
    415419
    416420void
    417 tr_peerDestruct( tr_torrent * tor, tr_peer * peer )
    418 {
    419     assert( peer != NULL );
    420 
    421     peerDeclinedAllRequests( tor->torrentPeers, peer );
    422 
    423     if( peer->msgs != NULL )
    424         tr_peerMsgsFree( peer->msgs );
    425 
    426     if( peer->io ) {
    427         tr_peerIoClear( peer->io );
    428         tr_peerIoUnref( peer->io ); /* balanced by the ref in handshakeDoneCB() */
    429     }
    430 
    431     tr_bitfieldDestruct( &peer->have );
    432     tr_bitfieldDestruct( &peer->blame );
    433     tr_free( peer->client );
    434 
    435     if( peer->atom )
     421tr_peerDestruct (tr_torrent * tor, tr_peer * peer)
     422{
     423    assert (peer != NULL);
     424
     425    peerDeclinedAllRequests (tor->torrentPeers, peer);
     426
     427    if (peer->msgs != NULL)
     428        tr_peerMsgsFree (peer->msgs);
     429
     430    if (peer->io) {
     431        tr_peerIoClear (peer->io);
     432        tr_peerIoUnref (peer->io); /* balanced by the ref in handshakeDoneCB () */
     433    }
     434
     435    tr_bitfieldDestruct (&peer->have);
     436    tr_bitfieldDestruct (&peer->blame);
     437    tr_free (peer->client);
     438
     439    if (peer->atom)
    436440        peer->atom->peer = NULL;
    437441}
    438442
    439443static void
    440 peerDelete( Torrent * t, tr_peer * peer )
    441 {
    442     tr_peerDestruct( t->tor, peer );
    443     tr_free( peer );
     444peerDelete (Torrent * t, tr_peer * peer)
     445{
     446    tr_peerDestruct (t->tor, peer);
     447    tr_free (peer);
    444448}
    445449
    446450static bool
    447 replicationExists( const Torrent * t )
     451replicationExists (const Torrent * t)
    448452{
    449453    return t->pieceReplication != NULL;
     
    451455
    452456static void
    453 replicationFree( Torrent * t )
    454 {
    455     tr_free( t->pieceReplication );
     457replicationFree (Torrent * t)
     458{
     459    tr_free (t->pieceReplication);
    456460    t->pieceReplication = NULL;
    457461    t->pieceReplicationSize = 0;
     
    459463
    460464static void
    461 replicationNew( Torrent * t )
     465replicationNew (Torrent * t)
    462466{
    463467    tr_piece_index_t piece_i;
    464468    const tr_piece_index_t piece_count = t->tor->info.pieceCount;
    465     tr_peer ** peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
    466     const int peer_count = tr_ptrArraySize( &t->peers );
    467 
    468     assert( !replicationExists( t ) );
     469    tr_peer ** peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
     470    const int peer_count = tr_ptrArraySize (&t->peers);
     471
     472    assert (!replicationExists (t));
    469473
    470474    t->pieceReplicationSize = piece_count;
    471     t->pieceReplication = tr_new0( uint16_t, piece_count );
    472 
    473     for( piece_i=0; piece_i<piece_count; ++piece_i )
     475    t->pieceReplication = tr_new0 (uint16_t, piece_count);
     476
     477    for (piece_i=0; piece_i<piece_count; ++piece_i)
    474478    {
    475479        int peer_i;
    476480        uint16_t r = 0;
    477481
    478         for( peer_i=0; peer_i<peer_count; ++peer_i )
    479             if( tr_bitfieldHas( &peers[peer_i]->have, piece_i ) )
     482        for (peer_i=0; peer_i<peer_count; ++peer_i)
     483            if (tr_bitfieldHas (&peers[peer_i]->have, piece_i))
    480484                ++r;
    481485
     
    485489
    486490static void
    487 torrentFree( void * vt )
     491torrentFree (void * vt)
    488492{
    489493    Torrent * t = vt;
    490494
    491     assert( t );
    492     assert( !t->isRunning );
    493     assert( torrentIsLocked( t ) );
    494     assert( tr_ptrArrayEmpty( &t->outgoingHandshakes ) );
    495     assert( tr_ptrArrayEmpty( &t->peers ) );
    496 
    497     tr_ptrArrayDestruct( &t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
    498     tr_ptrArrayDestruct( &t->pool, (PtrArrayForeachFunc)tr_free );
    499     tr_ptrArrayDestruct( &t->outgoingHandshakes, NULL );
    500     tr_ptrArrayDestruct( &t->peers, NULL );
    501 
    502     replicationFree( t );
    503 
    504     tr_free( t->requests );
    505     tr_free( t->pieces );
    506     tr_free( t );
    507 }
    508 
    509 static void peerCallbackFunc( tr_peer *, const tr_peer_event *, void * );
    510 
    511 static void
    512 rebuildWebseedArray( Torrent * t, tr_torrent * tor )
     495    assert (t);
     496    assert (!t->isRunning);
     497    assert (torrentIsLocked (t));
     498    assert (tr_ptrArrayEmpty (&t->outgoingHandshakes));
     499    assert (tr_ptrArrayEmpty (&t->peers));
     500
     501    tr_ptrArrayDestruct (&t->webseeds, (PtrArrayForeachFunc)tr_webseedFree);
     502    tr_ptrArrayDestruct (&t->pool, (PtrArrayForeachFunc)tr_free);
     503    tr_ptrArrayDestruct (&t->outgoingHandshakes, NULL);
     504    tr_ptrArrayDestruct (&t->peers, NULL);
     505
     506    replicationFree (t);
     507
     508    tr_free (t->requests);
     509    tr_free (t->pieces);
     510    tr_free (t);
     511}
     512
     513static void peerCallbackFunc (tr_peer *, const tr_peer_event *, void *);
     514
     515static void
     516rebuildWebseedArray (Torrent * t, tr_torrent * tor)
    513517{
    514518    int i;
     
    516520
    517521    /* clear the array */
    518     tr_ptrArrayDestruct( &t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
     522    tr_ptrArrayDestruct (&t->webseeds, (PtrArrayForeachFunc)tr_webseedFree);
    519523    t->webseeds = TR_PTR_ARRAY_INIT;
    520524
    521525    /* repopulate it */
    522     for( i = 0; i < inf->webseedCount; ++i )
    523     {
    524         tr_webseed * w = tr_webseedNew( tor, inf->webseeds[i], peerCallbackFunc, t );
    525         tr_ptrArrayAppend( &t->webseeds, w );
     526    for (i = 0; i < inf->webseedCount; ++i)
     527    {
     528        tr_webseed * w = tr_webseedNew (tor, inf->webseeds[i], peerCallbackFunc, t);
     529        tr_ptrArrayAppend (&t->webseeds, w);
    526530    }
    527531}
    528532
    529533static Torrent*
    530 torrentNew( tr_peerMgr * manager, tr_torrent * tor )
     534torrentNew (tr_peerMgr * manager, tr_torrent * tor)
    531535{
    532536    Torrent * t;
    533537
    534     t = tr_new0( Torrent, 1 );
     538    t = tr_new0 (Torrent, 1);
    535539    t->manager = manager;
    536540    t->tor = tor;
     
    540544    t->outgoingHandshakes = TR_PTR_ARRAY_INIT;
    541545
    542     rebuildWebseedArray( t, tor );
     546    rebuildWebseedArray (t, tor);
    543547
    544548    return t;
    545549}
    546550
    547 static void ensureMgrTimersExist( struct tr_peerMgr * m );
     551static void ensureMgrTimersExist (struct tr_peerMgr * m);
    548552
    549553tr_peerMgr*
    550 tr_peerMgrNew( tr_session * session )
    551 {
    552     tr_peerMgr * m = tr_new0( tr_peerMgr, 1 );
     554tr_peerMgrNew (tr_session * session)
     555{
     556    tr_peerMgr * m = tr_new0 (tr_peerMgr, 1);
    553557    m->session = session;
    554558    m->incomingHandshakes = TR_PTR_ARRAY_INIT;
    555     ensureMgrTimersExist( m );
     559    ensureMgrTimersExist (m);
    556560    return m;
    557561}
    558562
    559563static void
    560 deleteTimer( struct event ** t )
    561 {
    562     if( *t != NULL )
    563     {
    564         event_free( *t );
     564deleteTimer (struct event ** t)
     565{
     566    if (*t != NULL)
     567    {
     568        event_free (*t);
    565569        *t = NULL;
    566570    }
     
    568572
    569573static void
    570 deleteTimers( struct tr_peerMgr * m )
    571 {
    572     deleteTimer( &m->atomTimer );
    573     deleteTimer( &m->bandwidthTimer );
    574     deleteTimer( &m->rechokeTimer );
    575     deleteTimer( &m->refillUpkeepTimer );
     574deleteTimers (struct tr_peerMgr * m)
     575{
     576    deleteTimer (&m->atomTimer);
     577    deleteTimer (&m->bandwidthTimer);
     578    deleteTimer (&m->rechokeTimer);
     579    deleteTimer (&m->refillUpkeepTimer);
    576580}
    577581
    578582void
    579 tr_peerMgrFree( tr_peerMgr * manager )
    580 {
    581     managerLock( manager );
    582 
    583     deleteTimers( manager );
    584 
    585     /* free the handshakes. Abort invokes handshakeDoneCB(), which removes
     583tr_peerMgrFree (tr_peerMgr * manager)
     584{
     585    managerLock (manager);
     586
     587    deleteTimers (manager);
     588
     589    /* free the handshakes. Abort invokes handshakeDoneCB (), which removes
    586590     * the item from manager->handshakes, so this is a little roundabout... */
    587     while( !tr_ptrArrayEmpty( &manager->incomingHandshakes ) )
    588         tr_handshakeAbort( tr_ptrArrayNth( &manager->incomingHandshakes, 0 ) );
    589 
    590     tr_ptrArrayDestruct( &manager->incomingHandshakes, NULL );
    591 
    592     managerUnlock( manager );
    593     tr_free( manager );
     591    while (!tr_ptrArrayEmpty (&manager->incomingHandshakes))
     592        tr_handshakeAbort (tr_ptrArrayNth (&manager->incomingHandshakes, 0));
     593
     594    tr_ptrArrayDestruct (&manager->incomingHandshakes, NULL);
     595
     596    managerUnlock (manager);
     597    tr_free (manager);
    594598}
    595599
    596600static int
    597 clientIsDownloadingFrom( const tr_torrent * tor, const tr_peer * peer )
    598 {
    599     if( !tr_torrentHasMetadata( tor ) )
     601clientIsDownloadingFrom (const tr_torrent * tor, const tr_peer * peer)
     602{
     603    if (!tr_torrentHasMetadata (tor))
    600604        return true;
    601605
     
    604608
    605609static int
    606 clientIsUploadingTo( const tr_peer * peer )
     610clientIsUploadingTo (const tr_peer * peer)
    607611{
    608612    return peer->peerIsInterested && !peer->peerIsChoked;
     
    614618
    615619void
    616 tr_peerMgrOnBlocklistChanged( tr_peerMgr * mgr )
     620tr_peerMgrOnBlocklistChanged (tr_peerMgr * mgr)
    617621{
    618622    tr_torrent * tor = NULL;
     
    621625    /* we cache whether or not a peer is blocklisted...
    622626       since the blocklist has changed, erase that cached value */
    623     while(( tor = tr_torrentNext( session, tor )))
     627    while ((tor = tr_torrentNext (session, tor)))
    624628    {
    625629        int i;
    626630        Torrent * t = tor->torrentPeers;
    627         const int n = tr_ptrArraySize( &t->pool );
    628         for( i=0; i<n; ++i ) {
    629             struct peer_atom * atom = tr_ptrArrayNth( &t->pool, i );
     631        const int n = tr_ptrArraySize (&t->pool);
     632        for (i=0; i<n; ++i) {
     633            struct peer_atom * atom = tr_ptrArrayNth (&t->pool, i);
    630634            atom->blocklisted = -1;
    631635        }
     
    634638
    635639static bool
    636 isAtomBlocklisted( tr_session * session, struct peer_atom * atom )
    637 {
    638     if( atom->blocklisted < 0 )
    639         atom->blocklisted = tr_sessionIsAddressBlocked( session, &atom->addr );
    640 
    641     assert( tr_isBool( atom->blocklisted ) );
     640isAtomBlocklisted (tr_session * session, struct peer_atom * atom)
     641{
     642    if (atom->blocklisted < 0)
     643        atom->blocklisted = tr_sessionIsAddressBlocked (session, &atom->addr);
     644
     645    assert (tr_isBool (atom->blocklisted));
    642646    return atom->blocklisted;
    643647}
     
    649653
    650654static void
    651 atomSetSeedProbability( struct peer_atom * atom, int seedProbability )
    652 {
    653     assert( atom != NULL );
    654     assert( -1<=seedProbability && seedProbability<=100 );
     655atomSetSeedProbability (struct peer_atom * atom, int seedProbability)
     656{
     657    assert (atom != NULL);
     658    assert (-1<=seedProbability && seedProbability<=100);
    655659
    656660    atom->seedProbability = seedProbability;
    657661
    658     if( seedProbability == 100 )
     662    if (seedProbability == 100)
    659663        atom->flags |= ADDED_F_SEED_FLAG;
    660     else if( seedProbability != -1 )
     664    else if (seedProbability != -1)
    661665        atom->flags &= ~ADDED_F_SEED_FLAG;
    662666}
    663667
    664668static inline bool
    665 atomIsSeed( const struct peer_atom * atom )
     669atomIsSeed (const struct peer_atom * atom)
    666670{
    667671    return atom->seedProbability == 100;
     
    669673
    670674static void
    671 atomSetSeed( const Torrent * t, struct peer_atom * atom )
    672 {
    673     if( !atomIsSeed( atom ) )
    674     {
    675         tordbg( t, "marking peer %s as a seed", tr_atomAddrStr( atom ) );
    676 
    677         atomSetSeedProbability( atom, 100 );
     675atomSetSeed (const Torrent * t, struct peer_atom * atom)
     676{
     677    if (!atomIsSeed (atom))
     678    {
     679        tordbg (t, "marking peer %s as a seed", tr_atomAddrStr (atom));
     680
     681        atomSetSeedProbability (atom, 100);
    678682    }
    679683}
     
    681685
    682686bool
    683 tr_peerMgrPeerIsSeed( const tr_torrent  * tor,
    684                       const tr_address  * addr )
     687tr_peerMgrPeerIsSeed (const tr_torrent  * tor,
     688                      const tr_address  * addr)
    685689{
    686690    bool isSeed = false;
    687691    const Torrent * t = tor->torrentPeers;
    688     const struct peer_atom * atom = getExistingAtom( t, addr );
    689 
    690     if( atom )
    691         isSeed = atomIsSeed( atom );
     692    const struct peer_atom * atom = getExistingAtom (t, addr);
     693
     694    if (atom)
     695        isSeed = atomIsSeed (atom);
    692696
    693697    return isSeed;
     
    695699
    696700void
    697 tr_peerMgrSetUtpSupported( tr_torrent * tor, const tr_address * addr )
    698 {
    699     struct peer_atom * atom = getExistingAtom( tor->torrentPeers, addr );
    700 
    701     if( atom )
     701tr_peerMgrSetUtpSupported (tr_torrent * tor, const tr_address * addr)
     702{
     703    struct peer_atom * atom = getExistingAtom (tor->torrentPeers, addr);
     704
     705    if (atom)
    702706        atom->flags |= ADDED_F_UTP_FLAGS;
    703707}
    704708
    705709void
    706 tr_peerMgrSetUtpFailed( tr_torrent *tor, const tr_address *addr, bool failed )
    707 {
    708     struct peer_atom * atom = getExistingAtom( tor->torrentPeers, addr );
    709 
    710     if( atom )
     710tr_peerMgrSetUtpFailed (tr_torrent *tor, const tr_address *addr, bool failed)
     711{
     712    struct peer_atom * atom = getExistingAtom (tor->torrentPeers, addr);
     713
     714    if (atom)
    711715        atom->utp_failed = failed;
    712716}
     
    725729*** 2. Torrent::pieces, an array of "struct weighted_piece" which lists the
    726730***    pieces that we want to request. It's used to decide which blocks to
    727 ***    return next when tr_peerMgrGetBlockRequests() is called.
     731***    return next when tr_peerMgrGetBlockRequests () is called.
    728732**/
    729733
     
    733737
    734738static int
    735 compareReqByBlock( const void * va, const void * vb )
     739compareReqByBlock (const void * va, const void * vb)
    736740{
    737741    const struct block_request * a = va;
     
    739743
    740744    /* primary key: block */
    741     if( a->block < b->block ) return -1;
    742     if( a->block > b->block ) return 1;
     745    if (a->block < b->block) return -1;
     746    if (a->block > b->block) return 1;
    743747
    744748    /* secondary key: peer */
    745     if( a->peer < b->peer ) return -1;
    746     if( a->peer > b->peer ) return 1;
     749    if (a->peer < b->peer) return -1;
     750    if (a->peer > b->peer) return 1;
    747751
    748752    return 0;
     
    750754
    751755static void
    752 requestListAdd( Torrent * t, tr_block_index_t block, tr_peer * peer )
     756requestListAdd (Torrent * t, tr_block_index_t block, tr_peer * peer)
    753757{
    754758    struct block_request key;
    755759
    756760    /* ensure enough room is available... */
    757     if( t->requestCount + 1 >= t->requestAlloc )
     761    if (t->requestCount + 1 >= t->requestAlloc)
    758762    {
    759763        const int CHUNK_SIZE = 128;
    760764        t->requestAlloc += CHUNK_SIZE;
    761         t->requests = tr_renew( struct block_request,
    762                                 t->requests, t->requestAlloc );
     765        t->requests = tr_renew (struct block_request,
     766                                t->requests, t->requestAlloc);
    763767    }
    764768
     
    766770    key.block = block;
    767771    key.peer = peer;
    768     key.sentAt = tr_time( );
     772    key.sentAt = tr_time ();
    769773
    770774    /* insert the request to our array... */
    771775    {
    772776        bool exact;
    773         const int pos = tr_lowerBound( &key, t->requests, t->requestCount,
    774                                        sizeof( struct block_request ),
    775                                        compareReqByBlock, &exact );
    776         assert( !exact );
    777         memmove( t->requests + pos + 1,
     777        const int pos = tr_lowerBound (&key, t->requests, t->requestCount,
     778                                       sizeof (struct block_request),
     779                                       compareReqByBlock, &exact);
     780        assert (!exact);
     781        memmove (t->requests + pos + 1,
    778782                 t->requests + pos,
    779                  sizeof( struct block_request ) * ( t->requestCount++ - pos ) );
     783                 sizeof (struct block_request) * (t->requestCount++ - pos));
    780784        t->requests[pos] = key;
    781785    }
    782786
    783     if( peer != NULL )
     787    if (peer != NULL)
    784788    {
    785789        ++peer->pendingReqsToPeer;
    786         assert( peer->pendingReqsToPeer >= 0 );
    787     }
    788 
    789     /*fprintf( stderr, "added request of block %lu from peer %s... "
     790        assert (peer->pendingReqsToPeer >= 0);
     791    }
     792
     793    /*fprintf (stderr, "added request of block %lu from peer %s... "
    790794                       "there are now %d block\n",
    791                        (unsigned long)block, tr_atomAddrStr( peer->atom ), t->requestCount );*/
     795                     (unsigned long)block, tr_atomAddrStr (peer->atom), t->requestCount);*/
    792796}
    793797
    794798static struct block_request *
    795 requestListLookup( Torrent * t, tr_block_index_t block, const tr_peer * peer )
     799requestListLookup (Torrent * t, tr_block_index_t block, const tr_peer * peer)
    796800{
    797801    struct block_request key;
     
    799803    key.peer = (tr_peer*) peer;
    800804
    801     return bsearch( &key, t->requests, t->requestCount,
    802                     sizeof( struct block_request ),
    803                     compareReqByBlock );
     805    return bsearch (&key, t->requests, t->requestCount,
     806                    sizeof (struct block_request),
     807                    compareReqByBlock);
    804808}
    805809
     
    809813 */
    810814static void
    811 getBlockRequestPeers( Torrent * t, tr_block_index_t block,
    812                       tr_ptrArray * peerArr )
     815getBlockRequestPeers (Torrent * t, tr_block_index_t block,
     816                      tr_ptrArray * peerArr)
    813817{
    814818    bool exact;
     
    818822    key.block = block;
    819823    key.peer = NULL;
    820     pos = tr_lowerBound( &key, t->requests, t->requestCount,
    821                          sizeof( struct block_request ),
    822                          compareReqByBlock, &exact );
    823 
    824     assert( !exact ); /* shouldn't have a request with .peer == NULL */
    825 
    826     for( i = pos; i < t->requestCount; ++i )
    827     {
    828         if( t->requests[i].block != block )
     824    pos = tr_lowerBound (&key, t->requests, t->requestCount,
     825                         sizeof (struct block_request),
     826                         compareReqByBlock, &exact);
     827
     828    assert (!exact); /* shouldn't have a request with .peer == NULL */
     829
     830    for (i = pos; i < t->requestCount; ++i)
     831    {
     832        if (t->requests[i].block != block)
    829833            break;
    830         tr_ptrArrayAppend( peerArr, t->requests[i].peer );
    831     }
    832 }
    833 
    834 static void
    835 decrementPendingReqCount( const struct block_request * b )
    836 {
    837     if( b->peer != NULL )
    838         if( b->peer->pendingReqsToPeer > 0 )
     834        tr_ptrArrayAppend (peerArr, t->requests[i].peer);
     835    }
     836}
     837
     838static void
     839decrementPendingReqCount (const struct block_request * b)
     840{
     841    if (b->peer != NULL)
     842        if (b->peer->pendingReqsToPeer > 0)
    839843            --b->peer->pendingReqsToPeer;
    840844}
    841845
    842846static void
    843 requestListRemove( Torrent * t, tr_block_index_t block, const tr_peer * peer )
    844 {
    845     const struct block_request * b = requestListLookup( t, block, peer );
    846     if( b != NULL )
     847requestListRemove (Torrent * t, tr_block_index_t block, const tr_peer * peer)
     848{
     849    const struct block_request * b = requestListLookup (t, block, peer);
     850    if (b != NULL)
    847851    {
    848852        const int pos = b - t->requests;
    849         assert( pos < t->requestCount );
    850 
    851         decrementPendingReqCount( b );
    852 
    853         tr_removeElementFromArray( t->requests,
     853        assert (pos < t->requestCount);
     854
     855        decrementPendingReqCount (b);
     856
     857        tr_removeElementFromArray (t->requests,
    854858                                   pos,
    855                                    sizeof( struct block_request ),
    856                                    t->requestCount-- );
    857 
    858         /*fprintf( stderr, "removing request of block %lu from peer %s... "
     859                                   sizeof (struct block_request),
     860                                   t->requestCount--);
     861
     862        /*fprintf (stderr, "removing request of block %lu from peer %s... "
    859863                           "there are now %d block requests left\n",
    860                            (unsigned long)block, tr_atomAddrStr( peer->atom ), t->requestCount );*/
     864                         (unsigned long)block, tr_atomAddrStr (peer->atom), t->requestCount);*/
    861865    }
    862866}
    863867
    864868static int
    865 countActiveWebseeds( const Torrent * t )
     869countActiveWebseeds (const Torrent * t)
    866870{
    867871    int activeCount = 0;
    868     const tr_webseed ** w = (const tr_webseed **) tr_ptrArrayBase( &t->webseeds );
    869     const tr_webseed ** const wend = w + tr_ptrArraySize( &t->webseeds );
    870 
    871     for( ; w!=wend; ++w )
    872         if( tr_webseedIsActive( *w ) )
     872    const tr_webseed ** w = (const tr_webseed **) tr_ptrArrayBase (&t->webseeds);
     873    const tr_webseed ** const wend = w + tr_ptrArraySize (&t->webseeds);
     874
     875    for (; w!=wend; ++w)
     876        if (tr_webseedIsActive (*w))
    873877            ++activeCount;
    874878
     
    877881
    878882static bool
    879 testForEndgame( const Torrent * t )
     883testForEndgame (const Torrent * t)
    880884{
    881885    /* we consider ourselves to be in endgame if the number of bytes
    882886       we've got requested is >= the number of bytes left to download */
    883     return ( t->requestCount * t->tor->blockSize )
    884                >= tr_cpLeftUntilDone( &t->tor->completion );
    885 }
    886 
    887 static void
    888 updateEndgame( Torrent * t )
    889 {
    890     assert( t->requestCount >= 0 );
    891 
    892     if( !testForEndgame( t ) )
     887    return (t->requestCount * t->tor->blockSize)
     888               >= tr_cpLeftUntilDone (&t->tor->completion);
     889}
     890
     891static void
     892updateEndgame (Torrent * t)
     893{
     894    assert (t->requestCount >= 0);
     895
     896    if (!testForEndgame (t))
    893897    {
    894898        /* not in endgame */
    895899        t->endgame = 0;
    896900    }
    897     else if( !t->endgame ) /* only recalculate when endgame first begins */
     901    else if (!t->endgame) /* only recalculate when endgame first begins */
    898902    {
    899903        int numDownloading = 0;
    900         const tr_peer ** p = (const tr_peer **) tr_ptrArrayBase( &t->peers );
    901         const tr_peer ** const pend = p + tr_ptrArraySize( &t->peers );
     904        const tr_peer ** p = (const tr_peer **) tr_ptrArrayBase (&t->peers);
     905        const tr_peer ** const pend = p + tr_ptrArraySize (&t->peers);
    902906
    903907        /* add the active bittorrent peers... */
    904         for( ; p!=pend; ++p )
    905             if( (*p)->pendingReqsToPeer > 0 )
     908        for (; p!=pend; ++p)
     909            if ((*p)->pendingReqsToPeer > 0)
    906910                ++numDownloading;
    907911
    908912        /* add the active webseeds... */
    909         numDownloading += countActiveWebseeds( t );
     913        numDownloading += countActiveWebseeds (t);
    910914
    911915        /* average number of pending requests per downloading peer */
    912         t->endgame = t->requestCount / MAX( numDownloading, 1 );
     916        t->endgame = t->requestCount / MAX (numDownloading, 1);
    913917    }
    914918}
     
    922926
    923927static inline void
    924 invalidatePieceSorting( Torrent * t )
     928invalidatePieceSorting (Torrent * t)
    925929{
    926930    t->pieceSortState = PIECES_UNSORTED;
     
    932936
    933937static void
    934 setComparePieceByWeightTorrent( Torrent * t )
    935 {
    936     if( !replicationExists( t ) )
    937         replicationNew( t );
     938setComparePieceByWeightTorrent (Torrent * t)
     939{
     940    if (!replicationExists (t))
     941        replicationNew (t);
    938942
    939943    weightTorrent = t->tor;
     
    944948 * and that partially-complete pieces come before empty ones. */
    945949static int
    946 comparePieceByWeight( const void * va, const void * vb )
     950comparePieceByWeight (const void * va, const void * vb)
    947951{
    948952    const struct weighted_piece * a = va;
     
    953957
    954958    /* primary key: weight */
    955     missing = tr_cpMissingBlocksInPiece( &tor->completion, a->index );
     959    missing = tr_cpMissingBlocksInPiece (&tor->completion, a->index);
    956960    pending = a->requestCount;
    957961    ia = missing > pending ? missing - pending : (tor->blockCountInPiece + pending);
    958     missing = tr_cpMissingBlocksInPiece( &tor->completion, b->index );
     962    missing = tr_cpMissingBlocksInPiece (&tor->completion, b->index);
    959963    pending = b->requestCount;
    960964    ib = missing > pending ? missing - pending : (tor->blockCountInPiece + pending);
    961     if( ia < ib ) return -1;
    962     if( ia > ib ) return 1;
     965    if (ia < ib) return -1;
     966    if (ia > ib) return 1;
    963967
    964968    /* secondary key: higher priorities go first */
    965969    ia = tor->info.pieces[a->index].priority;
    966970    ib = tor->info.pieces[b->index].priority;
    967     if( ia > ib ) return -1;
    968     if( ia < ib ) return 1;
     971    if (ia > ib) return -1;
     972    if (ia < ib) return 1;
    969973
    970974    /* tertiary key: rarest first. */
    971975    ia = rep[a->index];
    972976    ib = rep[b->index];
    973     if( ia < ib ) return -1;
    974     if( ia > ib ) return 1;
     977    if (ia < ib) return -1;
     978    if (ia > ib) return 1;
    975979
    976980    /* quaternary key: random */
    977     if( a->salt < b->salt ) return -1;
    978     if( a->salt > b->salt ) return 1;
     981    if (a->salt < b->salt) return -1;
     982    if (a->salt > b->salt) return 1;
    979983
    980984    /* okay, they're equal */
     
    983987
    984988static int
    985 comparePieceByIndex( const void * va, const void * vb )
     989comparePieceByIndex (const void * va, const void * vb)
    986990{
    987991    const struct weighted_piece * a = va;
    988992    const struct weighted_piece * b = vb;
    989     if( a->index < b->index ) return -1;
    990     if( a->index > b->index ) return 1;
     993    if (a->index < b->index) return -1;
     994    if (a->index > b->index) return 1;
    991995    return 0;
    992996}
    993997
    994998static void
    995 pieceListSort( Torrent * t, enum piece_sort_state state )
    996 {
    997     assert( state==PIECES_SORTED_BY_INDEX
    998          || state==PIECES_SORTED_BY_WEIGHT );
    999 
    1000 
    1001     if( state == PIECES_SORTED_BY_WEIGHT )
    1002     {
    1003         setComparePieceByWeightTorrent( t );
    1004         qsort( t->pieces, t->pieceCount, sizeof( struct weighted_piece ), comparePieceByWeight );
     999pieceListSort (Torrent * t, enum piece_sort_state state)
     1000{
     1001    assert (state==PIECES_SORTED_BY_INDEX
     1002         || state==PIECES_SORTED_BY_WEIGHT);
     1003
     1004
     1005    if (state == PIECES_SORTED_BY_WEIGHT)
     1006    {
     1007        setComparePieceByWeightTorrent (t);
     1008        qsort (t->pieces, t->pieceCount, sizeof (struct weighted_piece), comparePieceByWeight);
    10051009    }
    10061010    else
    1007         qsort( t->pieces, t->pieceCount, sizeof( struct weighted_piece ), comparePieceByIndex );
     1011        qsort (t->pieces, t->pieceCount, sizeof (struct weighted_piece), comparePieceByIndex);
    10081012
    10091013    t->pieceSortState = state;
     
    10191023#else
    10201024static void
    1021 assertWeightedPiecesAreSorted( Torrent * t )
    1022 {
    1023     if( !t->endgame )
     1025assertWeightedPiecesAreSorted (Torrent * t)
     1026{
     1027    if (!t->endgame)
    10241028    {
    10251029        int i;
    1026         setComparePieceByWeightTorrent( t );
    1027         for( i=0; i<t->pieceCount-1; ++i )
    1028             assert( comparePieceByWeight( &t->pieces[i], &t->pieces[i+1] ) <= 0 );
    1029     }
    1030 }
    1031 static void
    1032 assertReplicationCountIsExact( Torrent * t )
     1030        setComparePieceByWeightTorrent (t);
     1031        for (i=0; i<t->pieceCount-1; ++i)
     1032            assert (comparePieceByWeight (&t->pieces[i], &t->pieces[i+1]) <= 0);
     1033    }
     1034}
     1035static void
     1036assertReplicationCountIsExact (Torrent * t)
    10331037{
    10341038    /* This assert might fail due to errors of implementations in other
     
    10401044    const uint16_t * rep = t->pieceReplication;
    10411045    const size_t piece_count = t->pieceReplicationSize;
    1042     const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
    1043     const int peer_count = tr_ptrArraySize( &t->peers );
    1044 
    1045     assert( piece_count == t->tor->info.pieceCount );
    1046 
    1047     for( piece_i=0; piece_i<piece_count; ++piece_i )
     1046    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
     1047    const int peer_count = tr_ptrArraySize (&t->peers);
     1048
     1049    assert (piece_count == t->tor->info.pieceCount);
     1050
     1051    for (piece_i=0; piece_i<piece_count; ++piece_i)
    10481052    {
    10491053        int peer_i;
    10501054        uint16_t r = 0;
    10511055
    1052         for( peer_i=0; peer_i<peer_count; ++peer_i )
    1053             if( tr_bitsetHas( &peers[peer_i]->have, piece_i ) )
     1056        for (peer_i=0; peer_i<peer_count; ++peer_i)
     1057            if (tr_bitsetHas (&peers[peer_i]->have, piece_i))
    10541058                ++r;
    10551059
    1056         assert( rep[piece_i] == r );
     1060        assert (rep[piece_i] == r);
    10571061    }
    10581062}
     
    10601064
    10611065static struct weighted_piece *
    1062 pieceListLookup( Torrent * t, tr_piece_index_t index )
     1066pieceListLookup (Torrent * t, tr_piece_index_t index)
    10631067{
    10641068    int i;
    10651069
    1066     for( i=0; i<t->pieceCount; ++i )
    1067         if( t->pieces[i].index == index )
     1070    for (i=0; i<t->pieceCount; ++i)
     1071        if (t->pieces[i].index == index)
    10681072            return &t->pieces[i];
    10691073
     
    10721076
    10731077static void
    1074 pieceListRebuild( Torrent * t )
    1075 {
    1076 
    1077     if( !tr_torrentIsSeed( t->tor ) )
     1078pieceListRebuild (Torrent * t)
     1079{
     1080
     1081    if (!tr_torrentIsSeed (t->tor))
    10781082    {
    10791083        tr_piece_index_t i;
     
    10811085        tr_piece_index_t poolCount = 0;
    10821086        const tr_torrent * tor = t->tor;
    1083         const tr_info * inf = tr_torrentInfo( tor );
     1087        const tr_info * inf = tr_torrentInfo (tor);
    10841088        struct weighted_piece * pieces;
    10851089        int pieceCount;
    10861090
    10871091        /* build the new list */
    1088         pool = tr_new( tr_piece_index_t, inf->pieceCount );
    1089         for( i=0; i<inf->pieceCount; ++i )
    1090             if( !inf->pieces[i].dnd )
    1091                 if( !tr_cpPieceIsComplete( &tor->completion, i ) )
     1092        pool = tr_new (tr_piece_index_t, inf->pieceCount);
     1093        for (i=0; i<inf->pieceCount; ++i)
     1094            if (!inf->pieces[i].dnd)
     1095                if (!tr_cpPieceIsComplete (&tor->completion, i))
    10921096                    pool[poolCount++] = i;
    10931097        pieceCount = poolCount;
    1094         pieces = tr_new0( struct weighted_piece, pieceCount );
    1095         for( i=0; i<poolCount; ++i ) {
     1098        pieces = tr_new0 (struct weighted_piece, pieceCount);
     1099        for (i=0; i<poolCount; ++i) {
    10961100            struct weighted_piece * piece = pieces + i;
    10971101            piece->index = pool[i];
    10981102            piece->requestCount = 0;
    1099             piece->salt = tr_cryptoWeakRandInt( 4096 );
     1103            piece->salt = tr_cryptoWeakRandInt (4096);
    11001104        }
    11011105
    11021106        /* if we already had a list of pieces, merge it into
    11031107         * the new list so we don't lose its requestCounts */
    1104         if( t->pieces != NULL )
     1108        if (t->pieces != NULL)
    11051109        {
    11061110            struct weighted_piece * o = t->pieces;
     
    11091113            struct weighted_piece * nend = n + pieceCount;
    11101114
    1111             pieceListSort( t, PIECES_SORTED_BY_INDEX );
    1112 
    1113             while( o!=oend && n!=nend ) {
    1114                 if( o->index < n->index )
     1115            pieceListSort (t, PIECES_SORTED_BY_INDEX);
     1116
     1117            while (o!=oend && n!=nend) {
     1118                if (o->index < n->index)
    11151119                    ++o;
    1116                 else if( o->index > n->index )
     1120                else if (o->index > n->index)
    11171121                    ++n;
    11181122                else
     
    11201124            }
    11211125
    1122             tr_free( t->pieces );
     1126            tr_free (t->pieces);
    11231127        }
    11241128
     
    11261130        t->pieceCount = pieceCount;
    11271131
    1128         pieceListSort( t, PIECES_SORTED_BY_WEIGHT );
     1132        pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
    11291133
    11301134        /* cleanup */
    1131         tr_free( pool );
    1132     }
    1133 }
    1134 
    1135 static void
    1136 pieceListRemovePiece( Torrent * t, tr_piece_index_t piece )
     1135        tr_free (pool);
     1136    }
     1137}
     1138
     1139static void
     1140pieceListRemovePiece (Torrent * t, tr_piece_index_t piece)
    11371141{
    11381142    struct weighted_piece * p;
    11391143
    1140     if(( p = pieceListLookup( t, piece )))
     1144    if ((p = pieceListLookup (t, piece)))
    11411145    {
    11421146        const int pos = p - t->pieces;
    11431147
    1144         tr_removeElementFromArray( t->pieces,
     1148        tr_removeElementFromArray (t->pieces,
    11451149                                   pos,
    1146                                    sizeof( struct weighted_piece ),
    1147                                    t->pieceCount-- );
    1148 
    1149         if( t->pieceCount == 0 )
     1150                                   sizeof (struct weighted_piece),
     1151                                   t->pieceCount--);
     1152
     1153        if (t->pieceCount == 0)
    11501154        {
    1151             tr_free( t->pieces );
     1155            tr_free (t->pieces);
    11521156            t->pieces = NULL;
    11531157        }
     
    11561160
    11571161static void
    1158 pieceListResortPiece( Torrent * t, struct weighted_piece * p )
     1162pieceListResortPiece (Torrent * t, struct weighted_piece * p)
    11591163{
    11601164    int pos;
    11611165    bool isSorted = true;
    11621166
    1163     if( p == NULL )
     1167    if (p == NULL)
    11641168        return;
    11651169
    11661170    /* is the torrent already sorted? */
    11671171    pos = p - t->pieces;
    1168     setComparePieceByWeightTorrent( t );
    1169     if( isSorted && ( pos > 0 ) && ( comparePieceByWeight( p-1, p ) > 0 ) )
     1172    setComparePieceByWeightTorrent (t);
     1173    if (isSorted && (pos > 0) && (comparePieceByWeight (p-1, p) > 0))
    11701174        isSorted = false;
    1171     if( isSorted && ( pos < t->pieceCount - 1 ) && ( comparePieceByWeight( p, p+1 ) > 0 ) )
     1175    if (isSorted && (pos < t->pieceCount - 1) && (comparePieceByWeight (p, p+1) > 0))
    11721176        isSorted = false;
    11731177
    1174     if( t->pieceSortState != PIECES_SORTED_BY_WEIGHT )
    1175     {
    1176        pieceListSort( t, PIECES_SORTED_BY_WEIGHT);
     1178    if (t->pieceSortState != PIECES_SORTED_BY_WEIGHT)
     1179    {
     1180       pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
    11771181       isSorted = true;
    11781182    }
    11791183
    11801184    /* if it's not sorted, move it around */
    1181     if( !isSorted )
     1185    if (!isSorted)
    11821186    {
    11831187        bool exact;
    11841188        const struct weighted_piece tmp = *p;
    11851189
    1186         tr_removeElementFromArray( t->pieces,
     1190        tr_removeElementFromArray (t->pieces,
    11871191                                   pos,
    1188                                    sizeof( struct weighted_piece ),
    1189                                    t->pieceCount-- );
    1190 
    1191         pos = tr_lowerBound( &tmp, t->pieces, t->pieceCount,
    1192                              sizeof( struct weighted_piece ),
    1193                              comparePieceByWeight, &exact );
    1194 
    1195         memmove( &t->pieces[pos + 1],
     1192                                   sizeof (struct weighted_piece),
     1193                                   t->pieceCount--);
     1194
     1195        pos = tr_lowerBound (&tmp, t->pieces, t->pieceCount,
     1196                             sizeof (struct weighted_piece),
     1197                             comparePieceByWeight, &exact);
     1198
     1199        memmove (&t->pieces[pos + 1],
    11961200                 &t->pieces[pos],
    1197                  sizeof( struct weighted_piece ) * ( t->pieceCount++ - pos ) );
     1201                 sizeof (struct weighted_piece) * (t->pieceCount++ - pos));
    11981202
    11991203        t->pieces[pos] = tmp;
    12001204    }
    12011205
    1202     assertWeightedPiecesAreSorted( t );
    1203 }
    1204 
    1205 static void
    1206 pieceListRemoveRequest( Torrent * t, tr_block_index_t block )
     1206    assertWeightedPiecesAreSorted (t);
     1207}
     1208
     1209static void
     1210pieceListRemoveRequest (Torrent * t, tr_block_index_t block)
    12071211{
    12081212    struct weighted_piece * p;
    1209     const tr_piece_index_t index = tr_torBlockPiece( t->tor, block );
    1210 
    1211     if( ((p = pieceListLookup( t, index ))) && ( p->requestCount > 0 ) )
     1213    const tr_piece_index_t index = tr_torBlockPiece (t->tor, block);
     1214
     1215    if (((p = pieceListLookup (t, index))) && (p->requestCount > 0))
    12121216    {
    12131217        --p->requestCount;
    1214         pieceListResortPiece( t, p );
     1218        pieceListResortPiece (t, p);
    12151219    }
    12161220}
     
    12191223/****
    12201224*****
    1221 *****  Replication count ( for rarest first policy )
     1225*****  Replication count (for rarest first policy)
    12221226*****
    12231227****/
     
    12281232 */
    12291233static void
    1230 tr_incrReplicationOfPiece( Torrent * t, const size_t index )
    1231 {
    1232     assert( replicationExists( t ) );
    1233     assert( t->pieceReplicationSize == t->tor->info.pieceCount );
     1234tr_incrReplicationOfPiece (Torrent * t, const size_t index)
     1235{
     1236    assert (replicationExists (t));
     1237    assert (t->pieceReplicationSize == t->tor->info.pieceCount);
    12341238
    12351239    /* One more replication of this piece is present in the swarm */
     
    12371241
    12381242    /* we only resort the piece if the list is already sorted */
    1239     if( t->pieceSortState == PIECES_SORTED_BY_WEIGHT )
    1240         pieceListResortPiece( t, pieceListLookup( t, index ) );
     1243    if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
     1244        pieceListResortPiece (t, pieceListLookup (t, index));
    12411245}
    12421246
     
    12451249 */
    12461250static void
    1247 tr_incrReplicationFromBitfield( Torrent * t, const tr_bitfield * b )
     1251tr_incrReplicationFromBitfield (Torrent * t, const tr_bitfield * b)
    12481252{
    12491253    size_t i;
     
    12511255    const size_t n = t->tor->info.pieceCount;
    12521256
    1253     assert( replicationExists( t ) );
    1254 
    1255     for( i=0; i<n; ++i )
    1256         if( tr_bitfieldHas( b, i ) )
     1257    assert (replicationExists (t));
     1258
     1259    for (i=0; i<n; ++i)
     1260        if (tr_bitfieldHas (b, i))
    12571261            ++rep[i];
    12581262
    1259     if( t->pieceSortState == PIECES_SORTED_BY_WEIGHT )
    1260         invalidatePieceSorting( t );
     1263    if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
     1264        invalidatePieceSorting (t);
    12611265}
    12621266
     
    12651269 */
    12661270static void
    1267 tr_incrReplication( Torrent * t )
     1271tr_incrReplication (Torrent * t)
    12681272{
    12691273    int i;
    12701274    const int n = t->pieceReplicationSize;
    12711275
    1272     assert( replicationExists( t ) );
    1273     assert( t->pieceReplicationSize == t->tor->info.pieceCount );
    1274 
    1275     for( i=0; i<n; ++i )
     1276    assert (replicationExists (t));
     1277    assert (t->pieceReplicationSize == t->tor->info.pieceCount);
     1278
     1279    for (i=0; i<n; ++i)
    12761280        ++t->pieceReplication[i];
    12771281}
     
    12811285 */
    12821286static void
    1283 tr_decrReplicationFromBitfield( Torrent * t, const tr_bitfield * b )
     1287tr_decrReplicationFromBitfield (Torrent * t, const tr_bitfield * b)
    12841288{
    12851289    int i;
    12861290    const int n = t->pieceReplicationSize;
    12871291
    1288     assert( replicationExists( t ) );
    1289     assert( t->pieceReplicationSize == t->tor->info.pieceCount );
    1290 
    1291     if( tr_bitfieldHasAll( b ) )
    1292     {
    1293         for( i=0; i<n; ++i )
     1292    assert (replicationExists (t));
     1293    assert (t->pieceReplicationSize == t->tor->info.pieceCount);
     1294
     1295    if (tr_bitfieldHasAll (b))
     1296    {
     1297        for (i=0; i<n; ++i)
    12941298            --t->pieceReplication[i];
    12951299    }
    1296     else if ( !tr_bitfieldHasNone( b ) )
    1297     {
    1298         for( i=0; i<n; ++i )
    1299             if( tr_bitfieldHas( b, i ) )
     1300    else if (!tr_bitfieldHasNone (b))
     1301    {
     1302        for (i=0; i<n; ++i)
     1303            if (tr_bitfieldHas (b, i))
    13001304                --t->pieceReplication[i];
    13011305
    1302         if( t->pieceSortState == PIECES_SORTED_BY_WEIGHT )
    1303             invalidatePieceSorting( t );
     1306        if (t->pieceSortState == PIECES_SORTED_BY_WEIGHT)
     1307            invalidatePieceSorting (t);
    13041308    }
    13051309}
     
    13101314
    13111315void
    1312 tr_peerMgrRebuildRequests( tr_torrent * tor )
    1313 {
    1314     assert( tr_isTorrent( tor ) );
    1315 
    1316     pieceListRebuild( tor->torrentPeers );
     1316tr_peerMgrRebuildRequests (tr_torrent * tor)
     1317{
     1318    assert (tr_isTorrent (tor));
     1319
     1320    pieceListRebuild (tor->torrentPeers);
    13171321}
    13181322
    13191323void
    1320 tr_peerMgrGetNextRequests( tr_torrent           * tor,
     1324tr_peerMgrGetNextRequests (tr_torrent           * tor,
    13211325                           tr_peer              * peer,
    13221326                           int                    numwant,
    13231327                           tr_block_index_t     * setme,
    13241328                           int                  * numgot,
    1325                            bool                   get_intervals )
     1329                           bool                   get_intervals)
    13261330{
    13271331    int i;
     
    13321336
    13331337    /* sanity clause */
    1334     assert( tr_isTorrent( tor ) );
    1335     assert( peer->clientIsInterested );
    1336     assert( !peer->clientIsChoked );
    1337     assert( numwant > 0 );
     1338    assert (tr_isTorrent (tor));
     1339    assert (peer->clientIsInterested);
     1340    assert (!peer->clientIsChoked);
     1341    assert (numwant > 0);
    13381342
    13391343    /* walk through the pieces and find blocks that should be requested */
     
    13421346
    13431347    /* prep the pieces list */
    1344     if( t->pieces == NULL )
    1345         pieceListRebuild( t );
    1346 
    1347     if( t->pieceSortState != PIECES_SORTED_BY_WEIGHT )
    1348         pieceListSort( t, PIECES_SORTED_BY_WEIGHT );
    1349 
    1350     assertReplicationCountIsExact( t );
    1351     assertWeightedPiecesAreSorted( t );
    1352 
    1353     updateEndgame( t );
     1348    if (t->pieces == NULL)
     1349        pieceListRebuild (t);
     1350
     1351    if (t->pieceSortState != PIECES_SORTED_BY_WEIGHT)
     1352        pieceListSort (t, PIECES_SORTED_BY_WEIGHT);
     1353
     1354    assertReplicationCountIsExact (t);
     1355    assertWeightedPiecesAreSorted (t);
     1356
     1357    updateEndgame (t);
    13541358    pieces = t->pieces;
    1355     for( i=0; i<t->pieceCount && got<numwant; ++i )
     1359    for (i=0; i<t->pieceCount && got<numwant; ++i)
    13561360    {
    13571361        struct weighted_piece * p = pieces + i;
    13581362
    13591363        /* if the peer has this piece that we want... */
    1360         if( tr_bitfieldHas( have, p->index ) )
     1364        if (tr_bitfieldHas (have, p->index))
    13611365        {
    13621366            tr_block_index_t b;
     
    13651369            tr_ptrArray peerArr = TR_PTR_ARRAY_INIT;
    13661370
    1367             tr_torGetPieceBlockRange( tor, p->index, &first, &last );
    1368 
    1369             for( b=first; b<=last && (got<numwant || (get_intervals && setme[2*got-1] == b-1)); ++b )
     1371            tr_torGetPieceBlockRange (tor, p->index, &first, &last);
     1372
     1373            for (b=first; b<=last && (got<numwant || (get_intervals && setme[2*got-1] == b-1)); ++b)
    13701374            {
    13711375                int peerCount;
     
    13731377
    13741378                /* don't request blocks we've already got */
    1375                 if( tr_cpBlockIsComplete( &tor->completion, b ) )
     1379                if (tr_cpBlockIsComplete (&tor->completion, b))
    13761380                    continue;
    13771381
    13781382                /* always add peer if this block has no peers yet */
    1379                 tr_ptrArrayClear( &peerArr );
    1380                 getBlockRequestPeers( t, b, &peerArr );
    1381                 peers = (tr_peer **) tr_ptrArrayPeek( &peerArr, &peerCount );
    1382                 if( peerCount != 0 )
     1383                tr_ptrArrayClear (&peerArr);
     1384                getBlockRequestPeers (t, b, &peerArr);
     1385                peers = (tr_peer **) tr_ptrArrayPeek (&peerArr, &peerCount);
     1386                if (peerCount != 0)
    13831387                {
    13841388                    /* don't make a second block request until the endgame */
    1385                     if( !t->endgame )
     1389                    if (!t->endgame)
    13861390                        continue;
    13871391
    13881392                    /* don't have more than two peers requesting this block */
    1389                     if( peerCount > 1 )
     1393                    if (peerCount > 1)
    13901394                        continue;
    13911395
    13921396                    /* don't send the same request to the same peer twice */
    1393                     if( peer == peers[0] )
     1397                    if (peer == peers[0])
    13941398                        continue;
    13951399
     
    13971401                       block but only if the peer seems to be handling requests
    13981402                       relatively fast */
    1399                     if( peer->pendingReqsToPeer + numwant - got < t->endgame )
     1403                    if (peer->pendingReqsToPeer + numwant - got < t->endgame)
    14001404                        continue;
    14011405                }
    14021406
    14031407                /* update the caller's table */
    1404                 if( !get_intervals ) {
     1408                if (!get_intervals) {
    14051409                    setme[got++] = b;
    14061410                }
    14071411                /* if intervals are requested two array entries are necessarry:
    14081412                   one for the interval's starting block and one for its end block */
    1409                 else if( got && setme[2 * got - 1] == b - 1 && b != first ) {
     1413                else if (got && setme[2 * got - 1] == b - 1 && b != first) {
    14101414                    /* expand the last interval */
    14111415                    ++setme[2 * got - 1];
     
    14181422
    14191423                /* update our own tables */
    1420                 requestListAdd( t, b, peer );
     1424                requestListAdd (t, b, peer);
    14211425                ++p->requestCount;
    14221426            }
    14231427
    1424             tr_ptrArrayDestruct( &peerArr, NULL );
     1428            tr_ptrArrayDestruct (&peerArr, NULL);
    14251429        }
    14261430    }
    14271431
    14281432    /* In most cases we've just changed the weights of a small number of pieces.
    1429      * So rather than qsort()ing the entire array, it's faster to apply an
     1433     * So rather than qsort ()ing the entire array, it's faster to apply an
    14301434     * adaptive insertion sort algorithm. */
    1431     if( got > 0 )
     1435    if (got > 0)
    14321436    {
    14331437        /* not enough requests || last piece modified */
    1434         if ( i == t->pieceCount ) --i;
    1435 
    1436         setComparePieceByWeightTorrent( t );
    1437         while( --i >= 0 )
     1438        if (i == t->pieceCount) --i;
     1439
     1440        setComparePieceByWeightTorrent (t);
     1441        while (--i >= 0)
    14381442        {
    14391443            bool exact;
    14401444
    14411445            /* relative position! */
    1442             const int newpos = tr_lowerBound( &t->pieces[i], &t->pieces[i + 1],
     1446            const int newpos = tr_lowerBound (&t->pieces[i], &t->pieces[i + 1],
    14431447                                              t->pieceCount - (i + 1),
    1444                                               sizeof( struct weighted_piece ),
    1445                                               comparePieceByWeight, &exact );
    1446             if( newpos > 0 )
     1448                                              sizeof (struct weighted_piece),
     1449                                              comparePieceByWeight, &exact);
     1450            if (newpos > 0)
    14471451            {
    14481452                const struct weighted_piece piece = t->pieces[i];
    1449                 memmove( &t->pieces[i],
     1453                memmove (&t->pieces[i],
    14501454                         &t->pieces[i + 1],
    1451                          sizeof( struct weighted_piece ) * ( newpos ) );
     1455                         sizeof (struct weighted_piece) * (newpos));
    14521456                t->pieces[i + newpos] = piece;
    14531457            }
     
    14551459    }
    14561460
    1457     assertWeightedPiecesAreSorted( t );
     1461    assertWeightedPiecesAreSorted (t);
    14581462    *numgot = got;
    14591463}
    14601464
    14611465bool
    1462 tr_peerMgrDidPeerRequest( const tr_torrent  * tor,
     1466tr_peerMgrDidPeerRequest (const tr_torrent  * tor,
    14631467                          const tr_peer     * peer,
    1464                           tr_block_index_t    block )
     1468                          tr_block_index_t    block)
    14651469{
    14661470    const Torrent * t = tor->torrentPeers;
    1467     return requestListLookup( (Torrent*)t, block, peer ) != NULL;
     1471    return requestListLookup ((Torrent*)t, block, peer) != NULL;
    14681472}
    14691473
    14701474/* cancel requests that are too old */
    14711475static void
    1472 refillUpkeep( int foo UNUSED, short bar UNUSED, void * vmgr )
     1476refillUpkeep (int foo UNUSED, short bar UNUSED, void * vmgr)
    14731477{
    14741478    time_t now;
     
    14781482    struct block_request * cancel = NULL;
    14791483    tr_peerMgr * mgr = vmgr;
    1480     managerLock( mgr );
    1481 
    1482     now = tr_time( );
     1484    managerLock (mgr);
     1485
     1486    now = tr_time ();
    14831487    too_old = now - REQUEST_TTL_SECS;
    14841488
    14851489    /* alloc the temporary "cancel" buffer */
    14861490    tor = NULL;
    1487     while(( tor = tr_torrentNext( mgr->session, tor )))
    1488         cancel_buflen = MAX( cancel_buflen, tor->torrentPeers->requestCount );
    1489     if( cancel_buflen > 0 )
    1490         cancel = tr_new( struct block_request, cancel_buflen );
     1491    while ((tor = tr_torrentNext (mgr->session, tor)))
     1492        cancel_buflen = MAX (cancel_buflen, tor->torrentPeers->requestCount);
     1493    if (cancel_buflen > 0)
     1494        cancel = tr_new (struct block_request, cancel_buflen);
    14911495
    14921496    /* prune requests that are too old */
    14931497    tor = NULL;
    1494     while(( tor = tr_torrentNext( mgr->session, tor )))
     1498    while ((tor = tr_torrentNext (mgr->session, tor)))
    14951499    {
    14961500        Torrent * t = tor->torrentPeers;
    14971501        const int n = t->requestCount;
    1498         if( n > 0 )
     1502        if (n > 0)
    14991503        {
    15001504            int keepCount = 0;
     
    15031507            const struct block_request * end;
    15041508
    1505             for( it=t->requests, end=it+n; it!=end; ++it )
     1509            for (it=t->requests, end=it+n; it!=end; ++it)
    15061510            {
    1507                 if( ( it->sentAt <= too_old ) && it->peer->msgs && !tr_peerMsgsIsReadingBlock( it->peer->msgs, it->block ) )
     1511                if ((it->sentAt <= too_old) && it->peer->msgs && !tr_peerMsgsIsReadingBlock (it->peer->msgs, it->block))
    15081512                    cancel[cancelCount++] = *it;
    15091513                else
    15101514                {
    1511                     if( it != &t->requests[keepCount] )
     1515                    if (it != &t->requests[keepCount])
    15121516                        t->requests[keepCount] = *it;
    15131517                    keepCount++;
     
    15191523
    15201524            /* send cancel messages for all the "cancel" ones */
    1521             for( it=cancel, end=it+cancelCount; it!=end; ++it ) {
    1522                 if( ( it->peer != NULL ) && ( it->peer->msgs != NULL ) ) {
    1523                     tr_historyAdd( &it->peer->cancelsSentToPeer, now, 1 );
    1524                     tr_peerMsgsCancel( it->peer->msgs, it->block );
    1525                     decrementPendingReqCount( it );
     1525            for (it=cancel, end=it+cancelCount; it!=end; ++it) {
     1526                if ((it->peer != NULL) && (it->peer->msgs != NULL)) {
     1527                    tr_historyAdd (&it->peer->cancelsSentToPeer, now, 1);
     1528                    tr_peerMsgsCancel (it->peer->msgs, it->block);
     1529                    decrementPendingReqCount (it);
    15261530                }
    15271531            }
    15281532
    15291533            /* decrement the pending request counts for the timed-out blocks */
    1530             for( it=cancel, end=it+cancelCount; it!=end; ++it )
    1531                 pieceListRemoveRequest( t, it->block );
     1534            for (it=cancel, end=it+cancelCount; it!=end; ++it)
     1535                pieceListRemoveRequest (t, it->block);
    15321536        }
    15331537    }
    15341538
    1535     tr_free( cancel );
    1536     tr_timerAddMsec( mgr->refillUpkeepTimer, REFILL_UPKEEP_PERIOD_MSEC );
    1537     managerUnlock( mgr );
    1538 }
    1539 
    1540 static void
    1541 addStrike( Torrent * t, tr_peer * peer )
    1542 {
    1543     tordbg( t, "increasing peer %s strike count to %d",
    1544             tr_atomAddrStr( peer->atom ), peer->strikes + 1 );
    1545 
    1546     if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
     1539    tr_free (cancel);
     1540    tr_timerAddMsec (mgr->refillUpkeepTimer, REFILL_UPKEEP_PERIOD_MSEC);
     1541    managerUnlock (mgr);
     1542}
     1543
     1544static void
     1545addStrike (Torrent * t, tr_peer * peer)
     1546{
     1547    tordbg (t, "increasing peer %s strike count to %d",
     1548            tr_atomAddrStr (peer->atom), peer->strikes + 1);
     1549
     1550    if (++peer->strikes >= MAX_BAD_PIECES_PER_PEER)
    15471551    {
    15481552        struct peer_atom * atom = peer->atom;
    15491553        atom->flags2 |= MYFLAG_BANNED;
    15501554        peer->doPurge = 1;
    1551         tordbg( t, "banning peer %s", tr_atomAddrStr( atom ) );
    1552     }
    1553 }
    1554 
    1555 static void
    1556 gotBadPiece( Torrent * t, tr_piece_index_t pieceIndex )
     1555        tordbg (t, "banning peer %s", tr_atomAddrStr (atom));
     1556    }
     1557}
     1558
     1559static void
     1560gotBadPiece (Torrent * t, tr_piece_index_t pieceIndex)
    15571561{
    15581562    tr_torrent *   tor = t->tor;
    1559     const uint32_t byteCount = tr_torPieceCountBytes( tor, pieceIndex );
     1563    const uint32_t byteCount = tr_torPieceCountBytes (tor, pieceIndex);
    15601564
    15611565    tor->corruptCur += byteCount;
    1562     tor->downloadedCur -= MIN( tor->downloadedCur, byteCount );
    1563 
    1564     tr_announcerAddBytes( tor, TR_ANN_CORRUPT, byteCount );
    1565 }
    1566 
    1567 static void
    1568 peerSuggestedPiece( Torrent            * t UNUSED,
     1566    tor->downloadedCur -= MIN (tor->downloadedCur, byteCount);
     1567
     1568    tr_announcerAddBytes (tor, TR_ANN_CORRUPT, byteCount);
     1569}
     1570
     1571static void
     1572peerSuggestedPiece (Torrent            * t UNUSED,
    15691573                    tr_peer            * peer UNUSED,
    15701574                    tr_piece_index_t     pieceIndex UNUSED,
    1571                     int                  isFastAllowed UNUSED )
     1575                    int                  isFastAllowed UNUSED)
    15721576{
    15731577#if 0
    1574     assert( t );
    1575     assert( peer );
    1576     assert( peer->msgs );
     1578    assert (t);
     1579    assert (peer);
     1580    assert (peer->msgs);
    15771581
    15781582    /* is this a valid piece? */
    1579     if(  pieceIndex >= t->tor->info.pieceCount )
     1583    if (pieceIndex >= t->tor->info.pieceCount)
    15801584        return;
    15811585
    15821586    /* don't ask for it if we've already got it */
    1583     if( tr_cpPieceIsComplete( t->tor->completion, pieceIndex ) )
     1587    if (tr_cpPieceIsComplete (t->tor->completion, pieceIndex))
    15841588        return;
    15851589
    15861590    /* don't ask for it if they don't have it */
    1587     if( !tr_bitfieldHas( peer->have, pieceIndex ) )
     1591    if (!tr_bitfieldHas (peer->have, pieceIndex))
    15881592        return;
    15891593
    15901594    /* don't ask for it if we're choked and it's not fast */
    1591     if( !isFastAllowed && peer->clientIsChoked )
     1595    if (!isFastAllowed && peer->clientIsChoked)
    15921596        return;
    15931597
     
    15991603        const tr_torrent * tor = t->tor;
    16001604
    1601         tr_torGetPieceBlockRange( t->tor, pieceIndex, &first, &last );
    1602 
    1603         for( b=first; b<=last; ++b )
     1605        tr_torGetPieceBlockRange (t->tor, pieceIndex, &first, &last);
     1606
     1607        for (b=first; b<=last; ++b)
    16041608        {
    1605             if( !tr_cpBlockIsComplete( tor->completion, b ) )
     1609            if (!tr_cpBlockIsComplete (tor->completion, b))
    16061610            {
    1607                 const uint32_t offset = getBlockOffsetInPiece( tor, b );
    1608                 const uint32_t length = tr_torBlockCountBytes( tor, b );
    1609                 tr_peerMsgsAddRequest( peer->msgs, pieceIndex, offset, length );
    1610                 incrementPieceRequests( t, pieceIndex );
     1611                const uint32_t offset = getBlockOffsetInPiece (tor, b);
     1612                const uint32_t length = tr_torBlockCountBytes (tor, b);
     1613                tr_peerMsgsAddRequest (peer->msgs, pieceIndex, offset, length);
     1614                incrementPieceRequests (t, pieceIndex);
    16111615            }
    16121616        }
     
    16161620
    16171621static void
    1618 removeRequestFromTables( Torrent * t, tr_block_index_t block, const tr_peer * peer )
    1619 {
    1620     requestListRemove( t, block, peer );
    1621     pieceListRemoveRequest( t, block );
     1622removeRequestFromTables (Torrent * t, tr_block_index_t block, const tr_peer * peer)
     1623{
     1624    requestListRemove (t, block, peer);
     1625    pieceListRemoveRequest (t, block);
    16221626}
    16231627
     
    16251629   either way we need to remove all its requests */
    16261630static void
    1627 peerDeclinedAllRequests( Torrent * t, const tr_peer * peer )
     1631peerDeclinedAllRequests (Torrent * t, const tr_peer * peer)
    16281632{
    16291633    int i, n;
    1630     tr_block_index_t * blocks = tr_new( tr_block_index_t, t->requestCount );
    1631 
    1632     for( i=n=0; i<t->requestCount; ++i )
    1633         if( peer == t->requests[i].peer )
     1634    tr_block_index_t * blocks = tr_new (tr_block_index_t, t->requestCount);
     1635
     1636    for (i=n=0; i<t->requestCount; ++i)
     1637        if (peer == t->requests[i].peer)
    16341638            blocks[n++] = t->requests[i].block;
    16351639
    1636     for( i=0; i<n; ++i )
    1637         removeRequestFromTables( t, blocks[i], peer );
    1638 
    1639     tr_free( blocks );
    1640 }
    1641 
    1642 static void tr_peerMgrSetBlame( tr_torrent *, tr_piece_index_t, int );
    1643 
    1644 static void
    1645 peerCallbackFunc( tr_peer * peer, const tr_peer_event * e, void * vt )
     1640    for (i=0; i<n; ++i)
     1641        removeRequestFromTables (t, blocks[i], peer);
     1642
     1643    tr_free (blocks);
     1644}
     1645
     1646static void tr_peerMgrSetBlame (tr_torrent *, tr_piece_index_t, int);
     1647
     1648static void
     1649peerCallbackFunc (tr_peer * peer, const tr_peer_event * e, void * vt)
    16461650{
    16471651    Torrent * t = vt;
    16481652
    1649     torrentLock( t );
    1650 
    1651     assert( peer != NULL );
    1652 
    1653     switch( e->eventType )
     1653    torrentLock (t);
     1654
     1655    assert (peer != NULL);
     1656
     1657    switch (e->eventType)
    16541658    {
    16551659        case TR_PEER_PEER_GOT_DATA:
    16561660        {
    1657             const time_t now = tr_time( );
     1661            const time_t now = tr_time ();
    16581662            tr_torrent * tor = t->tor;
    16591663
    1660             if( e->wasPieceData )
     1664            if (e->wasPieceData)
    16611665            {
    16621666                tor->uploadedCur += e->length;
    1663                 tr_announcerAddBytes( tor, TR_ANN_UP, e->length );
    1664                 tr_torrentSetActivityDate( tor, now );
    1665                 tr_torrentSetDirty( tor );
     1667                tr_announcerAddBytes (tor, TR_ANN_UP, e->length);
     1668                tr_torrentSetActivityDate (tor, now);
     1669                tr_torrentSetDirty (tor);
    16661670            }
    16671671
    16681672            /* update the stats */
    1669             if( e->wasPieceData )
    1670                 tr_statsAddUploaded( tor->session, e->length );
     1673            if (e->wasPieceData)
     1674                tr_statsAddUploaded (tor->session, e->length);
    16711675
    16721676            /* update our atom */
    1673             if( peer->atom && e->wasPieceData )
     1677            if (peer->atom && e->wasPieceData)
    16741678                peer->atom->piece_data_time = now;
    16751679
     
    16781682
    16791683        case TR_PEER_CLIENT_GOT_HAVE:
    1680             if( replicationExists( t ) ) {
    1681                 tr_incrReplicationOfPiece( t, e->pieceIndex );
    1682                 assertReplicationCountIsExact( t );
     1684            if (replicationExists (t)) {
     1685                tr_incrReplicationOfPiece (t, e->pieceIndex);
     1686                assertReplicationCountIsExact (t);
    16831687            }
    16841688            break;
    16851689
    16861690        case TR_PEER_CLIENT_GOT_HAVE_ALL:
    1687             if( replicationExists( t ) ) {
    1688                 tr_incrReplication( t );
    1689                 assertReplicationCountIsExact( t );
     1691            if (replicationExists (t)) {
     1692                tr_incrReplication (t);
     1693                assertReplicationCountIsExact (t);
    16901694            }
    16911695            break;
     
    16961700
    16971701        case TR_PEER_CLIENT_GOT_BITFIELD:
    1698             assert( e->bitfield != NULL );
    1699             if( replicationExists( t ) ) {
    1700                 tr_incrReplicationFromBitfield( t, e->bitfield );
    1701                 assertReplicationCountIsExact( t );
     1702            assert (e->bitfield != NULL);
     1703            if (replicationExists (t)) {
     1704                tr_incrReplicationFromBitfield (t, e->bitfield);
     1705                assertReplicationCountIsExact (t);
    17021706            }
    17031707            break;
    17041708
    17051709        case TR_PEER_CLIENT_GOT_REJ: {
    1706             tr_block_index_t b = _tr_block( t->tor, e->pieceIndex, e->offset );
    1707             if( b < t->tor->blockCount )
    1708                 removeRequestFromTables( t, b, peer );
     1710            tr_block_index_t b = _tr_block (t->tor, e->pieceIndex, e->offset);
     1711            if (b < t->tor->blockCount)
     1712                removeRequestFromTables (t, b, peer);
    17091713            else
    1710                 tordbg( t, "Peer %s sent an out-of-range reject message",
    1711                            tr_atomAddrStr( peer->atom ) );
     1714                tordbg (t, "Peer %s sent an out-of-range reject message",
     1715                           tr_atomAddrStr (peer->atom));
    17121716            break;
    17131717        }
    17141718
    17151719        case TR_PEER_CLIENT_GOT_CHOKE:
    1716             peerDeclinedAllRequests( t, peer );
     1720            peerDeclinedAllRequests (t, peer);
    17171721            break;
    17181722
    17191723        case TR_PEER_CLIENT_GOT_PORT:
    1720             if( peer->atom )
     1724            if (peer->atom)
    17211725                peer->atom->port = e->port;
    17221726            break;
    17231727
    17241728        case TR_PEER_CLIENT_GOT_SUGGEST:
    1725             peerSuggestedPiece( t, peer, e->pieceIndex, false );
     1729            peerSuggestedPiece (t, peer, e->pieceIndex, false);
    17261730            break;
    17271731
    17281732        case TR_PEER_CLIENT_GOT_ALLOWED_FAST:
    1729             peerSuggestedPiece( t, peer, e->pieceIndex, true );
     1733            peerSuggestedPiece (t, peer, e->pieceIndex, true);
    17301734            break;
    17311735
    17321736        case TR_PEER_CLIENT_GOT_DATA:
    17331737        {
    1734             const time_t now = tr_time( );
     1738            const time_t now = tr_time ();
    17351739            tr_torrent * tor = t->tor;
    17361740
    1737             if( e->wasPieceData )
     1741            if (e->wasPieceData)
    17381742            {
    17391743                tor->downloadedCur += e->length;
    1740                 tr_torrentSetActivityDate( tor, now );
    1741                 tr_torrentSetDirty( tor );
     1744                tr_torrentSetActivityDate (tor, now);
     1745                tr_torrentSetDirty (tor);
    17421746            }
    17431747
    17441748            /* update the stats */
    1745             if( e->wasPieceData )
    1746                 tr_statsAddDownloaded( tor->session, e->length );
     1749            if (e->wasPieceData)
     1750                tr_statsAddDownloaded (tor->session, e->length);
    17471751
    17481752            /* update our atom */
    1749             if( peer->atom && e->wasPieceData )
     1753            if (peer->atom && e->wasPieceData)
    17501754                peer->atom->piece_data_time = now;
    17511755
     
    17561760        {
    17571761            tr_torrent * tor = t->tor;
    1758             tr_block_index_t block = _tr_block( tor, e->pieceIndex, e->offset );
     1762            tr_block_index_t block = _tr_block (tor, e->pieceIndex, e->offset);
    17591763            int i, peerCount;
    17601764            tr_peer ** peers;
    17611765            tr_ptrArray peerArr = TR_PTR_ARRAY_INIT;
    17621766
    1763             removeRequestFromTables( t, block, peer );
    1764             getBlockRequestPeers( t, block, &peerArr );
    1765             peers = (tr_peer **) tr_ptrArrayPeek( &peerArr, &peerCount );
     1767            removeRequestFromTables (t, block, peer);
     1768            getBlockRequestPeers (t, block, &peerArr);
     1769            peers = (tr_peer **) tr_ptrArrayPeek (&peerArr, &peerCount);
    17661770
    17671771            /* remove additional block requests and send cancel to peers */
    1768             for( i=0; i<peerCount; i++ ) {
     1772            for (i=0; i<peerCount; i++) {
    17691773                tr_peer * p = peers[i];
    1770                 assert( p != peer );
    1771                 if( p->msgs ) {
    1772                     tr_historyAdd( &p->cancelsSentToPeer, tr_time( ), 1 );
    1773                     tr_peerMsgsCancel( p->msgs, block );
     1774                assert (p != peer);
     1775                if (p->msgs) {
     1776                    tr_historyAdd (&p->cancelsSentToPeer, tr_time (), 1);
     1777                    tr_peerMsgsCancel (p->msgs, block);
    17741778                }
    1775                 removeRequestFromTables( t, block, p );
     1779                removeRequestFromTables (t, block, p);
    17761780            }
    17771781
    1778             tr_ptrArrayDestruct( &peerArr, false );
    1779 
    1780             tr_historyAdd( &peer->blocksSentToClient, tr_time( ), 1 );
    1781 
    1782             if( tr_cpBlockIsComplete( &tor->completion, block ) )
     1782            tr_ptrArrayDestruct (&peerArr, false);
     1783
     1784            tr_historyAdd (&peer->blocksSentToClient, tr_time (), 1);
     1785
     1786            if (tr_cpBlockIsComplete (&tor->completion, block))
    17831787            {
    17841788                /* we already have this block... */
    1785                 const uint32_t n = tr_torBlockCountBytes( tor, block );
    1786                 tor->downloadedCur -= MIN( tor->downloadedCur, n );
    1787                 tordbg( t, "we have this block already..." );
     1789                const uint32_t n = tr_torBlockCountBytes (tor, block);
     1790                tor->downloadedCur -= MIN (tor->downloadedCur, n);
     1791                tordbg (t, "we have this block already...");
    17881792            }
    17891793            else
    17901794            {
    1791                 tr_cpBlockAdd( &tor->completion, block );
    1792                 pieceListResortPiece( t, pieceListLookup( t, e->pieceIndex ) );
    1793                 tr_torrentSetDirty( tor );
    1794 
    1795                 if( tr_cpPieceIsComplete( &tor->completion, e->pieceIndex ) )
     1795                tr_cpBlockAdd (&tor->completion, block);
     1796                pieceListResortPiece (t, pieceListLookup (t, e->pieceIndex));
     1797                tr_torrentSetDirty (tor);
     1798
     1799                if (tr_cpPieceIsComplete (&tor->completion, e->pieceIndex))
    17961800                {
    17971801                    const tr_piece_index_t p = e->pieceIndex;
    1798                     const bool ok = tr_torrentCheckPiece( tor, p );
    1799 
    1800                     tordbg( t, "[LAZY] checked just-completed piece %zu", (size_t)p );
    1801 
    1802                     if( !ok )
     1802                    const bool ok = tr_torrentCheckPiece (tor, p);
     1803
     1804                    tordbg (t, "[LAZY] checked just-completed piece %zu", (size_t)p);
     1805
     1806                    if (!ok)
    18031807                    {
    1804                         tr_torerr( tor, _( "Piece %lu, which was just downloaded, failed its checksum test" ),
    1805                                    (unsigned long)p );
     1808                        tr_torerr (tor, _ ("Piece %lu, which was just downloaded, failed its checksum test"),
     1809                                 (unsigned long)p);
    18061810                    }
    18071811
    1808                     tr_peerMgrSetBlame( tor, p, ok );
    1809 
    1810                     if( !ok )
     1812                    tr_peerMgrSetBlame (tor, p, ok);
     1813
     1814                    if (!ok)
    18111815                    {
    1812                         gotBadPiece( t, p );
     1816                        gotBadPiece (t, p);
    18131817                    }
    18141818                    else
     
    18251829                         * to manage the swarms, not the web server and does not fit
    18261830                         * into the jurisdiction of the tracker." */
    1827                         if( peer->msgs != NULL ) {
    1828                             const uint32_t n = tr_torPieceCountBytes( tor, p );
    1829                             tr_announcerAddBytes( tor, TR_ANN_DOWN, n );
     1831                        if (peer->msgs != NULL) {
     1832                            const uint32_t n = tr_torPieceCountBytes (tor, p);
     1833                            tr_announcerAddBytes (tor, TR_ANN_DOWN, n);
    18301834                        }
    18311835
    1832                         peerCount = tr_ptrArraySize( &t->peers );
    1833                         peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
    1834                         for( i=0; i<peerCount; ++i )
    1835                             tr_peerMsgsHave( peers[i]->msgs, p );
    1836 
    1837                         for( fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex ) {
     1836                        peerCount = tr_ptrArraySize (&t->peers);
     1837                        peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
     1838                        for (i=0; i<peerCount; ++i)
     1839                            tr_peerMsgsHave (peers[i]->msgs, p);
     1840
     1841                        for (fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex) {
    18381842                            const tr_file * file = &tor->info.files[fileIndex];
    1839                             if( ( file->firstPiece <= p ) && ( p <= file->lastPiece ) ) {
    1840                                 if( tr_cpFileIsComplete( &tor->completion, fileIndex ) ) {
    1841                                     tr_cacheFlushFile( tor->session->cache, tor, fileIndex );
    1842                                     tr_torrentFileCompleted( tor, fileIndex );
     1843                            if ((file->firstPiece <= p) && (p <= file->lastPiece)) {
     1844                                if (tr_cpFileIsComplete (&tor->completion, fileIndex)) {
     1845                                    tr_cacheFlushFile (tor->session->cache, tor, fileIndex);
     1846                                    tr_torrentFileCompleted (tor, fileIndex);
    18431847                                }
    18441848                            }
    18451849                        }
    18461850
    1847                         pieceListRemovePiece( t, p );
     1851                        pieceListRemovePiece (t, p);
    18481852                    }
    18491853                }
     
    18551859
    18561860        case TR_PEER_ERROR:
    1857             if( ( e->err == ERANGE ) || ( e->err == EMSGSIZE ) || ( e->err == ENOTCONN ) )
     1861            if ((e->err == ERANGE) || (e->err == EMSGSIZE) || (e->err == ENOTCONN))
    18581862            {
    18591863                /* some protocol error from the peer */
    18601864                peer->doPurge = 1;
    1861                 tordbg( t, "setting %s doPurge flag because we got an ERANGE, EMSGSIZE, or ENOTCONN error",
    1862                         tr_atomAddrStr( peer->atom ) );
     1865                tordbg (t, "setting %s doPurge flag because we got an ERANGE, EMSGSIZE, or ENOTCONN error",
     1866                        tr_atomAddrStr (peer->atom));
    18631867            }
    18641868            else
    18651869            {
    1866                 tordbg( t, "unhandled error: %s", tr_strerror( e->err ) );
     1870                tordbg (t, "unhandled error: %s", tr_strerror (e->err));
    18671871            }
    18681872            break;
    18691873
    18701874        default:
    1871             assert( 0 );
    1872     }
    1873 
    1874     torrentUnlock( t );
     1875            assert (0);
     1876    }
     1877
     1878    torrentUnlock (t);
    18751879}
    18761880
    18771881static int
    1878 getDefaultShelfLife( uint8_t from )
     1882getDefaultShelfLife (uint8_t from)
    18791883{
    18801884    /* in general, peers obtained from firsthand contact
    18811885     * are better than those from secondhand, etc etc */
    1882     switch( from )
     1886    switch (from)
    18831887    {
    18841888        case TR_PEER_FROM_INCOMING : return 60 * 60 * 6;
     
    18941898
    18951899static void
    1896 ensureAtomExists( Torrent           * t,
     1900ensureAtomExists (Torrent           * t,
    18971901                  const tr_address  * addr,
    18981902                  const tr_port       port,
    18991903                  const uint8_t       flags,
    19001904                  const int8_t        seedProbability,
    1901                   const uint8_t       from )
     1905                  const uint8_t       from)
    19021906{
    19031907    struct peer_atom * a;
    19041908
    1905     assert( tr_address_is_valid( addr ) );
    1906     assert( from < TR_PEER_FROM__MAX );
    1907 
    1908     a = getExistingAtom( t, addr );
    1909 
    1910     if( a == NULL )
    1911     {
    1912         const int jitter = tr_cryptoWeakRandInt( 60*10 );
    1913         a = tr_new0( struct peer_atom, 1 );
     1909    assert (tr_address_is_valid (addr));
     1910    assert (from < TR_PEER_FROM__MAX);
     1911
     1912    a = getExistingAtom (t, addr);
     1913
     1914    if (a == NULL)
     1915    {
     1916        const int jitter = tr_cryptoWeakRandInt (60*10);
     1917        a = tr_new0 (struct peer_atom, 1);
    19141918        a->addr = *addr;
    19151919        a->port = port;
     
    19171921        a->fromFirst = from;
    19181922        a->fromBest = from;
    1919         a->shelf_date = tr_time( ) + getDefaultShelfLife( from ) + jitter;
     1923        a->shelf_date = tr_time () + getDefaultShelfLife (from) + jitter;
    19201924        a->blocklisted = -1;
    1921         atomSetSeedProbability( a, seedProbability );
    1922         tr_ptrArrayInsertSorted( &t->pool, a, compareAtomsByAddress );
    1923 
    1924         tordbg( t, "got a new atom: %s", tr_atomAddrStr( a ) );
     1925        atomSetSeedProbability (a, seedProbability);
     1926        tr_ptrArrayInsertSorted (&t->pool, a, compareAtomsByAddress);
     1927
     1928        tordbg (t, "got a new atom: %s", tr_atomAddrStr (a));
    19251929    }
    19261930    else
    19271931    {
    1928         if( from < a->fromBest )
     1932        if (from < a->fromBest)
    19291933            a->fromBest = from;
    19301934
    1931         if( a->seedProbability == -1 )
    1932             atomSetSeedProbability( a, seedProbability );
     1935        if (a->seedProbability == -1)
     1936            atomSetSeedProbability (a, seedProbability);
    19331937
    19341938        a->flags |= flags;
     
    19371941
    19381942static int
    1939 getMaxPeerCount( const tr_torrent * tor )
     1943getMaxPeerCount (const tr_torrent * tor)
    19401944{
    19411945    return tor->maxConnectedPeers;
     
    19431947
    19441948static int
    1945 getPeerCount( const Torrent * t )
    1946 {
    1947     return tr_ptrArraySize( &t->peers );/* + tr_ptrArraySize( &t->outgoingHandshakes ); */
     1949getPeerCount (const Torrent * t)
     1950{
     1951    return tr_ptrArraySize (&t->peers);/* + tr_ptrArraySize (&t->outgoingHandshakes); */
    19481952}
    19491953
    19501954/* FIXME: this is kind of a mess. */
    19511955static bool
    1952 myHandshakeDoneCB( tr_handshake  * handshake,
     1956myHandshakeDoneCB (tr_handshake  * handshake,
    19531957                   tr_peerIo     * io,
    19541958                   bool            readAnythingFromPeer,
    19551959                   bool            isConnected,
    19561960                   const uint8_t * peer_id,
    1957                    void          * vmanager )
     1961                   void          * vmanager)
    19581962{
    19591963    bool               ok = isConnected;
     
    19651969    tr_handshake     * ours;
    19661970
    1967     assert( io );
    1968     assert( tr_isBool( ok ) );
    1969 
    1970     t = tr_peerIoHasTorrentHash( io )
    1971         ? getExistingTorrent( manager, tr_peerIoGetTorrentHash( io ) )
     1971    assert (io);
     1972    assert (tr_isBool (ok));
     1973
     1974    t = tr_peerIoHasTorrentHash (io)
     1975        ? getExistingTorrent (manager, tr_peerIoGetTorrentHash (io))
    19721976        : NULL;
    19731977
    1974     if( tr_peerIoIsIncoming ( io ) )
    1975         ours = tr_ptrArrayRemoveSorted( &manager->incomingHandshakes,
    1976                                         handshake, handshakeCompare );
    1977     else if( t )
    1978         ours = tr_ptrArrayRemoveSorted( &t->outgoingHandshakes,
    1979                                         handshake, handshakeCompare );
     1978    if (tr_peerIoIsIncoming (io))
     1979        ours = tr_ptrArrayRemoveSorted (&manager->incomingHandshakes,
     1980                                        handshake, handshakeCompare);
     1981    else if (t)
     1982        ours = tr_ptrArrayRemoveSorted (&t->outgoingHandshakes,
     1983                                        handshake, handshakeCompare);
    19801984    else
    19811985        ours = handshake;
    19821986
    1983     assert( ours );
    1984     assert( ours == handshake );
    1985 
    1986     if( t )
    1987         torrentLock( t );
    1988 
    1989     addr = tr_peerIoGetAddress( io, &port );
    1990 
    1991     if( !ok || !t || !t->isRunning )
    1992     {
    1993         if( t )
     1987    assert (ours);
     1988    assert (ours == handshake);
     1989
     1990    if (t)
     1991        torrentLock (t);
     1992
     1993    addr = tr_peerIoGetAddress (io, &port);
     1994
     1995    if (!ok || !t || !t->isRunning)
     1996    {
     1997        if (t)
    19941998        {
    1995             struct peer_atom * atom = getExistingAtom( t, addr );
    1996             if( atom )
     1999            struct peer_atom * atom = getExistingAtom (t, addr);
     2000            if (atom)
    19972001            {
    19982002                ++atom->numFails;
    19992003
    2000                 if( !readAnythingFromPeer )
     2004                if (!readAnythingFromPeer)
    20012005                {
    2002                     tordbg( t, "marking peer %s as unreachable... numFails is %d", tr_atomAddrStr( atom ), (int)atom->numFails );
     2006                    tordbg (t, "marking peer %s as unreachable... numFails is %d", tr_atomAddrStr (atom), (int)atom->numFails);
    20032007                    atom->flags2 |= MYFLAG_UNREACHABLE;
    20042008                }
     
    20102014        struct peer_atom * atom;
    20112015
    2012         ensureAtomExists( t, addr, port, 0, -1, TR_PEER_FROM_INCOMING );
    2013         atom = getExistingAtom( t, addr );
    2014         atom->time = tr_time( );
     2016        ensureAtomExists (t, addr, port, 0, -1, TR_PEER_FROM_INCOMING);
     2017        atom = getExistingAtom (t, addr);
     2018        atom->time = tr_time ();
    20152019        atom->piece_data_time = 0;
    2016         atom->lastConnectionAt = tr_time( );
    2017 
    2018         if( !tr_peerIoIsIncoming( io ) )
     2020        atom->lastConnectionAt = tr_time ();
     2021
     2022        if (!tr_peerIoIsIncoming (io))
    20192023        {
    20202024            atom->flags |= ADDED_F_CONNECTABLE;
     
    20242028        /* In principle, this flag specifies whether the peer groks uTP,
    20252029           not whether it's currently connected over uTP. */
    2026         if( io->utp_socket )
     2030        if (io->utp_socket)
    20272031            atom->flags |= ADDED_F_UTP_FLAGS;
    20282032
    2029         if( atom->flags2 & MYFLAG_BANNED )
     2033        if (atom->flags2 & MYFLAG_BANNED)
    20302034        {
    2031             tordbg( t, "banned peer %s tried to reconnect",
    2032                     tr_atomAddrStr( atom ) );
     2035            tordbg (t, "banned peer %s tried to reconnect",
     2036                    tr_atomAddrStr (atom));
    20332037        }
    2034         else if( tr_peerIoIsIncoming( io )
    2035                && ( getPeerCount( t ) >= getMaxPeerCount( t->tor ) ) )
     2038        else if (tr_peerIoIsIncoming (io)
     2039               && (getPeerCount (t) >= getMaxPeerCount (t->tor)))
    20362040
    20372041        {
     
    20412045            tr_peer * peer = atom->peer;
    20422046
    2043             if( peer ) /* we already have this peer */
     2047            if (peer) /* we already have this peer */
    20442048            {
    20452049            }
    20462050            else
    20472051            {
    2048                 peer = getPeer( t, atom );
    2049                 tr_free( peer->client );
    2050 
    2051                 if( !peer_id )
     2052                peer = getPeer (t, atom);
     2053                tr_free (peer->client);
     2054
     2055                if (!peer_id)
    20522056                    peer->client = NULL;
    20532057                else {
    20542058                    char client[128];
    2055                     tr_clientForId( client, sizeof( client ), peer_id );
    2056                     peer->client = tr_strdup( client );
     2059                    tr_clientForId (client, sizeof (client), peer_id);
     2060                    peer->client = tr_strdup (client);
    20572061                }
    20582062
    2059                 peer->io = tr_handshakeStealIO( handshake ); /* this steals its refcount too, which is
    2060                                                                 balanced by our unref in peerDelete()  */
    2061                 tr_peerIoSetParent( peer->io, &t->tor->bandwidth );
    2062                 tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t );
     2063                peer->io = tr_handshakeStealIO (handshake); /* this steals its refcount too, which is
     2064                                                                balanced by our unref in peerDelete ()  */
     2065                tr_peerIoSetParent (peer->io, &t->tor->bandwidth);
     2066                tr_peerMsgsNew (t->tor, peer, peerCallbackFunc, t);
    20632067
    20642068                success = true;
     
    20672071    }
    20682072
    2069     if( t )
    2070         torrentUnlock( t );
     2073    if (t)
     2074        torrentUnlock (t);
    20712075
    20722076    return success;
     
    20742078
    20752079void
    2076 tr_peerMgrAddIncoming( tr_peerMgr * manager,
     2080tr_peerMgrAddIncoming (tr_peerMgr * manager,
    20772081                       tr_address * addr,
    20782082                       tr_port      port,
    20792083                       int          socket,
    2080                        struct UTPSocket * utp_socket )
     2084                       struct UTPSocket * utp_socket)
    20812085{
    20822086    tr_session * session;
    20832087
    2084     managerLock( manager );
    2085 
    2086     assert( tr_isSession( manager->session ) );
     2088    managerLock (manager);
     2089
     2090    assert (tr_isSession (manager->session));
    20872091    session = manager->session;
    20882092
    2089     if( tr_sessionIsAddressBlocked( session, addr ) )
    2090     {
    2091         tr_dbg( "Banned IP address \"%s\" tried to connect to us", tr_address_to_string( addr ) );
    2092         if(socket >= 0)
    2093             tr_netClose( session, socket );
     2093    if (tr_sessionIsAddressBlocked (session, addr))
     2094    {
     2095        tr_dbg ("Banned IP address \"%s\" tried to connect to us", tr_address_to_string (addr));
     2096        if (socket >= 0)
     2097            tr_netClose (session, socket);
    20942098        else
    2095             UTP_Close( utp_socket );
    2096     }
    2097     else if( getExistingHandshake( &manager->incomingHandshakes, addr ) )
    2098     {
    2099         if(socket >= 0)
    2100             tr_netClose( session, socket );
     2099            UTP_Close (utp_socket);
     2100    }
     2101    else if (getExistingHandshake (&manager->incomingHandshakes, addr))
     2102    {
     2103        if (socket >= 0)
     2104            tr_netClose (session, socket);
    21012105        else
    2102             UTP_Close( utp_socket );
     2106            UTP_Close (utp_socket);
    21032107    }
    21042108    else /* we don't have a connection to them yet... */
     
    21072111        tr_handshake * handshake;
    21082112
    2109         io = tr_peerIoNewIncoming( session, &session->bandwidth, addr, port, socket, utp_socket );
    2110 
    2111         handshake = tr_handshakeNew( io,
     2113        io = tr_peerIoNewIncoming (session, &session->bandwidth, addr, port, socket, utp_socket);
     2114
     2115        handshake = tr_handshakeNew (io,
    21122116                                     session->encryptionMode,
    21132117                                     myHandshakeDoneCB,
    2114                                      manager );
    2115 
    2116         tr_peerIoUnref( io ); /* balanced by the implicit ref in tr_peerIoNewIncoming() */
    2117 
    2118         tr_ptrArrayInsertSorted( &manager->incomingHandshakes, handshake,
    2119                                  handshakeCompare );
    2120     }
    2121 
    2122     managerUnlock( manager );
     2118                                     manager);
     2119
     2120        tr_peerIoUnref (io); /* balanced by the implicit ref in tr_peerIoNewIncoming () */
     2121
     2122        tr_ptrArrayInsertSorted (&manager->incomingHandshakes, handshake,
     2123                                 handshakeCompare);
     2124    }
     2125
     2126    managerUnlock (manager);
    21232127}
    21242128
    21252129void
    2126 tr_peerMgrAddPex( tr_torrent * tor, uint8_t from,
    2127                   const tr_pex * pex, int8_t seedProbability )
    2128 {
    2129     if( tr_isPex( pex ) ) /* safeguard against corrupt data */
     2130tr_peerMgrAddPex (tr_torrent * tor, uint8_t from,
     2131                  const tr_pex * pex, int8_t seedProbability)
     2132{
     2133    if (tr_isPex (pex)) /* safeguard against corrupt data */
    21302134    {
    21312135        Torrent * t = tor->torrentPeers;
    2132         managerLock( t->manager );
    2133 
    2134         if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
    2135             if( tr_address_is_valid_for_peers( &pex->addr, pex->port ) )
    2136                 ensureAtomExists( t, &pex->addr, pex->port, pex->flags, seedProbability, from );
    2137 
    2138         managerUnlock( t->manager );
     2136        managerLock (t->manager);
     2137
     2138        if (!tr_sessionIsAddressBlocked (t->manager->session, &pex->addr))
     2139            if (tr_address_is_valid_for_peers (&pex->addr, pex->port))
     2140                ensureAtomExists (t, &pex->addr, pex->port, pex->flags, seedProbability, from);
     2141
     2142        managerUnlock (t->manager);
    21392143    }
    21402144}
    21412145
    21422146void
    2143 tr_peerMgrMarkAllAsSeeds( tr_torrent * tor )
     2147tr_peerMgrMarkAllAsSeeds (tr_torrent * tor)
    21442148{
    21452149    Torrent * t = tor->torrentPeers;
    2146     const int n = tr_ptrArraySize( &t->pool );
    2147     struct peer_atom ** it = (struct peer_atom**) tr_ptrArrayBase( &t->pool );
     2150    const int n = tr_ptrArraySize (&t->pool);
     2151    struct peer_atom ** it = (struct peer_atom**) tr_ptrArrayBase (&t->pool);
    21482152    struct peer_atom ** end = it + n;
    21492153
    2150     while( it != end )
    2151         atomSetSeed( t, *it++ );
     2154    while (it != end)
     2155        atomSetSeed (t, *it++);
    21522156}
    21532157
    21542158tr_pex *
    2155 tr_peerMgrCompactToPex( const void *    compact,
     2159tr_peerMgrCompactToPex (const void *    compact,
    21562160                        size_t          compactLen,
    21572161                        const uint8_t * added_f,
    21582162                        size_t          added_f_len,
    2159                         size_t *        pexCount )
     2163                        size_t *        pexCount)
    21602164{
    21612165    size_t          i;
    21622166    size_t          n = compactLen / 6;
    21632167    const uint8_t * walk = compact;
    2164     tr_pex *        pex = tr_new0( tr_pex, n );
    2165 
    2166     for( i = 0; i < n; ++i )
     2168    tr_pex *        pex = tr_new0 (tr_pex, n);
     2169
     2170    for (i = 0; i < n; ++i)
    21672171    {
    21682172        pex[i].addr.type = TR_AF_INET;
    2169         memcpy( &pex[i].addr.addr, walk, 4 ); walk += 4;
    2170         memcpy( &pex[i].port, walk, 2 ); walk += 2;
    2171         if( added_f && ( n == added_f_len ) )
     2173        memcpy (&pex[i].addr.addr, walk, 4); walk += 4;
     2174        memcpy (&pex[i].port, walk, 2); walk += 2;
     2175        if (added_f && (n == added_f_len))
    21722176            pex[i].flags = added_f[i];
    21732177    }
     
    21782182
    21792183tr_pex *
    2180 tr_peerMgrCompact6ToPex( const void    * compact,
     2184tr_peerMgrCompact6ToPex (const void    * compact,
    21812185                         size_t          compactLen,
    21822186                         const uint8_t * added_f,
    21832187                         size_t          added_f_len,
    2184                          size_t        * pexCount )
     2188                         size_t        * pexCount)
    21852189{
    21862190    size_t          i;
    21872191    size_t          n = compactLen / 18;
    21882192    const uint8_t * walk = compact;
    2189     tr_pex *        pex = tr_new0( tr_pex, n );
    2190 
    2191     for( i = 0; i < n; ++i )
     2193    tr_pex *        pex = tr_new0 (tr_pex, n);
     2194
     2195    for (i = 0; i < n; ++i)
    21922196    {
    21932197        pex[i].addr.type = TR_AF_INET6;
    2194         memcpy( &pex[i].addr.addr.addr6.s6_addr, walk, 16 ); walk += 16;
    2195         memcpy( &pex[i].port, walk, 2 ); walk += 2;
    2196         if( added_f && ( n == added_f_len ) )
     2198        memcpy (&pex[i].addr.addr.addr6.s6_addr, walk, 16); walk += 16;
     2199        memcpy (&pex[i].port, walk, 2); walk += 2;
     2200        if (added_f && (n == added_f_len))
    21972201            pex[i].flags = added_f[i];
    21982202    }
     
    22032207
    22042208tr_pex *
    2205 tr_peerMgrArrayToPex( const void * array,
     2209tr_peerMgrArrayToPex (const void * array,
    22062210                      size_t       arrayLen,
    2207                       size_t      * pexCount )
     2211                      size_t      * pexCount)
    22082212{
    22092213    size_t          i;
    2210     size_t          n = arrayLen / ( sizeof( tr_address ) + 2 );
    2211     /*size_t          n = arrayLen / sizeof( tr_peerArrayElement );*/
     2214    size_t          n = arrayLen / (sizeof (tr_address) + 2);
     2215    /*size_t          n = arrayLen / sizeof (tr_peerArrayElement);*/
    22122216    const uint8_t * walk = array;
    2213     tr_pex        * pex = tr_new0( tr_pex, n );
    2214 
    2215     for( i = 0 ; i < n ; i++ ) {
    2216         memcpy( &pex[i].addr, walk, sizeof( tr_address ) );
    2217         memcpy( &pex[i].port, walk + sizeof( tr_address ), 2 );
     2217    tr_pex        * pex = tr_new0 (tr_pex, n);
     2218
     2219    for (i = 0 ; i < n ; i++) {
     2220        memcpy (&pex[i].addr, walk, sizeof (tr_address));
     2221        memcpy (&pex[i].port, walk + sizeof (tr_address), 2);
    22182222        pex[i].flags = 0x00;
    2219         walk += sizeof( tr_address ) + 2;
     2223        walk += sizeof (tr_address) + 2;
    22202224    }
    22212225
     
    22292233
    22302234static void
    2231 tr_peerMgrSetBlame( tr_torrent     * tor,
     2235tr_peerMgrSetBlame (tr_torrent     * tor,
    22322236                    tr_piece_index_t pieceIndex,
    2233                     int              success )
    2234 {
    2235     if( !success )
     2237                    int              success)
     2238{
     2239    if (!success)
    22362240    {
    22372241        int        peerCount, i;
     
    22392243        tr_peer ** peers;
    22402244
    2241         assert( torrentIsLocked( t ) );
    2242 
    2243         peers = (tr_peer **) tr_ptrArrayPeek( &t->peers, &peerCount );
    2244         for( i = 0; i < peerCount; ++i )
     2245        assert (torrentIsLocked (t));
     2246
     2247        peers = (tr_peer **) tr_ptrArrayPeek (&t->peers, &peerCount);
     2248        for (i = 0; i < peerCount; ++i)
    22452249        {
    22462250            tr_peer * peer = peers[i];
    2247             if( tr_bitfieldHas( &peer->blame, pieceIndex ) )
     2251            if (tr_bitfieldHas (&peer->blame, pieceIndex))
    22482252            {
    2249                 tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
    2250                         tr_atomAddrStr( peer->atom ),
    2251                         pieceIndex, (int)peer->strikes + 1 );
    2252                 addStrike( t, peer );
     2253                tordbg (t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
     2254                        tr_atomAddrStr (peer->atom),
     2255                        pieceIndex, (int)peer->strikes + 1);
     2256                addStrike (t, peer);
    22532257            }
    22542258        }
     
    22572261
    22582262int
    2259 tr_pexCompare( const void * va, const void * vb )
     2263tr_pexCompare (const void * va, const void * vb)
    22602264{
    22612265    const tr_pex * a = va;
     
    22632267    int i;
    22642268
    2265     assert( tr_isPex( a ) );
    2266     assert( tr_isPex( b ) );
    2267 
    2268     if(( i = tr_address_compare( &a->addr, &b->addr )))
     2269    assert (tr_isPex (a));
     2270    assert (tr_isPex (b));
     2271
     2272    if ((i = tr_address_compare (&a->addr, &b->addr)))
    22692273        return i;
    22702274
    2271     if( a->port != b->port )
     2275    if (a->port != b->port)
    22722276        return a->port < b->port ? -1 : 1;
    22732277
     
    22772281/* better goes first */
    22782282static int
    2279 compareAtomsByUsefulness( const void * va, const void *vb )
     2283compareAtomsByUsefulness (const void * va, const void *vb)
    22802284{
    22812285    const struct peer_atom * a = * (const struct peer_atom**) va;
    22822286    const struct peer_atom * b = * (const struct peer_atom**) vb;
    22832287
    2284     assert( tr_isAtom( a ) );
    2285     assert( tr_isAtom( b ) );
    2286 
    2287     if( a->piece_data_time != b->piece_data_time )
     2288    assert (tr_isAtom (a));
     2289    assert (tr_isAtom (b));
     2290
     2291    if (a->piece_data_time != b->piece_data_time)
    22882292        return a->piece_data_time > b->piece_data_time ? -1 : 1;
    2289     if( a->fromBest != b->fromBest )
     2293    if (a->fromBest != b->fromBest)
    22902294        return a->fromBest < b->fromBest ? -1 : 1;
    2291     if( a->numFails != b->numFails )
     2295    if (a->numFails != b->numFails)
    22922296        return a->numFails < b->numFails ? -1 : 1;
    22932297
     
    22962300
    22972301static bool
    2298 isAtomInteresting( const tr_torrent * tor, struct peer_atom * atom )
    2299 {
    2300     if( tr_torrentIsSeed( tor ) && atomIsSeed( atom ) )
     2302isAtomInteresting (const tr_torrent * tor, struct peer_atom * atom)
     2303{
     2304    if (tr_torrentIsSeed (tor) && atomIsSeed (atom))
    23012305        return false;
    23022306
    2303     if( peerIsInUse( tor->torrentPeers, atom ) )
     2307    if (peerIsInUse (tor->torrentPeers, atom))
    23042308        return true;
    23052309
    2306     if( isAtomBlocklisted( tor->session, atom ) )
     2310    if (isAtomBlocklisted (tor->session, atom))
    23072311        return false;
    23082312
    2309     if( atom->flags2 & MYFLAG_BANNED )
     2313    if (atom->flags2 & MYFLAG_BANNED)
    23102314        return false;
    23112315
     
    23142318
    23152319int
    2316 tr_peerMgrGetPeers( tr_torrent   * tor,
     2320tr_peerMgrGetPeers (tr_torrent   * tor,
    23172321                    tr_pex      ** setme_pex,
    23182322                    uint8_t        af,
    23192323                    uint8_t        list_mode,
    2320                     int            maxCount )
     2324                    int            maxCount)
    23212325{
    23222326    int i;
     
    23292333    tr_pex * walk;
    23302334
    2331     assert( tr_isTorrent( tor ) );
    2332     assert( setme_pex != NULL );
    2333     assert( af==TR_AF_INET || af==TR_AF_INET6 );
    2334     assert( list_mode==TR_PEERS_CONNECTED || list_mode==TR_PEERS_INTERESTING );
    2335 
    2336     managerLock( t->manager );
     2335    assert (tr_isTorrent (tor));
     2336    assert (setme_pex != NULL);
     2337    assert (af==TR_AF_INET || af==TR_AF_INET6);
     2338    assert (list_mode==TR_PEERS_CONNECTED || list_mode==TR_PEERS_INTERESTING);
     2339
     2340    managerLock (t->manager);
    23372341
    23382342    /**
     
    23402344    **/
    23412345
    2342     if( list_mode == TR_PEERS_CONNECTED ) /* connected peers only */
     2346    if (list_mode == TR_PEERS_CONNECTED) /* connected peers only */
    23432347    {
    23442348        int i;
    2345         const tr_peer ** peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
    2346         atomCount = tr_ptrArraySize( &t->peers );
    2347         atoms = tr_new( struct peer_atom *, atomCount );
    2348         for( i=0; i<atomCount; ++i )
     2349        const tr_peer ** peers = (const tr_peer **) tr_ptrArrayBase (&t->peers);
     2350        atomCount = tr_ptrArraySize (&t->peers);
     2351        atoms = tr_new (struct peer_atom *, atomCount);
     2352        for (i=0; i<atomCount; ++i)
    23492353            atoms[i] = peers[i]->atom;
    23502354    }
     
    23522356    {
    23532357        int i;
    2354         struct peer_atom ** atomBase = (struct peer_atom**) tr_ptrArrayBase( &t->pool );
    2355         n = tr_ptrArraySize( &t->pool );
    2356         atoms = tr_new( struct peer_atom *, n );
    2357         for( i=0; i<n; ++i )
    2358             if( isAtomInteresting( tor, atomBase[i] ) )
     2358        struct peer_atom ** atomBase = (struct peer_atom**) tr_ptrArrayBase (&t->pool);
     2359        n = tr_ptrArraySize (&t->pool);
     2360        atoms = tr_new (struct peer_atom *, n);
     2361        for (i=0; i<n; ++i)
     2362            if (isAtomInteresting (tor, atomBase[i]))
    23592363                atoms[atomCount++] = atomBase[i];
    23602364    }
    23612365
    2362     qsort( atoms, atomCount, sizeof( struct peer_atom * ), compareAtomsByUsefulness );
     2366    qsort (atoms, atomCount, sizeof (struct peer_atom *), compareAtomsByUsefulness);
    23632367
    23642368    /**
     
    23662370    **/
    23672371
    2368     n = MIN( atomCount, maxCount );
    2369     pex = walk = tr_new0( tr_pex, n );
    2370 
    2371     for( i=0; i<atomCount && count<n; ++i )
     2372    n = MIN (atomCount, maxCount);
     2373    pex = walk = tr_new0 (tr_pex, n);
     2374
     2375    for (i=0; i<atomCount && count<n; ++i)
    23722376    {
    23732377        const struct peer_atom * atom = atoms[i];
    2374         if( atom->addr.type == af )
     2378        if (atom->addr.type == af)
    23752379        {
    2376             assert( tr_address_is_valid( &atom->addr ) );
     2380            assert (tr_address_is_valid (&atom->addr));
    23772381            walk->addr = atom->addr;
    23782382            walk->port = atom->port;
     
    23832387    }
    23842388
    2385     qsort( pex, count, sizeof( tr_pex ), tr_pexCompare );
    2386 
    2387     assert( ( walk - pex ) == count );
     2389    qsort (pex, count, sizeof (tr_pex), tr_pexCompare);
     2390
     2391    assert ((walk - pex) == count);
    23882392    *setme_pex = pex;
    23892393
    23902394    /* cleanup */
    2391     tr_free( atoms );
    2392     managerUnlock( t->manager );
     2395    tr_free (atoms);
     2396    managerUnlock (t->manager);
    23932397    return count;
    23942398}
    23952399
    2396 static void atomPulse      ( int, short, void * );
    2397 static void bandwidthPulse ( int, short, void * );
    2398 static void rechokePulse   ( int, short, void * );
    2399 static void reconnectPulse ( int, short, void * );
     2400static void atomPulse    (int, short, void *);
     2401static void bandwidthPulse (int, short, void *);
     2402static void rechokePulse (int, short, void *);
     2403static void reconnectPulse (int, short, void *);
    24002404
    24012405static struct event *
    2402 createTimer( tr_session * session, int msec, void (*callback)(int, short, void *), void * cbdata )
    2403 {
    2404     struct event * timer = evtimer_new( session->event_base, callback, cbdata );
    2405     tr_timerAddMsec( timer, msec );
     2406createTimer (tr_session * session, int msec, void (*callback)(int, short, void *), void * cbdata)
     2407{
     2408    struct event * timer = evtimer_new (session->event_base, callback, cbdata);
     2409    tr_timerAddMsec (timer, msec);
    24062410    return timer;
    24072411}
    24082412
    24092413static void
    2410 ensureMgrTimersExist( struct tr_peerMgr * m )
    2411 {
    2412     if( m->atomTimer == NULL )
    2413         m->atomTimer = createTimer( m->session, ATOM_PERIOD_MSEC, atomPulse, m );
    2414 
    2415     if( m->bandwidthTimer == NULL )
    2416         m->bandwidthTimer = createTimer( m->session, BANDWIDTH_PERIOD_MSEC, bandwidthPulse, m );
    2417 
    2418     if( m->rechokeTimer == NULL )
    2419         m->rechokeTimer = createTimer( m->session, RECHOKE_PERIOD_MSEC, rechokePulse, m );
    2420 
    2421     if( m->refillUpkeepTimer == NULL )
    2422         m->refillUpkeepTimer = createTimer( m->session, REFILL_UPKEEP_PERIOD_MSEC, refillUpkeep, m );
     2414ensureMgrTimersExist (struct tr_peerMgr * m)
     2415{
     2416    if (m->atomTimer == NULL)
     2417        m->atomTimer = createTimer (m->session, ATOM_PERIOD_MSEC, atomPulse, m);
     2418
     2419    if (m->bandwidthTimer == NULL)
     2420        m->bandwidthTimer = createTimer (m->session, BANDWIDTH_PERIOD_MSEC, bandwidthPulse, m);
     2421
     2422    if (m->rechokeTimer == NULL)
     2423        m->rechokeTimer = createTimer (m->session, RECHOKE_PERIOD_MSEC, rechokePulse, m);
     2424
     2425    if (m->refillUpkeepTimer == NULL)
     2426        m->refillUpkeepTimer = createTimer (m->session, REFILL_UPKEEP_PERIOD_MSEC, refillUpkeep, m);
    24232427}
    24242428
    24252429void
    2426 tr_peerMgrStartTorrent( tr_torrent * tor )
     2430tr_peerMgrStartTorrent (tr_torrent * tor)
    24272431{
    24282432    Torrent * t = tor->torrentPeers;
    24292433
    2430     assert( tr_isTorrent( tor ) );
    2431     assert( tr_torrentIsLocked( tor ) );
    2432 
    2433     ensureMgrTimersExist( t->manager );
     2434    assert (tr_isTorrent (tor));
     2435    assert (tr_torrentIsLocked (tor));
     2436
     2437    ensureMgrTimersExist (t->manager);
    24342438
    24352439    t->isRunning = true;
     
    24372441    t->pieceSortState = PIECES_UNSORTED;
    24382442
    2439     rechokePulse( 0, 0, t->manager );
    2440 }
    2441 
    2442 static void
    2443 stopTorrent( Torrent * t )
     2443    rechokePulse (0, 0, t->manager);
     2444}
     2445
     2446static void
     2447stopTorrent (Torrent * t)
    24442448{
    24452449    tr_peer * peer;
     
    24472451    t->isRunning = false;
    24482452
    2449     replicationFree( t );
    2450     invalidatePieceSorting( t );
     2453    replicationFree (t);
     2454    invalidatePieceSorting (t);
    24512455
    24522456    /* disconnect the peers. */
    2453     while(( peer = tr_ptrArrayPop( &t->peers )))
    2454         peerDelete( t, peer );
    2455 
    2456     /* disconnect the handshakes. handshakeAbort calls handshakeDoneCB(),
     2457    while ((peer = tr_ptrArrayPop (&t->peers)))
     2458        peerDelete (t, peer);
     2459
     2460    /* disconnect the handshakes. handshakeAbort calls handshakeDoneCB (),
    24572461     * which removes the handshake from t->outgoingHandshakes... */
    2458     while( !tr_ptrArrayEmpty( &t->outgoingHandshakes ) )
    2459         tr_handshakeAbort( tr_ptrArrayNth( &t->outgoingHandshakes, 0 ) );
     2462    while (!tr_ptrArrayEmpty (&t->outgoingHandshakes))
     2463        tr_handshakeAbort (tr_ptrArrayNth (&t->outgoingHandshakes, 0));
    24602464}
    24612465
    24622466void
    2463 tr_peerMgrStopTorrent( tr_torrent * tor )
    2464 {
    2465     assert( tr_isTorrent( tor ) );
    2466     assert( tr_torrentIsLocked( tor ) );
    2467 
    2468     stopTorrent( tor->torrentPeers );
     2467tr_peerMgrStopTorrent (tr_torrent * tor)
     2468{
     2469    assert (tr_isTorrent (tor));
     2470    assert (tr_torrentIsLocked (tor));
     2471
     2472    stopTorrent (tor->torrentPeers);
    24692473}
    24702474
    24712475void
    2472 tr_peerMgrAddTorrent( tr_peerMgr * manager, tr_torrent * tor )
    2473 {
    2474     assert( tr_isTorrent( tor ) );
    2475     assert( tr_torrentIsLocked( tor ) );
    2476     assert( tor->torrentPeers == NULL );
    2477 
    2478     tor->torrentPeers = torrentNew( manager, tor );
     2476tr_peerMgrAddTorrent (tr_peerMgr * manager, tr_torrent * tor)
     2477{
     2478    assert (tr_isTorrent (tor));
     2479    assert (tr_torrentIsLocked (tor));
     2480    assert (tor->torrentPeers == NULL);
     2481
     2482    tor->torrentPeers = torrentNew (manager, tor);
    24792483}
    24802484
    24812485void
    2482 tr_peerMgrRemoveTorrent( tr_torrent * tor )
    2483 {
    2484     assert( tr_isTorrent( tor ) );
    2485     assert( tr_torrentIsLocked( tor ) );
    2486 
    2487     stopTorrent( tor->torrentPeers );
    2488     torrentFree( tor->torrentPeers );
     2486tr_peerMgrRemoveTorrent (tr_torrent * tor)
     2487{
     2488    assert (tr_isTorrent (tor));
     2489    assert (tr_torrentIsLocked (tor));
     2490
     2491    stopTorrent (tor->torrentPeers);
     2492    torrentFree (tor->torrentPeers);
    24892493}
    24902494
    24912495void
    2492 tr_peerUpdateProgress( tr_torrent * tor, tr_peer * peer )
     2496tr_peerUpdateProgress (tr_torrent * tor, tr_peer * peer)
    24932497{
    24942498    const tr_bitfield * have = &peer->have;
    24952499
    2496     if( tr_bitfieldHasAll( have ) )
     2500    if (tr_bitfieldHasAll (have))
    24972501    {
    24982502        peer->progress = 1.0;
    24992503    }
    2500     else if( tr_bitfieldHasNone( have ) )
     2504    else if (tr_bitfieldHasNone (have))
    25012505    {
    25022506        peer->progress = 0.0;
     
    25042508    else
    25052509    {
    2506         const float true_count = tr_bitfieldCountTrueBits( have );
    2507 
    2508         if( tr_torrentHasMetadata( tor ) )
     2510        const float true_count = tr_bitfieldCountTrueBits (have);
     2511
     2512        if (tr_torrentHasMetadata (tor))
    25092513        {
    25102514            peer->progress = true_count / tor->info.pieceCount;
     
    25122516        else /* without pieceCount, this result is only a best guess... */
    25132517        {
    2514             peer->progress = true_count / ( have->bit_count + 1 );
     2518            peer->progress = true_count / (have->bit_count + 1);
    25152519        }
    25162520    }
    25172521
    25182522    /* clamp the progress range */
    2519     if ( peer->progress < 0.0 )
     2523    if (peer->progress < 0.0)
    25202524        peer->progress = 0.0;
    2521     if ( peer->progress > 1.0 )
     2525    if (peer->progress > 1.0)
    25222526        peer->progress = 1.0;
    25232527
    2524     if( peer->atom && ( peer->progress >= 1.0 ) )
    2525         atomSetSeed( tor->torrentPeers, peer->atom );
     2528    if (peer->atom && (peer->progress >= 1.0))
     2529        atomSetSeed (tor->torrentPeers, peer->atom);
    25262530}
    25272531
    25282532void
    2529 tr_peerMgrOnTorrentGotMetainfo( tr_torrent * tor )
     2533tr_peerMgrOnTorrentGotMetainfo (tr_torrent * tor)
    25302534{
    25312535    int i;
     
    25342538
    25352539    /* the webseed list may have changed... */
    2536     rebuildWebseedArray( tor->torrentPeers, tor );
     2540    rebuildWebseedArray (tor->torrentPeers, tor);
    25372541
    25382542    /* some peer_msgs' progress fields may not be accurate if we
    25392543       didn't have the metadata before now... so refresh them all... */
    2540     peerCount = tr_ptrArraySize( &tor->torrentPeers->peers );
    2541     peers = (tr_peer**) tr_ptrArrayBase( &tor->torrentPeers->peers );
    2542     for( i=0; i<peerCount; ++i )
    2543         tr_peerUpdateProgress( tor, peers[i] );
     2544    peerCount = tr_ptrArraySize (&tor->torrentPeers->peers);
     2545    peers = (tr_peer**) tr_ptrArrayBase (&tor->torrentPeers->peers);
     2546    for (i=0; i<peerCount; ++i)
     2547        tr_peerUpdateProgress (tor, peers[i]);
    25442548
    25452549}
    25462550
    25472551void
    2548 tr_peerMgrTorrentAvailability( const tr_torrent * tor, int8_t * tab, unsigned int tabCount )
    2549 {
    2550     assert( tr_isTorrent( tor ) );
    2551     assert( torrentIsLocked( tor->torrentPeers ) );
    2552     assert( tab != NULL );
    2553     assert( tabCount > 0 );
    2554 
    2555     memset( tab, 0, tabCount );
    2556 
    2557     if( tr_torrentHasMetadata( tor ) )
     2552tr_peerMgrTorrentAvailability (const tr_torrent * tor, int8_t * tab, unsigned int tabCount)
     2553{
     2554    assert (tr_isTorrent (tor));
     2555    assert (torrentIsLocked (tor->torrentPeers));
     2556    assert (tab != NULL);
     2557    assert (tabCount > 0);
     2558
     2559    memset (tab, 0, tabCount);
     2560
     2561    if (tr_torrentHasMetadata (tor))
    25582562    {
    25592563        tr_piece_index_t i;
    2560         const int peerCount = tr_ptrArraySize( &tor->torrentPeers->peers );
    2561         const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &tor->torrentPeers->peers );
     2564        const int peerCount = tr_ptrArraySize (&tor->torrentPeers->peers);
     2565        const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&tor->torrentPeers->peers);
    25622566        const float interval = tor->info.pieceCount / (float)tabCount;
    2563         const bool isSeed = tr_cpGetStatus( &tor->completion ) == TR_SEED;
    2564 
    2565         for( i=0; i<tabCount; ++i )
     2567        const bool isSeed = tr_cpGetStatus (&tor->completion) == TR_SEED;
     2568
     2569        for (i=0; i<tabCount; ++i)
    25662570        {
    25672571            const int piece = i * interval;
    25682572
    2569             if( isSeed || tr_cpPieceIsComplete( &tor->completion, piece ) )
     2573            if (isSeed || tr_cpPieceIsComplete (&tor->completion, piece))
    25702574                tab[i] = -1;
    2571             else if( peerCount ) {
     2575            else if (peerCount) {
    25722576                int j;
    2573                 for( j=0; j<peerCount; ++j )
    2574                     if( tr_bitfieldHas( &peers[j]->have, piece ) )
     2577                for (j=0; j<peerCount; ++j)
     2578                    if (tr_bitfieldHas (&peers[j]->have, piece))
    25752579                        ++tab[i];
    25762580            }
     
    25802584
    25812585static bool
    2582 peerIsSeed( const tr_peer * peer )
    2583 {
    2584     if( peer->progress >= 1.0 )
     2586peerIsSeed (const tr_peer * peer)
     2587{
     2588    if (peer->progress >= 1.0)
    25852589        return true;
    25862590
    2587     if( peer->atom && atomIsSeed( peer->atom ) )
     2591    if (peer->atom && atomIsSeed (peer->atom))
    25882592        return true;
    25892593
     
    25932597/* count how many bytes we want that connected peers have */
    25942598uint64_t
    2595 tr_peerMgrGetDesiredAvailable( const tr_torrent * tor )
     2599tr_peerMgrGetDesiredAvailable (const tr_torrent * tor)
    25962600{
    25972601    size_t i;
     
    26022606    /* common shortcuts... */
    26032607
    2604     if( tr_torrentIsSeed( t->tor ) )
     2608    if (tr_torrentIsSeed (t->tor))
    26052609        return 0;
    26062610
    2607     if( !tr_torrentHasMetadata( tor ) )
     2611    if (!tr_torrentHasMetadata (tor))
    26082612        return 0;
    26092613
    2610     n = tr_ptrArraySize( &t->peers );
    2611     if( n == 0 )
     2614    n = tr_ptrArraySize (&t->peers);
     2615    if (n == 0)
    26122616        return 0;
    26132617    else {
    2614         const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
    2615         for( i=0; i<n; ++i )
    2616             if( peers[i]->atom && atomIsSeed( peers[i]->atom ) )
    2617                 return tr_cpLeftUntilDone( &tor->completion );
    2618     }
    2619 
    2620     if( !t->pieceReplication || !t->pieceReplicationSize )
     2618        const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
     2619        for (i=0; i<n; ++i)
     2620            if (peers[i]->atom && atomIsSeed (peers[i]->atom))
     2621                return tr_cpLeftUntilDone (&tor->completion);
     2622    }
     2623
     2624    if (!t->pieceReplication || !t->pieceReplicationSize)
    26212625        return 0;
    26222626
     
    26242628
    26252629    desiredAvailable = 0;
    2626     for( i=0, n=MIN(tor->info.pieceCount, t->pieceReplicationSize); i<n; ++i )
    2627         if( !tor->info.pieces[i].dnd && ( t->pieceReplication[i] > 0 ) )
    2628             desiredAvailable += tr_cpMissingBytesInPiece( &t->tor->completion, i );
    2629 
    2630     assert( desiredAvailable <= tor->info.totalSize );
     2630    for (i=0, n=MIN (tor->info.pieceCount, t->pieceReplicationSize); i<n; ++i)
     2631        if (!tor->info.pieces[i].dnd && (t->pieceReplication[i] > 0))
     2632            desiredAvailable += tr_cpMissingBytesInPiece (&t->tor->completion, i);
     2633
     2634    assert (desiredAvailable <= tor->info.totalSize);
    26312635    return desiredAvailable;
    26322636}
    26332637
    26342638void
    2635 tr_peerMgrTorrentStats( tr_torrent  * tor,
     2639tr_peerMgrTorrentStats (tr_torrent  * tor,
    26362640                        int         * setmePeersConnected,
    26372641                        int         * setmeWebseedsSendingToUs,
    26382642                        int         * setmePeersSendingToUs,
    26392643                        int         * setmePeersGettingFromUs,
    2640                         int         * setmePeersFrom )
     2644                        int         * setmePeersFrom)
    26412645{
    26422646    int i, size;
     
    26442648    const tr_peer ** peers;
    26452649
    2646     assert( tr_torrentIsLocked( tor ) );
    2647 
    2648     peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
    2649     size = tr_ptrArraySize( &t->peers );
     2650    assert (tr_torrentIsLocked (tor));
     2651
     2652    peers = (const tr_peer **) tr_ptrArrayBase (&t->peers);
     2653    size = tr_ptrArraySize (&t->peers);
    26502654
    26512655    *setmePeersConnected       = 0;
     
    26542658    *setmeWebseedsSendingToUs  = 0;
    26552659
    2656     for( i=0; i<TR_PEER_FROM__MAX; ++i )
     2660    for (i=0; i<TR_PEER_FROM__MAX; ++i)
    26572661        setmePeersFrom[i] = 0;
    26582662
    2659     for( i=0; i<size; ++i )
     2663    for (i=0; i<size; ++i)
    26602664    {
    26612665        const tr_peer * peer = peers[i];
    26622666        const struct peer_atom * atom = peer->atom;
    26632667
    2664         if( peer->io == NULL ) /* not connected */
     2668        if (peer->io == NULL) /* not connected */
    26652669            continue;
    26662670
     
    26692673        ++setmePeersFrom[atom->fromFirst];
    26702674
    2671         if( clientIsDownloadingFrom( tor, peer ) )
     2675        if (clientIsDownloadingFrom (tor, peer))
    26722676            ++*setmePeersSendingToUs;
    26732677
    2674         if( clientIsUploadingTo( peer ) )
     2678        if (clientIsUploadingTo (peer))
    26752679            ++*setmePeersGettingFromUs;
    26762680    }
    26772681
    2678     *setmeWebseedsSendingToUs = countActiveWebseeds( t );
     2682    *setmeWebseedsSendingToUs = countActiveWebseeds (t);
    26792683}
    26802684
    26812685double*
    2682 tr_peerMgrWebSpeeds_KBps( const tr_torrent * tor )
     2686tr_peerMgrWebSpeeds_KBps (const tr_torrent * tor)
    26832687{
    26842688    int i;
    26852689    const Torrent * t = tor->torrentPeers;
    2686     const int webseedCount = tr_ptrArraySize( &t->webseeds );
    2687     const tr_webseed ** webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
    2688     const uint64_t now = tr_time_msec( );
    2689     double * ret = tr_new0( double, webseedCount );
    2690 
    2691     assert( tr_isTorrent( tor ) );
    2692     assert( tr_torrentIsLocked( tor ) );
    2693     assert( t->manager != NULL );
    2694     assert( webseedCount == tor->info.webseedCount );
    2695 
    2696     for( i=0; i<webseedCount; ++i ) {
     2690    const int webseedCount = tr_ptrArraySize (&t->webseeds);
     2691    const tr_webseed ** webseeds = (const tr_webseed**) tr_ptrArrayBase (&t->webseeds);
     2692    const uint64_t now = tr_time_msec ();
     2693    double * ret = tr_new0 (double, webseedCount);
     2694
     2695    assert (tr_isTorrent (tor));
     2696    assert (tr_torrentIsLocked (tor));
     2697    assert (t->manager != NULL);
     2698    assert (webseedCount == tor->info.webseedCount);
     2699
     2700    for (i=0; i<webseedCount; ++i) {
    26972701        unsigned int Bps;
    2698         if( tr_webseedGetSpeed_Bps( webseeds[i], now, &Bps ) )
     2702        if (tr_webseedGetSpeed_Bps (webseeds[i], now, &Bps))
    26992703            ret[i] = Bps / (double)tr_speed_K;
    27002704        else
     
    27062710
    27072711unsigned int
    2708 tr_peerGetPieceSpeed_Bps( const tr_peer * peer, uint64_t now, tr_direction direction )
    2709 {
    2710     return peer->io ? tr_peerIoGetPieceSpeed_Bps( peer->io, now, direction ) : 0.0;
     2712tr_peerGetPieceSpeed_Bps (const tr_peer * peer, uint64_t now, tr_direction direction)
     2713{
     2714    return peer->io ? tr_peerIoGetPieceSpeed_Bps (peer->io, now, direction) : 0.0;
    27112715}
    27122716
    27132717struct tr_peer_stat *
    2714 tr_peerMgrPeerStats( const tr_torrent * tor, int * setmeCount )
     2718tr_peerMgrPeerStats (const tr_torrent * tor, int * setmeCount)
    27152719{
    27162720    int i;
    27172721    const Torrent * t = tor->torrentPeers;
    2718     const int size = tr_ptrArraySize( &t->peers );
    2719     const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
    2720     const uint64_t now_msec = tr_time_msec( );
    2721     const time_t now = tr_time();
    2722     tr_peer_stat * ret = tr_new0( tr_peer_stat, size );
    2723 
    2724     assert( tr_isTorrent( tor ) );
    2725     assert( tr_torrentIsLocked( tor ) );
    2726     assert( t->manager );
    2727 
    2728     for( i=0; i<size; ++i )
     2722    const int size = tr_ptrArraySize (&t->peers);
     2723    const tr_peer ** peers = (const tr_peer**) tr_ptrArrayBase (&t->peers);
     2724    const uint64_t now_msec = tr_time_msec ();
     2725    const time_t now = tr_time ();
     2726    tr_peer_stat * ret = tr_new0 (tr_peer_stat, size);
     2727
     2728    assert (tr_isTorrent (tor));
     2729    assert (tr_torrentIsLocked (tor));
     2730    assert (t->manager);
     2731
     2732    for (i=0; i<size; ++i)
    27292733    {
    27302734        char *                   pch;
     
    27332737        tr_peer_stat *           stat = ret + i;
    27342738
    2735         tr_address_to_string_with_buf( &atom->addr, stat->addr, sizeof( stat->addr ) );
    2736         tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
    2737                    sizeof( stat->client ) );
    2738         stat->port                = ntohs( peer->atom->port );
     2739        tr_address_to_string_with_buf (&atom->addr, stat->addr, sizeof (stat->addr));
     2740        tr_strlcpy (stat->client, (peer->client ? peer->client : ""),
     2741                   sizeof (stat->client));
     2742        stat->port                = ntohs (peer->atom->port);
    27392743        stat->from                = atom->fromFirst;
    27402744        stat->progress            = peer->progress;
    27412745        stat->isUTP               = peer->io->utp_socket != NULL;
    2742         stat->isEncrypted         = tr_peerIoIsEncrypted( peer->io ) ? 1 : 0;
    2743         stat->rateToPeer_KBps     = toSpeedKBps( tr_peerGetPieceSpeed_Bps( peer, now_msec, TR_CLIENT_TO_PEER ) );
    2744         stat->rateToClient_KBps   = toSpeedKBps( tr_peerGetPieceSpeed_Bps( peer, now_msec, TR_PEER_TO_CLIENT ) );
     2746        stat->isEncrypted         = tr_peerIoIsEncrypted (peer->io) ? 1 : 0;
     2747        stat->rateToPeer_KBps     = toSpeedKBps (tr_peerGetPieceSpeed_Bps (peer, now_msec, TR_CLIENT_TO_PEER));
     2748        stat->rateToClient_KBps   = toSpeedKBps (tr_peerGetPieceSpeed_Bps (peer, now_msec, TR_PEER_TO_CLIENT));
    27452749        stat->peerIsChoked        = peer->peerIsChoked;
    27462750        stat->peerIsInterested    = peer->peerIsInterested;
    27472751        stat->clientIsChoked      = peer->clientIsChoked;
    27482752        stat->clientIsInterested  = peer->clientIsInterested;
    2749         stat->isIncoming          = tr_peerIoIsIncoming( peer->io );
    2750         stat->isDownloadingFrom   = clientIsDownloadingFrom( tor, peer );
    2751         stat->isUploadingTo       = clientIsUploadingTo( peer );
    2752         stat->isSeed              = peerIsSeed( peer );
    2753 
    2754         stat->blocksToPeer        = tr_historyGet( &peer->blocksSentToPeer,    now, CANCEL_HISTORY_SEC );
    2755         stat->blocksToClient      = tr_historyGet( &peer->blocksSentToClient,  now, CANCEL_HISTORY_SEC );
    2756         stat->cancelsToPeer       = tr_historyGet( &peer->cancelsSentToPeer,   now, CANCEL_HISTORY_SEC );
    2757         stat->cancelsToClient     = tr_historyGet( &peer->cancelsSentToClient, now, CANCEL_HISTORY_SEC );
     2753        stat->isIncoming          = tr_peerIoIsIncoming (peer->io);
     2754        stat->isDownloadingFrom   = clientIsDownloadingFrom (tor, peer);
     2755        stat->isUploadingTo       = clientIsUploadingTo (peer);
     2756        stat->isSeed              = peerIsSeed (peer);
     2757
     2758        stat->blocksToPeer        = tr_historyGet (&peer->blocksSentToPeer,    now, CANCEL_HISTORY_SEC);
     2759        stat->blocksToClient      = tr_historyGet (&peer->blocksSentToClient,  now, CANCEL_HISTORY_SEC);
     2760        stat->cancelsToPeer       = tr_historyGet (&peer->cancelsSentToPeer,   now, CANCEL_HISTORY_SEC);
     2761        stat->cancelsToClient     = tr_historyGet (&peer->cancelsSentToClient, now, CANCEL_HISTORY_SEC);
    27582762
    27592763        stat->pendingReqsToPeer   = peer->pendingReqsToPeer;
     
    27612765
    27622766        pch = stat->flagStr;
    2763         if( stat->isUTP ) *pch++ = 'T';
    2764         if( t->optimistic == peer ) *pch++ = 'O';
    2765         if( stat->isDownloadingFrom ) *pch++ = 'D';
    2766         else if( stat->clientIsInterested ) *pch++ = 'd';
    2767         if( stat->isUploadingTo ) *pch++ = 'U';
    2768         else if( stat->peerIsInterested ) *pch++ = 'u';
    2769         if( !stat->clientIsChoked && !stat->clientIsInterested ) *pch++ = 'K';
    2770         if( !stat->peerIsChoked && !stat->peerIsInterested ) *pch++ = '?';
    2771         if( stat->isEncrypted ) *pch++ = 'E';
    2772         if( stat->from == TR_PEER_FROM_DHT ) *pch++ = 'H';
    2773         else if( stat->from == TR_PEER_FROM_PEX ) *pch++ = 'X';
    2774         if( stat->isIncoming ) *pch++ = 'I';
     2767        if (stat->isUTP) *pch++ = 'T';
     2768        if (t->optimistic == peer) *pch++ = 'O';
     2769        if (stat->isDownloadingFrom) *pch++ = 'D';
     2770        else if (stat->clientIsInterested) *pch++ = 'd';
     2771        if (stat->isUploadingTo) *pch++ = 'U';
     2772        else if (stat->peerIsInterested) *pch++ = 'u';
     2773        if (!stat->clientIsChoked && !stat->clientIsInterested) *pch++ = 'K';
     2774        if (!stat->peerIsChoked && !stat->peerIsInterested) *pch++ = '?';
     2775        if (stat->isEncrypted) *pch++ = 'E';
     2776        if (stat->from == TR_PEER_FROM_DHT) *pch++ = 'H';
     2777        else if (stat->from == TR_PEER_FROM_PEX) *pch++ = 'X';
     2778        if (stat->isIncoming) *pch++ = 'I';
    27752779        *pch = '\0';
    27762780    }
     
    27872791
    27882792void
    2789 tr_peerMgrClearInterest( tr_torrent * tor )
     2793tr_peerMgrClearInterest (tr_torrent * tor)
    27902794{
    27912795    int i;
    27922796    Torrent * t = tor->torrentPeers;
    2793     const int peerCount = tr_ptrArraySize( &t->peers );
    2794 
    2795     assert( tr_isTorrent( tor ) );
    2796     assert( tr_torrentIsLocked( tor ) );
    2797 
    2798     for( i=0; i<peerCount; ++i )
    2799     {
    2800         const tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
    2801         tr_peerMsgsSetInterested( peer->msgs, false );
     2797    const int peerCount = tr_ptrArraySize (&t->peers);
     2798
     2799    assert (tr_isTorrent (tor));
     2800    assert (tr_torrentIsLocked (tor));
     2801
     2802    for (i=0; i<peerCount; ++i)
     2803    {
     2804        const tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
     2805        tr_peerMsgsSetInterested (peer->msgs, false);
    28022806    }
    28032807}
     
    28052809/* does this peer have any pieces that we want? */
    28062810static bool
    2807 isPeerInteresting( const tr_torrent  * const tor,
     2811isPeerInteresting (const tr_torrent  * const tor,
    28082812                   const bool        * const piece_is_interesting,
    2809                    const tr_peer     * const peer )
     2813                   const tr_peer     * const peer)
    28102814{
    28112815    tr_piece_index_t i, n;
    28122816
    28132817    /* these cases should have already been handled by the calling code... */
    2814     assert( !tr_torrentIsSeed( tor ) );
    2815     assert( tr_torrentIsPieceTransferAllowed( tor, TR_PEER_TO_CLIENT ) );
    2816 
    2817     if( peerIsSeed( peer ) )
     2818    assert (!tr_torrentIsSeed (tor));
     2819    assert (tr_torrentIsPieceTransferAllowed (tor, TR_PEER_TO_CLIENT));
     2820
     2821    if (peerIsSeed (peer))
    28182822        return true;
    28192823
    2820     for( i=0, n=tor->info.pieceCount; i<n; ++i )
    2821         if( piece_is_interesting[i] && tr_bitfieldHas( &peer->have, i ) )
     2824    for (i=0, n=tor->info.pieceCount; i<n; ++i)
     2825        if (piece_is_interesting[i] && tr_bitfieldHas (&peer->have, i))
    28222826            return true;
    28232827
     
    28412845
    28422846static int
    2843 compare_rechoke_info( const void * va, const void * vb )
     2847compare_rechoke_info (const void * va, const void * vb)
    28442848{
    28452849    const struct tr_rechoke_info * a = va;
    28462850    const struct tr_rechoke_info * b = vb;
    28472851
    2848     if( a->rechoke_state != b->rechoke_state )
     2852    if (a->rechoke_state != b->rechoke_state)
    28492853        return a->rechoke_state - b->rechoke_state;
    28502854
     
    28542858/* determines who we send "interested" messages to */
    28552859static void
    2856 rechokeDownloads( Torrent * t )
     2860rechokeDownloads (Torrent * t)
    28572861{
    28582862    int i;
     
    28612865    struct tr_rechoke_info * rechoke = NULL;
    28622866    const int MIN_INTERESTING_PEERS = 5;
    2863     const int peerCount = tr_ptrArraySize( &t->peers );
    2864     const time_t now = tr_time( );
     2867    const int peerCount = tr_ptrArraySize (&t->peers);
     2868    const time_t now = tr_time ();
    28652869
    28662870    /* some cases where this function isn't necessary */
    2867     if( tr_torrentIsSeed( t->tor ) )
     2871    if (tr_torrentIsSeed (t->tor))
    28682872        return;
    2869     if ( !tr_torrentIsPieceTransferAllowed( t->tor, TR_PEER_TO_CLIENT ) )
     2873    if (!tr_torrentIsPieceTransferAllowed (t->tor, TR_PEER_TO_CLIENT))
    28702874        return;
    28712875
     
    28902894         * thinking it's hit its bandwidth cap.
    28912895         */
    2892         for( i=0; i<peerCount; ++i )
     2896        for (i=0; i<peerCount; ++i)
    28932897        {
    2894             const tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
    2895             const int b = tr_historyGet( &peer->blocksSentToClient, now, CANCEL_HISTORY_SEC );
    2896             const int c = tr_historyGet( &peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC );
    2897 
    2898             if( b == 0 ) /* ignore unresponsive peers, as described above */
     2898            const tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
     2899            const int b = tr_historyGet (&peer->blocksSentToClient, now, CANCEL_HISTORY_SEC);
     2900            const int c = tr_historyGet (&peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC);
     2901
     2902            if (b == 0) /* ignore unresponsive peers, as described above */
    28992903                continue;
    29002904
     
    29032907        }
    29042908
    2905         if( cancels > 0 )
     2909        if (cancels > 0)
    29062910        {
    29072911            /* cancelRate: of the block requests we've recently made, the percentage we cancelled.
    29082912             * higher values indicate more congestion. */
    29092913            const double cancelRate = cancels / (double)(cancels + blocks);
    2910             const double mult = 1 - MIN( cancelRate, 0.5 );
     2914            const double mult = 1 - MIN (cancelRate, 0.5);
    29112915            maxPeers = t->interestedCount * mult;
    2912             tordbg( t, "cancel rate is %.3f -- reducing the "
     2916            tordbg (t, "cancel rate is %.3f -- reducing the "
    29132917                       "number of peers we're interested in by %.0f percent",
    2914                        cancelRate, mult * 100 );
     2918                       cancelRate, mult * 100);
    29152919            t->lastCancel = now;
    29162920        }
    29172921
    29182922        timeSinceCancel = now - t->lastCancel;
    2919         if( timeSinceCancel )
     2923        if (timeSinceCancel)
    29202924        {
    29212925            const int maxIncrease = 15;
    29222926            const time_t maxHistory = 2 * CANCEL_HISTORY_SEC;
    2923             const double mult = MIN( timeSinceCancel, maxHistory ) / (double) maxHistory;
     2927            const double mult = MIN (timeSinceCancel, maxHistory) / (double) maxHistory;
    29242928            const int inc = maxIncrease * mult;
    29252929            maxPeers = t->maxPeers + inc;
    2926             tordbg( t, "time since last cancel is %li -- increasing the "
     2930            tordbg (t, "time since last cancel is %li -- increasing the "
    29272931                       "number of peers we're interested in by %d",
    2928                        timeSinceCancel, inc );
     2932                       timeSinceCancel, inc);
    29292933        }
    29302934    }
    29312935
    29322936    /* don't let the previous section's number tweaking go too far... */
    2933     if( maxPeers < MIN_INTERESTING_PEERS )
     2937    if (maxPeers < MIN_INTERESTING_PEERS)
    29342938        maxPeers = MIN_INTERESTING_PEERS;
    2935     if( maxPeers > t->tor->maxConnectedPeers )
     2939    if (maxPeers > t->tor->maxConnectedPeers)
    29362940        maxPeers = t->tor->maxConnectedPeers;
    29372941
    29382942    t->maxPeers = maxPeers;
    29392943
    2940     if( peerCount > 0 )
     2944    if (peerCount > 0)
    29412945    {
    29422946        bool * piece_is_interesting;
     
    29452949
    29462950        /* build a bitfield of interesting pieces... */
    2947         piece_is_interesting = tr_new( bool, n );
    2948         for( i=0; i<n; i++ )
    2949             piece_is_interesting[i] = !tor->info.pieces[i].dnd && !tr_cpPieceIsComplete( &tor->completion, i );
     2951        piece_is_interesting = tr_new (bool, n);
     2952        for (i=0; i<n; i++)
     2953            piece_is_interesting[i] = !tor->info.pieces[i].dnd && !tr_cpPieceIsComplete (&tor->completion, i);
    29502954
    29512955        /* decide WHICH peers to be interested in (based on their cancel-to-block ratio) */
    2952         for( i=0; i<peerCount; ++i )
     2956        for (i=0; i<peerCount; ++i)
    29532957        {
    2954             tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
    2955 
    2956             if( !isPeerInteresting( t->tor, piece_is_interesting, peer ) )
     2958            tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
     2959
     2960            if (!isPeerInteresting (t->tor, piece_is_interesting, peer))
    29572961            {
    2958                 tr_peerMsgsSetInterested( peer->msgs, false );
     2962                tr_peerMsgsSetInterested (peer->msgs, false);
    29592963            }
    29602964            else
    29612965            {
    29622966                tr_rechoke_state rechoke_state;
    2963                 const int blocks = tr_historyGet( &peer->blocksSentToClient, now, CANCEL_HISTORY_SEC );
    2964                 const int cancels = tr_historyGet( &peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC );
    2965 
    2966                 if( !blocks && !cancels )
     2967                const int blocks = tr_historyGet (&peer->blocksSentToClient, now, CANCEL_HISTORY_SEC);
     2968                const int cancels = tr_historyGet (&peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC);
     2969
     2970                if (!blocks && !cancels)
    29672971                    rechoke_state = RECHOKE_STATE_UNTESTED;
    2968                 else if( !cancels )
     2972                else if (!cancels)
    29692973                    rechoke_state = RECHOKE_STATE_GOOD;
    2970                 else if( !blocks )
     2974                else if (!blocks)
    29712975                    rechoke_state = RECHOKE_STATE_BAD;
    2972                 else if( ( cancels * 10 ) < blocks )
     2976                else if ((cancels * 10) < blocks)
    29732977                    rechoke_state = RECHOKE_STATE_GOOD;
    29742978                else
    29752979                    rechoke_state = RECHOKE_STATE_BAD;
    29762980
    2977                 if( rechoke == NULL )
    2978                     rechoke = tr_new( struct tr_rechoke_info, peerCount );
     2981                if (rechoke == NULL)
     2982                    rechoke = tr_new (struct tr_rechoke_info, peerCount);
    29792983
    29802984                 rechoke[rechoke_count].peer = peer;
    29812985                 rechoke[rechoke_count].rechoke_state = rechoke_state;
    2982                  rechoke[rechoke_count].salt = tr_cryptoWeakRandInt( INT_MAX );
     2986                 rechoke[rechoke_count].salt = tr_cryptoWeakRandInt (INT_MAX);
    29832987                 rechoke_count++;
    29842988            }
     
    29862990        }
    29872991
    2988         tr_free( piece_is_interesting );
     2992        tr_free (piece_is_interesting);
    29892993    }
    29902994
    29912995    /* now that we know which & how many peers to be interested in... update the peer interest */
    2992     qsort( rechoke, rechoke_count, sizeof( struct tr_rechoke_info ), compare_rechoke_info );
    2993     t->interestedCount = MIN( maxPeers, rechoke_count );
    2994     for( i=0; i<rechoke_count; ++i )
    2995         tr_peerMsgsSetInterested( rechoke[i].peer->msgs, i<t->interestedCount );
     2996    qsort (rechoke, rechoke_count, sizeof (struct tr_rechoke_info), compare_rechoke_info);
     2997    t->interestedCount = MIN (maxPeers, rechoke_count);
     2998    for (i=0; i<rechoke_count; ++i)
     2999        tr_peerMsgsSetInterested (rechoke[i].peer->msgs, i<t->interestedCount);
    29963000
    29973001    /* cleanup */
    2998     tr_free( rechoke );
     3002    tr_free (rechoke);
    29993003}
    30003004
     
    30143018
    30153019static int
    3016 compareChoke( const void * va, const void * vb )
     3020compareChoke (const void * va, const void * vb)
    30173021{
    30183022    const struct ChokeData * a = va;
    30193023    const struct ChokeData * b = vb;
    30203024
    3021     if( a->rate != b->rate ) /* prefer higher overall speeds */
     3025    if (a->rate != b->rate) /* prefer higher overall speeds */
    30223026        return a->rate > b->rate ? -1 : 1;
    30233027
    3024     if( a->wasChoked != b->wasChoked ) /* prefer unchoked */
     3028    if (a->wasChoked != b->wasChoked) /* prefer unchoked */
    30253029        return a->wasChoked ? 1 : -1;
    30263030
    3027     if( a->salt != b->salt ) /* random order */
     3031    if (a->salt != b->salt) /* random order */
    30283032        return a->salt - b->salt;
    30293033
     
    30333037/* is this a new connection? */
    30343038static int
    3035 isNew( const tr_peer * peer )
    3036 {
    3037     return peer && peer->io && tr_peerIoGetAge( peer->io ) < 45;
     3039isNew (const tr_peer * peer)
     3040{
     3041    return peer && peer->io && tr_peerIoGetAge (peer->io) < 45;
    30383042}
    30393043
    30403044/* get a rate for deciding which peers to choke and unchoke. */
    30413045static int
    3042 getRate( const tr_torrent * tor, struct peer_atom * atom, uint64_t now )
     3046getRate (const tr_torrent * tor, struct peer_atom * atom, uint64_t now)
    30433047{
    30443048    unsigned int Bps;
    30453049
    3046     if( tr_torrentIsSeed( tor ) )
    3047         Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_CLIENT_TO_PEER );
     3050    if (tr_torrentIsSeed (tor))
     3051        Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_CLIENT_TO_PEER);
    30483052
    30493053    /* downloading a private torrent... take upload speed into account
    30503054     * because there may only be a small window of opportunity to share */
    3051     else if( tr_torrentIsPrivate( tor ) )
    3052         Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_PEER_TO_CLIENT )
    3053             + tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_CLIENT_TO_PEER );
     3055    else if (tr_torrentIsPrivate (tor))
     3056        Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_PEER_TO_CLIENT)
     3057            + tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_CLIENT_TO_PEER);
    30543058
    30553059    /* downloading a public torrent */
    30563060    else
    3057         Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_PEER_TO_CLIENT );
     3061        Bps = tr_peerGetPieceSpeed_Bps (atom->peer, now, TR_PEER_TO_CLIENT);
    30583062
    30593063    /* convert it to bytes per second */
     
    30623066
    30633067static inline bool
    3064 isBandwidthMaxedOut( const tr_bandwidth * b,
    3065                      const uint64_t now_msec, tr_direction dir )
    3066 {
    3067     if( !tr_bandwidthIsLimited( b, dir ) )
     3068isBandwidthMaxedOut (const tr_bandwidth * b,
     3069                     const uint64_t now_msec, tr_direction dir)
     3070{
     3071    if (!tr_bandwidthIsLimited (b, dir))
    30683072        return false;
    30693073    else {
    3070         const unsigned int got = tr_bandwidthGetPieceSpeed_Bps( b, now_msec, dir );
    3071         const unsigned int want = tr_bandwidthGetDesiredSpeed_Bps( b, dir );
     3074        const unsigned int got = tr_bandwidthGetPieceSpeed_Bps (b, now_msec, dir);
     3075        const unsigned int want = tr_bandwidthGetDesiredSpeed_Bps (b, dir);
    30723076        return got >= want;
    30733077    }
     
    30753079
    30763080static void
    3077 rechokeUploads( Torrent * t, const uint64_t now )
     3081rechokeUploads (Torrent * t, const uint64_t now)
    30783082{
    30793083    int i, size, unchokedInterested;
    3080     const int peerCount = tr_ptrArraySize( &t->peers );
    3081     tr_peer ** peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
    3082     struct ChokeData * choke = tr_new0( struct ChokeData, peerCount );
     3084    const int peerCount = tr_ptrArraySize (&t->peers);
     3085    tr_peer ** peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
     3086    struct ChokeData * choke = tr_new0 (struct ChokeData, peerCount);
    30833087    const tr_session * session = t->manager->session;
    3084     const int chokeAll = !tr_torrentIsPieceTransferAllowed( t->tor, TR_CLIENT_TO_PEER );
    3085     const bool isMaxedOut = isBandwidthMaxedOut( &t->tor->bandwidth, now, TR_UP );
    3086 
    3087     assert( torrentIsLocked( t ) );
     3088    const int chokeAll = !tr_torrentIsPieceTransferAllowed (t->tor, TR_CLIENT_TO_PEER);
     3089    const bool isMaxedOut = isBandwidthMaxedOut (&t->tor->bandwidth, now, TR_UP);
     3090
     3091    assert (torrentIsLocked (t));
    30883092
    30893093    /* an optimistic unchoke peer's "optimistic"
    3090      * state lasts for N calls to rechokeUploads(). */
    3091     if( t->optimisticUnchokeTimeScaler > 0 )
     3094     * state lasts for N calls to rechokeUploads (). */
     3095    if (t->optimisticUnchokeTimeScaler > 0)
    30923096        t->optimisticUnchokeTimeScaler--;
    30933097    else
     
    30953099
    30963100    /* sort the peers by preference and rate */
    3097     for( i = 0, size = 0; i < peerCount; ++i )
     3101    for (i = 0, size = 0; i < peerCount; ++i)
    30983102    {
    30993103        tr_peer * peer = peers[i];
    31003104        struct peer_atom * atom = peer->atom;
    31013105
    3102         if( peerIsSeed( peer ) ) /* choke seeds and partial seeds */
     3106        if (peerIsSeed (peer)) /* choke seeds and partial seeds */
    31033107        {
    3104             tr_peerMsgsSetChoke( peer->msgs, true );
     3108            tr_peerMsgsSetChoke (peer->msgs, true);
    31053109        }
    3106         else if( chokeAll ) /* choke everyone if we're not uploading */
     3110        else if (chokeAll) /* choke everyone if we're not uploading */
    31073111        {
    3108             tr_peerMsgsSetChoke( peer->msgs, true );
     3112            tr_peerMsgsSetChoke (peer->msgs, true);
    31093113        }
    3110         else if( peer != t->optimistic )
     3114        else if (peer != t->optimistic)
    31113115        {
    31123116            struct ChokeData * n = &choke[size++];
     
    31143118            n->isInterested = peer->peerIsInterested;
    31153119            n->wasChoked    = peer->peerIsChoked;
    3116             n->rate         = getRate( t->tor, atom, now );
    3117             n->salt         = tr_cryptoWeakRandInt( INT_MAX );
     3120            n->rate         = getRate (t->tor, atom, now);
     3121            n->salt         = tr_cryptoWeakRandInt (INT_MAX);
    31183122            n->isChoked     = true;
    31193123        }
    31203124    }
    31213125
    3122     qsort( choke, size, sizeof( struct ChokeData ), compareChoke );
     3126    qsort (choke, size, sizeof (struct ChokeData), compareChoke);
    31233127
    31243128    /**
     
    31383142     */
    31393143    unchokedInterested = 0;
    3140     for( i=0; i<size && unchokedInterested<session->uploadSlotsPerTorrent; ++i ) {
     3144    for (i=0; i<size && unchokedInterested<session->uploadSlotsPerTorrent; ++i) {
    31413145        choke[i].isChoked = isMaxedOut ? choke[i].wasChoked : false;
    3142         if( choke[i].isInterested )
     3146        if (choke[i].isInterested)
    31433147            ++unchokedInterested;
    31443148    }
    31453149
    31463150    /* optimistic unchoke */
    3147     if( !t->optimistic && !isMaxedOut && (i<size) )
     3151    if (!t->optimistic && !isMaxedOut && (i<size))
    31483152    {
    31493153        int n;
     
    31513155        tr_ptrArray randPool = TR_PTR_ARRAY_INIT;
    31523156
    3153         for( ; i<size; ++i )
     3157        for (; i<size; ++i)
    31543158        {
    3155             if( choke[i].isInterested )
     3159            if (choke[i].isInterested)
    31563160            {
    31573161                const tr_peer * peer = choke[i].peer;
    31583162                int x = 1, y;
    3159                 if( isNew( peer ) ) x *= 3;
    3160                 for( y=0; y<x; ++y )
    3161                     tr_ptrArrayAppend( &randPool, &choke[i] );
     3163                if (isNew (peer)) x *= 3;
     3164                for (y=0; y<x; ++y)
     3165                    tr_ptrArrayAppend (&randPool, &choke[i]);
    31623166            }
    31633167        }
    31643168
    3165         if(( n = tr_ptrArraySize( &randPool )))
     3169        if ((n = tr_ptrArraySize (&randPool)))
    31663170        {
    3167             c = tr_ptrArrayNth( &randPool, tr_cryptoWeakRandInt( n ));
     3171            c = tr_ptrArrayNth (&randPool, tr_cryptoWeakRandInt (n));
    31683172            c->isChoked = false;
    31693173            t->optimistic = c->peer;
     
    31713175        }
    31723176
    3173         tr_ptrArrayDestruct( &randPool, NULL );
    3174     }
    3175 
    3176     for( i=0; i<size; ++i )
    3177         tr_peerMsgsSetChoke( choke[i].peer->msgs, choke[i].isChoked );
     3177        tr_ptrArrayDestruct (&randPool, NULL);
     3178    }
     3179
     3180    for (i=0; i<size; ++i)
     3181        tr_peerMsgsSetChoke (choke[i].peer->msgs, choke[i].isChoked);
    31783182
    31793183    /* cleanup */
    3180     tr_free( choke );
    3181 }
    3182 
    3183 static void
    3184 rechokePulse( int foo UNUSED, short bar UNUSED, void * vmgr )
     3184    tr_free (choke);
     3185}
     3186
     3187static void
     3188rechokePulse (int foo UNUSED, short bar UNUSED, void * vmgr)
    31853189{
    31863190    tr_torrent * tor = NULL;
    31873191    tr_peerMgr * mgr = vmgr;
    3188     const uint64_t now = tr_time_msec( );
    3189 
    3190     managerLock( mgr );
    3191 
    3192     while(( tor = tr_torrentNext( mgr->session, tor ))) {
    3193         if( tor->isRunning ) {
     3192    const uint64_t now = tr_time_msec ();
     3193
     3194    managerLock (mgr);
     3195
     3196    while ((tor = tr_torrentNext (mgr->session, tor))) {
     3197        if (tor->isRunning) {
    31943198            Torrent * t = tor->torrentPeers;
    3195             if( !tr_ptrArrayEmpty( &t->peers ) ) {
    3196                 rechokeUploads( t, now );
    3197                 rechokeDownloads( t );
     3199            if (!tr_ptrArrayEmpty (&t->peers)) {
     3200                rechokeUploads (t, now);
     3201                rechokeDownloads (t);
    31983202            }
    31993203        }
    32003204    }
    32013205
    3202     tr_timerAddMsec( mgr->rechokeTimer, RECHOKE_PERIOD_MSEC );
    3203     managerUnlock( mgr );
     3206    tr_timerAddMsec (mgr->rechokeTimer, RECHOKE_PERIOD_MSEC);
     3207    managerUnlock (mgr);
    32043208}
    32053209
     
    32113215
    32123216static bool
    3213 shouldPeerBeClosed( const Torrent    * t,
     3217shouldPeerBeClosed (const Torrent    * t,
    32143218                    const tr_peer    * peer,
    32153219                    int                peerCount,
    3216                     const time_t       now )
     3220                    const time_t       now)
    32173221{
    32183222    const tr_torrent *       tor = t->tor;
     
    32203224
    32213225    /* if it's marked for purging, close it */
    3222     if( peer->doPurge )
    3223     {
    3224         tordbg( t, "purging peer %s because its doPurge flag is set",
    3225                 tr_atomAddrStr( atom ) );
     3226    if (peer->doPurge)
     3227    {
     3228        tordbg (t, "purging peer %s because its doPurge flag is set",
     3229                tr_atomAddrStr (atom));
    32263230        return true;
    32273231    }
    32283232
    32293233    /* disconnect if we're both seeds and enough time has passed for PEX */
    3230     if( tr_torrentIsSeed( tor ) && peerIsSeed( peer ) )
    3231         return !tr_torrentAllowsPex(tor) || (now-atom->time>=30);
     3234    if (tr_torrentIsSeed (tor) && peerIsSeed (peer))
     3235        return !tr_torrentAllowsPex (tor) || (now-atom->time>=30);
    32323236
    32333237    /* disconnect if it's been too long since piece data has been transferred.
    32343238     * this is on a sliding scale based on number of available peers... */
    32353239    {
    3236         const int relaxStrictnessIfFewerThanN = (int)( ( getMaxPeerCount( tor ) * 0.9 ) + 0.5 );
     3240        const int relaxStrictnessIfFewerThanN = (int)((getMaxPeerCount (tor) * 0.9) + 0.5);
    32373241        /* if we have >= relaxIfFewerThan, strictness is 100%.
    32383242         * if we have zero connections, strictness is 0% */
     
    32423246        const int lo = MIN_UPLOAD_IDLE_SECS;
    32433247        const int hi = MAX_UPLOAD_IDLE_SECS;
    3244         const int limit = hi - ( ( hi - lo ) * strictness );
    3245         const int idleTime = now - MAX( atom->time, atom->piece_data_time );
    3246 /*fprintf( stderr, "strictness is %.3f, limit is %d seconds... time since connect is %d, time since piece is %d ... idleTime is %d, doPurge is %d\n", (double)strictness, limit, (int)(now - atom->time), (int)(now - atom->piece_data_time), idleTime, idleTime > limit );*/
    3247         if( idleTime > limit ) {
    3248             tordbg( t, "purging peer %s because it's been %d secs since we shared anything",
    3249                        tr_atomAddrStr( atom ), idleTime );
     3248        const int limit = hi - ((hi - lo) * strictness);
     3249        const int idleTime = now - MAX (atom->time, atom->piece_data_time);
     3250/*fprintf (stderr, "strictness is %.3f, limit is %d seconds... time since connect is %d, time since piece is %d ... idleTime is %d, doPurge is %d\n", (double)strictness, limit, (int)(now - atom->time), (int)(now - atom->piece_data_time), idleTime, idleTime > limit);*/
     3251        if (idleTime > limit) {
     3252            tordbg (t, "purging peer %s because it's been %d secs since we shared anything",
     3253                       tr_atomAddrStr (atom), idleTime);
    32503254            return true;
    32513255        }
     
    32563260
    32573261static tr_peer **
    3258 getPeersToClose( Torrent * t, const time_t now_sec, int * setmeSize )
     3262getPeersToClose (Torrent * t, const time_t now_sec, int * setmeSize)
    32593263{
    32603264    int i, peerCount, outsize;
    32613265    struct tr_peer ** ret = NULL;
    3262     tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek( &t->peers, &peerCount );
    3263 
    3264     assert( torrentIsLocked( t ) );
    3265 
    3266     for( i = outsize = 0; i < peerCount; ++i ) {
    3267         if( shouldPeerBeClosed( t, peers[i], peerCount, now_sec ) ) {
    3268             if( ret == NULL )
    3269                 ret = tr_new( tr_peer *, peerCount );
     3266    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek (&t->peers, &peerCount);
     3267
     3268    assert (torrentIsLocked (t));
     3269
     3270    for (i = outsize = 0; i < peerCount; ++i) {
     3271        if (shouldPeerBeClosed (t, peers[i], peerCount, now_sec)) {
     3272            if (ret == NULL)
     3273                ret = tr_new (tr_peer *, peerCount);
    32703274            ret[outsize++] = peers[i];
    32713275        }
     
    32773281
    32783282static int
    3279 getReconnectIntervalSecs( const struct peer_atom * atom, const time_t now )
     3283getReconnectIntervalSecs (const struct peer_atom * atom, const time_t now)
    32803284{
    32813285    int sec;
     
    32843288     * data, try to reconnect to them sooner rather that later -- we don't
    32853289     * want network troubles to get in the way of a good peer. */
    3286     if( ( now - atom->piece_data_time ) <= ( MINIMUM_RECONNECT_INTERVAL_SECS * 2 ) )
     3290    if ((now - atom->piece_data_time) <= (MINIMUM_RECONNECT_INTERVAL_SECS * 2))
    32873291        sec = MINIMUM_RECONNECT_INTERVAL_SECS;
    32883292
    32893293    /* don't allow reconnects more often than our minimum */
    3290     else if( ( now - atom->time ) < MINIMUM_RECONNECT_INTERVAL_SECS )
     3294    else if ((now - atom->time) < MINIMUM_RECONNECT_INTERVAL_SECS)
    32913295        sec = MINIMUM_RECONNECT_INTERVAL_SECS;
    32923296
    32933297    /* otherwise, the interval depends on how many times we've tried
    32943298     * and failed to connect to the peer */
    3295     else switch( atom->numFails ) {
     3299    else switch (atom->numFails) {
    32963300        case 0: sec = 0; break;
    32973301        case 1: sec = 5; break;
     
    33043308
    33053309    /* penalize peers that were unreachable the last time we tried */
    3306     if( atom->flags2 & MYFLAG_UNREACHABLE )
     3310    if (atom->flags2 & MYFLAG_UNREACHABLE)
    33073311        sec += sec;
    33083312
    3309     dbgmsg( "reconnect interval for %s is %d seconds", tr_atomAddrStr( atom ), sec );
     3313    dbgmsg ("reconnect interval for %s is %d seconds", tr_atomAddrStr (atom), sec);
    33103314    return sec;
    33113315}
    33123316
    33133317static void
    3314 removePeer( Torrent * t, tr_peer * peer )
     3318removePeer (Torrent * t, tr_peer * peer)
    33153319{
    33163320    tr_peer * removed;
    33173321    struct peer_atom * atom = peer->atom;
    33183322
    3319     assert( torrentIsLocked( t ) );
    3320     assert( atom );
    3321 
    3322     atom->time = tr_time( );
    3323 
    3324     removed = tr_ptrArrayRemoveSorted( &t->peers, peer, peerCompare );
    3325 
    3326     if( replicationExists( t ) )
    3327         tr_decrReplicationFromBitfield( t, &peer->have );
    3328 
    3329     assert( removed == peer );
    3330     peerDelete( t, removed );
    3331 }
    3332 
    3333 static void
    3334 closePeer( Torrent * t, tr_peer * peer )
     3323    assert (torrentIsLocked (t));
     3324    assert (atom);
     3325
     3326    atom->time = tr_time ();
     3327
     3328    removed = tr_ptrArrayRemoveSorted (&t->peers, peer, peerCompare);
     3329
     3330    if (replicationExists (t))
     3331        tr_decrReplicationFromBitfield (t, &peer->have);
     3332
     3333    assert (removed == peer);
     3334    peerDelete (t, removed);
     3335}
     3336
     3337static void
     3338closePeer (Torrent * t, tr_peer * peer)
    33353339{
    33363340    struct peer_atom * atom;
    33373341
    3338     assert( t != NULL );
    3339     assert( peer != NULL );
     3342    assert (t != NULL);
     3343    assert (peer != NULL);
    33403344
    33413345    atom = peer->atom;
     
    33443348       so reset their `numFails' weight to zero. otherwise we connected
    33453349       to them fruitlessly, so mark it as another fail */
    3346     if( atom->piece_data_time ) {
    3347         tordbg( t, "resetting atom %s numFails to 0", tr_atomAddrStr(atom) );
     3350    if (atom->piece_data_time) {
     3351        tordbg (t, "resetting atom %s numFails to 0", tr_atomAddrStr (atom));
    33483352        atom->numFails = 0;
    33493353    } else {
    33503354        ++atom->numFails;
    3351         tordbg( t, "incremented atom %s numFails to %d", tr_atomAddrStr(atom), (int)atom->numFails );
    3352     }
    3353 
    3354     tordbg( t, "removing bad peer %s", tr_peerIoGetAddrStr( peer->io ) );
    3355     removePeer( t, peer );
    3356 }
    3357 
    3358 static void
    3359 removeAllPeers( Torrent * t )
    3360 {
    3361     while( !tr_ptrArrayEmpty( &t->peers ) )
    3362         removePeer( t, tr_ptrArrayNth( &t->peers, 0 ) );
    3363 }
    3364 
    3365 static void
    3366 closeBadPeers( Torrent * t, const time_t now_sec )
    3367 {
    3368     if( !tr_ptrArrayEmpty( &t->peers ) )
     3355        tordbg (t, "incremented atom %s numFails to %d", tr_atomAddrStr (atom), (int)atom->numFails);
     3356    }
     3357
     3358    tordbg (t, "removing bad peer %s", tr_peerIoGetAddrStr (peer->io));
     3359    removePeer (t, peer);
     3360}
     3361
     3362static void
     3363removeAllPeers (Torrent * t)
     3364{
     3365    while (!tr_ptrArrayEmpty (&t->peers))
     3366        removePeer (t, tr_ptrArrayNth (&t->peers, 0));
     3367}
     3368
     3369static void
     3370closeBadPeers (Torrent * t, const time_t now_sec)
     3371{
     3372    if (!tr_ptrArrayEmpty (&t->peers))
    33693373    {
    33703374        int i;
    33713375        int peerCount;
    3372         struct tr_peer ** peers = getPeersToClose( t, now_sec, &peerCount );
    3373         for( i=0; i<peerCount; ++i )
    3374             closePeer( t, peers[i] );
    3375         tr_free( peers );
     3376        struct tr_peer ** peers = getPeersToClose (t, now_sec, &peerCount);
     3377        for (i=0; i<peerCount; ++i)
     3378            closePeer (t, peers[i]);
     3379        tr_free (peers);
    33763380    }
    33773381}
     
    33883392
    33893393static int
    3390 comparePeerLiveliness( const void * va, const void * vb )
     3394comparePeerLiveliness (const void * va, const void * vb)
    33913395{
    33923396    const struct peer_liveliness * a = va;
    33933397    const struct peer_liveliness * b = vb;
    33943398
    3395     if( a->doPurge != b->doPurge )
     3399    if (a->doPurge != b->doPurge)
    33963400        return a->doPurge ? 1 : -1;
    33973401
    3398     if( a->speed != b->speed ) /* faster goes first */
     3402    if (a->speed != b->speed) /* faster goes first */
    33993403        return a->speed > b->speed ? -1 : 1;
    34003404
    34013405    /* the one to give us data more recently goes first */
    3402     if( a->pieceDataTime != b->pieceDataTime )
     3406    if (a->pieceDataTime != b->pieceDataTime)
    34033407        return a->pieceDataTime > b->pieceDataTime ? -1 : 1;
    34043408
    34053409    /* the one we connected to most recently goes first */
    3406     if( a->time != b->time )
     3410    if (a->time != b->time)
    34073411        return a->time > b->time ? -1 : 1;
    34083412
     
    34113415
    34123416static void
    3413 sortPeersByLivelinessImpl( tr_peer  ** peers,
     3417sortPeersByLivelinessImpl (tr_peer  ** peers,
    34143418                           void     ** clientData,
    34153419                           int         n,
    34163420                           uint64_t    now,
    3417                            int (*compare) ( const void *va, const void *vb ) )
     3421                           int (*compare)(const void *va, const void *vb))
    34183422{
    34193423    int i;
     
    34213425
    34223426    /* build a sortable array of peer + extra info */
    3423     lives = l = tr_new0( struct peer_liveliness, n );
    3424     for( i=0; i<n; ++i, ++l )
     3427    lives = l = tr_new0 (struct peer_liveliness, n);
     3428    for (i=0; i<n; ++i, ++l)
    34253429    {
    34263430        tr_peer * p = peers[i];
     
    34293433        l->pieceDataTime = p->atom->piece_data_time;
    34303434        l->time = p->atom->time;
    3431         l->speed = tr_peerGetPieceSpeed_Bps( p, now, TR_UP )
    3432                  + tr_peerGetPieceSpeed_Bps( p, now, TR_DOWN );
    3433         if( clientData )
     3435        l->speed = tr_peerGetPieceSpeed_Bps (p, now, TR_UP)
     3436                 + tr_peerGetPieceSpeed_Bps (p, now, TR_DOWN);
     3437        if (clientData)
    34343438            l->clientData = clientData[i];
    34353439    }
    34363440
    34373441    /* sort 'em */
    3438     assert( n == ( l - lives ) );
    3439     qsort( lives, n, sizeof( struct peer_liveliness ), compare );
     3442    assert (n == (l - lives));
     3443    qsort (lives, n, sizeof (struct peer_liveliness), compare);
    34403444
    34413445    /* build the peer array */
    3442     for( i=0, l=lives; i<n; ++i, ++l ) {
     3446    for (i=0, l=lives; i<n; ++i, ++l) {
    34433447        peers[i] = l->peer;
    3444         if( clientData )
     3448        if (clientData)
    34453449            clientData[i] = l->clientData;
    34463450    }
    3447     assert( n == ( l - lives ) );
     3451    assert (n == (l - lives));
    34483452
    34493453    /* cleanup */
    3450     tr_free( lives );
    3451 }
    3452 
    3453 static void
    3454 sortPeersByLiveliness( tr_peer ** peers, void ** clientData, int n, uint64_t now )
    3455 {
    3456     sortPeersByLivelinessImpl( peers, clientData, n, now, comparePeerLiveliness );
    3457 }
    3458 
    3459 
    3460 static void
    3461 enforceTorrentPeerLimit( Torrent * t, uint64_t now )
    3462 {
    3463     int n = tr_ptrArraySize( &t->peers );
    3464     const int max = tr_torrentGetPeerLimit( t->tor );
    3465     if( n > max )
    3466     {
    3467         void * base = tr_ptrArrayBase( &t->peers );
    3468         tr_peer ** peers = tr_memdup( base, n*sizeof( tr_peer* ) );
    3469         sortPeersByLiveliness( peers, NULL, n, now );
    3470         while( n > max )
    3471             closePeer( t, peers[--n] );
    3472         tr_free( peers );
    3473     }
    3474 }
    3475 
    3476 static void
    3477 enforceSessionPeerLimit( tr_session * session, uint64_t now )
     3454    tr_free (lives);
     3455}
     3456
     3457static void
     3458sortPeersByLiveliness (tr_peer ** peers, void ** clientData, int n, uint64_t now)
     3459{
     3460    sortPeersByLivelinessImpl (peers, clientData, n, now, comparePeerLiveliness);
     3461}
     3462
     3463
     3464static void
     3465enforceTorrentPeerLimit (Torrent * t, uint64_t now)
     3466{
     3467    int n = tr_ptrArraySize (&t->peers);
     3468    const int max = tr_torrentGetPeerLimit (t->tor);
     3469    if (n > max)
     3470    {
     3471        void * base = tr_ptrArrayBase (&t->peers);
     3472        tr_peer ** peers = tr_memdup (base, n*sizeof (tr_peer*));
     3473        sortPeersByLiveliness (peers, NULL, n, now);
     3474        while (n > max)
     3475            closePeer (t, peers[--n]);
     3476        tr_free (peers);
     3477    }
     3478}
     3479
     3480static void
     3481enforceSessionPeerLimit (tr_session * session, uint64_t now)
    34783482{
    34793483    int n = 0;
    34803484    tr_torrent * tor = NULL;
    3481     const int max = tr_sessionGetPeerLimit( session );
     3485    const int max = tr_sessionGetPeerLimit (session);
    34823486
    34833487    /* count the total number of peers */
    3484     while(( tor = tr_torrentNext( session, tor )))
    3485         n += tr_ptrArraySize( &tor->torrentPeers->peers );
     3488    while ((tor = tr_torrentNext (session, tor)))
     3489        n += tr_ptrArraySize (&tor->torrentPeers->peers);
    34863490
    34873491    /* if there are too many, prune out the worst */
    3488     if( n > max )
    3489     {
    3490         tr_peer ** peers = tr_new( tr_peer*, n );
    3491         Torrent ** torrents = tr_new( Torrent*, n );
     3492    if (n > max)
     3493    {
     3494        tr_peer ** peers = tr_new (tr_peer*, n);
     3495        Torrent ** torrents = tr_new (Torrent*, n);
    34923496
    34933497        /* populate the peer array */
    34943498        n = 0;
    34953499        tor = NULL;
    3496         while(( tor = tr_torrentNext( session, tor ))) {
     3500        while ((tor = tr_torrentNext (session, tor))) {
    34973501            int i;
    34983502            Torrent * t = tor->torrentPeers;
    3499             const int tn = tr_ptrArraySize( &t->peers );
    3500             for( i=0; i<tn; ++i, ++n ) {
    3501                 peers[n] = tr_ptrArrayNth( &t->peers, i );
     3503            const int tn = tr_ptrArraySize (&t->peers);
     3504            for (i=0; i<tn; ++i, ++n) {
     3505                peers[n] = tr_ptrArrayNth (&t->peers, i);
    35023506                torrents[n] = t;
    35033507            }
     
    35053509
    35063510        /* sort 'em */
    3507         sortPeersByLiveliness( peers, (void**)torrents, n, now );
     3511        sortPeersByLiveliness (peers, (void**)torrents, n, now);
    35083512
    35093513        /* cull out the crappiest */
    3510         while( n-- > max )
    3511             closePeer( torrents[n], peers[n] );
     3514        while (n-- > max)
     3515            closePeer (torrents[n], peers[n]);
    35123516
    35133517        /* cleanup */
    3514         tr_free( torrents );
    3515         tr_free( peers );
    3516     }
    3517 }
    3518 
    3519 static void makeNewPeerConnections( tr_peerMgr * mgr, const int max );
    3520 
    3521 static void
    3522 reconnectPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
     3518        tr_free (torrents);
     3519        tr_free (peers);
     3520    }
     3521}
     3522
     3523static void makeNewPeerConnections (tr_peerMgr * mgr, const int max);
     3524
     3525static void
     3526reconnectPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
    35233527{
    35243528    tr_torrent * tor;
    35253529    tr_peerMgr * mgr = vmgr;
    3526     const time_t now_sec = tr_time( );
    3527     const uint64_t now_msec = tr_time_msec( );
     3530    const time_t now_sec = tr_time ();
     3531    const uint64_t now_msec = tr_time_msec ();
    35283532
    35293533    /**
     
    35333537    /* if we're over the per-torrent peer limits, cull some peers */
    35343538    tor = NULL;
    3535     while(( tor = tr_torrentNext( mgr->session, tor )))
    3536         if( tor->isRunning )
    3537             enforceTorrentPeerLimit( tor->torrentPeers, now_msec );
     3539    while ((tor = tr_torrentNext (mgr->session, tor)))
     3540        if (tor->isRunning)
     3541            enforceTorrentPeerLimit (tor->torrentPeers, now_msec);
    35383542
    35393543    /* if we're over the per-session peer limits, cull some peers */
    3540     enforceSessionPeerLimit( mgr->session, now_msec );
     3544    enforceSessionPeerLimit (mgr->session, now_msec);
    35413545
    35423546    /* remove crappy peers */
    35433547    tor = NULL;
    3544     while(( tor = tr_torrentNext( mgr->session, tor )))
    3545         if( !tor->torrentPeers->isRunning )
    3546             removeAllPeers( tor->torrentPeers );
     3548    while ((tor = tr_torrentNext (mgr->session, tor)))
     3549        if (!tor->torrentPeers->isRunning)
     3550            removeAllPeers (tor->torrentPeers);
    35473551        else
    3548             closeBadPeers( tor->torrentPeers, now_sec );
     3552            closeBadPeers (tor->torrentPeers, now_sec);
    35493553
    35503554    /* try to make new peer connections */
    3551     makeNewPeerConnections( mgr, MAX_CONNECTIONS_PER_PULSE );
     3555    makeNewPeerConnections (mgr, MAX_CONNECTIONS_PER_PULSE);
    35523556}
    35533557
     
    35593563
    35603564static void
    3561 pumpAllPeers( tr_peerMgr * mgr )
     3565pumpAllPeers (tr_peerMgr * mgr)
    35623566{
    35633567    tr_torrent * tor = NULL;
    35643568
    3565     while(( tor = tr_torrentNext( mgr->session, tor )))
     3569    while ((tor = tr_torrentNext (mgr->session, tor)))
    35663570    {
    35673571        int j;
    35683572        Torrent * t = tor->torrentPeers;
    35693573
    3570         for( j=0; j<tr_ptrArraySize( &t->peers ); ++j )
     3574        for (j=0; j<tr_ptrArraySize (&t->peers); ++j)
    35713575        {
    3572             tr_peer * peer = tr_ptrArrayNth( &t->peers, j );
    3573             tr_peerMsgsPulse( peer->msgs );
     3576            tr_peer * peer = tr_ptrArrayNth (&t->peers, j);
     3577            tr_peerMsgsPulse (peer->msgs);
    35743578        }
    35753579    }
     
    35773581
    35783582static void
    3579 queuePulse( tr_session * session, tr_direction dir )
    3580 {
    3581     assert( tr_isSession( session ) );
    3582     assert( tr_isDirection( dir ) );
    3583 
    3584     if( tr_sessionGetQueueEnabled( session, dir ) )
     3583queuePulse (tr_session * session, tr_direction dir)
     3584{
     3585    assert (tr_isSession (session));
     3586    assert (tr_isDirection (dir));
     3587
     3588    if (tr_sessionGetQueueEnabled (session, dir))
    35853589    {
    35863590        int i;
    3587         const int n = tr_sessionCountQueueFreeSlots( session, dir );
    3588         for( i=0; i<n; i++ ) {
    3589             tr_torrent * tor = tr_sessionGetNextQueuedTorrent( session, dir );
    3590             if( tor != NULL ) {
    3591                 tr_torrentStartNow( tor );
    3592                 if( tor->queue_started_callback != NULL )
    3593                     (*tor->queue_started_callback)( tor, tor->queue_started_user_data );
     3591        const int n = tr_sessionCountQueueFreeSlots (session, dir);
     3592        for (i=0; i<n; i++) {
     3593            tr_torrent * tor = tr_sessionGetNextQueuedTorrent (session, dir);
     3594            if (tor != NULL) {
     3595                tr_torrentStartNow (tor);
     3596                if (tor->queue_started_callback != NULL)
     3597                  (*tor->queue_started_callback)(tor, tor->queue_started_user_data);
    35943598            }
    35953599        }
     
    35983602
    35993603static void
    3600 bandwidthPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
     3604bandwidthPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
    36013605{
    36023606    tr_torrent * tor;
    36033607    tr_peerMgr * mgr = vmgr;
    36043608    tr_session * session = mgr->session;
    3605     managerLock( mgr );
     3609    managerLock (mgr);
    36063610
    36073611    /* FIXME: this next line probably isn't necessary... */
    3608     pumpAllPeers( mgr );
     3612    pumpAllPeers (mgr);
    36093613
    36103614    /* allocate bandwidth to the peers */
    3611     tr_bandwidthAllocate( &session->bandwidth, TR_UP, BANDWIDTH_PERIOD_MSEC );
    3612     tr_bandwidthAllocate( &session->bandwidth, TR_DOWN, BANDWIDTH_PERIOD_MSEC );
     3615    tr_bandwidthAllocate (&session->bandwidth, TR_UP, BANDWIDTH_PERIOD_MSEC);
     3616    tr_bandwidthAllocate (&session->bandwidth, TR_DOWN, BANDWIDTH_PERIOD_MSEC);
    36133617
    36143618    /* torrent upkeep */
    36153619    tor = NULL;
    3616     while(( tor = tr_torrentNext( session, tor )))
     3620    while ((tor = tr_torrentNext (session, tor)))
    36173621    {
    36183622        /* possibly stop torrents that have seeded enough */
    3619         tr_torrentCheckSeedLimit( tor );
     3623        tr_torrentCheckSeedLimit (tor);
    36203624
    36213625        /* run the completeness check for any torrents that need it */
    3622         if( tor->torrentPeers->needsCompletenessCheck ) {
     3626        if (tor->torrentPeers->needsCompletenessCheck) {
    36233627            tor->torrentPeers->needsCompletenessCheck  = false;
    3624             tr_torrentRecheckCompleteness( tor );
     3628            tr_torrentRecheckCompleteness (tor);
    36253629        }
    36263630
    36273631        /* stop torrents that are ready to stop, but couldn't be stopped
    36283632           earlier during the peer-io callback call chain */
    3629         if( tor->isStopping )
    3630             tr_torrentStop( tor );
     3633        if (tor->isStopping)
     3634            tr_torrentStop (tor);
    36313635    }
    36323636
    36333637    /* pump the queues */
    3634     queuePulse( session, TR_UP );
    3635     queuePulse( session, TR_DOWN );
    3636 
    3637     reconnectPulse( 0, 0, mgr );
    3638 
    3639     tr_timerAddMsec( mgr->bandwidthTimer, BANDWIDTH_PERIOD_MSEC );
    3640     managerUnlock( mgr );
     3638    queuePulse (session, TR_UP);
     3639    queuePulse (session, TR_DOWN);
     3640
     3641    reconnectPulse (0, 0, mgr);
     3642
     3643    tr_timerAddMsec (mgr->bandwidthTimer, BANDWIDTH_PERIOD_MSEC);
     3644    managerUnlock (mgr);
    36413645}
    36423646
     
    36463650
    36473651static int
    3648 compareAtomPtrsByAddress( const void * va, const void *vb )
     3652compareAtomPtrsByAddress (const void * va, const void *vb)
    36493653{
    36503654    const struct peer_atom * a = * (const struct peer_atom**) va;
    36513655    const struct peer_atom * b = * (const struct peer_atom**) vb;
    36523656
    3653     assert( tr_isAtom( a ) );
    3654     assert( tr_isAtom( b ) );
    3655 
    3656     return tr_address_compare( &a->addr, &b->addr );
     3657    assert (tr_isAtom (a));
     3658    assert (tr_isAtom (b));
     3659
     3660    return tr_address_compare (&a->addr, &b->addr);
    36573661}
    36583662
    36593663/* best come first, worst go last */
    36603664static int
    3661 compareAtomPtrsByShelfDate( const void * va, const void *vb )
     3665compareAtomPtrsByShelfDate (const void * va, const void *vb)
    36623666{
    36633667    time_t atime;
     
    36663670    const struct peer_atom * b = * (const struct peer_atom**) vb;
    36673671    const int data_time_cutoff_secs = 60 * 60;
    3668     const time_t tr_now = tr_time( );
    3669 
    3670     assert( tr_isAtom( a ) );
    3671     assert( tr_isAtom( b ) );
     3672    const time_t tr_now = tr_time ();
     3673
     3674    assert (tr_isAtom (a));
     3675    assert (tr_isAtom (b));
    36723676
    36733677    /* primary key: the last piece data time *if* it was within the last hour */
    3674     atime = a->piece_data_time; if( atime + data_time_cutoff_secs < tr_now ) atime = 0;
    3675     btime = b->piece_data_time; if( btime + data_time_cutoff_secs < tr_now ) btime = 0;
    3676     if( atime != btime )
     3678    atime = a->piece_data_time; if (atime + data_time_cutoff_secs < tr_now) atime = 0;
     3679    btime = b->piece_data_time; if (btime + data_time_cutoff_secs < tr_now) btime = 0;
     3680    if (atime != btime)
    36773681        return atime > btime ? -1 : 1;
    36783682
    36793683    /* secondary key: shelf date. */
    3680     if( a->shelf_date != b->shelf_date )
     3684    if (a->shelf_date != b->shelf_date)
    36813685        return a->shelf_date > b->shelf_date ? -1 : 1;
    36823686
     
    36853689
    36863690static int
    3687 getMaxAtomCount( const tr_torrent * tor )
     3691getMaxAtomCount (const tr_torrent * tor)
    36883692{
    36893693    const int n = tor->maxConnectedPeers;
    36903694    /* approximate fit of the old jump discontinuous function */
    3691     if( n >= 55 ) return     n + 150;
    3692     if( n >= 20 ) return 2 * n + 95;
     3695    if (n >= 55) return     n + 150;
     3696    if (n >= 20) return 2 * n + 95;
    36933697    return               4 * n + 55;
    36943698}
    36953699
    36963700static void
    3697 atomPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
     3701atomPulse (int foo UNUSED, short bar UNUSED, void * vmgr)
    36983702{
    36993703    tr_torrent * tor = NULL;
    37003704    tr_peerMgr * mgr = vmgr;
    3701     managerLock( mgr );
    3702 
    3703     while(( tor = tr_torrentNext( mgr->session, tor )))
     3705    managerLock (mgr);
     3706
     3707    while ((tor = tr_torrentNext (mgr->session, tor)))
    37043708    {
    37053709        int atomCount;
    37063710        Torrent * t = tor->torrentPeers;
    3707         const int maxAtomCount = getMaxAtomCount( tor );
    3708         struct peer_atom ** atoms = (struct peer_atom**) tr_ptrArrayPeek( &t->pool, &atomCount );
    3709 
    3710         if( atomCount > maxAtomCount ) /* we've got too many atoms... time to prune */
     3711        const int maxAtomCount = getMaxAtomCount (tor);
     3712        struct peer_atom ** atoms = (struct peer_atom**) tr_ptrArrayPeek (&t->pool, &atomCount);
     3713
     3714        if (atomCount > maxAtomCount) /* we've got too many atoms... time to prune */
    37113715        {
    37123716            int i;
    37133717            int keepCount = 0;
    37143718            int testCount = 0;
    3715             struct peer_atom ** keep = tr_new( struct peer_atom*, atomCount );
    3716             struct peer_atom ** test = tr_new( struct peer_atom*, atomCount );
     3719            struct peer_atom ** keep = tr_new (struct peer_atom*, atomCount);
     3720            struct peer_atom ** test = tr_new (struct peer_atom*, atomCount);
    37173721
    37183722            /* keep the ones that are in use */
    3719             for( i=0; i<atomCount; ++i ) {
     3723            for (i=0; i<atomCount; ++i) {
    37203724                struct peer_atom * atom = atoms[i];
    3721                 if( peerIsInUse( t, atom ) )
     3725                if (peerIsInUse (t, atom))
    37223726                    keep[keepCount++] = atom;
    37233727                else
     
    37273731            /* if there's room, keep the best of what's left */
    37283732            i = 0;
    3729             if( keepCount < maxAtomCount ) {
    3730                 qsort( test, testCount, sizeof( struct peer_atom * ), compareAtomPtrsByShelfDate );
    3731                 while( i<testCount && keepCount<maxAtomCount )
     3733            if (keepCount < maxAtomCount) {
     3734                qsort (test, testCount, sizeof (struct peer_atom *), compareAtomPtrsByShelfDate);
     3735                while (i<testCount && keepCount<maxAtomCount)
    37323736                    keep[keepCount++] = test[i++];
    37333737            }
    37343738
    37353739            /* free the culled atoms */
    3736             while( i<testCount )
    3737                 tr_free( test[i++] );
     3740            while (i<testCount)
     3741                tr_free (test[i++]);
    37383742
    37393743            /* rebuild Torrent.pool with what's left */
    3740             tr_ptrArrayDestruct( &t->pool, NULL );
     3744            tr_ptrArrayDestruct (&t->pool, NULL);
    37413745            t->pool = TR_PTR_ARRAY_INIT;
    3742             qsort( keep, keepCount, sizeof( struct peer_atom * ), compareAtomPtrsByAddress );
    3743             for( i=0; i<keepCount; ++i )
    3744                 tr_ptrArrayAppend( &t->pool, keep[i] );
    3745 
    3746             tordbg( t, "max atom count is %d... pruned from %d to %d\n", maxAtomCount, atomCount, keepCount );
     3746            qsort (keep, keepCount, sizeof (struct peer_atom *), compareAtomPtrsByAddress);
     3747            for (i=0; i<keepCount; ++i)
     3748                tr_ptrArrayAppend (&t->pool, keep[i]);
     3749
     3750            tordbg (t, "max atom count is %d... pruned from %d to %d\n", maxAtomCount, atomCount, keepCount);
    37473751
    37483752            /* cleanup */
    3749             tr_free( test );
    3750             tr_free( keep );
     3753            tr_free (test);
     3754            tr_free (keep);
    37513755        }
    37523756    }
    37533757
    3754     tr_timerAddMsec( mgr->atomTimer, ATOM_PERIOD_MSEC );
    3755     managerUnlock( mgr );
     3758    tr_timerAddMsec (mgr->atomTimer, ATOM_PERIOD_MSEC);
     3759    managerUnlock (mgr);
    37563760}
    37573761
     
    37643768/* is this atom someone that we'd want to initiate a connection to? */
    37653769static bool
    3766 isPeerCandidate( const tr_torrent * tor, struct peer_atom * atom, const time_t now )
     3770isPeerCandidate (const tr_torrent * tor, struct peer_atom * atom, const time_t now)
    37673771{
    37683772    /* not if we're both seeds */
    3769     if( tr_torrentIsSeed( tor ) && atomIsSeed( atom ) )
     3773    if (tr_torrentIsSeed (tor) && atomIsSeed (atom))
    37703774        return false;
    37713775
    37723776    /* not if we've already got a connection to them... */
    3773     if( peerIsInUse( tor->torrentPeers, atom ) )
     3777    if (peerIsInUse (tor->torrentPeers, atom))
    37743778        return false;
    37753779
    37763780    /* not if we just tried them already */
    3777     if( ( now - atom->time ) < getReconnectIntervalSecs( atom, now ) )
     3781    if ((now - atom->time) < getReconnectIntervalSecs (atom, now))
    37783782        return false;
    37793783
    37803784    /* not if they're blocklisted */
    3781     if( isAtomBlocklisted( tor->session, atom ) )
     3785    if (isAtomBlocklisted (tor->session, atom))
    37823786        return false;
    37833787
    37843788    /* not if they're banned... */
    3785     if( atom->flags2 & MYFLAG_BANNED )
     3789    if (atom->flags2 & MYFLAG_BANNED)
    37863790        return false;
    37873791
     
    37973801
    37983802static bool
    3799 torrentWasRecentlyStarted( const tr_torrent * tor )
    3800 {
    3801     return difftime( tr_time( ), tor->startDate ) < 120;
     3803torrentWasRecentlyStarted (const tr_torrent * tor)
     3804{
     3805    return difftime (tr_time (), tor->startDate) < 120;
    38023806}
    38033807
    38043808static inline uint64_t
    3805 addValToKey( uint64_t value, int width, uint64_t addme )
     3809addValToKey (uint64_t value, int width, uint64_t addme)
    38063810{
    38073811    value = (value << (uint64_t)width);
     
    38123816/* smaller value is better */
    38133817static uint64_t
    3814 getPeerCandidateScore( const tr_torrent * tor, const struct peer_atom * atom, uint8_t salt  )
     3818getPeerCandidateScore (const tr_torrent * tor, const struct peer_atom * atom, uint8_t salt)
    38153819{
    38163820    uint64_t i;
     
    38203824    /* prefer peers we've connected to, or never tried, over peers we failed to connect to. */
    38213825    i = failed ? 1 : 0;
    3822     score = addValToKey( score, 1, i );
     3826    score = addValToKey (score, 1, i);
    38233827
    38243828    /* prefer the one we attempted least recently (to cycle through all peers) */
    38253829    i = atom->lastConnectionAttemptAt;
    3826     score = addValToKey( score, 32, i );
     3830    score = addValToKey (score, 32, i);
    38273831
    38283832    /* prefer peers belonging to a torrent of a higher priority */
    3829     switch( tr_torrentGetPriority( tor ) ) {
     3833    switch (tr_torrentGetPriority (tor)) {
    38303834        case TR_PRI_HIGH:    i = 0; break;
    38313835        case TR_PRI_NORMAL:  i = 1; break;
    38323836        case TR_PRI_LOW:     i = 2; break;
    38333837    }
    3834     score = addValToKey( score, 4, i );
     3838    score = addValToKey (score, 4, i);
    38353839
    38363840    /* prefer recently-started torrents */
    3837     i = torrentWasRecentlyStarted( tor ) ? 0 : 1;
    3838     score = addValToKey( score, 1, i );
     3841    i = torrentWasRecentlyStarted (tor) ? 0 : 1;
     3842    score = addValToKey (score, 1, i);
    38393843
    38403844    /* prefer torrents we're downloading with */
    3841     i = tr_torrentIsSeed( tor ) ? 1 : 0;
    3842     score = addValToKey( score, 1, i );
     3845    i = tr_torrentIsSeed (tor) ? 1 : 0;
     3846    score = addValToKey (score, 1, i);
    38433847
    38443848    /* prefer peers that are known to be connectible */
    3845     i = ( atom->flags & ADDED_F_CONNECTABLE ) ? 0 : 1;
    3846     score = addValToKey( score, 1, i );
     3849    i = (atom->flags & ADDED_F_CONNECTABLE) ? 0 : 1;
     3850    score = addValToKey (score, 1, i);
    38473851
    38483852    /* prefer peers that we might have a chance of uploading to...
    38493853       so lower seed probability is better */
    3850     if( atom->seedProbability == 100 ) i = 101;
    3851     else if( atom->seedProbability == -1 ) i = 100;
     3854    if (atom->seedProbability == 100) i = 101;
     3855    else if (atom->seedProbability == -1) i = 100;
    38523856    else i = atom->seedProbability;
    3853     score = addValToKey( score, 8, i );
     3857    score = addValToKey (score, 8, i);
    38543858
    38553859    /* Prefer peers that we got from more trusted sources.
    38563860     * lower `fromBest' values indicate more trusted sources */
    3857     score = addValToKey( score, 4, atom->fromBest );
     3861    score = addValToKey (score, 4, atom->fromBest);
    38583862
    38593863    /* salt */
    3860     score = addValToKey( score, 8, salt );
     3864    score = addValToKey (score, 8, salt);
    38613865
    38623866    return score;
     
    38653869#ifndef NDEBUG
    38663870static int
    3867 checkPartition( const struct peer_candidate * candidates, int left, int right, uint64_t pivotScore, int storeIndex )
     3871checkPartition (const struct peer_candidate * candidates, int left, int right, uint64_t pivotScore, int storeIndex)
    38683872{
    38693873    int i;
    38703874
    3871     assert( storeIndex >= left );
    3872     assert( storeIndex <= right );
    3873     assert( candidates[storeIndex].score == pivotScore );
    3874 
    3875     for( i=left; i<storeIndex; ++i )
    3876         assert( candidates[i].score < pivotScore );
    3877     for( i=storeIndex+1; i<=right; ++i )
    3878         assert( candidates[i].score >= pivotScore );
     3875    assert (storeIndex >= left);
     3876    assert (storeIndex <= right);
     3877    assert (candidates[storeIndex].score == pivotScore);
     3878
     3879    for (i=left; i<storeIndex; ++i)
     3880        assert (candidates[i].score < pivotScore);
     3881    for (i=storeIndex+1; i<=right; ++i)
     3882        assert (candidates[i].score >= pivotScore);
    38793883
    38803884    return true;
     
    38823886#endif
    38833887
    3884 /* Helper to selectBestCandidates().
     3888/* Helper to selectBestCandidates ().
    38853889 * Adapted from http://en.wikipedia.org/wiki/Selection_algorithm */
    38863890static int
    3887 partitionPeerCandidates( struct peer_candidate * candidates, int left, int right, int pivotIndex )
     3891partitionPeerCandidates (struct peer_candidate * candidates, int left, int right, int pivotIndex)
    38883892{
    38893893    int i;
     
    38983902
    38993903    storeIndex = left;
    3900     for( i=left; i<=right; ++i )
    3901     {
    3902         if( candidates[i].score < pivotValue.score )
     3904    for (i=left; i<=right; ++i)
     3905    {
     3906        if (candidates[i].score < pivotValue.score)
    39033907        {
    39043908            tmp = candidates[storeIndex];
     
    39153919
    39163920    /* sanity check */
    3917     assert( checkPartition( candidates, left, right, pivotValue.score, storeIndex ) );
     3921    assert (checkPartition (candidates, left, right, pivotValue.score, storeIndex));
    39183922
    39193923    return storeIndex;
     
    39223926/* Adapted from http://en.wikipedia.org/wiki/Selection_algorithm */
    39233927static void
    3924 selectPeerCandidates( struct peer_candidate * candidates, int left, int right, int k )
    3925 {
    3926     if( right > left )
     3928selectPeerCandidates (struct peer_candidate * candidates, int left, int right, int k)
     3929{
     3930    if (right > left)
    39273931    {
    39283932        const int pivotIndex = left + (right-left)/2;
    39293933
    3930         int pivotNewIndex = partitionPeerCandidates( candidates, left, right, pivotIndex );
    3931 
    3932         if( pivotNewIndex > left + k ) /* new condition */
    3933             selectPeerCandidates( candidates, left, pivotNewIndex-1, k );
    3934         else if( pivotNewIndex < left + k )
    3935             selectPeerCandidates( candidates, pivotNewIndex+1, right, k+left-pivotNewIndex-1 );
     3934        int pivotNewIndex = partitionPeerCandidates (candidates, left, right, pivotIndex);
     3935
     3936        if (pivotNewIndex > left + k) /* new condition */
     3937            selectPeerCandidates (candidates, left, pivotNewIndex-1, k);
     3938        else if (pivotNewIndex < left + k)
     3939            selectPeerCandidates (candidates, pivotNewIndex+1, right, k+left-pivotNewIndex-1);
    39363940    }
    39373941}
     
    39393943#ifndef NDEBUG
    39403944static bool
    3941 checkBestScoresComeFirst( const struct peer_candidate * candidates, int n, int k )
     3945checkBestScoresComeFirst (const struct peer_candidate * candidates, int n, int k)
    39423946{
    39433947    int i;
    39443948    uint64_t worstFirstScore = 0;
    3945     const int x = MIN( n, k ) - 1;
    3946 
    3947     for( i=0; i<x; i++ )
    3948         if( worstFirstScore < candidates[i].score )
     3949    const int x = MIN (n, k) - 1;
     3950
     3951    for (i=0; i<x; i++)
     3952        if (worstFirstScore < candidates[i].score)
    39493953            worstFirstScore = candidates[i].score;
    39503954
    3951     for( i=0; i<x; i++ )
    3952         assert( candidates[i].score <= worstFirstScore );
    3953 
    3954     for( i=x+1; i<n; i++ )
    3955         assert( candidates[i].score >= worstFirstScore );
     3955    for (i=0; i<x; i++)
     3956        assert (candidates[i].score <= worstFirstScore);
     3957
     3958    for (i=x+1; i<n; i++)
     3959        assert (candidates[i].score >= worstFirstScore);
    39563960
    39573961    return true;
     
    39613965/** @return an array of all the atoms we might want to connect to */
    39623966static struct peer_candidate*
    3963 getPeerCandidates( tr_session * session, int * candidateCount, int max )
     3967getPeerCandidates (tr_session * session, int * candidateCount, int max)
    39643968{
    39653969    int atomCount;
     
    39683972    struct peer_candidate * candidates;
    39693973    struct peer_candidate * walk;
    3970     const time_t now = tr_time( );
    3971     const uint64_t now_msec = tr_time_msec( );
     3974    const time_t now = tr_time ();
     3975    const uint64_t now_msec = tr_time_msec ();
    39723976    /* leave 5% of connection slots for incoming connections -- ticket #2609 */
    3973     const int maxCandidates = tr_sessionGetPeerLimit( session ) * 0.95;
     3977    const int maxCandidates = tr_sessionGetPeerLimit (session) * 0.95;
    39743978
    39753979    /* count how many peers and atoms we've got */
     
    39773981    atomCount = 0;
    39783982    peerCount = 0;
    3979     while(( tor = tr_torrentNext( session, tor ))) {
    3980         atomCount += tr_ptrArraySize( &tor->torrentPeers->pool );
    3981         peerCount += tr_ptrArraySize( &tor->torrentPeers->peers );
     3983    while ((tor = tr_torrentNext (session, tor))) {
     3984        atomCount += tr_ptrArraySize (&tor->torrentPeers->pool);
     3985        peerCount += tr_ptrArraySize (&tor->torrentPeers->peers);
    39823986    }
    39833987
    39843988    /* don't start any new handshakes if we're full up */
    3985     if( maxCandidates <= peerCount ) {
     3989    if (maxCandidates <= peerCount) {
    39863990        *candidateCount = 0;
    39873991        return NULL;
     
    39893993
    39903994    /* allocate an array of candidates */
    3991     walk = candidates = tr_new( struct peer_candidate, atomCount );
     3995    walk = candidates = tr_new (struct peer_candidate, atomCount);
    39923996
    39933997    /* populate the candidate array */
    39943998    tor = NULL;
    3995     while(( tor = tr_torrentNext( session, tor )))
     3999    while ((tor = tr_torrentNext (session, tor)))
    39964000    {
    39974001        int i, nAtoms;
    39984002        struct peer_atom ** atoms;
    39994003
    4000         if( !tor->torrentPeers->isRunning )
     4004        if (!tor->torrentPeers->isRunning)
    40014005            continue;
    40024006
    40034007        /* if we've already got enough peers in this torrent... */
    4004         if( tr_torrentGetPeerLimit( tor ) <= tr_ptrArraySize( &tor->torrentPeers->peers ) )
     4008        if (tr_torrentGetPeerLimit (tor) <= tr_ptrArraySize (&tor->torrentPeers->peers))
    40054009            continue;
    40064010
    40074011        /* if we've already got enough speed in this torrent... */
    4008         if( tr_torrentIsSeed( tor ) && isBandwidthMaxedOut( &tor->bandwidth, now_msec, TR_UP ) )
     4012        if (tr_torrentIsSeed (tor) && isBandwidthMaxedOut (&tor->bandwidth, now_msec, TR_UP))
    40094013            continue;
    40104014
    4011         atoms = (struct peer_atom**) tr_ptrArrayPeek( &tor->torrentPeers->pool, &nAtoms );
    4012         for( i=0; i<nAtoms; ++i )
     4015        atoms = (struct peer_atom**) tr_ptrArrayPeek (&tor->torrentPeers->pool, &nAtoms);
     4016        for (i=0; i<nAtoms; ++i)
    40134017        {
    40144018            struct peer_atom * atom = atoms[i];
    40154019
    4016             if( isPeerCandidate( tor, atom, now ) )
     4020            if (isPeerCandidate (tor, atom, now))
    40174021            {
    4018                 const uint8_t salt = tr_cryptoWeakRandInt( 1024 );
     4022                const uint8_t salt = tr_cryptoWeakRandInt (1024);
    40194023                walk->tor = tor;
    40204024                walk->atom = atom;
    4021                 walk->score = getPeerCandidateScore( tor, atom, salt );
     4025                walk->score = getPeerCandidateScore (tor, atom, salt);
    40224026                ++walk;
    40234027            }
     
    40264030
    40274031    *candidateCount = walk - candidates;
    4028     if( walk != candidates )
    4029         selectPeerCandidates( candidates, 0, (walk-candidates)-1, max );
    4030 
    4031     assert( checkBestScoresComeFirst( candidates, *candidateCount, max ) );
     4032    if (walk != candidates)
     4033        selectPeerCandidates (candidates, 0, (walk-candidates)-1, max);
     4034
     4035    assert (checkBestScoresComeFirst (candidates, *candidateCount, max));
    40324036
    40334037    return candidates;
     
    40354039
    40364040static void
    4037 initiateConnection( tr_peerMgr * mgr, Torrent * t, struct peer_atom * atom )
     4041initiateConnection (tr_peerMgr * mgr, Torrent * t, struct peer_atom * atom)
    40384042{
    40394043    tr_peerIo * io;
    4040     const time_t now = tr_time( );
    4041     bool utp = tr_sessionIsUTPEnabled(mgr->session) && !atom->utp_failed;
    4042 
    4043     if( atom->fromFirst == TR_PEER_FROM_PEX )
     4044    const time_t now = tr_time ();
     4045    bool utp = tr_sessionIsUTPEnabled (mgr->session) && !atom->utp_failed;
     4046
     4047    if (atom->fromFirst == TR_PEER_FROM_PEX)
    40444048        /* PEX has explicit signalling for uTP support.  If an atom
    40454049           originally came from PEX and doesn't have the uTP flag, skip the
     
    40474051        utp = utp && (atom->flags & ADDED_F_UTP_FLAGS);
    40484052
    4049     tordbg( t, "Starting an OUTGOING%s connection with %s",
     4053    tordbg (t, "Starting an OUTGOING%s connection with %s",
    40504054            utp ? " µTP" : "",
    4051             tr_atomAddrStr( atom ) );
    4052 
    4053     io = tr_peerIoNewOutgoing( mgr->session,
     4055            tr_atomAddrStr (atom));
     4056
     4057    io = tr_peerIoNewOutgoing (mgr->session,
    40544058                               &mgr->session->bandwidth,
    40554059                               &atom->addr,
     
    40574061                               t->tor->info.hash,
    40584062                               t->tor->completeness == TR_SEED,
    4059                                utp );
    4060 
    4061     if( io == NULL )
    4062     {
    4063         tordbg( t, "peerIo not created; marking peer %s as unreachable",
    4064                 tr_atomAddrStr( atom ) );
     4063                               utp);
     4064
     4065    if (io == NULL)
     4066    {
     4067        tordbg (t, "peerIo not created; marking peer %s as unreachable",
     4068                tr_atomAddrStr (atom));
    40654069        atom->flags2 |= MYFLAG_UNREACHABLE;
    40664070        atom->numFails++;
     
    40684072    else
    40694073    {
    4070         tr_handshake * handshake = tr_handshakeNew( io,
     4074        tr_handshake * handshake = tr_handshakeNew (io,
    40714075                                                    mgr->session->encryptionMode,
    40724076                                                    myHandshakeDoneCB,
    4073                                                     mgr );
    4074 
    4075         assert( tr_peerIoGetTorrentHash( io ) );
    4076 
    4077         tr_peerIoUnref( io ); /* balanced by the initial ref
    4078                                  in tr_peerIoNewOutgoing() */
    4079 
    4080         tr_ptrArrayInsertSorted( &t->outgoingHandshakes, handshake,
    4081                                  handshakeCompare );
     4077                                                    mgr);
     4078
     4079        assert (tr_peerIoGetTorrentHash (io));
     4080
     4081        tr_peerIoUnref (io); /* balanced by the initial ref
     4082                                 in tr_peerIoNewOutgoing () */
     4083
     4084        tr_ptrArrayInsertSorted (&t->outgoingHandshakes, handshake,
     4085                                 handshakeCompare);
    40824086    }
    40834087
     
    40874091
    40884092static void
    4089 initiateCandidateConnection( tr_peerMgr * mgr, struct peer_candidate * c )
     4093initiateCandidateConnection (tr_peerMgr * mgr, struct peer_candidate * c)
    40904094{
    40914095#if 0
    4092     fprintf( stderr, "Starting an OUTGOING connection with %s - [%s] seedProbability==%d; %s, %s\n",
    4093              tr_atomAddrStr( c->atom ),
    4094              tr_torrentName( c->tor ),
    4095              (int)c->atom->seedProbability,
    4096              tr_torrentIsPrivate( c->tor ) ? "private" : "public",
    4097              tr_torrentIsSeed( c->tor ) ? "seed" : "downloader" );
     4096    fprintf (stderr, "Starting an OUTGOING connection with %s - [%s] seedProbability==%d; %s, %s\n",
     4097             tr_atomAddrStr (c->atom),
     4098             tr_torrentName (c->tor),
     4099           (int)c->atom->seedProbability,
     4100             tr_torrentIsPrivate (c->tor) ? "private" : "public",
     4101             tr_torrentIsSeed (c->tor) ? "seed" : "downloader");
    40984102#endif
    40994103
    4100     initiateConnection( mgr, c->tor->torrentPeers, c->atom );
    4101 }
    4102 
    4103 static void
    4104 makeNewPeerConnections( struct tr_peerMgr * mgr, const int max )
     4104    initiateConnection (mgr, c->tor->torrentPeers, c->atom);
     4105}
     4106
     4107static void
     4108makeNewPeerConnections (struct tr_peerMgr * mgr, const int max)
    41054109{
    41064110    int i, n;
    41074111    struct peer_candidate * candidates;
    41084112
    4109     candidates = getPeerCandidates( mgr->session, &n, max );
    4110 
    4111     for( i=0; i<n && i<max; ++i )
    4112         initiateCandidateConnection( mgr, &candidates[i] );
    4113 
    4114     tr_free( candidates );
    4115 }
     4113    candidates = getPeerCandidates (mgr->session, &n, max);
     4114
     4115    for (i=0; i<n && i<max; ++i)
     4116        initiateCandidateConnection (mgr, &candidates[i]);
     4117
     4118    tr_free (candidates);
     4119}
Note: See TracChangeset for help on using the changeset viewer.