source: branches/0.9x/libtransmission/peer-mgr.c @ 3783

Last change on this file since 3783 was 3783, checked in by charles, 15 years ago

backport the rest of the "router death" fixes.

  • Property svn:keywords set to Date Rev Author Id
File size: 48.6 KB
Line 
1/*
2 * This file Copyright (C) 2007 Charles Kerr <charles@rebelbase.com>
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 3783 2007-11-10 15:13:31Z charles $
11 */
12
13#include <assert.h>
14#include <string.h> /* memcpy, memcmp */
15#include <stdlib.h> /* qsort */
16#include <stdio.h> /* printf */
17#include <limits.h> /* INT_MAX */
18
19#include <libgen.h> /* basename */
20#include <sys/types.h> /* event.h needs this */
21#include <arpa/inet.h> /* inet_ntoa */
22
23#include <event.h>
24
25#include "transmission.h"
26#include "clients.h"
27#include "completion.h"
28#include "crypto.h"
29#include "handshake.h"
30#include "net.h"
31#include "peer-io.h"
32#include "peer-mgr.h"
33#include "peer-mgr-private.h"
34#include "peer-msgs.h"
35#include "platform.h"
36#include "ptrarray.h"
37#include "ratecontrol.h"
38#include "shared.h"
39#include "trevent.h"
40#include "utils.h"
41
42enum
43{
44    /* how frequently to change which peers are choked */
45    RECHOKE_PERIOD_MSEC = (1000),
46
47    /* how frequently to decide which peers live and die */
48    RECONNECT_PERIOD_MSEC = (5 * 1000),
49
50    /* how frequently to refill peers' request lists */
51    REFILL_PERIOD_MSEC = 666,
52
53    /* don't change a peer's choke status more often than this */
54    MIN_CHOKE_PERIOD_SEC = 10,
55
56    /* following the BT spec, we consider ourselves `snubbed' if
57     * we're we don't get piece data from a peer in this long */
58    SNUBBED_SEC = 60,
59
60    /* arbitrary */
61    MAX_CONNECTED_PEERS_PER_TORRENT = 60,
62
63    /* when many peers are available, keep idle ones this long */
64    MIN_UPLOAD_IDLE_SECS = 60,
65
66    /* when few peers are available, keep idle ones this long */
67    MAX_UPLOAD_IDLE_SECS = 240,
68
69    /* how many peers to unchoke per-torrent. */
70    /* FIXME: make this user-configurable? */
71    NUM_UNCHOKED_PEERS_PER_TORRENT = 12, /* arbitrary */
72
73    /* set this too high and there will be a lot of churn.
74     * set it too low and you'll get peers too slowly */
75    MAX_RECONNECTIONS_PER_PULSE = 5,
76
77    /* corresponds to ut_pex's added.f flags */
78    ADDED_F_ENCRYPTION_FLAG = 1,
79    /* corresponds to ut_pex's added.f flags */
80    ADDED_F_SEED_FLAG = 2,
81
82    /* number of bad pieces a peer is allowed to send before we ban them */
83    MAX_BAD_PIECES_PER_PEER = 3,
84    /* use for bitwise operations w/peer_atom.myflags */
85    MYFLAG_BANNED = 1
86};
87
88
89/**
90***
91**/
92
93/* We keep one of these for every peer we know about, whether
94 * it's connected or not, so the struct must be small.
95 * When our current connections underperform, we dip back
96 * into this list for new ones. */
97struct peer_atom
98{   
99    uint8_t from;
100    uint8_t flags; /* these match the added_f flags */
101    uint8_t myflags; /* flags that aren't defined in added_f */
102    uint16_t port;
103    uint16_t numFails;
104    struct in_addr addr;
105    time_t time;
106};
107
108typedef struct
109{
110    uint8_t hash[SHA_DIGEST_LENGTH];
111    tr_ptrArray * outgoingHandshakes; /* tr_handshake */
112    tr_ptrArray * pool; /* struct peer_atom */
113    tr_ptrArray * peers; /* tr_peer */
114    tr_timer * reconnectTimer;
115    tr_timer * rechokeTimer;
116    tr_timer * refillTimer;
117    tr_torrent * tor;
118    tr_bitfield * requested;
119
120    unsigned int isRunning : 1;
121
122    struct tr_peerMgr * manager;
123}
124Torrent;
125
126struct tr_peerMgr
127{
128    tr_handle * handle;
129    tr_ptrArray * torrents; /* Torrent */
130    tr_ptrArray * incomingHandshakes; /* tr_handshake */
131};
132
133/**
134***
135**/
136
137static void
138myDebug( const char * file, int line, const Torrent * t, const char * fmt, ... )
139{
140    FILE * fp = tr_getLog( );
141    if( fp != NULL )
142    {
143        va_list args;
144        char timestr[64];
145        struct evbuffer * buf = evbuffer_new( );
146        char * myfile = tr_strdup( file );
147
148        evbuffer_add_printf( buf, "[%s] ", tr_getLogTimeStr( timestr, sizeof(timestr) ) );
149        if( t != NULL )
150            evbuffer_add_printf( buf, "%s ", t->tor->info.name );
151        va_start( args, fmt );
152        evbuffer_add_vprintf( buf, fmt, args );
153        va_end( args );
154        evbuffer_add_printf( buf, " (%s:%d)\n", basename(myfile), line );
155        fwrite( EVBUFFER_DATA(buf), 1, EVBUFFER_LENGTH(buf), fp );
156
157        tr_free( myfile );
158        evbuffer_free( buf );
159    }
160}
161
162#define tordbg(t, fmt...) myDebug(__FILE__, __LINE__, t, ##fmt )
163
164/**
165***
166**/
167
168static void
169managerLock( struct tr_peerMgr * manager )
170{
171    tr_globalLock( manager->handle );
172}
173static void
174managerUnlock( struct tr_peerMgr * manager )
175{
176    tr_globalUnlock( manager->handle );
177}
178static void
179torrentLock( Torrent * torrent )
180{
181    managerLock( torrent->manager );
182}
183static void
184torrentUnlock( Torrent * torrent )
185{
186    managerUnlock( torrent->manager );
187}
188static int
189torrentIsLocked( const Torrent * t )
190{
191    return tr_globalIsLocked( t->manager->handle );
192}
193
194/**
195***
196**/
197
198static int
199compareAddresses( const struct in_addr * a, const struct in_addr * b )
200{
201    return tr_compareUint32( a->s_addr, b->s_addr );
202}
203
204static int
205handshakeCompareToAddr( const void * va, const void * vb )
206{
207    const tr_handshake * a = va;
208    return compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
209}
210
211static int
212handshakeCompare( const void * a, const void * b )
213{
214    return handshakeCompareToAddr( a, tr_handshakeGetAddr( b, NULL ) );
215}
216
217static tr_handshake*
218getExistingHandshake( tr_ptrArray * handshakes, const struct in_addr * in_addr )
219{
220    return tr_ptrArrayFindSorted( handshakes,
221                                  in_addr,
222                                  handshakeCompareToAddr );
223}
224
225static int
226comparePeerAtomToAddress( const void * va, const void * vb )
227{
228    const struct peer_atom * a = va;
229    return compareAddresses( &a->addr, vb );
230}
231
232static int
233comparePeerAtoms( const void * va, const void * vb )
234{
235    const struct peer_atom * b = vb;
236    return comparePeerAtomToAddress( va, &b->addr );
237}
238
239/**
240***
241**/
242
243static int
244torrentCompare( const void * va, const void * vb )
245{
246    const Torrent * a = va;
247    const Torrent * b = vb;
248    return memcmp( a->hash, b->hash, SHA_DIGEST_LENGTH );
249}
250
251static int
252torrentCompareToHash( const void * va, const void * vb )
253{
254    const Torrent * a = va;
255    const uint8_t * b_hash = vb;
256    return memcmp( a->hash, b_hash, SHA_DIGEST_LENGTH );
257}
258
259static Torrent*
260getExistingTorrent( tr_peerMgr * manager, const uint8_t * hash )
261{
262    return (Torrent*) tr_ptrArrayFindSorted( manager->torrents,
263                                             hash,
264                                             torrentCompareToHash );
265}
266
267static int
268peerCompare( const void * va, const void * vb )
269{
270    const tr_peer * a = va;
271    const tr_peer * b = vb;
272    return compareAddresses( &a->in_addr, &b->in_addr );
273}
274
275static int
276peerCompareToAddr( const void * va, const void * vb )
277{
278    const tr_peer * a = va;
279    return compareAddresses( &a->in_addr, vb );
280}
281
282static tr_peer*
283getExistingPeer( Torrent * torrent, const struct in_addr * in_addr )
284{
285    assert( torrentIsLocked( torrent ) );
286    assert( in_addr != NULL );
287
288    return (tr_peer*) tr_ptrArrayFindSorted( torrent->peers,
289                                             in_addr,
290                                             peerCompareToAddr );
291}
292
293static struct peer_atom*
294getExistingAtom( const Torrent * t, const struct in_addr * addr )
295{
296    assert( torrentIsLocked( t ) );
297    return tr_ptrArrayFindSorted( t->pool, addr, comparePeerAtomToAddress );
298}
299
300static int
301peerIsInUse( const Torrent * ct, const struct in_addr * addr )
302{
303    Torrent * t = (Torrent*) ct;
304
305    assert( torrentIsLocked ( t ) );
306
307    return getExistingPeer( t, addr )
308        || getExistingHandshake( t->outgoingHandshakes, addr )
309        || getExistingHandshake( t->manager->incomingHandshakes, addr );
310}
311
312static tr_peer*
313peerConstructor( const struct in_addr * in_addr )
314{
315    tr_peer * p;
316    p = tr_new0( tr_peer, 1 );
317    p->rcToClient = tr_rcInit( );
318    p->rcToPeer = tr_rcInit( );
319    memcpy( &p->in_addr, in_addr, sizeof(struct in_addr) );
320    return p;
321}
322
323static tr_peer*
324getPeer( Torrent * torrent, const struct in_addr * in_addr )
325{
326    tr_peer * peer;
327
328    assert( torrentIsLocked( torrent ) );
329
330    peer = getExistingPeer( torrent, in_addr );
331
332    if( peer == NULL ) {
333        peer = peerConstructor( in_addr );
334        tr_ptrArrayInsertSorted( torrent->peers, peer, peerCompare );
335    }
336
337    return peer;
338}
339
340static void
341peerDestructor( tr_peer * peer )
342{
343    assert( peer != NULL );
344    assert( peer->msgs != NULL );
345
346    tr_peerMsgsUnsubscribe( peer->msgs, peer->msgsTag );
347    tr_peerMsgsFree( peer->msgs );
348
349    tr_peerIoFree( peer->io );
350
351    tr_bitfieldFree( peer->have );
352    tr_bitfieldFree( peer->blame );
353    tr_rcClose( peer->rcToClient );
354    tr_rcClose( peer->rcToPeer );
355    tr_free( peer->client );
356    tr_free( peer );
357}
358
359static void
360removePeer( Torrent * t, tr_peer * peer )
361{
362    tr_peer * removed;
363    struct peer_atom * atom;
364
365    assert( torrentIsLocked( t ) );
366
367    atom = getExistingAtom( t, &peer->in_addr );
368    assert( atom != NULL );
369    atom->time = time( NULL );
370
371    removed = tr_ptrArrayRemoveSorted  ( t->peers, peer, peerCompare );
372    assert( removed == peer );
373    peerDestructor( removed );
374}
375
376static void
377removeAllPeers( Torrent * t )
378{
379    while( !tr_ptrArrayEmpty( t->peers ) )
380        removePeer( t, tr_ptrArrayNth( t->peers, 0 ) );
381}
382
383static void
384torrentDestructor( Torrent * t )
385{
386    uint8_t hash[SHA_DIGEST_LENGTH];
387
388    assert( t != NULL );
389    assert( !t->isRunning );
390    assert( t->peers != NULL );
391    assert( torrentIsLocked( t ) );
392    assert( tr_ptrArrayEmpty( t->outgoingHandshakes ) );
393    assert( tr_ptrArrayEmpty( t->peers ) );
394
395    memcpy( hash, t->hash, SHA_DIGEST_LENGTH );
396
397    tr_timerFree( &t->reconnectTimer );
398    tr_timerFree( &t->rechokeTimer );
399    tr_timerFree( &t->refillTimer );
400
401    tr_bitfieldFree( t->requested );
402    tr_ptrArrayFree( t->pool, (PtrArrayForeachFunc)tr_free );
403    tr_ptrArrayFree( t->outgoingHandshakes, NULL );
404    tr_ptrArrayFree( t->peers, NULL );
405
406    tr_free( t );
407}
408
409static Torrent*
410torrentConstructor( tr_peerMgr * manager, tr_torrent * tor )
411{
412    Torrent * t;
413
414    t = tr_new0( Torrent, 1 );
415    t->manager = manager;
416    t->tor = tor;
417    t->pool = tr_ptrArrayNew( );
418    t->peers = tr_ptrArrayNew( );
419    t->outgoingHandshakes = tr_ptrArrayNew( );
420    t->requested = tr_bitfieldNew( tor->blockCount );
421    memcpy( t->hash, tor->info.hash, SHA_DIGEST_LENGTH );
422
423    return t;
424}
425
426/**
427***
428**/
429
430struct tr_bitfield *
431tr_peerMgrGenerateAllowedSet( const uint32_t         setCount,
432                              const uint32_t         pieceCount,
433                              const uint8_t          infohash[20],
434                              const struct in_addr * ip )
435{
436    /* This has been checked against the spec example implementation. Feeding it with :
437    setCount = 9, pieceCount = 1313, infohash = Oxaa,0xaa,...0xaa, ip = 80.4.4.200
438generate :
439    1059, 431, 808, 1217, 287, 376, 1188, 353, 508
440    but since we're storing in a bitfield, it won't be in this order... */
441    /* TODO : We should translate link-local IPv4 adresses to external IP,
442     * so that being on same local network gives us the same allowed pieces */
443   
444    uint8_t *seed;
445    char buf[4];
446    uint32_t allowedPieceCount = 0;
447    tr_bitfield_t * ret;
448
449    printf( "%d piece allowed fast set for torrent with %d pieces and hex infohash\n", setCount, pieceCount );
450    printf( "%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x for node with IP %s:\n",
451            infohash[0], infohash[1], infohash[2], infohash[3], infohash[4], infohash[5], infohash[6], infohash[7], infohash[8], infohash[9],
452            infohash[10], infohash[11], infohash[12], infohash[13], infohash[14], infohash[15], infohash[16], infohash[7], infohash[18], infohash[19],
453            inet_ntoa( *ip ) );
454   
455    seed = malloc(4 + SHA_DIGEST_LENGTH);
456   
457    ret = tr_bitfieldNew( pieceCount );
458   
459    /* We need a seed based on most significant bytes of peer address
460        concatenated with torrent's infohash */
461    *(uint32_t*)buf = ntohl( htonl(ip->s_addr) & 0xffffff00 );
462   
463    memcpy( seed, &buf, 4 );
464    memcpy( seed + 4, infohash, SHA_DIGEST_LENGTH );
465   
466    tr_sha1( seed, seed, 4 + SHA_DIGEST_LENGTH, NULL );
467   
468    while ( allowedPieceCount < setCount )
469    {
470        int i;
471        for ( i = 0 ; i < 5 && allowedPieceCount < setCount ; i++ )
472        {
473            /* We generate indices from 4-byte chunks of the seed */
474            uint32_t j = i * 4;
475            uint32_t y = ntohl( *(uint32_t*)(seed + j) );
476            uint32_t index = y % pieceCount;
477           
478            if ( !tr_bitfieldHas( ret, index ) )
479            {
480                tr_bitfieldAdd( ret, index );
481                allowedPieceCount++;
482            }
483        }
484        /* We randomize the seed, in case we need to iterate more */
485        tr_sha1( seed, seed, SHA_DIGEST_LENGTH, NULL );
486    }
487    tr_free( seed );
488   
489    return ret;
490}
491
492tr_peerMgr*
493tr_peerMgrNew( tr_handle * handle )
494{
495    tr_peerMgr * m = tr_new0( tr_peerMgr, 1 );
496    m->handle = handle;
497    m->torrents = tr_ptrArrayNew( );
498    m->incomingHandshakes = tr_ptrArrayNew( );
499    return m;
500}
501
502void
503tr_peerMgrFree( tr_peerMgr * manager )
504{
505    managerLock( manager );
506
507    /* free the handshakes.  Abort invokes handshakeDoneCB(), which removes
508     * the item from manager->handshakes, so this is a little roundabout... */
509    while( !tr_ptrArrayEmpty( manager->incomingHandshakes ) )
510        tr_handshakeAbort( tr_ptrArrayNth( manager->incomingHandshakes, 0 ) );
511    tr_ptrArrayFree( manager->incomingHandshakes, NULL );
512
513    /* free the torrents. */
514    tr_ptrArrayFree( manager->torrents, (PtrArrayForeachFunc)torrentDestructor );
515
516    managerUnlock( manager );
517    tr_free( manager );
518}
519
520static tr_peer**
521getConnectedPeers( Torrent * t, int * setmeCount )
522{
523    int i, peerCount, connectionCount;
524    tr_peer **peers;
525    tr_peer **ret;
526
527    assert( torrentIsLocked( t ) );
528
529    peers = (tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
530    ret = tr_new( tr_peer*, peerCount );
531
532    for( i=connectionCount=0; i<peerCount; ++i )
533        if( peers[i]->msgs != NULL )
534            ret[connectionCount++] = peers[i];
535
536    *setmeCount = connectionCount;
537    return ret;
538}
539
540/***
541****  Refill
542***/
543
544struct tr_refill_piece
545{
546    tr_priority_t priority;
547    int percentDone;
548    uint16_t random;
549    uint32_t piece;
550    uint32_t peerCount;
551    uint32_t fastAllowed;
552};
553
554static int
555compareRefillPiece (const void * aIn, const void * bIn)
556{
557    const struct tr_refill_piece * a = aIn;
558    const struct tr_refill_piece * b = bIn;
559   
560    /* if one *might be* fastallowed to us, get it first...
561     * I'm putting it on top so we prioritise those pieces at
562     * startup, then we'll have them, and we'll be denied access
563     * to them */
564    if (a->fastAllowed != b->fastAllowed)
565        return a->fastAllowed < b->fastAllowed ? -1 : 1;
566   
567    /* if one piece has a higher priority, it goes first */
568    if (a->priority != b->priority)
569        return a->priority > b->priority ? -1 : 1;
570
571    /* try to fill partial pieces */
572    if( a->percentDone != b->percentDone )
573        return a->percentDone > b->percentDone ? -1 : 1;
574   
575    /* otherwise if one has fewer peers, it goes first */
576    if (a->peerCount != b->peerCount)
577        return a->peerCount < b->peerCount ? -1 : 1;
578
579    /* otherwise go with our random seed */
580    return tr_compareUint16( a->random, b->random );
581}
582
583static int
584isPieceInteresting( const tr_torrent  * tor,
585                    int                 piece )
586{
587    if( tor->info.pieces[piece].dnd ) /* we don't want it */
588        return 0;
589
590    if( tr_cpPieceIsComplete( tor->completion, piece ) ) /* we have it */
591        return 0;
592
593    return 1;
594}
595
596static uint32_t*
597getPreferredPieces( Torrent     * t,
598                    uint32_t    * pieceCount )
599{
600    const tr_torrent * tor = t->tor;
601    const tr_info * inf = &tor->info;
602    int i;
603    uint32_t poolSize = 0;
604    uint32_t * pool = tr_new( uint32_t, inf->pieceCount );
605    int peerCount;
606    tr_peer** peers;
607
608    assert( torrentIsLocked( t ) );
609
610    peers = getConnectedPeers( t, &peerCount );
611
612    for( i=0; i<inf->pieceCount; ++i )
613        if( isPieceInteresting( tor, i ) )
614            pool[poolSize++] = i;
615
616    /* sort the pool from most interesting to least... */
617    if( poolSize > 1 )
618    {
619        uint32_t j;
620        struct tr_refill_piece * p = tr_new( struct tr_refill_piece, poolSize );
621
622        for( j=0; j<poolSize; ++j )
623        {
624            int k;
625            const int piece = pool[j];
626            struct tr_refill_piece * setme = p + j;
627
628            setme->piece = piece;
629            setme->priority = inf->pieces[piece].priority;
630            setme->peerCount = 0;
631            setme->fastAllowed = 0;
632            setme->random = tr_rand( UINT16_MAX );
633            setme->percentDone = (int)( 100.0 * tr_cpPercentBlocksInPiece( tor->completion, piece ) );
634
635            for( k=0; k<peerCount; ++k ) {
636                const tr_peer * peer = peers[k];
637                if( peer->peerIsInterested && !peer->clientIsChoked && tr_bitfieldHas( peer->have, piece ) )
638                    ++setme->peerCount;
639                /* The fast peer extension doesn't force a peer to actually HAVE a fast-allowed piece,
640                    but we're guaranteed to get the same pieces from different peers,
641                    so we'll build a list and pray one actually have this one */
642                setme->fastAllowed = tr_peerMsgIsPieceFastAllowed( peer->msgs, i);
643            }
644        }
645
646        qsort( p, poolSize, sizeof(struct tr_refill_piece), compareRefillPiece );
647
648        for( j=0; j<poolSize; ++j )
649            pool[j] = p[j].piece;
650
651        tr_free( p );
652    }
653
654    tr_free( peers );
655
656    *pieceCount = poolSize;
657    return pool;
658}
659
660static uint64_t*
661getPreferredBlocks( Torrent * t, uint64_t * setmeCount )
662{
663    uint32_t i;
664    uint32_t pieceCount;
665    uint32_t * pieces;
666    uint64_t *req, *unreq, *ret, *walk;
667    int reqCount, unreqCount;
668    const tr_torrent * tor = t->tor;
669
670    assert( torrentIsLocked( t ) );
671
672    pieces = getPreferredPieces( t, &pieceCount );
673
674    req = tr_new( uint64_t, pieceCount *  tor->blockCountInPiece );
675    reqCount = 0;
676    unreq = tr_new( uint64_t, pieceCount *  tor->blockCountInPiece );
677    unreqCount = 0;
678
679    for( i=0; i<pieceCount; ++i ) {
680        const uint32_t index = pieces[i];
681        const int begin = tr_torPieceFirstBlock( tor, index );
682        const int end = begin + tr_torPieceCountBlocks( tor, (int)index );
683        int block;
684        for( block=begin; block<end; ++block )
685            if( tr_cpBlockIsComplete( tor->completion, block ) )
686                continue;
687            else if( tr_bitfieldHas( t->requested, block ) )
688                req[reqCount++] = block;
689            else
690                unreq[unreqCount++] = block;
691    }
692
693    ret = walk = tr_new( uint64_t, unreqCount + reqCount );
694    memcpy( walk, unreq, sizeof(uint64_t) * unreqCount );
695    walk += unreqCount;
696    memcpy( walk, req, sizeof(uint64_t) * reqCount );
697    walk += reqCount;
698    assert( ( walk - ret ) == ( unreqCount + reqCount ) );
699    *setmeCount = walk - ret;
700
701    tr_free( req );
702    tr_free( unreq );
703    tr_free( pieces );
704
705    return ret;
706}
707
708static int
709refillPulse( void * vtorrent )
710{
711    Torrent * t = vtorrent;
712    tr_torrent * tor = t->tor;
713    uint32_t i;
714    int peerCount;
715    tr_peer ** peers;
716    uint64_t blockCount;
717    uint64_t * blocks;
718
719    if( !t->isRunning )
720        return TRUE;
721    if( tr_torrentIsSeed( t->tor ) )
722        return TRUE;
723
724    torrentLock( t );
725    tordbg( t, "Refilling Request Buffers..." );
726
727    blocks = getPreferredBlocks( t, &blockCount );
728    peers = getConnectedPeers( t, &peerCount );
729
730    for( i=0; peerCount && i<blockCount; ++i )
731    {
732        const int block = blocks[i];
733        const uint32_t index = tr_torBlockPiece( tor, block );
734        const uint32_t begin = (block * tor->blockSize) - (index * tor->info.pieceSize);
735        const uint32_t length = tr_torBlockCountBytes( tor, block );
736        int j;
737        assert( _tr_block( tor, index, begin ) == block );
738        assert( begin < (uint32_t)tr_torPieceCountBytes( tor, (int)index ) );
739        assert( (begin + length) <= (uint32_t)tr_torPieceCountBytes( tor, (int)index ) );
740
741
742        /* find a peer who can ask for this block */
743        for( j=0; j<peerCount; )
744        {
745            const int val = tr_peerMsgsAddRequest( peers[j]->msgs, index, begin, length );
746            switch( val )
747            {
748                case TR_ADDREQ_FULL: 
749                case TR_ADDREQ_CLIENT_CHOKED:
750                    memmove( peers+j, peers+j+1, sizeof(tr_peer*)*(--peerCount-j) );
751                    break;
752
753                case TR_ADDREQ_MISSING: 
754                case TR_ADDREQ_DUPLICATE: 
755                    ++j;
756                    break;
757
758                case TR_ADDREQ_OK:
759                    tr_bitfieldAdd( t->requested, block );
760                    j = peerCount;
761                    break;
762
763                default:
764                    assert( 0 && "unhandled value" );
765                    break;
766            }
767        }
768    }
769
770    /* cleanup */
771    tr_free( peers );
772    tr_free( blocks );
773
774    t->refillTimer = NULL;
775    torrentUnlock( t );
776    return FALSE;
777}
778
779static void
780broadcastClientHave( Torrent * t, uint32_t index )
781{
782    int i, size;
783    tr_peer ** peers;
784
785    assert( torrentIsLocked( t ) );
786
787    peers = getConnectedPeers( t, &size );
788    for( i=0; i<size; ++i )
789        tr_peerMsgsHave( peers[i]->msgs, index );
790    tr_free( peers );
791}
792
793static void
794broadcastGotBlock( Torrent * t, uint32_t index, uint32_t offset, uint32_t length )
795{
796    int i, size;
797    tr_peer ** peers;
798
799    assert( torrentIsLocked( t ) );
800
801    peers = getConnectedPeers( t, &size );
802    for( i=0; i<size; ++i )
803        tr_peerMsgsCancel( peers[i]->msgs, index, offset, length );
804    tr_free( peers );
805}
806
807static void
808msgsCallbackFunc( void * vpeer, void * vevent, void * vt )
809{
810    tr_peer * peer = vpeer;
811    Torrent * t = (Torrent *) vt;
812    const tr_peermsgs_event * e = (const tr_peermsgs_event *) vevent;
813
814    torrentLock( t );
815
816    switch( e->eventType )
817    {
818        case TR_PEERMSG_NEED_REQ:
819            if( t->refillTimer == NULL )
820                t->refillTimer = tr_timerNew( t->manager->handle,
821                                              refillPulse, t,
822                                              REFILL_PERIOD_MSEC );
823            break;
824
825        case TR_PEERMSG_CANCEL:
826            tr_bitfieldRem( t->requested, _tr_block( t->tor, e->pieceIndex, e->offset ) );
827            break;
828
829        case TR_PEERMSG_CLIENT_HAVE:
830            broadcastClientHave( t, e->pieceIndex );
831            tr_torrentRecheckCompleteness( t->tor );
832            break;
833
834        case TR_PEERMSG_PEER_PROGRESS: {
835            struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
836            const int peerIsSeed = e->progress >= 1.0;
837            if( peerIsSeed ) {
838                tordbg( t, "marking peer %s as a seed", tr_peerIoAddrStr(&atom->addr,atom->port) );
839                atom->flags |= ADDED_F_SEED_FLAG;
840            } else {
841                tordbg( t, "marking peer %s as a non-seed", tr_peerIoAddrStr(&atom->addr,atom->port) );
842                atom->flags &= ~ADDED_F_SEED_FLAG;
843            } break;
844        }
845
846        case TR_PEERMSG_CLIENT_BLOCK:
847            broadcastGotBlock( t, e->pieceIndex, e->offset, e->length );
848            break;
849
850        case TR_PEERMSG_GOT_ERROR:
851            peer->doPurge = 1;
852            break;
853
854        default:
855            assert(0);
856    }
857
858    torrentUnlock( t );
859}
860
861static void
862ensureAtomExists( Torrent * t, const struct in_addr * addr, uint16_t port, uint8_t flags, uint8_t from )
863{
864    if( getExistingAtom( t, addr ) == NULL )
865    {
866        struct peer_atom * a;
867        a = tr_new0( struct peer_atom, 1 );
868        a->addr = *addr;
869        a->port = port;
870        a->flags = flags;
871        a->from = from;
872        tordbg( t, "got a new atom: %s", tr_peerIoAddrStr(&a->addr,a->port) );
873        tr_ptrArrayInsertSorted( t->pool, a, comparePeerAtoms );
874    }
875}
876
877/* FIXME: this is kind of a mess. */
878static void
879myHandshakeDoneCB( tr_handshake    * handshake,
880                   tr_peerIo       * io,
881                   int               isConnected,
882                   const uint8_t   * peer_id,
883                   void            * vmanager )
884{
885    int ok = isConnected;
886    uint16_t port;
887    const struct in_addr * addr;
888    tr_peerMgr * manager = (tr_peerMgr*) vmanager;
889    Torrent * t;
890    tr_handshake * ours;
891
892    assert( io != NULL );
893    assert( isConnected==0 || isConnected==1 );
894
895    t = tr_peerIoHasTorrentHash( io )
896        ? getExistingTorrent( manager, tr_peerIoGetTorrentHash( io ) )
897        : NULL;
898
899    if( tr_peerIoIsIncoming ( io ) )
900        ours = tr_ptrArrayRemoveSorted( manager->incomingHandshakes,
901                                        handshake, handshakeCompare );
902    else if( t != NULL )
903        ours = tr_ptrArrayRemoveSorted( t->outgoingHandshakes,
904                                        handshake, handshakeCompare );
905    else
906        ours = handshake;
907
908    assert( ours != NULL );
909    assert( ours == handshake );
910
911    if( t != NULL )
912        torrentLock( t );
913
914    addr = tr_peerIoGetAddress( io, &port );
915
916    if( !ok || !t || !t->isRunning )
917    {
918        if( t ) {
919            struct peer_atom * atom = getExistingAtom( t, addr );
920            if( atom )
921                ++atom->numFails;
922        }
923
924        tr_peerIoFree( io );
925    }
926    else /* looking good */
927    {
928        struct peer_atom * atom;
929        ensureAtomExists( t, addr, port, 0, TR_PEER_FROM_INCOMING );
930        atom = getExistingAtom( t, addr );
931
932        if( atom->myflags & MYFLAG_BANNED )
933        {
934            tordbg( t, "banned peer %s tried to reconnect", tr_peerIoAddrStr(&atom->addr,atom->port) );
935            tr_peerIoFree( io );
936        }
937        else
938        {
939            tr_peer * peer = getExistingPeer( t, addr );
940
941            if( peer != NULL ) /* we already have this peer */
942            {
943                tr_peerIoFree( io );
944            }
945            else if( tr_ptrArraySize( t->peers ) >= MAX_CONNECTED_PEERS_PER_TORRENT )
946            {
947                tr_peerIoFree( io );
948            }
949            else
950            {
951                peer = getPeer( t, addr );
952                tr_free( peer->client );
953                peer->client = peer_id ? tr_clientForId( peer_id ) : NULL;
954                peer->port = port;
955                peer->io = io;
956                peer->msgs = tr_peerMsgsNew( t->tor, peer, msgsCallbackFunc, t, &peer->msgsTag );
957                atom->time = time( NULL );
958            }
959        }
960    }
961
962    if( t != NULL )
963        torrentUnlock( t );
964}
965
966void
967tr_peerMgrAddIncoming( tr_peerMgr      * manager,
968                       struct in_addr  * addr,
969                       uint16_t          port,
970                       int               socket )
971{
972    managerLock( manager );
973
974    if( getExistingHandshake( manager->incomingHandshakes, addr ) )
975    {
976        tr_netClose( socket );
977    }
978    else /* we don't have a connetion to them yet... */
979    {
980        tr_peerIo * io;
981        tr_handshake * handshake;
982
983        tordbg( NULL, "Got an INCOMING connection with %s", tr_peerIoAddrStr( addr, port ) );
984
985        io = tr_peerIoNewIncoming( manager->handle, addr, port, socket );
986
987        handshake = tr_handshakeNew( io,
988                                     manager->handle->encryptionMode,
989                                     myHandshakeDoneCB,
990                                     manager );
991
992        tr_ptrArrayInsertSorted( manager->incomingHandshakes, handshake, handshakeCompare );
993    }
994
995    managerUnlock( manager );
996}
997
998void
999tr_peerMgrAddPex( tr_peerMgr     * manager,
1000                  const uint8_t  * torrentHash,
1001                  uint8_t          from,
1002                  const tr_pex   * pex,
1003                  int              pexCount )
1004{
1005    Torrent * t;
1006    const tr_pex * end;
1007
1008    managerLock( manager );
1009
1010    t = getExistingTorrent( manager, torrentHash );
1011    for( end=pex+pexCount; pex!=end; ++pex )
1012        ensureAtomExists( t, &pex->in_addr, pex->port, pex->flags, from );
1013
1014    managerUnlock( manager );
1015}
1016
1017void
1018tr_peerMgrAddPeers( tr_peerMgr    * manager,
1019                    const uint8_t * torrentHash,
1020                    uint8_t         from,
1021                    const uint8_t * peerCompact,
1022                    int             peerCount )
1023{
1024    int i;
1025    const uint8_t * walk = peerCompact;
1026    Torrent * t;
1027
1028    managerLock( manager );
1029
1030    t = getExistingTorrent( manager, torrentHash );
1031    for( i=0; t!=NULL && i<peerCount; ++i )
1032    {
1033        struct in_addr addr;
1034        uint16_t port;
1035        memcpy( &addr, walk, 4 ); walk += 4;
1036        memcpy( &port, walk, 2 ); walk += 2;
1037        ensureAtomExists( t, &addr, port, 0, from );
1038    }
1039
1040    managerUnlock( manager );
1041}
1042
1043/**
1044***
1045**/
1046
1047void
1048tr_peerMgrSetBlame( tr_peerMgr     * manager,
1049                    const uint8_t  * torrentHash,
1050                    int              pieceIndex,
1051                    int              success )
1052{
1053    if( !success )
1054    {
1055        int peerCount, i;
1056        Torrent * t = getExistingTorrent( manager, torrentHash );
1057        tr_peer ** peers;
1058
1059        assert( torrentIsLocked( t ) );
1060
1061        peers = (tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
1062        for( i=0; i<peerCount; ++i )
1063        {
1064            struct peer_atom * atom;
1065            tr_peer * peer;
1066
1067            peer = peers[i];
1068            if( !tr_bitfieldHas( peer->blame, pieceIndex ) )
1069                continue;
1070
1071            ++peer->strikes;
1072            tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
1073                       tr_peerIoAddrStr(&peer->in_addr,peer->port),
1074                       pieceIndex, (int)peer->strikes );
1075            if( peer->strikes < MAX_BAD_PIECES_PER_PEER )
1076                continue;
1077
1078            atom = getExistingAtom( t, &peer->in_addr );
1079            atom->myflags |= MYFLAG_BANNED;
1080            peer->doPurge = 1;
1081            tordbg( t, "banning peer %s due to corrupt data", tr_peerIoAddrStr(&atom->addr,atom->port) );
1082        }
1083    }
1084}
1085
1086int
1087tr_pexCompare( const void * va, const void * vb )
1088{
1089    const tr_pex * a = (const tr_pex *) va;
1090    const tr_pex * b = (const tr_pex *) vb;
1091    int i = memcmp( &a->in_addr, &b->in_addr, sizeof(struct in_addr) );
1092    if( i ) return i;
1093    if( a->port < b->port ) return -1;
1094    if( a->port > b->port ) return 1;
1095    return 0;
1096}
1097
1098int tr_pexCompare( const void * a, const void * b );
1099
1100static int
1101peerPrefersCrypto( const tr_peer * peer )
1102{
1103    if( peer->encryption_preference == ENCRYPTION_PREFERENCE_YES )
1104        return TRUE;
1105
1106    if( peer->encryption_preference == ENCRYPTION_PREFERENCE_NO )
1107        return FALSE;
1108
1109    return tr_peerIoIsEncrypted( peer->io );
1110};
1111
1112int
1113tr_peerMgrGetPeers( tr_peerMgr      * manager,
1114                    const uint8_t   * torrentHash,
1115                    tr_pex         ** setme_pex )
1116{
1117    const Torrent * t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1118    int i, peerCount;
1119    const tr_peer ** peers;
1120    tr_pex * pex;
1121    tr_pex * walk;
1122
1123    torrentLock( (Torrent*)t );
1124
1125    peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
1126    pex = walk = tr_new( tr_pex, peerCount );
1127
1128    for( i=0; i<peerCount; ++i, ++walk )
1129    {
1130        const tr_peer * peer = peers[i];
1131
1132        walk->in_addr = peer->in_addr;
1133
1134        walk->port = peer->port;
1135
1136        walk->flags = 0;
1137        if( peerPrefersCrypto(peer) )  walk->flags |= ADDED_F_ENCRYPTION_FLAG;
1138        if( peer->progress >= 1.0 )    walk->flags |= ADDED_F_SEED_FLAG;
1139    }
1140
1141    assert( ( walk - pex ) == peerCount );
1142    qsort( pex, peerCount, sizeof(tr_pex), tr_pexCompare );
1143    *setme_pex = pex;
1144
1145    torrentUnlock( (Torrent*)t );
1146
1147    return peerCount;
1148}
1149
1150static int reconnectPulse( void * vtorrent );
1151static int rechokePulse( void * vtorrent );
1152
1153void
1154tr_peerMgrStartTorrent( tr_peerMgr     * manager,
1155                        const uint8_t  * torrentHash )
1156{
1157    Torrent * t;
1158
1159    managerLock( manager );
1160
1161    t = getExistingTorrent( manager, torrentHash );
1162
1163    assert( t != NULL );
1164    assert( ( t->isRunning != 0 ) == ( t->reconnectTimer != NULL ) );
1165    assert( ( t->isRunning != 0 ) == ( t->rechokeTimer != NULL ) );
1166
1167    if( !t->isRunning )
1168    {
1169        t->isRunning = 1;
1170
1171        t->reconnectTimer = tr_timerNew( t->manager->handle,
1172                                         reconnectPulse, t,
1173                                         RECONNECT_PERIOD_MSEC );
1174
1175        t->rechokeTimer = tr_timerNew( t->manager->handle,
1176                                       rechokePulse, t,
1177                                       RECHOKE_PERIOD_MSEC );
1178
1179        reconnectPulse( t );
1180
1181        rechokePulse( t );
1182    }
1183
1184    managerUnlock( manager );
1185}
1186
1187static void
1188stopTorrent( Torrent * t )
1189{
1190    assert( torrentIsLocked( t ) );
1191
1192    t->isRunning = 0;
1193    tr_timerFree( &t->rechokeTimer );
1194    tr_timerFree( &t->reconnectTimer );
1195
1196    /* disconnect the peers. */
1197    tr_ptrArrayForeach( t->peers, (PtrArrayForeachFunc)peerDestructor );
1198    tr_ptrArrayClear( t->peers );
1199
1200    /* disconnect the handshakes.  handshakeAbort calls handshakeDoneCB(),
1201     * which removes the handshake from t->outgoingHandshakes... */
1202    while( !tr_ptrArrayEmpty( t->outgoingHandshakes ) )
1203        tr_handshakeAbort( tr_ptrArrayNth( t->outgoingHandshakes, 0 ) );
1204}
1205void
1206tr_peerMgrStopTorrent( tr_peerMgr     * manager,
1207                       const uint8_t  * torrentHash)
1208{
1209    managerLock( manager );
1210
1211    stopTorrent( getExistingTorrent( manager, torrentHash ) );
1212
1213    managerUnlock( manager );
1214}
1215
1216void
1217tr_peerMgrAddTorrent( tr_peerMgr * manager,
1218                      tr_torrent * tor )
1219{
1220    Torrent * t;
1221
1222    managerLock( manager );
1223
1224    assert( tor != NULL );
1225    assert( getExistingTorrent( manager, tor->info.hash ) == NULL );
1226
1227    t = torrentConstructor( manager, tor );
1228    tr_ptrArrayInsertSorted( manager->torrents, t, torrentCompare );
1229
1230    managerUnlock( manager );
1231}
1232
1233void
1234tr_peerMgrRemoveTorrent( tr_peerMgr     * manager,
1235                         const uint8_t  * torrentHash )
1236{
1237    Torrent * t;
1238
1239    managerLock( manager );
1240
1241    t = getExistingTorrent( manager, torrentHash );
1242    assert( t != NULL );
1243    stopTorrent( t );
1244    tr_ptrArrayRemoveSorted( manager->torrents, t, torrentCompare );
1245    torrentDestructor( t );
1246
1247    managerUnlock( manager );
1248}
1249
1250void
1251tr_peerMgrTorrentAvailability( const tr_peerMgr * manager,
1252                               const uint8_t    * torrentHash,
1253                               int8_t           * tab,
1254                               int                tabCount )
1255{
1256    int i;
1257    const Torrent * t;
1258    const tr_torrent * tor;
1259    float interval;
1260
1261    managerLock( (tr_peerMgr*)manager );
1262
1263    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1264    tor = t->tor;
1265    interval = tor->info.pieceCount / (float)tabCount;
1266
1267    memset( tab, 0, tabCount );
1268
1269    for( i=0; i<tabCount; ++i )
1270    {
1271        const int piece = i * interval;
1272
1273        if( tor == NULL )
1274            tab[i] = 0;
1275        else if( tr_cpPieceIsComplete( tor->completion, piece ) )
1276            tab[i] = -1;
1277        else {
1278            int j, peerCount;
1279            const tr_peer ** peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &peerCount );
1280            for( j=0; j<peerCount; ++j )
1281                if( tr_bitfieldHas( peers[j]->have, i ) )
1282                    ++tab[i];
1283        }
1284    }
1285
1286    managerUnlock( (tr_peerMgr*)manager );
1287}
1288
1289/* Returns the pieces that we and/or a connected peer has */
1290tr_bitfield*
1291tr_peerMgrGetAvailable( const tr_peerMgr * manager,
1292                        const uint8_t    * torrentHash )
1293{
1294    int i, size;
1295    const Torrent * t;
1296    const tr_peer ** peers;
1297    tr_bitfield * pieces;
1298
1299    managerLock( (tr_peerMgr*)manager );
1300
1301    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1302    peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &size );
1303    pieces = tr_bitfieldDup( tr_cpPieceBitfield( t->tor->completion ) );
1304    for( i=0; i<size; ++i )
1305        if( peers[i]->io != NULL )
1306            tr_bitfieldAnd( pieces, peers[i]->have );
1307
1308    managerUnlock( (tr_peerMgr*)manager );
1309    return pieces;
1310}
1311
1312int
1313tr_peerMgrHasConnections( const tr_peerMgr * manager,
1314                          const uint8_t    * torrentHash )
1315{
1316    int ret;
1317    const Torrent * t;
1318    managerLock( (tr_peerMgr*)manager );
1319
1320    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1321    ret = t && tr_ptrArraySize( t->peers );
1322
1323    managerUnlock( (tr_peerMgr*)manager );
1324    return ret;
1325}
1326
1327void
1328tr_peerMgrTorrentStats( const tr_peerMgr * manager,
1329                        const uint8_t    * torrentHash,
1330                        int              * setmePeersKnown,
1331                        int              * setmePeersConnected,
1332                        int              * setmePeersSendingToUs,
1333                        int              * setmePeersGettingFromUs,
1334                        int              * setmePeersFrom )
1335{
1336    int i, size;
1337    const Torrent * t;
1338    const tr_peer ** peers;
1339
1340    managerLock( (tr_peerMgr*)manager );
1341
1342    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1343    peers = (const tr_peer **) tr_ptrArrayPeek( t->peers, &size );
1344
1345    *setmePeersKnown          = tr_ptrArraySize( t->pool );
1346    *setmePeersConnected      = 0;
1347    *setmePeersSendingToUs    = 0;
1348    *setmePeersGettingFromUs  = 0;
1349
1350    for( i=0; i<TR_PEER_FROM__MAX; ++i )
1351        setmePeersFrom[i] = 0;
1352
1353    for( i=0; i<size; ++i )
1354    {
1355        const tr_peer * peer = peers[i];
1356        const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
1357
1358        if( peer->io == NULL ) /* not connected */
1359            continue;
1360
1361        ++*setmePeersConnected;
1362
1363        ++setmePeersFrom[atom->from];
1364
1365        if( peer->rateToPeer > 0.01 )
1366            ++*setmePeersGettingFromUs;
1367
1368        if( peer->rateToClient > 0.01 )
1369            ++*setmePeersSendingToUs;
1370    }
1371
1372    managerUnlock( (tr_peerMgr*)manager );
1373}
1374
1375struct tr_peer_stat *
1376tr_peerMgrPeerStats( const tr_peerMgr  * manager,
1377                     const uint8_t     * torrentHash,
1378                     int               * setmeCount UNUSED )
1379{
1380    int i, size;
1381    const Torrent * t;
1382    tr_peer ** peers;
1383    tr_peer_stat * ret;
1384
1385    assert( manager != NULL );
1386    managerLock( (tr_peerMgr*)manager );
1387
1388    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
1389    peers = getConnectedPeers( (Torrent*)t, &size );
1390    ret = tr_new0( tr_peer_stat, size );
1391
1392    for( i=0; i<size; ++i )
1393    {
1394        const tr_peer * peer = peers[i];
1395        const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
1396        tr_peer_stat * stat = ret + i;
1397
1398        tr_netNtop( &peer->in_addr, stat->addr, sizeof(stat->addr) );
1399        stat->port             = peer->port;
1400        stat->from             = atom->from;
1401        stat->client           = tr_strdup( peer->client ? peer->client : "" );
1402        stat->progress         = peer->progress;
1403        stat->isEncrypted      = tr_peerIoIsEncrypted( peer->io ) ? 1 : 0;
1404        stat->uploadToRate     = peer->rateToPeer;
1405        stat->downloadFromRate = peer->rateToClient;
1406        stat->isDownloading    = stat->uploadToRate > 0.01;
1407        stat->isUploading      = stat->downloadFromRate > 0.01;
1408    }
1409
1410    *setmeCount = size;
1411    tr_free( peers );
1412
1413    managerUnlock( (tr_peerMgr*)manager );
1414    return ret;
1415}
1416
1417/**
1418***
1419**/
1420
1421struct ChokeData
1422{
1423    tr_peer * peer;
1424    float rate;
1425    int randomKey;
1426    int preferred;
1427    int doUnchoke;
1428};
1429
1430static int
1431compareChoke( const void * va, const void * vb )
1432{
1433    const struct ChokeData * a = va;
1434    const struct ChokeData * b = vb;
1435
1436    if( a->preferred != b->preferred )
1437        return a->preferred ? -1 : 1;
1438
1439    if( a->preferred )
1440    {
1441        if( a->rate > b->rate ) return -1;
1442        if( a->rate < b->rate ) return 1;
1443        return 0;
1444    }
1445    else
1446    {
1447        return a->randomKey - b->randomKey;
1448    }
1449}
1450
1451static int
1452clientIsSnubbedBy( const tr_peer * peer )
1453{
1454    assert( peer != NULL );
1455
1456    return peer->peerSentPieceDataAt < (time(NULL) - SNUBBED_SEC);
1457}
1458
1459/**
1460***
1461**/
1462
1463static double
1464getWeightedThroughput( const tr_peer * peer )
1465{
1466    return ( 3 * peer->rateToPeer )
1467         + ( 1 * peer->rateToClient );
1468}
1469
1470static void
1471rechoke( Torrent * t )
1472{
1473    int i, peerCount, size=0, unchoked=0;
1474    const time_t fibrillationTime = time(NULL) - MIN_CHOKE_PERIOD_SEC;
1475    tr_peer ** peers = getConnectedPeers( t, &peerCount );
1476    struct ChokeData * choke = tr_new0( struct ChokeData, peerCount );
1477
1478    assert( torrentIsLocked( t ) );
1479   
1480    /* sort the peers by preference and rate */
1481    for( i=0; i<peerCount; ++i )
1482    {
1483        tr_peer * peer = peers[i];
1484        struct ChokeData * node;
1485        if( peer->chokeChangedAt > fibrillationTime )
1486            continue;
1487
1488        node = &choke[size++];
1489        node->peer = peer;
1490        node->preferred = peer->peerIsInterested && !clientIsSnubbedBy(peer);
1491        node->randomKey = tr_rand( INT_MAX );
1492        node->rate = getWeightedThroughput( peer );
1493    }
1494
1495    qsort( choke, size, sizeof(struct ChokeData), compareChoke );
1496
1497    for( i=0; i<size && i<NUM_UNCHOKED_PEERS_PER_TORRENT; ++i ) {
1498        choke[i].doUnchoke = 1;
1499        ++unchoked;
1500    }
1501
1502    for( ; i<size; ++i ) {
1503        choke[i].doUnchoke = 1;
1504        ++unchoked;
1505        if( choke[i].peer->peerIsInterested )
1506            break;
1507    }
1508
1509    for( i=0; i<size; ++i )
1510        tr_peerMsgsSetChoke( choke[i].peer->msgs, !choke[i].doUnchoke );
1511
1512    /* cleanup */
1513    tr_free( choke );
1514    tr_free( peers );
1515}
1516
1517static int
1518rechokePulse( void * vtorrent )
1519{
1520    Torrent * t = vtorrent;
1521    torrentLock( t );
1522    rechoke( t );
1523    torrentUnlock( t );
1524    return TRUE;
1525}
1526
1527/***
1528****
1529****  Life and Death
1530****
1531***/
1532
1533static int
1534shouldPeerBeClosed( const Torrent * t, const tr_peer * peer, int peerCount )
1535{
1536    const tr_torrent * tor = t->tor;
1537    const time_t now = time( NULL );
1538    const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
1539
1540    /* if it's marked for purging, close it */
1541    if( peer->doPurge ) {
1542        tordbg( t, "purging peer %s because its doPurge flag is set", tr_peerIoAddrStr(&atom->addr,atom->port) );
1543        return TRUE;
1544    }
1545
1546    /* if we're both seeds and it's been long enough for a pex exchange, close it */
1547    if( 1 ) {
1548        const int clientIsSeed = tr_torrentIsSeed( tor );
1549        const int peerIsSeed = atom->flags & ADDED_F_SEED_FLAG;
1550        if( peerIsSeed && clientIsSeed && ( !tr_torrentIsPexEnabled(tor) || (now-atom->time>=30) ) ) {
1551            tordbg( t, "purging peer %s because we're both seeds", tr_peerIoAddrStr(&atom->addr,atom->port) );
1552            return TRUE;
1553        }
1554    }
1555
1556    /* disconnect if it's been too long since piece data has been transferred.
1557     * this is on a sliding scale based on number of available peers... */
1558    if( 1 ) {
1559        const int relaxStrictnessIfFewerThanN = (int)((MAX_CONNECTED_PEERS_PER_TORRENT * 0.9) + 0.5);
1560        /* if we have >= relaxIfFewerThan, strictness is 100%.
1561         * if we have zero connections, strictness is 0% */
1562        const double strictness = peerCount >= relaxStrictnessIfFewerThanN
1563            ? 1.0
1564            : peerCount / (double)relaxStrictnessIfFewerThanN;
1565        const int lo = MIN_UPLOAD_IDLE_SECS;
1566        const int hi = MAX_UPLOAD_IDLE_SECS;
1567        const int limit = lo + ((hi-lo) * strictness);
1568        const time_t then = peer->pieceDataActivityDate;
1569        const int idleTime = then ? (now-then) : 0;
1570        if( idleTime > limit ) {
1571            tordbg( t, "purging peer %s because it's been %d secs since we shared anything",
1572                       tr_peerIoAddrStr(&atom->addr,atom->port), idleTime );
1573            return TRUE;
1574        }
1575    }
1576
1577    return FALSE;
1578}
1579
1580static tr_peer **
1581getPeersToClose( Torrent * t, int * setmeSize )
1582{
1583    int i, peerCount, outsize;
1584    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek( t->peers, &peerCount );
1585    struct tr_peer ** ret = tr_new( tr_peer*, peerCount );
1586
1587    assert( torrentIsLocked( t ) );
1588
1589    for( i=outsize=0; i<peerCount; ++i )
1590        if( shouldPeerBeClosed( t, peers[i], peerCount ) )
1591            ret[outsize++] = peers[i];
1592
1593    *setmeSize = outsize;
1594    return ret;
1595}
1596
1597static int
1598compareCandidates( const void * va, const void * vb )
1599{
1600    const struct peer_atom * a = * (const struct peer_atom**) va;
1601    const struct peer_atom * b = * (const struct peer_atom**) vb;
1602    int i;
1603
1604    if(( i = tr_compareUint16( a->numFails, b->numFails )))
1605        return i;
1606
1607    if( a->time != b->time )
1608        return a->time < b->time ? -1 : 1;
1609
1610    return 0;
1611}
1612
1613static struct peer_atom **
1614getPeerCandidates( Torrent * t, int * setmeSize )
1615{
1616    int i, atomCount, retCount;
1617    struct peer_atom ** atoms;
1618    struct peer_atom ** ret;
1619    const time_t now = time( NULL );
1620    const int seed = tr_torrentIsSeed( t->tor );
1621
1622    assert( torrentIsLocked( t ) );
1623
1624    atoms = (struct peer_atom**) tr_ptrArrayPeek( t->pool, &atomCount );
1625    ret = tr_new( struct peer_atom*, atomCount );
1626    for( i=retCount=0; i<atomCount; ++i )
1627    {
1628        int wait, minWait, maxWait;
1629        struct peer_atom * atom = atoms[i];
1630
1631        /* peer fed us too much bad data ... we only keep it around
1632         * now to weed it out in case someone sends it to us via pex */
1633        if( atom->myflags & MYFLAG_BANNED ) {
1634            tordbg( t, "RECONNECT peer %d (%s) is banned...",
1635                    i, tr_peerIoAddrStr(&atom->addr,atom->port) );
1636            continue;
1637        }
1638
1639        /* we don't need two connections to the same peer... */
1640        if( peerIsInUse( t, &atom->addr ) ) {
1641            tordbg( t, "RECONNECT peer %d (%s) is in use..",
1642                    i, tr_peerIoAddrStr(&atom->addr,atom->port) );
1643            continue;
1644        }
1645
1646        /* no need to connect if we're both seeds... */
1647        if( seed && (atom->flags & ADDED_F_SEED_FLAG) ) {
1648            tordbg( t, "RECONNECT peer %d (%s) is a seed and so are we..",
1649                    i, tr_peerIoAddrStr(&atom->addr,atom->port) );
1650            continue;
1651        }
1652
1653        /* we're wasting our time trying to connect to this bozo. */
1654        if( atom->numFails > 10 ) {
1655            tordbg( t, "RECONNECT peer %d (%s) gives us nothing but failure.",
1656                    i, tr_peerIoAddrStr(&atom->addr,atom->port) );
1657            continue;
1658        }
1659
1660        /* if we used this peer recently, give someone else a turn */
1661        minWait = 10; /* ten seconds */
1662        maxWait = (60 * 20); /* twenty minutes */
1663        wait = atom->numFails * 30; /* add 15 secs to the wait interval for each consecutive failure*/
1664        if( wait < minWait ) wait = minWait;
1665        if( wait > maxWait ) wait = maxWait;
1666        if( ( now - atom->time ) < wait ) {
1667            tordbg( t, "RECONNECT peer %d (%s) is in its grace period of %d seconds..",
1668                    i, tr_peerIoAddrStr(&atom->addr,atom->port), wait );
1669            continue;
1670        }
1671
1672        ret[retCount++] = atom;
1673    }
1674
1675    qsort( ret, retCount, sizeof(struct peer_atom*), compareCandidates );
1676    *setmeSize = retCount;
1677    return ret;
1678}
1679
1680static int
1681reconnectPulse( void * vtorrent )
1682{
1683    Torrent * t = vtorrent;
1684
1685    torrentLock( t );
1686
1687    if( !t->isRunning )
1688    {
1689        removeAllPeers( t );
1690    }
1691    else
1692    {
1693        int i, nCandidates, nBad, nAdd;
1694        struct peer_atom ** candidates = getPeerCandidates( t, &nCandidates );
1695        struct tr_peer ** connections = getPeersToClose( t, &nBad );
1696        const int peerCount = tr_ptrArraySize( t->peers );
1697
1698        if( nBad || nCandidates )
1699            tordbg( t, "reconnect pulse for [%s]: %d bad connections, "
1700                       "%d connection candidates, %d atoms, max per pulse is %d",
1701                       t->tor->info.name, nBad, nCandidates,
1702                       tr_ptrArraySize(t->pool),
1703                       (int)MAX_RECONNECTIONS_PER_PULSE );
1704
1705        /* disconnect some peers.
1706           if we got transferred piece data, then they might be good peers,
1707           so reset their `numFails' weight to zero.  otherwise we connected
1708           to them fruitlessly, so mark it as another fail */
1709        for( i=0; i<nBad; ++i ) {
1710            tr_peer * peer = connections[i];
1711            struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
1712            if( peer->pieceDataActivityDate )
1713                atom->numFails = 0;
1714            else
1715                ++atom->numFails;
1716            removePeer( t, peer );
1717        }
1718
1719        /* add some new ones */
1720        nAdd = !peerCount ? MAX_CONNECTED_PEERS_PER_TORRENT
1721                          : MAX_RECONNECTIONS_PER_PULSE;
1722        for( i=0; i<nAdd && i<nCandidates && i<MAX_RECONNECTIONS_PER_PULSE; ++i )
1723        {
1724            tr_peerMgr * mgr = t->manager;
1725            struct peer_atom * atom = candidates[i];
1726            tr_peerIo * io;
1727            tr_handshake * handshake;
1728
1729            tordbg( t, "Starting an OUTGOING connection with %s",
1730                       tr_peerIoAddrStr( &atom->addr, atom->port ) );
1731
1732            io = tr_peerIoNewOutgoing( mgr->handle, &atom->addr, atom->port, t->hash );
1733
1734            handshake = tr_handshakeNew( io,
1735                                         mgr->handle->encryptionMode,
1736                                         myHandshakeDoneCB,
1737                                         mgr );
1738
1739            assert( tr_peerIoGetTorrentHash( io ) != NULL );
1740
1741            tr_ptrArrayInsertSorted( t->outgoingHandshakes, handshake, handshakeCompare );
1742
1743            atom->time = time( NULL );
1744        }
1745
1746        /* cleanup */
1747        tr_free( connections );
1748        tr_free( candidates );
1749    }
1750
1751    torrentUnlock( t );
1752    return TRUE;
1753}
Note: See TracBrowser for help on using the repository browser.