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

Last change on this file since 10877 was 10877, checked in by charles, 12 years ago

(trunk libT) #3329 "connection problems when downloading" -- when deciding which peer to connect to, take download/seed status into account

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