Changeset 7419


Ignore:
Timestamp:
Dec 16, 2008, 10:08:17 PM (12 years ago)
Author:
charles
Message:

(trunk libT) really fuck up the peer i/o code. also this breaks the mac build until someone removes iobuf.c from libtransmission's list of files.

Location:
trunk/libtransmission
Files:
2 deleted
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/Makefile.am

    r7293 r7419  
    2525    handshake.c \
    2626    inout.c \
    27     iobuf.c \
    2827    json.c \
    2928    JSON_parser.c \
     
    7170    handshake.h \
    7271    inout.h \
    73     iobuf.h \
    7472    json.h \
    7573    JSON_parser.h \
  • trunk/libtransmission/bandwidth.c

    r7404 r7419  
    1919#include "bandwidth.h"
    2020#include "crypto.h"
    21 #include "iobuf.h"
     21#include "peer-io.h"
    2222#include "ptrarray.h"
    2323#include "utils.h"
     
    100100    tr_session * session;
    101101    tr_ptrArray * children; /* struct tr_bandwidth */
    102     tr_ptrArray * iobufs; /* struct tr_iobuf */
     102    tr_ptrArray * peers; /* tr_peerIo */
    103103};
    104104
     
    135135    b->session = session;
    136136    b->children = tr_ptrArrayNew( );
    137     b->iobufs = tr_ptrArrayNew( );
     137    b->peers = tr_ptrArrayNew( );
    138138    b->magicNumber = MAGIC_NUMBER;
    139139    b->band[TR_UP].honorParentLimits = 1;
     
    149149
    150150    tr_bandwidthSetParent( b, NULL );
    151     tr_ptrArrayFree( b->iobufs, NULL );
     151    tr_ptrArrayFree( b->peers, NULL );
    152152    tr_ptrArrayFree( b->children, NULL );
    153153    b->magicNumber = 0xDEAD;
     
    250250                   tr_direction    dir,
    251251                   int             period_msec,
    252                    tr_ptrArray   * iobuf_pool )
     252                   tr_ptrArray   * peer_pool )
    253253{
    254254    assert( isBandwidth( b ) );
     
    271271    {
    272272        int i;
    273         const int n = tr_ptrArraySize( b->iobufs );
     273        const int n = tr_ptrArraySize( b->peers );
    274274        for( i=0; i<n; ++i )
    275             tr_ptrArrayAppend( iobuf_pool, tr_ptrArrayNth( b->iobufs, i ) );
     275            tr_ptrArrayAppend( peer_pool, tr_ptrArrayNth( b->peers, i ) );
    276276    }
    277277
    278278#ifdef DEBUG_DIRECTION
    279279if( ( dir == DEBUG_DIRECTION ) && ( n > 1 ) )
    280 fprintf( stderr, "bandwidth %p has %d iobufs\n", b, n );
     280fprintf( stderr, "bandwidth %p has %d peers\n", b, n );
    281281#endif
    282282
     
    286286        struct tr_bandwidth ** children = (struct tr_bandwidth**) tr_ptrArrayPeek( b->children, &n );
    287287        for( i=0; i<n; ++i )
    288             allocateBandwidth( children[i], dir, period_msec, iobuf_pool );
     288            allocateBandwidth( children[i], dir, period_msec, peer_pool );
    289289    }
    290290}
     
    297297    int n;
    298298    tr_ptrArray * tmp;
    299     struct tr_iobuf ** buffers;
     299    struct tr_peerIo ** peers;
    300300    const size_t chunkSize = 1024; /* arbitrary */
    301301
    302302    tmp = tr_ptrArrayNew( );
    303303    allocateBandwidth( b, dir, period_msec, tmp );
    304     buffers = (struct tr_iobuf**) tr_ptrArrayPeek( tmp, &n );
     304    peers = (struct tr_peerIo**) tr_ptrArrayPeek( tmp, &n );
    305305
    306306    /* loop through all the peers, reading and writing in small chunks,
    307307     * until we run out of bandwidth or peers. we do it this way to
    308308     * prevent one peer from using up all the bandwidth */
     309fprintf( stderr, "%s - %d peers\n", (dir==TR_UP)?"up":"down", n );
    309310    while( n > 0 )
    310311    {
     
    312313        for( i=0; i<n; )
    313314        {
    314             int byteCount;
    315             if( dir == TR_UP )
    316                 byteCount = tr_iobuf_flush_output_buffer( buffers[i], chunkSize );
    317             else
    318                 byteCount = tr_iobuf_tryread( buffers[i], chunkSize );
     315            const int byteCount = tr_peerIoFlush( peers[i], dir, chunkSize );
     316
     317            if( byteCount )
     318                fprintf( stderr, "peer %p: %d bytes\n", peers[i], byteCount );
     319
    319320            if( byteCount == (int)chunkSize )
    320321                ++i;
    321322            else
    322                 buffers[i] = buffers[--n];
     323                peers[i] = peers[--n];
    323324        }
    324325    }
     
    333334
    334335void
    335 tr_bandwidthAddBuffer( tr_bandwidth        * b,
    336                        struct tr_iobuf     * iobuf )
    337 {
    338     assert( isBandwidth( b ) );
    339     assert( iobuf );
    340 
    341     tr_ptrArrayInsertSorted( b->iobufs, iobuf, comparePointers );
    342 }
    343 
    344 void
    345 tr_bandwidthRemoveBuffer( tr_bandwidth        * b,
    346                           struct tr_iobuf     * iobuf )
    347 {
    348     assert( isBandwidth( b ) );
    349     assert( iobuf );
    350 
    351     tr_ptrArrayRemoveSorted( b->iobufs, iobuf, comparePointers );
     336tr_bandwidthAddPeer( tr_bandwidth   * b,
     337                     tr_peerIo      * peerIo )
     338{
     339    assert( isBandwidth( b ) );
     340    assert( peerIo );
     341
     342    tr_ptrArrayInsertSorted( b->peers, peerIo, comparePointers );
     343}
     344
     345void
     346tr_bandwidthRemovePeer( tr_bandwidth  * b,
     347                        tr_peerIo     * peerIo )
     348{
     349    assert( isBandwidth( b ) );
     350    assert( peerIo );
     351
     352    tr_ptrArrayRemoveSorted( b->peers, peerIo, comparePointers );
    352353}
    353354
  • trunk/libtransmission/bandwidth.h

    r7404 r7419  
    5959 *   bandwidth they can safely use.
    6060 */
     61
    6162typedef struct tr_bandwidth tr_bandwidth;
     63
     64struct tr_peerIo;
    6265
    6366/**
     
    167170
    168171/**
    169  * @brief add an iobuf to this bandwidth's list of iobufs.
     172 * @brief add a tr_peerIo to this bandwidth's list.
    170173 * They will be notified when more bandwidth is made available for them to consume.
    171174 */
    172 void    tr_bandwidthAddBuffer         ( tr_bandwidth        * bandwidth,
    173                                         struct tr_iobuf     * iobuf );
     175void    tr_bandwidthAddPeer           ( tr_bandwidth        * bandwidth,
     176                                        struct tr_peerIo    * peerIo );
    174177
    175178/**
    176179 * @brief remove an iobuf from this bandwidth's list of iobufs.
    177180 */
    178 void    tr_bandwidthRemoveBuffer      ( tr_bandwidth        * bandwidth,
    179                                         struct tr_iobuf     * iobuf );
     181void    tr_bandwidthRemovePeer        ( tr_bandwidth        * bandwidth,
     182                                        struct tr_peerIo    * peerIo );
    180183
    181184#endif
  • trunk/libtransmission/handshake.c

    r7404 r7419  
    2525#include "crypto.h"
    2626#include "handshake.h"
    27 #include "iobuf.h"
    2827#include "peer-io.h"
    2928#include "peer-mgr.h"
     
    10051004
    10061005static ReadState
    1007 canRead( struct tr_iobuf * iobuf, void * arg, size_t * piece )
     1006canRead( struct tr_peerIo * io, void * arg, size_t * piece )
    10081007{
    10091008    tr_handshake    * handshake = arg;
    1010     struct evbuffer * inbuf = tr_iobuf_input( iobuf );
     1009    struct evbuffer * inbuf = tr_peerIoGetReadBuffer( io );
    10111010    ReadState         ret;
    10121011    tr_bool           readyForMore = TRUE;
     
    11151114
    11161115static void
    1117 gotError( struct tr_iobuf  * iobuf UNUSED,
    1118           short              what,
    1119           void             * arg )
     1116gotError( tr_peerIo  * io UNUSED,
     1117          short        what,
     1118          void       * arg )
    11201119{
    11211120    tr_handshake * handshake = (tr_handshake *) arg;
     
    11651164    handshake->doneUserData = doneUserData;
    11661165    handshake->session = tr_peerIoGetSession( io );
    1167     tr_peerIoSetTimeoutSecs( io, 15 );
    11681166
    11691167    tr_peerIoSetIOFuncs( handshake->io, canRead, NULL, gotError, handshake );
  • trunk/libtransmission/peer-io.c

    r7404 r7419  
    2828#include "bandwidth.h"
    2929#include "crypto.h"
    30 #include "iobuf.h"
    3130#include "list.h"
    3231#include "net.h"
     
    8079struct tr_peerIo
    8180{
    82     tr_bool                  isEncrypted;
    83     tr_bool                  isIncoming;
    84     tr_bool                  peerIdIsSet;
    85     tr_bool                  extendedProtocolSupported;
    86     tr_bool                  fastExtensionSupported;
    87 
    88     int                      magicNumber;
    89 
    90     uint8_t                  encryptionMode;
    91     uint8_t                  timeout;
    92     tr_port                  port;
    93     int                      socket;
    94 
    95     uint8_t                  peerId[20];
    96     time_t                   timeCreated;
    97 
    98     tr_session             * session;
    99 
    100     tr_address               addr;
    101     struct tr_iobuf        * iobuf;
    102     tr_list                * output_datatypes; /* struct tr_datatype */
    103 
    104     tr_can_read_cb           canRead;
    105     tr_did_write_cb          didWrite;
    106     tr_net_error_cb          gotError;
    107     void *                   userData;
    108 
    109     size_t                   bufferSize[2];
    110 
    111     tr_bandwidth           * bandwidth;
    112     tr_crypto              * crypto;
     81    tr_bool            isEncrypted;
     82    tr_bool            isIncoming;
     83    tr_bool            peerIdIsSet;
     84    tr_bool            extendedProtocolSupported;
     85    tr_bool            fastExtensionSupported;
     86
     87    int                magicNumber;
     88
     89    uint8_t            encryptionMode;
     90    uint8_t            timeout;
     91    tr_port            port;
     92    int                socket;
     93
     94    uint8_t            peerId[20];
     95    time_t             timeCreated;
     96
     97    tr_session       * session;
     98
     99    tr_address         addr;
     100    tr_list          * output_datatypes; /* struct tr_datatype */
     101
     102    tr_can_read_cb     canRead;
     103    tr_did_write_cb    didWrite;
     104    tr_net_error_cb    gotError;
     105    void *             userData;
     106
     107    size_t             bufferSize[2];
     108
     109    tr_bandwidth     * bandwidth;
     110    tr_crypto        * crypto;
     111
     112    struct evbuffer  * inbuf;
     113    struct evbuffer  * outbuf;
    113114};
    114115
     
    118119
    119120static void
    120 didWriteWrapper( struct tr_iobuf  * iobuf,
    121                  size_t             bytes_transferred,
    122                  void             * vio )
     121didWriteWrapper( void     * unused UNUSED,
     122                 size_t     bytes_transferred,
     123                 void     * vio )
    123124{
    124125    tr_peerIo *  io = vio;
     
    143144            tr_free( tr_list_pop_front( &io->output_datatypes ) );
    144145    }
    145 
    146     if( EVBUFFER_LENGTH( tr_iobuf_output( iobuf ) ) )
    147         tr_iobuf_enable( io->iobuf, EV_WRITE );
    148146}
    149147
    150148static void
    151 canReadWrapper( struct tr_iobuf  * iobuf,
    152                 size_t             bytes_transferred UNUSED,
    153                 void              * vio )
     149canReadWrapper( void    * unused UNUSED,
     150                size_t    bytes_transferred UNUSED,
     151                void    * vio )
    154152{
    155153    int          done = 0;
     
    168166        {
    169167            size_t piece = 0;
    170             const size_t oldLen = EVBUFFER_LENGTH( tr_iobuf_input( iobuf ) );
    171             const int ret = io->canRead( iobuf, io->userData, &piece );
     168            const size_t oldLen = EVBUFFER_LENGTH( io->inbuf );
     169            const int ret = io->canRead( io, io->userData, &piece );
    172170
    173171            if( ret != READ_ERR )
    174172            {
    175                 const size_t used = oldLen - EVBUFFER_LENGTH( tr_iobuf_input( iobuf ) );
     173                const size_t used = oldLen - EVBUFFER_LENGTH( io->inbuf );
    176174                if( piece )
    177175                    tr_bandwidthUsed( io->bandwidth, TR_DOWN, piece, TRUE );
     
    183181            {
    184182                case READ_NOW:
    185                     if( EVBUFFER_LENGTH( tr_iobuf_input( iobuf )))
     183                    if( EVBUFFER_LENGTH( io->inbuf ) )
    186184                        continue;
    187185                    done = 1;
     
    202200}
    203201
     202#if 0
    204203static void
    205204gotErrorWrapper( struct tr_iobuf  * iobuf,
     
    212211        c->gotError( iobuf, what, c->userData );
    213212}
    214 
    215 /**
    216 ***
    217 **/
    218 
     213#endif
     214
     215/**
     216***
     217**/
     218
     219#if 0
    219220static void
    220221bufevNew( tr_peerIo * io )
     
    231232    tr_iobuf_settimeout( io->iobuf, io->timeout, io->timeout );
    232233}
     234#endif
    233235
    234236static int
     
    267269    io->timeout = IO_TIMEOUT_SECS;
    268270    io->timeCreated = time( NULL );
     271    io->inbuf = evbuffer_new( );
     272    io->outbuf = evbuffer_new( );
     273#if 0
    269274    bufevNew( io );
     275#endif
    270276    tr_peerIoSetBandwidth( io, session->bandwidth );
    271277    return io;
     
    310316
    311317    tr_peerIoSetBandwidth( io, NULL );
    312     tr_iobuf_free( io->iobuf );
     318    evbuffer_free( io->outbuf );
     319    evbuffer_free( io->inbuf );
    313320    tr_netClose( io->socket );
    314321    tr_cryptoFree( io->crypto );
     
    371378}
    372379
     380#if 0
    373381static void
    374382tr_peerIoTryRead( tr_peerIo * io )
     
    377385        (*canReadWrapper)( io->iobuf, ~0, io );
    378386}
     387#endif
    379388
    380389void
     
    390399    io->userData = userData;
    391400
     401#if 0
    392402    tr_peerIoTryRead( io );
    393 }
    394 
    395 int
     403#endif
     404}
     405
     406tr_bool
    396407tr_peerIoIsIncoming( const tr_peerIo * c )
    397408{
    398     return c->isIncoming ? 1 : 0;
     409    return c->isIncoming != 0;
    399410}
    400411
     
    415426
    416427        tr_netSetTOS( io->socket, io->session->peerSocketTOS );
    417         tr_iobuf_free( io->iobuf );
     428#if 0
    418429        bufevNew( io );
     430#endif
    419431
    420432        tr_peerIoSetBandwidth( io, bandwidth );
     
    425437}
    426438
     439#if 0
    427440void
    428441tr_peerIoSetTimeoutSecs( tr_peerIo * io,
     
    433446    tr_iobuf_enable( io->iobuf, EV_READ | EV_WRITE );
    434447}
     448#endif
    435449
    436450/**
     
    557571{
    558572    const size_t desiredLen = getDesiredOutputBufferSize( io );
    559     const size_t currentLen = EVBUFFER_LENGTH( tr_iobuf_output( io->iobuf ) );
     573    const size_t currentLen = EVBUFFER_LENGTH( io->outbuf );
    560574    size_t freeSpace = 0;
    561575
     
    573587
    574588    if( io->bandwidth )
    575         tr_bandwidthRemoveBuffer( io->bandwidth, io->iobuf );
     589        tr_bandwidthRemovePeer( io->bandwidth, io );
    576590
    577591    io->bandwidth = bandwidth;
    578     tr_iobuf_set_bandwidth( io->iobuf, bandwidth );
    579592
    580593    if( io->bandwidth )
    581         tr_bandwidthAddBuffer( io->bandwidth, io->iobuf );
    582 
    583     tr_iobuf_enable( io->iobuf, EV_READ | EV_WRITE );
     594        tr_bandwidthAddPeer( io->bandwidth, io );
    584595}
    585596
     
    630641    tr_list_append( &io->output_datatypes, datatype );
    631642
    632     evbuffer_add( tr_iobuf_output( io->iobuf ), writeme, writemeLen );
    633     tr_iobuf_enable( io->iobuf, EV_WRITE );
     643    evbuffer_add( io->outbuf, writeme, writemeLen );
    634644}
    635645
     
    777787    return time( NULL ) - io->timeCreated;
    778788}
     789
     790/***
     791****
     792***/
     793
     794static int
     795tr_peerIoTryRead( tr_peerIo * io, size_t howmuch )
     796{
     797    int res;
     798
     799    assert( isPeerIo( io ) );
     800
     801    howmuch = tr_bandwidthClamp( io->bandwidth, TR_DOWN, howmuch );
     802
     803    res = howmuch ? evbuffer_read( io->inbuf, io->socket, howmuch ) : 0;
     804
     805    dbgmsg( io, "read %d from peer (%s)", res, (res==-1?strerror(errno):"") );
     806
     807    if( res > 0 )
     808        canReadWrapper( io, res, io );
     809
     810    if( ( res <= 0 ) && ( io->gotError ) && ( errno != EAGAIN ) && ( errno != EINTR ) )
     811    {
     812        short what = EVBUFFER_READ | EVBUFFER_ERROR;
     813        if( res == 0 )
     814            what |= EVBUFFER_EOF;
     815        io->gotError( io, what, io->userData );
     816    }
     817
     818    return res;
     819}
     820
     821static int
     822tr_peerIoTryWrite( tr_peerIo * io, size_t howmuch )
     823{
     824    int n;
     825
     826    assert( isPeerIo( io ) );
     827
     828    howmuch = tr_bandwidthClamp( io->bandwidth, TR_UP, howmuch );
     829    howmuch = MIN( howmuch, EVBUFFER_LENGTH( io->outbuf ) );
     830    n = (int) howmuch;
     831
     832#ifdef WIN32
     833    n = send( io->socket, EVBUFFER_DATA( io->outbuf ), n,  0 );
     834#else
     835    n = write( io->socket, EVBUFFER_DATA( io->outbuf ),  n );
     836#endif
     837    dbgmsg( io, "wrote %d to peer (%s)", n, (n==-1?strerror(errno):"") );
     838
     839    if( n > 0 )
     840    {
     841        evbuffer_drain( io->outbuf, n );
     842
     843        didWriteWrapper( NULL, n, io );
     844    }
     845
     846    if( ( n < 0 ) && ( io->gotError ) && ( errno != EPIPE ) && ( errno != EAGAIN ) && ( errno != EINTR ) && ( errno != EINPROGRESS ) )
     847    {
     848        short what = EVBUFFER_WRITE | EVBUFFER_ERROR;
     849        io->gotError( io, what, io->userData );
     850    }
     851
     852    return n;
     853}
     854
     855int
     856tr_peerIoFlush( tr_peerIo  * io, tr_direction dir, size_t limit )
     857{
     858    int ret;
     859
     860    assert( isPeerIo( io ) );
     861    assert( dir==TR_UP || dir==TR_DOWN );
     862
     863    if( dir==TR_DOWN )
     864        ret = tr_peerIoTryRead( io, limit );
     865    else
     866        ret = tr_peerIoTryWrite( io, limit );
     867
     868    return ret;
     869}
     870
     871struct evbuffer *
     872tr_peerIoGetReadBuffer( tr_peerIo * io )
     873{
     874    assert( isPeerIo( io ) );
     875
     876    return io->inbuf;
     877}
  • trunk/libtransmission/peer-io.h

    r7404 r7419  
    8181int                  tr_peerIoReconnect( tr_peerIo * io );
    8282
    83 int                  tr_peerIoIsIncoming( const tr_peerIo * io );
    84 
    85 void                 tr_peerIoSetTimeoutSecs( tr_peerIo * io,
    86                                               int         secs );
     83tr_bool              tr_peerIoIsIncoming( const tr_peerIo * io );
    8784
    8885int                  tr_peerIoGetAge( const tr_peerIo * io );
     
    110107ReadState;
    111108
    112 typedef ReadState ( *tr_can_read_cb  )( struct tr_iobuf  * iobuf,
     109typedef ReadState ( *tr_can_read_cb  )( tr_peerIo        * io,
    113110                                        void             * user_data,
    114111                                        size_t           * setme_piece_byte_count );
     
    119116                                        void             * userData );
    120117
    121 typedef void      ( *tr_net_error_cb )( struct tr_iobuf  * ev,
     118typedef void      ( *tr_net_error_cb )( tr_peerIo        * io,
    122119                                        short              what,
    123120                                        void             * userData );
     
    156153EncryptionMode;
    157154
    158 void              tr_peerIoSetEncryption( tr_peerIo * io,
    159                                           int         encryptionMode );
    160 
    161 int               tr_peerIoIsEncrypted( const tr_peerIo * io );
    162 
    163 void              tr_peerIoWriteBytes( tr_peerIo *       io,
    164                                        struct evbuffer * outbuf,
    165                                        const void *      bytes,
    166                                        size_t            byteCount );
    167 
    168 void              tr_peerIoWriteUint8( tr_peerIo *       io,
    169                                        struct evbuffer * outbuf,
    170                                        uint8_t           writeme );
    171 
    172 void              tr_peerIoWriteUint16( tr_peerIo *       io,
    173                                         struct evbuffer * outbuf,
    174                                         uint16_t          writeme );
    175 
    176 void              tr_peerIoWriteUint32( tr_peerIo *       io,
    177                                         struct evbuffer * outbuf,
    178                                         uint32_t          writeme );
    179 
    180 void              tr_peerIoReadBytes( tr_peerIo *       io,
    181                                       struct evbuffer * inbuf,
    182                                       void *            bytes,
    183                                       size_t            byteCount );
    184 
    185 void              tr_peerIoReadUint8( tr_peerIo *       io,
    186                                       struct evbuffer * inbuf,
    187                                       uint8_t *         setme );
    188 
    189 void              tr_peerIoReadUint16( tr_peerIo *       io,
    190                                        struct evbuffer * inbuf,
    191                                        uint16_t *        setme );
    192 
    193 void              tr_peerIoReadUint32( tr_peerIo *       io,
    194                                        struct evbuffer * inbuf,
    195                                        uint32_t *        setme );
    196 
    197 void              tr_peerIoDrain( tr_peerIo *       io,
    198                                   struct evbuffer * inbuf,
    199                                   size_t            byteCount );
    200 
    201 /**
    202 ***
    203 **/
    204 
    205 size_t            tr_peerIoGetWriteBufferSpace( const tr_peerIo * io );
    206 
    207 void              tr_peerIoSetBandwidth( tr_peerIo            * io,
    208                                          struct tr_bandwidth  * bandwidth );
    209 
    210 void              tr_peerIoBandwidthUsed( tr_peerIo           * io,
    211                                           tr_direction          direction,
    212                                           size_t                byteCount,
    213                                           int                   isPieceData );
     155void      tr_peerIoSetEncryption( tr_peerIo * io,
     156                                  int         encryptionMode );
     157
     158int       tr_peerIoIsEncrypted( const tr_peerIo * io );
     159
     160void      tr_peerIoWriteBytes( tr_peerIo *       io,
     161                               struct evbuffer * outbuf,
     162                               const void *      bytes,
     163                               size_t            byteCount );
     164
     165void      tr_peerIoWriteUint8( tr_peerIo *       io,
     166                               struct evbuffer * outbuf,
     167                               uint8_t           writeme );
     168
     169void      tr_peerIoWriteUint16( tr_peerIo *       io,
     170                                struct evbuffer * outbuf,
     171                                uint16_t          writeme );
     172
     173void      tr_peerIoWriteUint32( tr_peerIo *       io,
     174                                struct evbuffer * outbuf,
     175                                uint32_t          writeme );
     176
     177void      tr_peerIoReadBytes( tr_peerIo *       io,
     178                              struct evbuffer * inbuf,
     179                              void *            bytes,
     180                              size_t            byteCount );
     181
     182void      tr_peerIoReadUint8( tr_peerIo *       io,
     183                              struct evbuffer * inbuf,
     184                              uint8_t *         setme );
     185
     186void      tr_peerIoReadUint16( tr_peerIo *       io,
     187                               struct evbuffer * inbuf,
     188                               uint16_t *        setme );
     189
     190void      tr_peerIoReadUint32( tr_peerIo *       io,
     191                               struct evbuffer * inbuf,
     192                               uint32_t *        setme );
     193
     194void      tr_peerIoDrain( tr_peerIo *       io,
     195                          struct evbuffer * inbuf,
     196                          size_t            byteCount );
     197
     198/**
     199***
     200**/
     201
     202size_t    tr_peerIoGetWriteBufferSpace( const tr_peerIo * io );
     203
     204void      tr_peerIoSetBandwidth( tr_peerIo            * io,
     205                                 struct tr_bandwidth  * bandwidth );
     206
     207void      tr_peerIoBandwidthUsed( tr_peerIo           * io,
     208                                  tr_direction          direction,
     209                                  size_t                byteCount,
     210                                  int                   isPieceData );
     211
     212/**
     213***
     214**/
     215
     216int       tr_peerIoFlush( tr_peerIo     * io,
     217                          tr_direction    dir,
     218                          size_t          byteLimit );
     219
     220struct evbuffer * tr_peerIoGetReadBuffer( tr_peerIo * io );
     221
    214222
    215223
  • trunk/libtransmission/peer-msgs.c

    r7404 r7419  
    2525#include "crypto.h"
    2626#include "inout.h"
    27 #include "iobuf.h"
    2827#ifdef WIN32
    2928#include "net.h" /* for ECONN */
     
    875874    struct request_list tmp = REQUEST_LIST_INIT;
    876875    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->peer->io );
     876    dbgmsg( msgs, "entering `expire old requests' block" );
    877877
    878878    /* cancel requests that have been queued for too long */
     
    898898        reqListClear( &tmp );
    899899    }
     900
     901    dbgmsg( msgs, "leaving `expire old requests' block" );
    900902}
    901903
     
    10551057    /* if it's only in the queue and hasn't been sent yet, free it */
    10561058    if( reqListRemove( &msgs->clientWillAskFor, &req ) ) {
    1057         dbgmsg( msgs, "cancelling %"PRIu32":%"PRIu32"->%"PRIu32"\n", pieceIndex, offset, length );
     1059        dbgmsg( msgs, "cancelling %"PRIu32":%"PRIu32"->%"PRIu32, pieceIndex, offset, length );
    10581060        fireCancelledReq( msgs, &req );
    10591061    }
     
    10611063    /* if it's already been sent, send a cancel message too */
    10621064    if( reqListRemove( &msgs->clientAskedFor, &req ) ) {
    1063         dbgmsg( msgs, "cancelling %"PRIu32":%"PRIu32"->%"PRIu32"\n", pieceIndex, offset, length );
     1065        dbgmsg( msgs, "cancelling %"PRIu32":%"PRIu32"->%"PRIu32, pieceIndex, offset, length );
    10641066        protocolSendCancel( msgs, &req );
    10651067        fireCancelledReq( msgs, &req );
     
    17221724
    17231725static ReadState
    1724 canRead( struct tr_iobuf * iobuf, void * vmsgs, size_t * piece )
     1726canRead( tr_peerIo * io, void * vmsgs, size_t * piece )
    17251727{
    17261728    ReadState         ret;
    17271729    tr_peermsgs *     msgs = vmsgs;
    1728     struct evbuffer * in = tr_iobuf_input( iobuf );
     1730    struct evbuffer * in = tr_peerIoGetReadBuffer( io );
    17291731    const size_t      inlen = EVBUFFER_LENGTH( in );
    17301732
     
    17681770    tr_peermsgs * msgs = vmsgs;
    17691771    const double rateToClient = tr_peerGetPieceSpeed( msgs->peer, TR_PEER_TO_CLIENT );
    1770     const int estimatedBlocksInNext30Seconds =
    1771                   ( rateToClient * 30 * 1024 ) / msgs->torrent->blockSize;
     1772    const int seconds = 10;
     1773    const int estimatedBlocksInPeriod = ( rateToClient * seconds * 1024 ) / msgs->torrent->blockSize;
     1774
    17721775    msgs->minActiveRequests = 8;
    1773     msgs->maxActiveRequests = msgs->minActiveRequests + estimatedBlocksInNext30Seconds;
     1776    msgs->maxActiveRequests = msgs->minActiveRequests + estimatedBlocksInPeriod;
     1777
    17741778    if( msgs->reqq > 0 )
    17751779        msgs->maxActiveRequests = MIN( msgs->maxActiveRequests, msgs->reqq );
     1780
    17761781    return TRUE;
    17771782}
     
    18821887tr_peerMsgsPulse( tr_peermsgs * msgs )
    18831888{
    1884     if( msgs != NULL )
     1889    if( msgs )
    18851890        peerPulse( msgs );
    18861891}
    18871892
    18881893static void
    1889 gotError( struct tr_iobuf  * iobuf UNUSED,
    1890           short              what,
    1891           void             * vmsgs )
     1894gotError( tr_peerIo  * io UNUSED,
     1895          short        what,
     1896          void       * vmsgs )
    18921897{
    18931898    if( what & EVBUFFER_TIMEOUT )
     
    22402245    tellPeerWhatWeHave( m );
    22412246
    2242     tr_peerIoSetTimeoutSecs( m->peer->io, 150 ); /* timeout after N seconds of inactivity */
    22432247    tr_peerIoSetIOFuncs( m->peer->io, canRead, didWrite, gotError, m );
    22442248    ratePulse( m );
Note: See TracChangeset for help on using the changeset viewer.