Changeset 11548

Timestamp:

Dec 20, 2010, 2:07:51 AM (12 years ago)

Author:

charles

Message:

(trunk) #3836 "libevent2 support" -- bump libevent2 requirement to 2.0.10. This will break the Mac build for a minute intil BMW applies his Mac patch

Location:

trunk

Files:

• configure.ac (modified) (4 diffs)
• gtk/tr-core.c (modified) (4 diffs)
• libtransmission/announcer.c (modified) (5 diffs)
• libtransmission/bencode-test.c (modified) (2 diffs)
• libtransmission/bencode.c (modified) (6 diffs)
• libtransmission/handshake.c (modified) (30 diffs)
• libtransmission/metainfo.c (modified) (3 diffs)
• libtransmission/peer-io.c (modified) (27 diffs)
• libtransmission/peer-io.h (modified) (4 diffs)
• libtransmission/peer-msgs.c (modified) (41 diffs)
• libtransmission/rpc-server.c (modified) (13 diffs)
• libtransmission/rpcimpl.c (modified) (4 diffs)
• libtransmission/rpcimpl.h (modified) (1 diff)
• libtransmission/torrent-magnet.c (modified) (3 diffs)
• libtransmission/tr-dht.c (modified) (5 diffs)
• libtransmission/tr-lpd.c (modified) (4 diffs)
• libtransmission/trevent.c (modified) (1 diff)
• libtransmission/utils.c (modified) (5 diffs)
• libtransmission/utils.h (modified) (2 diffs)
• libtransmission/web.c (modified) (3 diffs)
• libtransmission/webseed.c (modified) (6 diffs)
• utils/edit.c (modified) (2 diffs)
• utils/show.c (modified) (2 diffs)

trunk/configure.ac

@@ -41 +41 @@
 CURL_MINIMUM=7.15.4
 AC_SUBST(CURL_MINIMUM)
-LIBEVENT_MINIMUM=1.4.9
+LIBEVENT_MINIMUM=2.0.10
 AC_SUBST(LIBEVENT_MINIUM)
 OPENSSL_MINIMUM=0.9.4
@@ -86 +86 @@
 if test "x$GCC" = "xyes" ; then
 
-    CFLAGS="$CFLAGS -std=gnu99 -ggdb3 -Wall -W -Wpointer-arith -Wformat-security -Wcast-align -Wundef -Wcast-align -Wstrict-prototypes -Wmissing-declarations -Wmissing-format-attribute -Wredundant-decls -Wnested-externs -Wunused-parameter -Wwrite-strings -Waggregate-return -Winline -Wfloat-equal"
+    CFLAGS="$CFLAGS -std=gnu99 -ggdb3 -Wall -W -Wpointer-arith -Wformat-security -Wcast-align -Wundef -Wcast-align -Wstrict-prototypes -Wmissing-declarations -Wmissing-format-attribute -Wredundant-decls -Wnested-externs -Wunused-parameter -Wwrite-strings -Winline -Wfloat-equal"
 
     dnl figure out gcc version
@@ -123 +123 @@
 PKG_CHECK_MODULES(OPENSSL, [openssl >= $OPENSSL_MINIMUM], , [CHECK_SSL()])
 PKG_CHECK_MODULES(LIBCURL, [libcurl >= $CURL_MINIMUM])
+PKG_CHECK_MODULES(LIBEVENT, [libevent >= $LIBEVENT_MINIMUM])
 AC_PATH_ZLIB
 
@@ -204 +205 @@
 
 
-dnl libevent
-dnl if the user specified LIBEVENT_LIBS or
-if test -n "$LIBEVENT_LIBS"; then
-    user_specified_libevent=yes
-elif test -n "$LIBEVENT_CFLAGS"; then
-    user_specified_libevent=yes
-fi
-if test "x$user_specified_libevent" = "xyes"; then
-    AC_MSG_NOTICE([Using user-specified LIBEVENT_LIBS and LIBEVENT_CFLAGS])
-else
-    AC_CHECK_LIB([event],[evutil_vsnprintf],
-                 [],
-                 [AC_MSG_ERROR(libevent $LIBEVENT_MINIMUM or higher not found!)],
-                 [$libevent_extra_libs])
-    AC_CHECK_HEADER([event-config.h],[],
-                    [AC_MSG_ERROR(event-config.h not found!)])
-    LIBEVENT_CFLAGS=""
-    LIBEVENT_LIBS="-levent $libevent_extra_libs"
-fi
-AC_ARG_VAR([LIBEVENT_CFLAGS], [C compiler flags for LIBEVENT, overriding pkg-config])dnl
-AC_ARG_VAR([LIBEVENT_LIBS], [linker flags for LIBEVENT, overriding pkg-config])dnl
-
-
-
 dnl ----------------------------------------------------------------------------
 dnl

trunk/gtk/tr-core.c

@@ -34 +34 @@
 #endif
 
+#include <event2/buffer.h>
+
 #include <libtransmission/transmission.h>
 #include <libtransmission/bencode.h>
@@ -1598 +1600 @@
     tr_benc top;
     int64_t intVal;
-    GByteArray * response = vresponse;
-
-    tr_jsonParse( NULL, response->data, response->len, &top, NULL );
+    struct evbuffer * response = vresponse;
+
+    tr_jsonParse( NULL, evbuffer_pullup( response, -1 ), evbuffer_get_length( response ), &top, NULL );
 
     if( tr_bencDictFindInt( &top, "tag", &intVal ) )
@@ -1614 +1616 @@
 
     tr_bencFree( &top );
-    g_byte_array_free( response, TRUE );
+    evbuffer_free( response );
     return FALSE;
 }
@@ -1620 +1622 @@
 static void
 readResponse( tr_session  * session UNUSED,
-              const char  * response,
-              size_t        response_len,
+              struct evbuffer * response,
               void        * unused UNUSED )
 {
-    GByteArray * bytes = g_byte_array_new( );
-#ifdef DEBUG_RPC
-    g_message( "response: [%*.*s]", (int)response_len, (int)response_len, response );
-#endif
-    g_byte_array_append( bytes, (const uint8_t*)response, response_len );
-    gtr_idle_add( readResponseIdle, bytes );
+    struct evbuffer * buf = evbuffer_new( );
+    evbuffer_add_buffer( buf, response );
+    gtr_idle_add( readResponseIdle, buf );
 }
 

trunk/libtransmission/announcer.c

@@ -14 +14 @@
 #include <limits.h>
 
-#include <event.h>
-#include <evhttp.h> /* for HTTP_OK */
+#include <event2/buffer.h>
+#include <event2/event.h>
+#include <event2/http.h> /* for HTTP_OK */
 
 #include "transmission.h"
@@ -264 +265 @@
     a->slotsAvailable = MAX_CONCURRENT_TASKS;
     a->lpdHouseKeepingAt = relaxUntil;
-    a->upkeepTimer = tr_new0( struct event, 1 );
-    evtimer_set( a->upkeepTimer, onUpkeepTimer, a );
+    a->upkeepTimer = evtimer_new( NULL, onUpkeepTimer, a );
     tr_timerAdd( a->upkeepTimer, UPKEEP_INTERVAL_SECS, 0 );
 
@@ -280 +280 @@
     flushCloseMessages( announcer );
 
-    evtimer_del( announcer->upkeepTimer );
-    tr_free( announcer->upkeepTimer );
+    event_free( announcer->upkeepTimer );
     announcer->upkeepTimer = NULL;
 
@@ -725 +724 @@
     const char * ann = tracker->announce;
     struct evbuffer * buf = evbuffer_new( );
-    char * ret;
     const char * str;
     const unsigned char * ipv6;
@@ -785 +783 @@
     }
 
-    ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
-    dbgmsg( tier, "announce URL is \"%s\"", ret );
-    evbuffer_free( buf );
-    return ret;
+    return evbuffer_free_to_str( buf );
 }
 

trunk/libtransmission/bencode-test.c

@@ -4 +4 @@
 #include <string.h>
 
-#include <event.h>
+#include <event2/buffer.h>
 
 #include "transmission.h"
@@ -326 +326 @@
     tr_bencLoad( benc_str, strlen( benc_str ), &top, NULL );
     tr_bencToBuf( &top, TR_FMT_JSON, buf );
-    serialized = (char*) EVBUFFER_DATA( buf );
+    serialized = (char*) evbuffer_pullup( buf, -1 );
     stripWhitespace( serialized );
 #if 0

trunk/libtransmission/bencode.c

@@ -30 +30 @@
 #include <unistd.h> /* stat() */
 
-#include <event.h> /* struct evbuffer */
+#include <event2/buffer.h>
 
 #include "ConvertUTF.h"
@@ -1587 +1587 @@
 tr_bencToBuf( const tr_benc * top, tr_fmt_mode mode, struct evbuffer * buf )
 {
-    evbuffer_drain( buf, EVBUFFER_LENGTH( buf ) );
+    evbuffer_drain( buf, evbuffer_get_length( buf ) );
     evbuffer_expand( buf, 4096 ); /* alloc a little memory to start off with */
 
@@ -1603 +1603 @@
             data.parents = NULL;
             bencWalk( top, &jsonWalkFuncs, &data );
-            if( EVBUFFER_LENGTH( buf ) )
+            if( evbuffer_get_length( buf ) )
                 evbuffer_add_printf( buf, "\n" );
             break;
@@ -1615 +1615 @@
     char * ret;
     struct evbuffer * buf = evbuffer_new( );
+    size_t n;
     tr_bencToBuf( top, mode, buf );
-    ret = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
+    n = evbuffer_get_length( buf );
+    ret = evbuffer_free_to_str( buf );
     if( len != NULL )
-        *len = (int) EVBUFFER_LENGTH( buf );
-    evbuffer_free( buf );
+        *len = (int) n;
     return ret;
 }
@@ -1667 +1668 @@
     if( fd >= 0 )
     {
-        int len;
-        char * str = tr_bencToStr( top, mode, &len );
-
-        if( write( fd, str, len ) == (ssize_t)len )
+        int nleft;
+
+        /* save the benc to a temporary file */
+        {
+            struct evbuffer * buffer = evbuffer_new( );
+            tr_bencToBuf( top, mode, buffer );
+            nleft = evbuffer_get_length( buffer );
+            while( nleft > 0 ) {
+                const int n = evbuffer_write( buffer, fd );
+                if( n < nleft )
+                    fprintf( stderr, "wrote %d of %d to %s\n", n, nleft, tmp );
+                if( n >= 0 )
+                    nleft -= n;
+                else if( errno != EAGAIN ) {
+                    err = errno;
+                    break;
+                }
+            }
+            evbuffer_free( buffer );
+        }
+
+        if( nleft > 0 )
+        {
+            tr_err( _( "Couldn't save temporary file \"%1$s\": %2$s" ), tmp, tr_strerror( err ) );
+            tr_close_file( fd );
+            unlink( tmp );
+        }
+        else
         {
             struct stat sb;
@@ -1698 +1723 @@
             }
         }
