Changeset 7176

Timestamp:

Nov 29, 2008, 4:44:24 PM (12 years ago)

Author:

charles

Message:

(1.4x libT) backport the bandwidth fixes back to the 1.4x branch, pass #2: most of the bandwidth code, plus autoconf and xcode makefile stuff

Location:

branches/1.4x

Files:

• Transmission.xcodeproj/project.pbxproj (modified) (8 diffs)
• libtransmission/Makefile.am (modified) (4 diffs)
• libtransmission/handshake.c (modified) (12 diffs)
• libtransmission/net.c (modified) (3 diffs)
• libtransmission/net.h (modified) (3 diffs)
• libtransmission/peer-common.h (modified) (2 diffs)
• libtransmission/peer-io.c (modified) (32 diffs)
• libtransmission/peer-io.h (modified) (5 diffs)
• libtransmission/peer-mgr-private.h (modified) (4 diffs)
• libtransmission/peer-mgr.c (modified) (22 diffs)
• libtransmission/peer-mgr.h (modified) (1 diff)
• libtransmission/peer-msgs.c (modified) (33 diffs)
• libtransmission/port-forwarding.c (modified) (8 diffs)
• libtransmission/session.c (modified) (8 diffs)
• libtransmission/session.h (modified) (4 diffs)
• libtransmission/torrent.c (modified) (6 diffs)
• libtransmission/torrent.h (modified) (4 diffs)
• libtransmission/transmission.h (modified) (1 diff)
• libtransmission/webseed.c (modified) (3 diffs)

branches/1.4x/Transmission.xcodeproj/project.pbxproj

@@ -86 +86 @@
                 A219798B0D07B78400438EA7 /* GroupToolbarItem.m in Sources */ = {isa = PBXBuildFile; fileRef = A219798A0D07B78400438EA7 /* GroupToolbarItem.m */; };
                 A21DFF100A292B2B007C5F76 /* Transfers.png in Resources */ = {isa = PBXBuildFile; fileRef = A21DFF0F0A292B2B007C5F76 /* Transfers.png */; };
+                A21FBBAB0EDA78C300BC3C51 /* bandwidth.h in Headers */ = {isa = PBXBuildFile; fileRef = A21FBBA90EDA78C300BC3C51 /* bandwidth.h */; };
+                A21FBBAC0EDA78C300BC3C51 /* bandwidth.c in Sources */ = {isa = PBXBuildFile; fileRef = A21FBBAA0EDA78C300BC3C51 /* bandwidth.c */; };
                 A22180980D148A71007D09ED /* GroupsWindowController.m in Sources */ = {isa = PBXBuildFile; fileRef = A22180970D148A71007D09ED /* GroupsWindowController.m */; };
                 A22180B60D148F0F007D09ED /* GroupsWindow.xib in Resources */ = {isa = PBXBuildFile; fileRef = A22180B50D148F0F007D09ED /* GroupsWindow.xib */; };
@@ -124 +126 @@
                 A259317E0A73B2CC002F4FE7 /* TransmissionHelp in Resources */ = {isa = PBXBuildFile; fileRef = A259316A0A73B2CC002F4FE7 /* TransmissionHelp */; };
                 A25AFDE90D1038AD0092A1BA /* MenuLabel.m in Sources */ = {isa = PBXBuildFile; fileRef = A25AFDE80D1038AD0092A1BA /* MenuLabel.m */; };
+                A25B400A0EDCB1B8005DD3F6 /* iobuf.c in Sources */ = {isa = PBXBuildFile; fileRef = A25B40080EDCB1B8005DD3F6 /* iobuf.c */; };
+                A25B400B0EDCB1B8005DD3F6 /* iobuf.h in Headers */ = {isa = PBXBuildFile; fileRef = A25B40090EDCB1B8005DD3F6 /* iobuf.h */; };
                 A25D2CBD0CF4C73E0096A262 /* stats.c in Sources */ = {isa = PBXBuildFile; fileRef = A25D2CBB0CF4C7190096A262 /* stats.c */; };
                 A25D2CBE0CF4C73E0096A262 /* stats.h in Headers */ = {isa = PBXBuildFile; fileRef = A25D2CBA0CF4C7190096A262 /* stats.h */; };
@@ -477 +481 @@
                 A219798A0D07B78400438EA7 /* GroupToolbarItem.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = GroupToolbarItem.m; path = macosx/GroupToolbarItem.m; sourceTree = "<group>"; };
                 A21DFF0F0A292B2B007C5F76 /* Transfers.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; name = Transfers.png; path = macosx/Images/Transfers.png; sourceTree = "<group>"; };
+                A21FBBA90EDA78C300BC3C51 /* bandwidth.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = bandwidth.h; path = libtransmission/bandwidth.h; sourceTree = "<group>"; };
+                A21FBBAA0EDA78C300BC3C51 /* bandwidth.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bandwidth.c; path = libtransmission/bandwidth.c; sourceTree = "<group>"; };
                 A22180960D148A71007D09ED /* GroupsWindowController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GroupsWindowController.h; path = macosx/GroupsWindowController.h; sourceTree = "<group>"; };
                 A22180970D148A71007D09ED /* GroupsWindowController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = GroupsWindowController.m; path = macosx/GroupsWindowController.m; sourceTree = "<group>"; };
@@ -523 +529 @@
                 A25AFDE70D1038AD0092A1BA /* MenuLabel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = MenuLabel.h; path = macosx/MenuLabel.h; sourceTree = "<group>"; };
                 A25AFDE80D1038AD0092A1BA /* MenuLabel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = MenuLabel.m; path = macosx/MenuLabel.m; sourceTree = "<group>"; };
+                A25B40080EDCB1B8005DD3F6 /* iobuf.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = iobuf.c; path = libtransmission/iobuf.c; sourceTree = "<group>"; };
+                A25B40090EDCB1B8005DD3F6 /* iobuf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = iobuf.h; path = libtransmission/iobuf.h; sourceTree = "<group>"; };
                 A25D2CBA0CF4C7190096A262 /* stats.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = stats.h; path = libtransmission/stats.h; sourceTree = "<group>"; };
                 A25D2CBB0CF4C7190096A262 /* stats.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = stats.c; path = libtransmission/stats.c; sourceTree = "<group>"; };
@@ -1121 +1129 @@
                                 4D36BA630CA2F00800A63CA5 /* handshake.c */,
                                 4D36BA640CA2F00800A63CA5 /* handshake.h */,
+                                A25B40080EDCB1B8005DD3F6 /* iobuf.c */,
+                                A25B40090EDCB1B8005DD3F6 /* iobuf.h */,
                                 4D36BA650CA2F00800A63CA5 /* peer-io.c */,
                                 4D36BA660CA2F00800A63CA5 /* peer-io.h */,
@@ -1158 +1168 @@
                                 BEFC1E000C07861A00B0BB3C /* ratecontrol.h */,
                                 BEFC1E010C07861A00B0BB3C /* ratecontrol.c */,
+                                A21FBBA90EDA78C300BC3C51 /* bandwidth.h */,
+                                A21FBBAA0EDA78C300BC3C51 /* bandwidth.c */,
                                 BEFC1E020C07861A00B0BB3C /* platform.h */,
                                 BEFC1E030C07861A00B0BB3C /* platform.c */,
@@ -1429 +1441 @@
                                 A2DF58590DE4B2B1000795D5 /* JSON_parser.h in Headers */,
                                 A25E03E20E4015380086C225 /* tr-getopt.h in Headers */,
+                                A21FBBAB0EDA78C300BC3C51 /* bandwidth.h in Headers */,
+                                A25B400B0EDCB1B8005DD3F6 /* iobuf.h in Headers */,
                         );
                         runOnlyForDeploymentPostprocessing = 0;
@@ -1841 +1855 @@
                                 A25E03E30E4015380086C225 /* tr-getopt.c in Sources */,
                                 4DB74F080E8CD75100AEB1A8 /* wildmat.c in Sources */,
+                                A21FBBAC0EDA78C300BC3C51 /* bandwidth.c in Sources */,
+                                A25B400A0EDCB1B8005DD3F6 /* iobuf.c in Sources */,
                         );
                         runOnlyForDeploymentPostprocessing = 0;

branches/1.4x/libtransmission/Makefile.am

@@ -13 +13 @@
 
 libtransmission_a_SOURCES = \
+    bandwidth.c \
     bencode.c \
     blocklist.c \
@@ -24 +25 @@
     handshake.c \
     inout.c \
+    iobuf.c \
     json.c \
     JSON_parser.c \
@@ -57 +59 @@
 
 noinst_HEADERS = \
+    bandwidth.h \
     bencode.h \
     blocklist.h \
@@ -68 +71 @@
     handshake.h \
     inout.h \
+    iobuf.h \
     json.h \
     JSON_parser.h \

branches/1.4x/libtransmission/handshake.c

@@ -25 +25 @@
 #include "crypto.h"
 #include "handshake.h"
+#include "iobuf.h"
 #include "peer-io.h"
 #include "peer-mgr.h"
@@ -89 +90 @@
 struct tr_handshake
 {
-    unsigned int          havePeerID                  : 1;
-    unsigned int          haveSentBitTorrentHandshake : 1;
+    tr_bool               havePeerID;
+    tr_bool               haveSentBitTorrentHandshake;
     tr_peerIo *           io;
     tr_crypto *           crypto;
@@ -334 +335 @@
     /* send it */
     setReadState( handshake, AWAITING_YB );
-    tr_peerIoWriteBuf( handshake->io, outbuf );
+    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
 
     /* cleanup */
@@ -486 +487 @@
     tr_cryptoDecryptInit( handshake->crypto );
     setReadState( handshake, AWAITING_VC );
-    tr_peerIoWriteBuf( handshake->io, outbuf );
+    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
 
     /* cleanup */
@@ -712 +713 @@
         int       msgSize;
         uint8_t * msg = buildHandshakeMessage( handshake, &msgSize );
-        tr_peerIoWrite( handshake->io, msg, msgSize );
+        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
         tr_free( msg );
         handshake->haveSentBitTorrentHandshake = 1;
@@ -780 +781 @@
 
     setReadState( handshake, AWAITING_PAD_A );
-    tr_peerIoWrite( handshake->io, outbuf, walk - outbuf );
+    tr_peerIoWrite( handshake->io, outbuf, walk - outbuf, FALSE );
     return READ_NOW;
 }
@@ -992 +993 @@
 
     /* send it out */
-    tr_peerIoWriteBuf( handshake->io, outbuf );
+    tr_peerIoWriteBuf( handshake->io, outbuf, FALSE );
     evbuffer_free( outbuf );
 
@@ -1029 +1030 @@
 
 static ReadState
