Ignore:
Timestamp:
Sep 23, 2008, 7:11:04 PM (14 years ago)
Author:
charles
Message:

run libT, cli, daemon, gtk through the source-code formatter "uncrustify" as promised/threatened

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/peer-io.c

    r6791 r6795  
    44 * This file is licensed by the GPL version 2.  Works owned by the
    55 * Transmission project are granted a special exemption to clause 2(b)
    6  * so that the bulk of its code can remain under the MIT license. 
     6 * so that the bulk of its code can remain under the MIT license.
    77 * This exemption does not extend to derived works not owned by
    88 * the Transmission project.
     
    1818
    1919#ifdef WIN32
    20 #include <winsock2.h>
     20 #include <winsock2.h>
    2121#else
    22 #include <netinet/in.h> /* struct in_addr */
    23 #include <arpa/inet.h> /* inet_ntoa */
     22 #include <netinet/in.h> /* struct in_addr */
     23 #include <arpa/inet.h> /* inet_ntoa */
    2424#endif
    2525
     
    4040**/
    4141
    42 #define dbgmsg(io, fmt...) \
    43     tr_deepLog( __FILE__,__LINE__, tr_peerIoGetAddrStr(io), ##fmt )
     42#define dbgmsg( io, fmt... ) \
     43    tr_deepLog( __FILE__, __LINE__, tr_peerIoGetAddrStr( io ), ## fmt )
    4444
    4545struct tr_bandwidth
    4646{
    47     unsigned int          isUnlimited : 1;
    48     size_t                bytesUsed;
    49     size_t                bytesLeft;
     47    unsigned int    isUnlimited : 1;
     48    size_t          bytesUsed;
     49    size_t          bytesLeft;
    5050};
    5151
    5252struct tr_peerIo
    5353{
    54     unsigned int          isEncrypted : 1;
    55     unsigned int          isIncoming : 1;
    56     unsigned int          peerIdIsSet : 1;
    57     unsigned int          extendedProtocolSupported : 1;
    58     unsigned int          fastPeersSupported : 1;
    59 
    60     uint8_t               encryptionMode;
    61     uint8_t               timeout;
    62     uint16_t              port;
    63     int                   socket;
    64 
    65     uint8_t               peerId[20];
    66     time_t                timeCreated;
    67 
    68     tr_session          * session;
    69 
    70     struct in_addr        in_addr;
    71     struct bufferevent  * bufev;
    72     struct evbuffer     * output;
    73 
    74     tr_can_read_cb        canRead;
    75     tr_did_write_cb       didWrite;
    76     tr_net_error_cb       gotError;
    77     void                * userData;
    78 
    79     size_t                bufferSize[2];
    80 
    81     struct tr_bandwidth   bandwidth[2];
    82     tr_ratecontrol      * speedometer[2];
    83 
    84     tr_crypto           * crypto;
     54    unsigned int           isEncrypted              : 1;
     55    unsigned int           isIncoming                : 1;
     56    unsigned int           peerIdIsSet              : 1;
     57    unsigned int           extendedProtocolSupported : 1;
     58    unsigned int           fastPeersSupported        : 1;
     59
     60    uint8_t                encryptionMode;
     61    uint8_t                timeout;
     62    uint16_t               port;
     63    int                    socket;
     64
     65    uint8_t                peerId[20];
     66    time_t                 timeCreated;
     67
     68    tr_session *          session;
     69
     70    struct in_addr         in_addr;
     71    struct bufferevent bufev;
     72    struct evbuffer *      output;
     73
     74    tr_can_read_cb         canRead;
     75    tr_did_write_cb        didWrite;
     76    tr_net_error_cb        gotError;
     77    void *                userData;
     78
     79    size_t                 bufferSize[2];
     80
     81    struct tr_bandwidth    bandwidth[2];
     82    tr_ratecontrol *      speedometer[2];
     83
     84    tr_crypto *            crypto;
    8585};
    8686
     
    112112        /* bufev's output buffer exceeds our bandwidth allocation;
    113113           move the excess out of bufev so it can't be sent yet */
    114         const size_t desiredLength = io->bandwidth[TR_UP].bytesLeft;
    115         const size_t over = EVBUFFER_LENGTH( live ) - desiredLength;
     114        const size_t      desiredLength = io->bandwidth[TR_UP].bytesLeft;
     115        const size_t      over = EVBUFFER_LENGTH( live ) - desiredLength;
    116116        struct evbuffer * buf = evbuffer_new( );
    117117        evbuffer_add( buf, EVBUFFER_DATA( live ) + desiredLength, over );
     
    163163
    164164static void
    165 didWriteWrapper( struct bufferevent * e, void * vio )
    166 {
    167     tr_peerIo * io = vio;
     165didWriteWrapper( struct bufferevent * e,
     166                 void *               vio )
     167{
     168    tr_peerIo *  io = vio;
    168169    const size_t len = EVBUFFER_LENGTH( EVBUFFER_OUTPUT( e ) );
    169170
     
    173174    if( len < io->bufferSize[TR_UP] )
    174175    {
    175         const size_t n = io->bufferSize[TR_UP] - len;
     176        const size_t          n = io->bufferSize[TR_UP] - len;
    176177        struct tr_bandwidth * b = &io->bandwidth[TR_UP];
    177178        b->bytesLeft -= MIN( b->bytesLeft, (size_t)n );
    178179        b->bytesUsed += n;
    179180        tr_rcTransferred( io->speedometer[TR_UP], n );
    180         dbgmsg( io, "wrote %zu bytes to peer... upload bytesLeft is now %zu",
    181                 n, b->bytesLeft );
     181        dbgmsg( io,
     182                "wrote %zu bytes to peer... upload bytesLeft is now %zu",
     183                n,
     184                b->bytesLeft );
    182185    }
    183186
     
    189192
    190193static void
    191 canReadWrapper( struct bufferevent * e, void * vio )
    192 {
    193     int done = 0;
    194     int err = 0;
    195     tr_peerIo * io = vio;
     194canReadWrapper( struct bufferevent * e,
     195                void *               vio )
     196{
     197    int          done = 0;
     198    int          err = 0;
     199    tr_peerIo *  io = vio;
    196200    tr_session * session = io->session;
    197201    const size_t len = EVBUFFER_LENGTH( EVBUFFER_INPUT( e ) );
     
    202206    if( len > io->bufferSize[TR_DOWN] )
    203207    {
    204         const size_t n = len - io->bufferSize[TR_DOWN];
     208        const size_t          n = len - io->bufferSize[TR_DOWN];
    205209        struct tr_bandwidth * b = io->bandwidth + TR_DOWN;
    206210        b->bytesLeft -= MIN( b->bytesLeft, (size_t)n );
    207211        b->bytesUsed += n;
    208212        tr_rcTransferred( io->speedometer[TR_DOWN], n );
    209         dbgmsg( io, "%zu new input bytes. bytesUsed is %zu, bytesLeft is %zu",
    210                 n, b->bytesUsed, b->bytesLeft );
     213        dbgmsg( io,
     214                "%zu new input bytes. bytesUsed is %zu, bytesLeft is %zu",
     215                n, b->bytesUsed,
     216                b->bytesLeft );
    211217
    212218        adjustInputBuffer( io );
     
    229235                    done = 1;
    230236                    break;
     237
    231238                case READ_LATER:
    232239                    done = 1;
    233240                    break;
     241
    234242                case READ_ERR:
    235243                    err = 1;
     
    246254
    247255static void
    248 gotErrorWrapper( struct bufferevent * e, short what, void * userData )
     256gotErrorWrapper( struct bufferevent * e,
     257                 short                what,
     258                 void *               userData )
    249259{
    250260    tr_peerIo * c = userData;
     261
    251262    if( c->gotError )
    252263        c->gotError( e, what, c->userData );
     
    272283    bufferevent_settimeout( io->bufev, io->timeout, io->timeout );
    273284
    274     bufferevent_enable( io->bufev, EV_READ|EV_WRITE );
     285    bufferevent_enable( io->bufev, EV_READ | EV_WRITE );
    275286}
    276287
    277288static tr_peerIo*
    278 tr_peerIoNew( tr_session             * session,
    279               const struct in_addr   * in_addr,
    280               uint16_t                 port,
    281               const uint8_t          * torrentHash,
    282               int                      isIncoming,
    283               int                      socket )
     289tr_peerIoNew( tr_session *          session,
     290              const struct in_addr * in_addr,
     291              uint16_t               port,
     292              const uint8_t *        torrentHash,
     293              int                    isIncoming,
     294              int                    socket )
    284295{
    285296    tr_peerIo * io;
     
    307318
    308319tr_peerIo*
    309 tr_peerIoNewIncoming( tr_session            * session,
    310                       const struct in_addr  * in_addr,
    311                       uint16_t                port,
    312                       int                     socket )
     320tr_peerIoNewIncoming( tr_session *          session,
     321                      const struct in_addr * in_addr,
     322                      uint16_t               port,
     323                      int                    socket )
    313324{
    314325    assert( session );
     
    322333
    323334tr_peerIo*
    324 tr_peerIoNewOutgoing( tr_session            * session,
    325                       const struct in_addr  * in_addr,
    326                       int                     port,
    327                       const uint8_t         * torrentHash )
     335tr_peerIoNewOutgoing( tr_session *          session,
     336                      const struct in_addr * in_addr,
     337                      int                    port,
     338                      const uint8_t *        torrentHash )
    328339{
    329340    int socket;
     
    337348
    338349    return socket < 0
    339         ? NULL
    340         : tr_peerIoNew( session, in_addr, port, torrentHash, 0, socket );
     350           ? NULL
     351           : tr_peerIoNew( session, in_addr, port, torrentHash, 0, socket );
    341352}
    342353
     
    377388
    378389const struct in_addr*
    379 tr_peerIoGetAddress( const tr_peerIo * io, uint16_t * port )
     390tr_peerIoGetAddress( const tr_peerIo * io,
     391                           uint16_t * port )
    380392{
    381393    assert( io );
    382394
    383395    if( port )
    384        *port = io->port;
     396        *port = io->port;
    385397
    386398    return &io->in_addr;
     
    388400
    389401const char*
    390 tr_peerIoAddrStr( const struct in_addr * addr, uint16_t port )
     402tr_peerIoAddrStr( const struct in_addr * addr,
     403                  uint16_t               port )
    391404{
    392405    static char buf[512];
    393     tr_snprintf( buf, sizeof(buf), "%s:%u", inet_ntoa( *addr ), ntohs( port ) );
     406
     407    tr_snprintf( buf, sizeof( buf ), "%s:%u", inet_ntoa( *addr ),
     408                ntohs( port ) );
    394409    return buf;
    395410}
     
    408423}
    409424
    410 void 
    411 tr_peerIoSetIOFuncs( tr_peerIo          * io,
    412                      tr_can_read_cb       readcb,
    413                      tr_did_write_cb      writecb,
    414                      tr_net_error_cb      errcb,
    415                      void               * userData )
     425void
     426tr_peerIoSetIOFuncs( tr_peerIo *    io,
     427                     tr_can_read_cb  readcb,
     428                     tr_did_write_cb writecb,
     429                     tr_net_error_cb errcb,
     430                     void *          userData )
    416431{
    417432    io->canRead = readcb;
     
    438453
    439454    io->socket = tr_netOpenTCP( &io->in_addr, io->port, 0 );
    440  
     455
    441456    if( io->socket >= 0 )
    442457    {
     
    447462        return 0;
    448463    }
    449  
     464
    450465    return -1;
    451466}
    452467
    453468void
    454 tr_peerIoSetTimeoutSecs( tr_peerIo * io, int secs )
     469tr_peerIoSetTimeoutSecs( tr_peerIo * io,
     470                         int         secs )
    455471{
    456472    io->timeout = secs;
    457473    bufferevent_settimeout( io->bufev, io->timeout, io->timeout );
    458     bufferevent_enable( io->bufev, EV_READ|EV_WRITE );
    459 }
    460 
    461 /**
    462 ***
    463 **/
    464 
    465 void
    466 tr_peerIoSetTorrentHash( tr_peerIo     * io,
     474    bufferevent_enable( io->bufev, EV_READ | EV_WRITE );
     475}
     476
     477/**
     478***
     479**/
     480
     481void
     482tr_peerIoSetTorrentHash( tr_peerIo *    io,
    467483                         const uint8_t * hash )
    468484{
     
    495511
    496512void
    497 tr_peerIoSetPeersId( tr_peerIo     * io,
     513tr_peerIoSetPeersId( tr_peerIo *    io,
    498514                     const uint8_t * peer_id )
    499515{
    500516    assert( io );
    501517
    502     if(( io->peerIdIsSet = peer_id != NULL ))
     518    if( ( io->peerIdIsSet = peer_id != NULL ) )
    503519        memcpy( io->peerId, peer_id, 20 );
    504520    else
     
    506522}
    507523
    508 const uint8_t* 
     524const uint8_t*
    509525tr_peerIoGetPeersId( const tr_peerIo * io )
    510526{
     
    520536
    521537void
    522 tr_peerIoEnableLTEP( tr_peerIo * io, int flag )
    523 {
    524     assert( io );
    525     assert( flag==0 || flag==1 );
    526    
     538tr_peerIoEnableLTEP( tr_peerIo * io,
     539                     int         flag )
     540{
     541    assert( io );
     542    assert( flag == 0 || flag == 1 );
     543
    527544    io->extendedProtocolSupported = flag;
    528545}
    529546
    530547void
    531 tr_peerIoEnableFEXT( tr_peerIo * io, int flag )
    532 {
    533     assert( io );
    534     assert( flag==0 || flag==1 );
    535    
     548tr_peerIoEnableFEXT( tr_peerIo * io,
     549                     int         flag )
     550{
     551    assert( io );
     552    assert( flag == 0 || flag == 1 );
     553
    536554    io->fastPeersSupported = flag;
    537555}
     
    541559{
    542560    assert( io );
    543    
     561
    544562    return io->extendedProtocolSupported;
    545563}
     
    549567{
    550568    assert( io );
    551    
     569
    552570    return io->fastPeersSupported;
    553571}
     
    558576
    559577size_t
    560 tr_peerIoGetBandwidthUsed( const tr_peerIo  * io,
    561                            tr_direction       direction )
    562 {
    563     assert( io );
    564     assert( direction==TR_UP || direction==TR_DOWN );
     578tr_peerIoGetBandwidthUsed( const tr_peerIo * io,
     579                           tr_direction      direction )
     580{
     581    assert( io );
     582    assert( direction == TR_UP || direction == TR_DOWN );
    565583    return io->bandwidth[direction].bytesUsed;
    566584}
    567585
    568586size_t
    569 tr_peerIoGetBandwidthLeft( const tr_peerIo  * io,
    570                            tr_direction       direction )
    571 {
    572     assert( io );
    573     assert( direction==TR_UP || direction==TR_DOWN );
     587tr_peerIoGetBandwidthLeft( const tr_peerIo * io,
     588                           tr_direction      direction )
     589{
     590    assert( io );
     591    assert( direction == TR_UP || direction == TR_DOWN );
    574592    return io->bandwidth[direction].bytesLeft;
    575593}
     
    579597{
    580598    const size_t desiredBufferLen = 4096;
    581     const size_t currentLiveLen = EVBUFFER_LENGTH( EVBUFFER_OUTPUT( io->bufev ) );
     599    const size_t currentLiveLen =
     600        EVBUFFER_LENGTH( EVBUFFER_OUTPUT( io->bufev ) );
    582601
    583602    const size_t desiredLiveLen = tr_peerIoGetBandwidthLeft( io, TR_UP );
     
    587606    const size_t currentLen = currentLiveLen + currentLbufLen;
    588607
    589     size_t freeSpace = 0;
     608    size_t       freeSpace = 0;
    590609
    591610    if( desiredLen > currentLen )
     
    598617
    599618void
    600 tr_peerIoSetBandwidth( tr_peerIo     * io,
    601                        tr_direction    direction,
    602                        size_t          bytesLeft )
     619tr_peerIoSetBandwidth( tr_peerIo * io,
     620                       tr_direction direction,
     621                       size_t       bytesLeft )
    603622{
    604623    struct tr_bandwidth * b;
    605624
    606625    assert( io );
    607     assert( direction==TR_UP || direction==TR_DOWN );
    608 
    609     b = io->bandwidth + direction;   
     626    assert( direction == TR_UP || direction == TR_DOWN );
     627
     628    b = io->bandwidth + direction;
    610629    b->isUnlimited = 0;
    611630    b->bytesUsed = 0;
     
    617636
    618637void
    619 tr_peerIoSetBandwidthUnlimited( tr_peerIo     * io,
    620                                 tr_direction    direction )
     638tr_peerIoSetBandwidthUnlimited( tr_peerIo * io,
     639                                tr_direction direction )
    621640{
    622641    struct tr_bandwidth * b;
    623642
    624643    assert( io );
    625     assert( direction==TR_UP || direction==TR_DOWN );
     644    assert( direction == TR_UP || direction == TR_DOWN );
    626645
    627646    b = io->bandwidth + direction;
     
    646665}
    647666
    648 
    649 /**
    650 ***
    651 **/
    652 
    653 tr_crypto*
     667/**
     668***
     669**/
     670
     671tr_crypto*
    654672tr_peerIoGetCrypto( tr_peerIo * c )
    655673{
     
    657675}
    658676
    659 void 
     677void
    660678tr_peerIoSetEncryption( tr_peerIo * io,
    661679                        int         encryptionMode )
    662680{
    663681    assert( io );
    664     assert( encryptionMode==PEER_ENCRYPTION_NONE
    665          || encryptionMode==PEER_ENCRYPTION_RC4 );
     682    assert( encryptionMode == PEER_ENCRYPTION_NONE
     683          || encryptionMode == PEER_ENCRYPTION_RC4 );
    666684
    667685    io->encryptionMode = encryptionMode;
     
    671689tr_peerIoIsEncrypted( const tr_peerIo * io )
    672690{
    673     return io!=NULL && io->encryptionMode==PEER_ENCRYPTION_RC4;
     691    return io != NULL && io->encryptionMode == PEER_ENCRYPTION_RC4;
    674692}
    675693
     
    679697
    680698int
    681 tr_peerIoWantsBandwidth( const tr_peerIo * io, tr_direction direction )
    682 {
    683     assert( direction==TR_UP || direction==TR_DOWN );
     699tr_peerIoWantsBandwidth( const tr_peerIo * io,
     700                         tr_direction      direction )
     701{
     702    assert( direction == TR_UP || direction == TR_DOWN );
    684703
    685704    if( direction == TR_DOWN )
     
    690709    {
    691710        return EVBUFFER_LENGTH( EVBUFFER_OUTPUT( io->bufev ) )
    692             || EVBUFFER_LENGTH( io->output );
    693     }
    694 }
    695 
    696 void
    697 tr_peerIoWrite( tr_peerIo   * io,
    698                 const void  * writeme,
    699                 size_t        writemeLen )
     711               || EVBUFFER_LENGTH( io->output );
     712    }
     713}
     714
     715void
     716tr_peerIoWrite( tr_peerIo * io,
     717                const void * writeme,
     718                size_t       writemeLen )
    700719{
    701720    assert( tr_amInEventThread( io->session ) );
     
    711730
    712731void
    713 tr_peerIoWriteBuf( tr_peerIo       * io,
     732tr_peerIoWriteBuf( tr_peerIo *      io,
    714733                   struct evbuffer * buf )
    715734{
    716735    const size_t n = EVBUFFER_LENGTH( buf );
     736
    717737    tr_peerIoWrite( io, EVBUFFER_DATA( buf ), n );
    718738    evbuffer_drain( buf, n );
     
    724744
    725745void
    726 tr_peerIoWriteBytes( tr_peerIo        * io,
    727                      struct evbuffer  * outbuf,
    728                      const void       * bytes,
    729                      size_t             byteCount )
     746tr_peerIoWriteBytes( tr_peerIo *      io,
     747                     struct evbuffer * outbuf,
     748                     const void *      bytes,
     749                     size_t            byteCount )
    730750{
    731751    uint8_t * tmp;
     
    750770
    751771void
    752 tr_peerIoWriteUint8( tr_peerIo        * io,
    753                      struct evbuffer  * outbuf,
    754                      uint8_t            writeme )
    755 {
    756     tr_peerIoWriteBytes( io, outbuf, &writeme, sizeof(uint8_t) );
    757 }
    758 
    759 void
    760 tr_peerIoWriteUint16( tr_peerIo        * io,
    761                       struct evbuffer  * outbuf,
    762                       uint16_t           writeme )
     772tr_peerIoWriteUint8( tr_peerIo *      io,
     773                     struct evbuffer * outbuf,
     774                     uint8_t           writeme )
     775{
     776    tr_peerIoWriteBytes( io, outbuf, &writeme, sizeof( uint8_t ) );
     777}
     778
     779void
     780tr_peerIoWriteUint16( tr_peerIo *      io,
     781                      struct evbuffer * outbuf,
     782                      uint16_t          writeme )
    763783{
    764784    uint16_t tmp = htons( writeme );
    765     tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof(uint16_t) );
    766 }
    767 
    768 void
    769 tr_peerIoWriteUint32( tr_peerIo        * io,
    770                       struct evbuffer  * outbuf,
    771                       uint32_t           writeme )
     785
     786    tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof( uint16_t ) );
     787}
     788
     789void
     790tr_peerIoWriteUint32( tr_peerIo *       io,
     791                      struct evbuffer * outbuf,
     792                      uint32_t          writeme )
    772793{
    773794    uint32_t tmp = htonl( writeme );
    774     tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof(uint32_t) );
     795
     796    tr_peerIoWriteBytes( io, outbuf, &tmp, sizeof( uint32_t ) );
    775797}
    776798
     
    780802
    781803void
    782 tr_peerIoReadBytes( tr_peerIo        * io,
    783                     struct evbuffer  * inbuf,
    784                     void             * bytes,
    785                     size_t             byteCount )
     804tr_peerIoReadBytes( tr_peerIo *      io,
     805                    struct evbuffer * inbuf,
     806                    void *            bytes,
     807                    size_t            byteCount )
    786808{
    787809    assert( EVBUFFER_LENGTH( inbuf ) >= byteCount );
     
    804826
    805827void
    806 tr_peerIoReadUint8( tr_peerIo         * io,
    807                     struct evbuffer   * inbuf,
    808                     uint8_t           * setme )
    809 {
    810     tr_peerIoReadBytes( io, inbuf, setme, sizeof(uint8_t) );
    811 }
    812 
    813 void
    814 tr_peerIoReadUint16( tr_peerIo         * io,
    815                      struct evbuffer   * inbuf,
    816                      uint16_t          * setme )
     828tr_peerIoReadUint8( tr_peerIo *      io,
     829                    struct evbuffer * inbuf,
     830                    uint8_t *        setme )
     831{
     832    tr_peerIoReadBytes( io, inbuf, setme, sizeof( uint8_t ) );
     833}
     834
     835void
     836tr_peerIoReadUint16( tr_peerIo *      io,
     837                     struct evbuffer * inbuf,
     838                     uint16_t *        setme )
    817839{
    818840    uint16_t tmp;
    819     tr_peerIoReadBytes( io, inbuf, &tmp, sizeof(uint16_t) );
     841
     842    tr_peerIoReadBytes( io, inbuf, &tmp, sizeof( uint16_t ) );
    820843    *setme = ntohs( tmp );
    821844}
    822845
    823846void
    824 tr_peerIoReadUint32( tr_peerIo         * io,
    825                      struct evbuffer   * inbuf,
    826                      uint32_t          * setme )
     847tr_peerIoReadUint32( tr_peerIo *      io,
     848                     struct evbuffer * inbuf,
     849                     uint32_t *        setme )
    827850{
    828851    uint32_t tmp;
    829     tr_peerIoReadBytes( io, inbuf, &tmp, sizeof(uint32_t) );
     852
     853    tr_peerIoReadBytes( io, inbuf, &tmp, sizeof( uint32_t ) );
    830854    *setme = ntohl( tmp );
    831855}
    832856
    833857void
    834 tr_peerIoDrain( tr_peerIo        * io,
    835                 struct evbuffer  * inbuf,
    836                 size_t             byteCount )
     858tr_peerIoDrain( tr_peerIo *      io,
     859                struct evbuffer * inbuf,
     860                size_t            byteCount )
    837861{
    838862    uint8_t * tmp = tr_new( uint8_t, byteCount );
     863
    839864    tr_peerIoReadBytes( io, inbuf, tmp, byteCount );
    840865    tr_free( tmp );
     
    846871    return time( NULL ) - io->timeCreated;
    847872}
     873
Note: See TracChangeset for help on using the changeset viewer.