-        else
-        {
-            err = errno;
-            tr_err( _( "Couldn't save temporary file \"%1$s\": %2$s" ), tmp, tr_strerror( err ) );
-            tr_close_file( fd );
-            unlink( tmp );
-        }
-
-        tr_free( str );
     }
     else

trunk/libtransmission/handshake.c

@@ -18 +18 @@
 #include <stdio.h>
 
-#include <event.h>
+#include <event2/event.h>
 
 #include "transmission.h"
@@ -121 +121 @@
     handshakeDoneCB       doneCB;
     void *                doneUserData;
-    struct event          timeout_timer;
+    struct event        * timeout_timer;
 };
 
@@ -266 +266 @@
 
     dbgmsg( handshake, "payload: need %d, got %zu",
-            (int)HANDSHAKE_SIZE, EVBUFFER_LENGTH( inbuf ) );
-
-    if( EVBUFFER_LENGTH( inbuf ) < HANDSHAKE_SIZE )
+            (int)HANDSHAKE_SIZE, evbuffer_get_length( inbuf ) );
+
+    if( evbuffer_get_length( inbuf ) < HANDSHAKE_SIZE )
         return READ_LATER;
 
@@ -347 +347 @@
     /* send it */
     setReadState( handshake, AWAITING_YB );
-    tr_peerIoWrite( handshake->io, outbuf, walk - outbuf, FALSE );
+    tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, FALSE );
 }
 
@@ -402 +402 @@
 
 static int
-readYb( tr_handshake *    handshake,
-        struct evbuffer * inbuf )
+readYb( tr_handshake * handshake, struct evbuffer * inbuf )
 {
     int               isEncrypted;
@@ -411 +410 @@
     size_t            needlen = HANDSHAKE_NAME_LEN;
 
-    if( EVBUFFER_LENGTH( inbuf ) < needlen )
+    if( evbuffer_get_length( inbuf ) < needlen )
         return READ_LATER;
 
-    isEncrypted = memcmp( EVBUFFER_DATA( inbuf ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
+    isEncrypted = memcmp( evbuffer_pullup( inbuf, HANDSHAKE_NAME_LEN ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
     if( isEncrypted )
     {
         needlen = KEY_LEN;
-        if( EVBUFFER_LENGTH( inbuf ) < needlen )
+        if( evbuffer_get_length( inbuf ) < needlen )
             return READ_LATER;
     }
@@ -476 +475 @@
         tr_peerIoSetEncryption( handshake->io, PEER_ENCRYPTION_RC4 );
 
-        tr_peerIoWriteBytes( handshake->io, outbuf, vc, VC_LENGTH );
-        tr_peerIoWriteUint32( handshake->io, outbuf,
-                             getCryptoProvide( handshake ) );
-        tr_peerIoWriteUint16( handshake->io, outbuf, 0 );
+        evbuffer_add        ( outbuf, vc, VC_LENGTH );
+        evbuffer_add_uint32 ( outbuf, getCryptoProvide( handshake ) );
+        evbuffer_add_uint16 ( outbuf, 0 );
     }
 
@@ -487 +485 @@
         buildHandshakeMessage( handshake, msg );
 
-        tr_peerIoWriteUint16( handshake->io, outbuf, sizeof( msg ) );
-        tr_peerIoWriteBytes( handshake->io, outbuf, msg, sizeof( msg ) );
+        evbuffer_add_uint16 ( outbuf, sizeof( msg ) );
+        evbuffer_add        ( outbuf, msg, sizeof( msg ) );
 
         handshake->haveSentBitTorrentHandshake = 1;
@@ -516 +514 @@
     for( ; ; )
     {
-        if( EVBUFFER_LENGTH( inbuf ) < VC_LENGTH )
+        if( evbuffer_get_length( inbuf ) < VC_LENGTH )
         {
             dbgmsg( handshake, "not enough bytes... returning read_more" );
@@ -522 +520 @@
         }
 
-        memcpy( tmp, EVBUFFER_DATA( inbuf ), key_len );
+        memcpy( tmp, evbuffer_pullup( inbuf, key_len ), key_len );
         tr_cryptoDecryptInit( handshake->crypto );
         tr_cryptoDecrypt( handshake->crypto, key_len, tmp, tmp );
@@ -545 +543 @@
     const size_t needlen = sizeof( uint32_t ) + sizeof( uint16_t );
 
-    if( EVBUFFER_LENGTH( inbuf ) < needlen )
+    if( evbuffer_get_length( inbuf ) < needlen )
         return READ_LATER;
 
@@ -581 +579 @@
 
     dbgmsg( handshake, "pad d: need %zu, got %zu",
-            needlen, EVBUFFER_LENGTH( inbuf ) );
-    if( EVBUFFER_LENGTH( inbuf ) < needlen )
+            needlen, evbuffer_get_length( inbuf ) );
+    if( evbuffer_get_length( inbuf ) < needlen )
         return READ_LATER;
 
@@ -611 +609 @@
 
     dbgmsg( handshake, "payload: need %d, got %zu",
-            (int)INCOMING_HANDSHAKE_LEN, EVBUFFER_LENGTH( inbuf ) );
-
-    if( EVBUFFER_LENGTH( inbuf ) < INCOMING_HANDSHAKE_LEN )
+            (int)INCOMING_HANDSHAKE_LEN, evbuffer_get_length( inbuf ) );
+
+    if( evbuffer_get_length( inbuf ) < INCOMING_HANDSHAKE_LEN )
         return READ_LATER;
 
     handshake->haveReadAnythingFromPeer = TRUE;
 
-    pstrlen = EVBUFFER_DATA( inbuf )[0]; /* peek, don't read.  We may be
-                                          handing inbuf to AWAITING_YA */
+    pstrlen = evbuffer_pullup( inbuf, 1 )[0]; /* peek, don't read.  We may be
+                                                 handing inbuf to AWAITING_YA */
 
     if( pstrlen == 19 ) /* unencrypted */
@@ -713 +711 @@
         uint8_t msg[HANDSHAKE_SIZE];
         buildHandshakeMessage( handshake, msg );
-        tr_peerIoWrite( handshake->io, msg, sizeof( msg ), FALSE );
+        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
         handshake->haveSentBitTorrentHandshake = 1;
     }
@@ -731 +729 @@
     uint8_t peer_id[PEER_ID_LEN];
 
-    if( EVBUFFER_LENGTH( inbuf ) < PEER_ID_LEN )
+    if( evbuffer_get_length( inbuf ) < PEER_ID_LEN )
         return READ_LATER;
 
@@ -760 +758 @@
 
     dbgmsg( handshake, "in readYa... need %d, have %zu",
-            (int)KEY_LEN, EVBUFFER_LENGTH( inbuf ) );
-    if( EVBUFFER_LENGTH( inbuf ) < KEY_LEN )
+            (int)KEY_LEN, evbuffer_get_length( inbuf ) );
+    if( evbuffer_get_length( inbuf ) < KEY_LEN )
         return READ_LATER;
 
@@ -781 +779 @@
 
     setReadState( handshake, AWAITING_PAD_A );
-    tr_peerIoWrite( handshake->io, outbuf, walk - outbuf, FALSE );
+    tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, FALSE );
     return READ_NOW;
 }
 
 static int
-readPadA( tr_handshake *    handshake,
-          struct evbuffer * inbuf )
-{
-    uint8_t * pch;
-
-    dbgmsg( handshake, "looking to get past pad a... & resync on hash('req',S) ... have %zu bytes",
-            EVBUFFER_LENGTH( inbuf ) );
-    /**
-    *** Resynchronizing on HASH('req1',S)
-    **/
-
-    pch = memchr( EVBUFFER_DATA( inbuf ),
-                 handshake->myReq1[0],
-                 EVBUFFER_LENGTH( inbuf ) );
-    if( pch == NULL )
-    {
-        dbgmsg( handshake, "no luck so far.. draining %zu bytes",
-                EVBUFFER_LENGTH( inbuf ) );
-        evbuffer_drain( inbuf, EVBUFFER_LENGTH( inbuf ) );
+readPadA( tr_handshake * handshake, struct evbuffer * inbuf )
+{
+    /* resynchronizing on HASH('req1',S) */
+    struct evbuffer_ptr ptr = evbuffer_search( inbuf, (const char*)handshake->myReq1, SHA_DIGEST_LENGTH, NULL );
+
+    if( ptr.pos != -1 ) /* match */
+    {
+        evbuffer_drain( inbuf, ptr.pos );
+        dbgmsg( handshake, "found it... looking setting to awaiting_crypto_provide" );
+        setState( handshake, AWAITING_CRYPTO_PROVIDE );
+        return READ_NOW;
+    }
+    else
+    {
+        const size_t len = evbuffer_get_length( inbuf );
+        if( len > SHA_DIGEST_LENGTH )
+            evbuffer_drain( inbuf, len - SHA_DIGEST_LENGTH );
         return READ_LATER;
     }
-    dbgmsg( handshake, "looking for hash('req',S) ... draining %d bytes",
-           (int)( pch - EVBUFFER_DATA( inbuf ) ) );
-    evbuffer_drain( inbuf, pch - EVBUFFER_DATA( inbuf ) );
-    if( EVBUFFER_LENGTH( inbuf ) < SHA_DIGEST_LENGTH )
-        return READ_LATER;
-    if( memcmp( EVBUFFER_DATA( inbuf ), handshake->myReq1,
-                SHA_DIGEST_LENGTH ) )
-    {
-        dbgmsg( handshake, "draining one more byte" );
-        evbuffer_drain( inbuf, 1 );
-        return READ_NOW;
-    }
-
-    dbgmsg( handshake,
-            "found it... looking setting to awaiting_crypto_provide" );
-    setState( handshake, AWAITING_CRYPTO_PROVIDE );
-    return READ_NOW;
 }
 
@@ -848 +827 @@
     tr_torrent * tor = NULL;
 
-    if( EVBUFFER_LENGTH( inbuf ) < needlen )
+    if( evbuffer_get_length( inbuf ) < needlen )
         return READ_LATER;
 
@@ -906 +885 @@
     const size_t needlen = handshake->pad_c_len + sizeof( uint16_t );
 
-    if( EVBUFFER_LENGTH( inbuf ) < needlen )
+    if( evbuffer_get_length( inbuf ) < needlen )
         return READ_LATER;
 
@@ -927 +906 @@
 
     dbgmsg( handshake, "reading IA... have %zu, need %zu",
-            EVBUFFER_LENGTH( inbuf ), needlen );
-    if( EVBUFFER_LENGTH( inbuf ) < needlen )
+            evbuffer_get_length( inbuf ), needlen );
+    if( evbuffer_get_length( inbuf ) < needlen )
         return READ_LATER;
 
@@ -943 +922 @@
         uint8_t vc[VC_LENGTH];
         memset( vc, 0, VC_LENGTH );
-        tr_peerIoWriteBytes( handshake->io, outbuf, vc, VC_LENGTH );
+        evbuffer_add( outbuf, vc, VC_LENGTH );
     }
 