-canRead( struct bufferevent * evin,
-         void *               arg )
-{
-    tr_handshake *    handshake = (tr_handshake *) arg;
-    struct evbuffer * inbuf = EVBUFFER_INPUT ( evin );
+canRead( struct tr_iobuf * iobuf, void * arg, size_t * piece )
+{
+    tr_handshake *    handshake = arg;
+    struct evbuffer * inbuf = tr_iobuf_input( iobuf );
     ReadState         ret;
     int               readyForMore = TRUE;
+
+    /* no piece data in handshake */
+    *piece = 0;
 
     dbgmsg( handshake, "handling canRead; state is [%s]",
@@ -1137 +1140 @@
 
 static void
-gotError( struct bufferevent * evbuf UNUSED,
-          short                      what,
-          void *                     arg )
+gotError( struct tr_iobuf  * iobuf UNUSED,
+          short              what,
+          void             * arg )
 {
     tr_handshake * handshake = (tr_handshake *) arg;
@@ -1157 +1160 @@
         handshake->haveSentBitTorrentHandshake = 1;
         setReadState( handshake, AWAITING_HANDSHAKE );
-        tr_peerIoWrite( handshake->io, msg, msgSize );
+        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
         tr_free( msg );
     }
@@ -1179 +1182 @@
 {
     tr_handshake * handshake;
-
-    tr_peerIoSetBandwidthUnlimited( io, TR_UP );
-    tr_peerIoSetBandwidthUnlimited( io, TR_DOWN );
 
     handshake = tr_new0( tr_handshake, 1 );
@@ -1204 +1204 @@
         handshake->haveSentBitTorrentHandshake = 1;
         setReadState( handshake, AWAITING_HANDSHAKE );
-        tr_peerIoWrite( handshake->io, msg, msgSize );
+        tr_peerIoWrite( handshake->io, msg, msgSize, FALSE );
         tr_free( msg );
     }

branches/1.4x/libtransmission/net.c

@@ -123 +123 @@
 }
 
-int
-tr_netOpenTCP( const struct in_addr * addr,
-               tr_port_t              port )
+static void
+setSndBuf( tr_session * session UNUSED, int fd UNUSED )
+{
+#if 0
+    if( fd >= 0 )
+    {
+        const int sndbuf = session->so_sndbuf;
+        const int rcvbuf = session->so_rcvbuf;
+        setsockopt( fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof( sndbuf ) );
+        setsockopt( fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof( rcvbuf ) );
+    }
+#endif
+}
+
+int
+tr_netOpenTCP( tr_session            * session,
+               const struct in_addr  * addr,
+               tr_port_t               port )
 {
     int                s;
@@ -133 +148 @@
     if( ( s = createSocket( type ) ) < 0 )
         return -1;
+
+    setSndBuf( session, s );
 
     memset( &sock, 0, sizeof( sock ) );
@@ -198 +215 @@
 
 int
-tr_netAccept( int              b,
-              struct in_addr * addr,
-              tr_port_t *      port )
-{
-    return makeSocketNonBlocking( tr_fdSocketAccept( b, addr, port ) );
+tr_netAccept( tr_session      * session,
+              int               b,
+              struct in_addr  * addr,
+              tr_port_t       * port )
+{
+    int fd = makeSocketNonBlocking( tr_fdSocketAccept( b, addr, port ) );
+    setSndBuf( session, fd );
+    return fd;
 }
 

branches/1.4x/libtransmission/net.h

@@ -22 +22 @@
  * DEALINGS IN THE SOFTWARE.
  *****************************************************************************/
+
+#ifndef __TRANSMISSION__
+#error only libtransmission should #include this header.
+#endif
 
 #ifndef _TR_NET_H_
@@ -59 +63 @@
 struct in_addr;
 struct sockaddr_in;
+struct tr_session;
 
 /***********************************************************************
@@ -70 +75 @@
  * Sockets
  **********************************************************************/
-int  tr_netOpenTCP( const struct in_addr * addr,
+int  tr_netOpenTCP( struct tr_handle     * session,
+                    const struct in_addr * addr,
                     tr_port_t              port );
 
 int  tr_netBindTCP( int port );
 
-int  tr_netAccept( int    s,
-                   struct in_addr *,
-                          tr_port_t * );
+int  tr_netAccept( struct tr_handle  * session,
+                   int                 bound,
+                   struct in_addr    * setme_addr,
+                   tr_port_t         * setme_port );
 
 int  tr_netSetTOS( int s,

branches/1.4x/libtransmission/peer-common.h

@@ -10 +10 @@
  * $Id$
  */
+
+#ifndef __TRANSMISSION__
+#error only libtransmission should #include this header.
+#endif
 
 #ifndef TR_PEER_H
@@ -50 +54 @@
 {
     PeerEventType    eventType;
-    uint32_t         pieceIndex; /* for GOT_BLOCK, CANCEL */
-    uint32_t         offset; /* for GOT_BLOCK */
-    uint32_t         length; /* for GOT_BLOCK + GOT_DATA */
-    float            progress; /* for TR_PEER_PEER_PROGRESS */
-    int              err; /* errno for TR_PEER_GOT_ERROR */
+    uint32_t         pieceIndex;   /* for GOT_BLOCK, CANCEL */
+    uint32_t         offset;       /* for GOT_BLOCK */
+    uint32_t         length;       /* for GOT_BLOCK + GOT_DATA */
+    float            progress;     /* for PEER_PROGRESS */
+    int              err;          /* errno for GOT_ERROR */
+    int              wasPieceData; /* for GOT_DATA */
 }
 tr_peer_event;

branches/1.4x/libtransmission/peer-io.c

@@ -27 +27 @@
 
 #include "transmission.h"
+#include "bandwidth.h"
 #include "crypto.h"
+#include "iobuf.h"
+#include "list.h"
 #include "net.h"
 #include "peer-io.h"
-#include "ratecontrol.h"
 #include "trevent.h"
 #include "utils.h"
 
+#define MAGIC_NUMBER 206745
 #define IO_TIMEOUT_SECS 8
 
 static size_t
-addPacketOverhead( size_t d )
+getPacketOverhead( size_t d )
 {
     /**
@@ -57 +60 @@
     static const double assumed_payload_data_rate = 94.0;
 
-    return (size_t)( d * ( 100.0 / assumed_payload_data_rate ) );
+    return (size_t)( d * ( 100.0 / assumed_payload_data_rate ) - d );
 }
 
@@ -70 +73 @@
     } while( 0 )
 
-struct tr_bandwidth
-{
-    unsigned int    isUnlimited : 1;
-    size_t          bytesUsed;
-    size_t          bytesLeft;
+struct tr_datatype
+{
+    tr_bool  isPieceData;
+    size_t   length;
 };
 
 struct tr_peerIo
 {
-    unsigned int           isEncrypted               : 1;
-    unsigned int           isIncoming                : 1;
-    unsigned int           peerIdIsSet               : 1;
-    unsigned int           extendedProtocolSupported : 1;
-    unsigned int           fastPeersSupported        : 1;
-
-    uint8_t                encryptionMode;
-    uint8_t                timeout;
-    uint16_t               port;
-    int                    socket;
-
-    uint8_t                peerId[20];
-    time_t                 timeCreated;
-
-    tr_session *           session;
-
-    struct in_addr         in_addr;
-    struct bufferevent *   bufev;
-    struct evbuffer *      output;
-
-    tr_can_read_cb         canRead;
-    tr_did_write_cb        didWrite;
-    tr_net_error_cb        gotError;
-    void *                 userData;
-
-    size_t                 bufferSize[2];
-
-    struct tr_bandwidth    bandwidth[2];
-
-    tr_crypto *            crypto;
+    tr_bool                  isEncrypted;
+    tr_bool                  isIncoming;
+    tr_bool                  peerIdIsSet;
+    tr_bool                  extendedProtocolSupported;
+    tr_bool                  fastPeersSupported;
+
+    int                      magicNumber;
+
+    uint8_t                  encryptionMode;
+    uint8_t                  timeout;
+    uint16_t                 port;
+    int                      socket;
+
+    uint8_t                  peerId[20];
+    time_t                   timeCreated;
+
+    tr_session             * session;
+
+    struct in_addr           in_addr;
+    struct tr_iobuf        * iobuf;
+    tr_list                * output_datatypes; /* struct tr_datatype */
+
+    tr_can_read_cb           canRead;
+    tr_did_write_cb          didWrite;
+    tr_net_error_cb          gotError;
+    void *                   userData;
+
+    size_t                   bufferSize[2];
+
+    tr_bandwidth           * bandwidth;
+    tr_crypto              * crypto;
 };
-
-/**
-***
-**/
-
-static void
-adjustOutputBuffer( tr_peerIo * io )
-{
-    struct evbuffer * live = EVBUFFER_OUTPUT( io->bufev );
-
-    if( io->bandwidth[TR_UP].isUnlimited )
-    {
-        bufferevent_write_buffer( io->bufev, io->output );
-    }
-    else if( io->bandwidth[TR_UP].bytesLeft > EVBUFFER_LENGTH( live ) )
-    {
-        /* there's free space in bufev's output buffer;
-           try to fill it up */
-        const size_t desiredLength = io->bandwidth[TR_UP].bytesLeft;
-        const size_t under = desiredLength - EVBUFFER_LENGTH( live );
-        const size_t n = MIN( under, EVBUFFER_LENGTH( io->output ) );
-        bufferevent_write( io->bufev, EVBUFFER_DATA( io->output ), n );
-        evbuffer_drain( io->output, n );
-    }
-    else if( io->bandwidth[TR_UP].bytesLeft < EVBUFFER_LENGTH( live ) )
-    {
-        /* bufev's output buffer exceeds our bandwidth allocation;
-           move the excess out of bufev so it can't be sent yet */
-        const size_t      desiredLength = io->bandwidth[TR_UP].bytesLeft;
-        const size_t      over = EVBUFFER_LENGTH( live ) - desiredLength;
-        struct evbuffer * buf = evbuffer_new( );
-        evbuffer_add( buf, EVBUFFER_DATA( live ) + desiredLength, over );
-        evbuffer_add_buffer( buf, io->output );
-        evbuffer_free( io->output );
-        io->output = buf;
-        EVBUFFER_LENGTH( live ) = desiredLength;
-    }
-    else if( EVBUFFER_LENGTH( live ) )
-    {
-        bufferevent_enable( io->bufev, EV_WRITE );
-    }
-
-    io->bufferSize[TR_UP] = EVBUFFER_LENGTH( live );
-
-    dbgmsg( io, "after adjusting the output buffer, its size is now %zu",
-            io->bufferSize[TR_UP] );
-}
-
-static void
-adjustInputBuffer( tr_peerIo * io )
-{
-    if( io->bandwidth[TR_DOWN].isUnlimited )
-    {
-        dbgmsg( io, "unlimited reading..." );
-        bufferevent_setwatermark( io->bufev, EV_READ, 0, 0 );
-        bufferevent_enable( io->bufev, EV_READ );
-    }
-    else
-    {
-        const size_t n = io->bandwidth[TR_DOWN].bytesLeft;
-        if( n == 0 )
-        {
-            dbgmsg( io, "disabling reads because we've hit our limit" );
-            bufferevent_disable( io->bufev, EV_READ );
-        }
-        else
-        {
-            dbgmsg( io, "enabling reading of %zu more bytes", n );
-            bufferevent_setwatermark( io->bufev, EV_READ, 0, n );
-            bufferevent_enable( io->bufev, EV_READ );
-        }
-    }
-}
 
 /***
@@ -189 +119 @@
 
 static void
-didWriteWrapper( struct bufferevent * e,
-                 void *               vio )
+didWriteWrapper( struct tr_iobuf  * iobuf,
+                 size_t             bytes_transferred,
+                 void             * vio )
 {
     tr_peerIo *  io = vio;
-    const size_t len = EVBUFFER_LENGTH( EVBUFFER_OUTPUT( e ) );
-
-    dbgmsg( io, "didWrite... io->outputBufferSize was %zu, is now %zu",
-            io->bufferSize[TR_UP], len );
-
-    if( len < io->bufferSize[TR_UP] )
+
+    while( bytes_transferred )
     {
-        const size_t payload = io->bufferSize[TR_UP] - len;
-        const size_t n = addPacketOverhead( payload );
-        struct tr_bandwidth * b = &io->bandwidth[TR_UP];
-        b->bytesLeft -= MIN( b->bytesLeft, (size_t)n );
-        b->bytesUsed += n;
-        tr_rcTransferred( io->session->rawSpeed[TR_UP], n );
-        dbgmsg( io,
-                "wrote %zu bytes to peer... upload bytesLeft is now %zu",
-                n,
-                b->bytesLeft );
+        struct tr_datatype * next = io->output_datatypes->data;
+        const size_t payload = MIN( next->length, bytes_transferred );
+        const size_t overhead = getPacketOverhead( payload );
+
+        tr_bandwidthUsed( io->bandwidth, TR_UP, payload, next->isPieceData );
+
+        if( overhead > 0 )
+            tr_bandwidthUsed( io->bandwidth, TR_UP, overhead, FALSE );
+
+        if( io->didWrite )
+            io->didWrite( io, payload, next->isPieceData, io->userData );
+
+        bytes_transferred -= payload;
+        next->length -= payload;
+        if( !next->length )
+            tr_free( tr_list_pop_front( &io->output_datatypes ) );
     }
 
-    adjustOutputBuffer( io );
-
-    if( io->didWrite )
-        io->didWrite( e, io->userData );
+    if( EVBUFFER_LENGTH( tr_iobuf_output( iobuf ) ) )
+        tr_iobuf_enable( io->iobuf, EV_WRITE );
 }
 
 static void
-canReadWrapper( struct bufferevent * e,
-                void *               vio )
+canReadWrapper( struct tr_iobuf  * iobuf,
+                size_t             bytes_transferred UNUSED,
+                void              * vio )
 {
     int          done = 0;
@@ -226 +158 @@
     tr_peerIo *  io = vio;
     tr_session * session = io->session;
-    const size_t len = EVBUFFER_LENGTH( EVBUFFER_INPUT( e ) );
 
     dbgmsg( io, "canRead" );
-
-    /* if the input buffer has grown, record the bytes that were read */
-    if( len > io->bufferSize[TR_DOWN] )
-    {
-        const size_t payload = len - io->bufferSize[TR_DOWN];
-        const size_t n = addPacketOverhead( payload );
-        struct tr_bandwidth * b = io->bandwidth + TR_DOWN;
-        b->bytesLeft -= MIN( b->bytesLeft, (size_t)n );
-        b->bytesUsed += n;
-        tr_rcTransferred( io->session->rawSpeed[TR_DOWN], n );
-        dbgmsg( io,
-                "%zu new input bytes. bytesUsed is %zu, bytesLeft is %zu",
-                n, b->bytesUsed,
-                b->bytesLeft );
-
-        adjustInputBuffer( io );
-    }
 
     /* try to consume the input buffer */
@@ -254 +168 @@
         while( !done && !err )
         {
-            const int ret = io->canRead( e, io->userData );
+            size_t piece = 0;
+            const size_t oldLen = EVBUFFER_LENGTH( tr_iobuf_input( iobuf ) );
+            const int ret = io->canRead( iobuf, io->userData, &piece );
+
+            if( ret != READ_ERR )
+            {
+                const size_t used = oldLen - EVBUFFER_LENGTH( tr_iobuf_input( iobuf ) );
+                if( piece )
+                    tr_bandwidthUsed( io->bandwidth, TR_DOWN, piece, TRUE );
+                if( used != piece )
+                    tr_bandwidthUsed( io->bandwidth, TR_DOWN, used - piece, FALSE );
+            }
 
             switch( ret )
             {
                 case READ_NOW:
-                    if( EVBUFFER_LENGTH( e->input ) )
+                    if( EVBUFFER_LENGTH( tr_iobuf_input( iobuf )))
                         continue;
                     done = 1;
@@ -276 +201 @@
         tr_globalUnlock( session );
     }
-
-    if( !err )
-        io->bufferSize[TR_DOWN] = EVBUFFER_LENGTH( EVBUFFER_INPUT( e ) );
 }
 
 static void
-gotErrorWrapper( struct bufferevent * e,
-                 short                what,
-                 void *               userData )
+gotErrorWrapper( struct tr_iobuf  * iobuf,
+                 short              what,
+                 void             * userData )
 {
     tr_peerIo * c = userData;
 
     if( c->gotError )
-        c->gotError( e, what, c->userData );
+        c->gotError( iobuf, what, c->userData );
 }
 
@@ -299 +221 @@
 bufevNew( tr_peerIo * io )
 {
-    io->bufev = bufferevent_new( io->socket,
-                                 canReadWrapper,
-                                 didWriteWrapper,
-                                 gotErrorWrapper,
-                                 io );
-
-    /* tell libevent to call didWriteWrapper after every write,
-     * not just when the write buffer is empty */
-    bufferevent_setwatermark( io->bufev, EV_WRITE, INT_MAX, 0 );
-
-    bufferevent_settimeout( io->bufev, io->timeout, io->timeout );
-
-    bufferevent_enable( io->bufev, EV_READ | EV_WRITE );
+    io->iobuf = tr_iobuf_new( io->session,
+                              io->bandwidth,
+                              io->socket,
+                              EV_READ | EV_WRITE,
+                              canReadWrapper,
+                              didWriteWrapper,
+                              gotErrorWrapper,
+                              io );
+
+    tr_iobuf_settimeout( io->iobuf, io->timeout, io->timeout );
+}
+
+static int
+isPeerIo( const tr_peerIo * io )
+{
+    return ( io != NULL ) && ( io->magicNumber == MAGIC_NUMBER );
 }
 
@@ -328 +253 @@
 
     io = tr_new0( tr_peerIo, 1 );
+    io->magicNumber = MAGIC_NUMBER;
     io->crypto = tr_cryptoNew( torrentHash, isIncoming );
     io->session = session;
@@ -336 +262 @@
     io->timeout = IO_TIMEOUT_SECS;
     io->timeCreated = time( NULL );
-    io->output = evbuffer_new( );
-    io->bandwidth[TR_UP].isUnlimited = 1;
-    io->bandwidth[TR_DOWN].isUnlimited = 1;
     bufevNew( io );
+    tr_peerIoSetBandwidth( io, session->bandwidth );
     return io;
 }
@@ -371 +295 @@
     assert( torrentHash );
 
-    socket = tr_netOpenTCP( in_addr, port );
+    socket = tr_netOpenTCP( session, in_addr, port );
 
     return socket < 0
@@ -383 +307 @@
     tr_peerIo * io = vio;
 
-    evbuffer_free( io->output );
-    bufferevent_free( io->bufev );
+    tr_peerIoSetBandwidth( io, NULL );
+    tr_iobuf_free( io->iobuf );
     tr_netClose( io->socket );
     tr_cryptoFree( io->crypto );
+    tr_list_free( &io->output_datatypes, tr_free );
+
+    io->magicNumber = 0xDEAD;
     tr_free( io );
 }
@@ -405 +332 @@
 tr_peerIoGetSession( tr_peerIo * io )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
     assert( io->session );
 
@@ -415 +342 @@
                            uint16_t * port )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
 
     if( port )
@@ -443 +370 @@
 tr_peerIoTryRead( tr_peerIo * io )
 {
-    if( EVBUFFER_LENGTH( io->bufev->input ) )
-        canReadWrapper( io->bufev, io );
+    if( EVBUFFER_LENGTH( tr_iobuf_input( io->iobuf )))
+        (*canReadWrapper)( io->iobuf, ~0, io );
 }
 
@@ -476 +403 @@
         tr_netClose( io->socket );
 
-    io->socket = tr_netOpenTCP( &io->in_addr, io->port );
+    io->socket = tr_netOpenTCP( io->session, &io->in_addr, io->port );
 
     if( io->socket >= 0 )
     {
+        tr_bandwidth * bandwidth = io->bandwidth;
+        tr_peerIoSetBandwidth( io, NULL );
+
         tr_netSetTOS( io->socket, io->session->peerSocketTOS );
-
-        bufferevent_free( io->bufev );
+        tr_iobuf_free( io->iobuf );
         bufevNew( io );
+
+        tr_peerIoSetBandwidth( io, bandwidth );
         return 0;
     }
@@ -495 +426 @@
 {
     io->timeout = secs;
-    bufferevent_settimeout( io->bufev, io->timeout, io->timeout );
-    bufferevent_enable( io->bufev, EV_READ | EV_WRITE );
+    tr_iobuf_settimeout( io->iobuf, io->timeout, io->timeout );
+    tr_iobuf_enable( io->iobuf, EV_READ | EV_WRITE );
 }
 
@@ -507 +438 @@
                          const uint8_t * hash )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
 
     tr_cryptoSetTorrentHash( io->crypto, hash );
@@ -515 +446 @@
 tr_peerIoGetTorrentHash( tr_peerIo * io )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
     assert( io->crypto );
 
@@ -524 +455 @@
 tr_peerIoHasTorrentHash( const tr_peerIo * io )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
     assert( io->crypto );
 
@@ -538 +469 @@
                      const uint8_t * peer_id )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
 
     if( ( io->peerIdIsSet = peer_id != NULL ) )
@@ -549 +480 @@
 tr_peerIoGetPeersId( const tr_peerIo * io )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
     assert( io->peerIdIsSet );
 
@@ -563 +494 @@
                      int         flag )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
     assert( flag == 0 || flag == 1 );
 
