mirror/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission synced 2025-03-16 08:49:47 +00:00
Code Issues Releases Wiki Activity

(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

Browse source
This commit is contained in:
Charles Kerr 2010-12-20 02:07:51 +00:00
parent 3a6cf6afc9
commit 345b14adbc
23 changed files with 444 additions and 520 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
configure.ac
View file

@ -40,7 +40,7 @@ AM_CONDITIONAL(TR_UNSTABLE, test "x$supported_build" = "xno")
##
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
AC_SUBST(OPENSSL_MINIMUM)
@ -85,7 +85,7 @@ AC_PROG_CXX
AC_C_INLINE
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
AC_MSG_CHECKING([gcc version])
@ -122,6 +122,7 @@ AC_SEARCH_LIBS([socket], [socket net])
AC_SEARCH_LIBS([gethostbyname], [nsl bind])
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
AC_SYS_LARGEFILE
@ -203,30 +204,6 @@ AC_CHECK_LIB([rt],
[libevent_extra_libs=""])
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
dnl dht

20
gtk/tr-core.c
View file

@ -33,6 +33,8 @@
#include <dbus/dbus-glib.h>
#endif
#include <event2/buffer.h>
#include <libtransmission/transmission.h>
#include <libtransmission/bencode.h>
#include <libtransmission/rpcimpl.h>
@ -1597,9 +1599,9 @@ readResponseIdle( void * vresponse )
{
tr_benc top;
int64_t intVal;
GByteArray * response = vresponse;
struct evbuffer * response = vresponse;
tr_jsonParse( NULL, response->data, response->len, &top, NULL );
tr_jsonParse( NULL, evbuffer_pullup( response, -1 ), evbuffer_get_length( response ), &top, NULL );
if( tr_bencDictFindInt( &top, "tag", &intVal ) )
{
@ -1613,22 +1615,18 @@ readResponseIdle( void * vresponse )
}
tr_bencFree( &top );
g_byte_array_free( response, TRUE );
evbuffer_free( response );
return FALSE;
}
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 );
}
static void

17
libtransmission/announcer.c
View file

@ -13,8 +13,9 @@
#include <assert.h>
#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"
#include "announcer.h"
@ -263,8 +264,7 @@ tr_announcerInit( tr_session * session )
a->session = session;
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 );
session->announcer = a;
@ -279,8 +279,7 @@ tr_announcerClose( tr_session * session )
flushCloseMessages( announcer );
evtimer_del( announcer->upkeepTimer );
tr_free( announcer->upkeepTimer );
event_free( announcer->upkeepTimer );
announcer->upkeepTimer = NULL;
tr_ptrArrayDestruct( &announcer->stops, NULL );
@ -724,7 +723,6 @@ createAnnounceURL( const tr_announcer * announcer,
const tr_tracker_item * tracker = tier->currentTracker;
const char * ann = tracker->announce;
struct evbuffer * buf = evbuffer_new( );
char * ret;
const char * str;
const unsigned char * ipv6;
@ -784,10 +782,7 @@ createAnnounceURL( const tr_announcer * announcer,
tr_http_escape( buf, ipv6_readable, -1, TRUE );
}
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 );
}

4
libtransmission/bencode-test.c
View file

