Changeset 3897

Timestamp:

Nov 20, 2007, 2:28:11 AM (15 years ago)

Author:

charles

Message:

partial backport of libT to 0.9x. 0.9x will probably be broken for a little bit.

Location:

branches/0.9x

Files:

• . (modified) (1 prop)
• libtransmission/Makefile.am (modified) (1 diff)
• libtransmission/bencode.c (modified) (4 diffs)
• libtransmission/bencode.h (modified) (1 diff)
• libtransmission/completion.c (modified) (4 diffs)
• libtransmission/completion.h (modified) (1 diff)
• libtransmission/fdlimit.c (modified) (4 diffs)
• libtransmission/handshake.c (modified) (10 diffs)
• libtransmission/inout.c (modified) (2 diffs)
• libtransmission/ipcparse.c (modified) (4 diffs)
• libtransmission/ipcparse.h (modified) (2 diffs)
• libtransmission/makemeta.c (modified) (1 diff)
• libtransmission/peer-io.c (modified) (22 diffs)
• libtransmission/peer-io.h (modified) (4 diffs)
• libtransmission/peer-mgr-private.h (modified) (3 diffs)
• libtransmission/peer-mgr.c (modified) (39 diffs)
• libtransmission/peer-msgs.c (modified) (50 diffs)
• libtransmission/peer-msgs.h (modified) (2 diffs)
• libtransmission/platform.c (modified) (2 diffs)
• libtransmission/platform.h (modified) (1 diff)
• libtransmission/torrent.c (modified) (6 diffs)
• libtransmission/transmission.c (modified) (5 diffs)
• libtransmission/transmission.h (modified) (8 diffs)
• libtransmission/trevent.c (modified) (5 diffs)
• libtransmission/trevent.h (modified) (2 diffs)
• libtransmission/utils.c (modified) (1 diff)

branches/0.9x

@@ -1 @@
-third-party/libevent  -r474 http://levent.svn.sourceforge.net/svnroot/levent/trunk/libevent
+third-party/libevent http://levent.svn.sourceforge.net/svnroot/levent/branches/patches-1.4

@@ -1 @@
-third-party/libevent  -r474 http://levent.svn.sourceforge.net/svnroot/levent/trunk/libevent
+third-party/libevent http://levent.svn.sourceforge.net/svnroot/levent/branches/patches-1.4

branches/0.9x/libtransmission/Makefile.am

@@ -28 +28 @@
     ratecontrol.c \
     shared.c \
-    strlcat.c \
-    strlcpy.c \
     torrent.c \
     tracker.c \

branches/0.9x/libtransmission/bencode.c

@@ -29 +29 @@
 #include <stdlib.h>
 
+#include <event.h>
+
 #include "transmission.h"
 #include "bencode.h"
@@ -391 +393 @@
 }
 
-char * tr_bencSaveMalloc( benc_val_t * val, int * len )
-{
-    char * buf   = NULL;
-    int alloc = 0;
-
-    *len = 0;
-    if( tr_bencSave( val, &buf, len, &alloc ) )
-    {
-        if( NULL != buf )
-        {
-            free(buf);
-        }
-        *len = 0;
-        return NULL;
-    }
-
-    return buf;
-}
-
-typedef struct
+struct KeyIndex
 {
     const char * key;
     int index;
-}
-KeyIndex;
+};
 
 static int compareKeyIndex( const void * va, const void * vb )
 {
-    const KeyIndex * a = (const KeyIndex *) va;
-    const KeyIndex * b = (const KeyIndex *) vb;
+    const struct KeyIndex * a = va;
+    const struct KeyIndex * b = vb;
     return strcmp( a->key, b->key );
 }
 
-int tr_bencSave( benc_val_t * val, char ** buf, int * used, int * max )
-{
-    int ii;    
+static void
+saveImpl( struct evbuffer * out, const benc_val_t * val )
+{
+    int ii;
 
     switch( val->type )
     {
         case TYPE_INT:
-            if( tr_sprintf( buf, used, max, "i%"PRId64"e", val->val.i ) )
-                return 1;
+            evbuffer_add_printf( out, "i%"PRId64"e", val->val.i );
             break;
 
         case TYPE_STR:
-            if( tr_sprintf( buf, used, max, "%i:", val->val.s.i ) ||
-                tr_concat( buf, used,  max, val->val.s.s, val->val.s.i ) )
-                return 1;
+            evbuffer_add_printf( out, "%i:", val->val.s.i );
+            evbuffer_add( out, val->val.s.s, val->val.s.i );
             break;
 
         case TYPE_LIST:
-            if( tr_sprintf( buf, used, max, "l" ) )
-                return 1;
+            evbuffer_add_printf( out, "l" );
             for( ii = 0; val->val.l.count > ii; ii++ )
-                if( tr_bencSave( val->val.l.vals + ii, buf, used, max ) )
-                    return 1;
-            if( tr_sprintf( buf, used, max, "e" ) )
-                return 1;
+                saveImpl( out, val->val.l.vals + ii );
+            evbuffer_add_printf( out, "e" );
             break;
 
@@ -454 +432 @@
             /* Keys must be strings and appear in sorted order
                (sorted as raw strings, not alphanumerics). */
-            if( tr_sprintf( buf, used, max, "d" ) )
-                return 1;
+            evbuffer_add_printf( out, "d" );
             if( 1 ) {
                 int i;
-                KeyIndex * indices = tr_new( KeyIndex, val->val.l.count );
+                struct KeyIndex * indices = tr_new( struct KeyIndex, val->val.l.count );
                 for( ii=i=0; i<val->val.l.count; i+=2 ) {
                     indices[ii].key = val->val.l.vals[i].val.s.s;
@@ -464 +441 @@
                     ii++;
                 }
-                qsort( indices, ii, sizeof(KeyIndex), compareKeyIndex );
+                qsort( indices, ii, sizeof(struct KeyIndex), compareKeyIndex );
                 for( i=0; i<ii; ++i ) {
                     const int index = indices[i].index;
-                    if( tr_bencSave( val->val.l.vals + index,     buf, used, max ) ||
-                        tr_bencSave( val->val.l.vals + index + 1, buf, used, max ) ) {
-                        tr_free( indices );
-                        return 1;
-                    }
+                    saveImpl( out, val->val.l.vals + index );
+                    saveImpl( out, val->val.l.vals + index + 1 );
                 }
                 tr_free( indices );
-            } 
-            if( tr_sprintf( buf, used, max, "e" ) )
-                return 1;
-            break;
-    }
-
-    return 0;
+            }
+            evbuffer_add_printf( out, "e" );
+            break;
+    }
+}
+
+char*
+tr_bencSave( const benc_val_t * val, int * len )
+{
+    struct evbuffer * buf = evbuffer_new( );
+    char * ret;
+    saveImpl( buf, val );
+    if( len != NULL )
+        *len = EVBUFFER_LENGTH( buf );
+    ret = tr_strndup( (char*) EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
+    evbuffer_free( buf );
+    return ret;
 }
 

branches/0.9x/libtransmission/bencode.h

@@ -87 +87 @@
 benc_val_t * tr_bencDictAdd( benc_val_t * dict, const char * key );
 
-char * tr_bencSaveMalloc( benc_val_t * val, int * len );
-int    tr_bencSave( benc_val_t * val, char ** buf,
-                          int * used, int * max );
+char*  tr_bencSave( const benc_val_t * val, int * len );
 
 int    tr_bencIsStr   ( const benc_val_t * val );

branches/0.9x/libtransmission/completion.c

@@ -49 +49 @@
 };
 
+static void
+tr_cpReset( tr_completion * cp )
+{
+    tr_torrent * tor = cp->tor;
+
+    tr_bitfieldClear( cp->pieceBitfield );
+    tr_bitfieldClear( cp->blockBitfield );
+    memset( cp->completeBlocks, 0, sizeof(uint16_t) * tor->info.pieceCount );
+
+    cp->doneDirty = TRUE;
+    cp->doneHave = 0;
+    cp->doneTotal = 0;
+    cp->completeHave = 0;
+}
+
 tr_completion * tr_cpInit( tr_torrent * tor )
 {
@@ -70 +85 @@
     tr_bitfieldFree( cp->blockBitfield );
     tr_free(         cp );
-}
-
-void tr_cpReset( tr_completion * cp )
-{
-    tr_torrent * tor = cp->tor;
-
-    tr_bitfieldClear( cp->pieceBitfield );
-    tr_bitfieldClear( cp->blockBitfield );
-    memset( cp->completeBlocks, 0, sizeof(uint16_t) * tor->info.pieceCount );
-
-    cp->doneDirty = TRUE;
-    cp->doneHave = 0;
-    cp->doneTotal = 0;
-    cp->completeHave = 0;
 }
 
@@ -311 +312 @@
         b -= (info->pieceSize - (info->totalSize % info->pieceSize));
 
-   return b;
+    return b;
 }
 
@@ -317 +318 @@
 tr_cpHaveTotal( const tr_completion * cp )
 {
-   return cp->completeHave;
-}
+    return cp->completeHave;
+}

branches/0.9x/libtransmission/completion.h

@@ -32 +32 @@
 tr_completion  * tr_cpInit( tr_torrent * );
 void             tr_cpClose( tr_completion * );
-void             tr_cpReset( tr_completion * );
 
 /* General */

branches/0.9x/libtransmission/fdlimit.c

@@ -36 +36 @@
 #include <fcntl.h> /* O_LARGEFILE */
 
-#include <sys/queue.h> /* libevent needs this */
-#include <sys/types.h> /* libevent needs this */
 #include <event.h>
-#include <evhttp.h>
 #include <evutil.h>
 
@@ -90 +87 @@
 enum
 {
-    TR_MAX_SOCKETS = 512,
-
-    TR_MAX_OPEN_FILES = 16, /* real files, not sockets */
-
-    TR_RESERVED_FDS   = 16 /* sockets reserved for tracker connections */
+    TR_MAX_SOCKETS = 320,
+
+    TR_MAX_OPEN_FILES = 8, /* real files, not sockets */
+
+    TR_RESERVED_FDS = 16 /* sockets reserved for tracker connections */
 };
 