@@ -573 +504 @@
                      int         flag )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
     assert( flag == 0 || flag == 1 );
 
@@ -582 +513 @@
 tr_peerIoSupportsLTEP( const tr_peerIo * io )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
 
     return io->extendedProtocolSupported;
@@ -590 +521 @@
 tr_peerIoSupportsFEXT( const tr_peerIo * io )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
 
     return io->fastPeersSupported;
@@ -599 +530 @@
 **/
 
-size_t
-tr_peerIoGetBandwidthUsed( const tr_peerIo * io,
-                           tr_direction      direction )
-{
-    assert( io );
-    assert( direction == TR_UP || direction == TR_DOWN );
-    return io->bandwidth[direction].bytesUsed;
+static size_t
+getDesiredOutputBufferSize( const tr_peerIo * io )
+{
+    /* this is all kind of arbitrary, but what seems to work well is
+     * being large enough to hold the next 15 seconds' worth of input,
+     * or two and a half blocks, whichever is bigger.
+     * It's okay to tweak this as needed */
+    const double maxBlockSize = 16 * 1024; /* 16 KiB is from BT spec */
+    const double currentSpeed = tr_bandwidthGetPieceSpeed( io->bandwidth, TR_UP );
+    const double period = 20; /* arbitrary */
+    return MAX( maxBlockSize*2.5, currentSpeed*1024*period );
 }
 
@@ -611 +546 @@
 tr_peerIoGetWriteBufferSpace( const tr_peerIo * io )
 {
-    const size_t desiredBufferLen = 4096;
-    const size_t currentLiveLen = EVBUFFER_LENGTH( EVBUFFER_OUTPUT( io->bufev ) );
-
-    const size_t currentLbufLen = EVBUFFER_LENGTH( io->output );
-    const size_t desiredLiveLen = io->bandwidth[TR_UP].isUnlimited
-                                ? INT_MAX
-                                : io->bandwidth[TR_UP].bytesLeft;
-
-    const size_t currentLen = currentLiveLen + currentLbufLen;
-    const size_t desiredLen = desiredBufferLen + desiredLiveLen;
-
-    size_t       freeSpace = 0;
+    const size_t desiredLen = getDesiredOutputBufferSize( io );
+    const size_t currentLen = EVBUFFER_LENGTH( tr_iobuf_output( io->iobuf ) );
+    size_t freeSpace = 0;
 
     if( desiredLen > currentLen )
         freeSpace = desiredLen - currentLen;
-    else
-        freeSpace = 0;
 
     return freeSpace;
@@ -633 +557 @@
 
 void
-tr_peerIoSetBandwidth( tr_peerIo *  io,
-                       tr_direction direction,
-                       size_t       bytesLeft )
-{
-    struct tr_bandwidth * b;
-
-    assert( io );
-    assert( direction == TR_UP || direction == TR_DOWN );
-
-    b = io->bandwidth + direction;
-    b->isUnlimited = 0;
-    b->bytesUsed = 0;
-    b->bytesLeft = bytesLeft;
-
-    adjustOutputBuffer( io );
-    adjustInputBuffer( io );
-}
-
-void
-tr_peerIoSetBandwidthUnlimited( tr_peerIo *  io,
-                                tr_direction direction )
-{
-    struct tr_bandwidth * b;
-
-    assert( io );
-    assert( direction == TR_UP || direction == TR_DOWN );
-
-    b = io->bandwidth + direction;
-    b->isUnlimited = 1;
-    b->bytesUsed = 0;
-    b->bytesLeft = 0;
-
-    adjustInputBuffer( io );
-    adjustOutputBuffer( io );
+tr_peerIoSetBandwidth( tr_peerIo     * io,
+                       tr_bandwidth  * bandwidth )
+{
+    assert( isPeerIo( io ) );
+
+    if( io->bandwidth )
+        tr_bandwidthRemoveBuffer( io->bandwidth, io->iobuf );
+
+    io->bandwidth = bandwidth;
+    tr_iobuf_set_bandwidth( io->iobuf, bandwidth );
+
+    if( io->bandwidth )
+        tr_bandwidthAddBuffer( io->bandwidth, io->iobuf );
+
+    tr_iobuf_enable( io->iobuf, EV_READ | EV_WRITE );
 }
 
@@ -683 +588 @@
                         int         encryptionMode )
 {
-    assert( io );
+    assert( isPeerIo( io ) );
     assert( encryptionMode == PEER_ENCRYPTION_NONE
           || encryptionMode == PEER_ENCRYPTION_RC4 );
@@ -700 +605 @@
 **/
 
-int
-tr_peerIoWantsBandwidth( const tr_peerIo * io,
-                         tr_direction      direction )
-{
-    assert( direction == TR_UP || direction == TR_DOWN );
-
-    if( direction == TR_DOWN )
-    {
-        return TRUE; /* FIXME -- is there a good way to test for this? */
-    }
-    else
-    {
-        return EVBUFFER_LENGTH( EVBUFFER_OUTPUT( io->bufev ) )
-               || EVBUFFER_LENGTH( io->output );
-    }
-}
-
-void
-tr_peerIoWrite( tr_peerIo *  io,
-                const void * writeme,
-                size_t       writemeLen )
-{
+void
+tr_peerIoWrite( tr_peerIo   * io,
+                const void  * writeme,
+                size_t        writemeLen,
+                int           isPieceData )
+{
+    struct tr_datatype * datatype;
     assert( tr_amInEventThread( io->session ) );
     dbgmsg( io, "adding %zu bytes into io->output", writemeLen );
 
-    if( io->bandwidth[TR_UP].isUnlimited )
-        bufferevent_write( io->bufev, writeme, writemeLen );
-    else
-        evbuffer_add( io->output, writeme, writemeLen );
-
-    adjustOutputBuffer( io );
-}
-
-void
-tr_peerIoWriteBuf( tr_peerIo *       io,
-                   struct evbuffer * buf )
+    datatype = tr_new( struct tr_datatype, 1 );
+    datatype->isPieceData = isPieceData != 0;
+    datatype->length = writemeLen;
+    tr_list_append( &io->output_datatypes, datatype );
+
+    evbuffer_add( tr_iobuf_output( io->iobuf ), writeme, writemeLen );
+    tr_iobuf_enable( io->iobuf, EV_WRITE );
+}
+
+void
+tr_peerIoWriteBuf( tr_peerIo         * io,
+                   struct evbuffer   * buf,
+                   int                 isPieceData )
 {
     const size_t n = EVBUFFER_LENGTH( buf );
 
-    tr_peerIoWrite( io, EVBUFFER_DATA( buf ), n );
+    tr_peerIoWrite( io, EVBUFFER_DATA( buf ), n, isPieceData );
     evbuffer_drain( buf, n );
 }
@@ -875 +767 @@
     return time( NULL ) - io->timeCreated;
 }
-

branches/1.4x/libtransmission/peer-io.h

@@ -11 +11 @@
  */
 
+#ifndef __TRANSMISSION__
+#error only libtransmission should #include this header.
+#endif
+
 #ifndef TR_PEER_IO_H
 #define TR_PEER_IO_H
@@ -20 +24 @@
 struct in_addr;
 struct evbuffer;
-struct bufferevent;
-struct tr_handle;
+struct tr_bandwidth;
 struct tr_crypto;
+struct tr_iobuf;
 typedef struct tr_peerIo tr_peerIo;
 
@@ -29 +33 @@
 **/
 
-tr_peerIo*           tr_peerIoNewOutgoing(
-    struct tr_handle *     session,
-    const struct in_addr * addr,
-    int                    port,
-    const  uint8_t *
-                           torrentHash );
-
-tr_peerIo*           tr_peerIoNewIncoming( struct tr_handle *     session,
+tr_peerIo*           tr_peerIoNewOutgoing( struct tr_handle     * session,
+                                           const struct in_addr * addr,
+                                           int                    port,
+                                           const  uint8_t       * torrentHash );
+
+tr_peerIo*           tr_peerIoNewIncoming( struct tr_handle     * session,
                                            const struct in_addr * addr,
                                            uint16_t               port,
@@ -109 +111 @@
 ReadState;
 
-typedef ReadState ( *tr_can_read_cb )( struct bufferevent*, void* user_data );
-typedef void ( *tr_did_write_cb )( struct bufferevent *, void * );
-typedef void ( *tr_net_error_cb )( struct bufferevent *, short what, void * );
-
-void              tr_peerIoSetIOFuncs( tr_peerIo *     io,
-                                       tr_can_read_cb  readcb,
-                                       tr_did_write_cb writecb,
-                                       tr_net_error_cb errcb,
-                                       void *          user_data );
-
-int               tr_peerIoWantsBandwidth( const tr_peerIo * io,
-                                                             tr_direction );
-
-#if 0
-void              tr_peerIoTryRead( tr_peerIo * io );
-
-#endif
-
-void              tr_peerIoWrite( tr_peerIo *  io,
-                                  const void * writeme,
-                                  size_t       writemeLen );
-
-void              tr_peerIoWriteBuf( tr_peerIo *       io,
-                                     struct evbuffer * buf );
-
+typedef ReadState ( *tr_can_read_cb  )( struct tr_iobuf  * iobuf,
+                                        void             * user_data,
+                                        size_t           * setme_piece_byte_count );
+
+typedef void      ( *tr_did_write_cb )( tr_peerIo        * io,
+                                        size_t             bytesWritten,
+                                        int                wasPieceData,
+                                        void             * userData );
+
+typedef void      ( *tr_net_error_cb )( struct tr_iobuf  * ev,
+                                        short              what,
+                                        void             * userData );
+
+void    tr_peerIoSetIOFuncs      ( tr_peerIo        * io,
+                                   tr_can_read_cb     readcb,
+                                   tr_did_write_cb    writecb,
+                                   tr_net_error_cb    errcb,
+                                   void             * user_data );
+
+/**
+***
+**/
+
+void    tr_peerIoWrite          ( tr_peerIo         * io,
+                                  const void        * writeme,
+                                  size_t              writemeLen,
+                                  int                 isPieceData );
+
+void    tr_peerIoWriteBuf       ( tr_peerIo         * io,
+                                  struct evbuffer   * buf,
+                                  int                 isPieceData );
 
 /**
@@ -196 +204 @@
 **/
 
-size_t            tr_peerIoGetBandwidthUsed( const tr_peerIo * io,
-                                             tr_direction      direction );
-
 size_t            tr_peerIoGetWriteBufferSpace( const tr_peerIo * io );
 
-void              tr_peerIoSetBandwidth( tr_peerIo *  io,
-                                         tr_direction direction,
-                                         size_t       bytesLeft );
-
-void              tr_peerIoSetBandwidthUnlimited( tr_peerIo *  io,
-                                                  tr_direction direction );
+void              tr_peerIoSetBandwidth( tr_peerIo            * io,
+                                         struct tr_bandwidth  * bandwidth );
+
+void              tr_peerIoBandwidthUsed( tr_peerIo           * io,
+                                          tr_direction          direction,
+                                          size_t                byteCount,
+                                          int                   isPieceData );
+
 
 

branches/1.4x/libtransmission/peer-mgr-private.h

@@ -10 +10 @@
  * $Id$
  */
+
+#ifndef __TRANSMISSION__
+#error only libtransmission should #include this header.
+#endif
 
 #ifndef TR_PEER_MGR_PRIVATE_H
@@ -24 +28 @@
 #include "publish.h" /* tr_publisher_tag */
 
+struct tr_bandwidth;
 struct tr_bitfield;
 struct tr_peerIo;
 struct tr_peermsgs;
-struct tr_ratecontrol;
 
 enum
@@ -38 +42 @@
 typedef struct tr_peer
 {
-    unsigned int             peerIsChoked       : 1;
-    unsigned int             peerIsInterested   : 1;
-    unsigned int             clientIsChoked     : 1;
-    unsigned int             clientIsInterested : 1;
-    unsigned int             doPurge            : 1;
+    tr_bool                  peerIsChoked;
+    tr_bool                  peerIsInterested;
+    tr_bool                  clientIsChoked;
+    tr_bool                  clientIsInterested;
+    tr_bool                  doPurge;
 
     /* number of bad pieces they've contributed to */
@@ -68 +72 @@
     tr_publisher_tag         msgsTag;
 
-    /* the rate at which pieces are being transferred between client and peer.
-     * protocol overhead is NOT included; this is only the piece data */
-    struct tr_ratecontrol  * pieceSpeed[2];
+    struct tr_bandwidth    * bandwidth;
 }
 tr_peer;

branches/1.4x/libtransmission/peer-mgr.c

@@ -20 +20 @@
 
 #include "transmission.h"
+#include "bandwidth.h"
+#include "bencode.h"
 #include "blocklist.h"
 #include "clients.h"
@@ -32 +34 @@
 #include "peer-msgs.h"
 #include "ptrarray.h"
-#include "ratecontrol.h"
 #include "stats.h" /* tr_statsAddUploaded, tr_statsAddDownloaded */
 #include "torrent.h"
@@ -60 +61 @@
 
     /* max # of peers to ask fer per torrent per reconnect pulse */
-    MAX_RECONNECTIONS_PER_PULSE = 2,
+    MAX_RECONNECTIONS_PER_PULSE = 4,
 
     /* max number of peers to ask for per second overall.
     * this throttle is to avoid overloading the router */
-    MAX_CONNECTIONS_PER_SECOND = 4,
+    MAX_CONNECTIONS_PER_SECOND = 8,
 
     /* number of unchoked peers per torrent.
      * FIXME: this probably ought to be configurable */
-    MAX_UNCHOKED_PEERS = 12,
+    MAX_UNCHOKED_PEERS = 14,
 
     /* number of bad pieces a peer is allowed to send before we ban them */
-    MAX_BAD_PIECES_PER_PEER = 3,
+    MAX_BAD_PIECES_PER_PEER = 5,
 
     /* use for bitwise operations w/peer_atom.myflags */
@@ -107 +108 @@
 typedef struct
 {
-    unsigned int    isRunning : 1;
+    tr_bool         isRunning;
 
     uint8_t         hash[SHA_DIGEST_LENGTH];
@@ -131 +132 @@
     tr_ptrArray     * incomingHandshakes; /* tr_handshake */
     tr_timer        * bandwidthTimer;
-    tr_ratecontrol  * globalPoolRawSpeed[2];
 };
 
@@ -323 +323 @@
 
 static tr_peer*
-peerConstructor( const struct in_addr * in_addr )
+peerConstructor( tr_torrent * tor, const struct in_addr * in_addr )
 {
     tr_peer * p;
@@ -329 +329 @@
     p = tr_new0( tr_peer, 1 );
     memcpy( &p->in_addr, in_addr, sizeof( struct in_addr ) );
-    p->pieceSpeed[TR_CLIENT_TO_PEER] = tr_rcInit( );
-    p->pieceSpeed[TR_PEER_TO_CLIENT] = tr_rcInit( );
+    p->bandwidth = tr_bandwidthNew( tor->session, tor->bandwidth );
     return p;
 }
@@ -346 +345 @@
     if( peer == NULL )
     {
-        peer = peerConstructor( in_addr );
+        peer = peerConstructor( torrent->tor, in_addr );
         tr_ptrArrayInsertSorted( torrent->peers, peer, peerCompare );
     }
@@ -368 +367 @@
     tr_free( peer->client );
 
-    tr_rcClose( peer->pieceSpeed[TR_CLIENT_TO_PEER] );
-    tr_rcClose( peer->pieceSpeed[TR_PEER_TO_CLIENT] );
+    tr_bandwidthFree( peer->bandwidth );
+
     tr_free( peer );
 }
@@ -517 +516 @@
     m->torrents = tr_ptrArrayNew( );
     m->incomingHandshakes = tr_ptrArrayNew( );
-    m->globalPoolRawSpeed[TR_CLIENT_TO_PEER] = tr_rcInit( );
-    m->globalPoolRawSpeed[TR_PEER_TO_CLIENT] = tr_rcInit( );
     m->bandwidthTimer = tr_timerNew( session, bandwidthPulse, m, BANDWIDTH_PERIOD_MSEC );
     return m;
@@ -529 +526 @@
 
     tr_timerFree( &manager->bandwidthTimer );
-    tr_rcClose( manager->globalPoolRawSpeed[TR_CLIENT_TO_PEER] );
-    tr_rcClose( manager->globalPoolRawSpeed[TR_PEER_TO_CLIENT] );
 
     /* free the handshakes.  Abort invokes handshakeDoneCB(), which removes
@@ -1017 +1012 @@
             const time_t now = time( NULL );
             tr_torrent * tor = t->tor;
+
             tor->activityDate = now;
-            tor->uploadedCur += e->length;
-            if( peer )
-                tr_rcTransferred ( peer->pieceSpeed[TR_CLIENT_TO_PEER], e->length );
-            tr_rcTransferred ( tor->pieceSpeed[TR_CLIENT_TO_PEER], e->length );
-            tr_rcTransferred ( tor->session->pieceSpeed[TR_CLIENT_TO_PEER], e->length );
-            tr_statsAddUploaded( tor->session, e->length );
-            if( peer )
-            {
+
+            if( e->wasPieceData )
+                tor->uploadedCur += e->length;
+
+            /* update the stats */
+            if( e->wasPieceData )
+                tr_statsAddUploaded( tor->session, e->length );
+
+            /* update our atom */
+            if( peer ) {
                 struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
                 a->piece_data_time = now;
             }
+
             break;
         }
@@ -1036 +1035 @@
             const time_t now = time( NULL );
             tr_torrent * tor = t->tor;
+
             tor->activityDate = now;
-            tr_statsAddDownloaded( tor->session, e->length );
-            if( peer )
-                tr_rcTransferred ( peer->pieceSpeed[TR_PEER_TO_CLIENT], e->length );
-            tr_rcTransferred ( tor->pieceSpeed[TR_PEER_TO_CLIENT], e->length );
-            tr_rcTransferred ( tor->session->pieceSpeed[TR_PEER_TO_CLIENT], e->length );
+
             /* only add this to downloadedCur if we got it from a peer --
              * webseeds shouldn't count against our ratio.  As one tracker
@@ -1048 +1044 @@
              * to manage the swarms, not the web server and does not fit
              * into the jurisdiction of the tracker." */
-            if( peer )
+            if( peer && e->wasPieceData )
                 tor->downloadedCur += e->length;
+
+            /* update the stats */ 
+            if( e->wasPieceData )
+                tr_statsAddDownloaded( tor->session, e->length );
+
+            /* update our atom */
             if( peer ) {
                 struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
                 a->piece_data_time = now;
             }
+
             break;
         }
@@ -1276 +1279 @@
                 if( !peer_id )
                     peer->client = NULL;
-                else
-                {
+                else {
                     char client[128];
                     tr_clientForId( client, sizeof( client ), peer_id );
                     peer->client = tr_strdup( client );
                 }
+
                 peer->port = port;
                 peer->io = io;
-                peer->msgs =
-                    tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t,
-                                    &peer->msgsTag );
+                peer->msgs = tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t, &peer->msgsTag );
+                tr_peerIoSetBandwidth( io, peer->bandwidth );
 
                 success = TRUE;