@ -3,7 +3,7 @@
#include <stdio.h>
#include <string.h>
#include <event.h>
#include <event2/buffer.h>
#include "transmission.h"
#include "bencode.h"
@ -325,7 +325,7 @@ testJSONSnippet( const char * benc_str,
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
fprintf( stderr, "benc: %s\n", benc_str );

52
libtransmission/bencode.c
View file

@ -29,7 +29,7 @@
#include <locale.h>
#include <unistd.h> /* stat() */
#include <event.h> /* struct evbuffer */
#include <event2/buffer.h>
#include "ConvertUTF.h"
@ -1586,7 +1586,7 @@ tr_bencMergeDicts( tr_benc * target, const tr_benc * source )
void
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 */
switch( mode )
@ -1602,7 +1602,7 @@ tr_bencToBuf( const tr_benc * top, tr_fmt_mode mode, struct evbuffer * buf )
data.out = buf;
data.parents = NULL;
bencWalk( top, &jsonWalkFuncs, &data );
if( EVBUFFER_LENGTH( buf ) )
if( evbuffer_get_length( buf ) )
evbuffer_add_printf( buf, "\n" );
break;
}
@ -1614,11 +1614,12 @@ tr_bencToStr( const tr_benc * top, tr_fmt_mode mode, int * len )
{
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;
}
@ -1666,10 +1667,34 @@ tr_bencToFile( const tr_benc * top, tr_fmt_mode mode, const char * filename )
tr_set_file_for_single_pass( fd );
if( fd >= 0 )
{
int len;
char * str = tr_bencToStr( top, mode, &len );
int nleft;
if( write( fd, str, len ) == (ssize_t)len )
/* 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;
const tr_bool already_exists = !stat( filename, &sb ) && S_ISREG( sb.st_mode );
@ -1697,15 +1722,6 @@ tr_bencToFile( const tr_benc * top, tr_fmt_mode mode, const char * filename )
unlink( tmp );
}
}
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
{

143
libtransmission/handshake.c
View file

@ -17,7 +17,7 @@
#include <string.h>
#include <stdio.h>
#include <event.h>
#include <event2/event.h>
#include "transmission.h"
#include "bencode.h"
@ -120,7 +120,7 @@ struct tr_handshake
uint8_t myReq1[SHA_DIGEST_LENGTH];
handshakeDoneCB doneCB;
void * doneUserData;
struct event timeout_timer;
struct event * timeout_timer;
};
/**
@ -265,9 +265,9 @@ parseHandshake( tr_handshake * handshake,
uint8_t peer_id[PEER_ID_LEN];
dbgmsg( handshake, "payload: need %d, got %zu",
(int)HANDSHAKE_SIZE, EVBUFFER_LENGTH( inbuf ) );
(int)HANDSHAKE_SIZE, evbuffer_get_length( inbuf ) );
if( EVBUFFER_LENGTH( inbuf ) < HANDSHAKE_SIZE )
if( evbuffer_get_length( inbuf ) < HANDSHAKE_SIZE )
return READ_LATER;
/* confirm the protocol */
@ -346,7 +346,7 @@ sendYa( tr_handshake * handshake )
/* send it */
setReadState( handshake, AWAITING_YB );
tr_peerIoWrite( handshake->io, outbuf, walk - outbuf, FALSE );
tr_peerIoWriteBytes( handshake->io, outbuf, walk - outbuf, FALSE );
}
static uint32_t
@ -401,8 +401,7 @@ getCryptoSelect( const tr_handshake * handshake,
}
static int
readYb( tr_handshake * handshake,
struct evbuffer * inbuf )
readYb( tr_handshake * handshake, struct evbuffer * inbuf )
{
int isEncrypted;
const uint8_t * secret;
@ -410,14 +409,14 @@ readYb( tr_handshake * handshake,
struct evbuffer * outbuf;
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;
}
@ -475,10 +474,9 @@ readYb( tr_handshake * handshake,
tr_cryptoEncryptInit( handshake->crypto );
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 );
}
/* ENCRYPT len(IA)), ENCRYPT(IA) */
@ -486,8 +484,8 @@ readYb( tr_handshake * handshake,
uint8_t msg[HANDSHAKE_SIZE];
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;
}
@ -515,13 +513,13 @@ readVC( tr_handshake * handshake,
* it would be nice to make this cleaner. */
for( ; ; )
{
if( EVBUFFER_LENGTH( inbuf ) < VC_LENGTH )
if( evbuffer_get_length( inbuf ) < VC_LENGTH )
{
dbgmsg( handshake, "not enough bytes... returning read_more" );
return READ_LATER;
}
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 );
if( !memcmp( tmp, key, key_len ) )
@ -544,7 +542,7 @@ readCryptoSelect( tr_handshake * handshake,
uint16_t pad_d_len;
const size_t needlen = sizeof( uint32_t ) + sizeof( uint16_t );
if( EVBUFFER_LENGTH( inbuf ) < needlen )
if( evbuffer_get_length( inbuf ) < needlen )
return READ_LATER;
tr_peerIoReadUint32( handshake->io, inbuf, &crypto_select );
@ -580,8 +578,8 @@ readPadD( tr_handshake * handshake,
uint8_t * tmp;
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;
tmp = tr_new( uint8_t, needlen );
@ -610,15 +608,15 @@ readHandshake( tr_handshake * handshake,
uint8_t hash[SHA_DIGEST_LENGTH];
dbgmsg( handshake, "payload: need %d, got %zu",
(int)INCOMING_HANDSHAKE_LEN, EVBUFFER_LENGTH( inbuf ) );
(int)INCOMING_HANDSHAKE_LEN, evbuffer_get_length( inbuf ) );
if( EVBUFFER_LENGTH( inbuf ) < INCOMING_HANDSHAKE_LEN )
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 */
{
@ -712,7 +710,7 @@ readHandshake( tr_handshake * handshake,
{
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;
}
@ -730,7 +728,7 @@ readPeerId( tr_handshake * handshake,
const uint8_t * tor_peer_id;
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;
/* peer id */
@ -759,8 +757,8 @@ readYa( tr_handshake * handshake,
int len;
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;
/* read the incoming peer's public key */
@ -780,49 +778,30 @@ readYa( tr_handshake * handshake,
walk += len;
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 )
readPadA( tr_handshake * handshake, struct evbuffer * inbuf )
{
uint8_t * pch;
/* resynchronizing on HASH('req1',S) */
struct evbuffer_ptr ptr = evbuffer_search( inbuf, (const char*)handshake->myReq1, SHA_DIGEST_LENGTH, NULL );
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 )
if( ptr.pos != -1 ) /* match */
{
dbgmsg( handshake, "no luck so far.. draining %zu bytes",
EVBUFFER_LENGTH( inbuf ) );
evbuffer_drain( inbuf, EVBUFFER_LENGTH( inbuf ) );
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 );
evbuffer_drain( inbuf, ptr.pos );
dbgmsg( handshake, "found it... looking setting to awaiting_crypto_provide" );
setState( handshake, AWAITING_CRYPTO_PROVIDE );
return READ_NOW;
}
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;
}
}
static int
@ -847,7 +826,7 @@ readCryptoProvide( tr_handshake * handshake,
+ sizeof( padc_len );
tr_torrent * tor = NULL;
if( EVBUFFER_LENGTH( inbuf ) < needlen )
if( evbuffer_get_length( inbuf ) < needlen )
return READ_LATER;
/* TODO: confirm they sent HASH('req1',S) here? */
@ -905,7 +884,7 @@ readPadC( tr_handshake * handshake,
uint16_t ia_len;
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;
evbuffer_drain( inbuf, handshake->pad_c_len );
@ -926,8 +905,8 @@ readIA( tr_handshake * handshake,
uint32_t crypto_select;
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;
/**
@ -942,7 +921,7 @@ readIA( tr_handshake * handshake,
{
uint8_t vc[VC_LENGTH];
memset( vc, 0, VC_LENGTH );
tr_peerIoWriteBytes( handshake->io, outbuf, vc, VC_LENGTH );
evbuffer_add( outbuf, vc, VC_LENGTH );
}
/* send crypto_select */
@ -950,7 +929,7 @@ readIA( tr_handshake * handshake,
if( crypto_select )
{
dbgmsg( handshake, "selecting crypto mode '%d'", (int)crypto_select );
tr_peerIoWriteUint32( handshake->io, outbuf, crypto_select );
evbuffer_add_uint32( outbuf, crypto_select );
}
else
{
@ -965,7 +944,7 @@ readIA( tr_handshake * handshake,
* standard practice at this time is for it to be zero-length */
{
const uint16_t len = 0;
tr_peerIoWriteUint16( handshake->io, outbuf, len );
evbuffer_add_uint16( outbuf, len );
}
/* maybe de-encrypt our connection */
@ -981,7 +960,7 @@ readIA( tr_handshake * handshake,
uint8_t msg[HANDSHAKE_SIZE];
buildHandshakeMessage( handshake, msg );
tr_peerIoWriteBytes( handshake->io, outbuf, msg, sizeof( msg ) );
evbuffer_add( outbuf, msg, sizeof( msg ) );
handshake->haveSentBitTorrentHandshake = 1;
}
@ -1002,8 +981,8 @@ readPayloadStream( tr_handshake * handshake,
const size_t needlen = HANDSHAKE_SIZE;
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;
/* parse the handshake ... */
@ -1085,11 +1064,11 @@ canRead( struct tr_peerIo * io, void * arg, size_t * piece )
if( ret != READ_NOW )
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;
}
return ret;
@ -1117,8 +1096,7 @@ tr_handshakeFree( tr_handshake * handshake )
if( handshake->io )
tr_peerIoUnref( handshake->io ); /* balanced by the ref in tr_handshakeNew */
evtimer_del( &handshake->timeout_timer );
event_free( handshake->timeout_timer );
tr_free( handshake );
}
@ -1166,7 +1144,7 @@ gotError( tr_peerIo * io UNUSED,
buildHandshakeMessage( handshake, msg );
handshake->haveSentBitTorrentHandshake = 1;
setReadState( handshake, AWAITING_HANDSHAKE );
tr_peerIoWrite( handshake->io, msg, sizeof( msg ), FALSE );
tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
}
else
{
@ -1201,9 +1179,8 @@ tr_handshakeNew( tr_peerIo * io,
handshake->doneCB = doneCB;
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 */
tr_peerIoSetIOFuncs( handshake->io, canRead, NULL, gotError, handshake );
@ -1220,7 +1197,7 @@ tr_handshakeNew( tr_peerIo * io,
handshake->haveSentBitTorrentHandshake = 1;
setReadState( handshake, AWAITING_HANDSHAKE );
tr_peerIoWrite( handshake->io, msg, sizeof( msg ), FALSE );
tr_peerIoWriteBytes( handshake->io, msg, sizeof( msg ), FALSE );
}
return handshake;

8
libtransmission/metainfo.c
View file

@ -19,7 +19,7 @@
#include <sys/stat.h>
#include <unistd.h> /* unlink, stat */
#include <event.h> /* struct evbuffer */
#include <event2/buffer.h>
#include "transmission.h"
#include "session.h"
@ -154,6 +154,7 @@ getfile( char ** setme, const char * root, tr_benc * path )
if( tr_bencIsList( path ) )
{
int i;
char * tmp;
const int n = tr_bencListSize( path );
struct evbuffer * buf = evbuffer_new( );
@ -168,9 +169,10 @@ getfile( char ** setme, const char * root, tr_benc * path )
}
}
*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;
}

226
libtransmission/peer-io.c
View file

@ -23,7 +23,8 @@
#include <arpa/inet.h> /* inet_ntoa */
#endif
#include <event.h>
#include <event2/event.h>
#include <event2/bufferevent.h>
#include "transmission.h"
#include "session.h"
@ -143,10 +144,10 @@ canReadWrapper( tr_peerIo * io )
while( !done && !err )
{
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 ) );
@ -164,7 +165,7 @@ canReadWrapper( tr_peerIo * io )
switch( ret )
{
case READ_NOW:
if( EVBUFFER_LENGTH( io->inbuf ) )
if( evbuffer_get_length( io->inbuf ) )
continue;
done = 1;
break;
@ -184,12 +185,6 @@ canReadWrapper( tr_peerIo * io )
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( );
}
assert( tr_isPeerIo( io ) );
tr_peerIoUnref( io );
}
@ -222,7 +217,7 @@ event_read_cb( int fd, short event UNUSED, void * vio )
io->hasFinishedConnecting = TRUE;
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 );
@ -248,16 +243,16 @@ event_read_cb( int fd, short event UNUSED, void * vio )
else
{
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 ) {
tr_peerIoSetEnabled( io, dir, TRUE );
return;
}
what |= EVBUFFER_ERROR;
what |= BEV_EVENT_ERROR;
}
tr_net_strerror( errstr, sizeof( errstr ), e );
@ -274,28 +269,14 @@ tr_evbuffer_write( tr_peerIo * io, int fd, size_t howmuch )
int e;
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;
}
@ -304,7 +285,7 @@ event_write_cb( int fd, short event UNUSED, void * vio )
{
int res = 0;
int e;
short what = EVBUFFER_WRITE;
short what = BEV_EVENT_WRITING;
tr_peerIo * io = vio;
size_t howmuch;
const tr_direction dir = TR_UP;
@ -318,7 +299,7 @@ event_write_cb( int fd, short event UNUSED, void * vio )
/* 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 */
if( howmuch < 1 ) {
@ -331,25 +312,25 @@ event_write_cb( int fd, short event UNUSED, void * vio )
e = EVUTIL_SOCKET_ERROR( );
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 );
didWriteWrapper( io, res );
return;
reschedule:
if( EVBUFFER_LENGTH( io->outbuf ) )
if( evbuffer_get_length( io->outbuf ) )
tr_peerIoSetEnabled( io, dir, TRUE );
return;
@ -415,13 +396,12 @@ tr_peerIoNew( tr_session * session,
io->timeCreated = tr_time( );
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;
}
@ -470,8 +450,8 @@ event_enable( tr_peerIo * io, short event )
assert( tr_amInEventThread( io->session ) );
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 )
return;
@ -479,14 +459,14 @@ event_enable( tr_peerIo * io, short event )
if( ( event & EV_READ ) && ! ( io->pendingEvents & EV_READ ) )
{
dbgmsg( io, "enabling libevent ready-to-read polling" );
event_add( &io->event_read, NULL );
event_add( io->event_read, NULL );
io->pendingEvents |= EV_READ;
}
if( ( event & EV_WRITE ) && ! ( io->pendingEvents & EV_WRITE ) )
{
dbgmsg( io, "enabling libevent ready-to-write polling" );
event_add( &io->event_write, NULL );
event_add( io->event_write, NULL );
io->pendingEvents |= EV_WRITE;
}
}
@ -497,20 +477,20 @@ event_disable( struct tr_peerIo * io, short event )
assert( tr_amInEventThread( io->session ) );
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;
}
if( ( event & EV_WRITE ) && ( io->pendingEvents & EV_WRITE ) )
{
dbgmsg( io, "disabling libevent ready-to-write polling" );
event_del( &io->event_write );
event_del( io->event_write );
io->pendingEvents &= ~EV_WRITE;
}
}
@ -548,6 +528,8 @@ io_dtor( void * vio )
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 );
evbuffer_free( io->inbuf );
@ -661,9 +643,11 @@ tr_peerIoReconnect( tr_peerIo * io )
if( io->socket >= 0 )
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 )
{
@ -745,7 +729,7 @@ size_t
tr_peerIoGetWriteBufferSpace( const tr_peerIo * io, uint64_t now )
{
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;
if( desiredLen > currentLen )
@ -772,81 +756,60 @@ tr_peerIoSetEncryption( tr_peerIo * io, uint32_t encryptionMode )
***
**/
void
tr_peerIoWrite( tr_peerIo * io,
const void * bytes,
size_t byteCount,
tr_bool isPieceData )
static void
addDatatype( tr_peerIo * io, 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;
struct tr_datatype * d;
assert( tr_amInEventThread( io->session ) );
dbgmsg( io, "adding %zu bytes into io->output", byteCount );
d = tr_new( struct tr_datatype, 1 );
d->isPieceData = isPieceData != 0;
d->length = byteCount;
tr_list_append( &io->outbuf_datatypes, d );
}
datatype = tr_new( struct tr_datatype, 1 );
datatype->isPieceData = isPieceData != 0;
datatype->length = byteCount;
tr_list_append( &io->outbuf_datatypes, datatype );
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;
}
switch( io->encryptionMode )
static void
maybeEncryptBuffer( tr_peerIo * io, struct evbuffer * buf )
{
if( io->encryptionMode == PEER_ENCRYPTION_RC4 )
{
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;
}
size_t i, n;
struct evbuffer_iovec * iovec = evbuffer_peek_all( buf, &n );
case PEER_ENCRYPTION_NONE:
evbuffer_add( io->outbuf, bytes, byteCount );
break;
for( i=0; i<n; ++i )
tr_cryptoEncrypt( io->crypto, iovec[i].iov_len, iovec[i].iov_base, iovec[i].iov_base );
default:
assert( 0 );
break;
tr_free( iovec );
}
}
void
tr_peerIoWriteBuf( tr_peerIo * io,
struct evbuffer * buf,
tr_bool isPieceData )
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 );
const size_t byteCount = evbuffer_get_length( buf );
maybeEncryptBuffer( io, buf );
evbuffer_add_buffer( io->outbuf, buf );
addDatatype( io, byteCount, isPieceData );
}
void
tr_peerIoWriteUint16( tr_peerIo * io,
struct evbuffer * outbuf,
uint16_t writeme )
tr_peerIoWriteBytes( tr_peerIo * io, const void * bytes, size_t byteCount, tr_bool isPieceData )
{
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 ) );
struct evbuffer * buf = evbuffer_new( );
evbuffer_add( buf, bytes, byteCount );
tr_peerIoWriteBuf( io, buf, isPieceData );
evbuffer_free( buf );
}
/***
@ -854,14 +817,28 @@ tr_peerIoWriteUint32( tr_peerIo * io,
***/
void
tr_peerIoReadBytes( tr_peerIo * io,
struct evbuffer * inbuf,
void * bytes,
size_t 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 ) );
/* FIXME(libevent2): use evbuffer_get_length() */
assert( EVBUFFER_LENGTH( inbuf ) >= byteCount );
assert( evbuffer_get_length( inbuf ) >= byteCount );
switch( io->encryptionMode )
{
@ -870,9 +847,8 @@ tr_peerIoReadBytes( tr_peerIo * io,
break;
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;
default:
@ -936,15 +912,15 @@ tr_peerIoTryRead( tr_peerIo * io, size_t howmuch )
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 );
if( ( res <= 0 ) && ( io->gotError ) && ( e != EAGAIN ) && ( e != EINTR ) && ( e != EINPROGRESS ) )
{
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 );
io->gotError( io, what, io->userData );
@ -969,10 +945,10 @@ tr_peerIoTryWrite( tr_peerIo * io, size_t howmuch )
if( n > 0 )
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 );
dbgmsg( io, "tr_peerIoTryWrite got an error. res is %d, what is %hd, errno is %d (%s)", n, what, e, errstr );

