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

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

tweak the debugging messages a bit.

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