Changeset 2949

Timestamp:

Aug 30, 2007, 8:51:35 PM (15 years ago)

Author:

charles

Message:

add libevent-ized uploads, downloads, speed limits, choke messages. It's still at least a weekend away from being something even bleeding-edge testers would want to try.

Location:

branches/encryption/libtransmission

Files:

• inout.c (modified) (2 diffs)
• inout.h (modified) (2 diffs)
• p.c (modified) (22 diffs)
• peer-connection.c (modified) (1 diff)
• peer-connection.h (modified) (1 diff)
• peermessages.h (modified) (1 diff)
• peerparse.h (modified) (1 diff)
• torrent.c (modified) (3 diffs)
• transmission.h (modified) (2 diffs)

branches/encryption/libtransmission/inout.c

@@ -141 +141 @@
 static int
 readOrWritePiece ( tr_torrent       * tor,
-                   int                  ioMode,
-                   int                  pieceIndex,
-                   int                  pieceOffset,
-                   uint8_t            * buf,
-                   size_t               buflen )
+                   int                ioMode,
+                   int                pieceIndex,
+                   int                pieceOffset,
+                   uint8_t          * buf,
+                   size_t             buflen )
 {
     int ret = 0;
@@ -178 +178 @@
 
 int
-tr_ioRead( tr_io_t * io, int pieceIndex, int begin, int len, uint8_t * buf )
-{
-    return readOrWritePiece ( io->tor, TR_IO_READ, pieceIndex, begin, buf, len );
+tr_ioRead( tr_torrent * tor, int pieceIndex, int begin, int len, uint8_t * buf )
+{
+    return readOrWritePiece ( tor, TR_IO_READ, pieceIndex, begin, buf, len );
 }
 
 int
-tr_ioWrite( tr_io_t * io, int pieceIndex, int begin, int len, uint8_t * buf )
-{
-    return readOrWritePiece ( io->tor, TR_IO_WRITE, pieceIndex, begin, buf, len );
+tr_ioWrite( tr_torrent * tor, int pieceIndex, int begin, int len, uint8_t * buf )
+{
+    return readOrWritePiece ( tor, TR_IO_WRITE, pieceIndex, begin, buf, len );
 }
 

branches/encryption/libtransmission/inout.h

@@ -26 +26 @@
 #define TR_IO_H 1
 
+struct tr_torrent;
+
 typedef struct tr_io_s tr_io_t;
 
@@ -40 +42 @@
  * TR_ERROR_IO_* otherwise.
  **********************************************************************/
-int tr_ioRead  ( tr_io_t *, int index, int begin, int len, uint8_t * );
-int tr_ioWrite ( tr_io_t *, int index, int begin, int len, uint8_t * );
+int tr_ioRead  ( struct tr_torrent*, int index, int begin, int len, uint8_t * );
+int tr_ioWrite ( struct tr_torrent *, int index, int begin, int len, uint8_t * );
 
 /***********************************************************************

branches/encryption/libtransmission/p.c

@@ -8 +8 @@
  * the Transmission project.
  *
- * $Id:$
+ * $Id$
  */
 
@@ -25 +25 @@
 #include "bencode.h"
 #include "completion.h"
+#include "inout.h"
 #include "list.h"
 #include "peer-connection.h"
@@ -59 +60 @@
 {
     AWAITING_BT_LENGTH,
-    AWAITING_BT_MESSAGE
+    AWAITING_BT_MESSAGE,
+    READING_BT_PIECE
 };
 
@@ -73 +75 @@
     fprintf (stderr, "PeerManager::getStateName: unhandled state %d\n", state );
     abort( );
+}
+
+struct peer_request
+{
+    uint32_t pieceIndex;
+    uint32_t offsetInPiece;
+    uint32_t length;
+};
+
+static int
+peer_request_compare_func( const void * va, const void * vb )
+{
+    struct peer_request * a = (struct peer_request*) va;
+    struct peer_request * b = (struct peer_request*) vb;
+    if( a->pieceIndex != b->pieceIndex )
+        return a->pieceIndex - b->pieceIndex;
+    if( a->offsetInPiece != b->offsetInPiece )
+        return a->offsetInPiece - b->offsetInPiece;
+    if( a->length != b->length )
+        return a->length - b->length;
+    return 0;
 }
 
@@ -80 +103 @@
     tr_torrent * torrent;
     tr_peerConnection * connection;
-    tr_bitfield * bitfield; /* the peer's bitfield */
-    tr_bitfield * banfield; /* bad pieces from the peer */
+    tr_bitfield * bitfield;   /* the peer's bitfield */
+    tr_bitfield * banfield;   /* bad pieces from the peer */
+    tr_bitfield * blamefield; /* lists pieces that this peer helped us with */
 
     struct evbuffer * outMessages; /* buffer of all the non-piece messages */
+    struct evbuffer * outBlock;    /* the block we're currently sending */
+    struct evbuffer * inBlock;     /* the block we're currently receiving */
+    tr_list * peerAskedFor;
     tr_list * outPieces;
 
     tr_timer_tag pulseTag;
 
-    tr_ratecontrol * rcIn;  /* rate of bytes from the peer to us */
-    tr_ratecontrol * rcOut; /* rate of bytes from us to the peer */
-
-    unsigned int  weAreChokingThem  : 1;
-    unsigned int  peerisChokingUs   : 1;
-    unsigned int  weAreInterested   : 1;
-    unsigned int  peerIsInterested  : 1;
-    unsigned int  isPrivate         : 1;
+    tr_ratecontrol * rcToUs;   /* rate of bytes from the peer to us */
+    tr_ratecontrol * rcToPeer; /* rate of bytes from us to the peer */
+
+    unsigned int  peerIsChoked        : 1;
+    unsigned int  weAreChoked         : 1;
+    unsigned int  peerIsInterested    : 1;
+    unsigned int  weAreInterested     : 1;
+    unsigned int  isPrivate           : 1;
+    unsigned int  notListening        : 1;
+
+    struct peer_request blockToUs;
 
     int state;
@@ -106 +136 @@
 
     uint16_t ut_pex;
-    uint32_t listeningPort;
+    uint16_t listeningPort;
 
     /* the client name from the `v' string in LTEP's handshake dictionary */
@@ -171 +201 @@
 }
 
+void
+setChoke( tr_peer * peer, int choke )
+{
+    if( peer->peerIsChoked != !!choke )
+    {
+        const uint32_t len = sizeof(uint8_t);
+        const uint8_t bt_msgid = choke ? BT_CHOKE : BT_UNCHOKE;
+
+        peer->peerIsChoked = choke ? 1 : 0;
+        if( peer->peerIsChoked )
+        {
+            tr_list_foreach( peer->peerAskedFor, tr_free );
+            tr_list_free( &peer->peerAskedFor );
+        }
+
+        fprintf( stderr, "peer %p: enqueuing a %s message\n", peer, (choke ? "choke" : "unchoke") );
+        tr_peerConnectionWriteUint32( peer->connection, peer->outMessages, len );
+        tr_peerConnectionWriteBytes( peer->connection, peer->outMessages, &bt_msgid, 1 );
+    }
+}
+
 /**
 ***
@@ -208 +259 @@
 for( i=0; i<sub->val.s.i; ++i ) fprintf( stderr, "[%c] (%d)\n", sub->val.s.s[i], (int)sub->val.s.s[i] );
         peer->client = tr_strndup( sub->val.s.s, sub->val.s.i );
-        for( i=0; i<sub->val.s.i; ++i )
-            if( !isprint(peer->client[i])) peer->client[i]='u';
         fprintf( stderr, "peer->client is now [%s]\n", peer->client );
     }
@@ -217 +266 @@
     if( tr_bencIsInt( sub ) ) {
         peer->listeningPort = htons( (uint16_t)sub->val.i );
-        fprintf( stderr, "peer->port is now %d\n", peer->listeningPort );
+        fprintf( stderr, "peer->port is now %hd\n", peer->listeningPort );
     }
 
@@ -311 +360 @@
     tr_peerConnectionReadBytes( peer->connection, inbuf, &id, 1 );
     msglen--;
-    fprintf( stderr, "got a message from the peer... bt id number is %d, and remaining len is %d\n", (int)id, (int)msglen );
+    fprintf( stderr, "got a message from the peer... "
+                     "bt id number is %d, and remaining len is %d\n", (int)id, (int)msglen );
 
     switch( id )
     {
         case BT_CHOKE:
+            assert( msglen == 0 );
             fprintf( stderr, "got a BT_CHOKE\n" );
-            peer->peerisChokingUs = 1;
+            peer->weAreChoked = 1;
+            tr_list_foreach( peer->peerAskedFor, tr_free );
+            tr_list_free( &peer->peerAskedFor );
             /* FIXME: maybe choke them */
-            /* FIXME: clear their outPieces queue */
-            /* FIXME: unmark those outpieces as requested */
+            /* FIXME: unmark anything we'd requested from them... */
             break;
 
         case BT_UNCHOKE:
+            assert( msglen == 0 );
             fprintf( stderr, "got a BT_UNCHOKE\n" );
-            peer->peerisChokingUs = 0;
+            peer->weAreChoked = 0;
             /* FIXME: maybe unchoke them */
             /* FIXME: maybe send them requests */
@@ -331 +384 @@
 
         case BT_INTERESTED:
+            assert( msglen == 0 );
             fprintf( stderr, "got a BT_INTERESTED\n" );
             peer->peerIsInterested = 1;
@@ -337 +391 @@
 
         case BT_NOT_INTERESTED:
+            assert( msglen == 0 );
             fprintf( stderr, "got a BT_NOT_INTERESTED\n" );
             peer->peerIsInterested = 0;
@@ -343 +398 @@
 
         case BT_HAVE:
+            assert( msglen == 4 );
             fprintf( stderr, "got a BT_HAVE\n" );
             tr_peerConnectionReadUint32( peer->connection, inbuf, &ui32 );
@@ -351 +407 @@
 
         case BT_BITFIELD:
+            assert( msglen == peer->bitfield->len );
             fprintf( stderr, "got a BT_BITFIELD\n" );
-            assert( msglen == peer->bitfield->len );
             tr_peerConnectionReadBytes( peer->connection, inbuf, peer->bitfield->bits, msglen );
             peer->progress = tr_bitfieldCountTrueBits( peer->bitfield ) / (float)peer->torrent->info.pieceCount;
@@ -360 +416 @@
             break;
 
-        case BT_REQUEST:
+        case BT_REQUEST: {
+            struct peer_request * req;
+            assert( msglen == 12 );
             fprintf( stderr, "got a BT_REQUEST\n" );
-            break;
-
-        case BT_PIECE:
+            req = tr_new( struct peer_request, 1 );
+            tr_peerConnectionReadUint32( peer->connection, inbuf, &req->pieceIndex );
+            tr_peerConnectionReadUint32( peer->connection, inbuf, &req->offsetInPiece );
+            tr_peerConnectionReadUint32( peer->connection, inbuf, &req->length );
+            if( !peer->peerIsChoked )
+                tr_list_append( &peer->peerAskedFor, req );
+            break;
+        }
+
+        case BT_CANCEL: {
+            struct peer_request req;
+            tr_list * node;
+            assert( msglen == 12 );
+            fprintf( stderr, "got a BT_CANCEL\n" );
+            tr_peerConnectionReadUint32( peer->connection, inbuf, &req.pieceIndex );
+            tr_peerConnectionReadUint32( peer->connection, inbuf, &req.offsetInPiece );
+            tr_peerConnectionReadUint32( peer->connection, inbuf, &req.length );
+            node = tr_list_find( peer->peerAskedFor, &req, peer_request_compare_func );
+            if( node != NULL ) {
+                fprintf( stderr, "found the req that peer is cancelling... cancelled.\n" );
+                tr_list_remove_data( &peer->peerAskedFor, node->data );
+            }
+            break;
+        }
+
+        case BT_PIECE: {
             fprintf( stderr, "got a BT_PIECE\n" );
-            break;
-
-        case BT_CANCEL:
-            fprintf( stderr, "got a BT_CANCEL\n" );
-            break;
-
-        case BT_PORT:
+            assert( peer->blockToUs.length == 0 );
+            peer->state = READING_BT_PIECE;
+            tr_peerConnectionReadUint32( peer->connection, inbuf, &peer->blockToUs.pieceIndex );
+            tr_peerConnectionReadUint32( peer->connection, inbuf, &peer->blockToUs.offsetInPiece );
+            peer->blockToUs.length = msglen - 8;
+            assert( peer->blockToUs.length > 0 );
+            evbuffer_drain( peer->inBlock, ~0 );
+            break;
+        }
+
+        case BT_PORT: {
+            assert( msglen == 2 );
             fprintf( stderr, "got a BT_PORT\n" );
-            break;
+            tr_peerConnectionReadUint16( peer->connection, inbuf, &peer->listeningPort );
+            break;
+        }
 
         case BT_LTEP:
@@ -383 +471 @@
         default:
             fprintf( stderr, "got an unknown BT message type: %d\n", (int)id );
+            tr_peerConnectionDrain( peer->connection, inbuf, msglen );
             assert( 0 );
     }
