Changeset 2954


Ignore:
Timestamp:
Aug 31, 2007, 8:43:39 PM (15 years ago)
Author:
charles
Message:

add peer-mgr to act as the hub between { handshake, peer io, choking, incoming peers }

Location:
branches/encryption
Files:
3 added
19 edited

Legend:

Unmodified
Added
Removed
  • branches/encryption/libtransmission/Makefile.am

    r2953 r2954  
    1010    basename.c \
    1111    bencode.c \
    12     choking.c \
    1312    clients.c \
    1413    completion.c \
     
    2726    net.c \
    2827    p.c \
    29     peer.c \
    3028    peer-io.c \
     29    peer-mgr.c \
    3130    platform.c \
    3231    ptrarray.c \
     
    4948    bsdqueue.h \
    5049    bsdtree.h \
    51     choking.h \
    5250    clients.h \
    5351    crypto.h \
     
    6664    net.h \
    6765    p.h \
    68     peeraz.h \
    69     peerext.h \
    70     peer.h \
    71     peermessages.h \
    72     peerparse.h \
    73     peertree.h \
    74     peerutils.h \
     66    peer-mgr.h \
    7567    peer-io.h \
    7668    platform.h \
  • branches/encryption/libtransmission/fastresume.c

    r2941 r2954  
    5656#include "completion.h"
    5757#include "fastresume.h"
    58 #include "peer.h"
     58#include "peer-mgr.h"
    5959#include "platform.h"
    6060#include "utils.h"
     
    294294    {
    295295        /* Write IPs and ports of connectable peers, if any */
    296         int size;
    297296        uint8_t * buf = NULL;
    298         if( ( size = tr_peerGetConnectable( tor, &buf ) ) > 0 )
     297        const int size = tr_peerMgrGetPeers( tor->handle->peerMgr,
     298                                             tor->info.hash, &buf );
     299        if( size > 0 )
    299300        {
    300301            fastResumeWriteData( FR_ID_PEERS, buf, size, 1, file );
     
    640641                if( !( TR_FLAG_PRIVATE & tor->info.flags ) )
    641642                {
    642                     int used;
    643643                    uint8_t * buf = malloc( len );
    644644                    if( 1 != fread( buf, len, 1, file ) )
     
    648648                        return ret;
    649649                    }
    650                     used = tr_torrentAddCompact( tor, TR_PEER_FROM_CACHE,
    651                                                  buf, len / 6 );
    652                     tr_dbg( "found %i peers in resume file, used %i",
    653                             len / 6, used );
     650
     651                    tr_peerMgrAddPeers( tor->handle->peerMgr,
     652                                        tor->info.hash,
     653                                        TR_PEER_FROM_CACHE,
     654                                        buf, len / 6 );
     655
     656                    tr_dbg( "found %i peers in resume file", len/6 );
    654657                    free( buf );
    655658                    ret |= TR_FR_PEERS;
  • branches/encryption/libtransmission/handshake.c

    r2953 r2954  
    385385    assert( tor != NULL );
    386386    fprintf( stderr, "found the torrent; it's [%s]\n", tor->info.name );
    387     tr_peerIoSetTorrent( handshake->io, tor );
     387    tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
    388388
    389389    /* next part: ENCRYPT(VC, crypto_provide, len(PadC), */
     
    680680    /* torrent hash */
    681681    tr_peerIoReadBytes( handshake->io, inbuf, hash, sizeof(hash) );
    682     assert( !memcmp( hash, tr_peerIoGetTorrent(handshake->io)->info.hash, SHA_DIGEST_LENGTH ) );
     682    assert( !memcmp( hash, tr_peerIoGetTorrentHash(handshake->io), SHA_DIGEST_LENGTH ) );
    683683    bytesRead += sizeof(hash);
    684684
  • branches/encryption/libtransmission/inout.c

    r2949 r2954  
    2525#include "inout.h"
    2626#include "net.h"
    27 #include "peer.h"
     27#include "peer-mgr.h"
    2828#include "utils.h"
    2929
     
    302302tr_ioHash( tr_io_t * io, int pieceIndex )
    303303{
    304     int i;
    305 
    306304    tr_torrent * tor = io->tor;
    307305    const int success = !checkPiece( tor, pieceIndex );
     
    317315    }
    318316
    319     /* Assign blame or credit to peers */
    320     for( i = 0; i < tor->peerCount; ++i )
    321         tr_peerBlame( tor->peers[i], pieceIndex, success );
     317    tr_peerMgrSetBlame( tor->handle->peerMgr, tor->info.hash, pieceIndex, success );
    322318
    323319    return 0;
  • branches/encryption/libtransmission/internal.h

    r2942 r2954  
    5252void tr_trackerInfoClear( struct tr_tracker_info_s * info );
    5353
    54 struct tr_peer_s;
    55 
    5654void tr_peerIdNew ( char* buf, int buflen );
    5755
    5856void tr_torrentResetTransferStats( tr_torrent * );
    59 
    60 int tr_torrentAddCompact( tr_torrent * tor, int from,
    61                            const uint8_t * buf, int count );
    62 int tr_torrentAttachPeer( tr_torrent * tor, struct tr_peer_s * );
    6357
    6458void tr_torrentSetHasPiece( tr_torrent * tor, int pieceIndex, int has );
     
    7165void tr_torrentChangeMyPort  ( tr_torrent *, int port );
    7266
     67tr_torrent* tr_torrentFindFromHash( tr_handle *, const uint8_t * );
    7368tr_torrent* tr_torrentFindFromObfuscatedHash( tr_handle *, const uint8_t* );
    7469
     
    160155    char                       fastResumeDirty;
    161156
    162     int                        peerCount;
    163     struct tr_peer_s *         peers[TR_MAX_PEER_COUNT];
    164 
    165157    uint64_t                   downloadedCur;
    166158    uint64_t                   downloadedPrev;
     
    181173struct tr_handle
    182174{
    183     struct tr_event_handle_s * events;
     175    struct tr_event_handle  * events;
    184176
    185177    int                        torrentCount;
     
    194186    struct tr_ratecontrol    * download;
    195187
    196     struct tr_shared_s       * shared;
     188    struct tr_peerMgr        * peerMgr;
     189    struct tr_shared         * shared;
    197190
    198     tr_handle_status_t         stats[2];
     191    tr_handle_status           stats[2];
    199192    int                        statCur;
    200193
  • branches/encryption/libtransmission/p.c

    r2953 r2954  
    2828#include "list.h"
    2929#include "peer-io.h"
     30#include "peer-mgr.h"
    3031#include "ratecontrol.h"
    3132#include "timer.h"
     
    295296        const int n = sub->val.s.i / 6 ;
    296297        fprintf( stderr, "got %d peers from uT pex\n", n );
    297         tr_torrentAddCompact( peer->torrent, TR_PEER_FROM_PEX, (uint8_t*)sub->val.s.s, n );
     298        tr_peerMgrAddPeers( peer->handle->peerMgr,
     299                            peer->torrent->info.hash,
     300                            TR_PEER_FROM_PEX,
     301                            (uint8_t*)sub->val.s.s, n );
    298302    }
    299303
     
    684688
    685689void
    686 tr_peerManagerAdd( struct tr_torrent * torrent,
    687                    struct tr_peerIo  * io )
     690tr_peerWorkAdd( struct tr_torrent * torrent,
     691                struct tr_peerIo  * io )
    688692{
    689693    tr_peer * peer;
  • branches/encryption/libtransmission/p.h

    r2953 r2954  
    1717struct tr_peerIo;
    1818
    19 void tr_peerManagerAdd( struct tr_torrent  * torrent,
    20                         struct tr_peerIo   * io );
     19void tr_peerWorkAdd( struct tr_torrent  * torrent,
     20                     struct tr_peerIo   * io );
    2121
    2222#endif
  • branches/encryption/libtransmission/peer-io.c

    r2953 r2954  
    3131{
    3232    struct tr_handle * handle;
    33     struct tr_torrent * torrent;
    3433
    3534    struct in_addr in_addr;
     
    9897tr_peerIoNew( struct tr_handle  * handle,
    9998              struct in_addr    * in_addr,
    100               struct tr_torrent * torrent,
     99              const uint8_t     * torrentHash,
    101100              int                 isIncoming,
    102101              int                 socket )
     
    104103    tr_peerIo * c;
    105104    c = tr_new0( tr_peerIo, 1 );
    106     c->torrent = torrent;
    107     c->crypto = tr_cryptoNew( torrent ? torrent->info.hash : NULL, isIncoming );
     105    c->crypto = tr_cryptoNew( torrentHash, isIncoming );
    108106    c->handle = handle;
    109107    c->in_addr = *in_addr;
     
    132130                      struct in_addr    * in_addr,
    133131                      int                 port,
    134                       struct tr_torrent * torrent )
     132                      const uint8_t     * torrentHash )
    135133{
    136134    tr_peerIo * c;
     
    139137    assert( in_addr != NULL );
    140138    assert( port >= 0 );
    141     assert( torrent != NULL );
    142 
    143     c = tr_peerIoNew( handle, in_addr, torrent, 0,
     139    assert( torrentHash != NULL );
     140
     141    c = tr_peerIoNew( handle, in_addr, torrentHash, 0,
    144142                              tr_netOpenTCP( in_addr, port, 0 ) );
    145143    c->port = port;
     
    163161
    164162    return io->handle;
     163}
     164
     165const struct in_addr*
     166tr_peerIoGetAddress( const tr_peerIo * io, uint16_t * port )
     167{
     168    assert( io != NULL );
     169
     170    if( port != NULL )
     171       *port = io->port;
     172
     173    return &io->in_addr;
    165174}
    166175
     
    221230
    222231void
    223 tr_peerIoSetTorrent( tr_peerIo  * io,
    224                              struct tr_torrent  * torrent )
    225 {
    226     io->torrent = torrent;
    227 
    228     tr_cryptoSetTorrentHash( io->crypto, torrent->info.hash );
    229 }
    230 
    231 struct tr_torrent*
     232tr_peerIoSetTorrentHash( tr_peerIo     * io,
     233                         const uint8_t * hash )
     234{
     235    tr_cryptoSetTorrentHash( io->crypto, hash );
     236}
     237
     238const uint8_t*
    232239tr_peerIoGetTorrent( tr_peerIo * io )
    233240{
    234     return io->torrent;
    235 }
    236 
    237 /**
    238 ***
    239 **/
    240 
    241 void
    242 tr_peerIoSetPeersId( tr_peerIo * io,
    243                              const uint8_t    * peer_id )
     241    return tr_cryptoGetTorrentHash( io->crypto );
     242}
     243
     244/**
     245***
     246**/
     247
     248void
     249tr_peerIoSetPeersId( tr_peerIo     * io,
     250                     const uint8_t * peer_id )
    244251{
    245252    assert( io != NULL );
     
    265272
    266273void
    267 tr_peerIoSetExtension( tr_peerIo * io,
    268                                int                 extensions )
     274tr_peerIoSetExtension( tr_peerIo   * io,
     275                       int           extensions )
    269276{
    270277    assert( io != NULL );
  • branches/encryption/libtransmission/peer-io.h

    r2953 r2954  
    2323struct tr_handle;
    2424struct tr_crypto;
    25 struct tr_torrent;
    2625typedef struct tr_peerIo tr_peerIo;
    2726
     
    3534                            struct in_addr     * addr,
    3635                            int                  port,
    37                             struct tr_torrent  * torrent );
     36                            const  uint8_t     * torrentHash );
    3837
    3938tr_peerIo*
     
    6665**/
    6766
    68 struct tr_torrent*
    69       tr_peerIoGetTorrent( tr_peerIo * io );
     67const struct in_addr*
     68      tr_peerIoGetAddress( const tr_peerIo * io, uint16_t * port );
    7069
    71 void  tr_peerIoSetTorrent( tr_peerIo         * io,
    72                            struct tr_torrent * tor );
     70const uint8_t*
     71      tr_peerIoGetTorrentHash( tr_peerIo * io );
     72
     73void  tr_peerIoSetTorrentHash( tr_peerIo      * io,
     74                               const uint8_t  * hash );
    7375
    7476int   tr_peerIoReconnect( tr_peerIo * io );
  • branches/encryption/libtransmission/peerext.h

    r2941 r2954  
    327327    if( NULL != sub && TYPE_STR == sub->type && 0 == sub->val.s.i % 6 )
    328328    {
     329#if 0
    329330        used = tr_torrentAddCompact( tor, TR_PEER_FROM_PEX,
    330331                                     ( uint8_t * )sub->val.s.s,
     
    332333        peer_dbg( "GET  extended-pex, got %i peers, used %i",
    333334                  sub->val.s.i / 6, used );
     335#endif
    334336    }
    335337    else
  • branches/encryption/libtransmission/ptrarray.c

    r2851 r2954  
    2020#define GROW 32
    2121
    22 struct tr_ptrArray_s
     22struct tr_ptrArray
    2323{
    2424    void ** items;
     
    2727};
    2828
    29 tr_ptrArray_t*
     29tr_ptrArray*
    3030tr_ptrArrayNew( void )
    3131{
    32     tr_ptrArray_t * p;
     32    tr_ptrArray * p;
    3333
    34     p = tr_new( tr_ptrArray_t, 1 );
     34    p = tr_new( tr_ptrArray, 1 );
    3535    p->n_items = 0;
    3636    p->n_alloc = GROW;
     
    4141
    4242void
    43 tr_ptrArrayFree( tr_ptrArray_t * t )
     43tr_ptrArrayFree( tr_ptrArray * t )
    4444{
    4545    assert( t != NULL );
     
    5151
    5252void**
    53 tr_ptrArrayPeek( tr_ptrArray_t * t, int * size )
     53tr_ptrArrayPeek( tr_ptrArray * t, int * size )
    5454{
    5555    *size = t->n_items;
     
    5858
    5959int
    60 tr_ptrArraySize( const tr_ptrArray_t * t )
     60tr_ptrArraySize( const tr_ptrArray * t )
    6161{
    6262    return t->n_items;
     
    6464
    6565int
    66 tr_ptrArrayEmpty( const tr_ptrArray_t * t )
     66tr_ptrArrayEmpty( const tr_ptrArray * t )
    6767{
    6868    return t->n_items == 0;
     
    7070
    7171void
    72 tr_ptrArrayClear( tr_ptrArray_t * t )
     72tr_ptrArrayClear( tr_ptrArray * t )
    7373{
    7474    t->n_items = 0;
     
    7676
    7777int
    78 tr_ptrArrayInsert( tr_ptrArray_t * t, void * ptr, int pos )
     78tr_ptrArrayInsert( tr_ptrArray * t, void * ptr, int pos )
    7979{
    8080    if( pos<0 || pos>t->n_items )
     
    9696
    9797int
    98 tr_ptrArrayAppend( tr_ptrArray_t * t, void * ptr )
     98tr_ptrArrayAppend( tr_ptrArray * t, void * ptr )
    9999{
    100100    return tr_ptrArrayInsert( t, ptr, -1 );
     
    102102
    103103void
    104 tr_ptrArrayErase( tr_ptrArray_t * t, int begin, int end )
     104tr_ptrArrayErase( tr_ptrArray * t, int begin, int end )
    105105{
    106106    assert( begin >= 0 );
     
    121121
    122122int
    123 tr_ptrArrayLowerBound( const tr_ptrArray_t * t,
    124                        void                * ptr,
    125                        int                   compare( const void *,const void * ),
    126                        int                 * exact_match )
     123tr_ptrArrayLowerBound( const tr_ptrArray * t,
     124                       const void        * ptr,
     125                       int                 compare( const void *,const void * ),
     126                       int               * exact_match )
    127127{
    128128    int c = -1;
     
    155155
    156156int
    157 tr_ptrArrayInsertSorted( tr_ptrArray_t  * t,
    158                          void           * ptr,
    159                          int              compare(const void*,const void*) )
     157tr_ptrArrayInsertSorted( tr_ptrArray  * t,
     158                         void         * ptr,
     159                         int            compare(const void*,const void*) )
    160160{
    161161    const int pos = tr_ptrArrayLowerBound( t, ptr, compare, NULL );
     
    164164
    165165void*
    166 tr_ptrArrayFindSorted( tr_ptrArray_t  * t,
    167                        void           * ptr,
    168                        int              compare(const void*,const void*) )
     166tr_ptrArrayFindSorted( tr_ptrArray  * t,
     167                       const void   * ptr,
     168                       int            compare(const void*,const void*) )
    169169{
    170170    int match;
     
    174174
    175175void*
    176 tr_ptrArrayRemoveSorted( tr_ptrArray_t  * t,
    177                          void           * ptr,
    178                          int              compare(const void*,const void*) )
     176tr_ptrArrayRemoveSorted( tr_ptrArray  * t,
     177                         void         * ptr,
     178                         int            compare(const void*,const void*) )
    179179{
    180180    void * ret = NULL;
  • branches/encryption/libtransmission/ptrarray.h

    r2849 r2954  
    1717 * A simple pointer array that resizes itself dynamically.
    1818 */
    19 typedef struct tr_ptrArray_s tr_ptrArray_t;
     19typedef struct tr_ptrArray tr_ptrArray;
    2020
    21 tr_ptrArray_t * tr_ptrArrayNew         ( void );
    22 void            tr_ptrArrayFree        ( tr_ptrArray_t* );
    23 void**          tr_ptrArrayPeek        ( tr_ptrArray_t*, int * size );
    24 void**          tr_ptrArrayBase        ( tr_ptrArray_t* );
    25 void            tr_ptrArrayClear       ( tr_ptrArray_t* );
    26 int             tr_ptrArrayInsert      ( tr_ptrArray_t*, void*, int pos );
    27 int             tr_ptrArrayAppend      ( tr_ptrArray_t*, void* );
    28 void            tr_ptrArrayErase       ( tr_ptrArray_t*, int begin, int end );
    29 int             tr_ptrArraySize        ( const tr_ptrArray_t* );
    30 int             tr_ptrArrayEmpty       ( const tr_ptrArray_t* );
     21tr_ptrArray * tr_ptrArrayNew     ( void );
    3122
    32 int             tr_ptrArrayInsertSorted( tr_ptrArray_t*, void*,
    33                                          int compare(const void*,const void*) );
    34 void*           tr_ptrArrayRemoveSorted( tr_ptrArray_t*, void*,
    35                                          int compare(const void*,const void*) );
    36 void*           tr_ptrArrayFindSorted  ( tr_ptrArray_t*, void*,
    37                                          int compare(const void*,const void*) );
     23void    tr_ptrArrayFree          ( tr_ptrArray* );
     24void**  tr_ptrArrayPeek          ( tr_ptrArray*, int * size );
     25void**  tr_ptrArrayBase          ( tr_ptrArray* );
     26void    tr_ptrArrayClear         ( tr_ptrArray* );
     27int     tr_ptrArrayInsert        ( tr_ptrArray*, void*, int pos );
     28int     tr_ptrArrayAppend        ( tr_ptrArray*, void* );
     29void    tr_ptrArrayErase         ( tr_ptrArray*, int begin, int end );
     30int     tr_ptrArraySize          ( const tr_ptrArray* );
     31int     tr_ptrArrayEmpty         ( const tr_ptrArray* );
     32int     tr_ptrArrayInsertSorted  ( tr_ptrArray*, void*,
     33                                   int compare(const void*,const void*) );
     34void*   tr_ptrArrayRemoveSorted  ( tr_ptrArray*, void*,
     35                                   int compare(const void*,const void*) );
     36void*   tr_ptrArrayFindSorted    ( tr_ptrArray*, const void*,
     37                                   int compare(const void*,const void*) );
    3838
    3939#endif
  • branches/encryption/libtransmission/shared.c

    r2953 r2954  
    3737#include "peer.h"
    3838#include "peer-io.h"
     39#include "peer-mgr.h"
    3940#include "platform.h"
    4041#include "shared.h"
     
    4647#define MAX_PEER_COUNT 128
    4748
    48 struct tr_shared_s
    49 {
    50     tr_handle_t  * h;
     49struct tr_shared
     50{
     51    tr_handle  * h;
    5152    volatile int   die;
    5253    tr_thread_t  * thread;
     
    5758    int          bindPort;
    5859    int          bindSocket;
    59     int          peerCount;
    60     tr_peer_t    * peers[MAX_PEER_COUNT];
    6160
    6261    /* NAT-PMP/UPnP */
     
    7271 **********************************************************************/
    7372static void SharedLoop( void * );
    74 static void SetPublicPort( tr_shared_t *, int );
    75 static void AcceptPeers( tr_shared_t * );
    76 static void ReadPeers( tr_shared_t * );
    77 static void DispatchPeers( tr_shared_t * );
     73static void SetPublicPort( tr_shared *, int );
     74static void AcceptPeers( tr_shared * );
    7875
    7976
     
    8380 *
    8481 **********************************************************************/
    85 tr_shared_t * tr_sharedInit( tr_handle_t * h )
    86 {
    87     tr_shared_t * s = calloc( 1, sizeof( tr_shared_t ) );
     82tr_shared * tr_sharedInit( tr_handle * h )
     83{
     84    tr_shared * s = calloc( 1, sizeof( tr_shared ) );
    8885
    8986    s->h          = h;
     
    106103 *
    107104 **********************************************************************/
    108 void tr_sharedClose( tr_shared_t * s )
    109 {
    110     int ii;
    111 
     105void tr_sharedClose( tr_shared * s )
     106{
    112107    /* Stop the thread */
    113108    s->die = 1;
    114109    tr_threadJoin( s->thread );
    115110
    116     /* Clean up */
    117     for( ii = 0; ii < s->peerCount; ii++ )
    118     {
    119         tr_peerDestroy( s->peers[ii] );
    120     }
    121111    if( s->bindSocket > -1 )
    122     {
    123112        tr_netClose( s->bindSocket );
    124     }
    125113    tr_lockFree( s->lock );
    126114    tr_natpmpClose( s->natpmp );
     
    135123 *
    136124 **********************************************************************/
    137 void tr_sharedLock( tr_shared_t * s )
     125void tr_sharedLock( tr_shared * s )
    138126{
    139127    tr_lockLock( s->lock );
    140128}
    141 void tr_sharedUnlock( tr_shared_t * s )
     129void tr_sharedUnlock( tr_shared * s )
    142130{
    143131    tr_lockUnlock( s->lock );
     
    149137 *
    150138 **********************************************************************/
    151 void tr_sharedSetPort( tr_shared_t * s, int port )
     139void tr_sharedSetPort( tr_shared * s, int port )
    152140{
    153141#ifdef BEOS_NETSERVER
     
    205193 *
    206194 **********************************************************************/
    207 int tr_sharedGetPublicPort( tr_shared_t * s )
     195int tr_sharedGetPublicPort( tr_shared * s )
    208196{
    209197    return s->publicPort;
     
    215203 *
    216204 **********************************************************************/
    217 void tr_sharedTraversalEnable( tr_shared_t * s, int enable )
     205void tr_sharedTraversalEnable( tr_shared * s, int enable )
    218206{
    219207    if( enable )
     
    229217}
    230218
    231 int tr_sharedTraversalStatus( tr_shared_t * s )
     219int tr_sharedTraversalStatus( tr_shared * s )
    232220{
    233221    int statuses[] = {
     
    262250 * tr_sharedSetLimit
    263251 **********************************************************************/
    264 void tr_sharedSetLimit( tr_shared_t * s, int limit )
     252void tr_sharedSetLimit( tr_shared * s, int limit )
    265253{
    266254    tr_chokingSetLimit( s->choking, limit );
     
    277265static void SharedLoop( void * _s )
    278266{
    279     tr_shared_t * s = _s;
     267    tr_shared * s = _s;
    280268    uint64_t      date1, date2, lastchoke = 0;
    281269    int           newPort;
     
    298286        /* Handle incoming connections */
    299287        AcceptPeers( s );
    300         ReadPeers( s );
    301         DispatchPeers( s );
    302288
    303289        /* Update choking every second */
     
    326312 * SetPublicPort
    327313 **********************************************************************/
    328 static void SetPublicPort( tr_shared_t * s, int port )
    329 {
    330     tr_handle_t * h = s->h;
     314static void SetPublicPort( tr_shared * s, int port )
     315{
     316    tr_handle * h = s->h;
    331317    tr_torrent * tor;
    332318
     
    337323}
    338324
     325/***********************************************************************
     326 * AcceptPeers
     327 ***********************************************************************
     328 * Check incoming connections and add the peers to our local list
     329 **********************************************************************/
    339330
    340331static void
    341 myHandshakeDoneCB( struct tr_peerIo * c, int isConnected, void * unused UNUSED )
    342 {
    343     if( isConnected )
    344         fprintf( stderr, "FIXME: add some way to push this connection to the tor\n" );
    345     else
    346         tr_peerIoFree( c );
    347 }
    348 
    349 /***********************************************************************
    350  * AcceptPeers
    351  ***********************************************************************
    352  * Check incoming connections and add the peers to our local list
    353  **********************************************************************/
    354 static void AcceptPeers( tr_shared_t * s )
    355 {
    356     int socket;
    357     struct in_addr addr;
    358 
     332AcceptPeers( tr_shared * s )
     333{
    359334    for( ;; )
    360335    {
    361         if( s->bindSocket < 0 || s->peerCount >= MAX_PEER_COUNT )
    362         {
     336        int socket;
     337        struct in_addr addr;
     338
     339        if( s->bindSocket < 0 || !tr_peerMgrIsAcceptingConnections( s->h->peerMgr ) )
    363340            break;
    364         }
    365341
    366342        socket = tr_netAccept( s->bindSocket, &addr, NULL );
    367343        if( socket < 0 )
    368         {
    369344            break;
    370         }
    371 
    372         tr_handshakeAdd( tr_peerIoNewIncoming( s->h, &addr, socket ),
    373                          HANDSHAKE_ENCRYPTION_PREFERRED,
    374                          myHandshakeDoneCB,
    375                          NULL );
    376     }
    377 }
    378 
    379 /***********************************************************************
    380  * ReadPeers
    381  ***********************************************************************
    382  * Try to read handshakes
    383  **********************************************************************/
    384 static void ReadPeers( tr_shared_t * s )
    385 {
    386     int ii;
    387 
    388     for( ii = 0; ii < s->peerCount; )
    389     {
    390         if( tr_peerRead( s->peers[ii] ) )
    391         {
    392             tr_peerDestroy( s->peers[ii] );
    393             s->peerCount--;
    394             memmove( &s->peers[ii], &s->peers[ii+1],
    395                      ( s->peerCount - ii ) * sizeof( tr_peer_t * ) );
    396             continue;
    397         }
    398         ii++;
    399     }
    400 }
    401 
    402 /***********************************************************************
    403  * DispatchPeers
    404  ***********************************************************************
    405  * If we got a handshake, try to find the torrent for this peer
    406  **********************************************************************/
    407 static void DispatchPeers( tr_shared_t * s )
    408 {
    409     tr_handle_t * h = s->h;
    410     int ii;
    411     const uint64_t now = tr_date();
    412 
    413     for( ii = 0; ii < s->peerCount; )
    414     {
    415         const uint8_t * hash = tr_peerHash( s->peers[ii] );
    416 
    417         if( !hash && now > tr_peerDate( s->peers[ii] ) + 10000 )
    418         {
    419             /* 10 seconds and no handshake, drop it */
    420             tr_peerDestroy( s->peers[ii] );
    421             goto removePeer;
    422         }
    423         if( hash )
    424         {
    425             tr_torrent * tor;
    426 
    427             for( tor = h->torrentList; tor; tor = tor->next )
    428             {
    429                 tr_torrentWriterLock( tor );
    430                 if( tor->runStatus != TR_RUN_RUNNING )
    431                 {
    432                     tr_torrentWriterUnlock( tor );
    433                     continue;
    434                 }
    435 
    436                 if( !memcmp( tor->info.hash, hash, SHA_DIGEST_LENGTH ) )
    437                 {
    438                     /* Found it! */
    439                     tr_torrentAttachPeer( tor, s->peers[ii] );
    440                     tr_torrentWriterUnlock( tor );
    441                     goto removePeer;
    442                 }
    443                 tr_torrentWriterUnlock( tor );
    444             }
    445 
    446             /* Couldn't find a torrent, we probably removed it */
    447             tr_peerDestroy( s->peers[ii] );
    448             goto removePeer;
    449         }
    450         ii++;
    451         continue;
    452 
    453 removePeer:
    454         s->peerCount--;
    455         memmove( &s->peers[ii], &s->peers[ii+1],
    456                 ( s->peerCount - ii ) * sizeof( tr_peer_t * ) );
    457     }
    458 }
    459 
     345
     346        tr_peerMgrAddIncoming( s->h->peerMgr, &addr, socket );
     347    }
     348}
  • branches/encryption/libtransmission/shared.h

    r2555 r2954  
    2828#include "transmission.h"
    2929
    30 typedef struct tr_shared_s tr_shared_t;
     30typedef struct tr_shared tr_shared;
    3131
    3232/***********************************************************************
     
    3636 * among the torrents: NAT-PMP/UPnP, incoming connections, peer choking
    3737 **********************************************************************/
    38 tr_shared_t * tr_sharedInit           ( tr_handle_t * );
    39 void          tr_sharedClose          ( tr_shared_t * );
     38tr_shared * tr_sharedInit           ( tr_handle * );
     39void        tr_sharedClose          ( tr_shared * );
    4040
    4141/***********************************************************************
     
    4545 * thread
    4646 **********************************************************************/
    47 void          tr_sharedLock           ( tr_shared_t * );
    48 void          tr_sharedUnlock         ( tr_shared_t * );
     47void          tr_sharedLock           ( tr_shared * );
     48void          tr_sharedUnlock         ( tr_shared * );
    4949
    5050/***********************************************************************
     
    5454 * should be called with the shared lock held.
    5555 **********************************************************************/
    56 void         tr_sharedSetPort         ( tr_shared_t *, int port );
    57 int          tr_sharedGetPublicPort   ( tr_shared_t * s );
     56void         tr_sharedSetPort         ( tr_shared *, int port );
     57int          tr_sharedGetPublicPort   ( tr_shared * s );
    5858
    5959/***********************************************************************
     
    6363 * be called with the shared lock held.
    6464 **********************************************************************/
    65 void         tr_sharedTraversalEnable ( tr_shared_t *, int enable );
    66 int          tr_sharedTraversalStatus ( tr_shared_t * );
     65void         tr_sharedTraversalEnable ( tr_shared *, int enable );
     66int          tr_sharedTraversalStatus ( tr_shared * );
    6767
    6868/***********************************************************************
     
    7171 *
    7272 **********************************************************************/
    73 void         tr_sharedSetLimit        ( tr_shared_t *, int limit );
     73void         tr_sharedSetLimit        ( tr_shared *, int limit );
    7474
    7575#endif
  • branches/encryption/libtransmission/torrent.c

    r2953 r2954  
    3838#include "metainfo.h"
    3939#include "net.h" /* tr_netNtop */
    40 #include "p.h"
    4140#include "peer.h"
    42 #include "peer-io.h"
     41#include "peer-mgr.h"
    4342#include "platform.h"
    4443#include "ratecontrol.h"
     
    5352
    5453tr_torrent*
     54tr_torrentFindFromHash( tr_handle      * handle,
     55                        const uint8_t  * torrentHash )
     56{
     57    tr_torrent * tor;
     58
     59    for( tor = handle->torrentList; tor; tor = tor->next )
     60        if( !memcmp( tor->info.hash, torrentHash, SHA_DIGEST_LENGTH ) )
     61            return tor;
     62
     63    return NULL;
     64}
     65
     66tr_torrent*
    5567tr_torrentFindFromObfuscatedHash( tr_handle      * handle,
    5668                                  const uint8_t  * obfuscatedTorrentHash )
     
    148160    {
    149161        case TR_TRACKER_PEERS:
    150             tr_torrentAddCompact( tor, TR_PEER_FROM_TRACKER,
    151                                   event->peerCompact, event->peerCount );
     162            tr_peerMgrAddPeers( tor->handle->peerMgr,
     163                                tor->info.hash,
     164                                TR_PEER_FROM_TRACKER,
     165                                event->peerCompact,
     166                                event->peerCount );
    152167            break;
    153168
     
    647662        if( tor->pexDisabled != disable )
    648663        {
    649             int i;
    650664            tor->pexDisabled = disable;
    651             for( i=0; i<tor->peerCount; ++i )
    652                 tr_peerSetPrivate( tor->peers[i], disable );
     665            tr_peerMgrDisablePex( tor->handle->peerMgr,
     666                                  tor->info.hash,
     667                                  tor->pexDisabled );
    653668        }
    654669    }
     
    701716    tr_stat_t * s;
    702717    struct tr_tracker * tc;
    703     int i;
    704718
    705719    tr_torrentReaderLock( tor );
     
    715729    s->tracker = tr_trackerGetAddress( tor->tracker );
    716730
    717     /* peers... */
    718     memset( s->peersFrom, 0, sizeof( s->peersFrom ) );
    719     s->peersTotal          = tor->peerCount;
    720     s->peersConnected      = 0;
    721     s->peersSendingToUs    = 0;
    722     s->peersGettingFromUs  = 0;
    723 
    724     for( i=0; i<tor->peerCount; ++i )
    725     {
    726         const tr_peer_t * peer = tor->peers[i];
    727 
    728         if( tr_peerIsConnected( peer ) )
    729         {
    730             ++s->peersConnected;
    731             ++s->peersFrom[tr_peerGetFrom(peer)];
    732 
    733             if( tr_peerDownloadRate( peer ) > 0.01 )
    734                 ++s->peersSendingToUs;
    735 
    736             if( tr_peerUploadRate( peer ) > 0.01 )
    737                 ++s->peersGettingFromUs;
    738         }
    739     }
     731    tr_peerMgrTorrentStats( tor->handle->peerMgr,
     732                            tor->info.hash,
     733                            &s->peersTotal,
     734                            &s->peersConnected,
     735                            &s->peersSendingToUs,
     736                            &s->peersGettingFromUs );
    740737
    741738    s->percentComplete = tr_cpPercentComplete ( tor->completion );
     
    897894tr_torrentPeers( const tr_torrent * tor, int * peerCount )
    898895{
    899     tr_peer_stat * peers;
    900 
    901     tr_torrentReaderLock( tor );
    902 
    903     *peerCount = tor->peerCount;
    904    
    905     peers = tr_new0( tr_peer_stat, tor->peerCount );
    906     if (peers != NULL)
    907     {
    908         tr_peer_t * peer;
    909         struct in_addr * addr;
    910         int i;
    911         for( i=0; i<tor->peerCount; ++i )
    912         {
    913             peer = tor->peers[i];
    914            
    915             addr = tr_peerAddress( peer );
    916             if( NULL != addr )
    917             {
    918                 tr_netNtop( addr, peers[i].addr,
    919                            sizeof( peers[i].addr ) );
    920             }
    921            
    922             peers[i].client           =  tr_peerClient( peer );
    923             peers[i].isConnected      =  tr_peerIsConnected( peer );
    924             peers[i].from             =  tr_peerGetFrom( peer );
    925             peers[i].progress         =  tr_peerProgress( peer );
    926             peers[i].port             =  tr_peerPort( peer );
    927 
    928             peers[i].uploadToRate     =  tr_peerUploadRate( peer );
    929             peers[i].downloadFromRate =  tr_peerDownloadRate( peer );
    930            
    931             peers[i].isDownloading    =  peers[i].uploadToRate > 0.01;
    932             peers[i].isUploading      =  peers[i].downloadFromRate > 0.01;
    933         }
    934     }
    935    
    936     tr_torrentReaderUnlock( tor );
    937    
    938     return peers;
     896    return tr_peerMgrPeerStats( tor->handle->peerMgr,
     897                                tor->info.hash, peerCount );
    939898}
    940899
     
    946905void tr_torrentAvailability( const tr_torrent * tor, int8_t * tab, int size )
    947906{
    948     int i, j, piece;
    949     float interval;
    950 
    951     tr_torrentReaderLock( tor );
    952 
    953     interval = (float)tor->info.pieceCount / (float)size;
    954     for( i = 0; i < size; i++ )
    955     {
    956         piece = i * interval;
    957 
    958         if( tr_cpPieceIsComplete( tor->completion, piece ) )
    959         {
    960             tab[i] = -1;
    961             continue;
    962         }
    963 
    964         tab[i] = 0;
    965         for( j = 0; j < tor->peerCount; j++ )
    966         {
    967             if( tr_peerHasPiece( tor->peers[j], piece ) )
    968             {
    969                 (tab[i])++;
    970             }
    971         }
    972     }
    973 
    974     tr_torrentReaderUnlock( tor );
     907    return tr_peerMgrTorrentAvailability( tor->handle->peerMgr,
     908                                          tor->info.hash,
     909                                          tab, size );
    975910}
    976911
     
    1033968
    1034969
     970#if 0
    1035971int tr_torrentAttachPeer( tr_torrent * tor, tr_peer_t * peer )
    1036972{
     
    10651001    return 1;
    10661002}
    1067 
    1068 static void
    1069 tr_torrentAddPeerIo( tr_torrent  * torrent,
    1070                      tr_peerIo   * io )
    1071 {
    1072     tr_peerManagerAdd( torrent, io );
    1073 }
    1074 
    1075 static void
    1076 myHandshakeDoneCB( tr_peerIo * io, int isConnected, void * userData UNUSED )
    1077 {
    1078     if( isConnected )
    1079         tr_torrentAddPeerIo( tr_peerIoGetTorrent(io), io );
    1080     else
    1081         tr_peerIoFree( io );
    1082 }
    1083 
    1084 int tr_torrentAddCompact( tr_torrent * tor, int from UNUSED,
    1085                           const uint8_t * buf, int count )
    1086 {
    1087     struct in_addr addr;
    1088     tr_port_t port;
    1089     int i, added;
    1090 
    1091     added = 0;
    1092     for( i=0; i<count; ++i )
    1093     {
    1094         memcpy( &addr, buf, 4 ); buf += 4;
    1095         memcpy( &port, buf, 2 ); buf += 2;
    1096 
    1097         tr_handshakeAdd (
    1098             tr_peerIoNewOutgoing( tor->handle, &addr, port, tor ),
    1099             HANDSHAKE_ENCRYPTION_PREFERRED,
    1100             myHandshakeDoneCB,
    1101             NULL );
    1102 
    1103         //added += tr_torrentAttachPeer( tor, peer );
    1104     }
    1105 
    1106     return added;
    1107 }
     1003#endif
    11081004
    11091005/***
     
    12281124        if( tor->runStatus == TR_RUN_STOPPING )
    12291125        {
    1230             int i;
    12311126            tr_torrentWriterLock( tor );
    12321127
     
    12371132
    12381133            /* close the peers */
    1239             for( i=0; i<tor->peerCount; ++i )
    1240                 tr_peerDestroy( tor->peers[i] );
    1241             tor->peerCount = 0;
     1134            tr_peerMgrStopTorrent( tor->handle->peerMgr, tor->info.hash );
    12421135
    12431136            /* resest the transfer rates */
     
    12941187        if( tor->runStatus == TR_RUN_RUNNING )
    12951188        {
    1296             int i;
    1297 
    12981189            /* starting to run... */
    12991190            if( tor->io == NULL )
     
    13071198            /* refresh our completion state */
    13081199            recheckCpState( tor );
    1309 
    1310             /* Shuffle peers */
    1311             if ( tor->peerCount > 1 ) {
    1312                 tr_peer_t * tmp = tor->peers[0];
    1313                 memmove( tor->peers, tor->peers+1,
    1314                         (tor->peerCount-1) * sizeof(void*) );
    1315                 tor->peers[tor->peerCount - 1] = tmp;
    1316             }
    1317 
    1318             /* receive/send messages */
    1319             tr_torrentWriterLock( tor );
    1320             for( i=0; i<tor->peerCount; ) {
    1321                 tr_peer_t * peer = tor->peers[i];
    1322                 int ret = tr_peerPulse( peer );
    1323                 if( ret & TR_ERROR_IO_MASK ) {
    1324                     tr_err( "Fatal error, stopping download (%d)", ret );
    1325                     tor->runStatus = TR_RUN_STOPPING;
    1326                     tor->error = ret;
    1327                     strlcpy( tor->errorString,
    1328                              tr_errorString(ret),
    1329                              sizeof(tor->errorString) );
    1330                     break;
    1331                 }
    1332                 if( ret ) {
    1333                     tr_peerDestroy( peer );
    1334                     tor->peerCount--;
    1335                     memmove( &tor->peers[i], &tor->peers[i+1],
    1336                              (tor->peerCount-i)*sizeof(void*) );
    1337                     continue;
    1338                 }
    1339                 i++;
    1340             }
    1341             tr_torrentWriterUnlock( tor );
    13421200        }
    13431201    }
  • branches/encryption/libtransmission/tracker.c

    r2941 r2954  
    6666    tr_handle_t * handle;
    6767
    68     tr_ptrArray_t * torrents;
    69     tr_ptrArray_t * scraping;
    70     tr_ptrArray_t * scrapeQueue;
     68    tr_ptrArray * torrents;
     69    tr_ptrArray * scraping;
     70    tr_ptrArray * scrapeQueue;
    7171
    7272    /* these are set from the latest scrape or tracker response */
     
    182182    connection_key_t *val, tmp;
    183183
    184     static tr_ptrArray_t * connections = NULL;
     184    static tr_ptrArray * connections = NULL;
    185185    if( !connections )
    186186         connections = tr_ptrArrayNew( );
     
    253253***/
    254254
    255 static tr_ptrArray_t *
     255static tr_ptrArray *
    256256getTrackerLookupTable( void )
    257257{
    258     static tr_ptrArray_t * myTrackers = NULL;
     258    static tr_ptrArray * myTrackers = NULL;
    259259    if( !myTrackers )
    260260         myTrackers = tr_ptrArrayNew( );
     
    291291{
    292292    const tr_info_t * info = &tor->info;
    293     tr_ptrArray_t * trackers = getTrackerLookupTable( );
     293    tr_ptrArray * trackers = getTrackerLookupTable( );
    294294    Tracker *t, tmp;
    295295    assert( info != NULL );
  • branches/encryption/libtransmission/transmission.c

    r2944 r2954  
    3838#include "list.h"
    3939#include "net.h"
     40#include "peer-mgr.h"
    4041#include "platform.h"
    4142#include "ratecontrol.h"
     
    9495    }
    9596
     97    h->peerMgr = tr_peerMgrNew( h );
    9698
    9799    /* Azureus identity */
     
    141143}
    142144
    143 tr_handle_status_t * tr_handleStatus( tr_handle_t * h )
    144 {
    145     tr_handle_status_t * s;
     145tr_handle_status * tr_handleStatus( tr_handle_t * h )
     146{
     147    tr_handle_status * s;
    146148
    147149    h->statCur = ( h->statCur + 1 ) % 2;
     
    238240    tr_rcClose( h->upload );
    239241    tr_rcClose( h->download );
    240    
    241     tr_eventClose( h );
     242
     243    tr_peerMgrFree( h->peerMgr );
    242244    tr_sharedClose( h->shared );
    243245    tr_fdClose();
     246    tr_eventClose( h );
    244247    free( h->tag );
    245248    free( h );
  • branches/encryption/libtransmission/transmission.h

    r2949 r2954  
    104104typedef struct tr_handle tr_handle;
    105105typedef struct tr_handle tr_handle_t;
    106 tr_handle_t * tr_init( const char * tag );
     106tr_handle * tr_init( const char * tag );
    107107
    108108typedef struct tr_tracker_info_s tr_tracker_info_t;
     
    149149 * This can be safely called even with active torrents.
    150150 **********************************************************************/
    151 void tr_setBindPort( tr_handle_t *, int );
    152 
    153 int tr_getPublicPort( const tr_handle_t * );
     151void tr_setBindPort( tr_handle *, int );
     152
     153int tr_getPublicPort( const tr_handle * );
    154154
    155155/***********************************************************************
     
    159159 * Enable or disable NAT traversal using NAT-PMP or UPnP IGD.
    160160 **********************************************************************/
    161 void tr_natTraversalEnable( tr_handle_t *, int enable );
     161void tr_natTraversalEnable( tr_handle *, int enable );
    162162
    163163/***********************************************************************
     
    166166 * Returns some status info for the given handle.
    167167 **********************************************************************/
    168 typedef struct tr_handle_status_s tr_handle_status_t;
    169 tr_handle_status_t * tr_handleStatus( tr_handle_t * );
     168typedef struct tr_handle_status tr_handle_status;
     169typedef struct tr_handle_status tr_handle_status_t;
     170tr_handle_status * tr_handleStatus( tr_handle * );
    170171
    171172
     
    175176 * Returns the count of open torrents
    176177 **********************************************************************/
    177 int tr_torrentCount( tr_handle_t * h );
     178int tr_torrentCount( tr_handle * h );
    178179
    179180
     
    186187typedef struct tr_torrent tr_torrent_t;
    187188typedef void (*tr_callback_t) ( tr_torrent *, void * );
    188 void tr_torrentIterate( tr_handle_t *, tr_callback_t, void * );
     189void tr_torrentIterate( tr_handle *, tr_callback_t, void * );
    189190
    190191
     
    217218                             int                 up_or_down );
    218219
    219 void tr_setUseGlobalSpeedLimit( tr_handle_t * handle,
     220void tr_setUseGlobalSpeedLimit( tr_handle * handle,
    220221                                int           up_or_down,
    221222                                int           use_flag );
    222223
    223 void tr_setGlobalSpeedLimit( tr_handle_t * handle,
     224void tr_setGlobalSpeedLimit( tr_handle * handle,
    224225                             int           up_or_down,
    225226                             int           global_KiB_sec );
    226227
    227 void tr_getGlobalSpeedLimit( tr_handle_t * handle,
     228void tr_getGlobalSpeedLimit( tr_handle * handle,
    228229                             int           up_or_down,
    229230                             int         * setme_is_enabled,
     
    280281 * Gets the total download and upload rates
    281282 **********************************************************************/
    282 void tr_torrentRates( tr_handle_t *, float *, float * );
     283void tr_torrentRates( tr_handle *, float *, float * );
    283284
    284285/***********************************************************************
     
    287288 * Frees memory allocated by tr_init.
    288289 **********************************************************************/
    289 void tr_close( tr_handle_t * );
     290void tr_close( tr_handle * );
    290291
    291292
     
    296297 *  from the previous session.
    297298 */
    298 tr_torrent ** tr_loadTorrents ( tr_handle_t  * h,
     299tr_torrent ** tr_loadTorrents ( tr_handle  * h,
    299300                                const char   * destination,
    300301                                int            flags,
     
    316317#define TR_EDUPLICATE   3
    317318#define TR_EOTHER       666
    318 tr_torrent * tr_torrentInit( tr_handle_t  * handle,
     319tr_torrent * tr_torrentInit( tr_handle  * handle,
    319320                             const char   * metainfo_filename,
    320321                             const char   * destination,
     
    340341 * call tr_metainfoFree( setme_info ) when done with it.
    341342 */
    342 int tr_torrentParse( const tr_handle_t  * handle,
     343int tr_torrentParse( const tr_handle  * handle,
    343344                     const char         * metainfo_filename,
    344345                     const char         * destination,
     
    350351 */
    351352int
    352 tr_torrentParseHash( const tr_handle_t  * h,
     353tr_torrentParseHash( const tr_handle  * h,
    353354                     const char         * hashStr,
    354355                     const char         * destination,
     
    362363 * instead of the filename.
    363364 **********************************************************************/
    364 tr_torrent * tr_torrentInitData( tr_handle_t *,
     365tr_torrent * tr_torrentInitData( tr_handle *,
    365366                                 const uint8_t * data, size_t size,
    366367                                 const char * destination,
     
    374375 * are currently no valid flags for this function.
    375376 **********************************************************************/
    376 tr_torrent * tr_torrentInitSaved( tr_handle_t *,
     377tr_torrent * tr_torrentInitSaved( tr_handle *,
    377378                                  const char * hashStr,
    378379                                  const char * destination,
     
    685686};
    686687
    687 struct tr_handle_status_s
     688struct tr_handle_status
    688689{
    689690#define TR_NAT_TRAVERSAL_MAPPING        1
  • branches/encryption/libtransmission/trevent.c

    r2946 r2954  
    4545***/
    4646
    47 typedef struct tr_event_handle_s
     47typedef struct tr_event_handle
    4848{
    4949    int fds[2];
Note: See TracChangeset for help on using the changeset viewer.