33
libtransmission/peer-io.h
View file

@ -23,7 +23,8 @@
#include <assert.h>
#include <event.h>
#include <event2/buffer.h>
#include <event2/event.h>
#include "transmission.h"
#include "bandwidth.h"
@ -109,8 +110,8 @@ typedef struct tr_peerIo
struct evbuffer * outbuf;
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;
@ -248,7 +249,7 @@ void tr_peerIoClear ( tr_peerIo * io );
***
**/
void tr_peerIoWrite ( tr_peerIo * io,
void tr_peerIoWriteBytes ( tr_peerIo * io,
const void * writeme,
size_t writemeLen,
tr_bool isPieceData );
@ -282,28 +283,14 @@ tr_peerIoIsEncrypted( const tr_peerIo * io )
return ( io != NULL ) && ( io->encryptionMode == PEER_ENCRYPTION_RC4 );
}
static inline void tr_peerIoWriteBytes( tr_peerIo * io UNUSED,
struct evbuffer * outbuf,
const void * bytes,
size_t byteCount )
static inline void
evbuffer_add_uint8( struct evbuffer * outbuf, uint8_t byte )
{
evbuffer_add( outbuf, bytes, byteCount );
evbuffer_add( outbuf, &byte, 1 );
}
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 );
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,
struct evbuffer * inbuf,