@@ -135 +132 @@
     if( write ) {
         char * tmp = tr_strdup( filename );
-        const int val = tr_mkdirp( dirname(tmp), 0700 );
+        const int val = tr_mkdirp( dirname(tmp), 0777 );
         tr_free( tmp );
         if( val )
@@ -150 +147 @@
 #endif
     errno = 0;
-    file->fd = open( filename, flags, 0600 );
+    file->fd = open( filename, flags, 0666 );
     if( file->fd < 0 ) {
         if( errno ) {

branches/0.9x/libtransmission/handshake.c

@@ -19 +19 @@
 #include <libgen.h> /* basename */
 
-#include <sys/types.h> /* event.h needs this */
 #include <event.h>
 
@@ -91 +90 @@
     unsigned int havePeerID                   : 1;
     unsigned int haveSentBitTorrentHandshake  : 1;
-    unsigned int allowUnencryptedPeers        : 1;
     tr_peerIo * io;
     tr_crypto * crypto;
@@ -98 +96 @@
     uint8_t mySecret[KEY_LEN];
     uint8_t state;
+    tr_encryption_mode encryptionMode;
     uint16_t pad_c_len;
     uint16_t pad_d_len;
@@ -326 +325 @@
 
 static uint32_t
-getCryptoProvide( const tr_handshake * handshake UNUSED )
-{
-    uint32_t i = 0;
-
-    i |= CRYPTO_PROVIDE_CRYPTO; /* always allow crypto */
-
-#if 0
-    /* by the time we send a crypto_provide, we _know_
-     * the peer supports encryption. */
-    if( handshake->allowUnencryptedPeers )
-        i |= CRYPTO_PROVIDE_PLAINTEXT;
-#endif
-
-   return i;
+getCryptoProvide( const tr_handshake * handshake )
+{
+    uint32_t provide = 0;
+
+    switch( handshake->encryptionMode )
+    {
+        case TR_ENCRYPTION_REQUIRED:
+        case TR_ENCRYPTION_PREFERRED:
+            provide |= CRYPTO_PROVIDE_CRYPTO;
+            break;
+
+        case TR_PLAINTEXT_PREFERRED:
+            provide |= CRYPTO_PROVIDE_CRYPTO | CRYPTO_PROVIDE_PLAINTEXT;
+            break;
+    }
+
+    return provide;
+}
+
+static uint32_t
+getCryptoSelect( const tr_handshake * handshake, uint32_t crypto_provide )
+{
+    uint32_t choices[4];
+    int i, nChoices=0;
+
+    switch( handshake->encryptionMode )
+    {
+        case TR_ENCRYPTION_REQUIRED:
+            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
+            break;
+
+        case TR_ENCRYPTION_PREFERRED:
+            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
+            choices[nChoices++] = CRYPTO_PROVIDE_PLAINTEXT;
+            break;
+
+        case TR_PLAINTEXT_PREFERRED:
+            choices[nChoices++] = CRYPTO_PROVIDE_PLAINTEXT;
+            choices[nChoices++] = CRYPTO_PROVIDE_CRYPTO;
+            break;
+    }
+
+    for( i=0; i<nChoices; ++i )
+        if( crypto_provide & choices[i] )
+            return choices[i];
+
+    return 0;
 }
 
@@ -546 +578 @@
         tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_NONE );
 
-        if( !handshake->allowUnencryptedPeers )
+        if( handshake->encryptionMode == TR_ENCRYPTION_REQUIRED )
         {
             dbgmsg( handshake, "peer is unencrypted, and we're disallowing that" );
@@ -842 +874 @@
     }
 
-dbgmsg( handshake, "sending crypto_select" );
     /* send crypto_select */
-    {
-dbgmsg( handshake, "handshake->crypto_provide is %d", (int)handshake->crypto_provide );
-        if( handshake->crypto_provide & CRYPTO_PROVIDE_CRYPTO )
-            crypto_select = CRYPTO_PROVIDE_CRYPTO;
-        else if( handshake->allowUnencryptedPeers )
-            crypto_select = CRYPTO_PROVIDE_PLAINTEXT;
-        else {
-dbgmsg( handshake, "gronk..." );
-            evbuffer_free( outbuf );
-            tr_handshakeDone( handshake, FALSE );
-            return READ_DONE;
-        }
-
-dbgmsg( handshake, "we select crypto_select as %d...", (int)crypto_select );
+    crypto_select = getCryptoSelect( handshake, handshake->crypto_provide );
+    if( crypto_select ) {
+        dbgmsg( handshake, "selecting crypto mode '%d'", (int)crypto_select );
         tr_peerIoWriteUint32( handshake->io, outbuf, crypto_select );
+    } else {
+        dbgmsg( handshake, "peer didn't offer an encryption mode we like." );
+        evbuffer_free( outbuf );
+        tr_handshakeDone( handshake, FALSE );
+        return READ_DONE;
     }
 
@@ -944 +969 @@
 {
     dbgmsg( handshake, "handshakeDone: %s", isOK ? "connected" : "aborting" );
-    tr_peerIoSetIOFuncs( handshake->io, NULL, NULL, NULL, NULL );
+    tr_peerIoSetIOFuncs( handshake->io, NULL, NULL, NULL );
 
     fireDoneFunc( handshake, isOK );
@@ -966 +991 @@
      * try a plaintext handshake */
     if(    ( ( handshake->state == AWAITING_YB ) || ( handshake->state == AWAITING_VC ) )
-        && ( handshake->allowUnencryptedPeers )
+        && ( handshake->encryptionMode != TR_ENCRYPTION_REQUIRED )
         && ( !tr_peerIoReconnect( handshake->io ) ) )
     {
@@ -992 +1017 @@
 tr_handshake*
 tr_handshakeNew( tr_peerIo           * io,
-                 tr_encryption_mode    encryption_mode,
+                 tr_encryption_mode    encryptionMode,
                  handshakeDoneCB       doneCB,
                  void                * doneUserData )
@@ -1001 +1026 @@
     handshake->io = io;
     handshake->crypto = tr_peerIoGetCrypto( io );
-    handshake->allowUnencryptedPeers = encryption_mode!=TR_ENCRYPTION_REQUIRED;
+    handshake->encryptionMode = encryptionMode;
     handshake->doneCB = doneCB;
     handshake->doneUserData = doneUserData;
     handshake->handle = tr_peerIoGetHandle( io );
     
-    tr_peerIoSetIOMode( handshake->io, EV_READ|EV_WRITE, 0 );
-    tr_peerIoSetIOFuncs( handshake->io, canRead, NULL, gotError, handshake );
+    tr_peerIoSetIOFuncs( handshake->io, canRead, gotError, handshake );
 
     if( tr_peerIoIsIncoming( handshake->io ) )
         setReadState( handshake, AWAITING_HANDSHAKE );
-    else
+    else if( encryptionMode != TR_PLAINTEXT_PREFERRED )
         sendYa( handshake );
+    else {
+        int msgSize; 
+        uint8_t * msg = buildHandshakeMessage( handshake, &msgSize );
+        handshake->haveSentBitTorrentHandshake = 1;
+        setReadState( handshake, AWAITING_HANDSHAKE );
+        tr_peerIoWrite( handshake->io, msg, msgSize );
+        tr_free( msg );
+    }
 
     return handshake;

branches/0.9x/libtransmission/inout.c

@@ -26 +26 @@
 #include "inout.h"
 #include "list.h"
-#include "net.h"
 #include "platform.h"
 #include "peer-mgr.h"
 #include "utils.h"
-
-struct tr_io
-{
-    tr_torrent * tor;
-};
 
 /****
@@ -78 +72 @@
         ret = TR_ERROR_IO_OTHER;
     else if( func( fd, buf, buflen ) != buflen )
-        ret = tr_ioErrorFromErrno ();
+        ret = tr_ioErrorFromErrno( );
     else
         ret = TR_OK;

branches/0.9x/libtransmission/ipcparse.c

@@ -31 +31 @@
 
 #include "transmission.h"
+#include "utils.h"
 
 #include "ipcparse.h"
@@ -141 +142 @@
     { "autostart",           2, IPC_MSG_AUTOSTART,    RB_ENTRY_INITIALIZER() },
     { "bad-format",          2, IPC_MSG_BAD,          RB_ENTRY_INITIALIZER() },
+    { "encryption",          2, IPC_MSG_CRYPTO,       RB_ENTRY_INITIALIZER() },
     { "directory",           2, IPC_MSG_DIR,          RB_ENTRY_INITIALIZER() },
     { "downlimit",           2, IPC_MSG_DOWNLIMIT,    RB_ENTRY_INITIALIZER() },
@@ -146 +148 @@
     { "get-automap",         2, IPC_MSG_GETAUTOMAP,   RB_ENTRY_INITIALIZER() },
     { "get-autostart",       2, IPC_MSG_GETAUTOSTART, RB_ENTRY_INITIALIZER() },
+    { "get-encryption",      2, IPC_MSG_GETCRYPTO,    RB_ENTRY_INITIALIZER() },
     { "get-directory",       2, IPC_MSG_GETDIR,       RB_ENTRY_INITIALIZER() },
     { "get-downlimit",       2, IPC_MSG_GETDOWNLIMIT, RB_ENTRY_INITIALIZER() },
@@ -362 +365 @@
 
 uint8_t *
-ipc_mkval( benc_val_t * pk, size_t * len )
-{
-    char * buf, hex[IPC_MIN_MSG_LEN+1];
-    int    used, max;
-
-    used = IPC_MIN_MSG_LEN;
-    max  = IPC_MIN_MSG_LEN;
-    buf  = malloc( IPC_MIN_MSG_LEN );
-    if( NULL == buf )
-    {
-        return NULL;
-    }
-
-    if( tr_bencSave( pk, &buf, &used, &max ) )
-    {
-        SAFEFREE( buf );
-        return NULL;
-    }
-
-    /* ok, this check is pretty laughable */
-    if( IPC_MAX_MSG_LEN < used )
-    {
-        free( buf );
+ipc_mkval( benc_val_t * pk, size_t * setmeSize )
+{
+    int bencSize = 0;
+    char * benc = tr_bencSave( pk, &bencSize );
+    uint8_t * ret = NULL;
+
+    if( bencSize > IPC_MAX_MSG_LEN )
         errno = EFBIG;
-        return NULL;
-    }
-
-    assert( 0 <= used );
-    snprintf( hex, sizeof hex, "%0*X",
-              IPC_MIN_MSG_LEN, used - IPC_MIN_MSG_LEN );
-    memcpy( buf, hex, IPC_MIN_MSG_LEN );
-    *len = used;
-
-    return ( uint8_t * )buf;
+    else {
+        const size_t size = IPC_MIN_MSG_LEN + bencSize;
+        ret = tr_new( uint8_t, size );
+        snprintf( (char*)ret, size, "%0*X", IPC_MIN_MSG_LEN, bencSize );
+        memcpy( ret + IPC_MIN_MSG_LEN, benc, bencSize );
+        *setmeSize = size;
+    }
+
+    tr_free( benc );
+    return ret;
 }
 

branches/0.9x/libtransmission/ipcparse.h

@@ -43 +43 @@
     IPC_MSG_AUTOSTART,
     IPC_MSG_BAD,
+    IPC_MSG_CRYPTO,
     IPC_MSG_DIR,
     IPC_MSG_DOWNLIMIT,
@@ -48 +49 @@
     IPC_MSG_GETAUTOMAP,
     IPC_MSG_GETAUTOSTART,
+    IPC_MSG_GETCRYPTO,
     IPC_MSG_GETDIR,
     IPC_MSG_GETDOWNLIMIT,

branches/0.9x/libtransmission/makemeta.c

@@ -386 +386 @@
     if ( !builder->abortFlag ) {
         size_t nmemb;
-        char * pch = tr_bencSaveMalloc( &top, &n );
+        char * pch = tr_bencSave( &top, &n );
         FILE * fp = fopen( builder->outputFile, "wb+" );
         nmemb = n;

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

@@ -18 +18 @@
 #include <arpa/inet.h> /* inet_ntoa */
 
-#include <sys/types.h> /* event.h needs this */
 #include <event.h>
 
@@ -31 +30 @@
 #define IO_TIMEOUT_SECS 8
 
+/* arbitrary */
+#define TR_RDBUF (1024*8)
+
 /**
 ***
@@ -49 +51 @@
     int socket;
     int encryptionMode;
+    int timeout;
     struct bufferevent * bufev;
     uint8_t peerId[20];
@@ -59 +62 @@
 
     tr_can_read_cb     canRead;
-    tr_did_write_cb    didWrite;
     tr_net_error_cb    gotError;
     void             * userData;
@@ -71 +73 @@
 
 static void
-didWriteWrapper( struct bufferevent * e, void * userData )
-{
-    tr_peerIo * c = (tr_peerIo *) userData;
-    if( c->didWrite != NULL )
-        (*c->didWrite)( e, c->userData );
-}
-
-static void
 canReadWrapper( struct bufferevent * e, void * userData )
 {
     int done = 0;
-    tr_peerIo * c = (tr_peerIo *) userData;
+    tr_peerIo * c = userData;
     tr_handle * handle = c->handle;
 
@@ -100 +94 @@
                     continue;
             case READ_MORE:
-                tr_peerIoSetIOMode( c, EV_READ, 0 );
             case READ_DONE:
                 done = 1;
@@ -112 +105 @@
 gotErrorWrapper( struct bufferevent * e, short what, void * userData )
 {
-    tr_peerIo * c = (tr_peerIo *) userData;
+    tr_peerIo * c = userData;
     if( c->gotError != NULL )
         (*c->gotError)( e, what, c->userData );
@@ -120 +113 @@
 ***
 **/
+
+void bufferevent_setwatermark(struct bufferevent *, short, size_t, size_t);
 
 static tr_peerIo*
@@ -137 +132 @@
     c->socket = socket;
     c->isIncoming = isIncoming ? 1 : 0;
+    c->timeout = IO_TIMEOUT_SECS;
     c->bufev = bufferevent_new( c->socket,
                                 canReadWrapper,
-                                didWriteWrapper,
+                                NULL,
                                 gotErrorWrapper,
                                 c );
-    bufferevent_settimeout( c->bufev, IO_TIMEOUT_SECS, IO_TIMEOUT_SECS );
+    bufferevent_settimeout( c->bufev, c->timeout, c->timeout );
     bufferevent_enable( c->bufev, EV_READ|EV_WRITE );
+    bufferevent_setwatermark( c->bufev, EV_READ, 0, TR_RDBUF );
+
     return c;
 }
@@ -195 +193 @@
     {
         io->canRead = NULL;
-        io->didWrite = NULL;
         io->gotError = NULL;
         tr_runInEventThread( io->handle, io_dtor, io );
@@ -235 +232 @@
 }
 
+void
+tr_peerIoTryRead( tr_peerIo * io )
+{
+    if( EVBUFFER_LENGTH( io->bufev->input ) )
+        canReadWrapper( io->bufev, io );
+}
+
 void 
 tr_peerIoSetIOFuncs( tr_peerIo          * io,
                      tr_can_read_cb       readcb,
-                     tr_did_write_cb      writecb,
                      tr_net_error_cb      errcb,
                      void               * userData )
 {
     io->canRead = readcb;
-    io->didWrite = writecb;
     io->gotError = errcb;
     io->userData = userData;
 
-    if( EVBUFFER_LENGTH( io->bufev->input ) )
-        canReadWrapper( io->bufev, io );
-}
-
-void
-tr_peerIoSetIOMode( tr_peerIo * c, short enable, short disable )
-{
-    tr_setBufferEventMode( c->handle, c->bufev, enable, disable );
+    tr_peerIoTryRead( io );
 }
 
@@ -278 +273 @@
 
         io->bufev = bufferevent_new( io->socket,
-                                     canReadWrapper,
-                                     didWriteWrapper,
-                                     gotErrorWrapper,
+                                     canReadWrapper, NULL, gotErrorWrapper,
                                      io );
-        bufferevent_settimeout( io->bufev, IO_TIMEOUT_SECS, IO_TIMEOUT_SECS );
+        bufferevent_settimeout( io->bufev, io->timeout, io->timeout );
         bufferevent_enable( io->bufev, EV_READ|EV_WRITE );
+        bufferevent_setwatermark( io->bufev, EV_READ, 0, TR_RDBUF );
 
         return 0;
@@ -294 +288 @@
 tr_peerIoSetTimeoutSecs( tr_peerIo * io, int secs )
 {
-    bufferevent_settimeout( io->bufev, secs, secs );
+    io->timeout = secs;
+    bufferevent_settimeout( io->bufev, io->timeout, io->timeout );
 }
 
@@ -405 +400 @@
                 int           writeme_len )
 {
-    tr_bufferevent_write( io->handle, io->bufev, writeme, writeme_len );
+    assert( tr_amInEventThread( io->handle ) );
+    bufferevent_write( io->bufev, writeme, writeme_len );
 }
 
@@ -412 +408 @@
                    struct evbuffer * buf )
 {
-    tr_peerIoWrite( io, EVBUFFER_DATA(buf), EVBUFFER_LENGTH(buf) );
-    evbuffer_drain( buf, ~0 );
+    const size_t n = EVBUFFER_LENGTH( buf );
+    tr_peerIoWrite( io, EVBUFFER_DATA(buf), n );
+    evbuffer_drain( buf, n );
 }
 
@@ -442 +439 @@
 }
 
+/**
+***
+**/
+
 void
 tr_peerIoWriteBytes( tr_peerIo        * io,
                      struct evbuffer  * outbuf,
                      const void       * bytes,
-                     int                byteCount )
+                     size_t             byteCount )
 {
     uint8_t * tmp;
@@ -469 +470 @@
 
 void
+tr_peerIoWriteUint8( tr_peerIo        * io,
+                     struct evbuffer  * outbuf,
+                     uint8_t            writeme )
+{
+    tr_peerIoWriteBytes( io, outbuf, &writeme, sizeof(uint8_t) );
+}
+
+void
 tr_peerIoWriteUint16( tr_peerIo        * io,
                       struct evbuffer  * outbuf,
@@ -478 +487 @@
 
 void
-tr_peerIoWriteUint8( tr_peerIo        * io,
-                     struct evbuffer  * outbuf,
-                     uint8_t            writeme )
-{
-    tr_peerIoWriteBytes( io, outbuf, &writeme, sizeof(uint8_t) );
-}
-
-void
 tr_peerIoWriteUint32( tr_peerIo        * io,
                       struct evbuffer  * outbuf,
@@ -494 +495 @@
 }
 
+/***
+****
+***/
+
 void
 tr_peerIoReadBytes( tr_peerIo        * io,
                     struct evbuffer  * inbuf,
                     void             * bytes,
-                    int                byteCount )
-{
-    assert( (int)EVBUFFER_LENGTH( inbuf ) >= byteCount );
+                    size_t             byteCount )
+{
+    assert( EVBUFFER_LENGTH( inbuf ) >= byteCount );
 
     switch( io->encryptionMode )
     {
         case PEER_ENCRYPTION_NONE:
-            evbuffer_remove(  inbuf, bytes, byteCount );
+            evbuffer_remove( inbuf, bytes, byteCount );
             break;
 
         case PEER_ENCRYPTION_RC4:
-            evbuffer_remove(  inbuf, bytes, byteCount );
+            evbuffer_remove( inbuf, bytes, byteCount );
             tr_cryptoDecrypt( io->crypto, byteCount, bytes, bytes );
             break;
@@ -519 +524 @@
 
 void
+tr_peerIoReadUint8( tr_peerIo         * io,
+                    struct evbuffer   * inbuf,
+                    uint8_t           * setme )
+{
+    tr_peerIoReadBytes( io, inbuf, setme, sizeof(uint8_t) );
+}
+
+void
 tr_peerIoReadUint16( tr_peerIo         * io,
                      struct evbuffer   * inbuf,
@@ -529 +542 @@
 
 void
-tr_peerIoReadUint8( tr_peerIo         * io,
-                    struct evbuffer   * inbuf,
-                    uint8_t           * setme )
-{
-    tr_peerIoReadBytes( io, inbuf, setme, sizeof(uint8_t) );
-}
-
-void
 tr_peerIoReadUint32( tr_peerIo         * io,
                      struct evbuffer   * inbuf,
@@ -549 +554 @@
 tr_peerIoDrain( tr_peerIo        * io,
                 struct evbuffer  * inbuf,
-                int                byteCount )
+                size_t             byteCount )
 {
     uint8_t * tmp = tr_new( uint8_t, byteCount );

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

@@ -100 +100 @@
 typedef enum { READ_MORE, READ_AGAIN, READ_DONE } 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 );
 
-void  tr_peerIoSetIOMode ( tr_peerIo   * io,
-                           short         enable_mode,
-                           short         disable_mode );
+size_t tr_peerIoWriteBytesWaiting( const tr_peerIo * io );
 
-size_t tr_peerIoWriteBytesWaiting( const tr_peerIo * io );
+void tr_peerIoTryRead( tr_peerIo * io );
 
 void tr_peerIoWrite( tr_peerIo   * io,
@@ -145 +141 @@
                             struct evbuffer  * outbuf,
                             const void       * bytes,
-                            int                byteCount );
+                            size_t             byteCount );
 
 void tr_peerIoWriteUint8  ( tr_peerIo        * io,
@@ -162 +158 @@
                             struct evbuffer  * inbuf,
                             void             * bytes,
-                            int                byteCount );
+                            size_t             byteCount );
 
 void tr_peerIoReadUint8   ( tr_peerIo        * io,
@@ -178 +174 @@
 void tr_peerIoDrain       ( tr_peerIo        * io,
                             struct evbuffer  * inbuf,
-                            int                byteCount );
+                            size_t             byteCount );
 
 

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

@@ -29 +29 @@
 };
 
+/**
+*** The "SWIFT" system is described by Karthik Tamilmani,
+*** Vinay Pai, and Alexander Mohr of Stony Brook University
+*** in their paper "SWIFT: A System With Incentives For Trading"
+*** http://citeseer.ist.psu.edu/tamilmani04swift.html
+***
+*** More SWIFT constants are defined in peer-mgr.c
+**/
+
+/**
+ * Use SWIFT?
+ */
+static const int SWIFT_ENABLED = 1;
+
+/**
+ * For every byte the peer uploads to us,
+ * allow them to download this many bytes from us
+ */
+static const double SWIFT_REPAYMENT_RATIO = 1.33;
+
+
 typedef struct tr_peer
 {
@@ -37 +58 @@
     unsigned int  doPurge : 1;
 
+    tr_peer_status status;
 
     /* number of bad pieces they've contributed to */
@@ -66 +88 @@
     double rateToClient;
     double rateToPeer;
+
+    int64_t credit;
 }
 tr_peer;

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

@@ -20 +20 @@
 #include <arpa/inet.h> /* inet_ntoa */
 
-#include <sys/queue.h> /* libevent needs this */
-#include <sys/types.h> /* libevent needs this */
 #include <event.h>
 
@@ -38 +36 @@
 #include "ratecontrol.h"
 #include "shared.h"
+#include "trcompat.h" /* strlcpy */
 #include "trevent.h"
 #include "utils.h"
 
+/**
+*** The "SWIFT" system is described by Karthik Tamilmani,
+*** Vinay Pai, and Alexander Mohr of Stony Brook University
+*** in their paper "SWIFT: A System With Incentives For Trading"
+*** http://citeseer.ist.psu.edu/tamilmani04swift.html
+***
+*** More SWIFT constants are defined in peer-mgr-private.h
+**/
+
+/**
+ * Allow new peers to download this many bytes from
+ * us when getting started.  This can prevent gridlock
+ * with other peers using tit-for-tat algorithms
+ */
+static const int SWIFT_INITIAL_CREDIT = 64 * 1024; /* 64 KiB */
+
+/**
+ * We expend a fraction of our torrent's total upload speed
+ * on largesse by uniformly distributing free credit to
+ * all of our peers.  This too helps prevent gridlock.
+ */
+static const double SWIFT_LARGESSE = 0.10; /* 10% of our UL */
+
+/**
+ * How frequently to extend largesse-based credit
+ */
+static const int SWIFT_PERIOD_MSEC = 5000;
+
+
 enum
 {
@@ -47 +75 @@
 
     /* how frequently to decide which peers live and die */
-    RECONNECT_PERIOD_MSEC = (5 * 1000),
+    RECONNECT_PERIOD_MSEC = (6 * 1000),
 
     /* how frequently to refill peers' request lists */
@@ -60 +88 @@
 
     /* arbitrary */
-    MAX_CONNECTED_PEERS_PER_TORRENT = 60,
+    MAX_CONNECTED_PEERS_PER_TORRENT = 50,
 
     /* when many peers are available, keep idle ones this long */
-    MIN_UPLOAD_IDLE_SECS = 60,
+    MIN_UPLOAD_IDLE_SECS = (60 * 3),
 
     /* when few peers are available, keep idle ones this long */
-    MAX_UPLOAD_IDLE_SECS = 240,
+    MAX_UPLOAD_IDLE_SECS = (60 * 10),
 
     /* how many peers to unchoke per-torrent. */
     /* FIXME: make this user-configurable? */
-    NUM_UNCHOKED_PEERS_PER_TORRENT = 12, /* arbitrary */
+    NUM_UNCHOKED_PEERS_PER_TORRENT = 10, /* arbitrary */
 
     /* set this too high and there will be a lot of churn.
@@ -116 +144 @@
     tr_timer * rechokeTimer;
     tr_timer * refillTimer;
+    tr_timer * swiftTimer;
     tr_torrent * tor;
     tr_bitfield * requested;
@@ -316 +345 @@
     tr_peer * p;
     p = tr_new0( tr_peer, 1 );
+    p->credit = SWIFT_INITIAL_CREDIT;
     p->rcToClient = tr_rcInit( );
     p->rcToPeer = tr_rcInit( );
@@ -399 +429 @@
     tr_timerFree( &t->rechokeTimer );
     tr_timerFree( &t->refillTimer );
+    tr_timerFree( &t->swiftTimer );
 
     tr_bitfieldFree( t->requested );
@@ -448 +479 @@
     tr_bitfield_t * ret;
 
+#if 0
     printf( "%d piece allowed fast set for torrent with %d pieces and hex infohash\n", setCount, pieceCount );
     printf( "%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x for node with IP %s:\n",
@@ -453 +485 @@
             infohash[10], infohash[11], infohash[12], infohash[13], infohash[14], infohash[15], infohash[16], infohash[7], infohash[18], infohash[19],
             inet_ntoa( *ip ) );
+#endif
     
     seed = malloc(4 + SHA_DIGEST_LENGTH);
@@ -551 +584 @@
     uint32_t peerCount;
     uint32_t fastAllowed;
+    uint32_t suggested;
 };
 
@@ -560 +594 @@
     
     /* if one *might be* fastallowed to us, get it first...
-     * I'm putting it on top so we prioritise those pieces at
+     * I'm putting it on top so we prioritize those pieces at
      * startup, then we'll have them, and we'll be denied access
      * to them */
@@ -569 +603 @@
     if (a->priority != b->priority)
         return a->priority > b->priority ? -1 : 1;
+    
+    /* otherwise if one was suggested to us, get it */
+    if (a->suggested != b->suggested)
+        return a->suggested < b->suggested ? -1 : 1;
 
     /* try to fill partial pieces */
@@ -641 +679 @@
                     but we're guaranteed to get the same pieces from different peers, 
                     so we'll build a list and pray one actually have this one */
-                setme->fastAllowed = tr_peerMsgIsPieceFastAllowed( peer->msgs, i);
+                setme->fastAllowed = tr_peerMsgsIsPieceFastAllowed( peer->msgs, i );
+                /* Also, if someone SUGGESTed a piece to us, prioritize it over non-suggested others
+                 */
+                setme->suggested   = tr_peerMsgsIsPieceSuggested( peer->msgs, i );
             }
         }
@@ -731 +772 @@
     for( i=0; peerCount && i<blockCount; ++i )
     {
-        const int block = blocks[i];
+        const uint64_t block = blocks[i];
         const uint32_t index = tr_torBlockPiece( tor, block );
         const uint32_t begin = (block * tor->blockSize) - (index * tor->info.pieceSize);
-        const uint32_t length = tr_torBlockCountBytes( tor, block );
+        const uint32_t length = tr_torBlockCountBytes( tor, (int)block );
         int j;
-        assert( _tr_block( tor, index, begin ) == block );
+        assert( _tr_block( tor, index, begin ) == (int)block );
         assert( begin < (uint32_t)tr_torPieceCountBytes( tor, (int)index ) );
         assert( (begin + length) <= (uint32_t)tr_torPieceCountBytes( tor, (int)index ) );
-
 
         /* find a peer who can ask for this block */
@@ -807 +847 @@
 
 static void
+addStrike( Torrent * t, tr_peer * peer )
+{
+    tordbg( t, "increasing peer %s strike count to %d", tr_peerIoAddrStr(&peer->in_addr,peer->port), peer->strikes+1 );
+
+    if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
+    {
+        struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
+        atom->myflags |= MYFLAG_BANNED;
+        peer->doPurge = 1;
+        tordbg( t, "banning peer %s", tr_peerIoAddrStr(&atom->addr,atom->port) );
+    }
+}
+
+static void
 msgsCallbackFunc( void * vpeer, void * vevent, void * vt )
 {
@@ -849 +903 @@
             break;
 
+        case TR_PEERMSG_GOT_ASSERT_ERROR:
+            addStrike( t, peer );
+            peer->doPurge = 1;
+            break;
+
         case TR_PEERMSG_GOT_ERROR:
             peer->doPurge = 1;
@@ -936 +995 @@
             tr_peerIoFree( io );
         }
+        else if( tr_ptrArraySize( t->peers ) >= MAX_CONNECTED_PEERS_PER_TORRENT )
+        {
+            tr_peerIoFree( io );
+        }
         else
         {
@@ -941 +1004 @@
 
             if( peer != NULL ) /* we already have this peer */
-            {
-                tr_peerIoFree( io );
-            }
-            else if( tr_ptrArraySize( t->peers ) >= MAX_CONNECTED_PEERS_PER_TORRENT )
             {
                 tr_peerIoFree( io );
@@ -1063 +1122 @@
         for( i=0; i<peerCount; ++i )
         {
-            struct peer_atom * atom;
-            tr_peer * peer;
-
-            peer = peers[i];
-            if( !tr_bitfieldHas( peer->blame, pieceIndex ) )
-                continue;
-
-            ++peer->strikes;
-            tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
-                       tr_peerIoAddrStr(&peer->in_addr,peer->port),
-                       pieceIndex, (int)peer->strikes );
-            if( peer->strikes < MAX_BAD_PIECES_PER_PEER )
-                continue;
-
-            atom = getExistingAtom( t, &peer->in_addr );
-            atom->myflags |= MYFLAG_BANNED;
-            peer->doPurge = 1;
-            tordbg( t, "banning peer %s due to corrupt data", tr_peerIoAddrStr(&atom->addr,atom->port) );
+            tr_peer * peer = peers[i];
+            if( tr_bitfieldHas( peer->blame, pieceIndex ) )
+            {
+                tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
+                           tr_peerIoAddrStr(&peer->in_addr,peer->port),
+                           pieceIndex, (int)peer->strikes+1 );
+                addStrike( t, peer );
+            }
         }
     }
@@ -1151 +1200 @@
 static int reconnectPulse( void * vtorrent );
 static int rechokePulse( void * vtorrent );
+static int swiftPulse( void * vtorrent );
 
 void
@@ -1165 +1215 @@
     assert( ( t->isRunning != 0 ) == ( t->reconnectTimer != NULL ) );
     assert( ( t->isRunning != 0 ) == ( t->rechokeTimer != NULL ) );
+    assert( ( t->isRunning != 0 ) == ( t->swiftTimer != NULL ) );
 
     if( !t->isRunning )
@@ -1178 +1229 @@
                                        RECHOKE_PERIOD_MSEC );
 
+        t->swiftTimer = tr_timerNew( t->manager->handle,
+                                     swiftPulse, t,
+                                     SWIFT_PERIOD_MSEC );
+
         reconnectPulse( t );
 
         rechokePulse( t );
+
+        swiftPulse( t );
     }
 
@@ -1194 +1251 @@
     tr_timerFree( &t->rechokeTimer );
     tr_timerFree( &t->reconnectTimer );
+    tr_timerFree( &t->swiftTimer );
 
     /* disconnect the peers. */
@@ -1305 +1363 @@
     for( i=0; i<size; ++i )
         if( peers[i]->io != NULL )
-            tr_bitfieldAnd( pieces, peers[i]->have );
+            tr_bitfieldOr( pieces, peers[i]->have );
 
     managerUnlock( (tr_peerMgr*)manager );
@@ -1398 +1456 @@
 
         tr_netNtop( &peer->in_addr, stat->addr, sizeof(stat->addr) );
+        strlcpy( stat->client, (peer->client ? peer->client : ""), sizeof(stat->client) );
         stat->port             = peer->port;
         stat->from             = atom->from;
-        stat->client           = tr_strdup( peer->client ? peer->client : "" );
         stat->progress         = peer->progress;
         stat->isEncrypted      = tr_peerIoIsEncrypted( peer->io ) ? 1 : 0;
@@ -1407 +1465 @@
         stat->isDownloading    = stat->uploadToRate > 0.01;
         stat->isUploading      = stat->downloadFromRate > 0.01;
+        stat->status           = peer->status;
     }
 