@@ -951 +930 @@
     {
         dbgmsg( handshake, "selecting crypto mode '%d'", (int)crypto_select );
-        tr_peerIoWriteUint32( handshake->io, outbuf, crypto_select );
+        evbuffer_add_uint32( outbuf, crypto_select );
     }
     else
@@ -966 +945 @@
     {
         const uint16_t len = 0;
-        tr_peerIoWriteUint16( handshake->io, outbuf, len );
+        evbuffer_add_uint16( outbuf, len );
     }
 
@@ -982 +961 @@
         buildHandshakeMessage( handshake, msg );
 
-        tr_peerIoWriteBytes( handshake->io, outbuf, msg, sizeof( msg ) );
+        evbuffer_add( outbuf, msg, sizeof( msg ) );
         handshake->haveSentBitTorrentHandshake = 1;
     }
@@ -1003 +982 @@
 
     dbgmsg( handshake, "reading payload stream... have %zu, need %zu",
-            EVBUFFER_LENGTH( inbuf ), needlen );
-    if( EVBUFFER_LENGTH( inbuf ) < needlen )
+            evbuffer_get_length( inbuf ), needlen );
+    if( evbuffer_get_length( inbuf ) < needlen )
         return READ_LATER;
 
@@ -1086 +1065 @@
             readyForMore = FALSE;
         else if( handshake->state == AWAITING_PAD_C )
-            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->pad_c_len;
+            readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_c_len;
         else if( handshake->state == AWAITING_PAD_D )
-            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->pad_d_len;
+            readyForMore = evbuffer_get_length( inbuf ) >= handshake->pad_d_len;
         else if( handshake->state == AWAITING_IA )
-            readyForMore = EVBUFFER_LENGTH( inbuf ) >= handshake->ia_len;
+            readyForMore = evbuffer_get_length( inbuf ) >= handshake->ia_len;
     }
 
@@ -1118 +1097 @@
         tr_peerIoUnref( handshake->io ); /* balanced by the ref in tr_handshakeNew */
 
-    evtimer_del( &handshake->timeout_timer );
-
+    event_free( handshake->timeout_timer );
     tr_free( handshake );
 }
@@ -1167 +1145 @@
         handshake->haveSentBitTorrentHandshake = 1;
         setReadState( handshake, AWAITING_HANDSHAKE );
-        tr_peerIoWrite( handshake->io, msg, sizeof( msg ), FALSE );
+        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
     }
     else
@@ -1202 +1180 @@
     handshake->doneUserData = doneUserData;
     handshake->session = tr_peerIoGetSession( io );
-
-    evtimer_set( &handshake->timeout_timer, handshakeTimeout, handshake );
-    tr_timerAdd( &handshake->timeout_timer, HANDSHAKE_TIMEOUT_SEC, 0 );
+    handshake->timeout_timer = evtimer_new( NULL, handshakeTimeout, handshake );
+    tr_timerAdd( handshake->timeout_timer, HANDSHAKE_TIMEOUT_SEC, 0 );
 
     tr_peerIoRef( io ); /* balanced by the unref in tr_handshakeFree */
@@ -1221 +1198 @@
         handshake->haveSentBitTorrentHandshake = 1;
         setReadState( handshake, AWAITING_HANDSHAKE );
-        tr_peerIoWrite( handshake->io, msg, sizeof( msg ), FALSE );
+        tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
     }
 

trunk/libtransmission/metainfo.c

@@ -20 +20 @@
 #include <unistd.h> /* unlink, stat */
 
-#include <event.h> /* struct evbuffer */
+#include <event2/buffer.h>
 
 #include "transmission.h"
@@ -155 +155 @@
     {
         int i;
+        char * tmp;
         const int n = tr_bencListSize( path );
         struct evbuffer * buf = evbuffer_new( );
@@ -169 +170 @@
         }
 
-        *setme = tr_utf8clean( (char*)EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
+        tmp = evbuffer_free_to_str( buf );
+        *setme = tr_utf8clean( tmp, -1 );
+        tr_free( tmp );
         /* fprintf( stderr, "[%s]\n", *setme ); */
-        evbuffer_free( buf );
         success = TRUE;
     }

trunk/libtransmission/peer-io.c

@@ -24 +24 @@
 #endif
 
-#include <event.h>
+#include <event2/event.h>
+#include <event2/bufferevent.h>
 
 #include "transmission.h"
