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

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

(0.9x) fix 0.90 socket leak.

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