@@ -1423 +1482 @@
 {
     tr_peer * peer;
-    float rate;
-    int randomKey;
+    int rate;
     int preferred;
     int doUnchoke;
@@ -1435 +1493 @@
     const struct ChokeData * b = vb;
 
+    /* primary key: larger speeds */
+    if( a->rate > b->rate )
+        return -1;
+    if ( a->rate < b->rate )
+        return 1;
+
+    /* secondary key: perferred peers */
     if( a->preferred != b->preferred )
         return a->preferred ? -1 : 1;
 
-    if( a->preferred )
-    {
-        if( a->rate > b->rate ) return -1;
-        if( a->rate < b->rate ) return 1;
-        return 0;
-    }
-    else
-    {
-        return a->randomKey - b->randomKey;
-    }
+    return 0;
 }
 
@@ -1463 +1519 @@
 
 static double
-getWeightedThroughput( const tr_peer * peer )
-{
-    return ( 3 * peer->rateToPeer )
-         + ( 1 * peer->rateToClient );
+getWeightedThroughput( const tr_peer * peer, int clientIsSeed )
+{
+    return (int)( 10.0 * ( clientIsSeed ? peer->rateToPeer
+                                        : peer->rateToClient ) );
 }
 
@@ -1476 +1532 @@
     tr_peer ** peers = getConnectedPeers( t, &peerCount );
     struct ChokeData * choke = tr_new0( struct ChokeData, peerCount );
+    const int clientIsSeed = tr_torrentIsSeed( t->tor );
 
     assert( torrentIsLocked( t ) );
@@ -1484 +1541 @@
         tr_peer * peer = peers[i];
         struct ChokeData * node;
-        if( peer->chokeChangedAt > fibrillationTime )
+        if( peer->chokeChangedAt > fibrillationTime ) {
+            if( !peer->peerIsChoked )
+                ++unchoked;
             continue;
+        }
 
         node = &choke[size++];
         node->peer = peer;
         node->preferred = peer->peerIsInterested && !clientIsSnubbedBy(peer);
-        node->randomKey = tr_rand( INT_MAX );
-        node->rate = getWeightedThroughput( peer );
+        node->rate = getWeightedThroughput( peer, clientIsSeed );
     }
 
     qsort( choke, size, sizeof(struct ChokeData), compareChoke );
 
