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

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

(trunk) #1521 "memory cache to reduce disk IO" -- commit block-cache-rc1.diff to trunk for the nightlies.

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