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

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

(trunk libT) add randomness to the peer unchoking algorithm

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