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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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}
Note: See TracChangeset for help on using the changeset viewer.