225
libtransmission/peer-msgs.c
View file

@ -18,7 +18,8 @@
#include <stdlib.h>
#include <string.h>
#include <event.h>
#include <event2/bufferevent.h>
#include <event2/event.h>
#include "transmission.h"
#include "bencode.h"
@ -227,7 +228,7 @@ struct tr_peermsgs
value is zero and should be ignored. */
int64_t reqq;
struct event pexTimer;
struct event * pexTimer;
};
/**
@ -277,8 +278,7 @@ myDebug( const char * file, int line,
evbuffer_add_vprintf( buf, fmt, args );
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 );
evbuffer_free( buf );
@ -309,39 +309,36 @@ pokeBatchPeriod( tr_peermsgs * msgs,
static void
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 ) );
}
static void
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 );
dbgOutMessageLen( msgs );
}
static void
protocolSendRequest( tr_peermsgs * msgs,
const struct peer_request * req )
protocolSendRequest( tr_peermsgs * msgs, const struct peer_request * req )
{
tr_peerIo * io = msgs->peer->io;
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 );
dbgOutMessageLen( msgs );
@ -349,17 +346,15 @@ protocolSendRequest( tr_peermsgs * msgs,
}
static void
protocolSendCancel( tr_peermsgs * msgs,
const struct peer_request * req )
protocolSendCancel( tr_peermsgs * msgs, const struct peer_request * req )
{
tr_peerIo * io = msgs->peer->io;
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 );
dbgOutMessageLen( msgs );
@ -369,25 +364,22 @@ protocolSendCancel( tr_peermsgs * msgs,
static void
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);
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 )
protocolSendHave( tr_peermsgs * msgs, uint32_t index )
{
tr_peerIo * io = msgs->peer->io;
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 );
dbgOutMessageLen( msgs );
@ -403,9 +395,9 @@ protocolSendAllowedFast( tr_peermsgs * msgs, uint32_t pieceIndex )
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 );
dbgOutMessageLen( msgs );
@ -413,14 +405,12 @@ protocolSendAllowedFast( tr_peermsgs * msgs, uint32_t pieceIndex )
#endif
static void
protocolSendChoke( tr_peermsgs * msgs,
int choke )
protocolSendChoke( tr_peermsgs * msgs, int choke )
{
tr_peerIo * io = msgs->peer->io;
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" );
dbgOutMessageLen( msgs );
@ -430,13 +420,12 @@ protocolSendChoke( tr_peermsgs * msgs,
static void
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..." );
dbgOutMessageLen( msgs );
@ -446,13 +435,12 @@ protocolSendHaveAll( tr_peermsgs * msgs )
static void
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..." );
dbgOutMessageLen( msgs );
@ -675,8 +663,8 @@ sendInterest( tr_peermsgs * msgs, tr_bool clientIsInterested )
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 );
dbgOutMessageLen( msgs );
@ -857,10 +845,10 @@ sendLtepHandshake( tr_peermsgs * msgs )
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 );
@ -1015,7 +1003,6 @@ parseUtMetadata( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
tr_benc tmp;
int payloadLen;
char * payload;
tr_peerIo * io = msgs->peer->io;
struct evbuffer * out = msgs->outMessages;
/* build the rejection message */
@ -1026,10 +1013,10 @@ parseUtMetadata( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
tr_bencFree( &tmp );
/* 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 );
@ -1303,7 +1290,7 @@ readBtPiece( tr_peermsgs * msgs,
{
struct peer_request * req = &msgs->incoming.blockReq;
assert( EVBUFFER_LENGTH( inbuf ) >= inlen );
assert( evbuffer_get_length( inbuf ) >= inlen );
dbgmsg( msgs, "In readBtPiece" );
if( !req->length )
@ -1322,7 +1309,7 @@ readBtPiece( tr_peermsgs * msgs,
int err;
/* 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;
void * buf = tr_sessionGetBuffer( getSession( msgs ) );
@ -1343,12 +1330,12 @@ readBtPiece( tr_peermsgs * msgs,
*setme_piece_bytes_read += n;
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 */
evbuffer_free( msgs->incoming.block );
@ -1368,7 +1355,7 @@ readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
uint32_t msglen = msgs->incoming.length;
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 );
@ -1558,7 +1545,7 @@ readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
}
assert( msglen + 1 == msgs->incoming.length );
assert( EVBUFFER_LENGTH( inbuf ) == startBufLen - msglen );
assert( evbuffer_get_length( inbuf ) == startBufLen - msglen );
msgs->state = AWAITING_BT_LENGTH;
return READ_NOW;
@ -1632,7 +1619,7 @@ canRead( tr_peerIo * io, void * vmsgs, size_t * piece )
ReadState ret;
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 );
@ -1663,8 +1650,8 @@ canRead( tr_peerIo * io, void * vmsgs, size_t * piece )
dbgmsg( msgs, "canRead: ret is %d", (int)ret );
/* 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;
}
@ -1744,7 +1731,6 @@ updateMetadataRequests( tr_peermsgs * msgs, time_t now )
tr_benc tmp;
int payloadLen;
char * payload;
tr_peerIo * io = msgs->peer->io;
struct evbuffer * out = msgs->outMessages;
/* build the data message */
@ -1757,10 +1743,10 @@ updateMetadataRequests( tr_peermsgs * msgs, time_t now )
dbgmsg( msgs, "requesting metadata piece #%d", piece );
/* 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 );
@ -1799,7 +1785,7 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
int piece;
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 );
/**
@ -1808,12 +1794,12 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
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 );
tr_peerIoWriteBuf( msgs->peer->io, msgs->outMessages, FALSE );
@ -1840,7 +1826,6 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
tr_benc tmp;
int payloadLen;
char * payload;
tr_peerIo * io = msgs->peer->io;
struct evbuffer * out = msgs->outMessages;
/* build the data message */
@ -1852,11 +1837,11 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
tr_bencFree( &tmp );
/* 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 );
@ -1871,7 +1856,6 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
tr_benc tmp;
int payloadLen;
char * payload;
tr_peerIo * io = msgs->peer->io;
struct evbuffer * out = msgs->outMessages;
/* build the rejection message */
@ -1882,10 +1866,10 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
tr_bencFree( &tmp );
/* 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 );
@ -1905,21 +1889,23 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
if( requestIsValid( msgs, &req )
&& 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 );
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 );
err = tr_cacheReadBlock( getSession(msgs)->cache, msgs->torrent, req.index, req.offset, req.length, EVBUFFER_DATA(out)+EVBUFFER_LENGTH(out) );
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... */
if( !err && tr_torrentPieceNeedsCheck( msgs->torrent, req.index ) )
@ -1933,11 +1919,11 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
}
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 );
}
@ -1968,7 +1954,7 @@ fillOutputBuffer( tr_peermsgs * msgs, time_t now )
&& ( ( now - msgs->clientSentAnythingAt ) > KEEPALIVE_INTERVAL_SECS ) )
{
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 );
}
@ -2006,9 +1992,9 @@ gotError( tr_peerIo * io UNUSED,
short what,
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 ) );
fireError( vmsgs, ENOTCONN );
@ -2053,13 +2039,11 @@ sendBitfield( tr_peermsgs * msgs )
tr_free( pool );
}
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 );
for( i = 0; i < lazyCount; ++i )
@ -2199,7 +2183,6 @@ sendPex( tr_peermsgs * msgs )
char * benc;
int bencLen;
uint8_t * tmp, *walk;
tr_peerIo * io = msgs->peer->io;
struct evbuffer * out = msgs->outMessages;
/* update peer */
@ -2288,12 +2271,12 @@ sendPex( tr_peermsgs * msgs )
/* 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 );
tr_free( benc );
@ -2319,7 +2302,7 @@ pexPulse( int foo UNUSED, short bar UNUSED, void * vmsgs )
sendPex( msgs );
tr_timerAdd( &msgs->pexTimer, PEX_INTERVAL_SECS, 0 );
tr_timerAdd( msgs->pexTimer, PEX_INTERVAL_SECS, 0 );
}
/**
@ -2351,9 +2334,9 @@ tr_peerMsgsNew( struct tr_torrent * torrent,
m->outMessagesBatchedAt = 0;
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 ) )
sendLtepHandshake( m );
@ -2380,7 +2363,7 @@ tr_peerMsgsFree( tr_peermsgs* msgs )
{
if( msgs )
{
evtimer_del( &msgs->pexTimer );
event_free( msgs->pexTimer );
evbuffer_free( msgs->incoming.block );
evbuffer_free( msgs->outMessages );

68
libtransmission/rpc-server.c
View file

@ -30,6 +30,7 @@
#include "transmission.h"
#include "bencode.h"
#include "crypto.h"
#include "fdlimit.h"
#include "list.h"
#include "net.h"
#include "platform.h"
@ -155,12 +156,12 @@ tr_mimepart_free( struct tr_mimepart * p )
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=";
const char * boundary_key_begin = strstr( content_type, boundary_key );
@ -277,7 +278,7 @@ handle_upload( struct evhttp_request * req,
tr_bencToBuf( &top, TR_FMT_JSON, json );
tr_rpc_request_exec_json( server->session,
EVBUFFER_DATA( json ),
EVBUFFER_LENGTH( json ),
evbuffer_get_length( json ),
NULL, NULL );
evbuffer_free( json );
}
@ -327,14 +328,11 @@ mimetype_guess( const char * path )
}
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";
const char * encoding = evhttp_find_header( req->input_headers, key );
@ -342,14 +340,14 @@ add_response( struct evhttp_request * req,
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 )
{
@ -370,36 +368,36 @@ add_response( struct evhttp_request * req,
deflateInit2( &server->stream, compressionLevel, Z_DEFLATED, 15+16, 8, Z_DEFAULT_STRATEGY );
}
server->stream.next_in = (Bytef*) content;
server->stream.next_in = content_ptr;
server->stream.avail_in = content_len;
/* allocate space for the raw data and call deflate() just once --
* 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,
"Content-Encoding", "gzip" );
}
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 );
}
#endif
@ -428,13 +426,16 @@ serve_file( struct evhttp_request * req,
}
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 )
{
@ -452,12 +453,13 @@ serve_file( struct evhttp_request * req,
evhttp_add_header( req->output_headers, "Content-Type", mimetype_guess( filename ) );
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 );
}
}
@ -512,17 +514,15 @@ struct rpc_response_data
struct tr_rpc_server * server;
};
/* 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 )
{
struct rpc_response_data * data = user_data;
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" );
evhttp_send_reply( data->req, HTTP_OK, "OK", buf );
@ -551,7 +551,7 @@ handle_rpc( struct evhttp_request * req,
{
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 );
}

16
libtransmission/rpcimpl.c
View file

@ -102,8 +102,7 @@ tr_idle_function_done( struct tr_rpc_idle_data * data, const char * result )
tr_bencDictAddStr( data->response, "result", result );
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 );
tr_bencFree( data->response );
@ -1647,10 +1646,9 @@ methods[] =
};
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 )
{
}
@ -1693,8 +1691,7 @@ request_exec( tr_session * session,
if( tr_bencDictFindInt( request, "tag", &tag ) )
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 );
tr_bencFree( &response );
@ -1715,8 +1712,7 @@ request_exec( tr_session * session,
if( tr_bencDictFindInt( request, "tag", &tag ) )
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 );
tr_bencFree( &response );

4
libtransmission/rpcimpl.h
View file

@ -22,11 +22,11 @@ extern "C" {
***/
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/ */
void tr_rpc_request_exec_json( tr_session * session,

8
libtransmission/torrent-magnet.c
View file

@ -11,9 +11,10 @@
*/
#include <assert.h>
#include <event.h> /* struct evbuffer */
#include <stdio.h> /* remove() */
#include <event2/buffer.h>
#include "transmission.h"
#include "bencode.h"
#include "crypto.h"
@ -370,7 +371,6 @@ char*
tr_torrentGetMagnetLink( const tr_torrent * tor )
{
int i;
char * ret;
const char * name;
struct evbuffer * s;
@ -390,7 +390,5 @@ tr_torrentGetMagnetLink( const tr_torrent * tor )
tr_http_escape( s, tor->info.trackers[i].announce, -1, TRUE );
}
ret = tr_strndup( EVBUFFER_DATA( s ), EVBUFFER_LENGTH( s ) );
evbuffer_free( s );
return ret;
return evbuffer_free_to_str( s );
}

