Changeset 3 for trunk/libtransmission

Timestamp:

Jan 12, 2006, 6:29:20 PM (16 years ago)

Author:

root

Message:

Update 2005-11-17

Location:

trunk/libtransmission

Files:

• Jamfile (modified) (1 diff)
• completion.c (added)
• completion.h (added)
• fastresume.h (modified) (4 diffs)
• fdlimit.c (modified) (4 diffs)
• inout.c (modified) (11 diffs)
• internal.h (modified) (6 diffs)
• peer.c (modified) (3 diffs)
• peermessages.h (modified) (2 diffs)
• peerparse.h (modified) (4 diffs)
• peerutils.h (modified) (6 diffs)
• tracker.c (modified) (2 diffs)
• transmission.c (modified) (14 diffs)
• utils.h (modified) (1 diff)

trunk/libtransmission/Jamfile

@@ -3 +3 @@
 LIBTRANSMISSION_SRC =
     transmission.c bencode.c net.c tracker.c peer.c inout.c
-    metainfo.c sha1.c utils.c upload.c fdlimit.c clients.c ;
+    metainfo.c sha1.c utils.c upload.c fdlimit.c clients.c
+    completion.c ;
 
 Library       libtransmission.a       : $(LIBTRANSMISSION_SRC) ;

trunk/libtransmission/fastresume.h

@@ -102 +102 @@
     char    * path;
     int     * fileMTimes;
-    int       i;
     uint8_t * blockBitfield;
 
@@ -131 +130 @@
 
     /* Build and write the bitfield for blocks */
-    blockBitfield = calloc( ( tor->blockCount + 7 ) / 8, 1 );
-    for( i = 0; i < tor->blockCount; i++ )
-    {
-        if( tor->blockHave[i] < 0 )
-        {
-            tr_bitfieldAdd( blockBitfield, i );
-        }
-    }
+    blockBitfield = tr_cpBlockBitfield( tor->completion );
     fwrite( blockBitfield, ( tor->blockCount + 7 ) / 8, 1, file );
-    free( blockBitfield );
 
     /* Write the 'slotPiece' table */
@@ -223 +214 @@
     blockBitfield = calloc( ( tor->blockCount + 7 ) / 8, 1 );
     fread( blockBitfield, ( tor->blockCount + 7 ) / 8, 1, file );
-    tor->blockHaveCount = 0;
-    for( i = 0; i < tor->blockCount; i++ )
-    {
-        if( tr_bitfieldHas( blockBitfield, i ) )
-        {
-            tor->blockHave[i] = -1;
-            (tor->blockHaveCount)++;
-        }
-    }
+    tr_cpBlockBitfieldSet( tor->completion, blockBitfield );
     free( blockBitfield );
 
@@ -254 +237 @@
             }
         }
-
-        for( j = tr_pieceStartBlock( i );
-             j < tr_pieceStartBlock( i ) + tr_pieceCountBlocks( i );
-             j++ )
-        {
-            if( tor->blockHave[j] > -1 )
-            {
-                break;
-            }
-        }
-        if( j >= tr_pieceStartBlock( i ) + tr_pieceCountBlocks( i ) )
-        {
-            // tr_dbg( "Piece %d is complete", i );
-            tr_bitfieldAdd( tor->bitfield, i );
-        }
     }
     // tr_dbg( "Slot used: %d", io->slotsUsed );

trunk/libtransmission/fdlimit.c

@@ -35 +35 @@
 #define STATUS_UNUSED  2
 #define STATUS_USED    4
+#define STATUS_CLOSING 8
     int        status;
 
