source: trunk/libtransmission/peer-mgr.c @ 7224

Last change on this file since 7224 was 7224, checked in by charles, 13 years ago

(libT) janitorial: use the tr_port type whenever we have a `port' as a function argument or as a field in a struct.

  • Property svn:keywords set to Date Rev Author Id
File size: 63.7 KB
Line 
1/*
2 * This file Copyright (C) 2007-2008 Charles Kerr <charles@rebelbase.com>
3 *
4 * 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)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: peer-mgr.c 7224 2008-12-01 20:51:01Z charles $
11 */
12
13#include <assert.h>
14#include <errno.h>
15#include <string.h> /* memcpy, memcmp, strstr */
16#include <stdlib.h> /* qsort */
17#include <limits.h> /* INT_MAX */
18
19#include <event.h>
20
21#include "transmission.h"
22#include "bandwidth.h"
23#include "bencode.h"
24#include "blocklist.h"
25#include "clients.h"
26#include "completion.h"
27#include "crypto.h"
28#include "handshake.h"
29#include "inout.h" /* tr_ioTestPiece */
30#include "net.h"
31#include "peer-io.h"
32#include "peer-mgr.h"
33#include "peer-mgr-private.h"
34#include "peer-msgs.h"
35#include "ptrarray.h"
36#include "stats.h" /* tr_statsAddUploaded, tr_statsAddDownloaded */
37#include "torrent.h"
38#include "trevent.h"
39#include "utils.h"
40#include "webseed.h"
41
42enum
43{
44    /* how frequently to change which peers are choked */
45    RECHOKE_PERIOD_MSEC = ( 10 * 1000 ),
46
47    /* minimum interval for refilling peers' request lists */
48    REFILL_PERIOD_MSEC = 333,
49
50    /* when many peers are available, keep idle ones this long */
51    MIN_UPLOAD_IDLE_SECS = ( 60 * 3 ),
52
53    /* when few peers are available, keep idle ones this long */
54    MAX_UPLOAD_IDLE_SECS = ( 60 * 10 ),
55
56    /* how frequently to decide which peers live and die */
57    RECONNECT_PERIOD_MSEC = ( 2 * 1000 ),
58   
59    /* how frequently to reallocate bandwidth */
60    BANDWIDTH_PERIOD_MSEC = 250,
61
62    /* max # of peers to ask fer per torrent per reconnect pulse */
63    MAX_RECONNECTIONS_PER_PULSE = 4,
64
65    /* max number of peers to ask for per second overall.
66    * this throttle is to avoid overloading the router */
67    MAX_CONNECTIONS_PER_SECOND = 8,
68
69    /* number of unchoked peers per torrent.
70     * FIXME: this probably ought to be configurable */
71    MAX_UNCHOKED_PEERS = 14,
72
73    /* number of bad pieces a peer is allowed to send before we ban them */
74    MAX_BAD_PIECES_PER_PEER = 5,
75
76    /* use for bitwise operations w/peer_atom.myflags */
77    MYFLAG_BANNED = 1,
78
79    /* unreachable for now... but not banned.
80     * if they try to connect to us it's okay */
81    MYFLAG_UNREACHABLE = 2,
82
83    /* the minimum we'll wait before attempting to reconnect to a peer */
84    MINIMUM_RECONNECT_INTERVAL_SECS = 5
85};
86
87
88/**
89***
90**/
91
92/* We keep one of these for every peer we know about, whether
93 * it's connected or not, so the struct must be small.
94 * When our current connections underperform, we dip back
95 * into this list for new ones. */
96struct peer_atom
97{
98    uint8_t           from;
99    uint8_t           flags; /* these match the added_f flags */
100    uint8_t           myflags; /* flags that aren't defined in added_f */
101    tr_port           port;
102    uint16_t          numFails;
103    struct in_addr    addr;
104    time_t            time; /* when the peer's connection status last changed */
105    time_t            piece_data_time;
106};
107
108typedef struct
109{
110    tr_bool         isRunning;
111
112    uint8_t         hash[SHA_DIGEST_LENGTH];
113    int         *   pendingRequestCount;
114    tr_ptrArray *   outgoingHandshakes; /* tr_handshake */
115    tr_ptrArray *   pool; /* struct peer_atom */
116    tr_ptrArray *   peers; /* tr_peer */
117    tr_ptrArray *   webseeds; /* tr_webseed */
118    tr_timer *      reconnectTimer;
119    tr_timer *      rechokeTimer;
120    tr_timer *      refillTimer;
121    tr_torrent *    tor;
122    tr_peer *       optimistic; /* the optimistic peer, or NULL if none */
123
124    struct tr_peerMgr * manager;
125}
126Torrent;
127
128struct tr_peerMgr
129{
130    tr_session      * session;
131    tr_ptrArray     * torrents; /* Torrent */
132    tr_ptrArray     * incomingHandshakes; /* tr_handshake */
133    tr_timer        * bandwidthTimer;
134};
135
136#define tordbg( t, ... ) \
137    do { \
138        if( tr_deepLoggingIsActive( ) ) \
139            tr_deepLog( __FILE__, __LINE__, t->tor->info.name, __VA_ARGS__ ); \
140    } while( 0 )
141
142#define dbgmsg( ... ) \
143    do { \
144        if( tr_deepLoggingIsActive( ) ) \
145            tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
146    } while( 0 )
147
148/**
149***
150**/
151
152static void
153managerLock( const struct tr_peerMgr * manager )
154{
155    tr_globalLock( manager->session );
156}
157
158static void
159managerUnlock( const struct tr_peerMgr * manager )
160{
161    tr_globalUnlock( manager->session );
162}
163
164static void
165torrentLock( Torrent * torrent )
166{
167    managerLock( torrent->manager );
168}
169
170static void
171torrentUnlock( Torrent * torrent )
172{
173    managerUnlock( torrent->manager );
174}
175
176static int
177torrentIsLocked( const Torrent * t )
178{
179    return tr_globalIsLocked( t->manager->session );
180}
181
182/**
183***
184**/
185
186static int
187compareAddresses( const struct in_addr * a,
188                  const struct in_addr * b )
189{
190    if( a->s_addr != b->s_addr )
191        return a->s_addr < b->s_addr ? -1 : 1;
192
193    return 0;
194}
195
196static int
197handshakeCompareToAddr( const void * va,
198                        const void * vb )
199{
200    const tr_handshake * a = va;
201
202    return compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
203}
204
205static int
206handshakeCompare( const void * a,
207                  const void * b )
208{
209    return handshakeCompareToAddr( a, tr_handshakeGetAddr( b, NULL ) );
210}
211
212static tr_handshake*
213getExistingHandshake( tr_ptrArray *          handshakes,
214                      const struct in_addr * in_addr )
215{
216    return tr_ptrArrayFindSorted( handshakes,
217                                  in_addr,
218                                  handshakeCompareToAddr );
219}
220
221static int
222comparePeerAtomToAddress( const void * va,
223                          const void * vb )
224{
225    const struct peer_atom * a = va;
226
227    return compareAddresses( &a->addr, vb );
228}
229
230static int
231comparePeerAtoms( const void * va,
232                  const void * vb )
233{
234    const struct peer_atom * b = vb;
235
236    return comparePeerAtomToAddress( va, &b->addr );
237}
238
239/**
240***
241**/
242
243static int
244torrentCompare( const void * va,
245                const void * vb )
246{
247    const Torrent * a = va;
248    const Torrent * b = vb;
249
250    return memcmp( a->hash, b->hash, SHA_DIGEST_LENGTH );
251}
252
253static int
254torrentCompareToHash( const void * va,
255                      const void * vb )
256{
257    const Torrent * a = va;
258    const uint8_t * b_hash = vb;
259
260    return memcmp( a->hash, b_hash, SHA_DIGEST_LENGTH );
261}
262
263static Torrent*
264getExistingTorrent( tr_peerMgr *    manager,
265                    const uint8_t * hash )
266{
267    return (Torrent*) tr_ptrArrayFindSorted( manager->torrents,
268                                             hash,
269                                             torrentCompareToHash );
270}
271
272static int
273peerCompare( const void * va,
274             const void * vb )
275{
276    const tr_peer * a = va;
277    const tr_peer * b = vb;
278
279    return compareAddresses( &a->in_addr, &b->in_addr );
280}
281
282static int
283peerCompareToAddr( const void * va,
284                   const void * vb )
285{
286    const tr_peer * a = va;
287
288    return compareAddresses( &a->in_addr, vb );
289}
290
291static tr_peer*
292getExistingPeer( Torrent *              torrent,
293                 const struct in_addr * in_addr )
294{
295    assert( torrentIsLocked( torrent ) );
296    assert( in_addr );
297
298    return tr_ptrArrayFindSorted( torrent->peers,
299                                  in_addr,
300                                  peerCompareToAddr );
301}
302
303static struct peer_atom*
304getExistingAtom( const                  Torrent * t,
305                 const struct in_addr * addr )
306{
307    assert( torrentIsLocked( t ) );
308    return tr_ptrArrayFindSorted( t->pool, addr, comparePeerAtomToAddress );
309}
310
311static int
312peerIsInUse( const Torrent *        ct,
313             const struct in_addr * addr )
314{
315    Torrent * t = (Torrent*) ct;
316
317    assert( torrentIsLocked ( t ) );
318
319    return getExistingPeer( t, addr )
320           || getExistingHandshake( t->outgoingHandshakes, addr )
321           || getExistingHandshake( t->manager->incomingHandshakes, addr );
322}
323
324static tr_peer*
325peerConstructor( tr_torrent * tor, const struct in_addr * in_addr )
326{
327    tr_peer * p;
328
329    p = tr_new0( tr_peer, 1 );
330    memcpy( &p->in_addr, in_addr, sizeof( struct in_addr ) );
331    p->bandwidth = tr_bandwidthNew( tor->session, tor->bandwidth );
332    return p;
333}
334
335static tr_peer*
336getPeer( Torrent *              torrent,
337         const struct in_addr * in_addr )
338{
339    tr_peer * peer;
340
341    assert( torrentIsLocked( torrent ) );
342
343    peer = getExistingPeer( torrent, in_addr );
344
345    if( peer == NULL )
346    {
347        peer = peerConstructor( torrent->tor, in_addr );
348        tr_ptrArrayInsertSorted( torrent->peers, peer, peerCompare );
349    }
350
351    return peer;
352}
353
354static void
355peerDestructor( tr_peer * peer )
356{
357    assert( peer );
358    assert( peer->msgs );
359
360    tr_peerMsgsUnsubscribe( peer->msgs, peer->msgsTag );
361    tr_peerMsgsFree( peer->msgs );
362
363    tr_peerIoFree( peer->io );
364
365    tr_bitfieldFree( peer->have );
366    tr_bitfieldFree( peer->blame );
367    tr_free( peer->client );
368
369    tr_bandwidthFree( peer->bandwidth );
370
371    tr_free( peer );
372}
373
374static void
375removePeer( Torrent * t,
376            tr_peer * peer )
377{
378    tr_peer *          removed;
379    struct peer_atom * atom;
380
381    assert( torrentIsLocked( t ) );
382
383    atom = getExistingAtom( t, &peer->in_addr );
384    assert( atom );
385    atom->time = time( NULL );
386
387    removed = tr_ptrArrayRemoveSorted( t->peers, peer, peerCompare );
388    assert( removed == peer );
389    peerDestructor( removed );
390}
391
392static void
393removeAllPeers( Torrent * t )
394{
395    while( !tr_ptrArrayEmpty( t->peers ) )
396        removePeer( t, tr_ptrArrayNth( t->peers, 0 ) );
397}
398
399static void
400torrentDestructor( void * vt )
401{
402    Torrent * t = vt;
403    uint8_t   hash[SHA_DIGEST_LENGTH];
404
405    assert( t );
406    assert( !t->isRunning );
407    assert( t->peers );
408    assert( torrentIsLocked( t ) );
409    assert( tr_ptrArrayEmpty( t->outgoingHandshakes ) );
410    assert( tr_ptrArrayEmpty( t->peers ) );
411
412    memcpy( hash, t->hash, SHA_DIGEST_LENGTH );
413
414    tr_timerFree( &t->reconnectTimer );
415    tr_timerFree( &t->rechokeTimer );
416    tr_timerFree( &t->refillTimer );
417
418    tr_ptrArrayFree( t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
419    tr_ptrArrayFree( t->pool, (PtrArrayForeachFunc)tr_free );
420    tr_ptrArrayFree( t->outgoingHandshakes, NULL );
421    tr_ptrArrayFree( t->peers, NULL );
422
423    tr_free( t->pendingRequestCount );
424    tr_free( t );
425}
426
427static void peerCallbackFunc( void * vpeer,
428                              void * vevent,
429                              void * vt );
430
431static Torrent*
432torrentConstructor( tr_peerMgr * manager,
433                    tr_torrent * tor )
434{
435    int       i;
436    Torrent * t;
437
438    t = tr_new0( Torrent, 1 );
439    t->manager = manager;
440    t->tor = tor;
441    t->pool = tr_ptrArrayNew( );
442    t->peers = tr_ptrArrayNew( );
443    t->webseeds = tr_ptrArrayNew( );
444    t->outgoingHandshakes = tr_ptrArrayNew( );
445    memcpy( t->hash, tor->info.hash, SHA_DIGEST_LENGTH );
446
447    for( i = 0; i < tor->info.webseedCount; ++i )
448    {
449        tr_webseed * w =
450            tr_webseedNew( tor, tor->info.webseeds[i], peerCallbackFunc,
451                           t );
452        tr_ptrArrayAppend( t->webseeds, w );
453    }
454
455    return t;
456}
457
458
459static int bandwidthPulse( void * vmgr );
460
461
462tr_peerMgr*
463tr_peerMgrNew( tr_session * session )
464{
465    tr_peerMgr * m = tr_new0( tr_peerMgr, 1 );
466
467    m->session = session;
468    m->torrents = tr_ptrArrayNew( );
469    m->incomingHandshakes = tr_ptrArrayNew( );
470    m->bandwidthTimer = tr_timerNew( session, bandwidthPulse, m, BANDWIDTH_PERIOD_MSEC );
471    return m;
472}
473
474void
475tr_peerMgrFree( tr_peerMgr * manager )
476{
477    managerLock( manager );
478
479    tr_timerFree( &manager->bandwidthTimer );
480
481    /* free the handshakes.  Abort invokes handshakeDoneCB(), which removes
482     * the item from manager->handshakes, so this is a little roundabout... */
483    while( !tr_ptrArrayEmpty( manager->incomingHandshakes ) )
484        tr_handshakeAbort( tr_ptrArrayNth( manager->incomingHandshakes, 0 ) );
485
486    tr_ptrArrayFree( manager->incomingHandshakes, NULL );
487
488    /* free the torrents. */
489    tr_ptrArrayFree( manager->torrents, torrentDestructor );
490
491    managerUnlock( manager );
492    tr_free( manager );
493}
494
495static tr_peer**
496getConnectedPeers( Torrent * t,
497                   int *     setmeCount )
498{
499    int       i, peerCount, connectionCount;
500    tr_peer **peers;
501    tr_peer **ret;
502
503    assert( torrentIsLocked( t ) );
504
505    peers = (tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
506    ret = tr_new( tr_peer *, peerCount );
507
508    for( i = connectionCount = 0; i < peerCount; ++i )
509        if( peers[i]->msgs )
510            ret[connectionCount++] = peers[i];
511
512    *setmeCount = connectionCount;
513    return ret;
514}
515
516static int
517clientIsDownloadingFrom( const tr_peer * peer )
518{
519    return peer->clientIsInterested && !peer->clientIsChoked;
520}
521
522static int
523clientIsUploadingTo( const tr_peer * peer )
524{
525    return peer->peerIsInterested && !peer->peerIsChoked;
526}
527
528/***
529****
530***/
531
532int
533tr_peerMgrPeerIsSeed( const tr_peerMgr *     mgr,
534                      const uint8_t *        torrentHash,
535                      const struct in_addr * addr )
536{
537    int                      isSeed = FALSE;
538    const Torrent *          t = NULL;
539    const struct peer_atom * atom = NULL;
540
541    t = getExistingTorrent( (tr_peerMgr*)mgr, torrentHash );
542    if( t )
543        atom = getExistingAtom( t, addr );
544    if( atom )
545        isSeed = ( atom->flags & ADDED_F_SEED_FLAG ) != 0;
546
547    return isSeed;
548}
549
550/****
551*****
552*****  REFILL
553*****
554****/
555
556static void
557assertValidPiece( Torrent * t, tr_piece_index_t piece )
558{
559    assert( t );
560    assert( t->tor );
561    assert( piece < t->tor->info.pieceCount );
562}
563
564static int
565getPieceRequests( Torrent * t, tr_piece_index_t piece )
566{
567    assertValidPiece( t, piece );
568
569    return t->pendingRequestCount ? t->pendingRequestCount[piece] : 0;
570}
571
572static void
573incrementPieceRequests( Torrent * t, tr_piece_index_t piece )
574{
575    assertValidPiece( t, piece );
576
577    if( t->pendingRequestCount == NULL )
578        t->pendingRequestCount = tr_new0( int, t->tor->info.pieceCount );
579    t->pendingRequestCount[piece]++;
580}
581
582static void
583decrementPieceRequests( Torrent * t, tr_piece_index_t piece )
584{
585    assertValidPiece( t, piece );
586
587    if( t->pendingRequestCount )
588        t->pendingRequestCount[piece]--;
589}
590
591struct tr_refill_piece
592{
593    tr_priority_t    priority;
594    uint32_t         piece;
595    uint32_t         peerCount;
596    int              random;
597    int              pendingRequestCount;
598    int              missingBlockCount;
599};
600
601static int
602compareRefillPiece( const void * aIn,
603                    const void * bIn )
604{
605    const struct tr_refill_piece * a = aIn;
606    const struct tr_refill_piece * b = bIn;
607
608    /* if one piece has a higher priority, it goes first */
609    if( a->priority != b->priority )
610        return a->priority > b->priority ? -1 : 1;
611
612    /* have a per-priority endgame */
613    if( a->pendingRequestCount != b->pendingRequestCount )
614        return a->pendingRequestCount < b->pendingRequestCount ? -1 : 1;
615
616    /* fewer missing pieces goes first */
617    if( a->missingBlockCount != b->missingBlockCount )
618        return a->missingBlockCount < b->missingBlockCount ? -1 : 1;
619
620    /* otherwise if one has fewer peers, it goes first */
621    if( a->peerCount != b->peerCount )
622        return a->peerCount < b->peerCount ? -1 : 1;
623
624    /* otherwise go with our random seed */
625    if( a->random != b->random )
626        return a->random < b->random ? -1 : 1;
627
628    return 0;
629}
630
631static tr_piece_index_t *
632getPreferredPieces( Torrent           * t,
633                    tr_piece_index_t  * pieceCount )
634{
635    const tr_torrent  * tor = t->tor;
636    const tr_info     * inf = &tor->info;
637    tr_piece_index_t    i;
638    tr_piece_index_t    poolSize = 0;
639    tr_piece_index_t  * pool = tr_new( tr_piece_index_t , inf->pieceCount );
640    int                 peerCount;
641    tr_peer**           peers;
642
643    assert( torrentIsLocked( t ) );
644
645    peers = getConnectedPeers( t, &peerCount );
646
647    /* make a list of the pieces that we want but don't have */
648    for( i = 0; i < inf->pieceCount; ++i )
649        if( !tor->info.pieces[i].dnd
650                && !tr_cpPieceIsComplete( tor->completion, i ) )
651            pool[poolSize++] = i;
652
653    /* sort the pool by which to request next */
654    if( poolSize > 1 )
655    {
656        tr_piece_index_t j;
657        struct tr_refill_piece * p = tr_new( struct tr_refill_piece, poolSize );
658
659        for( j = 0; j < poolSize; ++j )
660        {
661            int k;
662            const tr_piece_index_t piece = pool[j];
663            struct tr_refill_piece * setme = p + j;
664
665            setme->piece = piece;
666            setme->priority = inf->pieces[piece].priority;
667            setme->peerCount = 0;
668            setme->random = tr_cryptoWeakRandInt( INT_MAX );
669            setme->pendingRequestCount = getPieceRequests( t, piece );
670            setme->missingBlockCount
671                         = tr_cpMissingBlocksInPiece( tor->completion, piece );
672
673            for( k = 0; k < peerCount; ++k )
674            {
675                const tr_peer * peer = peers[k];
676                if( peer->peerIsInterested
677                        && !peer->clientIsChoked
678                        && tr_bitfieldHas( peer->have, piece ) )
679                    ++setme->peerCount;
680            }
681        }
682
683        qsort( p, poolSize, sizeof( struct tr_refill_piece ),
684               compareRefillPiece );
685
686        for( j = 0; j < poolSize; ++j )
687            pool[j] = p[j].piece;
688
689        tr_free( p );
690    }
691
692    tr_free( peers );
693
694    *pieceCount = poolSize;
695    return pool;
696}
697
698struct tr_blockIterator
699{
700    Torrent * t;
701    tr_block_index_t blockIndex, blockCount, *blocks;
702    tr_piece_index_t pieceIndex, pieceCount, *pieces;
703};
704
705static struct tr_blockIterator*
706blockIteratorNew( Torrent * t )
707{
708    struct tr_blockIterator * i = tr_new0( struct tr_blockIterator, 1 );
709    i->t = t;
710    i->pieces = getPreferredPieces( t, &i->pieceCount );
711    i->blocks = tr_new0( tr_block_index_t, t->tor->blockCount );
712    return i;
713}
714
715static int
716blockIteratorNext( struct tr_blockIterator * i, tr_block_index_t * setme )
717{
718    int found;
719    Torrent * t = i->t;
720    tr_torrent * tor = t->tor;
721
722    while( ( i->blockIndex == i->blockCount )
723        && ( i->pieceIndex < i->pieceCount ) )
724    {
725        const tr_piece_index_t index = i->pieces[i->pieceIndex++];
726        const tr_block_index_t b = tr_torPieceFirstBlock( tor, index );
727        const tr_block_index_t e = b + tr_torPieceCountBlocks( tor, index );
728        tr_block_index_t block;
729
730        assert( index < tor->info.pieceCount );
731
732        i->blockCount = 0;
733        i->blockIndex = 0;
734        for( block=b; block!=e; ++block )
735            if( !tr_cpBlockIsComplete( tor->completion, block ) )
736                i->blocks[i->blockCount++] = block;
737    }
738
739    if(( found = ( i->blockIndex < i->blockCount )))
740        *setme = i->blocks[i->blockIndex++];
741
742    return found;
743}
744
745static void
746blockIteratorFree( struct tr_blockIterator * i )
747{
748    tr_free( i->blocks );
749    tr_free( i->pieces );
750    tr_free( i );
751}
752
753static tr_peer**
754getPeersUploadingToClient( Torrent * t,
755                           int *     setmeCount )
756{
757    int j;
758    int peerCount = 0;
759    int retCount = 0;
760    tr_peer ** peers = (tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
761    tr_peer ** ret = tr_new( tr_peer *, peerCount );
762
763    j = 0; /* this is a temporary test to make sure we walk through all the peers */
764    if( peerCount )
765    {
766        /* Get a list of peers we're downloading from.
767           Pick a different starting point each time so all peers
768           get a chance at being the first in line */
769        const int fencepost = tr_cryptoWeakRandInt( peerCount );
770        int i = fencepost;
771        do {
772            if( clientIsDownloadingFrom( peers[i] ) )
773                ret[retCount++] = peers[i];
774            i = ( i + 1 ) % peerCount;
775            ++j;
776        } while( i != fencepost );
777    }
778    assert( j == peerCount );
779    *setmeCount = retCount;
780    return ret;
781}
782
783static uint32_t
784getBlockOffsetInPiece( const tr_torrent * tor, uint64_t b )
785{
786    const uint64_t piecePos = tor->info.pieceSize * tr_torBlockPiece( tor, b );
787    const uint64_t blockPos = tor->blockSize * b;
788    assert( blockPos >= piecePos );
789    return (uint32_t)( blockPos - piecePos );
790}
791
792static int
793refillPulse( void * vtorrent )
794{
795    tr_block_index_t block;
796    int peerCount;
797    int webseedCount;
798    tr_peer ** peers;
799    tr_webseed ** webseeds;
800    struct tr_blockIterator * blockIterator;
801    Torrent * t = vtorrent;
802    tr_torrent * tor = t->tor;
803
804    if( !t->isRunning )
805        return TRUE;
806    if( tr_torrentIsSeed( t->tor ) )
807        return TRUE;
808
809    torrentLock( t );
810    tordbg( t, "Refilling Request Buffers..." );
811
812    blockIterator = blockIteratorNew( t );
813    peers = getPeersUploadingToClient( t, &peerCount );
814    webseedCount = tr_ptrArraySize( t->webseeds );
815    webseeds = tr_memdup( tr_ptrArrayBase( t->webseeds ),
816                          webseedCount * sizeof( tr_webseed* ) );
817
818    while( ( webseedCount || peerCount )
819        && blockIteratorNext( blockIterator, &block ) )
820    {
821        int j;
822        int handled = FALSE;
823
824        const tr_piece_index_t index = tr_torBlockPiece( tor, block );
825        const uint32_t offset = getBlockOffsetInPiece( tor, block );
826        const uint32_t length = tr_torBlockCountBytes( tor, block );
827
828        /* find a peer who can ask for this block */
829        for( j=0; !handled && j<peerCount; )
830        {
831            const int val = tr_peerMsgsAddRequest( peers[j]->msgs,
832                                                   index, offset, length );
833            switch( val )
834            {
835                case TR_ADDREQ_FULL:
836                case TR_ADDREQ_CLIENT_CHOKED:
837                    peers[j] = peers[--peerCount];
838                    break;
839
840                case TR_ADDREQ_MISSING:
841                case TR_ADDREQ_DUPLICATE:
842                    ++j;
843                    break;
844
845                case TR_ADDREQ_OK:
846                    incrementPieceRequests( t, index );
847                    handled = TRUE;
848                    break;
849
850                default:
851                    assert( 0 && "unhandled value" );
852                    break;
853            }
854        }
855
856        /* maybe one of the webseeds can do it */
857        for( j=0; !handled && j<webseedCount; )
858        {
859            const tr_addreq_t val = tr_webseedAddRequest( webseeds[j],
860                                                          index, offset, length );
861            switch( val )
862            {
863                case TR_ADDREQ_FULL:
864                    webseeds[j] = webseeds[--webseedCount];
865                    break;
866
867                case TR_ADDREQ_OK:
868                    incrementPieceRequests( t, index );
869                    handled = TRUE;
870                    break;
871
872                default:
873                    assert( 0 && "unhandled value" );
874                    break;
875            }
876        }
877    }
878
879    /* cleanup */
880    blockIteratorFree( blockIterator );
881    tr_free( webseeds );
882    tr_free( peers );
883
884    t->refillTimer = NULL;
885    torrentUnlock( t );
886    return FALSE;
887}
888
889static void
890broadcastGotBlock( Torrent * t, uint32_t index, uint32_t offset, uint32_t length )
891{
892    int i, size;
893    tr_peer ** peers;
894
895    assert( torrentIsLocked( t ) );
896
897    peers = getConnectedPeers( t, &size );
898    for( i=0; i<size; ++i )
899        tr_peerMsgsCancel( peers[i]->msgs, index, offset, length );
900    tr_free( peers );
901}
902
903static void
904addStrike( Torrent * t,
905           tr_peer * peer )
906{
907    tordbg( t, "increasing peer %s strike count to %d",
908            tr_peerIoAddrStr( &peer->in_addr,
909                              peer->port ), peer->strikes + 1 );
910
911    if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
912    {
913        struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
914        atom->myflags |= MYFLAG_BANNED;
915        peer->doPurge = 1;
916        tordbg( t, "banning peer %s",
917               tr_peerIoAddrStr( &atom->addr, atom->port ) );
918    }
919}
920
921static void
922gotBadPiece( Torrent *        t,
923             tr_piece_index_t pieceIndex )
924{
925    tr_torrent *   tor = t->tor;
926    const uint32_t byteCount = tr_torPieceCountBytes( tor, pieceIndex );
927
928    tor->corruptCur += byteCount;
929    tor->downloadedCur -= MIN( tor->downloadedCur, byteCount );
930}
931
932static void
933refillSoon( Torrent * t )
934{
935    if( t->refillTimer == NULL )
936        t->refillTimer = tr_timerNew( t->manager->session,
937                                      refillPulse, t,
938                                      REFILL_PERIOD_MSEC );
939}
940
941static void
942peerCallbackFunc( void * vpeer,
943                  void * vevent,
944                  void * vt )
945{
946    tr_peer *             peer = vpeer; /* may be NULL if peer is a webseed */
947    Torrent *             t = (Torrent *) vt;
948    const tr_peer_event * e = vevent;
949
950    torrentLock( t );
951
952    switch( e->eventType )
953    {
954        case TR_PEER_NEED_REQ:
955            refillSoon( t );
956            break;
957
958        case TR_PEER_CANCEL:
959            decrementPieceRequests( t, e->pieceIndex );
960            break;
961
962        case TR_PEER_PEER_GOT_DATA:
963        {
964            const time_t now = time( NULL );
965            tr_torrent * tor = t->tor;
966
967            tor->activityDate = now;
968
969            if( e->wasPieceData )
970                tor->uploadedCur += e->length;
971
972            /* update the stats */
973            if( e->wasPieceData )
974                tr_statsAddUploaded( tor->session, e->length );
975
976            /* update our atom */
977            if( peer ) {
978                struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
979                a->piece_data_time = now;
980            }
981
982            break;
983        }
984
985        case TR_PEER_CLIENT_GOT_DATA:
986        {
987            const time_t now = time( NULL );
988            tr_torrent * tor = t->tor;
989
990            tor->activityDate = now;
991
992            /* only add this to downloadedCur if we got it from a peer --
993             * webseeds shouldn't count against our ratio.  As one tracker
994             * admin put it, "Those pieces are downloaded directly from the
995             * content distributor, not the peers, it is the tracker's job
996             * to manage the swarms, not the web server and does not fit
997             * into the jurisdiction of the tracker." */
998            if( peer && e->wasPieceData )
999                tor->downloadedCur += e->length;
1000
1001            /* update the stats */ 
1002            if( e->wasPieceData )
1003                tr_statsAddDownloaded( tor->session, e->length );
1004
1005            /* update our atom */
1006            if( peer ) {
1007                struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
1008                a->piece_data_time = now;
1009            }
1010
1011            break;
1012        }
1013
1014        case TR_PEER_PEER_PROGRESS:
1015        {
1016            if( peer )
1017            {
1018                struct peer_atom * atom = getExistingAtom( t,
1019                                                           &peer->in_addr );
1020                const int          peerIsSeed = e->progress >= 1.0;
1021                if( peerIsSeed )
1022                {
1023                    tordbg( t, "marking peer %s as a seed",
1024                           tr_peerIoAddrStr( &atom->addr,
1025                                             atom->port ) );
1026                    atom->flags |= ADDED_F_SEED_FLAG;
1027                }
1028                else
1029                {
1030                    tordbg( t, "marking peer %s as a non-seed",
1031                           tr_peerIoAddrStr( &atom->addr,
1032                                             atom->port ) );
1033                    atom->flags &= ~ADDED_F_SEED_FLAG;
1034                }
1035            }
1036            break;
1037        }
1038
1039        case TR_PEER_CLIENT_GOT_BLOCK:
1040        {
1041            tr_torrent *     tor = t->tor;
1042
1043            tr_block_index_t block = _tr_block( tor, e->pieceIndex,
1044                                                e->offset );
1045
1046            tr_cpBlockAdd( tor->completion, block );
1047            decrementPieceRequests( t, e->pieceIndex );
1048
1049            broadcastGotBlock( t, e->pieceIndex, e->offset, e->length );
1050
1051            if( tr_cpPieceIsComplete( tor->completion, e->pieceIndex ) )
1052            {
1053                const tr_piece_index_t p = e->pieceIndex;
1054                const int              ok = tr_ioTestPiece( tor, p );
1055
1056                if( !ok )
1057                {
1058                    tr_torerr( tor,
1059                              _( "Piece %lu, which was just downloaded, failed its checksum test" ),
1060                              (unsigned long)p );
1061                }
1062
1063                tr_torrentSetHasPiece( tor, p, ok );
1064                tr_torrentSetPieceChecked( tor, p, TRUE );
1065                tr_peerMgrSetBlame( tor->session->peerMgr, tor->info.hash, p, ok );
1066
1067                if( !ok )
1068                    gotBadPiece( t, p );
1069                else
1070                {
1071                    int        i, peerCount;
1072                    tr_peer ** peers = getConnectedPeers( t, &peerCount );
1073                    for( i = 0; i < peerCount; ++i )
1074                        tr_peerMsgsHave( peers[i]->msgs, p );
1075                    tr_free( peers );
1076                }
1077
1078                tr_torrentRecheckCompleteness( tor );
1079            }
1080            break;
1081        }
1082
1083        case TR_PEER_ERROR:
1084            if( e->err == EINVAL )
1085            {
1086                addStrike( t, peer );
1087                peer->doPurge = 1;
1088            }
1089            else if( ( e->err == ERANGE )
1090                  || ( e->err == EMSGSIZE )
1091                  || ( e->err == ENOTCONN ) )
1092            {
1093                /* some protocol error from the peer */
1094                peer->doPurge = 1;
1095            }
1096            else /* a local error, such as an IO error */
1097            {
1098                t->tor->error = e->err;
1099                tr_strlcpy( t->tor->errorString,
1100                            tr_strerror( t->tor->error ),
1101                            sizeof( t->tor->errorString ) );
1102                tr_torrentStop( t->tor );
1103            }
1104            break;
1105
1106        default:
1107            assert( 0 );
1108    }
1109
1110    torrentUnlock( t );
1111}
1112
1113static void
1114ensureAtomExists( Torrent *              t,
1115                  const struct in_addr * addr,
1116                  tr_port                port,
1117                  uint8_t                flags,
1118                  uint8_t                from )
1119{
1120    if( getExistingAtom( t, addr ) == NULL )
1121    {
1122        struct peer_atom * a;
1123        a = tr_new0( struct peer_atom, 1 );
1124        a->addr = *addr;
1125        a->port = port;
1126        a->flags = flags;
1127        a->from = from;
1128        tordbg( t, "got a new atom: %s",
1129               tr_peerIoAddrStr( &a->addr, a->port ) );
1130        tr_ptrArrayInsertSorted( t->pool, a, comparePeerAtoms );
1131    }
1132}
1133
1134static int
1135getMaxPeerCount( const tr_torrent * tor )
1136{
1137    return tor->maxConnectedPeers;
1138}
1139
1140static int
1141getPeerCount( const Torrent * t )
1142{
1143    return tr_ptrArraySize( t->peers ) + tr_ptrArraySize(
1144               t->outgoingHandshakes );
1145}
1146
1147/* FIXME: this is kind of a mess. */
1148static int
1149myHandshakeDoneCB( tr_handshake *  handshake,
1150                   tr_peerIo *     io,
1151                   int             isConnected,
1152                   const uint8_t * peer_id,
1153                   void *          vmanager )
1154{
1155    int                    ok = isConnected;
1156    int                    success = FALSE;
1157    tr_port                port;
1158    const struct in_addr * addr;
1159    tr_peerMgr *           manager = (tr_peerMgr*) vmanager;
1160    Torrent *              t;
1161    tr_handshake *         ours;
1162
1163    assert( io );
1164    assert( isConnected == 0 || isConnected == 1 );
1165
1166    t = tr_peerIoHasTorrentHash( io )
1167        ? getExistingTorrent( manager, tr_peerIoGetTorrentHash( io ) )
1168        : NULL;
1169
1170    if( tr_peerIoIsIncoming ( io ) )
1171        ours = tr_ptrArrayRemoveSorted( manager->incomingHandshakes,
1172                                        handshake, handshakeCompare );
1173    else if( t )
1174        ours = tr_ptrArrayRemoveSorted( t->outgoingHandshakes,
1175                                        handshake, handshakeCompare );
1176    else
1177        ours = handshake;
1178
1179    assert( ours );
1180    assert( ours == handshake );
1181
1182    if( t )
1183        torrentLock( t );
1184
1185    addr = tr_peerIoGetAddress( io, &port );
1186
1187    if( !ok || !t || !t->isRunning )
1188    {
1189        if( t )
1190        {
1191            struct peer_atom * atom = getExistingAtom( t, addr );
1192            if( atom )
1193                ++atom->numFails;
1194        }
1195
1196        tr_peerIoFree( io );
1197    }
1198    else /* looking good */
1199    {
1200        struct peer_atom * atom;
1201        ensureAtomExists( t, addr, port, 0, TR_PEER_FROM_INCOMING );
1202        atom = getExistingAtom( t, addr );
1203        atom->time = time( NULL );
1204
1205        if( atom->myflags & MYFLAG_BANNED )
1206        {
1207            tordbg( t, "banned peer %s tried to reconnect",
1208                   tr_peerIoAddrStr( &atom->addr,
1209                                     atom->port ) );
1210            tr_peerIoFree( io );
1211        }
1212        else if( tr_peerIoIsIncoming( io )
1213               && ( getPeerCount( t ) >= getMaxPeerCount( t->tor ) ) )
1214
1215        {
1216            tr_peerIoFree( io );
1217        }
1218        else
1219        {
1220            tr_peer * peer = getExistingPeer( t, addr );
1221
1222            if( peer ) /* we already have this peer */
1223            {
1224                tr_peerIoFree( io );
1225            }
1226            else
1227            {
1228                peer = getPeer( t, addr );
1229                tr_free( peer->client );
1230
1231                if( !peer_id )
1232                    peer->client = NULL;
1233                else {
1234                    char client[128];
1235                    tr_clientForId( client, sizeof( client ), peer_id );
1236                    peer->client = tr_strdup( client );
1237                }
1238
1239                peer->port = port;
1240                peer->io = io;
1241                peer->msgs = tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t, &peer->msgsTag );
1242                tr_peerIoSetBandwidth( io, peer->bandwidth );
1243
1244                success = TRUE;
1245            }
1246        }
1247    }
1248
1249    if( t )
1250        torrentUnlock( t );
1251
1252    return success;
1253}
1254
1255void
1256tr_peerMgrAddIncoming( tr_peerMgr *     manager,
1257                       struct in_addr * addr,
1258                       tr_port          port,
1259                       int              socket )
1260{
1261    managerLock( manager );
1262
1263    if( tr_sessionIsAddressBlocked( manager->session, addr ) )
1264    {
1265        tr_dbg( "Banned IP address \"%s\" tried to connect to us",
1266               inet_ntoa( *addr ) );
1267        tr_netClose( socket );
1268    }
1269    else if( getExistingHandshake( manager->incomingHandshakes, addr ) )
1270    {
1271        tr_netClose( socket );
1272    }
1273    else /* we don't have a connetion to them yet... */
1274    {
1275        tr_peerIo *    io;
1276        tr_handshake * handshake;
1277
1278        io = tr_peerIoNewIncoming( manager->session, addr, port, socket );
1279
1280        handshake = tr_handshakeNew( io,
1281                                     manager->session->encryptionMode,
1282                                     myHandshakeDoneCB,
1283                                     manager );
1284
1285        tr_ptrArrayInsertSorted( manager->incomingHandshakes, handshake,
1286                                 handshakeCompare );
1287    }
1288
1289    managerUnlock( manager );
1290}
1291
1292void
1293tr_peerMgrAddPex( tr_peerMgr *    manager,
1294                  const uint8_t * torrentHash,
1295                  uint8_t         from,
1296                  const tr_pex *  pex )
1297{
1298    Torrent * t;
1299
1300    managerLock( manager );
1301
1302    t = getExistingTorrent( manager, torrentHash );
1303    if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->in_addr ) )
1304        ensureAtomExists( t, &pex->in_addr, pex->port, pex->flags, from );
1305
1306    managerUnlock( manager );
1307}
1308
1309tr_pex *
1310tr_peerMgrCompactToPex( const void *    compact,
1311                        size_t          compactLen,
1312                        const uint8_t * added_f,
1313                        size_t          added_f_len,
1314                        size_t *        pexCount )
1315{
1316    size_t          i;
1317    size_t          n = compactLen / 6;
1318    const uint8_t * walk = compact;
1319    tr_pex *        pex = tr_new0( tr_pex, n );
1320
1321    for( i = 0; i < n; ++i )
1322    {
1323        memcpy( &pex[i].in_addr, walk, 4 ); walk += 4;
1324        memcpy( &pex[i].port, walk, 2 ); walk += 2;
1325        if( added_f && ( n == added_f_len ) )
1326            pex[i].flags = added_f[i];
1327    }
1328
1329    *pexCount = n;
1330    return pex;
1331}
1332
1333/**
1334***
1335**/
1336
1337void
1338tr_peerMgrSetBlame( tr_peerMgr *     manager,
1339                    const uint8_t *  torrentHash,
1340                    tr_piece_index_t pieceIndex,
1341                    int              success )
1342{
1343    if( !success )
1344    {
1345        int        peerCount, i;
1346        Torrent *  t = getExistingTorrent( manager, torrentHash );
1347        tr_peer ** peers;
1348
1349        assert( torrentIsLocked( t ) );
1350
1351        peers = (tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
1352        for( i = 0; i < peerCount; ++i )
1353        {
1354            tr_peer * peer = peers[i];
1355            if( tr_bitfieldHas( peer->blame, pieceIndex ) )
1356            {
1357                tordbg(
1358                    t,
1359                    "peer %s contributed to corrupt piece (%d); now has %d strikes",
1360                    tr_peerIoAddrStr( &peer->in_addr, peer->port ),
1361                    pieceIndex, (int)peer->strikes + 1 );
1362                addStrike( t, peer );
1363            }
1364        }
1365    }
1366}
1367
1368int
1369tr_pexCompare( const void * va,
1370               const void * vb )
1371{
1372    const tr_pex * a = va;
1373    const tr_pex * b = vb;
1374    int            i =
1375        memcmp( &a->in_addr, &b->in_addr, sizeof( struct in_addr ) );
1376
1377    if( i ) return i;
1378    if( a->port < b->port ) return -1;
1379    if( a->port > b->port ) return 1;
1380    return 0;
1381}
1382
1383int tr_pexCompare( const void * a,
1384                   const void * b );
1385
1386static int
1387peerPrefersCrypto( const tr_peer * peer )
1388{
1389    if( peer->encryption_preference == ENCRYPTION_PREFERENCE_YES )
1390        return TRUE;
1391
1392    if( peer->encryption_preference == ENCRYPTION_PREFERENCE_NO )
1393        return FALSE;
1394
1395    return tr_peerIoIsEncrypted( peer->io );
1396}
1397
1398int
1399tr_peerMgrGetPeers( tr_peerMgr *    manager,
1400                    const uint8_t * torrentHash,
1401                    tr_pex **       setme_pex )
1402{
1403    int peerCount = 0;
1404    const Torrent *  t;
1405
1406    managerLock( manager );
1407
1408    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1409    if( !t )
1410    {
1411        *setme_pex = NULL;
1412    }
1413    else
1414    {
1415        int i;
1416        const tr_peer ** peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
1417        tr_pex * pex = tr_new( tr_pex, peerCount );
1418        tr_pex * walk = pex;
1419
1420        for( i = 0; i < peerCount; ++i, ++walk )
1421        {
1422            const tr_peer * peer = peers[i];
1423            walk->in_addr = peer->in_addr;
1424            walk->port = peer->port;
1425            walk->flags = 0;
1426            if( peerPrefersCrypto( peer ) ) walk->flags |= ADDED_F_ENCRYPTION_FLAG;
1427            if( peer->progress >= 1.0 ) walk->flags |= ADDED_F_SEED_FLAG;
1428        }
1429
1430        assert( ( walk - pex ) == peerCount );
1431        qsort( pex, peerCount, sizeof( tr_pex ), tr_pexCompare );
1432        *setme_pex = pex;
1433    }
1434
1435    managerUnlock( manager );
1436    return peerCount;
1437}
1438
1439static int reconnectPulse( void * vtorrent );
1440
1441static int rechokePulse( void * vtorrent );
1442
1443void
1444tr_peerMgrStartTorrent( tr_peerMgr *    manager,
1445                        const uint8_t * torrentHash )
1446{
1447    Torrent * t;
1448
1449    managerLock( manager );
1450
1451    t = getExistingTorrent( manager, torrentHash );
1452
1453    assert( t );
1454    assert( ( t->isRunning != 0 ) == ( t->reconnectTimer != NULL ) );
1455    assert( ( t->isRunning != 0 ) == ( t->rechokeTimer != NULL ) );
1456
1457    if( !t->isRunning )
1458    {
1459        t->isRunning = 1;
1460
1461        t->reconnectTimer = tr_timerNew( t->manager->session,
1462                                         reconnectPulse, t,
1463                                         RECONNECT_PERIOD_MSEC );
1464
1465        t->rechokeTimer = tr_timerNew( t->manager->session,
1466                                       rechokePulse, t,
1467                                       RECHOKE_PERIOD_MSEC );
1468
1469        reconnectPulse( t );
1470
1471        rechokePulse( t );
1472
1473        if( !tr_ptrArrayEmpty( t->webseeds ) )
1474            refillSoon( t );
1475    }
1476
1477    managerUnlock( manager );
1478}
1479
1480static void
1481stopTorrent( Torrent * t )
1482{
1483    assert( torrentIsLocked( t ) );
1484
1485    t->isRunning = 0;
1486    tr_timerFree( &t->rechokeTimer );
1487    tr_timerFree( &t->reconnectTimer );
1488
1489    /* disconnect the peers. */
1490    tr_ptrArrayForeach( t->peers, (PtrArrayForeachFunc)peerDestructor );
1491    tr_ptrArrayClear( t->peers );
1492
1493    /* disconnect the handshakes.  handshakeAbort calls handshakeDoneCB(),
1494     * which removes the handshake from t->outgoingHandshakes... */
1495    while( !tr_ptrArrayEmpty( t->outgoingHandshakes ) )
1496        tr_handshakeAbort( tr_ptrArrayNth( t->outgoingHandshakes, 0 ) );
1497}
1498
1499void
1500tr_peerMgrStopTorrent( tr_peerMgr *    manager,
1501                       const uint8_t * torrentHash )
1502{
1503    managerLock( manager );
1504
1505    stopTorrent( getExistingTorrent( manager, torrentHash ) );
1506
1507    managerUnlock( manager );
1508}
1509
1510void
1511tr_peerMgrAddTorrent( tr_peerMgr * manager,
1512                      tr_torrent * tor )
1513{
1514    Torrent * t;
1515
1516    managerLock( manager );
1517
1518    assert( tor );
1519    assert( getExistingTorrent( manager, tor->info.hash ) == NULL );
1520
1521    t = torrentConstructor( manager, tor );
1522    tr_ptrArrayInsertSorted( manager->torrents, t, torrentCompare );
1523
1524    managerUnlock( manager );
1525}
1526
1527void
1528tr_peerMgrRemoveTorrent( tr_peerMgr *    manager,
1529                         const uint8_t * torrentHash )
1530{
1531    Torrent * t;
1532
1533    managerLock( manager );
1534
1535    t = getExistingTorrent( manager, torrentHash );
1536    assert( t );
1537    stopTorrent( t );
1538    tr_ptrArrayRemoveSorted( manager->torrents, t, torrentCompare );
1539    torrentDestructor( t );
1540
1541    managerUnlock( manager );
1542}
1543
1544void
1545tr_peerMgrTorrentAvailability( const tr_peerMgr * manager,
1546                               const uint8_t *    torrentHash,
1547                               int8_t *           tab,
1548                               unsigned int       tabCount )
1549{
1550    tr_piece_index_t   i;
1551    const Torrent *    t;
1552    const tr_torrent * tor;
1553    float              interval;
1554    int                isSeed;
1555    int                peerCount;
1556    const tr_peer **   peers;
1557
1558    managerLock( manager );
1559
1560    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1561    tor = t->tor;
1562    interval = tor->info.pieceCount / (float)tabCount;
1563    isSeed = tor && ( tr_cpGetStatus ( tor->completion ) == TR_SEED );
1564    peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
1565
1566    memset( tab, 0, tabCount );
1567
1568    for( i = 0; tor && i < tabCount; ++i )
1569    {
1570        const int piece = i * interval;
1571
1572        if( isSeed || tr_cpPieceIsComplete( tor->completion, piece ) )
1573            tab[i] = -1;
1574        else if( peerCount )
1575        {
1576            int j;
1577            for( j = 0; j < peerCount; ++j )
1578                if( tr_bitfieldHas( peers[j]->have, i ) )
1579                    ++tab[i];
1580        }
1581    }
1582
1583    managerUnlock( manager );
1584}
1585
1586/* Returns the pieces that are available from peers */
1587tr_bitfield*
1588tr_peerMgrGetAvailable( const tr_peerMgr * manager,
1589                        const uint8_t *    torrentHash )
1590{
1591    int           i, size;
1592    Torrent *     t;
1593    tr_peer **    peers;
1594    tr_bitfield * pieces;
1595
1596    managerLock( manager );
1597
1598    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1599    pieces = tr_bitfieldNew( t->tor->info.pieceCount );
1600    peers = getConnectedPeers( t, &size );
1601    for( i = 0; i < size; ++i )
1602        tr_bitfieldOr( pieces, peers[i]->have );
1603
1604    managerUnlock( manager );
1605    tr_free( peers );
1606    return pieces;
1607}
1608
1609int
1610tr_peerMgrHasConnections( const tr_peerMgr * manager,
1611                          const uint8_t *    torrentHash )
1612{
1613    int             ret;
1614    const Torrent * t;
1615
1616    managerLock( manager );
1617
1618    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1619    ret = t && ( !tr_ptrArrayEmpty( t->peers )
1620               || !tr_ptrArrayEmpty( t->webseeds ) );
1621
1622    managerUnlock( manager );
1623    return ret;
1624}
1625
1626void
1627tr_peerMgrTorrentStats( const tr_peerMgr * manager,
1628                        const uint8_t *    torrentHash,
1629                        int *              setmePeersKnown,
1630                        int *              setmePeersConnected,
1631                        int *              setmeSeedsConnected,
1632                        int *              setmeWebseedsSendingToUs,
1633                        int *              setmePeersSendingToUs,
1634                        int *              setmePeersGettingFromUs,
1635                        int *              setmePeersFrom )
1636{
1637    int                 i, size;
1638    const Torrent *     t;
1639    const tr_peer **    peers;
1640    const tr_webseed ** webseeds;
1641
1642    managerLock( manager );
1643
1644    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1645    peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &size );
1646
1647    *setmePeersKnown           = tr_ptrArraySize( t->pool );
1648    *setmePeersConnected       = 0;
1649    *setmeSeedsConnected       = 0;
1650    *setmePeersGettingFromUs   = 0;
1651    *setmePeersSendingToUs     = 0;
1652    *setmeWebseedsSendingToUs  = 0;
1653
1654    for( i = 0; i < TR_PEER_FROM__MAX; ++i )
1655        setmePeersFrom[i] = 0;
1656
1657    for( i = 0; i < size; ++i )
1658    {
1659        const tr_peer *          peer = peers[i];
1660        const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
1661
1662        if( peer->io == NULL ) /* not connected */
1663            continue;
1664
1665        ++ * setmePeersConnected;
1666
1667        ++setmePeersFrom[atom->from];
1668
1669        if( clientIsDownloadingFrom( peer ) )
1670            ++ * setmePeersSendingToUs;
1671
1672        if( clientIsUploadingTo( peer ) )
1673            ++ * setmePeersGettingFromUs;
1674
1675        if( atom->flags & ADDED_F_SEED_FLAG )
1676            ++ * setmeSeedsConnected;
1677    }
1678
1679    webseeds = (const tr_webseed **) tr_ptrArrayPeek( t->webseeds, &size );
1680    for( i = 0; i < size; ++i )
1681    {
1682        if( tr_webseedIsActive( webseeds[i] ) )
1683            ++ * setmeWebseedsSendingToUs;
1684    }
1685
1686    managerUnlock( manager );
1687}
1688
1689float*
1690tr_peerMgrWebSpeeds( const tr_peerMgr * manager,
1691                     const uint8_t *    torrentHash )
1692{
1693    const Torrent *     t;
1694    const tr_webseed ** webseeds;
1695    int                 i;
1696    int                 webseedCount;
1697    float *             ret;
1698
1699    assert( manager );
1700    managerLock( manager );
1701
1702    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1703    webseeds = (const tr_webseed**) tr_ptrArrayPeek( t->webseeds,
1704                                                     &webseedCount );
1705    assert( webseedCount == t->tor->info.webseedCount );
1706    ret = tr_new0( float, webseedCount );
1707
1708    for( i = 0; i < webseedCount; ++i )
1709        if( !tr_webseedGetSpeed( webseeds[i], &ret[i] ) )
1710            ret[i] = -1.0;
1711
1712    managerUnlock( manager );
1713    return ret;
1714}
1715
1716double
1717tr_peerGetPieceSpeed( const tr_peer    * peer,
1718                      tr_direction       direction )
1719{
1720    assert( peer );
1721    assert( direction==TR_CLIENT_TO_PEER || direction==TR_PEER_TO_CLIENT );
1722
1723    return tr_bandwidthGetPieceSpeed( peer->bandwidth, direction );
1724}
1725
1726
1727struct tr_peer_stat *
1728tr_peerMgrPeerStats( const   tr_peerMgr  * manager,
1729                     const   uint8_t     * torrentHash,
1730                     int                 * setmeCount UNUSED )
1731{
1732    int             i, size;
1733    const Torrent * t;
1734    tr_peer **      peers;
1735    tr_peer_stat *  ret;
1736
1737    assert( manager );
1738    managerLock( manager );
1739
1740    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1741    peers = getConnectedPeers( (Torrent*)t, &size );
1742    ret = tr_new0( tr_peer_stat, size );
1743
1744    for( i = 0; i < size; ++i )
1745    {
1746        char *                   pch;
1747        const tr_peer *          peer = peers[i];
1748        const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
1749        tr_peer_stat *           stat = ret + i;
1750
1751        tr_netNtop( &peer->in_addr, stat->addr, sizeof( stat->addr ) );
1752        tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
1753                   sizeof( stat->client ) );
1754        stat->port               = ntohs( peer->port );
1755        stat->from               = atom->from;
1756        stat->progress           = peer->progress;
1757        stat->isEncrypted        = tr_peerIoIsEncrypted( peer->io ) ? 1 : 0;
1758        stat->rateToPeer         = tr_peerGetPieceSpeed( peer, TR_CLIENT_TO_PEER );
1759        stat->rateToClient       = tr_peerGetPieceSpeed( peer, TR_PEER_TO_CLIENT );
1760        stat->peerIsChoked       = peer->peerIsChoked;
1761        stat->peerIsInterested   = peer->peerIsInterested;
1762        stat->clientIsChoked     = peer->clientIsChoked;
1763        stat->clientIsInterested = peer->clientIsInterested;
1764        stat->isIncoming         = tr_peerIoIsIncoming( peer->io );
1765        stat->isDownloadingFrom  = clientIsDownloadingFrom( peer );
1766        stat->isUploadingTo      = clientIsUploadingTo( peer );
1767
1768        pch = stat->flagStr;
1769        if( t->optimistic == peer ) *pch++ = 'O';
1770        if( stat->isDownloadingFrom ) *pch++ = 'D';
1771        else if( stat->clientIsInterested ) *pch++ = 'd';
1772        if( stat->isUploadingTo ) *pch++ = 'U';
1773        else if( stat->peerIsInterested ) *pch++ = 'u';
1774        if( !stat->clientIsChoked && !stat->clientIsInterested ) *pch++ =
1775                'K';
1776        if( !stat->peerIsChoked && !stat->peerIsInterested ) *pch++ = '?';
1777        if( stat->isEncrypted ) *pch++ = 'E';
1778        if( stat->from == TR_PEER_FROM_PEX ) *pch++ = 'X';
1779        if( stat->isIncoming ) *pch++ = 'I';
1780        *pch = '\0';
1781    }
1782
1783    *setmeCount = size;
1784    tr_free( peers );
1785
1786    managerUnlock( manager );
1787    return ret;
1788}
1789
1790/**
1791***
1792**/
1793
1794struct ChokeData
1795{
1796    tr_bool         doUnchoke;
1797    tr_bool         isInterested;
1798    tr_bool         isChoked;
1799    int             rate;
1800    tr_peer *       peer;
1801};
1802
1803static int
1804compareChoke( const void * va,
1805              const void * vb )
1806{
1807    const struct ChokeData * a = va;
1808    const struct ChokeData * b = vb;
1809
1810    if( a->rate != b->rate ) /* prefer higher overall speeds */
1811        return a->rate > b->rate ? -1 : 1;
1812
1813    if( a->isChoked != b->isChoked ) /* prefer unchoked */
1814        return a->isChoked ? 1 : -1;
1815
1816    return 0;
1817}
1818
1819static int
1820isNew( const tr_peer * peer )
1821{
1822    return peer && peer->io && tr_peerIoGetAge( peer->io ) < 45;
1823}
1824
1825static int
1826isSame( const tr_peer * peer )
1827{
1828    return peer && peer->client && strstr( peer->client, "Transmission" );
1829}
1830
1831/**
1832***
1833**/
1834
1835static void
1836rechoke( Torrent * t )
1837{
1838    int                i, peerCount, size, unchokedInterested;
1839    tr_peer **         peers = getConnectedPeers( t, &peerCount );
1840    struct ChokeData * choke = tr_new0( struct ChokeData, peerCount );
1841    const int          chokeAll = !tr_torrentIsPieceTransferAllowed( t->tor, TR_CLIENT_TO_PEER );
1842
1843    assert( torrentIsLocked( t ) );
1844
1845    /* sort the peers by preference and rate */
1846    for( i = 0, size = 0; i < peerCount; ++i )
1847    {
1848        tr_peer * peer = peers[i];
1849        if( peer->progress >= 1.0 ) /* choke all seeds */
1850            tr_peerMsgsSetChoke( peer->msgs, TRUE );
1851        else if( chokeAll )
1852            tr_peerMsgsSetChoke( peer->msgs, TRUE );
1853        else {
1854            struct ChokeData * n = &choke[size++];
1855            n->peer         = peer;
1856            n->isInterested = peer->peerIsInterested;
1857            n->isChoked     = peer->peerIsChoked;
1858            n->rate         = tr_peerGetPieceSpeed( peer, TR_CLIENT_TO_PEER ) * 1024;
1859        }
1860    }
1861
1862    qsort( choke, size, sizeof( struct ChokeData ), compareChoke );
1863
1864    /**
1865     * Reciprocation and number of uploads capping is managed by unchoking
1866     * the N peers which have the best upload rate and are interested.
1867     * This maximizes the client's download rate. These N peers are
1868     * referred to as downloaders, because they are interested in downloading
1869     * from the client.
1870     *
1871     * Peers which have a better upload rate (as compared to the downloaders)
1872     * but aren't interested get unchoked. If they become interested, the
1873     * downloader with the worst upload rate gets choked. If a client has
1874     * a complete file, it uses its upload rate rather than its download
1875     * rate to decide which peers to unchoke.
1876     */
1877    unchokedInterested = 0;
1878    for( i = 0; i < size && unchokedInterested < MAX_UNCHOKED_PEERS; ++i )
1879    {
1880        choke[i].doUnchoke = 1;
1881        if( choke[i].isInterested )
1882            ++unchokedInterested;
1883    }
1884
1885    /* optimistic unchoke */
1886    if( i < size )
1887    {
1888        int                n;
1889        struct ChokeData * c;
1890        tr_ptrArray *      randPool = tr_ptrArrayNew( );
1891
1892        for( ; i < size; ++i )
1893        {
1894            if( choke[i].isInterested )
1895            {
1896                const tr_peer * peer = choke[i].peer;
1897                int             x = 1, y;
1898                if( isNew( peer ) ) x *= 3;
1899                if( isSame( peer ) ) x *= 3;
1900                for( y = 0; y < x; ++y )
1901                    tr_ptrArrayAppend( randPool, &choke[i] );
1902            }
1903        }
1904
1905        if( ( n = tr_ptrArraySize( randPool ) ) )
1906        {
1907            c = tr_ptrArrayNth( randPool, tr_cryptoWeakRandInt( n ) );
1908            c->doUnchoke = 1;
1909            t->optimistic = c->peer;
1910        }
1911
1912        tr_ptrArrayFree( randPool, NULL );
1913    }
1914
1915    for( i = 0; i < size; ++i )
1916        tr_peerMsgsSetChoke( choke[i].peer->msgs, !choke[i].doUnchoke );
1917
1918    /* cleanup */
1919    tr_free( choke );
1920    tr_free( peers );
1921}
1922
1923static int
1924rechokePulse( void * vtorrent )
1925{
1926    Torrent * t = vtorrent;
1927
1928    torrentLock( t );
1929    rechoke( t );
1930    torrentUnlock( t );
1931    return TRUE;
1932}
1933
1934/***
1935****
1936****  Life and Death
1937****
1938***/
1939
1940static int
1941shouldPeerBeClosed( const Torrent * t,
1942                    const tr_peer * peer,
1943                    int             peerCount )
1944{
1945    const tr_torrent *       tor = t->tor;
1946    const time_t             now = time( NULL );
1947    const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
1948
1949    /* if it's marked for purging, close it */
1950    if( peer->doPurge )
1951    {
1952        tordbg( t, "purging peer %s because its doPurge flag is set",
1953               tr_peerIoAddrStr( &atom->addr,
1954                                 atom->port ) );
1955        return TRUE;
1956    }
1957
1958    /* if we're seeding and the peer has everything we have,
1959     * and enough time has passed for a pex exchange, then disconnect */
1960    if( tr_torrentIsSeed( tor ) )
1961    {
1962        int peerHasEverything;
1963        if( atom->flags & ADDED_F_SEED_FLAG )
1964            peerHasEverything = TRUE;
1965        else if( peer->progress < tr_cpPercentDone( tor->completion ) )
1966            peerHasEverything = FALSE;
1967        else
1968        {
1969            tr_bitfield * tmp =
1970                tr_bitfieldDup( tr_cpPieceBitfield( tor->completion ) );
1971            tr_bitfieldDifference( tmp, peer->have );
1972            peerHasEverything = tr_bitfieldCountTrueBits( tmp ) == 0;
1973            tr_bitfieldFree( tmp );
1974        }
1975        if( peerHasEverything
1976          && ( !tr_torrentAllowsPex( tor ) || ( now - atom->time >= 30 ) ) )
1977        {
1978            tordbg( t, "purging peer %s because we're both seeds",
1979                   tr_peerIoAddrStr( &atom->addr,
1980                                     atom->port ) );
1981            return TRUE;
1982        }
1983    }
1984
1985    /* disconnect if it's been too long since piece data has been transferred.
1986     * this is on a sliding scale based on number of available peers... */
1987    {
1988        const int    relaxStrictnessIfFewerThanN =
1989            (int)( ( getMaxPeerCount( tor ) * 0.9 ) + 0.5 );
1990        /* if we have >= relaxIfFewerThan, strictness is 100%.
1991         * if we have zero connections, strictness is 0% */
1992        const float  strictness = peerCount >= relaxStrictnessIfFewerThanN
1993                                  ? 1.0
1994                                  : peerCount /
1995                                  (float)relaxStrictnessIfFewerThanN;
1996        const int    lo = MIN_UPLOAD_IDLE_SECS;
1997        const int    hi = MAX_UPLOAD_IDLE_SECS;
1998        const int    limit = lo + ( ( hi - lo ) * strictness );
1999        const time_t then = peer->pieceDataActivityDate;
2000        const int    idleTime = then ? ( now - then ) : 0;
2001        if( idleTime > limit )
2002        {
2003            tordbg(
2004                t,
2005                "purging peer %s because it's been %d secs since we shared anything",
2006                tr_peerIoAddrStr( &atom->addr, atom->port ), idleTime );
2007            return TRUE;
2008        }
2009    }
2010
2011    return FALSE;
2012}
2013
2014static tr_peer **
2015getPeersToClose( Torrent * t,
2016                 int *     setmeSize )
2017{
2018    int               i, peerCount, outsize;
2019    tr_peer **        peers = (tr_peer**) tr_ptrArrayPeek( t->peers,
2020                                                           &peerCount );
2021    struct tr_peer ** ret = tr_new( tr_peer *, peerCount );
2022
2023    assert( torrentIsLocked( t ) );
2024
2025    for( i = outsize = 0; i < peerCount; ++i )
2026        if( shouldPeerBeClosed( t, peers[i], peerCount ) )
2027            ret[outsize++] = peers[i];
2028
2029    *setmeSize = outsize;
2030    return ret;
2031}
2032
2033static int
2034compareCandidates( const void * va,
2035                   const void * vb )
2036{
2037    const struct peer_atom * a = *(const struct peer_atom**) va;
2038    const struct peer_atom * b = *(const struct peer_atom**) vb;
2039
2040    /* <Charles> Here we would probably want to try reconnecting to
2041     * peers that had most recently given us data. Lots of users have
2042     * trouble with resets due to their routers and/or ISPs. This way we
2043     * can quickly recover from an unwanted reset. So we sort
2044     * piece_data_time in descending order.
2045     */
2046
2047    if( a->piece_data_time != b->piece_data_time )
2048        return a->piece_data_time < b->piece_data_time ? 1 : -1;
2049
2050    if( a->numFails != b->numFails )
2051        return a->numFails < b->numFails ? -1 : 1;
2052
2053    if( a->time != b->time )
2054        return a->time < b->time ? -1 : 1;
2055
2056    return 0;
2057}
2058
2059static int
2060getReconnectIntervalSecs( const struct peer_atom * atom )
2061{
2062    int          sec;
2063    const time_t now = time( NULL );
2064
2065    /* if we were recently connected to this peer and transferring piece
2066     * data, try to reconnect to them sooner rather that later -- we don't
2067     * want network troubles to get in the way of a good peer. */
2068    if( ( now - atom->piece_data_time ) <=
2069       ( MINIMUM_RECONNECT_INTERVAL_SECS * 2 ) )
2070        sec = MINIMUM_RECONNECT_INTERVAL_SECS;
2071
2072    /* don't allow reconnects more often than our minimum */
2073    else if( ( now - atom->time ) < MINIMUM_RECONNECT_INTERVAL_SECS )
2074        sec = MINIMUM_RECONNECT_INTERVAL_SECS;
2075
2076    /* otherwise, the interval depends on how many times we've tried
2077     * and failed to connect to the peer */
2078    else switch( atom->numFails )
2079        {
2080            case 0:
2081                sec = 0; break;
2082
2083            case 1:
2084                sec = 5; break;
2085
2086            case 2:
2087                sec = 2 * 60; break;
2088
2089            case 3:
2090                sec = 15 * 60; break;
2091
2092            case 4:
2093                sec = 30 * 60; break;
2094
2095            case 5:
2096                sec = 60 * 60; break;
2097
2098            default:
2099                sec = 120 * 60; break;
2100        }
2101
2102    return sec;
2103}
2104
2105static struct peer_atom **
2106getPeerCandidates(                               Torrent * t,
2107                                           int * setmeSize )
2108{
2109    int                 i, atomCount, retCount;
2110    struct peer_atom ** atoms;
2111    struct peer_atom ** ret;
2112    const time_t        now = time( NULL );
2113    const int           seed = tr_torrentIsSeed( t->tor );
2114
2115    assert( torrentIsLocked( t ) );
2116
2117    atoms = (struct peer_atom**) tr_ptrArrayPeek( t->pool, &atomCount );
2118    ret = tr_new( struct peer_atom*, atomCount );
2119    for( i = retCount = 0; i < atomCount; ++i )
2120    {
2121        int                interval;
2122        struct peer_atom * atom = atoms[i];
2123
2124        /* peer fed us too much bad data ... we only keep it around
2125         * now to weed it out in case someone sends it to us via pex */
2126        if( atom->myflags & MYFLAG_BANNED )
2127            continue;
2128
2129        /* peer was unconnectable before, so we're not going to keep trying.
2130         * this is needs a separate flag from `banned', since if they try
2131         * to connect to us later, we'll let them in */
2132        if( atom->myflags & MYFLAG_UNREACHABLE )
2133            continue;
2134
2135        /* we don't need two connections to the same peer... */
2136        if( peerIsInUse( t, &atom->addr ) )
2137            continue;
2138
2139        /* no need to connect if we're both seeds... */
2140        if( seed && ( atom->flags & ADDED_F_SEED_FLAG ) )
2141            continue;
2142
2143        /* don't reconnect too often */
2144        interval = getReconnectIntervalSecs( atom );
2145        if( ( now - atom->time ) < interval )
2146        {
2147            tordbg(
2148                t,
2149                "RECONNECT peer %d (%s) is in its grace period of %d seconds..",
2150                i, tr_peerIoAddrStr( &atom->addr,
2151                                     atom->port ), interval );
2152            continue;
2153        }
2154
2155        /* Don't connect to peers in our blocklist */
2156        if( tr_sessionIsAddressBlocked( t->manager->session, &atom->addr ) )
2157            continue;
2158
2159        ret[retCount++] = atom;
2160    }
2161
2162    qsort( ret, retCount, sizeof( struct peer_atom* ), compareCandidates );
2163    *setmeSize = retCount;
2164    return ret;
2165}
2166
2167static int
2168reconnectPulse( void * vtorrent )
2169{
2170    Torrent *     t = vtorrent;
2171    static time_t prevTime = 0;
2172    static int    newConnectionsThisSecond = 0;
2173    time_t        now;
2174
2175    torrentLock( t );
2176
2177    now = time( NULL );
2178    if( prevTime != now )
2179    {
2180        prevTime = now;
2181        newConnectionsThisSecond = 0;
2182    }
2183
2184    if( !t->isRunning )
2185    {
2186        removeAllPeers( t );
2187    }
2188    else
2189    {
2190        int                 i, nCandidates, nBad;
2191        struct peer_atom ** candidates = getPeerCandidates( t, &nCandidates );
2192        struct tr_peer **   connections = getPeersToClose( t, &nBad );
2193
2194        if( nBad || nCandidates )
2195            tordbg(
2196                t, "reconnect pulse for [%s]: %d bad connections, "
2197                   "%d connection candidates, %d atoms, max per pulse is %d",
2198                t->tor->info.name, nBad, nCandidates,
2199                tr_ptrArraySize( t->pool ),
2200                (int)MAX_RECONNECTIONS_PER_PULSE );
2201
2202        /* disconnect some peers.
2203           if we transferred piece data, then they might be good peers,
2204           so reset their `numFails' weight to zero.  otherwise we connected
2205           to them fruitlessly, so mark it as another fail */
2206        for( i = 0; i < nBad; ++i )
2207        {
2208            tr_peer *          peer = connections[i];
2209            struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
2210            if( peer->pieceDataActivityDate )
2211                atom->numFails = 0;
2212            else
2213                ++atom->numFails;
2214            tordbg( t, "removing bad peer %s",
2215                   tr_peerIoGetAddrStr( peer->io ) );
2216            removePeer( t, peer );
2217        }
2218
2219        /* add some new ones */
2220        for( i = 0;    ( i < nCandidates )
2221           && ( i < MAX_RECONNECTIONS_PER_PULSE )
2222           && ( getPeerCount( t ) < getMaxPeerCount( t->tor ) )
2223           && ( newConnectionsThisSecond < MAX_CONNECTIONS_PER_SECOND );
2224             ++i )
2225        {
2226            tr_peerMgr *       mgr = t->manager;
2227            struct peer_atom * atom = candidates[i];
2228            tr_peerIo *        io;
2229
2230            tordbg( t, "Starting an OUTGOING connection with %s",
2231                   tr_peerIoAddrStr( &atom->addr, atom->port ) );
2232
2233            io =
2234                tr_peerIoNewOutgoing( mgr->session, &atom->addr, atom->port,
2235                                      t->hash );
2236            if( io == NULL )
2237            {
2238                atom->myflags |= MYFLAG_UNREACHABLE;
2239            }
2240            else
2241            {
2242                tr_handshake * handshake = tr_handshakeNew(
2243                    io,
2244                    mgr->session->
2245                    encryptionMode,
2246                    myHandshakeDoneCB,
2247                    mgr );
2248
2249                assert( tr_peerIoGetTorrentHash( io ) );
2250
2251                ++newConnectionsThisSecond;
2252
2253                tr_ptrArrayInsertSorted( t->outgoingHandshakes, handshake,
2254                                         handshakeCompare );
2255            }
2256
2257            atom->time = time( NULL );
2258        }
2259
2260        /* cleanup */
2261        tr_free( connections );
2262        tr_free( candidates );
2263    }
2264
2265    torrentUnlock( t );
2266    return TRUE;
2267}
2268
2269/****
2270*****
2271*****  BANDWIDTH ALLOCATION
2272*****
2273****/
2274
2275static void
2276pumpAllPeers( tr_peerMgr * mgr )
2277{
2278    const int torrentCount = tr_ptrArraySize( mgr->torrents );
2279    int       i, j;
2280
2281    for( i=0; i<torrentCount; ++i )
2282    {
2283        Torrent * t = tr_ptrArrayNth( mgr->torrents, i );
2284        for( j=0; j<tr_ptrArraySize( t->peers ); ++j )
2285        {
2286            tr_peer * peer = tr_ptrArrayNth( t->peers, j );
2287            tr_peerMsgsPulse( peer->msgs );
2288        }
2289    }
2290}
2291
2292static int
2293bandwidthPulse( void * vmgr )
2294{
2295    tr_peerMgr * mgr = vmgr;
2296    managerLock( mgr );
2297
2298    pumpAllPeers( mgr );
2299    tr_bandwidthAllocate( mgr->session->bandwidth, TR_UP, BANDWIDTH_PERIOD_MSEC );
2300    tr_bandwidthAllocate( mgr->session->bandwidth, TR_DOWN, BANDWIDTH_PERIOD_MSEC );
2301    pumpAllPeers( mgr );
2302
2303    managerUnlock( mgr );
2304    return TRUE;
2305}
Note: See TracBrowser for help on using the repository browser.