24
libtransmission/tr-dht.c
View file

@ -43,7 +43,7 @@ THE SOFTWARE.
#endif
/* third party */
#include <event.h>
#include <event2/event.h>
#include <dht/dht.h>
/* libT */
@ -60,7 +60,8 @@ THE SOFTWARE.
#include "utils.h"
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];
static tr_session *session = NULL;
@ -399,13 +400,13 @@ tr_dhtInit(tr_session *ss, const tr_address * tr_addr)
cl->len6 = len6;
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 ) );
}
tr_ndbg( "DHT", "DHT initialized" );
@ -435,10 +436,13 @@ tr_dhtUninit(tr_session *ss)
tr_ndbg( "DHT", "Uninitializing DHT" );
event_del( &dht_event );
event_free( dht_event );
dht_event = NULL;
if( dht6_socket >= 0 )
event_del( &dht6_event );
if( dht6_event ) {
event_free( dht6_event );
dht6_event = NULL;
}
/* Since we only save known good nodes, avoid erasing older data if we
don't know enough nodes. */
@ -691,7 +695,7 @@ tr_dhtAnnounce(tr_torrent *tor, int af, tr_bool announce)
static void
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;

13
libtransmission/tr-lpd.c
View file

@ -42,8 +42,8 @@ THE SOFTWARE.
#endif
/* third party */
#include <event.h>
#include <evutil.h>
#include <event2/event.h>
#include <event2/util.h>
/* libT */
#include "transmission.h"
@ -70,7 +70,7 @@ static void event_callback( int, short, void* );
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;
static tr_torrent* lpd_torStaticType UNUSED; /* just a helper for static type analysis */
@ -338,8 +338,8 @@ int tr_lpdInit( tr_session* ss, tr_address* tr_addr UNUSED )
/* Note: lpd_unsolicitedMsgCounter remains 0 until the first timeout event, thus
* 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" );
@ -367,7 +367,8 @@ void tr_lpdUninit( tr_session* ss )
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 */
EVUTIL_CLOSESOCKET( lpd_socket );