@@ -1768 +1770 @@
     assert( direction==TR_CLIENT_TO_PEER || direction==TR_PEER_TO_CLIENT );
 
-    return tr_rcRate( peer->pieceSpeed[direction] );
+    return tr_bandwidthGetPieceSpeed( peer->bandwidth, direction );
 }
 
@@ -1799 +1801 @@
         tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
                    sizeof( stat->client ) );
-        stat->port               = peer->port;
+        stat->port               = ntohs( peer->port );
         stat->from               = atom->from;
         stat->progress           = peer->progress;
@@ -1841 +1843 @@
 struct ChokeData
 {
-    unsigned int    doUnchoke    : 1;
-    unsigned int    isInterested : 1;
-    unsigned int    isChoked     : 1;
+    tr_bool         doUnchoke;
+    tr_bool         isInterested;
+    tr_bool         isChoked;
     int             rate;
     tr_peer *       peer;
@@ -1903 +1905 @@
             n->isInterested = peer->peerIsInterested;
             n->isChoked     = peer->peerIsChoked;
-            n->rate = (int)(tr_peerGetPieceSpeed( peer, TR_CLIENT_TO_PEER )
-                            + tr_peerGetPieceSpeed( peer, TR_PEER_TO_CLIENT ) );
+            n->rate         = tr_peerGetPieceSpeed( peer, TR_CLIENT_TO_PEER ) * 1024;
         }
     }