@@ -112 +113 @@
             !strcmp( path, f->open[i].path ) )
         {
+            if( f->open[i].status & STATUS_CLOSING )
+            {
+                /* Wait until the file is closed */
+                tr_lockUnlock( f->lock );
+                tr_wait( 10 );
+                tr_lockLock( f->lock );
+                i = -1;
+                continue;
+            }
             winner = i;
             goto done;
@@ -135 +145 @@
         for( i = 0; i < TR_MAX_OPEN_FILES; i++ )
         {
-            if( f->open[i].status & STATUS_USED )
+            if( !( f->open[i].status & STATUS_UNUSED ) )
             {
                 continue;
@@ -148 +158 @@
         if( winner >= 0 )
         {
+            /* Close the file: we mark it as closing then release the
+               lock while doing so, because fclose may take same time
+               and we don't want to block other threads */
             tr_dbg( "Closing %s", f->open[winner].path );
+            f->open[winner].status = STATUS_CLOSING;
+            tr_lockUnlock( f->lock );
             fclose( f->open[winner].file );
+            tr_lockLock( f->lock );
             goto open;
         }

trunk/libtransmission/inout.c

@@ -137 +137 @@
     for( i = startBlock; i < endBlock; i++ )
     {
-        if( tor->blockHave[i] >= 0 )
+        if( !tr_cpBlockIsComplete( tor->completion, i ) )
         {
             /* The piece is not complete */
@@ -160 +160 @@
         for( i = startBlock; i < endBlock; i++ )
         {
-            tor->blockHave[i]    = 0;
-            tor->blockHaveCount -= 1;
+            tr_cpBlockRem( tor->completion, i );
         }
     }
@@ -168 +167 @@
         tr_inf( "Piece %d (slot %d): hash OK", index,
                 io->pieceSlot[index] );
-        tr_bitfieldAdd( tor->bitfield, index );
+        tr_cpPieceAdd( tor->completion, index );
     }
 
@@ -267 +266 @@
     uint8_t * buf;
     uint8_t hash[SHA_DIGEST_LENGTH];
-    int startBlock, endBlock;
 
     io->pieceSlot = malloc( inf->pieceCount * sizeof( int ) );
@@ -282 +280 @@
     memset( io->pieceSlot, 0xFF, inf->pieceCount * sizeof( int ) );
     memset( io->slotPiece, 0xFF, inf->pieceCount * sizeof( int ) );
-    memset( tor->bitfield, 0, ( inf->pieceCount + 7 ) / 8 );
-    memset( tor->blockHave, 0, tor->blockCount );
-    tor->blockHaveCount = 0;
 
     /* Check pieces */
@@ -305 +300 @@
             if( !memcmp( hash, &inf->pieces[20*j], SHA_DIGEST_LENGTH ) )
             {
-                int k;
                 io->pieceSlot[j] = i;
                 io->slotPiece[i] = j;
-                tr_bitfieldAdd( tor->bitfield, j );
-
-                startBlock = tr_pieceStartBlock( j );
-                endBlock   = startBlock + tr_pieceCountBlocks( j );
-                for( k = startBlock; k < endBlock; k++ )
-                {
-                    tor->blockHave[k] = -1;
-                    tor->blockHaveCount++;
-                }
+
+                tr_cpPieceAdd( tor->completion, j );
                 break;
             }
@@ -333 +320 @@
             io->pieceSlot[inf->pieceCount - 1] = i;
             io->slotPiece[i]                   = inf->pieceCount - 1;
-            tr_bitfieldAdd( tor->bitfield, inf->pieceCount - 1 );
-
-            startBlock = tr_pieceStartBlock( inf->pieceCount - 1 );
-            endBlock   = startBlock +
-                tr_pieceCountBlocks( inf->pieceCount - 1 );
-            for( j = startBlock; j < endBlock; j++ )
-            {
-                tor->blockHave[j] = -1;
-                tor->blockHaveCount++;
-            }
+
+            tr_cpPieceAdd( tor->completion, inf->pieceCount - 1 );
         }
     }
@@ -411 +390 @@
     {
         asprintf( &path, "%s/%s", tor->destination, inf->files[i].name );
+        tr_lockUnlock( tor->lock );
         file = tr_fdFileOpen( tor->fdlimit, path );
+        tr_lockLock( tor->lock );
         free( path );
 
@@ -422 +403 @@
                           (uint64_t) size );
 
+        tr_lockUnlock( tor->lock );
         if( fseeko( file, posInFile, SEEK_SET ) )
         {
+            tr_lockLock( tor->lock );
             return 1;
         }
@@ -430 +413 @@
             if( fwrite( buf, willRead, 1, file ) != 1 )
             {
+                tr_lockLock( tor->lock );
                 return 1;
             }
@@ -437 +421 @@
             if( fread( buf, willRead, 1, file ) != 1 )
             {
+                tr_lockLock( tor->lock );
                 return 1;
             }
         }