2
libtransmission/trevent.c
View file

@ -126,8 +126,6 @@ piperead( int s, char *buf, int len )
#include <unistd.h>
#include <event.h>
#include "transmission.h"
#include "platform.h"
#include "trevent.h"

23
libtransmission/utils.c
View file

@ -42,7 +42,8 @@
#include <sys/stat.h>
#include <unistd.h> /* stat(), getcwd(), getpagesize() */
#include "event.h"
#include <event2/buffer.h>
#include <event2/event.h>
#ifdef WIN32
#include <w32api.h>
@ -247,9 +248,9 @@ tr_deepLog( const char * file,
va_end( args );
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 );
evbuffer_free( buf );
@ -691,6 +692,17 @@ tr_buildPath( const char *first_element, ... )
*****
****/
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 )
{
@ -1249,7 +1261,6 @@ tr_lowerBound( const void * key,
static char*
strip_non_utf8( const char * in, size_t inlen )
{
char * ret;
const char * end;
const char zero = '\0';
struct evbuffer * buf = evbuffer_new( );
@ -1266,9 +1277,7 @@ strip_non_utf8( const char * in, size_t inlen )
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 );
}
static char*

11
libtransmission/utils.h
View file

@ -303,6 +303,12 @@ void* tr_malloc0( size_t size );
/** @brief Portability wrapper around free() in which `NULL' is a safe argument */
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
* @param src the memory to copy
@ -337,6 +343,11 @@ char* tr_strndup( const void * in, int len ) TR_GNUC_MALLOC;
*/
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 */
int tr_lowerBound( const void * key,
const void * base,

9
libtransmission/web.c
View file

@ -17,7 +17,8 @@
#endif
#include <curl/curl.h>
#include <event.h>
#include <event2/buffer.h>
#include "transmission.h"
#include "list.h"
@ -192,8 +193,8 @@ task_finish_func( void * vtask )
if( task->done_func != NULL )
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 );
task_free( task );
@ -350,7 +351,7 @@ tr_webThreadFunc( void * vsession )
curl_easy_getinfo( e, CURLINFO_RESPONSE_CODE, &task->code );
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;
}