-    for( i=0; i<size && i<NUM_UNCHOKED_PEERS_PER_TORRENT; ++i ) {
+    for( i=0; i<size && unchoked<NUM_UNCHOKED_PEERS_PER_TORRENT; ++i ) {
         choke[i].doUnchoke = 1;
         ++unchoked;
@@ -1502 +1561 @@
 
     for( ; i<size; ++i ) {
+        ++unchoked;
         choke[i].doUnchoke = 1;
-        ++unchoked;
         if( choke[i].peer->peerIsInterested )
             break;
@@ -1522 +1581 @@
     torrentLock( t );
     rechoke( t );
+    torrentUnlock( t );
+    return TRUE;
+}
+
+/***
+****
+***/
+
+static int
+swiftPulse( void * vtorrent )
+{
+    Torrent * t = vtorrent;
+    torrentLock( t );
+
+    if( !tr_torrentIsSeed( t->tor ) )
+    {
+        int i;
+        int peerCount = 0;
+        int deadbeatCount = 0;
+        tr_peer ** peers = getConnectedPeers( t, &peerCount );
+        tr_peer ** deadbeats = tr_new( tr_peer*, peerCount );
+
+        const double ul_KiBsec = tr_rcRate( t->tor->upload );
+        const double ul_KiB = ul_KiBsec * (SWIFT_PERIOD_MSEC/1000.0);
+        const double ul_bytes = ul_KiB * 1024;
+        const double freeCreditTotal = ul_bytes * SWIFT_LARGESSE;
+        int freeCreditPerPeer;
+
+        for( i=0; i<peerCount; ++i ) {
+            tr_peer * peer = peers[i];
+            if( peer->credit <= 0 )
+                deadbeats[deadbeatCount++] =  peer;
+        }
+
+        freeCreditPerPeer = (int)( freeCreditTotal / deadbeatCount );
+        for( i=0; i<deadbeatCount; ++i )
+            deadbeats[i]->credit = freeCreditPerPeer;
+
+        tordbg( t, "%d deadbeats, "
+            "who are each being granted %d bytes' credit "
+            "for a total of %.1f KiB, "
+            "%d%% of the torrent's ul speed %.1f\n",
+            deadbeatCount, freeCreditPerPeer,
+            ul_KiBsec*SWIFT_LARGESSE, (int)(SWIFT_LARGESSE*100), ul_KiBsec );
+
+        tr_free( deadbeats );
+        tr_free( peers );
+    }
+
     torrentUnlock( t );
     return TRUE;
@@ -1633 +1741 @@
          * now to weed it out in case someone sends it to us via pex */
         if( atom->myflags & MYFLAG_BANNED ) {
+#if 0
             tordbg( t, "RECONNECT peer %d (%s) is banned...",
                     i, tr_peerIoAddrStr(&atom->addr,atom->port) );
+#endif
             continue;
         }
@@ -1640 +1750 @@
         /* we don't need two connections to the same peer... */
         if( peerIsInUse( t, &atom->addr ) ) {
+#if 0
             tordbg( t, "RECONNECT peer %d (%s) is in use..",
                     i, tr_peerIoAddrStr(&atom->addr,atom->port) );
+#endif
             continue;
         }
@@ -1647 +1759 @@
         /* no need to connect if we're both seeds... */
         if( seed && (atom->flags & ADDED_F_SEED_FLAG) ) {
+#if 0
             tordbg( t, "RECONNECT peer %d (%s) is a seed and so are we..",
                     i, tr_peerIoAddrStr(&atom->addr,atom->port) );
+#endif
             continue;
         }
@@ -1654 +1768 @@
         /* we're wasting our time trying to connect to this bozo. */
         if( atom->numFails > 10 ) {
+#if 0
             tordbg( t, "RECONNECT peer %d (%s) gives us nothing but failure.",
                     i, tr_peerIoAddrStr(&atom->addr,atom->port) );
+#endif
             continue;
         }
@@ -1692 +1808 @@
     else
     {
-        int i, nCandidates, nBad, nAdd;
+        int i, nCandidates, nBad;
         struct peer_atom ** candidates = getPeerCandidates( t, &nCandidates );
         struct tr_peer ** connections = getPeersToClose( t, &nBad );
-        const int peerCount = tr_ptrArraySize( t->peers );
 
         if( nBad || nCandidates )
@@ -1719 +1834 @@
 
         /* add some new ones */
-        nAdd = !peerCount ? MAX_CONNECTED_PEERS_PER_TORRENT
-                          : MAX_RECONNECTIONS_PER_PULSE;
-        for( i=0; i<nAdd && i<nCandidates && i<MAX_RECONNECTIONS_PER_PULSE; ++i )
+        for( i=0; i<nCandidates && i<MAX_RECONNECTIONS_PER_PULSE; ++i )
         {
             tr_peerMgr * mgr = t->manager;

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

@@ -21 +21 @@
 #include <netinet/in.h> /* struct in_addr */
 
-#include <sys/queue.h> /* libevent needs this */
-#include <sys/types.h> /* libevent needs this */
 #include <event.h>
 
@@ -71 +69 @@
 
     PEX_INTERVAL            = (60 * 1000), /* msec between calls to sendPex() */
-    PEER_PULSE_INTERVAL     = (100),       /* msec between calls to pulse() */
+    PEER_PULSE_INTERVAL     = (250),       /* msec between calls to pulse() */
     RATE_PULSE_INTERVAL     = (333),       /* msec between calls to ratePulse() */
-
-    /* number of pieces generated for allow-fast,
-      threshold for fast-allowing others */
-    MAX_ALLOWED_SET_COUNT   = 10
+     
+    /* Fast Peers Extension constants */
+    MAX_FAST_ALLOWED_COUNT   = 10,          /* max. number of pieces we fast-allow to another peer */
+    MAX_FAST_ALLOWED_THRESHOLD = 10,        /* max threshold for allowing fast-pieces requests */
+
 };
 
@@ -82 +81 @@
 {
     AWAITING_BT_LENGTH,
-    AWAITING_BT_MESSAGE
+    AWAITING_BT_ID,
+    AWAITING_BT_MESSAGE,
+    AWAITING_BT_PIECE
 };
 
@@ -105 +106 @@
 }
 
+/* this is raw, unchanged data from the peer regarding
+ * the current message that it's sending us. */
+struct tr_incoming
+{
+    uint32_t length; /* includes the +1 for id length */
+    uint8_t id;
+    struct peer_request blockReq; /* metadata for incoming blocks */
+    struct evbuffer * block; /* piece data for incoming blocks */
+};
+
 struct tr_peermsgs
 {
@@ -130 +141 @@
     time_t clientSentAnythingAt;
 
-    unsigned int notListening             : 1;
+    unsigned int peerSentBitfield         : 1;
     unsigned int peerSupportsPex          : 1;
     unsigned int clientSentLtepHandshake  : 1;
     unsigned int peerSentLtepHandshake    : 1;
+    unsigned int sendingBlock             : 1;
     
     tr_bitfield * clientAllowedPieces;
     tr_bitfield * peerAllowedPieces;
     
+    tr_bitfield * clientSuggestedPieces;
+    
     uint8_t state;
     uint8_t ut_pex_id;
     uint16_t pexCount;
-    uint32_t incomingMessageLength;
     uint32_t maxActiveRequests;
     uint32_t minActiveRequests;
+
+    struct tr_incoming incoming; 
 
     tr_pex * pex;
@@ -251 +266 @@
 
 static void
+fireGotAssertError( tr_peermsgs * msgs )
+{
+    tr_peermsgs_event e = blankEvent;
+    e.eventType = TR_PEERMSG_GOT_ASSERT_ERROR;
+    publish( msgs, &e );
+}
+
+static void
 fireGotError( tr_peermsgs * msgs )
 {
@@ -426 +449 @@
                  uint32_t      pieceIndex )
 {
-    dbgmsg( msgs, "w00t SUGGESTing them piece #%d", pieceIndex );
-    tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) + sizeof(uint32_t) );
-    tr_peerIoWriteUint8( msgs->io, msgs->outMessages, BT_SUGGEST );
-    tr_peerIoWriteUint32( msgs->io, msgs->outMessages, pieceIndex );
+    assert( msgs != NULL );
     
-    updateInterest( msgs );
+    if( tr_peerIoSupportsFEXT( msgs->io ) )
+    {
+        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) + sizeof(uint32_t) );
+        tr_peerIoWriteUint8( msgs->io, msgs->outMessages, BT_SUGGEST );
+        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, pieceIndex );
+    }
 }
 #endif