@@ -2321 +2322 @@
 ****/
 
-static double
-allocateHowMuch( double                  desired_average_kb_per_sec,
-                 const tr_ratecontrol  * ratecontrol )
-{
-    const int pulses_per_history = TR_RATECONTROL_HISTORY_MSEC / BANDWIDTH_PERIOD_MSEC;
-    const double seconds_per_pulse = BANDWIDTH_PERIOD_MSEC / 1000.0;
-    const double baseline_bytes_per_pulse = desired_average_kb_per_sec * 1024.0 * seconds_per_pulse;
-    const double min = baseline_bytes_per_pulse * 0.80;
-    const double max = baseline_bytes_per_pulse * 1.10;
-    const double current_bytes_per_pulse = tr_rcRate( ratecontrol ) * 1024.0 * seconds_per_pulse;
-    const double next_pulse_bytes = baseline_bytes_per_pulse * ( pulses_per_history + 1 )
-                                  - ( current_bytes_per_pulse * pulses_per_history );
-    double clamped;
-
-    /* clamp the return value to lessen oscillation */
-    clamped = next_pulse_bytes;
-    clamped = MAX( clamped, min );
-    clamped = MIN( clamped, max );
-
-#if 0
-fprintf( stderr, "desiredAvgKB is %5.2f, rate is %5.2f, allocating %5.2f (%5.2f)\n",
-         desired_average_kb_per_sec,
-         tr_rcRate( ratecontrol ),
-         clamped/1024.0,
-         next_pulse_bytes/1024.0 );
-#endif
-
-    return clamped;
-}
-
-/**
- * Distributes a fixed amount of bandwidth among a set of peers.
- *
- * @param peerArray peers whose client-to-peer bandwidth will be set
- * @param direction whether to allocate upload or download bandwidth
- * @param history recent bandwidth history for these peers
- * @param desiredAvgKB overall bandwidth goal for this set of peers
- */
-static void
-setPeerBandwidth( tr_ptrArray          * peerArray,
-                  const tr_direction     direction,
-                  const tr_ratecontrol * ratecontrol,
-                  double                 desiredAvgKB )
-{
-    const int    peerCount = tr_ptrArraySize( peerArray );
-    const double bytes = allocateHowMuch( desiredAvgKB, ratecontrol );
-    const double welfareBytes = MIN( 2048, bytes * 0.2 );
-    const double meritBytes = MAX( 0, bytes - welfareBytes );
-    tr_peer **   peers = (tr_peer**) tr_ptrArrayBase( peerArray );
-    tr_peer **   candidates = tr_new( tr_peer *, peerCount );
-    int          i;
-    int          candidateCount;
-    double       welfare;
-    size_t       bytesUsed;
-
-    assert( meritBytes >= 0.0 );
-    assert( welfareBytes >= 0.0 );
-    assert( direction == TR_UP || direction == TR_DOWN );
-
-    for( i = candidateCount = 0; i < peerCount; ++i )
-        if( tr_peerIoWantsBandwidth( peers[i]->io, direction ) )
-            candidates[candidateCount++] = peers[i];
-        else
-            tr_peerIoSetBandwidth( peers[i]->io, direction, 0 );
-
-    for( i = bytesUsed = 0; i < candidateCount; ++i )
-        bytesUsed += tr_peerIoGetBandwidthUsed( candidates[i]->io,
-                                                direction );
-
-    welfare = welfareBytes / candidateCount;
-
-    for( i = 0; i < candidateCount; ++i )
-    {
-        tr_peer *    peer = candidates[i];
-        const double merit = bytesUsed
-                             ? ( meritBytes *
-                                tr_peerIoGetBandwidthUsed( peer->io,
-                                                           direction ) ) /
-                             bytesUsed
-                             : ( meritBytes / candidateCount );
-        tr_peerIoSetBandwidth( peer->io, direction, merit + welfare );
-    }
-
-    /* cleanup */
-    tr_free( candidates );
-}
-
-static size_t
-countHandshakeBandwidth( tr_ptrArray * handshakes,
-                         tr_direction  direction )
-{
-    const int n = tr_ptrArraySize( handshakes );
-    int       i;
-    size_t    total;
-
-    for( i = total = 0; i < n; ++i )
-    {
-        tr_peerIo * io = tr_handshakeGetIO( tr_ptrArrayNth( handshakes, i ) );
-        total += tr_peerIoGetBandwidthUsed( io, direction );
-    }
-    return total;
-}
-
-static size_t
-countPeerBandwidth( tr_ptrArray * peers,
-                    tr_direction  direction )
-{
-    const int n = tr_ptrArraySize( peers );
-    int       i;
-    size_t    total;
-
-    for( i = total = 0; i < n; ++i )
-    {
-        tr_peer * peer = tr_ptrArrayNth( peers, i );
-        total += tr_peerIoGetBandwidthUsed( peer->io, direction );
-    }
-    return total;
-}
-
-static void
-givePeersUnlimitedBandwidth( tr_ptrArray * peers,
-                             tr_direction  direction )
-{
-    const int n = tr_ptrArraySize( peers );
-    int       i;
-
-    for( i = 0; i < n; ++i )
-    {
-        tr_peer * peer = tr_ptrArrayNth( peers, i );
-        tr_peerIoSetBandwidthUnlimited( peer->io, direction );
-    }
-}
-
 static void
 pumpAllPeers( tr_peerMgr * mgr )
@@ -2460 +2328 @@
     int       i, j;
 
-    for( i = 0; i < torrentCount; ++i )
+    for( i=0; i<torrentCount; ++i )
     {
         Torrent * t = tr_ptrArrayNth( mgr->torrents, i );
-        for( j = 0; j < tr_ptrArraySize( t->peers ); ++j )
+        for( j=0; j<tr_ptrArraySize( t->peers ); ++j )
         {
             tr_peer * peer = tr_ptrArrayNth( t->peers, j );
@@ -2471 +2339 @@
 }
 
-/**
- * Allocate bandwidth for each peer connection.
- *
- * @param mgr the peer manager
- * @param direction whether to allocate upload or download bandwidth
- * @return the amount of directional bandwidth used since the last pulse.
- */
-static double
-allocateBandwidth( tr_peerMgr * mgr,
-                   tr_direction direction )
-{
-    tr_session *  session = mgr->session;
-    const int     torrentCount = tr_ptrArraySize( mgr->torrents );
-    Torrent **    torrents = (Torrent **) tr_ptrArrayBase( mgr->torrents );
-    tr_ptrArray * globalPool = tr_ptrArrayNew( );
-    double        allBytesUsed = 0;
-    size_t        poolBytesUsed = 0;
-    int           i;
-
-    assert( mgr );
-    assert( direction == TR_UP || direction == TR_DOWN );
-
-    /* before allocating bandwidth, pump the connected peers */
+static int
+bandwidthPulse( void * vmgr )
+{
+    tr_peerMgr * mgr = vmgr;
+    managerLock( mgr );
+
     pumpAllPeers( mgr );
-
-    for( i=0; i<torrentCount; ++i )
-    {
-        Torrent * t = torrents[i];
-        size_t used;
-        tr_speedlimit speedMode;
-
-        /* no point in allocating bandwidth for stopped torrents */
-        if( tr_torrentGetActivity( t->tor ) == TR_STATUS_STOPPED )
-            continue;
-
-        used = countPeerBandwidth( t->peers, direction );
-        countHandshakeBandwidth( t->outgoingHandshakes, direction );
-
-        /* remember this torrent's bytes used */
-        tr_rcTransferred( t->tor->rawSpeed[direction], used );
-
-        /* add this torrent's bandwidth use to allBytesUsed */
-        allBytesUsed += used;
-
-        /* if piece data is disallowed, don't bother limiting bandwidth --
-         * we won't be asking for, or sending out, any pieces */
-        if( !tr_torrentIsPieceTransferAllowed( t->tor, direction ) )
-            speedMode = TR_SPEEDLIMIT_UNLIMITED;
-        else
-            speedMode = tr_torrentGetSpeedMode( t->tor, direction );
-            
-        /* process the torrent's peers based on its speed mode */
-        switch( speedMode )
-        {
-            case TR_SPEEDLIMIT_UNLIMITED:
-                givePeersUnlimitedBandwidth( t->peers, direction );
-                break;
-
-            case TR_SPEEDLIMIT_SINGLE:
-                setPeerBandwidth( t->peers, direction,
-                                  t->tor->rawSpeed[direction],
-                                  tr_torrentGetSpeedLimit( t->tor, direction ) );
-                break;
-
-            case TR_SPEEDLIMIT_GLOBAL:
-            {
-                int       i;
-                const int n = tr_ptrArraySize( t->peers );
-                for( i = 0; i < n; ++i )
-                    tr_ptrArrayAppend( globalPool,
-                                      tr_ptrArrayNth( t->peers, i ) );
-                poolBytesUsed += used;
-                break;
-            }
-        }
-    }
-
-    /* add incoming handshakes to the global pool */
-    i = countHandshakeBandwidth( mgr->incomingHandshakes, direction );
-    allBytesUsed += i;
-    poolBytesUsed += i;
-
-    tr_rcTransferred( mgr->globalPoolRawSpeed[direction], poolBytesUsed );
-
-    /* handle the global pool's connections */
-    if( !tr_sessionIsSpeedLimitEnabled( session, direction ) )
-        givePeersUnlimitedBandwidth( globalPool, direction );
-    else
-        setPeerBandwidth( globalPool, direction,
-                          mgr->globalPoolRawSpeed[direction],
-                          tr_sessionGetSpeedLimit( session, direction ) );
-
-    /* now that we've allocated bandwidth, pump all the connected peers */
+    tr_bandwidthAllocate( mgr->session->bandwidth, TR_UP, BANDWIDTH_PERIOD_MSEC );
+    tr_bandwidthAllocate( mgr->session->bandwidth, TR_DOWN, BANDWIDTH_PERIOD_MSEC );
     pumpAllPeers( mgr );
-
-    /* cleanup */
-    tr_ptrArrayFree( globalPool, NULL );
-    return allBytesUsed;
-}
-
-static int
-bandwidthPulse( void * vmgr )
-{
-    tr_peerMgr * mgr = vmgr;
-    int          i;
-
-    managerLock( mgr );
-
-    /* allocate the upload and download bandwidth */
-    for( i = 0; i < 2; ++i )
-        allocateBandwidth( mgr, i );
 
     managerUnlock( mgr );
     return TRUE;
 }
-

branches/1.4x/libtransmission/peer-mgr.h

@@ -10 +10 @@
  * $Id$
  */
+
+#ifndef __TRANSMISSION__
+#error only libtransmission should #include this header.
+#endif
 
 #ifndef TR_PEER_MGR_H

branches/1.4x/libtransmission/peer-msgs.c

@@ -25 +25 @@
 #include "crypto.h"
 #include "inout.h"
+#include "iobuf.h"
 #ifdef WIN32
 #include "net.h" /* for ECONN */
@@ -261 +262 @@
 struct tr_peermsgs
 {
-    unsigned int    peerSentBitfield        : 1;
-    unsigned int    peerSupportsPex         : 1;
-    unsigned int    clientSentLtepHandshake : 1;
-    unsigned int    peerSentLtepHandshake   : 1;
-    unsigned int    sendingBlock            : 1;
+    tr_bool         peerSentBitfield;
+    tr_bool         peerSupportsPex;
+    tr_bool         clientSentLtepHandshake;
+    tr_bool         peerSentLtepHandshake;
 
     uint8_t         state;
@@ -286 +286 @@
     tr_publisher_t *       publisher;
 
-    struct evbuffer *      outBlock; /* buffer of the current piece message */
     struct evbuffer *      outMessages; /* all the non-piece messages */
 
@@ -345 +344 @@
 }
 
-#define dbgmsg( msgs, ... ) myDebug( __FILE__, __LINE__, msgs, __VA_ARGS__ )
+#define dbgmsg( msgs, ... ) \
+    do { \
+        if( tr_deepLoggingIsActive( ) ) \
+            myDebug( __FILE__, __LINE__, msgs, __VA_ARGS__ ); \
+    } while( 0 )
 
 /**
@@ -430 +433 @@
 **/
 
-static const tr_peer_event blankEvent = { 0, 0, 0, 0, 0.0f, 0 };
+static const tr_peer_event blankEvent = { 0, 0, 0, 0, 0.0f, 0, 0 };
 
 static void
@@ -484 +487 @@
 static void
 fireClientGotData( tr_peermsgs * msgs,
-                   uint32_t      length )
+                   uint32_t      length,
+                   int           wasPieceData )
 {
     tr_peer_event e = blankEvent;
@@ -490 +494 @@
     e.length = length;
     e.eventType = TR_PEER_CLIENT_GOT_DATA;
+    e.wasPieceData = wasPieceData;
     publish( msgs, &e );
 }
 
 static void
-firePeerGotData( tr_peermsgs * msgs,
-                 uint32_t      length )
+firePeerGotData( tr_peermsgs  * msgs,
+                 uint32_t       length,
+                 int            wasPieceData )
 {
     tr_peer_event e = blankEvent;
@@ -501 +507 @@
     e.length = length;
     e.eventType = TR_PEER_PEER_GOT_DATA;
+    e.wasPieceData = wasPieceData;
+
     publish( msgs, &e );
 }
@@ -906 +914 @@
     **/
 
-    dbgmsg( msgs, "added req for piece %lu", (unsigned long)index );
+    dbgmsg( msgs, "adding req for %"PRIu32":%"PRIu32"->%"PRIu32" to our `will request' list",
+            index, offset, length );
     req.time_requested = time( NULL );
     reqListAppend( &msgs->clientWillAskFor, &req );
@@ -918 +927 @@
     struct request_list a = msgs->clientWillAskFor;
     struct request_list b = msgs->clientAskedFor;
+    dbgmsg( msgs, "cancelling all requests to peer" );
 
     msgs->clientAskedFor = REQUEST_LIST_INIT;
@@ -945 +955 @@
     assert( length > 0 );
 
+
     /* have we asked the peer for this piece? */
     req.index = pieceIndex;
@@ -951 +962 @@
 
     /* if it's only in the queue and hasn't been sent yet, free it */
-    if( reqListRemove( &msgs->clientWillAskFor, &req ) )
+    if( reqListRemove( &msgs->clientWillAskFor, &req ) ) {
+        dbgmsg( msgs, "cancelling %"PRIu32":%"PRIu32"->%"PRIu32"\n", pieceIndex, offset, length );
         fireCancelledReq( msgs, &req );
+    }
 
     /* if it's already been sent, send a cancel message too */
     if( reqListRemove( &msgs->clientAskedFor, &req ) ) {
+        dbgmsg( msgs, "cancelling %"PRIu32":%"PRIu32"->%"PRIu32"\n", pieceIndex, offset, length );
         protocolSendCancel( msgs, &req );
         fireCancelledReq( msgs, &req );
@@ -1029 +1043 @@
     }
 
-    dbgmsg( msgs, "here is the ltep handshake we got [%*.*s]", len, len,
-            tmp );
+    dbgmsg( msgs, "here is the handshake: [%*.*s]", len, len,  tmp );
 
     /* does the peer prefer encrypted connections? */
@@ -1300 +1313 @@
                            const struct peer_request * req );
 