17
libtransmission/webseed.c
View file

@ -12,7 +12,7 @@
#include <string.h> /* strlen */
#include <event.h>
#include <event2/buffer.h>
#include "transmission.h"
#include "inout.h"
@ -97,7 +97,6 @@ static char*
makeURL( tr_webseed * w,
const tr_file * file )
{
char * ret;
struct evbuffer * out = evbuffer_new( );
const char * url = w->url;
const size_t url_len = strlen( url );
@ -108,9 +107,7 @@ makeURL( tr_webseed * w,
if( url[url_len - 1] == '/' && file->name )
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 );
}
static void requestNextChunk( tr_webseed * w );
@ -141,11 +138,11 @@ webResponseFunc( tr_session * session,
tr_rcTransferred( &w->rateDown, response_byte_count );
}
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 )
tr_webseedFree( w );
@ -165,7 +162,7 @@ requestNextChunk( tr_webseed * w )
if( tor != NULL )
{
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;
tr_file_index_t fileIndex;
@ -206,7 +203,7 @@ tr_webseedAddRequest( tr_webseed * w,
w->pieceIndex = pieceIndex;
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;
}

6
utils/edit.c
View file

@ -12,7 +12,7 @@
#include <stdio.h>
#include <event.h> /* evbuffer */
#include <event2/buffer.h>
#include <libtransmission/transmission.h>
#include <libtransmission/bencode.h>
@ -156,9 +156,7 @@ replaceSubstr( const char * str, const char * in, const char * out )
str = walk + inlen;
}
walk = tr_strndup( EVBUFFER_DATA( buf ), EVBUFFER_LENGTH( buf ) );
evbuffer_free( buf );
return walk;
return evbuffer_free_to_str( buf );
}
static tr_bool

6
utils/show.c
View file

@ -16,7 +16,7 @@
#define CURL_DISABLE_TYPECHECK /* otherwise -Wunreachable-code goes insane */
#include <curl/curl.h>
#include <event.h> /* struct evbuffer */
#include <event2/buffer.h>
#include <libtransmission/transmission.h>
#include <libtransmission/bencode.h>
@ -221,8 +221,8 @@ doScrape( const tr_info * inf )
tr_benc top;
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 ) )
{