@@ -389 +478 @@
     peer->state = AWAITING_BT_LENGTH;
     return READ_AGAIN;
+}
+
+static int
+canDownload( const tr_peer * peer )
+{
+    tr_torrent * tor = peer->torrent;
+
+#if 0
+    /* FIXME: was swift worth it?  did anyone notice a difference? :) */
+    if( SWIFT_ENABLED && !isSeeding && (peer->credit<0) )
+        return FALSE;
+#endif
+
+    if( tor->downloadLimitMode == TR_SPEEDLIMIT_GLOBAL )
+        return !tor->handle->useDownloadLimit || tr_rcCanTransfer( tor->handle->download );
+
+    if( tor->downloadLimitMode == TR_SPEEDLIMIT_SINGLE )
+        return tr_rcCanTransfer( tor->download );
+
+    return TRUE;
+}
+
+static void
+gotBlock( tr_peer * peer, int pieceIndex, int offset, struct evbuffer * inbuf )
+{
+    tr_torrent * tor = peer->torrent;
+    const size_t len = EVBUFFER_LENGTH( inbuf );
+    const int block = _tr_block( tor, pieceIndex, offset );
+
+    /* sanity clause */
+    if( tr_cpBlockIsComplete( tor->completion, block ) ) {
+        tr_dbg( "have this block already..." );
+        return;
+    }
+    if( (int)len != tr_torBlockCountBytes( tor, block ) ) {
+        tr_dbg( "block is the wrong length..." );
+        return;
+    }
+
+    /* write to disk */
+    if( tr_ioWrite( tor, pieceIndex, offset, len, EVBUFFER_DATA( inbuf )))
+        return;
+
+    /* make a note that this peer helped us with this piece */
+    if( !peer->blamefield )
+         peer->blamefield = tr_bitfieldNew( tor->info.pieceCount );
+    tr_bitfieldAdd( peer->blamefield, pieceIndex );
+
+    tr_cpBlockAdd( tor->completion, block );
+
+    tor->downloadedCur += len;
+    tr_rcTransferred( peer->rcToUs, len );
+    tr_rcTransferred( tor->download, len );
+    tr_rcTransferred( tor->handle->download, len );
+
+//    broadcastCancel( tor, index, begin, len - 8 );
+}
+
+
+static ReadState
+readBtPiece( tr_peer * peer, struct evbuffer * inbuf )
+{
+    assert( peer->blockToUs.length > 0 );
+
+    if( !canDownload( peer ) )
+    {
+        peer->notListening = 1;
+        tr_peerConnectionSetIOMode ( peer->connection, 0, EV_READ );
+        return READ_DONE;
+    }
+    else
+    {
+        /* inbuf ->  inBlock */
+        const uint32_t len = MIN( EVBUFFER_LENGTH(inbuf), peer->blockToUs.length );
+        uint8_t * tmp = tr_new( uint8_t, len );
+        tr_peerConnectionReadBytes( peer->connection, inbuf, tmp, len );
+        evbuffer_add( peer->inBlock, tmp, len );
+        tr_free( tmp );
+        peer->blockToUs.length -= len;
+
+        if( !peer->blockToUs.length )
+        {
+            gotBlock( peer, peer->blockToUs.pieceIndex,
+                            peer->blockToUs.offsetInPiece,
+                            peer->inBlock );
+            evbuffer_drain( peer->outBlock, ~0 );
+            peer->state = AWAITING_BT_LENGTH;
+        }
+
+        return READ_AGAIN;
+    }
 }
 