@@ -144 +145 @@
         {
             size_t piece = 0;
-            const size_t oldLen = EVBUFFER_LENGTH( io->inbuf );
+            const size_t oldLen = evbuffer_get_length( io->inbuf );
             const int ret = io->canRead( io, io->userData, &piece );
 
-            const size_t used = oldLen - EVBUFFER_LENGTH( io->inbuf );
+            const size_t used = oldLen - evbuffer_get_length( io->inbuf );
 
             assert( tr_isPeerIo( io ) );
@@ -165 +166 @@
             {
                 case READ_NOW:
-                    if( EVBUFFER_LENGTH( io->inbuf ) )
+                    if( evbuffer_get_length( io->inbuf ) )
                         continue;
                     done = 1;
@@ -183 +184 @@
 
         tr_sessionUnlock( session );
-    }
-
-    /* keep the iobuf's excess capacity from growing too large */
-    if( EVBUFFER_LENGTH( io->inbuf ) == 0 ) {
-        evbuffer_free( io->inbuf );
-        io->inbuf = evbuffer_new( );
     }
 
@@ -223 +218 @@
     io->pendingEvents &= ~EV_READ;
 
-    curlen = EVBUFFER_LENGTH( io->inbuf );
+    curlen = evbuffer_get_length( io->inbuf );
     howmuch = curlen >= max ? 0 : max - curlen;
     howmuch = tr_bandwidthClamp( &io->bandwidth, TR_DOWN, howmuch );
@@ -249 +244 @@
     {
         char errstr[512];
-        short what = EVBUFFER_READ;
+        short what = BEV_EVENT_READING;
 
         if( res == 0 ) /* EOF */
-            what |= EVBUFFER_EOF;
+            what |= BEV_EVENT_EOF;
         else if( res == -1 ) {
             if( e == EAGAIN || e == EINTR ) {
@@ -258 +253 @@
                 return;
             }
-            what |= EVBUFFER_ERROR;
+            what |= BEV_EVENT_ERROR;
         }
 
@@ -275 +270 @@
     int n;
     char errstr[256];
-    struct evbuffer * buffer = io->outbuf;
-
-    howmuch = MIN( EVBUFFER_LENGTH( buffer ), howmuch );
+    const size_t len = evbuffer_get_length( io->outbuf );
+    const int vecCount = evbuffer_peek( io->outbuf, len, NULL, NULL, 0 );
 
     EVUTIL_SET_SOCKET_ERROR( 0 );
-#ifdef WIN32
-    n = (int) send(fd, buffer->buffer, howmuch,  0 );
-#else
-    n = (int) write(fd, buffer->buffer, howmuch );
-#endif
+    n = evbuffer_write_atmost( io->outbuf, fd, howmuch );
     e = EVUTIL_SOCKET_ERROR( );
     dbgmsg( io, "wrote %d to peer (%s)", n, (n==-1?tr_net_strerror(errstr,sizeof(errstr),e):"") );
 
-    if( n > 0 )
-        evbuffer_drain( buffer, (size_t)n );
-
-    /* keep the iobuf's excess capacity from growing too large */
-    if( EVBUFFER_LENGTH( io->outbuf ) == 0 ) {
-        evbuffer_free( io->outbuf );
-        io->outbuf = evbuffer_new( );
-    }
-
     return n;
 }
@@ -305 +286 @@
     int res = 0;
     int e;
-    short what = EVBUFFER_WRITE;
+    short what = BEV_EVENT_WRITING;
     tr_peerIo * io = vio;
     size_t howmuch;
@@ -319 +300 @@
     /* Write as much as possible, since the socket is non-blocking, write() will
      * return if it can't write any more data without blocking */
-    howmuch = tr_bandwidthClamp( &io->bandwidth, dir, EVBUFFER_LENGTH( io->outbuf ) );
+    howmuch = tr_bandwidthClamp( &io->bandwidth, dir, evbuffer_get_length( io->outbuf ) );
 
     /* if we don't have any bandwidth left, stop writing */
@@ -332 +313 @@
 
     if (res == -1) {
-        if (e == EAGAIN || e == EINTR || e == EINPROGRESS)
+        if (!e || e == EAGAIN || e == EINTR || e == EINPROGRESS)
             goto reschedule;
         /* error case */
-        what |= EVBUFFER_ERROR;
+        what |= BEV_EVENT_ERROR;
     } else if (res == 0) {
         /* eof case */
-        what |= EVBUFFER_EOF;
+        what |= BEV_EVENT_EOF;
     }
     if (res <= 0)
         goto error;
 
-    if( EVBUFFER_LENGTH( io->outbuf ) )
+    if( evbuffer_get_length( io->outbuf ) )
         tr_peerIoSetEnabled( io, dir, TRUE );
 
@@ -350 +331 @@
 
  reschedule:
-    if( EVBUFFER_LENGTH( io->outbuf ) )
+    if( evbuffer_get_length( io->outbuf ) )
         tr_peerIoSetEnabled( io, dir, TRUE );
     return;
@@ -416 +397 @@
     io->inbuf = evbuffer_new( );
     io->outbuf = evbuffer_new( );
+    io->event_read = event_new( NULL, io->socket, EV_READ, event_read_cb, io );
+    io->event_write = event_new( NULL, io->socket, EV_WRITE, event_write_cb, io );
     tr_bandwidthConstruct( &io->bandwidth, session, parent );
     tr_bandwidthSetPeer( &io->bandwidth, io );
     dbgmsg( io, "bandwidth is %p; its parent is %p", &io->bandwidth, parent );
-
-    event_set( &io->event_read, io->socket, EV_READ, event_read_cb, io );
-    event_set( &io->event_write, io->socket, EV_WRITE, event_write_cb, io );
 
     return io;
@@ -471 +451 @@
     assert( io->session != NULL );
     assert( io->session->events != NULL );
-    assert( event_initialized( &io->event_read ) );
-    assert( event_initialized( &io->event_write ) );
+    assert( event_initialized( io->event_read ) );
+    assert( event_initialized( io->event_write ) );
 
     if( io->socket < 0 )
@@ -480 +460 @@
     {
         dbgmsg( io, "enabling libevent ready-to-read polling" );
-        event_add( &io->event_read, NULL );
+        event_add( io->event_read, NULL );
         io->pendingEvents |= EV_READ;
     }
@@ -487 +467 @@
     {
         dbgmsg( io, "enabling libevent ready-to-write polling" );
-        event_add( &io->event_write, NULL );
+        event_add( io->event_write, NULL );
         io->pendingEvents |= EV_WRITE;
     }
@@ -498 +478 @@
     assert( io->session != NULL );
     assert( io->session->events != NULL );
-    assert( event_initialized( &io->event_read ) );
-    assert( event_initialized( &io->event_write ) );
+    assert( event_initialized( io->event_read ) );
+    assert( event_initialized( io->event_write ) );
 
     if( ( event & EV_READ ) && ( io->pendingEvents & EV_READ ) )
     {
         dbgmsg( io, "disabling libevent ready-to-read polling" );
-        event_del( &io->event_read );
+        event_del( io->event_read );
         io->pendingEvents &= ~EV_READ;
     }
@@ -511 +491 @@
     {
         dbgmsg( io, "disabling libevent ready-to-write polling" );
-        event_del( &io->event_write );
+        event_del( io->event_write );
         io->pendingEvents &= ~EV_WRITE;
     }
@@ -549 +529 @@
     dbgmsg( io, "in tr_peerIo destructor" );
     event_disable( io, EV_READ | EV_WRITE );
+    event_free( io->event_read );
+    event_free( io->event_write );
     tr_bandwidthDestruct( &io->bandwidth );
     evbuffer_free( io->outbuf );
@@ -662 +644 @@
         tr_netClose( session, io->socket );
 
+    event_del( io->event_read );
+    event_del( io->event_write );
     io->socket = tr_netOpenPeerSocket( session, &io->addr, io->port, io->isSeed );
-    event_set( &io->event_read, io->socket, EV_READ, event_read_cb, io );
-    event_set( &io->event_write, io->socket, EV_WRITE, event_write_cb, io );
+    io->event_read = event_new( NULL, io->socket, EV_READ, event_read_cb, io );
+    io->event_write = event_new( NULL, io->socket, EV_WRITE, event_write_cb, io );
 
     if( io->socket >= 0 )
@@ -746 +730 @@
 {
     const size_t desiredLen = getDesiredOutputBufferSize( io, now );
-    const size_t currentLen = EVBUFFER_LENGTH( io->outbuf );
+    const size_t currentLen = evbuffer_get_length( io->outbuf );
     size_t freeSpace = 0;
 
@@ -773 +757 @@
 **/
 
-void
-tr_peerIoWrite( tr_peerIo   * io,
-                const void  * bytes,
-                size_t        byteCount,
-                tr_bool       isPieceData )
-{
-    /* FIXME(libevent2): this implementation snould be moved to tr_peerIoWriteBuf.   This function should be implemented as evbuffer_new() + evbuffer_add_reference() + a call to tr_peerIoWriteBuf() + evbuffer_free() */
-    struct tr_datatype * datatype;
-
-    assert( tr_amInEventThread( io->session ) );
-    dbgmsg( io, "adding %zu bytes into io->output", byteCount );
-
-    datatype = tr_new( struct tr_datatype, 1 );
-    datatype->isPieceData = isPieceData != 0;
-    datatype->length = byteCount;
-    tr_list_append( &io->outbuf_datatypes, datatype );
-
-    switch( io->encryptionMode )
-    {
-        case PEER_ENCRYPTION_RC4:
-        {
-            /* FIXME(libevent2): use evbuffer_reserve_space() and evbuffer_commit_space() instead of tmp */
-            void * tmp = tr_sessionGetBuffer( io->session );
-            const size_t tmplen = SESSION_BUFFER_SIZE;
-            const uint8_t * walk = bytes;
-            evbuffer_expand( io->outbuf, byteCount );
-            while( byteCount > 0 )
-            {
-                const size_t thisPass = MIN( byteCount, tmplen );
-                tr_cryptoEncrypt( io->crypto, thisPass, walk, tmp );
-                evbuffer_add( io->outbuf, tmp, thisPass );
-                walk += thisPass;
-                byteCount -= thisPass;
-            }
-            tr_sessionReleaseBuffer( io->session );
-            break;
-        }
-
-        case PEER_ENCRYPTION_NONE:
-            evbuffer_add( io->outbuf, bytes, byteCount );
-            break;
-
-        default:
-            assert( 0 );
-            break;
-    }
-}
-
-void
-tr_peerIoWriteBuf( tr_peerIo         * io,
-                   struct evbuffer   * buf,
-                   tr_bool             isPieceData )
-{
-    /* FIXME(libevent2): loop through calls to evbuffer_get_contiguous_space() + evbuffer_drain() */
-    const size_t n = EVBUFFER_LENGTH( buf );
-    tr_peerIoWrite( io, EVBUFFER_DATA( buf ), n, isPieceData );
-    evbuffer_drain( buf, n );
-}
-
-void
-tr_peerIoWriteUint16( tr_peerIo        * io,
-                      struct evbuffer  * outbuf,
-                      uint16_t           writeme )
-{
-    const uint16_t tmp = htons( writeme );
-    tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof( uint16_t ) );
-}
-
-void
-tr_peerIoWriteUint32( tr_peerIo        * io,
-                      struct evbuffer  * outbuf,
-                      uint32_t           writeme )
-{
-    const uint32_t tmp = htonl( writeme );
-    tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof( uint32_t ) );
+static void
+addDatatype( tr_peerIo * io, size_t byteCount, tr_bool isPieceData )
+{
+    struct tr_datatype * d;
+
+    d = tr_new( struct tr_datatype, 1 );
+    d->isPieceData = isPieceData != 0;
+    d->length = byteCount;
+    tr_list_append( &io->outbuf_datatypes, d );
+}
+
+static struct evbuffer_iovec *
+evbuffer_peek_all( struct evbuffer * buf, size_t * setme_vecCount )
+{
+    const size_t byteCount = evbuffer_get_length( buf );
+    const int vecCount = evbuffer_peek( buf, byteCount, NULL, NULL, 0 );
+    struct evbuffer_iovec * iovec = tr_new0( struct evbuffer_iovec, vecCount );
+    const int n = evbuffer_peek( buf, byteCount, NULL, iovec, vecCount );
+    assert( vecCount == n );
+    *setme_vecCount = vecCount;
+    return iovec;
+}
+
+static void
+maybeEncryptBuffer( tr_peerIo * io, struct evbuffer * buf )
+{
+    if( io->encryptionMode == PEER_ENCRYPTION_RC4 )
+    {
+        size_t i, n;
+        struct evbuffer_iovec * iovec = evbuffer_peek_all( buf, &n );
+
+        for( i=0; i<n; ++i )
+            tr_cryptoEncrypt( io->crypto, iovec[i].iov_len, iovec[i].iov_base, iovec[i].iov_base );
+
+        tr_free( iovec );
+    }
+}
+
+void
+tr_peerIoWriteBuf( tr_peerIo * io, struct evbuffer * buf, tr_bool isPieceData )
+{
+    const size_t byteCount = evbuffer_get_length( buf );
+    maybeEncryptBuffer( io, buf );
+    evbuffer_add_buffer( io->outbuf, buf );
+    addDatatype( io, byteCount, isPieceData );
+}
+
+void
+tr_peerIoWriteBytes( tr_peerIo * io, const void * bytes, size_t byteCount, tr_bool isPieceData )
+{
+    struct evbuffer * buf = evbuffer_new( );
+    evbuffer_add( buf, bytes, byteCount );
+    tr_peerIoWriteBuf( io, buf, isPieceData );
+    evbuffer_free( buf );
 }
 
@@ -855 +818 @@
 
 void
-tr_peerIoReadBytes( tr_peerIo       * io,
-                    struct evbuffer * inbuf,
-                    void            * bytes,
-                    size_t            byteCount )
-{
-    assert( tr_isPeerIo( io ) );
-    /* FIXME(libevent2): use evbuffer_get_length() */
-    assert( EVBUFFER_LENGTH( inbuf ) >= byteCount );
+evbuffer_add_uint16( struct evbuffer * outbuf, uint16_t addme_hs )
+{
+    const uint16_t ns = htons( addme_hs );
+    evbuffer_add( outbuf, &ns, sizeof( ns ) );
+}
+
+void
+evbuffer_add_uint32( struct evbuffer * outbuf, uint32_t addme_hl )
+{
+    const uint32_t nl = htonl( addme_hl );
+    evbuffer_add( outbuf, &nl, sizeof( nl ) );
+}
+
+/***
+****
+***/
+
+void
+tr_peerIoReadBytes( tr_peerIo * io, struct evbuffer * inbuf, void * bytes, size_t byteCount )
+{
+    assert( tr_isPeerIo( io ) );
+    assert( evbuffer_get_length( inbuf )  >= byteCount );
 
     switch( io->encryptionMode )
@@ -871 +848 @@
 
         case PEER_ENCRYPTION_RC4:
-            /* FIXME(libevent2): loop through calls to evbuffer_get_contiguous_space() + evbuffer_drain() */
-            tr_cryptoDecrypt( io->crypto, byteCount, EVBUFFER_DATA(inbuf), bytes );
-            evbuffer_drain(inbuf, byteCount );
+            evbuffer_remove( inbuf, bytes, byteCount );
+            tr_cryptoDecrypt( io->crypto, byteCount, bytes, bytes );
             break;
 
@@ -937 +913 @@
         dbgmsg( io, "read %d from peer (%s)", res, (res==-1?strerror(e):"") );
 
-        if( EVBUFFER_LENGTH( io->inbuf ) )
+        if( evbuffer_get_length( io->inbuf ) )
             canReadWrapper( io );
 
@@ -943 +919 @@
         {
             char errstr[512];
-            short what = EVBUFFER_READ | EVBUFFER_ERROR;
+            short what = BEV_EVENT_READING | BEV_EVENT_ERROR;
             if( res == 0 )
-                what |= EVBUFFER_EOF;
+                what |= BEV_EVENT_EOF;
             tr_net_strerror( errstr, sizeof( errstr ), e );
             dbgmsg( io, "tr_peerIoTryRead got an error. res is %d, what is %hd, errno is %d (%s)", res, what, e, errstr );
@@ -970 +946 @@
             didWriteWrapper( io, n );
 
-        if( ( n < 0 ) && ( io->gotError ) && ( e != EPIPE ) && ( e != EAGAIN ) && ( e != EINTR ) && ( e != EINPROGRESS ) )
+        if( ( n < 0 ) && ( io->gotError ) && e && ( e != EPIPE ) && ( e != EAGAIN ) && ( e != EINTR ) && ( e != EINPROGRESS ) )
         {
             char errstr[512];
-            const short what = EVBUFFER_WRITE | EVBUFFER_ERROR;
+            const short what = BEV_EVENT_WRITING | BEV_EVENT_ERROR;
 
             tr_net_strerror( errstr, sizeof( errstr ), e );

trunk/libtransmission/peer-io.h

@@ -24 +24 @@
 #include <assert.h>
 
-#include <event.h>
+#include <event2/buffer.h>
+#include <event2/event.h>
 
 #include "transmission.h"
@@ -110 +111 @@
     struct tr_list      * outbuf_datatypes; /* struct tr_datatype */
 
-    struct event          event_read;
-    struct event          event_write;
+    struct event        * event_read;
+    struct event        * event_write;
 }
 tr_peerIo;
@@ -249 +250 @@
 **/
 
-void    tr_peerIoWrite          ( tr_peerIo         * io,
+void    tr_peerIoWriteBytes     ( tr_peerIo         * io,
                                   const void        * writeme,
                                   size_t              writemeLen,
@@ -283 +284 @@
 }
 
-static inline void tr_peerIoWriteBytes( tr_peerIo        * io UNUSED,
-                                           struct evbuffer  * outbuf,
-                                           const void       * bytes,
-                                           size_t             byteCount )
-{
-    evbuffer_add( outbuf, bytes, byteCount );
-}
-
-static inline 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,
-                           uint16_t           writeme );
-
-void tr_peerIoWriteUint32( tr_peerIo        * io,
-                           struct evbuffer  * outbuf,
-                           uint32_t           writeme );
+static inline void
+evbuffer_add_uint8( struct evbuffer * outbuf, uint8_t byte )
+{
+    evbuffer_add( outbuf, &byte, 1 );
+}
+
+void evbuffer_add_uint16( struct evbuffer * outbuf, uint16_t hs );
+void evbuffer_add_uint32( struct evbuffer * outbuf, uint32_t hl );
 
 void tr_peerIoReadBytes( tr_peerIo        * io,

trunk/libtransmission/peer-msgs.c

@@ -19 +19 @@
 #include <string.h>
 
-#include <event.h>
+#include <event2/bufferevent.h>
+#include <event2/event.h>
 
 #include "transmission.h"
@@ -228 +229 @@
     int64_t               reqq;
 
-    struct event          pexTimer;
+    struct event        * pexTimer;
 };
 
@@ -278 +279 @@
         va_end( args );
         evbuffer_add_printf( buf, " (%s:%d)\n", base, line );
-        /* FIXME(libevent2) tr_getLog() should return an fd, then use evbuffer_write() here */
-        fwrite( EVBUFFER_DATA( buf ), 1, EVBUFFER_LENGTH( buf ), fp );
+        fwrite( evbuffer_pullup( buf, -1 ), 1, evbuffer_get_length( buf ), fp );
 
         tr_free( base );
@@ -310 +310 @@
 dbgOutMessageLen( tr_peermsgs * msgs )
 {
-    dbgmsg( msgs, "outMessage size is now %zu", EVBUFFER_LENGTH( msgs->outMessages ) );
+    dbgmsg( msgs, "outMessage size is now %zu", evbuffer_get_length( msgs->outMessages ) );
 }
 
@@ -316 +316 @@
 protocolSendReject( tr_peermsgs * msgs, const struct peer_request * req )
 {
-    tr_peerIo       * io  = msgs->peer->io;
     struct evbuffer * out = msgs->outMessages;
 
     assert( tr_peerIoSupportsFEXT( msgs->peer->io ) );
 
-    tr_peerIoWriteUint32( io, out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
-    tr_peerIoWriteUint8 ( io, out, BT_FEXT_REJECT );
-    tr_peerIoWriteUint32( io, out, req->index );
-    tr_peerIoWriteUint32( io, out, req->offset );
-    tr_peerIoWriteUint32( io, out, req->length );
+    evbuffer_add_uint32( out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
+    evbuffer_add_uint8 ( out, BT_FEXT_REJECT );
+    evbuffer_add_uint32( out, req->index );
+    evbuffer_add_uint32( out, req->offset );
+    evbuffer_add_uint32( out, req->length );
 
     dbgmsg( msgs, "rejecting %u:%u->%u...", req->index, req->offset, req->length );
@@ -332 +331 @@
 
 static void
-protocolSendRequest( tr_peermsgs               * msgs,
-                     const struct peer_request * req )
-{
-    tr_peerIo       * io  = msgs->peer->io;
+protocolSendRequest( tr_peermsgs * msgs, const struct peer_request * req )
+{
     struct evbuffer * out = msgs->outMessages;
 
-    tr_peerIoWriteUint32( io, out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
-    tr_peerIoWriteUint8 ( io, out, BT_REQUEST );
-    tr_peerIoWriteUint32( io, out, req->index );
-    tr_peerIoWriteUint32( io, out, req->offset );
-    tr_peerIoWriteUint32( io, out, req->length );
+    evbuffer_add_uint32( out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
+    evbuffer_add_uint8 ( out, BT_REQUEST );
+    evbuffer_add_uint32( out, req->index );
+    evbuffer_add_uint32( out, req->offset );
+    evbuffer_add_uint32( out, req->length );
 
     dbgmsg( msgs, "requesting %u:%u->%u...", req->index, req->offset, req->length );
@@ -350 +347 @@
 
 static void
-protocolSendCancel( tr_peermsgs               * msgs,
-                    const struct peer_request * req )
-{
-    tr_peerIo       * io  = msgs->peer->io;
+protocolSendCancel( tr_peermsgs * msgs, const struct peer_request * req )
+{
     struct evbuffer * out = msgs->outMessages;
 
-    tr_peerIoWriteUint32( io, out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
-    tr_peerIoWriteUint8 ( io, out, BT_CANCEL );
-    tr_peerIoWriteUint32( io, out, req->index );
-    tr_peerIoWriteUint32( io, out, req->offset );
-    tr_peerIoWriteUint32( io, out, req->length );
+    evbuffer_add_uint32( out, sizeof( uint8_t ) + 3 * sizeof( uint32_t ) );
+    evbuffer_add_uint8 ( out, BT_CANCEL );
+    evbuffer_add_uint32( out, req->index );
+    evbuffer_add_uint32( out, req->offset );
+    evbuffer_add_uint32( out, req->length );
 
     dbgmsg( msgs, "cancelling %u:%u->%u...", req->index, req->offset, req->length );
@@ -370 +365 @@
 protocolSendPort(tr_peermsgs *msgs, uint16_t port)
 {
-    tr_peerIo       * io  = msgs->peer->io;
     struct evbuffer * out = msgs->outMessages;
 
     dbgmsg( msgs, "sending Port %u", port);
-    tr_peerIoWriteUint32( io, out, 3 );
-    tr_peerIoWriteUint8 ( io, out, BT_PORT );
-    tr_peerIoWriteUint16( io, out, port);
-}
-
-static void
-protocolSendHave( tr_peermsgs * msgs,
-                  uint32_t      index )
-{
-    tr_peerIo       * io  = msgs->peer->io;
+    evbuffer_add_uint32( out, 3 );
+    evbuffer_add_uint8 ( out, BT_PORT );
+    evbuffer_add_uint16( out, port);
+}
+
+static void
+protocolSendHave( tr_peermsgs * msgs, uint32_t index )
+{
     struct evbuffer * out = msgs->outMessages;
 
-    tr_peerIoWriteUint32( io, out, sizeof(uint8_t) + sizeof(uint32_t) );
-    tr_peerIoWriteUint8 ( io, out, BT_HAVE );
-    tr_peerIoWriteUint32( io, out, index );
+    evbuffer_add_uint32( out, sizeof(uint8_t) + sizeof(uint32_t) );
+    evbuffer_add_uint8 ( out, BT_HAVE );
+    evbuffer_add_uint32( out, index );
 
     dbgmsg( msgs, "sending Have %u", index );
@@ -404 +396 @@
     assert( tr_peerIoSupportsFEXT( msgs->peer->io ) );
 
-    tr_peerIoWriteUint32( io, out, sizeof(uint8_t) + sizeof(uint32_t) );
-    tr_peerIoWriteUint8 ( io, out, BT_FEXT_ALLOWED_FAST );
-    tr_peerIoWriteUint32( io, out, pieceIndex );
+    evbuffer_add_uint32( io, out, sizeof(uint8_t) + sizeof(uint32_t) );
+    evbuffer_add_uint8 ( io, out, BT_FEXT_ALLOWED_FAST );
+    evbuffer_add_uint32( io, out, pieceIndex );
 
     dbgmsg( msgs, "sending Allowed Fast %u...", pieceIndex );
@@ -414 +406 @@
 
 static void
-protocolSendChoke( tr_peermsgs * msgs,
-                   int           choke )
-{
-    tr_peerIo       * io  = msgs->peer->io;
+protocolSendChoke( tr_peermsgs * msgs, int choke )
+{
     struct evbuffer * out = msgs->outMessages;
 
-    tr_peerIoWriteUint32( io, out, sizeof( uint8_t ) );
-    tr_peerIoWriteUint8 ( io, out, choke ? BT_CHOKE : BT_UNCHOKE );
+    evbuffer_add_uint32( out, sizeof( uint8_t ) );
+    evbuffer_add_uint8 ( out, choke ? BT_CHOKE : BT_UNCHOKE );
 
     dbgmsg( msgs, "sending %s...", choke ? "Choke" : "Unchoke" );
@@ -431 +421 @@
 protocolSendHaveAll( tr_peermsgs * msgs )
 {
-    tr_peerIo       * io  = msgs->peer->io;
     struct evbuffer * out = msgs->outMessages;
 
     assert( tr_peerIoSupportsFEXT( msgs->peer->io ) );
 
-    tr_peerIoWriteUint32( io, out, sizeof( uint8_t ) );
-    tr_peerIoWriteUint8 ( io, out, BT_FEXT_HAVE_ALL );
+    evbuffer_add_uint32( out, sizeof( uint8_t ) );
+    evbuffer_add_uint8 ( out, BT_FEXT_HAVE_ALL );
 
     dbgmsg( msgs, "sending HAVE_ALL..." );
@@ -447 +436 @@
 protocolSendHaveNone( tr_peermsgs * msgs )
 {
-    tr_peerIo       * io  = msgs->peer->io;
     struct evbuffer * out = msgs->outMessages;
 
     assert( tr_peerIoSupportsFEXT( msgs->peer->io ) );
 
-    tr_peerIoWriteUint32( io, out, sizeof( uint8_t ) );
-    tr_peerIoWriteUint8 ( io, out, BT_FEXT_HAVE_NONE );
+    evbuffer_add_uint32( out, sizeof( uint8_t ) );
+    evbuffer_add_uint8 ( out, BT_FEXT_HAVE_NONE );
 
     dbgmsg( msgs, "sending HAVE_NONE..." );
@@ -676 +664 @@
     msgs->peer->clientIsInterested = clientIsInterested;
     dbgmsg( msgs, "Sending %s", clientIsInterested ? "Interested" : "Not Interested" );
-    tr_peerIoWriteUint32( msgs->peer->io, out, sizeof( uint8_t ) );
-    tr_peerIoWriteUint8 ( msgs->peer->io, out, clientIsInterested ? BT_INTERESTED : BT_NOT_INTERESTED );
+    evbuffer_add_uint32( out, sizeof( uint8_t ) );
+    evbuffer_add_uint8 ( out, clientIsInterested ? BT_INTERESTED : BT_NOT_INTERESTED );
 
     pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
@@ -858 +846 @@
     buf = tr_bencToStr( &val, TR_FMT_BENC, &len );
 
-    tr_peerIoWriteUint32( msgs->peer->io, out, 2 * sizeof( uint8_t ) + len );
-    tr_peerIoWriteUint8 ( msgs->peer->io, out, BT_LTEP );
-    tr_peerIoWriteUint8 ( msgs->peer->io, out, LTEP_HANDSHAKE );
-    tr_peerIoWriteBytes ( msgs->peer->io, out, buf, len );
+    evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + len );
+    evbuffer_add_uint8 ( out, BT_LTEP );
+    evbuffer_add_uint8 ( out, LTEP_HANDSHAKE );
+    evbuffer_add       ( out, buf, len );
     pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
     dbgOutMessageLen( msgs );
@@ -1016 +1004 @@
             int payloadLen;
             char * payload;
-            tr_peerIo  * io  = msgs->peer->io;
             struct evbuffer * out = msgs->outMessages;
 
@@ -1027 +1014 @@
 
             /* write it out as a LTEP message to our outMessages buffer */
-            tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + payloadLen );
-            tr_peerIoWriteUint8 ( io, out, BT_LTEP );
-            tr_peerIoWriteUint8 ( io, out, msgs->ut_metadata_id );
-            tr_peerIoWriteBytes ( io, out, payload, payloadLen );
+            evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + payloadLen );
+            evbuffer_add_uint8 ( out, BT_LTEP );
+            evbuffer_add_uint8 ( out, msgs->ut_metadata_id );
+            evbuffer_add       ( out, payload, payloadLen );
             pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
             dbgOutMessageLen( msgs );
@@ -1304 +1291 @@
     struct peer_request * req = &msgs->incoming.blockReq;
 
-    assert( EVBUFFER_LENGTH( inbuf ) >= inlen );
+    assert( evbuffer_get_length( inbuf ) >= inlen );
     dbgmsg( msgs, "In readBtPiece" );
 
@@ -1323 +1310 @@
 
         /* read in another chunk of data */
-        const size_t nLeft = req->length - EVBUFFER_LENGTH( msgs->incoming.block );
+        const size_t nLeft = req->length - evbuffer_get_length( msgs->incoming.block );
         size_t n = MIN( nLeft, inlen );
         size_t i = n;
@@ -1344 +1331 @@
         dbgmsg( msgs, "got %zu bytes for block %u:%u->%u ... %d remain",
                n, req->index, req->offset, req->length,
-               (int)( req->length - EVBUFFER_LENGTH( msgs->incoming.block ) ) );
-        if( EVBUFFER_LENGTH( msgs->incoming.block ) < req->length )
+               (int)( req->length - evbuffer_get_length( msgs->incoming.block ) ) );
+        if( evbuffer_get_length( msgs->incoming.block ) < req->length )
             return READ_LATER;
 
         /* we've got the whole block ... process it */
-        err = clientGotBlock( msgs, EVBUFFER_DATA( msgs->incoming.block ), req );
+        err = clientGotBlock( msgs, evbuffer_pullup( msgs->incoming.block, -1 ), req );
 
         /* cleanup */
@@ -1369 +1356 @@
     const uint8_t id = msgs->incoming.id;
 #ifndef NDEBUG
-    const size_t  startBufLen = EVBUFFER_LENGTH( inbuf );
+    const size_t  startBufLen = evbuffer_get_length( inbuf );
 #endif
     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
@@ -1559 +1546 @@
 
     assert( msglen + 1 == msgs->incoming.length );
-    assert( EVBUFFER_LENGTH( inbuf ) == startBufLen - msglen );
+    assert( evbuffer_get_length( inbuf ) == startBufLen - msglen );
 
     msgs->state = AWAITING_BT_LENGTH;
@@ -1633 +1620 @@
     tr_peermsgs *     msgs = vmsgs;
     struct evbuffer * in = tr_peerIoGetReadBuffer( io );
-    const size_t      inlen = EVBUFFER_LENGTH( in );
+    const size_t      inlen = evbuffer_get_length( in );
 
     dbgmsg( msgs, "canRead: inlen is %zu, msgs->state is %d", inlen, msgs->state );
@@ -1664 +1651 @@
 
     /* log the raw data that was read */
-    if( ( ret != READ_ERR ) && ( EVBUFFER_LENGTH( in ) != inlen ) )
-        fireClientGotData( msgs, inlen - EVBUFFER_LENGTH( in ), FALSE );
+    if( ( ret != READ_ERR ) && ( evbuffer_get_length( in ) != inlen ) )
+        fireClientGotData( msgs, inlen - evbuffer_get_length( in ), FALSE );
 
     return ret;
@@ -1745 +1732 @@
         int payloadLen;
         char * payload;
-        tr_peerIo  * io  = msgs->peer->io;
         struct evbuffer * out = msgs->outMessages;
 
@@ -1758 +1744 @@
 
         /* write it out as a LTEP message to our outMessages buffer */
-        tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + payloadLen );
-        tr_peerIoWriteUint8 ( io, out, BT_LTEP );
-        tr_peerIoWriteUint8 ( io, out, msgs->ut_metadata_id );
-        tr_peerIoWriteBytes ( io, out, payload, payloadLen );
+        evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + payloadLen );
+        evbuffer_add_uint8 ( out, BT_LTEP );
+        evbuffer_add_uint8 ( out, msgs->ut_metadata_id );
+        evbuffer_add       ( out, payload, payloadLen );
         pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
         dbgOutMessageLen( msgs );
@@ -1800 +1786 @@
     size_t bytesWritten = 0;
     struct peer_request req;
-    const tr_bool haveMessages = EVBUFFER_LENGTH( msgs->outMessages ) != 0;
+    const tr_bool haveMessages = evbuffer_get_length( msgs->outMessages ) != 0;
     const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
 
@@ -1809 +1795 @@
     if( haveMessages && !msgs->outMessagesBatchedAt ) /* fresh batch */
     {
-        dbgmsg( msgs, "started an outMessages batch (length is %zu)", EVBUFFER_LENGTH( msgs->outMessages ) );
+        dbgmsg( msgs, "started an outMessages batch (length is %zu)", evbuffer_get_length( msgs->outMessages ) );
         msgs->outMessagesBatchedAt = now;
     }
     else if( haveMessages && ( ( now - msgs->outMessagesBatchedAt ) >= msgs->outMessagesBatchPeriod ) )
     {
-        const size_t len = EVBUFFER_LENGTH( msgs->outMessages );
+        const size_t len = evbuffer_get_length( msgs->outMessages );
         /* flush the protocol messages */
         dbgmsg( msgs, "flushing outMessages... to %p (length is %zu)", msgs->peer->io, len );
@@ -1841 +1827 @@
             int payloadLen;
             char * payload;
-            tr_peerIo  * io  = msgs->peer->io;
             struct evbuffer * out = msgs->outMessages;
 
@@ -1853 +1838 @@
 
             /* write it out as a LTEP message to our outMessages buffer */
-            tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + payloadLen + dataLen );
-            tr_peerIoWriteUint8 ( io, out, BT_LTEP );
-            tr_peerIoWriteUint8 ( io, out, msgs->ut_metadata_id );
-            tr_peerIoWriteBytes ( io, out, payload, payloadLen );
-            tr_peerIoWriteBytes ( io, out, data, dataLen );
+            evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + payloadLen + dataLen );
+            evbuffer_add_uint8 ( out, BT_LTEP );
+            evbuffer_add_uint8 ( out, msgs->ut_metadata_id );
+            evbuffer_add       ( out, payload, payloadLen );
+            evbuffer_add       ( out, data, dataLen );
             pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
             dbgOutMessageLen( msgs );
@@ -1872 +1857 @@
             int payloadLen;
             char * payload;
-            tr_peerIo  * io  = msgs->peer->io;
             struct evbuffer * out = msgs->outMessages;
 
@@ -1883 +1867 @@
 
             /* write it out as a LTEP message to our outMessages buffer */
-            tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + payloadLen );
-            tr_peerIoWriteUint8 ( io, out, BT_LTEP );
-            tr_peerIoWriteUint8 ( io, out, msgs->ut_metadata_id );
-            tr_peerIoWriteBytes ( io, out, payload, payloadLen );
+            evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + payloadLen );
+            evbuffer_add_uint8 ( out, BT_LTEP );
+            evbuffer_add_uint8 ( out, msgs->ut_metadata_id );
+            evbuffer_add       ( out, payload, payloadLen );
             pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
             dbgOutMessageLen( msgs );
@@ -1906 +1890 @@
             && tr_cpPieceIsComplete( &msgs->torrent->completion, req.index ) )
         {
-            /* FIXME(libevent2) use evbuffer_reserve_space() + evbuffer_commit_space() */
             int err;
             const uint32_t msglen = 4 + 1 + 4 + 4 + req.length;
             struct evbuffer * out;
-            tr_peerIo * io = msgs->peer->io;
+            struct evbuffer_iovec iovec[1];
 
             out = evbuffer_new( );
             evbuffer_expand( out, msglen );
 
-            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 );
-
-            err = tr_cacheReadBlock( getSession(msgs)->cache, msgs->torrent, req.index, req.offset, req.length, EVBUFFER_DATA(out)+EVBUFFER_LENGTH(out) );
+            evbuffer_add_uint32( out, sizeof( uint8_t ) + 2 * sizeof( uint32_t ) + req.length );
+            evbuffer_add_uint8 ( out, BT_PIECE );
+            evbuffer_add_uint32( out, req.index );
+            evbuffer_add_uint32( out, req.offset );
+
+            evbuffer_reserve_space( out, req.length, iovec, 1 );
+            err = tr_cacheReadBlock( getSession(msgs)->cache, msgs->torrent, req.index, req.offset, req.length, iovec[0].iov_base );
+            iovec[0].iov_len = req.length;
+            evbuffer_commit_space( out, iovec, 1 );
 
             /* check the piece if it needs checking... */
@@ -1934 +1920 @@
             else
             {
+                const size_t n = evbuffer_get_length( out );
                 dbgmsg( msgs, "sending block %u:%u->%u", req.index, req.offset, req.length );
-                EVBUFFER_LENGTH(out) += req.length;
-                assert( EVBUFFER_LENGTH( out ) == msglen );
-                tr_peerIoWriteBuf( io, out, TRUE );
-                bytesWritten += EVBUFFER_LENGTH( out );
+                assert( n == msglen );
+                tr_peerIoWriteBuf( msgs->peer->io, out, TRUE );
+                bytesWritten += n;
                 msgs->clientSentAnythingAt = now;
                 tr_historyAdd( msgs->peer->blocksSentToPeer, tr_time( ), 1 );
@@ -1969 +1955 @@
     {
         dbgmsg( msgs, "sending a keepalive message" );
-        tr_peerIoWriteUint32( msgs->peer->io, msgs->outMessages, 0 );
+        evbuffer_add_uint32( msgs->outMessages, 0 );
         pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
     }
@@ -2007 +1993 @@
           void       * vmsgs )
 {
-    if( what & EVBUFFER_TIMEOUT )
+    if( what & BEV_EVENT_TIMEOUT )
         dbgmsg( vmsgs, "libevent got a timeout, what=%hd", what );
-    if( what & ( EVBUFFER_EOF | EVBUFFER_ERROR ) )
+    if( what & ( BEV_EVENT_EOF | BEV_EVENT_ERROR ) )
         dbgmsg( vmsgs, "libevent got an error! what=%hd, errno=%d (%s)",
                what, errno, tr_strerror( errno ) );
@@ -2054 +2040 @@
     }
 
-    tr_peerIoWriteUint32( msgs->peer->io, out,
-                          sizeof( uint8_t ) + field->byteCount );
-    tr_peerIoWriteUint8 ( msgs->peer->io, out, BT_BITFIELD );
-    /* FIXME(libevent2): use evbuffer_add_reference() */
-    tr_peerIoWriteBytes ( msgs->peer->io, out, field->bits, field->byteCount );
+    evbuffer_add_uint32( out, sizeof( uint8_t ) + field->byteCount );
+    evbuffer_add_uint8 ( out, BT_BITFIELD );
+    evbuffer_add       ( out, field->bits, field->byteCount );
     dbgmsg( msgs, "sending bitfield... outMessage size is now %zu",
-            EVBUFFER_LENGTH( out ) );
+            evbuffer_get_length( out ) );
     pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
 
@@ -2200 +2184 @@
             int bencLen;
             uint8_t * tmp, *walk;
-            tr_peerIo       * io  = msgs->peer->io;
             struct evbuffer * out = msgs->outMessages;
 
@@ -2289 +2272 @@
             /* write the pex message */
             benc = tr_bencToStr( &val, TR_FMT_BENC, &bencLen );
-            tr_peerIoWriteUint32( io, out, 2 * sizeof( uint8_t ) + bencLen );
-            tr_peerIoWriteUint8 ( io, out, BT_LTEP );
-            tr_peerIoWriteUint8 ( io, out, msgs->ut_pex_id );
-            tr_peerIoWriteBytes ( io, out, benc, bencLen );
+            evbuffer_add_uint32( out, 2 * sizeof( uint8_t ) + bencLen );
+            evbuffer_add_uint8 ( out, BT_LTEP );
+            evbuffer_add_uint8 ( out, msgs->ut_pex_id );
+            evbuffer_add       ( out, benc, bencLen );
             pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
-            dbgmsg( msgs, "sending a pex message; outMessage size is now %zu", EVBUFFER_LENGTH( out ) );
+            dbgmsg( msgs, "sending a pex message; outMessage size is now %zu", evbuffer_get_length( out ) );
             dbgOutMessageLen( msgs );
 
@@ -2320 +2303 @@
     sendPex( msgs );
 
-    tr_timerAdd( &msgs->pexTimer, PEX_INTERVAL_SECS, 0 );
+    tr_timerAdd( msgs->pexTimer, PEX_INTERVAL_SECS, 0 );
 }
 
@@ -2352 +2335 @@
     m->outMessagesBatchPeriod = LOW_PRIORITY_INTERVAL_SECS;
     m->incoming.block = evbuffer_new( );
-    evtimer_set( &m->pexTimer, pexPulse, m );
-    tr_timerAdd( &m->pexTimer, PEX_INTERVAL_SECS, 0 );
+    m->pexTimer = evtimer_new( NULL, pexPulse, m );
     peer->msgs = m;
+    tr_timerAdd( m->pexTimer, PEX_INTERVAL_SECS, 0 );
 
     if( tr_peerIoSupportsLTEP( peer->io ) )
@@ -2381 +2364 @@
     if( msgs )
     {
-        evtimer_del( &msgs->pexTimer );
+        event_free( msgs->pexTimer );
 
         evbuffer_free( msgs->incoming.block );

trunk/libtransmission/rpc-server.c

@@ -31 +31 @@
 #include "bencode.h"
 #include "crypto.h"
+#include "fdlimit.h"
 #include "list.h"
 #include "net.h"
@@ -156 +157 @@
 static void
 extract_parts_from_multipart( const struct evkeyvalq * headers,
-                              const struct evbuffer * body,
+                              struct evbuffer * body,
                               tr_ptrArray * setme_parts )
 {
     const char * content_type = evhttp_find_header( headers, "Content-Type" );
     const char * in = (const char*) EVBUFFER_DATA( body );
-    size_t inlen = EVBUFFER_LENGTH( body );
+    size_t inlen = evbuffer_get_length( body );
 
     const char * boundary_key = "boundary=";
@@ -278 +279 @@
                 tr_rpc_request_exec_json( server->session,
                                           EVBUFFER_DATA( json ),
-                                          EVBUFFER_LENGTH( json ),
+                                          evbuffer_get_length( json ),
                                           NULL, NULL );
                 evbuffer_free( json );
@@ -328 +329 @@
 
 static void
-add_response( struct evhttp_request * req,
-              struct tr_rpc_server *  server,
-              struct evbuffer *       out,
-              const void *            content,
-              size_t                  content_len )
+add_response( struct evhttp_request * req, struct tr_rpc_server * server,
+              struct evbuffer * out, struct evbuffer * content )
 {
 #ifndef HAVE_ZLIB
-    evbuffer_add( out, content, content_len );
+    evbuffer_add_buffer( out, content );
 #else
     const char * key = "Accept-Encoding";
@@ -343 +341 @@
     if( !do_compress )
     {
-        evbuffer_add( out, content, content_len );
+        evbuffer_add_buffer( out, content );
     }
     else
     {
         int state;
-
-        /* FIXME(libevent2): this won't compile under libevent2.
-           but we can use evbuffer_reserve_space() + evbuffer_commit_space() instead */
+        struct evbuffer_iovec iovec[1];
+        void * content_ptr = evbuffer_pullup( content, -1 );
+        const size_t content_len = evbuffer_get_length( content );
 
         if( !server->isStreamInitialized )
@@ -371 +369 @@
         }
 
-        server->stream.next_in = (Bytef*) content;
+        server->stream.next_in = content_ptr;
         server->stream.avail_in = content_len;
 
@@ -377 +375 @@
          * we won't use the deflated data if it's longer than the raw data,
          * so it's okay to let deflate() run out of output buffer space */
-        evbuffer_expand( out, content_len );
-        server->stream.next_out = EVBUFFER_DATA( out );
-        server->stream.avail_out = content_len;
-
+        evbuffer_reserve_space( out, content_len, iovec, 1 );
+        server->stream.next_out = iovec[0].iov_base;
+        server->stream.avail_out = iovec[0].iov_len;
         state = deflate( &server->stream, Z_FINISH );
 
         if( state == Z_STREAM_END )
         {
-            EVBUFFER_LENGTH( out ) = content_len - server->stream.avail_out;
+            iovec[0].iov_len -= server->stream.avail_out;
 
 #if 0
             fprintf( stderr, "compressed response is %.2f of original (raw==%zu bytes; compressed==%zu)\n",
-                             (double)EVBUFFER_LENGTH(out)/content_len,
-                             content_len, EVBUFFER_LENGTH(out) );
+                             (double)evbuffer_get_length(out)/content_len,
+                             content_len, evbuffer_get_length(out) );
 #endif
             evhttp_add_header( req->output_headers,
@@ -397 +394 @@
         else
         {
-            evbuffer_drain( out, EVBUFFER_LENGTH( out ) );
-            evbuffer_add( out, content, content_len );
-        }
-
+            memcpy( iovec[0].iov_base, content_ptr, content_len );
+            iovec[0].iov_len = content_len;
+        }
+
+        evbuffer_commit_space( out, iovec, 1 );
         deflateReset( &server->stream );
     }
@@ -429 +427 @@
     else
     {
-        size_t content_len;
-        uint8_t * content;
+        void * file;
+        size_t file_len;
+        struct evbuffer * content = evbuffer_new( );
         const int error = errno;
 
         errno = 0;
-        content_len = 0;
-        content = tr_loadFile( filename, &content_len );
+        file_len = 0;
+        file = tr_loadFile( filename, &file_len );
+        content = evbuffer_new( );
+        evbuffer_add_reference( content, file, file_len, evbuffer_ref_cleanup_tr_free, file );
 
         if( errno )
@@ -453 +454 @@
             add_time_header( req->output_headers, "Date", now );
             add_time_header( req->output_headers, "Expires", now+(24*60*60) );
-            add_response( req, server, out, content, content_len );
+            add_response( req, server, out, content );
             evhttp_send_reply( req, HTTP_OK, "OK", out );
 
             evbuffer_free( out );
-            tr_free( content );
-        }
+        }
+
+        evbuffer_free( content );
     }
 }
@@ -513 +515 @@
 };
 
-/* FIXME(libevent2): make "response" an evbuffer and remove response_len */
 static void
 rpc_response_func( tr_session      * session UNUSED,
-                   const char      * response,
-                   size_t            response_len,
+                   struct evbuffer * response,
                    void            * user_data )
 {
@@ -523 +523 @@
     struct evbuffer * buf = evbuffer_new( );
 
-    add_response( data->req, data->server, buf, response, response_len );
+    add_response( data->req, data->server, buf, response );
     evhttp_add_header( data->req->output_headers,
                            "Content-Type", "application/json; charset=UTF-8" );
@@ -552 +552 @@
         tr_rpc_request_exec_json( server->session,
                                   EVBUFFER_DATA( req->input_buffer ),
-                                  EVBUFFER_LENGTH( req->input_buffer ),
+                                  evbuffer_get_length( req->input_buffer ),
                                   rpc_response_func, data );
     }

trunk/libtransmission/rpcimpl.c

@@ -103 +103 @@
 
     tr_bencToBuf( data->response, TR_FMT_JSON_LEAN, buf );
-    (*data->callback)( data->session, (const char*)EVBUFFER_DATA(buf),
-                       EVBUFFER_LENGTH(buf), data->callback_user_data );
+    (*data->callback)( data->session, buf, data->callback_user_data );
 
     evbuffer_free( buf );
@@ -1648 +1647 @@
 
 static void
-noop_response_callback( tr_session * session UNUSED,
-                        const char * response UNUSED,
-                        size_t       response_len UNUSED,
-                        void       * user_data UNUSED )
+noop_response_callback( tr_session       * session UNUSED,
+                        struct evbuffer  * response UNUSED,
+                        void             * user_data UNUSED )
 {
 }
@@ -1694 +1692 @@
             tr_bencDictAddInt( &response, "tag", tag );
         tr_bencToBuf( &response, TR_FMT_JSON_LEAN, buf );
-        (*callback)( session, (const char*)EVBUFFER_DATA(buf),
-                     EVBUFFER_LENGTH( buf ), callback_user_data );
+        (*callback)( session, buf, callback_user_data );
 
         evbuffer_free( buf );
@@ -1716 +1713 @@
             tr_bencDictAddInt( &response, "tag", tag );
         tr_bencToBuf( &response, TR_FMT_JSON_LEAN, buf );
-        (*callback)( session, (const char*)EVBUFFER_DATA(buf),
-                     EVBUFFER_LENGTH(buf), callback_user_data );
+        (*callback)( session, buf, callback_user_data );
 
         evbuffer_free( buf );

trunk/libtransmission/rpcimpl.h

@@ -23 +23 @@
 
 struct tr_benc;
+struct evbuffer;
 
 /* FIXME(libevent2): make "response" an evbuffer and remove response_len */
 typedef void( *tr_rpc_response_func )( tr_session      * session,
-                                       const char      * response,
-                                       size_t            response_len,
+                                       struct evbuffer * response,
                                        void            * user_data );
 /* http://www.json.org/ */

trunk/libtransmission/torrent-magnet.c

@@ -12 +12 @@
 
 #include <assert.h>
-#include <event.h> /* struct evbuffer */
 #include <stdio.h> /* remove() */
+
+#include <event2/buffer.h>
 
 #include "transmission.h"
@@ -371 +372 @@
 {
     int i;
-    char * ret;
     const char * name;
     struct evbuffer * s;
@@ -391 +391 @@
     }
 
-    ret = tr_strndup( EVBUFFER_DATA( s ), EVBUFFER_LENGTH( s ) );
-    evbuffer_free( s );
-    return ret;
-}
+    return evbuffer_free_to_str( s );
+}

trunk/libtransmission/tr-dht.c

@@ -44 +44 @@
 
 /* third party */
-#include <event.h>
+#include <event2/event.h>
 #include <dht/dht.h>
 
@@ -61 +61 @@
 
 static int dht_socket = -1, dht6_socket = -1;
-static struct event dht_event, dht6_event;
+static struct event * dht_event = NULL;
+static struct event * dht6_event = NULL;
 static tr_port dht_port;
 static unsigned char myid[20];
@@ -400 +401 @@
     tr_threadNew( dht_bootstrap, cl );
 
-    event_set( &dht_event, dht_socket, EV_READ, event_callback, NULL );
-    tr_timerAdd( &dht_event, 0, tr_cryptoWeakRandInt( 1000000 ) );
+    dht_event = event_new( NULL, dht_socket, EV_READ, event_callback, NULL );
+    tr_timerAdd( dht_event, 0, tr_cryptoWeakRandInt( 1000000 ) );
 
     if( dht6_socket >= 0 )
     {
-        event_set( &dht6_event, dht6_socket, EV_READ, event_callback, NULL );
-        tr_timerAdd( &dht6_event, 0, tr_cryptoWeakRandInt( 1000000 ) );
+        dht6_event = event_new( NULL, dht6_socket, EV_READ, event_callback, NULL );
+        tr_timerAdd( dht6_event, 0, tr_cryptoWeakRandInt( 1000000 ) );
     }
 
@@ -436 +437 @@
     tr_ndbg( "DHT", "Uninitializing DHT" );
 
-    event_del( &dht_event );
-
-    if( dht6_socket >= 0 )
-        event_del( &dht6_event );
+    event_free( dht_event );
+    dht_event = NULL;
+
+    if( dht6_event ) {
+        event_free( dht6_event );
+        dht6_event = NULL;
+    }
 
     /* Since we only save known good nodes, avoid erasing older data if we
@@ -692 +696 @@
 event_callback(int s, short type, void *ignore UNUSED )
 {
-    struct event *event = (s == dht_socket) ? &dht_event : &dht6_event;
+    struct event *event = (s == dht_socket) ? dht_event : dht6_event;
     time_t tosleep;
     static int count = 0;

trunk/libtransmission/tr-lpd.c

@@ -43 +43 @@
 
 /* third party */
-#include <event.h>
-#include <evutil.h>
+#include <event2/event.h>
+#include <event2/util.h>
 
 /* libT */
@@ -71 +71 @@
 static int lpd_socket; /**<separate multicast receive socket */
 static int lpd_socket2; /**<and multicast send socket */
-static struct event lpd_event;
+static struct event * lpd_event = NULL;
 static tr_port lpd_port;
 
@@ -339 +339 @@
      * any announcement received during the initial interval will be discarded. */
 
-    event_set( &lpd_event, lpd_socket, EV_READ | EV_PERSIST, event_callback, NULL );
-    event_add( &lpd_event, NULL );
+    lpd_event = event_new( NULL, lpd_socket, EV_READ | EV_PERSIST, event_callback, NULL );
+    event_add( lpd_event, NULL );
 
     tr_ndbg( "LPD", "Local Peer Discovery initialised" );
@@ -368 +368 @@
     tr_ndbg( "LPD", "Uninitialising Local Peer Discovery" );
 
-    event_del( &lpd_event );
+    event_free( lpd_event );
+    lpd_event = NULL;
 
     /* just shut down, we won't remember any former nodes */

trunk/libtransmission/trevent.c

@@ -127 +127 @@
 #include <unistd.h>
 
-#include <event.h>
-
 #include "transmission.h"
 #include "platform.h"

trunk/libtransmission/utils.c

@@ -43 +43 @@
 #include <unistd.h> /* stat(), getcwd(), getpagesize() */
 
-#include "event.h"
+#include <event2/buffer.h>
+#include <event2/event.h>
 
 #ifdef WIN32
@@ -248 +249 @@
         evbuffer_add_printf( buf, " (%s:%d)\n", base, line );
         /* FIXME(libevent2) ifdef this out for nonwindows platforms */
-        OutputDebugString( EVBUFFER_DATA( buf ) );
+        OutputDebugString( evbuffer_pullup( buf, -1 ) );
         if(fp) /* FIXME(libevent2) tr_getLog() should return an fd, then use evbuffer_write() here ) */
-            (void) fwrite( EVBUFFER_DATA( buf ), 1, EVBUFFER_LENGTH( buf ), fp );
+            (void) fwrite( evbuffer_pullup( buf, -1 ), 1, evbuffer_get_length( buf ), fp );
 
         tr_free( base );
@@ -693 +694 @@
 
 char*
+evbuffer_free_to_str( struct evbuffer * buf )
+{
+    const size_t n = evbuffer_get_length( buf );
+    char * ret = tr_new( char, n + 1 );
+    evbuffer_copyout( buf, ret, n );
+    evbuffer_free( buf );
+    ret[n] = '\0';
+    return ret;
+}
+
+char*
 tr_strdup( const void * in )
 {
@@ -1250 +1262 @@
 strip_non_utf8( const char * in, size_t inlen )
 {
-    char * ret;
     const char * end;
     const char zero = '\0';
@@ -1267 +1278 @@
     evbuffer_add( buf, in, inlen );
     evbuffer_add( buf, &zero, 1 );
-    ret = tr_memdup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
-    evbuffer_free( buf );
-    return ret;
+    return evbuffer_free_to_str( buf );
 }
 

trunk/libtransmission/utils.h

@@ -304 +304 @@
 void tr_free( void * p );
 
+static inline
+void evbuffer_ref_cleanup_tr_free( const void * data UNUSED, size_t datalen UNUSED, void * extra )
+{
+    tr_free( extra );
+}
+
 /**
  * @brief make a newly-allocated copy of a chunk of memory
@@ -337 +343 @@
  */
 char* tr_strdup( const void * in );
+
+
+struct evbuffer;
+
+char* evbuffer_free_to_str( struct evbuffer * buf );
 
 /** @brief similar to bsearch() but returns the index of the lower bound */

trunk/libtransmission/web.c

@@ -18 +18 @@
 
 #include <curl/curl.h>
-#include <event.h>
+
+#include <event2/buffer.h>
 
 #include "transmission.h"
@@ -193 +194 @@
         task->done_func( task->session,
                          task->code,
-                         EVBUFFER_DATA( task->response ),
-                         EVBUFFER_LENGTH( task->response ),
+                         evbuffer_pullup( task->response, -1 ),
+                         evbuffer_get_length( task->response ),
                          task->done_func_user_data );
 
@@ -351 +352 @@
                 curl_multi_remove_handle( multi, e );
                 curl_easy_cleanup( e );
-/*fprintf( stderr, "removing a completed task.. taskCount is now %d (response code: %d, response len: %d)\n", taskCount, (int)task->code, (int)EVBUFFER_LENGTH(task->response) );*/
+/*fprintf( stderr, "removing a completed task.. taskCount is now %d (response code: %d, response len: %d)\n", taskCount, (int)task->code, (int)evbuffer_get_length(task->response) );*/
                 tr_runInEventThread( task->session, task_finish_func, task );
                 --taskCount;

trunk/libtransmission/webseed.c

@@ -13 +13 @@
 #include <string.h> /* strlen */
 
-#include <event.h>
+#include <event2/buffer.h>
 
 #include "transmission.h"
@@ -98 +98 @@
          const tr_file * file )
 {
-    char *            ret;
     struct evbuffer * out = evbuffer_new( );
     const char *      url = w->url;
@@ -109 +108 @@
         tr_http_escape( out, file->name, strlen(file->name), FALSE );
 
-    ret = tr_strndup( EVBUFFER_DATA( out ), EVBUFFER_LENGTH( out ) );
-    evbuffer_free( out );
-    return ret;
+    return evbuffer_free_to_str( out );
 }
 
@@ -142 +139 @@
         }
 
-        if( EVBUFFER_LENGTH( w->content ) < w->byteCount )
+        if( evbuffer_get_length( w->content ) < w->byteCount )
             requestNextChunk( w );
         else {
-            tr_ioWrite( tor, w->pieceIndex, w->pieceOffset, w->byteCount, EVBUFFER_DATA(w->content) );
-            evbuffer_drain( w->content, EVBUFFER_LENGTH( w->content ) );
+            tr_ioWrite( tor, w->pieceIndex, w->pieceOffset, w->byteCount, evbuffer_pullup( w->content, -1 ) );
+            evbuffer_drain( w->content, evbuffer_get_length( w->content ) );
             w->busy = 0;
             if( w->dead )
@@ -166 +163 @@
     {
         const tr_info * inf = tr_torrentInfo( tor );
-        const uint32_t have = EVBUFFER_LENGTH( w->content );
+        const uint32_t have = evbuffer_get_length( w->content );
         const uint32_t left = w->byteCount - have;
         const uint32_t pieceOffset = w->pieceOffset + have;
@@ -207 +204 @@
         w->pieceOffset = pieceOffset;
         w->byteCount = byteCount;
-        evbuffer_drain( w->content, EVBUFFER_LENGTH( w->content ) );
+        evbuffer_drain( w->content, evbuffer_get_length( w->content ) );
         requestNextChunk( w );
         ret = TR_ADDREQ_OK;

trunk/utils/edit.c

@@ -13 +13 @@
 #include <stdio.h>
 
-#include <event.h> /* evbuffer */
+#include <event2/buffer.h>
 
 #include <libtransmission/transmission.h>
@@ -157 +157 @@
     }
 
-    walk = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
-    evbuffer_free( buf );
-    return walk;
+    return evbuffer_free_to_str( buf );
 }
 

trunk/utils/show.c

@@ -17 +17 @@
 #include <curl/curl.h>
 
-#include <event.h> /* struct evbuffer */
+#include <event2/buffer.h>
 
 #include <libtransmission/transmission.h>
@@ -222 +222 @@
                 tr_benc * files;
                 tr_bool matched = FALSE;
-                const char * begin = (const char*) EVBUFFER_DATA( buf );
-                const char * end = begin + EVBUFFER_LENGTH( buf );
+                const char * begin = (const char*) evbuffer_pullup( buf, -1 );
+                const char * end = begin + evbuffer_get_length( buf );
 
                 if( !tr_bencParse( begin, end, &top, NULL ) )