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

Last change on this file since 11533 was 11533, checked in by charles, 11 years ago

(trunk libT) #3656 "endgame could be faster" -- revert the test code from r11528

  • Property svn:keywords set to Date Rev Author Id
File size: 104.3 KB
Line 
1/*
2 * This file Copyright (C) 2007-2010 Mnemosyne LLC
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 11533 2010-12-14 18:36:31Z charles $
11 */
12
13#include <assert.h>
14#include <errno.h> /* error codes ERANGE, ... */
15#include <limits.h> /* INT_MAX */
16#include <string.h> /* memcpy, memcmp, strstr */
17#include <stdlib.h> /* qsort */
18
19#include <event.h>
20
21#include "transmission.h"
22#include "announcer.h"
23#include "bandwidth.h"
24#include "bencode.h"
25#include "blocklist.h"
26#include "cache.h"
27#include "clients.h"
28#include "completion.h"
29#include "crypto.h"
30#include "handshake.h"
31#include "net.h"
32#include "peer-io.h"
33#include "peer-mgr.h"
34#include "peer-msgs.h"
35#include "ptrarray.h"
36#include "session.h"
37#include "stats.h" /* tr_statsAddUploaded, tr_statsAddDownloaded */
38#include "torrent.h"
39#include "utils.h"
40#include "webseed.h"
41
42enum
43{
44    /* how frequently to cull old atoms */
45    ATOM_PERIOD_MSEC = ( 60 * 1000 ),
46
47    /* how frequently to change which peers are choked */
48    RECHOKE_PERIOD_MSEC = ( 10 * 1000 ),
49
50    /* an optimistically unchoked peer is immune from rechoking
51       for this many calls to rechokeUploads(). */
52    OPTIMISTIC_UNCHOKE_MULTIPLIER = 4,
53
54    /* how frequently to reallocate bandwidth */
55    BANDWIDTH_PERIOD_MSEC = 500,
56
57    /* how frequently to age out old piece request lists */
58    REFILL_UPKEEP_PERIOD_MSEC = ( 10 * 1000 ),
59
60    /* how frequently to decide which peers live and die */
61    RECONNECT_PERIOD_MSEC = 500,
62
63    /* when many peers are available, keep idle ones this long */
64    MIN_UPLOAD_IDLE_SECS = ( 60 ),
65
66    /* when few peers are available, keep idle ones this long */
67    MAX_UPLOAD_IDLE_SECS = ( 60 * 5 ),
68
69    /* max number of peers to ask for per second overall.
70     * this throttle is to avoid overloading the router */
71    MAX_CONNECTIONS_PER_SECOND = 12,
72
73    MAX_CONNECTIONS_PER_PULSE = (int)(MAX_CONNECTIONS_PER_SECOND * (RECONNECT_PERIOD_MSEC/1000.0)),
74
75    /* number of bad pieces a peer is allowed to send before we ban them */
76    MAX_BAD_PIECES_PER_PEER = 5,
77
78    /* amount of time to keep a list of request pieces lying around
79       before it's considered too old and needs to be rebuilt */
80    PIECE_LIST_SHELF_LIFE_SECS = 60,
81
82    /* use for bitwise operations w/peer_atom.flags2 */
83    MYFLAG_BANNED = 1,
84
85    /* use for bitwise operations w/peer_atom.flags2 */
86    /* unreachable for now... but not banned.
87     * if they try to connect to us it's okay */
88    MYFLAG_UNREACHABLE = 2,
89
90    /* the minimum we'll wait before attempting to reconnect to a peer */
91    MINIMUM_RECONNECT_INTERVAL_SECS = 5,
92
93    /** how long we'll let requests we've made linger before we cancel them */
94    REQUEST_TTL_SECS = 120,
95
96    NO_BLOCKS_CANCEL_HISTORY = 120,
97
98    CANCEL_HISTORY_SEC = 60
99};
100
101
102/**
103***
104**/
105
106enum
107{
108    UPLOAD_ONLY_UKNOWN,
109    UPLOAD_ONLY_YES,
110    UPLOAD_ONLY_NO
111};
112
113/**
114 * Peer information that should be kept even before we've connected and
115 * after we've disconnected.  These are kept in a pool of peer_atoms to decide
116 * which ones would make good candidates for connecting to, and to watch out
117 * for banned peers.
118 *
119 * @see tr_peer
120 * @see tr_peermsgs
121 */
122struct peer_atom
123{
124    uint8_t     from;
125    uint8_t     flags;              /* these match the added_f flags */
126    uint8_t     flags2;             /* flags that aren't defined in added_f */
127    uint8_t     uploadOnly;         /* UPLOAD_ONLY_ */
128    int8_t      seedProbability;    /* how likely is this to be a seed... [0..100] or -1 for unknown */
129    int8_t      blocklisted;        /* -1 for unknown, TRUE for blocklisted, FALSE for not blocklisted */
130
131    tr_port     port;
132    uint16_t    numFails;
133    time_t      time;               /* when the peer's connection status last changed */
134    time_t      piece_data_time;
135
136    time_t      lastConnectionAttemptAt;
137    time_t      lastConnectionAt;
138
139    /* similar to a TTL field, but less rigid --
140     * if the swarm is small, the atom will be kept past this date. */
141    time_t      shelf_date;
142    tr_peer   * peer;               /* will be NULL if not connected */
143    tr_address  addr;
144};
145
146#ifdef NDEBUG
147#define tr_isAtom(a) (TRUE)
148#else
149static tr_bool
150tr_isAtom( const struct peer_atom * atom )
151{
152    return ( atom != NULL )
153        && ( atom->from < TR_PEER_FROM__MAX )
154        && ( tr_isAddress( &atom->addr ) );
155}
156#endif
157
158static const char*
159tr_atomAddrStr( const struct peer_atom * atom )
160{
161    return tr_peerIoAddrStr( &atom->addr, atom->port );
162}
163
164struct block_request
165{
166    tr_block_index_t block;
167    tr_peer * peer;
168    time_t sentAt;
169};
170
171struct weighted_piece
172{
173    tr_piece_index_t index;
174    int16_t salt;
175    int16_t requestCount;
176};
177
178/** @brief Opaque, per-torrent data structure for peer connection information */
179typedef struct tr_torrent_peers
180{
181    tr_ptrArray                outgoingHandshakes; /* tr_handshake */
182    tr_ptrArray                pool; /* struct peer_atom */
183    tr_ptrArray                peers; /* tr_peer */
184    tr_ptrArray                webseeds; /* tr_webseed */
185
186    tr_torrent               * tor;
187    struct tr_peerMgr        * manager;
188
189    tr_peer                  * optimistic; /* the optimistic peer, or NULL if none */
190    int                        optimisticUnchokeTimeScaler;
191
192    tr_bool                    isRunning;
193    tr_bool                    needsCompletenessCheck;
194
195    struct block_request     * requests;
196    int                        requestCount;
197    int                        requestAlloc;
198
199    struct weighted_piece    * pieces;
200    int                        pieceCount;
201
202    int                        interestedCount;
203    int                        maxPeers;
204    time_t                     lastCancel;
205}
206Torrent;
207
208struct tr_peerMgr
209{
210    tr_session    * session;
211    tr_ptrArray     incomingHandshakes; /* tr_handshake */
212    struct event  * bandwidthTimer;
213    struct event  * rechokeTimer;
214    struct event  * refillUpkeepTimer;
215    struct event  * atomTimer;
216};
217
218#define tordbg( t, ... ) \
219    do { \
220        if( tr_deepLoggingIsActive( ) ) \
221            tr_deepLog( __FILE__, __LINE__, tr_torrentName( t->tor ), __VA_ARGS__ ); \
222    } while( 0 )
223
224#define dbgmsg( ... ) \
225    do { \
226        if( tr_deepLoggingIsActive( ) ) \
227            tr_deepLog( __FILE__, __LINE__, NULL, __VA_ARGS__ ); \
228    } while( 0 )
229
230/**
231***
232**/
233
234static inline void
235managerLock( const struct tr_peerMgr * manager )
236{
237    tr_sessionLock( manager->session );
238}
239
240static inline void
241managerUnlock( const struct tr_peerMgr * manager )
242{
243    tr_sessionUnlock( manager->session );
244}
245
246static inline void
247torrentLock( Torrent * torrent )
248{
249    managerLock( torrent->manager );
250}
251
252static inline void
253torrentUnlock( Torrent * torrent )
254{
255    managerUnlock( torrent->manager );
256}
257
258static inline int
259torrentIsLocked( const Torrent * t )
260{
261    return tr_sessionIsLocked( t->manager->session );
262}
263
264/**
265***
266**/
267
268static int
269handshakeCompareToAddr( const void * va, const void * vb )
270{
271    const tr_handshake * a = va;
272
273    return tr_compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
274}
275
276static int
277handshakeCompare( const void * a, const void * b )
278{
279    return handshakeCompareToAddr( a, tr_handshakeGetAddr( b, NULL ) );
280}
281
282static inline tr_handshake*
283getExistingHandshake( tr_ptrArray * handshakes, const tr_address * addr )
284{
285    if( tr_ptrArrayEmpty( handshakes ) )
286        return NULL;
287
288    return tr_ptrArrayFindSorted( handshakes, addr, handshakeCompareToAddr );
289}
290
291static int
292comparePeerAtomToAddress( const void * va, const void * vb )
293{
294    const struct peer_atom * a = va;
295
296    return tr_compareAddresses( &a->addr, vb );
297}
298
299static int
300compareAtomsByAddress( const void * va, const void * vb )
301{
302    const struct peer_atom * b = vb;
303
304    assert( tr_isAtom( b ) );
305
306    return comparePeerAtomToAddress( va, &b->addr );
307}
308
309/**
310***
311**/
312
313const tr_address *
314tr_peerAddress( const tr_peer * peer )
315{
316    return &peer->atom->addr;
317}
318
319static Torrent*
320getExistingTorrent( tr_peerMgr *    manager,
321                    const uint8_t * hash )
322{
323    tr_torrent * tor = tr_torrentFindFromHash( manager->session, hash );
324
325    return tor == NULL ? NULL : tor->torrentPeers;
326}
327
328static int
329peerCompare( const void * a, const void * b )
330{
331    return tr_compareAddresses( tr_peerAddress( a ), tr_peerAddress( b ) );
332}
333
334static struct peer_atom*
335getExistingAtom( const Torrent    * t,
336                 const tr_address * addr )
337{
338    Torrent * tt = (Torrent*)t;
339    assert( torrentIsLocked( t ) );
340    return tr_ptrArrayFindSorted( &tt->pool, addr, comparePeerAtomToAddress );
341}
342
343static tr_bool
344peerIsInUse( const Torrent * ct, const struct peer_atom * atom )
345{
346    Torrent * t = (Torrent*) ct;
347
348    assert( torrentIsLocked ( t ) );
349
350    return ( atom->peer != NULL )
351        || getExistingHandshake( &t->outgoingHandshakes, &atom->addr )
352        || getExistingHandshake( &t->manager->incomingHandshakes, &atom->addr );
353}
354
355static tr_peer*
356peerConstructor( struct peer_atom * atom )
357{
358    tr_peer * peer = tr_new0( tr_peer, 1 );
359
360    tr_bitsetConstructor( &peer->have, 0 );
361
362    peer->atom = atom;
363    atom->peer = peer;
364
365    peer->blocksSentToClient  = tr_historyNew( CANCEL_HISTORY_SEC, ( RECHOKE_PERIOD_MSEC / 1000 ) );
366    peer->blocksSentToPeer    = tr_historyNew( CANCEL_HISTORY_SEC, ( RECHOKE_PERIOD_MSEC / 1000 ) );
367    peer->cancelsSentToClient = tr_historyNew( CANCEL_HISTORY_SEC, ( RECHOKE_PERIOD_MSEC / 1000 ) );
368    peer->cancelsSentToPeer   = tr_historyNew( CANCEL_HISTORY_SEC, ( REFILL_UPKEEP_PERIOD_MSEC / 1000 ) );
369
370    return peer;
371}
372
373static tr_peer*
374getPeer( Torrent * torrent, struct peer_atom * atom )
375{
376    tr_peer * peer;
377
378    assert( torrentIsLocked( torrent ) );
379
380    peer = atom->peer;
381
382    if( peer == NULL )
383    {
384        peer = peerConstructor( atom );
385        tr_ptrArrayInsertSorted( &torrent->peers, peer, peerCompare );
386    }
387
388    return peer;
389}
390
391static void peerDeclinedAllRequests( Torrent *, const tr_peer * );
392
393static void
394peerDestructor( Torrent * t, tr_peer * peer )
395{
396    assert( peer != NULL );
397
398    peerDeclinedAllRequests( t, peer );
399
400    if( peer->msgs != NULL )
401        tr_peerMsgsFree( peer->msgs );
402
403    tr_peerIoClear( peer->io );
404    tr_peerIoUnref( peer->io ); /* balanced by the ref in handshakeDoneCB() */
405
406    tr_historyFree( peer->blocksSentToClient  );
407    tr_historyFree( peer->blocksSentToPeer    );
408    tr_historyFree( peer->cancelsSentToClient );
409    tr_historyFree( peer->cancelsSentToPeer   );
410
411    tr_bitsetDestructor( &peer->have );
412    tr_bitfieldFree( peer->blame );
413    tr_free( peer->client );
414    peer->atom->peer = NULL;
415
416    tr_free( peer );
417}
418
419static void
420removePeer( Torrent * t, tr_peer * peer )
421{
422    tr_peer * removed;
423    struct peer_atom * atom = peer->atom;
424
425    assert( torrentIsLocked( t ) );
426    assert( atom );
427
428    atom->time = tr_time( );
429
430    removed = tr_ptrArrayRemoveSorted( &t->peers, peer, peerCompare );
431    assert( removed == peer );
432    peerDestructor( t, removed );
433}
434
435static void
436removeAllPeers( Torrent * t )
437{
438    while( !tr_ptrArrayEmpty( &t->peers ) )
439        removePeer( t, tr_ptrArrayNth( &t->peers, 0 ) );
440}
441
442static void
443torrentDestructor( void * vt )
444{
445    Torrent * t = vt;
446
447    assert( t );
448    assert( !t->isRunning );
449    assert( torrentIsLocked( t ) );
450    assert( tr_ptrArrayEmpty( &t->outgoingHandshakes ) );
451    assert( tr_ptrArrayEmpty( &t->peers ) );
452
453    tr_ptrArrayDestruct( &t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
454    tr_ptrArrayDestruct( &t->pool, (PtrArrayForeachFunc)tr_free );
455    tr_ptrArrayDestruct( &t->outgoingHandshakes, NULL );
456    tr_ptrArrayDestruct( &t->peers, NULL );
457
458    tr_free( t->requests );
459    tr_free( t->pieces );
460    tr_free( t );
461}
462
463static void peerCallbackFunc( tr_peer *, const tr_peer_event *, void * );
464
465static Torrent*
466torrentConstructor( tr_peerMgr * manager,
467                    tr_torrent * tor )
468{
469    int       i;
470    Torrent * t;
471
472    t = tr_new0( Torrent, 1 );
473    t->manager = manager;
474    t->tor = tor;
475    t->pool = TR_PTR_ARRAY_INIT;
476    t->peers = TR_PTR_ARRAY_INIT;
477    t->webseeds = TR_PTR_ARRAY_INIT;
478    t->outgoingHandshakes = TR_PTR_ARRAY_INIT;
479
480    for( i = 0; i < tor->info.webseedCount; ++i )
481    {
482        tr_webseed * w =
483            tr_webseedNew( tor, tor->info.webseeds[i], peerCallbackFunc, t );
484        tr_ptrArrayAppend( &t->webseeds, w );
485    }
486
487    return t;
488}
489
490tr_peerMgr*
491tr_peerMgrNew( tr_session * session )
492{
493    tr_peerMgr * m = tr_new0( tr_peerMgr, 1 );
494    m->session = session;
495    m->incomingHandshakes = TR_PTR_ARRAY_INIT;
496    return m;
497}
498
499static void
500deleteTimer( struct event ** t )
501{
502    if( *t != NULL )
503    {
504        evtimer_del( *t );
505        tr_free( *t );
506        *t = NULL;
507    }
508}
509
510static void
511deleteTimers( struct tr_peerMgr * m )
512{
513    deleteTimer( &m->atomTimer );
514    deleteTimer( &m->bandwidthTimer );
515    deleteTimer( &m->rechokeTimer );
516    deleteTimer( &m->refillUpkeepTimer );
517}
518
519void
520tr_peerMgrFree( tr_peerMgr * manager )
521{
522    managerLock( manager );
523
524    deleteTimers( manager );
525
526    /* free the handshakes.  Abort invokes handshakeDoneCB(), which removes
527     * the item from manager->handshakes, so this is a little roundabout... */
528    while( !tr_ptrArrayEmpty( &manager->incomingHandshakes ) )
529        tr_handshakeAbort( tr_ptrArrayNth( &manager->incomingHandshakes, 0 ) );
530
531    tr_ptrArrayDestruct( &manager->incomingHandshakes, NULL );
532
533    managerUnlock( manager );
534    tr_free( manager );
535}
536
537static int
538clientIsDownloadingFrom( const tr_torrent * tor, const tr_peer * peer )
539{
540    if( !tr_torrentHasMetadata( tor ) )
541        return TRUE;
542
543    return peer->clientIsInterested && !peer->clientIsChoked;
544}
545
546static int
547clientIsUploadingTo( const tr_peer * peer )
548{
549    return peer->peerIsInterested && !peer->peerIsChoked;
550}
551
552/***
553****
554***/
555
556void
557tr_peerMgrOnBlocklistChanged( tr_peerMgr * mgr )
558{
559    tr_torrent * tor = NULL;
560    tr_session * session = mgr->session;
561
562    /* we cache whether or not a peer is blocklisted...
563       since the blocklist has changed, erase that cached value */
564    while(( tor = tr_torrentNext( session, tor )))
565    {
566        int i;
567        Torrent * t = tor->torrentPeers;
568        const int n = tr_ptrArraySize( &t->pool );
569        for( i=0; i<n; ++i ) {
570            struct peer_atom * atom = tr_ptrArrayNth( &t->pool, i );
571            atom->blocklisted = -1;
572        }
573    }
574}
575
576static tr_bool
577isAtomBlocklisted( tr_session * session, struct peer_atom * atom )
578{
579    if( atom->blocklisted < 0 )
580        atom->blocklisted = tr_sessionIsAddressBlocked( session, &atom->addr );
581
582    assert( tr_isBool( atom->blocklisted ) );
583    return atom->blocklisted;
584}
585
586
587/***
588****
589***/
590
591static void
592atomSetSeedProbability( struct peer_atom * atom, int seedProbability )
593{
594    assert( atom != NULL );
595    assert( -1<=seedProbability && seedProbability<=100 );
596
597    atom->seedProbability = seedProbability;
598
599    if( seedProbability == 100 )
600        atom->flags |= ADDED_F_SEED_FLAG;
601    else if( seedProbability != -1 )
602        atom->flags &= ~ADDED_F_SEED_FLAG;
603}
604
605static void
606atomSetSeed( struct peer_atom * atom )
607{
608    atomSetSeedProbability( atom, 100 );
609}
610
611static inline tr_bool
612atomIsSeed( const struct peer_atom * atom )
613{
614    return atom->seedProbability == 100;
615}
616
617tr_bool
618tr_peerMgrPeerIsSeed( const tr_torrent  * tor,
619                      const tr_address  * addr )
620{
621    tr_bool isSeed = FALSE;
622    const Torrent * t = tor->torrentPeers;
623    const struct peer_atom * atom = getExistingAtom( t, addr );
624
625    if( atom )
626        isSeed = atomIsSeed( atom );
627
628    return isSeed;
629}
630
631/**
632***  REQUESTS
633***
634*** There are two data structures associated with managing block requests:
635***
636*** 1. Torrent::requests, an array of "struct block_request" which keeps
637***    track of which blocks have been requested, and when, and by which peers.
638***    This is list is used for (a) cancelling requests that have been pending
639***    for too long and (b) avoiding duplicate requests before endgame.
640***
641*** 2. Torrent::pieces, an array of "struct weighted_piece" which lists the
642***    pieces that we want to request.  It's used to decide which blocks to
643***    return next when tr_peerMgrGetBlockRequests() is called.
644**/
645
646/**
647*** struct block_request
648**/
649
650static int
651compareReqByBlock( const void * va, const void * vb )
652{
653    const struct block_request * a = va;
654    const struct block_request * b = vb;
655
656    /* primary key: block */
657    if( a->block < b->block ) return -1;
658    if( a->block > b->block ) return 1;
659
660    /* secondary key: peer */
661    if( a->peer < b->peer ) return -1;
662    if( a->peer > b->peer ) return 1;
663
664    return 0;
665}
666
667static void
668requestListAdd( Torrent * t, tr_block_index_t block, tr_peer * peer )
669{
670    struct block_request key;
671
672    /* ensure enough room is available... */
673    if( t->requestCount + 1 >= t->requestAlloc )
674    {
675        const int CHUNK_SIZE = 128;
676        t->requestAlloc += CHUNK_SIZE;
677        t->requests = tr_renew( struct block_request,
678                                t->requests, t->requestAlloc );
679    }
680
681    /* populate the record we're inserting */
682    key.block = block;
683    key.peer = peer;
684    key.sentAt = tr_time( );
685
686    /* insert the request to our array... */
687    {
688        tr_bool exact;
689        const int pos = tr_lowerBound( &key, t->requests, t->requestCount,
690                                       sizeof( struct block_request ),
691                                       compareReqByBlock, &exact );
692        assert( !exact );
693        memmove( t->requests + pos + 1,
694                 t->requests + pos,
695                 sizeof( struct block_request ) * ( t->requestCount++ - pos ) );
696        t->requests[pos] = key;
697    }
698
699    if( peer != NULL )
700    {
701        ++peer->pendingReqsToPeer;
702        assert( peer->pendingReqsToPeer >= 0 );
703    }
704
705    /*fprintf( stderr, "added request of block %lu from peer %s... "
706                       "there are now %d block\n",
707                       (unsigned long)block, tr_atomAddrStr( peer->atom ), t->requestCount );*/
708}
709
710static struct block_request *
711requestListLookup( Torrent * t, tr_block_index_t block, const tr_peer * peer )
712{
713    struct block_request key;
714    key.block = block;
715    key.peer = (tr_peer*) peer;
716
717    return bsearch( &key, t->requests, t->requestCount,
718                    sizeof( struct block_request ),
719                    compareReqByBlock );
720}
721
722/* how many peers are we currently requesting this block from... */
723static int
724countBlockRequests( Torrent * t, tr_block_index_t block )
725{
726    tr_bool exact;
727    int i, n, pos;
728    struct block_request key;
729
730    key.block = block;
731    key.peer = NULL;
732    pos = tr_lowerBound( &key, t->requests, t->requestCount,
733                         sizeof( struct block_request ),
734                         compareReqByBlock, &exact );
735
736    assert( !exact ); /* shouldn't have a request with .peer == NULL */
737
738    n = 0;
739    for( i=pos; i<t->requestCount; ++i ) {
740        if( t->requests[i].block == block )
741            ++n;
742        else
743            break;
744    }
745
746    return n;
747}
748
749static void
750decrementPendingReqCount( const struct block_request * b )
751{
752    if( b->peer != NULL )
753        if( b->peer->pendingReqsToPeer > 0 )
754            --b->peer->pendingReqsToPeer;
755}
756
757static void
758requestListRemove( Torrent * t, tr_block_index_t block, const tr_peer * peer )
759{
760    const struct block_request * b = requestListLookup( t, block, peer );
761    if( b != NULL )
762    {
763        const int pos = b - t->requests;
764        assert( pos < t->requestCount );
765
766        decrementPendingReqCount( b );
767
768        tr_removeElementFromArray( t->requests,
769                                   pos,
770                                   sizeof( struct block_request ),
771                                   t->requestCount-- );
772
773        /*fprintf( stderr, "removing request of block %lu from peer %s... "
774                           "there are now %d block requests left\n",
775                           (unsigned long)block, tr_atomAddrStr( peer->atom ), t->requestCount );*/
776    }
777}
778
779/**
780*** struct weighted_piece
781**/
782
783enum
784{
785    PIECES_UNSORTED,
786    PIECES_SORTED_BY_INDEX,
787    PIECES_SORTED_BY_WEIGHT
788};
789
790const tr_torrent * weightTorrent;
791
792/* we try to create a "weight" s.t. high-priority pieces come before others,
793 * and that partially-complete pieces come before empty ones. */
794static int
795comparePieceByWeight( const void * va, const void * vb )
796{
797    const struct weighted_piece * a = va;
798    const struct weighted_piece * b = vb;
799    int ia, ib, missing, pending;
800    const tr_torrent * tor = weightTorrent;
801
802    /* primary key: weight */
803    missing = tr_cpMissingBlocksInPiece( &tor->completion, a->index );
804    pending = a->requestCount;
805    ia = missing > pending ? missing - pending : (int)(tor->blockCountInPiece + pending);
806    missing = tr_cpMissingBlocksInPiece( &tor->completion, b->index );
807    pending = b->requestCount;
808    ib = missing > pending ? missing - pending : (int)(tor->blockCountInPiece + pending);
809    if( ia < ib ) return -1;
810    if( ia > ib ) return 1;
811
812    /* secondary key: higher priorities go first */
813    ia = tor->info.pieces[a->index].priority;
814    ib = tor->info.pieces[b->index].priority;
815    if( ia > ib ) return -1;
816    if( ia < ib ) return 1;
817
818    /* tertiary key: random */
819    if( a->salt < b->salt ) return -1;
820    if( a->salt > b->salt ) return 1;
821
822    /* okay, they're equal */
823    return 0;
824}
825
826static int
827comparePieceByIndex( const void * va, const void * vb )
828{
829    const struct weighted_piece * a = va;
830    const struct weighted_piece * b = vb;
831    if( a->index < b->index ) return -1;
832    if( a->index > b->index ) return 1;
833    return 0;
834}
835
836static void
837pieceListSort( Torrent * t, int mode )
838{
839    assert( mode==PIECES_SORTED_BY_INDEX
840         || mode==PIECES_SORTED_BY_WEIGHT );
841
842    weightTorrent = t->tor;
843
844    if( mode == PIECES_SORTED_BY_WEIGHT )
845        qsort( t->pieces, t->pieceCount, sizeof( struct weighted_piece ), comparePieceByWeight );
846    else
847        qsort( t->pieces, t->pieceCount, sizeof( struct weighted_piece ), comparePieceByIndex );
848}
849
850static tr_bool
851isInEndgame( Torrent * t )
852{
853    tr_bool endgame = FALSE;
854
855    if( ( t->pieces != NULL ) && ( t->pieceCount > 0 ) )
856    {
857        const struct weighted_piece * p = t->pieces;
858        const int pending = p->requestCount;
859        const int missing = tr_cpMissingBlocksInPiece( &t->tor->completion, p->index );
860        endgame = pending >= missing;
861    }
862
863    /*if( endgame ) fprintf( stderr, "ENDGAME reached\n" );*/
864    return endgame;
865}
866
867/**
868 * This function is useful for sanity checking,
869 * but is too expensive even for nightly builds...
870 * let's leave it disabled but add an easy hook to compile it back in
871 */
872#if 0
873static void
874assertWeightedPiecesAreSorted( Torrent * t )
875{
876    if( !isInEndgame( t ) )
877    {
878        int i;
879        weightTorrent = t->tor;
880        for( i=0; i<t->pieceCount-1; ++i )
881            assert( comparePieceByWeight( &t->pieces[i], &t->pieces[i+1] ) <= 0 );
882    }
883}
884#else
885#define assertWeightedPiecesAreSorted(t)
886#endif
887
888static struct weighted_piece *
889pieceListLookup( Torrent * t, tr_piece_index_t index )
890{
891    int i;
892
893    for( i=0; i<t->pieceCount; ++i )
894        if( t->pieces[i].index == index )
895            return &t->pieces[i];
896
897    return NULL;
898}
899
900static void
901pieceListRebuild( Torrent * t )
902{
903    assertWeightedPiecesAreSorted( t );
904
905    if( !tr_torrentIsSeed( t->tor ) )
906    {
907        tr_piece_index_t i;
908        tr_piece_index_t * pool;
909        tr_piece_index_t poolCount = 0;
910        const tr_torrent * tor = t->tor;
911        const tr_info * inf = tr_torrentInfo( tor );
912        struct weighted_piece * pieces;
913        int pieceCount;
914
915        /* build the new list */
916        pool = tr_new( tr_piece_index_t, inf->pieceCount );
917        for( i=0; i<inf->pieceCount; ++i )
918            if( !inf->pieces[i].dnd )
919                if( !tr_cpPieceIsComplete( &tor->completion, i ) )
920                    pool[poolCount++] = i;
921        pieceCount = poolCount;
922        pieces = tr_new0( struct weighted_piece, pieceCount );
923        for( i=0; i<poolCount; ++i ) {
924            struct weighted_piece * piece = pieces + i;
925            piece->index = pool[i];
926            piece->requestCount = 0;
927            piece->salt = tr_cryptoWeakRandInt( 4096 );
928        }
929
930        /* if we already had a list of pieces, merge it into
931         * the new list so we don't lose its requestCounts */
932        if( t->pieces != NULL )
933        {
934            struct weighted_piece * o = t->pieces;
935            struct weighted_piece * oend = o + t->pieceCount;
936            struct weighted_piece * n = pieces;
937            struct weighted_piece * nend = n + pieceCount;
938
939            pieceListSort( t, PIECES_SORTED_BY_INDEX );
940
941            while( o!=oend && n!=nend ) {
942                if( o->index < n->index )
943                    ++o;
944                else if( o->index > n->index )
945                    ++n;
946                else
947                    *n++ = *o++;
948            }
949
950            tr_free( t->pieces );
951        }
952
953        t->pieces = pieces;
954        t->pieceCount = pieceCount;
955
956        pieceListSort( t, PIECES_SORTED_BY_WEIGHT );
957
958        /* cleanup */
959        tr_free( pool );
960    }
961}
962
963static void
964pieceListRemovePiece( Torrent * t, tr_piece_index_t piece )
965{
966    struct weighted_piece * p;
967
968    assertWeightedPiecesAreSorted( t );
969
970    if(( p = pieceListLookup( t, piece )))
971    {
972        const int pos = p - t->pieces;
973
974        tr_removeElementFromArray( t->pieces,
975                                   pos,
976                                   sizeof( struct weighted_piece ),
977                                   t->pieceCount-- );
978
979        if( t->pieceCount == 0 )
980        {
981            tr_free( t->pieces );
982            t->pieces = NULL;
983        }
984    }
985
986    assertWeightedPiecesAreSorted( t );
987}
988
989static void
990pieceListResortPiece( Torrent * t, struct weighted_piece * p )
991{
992    int pos;
993    tr_bool isSorted = TRUE;
994
995    if( p == NULL )
996        return;
997
998    /* is the torrent already sorted? */
999    pos = p - t->pieces;
1000    weightTorrent = t->tor;
1001    if( isSorted && ( pos > 0 ) && ( comparePieceByWeight( p-1, p ) > 0 ) )
1002        isSorted = FALSE;
1003    if( isSorted && ( pos < t->pieceCount - 1 ) && ( comparePieceByWeight( p, p+1 ) > 0 ) )
1004        isSorted = FALSE;
1005
1006    /* if it's not sorted, move it around */
1007    if( !isSorted )
1008    {
1009        tr_bool exact;
1010        const struct weighted_piece tmp = *p;
1011
1012        tr_removeElementFromArray( t->pieces,
1013                                   pos,
1014                                   sizeof( struct weighted_piece ),
1015                                   t->pieceCount-- );
1016
1017        pos = tr_lowerBound( &tmp, t->pieces, t->pieceCount,
1018                             sizeof( struct weighted_piece ),
1019                             comparePieceByWeight, &exact );
1020
1021        memmove( &t->pieces[pos + 1],
1022                 &t->pieces[pos],
1023                 sizeof( struct weighted_piece ) * ( t->pieceCount++ - pos ) );
1024
1025        t->pieces[pos] = tmp;
1026    }
1027
1028    assertWeightedPiecesAreSorted( t );
1029}
1030
1031static void
1032pieceListRemoveRequest( Torrent * t, tr_block_index_t block )
1033{
1034    struct weighted_piece * p;
1035    const tr_piece_index_t index = tr_torBlockPiece( t->tor, block );
1036
1037    assertWeightedPiecesAreSorted( t );
1038
1039    if( ((p = pieceListLookup( t, index ))) && ( p->requestCount > 0 ) )
1040    {
1041        --p->requestCount;
1042        pieceListResortPiece( t, p );
1043    }
1044
1045    assertWeightedPiecesAreSorted( t );
1046}
1047
1048/**
1049***
1050**/
1051
1052void
1053tr_peerMgrRebuildRequests( tr_torrent * tor )
1054{
1055    assert( tr_isTorrent( tor ) );
1056
1057    pieceListRebuild( tor->torrentPeers );
1058}
1059
1060void
1061tr_peerMgrGetNextRequests( tr_torrent           * tor,
1062                           tr_peer              * peer,
1063                           int                    numwant,
1064                           tr_block_index_t     * setme,
1065                           int                  * numgot )
1066{
1067    int i;
1068    int got;
1069    Torrent * t;
1070    tr_bool endgame;
1071    struct weighted_piece * pieces;
1072    const tr_bitset * have = &peer->have;
1073
1074    /* sanity clause */
1075    assert( tr_isTorrent( tor ) );
1076    assert( peer->clientIsInterested );
1077    assert( !peer->clientIsChoked );
1078    assert( numwant > 0 );
1079
1080    /* walk through the pieces and find blocks that should be requested */
1081    got = 0;
1082    t = tor->torrentPeers;
1083    assertWeightedPiecesAreSorted( t );
1084
1085    /* prep the pieces list */
1086    if( t->pieces == NULL )
1087        pieceListRebuild( t );
1088
1089    endgame = isInEndgame( t );
1090
1091    pieces = t->pieces;
1092    for( i=0; i<t->pieceCount && got<numwant; ++i )
1093    {
1094        struct weighted_piece * p = pieces + i;
1095        const int missing = tr_cpMissingBlocksInPiece( &tor->completion, p->index );
1096        const int maxDuplicatesPerBlock = endgame ? 3 : 1;
1097
1098        if( p->requestCount > ( missing * maxDuplicatesPerBlock ) )
1099            continue;
1100
1101        /* if the peer has this piece that we want... */
1102        if( tr_bitsetHasFast( have, p->index ) )
1103        {
1104            tr_block_index_t b = tr_torPieceFirstBlock( tor, p->index );
1105            const tr_block_index_t e = b + tr_torPieceCountBlocks( tor, p->index );
1106
1107            for( ; b!=e && got<numwant; ++b )
1108            {
1109                /* don't request blocks we've already got */
1110                if( tr_cpBlockIsCompleteFast( &tor->completion, b ) )
1111                    continue;
1112
1113                /* don't send the same request to the same peer twice */
1114                if( tr_peerMgrDidPeerRequest( tor, peer, b ) )
1115                    continue;
1116
1117                /* don't send the same request to any peer too many times */
1118                if( countBlockRequests( t, b ) >= maxDuplicatesPerBlock )
1119                    continue;
1120
1121                /* update the caller's table */
1122                setme[got++] = b;
1123
1124                /* update our own tables */
1125                requestListAdd( t, b, peer );
1126                ++p->requestCount;
1127            }
1128        }
1129    }
1130
1131    /* In most cases we've just changed the weights of a small number of pieces.
1132     * So rather than qsort()ing the entire array, it's faster to apply an
1133     * adaptive insertion sort algorithm. */
1134    if( got > 0 )
1135    {
1136        /* not enough requests || last piece modified */
1137        if ( i == t->pieceCount ) --i;
1138
1139        weightTorrent = t->tor;
1140        while( --i >= 0 )
1141        {
1142            tr_bool exact;
1143
1144            /* relative position! */
1145            const int newpos = tr_lowerBound( &t->pieces[i], &t->pieces[i + 1],
1146                                              t->pieceCount - (i + 1),
1147                                              sizeof( struct weighted_piece ),
1148                                              comparePieceByWeight, &exact );
1149            if( newpos > 0 )
1150            {
1151                const struct weighted_piece piece = t->pieces[i];
1152                memmove( &t->pieces[i],
1153                         &t->pieces[i + 1],
1154                         sizeof( struct weighted_piece ) * ( newpos ) );
1155                t->pieces[i + newpos] = piece;
1156            }
1157        }
1158    }
1159
1160    assertWeightedPiecesAreSorted( t );
1161    *numgot = got;
1162}
1163
1164tr_bool
1165tr_peerMgrDidPeerRequest( const tr_torrent  * tor,
1166                          const tr_peer     * peer,
1167                          tr_block_index_t    block )
1168{
1169    const Torrent * t = tor->torrentPeers;
1170    return requestListLookup( (Torrent*)t, block, peer ) != NULL;
1171}
1172
1173/* cancel requests that are too old */
1174static void
1175refillUpkeep( int foo UNUSED, short bar UNUSED, void * vmgr )
1176{
1177    time_t now;
1178    time_t too_old;
1179    tr_torrent * tor;
1180    tr_peerMgr * mgr = vmgr;
1181    managerLock( mgr );
1182
1183    now = tr_time( );
1184    too_old = now - REQUEST_TTL_SECS;
1185
1186    tor = NULL;
1187    while(( tor = tr_torrentNext( mgr->session, tor )))
1188    {
1189        Torrent * t = tor->torrentPeers;
1190        const int n = t->requestCount;
1191        if( n > 0 )
1192        {
1193            int keepCount = 0;
1194            int cancelCount = 0;
1195            struct block_request * cancel = tr_new( struct block_request, n );
1196            const struct block_request * it;
1197            const struct block_request * end;
1198
1199            for( it=t->requests, end=it+n; it!=end; ++it )
1200            {
1201                if( ( it->sentAt <= too_old ) && !tr_peerMsgsIsReadingBlock( it->peer->msgs, it->block ) )
1202                    cancel[cancelCount++] = *it;
1203                else
1204                {
1205                    if( it != &t->requests[keepCount] )
1206                        t->requests[keepCount] = *it;
1207                    keepCount++;
1208                }
1209            }
1210
1211            /* prune out the ones we aren't keeping */
1212            t->requestCount = keepCount;
1213
1214            /* send cancel messages for all the "cancel" ones */
1215            for( it=cancel, end=it+cancelCount; it!=end; ++it ) {
1216                if( ( it->peer != NULL ) && ( it->peer->msgs != NULL ) ) {
1217                    tr_historyAdd( it->peer->cancelsSentToPeer, now, 1 );
1218                    tr_peerMsgsCancel( it->peer->msgs, it->block );
1219                    decrementPendingReqCount( it );
1220                }
1221            }
1222
1223            /* decrement the pending request counts for the timed-out blocks */
1224            for( it=cancel, end=it+cancelCount; it!=end; ++it )
1225                pieceListRemoveRequest( t, it->block );
1226
1227            /* cleanup loop */
1228            tr_free( cancel );
1229        }
1230    }
1231
1232    tr_timerAddMsec( mgr->refillUpkeepTimer, REFILL_UPKEEP_PERIOD_MSEC );
1233    managerUnlock( mgr );
1234}
1235
1236static void
1237addStrike( Torrent * t, tr_peer * peer )
1238{
1239    tordbg( t, "increasing peer %s strike count to %d",
1240            tr_atomAddrStr( peer->atom ), peer->strikes + 1 );
1241
1242    if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
1243    {
1244        struct peer_atom * atom = peer->atom;
1245        atom->flags2 |= MYFLAG_BANNED;
1246        peer->doPurge = 1;
1247        tordbg( t, "banning peer %s", tr_atomAddrStr( atom ) );
1248    }
1249}
1250
1251static void
1252gotBadPiece( Torrent * t, tr_piece_index_t pieceIndex )
1253{
1254    tr_torrent *   tor = t->tor;
1255    const uint32_t byteCount = tr_torPieceCountBytes( tor, pieceIndex );
1256
1257    tor->corruptCur += byteCount;
1258    tor->downloadedCur -= MIN( tor->downloadedCur, byteCount );
1259
1260    tr_announcerAddBytes( tor, TR_ANN_CORRUPT, byteCount );
1261}
1262
1263static void
1264peerSuggestedPiece( Torrent            * t UNUSED,
1265                    tr_peer            * peer UNUSED,
1266                    tr_piece_index_t     pieceIndex UNUSED,
1267                    int                  isFastAllowed UNUSED )
1268{
1269#if 0
1270    assert( t );
1271    assert( peer );
1272    assert( peer->msgs );
1273
1274    /* is this a valid piece? */
1275    if(  pieceIndex >= t->tor->info.pieceCount )
1276        return;
1277
1278    /* don't ask for it if we've already got it */
1279    if( tr_cpPieceIsComplete( t->tor->completion, pieceIndex ) )
1280        return;
1281
1282    /* don't ask for it if they don't have it */
1283    if( !tr_bitfieldHas( peer->have, pieceIndex ) )
1284        return;
1285
1286    /* don't ask for it if we're choked and it's not fast */
1287    if( !isFastAllowed && peer->clientIsChoked )
1288        return;
1289
1290    /* request the blocks that we don't have in this piece */
1291    {
1292        tr_block_index_t block;
1293        const tr_torrent * tor = t->tor;
1294        const tr_block_index_t start = tr_torPieceFirstBlock( tor, pieceIndex );
1295        const tr_block_index_t end = start + tr_torPieceCountBlocks( tor, pieceIndex );
1296
1297        for( block=start; block<end; ++block )
1298        {
1299            if( !tr_cpBlockIsComplete( tor->completion, block ) )
1300            {
1301                const uint32_t offset = getBlockOffsetInPiece( tor, block );
1302                const uint32_t length = tr_torBlockCountBytes( tor, block );
1303                tr_peerMsgsAddRequest( peer->msgs, pieceIndex, offset, length );
1304                incrementPieceRequests( t, pieceIndex );
1305            }
1306        }
1307    }
1308#endif
1309}
1310
1311static void
1312removeRequestFromTables( Torrent * t, tr_block_index_t block, const tr_peer * peer )
1313{
1314    requestListRemove( t, block, peer );
1315    pieceListRemoveRequest( t, block );
1316}
1317
1318/* peer choked us, or maybe it disconnected.
1319   either way we need to remove all its requests */
1320static void
1321peerDeclinedAllRequests( Torrent * t, const tr_peer * peer )
1322{
1323    int i, n;
1324    tr_block_index_t * blocks = tr_new( tr_block_index_t, t->requestCount );
1325
1326    for( i=n=0; i<t->requestCount; ++i )
1327        if( peer == t->requests[i].peer )
1328            blocks[n++] = t->requests[i].block;
1329
1330    for( i=0; i<n; ++i )
1331        removeRequestFromTables( t, blocks[i], peer );
1332
1333    tr_free( blocks );
1334}
1335
1336static void
1337peerCallbackFunc( tr_peer * peer, const tr_peer_event * e, void * vt )
1338{
1339    Torrent * t = vt;
1340
1341    torrentLock( t );
1342
1343    switch( e->eventType )
1344    {
1345        case TR_PEER_PEER_GOT_DATA:
1346        {
1347            const time_t now = tr_time( );
1348            tr_torrent * tor = t->tor;
1349
1350            if( e->wasPieceData )
1351            {
1352                tor->uploadedCur += e->length;
1353                tr_announcerAddBytes( tor, TR_ANN_UP, e->length );
1354                tr_torrentSetActivityDate( tor, now );
1355                tr_torrentSetDirty( tor );
1356            }
1357
1358            /* update the stats */
1359            if( e->wasPieceData )
1360                tr_statsAddUploaded( tor->session, e->length );
1361
1362            /* update our atom */
1363            if( peer && e->wasPieceData )
1364                peer->atom->piece_data_time = now;
1365
1366            break;
1367        }
1368
1369        case TR_PEER_CLIENT_GOT_REJ:
1370            removeRequestFromTables( t, _tr_block( t->tor, e->pieceIndex, e->offset ), peer );
1371            break;
1372
1373        case TR_PEER_CLIENT_GOT_CHOKE:
1374            peerDeclinedAllRequests( t, peer );
1375            break;
1376
1377        case TR_PEER_CLIENT_GOT_PORT:
1378            if( peer )
1379                peer->atom->port = e->port;
1380            break;
1381
1382        case TR_PEER_CLIENT_GOT_SUGGEST:
1383            if( peer )
1384                peerSuggestedPiece( t, peer, e->pieceIndex, FALSE );
1385            break;
1386
1387        case TR_PEER_CLIENT_GOT_ALLOWED_FAST:
1388            if( peer )
1389                peerSuggestedPiece( t, peer, e->pieceIndex, TRUE );
1390            break;
1391
1392        case TR_PEER_CLIENT_GOT_DATA:
1393        {
1394            const time_t now = tr_time( );
1395            tr_torrent * tor = t->tor;
1396
1397            if( e->wasPieceData )
1398            {
1399                tor->downloadedCur += e->length;
1400                tr_torrentSetActivityDate( tor, now );
1401                tr_torrentSetDirty( tor );
1402            }
1403
1404            /* update the stats */
1405            if( e->wasPieceData )
1406                tr_statsAddDownloaded( tor->session, e->length );
1407
1408            /* update our atom */
1409            if( peer && e->wasPieceData )
1410                peer->atom->piece_data_time = now;
1411
1412            break;
1413        }
1414
1415        case TR_PEER_PEER_PROGRESS:
1416        {
1417            if( peer )
1418            {
1419                struct peer_atom * atom = peer->atom;
1420                if( e->progress >= 1.0 ) {
1421                    tordbg( t, "marking peer %s as a seed", tr_atomAddrStr( atom ) );
1422                    atomSetSeed( atom );
1423                }
1424            }
1425            break;
1426        }
1427
1428        case TR_PEER_CLIENT_GOT_BLOCK:
1429        {
1430            tr_torrent * tor = t->tor;
1431            tr_block_index_t block = _tr_block( tor, e->pieceIndex, e->offset );
1432
1433            requestListRemove( t, block, peer );
1434            pieceListRemoveRequest( t, block );
1435
1436            if( peer != NULL )
1437                tr_historyAdd( peer->blocksSentToClient, tr_time( ), 1 );
1438
1439            if( tr_cpBlockIsComplete( &tor->completion, block ) )
1440            {
1441                /* we already have this block... */
1442                const uint32_t n = tr_torBlockCountBytes( tor, block );
1443                tor->downloadedCur -= MIN( tor->downloadedCur, n );
1444                tordbg( t, "we have this block already..." );
1445            }
1446            else
1447            {
1448                tr_cpBlockAdd( &tor->completion, block );
1449                pieceListResortPiece( t, pieceListLookup( t, e->pieceIndex ) );
1450                tr_torrentSetDirty( tor );
1451
1452                if( tr_cpPieceIsComplete( &tor->completion, e->pieceIndex ) )
1453                {
1454                    const tr_piece_index_t p = e->pieceIndex;
1455                    const tr_bool ok = tr_torrentCheckPiece( tor, p );
1456
1457                    tr_tordbg( tor, "[LAZY] checked just-completed piece %zu", (size_t)p );
1458
1459                    if( !ok )
1460                    {
1461                        tr_torerr( tor, _( "Piece %lu, which was just downloaded, failed its checksum test" ),
1462                                   (unsigned long)p );
1463                    }
1464
1465                    tr_peerMgrSetBlame( tor, p, ok );
1466
1467                    if( !ok )
1468                    {
1469                        gotBadPiece( t, p );
1470                    }
1471                    else
1472                    {
1473                        int i;
1474                        int peerCount;
1475                        tr_peer ** peers;
1476                        tr_file_index_t fileIndex;
1477
1478                        /* only add this to downloadedCur if we got it from a peer --
1479                         * webseeds shouldn't count against our ratio.  As one tracker
1480                         * admin put it, "Those pieces are downloaded directly from the
1481                         * content distributor, not the peers, it is the tracker's job
1482                         * to manage the swarms, not the web server and does not fit
1483                         * into the jurisdiction of the tracker." */
1484                        if( peer != NULL ) {
1485                            const uint32_t n = tr_torPieceCountBytes( tor, p );
1486                            tr_announcerAddBytes( tor, TR_ANN_DOWN, n );
1487                        }
1488
1489                        peerCount = tr_ptrArraySize( &t->peers );
1490                        peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
1491                        for( i=0; i<peerCount; ++i )
1492                            tr_peerMsgsHave( peers[i]->msgs, p );
1493
1494                        for( fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex ) {
1495                            const tr_file * file = &tor->info.files[fileIndex];
1496                            if( ( file->firstPiece <= p ) && ( p <= file->lastPiece ) ) {
1497                                if( tr_cpFileIsComplete( &tor->completion, fileIndex ) ) {
1498                                    tr_cacheFlushFile( tor->session->cache, tor, fileIndex );
1499                                    tr_torrentFileCompleted( tor, fileIndex );
1500                                }
1501                            }
1502                        }
1503
1504                        pieceListRemovePiece( t, p );
1505                    }
1506                }
1507
1508                t->needsCompletenessCheck = TRUE;
1509            }
1510            break;
1511        }
1512
1513        case TR_PEER_ERROR:
1514            if( ( e->err == ERANGE ) || ( e->err == EMSGSIZE ) || ( e->err == ENOTCONN ) )
1515            {
1516                /* some protocol error from the peer */
1517                peer->doPurge = 1;
1518                tordbg( t, "setting %s doPurge flag because we got an ERANGE, EMSGSIZE, or ENOTCONN error",
1519                        tr_atomAddrStr( peer->atom ) );
1520            }
1521            else
1522            {
1523                tordbg( t, "unhandled error: %s", tr_strerror( e->err ) );
1524            }
1525            break;
1526
1527        default:
1528            assert( 0 );
1529    }
1530
1531    torrentUnlock( t );
1532}
1533
1534static int
1535getDefaultShelfLife( uint8_t from )
1536{
1537    /* in general, peers obtained from firsthand contact
1538     * are better than those from secondhand, etc etc */
1539    switch( from )
1540    {
1541        case TR_PEER_FROM_INCOMING : return 60 * 60 * 6;
1542        case TR_PEER_FROM_LTEP     : return 60 * 60 * 6;
1543        case TR_PEER_FROM_TRACKER  : return 60 * 60 * 3;
1544        case TR_PEER_FROM_DHT      : return 60 * 60 * 3;
1545        case TR_PEER_FROM_PEX      : return 60 * 60 * 2;
1546        case TR_PEER_FROM_RESUME   : return 60 * 60;
1547        case TR_PEER_FROM_LPD      : return 10 * 60;
1548        default                    : return 60 * 60;
1549    }
1550}
1551
1552static void
1553ensureAtomExists( Torrent           * t,
1554                  const tr_address  * addr,
1555                  const tr_port       port,
1556                  const uint8_t       flags,
1557                  const int8_t        seedProbability,
1558                  const uint8_t       from )
1559{
1560    struct peer_atom * a;
1561
1562    assert( tr_isAddress( addr ) );
1563    assert( from < TR_PEER_FROM__MAX );
1564
1565    a = getExistingAtom( t, addr );
1566
1567    if( a == NULL )
1568    {
1569        const int jitter = tr_cryptoWeakRandInt( 60*10 );
1570        a = tr_new0( struct peer_atom, 1 );
1571        a->addr = *addr;
1572        a->port = port;
1573        a->flags = flags;
1574        a->from = from;
1575        a->shelf_date = tr_time( ) + getDefaultShelfLife( from ) + jitter;
1576        a->blocklisted = -1;
1577        atomSetSeedProbability( a, seedProbability );
1578        tr_ptrArrayInsertSorted( &t->pool, a, compareAtomsByAddress );
1579
1580        tordbg( t, "got a new atom: %s", tr_atomAddrStr( a ) );
1581    }
1582    else if( a->seedProbability == -1 )
1583    {
1584        atomSetSeedProbability( a, seedProbability );
1585    }
1586}
1587
1588static int
1589getMaxPeerCount( const tr_torrent * tor )
1590{
1591    return tor->maxConnectedPeers;
1592}
1593
1594static int
1595getPeerCount( const Torrent * t )
1596{
1597    return tr_ptrArraySize( &t->peers );/* + tr_ptrArraySize( &t->outgoingHandshakes ); */
1598}
1599
1600/* FIXME: this is kind of a mess. */
1601static tr_bool
1602myHandshakeDoneCB( tr_handshake  * handshake,
1603                   tr_peerIo     * io,
1604                   tr_bool         readAnythingFromPeer,
1605                   tr_bool         isConnected,
1606                   const uint8_t * peer_id,
1607                   void          * vmanager )
1608{
1609    tr_bool            ok = isConnected;
1610    tr_bool            success = FALSE;
1611    tr_port            port;
1612    const tr_address * addr;
1613    tr_peerMgr       * manager = vmanager;
1614    Torrent          * t;
1615    tr_handshake     * ours;
1616
1617    assert( io );
1618    assert( tr_isBool( ok ) );
1619
1620    t = tr_peerIoHasTorrentHash( io )
1621        ? getExistingTorrent( manager, tr_peerIoGetTorrentHash( io ) )
1622        : NULL;
1623
1624    if( tr_peerIoIsIncoming ( io ) )
1625        ours = tr_ptrArrayRemoveSorted( &manager->incomingHandshakes,
1626                                        handshake, handshakeCompare );
1627    else if( t )
1628        ours = tr_ptrArrayRemoveSorted( &t->outgoingHandshakes,
1629                                        handshake, handshakeCompare );
1630    else
1631        ours = handshake;
1632
1633    assert( ours );
1634    assert( ours == handshake );
1635
1636    if( t )
1637        torrentLock( t );
1638
1639    addr = tr_peerIoGetAddress( io, &port );
1640
1641    if( !ok || !t || !t->isRunning )
1642    {
1643        if( t )
1644        {
1645            struct peer_atom * atom = getExistingAtom( t, addr );
1646            if( atom )
1647            {
1648                ++atom->numFails;
1649
1650                if( !readAnythingFromPeer )
1651                {
1652                    tordbg( t, "marking peer %s as unreachable... numFails is %d", tr_atomAddrStr( atom ), (int)atom->numFails );
1653                    atom->flags2 |= MYFLAG_UNREACHABLE;
1654                }
1655            }
1656        }
1657    }
1658    else /* looking good */
1659    {
1660        struct peer_atom * atom;
1661
1662        ensureAtomExists( t, addr, port, 0, -1, TR_PEER_FROM_INCOMING );
1663        atom = getExistingAtom( t, addr );
1664        atom->time = tr_time( );
1665        atom->piece_data_time = 0;
1666        atom->lastConnectionAt = tr_time( );
1667
1668        if( !tr_peerIoIsIncoming( io ) )
1669        {
1670            atom->flags |= ADDED_F_CONNECTABLE;
1671            atom->flags2 &= ~MYFLAG_UNREACHABLE;
1672        }
1673
1674        if( atom->flags2 & MYFLAG_BANNED )
1675        {
1676            tordbg( t, "banned peer %s tried to reconnect",
1677                    tr_atomAddrStr( atom ) );
1678        }
1679        else if( tr_peerIoIsIncoming( io )
1680               && ( getPeerCount( t ) >= getMaxPeerCount( t->tor ) ) )
1681
1682        {
1683        }
1684        else
1685        {
1686            tr_peer * peer = atom->peer;
1687
1688            if( peer ) /* we already have this peer */
1689            {
1690            }
1691            else
1692            {
1693                peer = getPeer( t, atom );
1694                tr_free( peer->client );
1695
1696                if( !peer_id )
1697                    peer->client = NULL;
1698                else {
1699                    char client[128];
1700                    tr_clientForId( client, sizeof( client ), peer_id );
1701                    peer->client = tr_strdup( client );
1702                }
1703
1704                peer->io = tr_handshakeStealIO( handshake ); /* this steals its refcount too, which is
1705                                                                balanced by our unref in peerDestructor()  */
1706                tr_peerIoSetParent( peer->io, t->tor->bandwidth );
1707                tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t );
1708
1709                success = TRUE;
1710            }
1711        }
1712    }
1713
1714    if( t )
1715        torrentUnlock( t );
1716
1717    return success;
1718}
1719
1720void
1721tr_peerMgrAddIncoming( tr_peerMgr * manager,
1722                       tr_address * addr,
1723                       tr_port      port,
1724                       int          socket )
1725{
1726    tr_session * session;
1727
1728    managerLock( manager );
1729
1730    assert( tr_isSession( manager->session ) );
1731    session = manager->session;
1732
1733    if( tr_sessionIsAddressBlocked( session, addr ) )
1734    {
1735        tr_dbg( "Banned IP address \"%s\" tried to connect to us", tr_ntop_non_ts( addr ) );
1736        tr_netClose( session, socket );
1737    }
1738    else if( getExistingHandshake( &manager->incomingHandshakes, addr ) )
1739    {
1740        tr_netClose( session, socket );
1741    }
1742    else /* we don't have a connection to them yet... */
1743    {
1744        tr_peerIo *    io;
1745        tr_handshake * handshake;
1746
1747        io = tr_peerIoNewIncoming( session, session->bandwidth, addr, port, socket );
1748
1749        handshake = tr_handshakeNew( io,
1750                                     session->encryptionMode,
1751                                     myHandshakeDoneCB,
1752                                     manager );
1753
1754        tr_peerIoUnref( io ); /* balanced by the implicit ref in tr_peerIoNewIncoming() */
1755
1756        tr_ptrArrayInsertSorted( &manager->incomingHandshakes, handshake,
1757                                 handshakeCompare );
1758    }
1759
1760    managerUnlock( manager );
1761}
1762
1763static tr_bool
1764tr_isPex( const tr_pex * pex )
1765{
1766    return pex && tr_isAddress( &pex->addr );
1767}
1768
1769void
1770tr_peerMgrAddPex( tr_torrent * tor, uint8_t from,
1771                  const tr_pex * pex, int8_t seedProbability )
1772{
1773    if( tr_isPex( pex ) ) /* safeguard against corrupt data */
1774    {
1775        Torrent * t = tor->torrentPeers;
1776        managerLock( t->manager );
1777
1778        if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
1779            if( tr_isValidPeerAddress( &pex->addr, pex->port ) )
1780                ensureAtomExists( t, &pex->addr, pex->port, pex->flags, seedProbability, from );
1781
1782        managerUnlock( t->manager );
1783    }
1784}
1785
1786void
1787tr_peerMgrMarkAllAsSeeds( tr_torrent * tor )
1788{
1789    Torrent * t = tor->torrentPeers;
1790    const int n = tr_ptrArraySize( &t->pool );
1791    struct peer_atom ** it = (struct peer_atom**) tr_ptrArrayBase( &t->pool );
1792    struct peer_atom ** end = it + n;
1793
1794    while( it != end )
1795        atomSetSeed( *it++ );
1796}
1797
1798tr_pex *
1799tr_peerMgrCompactToPex( const void *    compact,
1800                        size_t          compactLen,
1801                        const uint8_t * added_f,
1802                        size_t          added_f_len,
1803                        size_t *        pexCount )
1804{
1805    size_t          i;
1806    size_t          n = compactLen / 6;
1807    const uint8_t * walk = compact;
1808    tr_pex *        pex = tr_new0( tr_pex, n );
1809
1810    for( i = 0; i < n; ++i )
1811    {
1812        pex[i].addr.type = TR_AF_INET;
1813        memcpy( &pex[i].addr.addr, walk, 4 ); walk += 4;
1814        memcpy( &pex[i].port, walk, 2 ); walk += 2;
1815        if( added_f && ( n == added_f_len ) )
1816            pex[i].flags = added_f[i];
1817    }
1818
1819    *pexCount = n;
1820    return pex;
1821}
1822
1823tr_pex *
1824tr_peerMgrCompact6ToPex( const void    * compact,
1825                         size_t          compactLen,
1826                         const uint8_t * added_f,
1827                         size_t          added_f_len,
1828                         size_t        * pexCount )
1829{
1830    size_t          i;
1831    size_t          n = compactLen / 18;
1832    const uint8_t * walk = compact;
1833    tr_pex *        pex = tr_new0( tr_pex, n );
1834
1835    for( i = 0; i < n; ++i )
1836    {
1837        pex[i].addr.type = TR_AF_INET6;
1838        memcpy( &pex[i].addr.addr.addr6.s6_addr, walk, 16 ); walk += 16;
1839        memcpy( &pex[i].port, walk, 2 ); walk += 2;
1840        if( added_f && ( n == added_f_len ) )
1841            pex[i].flags = added_f[i];
1842    }
1843
1844    *pexCount = n;
1845    return pex;
1846}
1847
1848tr_pex *
1849tr_peerMgrArrayToPex( const void * array,
1850                      size_t       arrayLen,
1851                      size_t      * pexCount )
1852{
1853    size_t          i;
1854    size_t          n = arrayLen / ( sizeof( tr_address ) + 2 );
1855    /*size_t          n = arrayLen / sizeof( tr_peerArrayElement );*/
1856    const uint8_t * walk = array;
1857    tr_pex        * pex = tr_new0( tr_pex, n );
1858
1859    for( i = 0 ; i < n ; i++ ) {
1860        memcpy( &pex[i].addr, walk, sizeof( tr_address ) );
1861        memcpy( &pex[i].port, walk + sizeof( tr_address ), 2 );
1862        pex[i].flags = 0x00;
1863        walk += sizeof( tr_address ) + 2;
1864    }
1865
1866    *pexCount = n;
1867    return pex;
1868}
1869
1870/**
1871***
1872**/
1873
1874void
1875tr_peerMgrSetBlame( tr_torrent     * tor,
1876                    tr_piece_index_t pieceIndex,
1877                    int              success )
1878{
1879    if( !success )
1880    {
1881        int        peerCount, i;
1882        Torrent *  t = tor->torrentPeers;
1883        tr_peer ** peers;
1884
1885        assert( torrentIsLocked( t ) );
1886
1887        peers = (tr_peer **) tr_ptrArrayPeek( &t->peers, &peerCount );
1888        for( i = 0; i < peerCount; ++i )
1889        {
1890            tr_peer * peer = peers[i];
1891            if( tr_bitfieldHas( peer->blame, pieceIndex ) )
1892            {
1893                tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
1894                        tr_atomAddrStr( peer->atom ),
1895                        pieceIndex, (int)peer->strikes + 1 );
1896                addStrike( t, peer );
1897            }
1898        }
1899    }
1900}
1901
1902int
1903tr_pexCompare( const void * va, const void * vb )
1904{
1905    const tr_pex * a = va;
1906    const tr_pex * b = vb;
1907    int i;
1908
1909    assert( tr_isPex( a ) );
1910    assert( tr_isPex( b ) );
1911
1912    if(( i = tr_compareAddresses( &a->addr, &b->addr )))
1913        return i;
1914
1915    if( a->port != b->port )
1916        return a->port < b->port ? -1 : 1;
1917
1918    return 0;
1919}
1920
1921#if 0
1922static int
1923peerPrefersCrypto( const tr_peer * peer )
1924{
1925    if( peer->encryption_preference == ENCRYPTION_PREFERENCE_YES )
1926        return TRUE;
1927
1928    if( peer->encryption_preference == ENCRYPTION_PREFERENCE_NO )
1929        return FALSE;
1930
1931    return tr_peerIoIsEncrypted( peer->io );
1932}
1933#endif
1934
1935/* better goes first */
1936static int
1937compareAtomsByUsefulness( const void * va, const void *vb )
1938{
1939    const struct peer_atom * a = * (const struct peer_atom**) va;
1940    const struct peer_atom * b = * (const struct peer_atom**) vb;
1941
1942    assert( tr_isAtom( a ) );
1943    assert( tr_isAtom( b ) );
1944
1945    if( a->piece_data_time != b->piece_data_time )
1946        return a->piece_data_time > b->piece_data_time ? -1 : 1;
1947    if( a->from != b->from )
1948        return a->from < b->from ? -1 : 1;
1949    if( a->numFails != b->numFails )
1950        return a->numFails < b->numFails ? -1 : 1;
1951
1952    return 0;
1953}
1954
1955int
1956tr_peerMgrGetPeers( tr_torrent   * tor,
1957                    tr_pex      ** setme_pex,
1958                    uint8_t        af,
1959                    uint8_t        list_mode,
1960                    int            maxCount )
1961{
1962    int i;
1963    int n;
1964    int count = 0;
1965    int atomCount = 0;
1966    const Torrent * t = tor->torrentPeers;
1967    struct peer_atom ** atoms = NULL;
1968    tr_pex * pex;
1969    tr_pex * walk;
1970
1971    assert( tr_isTorrent( tor ) );
1972    assert( setme_pex != NULL );
1973    assert( af==TR_AF_INET || af==TR_AF_INET6 );
1974    assert( list_mode==TR_PEERS_CONNECTED || list_mode==TR_PEERS_ALL );
1975
1976    managerLock( t->manager );
1977
1978    /**
1979    ***  build a list of atoms
1980    **/
1981
1982    if( list_mode == TR_PEERS_CONNECTED ) /* connected peers only */
1983    {
1984        int i;
1985        const tr_peer ** peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
1986        atomCount = tr_ptrArraySize( &t->peers );
1987        atoms = tr_new( struct peer_atom *, atomCount );
1988        for( i=0; i<atomCount; ++i )
1989            atoms[i] = peers[i]->atom;
1990    }
1991    else /* TR_PEERS_ALL */
1992    {
1993        const struct peer_atom ** atomsBase = (const struct peer_atom**) tr_ptrArrayBase( &t->pool );
1994        atomCount = tr_ptrArraySize( &t->pool );
1995        atoms = tr_memdup( atomsBase, atomCount * sizeof( struct peer_atom * ) );
1996    }
1997
1998    qsort( atoms, atomCount, sizeof( struct peer_atom * ), compareAtomsByUsefulness );
1999
2000    /**
2001    ***  add the first N of them into our return list
2002    **/
2003
2004    n = MIN( atomCount, maxCount );
2005    pex = walk = tr_new0( tr_pex, n );
2006
2007    for( i=0; i<atomCount && count<n; ++i )
2008    {
2009        const struct peer_atom * atom = atoms[i];
2010        if( atom->addr.type == af )
2011        {
2012            assert( tr_isAddress( &atom->addr ) );
2013            walk->addr = atom->addr;
2014            walk->port = atom->port;
2015            walk->flags = atom->flags;
2016            ++count;
2017            ++walk;
2018        }
2019    }
2020
2021    qsort( pex, count, sizeof( tr_pex ), tr_pexCompare );
2022
2023    assert( ( walk - pex ) == count );
2024    *setme_pex = pex;
2025
2026    /* cleanup */
2027    tr_free( atoms );
2028    managerUnlock( t->manager );
2029    return count;
2030}
2031
2032static void atomPulse      ( int, short, void * );
2033static void bandwidthPulse ( int, short, void * );
2034static void rechokePulse   ( int, short, void * );
2035static void reconnectPulse ( int, short, void * );
2036
2037static struct event *
2038createTimer( int msec, void (*callback)(int, short, void *), void * cbdata )
2039{
2040    struct event * timer = tr_new0( struct event, 1 );
2041    evtimer_set( timer, callback, cbdata );
2042    tr_timerAddMsec( timer, msec );
2043    return timer;
2044}
2045
2046static void
2047ensureMgrTimersExist( struct tr_peerMgr * m )
2048{
2049    if( m->atomTimer == NULL )
2050        m->atomTimer = createTimer( ATOM_PERIOD_MSEC, atomPulse, m );
2051
2052    if( m->bandwidthTimer == NULL )
2053        m->bandwidthTimer = createTimer( BANDWIDTH_PERIOD_MSEC, bandwidthPulse, m );
2054
2055    if( m->rechokeTimer == NULL )
2056        m->rechokeTimer = createTimer( RECHOKE_PERIOD_MSEC, rechokePulse, m );
2057
2058   if( m->refillUpkeepTimer == NULL )
2059        m->refillUpkeepTimer = createTimer( REFILL_UPKEEP_PERIOD_MSEC, refillUpkeep, m );
2060}
2061
2062void
2063tr_peerMgrStartTorrent( tr_torrent * tor )
2064{
2065    Torrent * t = tor->torrentPeers;
2066
2067    assert( t != NULL );
2068    managerLock( t->manager );
2069    ensureMgrTimersExist( t->manager );
2070
2071    t->isRunning = TRUE;
2072    t->maxPeers = t->tor->maxConnectedPeers;
2073
2074    rechokePulse( 0, 0, t->manager );
2075    managerUnlock( t->manager );
2076}
2077
2078static void
2079stopTorrent( Torrent * t )
2080{
2081    int i, n;
2082
2083    assert( torrentIsLocked( t ) );
2084
2085    t->isRunning = FALSE;
2086
2087    /* disconnect the peers. */
2088    for( i=0, n=tr_ptrArraySize( &t->peers ); i<n; ++i )
2089        peerDestructor( t, tr_ptrArrayNth( &t->peers, i ) );
2090    tr_ptrArrayClear( &t->peers );
2091
2092    /* disconnect the handshakes.  handshakeAbort calls handshakeDoneCB(),
2093     * which removes the handshake from t->outgoingHandshakes... */
2094    while( !tr_ptrArrayEmpty( &t->outgoingHandshakes ) )
2095        tr_handshakeAbort( tr_ptrArrayNth( &t->outgoingHandshakes, 0 ) );
2096}
2097
2098void
2099tr_peerMgrStopTorrent( tr_torrent * tor )
2100{
2101    Torrent * t = tor->torrentPeers;
2102
2103    managerLock( t->manager );
2104
2105    stopTorrent( t );
2106
2107    managerUnlock( t->manager );
2108}
2109
2110void
2111tr_peerMgrAddTorrent( tr_peerMgr * manager,
2112                      tr_torrent * tor )
2113{
2114    managerLock( manager );
2115
2116    assert( tor );
2117    assert( tor->torrentPeers == NULL );
2118
2119    tor->torrentPeers = torrentConstructor( manager, tor );
2120
2121    managerUnlock( manager );
2122}
2123
2124void
2125tr_peerMgrRemoveTorrent( tr_torrent * tor )
2126{
2127    tr_torrentLock( tor );
2128
2129    stopTorrent( tor->torrentPeers );
2130    torrentDestructor( tor->torrentPeers );
2131
2132    tr_torrentUnlock( tor );
2133}
2134
2135void
2136tr_peerMgrTorrentAvailability( const tr_torrent * tor,
2137                               int8_t           * tab,
2138                               unsigned int       tabCount )
2139{
2140    tr_piece_index_t   i;
2141    const Torrent *    t;
2142    float              interval;
2143    tr_bool            isSeed;
2144    int                peerCount;
2145    const tr_peer **   peers;
2146    tr_torrentLock( tor );
2147
2148    t = tor->torrentPeers;
2149    tor = t->tor;
2150    interval = tor->info.pieceCount / (float)tabCount;
2151    isSeed = tor && ( tr_cpGetStatus ( &tor->completion ) == TR_SEED );
2152    peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
2153    peerCount = tr_ptrArraySize( &t->peers );
2154
2155    memset( tab, 0, tabCount );
2156
2157    for( i = 0; tor && i < tabCount; ++i )
2158    {
2159        const int piece = i * interval;
2160
2161        if( isSeed || tr_cpPieceIsComplete( &tor->completion, piece ) )
2162            tab[i] = -1;
2163        else if( peerCount ) {
2164            int j;
2165            for( j = 0; j < peerCount; ++j )
2166                if( tr_bitsetHas( &peers[j]->have, i ) )
2167                    ++tab[i];
2168        }
2169    }
2170
2171    tr_torrentUnlock( tor );
2172}
2173
2174/* Returns the pieces that are available from peers */
2175tr_bitfield*
2176tr_peerMgrGetAvailable( const tr_torrent * tor )
2177{
2178    int i;
2179    int peerCount;
2180    Torrent * t = tor->torrentPeers;
2181    const tr_peer ** peers;
2182    tr_bitfield * pieces;
2183    managerLock( t->manager );
2184
2185    pieces = tr_bitfieldNew( t->tor->info.pieceCount );
2186    peerCount = tr_ptrArraySize( &t->peers );
2187    peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
2188    for( i=0; i<peerCount; ++i )
2189        tr_bitsetOr( pieces, &peers[i]->have );
2190
2191    managerUnlock( t->manager );
2192    return pieces;
2193}
2194
2195void
2196tr_peerMgrTorrentStats( tr_torrent       * tor,
2197                        int              * setmePeersKnown,
2198                        int              * setmePeersConnected,
2199                        int              * setmeSeedsConnected,
2200                        int              * setmeWebseedsSendingToUs,
2201                        int              * setmePeersSendingToUs,
2202                        int              * setmePeersGettingFromUs,
2203                        int              * setmePeersFrom )
2204{
2205    int i, size;
2206    const Torrent * t = tor->torrentPeers;
2207    const tr_peer ** peers;
2208    const tr_webseed ** webseeds;
2209
2210    managerLock( t->manager );
2211
2212    peers = (const tr_peer **) tr_ptrArrayBase( &t->peers );
2213    size = tr_ptrArraySize( &t->peers );
2214
2215    *setmePeersKnown           = tr_ptrArraySize( &t->pool );
2216    *setmePeersConnected       = 0;
2217    *setmeSeedsConnected       = 0;
2218    *setmePeersGettingFromUs   = 0;
2219    *setmePeersSendingToUs     = 0;
2220    *setmeWebseedsSendingToUs  = 0;
2221
2222    for( i=0; i<TR_PEER_FROM__MAX; ++i )
2223        setmePeersFrom[i] = 0;
2224
2225    for( i=0; i<size; ++i )
2226    {
2227        const tr_peer * peer = peers[i];
2228        const struct peer_atom * atom = peer->atom;
2229
2230        if( peer->io == NULL ) /* not connected */
2231            continue;
2232
2233        ++*setmePeersConnected;
2234
2235        ++setmePeersFrom[atom->from];
2236
2237        if( clientIsDownloadingFrom( tor, peer ) )
2238            ++*setmePeersSendingToUs;
2239
2240        if( clientIsUploadingTo( peer ) )
2241            ++*setmePeersGettingFromUs;
2242
2243        if( atomIsSeed( atom ) )
2244            ++*setmeSeedsConnected;
2245    }
2246
2247    webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
2248    size = tr_ptrArraySize( &t->webseeds );
2249    for( i=0; i<size; ++i )
2250        if( tr_webseedIsActive( webseeds[i] ) )
2251            ++*setmeWebseedsSendingToUs;
2252
2253    managerUnlock( t->manager );
2254}
2255
2256int
2257tr_peerMgrGetWebseedSpeed_Bps( const tr_torrent * tor, uint64_t now )
2258{
2259    int i;
2260    int tmp;
2261    int ret = 0;
2262
2263    const Torrent * t = tor->torrentPeers;
2264    const int n = tr_ptrArraySize( &t->webseeds );
2265    const tr_webseed ** webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
2266
2267    for( i=0; i<n; ++i )
2268        if( tr_webseedGetSpeed_Bps( webseeds[i], now, &tmp ) )
2269            ret += tmp;
2270
2271    return ret;
2272}
2273
2274
2275double*
2276tr_peerMgrWebSpeeds_KBps( const tr_torrent * tor )
2277{
2278    const Torrent * t = tor->torrentPeers;
2279    const tr_webseed ** webseeds;
2280    int i;
2281    int webseedCount;
2282    double * ret;
2283    uint64_t now;
2284
2285    assert( t->manager );
2286    managerLock( t->manager );
2287
2288    webseeds = (const tr_webseed**) tr_ptrArrayBase( &t->webseeds );
2289    webseedCount = tr_ptrArraySize( &t->webseeds );
2290    assert( webseedCount == tor->info.webseedCount );
2291    ret = tr_new0( double, webseedCount );
2292    now = tr_time_msec( );
2293
2294    for( i=0; i<webseedCount; ++i ) {
2295        int Bps;
2296        if( tr_webseedGetSpeed_Bps( webseeds[i], now, &Bps ) )
2297            ret[i] = Bps / (double)tr_speed_K;
2298        else
2299            ret[i] = -1.0;
2300    }
2301
2302    managerUnlock( t->manager );
2303    return ret;
2304}
2305
2306int
2307tr_peerGetPieceSpeed_Bps( const tr_peer * peer, uint64_t now, tr_direction direction )
2308{
2309    return peer->io ? tr_peerIoGetPieceSpeed_Bps( peer->io, now, direction ) : 0.0;
2310}
2311
2312
2313struct tr_peer_stat *
2314tr_peerMgrPeerStats( const tr_torrent    * tor,
2315                     int                 * setmeCount )
2316{
2317    int i, size;
2318    const Torrent * t = tor->torrentPeers;
2319    const tr_peer ** peers;
2320    tr_peer_stat * ret;
2321    uint64_t now_msec;
2322    time_t now;
2323
2324    assert( t->manager );
2325    managerLock( t->manager );
2326
2327    size = tr_ptrArraySize( &t->peers );
2328    peers = (const tr_peer**) tr_ptrArrayBase( &t->peers );
2329    ret = tr_new0( tr_peer_stat, size );
2330    now_msec = tr_time_msec( );
2331    now = tr_time();
2332
2333    for( i=0; i<size; ++i )
2334    {
2335        char *                   pch;
2336        const tr_peer *          peer = peers[i];
2337        const struct peer_atom * atom = peer->atom;
2338        tr_peer_stat *           stat = ret + i;
2339
2340        tr_ntop( &atom->addr, stat->addr, sizeof( stat->addr ) );
2341        tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
2342                   sizeof( stat->client ) );
2343        stat->port                = ntohs( peer->atom->port );
2344        stat->from                = atom->from;
2345        stat->progress            = peer->progress;
2346        stat->isEncrypted         = tr_peerIoIsEncrypted( peer->io ) ? 1 : 0;
2347        stat->rateToPeer_KBps     = toSpeedKBps( tr_peerGetPieceSpeed_Bps( peer, now_msec, TR_CLIENT_TO_PEER ) );
2348        stat->rateToClient_KBps   = toSpeedKBps( tr_peerGetPieceSpeed_Bps( peer, now_msec, TR_PEER_TO_CLIENT ) );
2349        stat->peerIsChoked        = peer->peerIsChoked;
2350        stat->peerIsInterested    = peer->peerIsInterested;
2351        stat->clientIsChoked      = peer->clientIsChoked;
2352        stat->clientIsInterested  = peer->clientIsInterested;
2353        stat->isIncoming          = tr_peerIoIsIncoming( peer->io );
2354        stat->isDownloadingFrom   = clientIsDownloadingFrom( tor, peer );
2355        stat->isUploadingTo       = clientIsUploadingTo( peer );
2356        stat->isSeed              = ( atom->uploadOnly == UPLOAD_ONLY_YES ) || ( peer->progress >= 1.0 );
2357
2358        stat->blocksToPeer        = tr_historyGet( peer->blocksSentToPeer,    now, CANCEL_HISTORY_SEC );
2359        stat->blocksToClient      = tr_historyGet( peer->blocksSentToClient,  now, CANCEL_HISTORY_SEC );
2360        stat->cancelsToPeer       = tr_historyGet( peer->cancelsSentToPeer,   now, CANCEL_HISTORY_SEC );
2361        stat->cancelsToClient     = tr_historyGet( peer->cancelsSentToClient, now, CANCEL_HISTORY_SEC );
2362
2363        stat->pendingReqsToPeer   = peer->pendingReqsToPeer;
2364        stat->pendingReqsToClient = peer->pendingReqsToClient;
2365
2366        pch = stat->flagStr;
2367        if( t->optimistic == peer ) *pch++ = 'O';
2368        if( stat->isDownloadingFrom ) *pch++ = 'D';
2369        else if( stat->clientIsInterested ) *pch++ = 'd';
2370        if( stat->isUploadingTo ) *pch++ = 'U';
2371        else if( stat->peerIsInterested ) *pch++ = 'u';
2372        if( !stat->clientIsChoked && !stat->clientIsInterested ) *pch++ = 'K';
2373        if( !stat->peerIsChoked && !stat->peerIsInterested ) *pch++ = '?';
2374        if( stat->isEncrypted ) *pch++ = 'E';
2375        if( stat->from == TR_PEER_FROM_DHT ) *pch++ = 'H';
2376        if( stat->from == TR_PEER_FROM_PEX ) *pch++ = 'X';
2377        if( stat->isIncoming ) *pch++ = 'I';
2378        *pch = '\0';
2379    }
2380
2381    *setmeCount = size;
2382
2383    managerUnlock( t->manager );
2384    return ret;
2385}
2386
2387/**
2388***
2389**/
2390
2391void
2392tr_peerMgrClearInterest( tr_torrent * tor )
2393{
2394    int i;
2395    Torrent * t;
2396    int peerCount;
2397
2398    assert( tr_isTorrent( tor ) );
2399
2400    t = tor->torrentPeers;
2401
2402    torrentLock( t );
2403
2404    peerCount = tr_ptrArraySize( &t->peers );
2405
2406    for( i=0; i<peerCount; ++i )
2407    {
2408        const tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
2409        tr_peerMsgsSetInterested( peer->msgs, FALSE );
2410    }
2411
2412    torrentUnlock( t );
2413}
2414
2415/* do we still want this piece and does the peer have it? */
2416static tr_bool
2417isPieceInteresting( const tr_torrent * tor, const tr_peer * peer, tr_piece_index_t index )
2418{
2419    return ( !tor->info.pieces[index].dnd ) /* we want it */
2420        && ( !tr_cpPieceIsComplete( &tor->completion, index ) )  /* we don't have it */
2421        && ( tr_bitsetHas( &peer->have, index ) ); /* peer has it */
2422}
2423
2424/* does this peer have any pieces that we want? */
2425static tr_bool
2426isPeerInteresting( const tr_torrent * tor, const tr_peer * peer )
2427{
2428    tr_piece_index_t i, n;
2429
2430    if ( tr_torrentIsSeed( tor ) )
2431        return FALSE;
2432
2433    if( !tr_torrentIsPieceTransferAllowed( tor, TR_PEER_TO_CLIENT ) )
2434        return FALSE;
2435
2436    for( i=0, n=tor->info.pieceCount; i<n; ++i )
2437        if( isPieceInteresting( tor, peer, i ) )
2438            return TRUE;
2439
2440    return FALSE;
2441}
2442
2443/* determines who we send "interested" messages to */
2444static void
2445rechokeDownloads( Torrent * t )
2446{
2447    int i;
2448    const time_t now = tr_time( );
2449    const int MIN_INTERESTING_PEERS = 5;
2450    const int peerCount = tr_ptrArraySize( &t->peers );
2451    int maxPeers;
2452
2453    int badCount         = 0;
2454    int goodCount        = 0;
2455    int untestedCount    = 0;
2456    tr_peer ** bad       = tr_new( tr_peer*, peerCount );
2457    tr_peer ** good      = tr_new( tr_peer*, peerCount );
2458    tr_peer ** untested  = tr_new( tr_peer*, peerCount );
2459
2460    /* decide how many peers to be interested in */
2461    {
2462        int blocks = 0;
2463        int cancels = 0;
2464        time_t timeSinceCancel;
2465
2466        /* Count up how many blocks & cancels each peer has.
2467         *
2468         * There are two situations where we send out cancels --
2469         *
2470         * 1. We've got unresponsive peers, which is handled by deciding
2471         *    -which- peers to be interested in.
2472         *
2473         * 2. We've hit our bandwidth cap, which is handled by deciding
2474         *    -how many- peers to be interested in.
2475         *
2476         * We're working on 2. here, so we need to ignore unresponsive
2477         * peers in our calculations lest they confuse Transmission into
2478         * thinking it's hit its bandwidth cap.
2479         */
2480        for( i=0; i<peerCount; ++i )
2481        {
2482            const tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
2483            const int b = tr_historyGet( peer->blocksSentToClient, now, CANCEL_HISTORY_SEC );
2484            const int c = tr_historyGet( peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC );
2485
2486            if( b == 0 ) /* ignore unresponsive peers, as described above */
2487                continue;
2488
2489            blocks += b;
2490            cancels += c;
2491        }
2492
2493        if( cancels > 0 )
2494        {
2495            /* cancelRate: of the block requests we've recently made, the percentage we cancelled.
2496             * higher values indicate more congestion. */
2497            const double cancelRate = cancels / (double)(cancels + blocks);
2498            const double mult = 1 - MIN( cancelRate, 0.5 );
2499            maxPeers = t->interestedCount * mult;
2500            tordbg( t, "cancel rate is %.3f -- reducing the "
2501                       "number of peers we're interested in by %.0f percent",
2502                       cancelRate, mult * 100 );
2503            t->lastCancel = now;
2504        }
2505
2506        timeSinceCancel = now - t->lastCancel;
2507        if( timeSinceCancel )
2508        {
2509            const int maxIncrease = 15;
2510            const time_t maxHistory = 2 * CANCEL_HISTORY_SEC;
2511            const double mult = MIN( timeSinceCancel, maxHistory ) / (double) maxHistory;
2512            const int inc = maxIncrease * mult;
2513            maxPeers = t->maxPeers + inc;
2514            tordbg( t, "time since last cancel is %li -- increasing the "
2515                       "number of peers we're interested in by %d",
2516                       timeSinceCancel, inc );
2517        }
2518    }
2519
2520    /* don't let the previous section's number tweaking go too far... */
2521    if( maxPeers < MIN_INTERESTING_PEERS )
2522        maxPeers = MIN_INTERESTING_PEERS;
2523    if( maxPeers > t->tor->maxConnectedPeers )
2524        maxPeers = t->tor->maxConnectedPeers;
2525
2526    t->maxPeers = maxPeers;
2527
2528    /* separate the peers into "good" (ones with a low cancel-to-block ratio),
2529     * untested peers, and "bad" (ones with a high cancel-to-block ratio).
2530     * That's the order in which we'll choose who to show interest in */
2531    {
2532        /* Randomize the peer array so the peers in the three groups will be unsorted... */
2533        int n = peerCount;
2534        tr_peer ** peers = tr_memdup( tr_ptrArrayBase( &t->peers ), n * sizeof( tr_peer * ) );
2535
2536        while( n > 0 )
2537        {
2538            const int i = tr_cryptoWeakRandInt( n );
2539            tr_peer * peer = tr_ptrArrayNth( &t->peers, i );
2540
2541            if( !isPeerInteresting( t->tor, peer ) )
2542            {
2543                tr_peerMsgsSetInterested( peer->msgs, FALSE );
2544            }
2545            else
2546            {
2547                const int blocks = tr_historyGet( peer->blocksSentToClient, now, CANCEL_HISTORY_SEC );
2548                const int cancels = tr_historyGet( peer->cancelsSentToPeer, now, CANCEL_HISTORY_SEC );
2549
2550                if( !blocks && !cancels )
2551                    untested[untestedCount++] = peer;
2552                else if( !cancels )
2553                    good[goodCount++] = peer;
2554                else if( !blocks )
2555                    bad[badCount++] = peer;
2556                else if( ( cancels * 10 ) < blocks )
2557                    good[goodCount++] = peer;
2558                else
2559                    bad[badCount++] = peer;
2560            }
2561
2562            tr_removeElementFromArray( peers, i, sizeof(tr_peer*), n-- );
2563        }
2564
2565        tr_free( peers );
2566    }
2567
2568    t->interestedCount = 0;
2569
2570    /* We've decided (1) how many peers to be interested in,
2571     * and (2) which peers are the best candidates,
2572     * Now it's time to update our `interest' flags. */
2573    for( i=0; i<goodCount; ++i ) {
2574        const tr_bool b = t->interestedCount < maxPeers;
2575        tr_peerMsgsSetInterested( good[i]->msgs, b );
2576        if( b )
2577            ++t->interestedCount;
2578    }
2579    for( i=0; i<untestedCount; ++i ) {
2580        const tr_bool b = t->interestedCount < maxPeers;
2581        tr_peerMsgsSetInterested( untested[i]->msgs, b );
2582        if( b )
2583            ++t->interestedCount;
2584    }
2585    for( i=0; i<badCount; ++i ) {
2586        const tr_bool b = t->interestedCount < maxPeers;
2587        tr_peerMsgsSetInterested( bad[i]->msgs, b );
2588        if( b )
2589            ++t->interestedCount;
2590    }
2591
2592/*fprintf( stderr, "num interested: %d\n", t->interestedCount );*/
2593
2594    /* cleanup */
2595    tr_free( untested );
2596    tr_free( good );
2597    tr_free( bad );
2598}
2599
2600/**
2601***
2602**/
2603
2604struct ChokeData
2605{
2606    tr_bool         isInterested;
2607    tr_bool         wasChoked;
2608    tr_bool         isChoked;
2609    int             rate;
2610    int             salt;
2611    tr_peer *       peer;
2612};
2613
2614static int
2615compareChoke( const void * va,
2616              const void * vb )
2617{
2618    const struct ChokeData * a = va;
2619    const struct ChokeData * b = vb;
2620
2621    if( a->rate != b->rate ) /* prefer higher overall speeds */
2622        return a->rate > b->rate ? -1 : 1;
2623
2624    if( a->wasChoked != b->wasChoked ) /* prefer unchoked */
2625        return a->wasChoked ? 1 : -1;
2626
2627    if( a->salt != b->salt ) /* random order */
2628        return a->salt - b->salt;
2629
2630    return 0;
2631}
2632
2633/* is this a new connection? */
2634static int
2635isNew( const tr_peer * peer )
2636{
2637    return peer && peer->io && tr_peerIoGetAge( peer->io ) < 45;
2638}
2639
2640/* get a rate for deciding which peers to choke and unchoke. */
2641static int
2642getRate( const tr_torrent * tor, struct peer_atom * atom, uint64_t now )
2643{
2644    int Bps;
2645
2646    if( tr_torrentIsSeed( tor ) )
2647        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_CLIENT_TO_PEER );
2648
2649    /* downloading a private torrent... take upload speed into account
2650     * because there may only be a small window of opportunity to share */
2651    else if( tr_torrentIsPrivate( tor ) )
2652        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_PEER_TO_CLIENT )
2653            + tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_CLIENT_TO_PEER );
2654
2655    /* downloading a public torrent */
2656    else
2657        Bps = tr_peerGetPieceSpeed_Bps( atom->peer, now, TR_PEER_TO_CLIENT );
2658
2659    /* convert it to bytes per second */
2660    return Bps;
2661}
2662
2663static inline tr_bool
2664isBandwidthMaxedOut( const tr_bandwidth * b,
2665                     const uint64_t now_msec, tr_direction dir )
2666{
2667    if( !tr_bandwidthIsLimited( b, dir ) )
2668        return FALSE;
2669    else {
2670        const int got = tr_bandwidthGetPieceSpeed_Bps( b, now_msec, dir );
2671        const int want = tr_bandwidthGetDesiredSpeed_Bps( b, dir );
2672        return got >= want;
2673    }
2674}
2675
2676static void
2677rechokeUploads( Torrent * t, const uint64_t now )
2678{
2679    int i, size, unchokedInterested;
2680    const int peerCount = tr_ptrArraySize( &t->peers );
2681    tr_peer ** peers = (tr_peer**) tr_ptrArrayBase( &t->peers );
2682    struct ChokeData * choke = tr_new0( struct ChokeData, peerCount );
2683    const tr_session * session = t->manager->session;
2684    const int chokeAll = !tr_torrentIsPieceTransferAllowed( t->tor, TR_CLIENT_TO_PEER );
2685    const tr_bool isMaxedOut = isBandwidthMaxedOut( t->tor->bandwidth, now, TR_UP );
2686
2687    assert( torrentIsLocked( t ) );
2688
2689    /* an optimistic unchoke peer's "optimistic"
2690     * state lasts for N calls to rechokeUploads(). */
2691    if( t->optimisticUnchokeTimeScaler > 0 )
2692        t->optimisticUnchokeTimeScaler--;
2693    else
2694        t->optimistic = NULL;
2695
2696    /* sort the peers by preference and rate */
2697    for( i = 0, size = 0; i < peerCount; ++i )
2698    {
2699        tr_peer * peer = peers[i];
2700        struct peer_atom * atom = peer->atom;
2701
2702        if( peer->progress >= 1.0 ) /* choke all seeds */
2703        {
2704            tr_peerMsgsSetChoke( peer->msgs, TRUE );
2705        }
2706        else if( atom->uploadOnly == UPLOAD_ONLY_YES ) /* choke partial seeds */
2707        {
2708            tr_peerMsgsSetChoke( peer->msgs, TRUE );
2709        }
2710        else if( chokeAll ) /* choke everyone if we're not uploading */
2711        {
2712            tr_peerMsgsSetChoke( peer->msgs, TRUE );
2713        }
2714        else if( peer != t->optimistic )
2715        {
2716            struct ChokeData * n = &choke[size++];
2717            n->peer         = peer;
2718            n->isInterested = peer->peerIsInterested;
2719            n->wasChoked    = peer->peerIsChoked;
2720            n->rate         = getRate( t->tor, atom, now );
2721            n->salt         = tr_cryptoWeakRandInt( INT_MAX );
2722            n->isChoked     = TRUE;
2723        }
2724    }
2725
2726    qsort( choke, size, sizeof( struct ChokeData ), compareChoke );
2727
2728    /**
2729     * Reciprocation and number of uploads capping is managed by unchoking
2730     * the N peers which have the best upload rate and are interested.
2731     * This maximizes the client's download rate. These N peers are
2732     * referred to as downloaders, because they are interested in downloading
2733     * from the client.
2734     *
2735     * Peers which have a better upload rate (as compared to the downloaders)
2736     * but aren't interested get unchoked. If they become interested, the
2737     * downloader with the worst upload rate gets choked. If a client has
2738     * a complete file, it uses its upload rate rather than its download
2739     * rate to decide which peers to unchoke.
2740     *
2741     * If our bandwidth is maxed out, don't unchoke any more peers.
2742     */
2743    unchokedInterested = 0;
2744    for( i=0; i<size && unchokedInterested<session->uploadSlotsPerTorrent; ++i ) {
2745        choke[i].isChoked = isMaxedOut ? choke[i].wasChoked : FALSE;
2746        if( choke[i].isInterested )
2747            ++unchokedInterested;
2748    }
2749
2750    /* optimistic unchoke */
2751    if( !t->optimistic && !isMaxedOut && (i<size) )
2752    {
2753        int n;
2754        struct ChokeData * c;
2755        tr_ptrArray randPool = TR_PTR_ARRAY_INIT;
2756
2757        for( ; i<size; ++i )
2758        {
2759            if( choke[i].isInterested )
2760            {
2761                const tr_peer * peer = choke[i].peer;
2762                int x = 1, y;
2763                if( isNew( peer ) ) x *= 3;
2764                for( y=0; y<x; ++y )
2765                    tr_ptrArrayAppend( &randPool, &choke[i] );
2766            }
2767        }
2768
2769        if(( n = tr_ptrArraySize( &randPool )))
2770        {
2771            c = tr_ptrArrayNth( &randPool, tr_cryptoWeakRandInt( n ));
2772            c->isChoked = FALSE;
2773            t->optimistic = c->peer;
2774            t->optimisticUnchokeTimeScaler = OPTIMISTIC_UNCHOKE_MULTIPLIER;
2775        }
2776
2777        tr_ptrArrayDestruct( &randPool, NULL );
2778    }
2779
2780    for( i=0; i<size; ++i )
2781        tr_peerMsgsSetChoke( choke[i].peer->msgs, choke[i].isChoked );
2782
2783    /* cleanup */
2784    tr_free( choke );
2785}
2786
2787static void
2788rechokePulse( int foo UNUSED, short bar UNUSED, void * vmgr )
2789{
2790    uint64_t now;
2791    tr_torrent * tor = NULL;
2792    tr_peerMgr * mgr = vmgr;
2793    managerLock( mgr );
2794
2795    now = tr_time_msec( );
2796    while(( tor = tr_torrentNext( mgr->session, tor ))) {
2797        if( tor->isRunning ) {
2798            rechokeUploads( tor->torrentPeers, now );
2799            if( !tr_torrentIsSeed( tor ) )
2800                rechokeDownloads( tor->torrentPeers );
2801        }
2802    }
2803
2804    tr_timerAddMsec( mgr->rechokeTimer, RECHOKE_PERIOD_MSEC );
2805    managerUnlock( mgr );
2806}
2807
2808/***
2809****
2810****  Life and Death
2811****
2812***/
2813
2814typedef enum
2815{
2816    TR_CAN_KEEP,
2817    TR_CAN_CLOSE,
2818    TR_MUST_CLOSE,
2819}
2820tr_close_type_t;
2821
2822static tr_close_type_t
2823shouldPeerBeClosed( const Torrent    * t,
2824                    const tr_peer    * peer,
2825                    int                peerCount,
2826                    const time_t       now )
2827{
2828    const tr_torrent *       tor = t->tor;
2829    const struct peer_atom * atom = peer->atom;
2830
2831    /* if it's marked for purging, close it */
2832    if( peer->doPurge )
2833    {
2834        tordbg( t, "purging peer %s because its doPurge flag is set",
2835                tr_atomAddrStr( atom ) );
2836        return TR_MUST_CLOSE;
2837    }
2838
2839    /* if we're seeding and the peer has everything we have,
2840     * and enough time has passed for a pex exchange, then disconnect */
2841    if( tr_torrentIsSeed( tor ) )
2842    {
2843        tr_bool peerHasEverything;
2844
2845        if( atom->seedProbability != -1 )
2846        {
2847            peerHasEverything = atomIsSeed( atom );
2848        }
2849        else
2850        {
2851            tr_bitfield * tmp = tr_bitfieldDup( tr_cpPieceBitfield( &tor->completion ) );
2852            tr_bitsetDifference( tmp, &peer->have );
2853            peerHasEverything = tr_bitfieldCountTrueBits( tmp ) == 0;
2854            tr_bitfieldFree( tmp );
2855        }
2856
2857        if( peerHasEverything && ( !tr_torrentAllowsPex(tor) || (now-atom->time>=30 )))
2858        {
2859            tordbg( t, "purging peer %s because we're both seeds",
2860                    tr_atomAddrStr( atom ) );
2861            return TR_MUST_CLOSE;
2862        }
2863    }
2864
2865    /* disconnect if it's been too long since piece data has been transferred.
2866     * this is on a sliding scale based on number of available peers... */
2867    {
2868        const int relaxStrictnessIfFewerThanN = (int)( ( getMaxPeerCount( tor ) * 0.9 ) + 0.5 );
2869        /* if we have >= relaxIfFewerThan, strictness is 100%.
2870         * if we have zero connections, strictness is 0% */
2871        const float strictness = peerCount >= relaxStrictnessIfFewerThanN
2872                               ? 1.0
2873                               : peerCount / (float)relaxStrictnessIfFewerThanN;
2874        const int lo = MIN_UPLOAD_IDLE_SECS;
2875        const int hi = MAX_UPLOAD_IDLE_SECS;
2876        const int limit = hi - ( ( hi - lo ) * strictness );
2877        const int idleTime = now - MAX( atom->time, atom->piece_data_time );
2878/*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 );*/
2879        if( idleTime > limit ) {
2880            tordbg( t, "purging peer %s because it's been %d secs since we shared anything",
2881                       tr_atomAddrStr( atom ), idleTime );
2882            return TR_CAN_CLOSE;
2883        }
2884    }
2885
2886    return TR_CAN_KEEP;
2887}
2888
2889static void sortPeersByLivelinessReverse( tr_peer ** peers, void ** clientData, int n, uint64_t now );
2890
2891static tr_peer **
2892getPeersToClose( Torrent * t, tr_close_type_t closeType,
2893                 const uint64_t now_msec, const time_t now_sec,
2894                 int * setmeSize )
2895{
2896    int i, peerCount, outsize;
2897    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek( &t->peers, &peerCount );
2898    struct tr_peer ** ret = tr_new( tr_peer *, peerCount );
2899
2900    assert( torrentIsLocked( t ) );
2901
2902    for( i = outsize = 0; i < peerCount; ++i )
2903        if( shouldPeerBeClosed( t, peers[i], peerCount, now_sec ) == closeType )
2904            ret[outsize++] = peers[i];
2905
2906    sortPeersByLivelinessReverse ( ret, NULL, outsize, now_msec );
2907
2908    *setmeSize = outsize;
2909    return ret;
2910}
2911
2912static int
2913getReconnectIntervalSecs( const struct peer_atom * atom, const time_t now )
2914{
2915    int sec;
2916
2917    /* if we were recently connected to this peer and transferring piece
2918     * data, try to reconnect to them sooner rather that later -- we don't
2919     * want network troubles to get in the way of a good peer. */
2920    if( ( now - atom->piece_data_time ) <= ( MINIMUM_RECONNECT_INTERVAL_SECS * 2 ) )
2921        sec = MINIMUM_RECONNECT_INTERVAL_SECS;
2922
2923    /* don't allow reconnects more often than our minimum */
2924    else if( ( now - atom->time ) < MINIMUM_RECONNECT_INTERVAL_SECS )
2925        sec = MINIMUM_RECONNECT_INTERVAL_SECS;
2926
2927    /* otherwise, the interval depends on how many times we've tried
2928     * and failed to connect to the peer */
2929    else switch( atom->numFails ) {
2930        case 0: sec = 0; break;
2931        case 1: sec = 5; break;
2932        case 2: sec = 2 * 60; break;
2933        case 3: sec = 15 * 60; break;
2934        case 4: sec = 30 * 60; break;
2935        case 5: sec = 60 * 60; break;
2936        default: sec = 120 * 60; break;
2937    }
2938
2939    /* penalize peers that were unreachable the last time we tried */
2940    if( atom->flags2 & MYFLAG_UNREACHABLE )
2941        sec += sec;
2942
2943    dbgmsg( "reconnect interval for %s is %d seconds", tr_atomAddrStr( atom ), sec );
2944    return sec;
2945}
2946
2947static void
2948closePeer( Torrent * t, tr_peer * peer )
2949{
2950    struct peer_atom * atom;
2951
2952    assert( t != NULL );
2953    assert( peer != NULL );
2954
2955    atom = peer->atom;
2956
2957    /* if we transferred piece data, then they might be good peers,
2958       so reset their `numFails' weight to zero.  otherwise we connected
2959       to them fruitlessly, so mark it as another fail */
2960    if( atom->piece_data_time ) {
2961        tordbg( t, "resetting atom %s numFails to 0", tr_atomAddrStr(atom) );
2962        atom->numFails = 0;
2963    } else {
2964        ++atom->numFails;
2965        tordbg( t, "incremented atom %s numFails to %d", tr_atomAddrStr(atom), (int)atom->numFails );
2966    }
2967
2968    tordbg( t, "removing bad peer %s", tr_peerIoGetAddrStr( peer->io ) );
2969    removePeer( t, peer );
2970}
2971
2972static void
2973closeBadPeers( Torrent * t, const uint64_t now_msec, const time_t now_sec )
2974{
2975    if( !t->isRunning )
2976    {
2977        removeAllPeers( t );
2978    }
2979    else
2980    {
2981        int i;
2982        int mustCloseCount;
2983        struct tr_peer ** mustClose;
2984
2985        /* disconnect the really bad peers */
2986        mustClose = getPeersToClose( t, TR_MUST_CLOSE, now_msec, now_sec, &mustCloseCount );
2987        for( i=0; i<mustCloseCount; ++i )
2988            closePeer( t, mustClose[i] );
2989        tr_free( mustClose );
2990    }
2991}
2992
2993struct peer_liveliness
2994{
2995    tr_peer * peer;
2996    void * clientData;
2997    time_t pieceDataTime;
2998    time_t time;
2999    int speed;
3000    tr_bool doPurge;
3001};
3002
3003static int
3004comparePeerLiveliness( const void * va, const void * vb )
3005{
3006    const struct peer_liveliness * a = va;
3007    const struct peer_liveliness * b = vb;
3008
3009    if( a->doPurge != b->doPurge )
3010        return a->doPurge ? 1 : -1;
3011
3012    if( a->speed != b->speed ) /* faster goes first */
3013        return a->speed > b->speed ? -1 : 1;
3014
3015    /* the one to give us data more recently goes first */
3016    if( a->pieceDataTime != b->pieceDataTime )
3017        return a->pieceDataTime > b->pieceDataTime ? -1 : 1;
3018
3019    /* the one we connected to most recently goes first */
3020    if( a->time != b->time )
3021        return a->time > b->time ? -1 : 1;
3022
3023    return 0;
3024}
3025
3026static int
3027comparePeerLivelinessReverse( const void * va, const void * vb )
3028{
3029    return -comparePeerLiveliness (va, vb);
3030}
3031
3032static void
3033sortPeersByLivelinessImpl( tr_peer  ** peers,
3034                           void     ** clientData,
3035                           int         n,
3036                           uint64_t    now,
3037                           int (*compare) ( const void *va, const void *vb ) )
3038{
3039    int i;
3040    struct peer_liveliness *lives, *l;
3041
3042    /* build a sortable array of peer + extra info */
3043    lives = l = tr_new0( struct peer_liveliness, n );
3044    for( i=0; i<n; ++i, ++l )
3045    {
3046        tr_peer * p = peers[i];
3047        l->peer = p;
3048        l->doPurge = p->doPurge;
3049        l->pieceDataTime = p->atom->piece_data_time;
3050        l->time = p->atom->time;
3051        l->speed = tr_peerGetPieceSpeed_Bps( p, now, TR_UP )
3052                 + tr_peerGetPieceSpeed_Bps( p, now, TR_DOWN );
3053        if( clientData )
3054            l->clientData = clientData[i];
3055    }
3056
3057    /* sort 'em */
3058    assert( n == ( l - lives ) );
3059    qsort( lives, n, sizeof( struct peer_liveliness ), compare );
3060
3061    /* build the peer array */
3062    for( i=0, l=lives; i<n; ++i, ++l ) {
3063        peers[i] = l->peer;
3064        if( clientData )
3065            clientData[i] = l->clientData;
3066    }
3067    assert( n == ( l - lives ) );
3068
3069    /* cleanup */
3070    tr_free( lives );
3071}
3072
3073static void
3074sortPeersByLiveliness( tr_peer ** peers, void ** clientData, int n, uint64_t now )
3075{
3076    sortPeersByLivelinessImpl( peers, clientData, n, now, comparePeerLiveliness );
3077}
3078
3079static void
3080sortPeersByLivelinessReverse( tr_peer ** peers, void ** clientData, int n, uint64_t now )
3081{
3082    sortPeersByLivelinessImpl( peers, clientData, n, now, comparePeerLivelinessReverse );
3083}
3084
3085
3086static void
3087enforceTorrentPeerLimit( Torrent * t, uint64_t now )
3088{
3089    int n = tr_ptrArraySize( &t->peers );
3090    const int max = tr_torrentGetPeerLimit( t->tor );
3091    if( n > max )
3092    {
3093        void * base = tr_ptrArrayBase( &t->peers );
3094        tr_peer ** peers = tr_memdup( base, n*sizeof( tr_peer* ) );
3095        sortPeersByLiveliness( peers, NULL, n, now );
3096        while( n > max )
3097            closePeer( t, peers[--n] );
3098        tr_free( peers );
3099    }
3100}
3101
3102static void
3103enforceSessionPeerLimit( tr_session * session, uint64_t now )
3104{
3105    int n = 0;
3106    tr_torrent * tor = NULL;
3107    const int max = tr_sessionGetPeerLimit( session );
3108
3109    /* count the total number of peers */
3110    while(( tor = tr_torrentNext( session, tor )))
3111        n += tr_ptrArraySize( &tor->torrentPeers->peers );
3112
3113    /* if there are too many, prune out the worst */
3114    if( n > max )
3115    {
3116        tr_peer ** peers = tr_new( tr_peer*, n );
3117        Torrent ** torrents = tr_new( Torrent*, n );
3118
3119        /* populate the peer array */
3120        n = 0;
3121        tor = NULL;
3122        while(( tor = tr_torrentNext( session, tor ))) {
3123            int i;
3124            Torrent * t = tor->torrentPeers;
3125            const int tn = tr_ptrArraySize( &t->peers );
3126            for( i=0; i<tn; ++i, ++n ) {
3127                peers[n] = tr_ptrArrayNth( &t->peers, i );
3128                torrents[n] = t;
3129            }
3130        }
3131
3132        /* sort 'em */
3133        sortPeersByLiveliness( peers, (void**)torrents, n, now );
3134
3135        /* cull out the crappiest */
3136        while( n-- > max )
3137            closePeer( torrents[n], peers[n] );
3138
3139        /* cleanup */
3140        tr_free( torrents );
3141        tr_free( peers );
3142    }
3143}
3144
3145static void makeNewPeerConnections( tr_peerMgr * mgr, const int max );
3146
3147static void
3148reconnectPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
3149{
3150    tr_torrent * tor;
3151    tr_peerMgr * mgr = vmgr;
3152    const time_t now_sec = tr_time( );
3153    const uint64_t now_msec = tr_time_msec( );
3154
3155    /**
3156    ***  enforce the per-session and per-torrent peer limits
3157    **/
3158
3159    /* if we're over the per-torrent peer limits, cull some peers */
3160    tor = NULL;
3161    while(( tor = tr_torrentNext( mgr->session, tor )))
3162        if( tor->isRunning )
3163            enforceTorrentPeerLimit( tor->torrentPeers, now_msec );
3164
3165    /* if we're over the per-session peer limits, cull some peers */
3166    enforceSessionPeerLimit( mgr->session, now_msec );
3167
3168    /* remove crappy peers */
3169    tor = NULL;
3170    while(( tor = tr_torrentNext( mgr->session, tor )))
3171        closeBadPeers( tor->torrentPeers, now_msec, now_sec );
3172
3173    /* try to make new peer connections */
3174    makeNewPeerConnections( mgr, MAX_CONNECTIONS_PER_PULSE );
3175}
3176
3177/****
3178*****
3179*****  BANDWIDTH ALLOCATION
3180*****
3181****/
3182
3183static void
3184pumpAllPeers( tr_peerMgr * mgr )
3185{
3186    tr_torrent * tor = NULL;
3187
3188    while(( tor = tr_torrentNext( mgr->session, tor )))
3189    {
3190        int j;
3191        Torrent * t = tor->torrentPeers;
3192
3193        for( j=0; j<tr_ptrArraySize( &t->peers ); ++j )
3194        {
3195            tr_peer * peer = tr_ptrArrayNth( &t->peers, j );
3196            tr_peerMsgsPulse( peer->msgs );
3197        }
3198    }
3199}
3200
3201static void
3202bandwidthPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
3203{
3204    tr_torrent * tor;
3205    tr_peerMgr * mgr = vmgr;
3206    managerLock( mgr );
3207
3208    /* FIXME: this next line probably isn't necessary... */
3209    pumpAllPeers( mgr );
3210
3211    /* allocate bandwidth to the peers */
3212    tr_bandwidthAllocate( mgr->session->bandwidth, TR_UP, BANDWIDTH_PERIOD_MSEC );
3213    tr_bandwidthAllocate( mgr->session->bandwidth, TR_DOWN, BANDWIDTH_PERIOD_MSEC );
3214
3215    /* possibly stop torrents that have seeded enough */
3216    tor = NULL;
3217    while(( tor = tr_torrentNext( mgr->session, tor )))
3218        tr_torrentCheckSeedLimit( tor );
3219
3220    /* run the completeness check for any torrents that need it */
3221    tor = NULL;
3222    while(( tor = tr_torrentNext( mgr->session, tor ))) {
3223        if( tor->torrentPeers->needsCompletenessCheck ) {
3224            tor->torrentPeers->needsCompletenessCheck  = FALSE;
3225            tr_torrentRecheckCompleteness( tor );
3226        }
3227    }
3228
3229    /* stop torrents that are ready to stop, but couldn't be stopped earlier
3230     * during the peer-io callback call chain */
3231    tor = NULL;
3232    while(( tor = tr_torrentNext( mgr->session, tor )))
3233        if( tor->isStopping )
3234            tr_torrentStop( tor );
3235
3236    reconnectPulse( 0, 0, mgr );
3237
3238    tr_timerAddMsec( mgr->bandwidthTimer, BANDWIDTH_PERIOD_MSEC );
3239    managerUnlock( mgr );
3240}
3241
3242/***
3243****
3244***/
3245
3246static int
3247compareAtomPtrsByAddress( const void * va, const void *vb )
3248{
3249    const struct peer_atom * a = * (const struct peer_atom**) va;
3250    const struct peer_atom * b = * (const struct peer_atom**) vb;
3251
3252    assert( tr_isAtom( a ) );
3253    assert( tr_isAtom( b ) );
3254
3255    return tr_compareAddresses( &a->addr, &b->addr );
3256}
3257
3258/* best come first, worst go last */
3259static int
3260compareAtomPtrsByShelfDate( const void * va, const void *vb )
3261{
3262    time_t atime;
3263    time_t btime;
3264    const struct peer_atom * a = * (const struct peer_atom**) va;
3265    const struct peer_atom * b = * (const struct peer_atom**) vb;
3266    const int data_time_cutoff_secs = 60 * 60;
3267    const time_t tr_now = tr_time( );
3268
3269    assert( tr_isAtom( a ) );
3270    assert( tr_isAtom( b ) );
3271
3272    /* primary key: the last piece data time *if* it was within the last hour */
3273    atime = a->piece_data_time; if( atime + data_time_cutoff_secs < tr_now ) atime = 0;
3274    btime = b->piece_data_time; if( btime + data_time_cutoff_secs < tr_now ) btime = 0;
3275    if( atime != btime )
3276        return atime > btime ? -1 : 1;
3277
3278    /* secondary key: shelf date. */
3279    if( a->shelf_date != b->shelf_date )
3280        return a->shelf_date > b->shelf_date ? -1 : 1;
3281
3282    return 0;
3283}
3284
3285static int
3286getMaxAtomCount( const tr_torrent * tor )
3287{
3288    const int n = tor->maxConnectedPeers;
3289    /* approximate fit of the old jump discontinuous function */
3290    if( n >= 55 ) return     n + 150;
3291    if( n >= 20 ) return 2 * n + 95;
3292    return               4 * n + 55;
3293}
3294
3295static void
3296atomPulse( int foo UNUSED, short bar UNUSED, void * vmgr )
3297{
3298    tr_torrent * tor = NULL;
3299    tr_peerMgr * mgr = vmgr;
3300    managerLock( mgr );
3301
3302    while(( tor = tr_torrentNext( mgr->session, tor )))
3303    {
3304        int atomCount;
3305        Torrent * t = tor->torrentPeers;
3306        const int maxAtomCount = getMaxAtomCount( tor );
3307        struct peer_atom ** atoms = (struct peer_atom**) tr_ptrArrayPeek( &t->pool, &atomCount );
3308
3309        if( atomCount > maxAtomCount ) /* we've got too many atoms... time to prune */
3310        {
3311            int i;
3312            int keepCount = 0;
3313            int testCount = 0;
3314            struct peer_atom ** keep = tr_new( struct peer_atom*, atomCount );
3315            struct peer_atom ** test = tr_new( struct peer_atom*, atomCount );
3316
3317            /* keep the ones that are in use */
3318            for( i=0; i<atomCount; ++i ) {
3319                struct peer_atom * atom = atoms[i];
3320                if( peerIsInUse( t, atom ) )
3321                    keep[keepCount++] = atom;
3322                else
3323                    test[testCount++] = atom;
3324            }
3325
3326            /* if there's room, keep the best of what's left */
3327            i = 0;
3328            if( keepCount < maxAtomCount ) {
3329                qsort( test, testCount, sizeof( struct peer_atom * ), compareAtomPtrsByShelfDate );
3330                while( i<testCount && keepCount<maxAtomCount )
3331                    keep[keepCount++] = test[i++];
3332            }
3333
3334            /* free the culled atoms */
3335            while( i<testCount )
3336                tr_free( test[i++] );
3337
3338            /* rebuild Torrent.pool with what's left */
3339            tr_ptrArrayDestruct( &t->pool, NULL );
3340            t->pool = TR_PTR_ARRAY_INIT;
3341            qsort( keep, keepCount, sizeof( struct peer_atom * ), compareAtomPtrsByAddress );
3342            for( i=0; i<keepCount; ++i )
3343                tr_ptrArrayAppend( &t->pool, keep[i] );
3344
3345            tordbg( t, "max atom count is %d... pruned from %d to %d\n", maxAtomCount, atomCount, keepCount );
3346
3347            /* cleanup */
3348            tr_free( test );
3349            tr_free( keep );
3350        }
3351    }
3352
3353    tr_timerAddMsec( mgr->atomTimer, ATOM_PERIOD_MSEC );
3354    managerUnlock( mgr );
3355}
3356
3357/***
3358****
3359****
3360****
3361***/
3362
3363/* is this atom someone that we'd want to initiate a connection to? */
3364static tr_bool
3365isPeerCandidate( const tr_torrent * tor, struct peer_atom * atom, const time_t now )
3366{
3367    /* not if we're both seeds */
3368    if( tr_torrentIsSeed( tor ) )
3369        if( atomIsSeed( atom ) || ( atom->uploadOnly == UPLOAD_ONLY_YES ) )
3370            return FALSE;
3371
3372    /* not if we've already got a connection to them...  */
3373    if( peerIsInUse( tor->torrentPeers, atom ) )
3374        return FALSE;
3375
3376    /* not if we just tried them already */
3377    if( ( now - atom->time ) < getReconnectIntervalSecs( atom, now ) )
3378        return FALSE;
3379
3380    /* not if they're blocklisted */
3381    if( isAtomBlocklisted( tor->session, atom ) )
3382        return FALSE;
3383
3384    /* not if they're banned... */
3385    if( atom->flags2 & MYFLAG_BANNED )
3386        return FALSE;
3387
3388    return TRUE;
3389}
3390
3391struct peer_candidate
3392{
3393    uint64_t score;
3394    tr_torrent * tor;
3395    struct peer_atom * atom;
3396};
3397
3398static tr_bool
3399torrentWasRecentlyStarted( const tr_torrent * tor )
3400{
3401    return difftime( tr_time( ), tor->startDate ) < 120;
3402}
3403
3404static inline uint64_t
3405addValToKey( uint64_t value, int width, uint64_t addme )
3406{
3407    value = (value << (uint64_t)width);
3408    value |= addme;
3409    return value;
3410}
3411
3412/* smaller value is better */
3413static uint64_t
3414getPeerCandidateScore( const tr_torrent * tor, const struct peer_atom * atom, uint8_t salt  )
3415{
3416    uint64_t i;
3417    uint64_t score = 0;
3418    const tr_bool failed = atom->lastConnectionAt < atom->lastConnectionAttemptAt;
3419
3420    /* prefer peers we've connected to, or never tried, over peers we failed to connect to. */
3421    i = failed ? 1 : 0;
3422    score = addValToKey( score, 1, i );
3423
3424    /* prefer the one we attempted least recently (to cycle through all peers) */
3425    i = atom->lastConnectionAttemptAt;
3426    score = addValToKey( score, 32, i );
3427
3428    /* prefer peers belonging to a torrent of a higher priority */
3429    switch( tr_torrentGetPriority( tor ) ) {
3430        case TR_PRI_HIGH:    i = 0; break;
3431        case TR_PRI_NORMAL:  i = 1; break;
3432        case TR_PRI_LOW:     i = 2; break;
3433    }
3434    score = addValToKey( score, 4, i );
3435
3436    /* prefer recently-started torrents */
3437    i = torrentWasRecentlyStarted( tor ) ? 0 : 1;
3438    score = addValToKey( score, 1, i );
3439
3440    /* prefer torrents we're downloading with */
3441    i = tr_torrentIsSeed( tor ) ? 1 : 0;
3442    score = addValToKey( score, 1, i );
3443
3444    /* prefer peers that are known to be connectible */
3445    i = ( atom->flags & ADDED_F_CONNECTABLE ) ? 0 : 1;
3446    score = addValToKey( score, 1, i );
3447
3448    /* prefer peers that we might have a chance of uploading to...
3449       so lower seed probability is better */
3450    if( atom->seedProbability == 100 ) i = 101;
3451    else if( atom->seedProbability == -1 ) i = 100;
3452    else i = atom->seedProbability;
3453    score = addValToKey( score, 8, i );
3454
3455    /* Prefer peers that we got from more trusted sources.
3456     * lower `from' values indicate more trusted sources */
3457    score = addValToKey( score, 4, atom->from );
3458
3459    /* salt */
3460    score = addValToKey( score, 8, salt );
3461
3462    return score;
3463}
3464
3465/* sort an array of peer candidates */
3466static int
3467comparePeerCandidates( const void * va, const void * vb )
3468{
3469    const struct peer_candidate * a = va;
3470    const struct peer_candidate * b = vb;
3471
3472    if( a->score < b->score ) return -1;
3473    if( a->score > b->score ) return 1;
3474
3475    return 0;
3476}
3477
3478/** @return an array of all the atoms we might want to connect to */
3479static struct peer_candidate*
3480getPeerCandidates( tr_session * session, int * candidateCount )
3481{
3482    int n;
3483    tr_torrent * tor;
3484    struct peer_candidate * candidates;
3485    struct peer_candidate * walk;
3486    const time_t now = tr_time( );
3487    const uint64_t now_msec = tr_time_msec( );
3488    /* leave 5% of connection slots for incoming connections -- ticket #2609 */
3489    const int maxCandidates = tr_sessionGetPeerLimit( session ) * 0.95;
3490
3491    /* don't start any new handshakes if we have enough peers */
3492    n = 0;
3493    tor= NULL;
3494    while(( tor = tr_torrentNext( session, tor )))
3495        n += tr_ptrArraySize( &tor->torrentPeers->peers );
3496    if( maxCandidates <= n ) {
3497        *candidateCount = 0;
3498        return NULL;
3499    }
3500
3501    /* allocate an array of candidates */
3502    n = 0;
3503    tor= NULL;
3504    while(( tor = tr_torrentNext( session, tor )))
3505        n += tr_ptrArraySize( &tor->torrentPeers->pool );
3506    walk = candidates = tr_new( struct peer_candidate, n );
3507
3508    /* populate the candidate array */
3509    tor = NULL;
3510    while(( tor = tr_torrentNext( session, tor )))
3511    {
3512        int i, nAtoms;
3513        tr_bool full_up;
3514        tr_bool full_dn;
3515        struct peer_atom ** atoms;
3516
3517        if( !tor->torrentPeers->isRunning )
3518            continue;
3519
3520        /* if we've already got enough peers in this torrent... */
3521        if( tr_torrentGetPeerLimit( tor ) <= tr_ptrArraySize( &tor->torrentPeers->peers ) )
3522            continue;
3523
3524        /* if we've already got enough speed in this torrent... */
3525        full_up = isBandwidthMaxedOut( tor->bandwidth, now_msec, TR_UP );
3526        full_dn = isBandwidthMaxedOut( tor->bandwidth, now_msec, TR_DOWN );
3527        if( full_up && full_dn )
3528            continue;
3529        if( full_up && tr_torrentIsSeed( tor ) )
3530            continue;
3531
3532        atoms = (struct peer_atom**) tr_ptrArrayPeek( &tor->torrentPeers->pool, &nAtoms );
3533        for( i=0; i<nAtoms; ++i )
3534        {
3535            struct peer_atom * atom = atoms[i];
3536
3537            if( isPeerCandidate( tor, atom, now ) )
3538            {
3539                const uint8_t salt = tr_cryptoWeakRandInt( 1024 );
3540                walk->tor = tor;
3541                walk->atom = atom;
3542                walk->score = getPeerCandidateScore( tor, atom, salt );
3543                ++walk;
3544            }
3545        }
3546    }
3547
3548    *candidateCount = walk - candidates;
3549    if( *candidateCount > 1 )
3550        qsort( candidates, *candidateCount, sizeof( struct peer_candidate ), comparePeerCandidates );
3551    return candidates;
3552}
3553
3554static void
3555initiateConnection( tr_peerMgr * mgr, Torrent * t, struct peer_atom * atom )
3556{
3557    tr_peerIo * io;
3558    const time_t now = tr_time( );
3559
3560    tordbg( t, "Starting an OUTGOING connection with %s", tr_atomAddrStr( atom ) );
3561
3562    io = tr_peerIoNewOutgoing( mgr->session,
3563                               mgr->session->bandwidth,
3564                               &atom->addr,
3565                               atom->port,
3566                               t->tor->info.hash,
3567                               t->tor->completeness == TR_SEED );
3568
3569    if( io == NULL )
3570    {
3571        tordbg( t, "peerIo not created; marking peer %s as unreachable",
3572                tr_atomAddrStr( atom ) );
3573        atom->flags2 |= MYFLAG_UNREACHABLE;
3574        atom->numFails++;
3575    }
3576    else
3577    {
3578        tr_handshake * handshake = tr_handshakeNew( io,
3579                                                    mgr->session->encryptionMode,
3580                                                    myHandshakeDoneCB,
3581                                                    mgr );
3582
3583        assert( tr_peerIoGetTorrentHash( io ) );
3584
3585        tr_peerIoUnref( io ); /* balanced by the initial ref
3586                                 in tr_peerIoNewOutgoing() */
3587
3588        tr_ptrArrayInsertSorted( &t->outgoingHandshakes, handshake,
3589                                 handshakeCompare );
3590    }
3591
3592    atom->lastConnectionAttemptAt = now;
3593    atom->time = now;
3594}
3595
3596static void
3597initiateCandidateConnection( tr_peerMgr * mgr, struct peer_candidate * c )
3598{
3599#if 0
3600    fprintf( stderr, "Starting an OUTGOING connection with %s - [%s] seedProbability==%d; %s, %s\n",
3601             tr_atomAddrStr( c->atom ),
3602             tr_torrentName( c->tor ),
3603             (int)c->atom->seedProbability,
3604             tr_torrentIsPrivate( c->tor ) ? "private" : "public",
3605             tr_torrentIsSeed( c->tor ) ? "seed" : "downloader" );
3606#endif
3607
3608    initiateConnection( mgr, c->tor->torrentPeers, c->atom );
3609}
3610
3611static void
3612makeNewPeerConnections( struct tr_peerMgr * mgr, const int max )
3613{
3614    int i, n;
3615    struct peer_candidate * candidates;
3616
3617    candidates = getPeerCandidates( mgr->session, &n );
3618
3619    for( i=0; i<n && i<max; ++i )
3620        initiateCandidateConnection( mgr, &candidates[i] );
3621
3622    tr_free( candidates );
3623}
Note: See TracBrowser for help on using the repository browser.