@@ -403 +583 @@
         case AWAITING_BT_LENGTH:  ret = readBtLength  ( peer, inbuf ); break;
         case AWAITING_BT_MESSAGE: ret = readBtMessage ( peer, inbuf ); break;
+        case READING_BT_PIECE:    ret = readBtPiece   ( peer, inbuf ); break;
         default: assert( 0 );
     }
     return ret;
-}
-
-static void
-didWrite( struct bufferevent * evin UNUSED, void * vpeer )
-{
-    tr_peer * peer = (tr_peer *) vpeer;
-    fprintf( stderr, "peer %p got a didWrite...\n", peer );
-}
-
-static void
-gotError( struct bufferevent * evbuf UNUSED, short what, void * vpeer )
-{
-    tr_peer * peer = (tr_peer *) vpeer;
-    fprintf( stderr, "peer %p got an error in %d\n", peer, (int)what );
 }
 
@@ -427 +594 @@
 
 static int
+canUpload( const tr_peer * peer )
+{
+    const tr_torrent * tor = peer->torrent;
+
+    if( tor->uploadLimitMode == TR_SPEEDLIMIT_GLOBAL )
+        return !tor->handle->useUploadLimit || tr_rcCanTransfer( tor->handle->upload );
+
+    if( tor->uploadLimitMode == TR_SPEEDLIMIT_SINGLE )
+        return tr_rcCanTransfer( tor->upload );
+
+    return TRUE;
+}
+
+static int
 pulse( void * vpeer )
 {
     tr_peer * peer = (tr_peer *) vpeer;
-
-    /* send out the non-piece messages. */
-    if( EVBUFFER_LENGTH( peer->outMessages ) ) {
-        fprintf( stderr, "peer %p pulse is writing %d bytes worth of messages...\n", peer, (int)EVBUFFER_LENGTH(peer->outMessages) );
+    size_t len;
+
+    /* if we froze out a downloaded block because of speed limits,
+       start listening to the peer again */
+    if( peer->notListening )
+    {
+        fprintf( stderr, "peer %p thawing out...\n", peer );
+        peer->notListening = 0;
+        tr_peerConnectionSetIOMode ( peer->connection, EV_READ, 0 );
+    }
+
+    if(( len = EVBUFFER_LENGTH( peer->outBlock ) ))
+    {
+        if( canUpload( peer ) )
+        {
+            const size_t outlen = MIN( len, 2048 );
+            tr_peerConnectionWrite( peer->connection, EVBUFFER_DATA(peer->outBlock), outlen );
+            evbuffer_drain( peer->outBlock, outlen );
+        }
+    }
+    else if(( len = EVBUFFER_LENGTH( peer->outMessages ) ))
+    {
+        fprintf( stderr, "peer %p pulse is writing %d bytes worth of messages...\n", peer, (int)len );
         tr_peerConnectionWriteBuf( peer->connection, peer->outMessages );
-        evbuffer_drain( peer->outMessages, EVBUFFER_LENGTH( peer->outMessages ) );
-    }
-
-    return TRUE;
+        evbuffer_drain( peer->outMessages, ~0 );
+    }
+    else if(( peer->peerAskedFor ))
+    {
+        struct peer_request * req = (struct peer_request*) peer->peerAskedFor->data;
+        uint8_t * tmp = tr_new( uint8_t, req->length );
+        const uint8_t msgid = BT_PIECE;
+        const uint32_t msglen = sizeof(uint8_t) + sizeof(uint32_t)*2 + req->length;
+        tr_ioRead( peer->torrent, req->pieceIndex, req->offsetInPiece, req->length, tmp );
+        tr_peerConnectionWriteUint32( peer->connection, peer->outBlock, msglen );
+        tr_peerConnectionWriteBytes ( peer->connection, peer->outBlock, &msgid, 1 );
+        tr_peerConnectionWriteUint32( peer->connection, peer->outBlock, req->pieceIndex );
+        tr_peerConnectionWriteUint32( peer->connection, peer->outBlock, req->offsetInPiece );
+        tr_peerConnectionWriteBytes ( peer->connection, peer->outBlock, tmp, req->length );
+        tr_free( tmp );
+    }
+
+    return TRUE; /* loop forever */
+}
+
+static void
+didWrite( struct bufferevent * evin UNUSED, void * vpeer )
+{
+    tr_peer * peer = (tr_peer *) vpeer;
+    fprintf( stderr, "peer %p got a didWrite...\n", peer );
+    pulse( vpeer );
+}
+
+static void
+gotError( struct bufferevent * evbuf UNUSED, short what, void * vpeer )
+{
+    tr_peer * peer = (tr_peer *) vpeer;
+    fprintf( stderr, "peer %p got an error in %d\n", peer, (int)what );
 }
 