-static void
-clientGotBytes( tr_peermsgs * msgs,
-                uint32_t      byteCount )
-{
-    msgs->info->pieceDataActivityDate = time( NULL );
-    fireClientGotData( msgs, byteCount );
-}
-
 static int
-readBtPiece( tr_peermsgs *     msgs,
-             struct evbuffer * inbuf,
-             size_t            inlen )
+readBtPiece( tr_peermsgs      * msgs,
+             struct evbuffer  * inbuf,
+             size_t             inlen,
+             size_t           * setme_piece_bytes_read )
 {
     struct peer_request * req = &msgs->incoming.blockReq;
@@ -1343 +1349 @@
         tr_peerIoReadBytes( msgs->io, inbuf, buf, n );
         evbuffer_add( msgs->incoming.block, buf, n );
-        clientGotBytes( msgs, n );
+        fireClientGotData( msgs, n, TRUE );
+        *setme_piece_bytes_read += n;
         tr_free( buf );
         dbgmsg( msgs, "got %d bytes for block %u:%u->%u ... %d remain",
@@ -1540 +1547 @@
 
 static void
-peerGotBytes( tr_peermsgs * msgs,
-              uint32_t      byteCount,
-              const time_t  now )
-{
-    msgs->info->pieceDataActivityDate = now;
-    firePeerGotData( msgs, byteCount );
-}
-
-static void
 decrementDownloadedCount( tr_peermsgs * msgs,
                           uint32_t      byteCount )
@@ -1635 +1633 @@
 }
 
+static int peerPulse( void * vmsgs );
+
+static void
+didWrite( tr_peerIo * io UNUSED, size_t bytesWritten, int wasPieceData, void * vmsgs )
+{
+    tr_peermsgs * msgs = vmsgs;
+    firePeerGotData( msgs, bytesWritten, wasPieceData );
+    peerPulse( msgs );
+}
+
 static ReadState
-canRead( struct bufferevent * evin,
-         void *               vmsgs )
+canRead( struct tr_iobuf * iobuf, void * vmsgs, size_t * piece )
 {
     ReadState         ret;
     tr_peermsgs *     msgs = vmsgs;
-    struct evbuffer * in = EVBUFFER_INPUT ( evin );
+    struct evbuffer * in = tr_iobuf_input( iobuf );
     const size_t      inlen = EVBUFFER_LENGTH( in );
 
@@ -1650 +1657 @@
     else if( msgs->state == AWAITING_BT_PIECE )
     {
-        ret = inlen ? readBtPiece( msgs, in, inlen ) : READ_LATER;
+        ret = inlen ? readBtPiece( msgs, in, inlen, piece ) : READ_LATER;
     }
     else switch( msgs->state )
-        {
-            case AWAITING_BT_LENGTH:
-                ret = readBtLength ( msgs, in, inlen ); break;
-
-            case AWAITING_BT_ID:
-                ret = readBtId     ( msgs, in, inlen ); break;
-
-            case AWAITING_BT_MESSAGE:
-                ret = readBtMessage( msgs, in, inlen ); break;
-
-            default:
-                assert( 0 );
-        }
+    {
+        case AWAITING_BT_LENGTH:
+            ret = readBtLength ( msgs, in, inlen ); break;
+
+        case AWAITING_BT_ID:
+            ret = readBtId     ( msgs, in, inlen ); break;
+
+        case AWAITING_BT_MESSAGE:
+            ret = readBtMessage( msgs, in, inlen ); break;
+
+        default:
+            assert( 0 );
+    }
+
+    /* log the raw data that was read */
+    if( EVBUFFER_LENGTH( in ) != inlen )
+        fireClientGotData( msgs, inlen - EVBUFFER_LENGTH( in ), FALSE );
 
     return ret;
-}
-
-static void
-sendKeepalive( tr_peermsgs * msgs )
-{
-    dbgmsg( msgs, "sending a keepalive message" );
-    tr_peerIoWriteUint32( msgs->io, msgs->outMessages, 0 );
-    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
 }
 
@@ -1691 +1694 @@
                   ( rateToClient * 30 * 1024 ) / peer->torrent->blockSize;
 
-    peer->minActiveRequests = 4;
-    peer->maxActiveRequests = peer->minActiveRequests +
-                              estimatedBlocksInNext30Seconds;
+    peer->minActiveRequests = 8;
+    peer->maxActiveRequests = peer->minActiveRequests + estimatedBlocksInNext30Seconds;
     return TRUE;
 }
@@ -1705 +1707 @@
 }
 
+static size_t
+fillOutputBuffer( tr_peermsgs * msgs, time_t now )
+{
+    size_t bytesWritten = 0;
+    struct peer_request req;
+    const int haveMessages = EVBUFFER_LENGTH( msgs->outMessages ) != 0;
+
+    /**
+    ***  Protocol messages
+    **/
+
+    if( haveMessages && !msgs->outMessagesBatchedAt ) /* fresh batch */
+    {
+        dbgmsg( msgs, "started an outMessages batch (length is %zu)", EVBUFFER_LENGTH( msgs->outMessages ) );
+        msgs->outMessagesBatchedAt = now;
+    }
+    else if( haveMessages && ( ( now - msgs->outMessagesBatchedAt ) >= msgs->outMessagesBatchPeriod ) )
+    {
+        const size_t len = EVBUFFER_LENGTH( msgs->outMessages );
+        /* flush the protocol messages */
+        dbgmsg( msgs, "flushing outMessages... to %p (length is %zu)", msgs->io, len );
+        tr_peerIoWriteBuf( msgs->io, msgs->outMessages, FALSE );
+        msgs->clientSentAnythingAt = now;
+        msgs->outMessagesBatchedAt = 0;
+        msgs->outMessagesBatchPeriod = LOW_PRIORITY_INTERVAL_SECS;
+        bytesWritten +=  len;
+    }
+
+    /**
+    ***  Blocks
+    **/
+
+    if( ( tr_peerIoGetWriteBufferSpace( msgs->io ) >= msgs->torrent->blockSize )
+        && popNextRequest( msgs, &req )
+        && requestIsValid( msgs, &req )
+        && tr_cpPieceIsComplete( msgs->torrent->completion, req.index ) )
+    {
+        /* send a block */
+        uint8_t * buf = tr_new( uint8_t, req.length );
+        const int err = tr_ioRead( msgs->torrent, req.index, req.offset, req.length, buf );
+        if( err ) {
+            fireError( msgs, err );
+        } else {
+            tr_peerIo * io = msgs->io;
+            struct evbuffer * out = evbuffer_new( );
+            dbgmsg( msgs, "sending block %u:%u->%u", req.index, req.offset, req.length );
+            tr_peerIoWriteUint32( io, out, sizeof( uint8_t ) + 2 * sizeof( uint32_t ) + req.length );
+            tr_peerIoWriteUint8 ( io, out, BT_PIECE );
+            tr_peerIoWriteUint32( io, out, req.index );
+            tr_peerIoWriteUint32( io, out, req.offset );
+            tr_peerIoWriteBytes ( io, out, buf, req.length );
+            tr_peerIoWriteBuf( io, out, TRUE );
+            bytesWritten += EVBUFFER_LENGTH( out );
+            evbuffer_free( out );
+            msgs->clientSentAnythingAt = now;
+        }
+        tr_free( buf );
+    }
+
+    /**
+    ***  Keepalive
+    **/
+
+    if( msgs->clientSentAnythingAt
+        && ( ( now - msgs->clientSentAnythingAt ) > KEEPALIVE_INTERVAL_SECS ) )
+    {
+        dbgmsg( msgs, "sending a keepalive message" );
+        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, 0 );
+        pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
+    }
+
+    return bytesWritten;
+}
+
 static int
 peerPulse( void * vmsgs )
@@ -1713 +1789 @@
     ratePulse( msgs );
 
-    /*tr_peerIoTryRead( msgs->io );*/
     pumpRequestQueue( msgs, now );
     expireOldRequests( msgs, now );
 