@@ -437 +462 @@
 sendFastHave( tr_peermsgs * msgs, int all )
 {
-    dbgmsg( msgs, "w00t telling them we have %s pieces", (all ? "ALL" : "NONE" ) );
-    tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) );
-    tr_peerIoWriteUint8( msgs->io, msgs->outMessages, ( all ? BT_HAVE_ALL
-                                                            : BT_HAVE_NONE ) );
-    updateInterest( msgs );
+    assert( msgs != NULL );
+    
+    if( tr_peerIoSupportsFEXT( msgs->io ) )
+    {
+        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) );
+        tr_peerIoWriteUint8( msgs->io, msgs->outMessages, ( all ? BT_HAVE_ALL
+                                                                : BT_HAVE_NONE ) );
+        updateInterest( msgs );
+    }
 }
 
@@ -467 +496 @@
                  uint32_t      pieceIndex)
 {
-    dbgmsg( msgs, "w00t telling them we ALLOW_FAST piece #%d", pieceIndex );
-    tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) + sizeof(uint32_t) );
-    tr_peerIoWriteUint8( msgs->io, msgs->outMessages, BT_ALLOWED_FAST );
-    tr_peerIoWriteUint32( msgs->io, msgs->outMessages, pieceIndex );
+    assert( msgs != NULL );
+    
+    if( tr_peerIoSupportsFEXT( msgs->io ) )
+    {
+        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) + sizeof(uint32_t) );
+        tr_peerIoWriteUint8( msgs->io, msgs->outMessages, BT_ALLOWED_FAST );
+        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, pieceIndex );
+    }
 }
 
@@ -534 +567 @@
     {
         struct peer_request * r = tr_list_pop_front( &msgs->clientWillAskFor );
+        assert( requestIsValid( msgs, r ) );
+        assert( tr_bitfieldHas( msgs->info->have, r->index ) );
         protocolSendRequest( msgs, r );
         r->time_requested = msgs->lastReqAddedAt = time( NULL );
@@ -550 +585 @@
         fireNeedReq( msgs );
 }
+
+static int
+pulse( void * vmsgs );
 
 int
@@ -701 +739 @@
         tr_bencInitInt( tr_bencDictAdd( &val, "p" ), port );
     tr_bencInitStr( tr_bencDictAdd( &val, "v" ), v, 0, 1 );
-    buf = tr_bencSaveMalloc( &val, &len );
+    buf = tr_bencSave( &val, &len );
 
     tr_peerIoWriteUint32( msgs->io, outbuf, 2*sizeof(uint8_t) + len );
@@ -713 +751 @@
     dbgmsg( msgs, "here is the ltep handshake we sent:" );
     tr_bencPrint( &val );
+    dbgmsg( msgs, "here is the ltep handshake we read [%s]:", tr_bencSave( &val, NULL ) );
 #endif
 
@@ -739 +778 @@
     dbgmsg( msgs, "here is the ltep handshake we read:" );
     tr_bencPrint( &val );
+    dbgmsg( msgs, "here is the ltep handshake we read [%s]:", tr_bencSave( &val, NULL ) );
 #endif
 
@@ -817 +857 @@
         dbgmsg( msgs, "got ltep handshake" );
         parseLtepHandshake( msgs, msglen, inbuf );
-        sendLtepHandshake( msgs );
-        sendPex( msgs );
+        if( tr_peerIoSupportsLTEP( msgs->io ) )
+        {
+            sendLtepHandshake( msgs );
+            sendPex( msgs );
+        }
     }
     else if( ltep_msgid == msgs->ut_pex_id )
@@ -834 +877 @@
 
 static int
-readBtLength( tr_peermsgs * msgs, struct evbuffer * inbuf )
+readBtLength( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
 {
     uint32_t len;
-    const size_t needlen = sizeof(uint32_t);
-
-    if( EVBUFFER_LENGTH(inbuf) < needlen )
+
+    if( inlen < sizeof(len) )
         return READ_MORE;
 
@@ -847 +889 @@
         dbgmsg( msgs, "got KeepAlive" );
     else {
-        msgs->incomingMessageLength = len;
+        msgs->incoming.length = len;
+        msgs->state = AWAITING_BT_ID;
+    }
+
+    return READ_AGAIN;
+}
+
+static int
+readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen );
+
+static int
+readBtId( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
+{
+    uint8_t id;
+
+    if( inlen < sizeof(uint8_t) )
+        return READ_MORE;
+
+    tr_peerIoReadUint8( msgs->io, inbuf, &id );
+    msgs->incoming.id = id;
+
+    if( id==BT_PIECE )
+    {
+        msgs->state = AWAITING_BT_PIECE;
+        return READ_AGAIN;
+    }
+    else if( msgs->incoming.length != 1 )
+    {
         msgs->state = AWAITING_BT_MESSAGE;
-    }
-
-    return READ_AGAIN;
+        return READ_AGAIN;
+    }
+    else return readBtMessage( msgs, inbuf, inlen-1 );
 }
 
@@ -866 +935 @@
 clientCanSendFastBlock( const tr_peermsgs * msgs UNUSED )
 {
-    /* FIXME(tiennou): base this on how many blocks we've already sent this
-     * peer, or maybe how many fast blocks per minute we've sent overall,
-     * or maybe how much bandwidth we're already using up w/o fast peers.
-     * I don't know what the Right Thing here is, but 
-     * the previous measurement of how many pieces we have is not enough. */
-    return FALSE;
+    /* We can't send a fast piece if a peer has more than MAX_FAST_ALLOWED_THRESHOLD pieces */
+    if( tr_bitfieldCountTrueBits( msgs->info->have ) > MAX_FAST_ALLOWED_THRESHOLD )
+        return FALSE;
+    
+    /* ...or if we don't have ourself enough pieces */
+    if( tr_bitfieldCountTrueBits( tr_cpPieceBitfield( msgs->torrent->completion ) ) < MAX_FAST_ALLOWED_THRESHOLD )
+        return FALSE;
+
+    /* Maybe a bandwidth limit ? */
+    return TRUE;
 }
 
@@ -954 +1027 @@
 }
 
-static void
+static int
 clientGotBlock( tr_peermsgs * msgs, const uint8_t * block, const struct peer_request * req );
 
+static void
+clientGotBytes( tr_peermsgs * msgs, uint32_t byteCount )
+{
+    tr_torrent * tor = msgs->torrent;
+    tor->activityDate = tr_date( );
+    tor->downloadedCur += byteCount;
+    msgs->info->pieceDataActivityDate = time( NULL );
+    msgs->info->credit += (int)(byteCount * SWIFT_REPAYMENT_RATIO);
+    tr_rcTransferred( msgs->info->rcToClient, byteCount );
+    tr_rcTransferred( tor->download, byteCount );
+    tr_rcTransferred( tor->handle->download, byteCount );
+}
+
+
 static int
-readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf )
-{
-    uint8_t id;
+readBtPiece( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
+{
+    struct peer_request * req = &msgs->incoming.blockReq;
+    assert( EVBUFFER_LENGTH(inbuf) >= inlen );
+    dbgmsg( msgs, "In readBtPiece" );
+
+    if( !req->length )
+    {
+        if( inlen < 8 )
+            return READ_MORE;
+
+        tr_peerIoReadUint32( msgs->io, inbuf, &req->index );
+        tr_peerIoReadUint32( msgs->io, inbuf, &req->offset );
+        req->length = msgs->incoming.length - 9;
+        dbgmsg( msgs, "got incoming block header %u:%u->%u", req->index, req->offset, req->length );
+        return READ_AGAIN;
+    }
+    else
+    {
+        int err;
+
+        /* read in another chunk of data */
+        const size_t nLeft = req->length - EVBUFFER_LENGTH(msgs->incoming.block);
+        size_t n = MIN( nLeft, inlen );
+        uint8_t * buf = tr_new( uint8_t, n );
+        assert( EVBUFFER_LENGTH(inbuf) >= n );
+        tr_peerIoReadBytes( msgs->io, inbuf, buf, n );
+        evbuffer_add( msgs->incoming.block, buf, n );
+        clientGotBytes( msgs, n );
+        tr_free( buf );
+        dbgmsg( msgs, "got %d bytes for block %u:%u->%u ... %d remain",
+               (int)n, req->index, req->offset, req->length,
+               (int)( req->length - EVBUFFER_LENGTH(msgs->incoming.block) ) );
+        if( EVBUFFER_LENGTH(msgs->incoming.block) < req->length )
+            return READ_MORE;
+
+        /* we've got the whole block ... process it */
+        err = clientGotBlock( msgs, EVBUFFER_DATA(msgs->incoming.block), req );
+
+        /* cleanup */
+        evbuffer_drain( msgs->incoming.block, EVBUFFER_LENGTH(msgs->incoming.block) );
+        req->length = 0;
+        msgs->state = AWAITING_BT_LENGTH;
+        if( !err )
+            return READ_AGAIN;
+        else {
+            fireGotAssertError( msgs );
+            return READ_DONE;
+        }
+    }
+}
+
+static int
+readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
+{
     uint32_t ui32;
-    uint32_t msglen = msgs->incomingMessageLength;
+    uint32_t msglen = msgs->incoming.length;
+    const uint8_t id = msgs->incoming.id;
     const size_t startBufLen = EVBUFFER_LENGTH( inbuf );
 
-    if( EVBUFFER_LENGTH(inbuf) < msglen )
+    --msglen; // id length
+
+    if( inlen < msglen )
         return READ_MORE;
 
-    tr_peerIoReadUint8( msgs->io, inbuf, &id );
-    dbgmsg( msgs, "got BT id %d, len %d, buffer size is %d", (int)id, (int)msglen, (int)EVBUFFER_LENGTH(inbuf) );
-
-    if( !messageLengthIsCorrect( msgs, id, msglen ) )
+    dbgmsg( msgs, "got BT id %d, len %d, buffer size is %d", (int)id, (int)msglen, (int)inlen );
+
+    if( !messageLengthIsCorrect( msgs, id, msglen+1 ) )
     {
         dbgmsg( msgs, "bad packet - BT message #%d with a length of %d", (int)id, (int)msglen );
@@ -977 +1118 @@
         return READ_DONE;
     }
-
-    --msglen;
 
     switch( id )
@@ -1005 +1144 @@
             msgs->info->peerIsInterested = 0;
             break;
-
+            
         case BT_HAVE:
             tr_peerIoReadUint32( msgs->io, inbuf, &ui32 );
             dbgmsg( msgs, "got Have: %u", ui32 );
             tr_bitfieldAdd( msgs->info->have, ui32 );
+            /* If this is a fast-allowed piece for this peer, mark it as normal now */
+            if( msgs->clientAllowedPieces != NULL && tr_bitfieldHas( msgs->clientAllowedPieces, ui32 ) )
+                tr_bitfieldRem( msgs->clientAllowedPieces, ui32 );
             updatePeerProgress( msgs );
             tr_rcTransferred( msgs->torrent->swarmspeed, msgs->torrent->info.pieceSize );
@@ -1017 +1159 @@
             const int clientIsSeed = tr_torrentIsSeed( msgs->torrent );
             dbgmsg( msgs, "got a bitfield" );
+            msgs->peerSentBitfield = 1;
             tr_peerIoReadBytes( msgs->io, inbuf, msgs->info->have->bits, msglen );
             updatePeerProgress( msgs );
@@ -1045 +1188 @@
         }
 
-        case BT_PIECE: {
-            uint8_t * block;
-            struct peer_request req;
-            tr_peerIoReadUint32( msgs->io, inbuf, &req.index );
-            tr_peerIoReadUint32( msgs->io, inbuf, &req.offset );
-            req.length = msglen - 8;
-            block = tr_new( uint8_t, req.length );
-            tr_peerIoReadBytes( msgs->io, inbuf, block, req.length );
-            dbgmsg( msgs, "got a Block %u:%u->%u", req.index, req.offset, req.length );
-            clientGotBlock( msgs, block, &req );
-            tr_free( block );
+        case BT_PIECE:
+            assert( 0 ); /* should be handled elsewhere! */
             break;
-        }
-
+        
         case BT_PORT:
             dbgmsg( msgs, "Got a BT_PORT" );
             tr_peerIoReadUint16( msgs->io, inbuf, &msgs->info->port );
             break;
-
-#if 0 
+            
         case BT_SUGGEST: {
-            /* FIXME(tiennou) */
-            uint32_t index;
-            tr_peerIoReadUint32( msgs->io, inbuf, &index );
+            dbgmsg( msgs, "Got a BT_SUGGEST" );
+            tr_peerIoReadUint32( msgs->io, inbuf, &ui32 );
+            const tr_bitfield * bt = tr_cpPieceBitfield( msgs->torrent->completion );
+            if( tr_bitfieldHas( bt, ui32 ) )
+                tr_bitfieldAdd( msgs->clientSuggestedPieces, ui32 );
             break;
         }
-
+            
         case BT_HAVE_ALL:
             dbgmsg( msgs, "Got a BT_HAVE_ALL" );
@@ -1077 +1211 @@
             updatePeerProgress( msgs );
             break;
-
+        
+        
         case BT_HAVE_NONE:
             dbgmsg( msgs, "Got a BT_HAVE_NONE" );
@@ -1083 +1218 @@
             updatePeerProgress( msgs );
             break;
-
+        
         case BT_REJECT: {
             struct peer_request req;
@@ -1100 +1235 @@
             break;
         }
-#endif
 
         case BT_LTEP:
@@ -1113 +1247 @@
     }
 
-
-dbgmsg( msgs, "startBufLen was %d, msglen was %d, current inbuf len is %d", (int)startBufLen, (int)(msglen+1), (int)EVBUFFER_LENGTH(inbuf) );
-
-    msgs->incomingMessageLength = -1;
+    assert( msglen + 1 == msgs->incoming.length );
+    assert( EVBUFFER_LENGTH(inbuf) == startBufLen - msglen );
+
     msgs->state = AWAITING_BT_LENGTH;
     return READ_AGAIN;
-}
-
-static void
-clientGotBytes( tr_peermsgs * msgs, uint32_t byteCount )
-{
-    tr_torrent * tor = msgs->torrent;
-    tor->activityDate = tr_date( );
-    tor->downloadedCur += byteCount;
-    msgs->info->pieceDataActivityDate = time( NULL );
-    tr_rcTransferred( msgs->info->rcToClient, byteCount );
-    tr_rcTransferred( tor->download, byteCount );
-    tr_rcTransferred( tor->handle->download, byteCount );
 }
 
@@ -1140 +1261 @@
     tor->uploadedCur += byteCount;
     msgs->info->pieceDataActivityDate = time( NULL );
+    msgs->info->credit -= byteCount;
     tr_rcTransferred( msgs->info->rcToPeer, byteCount );
     tr_rcTransferred( tor->upload, byteCount );
@@ -1145 +1267 @@
 }
 
-static int
-canDownload( const tr_peermsgs * msgs )
-{
-    tr_torrent * tor = msgs->torrent;
+static size_t
+getDownloadMax( const tr_peermsgs * msgs )
+{
+    static const size_t maxval = ~0;
+    const tr_torrent * tor = msgs->torrent;
 
     if( tor->downloadLimitMode == TR_SPEEDLIMIT_GLOBAL )
-        return !tor->handle->useDownloadLimit || tr_rcCanTransfer( tor->handle->download );
+        return tor->handle->useDownloadLimit
+            ? tr_rcBytesLeft( tor->handle->download ) : maxval;
 
     if( tor->downloadLimitMode == TR_SPEEDLIMIT_SINGLE )
-        return tr_rcCanTransfer( tor->download );
-
-    return TRUE;
+        return tr_rcBytesLeft( tor->download );
+
+    return maxval;
 }
 
@@ -1178 +1302 @@
 gotBadPiece( tr_peermsgs * msgs, uint32_t pieceIndex )
 {
-    const uint32_t byteCount = tr_torPieceCountBytes( msgs->torrent, (int)pieceIndex );
+    const uint32_t byteCount =
+        tr_torPieceCountBytes( msgs->torrent, (int)pieceIndex );
     reassignBytesToCorrupt( msgs, byteCount );
 }
@@ -1196 +1321 @@
 }
 
-static void
-clientGotBlock( tr_peermsgs * msgs, const uint8_t * data, const struct peer_request * req )
+static int
+clientGotBlock( tr_peermsgs                * msgs,
+                const uint8_t              * data,
+                const struct peer_request  * req )
 {
     int i;
@@ -1206 +1333 @@
     assert( msgs != NULL );
     assert( req != NULL );
-    assert( req->length > 0 );
-    assert( req->length == (uint32_t)tr_torBlockCountBytes( msgs->torrent, block ) );
+
+    if( req->length != (uint32_t)tr_torBlockCountBytes( msgs->torrent, block ) )
+    {
+        dbgmsg( msgs, "wrong block size -- expected %u, got %d",
+                tr_torBlockCountBytes( msgs->torrent, block ), req->length );
+        return TR_ERROR_ASSERT;
+    }
 
     /* save the block */
@@ -1220 +1352 @@
         clientGotUnwantedBlock( msgs, req );
         dbgmsg( msgs, "we didn't ask for this message..." );
-        return;
+        return 0;
     }
 
@@ -1239 +1371 @@
         dbgmsg( msgs, "we have this block already..." );
         clientGotUnwantedBlock( msgs, req );
-        return;
+        return 0;
     }
 
@@ -1247 +1379 @@
 
     msgs->info->peerSentPieceDataAt = time( NULL );
-    clientGotBytes( msgs, req->length );
     i = tr_ioWrite( tor, req->index, req->offset, req->length, data );
     if( i )
-        return;
+        return 0;
 
     tr_cpBlockAdd( tor->completion, block );
@@ -1267 +1398 @@
         {
             gotBadPiece( msgs, req->index );
-            return;
+            return 0;
         }
 
         fireClientHave( msgs, req->index );
     }
+
+    return 0;
 }
 
@@ -1280 +1413 @@
     tr_peermsgs * msgs = (tr_peermsgs *) vmsgs;
     struct evbuffer * inbuf = EVBUFFER_INPUT ( evin );
-
-    if( !canDownload( msgs ) )
-    {
-        msgs->notListening = 1;
-        tr_peerIoSetIOMode ( msgs->io, 0, EV_READ );
+    const size_t buflen = EVBUFFER_LENGTH( inbuf );
+    const size_t downloadMax = getDownloadMax( msgs );
+    const size_t n = MIN( buflen, downloadMax );
+
+    if( !n )
+    {
         ret = READ_DONE;
     }
     else switch( msgs->state )
     {
-        case AWAITING_BT_LENGTH:  ret = readBtLength  ( msgs, inbuf ); break;
-        case AWAITING_BT_MESSAGE: ret = readBtMessage ( msgs, inbuf ); break;
+        case AWAITING_BT_LENGTH:  ret = readBtLength ( msgs, inbuf, n ); break;
+        case AWAITING_BT_ID:      ret = readBtId     ( msgs, inbuf, n ); break;
+        case AWAITING_BT_MESSAGE: ret = readBtMessage( msgs, inbuf, n ); break;
+        case AWAITING_BT_PIECE:   ret = readBtPiece  ( msgs, inbuf, n ); break;
         default: assert( 0 );
     }
@@ -1308 +1444 @@
 **/
 
-static int
-canWrite( const tr_peermsgs * msgs )
-{
-    /* don't let our outbuffer get too large */
-    if( tr_peerIoWriteBytesWaiting( msgs->io ) > 4096 )
-        return FALSE;
-
-    return TRUE;
-}
-
 static size_t
 getUploadMax( const tr_peermsgs * msgs )
@@ -1323 +1449 @@
     static const size_t maxval = ~0;
     const tr_torrent * tor = msgs->torrent;
-
-    if( !canWrite( msgs ) )
-        return 0;
+    const int useSwift = SWIFT_ENABLED && !tr_torrentIsSeed( msgs->torrent );
+    const size_t swiftLeft = msgs->info->credit;
+    size_t speedLeft;
+    size_t bufLeft;
+    size_t ret;
 
     if( tor->uploadLimitMode == TR_SPEEDLIMIT_GLOBAL )
-        return tor->handle->useUploadLimit
-            ? tr_rcBytesLeft( tor->handle->upload ) : maxval;
-
-    if( tor->uploadLimitMode == TR_SPEEDLIMIT_SINGLE )
-        return tr_rcBytesLeft( tor->upload );
-
-    return maxval;
+        speedLeft = tor->handle->useUploadLimit ? tr_rcBytesLeft( tor->handle->upload ) : maxval;
+    else if( tor->uploadLimitMode == TR_SPEEDLIMIT_SINGLE )
+        speedLeft = tr_rcBytesLeft( tor->upload );
+    else
+        speedLeft = ~0;
+
+    bufLeft = 4096 - tr_peerIoWriteBytesWaiting( msgs->io );
+    ret = MIN( speedLeft, bufLeft );
+    if( useSwift)
+        ret = MIN( ret, swiftLeft );
+    return ret;
 }
 
@@ -1358 +1490 @@
 }
 
+static void
+updatePeerStatus( tr_peermsgs * msgs )
+{
+    tr_peer * peer = msgs->info;
+
+    if( !msgs->peerSentBitfield )
+        peer->status = TR_PEER_STATUS_HANDSHAKE;
+
+    else if( ( time(NULL) - peer->pieceDataActivityDate ) < 3 )
+        peer->status = peer->clientIsChoked
+                       ? TR_PEER_STATUS_ACTIVE_AND_CHOKED
+                       : TR_PEER_STATUS_ACTIVE;
+
+    else if( peer->peerIsChoked )
+        peer->status = TR_PEER_STATUS_PEER_IS_CHOKED;
+
+    else if( peer->clientIsChoked )
+        peer->status = peer->clientIsInterested 
+                       ? TR_PEER_STATUS_CLIENT_IS_INTERESTED
+                       : TR_PEER_STATUS_CLIENT_IS_CHOKED;
+
+    else if( msgs->clientAskedFor != NULL )
+        peer->status = TR_PEER_STATUS_REQUEST_SENT;
+
+    else
+        peer->status = TR_PEER_STATUS_READY;
+}
+
 static int
 pulse( void * vmsgs )
@@ -1364 +1524 @@
     tr_peermsgs * msgs = vmsgs;
     struct peer_request * r;
-    size_t len;
-
-    /* if we froze out a downloaded block because of speed limits,
-       start listening to the peer again */
-    if( msgs->notListening && canDownload( msgs ) )
-    {
-        msgs->notListening = 0;
-        tr_peerIoSetIOMode ( msgs->io, EV_READ, 0 );
-    }
-
+
+    tr_peerIoTryRead( msgs->io );
     pumpRequestQueue( msgs );