@@ -464 +693 @@
     peer->torrent = torrent;
     peer->connection = connection;
-    peer->rcIn = tr_rcInit( );
-    peer->rcOut = tr_rcInit( );
-    peer->weAreChokingThem = 1;
-    peer->peerisChokingUs = 1;
+    peer->weAreChoked = 1;
+    peer->peerIsChoked = 1;
     peer->weAreInterested = 0;
     peer->peerIsInterested = 0;
@@ -473 +700 @@
     peer->bitfield = tr_bitfieldNew( torrent->info.pieceCount );
     peer->outMessages = evbuffer_new( );
+    peer->outBlock = evbuffer_new( );
+    peer->inBlock = evbuffer_new( );
 
     tr_peerConnectionSetIOFuncs( connection, canRead, didWrite, gotError, peer );
@@ -479 +708 @@
     sendBitfield( peer );
 }
+
+void
+tr_peerGetInfo( const tr_peer * peer, tr_peer_stat * setme )
+{
+    setme->client = peer->client;
+    setme->isConnected = TRUE;
+    setme->progress = peer->progress;
+    setme->downloadFromRate = tr_rcRate( peer->rcToUs );
+    setme->downloadFromRate = tr_rcRate( peer->rcToPeer );
+
+    //char    addr[INET_ADDRSTRLEN];
+    //int     from;
+    //int     port;
+    //int     isDownloading;
+    //int     isUploading;
+
+}