-    if( msgs->sendingBlock )
-    {
-        const size_t uploadMax = tr_peerIoGetWriteBufferSpace( msgs->io );
-        size_t       len = EVBUFFER_LENGTH( msgs->outBlock );
-        const size_t outlen = MIN( len, uploadMax );
-
-        assert( len );
-
-        if( outlen )
-        {
-            tr_peerIoWrite( msgs->io, EVBUFFER_DATA( msgs->outBlock ), outlen );
-            evbuffer_drain( msgs->outBlock, outlen );
-            peerGotBytes( msgs, outlen, now );
-
-            len -= outlen;
-            msgs->clientSentAnythingAt = now;
-            msgs->sendingBlock = len != 0;
-
-            dbgmsg( msgs, "wrote %d bytes; %d left in block", (int)outlen,
-                    (int)len );
-        }
-        else dbgmsg( msgs,
-                     "stalled writing block... uploadMax %lu, outlen %lu",
-                     uploadMax, outlen );
-    }
-
-    if( !msgs->sendingBlock )
-    {
-        struct peer_request req;
-        const int haveMessages = EVBUFFER_LENGTH( msgs->outMessages ) != 0;
-
-        if( haveMessages && !msgs->outMessagesBatchedAt ) /* fresh batch */
-        {
-            dbgmsg( msgs, "started an outMessages batch (length is %d)",
-                   (int)EVBUFFER_LENGTH( msgs->outMessages ) );
-            msgs->outMessagesBatchedAt = now;
-        }
-        else if( haveMessages
-               && ( ( now - msgs->outMessagesBatchedAt ) >
-                   msgs->outMessagesBatchPeriod ) )
-        {
-            dbgmsg( msgs, "flushing outMessages... (length is %d)",
-                   (int)EVBUFFER_LENGTH(
-                       msgs->outMessages ) );
-            tr_peerIoWriteBuf( msgs->io, msgs->outMessages );
-            msgs->clientSentAnythingAt = now;
-            msgs->outMessagesBatchedAt = 0;
-            msgs->outMessagesBatchPeriod = LOW_PRIORITY_INTERVAL_SECS;
-        }
-        else if( !EVBUFFER_LENGTH( msgs->outBlock )
-               && popNextRequest( msgs, &req )
-               && requestIsValid( msgs, &req )
-               && tr_cpPieceIsComplete( msgs->torrent->completion,
-                                        req.index ) )
-        {
-            uint8_t * buf = tr_new( uint8_t, req.length );
-            const int err = tr_ioRead( msgs->torrent,
-                                       req.index, req.offset, req.length,
-                                       buf );
-            if( err )
-            {
-                fireError( msgs, err );
-            }
-            else
-            {
-                tr_peerIo *       io = msgs->io;
-                struct evbuffer * out = msgs->outBlock;
-
-                dbgmsg( msgs, "sending block %u:%u->%u", req.index,
-                        req.offset,
-                        req.length );
-                tr_peerIoWriteUint32(
-                    io, out, sizeof( uint8_t ) + 2 * sizeof( uint32_t ) +
-                    req.length );
-                tr_peerIoWriteUint8 ( io, out, BT_PIECE );
-                tr_peerIoWriteUint32( io, out, req.index );
-                tr_peerIoWriteUint32( io, out, req.offset );
-                tr_peerIoWriteBytes ( io, out, buf, req.length );
-                msgs->sendingBlock = 1;
-            }
-
-            tr_free( buf );
-        }
-        else if( ( !haveMessages )
-               && ( now - msgs->clientSentAnythingAt ) >
-                KEEPALIVE_INTERVAL_SECS )
-        {
-            sendKeepalive( msgs );
-        }
-    }
+    for( ;; )
+        if( fillOutputBuffer( msgs, now ) < 1 )
+            break;
 
     return TRUE; /* loop forever */
@@ -1819 +1807 @@
 
 static void