-
+        tr_lockLock( tor->lock );
         tr_fdFileRelease( tor->fdlimit, file );
 

trunk/libtransmission/internal.h

@@ -108 +108 @@
 
 typedef struct tr_torrent_s tr_torrent_t;
+typedef struct tr_completion_s tr_completion_t;
 
 #include "bencode.h"
@@ -130 +131 @@
 
     char            * id;
+    char            * key;
 
     /* An escaped string used to include the hash in HTTP queries */
@@ -143 +145 @@
     int               blockCount;
     
+#if 0
     /* Status for each block
        -1 = we have it
@@ -149 +152 @@
     int               blockHaveCount;
     uint8_t         * bitfield;
+#endif
+    tr_completion_t * completion;
 
     volatile char     die;
@@ -171 +176 @@
 
 #include "utils.h"
+#include "completion.h"
 
 struct tr_handle_s
@@ -183 +189 @@
 
     char           id[21];
+    char           key[21];
     char           prefsDirectory[256];
 };

trunk/libtransmission/peer.c

@@ -170 +170 @@
         r     = &peer->inRequests[j];
         block = tr_block( r->index,r->begin );
-        if( tor->blockHave[block] > 0 )
-        {
-          (tor->blockHave[block])--;
-        }
+        tr_cpDownloaderRem( tor->completion, block );
     }
     if( !peer->amChoking )
@@ -272 +269 @@
         peer = tor->peers[i];
 
-        /* Connect */
-        if( ( peer->status & PEER_STATUS_IDLE ) &&
-            !tr_fdSocketWillCreate( tor->fdlimit, 0 ) )
-        {
-            peer->socket = tr_netOpen( peer->addr, peer->port );
-            if( peer->socket < 0 )
-            {
-                peer_dbg( "connection failed" );
-                goto dropPeer;
-            }
-            peer->status = PEER_STATUS_CONNECTING;
-        }
-
-        /* Try to send handshake */
-        if( peer->status & PEER_STATUS_CONNECTING )
-        {
-            uint8_t buf[68];
-            tr_info_t * inf = &tor->info;
-
-            buf[0] = 19;
-            memcpy( &buf[1], "BitTorrent protocol", 19 );
-            memset( &buf[20], 0, 8 );
-            memcpy( &buf[28], inf->hash, 20 );
-            memcpy( &buf[48], tor->id, 20 );
-
-            ret = tr_netSend( peer->socket, buf, 68 );
+        if( peer->status < PEER_STATUS_HANDSHAKE )
+        {
+            i++;
+            continue;
+        }
+
+        /* Try to read */
+        for( ;; )
+        {
+            if( peer->size < 1 )
+            {
+                peer->size = 1024;
+                peer->buf  = malloc( peer->size );
+            }
+            else if( peer->pos >= peer->size )
+            {
+                peer->size *= 2;
+                peer->buf   = realloc( peer->buf, peer->size );
+            }
+            ret = tr_netRecv( peer->socket, &peer->buf[peer->pos],
+                              peer->size - peer->pos );
             if( ret & TR_NET_CLOSE )
             {
@@ -303 +295 @@
                 goto dropPeer;
             }
-            else if( !( ret & TR_NET_BLOCK ) )
-            {
-                peer_dbg( "SEND handshake" );
-                peer->status = PEER_STATUS_HANDSHAKE;
-            }
-        }
-
-        /* Try to read */
-        if( peer->status >= PEER_STATUS_HANDSHAKE )
-        {
-            for( ;; )
-            {
-                if( peer->size < 1 )
-                {
-                    peer->size = 1024;
-                    peer->buf  = malloc( peer->size );
-                }
-                else if( peer->pos >= peer->size )
-                {
-                    peer->size *= 2;
-                    peer->buf   = realloc( peer->buf, peer->size );
-                }
-                ret = tr_netRecv( peer->socket, &peer->buf[peer->pos],
-                                  peer->size - peer->pos );
-                if( ret & TR_NET_CLOSE )
-                {
-                    peer_dbg( "connection closed" );
-                    goto dropPeer;
-                }
-                else if( ret & TR_NET_BLOCK )
+            else if( ret & TR_NET_BLOCK )
+            {
+                break;
+            }
+            peer->date  = tr_date();
+            peer->pos  += ret;
+            if( parseBuf( tor, peer, ret ) )
+            {
+                goto dropPeer;
+            }
+        }
+
+        if( peer->status < PEER_STATUS_CONNECTED )
+        {
+            i++;
+            continue;
+        }
+
+        /* Try to write */
+writeBegin:
+
+        /* Send all smaller messages regardless of the upload cap */
+        while( ( p = messagesPending( peer, &size ) ) )
+        {
+            ret = tr_netSend( peer->socket, p, size );
+            if( ret & TR_NET_CLOSE )
+            {
+                goto dropPeer;
+            }
+            else if( ret & TR_NET_BLOCK )
+            {
+                goto writeEnd;
+            }
+            messagesSent( peer, ret );
+        }
+
+        /* Send pieces if we can */
+        while( ( p = blockPending( tor, peer, &size ) ) )
+        {
+            if( !tr_uploadCanUpload( tor->upload ) )
+            {
+                break;
+            }
+
+            ret = tr_netSend( peer->socket, p, size );
+            if( ret & TR_NET_CLOSE )
+            {
+                goto dropPeer;
+            }
+            else if( ret & TR_NET_BLOCK )
+            {
+                break;
+            }
+
+            blockSent( peer, ret );
+            tr_uploadUploaded( tor->upload, ret );
+
+            tor->uploaded[9] += ret;
+            peer->outTotal   += ret;
+            peer->outDate     = tr_date();
+
+            /* In case this block is done, you may have messages
+               pending. Send them before we start the next block */
+            goto writeBegin;
+        }
+writeEnd:
+
+        /* Ask for a block whenever possible */
+        if( !tr_cpIsSeeding( tor->completion ) &&
+            !peer->amInterested && tor->peerCount > TR_MAX_PEER_COUNT - 2 )
+        {
+            /* This peer is no use to us, and it seems there are
+               more */
+            peer_dbg( "not interesting" );
+            tr_peerRem( tor, i );
+            continue;
+        }
+
+        if( peer->amInterested && !peer->peerChoking )
+        {
+            int block;
+            while( peer->inRequestCount < OUR_REQUEST_COUNT )
+            {
+                block = chooseBlock( tor, peer );
+                if( block < 0 )
                 {
                     break;
                 }
-                peer->date  = tr_date();
-                peer->pos  += ret;
-                if( parseBuf( tor, peer, ret ) )
-                {
-                    goto dropPeer;
-                }
-            }
-        }
-
-        /* Try to write */
-writeBegin:
-
-        /* Send all smaller messages regardless of the upload cap */
-        while( ( p = messagesPending( peer, &size ) ) )
-        {
-            ret = tr_netSend( peer->socket, p, size );
-            if( ret & TR_NET_CLOSE )
-            {
-                goto dropPeer;
-            }
-            else if( ret & TR_NET_BLOCK )
-            {
-                goto writeEnd;
-            }
-            messagesSent( peer, ret );
-        }
-
-        /* Send pieces if we can */
-        while( ( p = blockPending( tor, peer, &size ) ) )
-        {
-            if( !tr_uploadCanUpload( tor->upload ) )
-            {
-                break;
-            }
-
-            ret = tr_netSend( peer->socket, p, size );
-            if( ret & TR_NET_CLOSE )
-            {
-                goto dropPeer;
-            }
-            else if( ret & TR_NET_BLOCK )
-            {
-                break;
-            }
-
-            blockSent( peer, ret );
-            tr_uploadUploaded( tor->upload, ret );
-
-            tor->uploaded[9] += ret;
-            peer->outTotal   += ret;
-            peer->outDate     = tr_date();
-
-            /* In case this block is done, you may have messages
-               pending. Send them before we start the next block */
-            goto writeBegin;
-        }
-writeEnd:
-
-        /* Connected peers: ask for a block whenever possible */
-        if( peer->status & PEER_STATUS_CONNECTED )
-        {
-            if( tor->blockHaveCount < tor->blockCount &&
-                !peer->amInterested && tor->peerCount > TR_MAX_PEER_COUNT - 2 )
-            {
-                /* This peer is no use to us, and it seems there are
-                   more */
-                peer_dbg( "not interesting" );
-                tr_peerRem( tor, i );
-                continue;
-            }
-
-            if( peer->amInterested && !peer->peerChoking )
-            {
-                int block;
-                while( peer->inRequestCount < OUR_REQUEST_COUNT )
-                {
-                    block = chooseBlock( tor, peer );
-                    if( block < 0 )
-                    {
-                        break;
-                    }
-                    sendRequest( tor, peer, block );
-                }
+                sendRequest( tor, peer, block );
             }
         }

trunk/libtransmission/peermessages.h

@@ -216 +216 @@
     TR_HTONL( 1 + bitfieldSize, p );
     p[4] = 5;
-    memcpy( &p[5], tor->bitfield, bitfieldSize );
+    memcpy( &p[5], tr_cpPieceBitfield( tor->completion ), bitfieldSize );
 
     peer_dbg( "SEND bitfield" );
@@ -258 +258 @@
     TR_HTONL( r->length, p + 13 );
 
-    /* Remember that we have one more uploader for this block */
-    (tor->blockHave[block])++;
+    tr_cpDownloaderAdd( tor->completion, block );
 
     peer_dbg( "SEND request %d/%d (%d bytes)",

trunk/libtransmission/peerparse.h

@@ -52 +52 @@
         {
             r = &peer->inRequests[i];
-            if( tor->blockHave[tr_block(r->index,r->begin)] > 0 )
-            {
-                tor->blockHave[tr_block(r->index,r->begin)]--;
-            }
+            tr_cpDownloaderRem( tor->completion, tr_block(r->index,r->begin) );
         }
         peer->inRequestCount = 0;
@@ -246 +243 @@
             {
                 r = &peer->inRequests[j];
-                if( tor->blockHave[tr_block(r->index,r->begin)] > 0 )
-                {
-                    tor->blockHave[tr_block(r->index,r->begin)]--;
-                }
+                tr_cpDownloaderRem( tor->completion,
+                                    tr_block(r->index,r->begin) );
             }
             suckyClient = 1;
@@ -275 +270 @@
 
     block = tr_block( r->index, r->begin );
-    if( tor->blockHave[block] < 0 )
+    if( tr_cpBlockIsComplete( tor->completion, block ) )
     {
         peer_dbg( "have this block already" );
@@ -284 +279 @@
     }
 
-    tor->blockHave[block]  = -1;
-    tor->blockHaveCount   +=  1;
+    tr_cpBlockAdd( tor->completion, block );
     tr_ioWrite( tor->io, index, begin, len - 9, &p[8] );
+    tr_cpDownloaderRem( tor->completion, block );
 
     sendCancel( tor, block );
 
-    if( tr_bitfieldHas( tor->bitfield, index ) )
+    if( tr_cpPieceIsComplete( tor->completion, index ) )
     {
         tr_peer_t * otherPeer;

trunk/libtransmission/peerutils.h

@@ -164 +164 @@
     }
 
+    /* Connect */
+    if( ( peer->status & PEER_STATUS_IDLE ) &&
+        !tr_fdSocketWillCreate( tor->fdlimit, 0 ) )
+    {
+        peer->socket = tr_netOpen( peer->addr, peer->port );
+        if( peer->socket < 0 )
+        {
+            peer_dbg( "connection failed" );
+            tr_fdSocketClosed( tor->fdlimit, 0 );
+            return 1;
+        }
+        peer->status = PEER_STATUS_CONNECTING;
+    }
+
+    /* Try to send handshake */
+    if( peer->status & PEER_STATUS_CONNECTING )
+    {
+        uint8_t buf[68];
+        tr_info_t * inf = &tor->info;
+        int ret;
+
+        buf[0] = 19;
+        memcpy( &buf[1], "BitTorrent protocol", 19 );
+        memset( &buf[20], 0, 8 );
+        memcpy( &buf[28], inf->hash, 20 );
+        memcpy( &buf[48], tor->id, 20 );
+
+        ret = tr_netSend( peer->socket, buf, 68 );
+        if( ret & TR_NET_CLOSE )
+        {
+            peer_dbg( "connection closed" );
+            return 1;
+        }
+        else if( !( ret & TR_NET_BLOCK ) )
+        {
+            peer_dbg( "SEND handshake" );
+            peer->status = PEER_STATUS_HANDSHAKE;
+        }
+    }
+
     return 0;
 }
@@ -179 +219 @@
     int i;
     int bitfieldSize = ( inf->pieceCount + 7 ) / 8;
+    uint8_t * bitfield = tr_cpPieceBitfield( tor->completion );
 
     if( !peer->bitfield )
@@ -188 +229 @@
     for( i = 0; i < bitfieldSize; i++ )
     {
-        if( ( peer->bitfield[i] & ~(tor->bitfield[i]) ) & 0xFF )
+        if( ( peer->bitfield[i] & ~(bitfield[i]) ) & 0xFF )
         {
             return 1;
@@ -223 +264 @@
     tr_info_t * inf = &tor->info;
 
-    int i, j;
-    int startBlock, endBlock, countBlocks;
+    int i;
     int missingBlocks, minMissing;
     int poolSize, * pool;
@@ -235 +275 @@
     for( i = 0; i < inf->pieceCount; i++ )
     {
+        missingBlocks = tr_cpMissingBlocksForPiece( tor->completion, i );
+        if( missingBlocks < 1 )
+        {
+            /* We already have or are downloading all blocks */
+            continue;
+        }
         if( !tr_bitfieldHas( peer->bitfield, i ) )
         {
             /* The peer doesn't have this piece */
-            continue;
-        }
-        if( tr_bitfieldHas( tor->bitfield, i ) )
-        {
-            /* We already have it */
-            continue;
-        }
-
-        /* Count how many blocks from this piece are missing */
-        startBlock    = tr_pieceStartBlock( i );
-        countBlocks   = tr_pieceCountBlocks( i );
-        endBlock      = startBlock + countBlocks;
-        missingBlocks = countBlocks;
-        for( j = startBlock; j < endBlock; j++ )
-        {
-            /* TODO: optimize */
-            if( tor->blockHave[j] )
-            {
-                missingBlocks--;
-            }
-            if( missingBlocks > minMissing )
-            {
-                break;
-            }
-        }
-
-        if( missingBlocks < 1 )
-        {
-            /* We are already downloading all blocks */
             continue;
         }
@@ -332 +349 @@
 
         /* Pick a block in this piece */
-        startBlock = tr_pieceStartBlock( piece );
-        endBlock   = startBlock + tr_pieceCountBlocks( piece );
-        for( i = startBlock; i < endBlock; i++ )
-        {
-            if( !tor->blockHave[i] )
-            {
-                block = i;
-                goto check;
-            }
-        }
-
+        block = tr_cpMissingBlockInPiece( tor->completion, piece );
+        goto check;
+    }
+
+    free( pool );
+
+    /* "End game" mode */
+    minDownloading = 255;
+    block = -1;
+    for( i = 0; i < inf->pieceCount; i++ )
+    {
+        int downloaders, block2;
+        if( !tr_bitfieldHas( peer->bitfield, i ) )
+        {
+            /* The peer doesn't have this piece */
+            continue;
+        }
+        if( tr_cpPieceIsComplete( tor->completion, i ) )
+        {
+            /* We already have it */
+            continue;
+        }
+        block2 = tr_cpMostMissingBlockInPiece( tor->completion, i, &downloaders );
+        if( block2 > -1 && downloaders < minDownloading )
+        {
+            block = block2;
+            minDownloading = downloaders;
+        }
+    }
+
+check:
+    if( block < 0 )
+    {
         /* Shouldn't happen */
         return -1;
     }
 
-    free( pool );
-
-    /* "End game" mode */
-    block          = -1;
-    minDownloading = TR_MAX_PEER_COUNT + 1;
-    for( i = 0; i < tor->blockCount; i++ )
-    {
-        /* TODO: optimize */
-        if( tr_bitfieldHas( peer->bitfield, tr_blockPiece( i ) ) &&
-            tor->blockHave[i] >= 0 && tor->blockHave[i] < minDownloading )
-        {
-            block          = i;
-            minDownloading = tor->blockHave[i];
-        }
-    }
-
-    if( block < 0 )
-    {
-        /* Shouldn't happen */
-        return -1;
-    }
-
-check:
     for( i = 0; i < peer->inRequestCount; i++ )
     {

trunk/libtransmission/tracker.c

@@ -246 +246 @@
         event = "";
 
-    left  = (uint64_t) ( tor->blockCount - tor->blockHaveCount ) *
-            (uint64_t) tor->blockSize;
-    left  = MIN( left, inf->totalSize );
+    left = tr_cpLeftBytes( tor->completion );
 
     ret = snprintf( (char *) tc->buf, tc->size,
-              "GET %s?info_hash=%s&peer_id=%s&port=%d&uploaded=%lld&"
-              "downloaded=%lld&left=%lld&compact=1&numwant=50%s "
-              "HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n",
-              inf->trackerAnnounce, tor->hashString, tc->id,
-              tor->bindPort, tor->uploaded[9], tor->downloaded[9],
-              left, event, inf->trackerAddress );
+            "GET %s?"
+            "info_hash=%s&"
+            "peer_id=%s&"
+            "port=%d&"
+            "uploaded=%lld&"
+            "downloaded=%lld&"
+            "left=%lld&"
+            "compact=1&"
+            "numwant=50&"
+            "key=%s"
+            "%s "
+            "HTTP/1.1\r\n"
+            "Host: %s\r\n"
+            "User-Agent: Transmission/%d.%d\r\n"
+            "Connection: close\r\n\r\n",
+            inf->trackerAnnounce, tor->hashString, tc->id,
+            tor->bindPort, tor->uploaded[9], tor->downloaded[9],
+            left, tor->key, event, inf->trackerAddress,
+            VERSION_MAJOR, VERSION_MINOR );
 
     ret = tr_netSend( tc->socket, tc->buf, ret );
@@ -382 +393 @@
         tc->leechers = beFoo->val.i;
     }
-    if( tc->seeders + tc->seeders >= 50 )
+    if( tc->seeders + tc->leechers >= 50 )
     {
         tc->hasManyPeers = 1;

trunk/libtransmission/transmission.c

@@ -52 +52 @@
     }
 
+    /* Random key */
+    for( i = 0; i < 20; i++ )
+    {
+        r         = tr_rand( 36 );
+        h->key[i] = ( r < 26 ) ? ( 'a' + r ) : ( '0' + r - 26 ) ;
+    }
+
     /* Don't exit when writing on a broken socket */
     signal( SIGPIPE, SIG_IGN );
@@ -165 +172 @@
     tor->status = TR_STATUS_PAUSE;
     tor->id     = h->id;
+    tor->key    = h->key;
 
     /* Guess scrape URL */
@@ -192 +200 @@
     tor->blockCount = ( inf->totalSize + tor->blockSize - 1 ) /
                         tor->blockSize;
-    tor->blockHave  = calloc( tor->blockCount, 1 );
-    tor->bitfield   = calloc( ( inf->pieceCount + 7 ) / 8, 1 );
+    tor->completion = tr_cpInit( tor );
 
     tr_lockInit( &tor->lock );
@@ -331 +338 @@
         inf = &tor->info;
 
-        tr_lockLock( tor->lock );
-
         if( ( tor->status & TR_STATUS_STOPPED ) ||
             ( ( tor->status & TR_STATUS_STOPPING ) &&
@@ -340 +345 @@
             tor->status = TR_STATUS_PAUSE;
         }
+
+        tr_lockLock( tor->lock );
 
         memcpy( &s[i].info, &tor->info, sizeof( tr_info_t ) );
@@ -365 +372 @@
         }
 
-        s[i].progress = (float) tor->blockHaveCount / (float) tor->blockCount;
-
+        s[i].progress     = tr_cpCompletionAsFloat( tor->completion );
         s[i].rateDownload = rateDownload( tor );
         s[i].rateUpload   = rateUpload( tor );
@@ -376 +382 @@
         else
         {
-            s[i].eta = (float) (tor->blockCount - tor->blockHaveCount ) *
-                (float) tor->blockSize / s[i].rateDownload / 1024.0;
+            s[i].eta = (float) ( 1.0 - s[i].progress ) *
+                (float) inf->totalSize / s[i].rateDownload / 1024.0;
             if( s[i].eta > 99 * 3600 + 59 * 60 + 59 )
             {
@@ -388 +394 @@
             piece = j * inf->pieceCount / 120;
 
-            if( tr_bitfieldHas( tor->bitfield, piece ) )
+            if( tr_cpPieceIsComplete( tor->completion, piece ) )
             {
                 s[i].pieces[j] = -1;
@@ -431 +437 @@
     {
         /* Join the thread first */
-        tr_lockLock( tor->lock );
         torrentReallyStop( h, t );
-        tr_lockUnlock( tor->lock );
     }
 
@@ -439 +443 @@
 
     tr_lockClose( tor->lock );
+    tr_cpClose( tor->completion );
 
     if( tor->destination )
@@ -446 +451 @@
     free( inf->pieces );
     free( inf->files );
-    free( tor->blockHave );
-    free( tor->bitfield );
     free( tor );
 
@@ -477 +480 @@
 #endif
 
+    tr_lockLock( tor->lock );
+
     tor->io     = tr_ioInit( tor );
-    tor->status = ( tor->blockHaveCount < tor->blockCount ) ?
-                      TR_STATUS_DOWNLOAD : TR_STATUS_SEED;
-    
+    tor->status = tr_cpIsSeeding( tor->completion ) ?
+                      TR_STATUS_SEED : TR_STATUS_DOWNLOAD;
+
     while( !tor->die )
     {
         date1 = tr_date();
-
-        tr_lockLock( tor->lock );
 
         /* Are we finished ? */
         if( ( tor->status & TR_STATUS_DOWNLOAD ) &&
-            tor->blockHaveCount >= tor->blockCount )
+            tr_cpIsSeeding( tor->completion ) )
         {
             /* Done */
@@ -502 +505 @@
         tr_trackerPulse( tor->tracker );
 
-        tr_lockUnlock( tor->lock );
-
         if( tor->status & TR_STATUS_STOPPED )
         {
@@ -513 +514 @@
         if( date2 < date1 + 20 )
         {
+            tr_lockUnlock( tor->lock );
             tr_wait( date1 + 20 - date2 );
-        }
-    }
+            tr_lockLock( tor->lock );
+        }
+    }
+
+    tr_lockUnlock( tor->lock );
 
     tr_ioClose( tor->io );

trunk/libtransmission/utils.h

@@ -76 +76 @@
 }
 
+static inline void tr_bitfieldRem( uint8_t * bitfield, int piece )
+{
+    bitfield[ piece / 8 ] &= ~( 1 << ( 7 - ( piece % 8 ) ) );
+}
+
 #define tr_blockPiece(a) _tr_blockPiece(tor,a)
 static inline int _tr_blockPiece( tr_torrent_t * tor, int block )