-
-    if( !canWrite( msgs ) )
-    {
-    }
-    else if(( len = EVBUFFER_LENGTH( msgs->outBlock ) ))
+    updatePeerStatus( msgs );
+
+    if( msgs->sendingBlock )
     {
         const size_t uploadMax = getUploadMax( msgs );
+        size_t len = EVBUFFER_LENGTH( msgs->outBlock );
         const size_t outlen = MIN( len, uploadMax );
-        tr_peerIoWrite( msgs->io, EVBUFFER_DATA( msgs->outBlock ), outlen );
-        evbuffer_drain( msgs->outBlock, outlen );
-        msgs->clientSentAnythingAt = now;
-        peerGotBytes( msgs, outlen );
-        len -= outlen;
-        dbgmsg( msgs, "wrote %d bytes; %d left in block", (int)outlen, (int)len );
-        fflush( stdout );
-    }
-    else if(( len = EVBUFFER_LENGTH( msgs->outMessages ) ))
-    {
-        tr_peerIoWriteBuf( msgs->io, msgs->outMessages );
-        msgs->clientSentAnythingAt = now;
-    }
-    else if( ( now - msgs->clientSentAnythingAt ) > KEEPALIVE_INTERVAL_SECS )
-    {
-        sendKeepalive( msgs );
-    }
-
-    if( !EVBUFFER_LENGTH( msgs->outBlock )
-        && (( r = popNextRequest( msgs )))
-        && requestIsValid( msgs, r )
-        && tr_cpPieceIsComplete( msgs->torrent->completion, r->index ) )
-    {
-        uint8_t * buf = tr_new( uint8_t, r->length );
-
-        if( !tr_ioRead( msgs->torrent, r->index, r->offset, r->length, buf ) )
+
+        assert( len );
+
+        if( outlen )
         {
-            tr_peerIo * io = msgs->io;
-            struct evbuffer * out = msgs->outBlock;
-
-            dbgmsg( msgs, "sending block %u:%u->%u", r->index, r->offset, r->length );
-            tr_peerIoWriteUint32( io, out, sizeof(uint8_t) + 2*sizeof(uint32_t) + r->length );
-            tr_peerIoWriteUint8 ( io, out, BT_PIECE );
-            tr_peerIoWriteUint32( io, out, r->index );
-            tr_peerIoWriteUint32( io, out, r->offset );
-            tr_peerIoWriteBytes ( io, out, buf, r->length );
+            tr_peerIoWrite( msgs->io, EVBUFFER_DATA( msgs->outBlock ), outlen );
+            evbuffer_drain( msgs->outBlock, outlen );
+            peerGotBytes( msgs, outlen );
+
+            len -= outlen;
+            msgs->clientSentAnythingAt = now;
+            msgs->sendingBlock = len!=0;
+
+            dbgmsg( msgs, "wrote %d bytes; %d left in block", (int)outlen, (int)len );
         }
-
-        tr_free( buf );
-        tr_free( r );
-
-        pulse( msgs ); /* start sending it right away */
+        else dbgmsg( msgs, "stalled writing block... uploadMax %lu, outlen %lu", uploadMax, outlen );
+    }
+
+    if( !msgs->sendingBlock )
+    {
+        if(( EVBUFFER_LENGTH( msgs->outMessages ) ))
+        {
+            dbgmsg( msgs, "flushing outMessages..." );
+            tr_peerIoWriteBuf( msgs->io, msgs->outMessages );
+            msgs->clientSentAnythingAt = now;
+        }
+        else if( !EVBUFFER_LENGTH( msgs->outBlock )
+            && (( r = popNextRequest( msgs )))
+            && requestIsValid( msgs, r )
+            && tr_cpPieceIsComplete( msgs->torrent->completion, r->index ) )
+        {
+            uint8_t * buf = tr_new( uint8_t, r->length );
+
+            if( !tr_ioRead( msgs->torrent, r->index, r->offset, r->length, buf ) )
+            {
+                tr_peerIo * io = msgs->io;
+                struct evbuffer * out = msgs->outBlock;
+
+                dbgmsg( msgs, "sending block %u:%u->%u", r->index, r->offset, r->length );
+                tr_peerIoWriteUint32( io, out, sizeof(uint8_t) + 2*sizeof(uint32_t) + r->length );
+                tr_peerIoWriteUint8 ( io, out, BT_PIECE );
+                tr_peerIoWriteUint32( io, out, r->index );
+                tr_peerIoWriteUint32( io, out, r->offset );
+                tr_peerIoWriteBytes ( io, out, buf, r->length );
+                msgs->sendingBlock = 1;
+            }
+
+            tr_free( buf );
+            tr_free( r );
+        }
+        else if( ( now - msgs->clientSentAnythingAt ) > KEEPALIVE_INTERVAL_SECS )
+        {
+            sendKeepalive( msgs );
+        }
     }
 
@@ -1431 +1594 @@
 
 static void
-didWrite( struct bufferevent * evin UNUSED, void * vmsgs )
-{
-    pulse( vmsgs );
-}
-
-static void
 gotError( struct bufferevent * evbuf UNUSED, short what, void * vmsgs )
 {
-    dbgmsg( vmsgs, "libevent got an error! what=%d, errno=%d (%s)",
-            (int)what, errno, strerror(errno) );
-    fireGotError( vmsgs );
+    if( what & EVBUFFER_TIMEOUT )
+        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)",
+                what, errno, strerror(errno) );
+        fireGotError( vmsgs );
+    }
 }
 
@@ -1579 +1741 @@
 
         /* write the pex message */
-        benc = tr_bencSaveMalloc( &val, &bencLen );
+        benc = tr_bencSave( &val, &bencLen );
         tr_peerIoWriteUint32( msgs->io, msgs->outMessages, 2*sizeof(uint8_t) + bencLen );
         tr_peerIoWriteUint8 ( msgs->io, msgs->outMessages, BT_LTEP );
@@ -1625 +1787 @@
     m->torrent = torrent;
     m->io = info->io;
+    m->info->status = TR_PEER_STATUS_HANDSHAKE;
     m->info->clientIsChoked = 1;
     m->info->peerIsChoked = 1;
@@ -1630 +1793 @@
     m->info->peerIsInterested = 0;
     m->info->have = tr_bitfieldNew( torrent->info.pieceCount );
+    m->state = AWAITING_BT_LENGTH;
     m->pulseTimer = tr_timerNew( m->handle, pulse, m, PEER_PULSE_INTERVAL );
     m->rateTimer = tr_timerNew( m->handle, ratePulse, m, RATE_PULSE_INTERVAL );
     m->pexTimer = tr_timerNew( m->handle, pexPulse, m, PEX_INTERVAL );
     m->outMessages = evbuffer_new( );
+    m->incoming.block = evbuffer_new( );
     m->outBlock = evbuffer_new( );
     m->peerAllowedPieces = NULL;
     m->clientAllowedPieces = NULL;
+    m->clientSuggestedPieces = NULL;
     *setme = tr_publisherSubscribe( m->publisher, func, userData );
     
@@ -1646 +1812 @@
             const struct in_addr *peerAddr = tr_peerIoGetAddress( m->io, NULL );
             
-            m->peerAllowedPieces = tr_peerMgrGenerateAllowedSet( MAX_ALLOWED_SET_COUNT,
+            m->peerAllowedPieces = tr_peerMgrGenerateAllowedSet( MAX_FAST_ALLOWED_COUNT,
                                                                  m->torrent->info.pieceCount,
                                                                  m->torrent->info.hash,
@@ -1652 +1818 @@
         }
         m->clientAllowedPieces = tr_bitfieldNew( m->torrent->info.pieceCount );
+        
+        m->clientSuggestedPieces = tr_bitfieldNew( m->torrent->info.pieceCount );
     }
     
     tr_peerIoSetTimeoutSecs( m->io, 150 ); /* timeout after N seconds of inactivity */
-    tr_peerIoSetIOFuncs( m->io, canRead, didWrite, gotError, m );
-    tr_peerIoSetIOMode( m->io, EV_READ|EV_WRITE, 0 );
+    tr_peerIoSetIOFuncs( m->io, canRead, gotError, m );
     ratePulse( m );
 
@@ -1677 +1844 @@
         peerProgress = m->torrent->info.pieceCount * m->info->progress;
         
-        if ( peerProgress < MAX_ALLOWED_SET_COUNT )
+        if ( peerProgress < MAX_FAST_ALLOWED_COUNT )
             sendFastAllowedSet( m );
     }
@@ -1697 +1864 @@
         tr_list_free( &msgs->peerAskedForFast, tr_free );
         tr_list_free( &msgs->peerAskedFor, tr_free );
+        tr_bitfieldFree( msgs->peerAllowedPieces );
+        tr_bitfieldFree( msgs->clientAllowedPieces );
+        tr_bitfieldFree( msgs->clientSuggestedPieces );
+        evbuffer_free( msgs->incoming.block );
         evbuffer_free( msgs->outMessages );
         evbuffer_free( msgs->outBlock );
         tr_free( msgs->pex );
-        msgs->pexCount = 0;
+
+        memset( msgs, ~0, sizeof( tr_peermsgs ) );
         tr_free( msgs );
     }
@@ -1721 +1893 @@
 
 int
-tr_peerMsgIsPieceFastAllowed( const tr_peermsgs * peer,
-                              uint32_t            index )
+tr_peerMsgsIsPieceFastAllowed( const tr_peermsgs * peer,
+                               uint32_t            index )
 {
     return tr_bitfieldHas( peer->clientAllowedPieces, index );
 }
+
+int
+tr_peerMsgsIsPieceSuggested( const tr_peermsgs * peer,
+                             uint32_t            index )
+{
+    return tr_bitfieldHas( peer->clientSuggestedPieces, index );
+}
+

branches/0.9x/libtransmission/peer-msgs.h

@@ -66 +66 @@
     TR_PEERMSG_PEER_PROGRESS,
     TR_PEERMSG_GOT_ERROR,
+    TR_PEERMSG_GOT_ASSERT_ERROR,
     TR_PEERMSG_CANCEL,
     TR_PEERMSG_NEED_REQ
@@ -88 +89 @@
                                            tr_publisher_tag    tag );
 
-int               tr_peerMsgIsPieceFastAllowed( const tr_peermsgs * peer,
-                                                uint32_t            index );
+int               tr_peerMsgsIsPieceFastAllowed( const tr_peermsgs * peer,
+                                                 uint32_t            index );
+
+int               tr_peerMsgsIsPieceSuggested( const tr_peermsgs * peer,
+                                              uint32_t            index );
 
 #endif

branches/0.9x/libtransmission/platform.c

@@ -232 +232 @@
 }
 
