Changeset 7289


Ignore:
Timestamp:
Dec 5, 2008, 10:56:19 PM (12 years ago)
Author:
charles
Message:

(libT) minor cleanup: using tr_bool, fixing up bad code indentation, using %zu on size_t instead of casting to int...

Location:
trunk/libtransmission
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/handshake.c

    r7266 r7289  
    247247    uint8_t hash[SHA_DIGEST_LENGTH];
    248248
    249     dbgmsg( handshake, "payload: need %d, got %d", (int)HANDSHAKE_SIZE,
    250            (int)EVBUFFER_LENGTH( inbuf ) );
     249    dbgmsg( handshake, "payload: need %d, got %zu",
     250            (int)HANDSHAKE_SIZE, EVBUFFER_LENGTH( inbuf ) );
    251251
    252252    if( EVBUFFER_LENGTH( inbuf ) < HANDSHAKE_SIZE )
     
    396396        return READ_LATER;
    397397
    398     isEncrypted = memcmp( EVBUFFER_DATA(
    399                               inbuf ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
     398    isEncrypted = memcmp( EVBUFFER_DATA( inbuf ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
    400399    if( isEncrypted )
    401400    {
     
    408407           ( isEncrypted ? "encrypted" : "plaintext" ) );
    409408
    410     tr_peerIoSetEncryption(
    411         handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
    412         : PEER_ENCRYPTION_NONE );
     409    tr_peerIoSetEncryption( handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
     410                                                       : PEER_ENCRYPTION_NONE );
    413411    if( !isEncrypted )
    414412    {
     
    440438        uint8_t buf[SHA_DIGEST_LENGTH];
    441439        tr_sha1( req2, "req2", 4,
    442                  tr_cryptoGetTorrentHash(
    443                      handshake->crypto ), SHA_DIGEST_LENGTH, NULL );
     440                 tr_cryptoGetTorrentHash( handshake->crypto ),
     441                 SHA_DIGEST_LENGTH, NULL );
    444442        tr_sha1( req3, "req3", 4, secret, KEY_LEN, NULL );
    445443        for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
     
    562560    uint8_t *    tmp;
    563561
    564     dbgmsg( handshake, "pad d: need %d, got %d", (int)needlen,
    565            (int)EVBUFFER_LENGTH(
    566                inbuf ) );
     562    dbgmsg( handshake, "pad d: need %zu, got %zu",
     563            needlen, EVBUFFER_LENGTH( inbuf ) );
    567564    if( EVBUFFER_LENGTH( inbuf ) < needlen )
    568565        return READ_LATER;
     
    594591    uint8_t   hash[SHA_DIGEST_LENGTH];
    595592
    596     dbgmsg( handshake, "payload: need %d, got %d",
    597            (int)INCOMING_HANDSHAKE_LEN, (int)EVBUFFER_LENGTH(
    598                inbuf ) );
     593    dbgmsg( handshake, "payload: need %d, got %zu",
     594            (int)INCOMING_HANDSHAKE_LEN, EVBUFFER_LENGTH( inbuf ) );
    599595
    600596    if( EVBUFFER_LENGTH( inbuf ) < INCOMING_HANDSHAKE_LEN )
     
    714710
    715711    /* peer id */
    716     tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id,
    717                         PEER_ID_LEN );
     712    tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id, PEER_ID_LEN );
    718713    tr_peerIoSetPeersId( handshake->io, handshake->peer_id );
    719714    handshake->havePeerID = TRUE;
    720715    tr_clientForId( client, sizeof( client ), handshake->peer_id );
    721716    dbgmsg( handshake, "peer-id is [%s] ... isIncoming is %d", client,
    722            tr_peerIoIsIncoming(
    723                handshake->io ) );
     717            tr_peerIoIsIncoming( handshake->io ) );
    724718
    725719    /* if we've somehow connected to ourselves, don't keep the connection */
     
    739733    int            len;
    740734
    741     dbgmsg( handshake, "in readYa... need %d, have %d", (int)KEY_LEN,
    742            (int)EVBUFFER_LENGTH(
    743                inbuf ) );
     735    dbgmsg( handshake, "in readYa... need %d, have %zu",
     736            (int)KEY_LEN, EVBUFFER_LENGTH( inbuf ) );
    744737    if( EVBUFFER_LENGTH( inbuf ) < KEY_LEN )
    745738        return READ_LATER;
     
    772765    uint8_t * pch;
    773766
    774     dbgmsg(
    775          handshake,
    776         "looking to get past pad a... & resync on hash('req',S) ... have %d bytes",
    777         (int)EVBUFFER_LENGTH( inbuf ) );
     767    dbgmsg( handshake, "looking to get past pad a... & resync on hash('req',S) ... have %zu bytes",
     768            EVBUFFER_LENGTH( inbuf ) );
    778769    /**
    779770    *** Resynchronizing on HASH('req1',S)
     
    785776    if( pch == NULL )
    786777    {
    787         dbgmsg( handshake, "no luck so far.. draining %d bytes",
    788                (int)EVBUFFER_LENGTH(
    789                    inbuf ) );
     778        dbgmsg( handshake, "no luck so far.. draining %zu bytes",
     779                EVBUFFER_LENGTH( inbuf ) );
    790780        evbuffer_drain( inbuf, EVBUFFER_LENGTH( inbuf ) );
    791781        return READ_LATER;
     
    850840                                               obfuscatedTorrentHash ) ) )
    851841    {
    852         dbgmsg(
    853             handshake,
    854             "got INCOMING connection's encrypted handshake for torrent [%s]",
    855             tor->info.name );
     842        dbgmsg( handshake, "got INCOMING connection's encrypted handshake for torrent [%s]",
     843                tor->info.name );
    856844        tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
    857845        if( !tr_torrentAllowsPex( tor )
     
    914902    uint32_t          crypto_select;
    915903
    916     dbgmsg( handshake, "reading IA... have %d, need %d",
    917             (int)EVBUFFER_LENGTH(
    918                 inbuf ), (int)needlen );
     904    dbgmsg( handshake, "reading IA... have %zu, need %zu",
     905            EVBUFFER_LENGTH( inbuf ), needlen );
    919906    if( EVBUFFER_LENGTH( inbuf ) < needlen )
    920907        return READ_LATER;
    921908
    922909    /**
    923     ***  B->A: ENCRYPT(VC, crypto_select, len(padD), padD), ENCRYPT2(Payload
    924     ***Stream)
     910    ***  B->A: ENCRYPT(VC, crypto_select, len(padD), padD), ENCRYPT2(Payload Stream)
    925911    **/
    926912
     
    951937
    952938    dbgmsg( handshake, "sending pad d" );
    953     /* ENCRYPT(VC, crypto_provide, len(PadC), PadC
     939    /* ENCRYPT(VC, crypto_provide, len(PadD), PadD
    954940     * PadD is reserved for future extensions to the handshake...
    955941     * standard practice at this time is for it to be zero-length */
     
    989975    const size_t      needlen = HANDSHAKE_SIZE;
    990976
    991     dbgmsg( handshake, "reading payload stream... have %d, need %d",
    992             (int)EVBUFFER_LENGTH( inbuf ), (int)needlen );
     977    dbgmsg( handshake, "reading payload stream... have %zu, need %zu",
     978            EVBUFFER_LENGTH( inbuf ), needlen );
    993979    if( EVBUFFER_LENGTH( inbuf ) < needlen )
    994980        return READ_LATER;
     
    1013999canRead( struct tr_iobuf * iobuf, void * arg, size_t * piece )
    10141000{
    1015     tr_handshake *    handshake = arg;
     1001    tr_handshake    * handshake = arg;
    10161002    struct evbuffer * inbuf = tr_iobuf_input( iobuf );
    10171003    ReadState         ret;
    1018     int               readyForMore = TRUE;
     1004    tr_bool           readyForMore = TRUE;
    10191005
    10201006    /* no piece data in handshake */
  • trunk/libtransmission/handshake.h

    r7231 r7289  
    2525
    2626/* returns true on success, false on error */
    27 typedef int ( *handshakeDoneCB )( struct tr_handshake * handshake,
    28                                   struct tr_peerIo *    io,
    29                                   int                   isConnected,
    30                                   const uint8_t *       peerId,
    31                                   void *                userData );
     27typedef tr_bool ( *handshakeDoneCB )( struct tr_handshake * handshake,
     28                                      struct tr_peerIo *    io,
     29                                      int                   isConnected,
     30                                      const uint8_t *       peerId,
     31                                      void *                userData );
    3232
    3333tr_handshake *         tr_handshakeNew( struct tr_peerIo * io,
  • trunk/libtransmission/peer-io.c

    r7234 r7289  
    496496void
    497497tr_peerIoEnableFEXT( tr_peerIo * io,
    498                      int         flag )
     498                     tr_bool     flag )
    499499{
    500500    assert( isPeerIo( io ) );
     
    505505}
    506506
    507 int
     507tr_bool
    508508tr_peerIoSupportsFEXT( const tr_peerIo * io )
    509509{
     
    518518
    519519void
    520 tr_peerIoEnableLTEP( tr_peerIo * io,
    521                      int         flag )
     520tr_peerIoEnableLTEP( tr_peerIo  * io,
     521                     tr_bool      flag )
    522522{
    523523    assert( isPeerIo( io ) );
     
    528528}
    529529
    530 int
     530tr_bool
    531531tr_peerIoSupportsLTEP( const tr_peerIo * io )
    532532{
  • trunk/libtransmission/peer-io.h

    r7234 r7289  
    5050**/
    5151
    52 void        tr_peerIoEnableLTEP( tr_peerIo * io, int flag );
    53 
    54 int         tr_peerIoSupportsLTEP( const tr_peerIo * io );
    55 
    56 void        tr_peerIoEnableFEXT( tr_peerIo * io, int flag );
    57 
    58 int         tr_peerIoSupportsFEXT( const tr_peerIo * io );
     52void        tr_peerIoEnableLTEP( tr_peerIo * io, tr_bool flag );
     53
     54tr_bool     tr_peerIoSupportsLTEP( const tr_peerIo * io );
     55
     56void        tr_peerIoEnableFEXT( tr_peerIo * io, tr_bool flag );
     57
     58tr_bool     tr_peerIoSupportsFEXT( const tr_peerIo * io );
    5959
    6060/**
  • trunk/libtransmission/peer-mgr.c

    r7248 r7289  
    300300}
    301301
    302 static int
     302static tr_bool
    303303peerIsInUse( const Torrent    * ct,
    304304             const tr_address * addr )
     
    309309
    310310    return getExistingPeer( t, addr )
    311            || getExistingHandshake( t->outgoingHandshakes, addr )
    312            || getExistingHandshake( t->manager->incomingHandshakes, addr );
     311        || getExistingHandshake( t->outgoingHandshakes, addr )
     312        || getExistingHandshake( t->manager->incomingHandshakes, addr );
    313313}
    314314
     
    317317{
    318318    tr_peer * p;
    319 
    320319    p = tr_new0( tr_peer, 1 );
    321320    p->addr = *addr;
     
    487486
    488487static tr_peer**
    489 getConnectedPeers( Torrent * t,
    490                    int *     setmeCount )
    491 {
    492     int       i, peerCount, connectionCount;
     488getConnectedPeers( Torrent * t, int * setmeCount )
     489{
     490    int i, peerCount, connectionCount;
    493491    tr_peer **peers;
    494492    tr_peer **ret;
     
    523521***/
    524522
    525 int
    526 tr_peerMgrPeerIsSeed( const tr_peerMgr * mgr,
    527                       const uint8_t    * torrentHash,
    528                       const tr_address * addr )
    529 {
    530     int                      isSeed = FALSE;
    531     const Torrent *          t = NULL;
     523tr_bool
     524tr_peerMgrPeerIsSeed( const tr_peerMgr   * mgr,
     525                      const uint8_t      * torrentHash,
     526                      const tr_address   * addr )
     527{
     528    tr_bool isSeed = FALSE;
     529    const Torrent * t = NULL;
    532530    const struct peer_atom * atom = NULL;
    533531
     
    593591
    594592static int
    595 compareRefillPiece( const void * aIn,
    596                     const void * bIn )
     593compareRefillPiece( const void * aIn, const void * bIn )
    597594{
    598595    const struct tr_refill_piece * a = aIn;
     
    623620
    624621static tr_piece_index_t *
    625 getPreferredPieces( Torrent           * t,
    626                     tr_piece_index_t  * pieceCount )
     622getPreferredPieces( Torrent * t, tr_piece_index_t  * pieceCount )
    627623{
    628624    const tr_torrent  * tor = t->tor;
     
    822818        for( j=0; !handled && j<peerCount; )
    823819        {
    824             const int val = tr_peerMsgsAddRequest( peers[j]->msgs, index, offset, length, FALSE );
     820            const tr_addreq_t val = tr_peerMsgsAddRequest( peers[j]->msgs, index, offset, length, FALSE );
    825821            switch( val )
    826822            {
     
    10431039            const time_t now = time( NULL );
    10441040            tr_torrent * tor = t->tor;
    1045 
    10461041            tor->activityDate = now;
    10471042
     
    10731068            {
    10741069                struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    1075                 const int          peerIsSeed = e->progress >= 1.0;
    1076                 if( peerIsSeed )
    1077                 {
    1078                     tordbg( t, "marking peer %s as a seed",
    1079                            tr_peerIoAddrStr( &atom->addr,
    1080                                              atom->port ) );
     1070                const int peerIsSeed = e->progress >= 1.0;
     1071                if( peerIsSeed ) {
     1072                    tordbg( t, "marking peer %s as a seed", tr_peerIoAddrStr( &atom->addr, atom->port ) );
    10811073                    atom->flags |= ADDED_F_SEED_FLAG;
    1082                 }
    1083                 else
    1084                 {
    1085                     tordbg( t, "marking peer %s as a non-seed",
    1086                            tr_peerIoAddrStr( &atom->addr,
    1087                                              atom->port ) );
     1074                } else {
     1075                    tordbg( t, "marking peer %s as a non-seed", tr_peerIoAddrStr( &atom->addr, atom->port ) );
    10881076                    atom->flags &= ~ADDED_F_SEED_FLAG;
    10891077                }
     
    10961084            tr_torrent *     tor = t->tor;
    10971085
    1098             tr_block_index_t block = _tr_block( tor, e->pieceIndex,
    1099                                                 e->offset );
     1086            tr_block_index_t block = _tr_block( tor, e->pieceIndex, e->offset );
    11001087
    11011088            tr_cpBlockAdd( tor->completion, block );
     
    11071094            {
    11081095                const tr_piece_index_t p = e->pieceIndex;
    1109                 const int              ok = tr_ioTestPiece( tor, p );
     1096                const tr_bool ok = tr_ioTestPiece( tor, p );
    11101097
    11111098                if( !ok )
    11121099                {
    1113                     tr_torerr( tor,
    1114                               _( "Piece %lu, which was just downloaded, failed its checksum test" ),
    1115                               (unsigned long)p );
     1100                    tr_torerr( tor, _( "Piece %lu, which was just downloaded, failed its checksum test" ),
     1101                               (unsigned long)p );
    11161102                }
    11171103
     
    11241110                else
    11251111                {
    1126                     int        i, peerCount;
     1112                    int i, peerCount;
    11271113                    tr_peer ** peers = getConnectedPeers( t, &peerCount );
    11281114                    for( i = 0; i < peerCount; ++i )
     
    11811167        a->flags = flags;
    11821168        a->from = from;
    1183         tordbg( t, "got a new atom: %s",
    1184                tr_peerIoAddrStr( &a->addr, a->port ) );
     1169        tordbg( t, "got a new atom: %s", tr_peerIoAddrStr( &a->addr, a->port ) );
    11851170        tr_ptrArrayInsertSorted( t->pool, a, comparePeerAtoms );
    11861171    }
     
    11961181getPeerCount( const Torrent * t )
    11971182{
    1198     return tr_ptrArraySize( t->peers ) + tr_ptrArraySize(
    1199                t->outgoingHandshakes );
     1183    return tr_ptrArraySize( t->peers ) + tr_ptrArraySize( t->outgoingHandshakes );
    12001184}
    12011185
    12021186/* FIXME: this is kind of a mess. */
    1203 static int
     1187static tr_bool
    12041188myHandshakeDoneCB( tr_handshake *  handshake,
    12051189                   tr_peerIo *     io,
     
    12081192                   void *          vmanager )
    12091193{
    1210     int                ok = isConnected;
    1211     int                success = FALSE;
     1194    tr_bool            ok = isConnected;
     1195    tr_bool            success = FALSE;
    12121196    tr_port            port;
    12131197    const tr_address * addr;
     
    12611245        {
    12621246            tordbg( t, "banned peer %s tried to reconnect",
    1263                    tr_peerIoAddrStr( &atom->addr,
    1264                                      atom->port ) );
     1247                    tr_peerIoAddrStr( &atom->addr, atom->port ) );
    12651248            tr_peerIoFree( io );
    12661249        }
     
    13181301    if( tr_sessionIsAddressBlocked( manager->session, addr ) )
    13191302    {
    1320         tr_dbg( "Banned IP address \"%s\" tried to connect to us",
    1321                tr_ntop_non_ts( addr ) );
     1303        tr_dbg( "Banned IP address \"%s\" tried to connect to us", tr_ntop_non_ts( addr ) );
    13221304        tr_netClose( socket );
    13231305    }
     
    14111393            if( tr_bitfieldHas( peer->blame, pieceIndex ) )
    14121394            {
    1413                 tordbg(
    1414                     t,
    1415                     "peer %s contributed to corrupt piece (%d); now has %d strikes",
    1416                     tr_peerIoAddrStr( &peer->addr, peer->port ),
    1417                     pieceIndex, (int)peer->strikes + 1 );
     1395                tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
     1396                        tr_peerIoAddrStr( &peer->addr, peer->port ),
     1397                        pieceIndex, (int)peer->strikes + 1 );
    14181398                addStrike( t, peer );
    14191399            }
     
    14231403
    14241404int
    1425 tr_pexCompare( const void * va,
    1426                const void * vb )
     1405tr_pexCompare( const void * va, const void * vb )
    14271406{
    14281407    const tr_pex * a = va;
    14291408    const tr_pex * b = vb;
    1430     int            i = tr_compareAddresses( &a->addr, &b->addr );
     1409    int i = tr_compareAddresses( &a->addr, &b->addr );
    14311410
    14321411    if( i ) return i;
     
    14361415}
    14371416
    1438 int tr_pexCompare( const void * a,
    1439                    const void * b );
    1440 
    14411417static int
    14421418peerPrefersCrypto( const tr_peer * peer )
     
    14611437    managerLock( manager );
    14621438
    1463     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
    1464     if( !t )
     1439    t = getExistingTorrent( manager, torrentHash );
     1440    if( t == NULL )
    14651441    {
    14661442        *setme_pex = NULL;
     
    14731449        tr_pex * walk = pex;
    14741450
    1475         for( i = 0; i < peerCount; ++i, ++walk )
     1451        for( i=0; i<peerCount; ++i, ++walk )
    14761452        {
    14771453            const tr_peer * peer = peers[i];
     
    16521628    tr_peer **    peers;
    16531629    tr_bitfield * pieces;
    1654 
    16551630    managerLock( manager );
    16561631
     
    16701645                          const uint8_t *    torrentHash )
    16711646{
    1672     int             ret;
     1647    int ret;
    16731648    const Torrent * t;
    1674 
    16751649    managerLock( manager );
    16761650
    16771651    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
    1678     ret = t && ( !tr_ptrArrayEmpty( t->peers )
    1679                || !tr_ptrArrayEmpty( t->webseeds ) );
     1652    ret = t && ( !tr_ptrArrayEmpty( t->peers ) || !tr_ptrArrayEmpty( t->webseeds ) );
    16801653
    16811654    managerUnlock( manager );
     
    16851658void
    16861659tr_peerMgrTorrentStats( const tr_peerMgr * manager,
    1687                         const uint8_t *    torrentHash,
    1688                         int *              setmePeersKnown,
    1689                         int *              setmePeersConnected,
    1690                         int *              setmeSeedsConnected,
    1691                         int *              setmeWebseedsSendingToUs,
    1692                         int *              setmePeersSendingToUs,
    1693                         int *              setmePeersGettingFromUs,
    1694                         int *              setmePeersFrom )
    1695 {
    1696     int                 i, size;
    1697     const Torrent *     t;
    1698     const tr_peer **    peers;
     1660                        const uint8_t    * torrentHash,
     1661                        int              * setmePeersKnown,
     1662                        int              * setmePeersConnected,
     1663                        int              * setmeSeedsConnected,
     1664                        int              * setmeWebseedsSendingToUs,
     1665                        int              * setmePeersSendingToUs,
     1666                        int              * setmePeersGettingFromUs,
     1667                        int              * setmePeersFrom )
     1668{
     1669    int i, size;
     1670    const Torrent * t;
     1671    const tr_peer ** peers;
    16991672    const tr_webseed ** webseeds;
    17001673
     
    17111684    *setmeWebseedsSendingToUs  = 0;
    17121685
    1713     for( i = 0; i < TR_PEER_FROM__MAX; ++i )
     1686    for( i=0; i<TR_PEER_FROM__MAX; ++i )
    17141687        setmePeersFrom[i] = 0;
    17151688
    1716     for( i = 0; i < size; ++i )
    1717     {
    1718         const tr_peer *          peer = peers[i];
     1689    for( i=0; i<size; ++i )
     1690    {
     1691        const tr_peer * peer = peers[i];
    17191692        const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    17201693
     
    17221695            continue;
    17231696
    1724         ++ * setmePeersConnected;
     1697        ++*setmePeersConnected;
    17251698
    17261699        ++setmePeersFrom[atom->from];
    17271700
    17281701        if( clientIsDownloadingFrom( peer ) )
    1729             ++ * setmePeersSendingToUs;
     1702            ++*setmePeersSendingToUs;
    17301703
    17311704        if( clientIsUploadingTo( peer ) )
    1732             ++ * setmePeersGettingFromUs;
     1705            ++*setmePeersGettingFromUs;
    17331706
    17341707        if( atom->flags & ADDED_F_SEED_FLAG )
    1735             ++ * setmeSeedsConnected;
     1708            ++*setmeSeedsConnected;
    17361709    }
    17371710
    17381711    webseeds = (const tr_webseed **) tr_ptrArrayPeek( t->webseeds, &size );
    1739     for( i = 0; i < size; ++i )
     1712    for( i=0; i<size; ++i )
    17401713    {
    17411714        if( tr_webseedIsActive( webseeds[i] ) )
    1742             ++ * setmeWebseedsSendingToUs;
     1715            ++*setmeWebseedsSendingToUs;
    17431716    }
    17441717
     
    17501723                     const uint8_t *    torrentHash )
    17511724{
    1752     const Torrent *     t;
     1725    const Torrent * t;
    17531726    const tr_webseed ** webseeds;
    1754     int                 i;
    1755     int                 webseedCount;
    1756     float *             ret;
     1727    int i;
     1728    int webseedCount;
     1729    float * ret;
    17571730
    17581731    assert( manager );
     
    17651738    ret = tr_new0( float, webseedCount );
    17661739
    1767     for( i = 0; i < webseedCount; ++i )
     1740    for( i=0; i<webseedCount; ++i )
    17681741        if( !tr_webseedGetSpeed( webseeds[i], &ret[i] ) )
    17691742            ret[i] = -1.0;
     
    17741747
    17751748double
    1776 tr_peerGetPieceSpeed( const tr_peer    * peer,
    1777                       tr_direction       direction )
     1749tr_peerGetPieceSpeed( const tr_peer * peer, tr_direction direction )
    17781750{
    17791751    assert( peer );
     
    18081780        tr_peer_stat *           stat = ret + i;
    18091781
    1810         tr_ntop( &peer->addr, stat->addr, sizeof( stat->addr ) );
    1811         tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
    1812                    sizeof( stat->client ) );
     1782        tr_ntop( &peer->addr, stat->addr, sizeof(stat->addr) );
     1783        tr_strlcpy( stat->client, (peer->client ? peer->client : ""), sizeof(stat->client) );
    18131784        stat->port               = ntohs( peer->port );
    18141785        stat->from               = atom->from;
     
    18321803        if( stat->isUploadingTo ) *pch++ = 'U';
    18331804        else if( stat->peerIsInterested ) *pch++ = 'u';
    1834         if( !stat->clientIsChoked && !stat->clientIsInterested ) *pch++ =
    1835                 'K';
     1805        if( !stat->clientIsChoked && !stat->clientIsInterested ) *pch++ = 'K';
    18361806        if( !stat->peerIsChoked && !stat->peerIsInterested ) *pch++ = '?';
    18371807        if( stat->isEncrypted ) *pch++ = 'E';
     
    19471917     */
    19481918    unchokedInterested = 0;
    1949     for( i = 0; i < size && unchokedInterested < MAX_UNCHOKED_PEERS; ++i )
    1950     {
     1919    for( i=0; i<size && unchokedInterested<MAX_UNCHOKED_PEERS; ++i ) {
    19511920        choke[i].doUnchoke = 1;
    19521921        if( choke[i].isInterested )
     
    19571926    if( i < size )
    19581927    {
    1959         int                n;
     1928        int n;
    19601929        struct ChokeData * c;
    1961         tr_ptrArray *      randPool = tr_ptrArrayNew( );
    1962 
    1963         for( ; i < size; ++i )
     1930        tr_ptrArray * randPool = tr_ptrArrayNew( );
     1931
     1932        for( ; i<size; ++i )
    19641933        {
    19651934            if( choke[i].isInterested )
    19661935            {
    19671936                const tr_peer * peer = choke[i].peer;
    1968                 int             x = 1, y;
     1937                int x = 1, y;
    19691938                if( isNew( peer ) ) x *= 3;
    19701939                if( isSame( peer ) ) x *= 3;
    1971                 for( y = 0; y < x; ++y )
     1940                for( y=0; y<x; ++y )
    19721941                    tr_ptrArrayAppend( randPool, &choke[i] );
    19731942            }
    19741943        }
    19751944
    1976         if( ( n = tr_ptrArraySize( randPool ) ) )
     1945        if(( n = tr_ptrArraySize( randPool )))
    19771946        {
    1978             c = tr_ptrArrayNth( randPool, tr_cryptoWeakRandInt( n ) );
     1947            c = tr_ptrArrayNth( randPool, tr_cryptoWeakRandInt( n ));
    19791948            c->doUnchoke = 1;
    19801949            t->optimistic = c->peer;
     
    20221991    {
    20231992        tordbg( t, "purging peer %s because its doPurge flag is set",
    2024                tr_peerIoAddrStr( &atom->addr,
    2025                                  atom->port ) );
     1993                tr_peerIoAddrStr( &atom->addr, atom->port ) );
    20261994        return TRUE;
    20271995    }
     
    20362004        else if( peer->progress < tr_cpPercentDone( tor->completion ) )
    20372005            peerHasEverything = FALSE;
    2038         else
    2039         {
    2040             tr_bitfield * tmp =
    2041                 tr_bitfieldDup( tr_cpPieceBitfield( tor->completion ) );
     2006        else {
     2007            tr_bitfield * tmp = tr_bitfieldDup( tr_cpPieceBitfield( tor->completion ) );
    20422008            tr_bitfieldDifference( tmp, peer->have );
    20432009            peerHasEverything = tr_bitfieldCountTrueBits( tmp ) == 0;
    20442010            tr_bitfieldFree( tmp );
    20452011        }
    2046         if( peerHasEverything
    2047           && ( !tr_torrentAllowsPex( tor ) || ( now - atom->time >= 30 ) ) )
    2048         {
     2012        if( peerHasEverything && ( !tr_torrentAllowsPex(tor) || (now-atom->time>=30 ))) {
    20492013            tordbg( t, "purging peer %s because we're both seeds",
    2050                    tr_peerIoAddrStr( &atom->addr,
    2051                                      atom->port ) );
     2014                   tr_peerIoAddrStr( &atom->addr, atom->port ) );
    20522015            return TRUE;
    20532016        }
     
    20572020     * this is on a sliding scale based on number of available peers... */
    20582021    {
    2059         const int    relaxStrictnessIfFewerThanN =
    2060             (int)( ( getMaxPeerCount( tor ) * 0.9 ) + 0.5 );
     2022        const int relaxStrictnessIfFewerThanN = (int)( ( getMaxPeerCount( tor ) * 0.9 ) + 0.5 );
    20612023        /* if we have >= relaxIfFewerThan, strictness is 100%.
    20622024         * if we have zero connections, strictness is 0% */
    2063         const float  strictness = peerCount >= relaxStrictnessIfFewerThanN
    2064                                   ? 1.0
    2065                                   : peerCount /
    2066                                   (float)relaxStrictnessIfFewerThanN;
    2067         const int    lo = MIN_UPLOAD_IDLE_SECS;
    2068         const int    hi = MAX_UPLOAD_IDLE_SECS;
    2069         const int    limit = lo + ( ( hi - lo ) * strictness );
     2025        const float strictness = peerCount >= relaxStrictnessIfFewerThanN
     2026            ? 1.0
     2027            : peerCount / (float)relaxStrictnessIfFewerThanN;
     2028        const int lo = MIN_UPLOAD_IDLE_SECS;
     2029        const int hi = MAX_UPLOAD_IDLE_SECS;
     2030        const int limit = lo + ( ( hi - lo ) * strictness );
    20702031        const time_t then = peer->pieceDataActivityDate;
    2071         const int    idleTime = then ? ( now - then ) : 0;
    2072         if( idleTime > limit )
    2073         {
    2074             tordbg(
    2075                 t,
    2076                 "purging peer %s because it's been %d secs since we shared anything",
    2077                 tr_peerIoAddrStr( &atom->addr, atom->port ), idleTime );
     2032        const int idleTime = then ? ( now - then ) : 0;
     2033        if( idleTime > limit ) {
     2034            tordbg( t, "purging peer %s because it's been %d secs since we shared anything",
     2035                       tr_peerIoAddrStr( &atom->addr, atom->port ), idleTime );
    20782036            return TRUE;
    20792037        }
     
    20842042
    20852043static tr_peer **
    2086 getPeersToClose( Torrent * t,
    2087                  int *     setmeSize )
    2088 {
    2089     int               i, peerCount, outsize;
    2090     tr_peer **        peers = (tr_peer**) tr_ptrArrayPeek( t->peers,
    2091                                                            &peerCount );
     2044getPeersToClose( Torrent * t, int * setmeSize )
     2045{
     2046    int i, peerCount, outsize;
     2047    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek( t->peers, &peerCount );
    20922048    struct tr_peer ** ret = tr_new( tr_peer *, peerCount );
    20932049
     
    21422098     * data, try to reconnect to them sooner rather that later -- we don't
    21432099     * want network troubles to get in the way of a good peer. */
    2144     if( ( now - atom->piece_data_time ) <=
    2145        ( MINIMUM_RECONNECT_INTERVAL_SECS * 2 ) )
     2100    if( ( now - atom->piece_data_time ) <= ( MINIMUM_RECONNECT_INTERVAL_SECS * 2 ) )
    21462101        sec = MINIMUM_RECONNECT_INTERVAL_SECS;
    21472102
     
    21522107    /* otherwise, the interval depends on how many times we've tried
    21532108     * and failed to connect to the peer */
    2154     else switch( atom->numFails )
    2155         {
    2156             case 0:
    2157                 sec = 0; break;
    2158 
    2159             case 1:
    2160                 sec = 5; break;
    2161 
    2162             case 2:
    2163                 sec = 2 * 60; break;
    2164 
    2165             case 3:
    2166                 sec = 15 * 60; break;
    2167 
    2168             case 4:
    2169                 sec = 30 * 60; break;
    2170 
    2171             case 5:
    2172                 sec = 60 * 60; break;
    2173 
    2174             default:
    2175                 sec = 120 * 60; break;
    2176         }
     2109    else switch( atom->numFails ) {
     2110        case 0: sec = 0; break;
     2111        case 1: sec = 5; break;
     2112        case 2: sec = 2 * 60; break;
     2113        case 3: sec = 15 * 60; break;
     2114        case 4: sec = 30 * 60; break;
     2115        case 5: sec = 60 * 60; break;
     2116        default: sec = 120 * 60; break;
     2117    }
    21772118
    21782119    return sec;
     
    21802121
    21812122static struct peer_atom **
    2182 getPeerCandidates(                               Torrent * t,
    2183                                            int * setmeSize )
     2123getPeerCandidates( Torrent * t, int * setmeSize )
    21842124{
    21852125    int                 i, atomCount, retCount;
     
    22222162        if( ( now - atom->time ) < interval )
    22232163        {
    2224             tordbg(
    2225                 t,
    2226                 "RECONNECT peer %d (%s) is in its grace period of %d seconds..",
    2227                 i, tr_peerIoAddrStr( &atom->addr,
    2228                                      atom->port ), interval );
     2164            tordbg( t, "RECONNECT peer %d (%s) is in its grace period of %d seconds..",
     2165                    i, tr_peerIoAddrStr( &atom->addr, atom->port ), interval );
    22292166            continue;
    22302167        }
     
    22652202    else
    22662203    {
    2267         int                 i, nCandidates, nBad;
     2204        int i, nCandidates, nBad;
    22682205        struct peer_atom ** candidates = getPeerCandidates( t, &nCandidates );
    2269         struct tr_peer **   connections = getPeersToClose( t, &nBad );
     2206        struct tr_peer ** connections = getPeersToClose( t, &nBad );
    22702207
    22712208        if( nBad || nCandidates )
    2272             tordbg(
    2273                 t, "reconnect pulse for [%s]: %d bad connections, "
     2209            tordbg( t, "reconnect pulse for [%s]: %d bad connections, "
    22742210                   "%d connection candidates, %d atoms, max per pulse is %d",
    2275                 t->tor->info.name, nBad, nCandidates,
    2276                 tr_ptrArraySize( t->pool ),
    2277                 (int)MAX_RECONNECTIONS_PER_PULSE );
     2211                   t->tor->info.name, nBad, nCandidates,
     2212                   tr_ptrArraySize( t->pool ),
     2213                   (int)MAX_RECONNECTIONS_PER_PULSE );
    22782214
    22792215        /* disconnect some peers.
     
    22812217           so reset their `numFails' weight to zero.  otherwise we connected
    22822218           to them fruitlessly, so mark it as another fail */
    2283         for( i = 0; i < nBad; ++i )
    2284         {
    2285             tr_peer *          peer = connections[i];
     2219        for( i = 0; i < nBad; ++i ) {
     2220            tr_peer * peer = connections[i];
    22862221            struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    22872222            if( peer->pieceDataActivityDate )
     
    22892224            else
    22902225                ++atom->numFails;
    2291             tordbg( t, "removing bad peer %s",
    2292                    tr_peerIoGetAddrStr( peer->io ) );
     2226            tordbg( t, "removing bad peer %s", tr_peerIoGetAddrStr( peer->io ) );
    22932227            removePeer( t, peer );
    22942228        }
     
    22982232           && ( i < MAX_RECONNECTIONS_PER_PULSE )
    22992233           && ( getPeerCount( t ) < getMaxPeerCount( t->tor ) )
    2300            && ( newConnectionsThisSecond < MAX_CONNECTIONS_PER_SECOND );
    2301              ++i )
     2234           && ( newConnectionsThisSecond < MAX_CONNECTIONS_PER_SECOND ); ++i )
    23022235        {
    23032236            tr_peerMgr *       mgr = t->manager;
     
    23082241                   tr_peerIoAddrStr( &atom->addr, atom->port ) );
    23092242
    2310             io =
    2311                 tr_peerIoNewOutgoing( mgr->session, &atom->addr, atom->port,
    2312                                       t->hash );
     2243            io = tr_peerIoNewOutgoing( mgr->session, &atom->addr, atom->port, t->hash );
    23132244            if( io == NULL )
    23142245            {
     
    23172248            else
    23182249            {
    2319                 tr_handshake * handshake = tr_handshakeNew(
    2320                     io,
    2321                     mgr->session->
    2322                     encryptionMode,
    2323                     myHandshakeDoneCB,
    2324                     mgr );
     2250                tr_handshake * handshake = tr_handshakeNew( io,
     2251                                                            mgr->session->encryptionMode,
     2252                                                            myHandshakeDoneCB,
     2253                                                            mgr );
    23252254
    23262255                assert( tr_peerIoGetTorrentHash( io ) );
  • trunk/libtransmission/peer-mgr.h

    r7231 r7289  
    5454void tr_peerMgrFree( tr_peerMgr * manager );
    5555
    56 int tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
    57                           const uint8_t     * torrentHash,
    58                           const tr_address  * addr );
     56tr_bool tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
     57                              const uint8_t     * torrentHash,
     58                              const tr_address  * addr );
    5959
    6060void tr_peerMgrAddIncoming( tr_peerMgr  * manager,
  • trunk/libtransmission/peer-msgs.c

    r7274 r7289  
    123123
    124124static int
    125 compareRequest( const void * va,
    126                 const void * vb )
     125compareRequest( const void * va, const void * vb )
    127126{
    128127    const struct peer_request * a = va;
     
    171170
    172171static void
    173 reqListCopy( struct request_list *       dest,
    174              const struct request_list * src )
     172reqListCopy( struct request_list * dest, const struct request_list * src )
    175173{
    176174    dest->count = dest->max = src->count;
    177     dest->requests =
    178         tr_memdup( src->requests, dest->count * sizeof( struct peer_request ) );
     175    dest->requests = tr_memdup( src->requests, dest->count * sizeof( struct peer_request ) );
    179176}
    180177
     
    186183
    187184    memmove( &list->requests[i],
    188             &list->requests[i + 1],
    189             sizeof( struct peer_request ) * ( --list->count - i ) );
     185             &list->requests[i + 1],
     186             sizeof( struct peer_request ) * ( --list->count - i ) );
    190187}
    191188
     
    317314
    318315static void
    319 myDebug( const char *               file,
    320          int                        line,
     316myDebug( const char * file, int line,
    321317         const struct tr_peermsgs * msgs,
    322          const char *               fmt,
    323          ... )
     318         const char * fmt, ... )
    324319{
    325320    FILE * fp = tr_getLog( );
     
    517512
    518513static void
    519 publish( tr_peermsgs *   msgs,
    520          tr_peer_event * e )
     514publish( tr_peermsgs * msgs, tr_peer_event * e )
    521515{
    522516    assert( msgs->info );
     
    527521
    528522static void
    529 fireError( tr_peermsgs * msgs,
    530            int           err )
     523fireError( tr_peermsgs * msgs, int err )
    531524{
    532525    tr_peer_event e = blankEvent;
    533 
    534526    e.eventType = TR_PEER_ERROR;
    535527    e.err = err;
     
    558550{
    559551    tr_peer_event e = blankEvent;
    560 
    561552    e.eventType = TR_PEER_PEER_PROGRESS;
    562553    e.progress = msgs->info->progress;
     
    565556
    566557static void
    567 fireGotBlock( tr_peermsgs *               msgs,
    568               const struct peer_request * req )
     558fireGotBlock( tr_peermsgs * msgs, const struct peer_request * req )
    569559{
    570560    tr_peer_event e = blankEvent;
    571 
    572561    e.eventType = TR_PEER_CLIENT_GOT_BLOCK;
    573562    e.pieceIndex = req->index;
     
    692681{
    693682#if 0
    694     const int fext = tr_peerIoSupportsFEXT( msgs->io );
     683    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
    695684    const int peerIsNeedy = msgs->info->progress < 0.10;
    696685
     
    724713
    725714    return ( !torrent->info.pieces[piece].dnd )                 /* we want it */
    726            && ( !tr_cpPieceIsComplete( torrent->completion, piece ) ) /* !have
    727                                                                         */
    728            && ( tr_bitfieldHas( peer->info->have, piece ) );   /* peer has it */
     715          && ( !tr_cpPieceIsComplete( torrent->completion, piece ) ) /* !have */
     716          && ( tr_bitfieldHas( peer->info->have, piece ) );    /* peer has it */
    729717}
    730718
     
    769757
    770758    msgs->info->clientIsInterested = weAreInterested;
    771     dbgmsg( msgs, "Sending %s",
    772             weAreInterested ? "Interested" : "Not Interested" );
     759    dbgmsg( msgs, "Sending %s", weAreInterested ? "Interested" : "Not Interested" );
    773760    tr_peerIoWriteUint32( msgs->io, out, sizeof( uint8_t ) );
    774     tr_peerIoWriteUint8 (
    775         msgs->io, out, weAreInterested ? BT_INTERESTED : BT_NOT_INTERESTED );
     761    tr_peerIoWriteUint8 ( msgs->io, out, weAreInterested ? BT_INTERESTED : BT_NOT_INTERESTED );
    776762    pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
    777     dbgmsg( msgs, "outMessage size is now %d", (int)EVBUFFER_LENGTH( out ) );
     763    dbgOutMessageLen( msgs );
    778764}
    779765
     
    820806    if( msgs->info->chokeChangedAt > fibrillationTime )
    821807    {
    822         dbgmsg( msgs, "Not changing choke to %d to avoid fibrillation",
    823                 choke );
     808        dbgmsg( msgs, "Not changing choke to %d to avoid fibrillation", choke );
    824809    }
    825810    else if( msgs->info->peerIsChoked != choke )
     
    869854expireOldRequests( tr_peermsgs * msgs, const time_t now  )
    870855{
    871     int                 i;
    872     time_t              oldestAllowed;
     856    int i;
     857    time_t oldestAllowed;
    873858    struct request_list tmp = REQUEST_LIST_INIT;
    874     const int fext = tr_peerIoSupportsFEXT( msgs->io );
     859    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
    875860
    876861    /* cancel requests that have been queued for too long */
     
    916901    while( ( count < max ) && reqListPop( &msgs->clientWillAskFor, &req ) )
    917902    {
    918         const tr_block_index_t block =
    919             _tr_block( msgs->torrent, req.index, req.offset );
     903        const tr_block_index_t block = _tr_block( msgs->torrent, req.index, req.offset );
    920904
    921905        assert( requestIsValid( msgs, &req ) );
     
    936920
    937921    if( sent )
    938         dbgmsg( msgs,
    939                 "pump sent %d requests, now have %d active and %d queued",
     922        dbgmsg( msgs, "pump sent %d requests, now have %d active and %d queued",
    940923                sent,
    941924                msgs->clientAskedFor.count,
     
    1015998cancelAllRequestsToPeer( tr_peermsgs * msgs, tr_bool sendCancel )
    1016999{
    1017     int                 i;
     1000    int i;
    10181001    struct request_list a = msgs->clientWillAskFor;
    10191002    struct request_list b = msgs->clientAskedFor;
     
    10751058sendLtepHandshake( tr_peermsgs * msgs )
    10761059{
    1077     tr_benc           val, *m;
    1078     char *            buf;
    1079     int               len;
    1080     int               pex;
     1060    tr_benc val, *m;
     1061    char * buf;
     1062    int len;
     1063    int pex;
    10811064    struct evbuffer * out = msgs->outMessages;
    10821065
     
    10951078        pex = 1;
    10961079
    1097     tr_bencInitDict( &val, 4 );
     1080    tr_bencInitDict( &val, 5 );
    10981081    tr_bencDictAddInt( &val, "e", msgs->session->encryptionMode != TR_CLEAR_PREFERRED );
    10991082    tr_bencDictAddInt( &val, "p", tr_sessionGetPeerPort( msgs->session ) );
     
    11101093    tr_peerIoWriteBytes ( msgs->io, out, buf, len );
    11111094    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
    1112     dbgmsg( msgs, "outMessage size is now %d", (int)EVBUFFER_LENGTH( out ) );
     1095    dbgOutMessageLen( msgs );
    11131096
    11141097    /* cleanup */
     
    11291112    msgs->peerSentLtepHandshake = 1;
    11301113
    1131     if( tr_bencLoad( tmp, len, &val, NULL ) || val.type != TYPE_DICT )
     1114    if( tr_bencLoad( tmp, len, &val, NULL ) || !tr_bencIsDict( &val ) )
    11321115    {
    11331116        dbgmsg( msgs, "GET  extended-handshake, couldn't get dictionary" );
     
    11411124    if( tr_bencDictFindInt( &val, "e", &i ) )
    11421125        msgs->info->encryption_preference = i ? ENCRYPTION_PREFERENCE_YES
    1143                                             : ENCRYPTION_PREFERENCE_NO;
     1126                                              : ENCRYPTION_PREFERENCE_NO;
    11441127
    11451128    /* check supported messages for utorrent pex */
    11461129    msgs->peerSupportsPex = 0;
    1147     if( tr_bencDictFindDict( &val, "m", &sub ) )
    1148     {
    1149         if( tr_bencDictFindInt( sub, "ut_pex", &i ) )
    1150         {
     1130    if( tr_bencDictFindDict( &val, "m", &sub ) ) {
     1131        if( tr_bencDictFindInt( sub, "ut_pex", &i ) ) {
    11511132            msgs->ut_pex_id = (uint8_t) i;
    11521133            msgs->peerSupportsPex = msgs->ut_pex_id == 0 ? 0 : 1;
     
    11601141
    11611142    /* get peer's listening port */
    1162     if( tr_bencDictFindInt( &val, "p", &i ) )
    1163     {
     1143    if( tr_bencDictFindInt( &val, "p", &i ) ) {
    11641144        msgs->info->port = htons( (uint16_t)i );
    11651145        dbgmsg( msgs, "msgs->port is now %hu", msgs->info->port );
     
    11711151
    11721152static void
    1173 parseUtPex( tr_peermsgs *     msgs,
    1174             int               msglen,
    1175             struct evbuffer * inbuf )
    1176 {
    1177     int                loaded = 0;
    1178     uint8_t *          tmp = tr_new( uint8_t, msglen );
    1179     tr_benc            val;
     1153parseUtPex( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
     1154{
     1155    int loaded = 0;
     1156    uint8_t * tmp = tr_new( uint8_t, msglen );
     1157    tr_benc val;
    11801158    const tr_torrent * tor = msgs->torrent;
    1181     const uint8_t *    added;
    1182     size_t             added_len;
     1159    const uint8_t * added;
     1160    size_t added_len;
    11831161
    11841162    tr_peerIoReadBytes( msgs->io, inbuf, tmp, msglen );
    11851163
    11861164    if( tr_torrentAllowsPex( tor )
    1187       && ( ( loaded = !tr_bencLoad( tmp, msglen, &val, NULL ) ) )
    1188       && tr_bencDictFindRaw( &val, "added", &added, &added_len ) )
     1165      && (( loaded = !tr_bencLoad( tmp, msglen, &val, NULL )))
     1166      && tr_bencDictFindRaw( &val, "added", &added, &added_len ))
    11891167    {
    11901168        const uint8_t * added_f = NULL;
     
    11931171        size_t          added_f_len = 0;
    11941172        tr_bencDictFindRaw( &val, "added.f", &added_f, &added_f_len );
    1195         pex =
    1196             tr_peerMgrCompactToPex( added, added_len, added_f, added_f_len,
    1197                                     &n );
    1198         for( i = 0; i < n; ++i )
     1173        pex = tr_peerMgrCompactToPex( added, added_len, added_f, added_f_len, &n );
     1174        for( i=0; i<n; ++i )
    11991175            tr_peerMgrAddPex( msgs->session->peerMgr, tor->info.hash,
    12001176                              TR_PEER_FROM_PEX, pex + i );
     
    13091285                 const struct peer_request * req )
    13101286{
    1311     const int fext = tr_peerIoSupportsFEXT( msgs->io );
     1287    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
    13121288    const int reqIsValid = requestIsValid( msgs, req );
    13131289    const int clientHasPiece = reqIsValid && tr_cpPieceIsComplete( msgs->torrent->completion, req->index );
     
    13321308
    13331309static int
    1334 messageLengthIsCorrect( const tr_peermsgs * msg,
    1335                         uint8_t             id,
    1336                         uint32_t            len )
     1310messageLengthIsCorrect( const tr_peermsgs * msg, uint8_t id, uint32_t len )
    13371311{
    13381312    switch( id )
     
    13961370        tr_peerIoReadUint32( msgs->io, inbuf, &req->offset );
    13971371        req->length = msgs->incoming.length - 9;
    1398         dbgmsg( msgs, "got incoming block header %u:%u->%u", req->index,
    1399                 req->offset,
    1400                 req->length );
     1372        dbgmsg( msgs, "got incoming block header %u:%u->%u", req->index, req->offset, req->length );
    14011373        return READ_NOW;
    14021374    }
    14031375    else
    14041376    {
    1405         int          err;
     1377        int err;
    14061378
    14071379        /* read in another chunk of data */
    1408         const size_t nLeft = req->length - EVBUFFER_LENGTH(
    1409             msgs->incoming.block );
    1410         size_t       n = MIN( nLeft, inlen );
    1411         uint8_t *    buf = tr_new( uint8_t, n );
     1380        const size_t nLeft = req->length - EVBUFFER_LENGTH( msgs->incoming.block );
     1381        size_t n = MIN( nLeft, inlen );
     1382        uint8_t * buf = tr_new( uint8_t, n );
    14121383        assert( EVBUFFER_LENGTH( inbuf ) >= n );
    14131384        tr_peerIoReadBytes( msgs->io, inbuf, buf, n );
     
    14161387        *setme_piece_bytes_read += n;
    14171388        tr_free( buf );
    1418         dbgmsg( msgs, "got %d bytes for block %u:%u->%u ... %d remain",
    1419                (int)n, req->index, req->offset, req->length,
     1389        dbgmsg( msgs, "got %zu bytes for block %u:%u->%u ... %d remain",
     1390               n, req->index, req->offset, req->length,
    14201391               (int)( req->length - EVBUFFER_LENGTH( msgs->incoming.block ) ) );
    14211392        if( EVBUFFER_LENGTH( msgs->incoming.block ) < req->length )
     
    14231394
    14241395        /* we've got the whole block ... process it */
    1425         err = clientGotBlock( msgs, EVBUFFER_DATA(
    1426                                   msgs->incoming.block ), req );
     1396        err = clientGotBlock( msgs, EVBUFFER_DATA( msgs->incoming.block ), req );
    14271397
    14281398        /* cleanup */
    1429         evbuffer_drain( msgs->incoming.block,
    1430                        EVBUFFER_LENGTH( msgs->incoming.block ) );
     1399        evbuffer_drain( msgs->incoming.block, EVBUFFER_LENGTH( msgs->incoming.block ) );
    14311400        req->length = 0;
    14321401        msgs->state = AWAITING_BT_LENGTH;
    14331402        if( !err )
    14341403            return READ_NOW;
    1435         else
    1436         {
     1404        else {
    14371405            fireError( msgs, err );
    14381406            return READ_ERR;
     
    14421410
    14431411static int
    1444 readBtMessage( tr_peermsgs *     msgs,
    1445                struct evbuffer * inbuf,
    1446                size_t            inlen )
     1412readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
    14471413{
    14481414    uint32_t      ui32;
     
    14501416    const uint8_t id = msgs->incoming.id;
    14511417    const size_t  startBufLen = EVBUFFER_LENGTH( inbuf );
    1452     const int    fext = tr_peerIoSupportsFEXT( msgs->io );
     1418    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
    14531419
    14541420    --msglen; /* id length */
     
    14571423        return READ_LATER;
    14581424
    1459     dbgmsg( msgs, "got BT id %d, len %d, buffer size is %d", (int)id,
    1460             (int)msglen,
    1461             (int)inlen );
     1425    dbgmsg( msgs, "got BT id %d, len %d, buffer size is %zu", (int)id, (int)msglen, inlen );
    14621426
    14631427    if( !messageLengthIsCorrect( msgs, id, msglen + 1 ) )
    14641428    {
    1465         dbgmsg( msgs, "bad packet - BT message #%d with a length of %d",
    1466                 (int)id, (int)msglen );
     1429        dbgmsg( msgs, "bad packet - BT message #%d with a length of %d", (int)id, (int)msglen );
    14671430        fireError( msgs, EMSGSIZE );
    14681431        return READ_ERR;
     
    14971460            tr_peerIoReadUint32( msgs->io, inbuf, &ui32 );
    14981461            dbgmsg( msgs, "got Have: %u", ui32 );
    1499             if( tr_bitfieldAdd( msgs->info->have, ui32 ) )
    1500             {
     1462            if( tr_bitfieldAdd( msgs->info->have, ui32 ) ) {
    15011463                fireError( msgs, ERANGE );
    15021464                return READ_ERR;
     
    15111473            dbgmsg( msgs, "got a bitfield" );
    15121474            msgs->peerSentBitfield = 1;
    1513             tr_peerIoReadBytes( msgs->io, inbuf, msgs->info->have->bits,
    1514                                 msglen );
     1475            tr_peerIoReadBytes( msgs->io, inbuf, msgs->info->have->bits, msglen );
    15151476            updatePeerProgress( msgs );
    15161477            fireNeedReq( msgs );
     
    16301591
    16311592static void
    1632 decrementDownloadedCount( tr_peermsgs * msgs,
    1633                           uint32_t      byteCount )
     1593decrementDownloadedCount( tr_peermsgs * msgs, uint32_t byteCount )
    16341594{
    16351595    tr_torrent * tor = msgs->torrent;
     
    16391599
    16401600static void
    1641 clientGotUnwantedBlock( tr_peermsgs *               msgs,
    1642                         const struct peer_request * req )
     1601clientGotUnwantedBlock( tr_peermsgs * msgs, const struct peer_request * req )
    16431602{
    16441603    decrementDownloadedCount( msgs, req->length );
     
    16461605
    16471606static void
    1648 addPeerToBlamefield( tr_peermsgs * msgs,
    1649                      uint32_t      index )
     1607addPeerToBlamefield( tr_peermsgs * msgs, uint32_t index )
    16501608{
    16511609    if( !msgs->info->blame )
    1652         msgs->info->blame = tr_bitfieldNew( msgs->torrent->info.pieceCount );
     1610         msgs->info->blame = tr_bitfieldNew( msgs->torrent->info.pieceCount );
    16531611    tr_bitfieldAdd( msgs->info->blame, index );
    16541612}
     
    16601618                const struct peer_request * req )
    16611619{
    1662     int                    err;
    1663     tr_torrent *           tor = msgs->torrent;
     1620    int err;
     1621    tr_torrent * tor = msgs->torrent;
    16641622    const tr_block_index_t block = _tr_block( tor, req->index, req->offset );
    16651623
     
    16671625    assert( req );
    16681626
    1669     if( req->length != tr_torBlockCountBytes( msgs->torrent, block ) )
    1670     {
     1627    if( req->length != tr_torBlockCountBytes( msgs->torrent, block ) ) {
    16711628        dbgmsg( msgs, "wrong block size -- expected %u, got %d",
    16721629                tr_torBlockCountBytes( msgs->torrent, block ), req->length );
     
    16751632
    16761633    /* save the block */
    1677     dbgmsg( msgs, "got block %u:%u->%u", req->index, req->offset,
    1678             req->length );
     1634    dbgmsg( msgs, "got block %u:%u->%u", req->index, req->offset, req->length );
    16791635
    16801636    /**
     
    16821638    **/
    16831639
    1684     if( !reqListRemove( &msgs->clientAskedFor, req ) )
    1685     {
     1640    if( !reqListRemove( &msgs->clientAskedFor, req ) ) {
    16861641        clientGotUnwantedBlock( msgs, req );
    16871642        dbgmsg( msgs, "we didn't ask for this message..." );
     
    16961651    **/
    16971652
    1698     if( tr_cpBlockIsComplete( tor->completion, block ) )
    1699     {
     1653    if( tr_cpBlockIsComplete( tor->completion, block ) ) {
    17001654        dbgmsg( msgs, "we have this block already..." );
    17011655        clientGotUnwantedBlock( msgs, req );
     
    17881742    struct peer_request req;
    17891743    const int haveMessages = EVBUFFER_LENGTH( msgs->outMessages ) != 0;
    1790     const int fext = tr_peerIoSupportsFEXT( msgs->io );
     1744    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
    17911745
    17921746    /**
     
    19471901    tr_peerIoWriteUint8 ( msgs->io, out, BT_BITFIELD );
    19481902    tr_peerIoWriteBytes ( msgs->io, out, field->bits, field->byteCount );
    1949     dbgmsg( msgs, "sending bitfield... outMessage size is now %d",
    1950            (int)EVBUFFER_LENGTH( out ) );
     1903    dbgmsg( msgs, "sending bitfield... outMessage size is now %zu",
     1904            EVBUFFER_LENGTH( out ) );
    19511905    pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
    19521906
     
    19601914tellPeerWhatWeHave( tr_peermsgs * msgs )
    19611915{
    1962     const int fext = tr_peerIoSupportsFEXT( msgs->io );
     1916    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
    19631917
    19641918    if( fext && ( tr_cpGetStatus( msgs->torrent->completion ) == TR_SEED ) )
  • trunk/libtransmission/webseed.c

    r7238 r7289  
    6666{
    6767    tr_peer_event e = blankEvent;
    68 
    6968    e.eventType = TR_PEER_NEED_REQ;
    7069    publish( w, &e );
     
    7271
    7372static void
    74 fireClientGotBlock( tr_webseed * w,
    75                     uint32_t     pieceIndex,
    76                     uint32_t     offset,
    77                     uint32_t     length )
     73fireClientGotBlock( tr_webseed * w, uint32_t pieceIndex, uint32_t offset, uint32_t length )
    7874{
    7975    tr_peer_event e = blankEvent;
    80 
    8176    e.eventType = TR_PEER_CLIENT_GOT_BLOCK;
    8277    e.pieceIndex = pieceIndex;
     
    8782
    8883static void
    89 fireClientGotData( tr_webseed * w,
    90                    uint32_t     length )
     84fireClientGotData( tr_webseed * w, uint32_t length )
    9185{
    9286    tr_peer_event e = blankEvent;
    93 
    9487    e.eventType = TR_PEER_CLIENT_GOT_DATA;
    9588    e.length = length;
    9689    e.wasPieceData = TRUE;
    97 
    9890    publish( w, &e );
    9991}
     
    125117            switch( *str )
    126118            {
    127                 case ',':
    128                 case '-':
    129                 case '.':
    130                 case '/':
    131                 case '0':
    132                 case '1':
    133                 case '2':
    134                 case '3':
    135                 case '4':
    136                 case '5':
    137                 case '6':
    138                 case '7':
    139                 case '8':
    140                 case '9':
    141                 case 'a':
    142                 case 'b':
    143                 case 'c':
    144                 case 'd':
    145                 case 'e':
    146                 case 'f':
    147                 case 'g':
    148                 case 'h':
    149                 case 'i':
    150                 case 'j':
    151                 case 'k':
    152                 case 'l':
    153                 case 'm':
    154                 case 'n':
    155                 case 'o':
    156                 case 'p':
    157                 case 'q':
    158                 case 'r':
    159                 case 's':
    160                 case 't':
    161                 case 'u':
    162                 case 'v':
    163                 case 'w':
    164                 case 'x':
    165                 case 'y':
    166                 case 'z':
    167                 case 'A':
    168                 case 'B':
    169                 case 'C':
    170                 case 'D':
    171                 case 'E':
    172                 case 'F':
    173                 case 'G':
    174                 case 'H':
    175                 case 'I':
    176                 case 'J':
    177                 case 'K':
    178                 case 'L':
    179                 case 'M':
    180                 case 'N':
    181                 case 'O':
    182                 case 'P':
    183                 case 'Q':
    184                 case 'R':
    185                 case 'S':
    186                 case 'T':
    187                 case 'U':
    188                 case 'V':
    189                 case 'W':
    190                 case 'X':
    191                 case 'Y':
    192                 case 'Z':
     119                case ',': case '-': case '.': case '/':
     120                case '0': case '1': case '2': case '3': case '4':
     121                case '5': case '6': case '7': case '8': case '9':
     122                case 'a': case 'b': case 'c': case 'd': case 'e':
     123                case 'f': case 'g': case 'h': case 'i': case 'j':
     124                case 'k': case 'l': case 'm': case 'n': case 'o':
     125                case 'p': case 'q': case 'r': case 's': case 't':
     126                case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
     127                case 'A': case 'B': case 'C': case 'D': case 'E':
     128                case 'F': case 'G': case 'H': case 'I': case 'J':
     129                case 'K': case 'L': case 'M': case 'N': case 'O':
     130                case 'P': case 'Q': case 'R': case 'S': case 'T':
     131                case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
    193132                    evbuffer_add( out, str, 1 );
    194133                    break;
    195 
    196134                default:
    197135                    evbuffer_add_printf( out, "%%%02X", *str );
     
    315253
    316254int
    317 tr_webseedGetSpeed( const tr_webseed * w,
    318                     float *            setme_KiBs )
     255tr_webseedGetSpeed( const tr_webseed * w, float * setme_KiBs )
    319256{
    320257    const int isActive = tr_webseedIsActive( w );
Note: See TracChangeset for help on using the changeset viewer.