branches/encryption/libtransmission/peer-connection.c

@@ -419 +419 @@
     *setme = ntohl( tmp );
 }
+
+void
+tr_peerConnectionDrain( tr_peerConnection   * conn,
+                        struct evbuffer     * inbuf,
+                        int                   byteCount )
+{
+    uint8_t * tmp = tr_new( uint8_t, byteCount );
+    tr_peerConnectionReadBytes( conn, inbuf, tmp, byteCount );
+    tr_free( tmp );
+}

branches/encryption/libtransmission/peer-connection.h

@@ -152 +152 @@
                                     uint32_t            * setme );
 
+void tr_peerConnectionDrain       ( tr_peerConnection   * conn,
+                                    struct evbuffer     * inbuf,
+                                    int                   byteCount );
+
 
 #endif

branches/encryption/libtransmission/peermessages.h

@@ -144 +144 @@
         buf += 4;
 
-        tr_ioRead( tor->io, r->index, r->begin, r->length, buf );
+        tr_ioRead( tor, r->index, r->begin, r->length, buf );
 
         peer_dbg( "SEND piece %d/%d (%d bytes)",

branches/encryption/libtransmission/peerparse.h

@@ -335 +335 @@
 
     /* Write to disk */
-    if( ( ret = tr_ioWrite( tor->io, index, begin, len - 8, &p[8] ) ) )
+    if( ( ret = tr_ioWrite( tor, index, begin, len - 8, &p[8] ) ) )
     {
         return ret;

branches/encryption/libtransmission/torrent.c

@@ -894 +894 @@
 ***/
 
-tr_peer_stat_t *
+tr_peer_stat *
 tr_torrentPeers( const tr_torrent * tor, int * peerCount )
 {
-    tr_peer_stat_t * peers;
+    tr_peer_stat * peers;
 
     tr_torrentReaderLock( tor );
@@ -903 +903 @@
     *peerCount = tor->peerCount;
    
-    peers = tr_new0( tr_peer_stat_t, tor->peerCount ); 
+    peers = tr_new0( tr_peer_stat, tor->peerCount ); 
     if (peers != NULL)
     {
@@ -939 +939 @@
 }
 
-void tr_torrentPeersFree( tr_peer_stat_t * peers, int peerCount UNUSED )
+void tr_torrentPeersFree( tr_peer_stat * peers, int peerCount UNUSED )
 {
     tr_free( peers );

branches/encryption/libtransmission/transmission.h

@@ -471 +471 @@
  * tr_torrentPeers
  ***********************************************************************/
-typedef struct tr_peer_stat_s tr_peer_stat_t;
-tr_peer_stat_t * tr_torrentPeers( const tr_torrent *, int * peerCount );
-void tr_torrentPeersFree( tr_peer_stat_t *, int peerCount );
+typedef struct tr_peer_stat tr_peer_stat;
+typedef struct tr_peer_stat tr_peer_stat_t;
+tr_peer_stat * tr_torrentPeers( const tr_torrent *, int * peerCount );
+void tr_torrentPeersFree( tr_peer_stat *, int peerCount );
 
 typedef struct tr_file_stat_s tr_file_stat_t;
@@ -652 +653 @@
 };
 
-struct tr_peer_stat_s
+struct tr_peer_stat
 {
     char    addr[INET_ADDRSTRLEN];