-int
-tr_lockTryLock( tr_lock * l ) /* success on zero! */
-{
-#ifdef __BEOS__
-    return acquire_sem_etc( l->lock, 1, B_RELATIVE_TIMEOUT, 0 );
-#elif defined(WIN32)
-    return !TryEnterCriticalSection( &l->lock );
-#else
-    return pthread_mutex_trylock( &l->lock );
-#endif
-}
-
 void
 tr_lockLock( tr_lock * l )
 {
-    tr_thread_id currentThread = tr_getCurrentThread( );
+    const tr_thread_id currentThread = tr_getCurrentThread( );
+
     if( l->lockThread == currentThread )
     {
@@ -261 +250 @@
         pthread_mutex_lock( &l->lock );
 #endif
-        l->lockThread = tr_getCurrentThread( );
+        l->lockThread = currentThread;
         l->depth = 1;
     }

branches/0.9x/libtransmission/platform.h

@@ -39 +39 @@
 tr_lock *    tr_lockNew        ( void );
 void         tr_lockFree       ( tr_lock * );
-int          tr_lockTryLock    ( tr_lock * );
 void         tr_lockLock       ( tr_lock * );
 void         tr_lockUnlock     ( tr_lock * );

branches/0.9x/libtransmission/torrent.c

@@ -881 +881 @@
 
 void
-tr_torrentPeersFree( tr_peer_stat * peers, int peerCount )
-{
-    int i;
-    for( i=0; i<peerCount; ++i )
-        tr_free( (char*) peers[i].client );
+tr_torrentPeersFree( tr_peer_stat * peers, int peerCount UNUSED )
+{
     tr_free( peers );
 }
@@ -1006 +1003 @@
 
 static void
-checkAndStartCB( tr_torrent * tor )
-{
+checkAndStartImpl( void * vtor )
+{
+    tr_torrent * tor = vtor;
+
     tr_globalLock( tor->handle );
 
@@ -1021 +1020 @@
     tr_globalUnlock( tor->handle );
 }
-    
+
+static void
+checkAndStartCB( tr_torrent * tor )
+{
+    tr_runInEventThread( tor->handle, checkAndStartImpl, tor );
+}
+
 void
 tr_torrentStart( tr_torrent * tor )
@@ -1039 +1044 @@
 }
 
+static void
+torrentRecheckDoneImpl( void * vtor )
+{
+    tr_torrentRecheckCompleteness( vtor );
+}
+static void
+torrentRecheckDoneCB( tr_torrent * tor )
+{
+    tr_runInEventThread( tor->handle, torrentRecheckDoneImpl, tor );
+}
 void
 tr_torrentRecheck( tr_torrent * tor )
@@ -1048 +1063 @@
     tr_bitfieldAddRange( tor->uncheckedPieces, 0, tor->info.pieceCount );
 
-    tr_ioRecheckAdd( tor, tr_torrentRecheckCompleteness );
+    tr_ioRecheckAdd( tor, torrentRecheckDoneCB );
 
     tr_globalUnlock( tor->handle );
@@ -1090 +1105 @@
     tr_globalLock( tor->handle );
 
+    tr_torrentClearStatusCallback( tor );
     tr_runInEventThread( tor->handle, closeTorrent, tor );
 

branches/0.9x/libtransmission/transmission.c

@@ -91 +91 @@
 {
     assert( handle != NULL );
-    assert( mode==TR_ENCRYPTION_PREFERRED || mode==TR_ENCRYPTION_REQUIRED );
+    assert( mode==TR_ENCRYPTION_PREFERRED
+         || mode==TR_ENCRYPTION_REQUIRED
+         || mode==TR_PLAINTEXT_PREFERRED );
 
     handle->encryptionMode = mode;
@@ -109 +111 @@
 {
     tr_handle * h;
-    int         i;
 
 #ifndef WIN32
@@ -139 +140 @@
 
     h->peerMgr = tr_peerMgrNew( h );
-
-    /* Azureus identity */
-    for( i=0; i < TR_AZ_ID_LEN; ++i )
-        h->azId[i] = tr_rand( 0xff );
 
     /* Initialize rate and file descripts controls */
@@ -299 +296 @@
 {
     tr_handle * h = vh;
+    tr_torrent * t;
+
+    for( t=h->torrentList; t!=NULL; t=t->next )
+        tr_torrentClose( t );
+
     tr_peerMgrFree( h->peerMgr );
 
     tr_rcClose( h->upload );
     tr_rcClose( h->download );
+    
+    tr_natTraversalEnable( h, 0 );
+    while( tr_handleStatus( h )->natTraversalStatus != TR_NAT_TRAVERSAL_DISABLED )
+        tr_wait( 100 );
 
     tr_sharedClose( h->shared );
@@ -333 +339 @@
     free( h->tag );
     free( h );
+}
+
+void
+tr_getSessionStats( const tr_handle   * handle,
+                    tr_session_stats  * setme )
+{
+    assert( handle != NULL );
+    assert( setme != NULL );
+
+    /* FIXME */
+    setme->downloadedGigs   = 4;
+    setme->downloadedBytes  = 8;
+    setme->uploadedGigs     = 15;
+    setme->uploadedBytes    = 16;
+    setme->ratio            = 23;
+    setme->filesAdded       = 42;
+    setme->sessionCount     = 666;
+    setme->secondsActive    = 2112;
+}
+
+void
+tr_getCumulativeSessionStats( const tr_handle   * handle,
+                              tr_session_stats  * setme )
+{
+    tr_getSessionStats( handle, setme );
 }
 

branches/0.9x/libtransmission/transmission.h

@@ -97 +97 @@
  * tr_init
  ***********************************************************************
- * Initializes a libtransmission instance. Returns a obscure handle to
- * be passed to all functions below. The tag argument is a short string
+ * Initializes a libtransmission instance and returns an opaque handle
+ * to be passed to functions below. The tag argument is a short string
  * unique to the program invoking tr_init(), it is currently used as
  * part of saved torrent files' names to prevent one frontend from
@@ -109 +109 @@
 tr_handle * tr_init( const char * tag );
 
-typedef struct tr_tracker_info tr_tracker_info;
+/* shut down a libtransmission instance created by tr_init(). */
+void tr_close( tr_handle * );
+
 
 /**
@@ -115 +117 @@
 **/
 
+typedef struct tr_session_stats
+{
+    uint64_t downloadedGigs;  /* total down / GiB */
+    uint64_t downloadedBytes; /* total down % GiB */
+    uint64_t uploadedGigs;    /* total up / GiB */
+    uint64_t uploadedBytes;   /* total up % GiB */
+    double ratio;             /* total up / total down */
+    uint64_t filesAdded;      /* number of files added */
+    uint64_t sessionCount;    /* program started N times */
+    uint64_t secondsActive;   /* how long Transmisson's been running */
+}
+tr_session_stats;
+
+/* stats from the current and past sessions. */
+void tr_getCumulativeSessionStats( const tr_handle   * handle,
+                                   tr_session_stats  * setme );
+
+/* stats from the current session. */
+void tr_getSessionStats( const tr_handle   * handle,
+                         tr_session_stats  * setme );
+
+
+/**
+***
+**/
+
 typedef enum
 {
+    TR_PLAINTEXT_PREFERRED,
     TR_ENCRYPTION_PREFERRED,
     TR_ENCRYPTION_REQUIRED
@@ -291 +320 @@
  **********************************************************************/
 void tr_torrentRates( tr_handle *, float *, float * );
-
-/***********************************************************************
- * tr_close
- ***********************************************************************
- * Frees memory allocated by tr_init.
- **********************************************************************/
-void tr_close( tr_handle * );
 
 
@@ -411 +433 @@
 const tr_info * tr_torrentInfo( const tr_torrent * );
 
-#if 0
-/***********************************************************************
- * tr_torrentScrape
- ***********************************************************************
- * Asks the tracker for the count of seeders and leechers. Returns 0
- * and fills 's' and 'l' if successful. Otherwise returns 1 if the
- * tracker doesn't support the scrape protocol, is unreachable or
- * replied with some error. tr_torrentScrape may block up to 20 seconds
- * before returning.
- **********************************************************************/
-int tr_torrentScrape( tr_torrent *, int * s, int * l, int * d );
-#endif
-
 void   tr_torrentSetFolder( tr_torrent *, const char * );
 const char * tr_torrentGetFolder( const tr_torrent * );
@@ -567 +576 @@
 tr_piece;
     
+typedef struct tr_tracker_info
+{
+    char * address;
+    int    port;
+    char * announce;
+    char * scrape;
+}
+tr_tracker_info;
+
 struct tr_info
 {
@@ -696 +714 @@
 };
 
+typedef enum
+{
+    TR_PEER_STATUS_HANDSHAKE,
+    TR_PEER_STATUS_PEER_IS_CHOKED,
+    TR_PEER_STATUS_CLIENT_IS_CHOKED,
+    TR_PEER_STATUS_CLIENT_IS_INTERESTED,
+    TR_PEER_STATUS_READY,
+    TR_PEER_STATUS_ACTIVE_AND_CHOKED,
+    TR_PEER_STATUS_REQUEST_SENT,
+    TR_PEER_STATUS_ACTIVE
+}
+tr_peer_status;
+
 struct tr_peer_stat
 {
-    char    addr[INET_ADDRSTRLEN];
-    const char * client;
+    char addr[INET_ADDRSTRLEN];
+    char client[80];
     
     unsigned int isEncrypted   : 1;
     unsigned int isDownloading : 1;
     unsigned int isUploading   : 1;
+
+    tr_peer_status status;
 
     uint8_t  from;
@@ -719 +752 @@
     char               * message;
     struct tr_msg_list * next;
-};
-
-struct tr_tracker_info
-{
-    char * address;
-    int    port;
-    char * announce;
-    char * scrape;
 };
 

branches/0.9x/libtransmission/trevent.c

@@ -65 +65 @@
 {
     TR_EV_EVHTTP_MAKE_REQUEST,
-    TR_EV_BUFFEREVENT_SET,
-    TR_EV_BUFFEREVENT_WRITE,
     TR_EV_TIMER_ADD,
-    TR_EV_TIMER_DEL,
     TR_EV_EXEC
 };
@@ -134 +131 @@
                 break;
 
-            case TR_EV_TIMER_DEL:
-                event_del( &cmd->timer->event );
-                tr_free( cmd->timer );
-                --eh->timerCount;
-                break;
-
             case TR_EV_EVHTTP_MAKE_REQUEST:
                 evhttp_make_request( cmd->evcon, cmd->req, cmd->evtype, cmd->uri );
                 tr_free( cmd->uri );
-                break;
-
-           case TR_EV_BUFFEREVENT_SET:
-                bufferevent_enable( cmd->bufev, cmd->enable );
-                bufferevent_disable( cmd->bufev, cmd->disable );
-                break;
-
-            case TR_EV_BUFFEREVENT_WRITE:
-                bufferevent_write( cmd->bufev, cmd->buf, cmd->buflen );
-                tr_free( cmd->buf );
                 break;
 
@@ -255 +236 @@
     tr_lockUnlock( eh->lock );
 }
+
+int
+tr_amInEventThread( struct tr_handle * handle )
+{
+    return tr_amInThread( handle->events->thread );
+}
+
 
 void
@@ -277 +265 @@
 }
 
-void
-tr_bufferevent_write( tr_handle             * handle,
-                      struct bufferevent    * bufev,
-                      const void            * buf,
-                      size_t                  buflen )
-{
-    if( tr_amInThread( handle->events->thread ) )
-        bufferevent_write( bufev, (void*)buf, buflen );
-    else {
-        struct tr_event_command * cmd = tr_new0( struct tr_event_command, 1 );
-        cmd->mode = TR_EV_BUFFEREVENT_WRITE;
-        cmd->bufev = bufev;
-        cmd->buf = tr_strndup( buf, buflen );
-        cmd->buflen = buflen;
-        pushList( handle->events, cmd );
-    }
-}
-
-void
-tr_setBufferEventMode( struct tr_handle   * handle,
-                       struct bufferevent * bufev,
-                       short                mode_enable,
-                       short                mode_disable )
-{
-    if( tr_amInThread( handle->events->thread ) ) {
-        bufferevent_enable( bufev, mode_enable );
-        bufferevent_disable( bufev, mode_disable );
-    } else {
-        struct tr_event_command * cmd = tr_new0( struct tr_event_command, 1 );
-        cmd->mode = TR_EV_BUFFEREVENT_SET;
-        cmd->bufev = bufev;
-        cmd->enable = mode_enable;
-        cmd->disable = mode_disable;
-        pushList( handle->events, cmd );
-    }
-}
-
 /**
 ***
@@ -363 +314 @@
     /* destroy the timer directly or via the command queue */
     if( timer!=NULL && !timer->inCallback ) {
-        if( tr_amInThread( timer->eh->thread ) ) {
-            void * del = tr_list_remove( &timer->eh->commands, timer, timerCompareFunc );
-            --timer->eh->timerCount;
-            event_del( &timer->event );
-            tr_free( timer );
-            tr_free( del );
-        } else {
-            struct tr_event_command * cmd = tr_new0( struct tr_event_command, 1 );
-            cmd->mode = TR_EV_TIMER_DEL;
-            cmd->timer = timer;
-            pushList( timer->eh, cmd );
-        }
+        void * del;
+        assert( tr_amInEventThread( timer->eh->h ) );
+        del = tr_list_remove( &timer->eh->commands, timer, timerCompareFunc );
+        --timer->eh->timerCount;
+        event_del( &timer->event );
+        tr_free( timer );
+        tr_free( del );
     }
 }

branches/0.9x/libtransmission/trevent.h

@@ -38 +38 @@
                              char                      * uri);
 
-void tr_bufferevent_write( struct tr_handle    * tr_handle,
-                           struct bufferevent  * bufferEvent,
-                           const void          * buf,
-                           size_t                buflen );
-
-
-void tr_setBufferEventMode( struct tr_handle   * tr_handle,
-                            struct bufferevent * bufferEvent,
-                            short                mode_enable,
-                            short                mode_disable );
-
 /**
 ***
@@ -70 +59 @@
 void tr_timerFree( tr_timer ** timer );
 
+
+int tr_amInEventThread( struct tr_handle * handle );
+
 void tr_runInEventThread( struct tr_handle * handle,
                           void               func( void* ),

branches/0.9x/libtransmission/utils.c

@@ -893 +893 @@
 #endif
 }
+
+/***
+****
+***/
+
+
+#ifndef HAVE_STRLCPY
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t
+strlcpy(char *dst, const char *src, size_t siz)
+{
+        char *d = dst;
+        const char *s = src;
+        size_t n = siz;
+
+        /* Copy as many bytes as will fit */
+        if (n != 0) {
+                while (--n != 0) {
+                        if ((*d++ = *s++) == '\0')
+                                break;
+                }
+        }
+
+        /* Not enough room in dst, add NUL and traverse rest of src */
+        if (n == 0) {
+                if (siz != 0)
+                        *d = '\0';              /* NUL-terminate dst */
+                while (*s++)
+                        ;
+        }
+
+        return(s - src - 1);    /* count does not include NUL */
+}
+
+#endif /* HAVE_STRLCPY */
+
+
+#ifndef HAVE_STRLCAT
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+size_t
+strlcat(char *dst, const char *src, size_t siz)
+{
+        char *d = dst;
+        const char *s = src;
+        size_t n = siz;
+        size_t dlen;
+
+        /* Find the end of dst and adjust bytes left but don't go past end */
+        while (n-- != 0 && *d != '\0')
+                d++;
+        dlen = d - dst;
+        n = siz - dlen;
+
+        if (n == 0)
+                return(dlen + strlen(s));
+        while (*s != '\0') {
+                if (n != 1) {
+                        *d++ = *s;
+                        n--;
+                }
+                s++;
+        }
+        *d = '\0';
+
+        return(dlen + (s - src));       /* count does not include NUL */
+}
+
+#endif /* HAVE_STRLCAT */

@@ -1 @@
-third-party/libevent  -r474 http://levent.svn.sourceforge.net/svnroot/levent/trunk/libevent
+third-party/libevent http://levent.svn.sourceforge.net/svnroot/levent/branches/patches-1.4