Changeset 7289

Timestamp:

Dec 5, 2008, 10:56:19 PM (14 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:

• handshake.c (modified) (15 diffs)
• handshake.h (modified) (1 diff)
• peer-io.c (modified) (4 diffs)
• peer-io.h (modified) (1 diff)
• peer-mgr.c (modified) (49 diffs)
• peer-mgr.h (modified) (1 diff)
• peer-msgs.c (modified) (45 diffs)
• webseed.c (modified) (5 diffs)

trunk/libtransmission/handshake.c

@@ -247 +247 @@
     uint8_t hash[SHA_DIGEST_LENGTH];
 
-    dbgmsg( handshake, "payload: need %d, got %d", (int)HANDSHAKE_SIZE,
-           (int)EVBUFFER_LENGTH( inbuf ) );
+    dbgmsg( handshake, "payload: need %d, got %zu",
+            (int)HANDSHAKE_SIZE, EVBUFFER_LENGTH( inbuf ) );
 
     if( EVBUFFER_LENGTH( inbuf ) < HANDSHAKE_SIZE )
@@ -396 +396 @@
         return READ_LATER;
 
-    isEncrypted = memcmp( EVBUFFER_DATA(
-                              inbuf ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
+    isEncrypted = memcmp( EVBUFFER_DATA( inbuf ), HANDSHAKE_NAME, HANDSHAKE_NAME_LEN );
     if( isEncrypted )
     {
@@ -408 +407 @@
            ( isEncrypted ? "encrypted" : "plaintext" ) );
 
-    tr_peerIoSetEncryption(
-        handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
-        : PEER_ENCRYPTION_NONE );
+    tr_peerIoSetEncryption( handshake->io, isEncrypted ? PEER_ENCRYPTION_RC4
+                                                       : PEER_ENCRYPTION_NONE );
     if( !isEncrypted )
     {
@@ -440 +438 @@
         uint8_t buf[SHA_DIGEST_LENGTH];
         tr_sha1( req2, "req2", 4,
-                 tr_cryptoGetTorrentHash(
-                     handshake->crypto ), SHA_DIGEST_LENGTH, NULL );
+                 tr_cryptoGetTorrentHash( handshake->crypto ),
+                 SHA_DIGEST_LENGTH, NULL );
         tr_sha1( req3, "req3", 4, secret, KEY_LEN, NULL );
         for( i = 0; i < SHA_DIGEST_LENGTH; ++i )
@@ -562 +560 @@
     uint8_t *    tmp;
 
-    dbgmsg( handshake, "pad d: need %d, got %d", (int)needlen,
-           (int)EVBUFFER_LENGTH(
-               inbuf ) );
+    dbgmsg( handshake, "pad d: need %zu, got %zu",
+            needlen, EVBUFFER_LENGTH( inbuf ) );
     if( EVBUFFER_LENGTH( inbuf ) < needlen )
         return READ_LATER;
@@ -594 +591 @@
     uint8_t   hash[SHA_DIGEST_LENGTH];
 
-    dbgmsg( handshake, "payload: need %d, got %d",
-           (int)INCOMING_HANDSHAKE_LEN, (int)EVBUFFER_LENGTH(
-               inbuf ) );
+    dbgmsg( handshake, "payload: need %d, got %zu",
+            (int)INCOMING_HANDSHAKE_LEN, EVBUFFER_LENGTH( inbuf ) );
 
     if( EVBUFFER_LENGTH( inbuf ) < INCOMING_HANDSHAKE_LEN )
@@ -714 +710 @@
 
     /* peer id */
-    tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id,
-                        PEER_ID_LEN );
+    tr_peerIoReadBytes( handshake->io, inbuf, handshake->peer_id, PEER_ID_LEN );
     tr_peerIoSetPeersId( handshake->io, handshake->peer_id );
     handshake->havePeerID = TRUE;
     tr_clientForId( client, sizeof( client ), handshake->peer_id );
     dbgmsg( handshake, "peer-id is [%s] ... isIncoming is %d", client,
-           tr_peerIoIsIncoming(
-               handshake->io ) );
+            tr_peerIoIsIncoming( handshake->io ) );
 
     /* if we've somehow connected to ourselves, don't keep the connection */
@@ -739 +733 @@
     int            len;
 
-    dbgmsg( handshake, "in readYa... need %d, have %d", (int)KEY_LEN,
-           (int)EVBUFFER_LENGTH(
-               inbuf ) );
+    dbgmsg( handshake, "in readYa... need %d, have %zu",
+            (int)KEY_LEN, EVBUFFER_LENGTH( inbuf ) );
     if( EVBUFFER_LENGTH( inbuf ) < KEY_LEN )
         return READ_LATER;
@@ -772 +765 @@
     uint8_t * pch;
 
-    dbgmsg(
-         handshake,
-        "looking to get past pad a... & resync on hash('req',S) ... have %d bytes",
-        (int)EVBUFFER_LENGTH( inbuf ) );
+    dbgmsg( handshake, "looking to get past pad a... & resync on hash('req',S) ... have %zu bytes",
+            EVBUFFER_LENGTH( inbuf ) );
     /**
     *** Resynchronizing on HASH('req1',S)
@@ -785 +776 @@
     if( pch == NULL )
     {
-        dbgmsg( handshake, "no luck so far.. draining %d bytes",
-               (int)EVBUFFER_LENGTH(
-                   inbuf ) );
+        dbgmsg( handshake, "no luck so far.. draining %zu bytes",
+                EVBUFFER_LENGTH( inbuf ) );
         evbuffer_drain( inbuf, EVBUFFER_LENGTH( inbuf ) );
         return READ_LATER;
@@ -850 +840 @@
                                                obfuscatedTorrentHash ) ) )
     {
-        dbgmsg(
-            handshake,
-            "got INCOMING connection's encrypted handshake for torrent [%s]",
-            tor->info.name );
+        dbgmsg( handshake, "got INCOMING connection's encrypted handshake for torrent [%s]",
+                tor->info.name );
         tr_peerIoSetTorrentHash( handshake->io, tor->info.hash );
         if( !tr_torrentAllowsPex( tor )
@@ -914 +902 @@
     uint32_t          crypto_select;
 
-    dbgmsg( handshake, "reading IA... have %d, need %d",
-            (int)EVBUFFER_LENGTH(
-                inbuf ), (int)needlen );
+    dbgmsg( handshake, "reading IA... have %zu, need %zu",
+            EVBUFFER_LENGTH( inbuf ), needlen );
     if( EVBUFFER_LENGTH( inbuf ) < needlen )
         return READ_LATER;
 
     /**
-    ***  B->A: ENCRYPT(VC, crypto_select, len(padD), padD), ENCRYPT2(Payload
-    ***Stream)
+    ***  B->A: ENCRYPT(VC, crypto_select, len(padD), padD), ENCRYPT2(Payload Stream)
     **/
 
@@ -951 +937 @@
 
     dbgmsg( handshake, "sending pad d" );
-    /* ENCRYPT(VC, crypto_provide, len(PadC), PadC
+    /* ENCRYPT(VC, crypto_provide, len(PadD), PadD
      * PadD is reserved for future extensions to the handshake...
      * standard practice at this time is for it to be zero-length */
@@ -989 +975 @@
     const size_t      needlen = HANDSHAKE_SIZE;
 
-    dbgmsg( handshake, "reading payload stream... have %d, need %d",
-            (int)EVBUFFER_LENGTH( inbuf ), (int)needlen );
+    dbgmsg( handshake, "reading payload stream... have %zu, need %zu",
+            EVBUFFER_LENGTH( inbuf ), needlen );
     if( EVBUFFER_LENGTH( inbuf ) < needlen )
         return READ_LATER;
@@ -1013 +999 @@
 canRead( struct tr_iobuf * iobuf, void * arg, size_t * piece )
 {
-    tr_handshake *    handshake = arg;
+    tr_handshake    * handshake = arg;
     struct evbuffer * inbuf = tr_iobuf_input( iobuf );
     ReadState         ret;
-    int               readyForMore = TRUE;
+    tr_bool           readyForMore = TRUE;
 
     /* no piece data in handshake */

trunk/libtransmission/handshake.h

@@ -25 +25 @@
 
 /* returns true on success, false on error */
-typedef int ( *handshakeDoneCB )( struct tr_handshake * handshake,
-                                  struct tr_peerIo *    io,
-                                  int                   isConnected,
-                                  const uint8_t *       peerId,
-                                  void *                userData );
+typedef tr_bool ( *handshakeDoneCB )( struct tr_handshake * handshake,
+                                      struct tr_peerIo *    io,
+                                      int                   isConnected,
+                                      const uint8_t *       peerId,
+                                      void *                userData );
 
 tr_handshake *         tr_handshakeNew( struct tr_peerIo * io,

trunk/libtransmission/peer-io.c

@@ -496 +496 @@
 void
 tr_peerIoEnableFEXT( tr_peerIo * io,
-                     int         flag )
+                     tr_bool     flag )
 {
     assert( isPeerIo( io ) );
@@ -505 +505 @@
 }
 
-int
+tr_bool
 tr_peerIoSupportsFEXT( const tr_peerIo * io )
 {
@@ -518 +518 @@
 
 void
-tr_peerIoEnableLTEP( tr_peerIo * io,
-                     int         flag )
+tr_peerIoEnableLTEP( tr_peerIo  * io,
+                     tr_bool      flag )
 {
     assert( isPeerIo( io ) );
@@ -528 +528 @@
 }
 
-int
+tr_bool
 tr_peerIoSupportsLTEP( const tr_peerIo * io )
 {

trunk/libtransmission/peer-io.h

@@ -50 +50 @@
 **/
 
-void        tr_peerIoEnableLTEP( tr_peerIo * io, int flag );
-
-int         tr_peerIoSupportsLTEP( const tr_peerIo * io );
-
-void        tr_peerIoEnableFEXT( tr_peerIo * io, int flag );
-
-int         tr_peerIoSupportsFEXT( const tr_peerIo * io );
+void        tr_peerIoEnableLTEP( tr_peerIo * io, tr_bool flag );
+
+tr_bool     tr_peerIoSupportsLTEP( const tr_peerIo * io );
+
+void        tr_peerIoEnableFEXT( tr_peerIo * io, tr_bool flag );
+
+tr_bool     tr_peerIoSupportsFEXT( const tr_peerIo * io );
 
 /**

trunk/libtransmission/peer-mgr.c

@@ -300 +300 @@
 }
 
-static int
+static tr_bool
 peerIsInUse( const Torrent    * ct,
              const tr_address * addr )
@@ -309 +309 @@
 
     return getExistingPeer( t, addr )
-           || getExistingHandshake( t->outgoingHandshakes, addr )
-           || getExistingHandshake( t->manager->incomingHandshakes, addr );
+        || getExistingHandshake( t->outgoingHandshakes, addr )
+        || getExistingHandshake( t->manager->incomingHandshakes, addr );
 }
 
@@ -317 +317 @@
 {
     tr_peer * p;
-
     p = tr_new0( tr_peer, 1 );
     p->addr = *addr;
@@ -487 +486 @@
 
 static tr_peer**
-getConnectedPeers( Torrent * t,
-                   int *     setmeCount )
-{
-    int       i, peerCount, connectionCount;
+getConnectedPeers( Torrent * t, int * setmeCount )
+{
+    int i, peerCount, connectionCount;
     tr_peer **peers;
     tr_peer **ret;
@@ -523 +521 @@
 ***/
 
-int
-tr_peerMgrPeerIsSeed( const tr_peerMgr * mgr,
-                      const uint8_t    * torrentHash,
-                      const tr_address * addr )
-{
-    int                      isSeed = FALSE;
-    const Torrent *          t = NULL;
+tr_bool
+tr_peerMgrPeerIsSeed( const tr_peerMgr   * mgr,
+                      const uint8_t      * torrentHash,
+                      const tr_address   * addr )
+{
+    tr_bool isSeed = FALSE;
+    const Torrent * t = NULL;
     const struct peer_atom * atom = NULL;
 
@@ -593 +591 @@
 
 static int
-compareRefillPiece( const void * aIn,
-                    const void * bIn )
+compareRefillPiece( const void * aIn, const void * bIn )
 {
     const struct tr_refill_piece * a = aIn;
@@ -623 +620 @@
 
 static tr_piece_index_t *
-getPreferredPieces( Torrent           * t,
-                    tr_piece_index_t  * pieceCount )
+getPreferredPieces( Torrent * t, tr_piece_index_t  * pieceCount )
 {
     const tr_torrent  * tor = t->tor;
@@ -822 +818 @@
         for( j=0; !handled && j<peerCount; )
         {
-            const int val = tr_peerMsgsAddRequest( peers[j]->msgs, index, offset, length, FALSE );
+            const tr_addreq_t val = tr_peerMsgsAddRequest( peers[j]->msgs, index, offset, length, FALSE );
             switch( val )
             {
@@ -1043 +1039 @@
             const time_t now = time( NULL );
             tr_torrent * tor = t->tor;
-
             tor->activityDate = now;
 
@@ -1073 +1068 @@
             {
                 struct peer_atom * atom = getExistingAtom( t, &peer->addr );
-                const int          peerIsSeed = e->progress >= 1.0;
-                if( peerIsSeed )
-                {
-                    tordbg( t, "marking peer %s as a seed",
-                           tr_peerIoAddrStr( &atom->addr,
-                                             atom->port ) );
+                const int peerIsSeed = e->progress >= 1.0;
+                if( peerIsSeed ) {
+                    tordbg( t, "marking peer %s as a seed", tr_peerIoAddrStr( &atom->addr, atom->port ) );
                     atom->flags |= ADDED_F_SEED_FLAG;
-                }
-                else
-                {
-                    tordbg( t, "marking peer %s as a non-seed",
-                           tr_peerIoAddrStr( &atom->addr,
-                                             atom->port ) );
+                } else {
+                    tordbg( t, "marking peer %s as a non-seed", tr_peerIoAddrStr( &atom->addr, atom->port ) );
                     atom->flags &= ~ADDED_F_SEED_FLAG;
                 }
@@ -1096 +1084 @@
             tr_torrent *     tor = t->tor;
 
-            tr_block_index_t block = _tr_block( tor, e->pieceIndex,
-                                                e->offset );
+            tr_block_index_t block = _tr_block( tor, e->pieceIndex, e->offset );
 
             tr_cpBlockAdd( tor->completion, block );
@@ -1107 +1094 @@
             {
                 const tr_piece_index_t p = e->pieceIndex;
-                const int              ok = tr_ioTestPiece( tor, p );
+                const tr_bool ok = tr_ioTestPiece( tor, p );
 
                 if( !ok )
                 {
-                    tr_torerr( tor,
-                              _( "Piece %lu, which was just downloaded, failed its checksum test" ),
-                              (unsigned long)p );
+                    tr_torerr( tor, _( "Piece %lu, which was just downloaded, failed its checksum test" ),
+                               (unsigned long)p );
                 }
 
@@ -1124 +1110 @@
                 else
                 {
-                    int        i, peerCount;
+                    int i, peerCount;
                     tr_peer ** peers = getConnectedPeers( t, &peerCount );
                     for( i = 0; i < peerCount; ++i )
@@ -1181 +1167 @@
         a->flags = flags;
         a->from = from;
-        tordbg( t, "got a new atom: %s",
-               tr_peerIoAddrStr( &a->addr, a->port ) );
+        tordbg( t, "got a new atom: %s", tr_peerIoAddrStr( &a->addr, a->port ) );
         tr_ptrArrayInsertSorted( t->pool, a, comparePeerAtoms );
     }
@@ -1196 +1181 @@
 getPeerCount( const Torrent * t )
 {
-    return tr_ptrArraySize( t->peers ) + tr_ptrArraySize(
-               t->outgoingHandshakes );
+    return tr_ptrArraySize( t->peers ) + tr_ptrArraySize( t->outgoingHandshakes );
 }
 
 /* FIXME: this is kind of a mess. */
-static int
+static tr_bool
 myHandshakeDoneCB( tr_handshake *  handshake,
                    tr_peerIo *     io,
@@ -1208 +1192 @@
                    void *          vmanager )
 {
-    int                ok = isConnected;
-    int                success = FALSE;
+    tr_bool            ok = isConnected;
+    tr_bool            success = FALSE;
     tr_port            port;
     const tr_address * addr;
@@ -1261 +1245 @@
         {
             tordbg( t, "banned peer %s tried to reconnect",
-                   tr_peerIoAddrStr( &atom->addr,
-                                     atom->port ) );
+                    tr_peerIoAddrStr( &atom->addr, atom->port ) );
             tr_peerIoFree( io );
         }
@@ -1318 +1301 @@
     if( tr_sessionIsAddressBlocked( manager->session, addr ) )
     {
-        tr_dbg( "Banned IP address \"%s\" tried to connect to us",
-               tr_ntop_non_ts( addr ) );
+        tr_dbg( "Banned IP address \"%s\" tried to connect to us", tr_ntop_non_ts( addr ) );
         tr_netClose( socket );
     }
@@ -1411 +1393 @@
             if( tr_bitfieldHas( peer->blame, pieceIndex ) )
             {
-                tordbg(
-                    t,
-                    "peer %s contributed to corrupt piece (%d); now has %d strikes",
-                    tr_peerIoAddrStr( &peer->addr, peer->port ),
-                    pieceIndex, (int)peer->strikes + 1 );
+                tordbg( t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
+                        tr_peerIoAddrStr( &peer->addr, peer->port ),
+                        pieceIndex, (int)peer->strikes + 1 );
                 addStrike( t, peer );
             }
@@ -1423 +1403 @@
 
 int
-tr_pexCompare( const void * va,
-               const void * vb )
+tr_pexCompare( const void * va, const void * vb )
 {
     const tr_pex * a = va;
     const tr_pex * b = vb;
-    int            i = tr_compareAddresses( &a->addr, &b->addr );
+    int i = tr_compareAddresses( &a->addr, &b->addr );
 
     if( i ) return i;
@@ -1436 +1415 @@
 }
 
-int tr_pexCompare( const void * a,
-                   const void * b );
-
 static int
 peerPrefersCrypto( const tr_peer * peer )
@@ -1461 +1437 @@
     managerLock( manager );
 
-    t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
-    if( !t )
+    t = getExistingTorrent( manager, torrentHash );
+    if( t == NULL )
     {
         *setme_pex = NULL;
@@ -1473 +1449 @@
         tr_pex * walk = pex;
 
-        for( i = 0; i < peerCount; ++i, ++walk )
+        for( i=0; i<peerCount; ++i, ++walk )
         {
             const tr_peer * peer = peers[i];
@@ -1652 +1628 @@
     tr_peer **    peers;
     tr_bitfield * pieces;
-
     managerLock( manager );
 
@@ -1670 +1645 @@
                           const uint8_t *    torrentHash )
 {
-    int             ret;
+    int ret;
     const Torrent * t;
-
     managerLock( manager );
 
     t = getExistingTorrent( (tr_peerMgr*)manager, torrentHash );
-    ret = t && ( !tr_ptrArrayEmpty( t->peers )
-               || !tr_ptrArrayEmpty( t->webseeds ) );
+    ret = t && ( !tr_ptrArrayEmpty( t->peers ) || !tr_ptrArrayEmpty( t->webseeds ) );
 
     managerUnlock( manager );
@@ -1685 +1658 @@
 void
 tr_peerMgrTorrentStats( const tr_peerMgr * manager,
-                        const uint8_t *    torrentHash,
-                        int *              setmePeersKnown,
-                        int *              setmePeersConnected,
-                        int *              setmeSeedsConnected,
-                        int *              setmeWebseedsSendingToUs,
-                        int *              setmePeersSendingToUs,
-                        int *              setmePeersGettingFromUs,
-                        int *              setmePeersFrom )
-{
-    int                 i, size;
-    const Torrent *     t;
-    const tr_peer **    peers;
+                        const uint8_t    * torrentHash,
+                        int              * setmePeersKnown,
+                        int              * setmePeersConnected,
+                        int              * setmeSeedsConnected,
+                        int              * setmeWebseedsSendingToUs,
+                        int              * setmePeersSendingToUs,
+                        int              * setmePeersGettingFromUs,
+                        int              * setmePeersFrom )
+{
+    int i, size;
+    const Torrent * t;
+    const tr_peer ** peers;
     const tr_webseed ** webseeds;
 
@@ -1711 +1684 @@
     *setmeWebseedsSendingToUs  = 0;
 
-    for( i = 0; i < TR_PEER_FROM__MAX; ++i )
+    for( i=0; i<TR_PEER_FROM__MAX; ++i )
         setmePeersFrom[i] = 0;
 
-    for( i = 0; i < size; ++i )
-    {
-        const tr_peer *          peer = peers[i];
+    for( i=0; i<size; ++i )
+    {
+        const tr_peer * peer = peers[i];
         const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
 
@@ -1722 +1695 @@
             continue;
 
-        ++ * setmePeersConnected;
+        ++*setmePeersConnected;
 
         ++setmePeersFrom[atom->from];
 
         if( clientIsDownloadingFrom( peer ) )
-            ++ * setmePeersSendingToUs;
+            ++*setmePeersSendingToUs;
 
         if( clientIsUploadingTo( peer ) )
-            ++ * setmePeersGettingFromUs;
+            ++*setmePeersGettingFromUs;
 
         if( atom->flags & ADDED_F_SEED_FLAG )
-            ++ * setmeSeedsConnected;
+            ++*setmeSeedsConnected;
     }
 
     webseeds = (const tr_webseed **) tr_ptrArrayPeek( t->webseeds, &size );
-    for( i = 0; i < size; ++i )
+    for( i=0; i<size; ++i )
     {
         if( tr_webseedIsActive( webseeds[i] ) )
-            ++ * setmeWebseedsSendingToUs;
+            ++*setmeWebseedsSendingToUs;
     }
 
@@ -1750 +1723 @@
                      const uint8_t *    torrentHash )
 {
-    const Torrent *     t;
+    const Torrent * t;
     const tr_webseed ** webseeds;
-    int                 i;
-    int                 webseedCount;
-    float *             ret;
+    int i;
+    int webseedCount;
+    float * ret;
 
     assert( manager );
@@ -1765 +1738 @@
     ret = tr_new0( float, webseedCount );
 
-    for( i = 0; i < webseedCount; ++i )
+    for( i=0; i<webseedCount; ++i )
         if( !tr_webseedGetSpeed( webseeds[i], &ret[i] ) )
             ret[i] = -1.0;
@@ -1774 +1747 @@
 
 double
-tr_peerGetPieceSpeed( const tr_peer    * peer,
-                      tr_direction       direction )
+tr_peerGetPieceSpeed( const tr_peer * peer, tr_direction direction )
 {
     assert( peer );
@@ -1808 +1780 @@
         tr_peer_stat *           stat = ret + i;
 
-        tr_ntop( &peer->addr, stat->addr, sizeof( stat->addr ) );
-        tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
-                   sizeof( stat->client ) );
+        tr_ntop( &peer->addr, stat->addr, sizeof(stat->addr) );
+        tr_strlcpy( stat->client, (peer->client ? peer->client : ""), sizeof(stat->client) );
         stat->port               = ntohs( peer->port );
         stat->from               = atom->from;
@@ -1832 +1803 @@
         if( stat->isUploadingTo ) *pch++ = 'U';
         else if( stat->peerIsInterested ) *pch++ = 'u';
-        if( !stat->clientIsChoked && !stat->clientIsInterested ) *pch++ =
-                'K';
+        if( !stat->clientIsChoked && !stat->clientIsInterested ) *pch++ = 'K';
         if( !stat->peerIsChoked && !stat->peerIsInterested ) *pch++ = '?';
         if( stat->isEncrypted ) *pch++ = 'E';
@@ -1947 +1917 @@
      */
     unchokedInterested = 0;
-    for( i = 0; i < size && unchokedInterested < MAX_UNCHOKED_PEERS; ++i )
-    {
+    for( i=0; i<size && unchokedInterested<MAX_UNCHOKED_PEERS; ++i ) {
         choke[i].doUnchoke = 1;
         if( choke[i].isInterested )
@@ -1957 +1926 @@
     if( i < size )
     {
-        int                n;
+        int n;
         struct ChokeData * c;
-        tr_ptrArray *      randPool = tr_ptrArrayNew( );
-
-        for( ; i < size; ++i )
+        tr_ptrArray * randPool = tr_ptrArrayNew( );
+
+        for( ; i<size; ++i )
         {
             if( choke[i].isInterested )
             {
                 const tr_peer * peer = choke[i].peer;
-                int             x = 1, y;
+                int x = 1, y;
                 if( isNew( peer ) ) x *= 3;
                 if( isSame( peer ) ) x *= 3;
-                for( y = 0; y < x; ++y )
+                for( y=0; y<x; ++y )
                     tr_ptrArrayAppend( randPool, &choke[i] );
             }
         }
 
-        if( ( n = tr_ptrArraySize( randPool ) ) )
+        if(( n = tr_ptrArraySize( randPool )))
         {
-            c = tr_ptrArrayNth( randPool, tr_cryptoWeakRandInt( n ) );
+            c = tr_ptrArrayNth( randPool, tr_cryptoWeakRandInt( n ));
             c->doUnchoke = 1;
             t->optimistic = c->peer;
@@ -2022 +1991 @@
     {
         tordbg( t, "purging peer %s because its doPurge flag is set",
-               tr_peerIoAddrStr( &atom->addr,
-                                 atom->port ) );
+                tr_peerIoAddrStr( &atom->addr, atom->port ) );
         return TRUE;
     }
@@ -2036 +2004 @@
         else if( peer->progress < tr_cpPercentDone( tor->completion ) )
             peerHasEverything = FALSE;
-        else
-        {
-            tr_bitfield * tmp =
-                tr_bitfieldDup( tr_cpPieceBitfield( tor->completion ) );
+        else {
+            tr_bitfield * tmp = tr_bitfieldDup( tr_cpPieceBitfield( tor->completion ) );
             tr_bitfieldDifference( tmp, peer->have );
             peerHasEverything = tr_bitfieldCountTrueBits( tmp ) == 0;
             tr_bitfieldFree( tmp );
         }
-        if( peerHasEverything
-          && ( !tr_torrentAllowsPex( tor ) || ( now - atom->time >= 30 ) ) )
-        {
+        if( peerHasEverything && ( !tr_torrentAllowsPex(tor) || (now-atom->time>=30 ))) {
             tordbg( t, "purging peer %s because we're both seeds",
-                   tr_peerIoAddrStr( &atom->addr,
-                                     atom->port ) );
+                   tr_peerIoAddrStr( &atom->addr, atom->port ) );
             return TRUE;
         }
@@ -2057 +2020 @@
      * this is on a sliding scale based on number of available peers... */
     {
-        const int    relaxStrictnessIfFewerThanN =
-            (int)( ( getMaxPeerCount( tor ) * 0.9 ) + 0.5 );
+        const int relaxStrictnessIfFewerThanN = (int)( ( getMaxPeerCount( tor ) * 0.9 ) + 0.5 );
         /* if we have >= relaxIfFewerThan, strictness is 100%.
          * if we have zero connections, strictness is 0% */
-        const float  strictness = peerCount >= relaxStrictnessIfFewerThanN
-                                  ? 1.0
-                                  : peerCount /
-                                  (float)relaxStrictnessIfFewerThanN;
-        const int    lo = MIN_UPLOAD_IDLE_SECS;
-        const int    hi = MAX_UPLOAD_IDLE_SECS;
-        const int    limit = lo + ( ( hi - lo ) * strictness );
+        const float strictness = peerCount >= relaxStrictnessIfFewerThanN
+            ? 1.0
+            : peerCount / (float)relaxStrictnessIfFewerThanN;
+        const int lo = MIN_UPLOAD_IDLE_SECS;
+        const int hi = MAX_UPLOAD_IDLE_SECS;
+        const int limit = lo + ( ( hi - lo ) * strictness );
         const time_t then = peer->pieceDataActivityDate;
-        const int    idleTime = then ? ( now - then ) : 0;
-        if( idleTime > limit )
-        {
-            tordbg(
-                t,
-                "purging peer %s because it's been %d secs since we shared anything",
-                tr_peerIoAddrStr( &atom->addr, atom->port ), idleTime );
+        const int idleTime = then ? ( now - then ) : 0;
+        if( idleTime > limit ) {
+            tordbg( t, "purging peer %s because it's been %d secs since we shared anything",
+                       tr_peerIoAddrStr( &atom->addr, atom->port ), idleTime );
             return TRUE;
         }
@@ -2084 +2042 @@
 
 static tr_peer **
-getPeersToClose( Torrent * t,
-                 int *     setmeSize )
-{
-    int               i, peerCount, outsize;
-    tr_peer **        peers = (tr_peer**) tr_ptrArrayPeek( t->peers,
-                                                           &peerCount );
+getPeersToClose( Torrent * t, int * setmeSize )
+{
+    int i, peerCount, outsize;
+    tr_peer ** peers = (tr_peer**) tr_ptrArrayPeek( t->peers, &peerCount );
     struct tr_peer ** ret = tr_new( tr_peer *, peerCount );
 
@@ -2142 +2098 @@
      * data, try to reconnect to them sooner rather that later -- we don't
      * want network troubles to get in the way of a good peer. */
-    if( ( now - atom->piece_data_time ) <=
-       ( MINIMUM_RECONNECT_INTERVAL_SECS * 2 ) )
+    if( ( now - atom->piece_data_time ) <= ( MINIMUM_RECONNECT_INTERVAL_SECS * 2 ) )
         sec = MINIMUM_RECONNECT_INTERVAL_SECS;
 
@@ -2152 +2107 @@
     /* otherwise, the interval depends on how many times we've tried
      * and failed to connect to the peer */
-    else switch( atom->numFails )
-        {
-            case 0:
-                sec = 0; break;
-
-            case 1:
-                sec = 5; break;
-
-            case 2:
-                sec = 2 * 60; break;
-
-            case 3:
-                sec = 15 * 60; break;
-
-            case 4:
-                sec = 30 * 60; break;
-
-            case 5:
-                sec = 60 * 60; break;
-
-            default:
-                sec = 120 * 60; break;
-        }
+    else switch( atom->numFails ) {
+        case 0: sec = 0; break;
+        case 1: sec = 5; break;
+        case 2: sec = 2 * 60; break;
+        case 3: sec = 15 * 60; break;
+        case 4: sec = 30 * 60; break;
+        case 5: sec = 60 * 60; break;
+        default: sec = 120 * 60; break;
+    }
 
     return sec;
@@ -2180 +2121 @@
 
 static struct peer_atom **
-getPeerCandidates(                               Torrent * t,
-                                           int * setmeSize )
+getPeerCandidates( Torrent * t, int * setmeSize )
 {
     int                 i, atomCount, retCount;
@@ -2222 +2162 @@
         if( ( now - atom->time ) < interval )
         {
-            tordbg(
-                t,
-                "RECONNECT peer %d (%s) is in its grace period of %d seconds..",
-                i, tr_peerIoAddrStr( &atom->addr,
-                                     atom->port ), interval );
+            tordbg( t, "RECONNECT peer %d (%s) is in its grace period of %d seconds..",
+                    i, tr_peerIoAddrStr( &atom->addr, atom->port ), interval );
             continue;
         }
@@ -2265 +2202 @@
     else
     {
-        int                 i, nCandidates, nBad;
+        int i, nCandidates, nBad;
         struct peer_atom ** candidates = getPeerCandidates( t, &nCandidates );
-        struct tr_peer **   connections = getPeersToClose( t, &nBad );
+        struct tr_peer ** connections = getPeersToClose( t, &nBad );
 
         if( nBad || nCandidates )
-            tordbg(
-                t, "reconnect pulse for [%s]: %d bad connections, "
+            tordbg( t, "reconnect pulse for [%s]: %d bad connections, "
                    "%d connection candidates, %d atoms, max per pulse is %d",
-                t->tor->info.name, nBad, nCandidates,
-                tr_ptrArraySize( t->pool ),
-                (int)MAX_RECONNECTIONS_PER_PULSE );
+                   t->tor->info.name, nBad, nCandidates,
+                   tr_ptrArraySize( t->pool ),
+                   (int)MAX_RECONNECTIONS_PER_PULSE );
 
         /* disconnect some peers.
@@ -2281 +2217 @@
            so reset their `numFails' weight to zero.  otherwise we connected
            to them fruitlessly, so mark it as another fail */
-        for( i = 0; i < nBad; ++i )
-        {
-            tr_peer *          peer = connections[i];
+        for( i = 0; i < nBad; ++i ) {
+            tr_peer * peer = connections[i];
             struct peer_atom * atom = getExistingAtom( t, &peer->addr );
             if( peer->pieceDataActivityDate )
@@ -2289 +2224 @@
             else
                 ++atom->numFails;
-            tordbg( t, "removing bad peer %s",
-                   tr_peerIoGetAddrStr( peer->io ) );
+            tordbg( t, "removing bad peer %s", tr_peerIoGetAddrStr( peer->io ) );
             removePeer( t, peer );
         }
@@ -2298 +2232 @@
            && ( i < MAX_RECONNECTIONS_PER_PULSE )
            && ( getPeerCount( t ) < getMaxPeerCount( t->tor ) )
-           && ( newConnectionsThisSecond < MAX_CONNECTIONS_PER_SECOND );
-             ++i )
+           && ( newConnectionsThisSecond < MAX_CONNECTIONS_PER_SECOND ); ++i )
         {
             tr_peerMgr *       mgr = t->manager;
@@ -2308 +2241 @@
                    tr_peerIoAddrStr( &atom->addr, atom->port ) );
 
-            io =
-                tr_peerIoNewOutgoing( mgr->session, &atom->addr, atom->port,
-                                      t->hash );
+            io = tr_peerIoNewOutgoing( mgr->session, &atom->addr, atom->port, t->hash );
             if( io == NULL )
             {
@@ -2317 +2248 @@
             else
             {
-                tr_handshake * handshake = tr_handshakeNew(
-                    io,
-                    mgr->session->
-                    encryptionMode,
-                    myHandshakeDoneCB,
-                    mgr );
+                tr_handshake * handshake = tr_handshakeNew( io,
+                                                            mgr->session->encryptionMode,
+                                                            myHandshakeDoneCB,
+                                                            mgr );
 
                 assert( tr_peerIoGetTorrentHash( io ) );

trunk/libtransmission/peer-mgr.h

@@ -54 +54 @@
 void tr_peerMgrFree( tr_peerMgr * manager );
 
-int tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
-                          const uint8_t     * torrentHash,
-                          const tr_address  * addr );
+tr_bool tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
+                              const uint8_t     * torrentHash,
+                              const tr_address  * addr );
 
 void tr_peerMgrAddIncoming( tr_peerMgr  * manager,

trunk/libtransmission/peer-msgs.c

@@ -123 +123 @@
 
 static int
-compareRequest( const void * va,
-                const void * vb )
+compareRequest( const void * va, const void * vb )
 {
     const struct peer_request * a = va;
@@ -171 +170 @@
 
 static void
-reqListCopy( struct request_list *       dest,
-             const struct request_list * src )
+reqListCopy( struct request_list * dest, const struct request_list * src )
 {
     dest->count = dest->max = src->count;
-    dest->requests =
-        tr_memdup( src->requests, dest->count * sizeof( struct peer_request ) );
+    dest->requests = tr_memdup( src->requests, dest->count * sizeof( struct peer_request ) );
 }
 
@@ -186 +183 @@
 
     memmove( &list->requests[i],
-            &list->requests[i + 1],
-            sizeof( struct peer_request ) * ( --list->count - i ) );
+             &list->requests[i + 1],
+             sizeof( struct peer_request ) * ( --list->count - i ) );
 }
 
@@ -317 +314 @@
 
 static void
-myDebug( const char *               file,
-         int                        line,
+myDebug( const char * file, int line,
          const struct tr_peermsgs * msgs,
-         const char *               fmt,
-         ... )
+         const char * fmt, ... )
 {
     FILE * fp = tr_getLog( );
@@ -517 +512 @@
 
 static void
-publish( tr_peermsgs *   msgs,
-         tr_peer_event * e )
+publish( tr_peermsgs * msgs, tr_peer_event * e )
 {
     assert( msgs->info );
@@ -527 +521 @@
 
 static void
-fireError( tr_peermsgs * msgs,
-           int           err )
+fireError( tr_peermsgs * msgs, int err )
 {
     tr_peer_event e = blankEvent;
-
     e.eventType = TR_PEER_ERROR;
     e.err = err;
@@ -558 +550 @@
 {
     tr_peer_event e = blankEvent;
-
     e.eventType = TR_PEER_PEER_PROGRESS;
     e.progress = msgs->info->progress;
@@ -565 +556 @@
 
 static void
-fireGotBlock( tr_peermsgs *               msgs,
-              const struct peer_request * req )
+fireGotBlock( tr_peermsgs * msgs, const struct peer_request * req )
 {
     tr_peer_event e = blankEvent;
-
     e.eventType = TR_PEER_CLIENT_GOT_BLOCK;
     e.pieceIndex = req->index;
@@ -692 +681 @@
 {
 #if 0
-    const int fext = tr_peerIoSupportsFEXT( msgs->io );
+    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
     const int peerIsNeedy = msgs->info->progress < 0.10;
 
@@ -724 +713 @@
 
     return ( !torrent->info.pieces[piece].dnd )                 /* we want it */
-           && ( !tr_cpPieceIsComplete( torrent->completion, piece ) ) /* !have
-                                                                        */
-           && ( tr_bitfieldHas( peer->info->have, piece ) );   /* peer has it */
+          && ( !tr_cpPieceIsComplete( torrent->completion, piece ) ) /* !have */
+          && ( tr_bitfieldHas( peer->info->have, piece ) );    /* peer has it */
 }
 
@@ -769 +757 @@
 
     msgs->info->clientIsInterested = weAreInterested;
-    dbgmsg( msgs, "Sending %s",
-            weAreInterested ? "Interested" : "Not Interested" );
+    dbgmsg( msgs, "Sending %s", weAreInterested ? "Interested" : "Not Interested" );
     tr_peerIoWriteUint32( msgs->io, out, sizeof( uint8_t ) );
-    tr_peerIoWriteUint8 (
-        msgs->io, out, weAreInterested ? BT_INTERESTED : BT_NOT_INTERESTED );
+    tr_peerIoWriteUint8 ( msgs->io, out, weAreInterested ? BT_INTERESTED : BT_NOT_INTERESTED );
     pokeBatchPeriod( msgs, HIGH_PRIORITY_INTERVAL_SECS );
-    dbgmsg( msgs, "outMessage size is now %d", (int)EVBUFFER_LENGTH( out ) );
+    dbgOutMessageLen( msgs );
 }
 
@@ -820 +806 @@
     if( msgs->info->chokeChangedAt > fibrillationTime )
     {
-        dbgmsg( msgs, "Not changing choke to %d to avoid fibrillation",
-                choke );
+        dbgmsg( msgs, "Not changing choke to %d to avoid fibrillation", choke );
     }
     else if( msgs->info->peerIsChoked != choke )
@@ -869 +854 @@
 expireOldRequests( tr_peermsgs * msgs, const time_t now  )
 {
-    int                 i;
-    time_t              oldestAllowed;
+    int i;
+    time_t oldestAllowed;
     struct request_list tmp = REQUEST_LIST_INIT;
-    const int fext = tr_peerIoSupportsFEXT( msgs->io );
+    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
 
     /* cancel requests that have been queued for too long */
@@ -916 +901 @@
     while( ( count < max ) && reqListPop( &msgs->clientWillAskFor, &req ) )
     {
-        const tr_block_index_t block =
-            _tr_block( msgs->torrent, req.index, req.offset );
+        const tr_block_index_t block = _tr_block( msgs->torrent, req.index, req.offset );
 
         assert( requestIsValid( msgs, &req ) );
@@ -936 +920 @@
 
     if( sent )
-        dbgmsg( msgs,
-                "pump sent %d requests, now have %d active and %d queued",
+        dbgmsg( msgs, "pump sent %d requests, now have %d active and %d queued",
                 sent,
                 msgs->clientAskedFor.count,
@@ -1015 +998 @@
 cancelAllRequestsToPeer( tr_peermsgs * msgs, tr_bool sendCancel )
 {
-    int                 i;
+    int i;
     struct request_list a = msgs->clientWillAskFor;
     struct request_list b = msgs->clientAskedFor;
@@ -1075 +1058 @@
 sendLtepHandshake( tr_peermsgs * msgs )
 {
-    tr_benc           val, *m;
-    char *            buf;
-    int               len;
-    int               pex;
+    tr_benc val, *m;
+    char * buf;
+    int len;
+    int pex;
     struct evbuffer * out = msgs->outMessages;
 
@@ -1095 +1078 @@
         pex = 1;
 
-    tr_bencInitDict( &val, 4 );
+    tr_bencInitDict( &val, 5 );
     tr_bencDictAddInt( &val, "e", msgs->session->encryptionMode != TR_CLEAR_PREFERRED );
     tr_bencDictAddInt( &val, "p", tr_sessionGetPeerPort( msgs->session ) );
@@ -1110 +1093 @@
     tr_peerIoWriteBytes ( msgs->io, out, buf, len );
     pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
-    dbgmsg( msgs, "outMessage size is now %d", (int)EVBUFFER_LENGTH( out ) );
+    dbgOutMessageLen( msgs );
 
     /* cleanup */
@@ -1129 +1112 @@
     msgs->peerSentLtepHandshake = 1;
 
-    if( tr_bencLoad( tmp, len, &val, NULL ) || val.type != TYPE_DICT )
+    if( tr_bencLoad( tmp, len, &val, NULL ) || !tr_bencIsDict( &val ) )
     {
         dbgmsg( msgs, "GET  extended-handshake, couldn't get dictionary" );
@@ -1141 +1124 @@
     if( tr_bencDictFindInt( &val, "e", &i ) )
         msgs->info->encryption_preference = i ? ENCRYPTION_PREFERENCE_YES
-                                            : ENCRYPTION_PREFERENCE_NO;
+                                              : ENCRYPTION_PREFERENCE_NO;
 
     /* check supported messages for utorrent pex */
     msgs->peerSupportsPex = 0;
-    if( tr_bencDictFindDict( &val, "m", &sub ) )
-    {
-        if( tr_bencDictFindInt( sub, "ut_pex", &i ) )
-        {
+    if( tr_bencDictFindDict( &val, "m", &sub ) ) {
+        if( tr_bencDictFindInt( sub, "ut_pex", &i ) ) {
             msgs->ut_pex_id = (uint8_t) i;
             msgs->peerSupportsPex = msgs->ut_pex_id == 0 ? 0 : 1;
@@ -1160 +1141 @@
 
     /* get peer's listening port */
-    if( tr_bencDictFindInt( &val, "p", &i ) )
-    {
+    if( tr_bencDictFindInt( &val, "p", &i ) ) {
         msgs->info->port = htons( (uint16_t)i );
         dbgmsg( msgs, "msgs->port is now %hu", msgs->info->port );
@@ -1171 +1151 @@
 
 static void
-parseUtPex( tr_peermsgs *     msgs,
-            int               msglen,
-            struct evbuffer * inbuf )
-{
-    int                loaded = 0;
-    uint8_t *          tmp = tr_new( uint8_t, msglen );
-    tr_benc            val;
+parseUtPex( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
+{
+    int loaded = 0;
+    uint8_t * tmp = tr_new( uint8_t, msglen );
+    tr_benc val;
     const tr_torrent * tor = msgs->torrent;
-    const uint8_t *    added;
-    size_t             added_len;
+    const uint8_t * added;
+    size_t added_len;
 
     tr_peerIoReadBytes( msgs->io, inbuf, tmp, msglen );
 
     if( tr_torrentAllowsPex( tor )
-      && ( ( loaded = !tr_bencLoad( tmp, msglen, &val, NULL ) ) )
-      && tr_bencDictFindRaw( &val, "added", &added, &added_len ) )
+      && (( loaded = !tr_bencLoad( tmp, msglen, &val, NULL )))
+      && tr_bencDictFindRaw( &val, "added", &added, &added_len ))
     {
         const uint8_t * added_f = NULL;
@@ -1193 +1171 @@
         size_t          added_f_len = 0;
         tr_bencDictFindRaw( &val, "added.f", &added_f, &added_f_len );
-        pex =
-            tr_peerMgrCompactToPex( added, added_len, added_f, added_f_len,
-                                    &n );
-        for( i = 0; i < n; ++i )
+        pex = tr_peerMgrCompactToPex( added, added_len, added_f, added_f_len, &n );
+        for( i=0; i<n; ++i )
             tr_peerMgrAddPex( msgs->session->peerMgr, tor->info.hash,
                               TR_PEER_FROM_PEX, pex + i );
@@ -1309 +1285 @@
                  const struct peer_request * req )
 {
-    const int fext = tr_peerIoSupportsFEXT( msgs->io );
+    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
     const int reqIsValid = requestIsValid( msgs, req );
     const int clientHasPiece = reqIsValid && tr_cpPieceIsComplete( msgs->torrent->completion, req->index );
@@ -1332 +1308 @@
 
 static int
-messageLengthIsCorrect( const tr_peermsgs * msg,
-                        uint8_t             id,
-                        uint32_t            len )
+messageLengthIsCorrect( const tr_peermsgs * msg, uint8_t id, uint32_t len )
 {
     switch( id )
@@ -1396 +1370 @@
         tr_peerIoReadUint32( msgs->io, inbuf, &req->offset );
         req->length = msgs->incoming.length - 9;
-        dbgmsg( msgs, "got incoming block header %u:%u->%u", req->index,
-                req->offset,
-                req->length );
+        dbgmsg( msgs, "got incoming block header %u:%u->%u", req->index, req->offset, req->length );
         return READ_NOW;
     }
     else
     {
-        int          err;
+        int err;
 
         /* read in another chunk of data */
-        const size_t nLeft = req->length - EVBUFFER_LENGTH(
-            msgs->incoming.block );
-        size_t       n = MIN( nLeft, inlen );
-        uint8_t *    buf = tr_new( uint8_t, n );
+        const size_t nLeft = req->length - EVBUFFER_LENGTH( msgs->incoming.block );
+        size_t n = MIN( nLeft, inlen );
+        uint8_t * buf = tr_new( uint8_t, n );
         assert( EVBUFFER_LENGTH( inbuf ) >= n );
         tr_peerIoReadBytes( msgs->io, inbuf, buf, n );
@@ -1416 +1387 @@
         *setme_piece_bytes_read += n;
         tr_free( buf );
-        dbgmsg( msgs, "got %d bytes for block %u:%u->%u ... %d remain",
-               (int)n, req->index, req->offset, req->length,
+        dbgmsg( msgs, "got %zu bytes for block %u:%u->%u ... %d remain",
+               n, req->index, req->offset, req->length,
                (int)( req->length - EVBUFFER_LENGTH( msgs->incoming.block ) ) );
         if( EVBUFFER_LENGTH( msgs->incoming.block ) < req->length )
@@ -1423 +1394 @@
 
         /* we've got the whole block ... process it */
-        err = clientGotBlock( msgs, EVBUFFER_DATA(
-                                  msgs->incoming.block ), req );
+        err = clientGotBlock( msgs, EVBUFFER_DATA( msgs->incoming.block ), req );
 
         /* cleanup */
-        evbuffer_drain( msgs->incoming.block,
-                       EVBUFFER_LENGTH( msgs->incoming.block ) );
+        evbuffer_drain( msgs->incoming.block, EVBUFFER_LENGTH( msgs->incoming.block ) );
         req->length = 0;
         msgs->state = AWAITING_BT_LENGTH;
         if( !err )
             return READ_NOW;
-        else
-        {
+        else {
             fireError( msgs, err );
             return READ_ERR;
@@ -1442 +1410 @@
 
 static int
-readBtMessage( tr_peermsgs *     msgs,
-               struct evbuffer * inbuf,
-               size_t            inlen )
+readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
 {
     uint32_t      ui32;
@@ -1450 +1416 @@
     const uint8_t id = msgs->incoming.id;
     const size_t  startBufLen = EVBUFFER_LENGTH( inbuf );
-    const int     fext = tr_peerIoSupportsFEXT( msgs->io );
+    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
 
     --msglen; /* id length */
@@ -1457 +1423 @@
         return READ_LATER;
 
-    dbgmsg( msgs, "got BT id %d, len %d, buffer size is %d", (int)id,
-            (int)msglen,
-            (int)inlen );
+    dbgmsg( msgs, "got BT id %d, len %d, buffer size is %zu", (int)id, (int)msglen, inlen );
 
     if( !messageLengthIsCorrect( msgs, id, msglen + 1 ) )
     {
-        dbgmsg( msgs, "bad packet - BT message #%d with a length of %d",
-                (int)id, (int)msglen );
+        dbgmsg( msgs, "bad packet - BT message #%d with a length of %d", (int)id, (int)msglen );
         fireError( msgs, EMSGSIZE );
         return READ_ERR;
@@ -1497 +1460 @@
             tr_peerIoReadUint32( msgs->io, inbuf, &ui32 );
             dbgmsg( msgs, "got Have: %u", ui32 );
-            if( tr_bitfieldAdd( msgs->info->have, ui32 ) )
-            {
+            if( tr_bitfieldAdd( msgs->info->have, ui32 ) ) {
                 fireError( msgs, ERANGE );
                 return READ_ERR;
@@ -1511 +1473 @@
             dbgmsg( msgs, "got a bitfield" );
             msgs->peerSentBitfield = 1;
-            tr_peerIoReadBytes( msgs->io, inbuf, msgs->info->have->bits,
-                                msglen );
+            tr_peerIoReadBytes( msgs->io, inbuf, msgs->info->have->bits, msglen );
             updatePeerProgress( msgs );
             fireNeedReq( msgs );
@@ -1630 +1591 @@
 
 static void
-decrementDownloadedCount( tr_peermsgs * msgs,
-                          uint32_t      byteCount )
+decrementDownloadedCount( tr_peermsgs * msgs, uint32_t byteCount )
 {
     tr_torrent * tor = msgs->torrent;
@@ -1639 +1599 @@
 
 static void
-clientGotUnwantedBlock( tr_peermsgs *               msgs,
-                        const struct peer_request * req )
+clientGotUnwantedBlock( tr_peermsgs * msgs, const struct peer_request * req )
 {
     decrementDownloadedCount( msgs, req->length );
@@ -1646 +1605 @@
 
 static void
-addPeerToBlamefield( tr_peermsgs * msgs,
-                     uint32_t      index )
+addPeerToBlamefield( tr_peermsgs * msgs, uint32_t index )
 {
     if( !msgs->info->blame )
-        msgs->info->blame = tr_bitfieldNew( msgs->torrent->info.pieceCount );
+         msgs->info->blame = tr_bitfieldNew( msgs->torrent->info.pieceCount );
     tr_bitfieldAdd( msgs->info->blame, index );
 }
@@ -1660 +1618 @@
                 const struct peer_request * req )
 {
-    int                    err;
-    tr_torrent *           tor = msgs->torrent;
+    int err;
+    tr_torrent * tor = msgs->torrent;
     const tr_block_index_t block = _tr_block( tor, req->index, req->offset );
 
@@ -1667 +1625 @@
     assert( req );
 
-    if( req->length != tr_torBlockCountBytes( msgs->torrent, block ) )
-    {
+    if( req->length != tr_torBlockCountBytes( msgs->torrent, block ) ) {
         dbgmsg( msgs, "wrong block size -- expected %u, got %d",
                 tr_torBlockCountBytes( msgs->torrent, block ), req->length );
@@ -1675 +1632 @@
 
     /* save the block */
-    dbgmsg( msgs, "got block %u:%u->%u", req->index, req->offset,
-            req->length );
+    dbgmsg( msgs, "got block %u:%u->%u", req->index, req->offset, req->length );
 
     /**
@@ -1682 +1638 @@
     **/
 
-    if( !reqListRemove( &msgs->clientAskedFor, req ) )
-    {
+    if( !reqListRemove( &msgs->clientAskedFor, req ) ) {
         clientGotUnwantedBlock( msgs, req );
         dbgmsg( msgs, "we didn't ask for this message..." );
@@ -1696 +1651 @@
     **/
 
-    if( tr_cpBlockIsComplete( tor->completion, block ) )
-    {
+    if( tr_cpBlockIsComplete( tor->completion, block ) ) {
         dbgmsg( msgs, "we have this block already..." );
         clientGotUnwantedBlock( msgs, req );
@@ -1788 +1742 @@
     struct peer_request req;
     const int haveMessages = EVBUFFER_LENGTH( msgs->outMessages ) != 0;
-    const int fext = tr_peerIoSupportsFEXT( msgs->io );
+    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
 
     /**
@@ -1947 +1901 @@
     tr_peerIoWriteUint8 ( msgs->io, out, BT_BITFIELD );
     tr_peerIoWriteBytes ( msgs->io, out, field->bits, field->byteCount );
-    dbgmsg( msgs, "sending bitfield... outMessage size is now %d",
-           (int)EVBUFFER_LENGTH( out ) );
+    dbgmsg( msgs, "sending bitfield... outMessage size is now %zu",
+            EVBUFFER_LENGTH( out ) );
     pokeBatchPeriod( msgs, IMMEDIATE_PRIORITY_INTERVAL_SECS );
 
@@ -1960 +1914 @@
 tellPeerWhatWeHave( tr_peermsgs * msgs )
 {
-    const int fext = tr_peerIoSupportsFEXT( msgs->io );
+    const tr_bool fext = tr_peerIoSupportsFEXT( msgs->io );
 
     if( fext && ( tr_cpGetStatus( msgs->torrent->completion ) == TR_SEED ) )

trunk/libtransmission/webseed.c

@@ -66 +66 @@
 {
     tr_peer_event e = blankEvent;
-
     e.eventType = TR_PEER_NEED_REQ;
     publish( w, &e );
@@ -72 +71 @@
 
 static void
-fireClientGotBlock( tr_webseed * w,
-                    uint32_t     pieceIndex,
-                    uint32_t     offset,
-                    uint32_t     length )
+fireClientGotBlock( tr_webseed * w, uint32_t pieceIndex, uint32_t offset, uint32_t length )
 {
     tr_peer_event e = blankEvent;
-
     e.eventType = TR_PEER_CLIENT_GOT_BLOCK;
     e.pieceIndex = pieceIndex;
@@ -87 +82 @@
 
 static void
-fireClientGotData( tr_webseed * w,
-                   uint32_t     length )
+fireClientGotData( tr_webseed * w, uint32_t length )
 {
     tr_peer_event e = blankEvent;
-
     e.eventType = TR_PEER_CLIENT_GOT_DATA;
     e.length = length;
     e.wasPieceData = TRUE;
-
     publish( w, &e );
 }
@@ -125 +117 @@
             switch( *str )
             {
-                case ',':
-                case '-':
-                case '.':
-                case '/':
-                case '0':
-                case '1':
-                case '2':
-                case '3':
-                case '4':
-                case '5':
-                case '6':
-                case '7':
-                case '8':
-                case '9':
-                case 'a':
-                case 'b':
-                case 'c':
-                case 'd':
-                case 'e':
-                case 'f':
-                case 'g':
-                case 'h':
-                case 'i':
-                case 'j':
-                case 'k':
-                case 'l':
-                case 'm':
-                case 'n':
-                case 'o':
-                case 'p':
-                case 'q':
-                case 'r':
-                case 's':
-                case 't':
-                case 'u':
-                case 'v':
-                case 'w':
-                case 'x':
-                case 'y':
-                case 'z':
-                case 'A':
-                case 'B':
-                case 'C':
-                case 'D':
-                case 'E':
-                case 'F':
-                case 'G':
-                case 'H':
-                case 'I':
-                case 'J':
-                case 'K':
-                case 'L':
-                case 'M':
-                case 'N':
-                case 'O':
-                case 'P':
-                case 'Q':
-                case 'R':
-                case 'S':
-                case 'T':
-                case 'U':
-                case 'V':
-                case 'W':
-                case 'X':
-                case 'Y':
-                case 'Z':
+                case ',': case '-': case '.': case '/':
+                case '0': case '1': case '2': case '3': case '4':
+                case '5': case '6': case '7': case '8': case '9':
+                case 'a': case 'b': case 'c': case 'd': case 'e':
+                case 'f': case 'g': case 'h': case 'i': case 'j':
+                case 'k': case 'l': case 'm': case 'n': case 'o':
+                case 'p': case 'q': case 'r': case 's': case 't':
+                case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
+                case 'A': case 'B': case 'C': case 'D': case 'E':
+                case 'F': case 'G': case 'H': case 'I': case 'J':
+                case 'K': case 'L': case 'M': case 'N': case 'O':
+                case 'P': case 'Q': case 'R': case 'S': case 'T':
+                case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
                     evbuffer_add( out, str, 1 );
                     break;
-
                 default:
                     evbuffer_add_printf( out, "%%%02X", *str );
@@ -315 +253 @@
 
 int
-tr_webseedGetSpeed( const tr_webseed * w,
-                    float *            setme_KiBs )
+tr_webseedGetSpeed( const tr_webseed * w, float * setme_KiBs )
 {
     const int isActive = tr_webseedIsActive( w );