-gotError( struct bufferevent * evbuf UNUSED,
-          short                      what,
-          void *                     vmsgs )
+gotError( struct tr_iobuf  * iobuf UNUSED,
+          short              what,
+          void             * vmsgs )
 {
     if( what & EVBUFFER_TIMEOUT )
-        dbgmsg( vmsgs, "libevent got a timeout, what=%hd, secs=%d", what,
-                evbuf->timeout_read );
+        dbgmsg( vmsgs, "libevent got a timeout, what=%hd", what );
     if( what & ( EVBUFFER_EOF | EVBUFFER_ERROR ) )
         dbgmsg( vmsgs, "libevent got an error! what=%hd, errno=%d (%s)",
@@ -1843 +1830 @@
     field = tr_bitfieldDup( tr_cpPieceBitfield( msgs->torrent->completion ) );
 
+#if 0
     if( tr_sessionIsLazyBitfieldEnabled( msgs->session ) )
     {
@@ -1848 +1836 @@
             speed over a truly random sample -- let's limit the pool size to
             the first 1000 pieces so large torrents don't bog things down */
-        size_t             poolSize = MIN( msgs->torrent->info.pieceCount,
-                                           1000 );
-        tr_piece_index_t * pool = tr_new( tr_piece_index_t, poolSize );
+        size_t poolSize;
+        const size_t maxPoolSize = MIN( msgs->torrent->info.pieceCount, 1000 );
+        tr_piece_index_t * pool = tr_new( tr_piece_index_t, maxPoolSize );
 
         /* build the pool */
-        for( i = 0; i < poolSize; ++i )
-            pool[i] = i;
+        for( i=poolSize=0; i<maxPoolSize; ++i )
+            if( tr_bitfieldHas( field, i ) )
+                pool[poolSize++] = i;
 
         /* pull random piece indices from the pool */
         while( ( poolSize > 0 ) && ( lazyCount < LAZY_PIECE_COUNT ) )
         {
-            const int              pos = tr_cryptoWeakRandInt( poolSize );
+            const int pos = tr_cryptoWeakRandInt( poolSize );
             const tr_piece_index_t piece = pool[pos];
             tr_bitfieldRem( field, piece );
@@ -1869 +1858 @@
         tr_free( pool );
     }
+#endif
 
     tr_peerIoWriteUint32( msgs->io, out,
@@ -1947 +1937 @@
     if( msgs->peerSupportsPex && tr_torrentAllowsPex( msgs->torrent ) )
     {
-        PexDiffs          diffs;
-        tr_pex *          newPex = NULL;
-        const int         newCount = tr_peerMgrGetPeers( msgs->session->peerMgr,
-                                                         msgs->torrent->info.hash,
-                                                         &newPex );
+        PexDiffs diffs;
+        tr_pex * newPex = NULL;
+        const int newCount = tr_peerMgrGetPeers( msgs->session->peerMgr,
+                                                 msgs->torrent->info.hash,
+                                                 &newPex );
+
         /* build the diffs */
         diffs.added = tr_new( tr_pex, newCount );
@@ -1970 +1961 @@
         if( diffs.addedCount || diffs.droppedCount )
         {
-            int               i;
-            tr_benc           val;
-            uint8_t *         tmp, *walk;
-            char *            benc;
-            int               bencLen;
+            int  i;
+            tr_benc val;
+            char * benc;
+            int bencLen;
+            uint8_t * tmp, *walk;
             struct evbuffer * out = msgs->outMessages;
 
@@ -1987 +1978 @@
             /* "added" */
             tmp = walk = tr_new( uint8_t, diffs.addedCount * 6 );
-            for( i = 0; i < diffs.addedCount; ++i )
-            {
+            for( i = 0; i < diffs.addedCount; ++i ) {
                 memcpy( walk, &diffs.added[i].in_addr, 4 ); walk += 4;
                 memcpy( walk, &diffs.added[i].port, 2 ); walk += 2;
@@ -2006 +1996 @@
             /* "dropped" */
             tmp = walk = tr_new( uint8_t, diffs.droppedCount * 6 );
-            for( i = 0; i < diffs.droppedCount; ++i )
-            {
+            for( i = 0; i < diffs.droppedCount; ++i ) {
                 memcpy( walk, &diffs.dropped[i].in_addr, 4 ); walk += 4;
                 memcpy( walk, &diffs.dropped[i].port, 2 ); walk += 2;
@@ -2021 +2010 @@
             tr_peerIoWriteUint8 ( msgs->io, out, msgs->ut_pex_id );
             tr_peerIoWriteBytes ( msgs->io, out, benc, bencLen );
-            pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
-            dbgmsg( msgs, "outMessage size is now %zu", EVBUFFER_LENGTH( out ) );
-
-            /* cleanup */
+            pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
+            dbgmsg( msgs, "sending a pex message; outMessage size is now %zu", EVBUFFER_LENGTH( out ) );
+
             tr_free( benc );
             tr_bencFree( &val );
         }
 
+        /* cleanup */
         tr_free( diffs.added );
         tr_free( diffs.dropped );
@@ -2077 +2066 @@
     m->outMessagesBatchPeriod = LOW_PRIORITY_INTERVAL_SECS;
     m->incoming.block = evbuffer_new( );
-    m->outBlock = evbuffer_new( );
     m->peerAllowedPieces = NULL;
     m->peerAskedFor = REQUEST_LIST_INIT;
@@ -2092 +2080 @@
     tr_peerIoSetTimeoutSecs( m->io, 150 ); /* timeout after N seconds of
                                              inactivity */
-    tr_peerIoSetIOFuncs( m->io, canRead, NULL, gotError, m );
+    tr_peerIoSetIOFuncs( m->io, canRead, didWrite, gotError, m );
     ratePulse( m );
 
@@ -2112 +2100 @@
         evbuffer_free( msgs->incoming.block );
         evbuffer_free( msgs->outMessages );
-        evbuffer_free( msgs->outBlock );
         tr_free( msgs->pex );
 

branches/1.4x/libtransmission/port-forwarding.c

@@ -33 +33 @@
 struct tr_shared
 {
-    unsigned int          isEnabled      : 1;
-    unsigned int          isShuttingDown : 1;
+    tr_bool               isEnabled;
+    tr_bool               isShuttingDown;
 
     tr_port_forwarding    natpmpStatus;
@@ -43 +43 @@
     int                   publicPort;
 
-    tr_handle *           h;
-    tr_timer *            pulseTimer;
-
-    tr_upnp *             upnp;
-    tr_natpmp *           natpmp;
+    tr_timer            * pulseTimer;
+
+    tr_upnp             * upnp;
+    tr_natpmp           * natpmp;
+    tr_session          * session;
 };
 
@@ -146 +146 @@
             break;
 
-        socket = tr_netAccept( s->bindSocket, &addr, &port );
+        socket = tr_netAccept( s->session, s->bindSocket, &addr, &port );
         if( socket < 0 )
             break;
@@ -152 +152 @@
         tr_deepLog( __FILE__, __LINE__, NULL,
                    "New INCOMING connection %d (%s)",
-                   socket, tr_peerIoAddrStr( &addr,
-                                             port ) );
-
-        tr_peerMgrAddIncoming( s->h->peerMgr, &addr, port, socket );
+                   socket, tr_peerIoAddrStr( &addr, port ) );
+
+        tr_peerMgrAddIncoming( s->session->peerMgr, &addr, port, socket );
     }
 }
@@ -178 +177 @@
         tr_natpmpClose( shared->natpmp );
         tr_upnpClose( shared->upnp );
-        shared->h->shared = NULL;
+        shared->session->shared = NULL;
         tr_free( shared );
         keepPulsing = 0;
@@ -191 +190 @@
 
 tr_shared *
-tr_sharedInit( tr_handle * h,
-               int         isEnabled,
-               int         publicPort )
+tr_sharedInit( tr_session  * session,
+               int           isEnabled,
+               int           publicPort )
 {
     tr_shared * s = tr_new0( tr_shared, 1 );
 
-    s->h            = h;
+    s->session      = session;
     s->publicPort   = publicPort;
     s->bindPort     = -1;
@@ -203 +202 @@
     s->natpmp       = tr_natpmpInit( );
     s->upnp         = tr_upnpInit( );
-    s->pulseTimer   = tr_timerNew( h, sharedPulse, s, 1000 );
+    s->pulseTimer   = tr_timerNew( session, sharedPulse, s, 1000 );
     s->isEnabled    = isEnabled ? 1 : 0;
     s->upnpStatus   = TR_PORT_UNMAPPED;
@@ -225 +224 @@
     s->publicPort = port;
 
-    while( ( tor = tr_torrentNext( s->h, tor ) ) )
+    while( ( tor = tr_torrentNext( s->session, tor ) ) )
         tr_torrentChangeMyPort( tor );
 }

branches/1.4x/libtransmission/session.c

@@ -22 +22 @@
 
 #include "transmission.h"
+#include "bandwidth.h"
 #include "blocklist.h"
 #include "fdlimit.h"
@@ -30 +31 @@
 #include "platform.h" /* tr_lock */
 #include "port-forwarding.h"
-#include "ratecontrol.h"
 #include "rpc-server.h"
 #include "stats.h"
@@ -255 +255 @@
     h->proxyUsername = tr_strdup( proxyUsername );
     h->proxyPassword = tr_strdup( proxyPassword );
-    h->pieceSpeed[TR_PEER_TO_CLIENT] = tr_rcInit( );
-    h->pieceSpeed[TR_CLIENT_TO_PEER] = tr_rcInit( );
-    h->rawSpeed[TR_PEER_TO_CLIENT] = tr_rcInit( );
-    h->rawSpeed[TR_CLIENT_TO_PEER] = tr_rcInit( );
+    h->so_sndbuf = 1500 * 3; /* 3x MTU for most ethernet/wireless */
+    h->so_rcvbuf = 8192;
 
     if( configDir == NULL )
@@ -277 +275 @@
     /* Initialize rate and file descripts controls */
 
-    h->uploadLimit = uploadLimit;
-    h->useUploadLimit = useUploadLimit;
-    h->downloadLimit = downloadLimit;
-    h->useDownloadLimit = useDownloadLimit;
-
     tr_fdInit( globalPeerLimit );
     h->shared = tr_sharedInit( h, isPortForwardingEnabled, publicPort );
     h->isPortSet = publicPort >= 0;
+
+    h->bandwidth = tr_bandwidthNew( h, NULL );
+    tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_UP, uploadLimit );
+    tr_bandwidthSetDesiredSpeed( h->bandwidth, TR_DOWN, downloadLimit );
+    tr_bandwidthSetLimited( h->bandwidth, TR_UP, useUploadLimit );
+    tr_bandwidthSetLimited( h->bandwidth, TR_DOWN, useDownloadLimit );
 
     /* first %s is the application name
@@ -444 +443 @@
 
 void
-tr_sessionSetSpeedLimitEnabled( tr_handle *  h,
-                                tr_direction direction,
-                                int          use_flag )
-{
-    assert( h );
-    assert( direction == TR_UP || direction == TR_DOWN );
-
-    if( direction == TR_UP )
-        h->useUploadLimit = use_flag ? 1 : 0;
-    else
-        h->useDownloadLimit = use_flag ? 1 : 0;
-}
-
-int
-tr_sessionIsSpeedLimitEnabled( const tr_handle * h,
-                               tr_direction      direction )
-{
-    return direction == TR_UP ? h->useUploadLimit : h->useDownloadLimit;
-}
-
-void
-tr_sessionSetSpeedLimit( tr_handle *  h,
-                         tr_direction direction,
-                         int          KiB_sec )
-{
-    if( direction == TR_DOWN )
-        h->downloadLimit = KiB_sec;
-    else
-        h->uploadLimit = KiB_sec;
-}
-
-int
-tr_sessionGetSpeedLimit( const tr_handle * h,
-                         tr_direction      direction )
-{
-    return direction == TR_UP ? h->uploadLimit : h->downloadLimit;
+tr_sessionSetSpeedLimitEnabled( tr_session      * session,
+                                tr_direction      dir,
+                                int               isLimited )
+{
+    tr_bandwidthSetLimited( session->bandwidth, dir, isLimited );
+}
+
+int
+tr_sessionIsSpeedLimitEnabled( const tr_session  * session,
+                               tr_direction        dir )
+{
+    return !tr_bandwidthIsLimited( session->bandwidth, dir );
+}
+
+void
+tr_sessionSetSpeedLimit( tr_session    * session,
+                         tr_direction    dir,
+                         int             desiredSpeed )
+{
+    tr_bandwidthSetDesiredSpeed( session->bandwidth, dir, desiredSpeed );
+}
+
+int
+tr_sessionGetSpeedLimit( const tr_session  * session,
+                         tr_direction        dir )
+{
+    return tr_bandwidthGetDesiredSpeed( session->bandwidth, dir );
 }
 
@@ -506 +496 @@
 tr_sessionGetPieceSpeed( const tr_session * session, tr_direction dir )
 {
-    assert( dir==TR_UP || dir==TR_DOWN );
-
-    return session ? tr_rcRate( session->pieceSpeed[dir] ) : 0.0;
+    return session ? tr_bandwidthGetPieceSpeed( session->bandwidth, dir ) : 0.0;
 }
 
@@ -514 +502 @@
 tr_sessionGetRawSpeed( const tr_session * session, tr_direction dir )
 {
-    assert( dir==TR_UP || dir==TR_DOWN );
-
-    return session ? tr_rcRate( session->rawSpeed[dir] ) : 0.0;
+    return session ? tr_bandwidthGetPieceSpeed( session->bandwidth, dir ) : 0.0;
 }
 
@@ -630 +616 @@
 
     /* free the session memory */
-    tr_rcClose( session->pieceSpeed[TR_PEER_TO_CLIENT] );
-    tr_rcClose( session->pieceSpeed[TR_CLIENT_TO_PEER] );
-    tr_rcClose( session->rawSpeed[TR_PEER_TO_CLIENT] );
-    tr_rcClose( session->rawSpeed[TR_CLIENT_TO_PEER] );
+    tr_bandwidthFree( session->bandwidth );
     tr_lockFree( session->lock );
     for( i = 0; i < session->metainfoLookupCount; ++i )

branches/1.4x/libtransmission/session.h

@@ -22 +22 @@
  * DEALINGS IN THE SOFTWARE.
  *****************************************************************************/
+
+#ifndef __TRANSMISSION__
+#error only libtransmission should #include this header.
+#endif
 
 #ifndef TR_INTERNAL_H
@@ -49 +53 @@
 };
 
-struct tr_ratecontrol;
+struct tr_bandwidth;
 
 struct tr_handle
 {
-    unsigned int                 isPortSet          : 1;
-    unsigned int                 isPexEnabled       : 1;
-    unsigned int                 isBlocklistEnabled : 1;
-    unsigned int                 isProxyEnabled     : 1;
-    unsigned int                 isProxyAuthEnabled : 1;
-    unsigned int                 isClosed           : 1;
-    unsigned int                 useUploadLimit     : 1;
-    unsigned int                 useDownloadLimit   : 1;
-    unsigned int                 useLazyBitfield    : 1;
+    tr_bool                      isPortSet;
+    tr_bool                      isPexEnabled;
+    tr_bool                      isBlocklistEnabled;
+    tr_bool                      isProxyEnabled;
+    tr_bool                      isProxyAuthEnabled;
+    tr_bool                      isClosed;
+    tr_bool                      useLazyBitfield;
 
     tr_encryption_mode           encryptionMode;
@@ -85 +87 @@
     char *                       proxyPassword;
 
-    int                          uploadLimit;
-    int                          downloadLimit;
-
     struct tr_list *             blocklists;
     struct tr_peerMgr *          peerMgr;
@@ -106 +105 @@
     int                          metainfoLookupCount;
 
-    /* the rate at which pieces are being transferred between client and peer.
-     * protocol overhead is NOT included; this is only the piece data */
-    struct tr_ratecontrol     *  pieceSpeed[2];
+    /* the size of the output buffer for peer connections */
+    int so_sndbuf;
 
-    /* the rate at which bytes are being transferred between client and peer. */
-    struct tr_ratecontrol     *  rawSpeed[2];
+    /* the size of the input buffer for peer connections */
+    int so_rcvbuf;
+
+    /* monitors the "global pool" speeds */
+    struct tr_bandwidth       * bandwidth;
 };
 

branches/1.4x/libtransmission/torrent.c

@@ -33 +33 @@
 
 #include "transmission.h"
+#include "bandwidth.h"
 #include "bencode.h"
 #include "completion.h"
@@ -143 +144 @@
 void
 tr_torrentSetSpeedMode( tr_torrent *  tor,
-                        tr_direction  direction,
+                        tr_direction  dir,
                         tr_speedlimit mode )
 {
-    tr_speedlimit * limit = direction == TR_UP ? &tor->uploadLimitMode
-                                               : &tor->downloadLimitMode;
-
-    *limit = mode;
+    assert( tor != NULL );
+    assert( dir==TR_UP || dir==TR_DOWN );
+    assert( mode==TR_SPEEDLIMIT_GLOBAL || mode==TR_SPEEDLIMIT_SINGLE || mode==TR_SPEEDLIMIT_UNLIMITED  );
+
+    tor->speedLimitMode[dir] = mode;
+
+    tr_bandwidthSetLimited( tor->bandwidth, dir, mode==TR_SPEEDLIMIT_SINGLE );
+    tr_bandwidthHonorParentLimits( tor->bandwidth, dir, mode!=TR_SPEEDLIMIT_UNLIMITED );
 }
 
 tr_speedlimit
 tr_torrentGetSpeedMode( const tr_torrent * tor,
-                        tr_direction       direction )
-{
-    return direction == TR_UP ? tor->uploadLimitMode
-                              : tor->downloadLimitMode;
+                        tr_direction       dir )
+{
+    assert( tor != NULL );
+    assert( dir==TR_UP || dir==TR_DOWN );
+
+    return tor->speedLimitMode[dir];
 }
 
 void
 tr_torrentSetSpeedLimit( tr_torrent * tor,
-                         tr_direction direction,
-                         int          single_KiB_sec )
-{
-    switch( direction )
-    {
-        case TR_UP:
-            tor->uploadLimit = single_KiB_sec; break;
-
-        case TR_DOWN:
-            tor->downloadLimit = single_KiB_sec; break;
-
-        default:
-            assert( 0 );
-    }
+                         tr_direction dir,
+                         int          desiredSpeed )
+{
+    tr_bandwidthSetDesiredSpeed( tor->bandwidth, dir, desiredSpeed );
 }
 
 int
 tr_torrentGetSpeedLimit( const tr_torrent * tor,
-                         tr_direction       direction )
-{
-    switch( direction )
-    {
-        case TR_UP:
-            return tor->uploadLimit;
-
-        case TR_DOWN:
-            return tor->downloadLimit;
-
-        default:
-            assert( 0 );
-    }
+                         tr_direction       dir )
+{
+    return tr_bandwidthGetDesiredSpeed( tor->bandwidth, dir );
 }
 
@@ -497 +484 @@
     randomizeTiers( info );
 
-    tor->rawSpeed[TR_CLIENT_TO_PEER] = tr_rcInit( );
-    tor->rawSpeed[TR_PEER_TO_CLIENT] = tr_rcInit( );
-    tor->pieceSpeed[TR_CLIENT_TO_PEER] = tr_rcInit( );
-    tor->pieceSpeed[TR_PEER_TO_CLIENT] = tr_rcInit( );
+    tor->bandwidth = tr_bandwidthNew( h, h->bandwidth );
 
     tor->blockSize = getBlockSize( info->pieceSize );
@@ -542 +526 @@
     tr_torrentInitFilePieces( tor );
 
-    tor->uploadLimit = 0;
-    tor->downloadLimit = 0;
     tor->swarmSpeed = tr_rcInit( );
 
@@ -815 +797 @@
                             s->peersFrom );
 
-    s->rawUploadSpeed     = tr_rcRate( tor->rawSpeed[TR_UP] );
-    s->rawDownloadSpeed   = tr_rcRate( tor->rawSpeed[TR_DOWN] );
-    s->pieceUploadSpeed   = tr_rcRate( tor->pieceSpeed[TR_UP] );
-    s->pieceDownloadSpeed = tr_rcRate( tor->pieceSpeed[TR_DOWN] );
+    s->rawUploadSpeed     = tr_bandwidthGetRawSpeed  ( tor->bandwidth, TR_UP );
+    s->rawDownloadSpeed   = tr_bandwidthGetRawSpeed  ( tor->bandwidth, TR_DOWN );
+    s->pieceUploadSpeed   = tr_bandwidthGetPieceSpeed( tor->bandwidth, TR_UP );
+    s->pieceDownloadSpeed = tr_bandwidthGetPieceSpeed( tor->bandwidth, TR_DOWN );
 
     usableSeeds += tor->info.webseedCount;
@@ -1101 +1083 @@
     h->torrentCount--;
 
-    tr_rcClose( tor->pieceSpeed[TR_PEER_TO_CLIENT] );
-    tr_rcClose( tor->pieceSpeed[TR_CLIENT_TO_PEER] );
-    tr_rcClose( tor->rawSpeed[TR_PEER_TO_CLIENT] );
-    tr_rcClose( tor->rawSpeed[TR_CLIENT_TO_PEER] );
+    tr_bandwidthFree( tor->bandwidth );
 
     tr_metainfoFree( inf );

branches/1.4x/libtransmission/torrent.h

@@ -23 +23 @@
  *****************************************************************************/
 
+#ifndef __TRANSMISSION__
+#error only libtransmission should #include this header.
+#endif
+
 #ifndef TR_TORRENT_H
 #define TR_TORRENT_H 1
 
+struct tr_bandwidth;
 struct tr_ratecontrol;
 
@@ -168 +173 @@
     tr_info                  info;
 
-    int                      uploadLimit;
-    tr_speedlimit            uploadLimitMode;
-    int                      downloadLimit;
-    tr_speedlimit            downloadLimitMode;
+    tr_speedlimit            speedLimitMode[2];
 
     struct tr_ratecontrol *  swarmSpeed;
@@ -216 +218 @@
     void *                     completeness_func_user_data;
 
-    unsigned int               isRunning  : 1;
-    unsigned int               isDeleting : 1;
+    tr_bool                    isRunning;
+    tr_bool                    isDeleting;
 
     uint16_t                   maxConnectedPeers;
@@ -230 +232 @@
     int                        uniqueId;
 
-    /* the rate at which pieces are being transferred between client and
-     * its peers.  protocol overhead is NOT included; only the piece data */
-    struct tr_ratecontrol    * pieceSpeed[2];
-
-    /* the rate at which bytes are being sent between client and peers */
-    struct tr_ratecontrol    * rawSpeed[2];
+    struct tr_bandwidth      * bandwidth;
 };
 

branches/1.4x/libtransmission/transmission.h

@@ -53 +53 @@
 typedef uint32_t tr_piece_index_t;
 typedef uint64_t tr_block_index_t;
+typedef uint8_t tr_bool;
+
 
 /**

branches/1.4x/libtransmission/webseed.c

@@ -27 +27 @@
 struct tr_webseed
 {
-    unsigned int        busy : 1;
-    unsigned int        dead : 1;
+    tr_bool             busy;
+    tr_bool             dead;
 
     uint8_t             hash[SHA_DIGEST_LENGTH];
@@ -52 +52 @@
 ***/
 
-static const tr_peer_event blankEvent = { 0, 0, 0, 0, 0.0f, 0 };
+static const tr_peer_event blankEvent = { 0, 0, 0, 0, 0.0f, 0, 0 };
 
 static void
@@ -94 +94 @@
     e.eventType = TR_PEER_CLIENT_GOT_DATA;
     e.length = length;
+    e.wasPieceData = TRUE;
+
     publish( w, &e );
 }