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

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

(trunk) Join the 21st century and use only 1 space at the end sentences. This commit is nearly as important as the semi-annual ones that remove trailing spaces from the ends of lines of code... :)

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