Changeset 6882

Timestamp:

Oct 11, 2008, 4:07:50 AM (13 years ago)

Author:

charles

Message:

possible fix for #1305 "Transmission losing data - Session Transfer significantly higher than actual download". This patch may need more user testing and will definitely make webseeds slower. suck it up.

Location:

trunk/libtransmission

Files:

• peer-mgr.c (modified) (17 diffs)
• peer-msgs.c (modified) (14 diffs)
• peer-msgs.h (modified) (2 diffs)
• webseed.c (modified) (9 diffs)
• webseed.h (modified) (1 diff)

trunk/libtransmission/peer-mgr.c

@@ -115 +115 @@
     tr_torrent *    tor;
     tr_peer *       optimistic; /* the optimistic peer, or NULL if none */
-    tr_bitfield *   requestedPieces;
+    tr_bitfield *   requestedBlocks;
 
     unsigned int    isRunning : 1;
@@ -406 +406 @@
     tr_timerFree( &t->refillTimer );
 
-    tr_bitfieldFree( t->requestedPieces );
+    tr_bitfieldFree( t->requestedBlocks );
     tr_ptrArrayFree( t->webseeds, (PtrArrayForeachFunc)tr_webseedFree );
     tr_ptrArrayFree( t->pool, (PtrArrayForeachFunc)tr_free );
@@ -433 +433 @@
     t->webseeds = tr_ptrArrayNew( );
     t->outgoingHandshakes = tr_ptrArrayNew( );
-    t->requestedPieces = tr_bitfieldNew( tor->info.pieceCount );
+    t->requestedBlocks = tr_bitfieldNew( tor->blockCount );
     memcpy( t->hash, tor->info.hash, SHA_DIGEST_LENGTH );
 
@@ -594 +594 @@
 struct tr_refill_piece
 {
+    int              missingBlockCount;
     tr_priority_t    priority;
     int              random;
@@ -606 +607 @@
     const struct tr_refill_piece * a = aIn;
     const struct tr_refill_piece * b = bIn;
+
+    /* fewer missing pieces goes first */
+    if( a->missingBlockCount != b->missingBlockCount )
+        return a->missingBlockCount < b->missingBlockCount ? -1 : 1;
 
     /* if one piece has a higher priority, it goes first */
@@ -672 +677 @@
             setme->peerCount = 0;
             setme->random = tr_cryptoWeakRandInt( INT_MAX );
+            setme->missingBlockCount = tr_cpMissingBlocksInPiece( tor->completion, piece );
 
             for( k = 0; k < peerCount; ++k )
@@ -697 +703 @@
 }
 
+static uint64_t*
+getPreferredBlocks( Torrent * t, tr_block_index_t * setmeCount )
+{
+    int s;
+    uint32_t i;
+    uint32_t pieceCount;
+    uint32_t blockCount;
+    uint32_t unreqCount[3], reqCount[3];
+    uint32_t * pieces;
+    uint64_t * ret, * walk;
+    uint64_t * unreq[3], *req[3];
+    const tr_torrent * tor = t->tor;
+
+    assert( torrentIsLocked( t ) );
+
+    pieces = getPreferredPieces( t, &pieceCount );
+
+    /**
+     * Now we walk through those preferred pieces to find all the blocks
+     * are still missing from them.  We put unrequested blocks first,
+     * of course, but by including requested blocks afterwards, endgame
+     * handling happens naturally.
+     *
+     * By doing this once per priority we also effectively get an endgame
+     * mode for each priority level.  The helps keep high priority files
+     * from getting stuck at 99% due of unresponsive peers.
+     */
+
+    /* make temporary bins for the four tiers of blocks */
+    for( i=0; i<3; ++i ) {
+        req[i] = tr_new( uint64_t, pieceCount *  tor->blockCountInPiece );
+        reqCount[i] = 0;
+        unreq[i] = tr_new( uint64_t, pieceCount *  tor->blockCountInPiece );
+        unreqCount[i] = 0;
+    }
+
+    /* sort the blocks into our temp bins */
+    for( i=blockCount=0; i<pieceCount; ++i )
+    {
+        const tr_piece_index_t index = pieces[i];
+        const int priorityIndex = tor->info.pieces[index].priority + 1;
+        const tr_block_index_t begin = tr_torPieceFirstBlock( tor, index );
+        const tr_block_index_t end = begin + tr_torPieceCountBlocks( tor, index );
+        tr_block_index_t block;
+
+        assert( tr_bitfieldTestFast( t->requestedBlocks, end-1 ) );
+
+        for( block=begin; block<end; ++block )
+        {
+            if( tr_cpBlockIsComplete( tor->completion, block ) )
+                continue;
+
+            ++blockCount;
+
+            if( tr_bitfieldHasFast( t->requestedBlocks, block ) )
+            {
+                const uint32_t n = reqCount[priorityIndex]++;
+                req[priorityIndex][n] = block;
+            }
+            else
+            {
+                const uint32_t n = unreqCount[priorityIndex]++;
+                unreq[priorityIndex][n] = block;
+            }
+        }
+    }
+
+    /* join the bins together, going from highest priority to lowest so
+     * the the blocks we want to request first will be first in the list */
+    ret = walk = tr_new( uint64_t, blockCount );
+    for( s=2; s>=0; --s ) {
+        memcpy( walk, unreq[s], sizeof(uint64_t) * unreqCount[s] );
+        walk += unreqCount[s];
+        memcpy( walk, req[s], sizeof(uint64_t) * reqCount[s] );
+        walk += reqCount[s];
+    }
+    assert( ( walk - ret ) == ( int )blockCount );
+    *setmeCount = blockCount;
+
+    /* cleanup */
+    tr_free( pieces );
+    for( i=0; i<3; ++i ) {
+        tr_free( unreq[i] );
+        tr_free( req[i] );
+    }
+    return ret;
+}
+
 static tr_peer**
 getPeersUploadingToClient( Torrent * t,
@@ -733 +827 @@
     Torrent *        t = vtorrent;
     tr_torrent *     tor = t->tor;
+    tr_block_index_t i;
     int              peerCount;
     int              webseedCount;
     tr_peer **       peers;
     tr_webseed **    webseeds;
-    uint32_t         pieceCount;
-    uint32_t *       pieces;
-    tr_piece_index_t i;
+    tr_block_index_t blockCount;
+    uint64_t       * blocks;
 
     if( !t->isRunning )
@@ -749 +843 @@
     tordbg( t, "Refilling Request Buffers..." );
 
-    pieces = getPreferredPieces( t, &pieceCount );
+    blocks = getPreferredBlocks( t, &blockCount );
     peers = getPeersUploadingToClient( t, &peerCount );
     webseedCount = tr_ptrArraySize( t->webseeds );
@@ -756 +850 @@
                          sizeof( tr_webseed* ) );
 
-    for( i = 0; ( webseedCount || peerCount ) && i < pieceCount; ++i )
-    {
-        int                    j;
-        int                    handled = FALSE;
-        const tr_piece_index_t piece = pieces[i];
-
-        assert( piece < tor->info.pieceCount );
-
-        /* find a peer who can ask for this piece */
+    for( i = 0; ( webseedCount || peerCount ) && i < blockCount; ++i )
+    {
+        int j;
+        int handled = FALSE;
+
+        const tr_block_index_t block = blocks[i];
+        const tr_piece_index_t index = tr_torBlockPiece( tor, block );
+        const uint32_t begin = (block * tor->blockSize) - (index * tor->info.pieceSize);
+        const uint32_t length = tr_torBlockCountBytes( tor, block );
+
+        assert( tr_torrentReqIsValid( tor, index, begin, length ) );
+        assert( _tr_block( tor, index, begin ) == block );
+        assert( begin < tr_torPieceCountBytes( tor, index ) );
+        assert( (begin + length) <= tr_torPieceCountBytes( tor, index ) );
+
+        /* find a peer who can ask for this block */
         for( j = 0; !handled && j < peerCount; )
         {
-            const tr_addreq_t val = tr_peerMsgsAddRequest( peers[j]->msgs,
-                                                           piece );
+            const int val = tr_peerMsgsAddRequest( peers[j]->msgs, index, begin, length );
             switch( val )
             {
@@ -782 +882 @@
 
                 case TR_ADDREQ_OK:
-                    tr_bitfieldAdd( t->requestedPieces, piece );
+                    tr_bitfieldAdd( t->requestedBlocks, block );
                     handled = TRUE;
                     break;
@@ -795 +895 @@
         for( j = 0; !handled && j < webseedCount; )
         {
-            const tr_addreq_t val = tr_webseedAddRequest( webseeds[j],
-                                                          piece );
+            const tr_addreq_t val = tr_webseedAddRequest( webseeds[j], index, begin, length );
             switch( val )
             {
@@ -804 +903 @@
 
                 case TR_ADDREQ_OK:
-                    tr_bitfieldAdd( t->requestedPieces, piece );
+                    tr_bitfieldAdd( t->requestedBlocks, block );
                     handled = TRUE;
                     break;
@@ -818 +917 @@
     tr_free( webseeds );
     tr_free( peers );
-    tr_free( pieces );
+    tr_free( blocks );
 
     t->refillTimer = NULL;
     torrentUnlock( t );
     return FALSE;
+}
+
+static void
+broadcastGotBlock( Torrent * t, uint32_t index, uint32_t offset, uint32_t length )
+{
+    int i, size;
+    tr_peer ** peers;
+
+    assert( torrentIsLocked( t ) );
+
+    peers = getConnectedPeers( t, &size );
+    for( i=0; i<size; ++i )
+        tr_peerMsgsCancel( peers[i]->msgs, index, offset, length );
+    tr_free( peers );
 }
 
@@ -881 +994 @@
 
         case TR_PEER_CANCEL:
-            tr_bitfieldRem( t->requestedPieces, e->pieceIndex );
+            tr_bitfieldRem( t->requestedBlocks, _tr_block( t->tor, e->pieceIndex, e->offset ) );
             break;
 
@@ -914 +1027 @@
                 tor->downloadedCur += e->length;
             tr_statsAddDownloaded( tor->session, e->length );
-            if( peer )
-            {
-                struct peer_atom * atom = getExistingAtom( t,
-                                                           &peer->in_addr );
+            if( peer ) {
+                struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
                 atom->piece_data_time = time( NULL );
             }
@@ -956 +1067 @@
 
             tr_cpBlockAdd( tor->completion, block );
+
+            broadcastGotBlock( t, e->pieceIndex, e->offset, e->length );
 
             if( tr_cpPieceIsComplete( tor->completion, e->pieceIndex ) )

trunk/libtransmission/peer-msgs.c

@@ -199 +199 @@
 }
 
-static void
-reqListAppendPiece( const tr_torrent *    tor,
-                    struct request_list * list,
-                    tr_piece_index_t      piece )
-{
-    const time_t           now = time( NULL );
-    const size_t           n = tr_torPieceCountBlocks( tor, piece );
-    const tr_block_index_t begin = tr_torPieceFirstBlock( tor, piece );
-    const tr_block_index_t end = begin + n;
-    tr_block_index_t       i;
-
-    if( list->count + n >= list->max )
-        reqListReserve( list, list->max + n );
-
-    for( i = begin; i < end; ++i )
-    {
-        if( !tr_cpBlockIsComplete( tor->completion, i ) )
-        {
-            struct peer_request * req = list->requests + list->count++;
-            req->index = piece;
-            req->offset =
-                ( i * tor->blockSize ) - ( piece * tor->info.pieceSize );
-            req->length = tr_torBlockCountBytes( tor, i );
-            req->time_requested = now;
-            assert( tr_torrentReqIsValid( tor, req->index, req->offset,
-                                          req->length ) );
-        }
-    }
-}
-
 static int
 reqListPop( struct request_list * list,
@@ -244 +214 @@
 
     return success;
-}
-
-static int
-reqListHasPiece( struct request_list *  list,
-                 const tr_piece_index_t piece )
-{
-    uint16_t i;
-
-    for( i = 0; i < list->count; ++i )
-        if( list->requests[i].index == piece )
-            return 1;
-
-    return 0;
 }
 
@@ -549 +506 @@
 
 static void
-fireCancelledReq( tr_peermsgs *          msgs,
-                  const tr_piece_index_t pieceIndex )
+fireCancelledReq( tr_peermsgs * msgs, const struct peer_request * req )
 {
     tr_peer_event e = blankEvent;
-
     e.eventType = TR_PEER_CANCEL;
-    e.pieceIndex = pieceIndex;
+    e.pieceIndex = req->index;
+    e.offset = req->offset;
+    e.length = req->length;
     publish( msgs, &e );
 }
@@ -806 +763 @@
 
 static int
-requestIsValid( const tr_peermsgs *         peer,
-                const struct peer_request * req )
-{
-    return reqIsValid( peer, req->index, req->offset, req->length );
-}
-
-static void
-tr_peerMsgsCancel( tr_peermsgs * msgs,
-                   uint32_t      pieceIndex )
-{
-    uint16_t              i;
-    struct request_list   tmp = REQUEST_LIST_INIT;
-    struct request_list * src;
-
-    src = &msgs->clientWillAskFor;
-    for( i = 0; i < src->count; ++i )
-        if( src->requests[i].index != pieceIndex )
-            reqListAppend( &tmp, src->requests + i );
-
-    /* swap */
-    reqListClear( &msgs->clientWillAskFor );
-    msgs->clientWillAskFor = tmp;
-    tmp = REQUEST_LIST_INIT;
-
-    src = &msgs->clientAskedFor;
-    for( i = 0; i < src->count; ++i )
-        if( src->requests[i].index == pieceIndex )
-            protocolSendCancel( msgs, src->requests + i );
-        else
-            reqListAppend( &tmp, src->requests + i );
-
-    /* swap */
-    reqListClear( &msgs->clientAskedFor );
-    msgs->clientAskedFor = tmp;
-    tmp = REQUEST_LIST_INIT;
-
-    fireCancelledReq( msgs, pieceIndex );
+requestIsValid( const tr_peermsgs * msgs, const struct peer_request * req )
+{
+    return reqIsValid( msgs, req->index, req->offset, req->length );
 }
 
@@ -859 +782 @@
         const struct peer_request * req = &tmp.requests[i];
         if( req->time_requested < oldestAllowed )
-            tr_peerMsgsCancel( msgs, req->index );
+            tr_peerMsgsCancel( msgs, req->index, req->offset, req->length );
     }
     reqListClear( &tmp );
@@ -870 +793 @@
         const struct peer_request * req = &tmp.requests[i];
         if( req->time_requested < oldestAllowed )
-            tr_peerMsgsCancel( msgs, req->index );
+            tr_peerMsgsCancel( msgs, req->index, req->offset, req->length );
     }
     reqListClear( &tmp );
@@ -926 +849 @@
 {
     const int req_max = msgs->maxActiveRequests;
-
     return msgs->clientWillAskFor.count >= req_max;
 }
@@ -932 +854 @@
 tr_addreq_t
 tr_peerMsgsAddRequest( tr_peermsgs *    msgs,
-                       tr_piece_index_t piece )
+                       uint32_t         index,
+                       uint32_t         offset,
+                       uint32_t         length )
 {
     struct peer_request req;
@@ -938 +862 @@
     assert( msgs );
     assert( msgs->torrent );
-    assert( piece < msgs->torrent->info.pieceCount );
+    assert( reqIsValid( msgs, index, offset, length ) );
 
     /**
@@ -952 +876 @@
 
     /* peer doesn't have this piece */
-    if( !tr_bitfieldHas( msgs->info->have, piece ) )
+    if( !tr_bitfieldHas( msgs->info->have, index ) )
         return TR_ADDREQ_MISSING;
 
     /* peer's queue is full */
-    if( requestQueueIsFull( msgs ) )
-    {
+    if( requestQueueIsFull( msgs ) ) {
         dbgmsg( msgs, "declining request because we're full" );
         return TR_ADDREQ_FULL;
@@ -963 +886 @@
 
     /* have we already asked for this piece? */
-    if( reqListHasPiece( &msgs->clientAskedFor, piece )
-      || reqListHasPiece( &msgs->clientWillAskFor, piece ) )
-    {
+    req.index = index;
+    req.offset = offset;
+    req.length = length;
+    if( reqListFind( &msgs->clientAskedFor, &req ) != -1 ) {
+        dbgmsg( msgs, "declining because it's a duplicate" );
+        return TR_ADDREQ_DUPLICATE;
+    }
+    if( reqListFind( &msgs->clientWillAskFor, &req ) != -1 ) {
         dbgmsg( msgs, "declining because it's a duplicate" );
         return TR_ADDREQ_DUPLICATE;
@@ -974 +902 @@
     **/
 
-    dbgmsg( msgs, "added req for piece %lu", (unsigned long)piece );
+    dbgmsg( msgs, "added req for piece %lu", (unsigned long)index );
     req.time_requested = time( NULL );
-    reqListAppendPiece( msgs->torrent, &msgs->clientWillAskFor, piece );
+    reqListAppend( &msgs->clientWillAskFor, &req );
     return TR_ADDREQ_OK;
 }
@@ -990 +918 @@
     msgs->clientWillAskFor = REQUEST_LIST_INIT;
 
-    for( i = 0; i < a.count; ++i )
-        fireCancelledReq( msgs, a.requests[i].index );
-
-    for( i = 0; i < b.count; ++i )
-    {
-        fireCancelledReq( msgs, b.requests[i].index );
+    for( i=0; i<a.count; ++i )
+        fireCancelledReq( msgs, &a.requests[i] );
+
+    for( i = 0; i < b.count; ++i ) {
+        fireCancelledReq( msgs, &b.requests[i] );
         protocolSendCancel( msgs, &b.requests[i] );
     }
@@ -1001 +928 @@
     reqListClear( &a );
     reqListClear( &b );
+}
+
+void
+tr_peerMsgsCancel( tr_peermsgs * msgs,
+                   uint32_t      pieceIndex,
+                   uint32_t      offset,
+                   uint32_t      length )
+{
+    struct peer_request req;
+
+    assert( msgs != NULL );
+    assert( length > 0 );
+
+    /* have we asked the peer for this piece? */
+    req.index = pieceIndex;
+    req.offset = offset;
+    req.length = length;
+
+    /* if it's only in the queue and hasn't been sent yet, free it */
+    if( !reqListRemove( &msgs->clientWillAskFor, &req ) )
+        fireCancelledReq( msgs, &req );
+
+    /* if it's already been sent, send a cancel message too */
+    if( !reqListRemove( &msgs->clientAskedFor, &req ) ) {
+        protocolSendCancel( msgs, &req );
+        fireCancelledReq( msgs, &req );
+    }
 }
 

trunk/libtransmission/peer-msgs.h

@@ -39 +39 @@
 void         tr_peerMsgsPulse( tr_peermsgs * msgs );
 
-#if 0
 void         tr_peerMsgsCancel( tr_peermsgs * msgs,
                                 uint32_t      pieceIndex,
@@ -45 +44 @@
                                 uint32_t      length );
 
-#endif
 
 void         tr_peerMsgsFree( tr_peermsgs* );
 
-tr_addreq_t  tr_peerMsgsAddRequest( tr_peermsgs *    peer,
-                                    tr_piece_index_t piece );
+tr_addreq_t  tr_peerMsgsAddRequest( tr_peermsgs * peer,
+                                    uint32_t      pieceIndex,
+                                    uint32_t      offset,
+                                    uint32_t      length );
 
 void         tr_peerMsgsUnsubscribe( tr_peermsgs *    peer,

trunk/libtransmission/webseed.c

@@ -25 +25 @@
 #include "webseed.h"
 
-#define MAX_QUEUE_SIZE 4
-
 struct tr_webseed
 {
+    unsigned int        busy : 1;
     unsigned int        dead : 1;
 
@@ -37 +36 @@
     void *              callback_userdata;
 
-    uint64_t            bytesSaved;
-
-    tr_piece_index_t    queue[MAX_QUEUE_SIZE];
-    int                 queueSize;
+    tr_piece_index_t    pieceIndex;
+    uint32_t            pieceOffset;
+    uint32_t            byteCount;
 
     tr_ratecontrol *    rateDown;
@@ -222 +220 @@
         /* FIXME */
     }
-    else if( w->dead )
-    {
-        tr_webseedFree( w );
-    }
     else
     {
-        const tr_piece_index_t piece = w->queue[0];
-        tr_block_index_t       block;
-        size_t                 len;
-
         evbuffer_add( w->content, response, response_byte_count );
-
-        fireClientGotData( w, response_byte_count );
-
-        block = _tr_block( w->torrent, piece, w->bytesSaved );
-        len = tr_torBlockCountBytes( w->torrent, block );
-
-        while( EVBUFFER_LENGTH( w->content ) >= len )
+        if( !w->dead )
         {
-/*fprintf( stderr, "saving piece index %lu, offset %lu, len %lu\n", (unsigned
-  long)piece, (unsigned long)w->bytesSaved, (unsigned long)len );*/
-            /* save one block */
-            tr_ioWrite( w->torrent, piece, w->bytesSaved, len,
-                       EVBUFFER_DATA( w->content ) );
-            evbuffer_drain( w->content, len );
-            tr_rcTransferred( w->rateDown, len );
-            fireClientGotBlock( w, piece, w->bytesSaved, len );
-            w->bytesSaved += len;
-
-            /* march to the next one */
-            ++block;
-            len = tr_torBlockCountBytes( w->torrent, block );
-        }
-
-        if( w->bytesSaved < tr_torPieceCountBytes( w->torrent, piece ) )
+            fireClientGotData( w, response_byte_count );
+            tr_rcTransferred( w->rateDown, response_byte_count );
+        }
+
+        if( EVBUFFER_LENGTH( w->content ) < w->byteCount )
             requestNextChunk( w );
-        else
-        {
-            w->bytesSaved = 0;
+        else {
+            tr_ioWrite( w->torrent, w->pieceIndex, w->pieceOffset, w->byteCount, EVBUFFER_DATA(w->content) );
             evbuffer_drain( w->content, EVBUFFER_LENGTH( w->content ) );
-/*fprintf( stderr, "w->callback_userdata is %p\n", w->callback_userdata );*/
-            memmove( w->queue, w->queue + 1, sizeof( tr_piece_index_t ) *
-                    ( MAX_QUEUE_SIZE - 1 ) );
-/*fprintf( stderr, "w->callback_userdata is %p\n", w->callback_userdata );*/
-            if( --w->queueSize )
-                requestNextChunk( w );
-            if( w->queueSize < ( MAX_QUEUE_SIZE / 2 ) )
+            w->busy = 0;
+            if( w->dead )
+                tr_webseedFree( w );
+            else  {
+                fireClientGotBlock( w, w->pieceIndex, w->pieceOffset, w->byteCount );
                 fireNeedReq( w );
+            }
         }
     }
@@ -277 +248 @@
 requestNextChunk( tr_webseed * w )
 {
-    const tr_info *        inf = tr_torrentInfo( w->torrent );
-    const uint32_t         have = w->bytesSaved + EVBUFFER_LENGTH(
-        w->content );
-    const tr_piece_index_t piece = w->queue[0];
-    const uint32_t         left =
-        tr_torPieceCountBytes( w->torrent, piece ) - have;
-    const uint32_t         pieceOffset = have;
-    tr_file_index_t        fileIndex;
-    uint64_t               fileOffset;
-    uint32_t               thisPass;
-    char *                 url;
-    char *                 range;
-
-    tr_ioFindFileLocation( w->torrent, piece, pieceOffset,
+    const tr_info * inf = tr_torrentInfo( w->torrent );
+    const uint32_t have = EVBUFFER_LENGTH( w->content );
+    const uint32_t left = w->byteCount - have;
+    const uint32_t pieceOffset = w->pieceOffset + have;
+    tr_file_index_t fileIndex;
+    uint64_t fileOffset;
+    uint32_t thisPass;
+    char * url;
+    char * range;
+
+    tr_ioFindFileLocation( w->torrent, w->pieceIndex, pieceOffset,
                            &fileIndex, &fileOffset );
     thisPass = MIN( left, inf->files[fileIndex].length - fileOffset );
 
     url = makeURL( w, &inf->files[fileIndex] );
-    range = tr_strdup_printf( "%" PRIu64 "-%" PRIu64, fileOffset,
-                              fileOffset + thisPass - 1 );
-/*fprintf( stderr, "range is [%s] ... we want %lu total, we have %lu, so %lu are
-  left, and we're asking for %lu this time\n", range, (unsigned
-  long)tr_torPieceCountBytes(w->torrent,piece), (unsigned long)have, (unsigned
-  long)left, (unsigned long)thisPass );*/
+//fprintf( stderr, "url is [%s]\n", url );
+    range = tr_strdup_printf( "%"PRIu64"-%"PRIu64, fileOffset, fileOffset + thisPass - 1 );
+//fprintf( stderr, "range is [%s] ... we want %lu total, we have %lu, so %lu are left, and we're asking for %lu this time\n", range, (unsigned long)w->byteCount, (unsigned long)have, (unsigned long)left, (unsigned long)thisPass );
     tr_webRun( w->torrent->session, url, range, webResponseFunc, w );
     tr_free( range );
@@ -307 +272 @@
 
 tr_addreq_t
-tr_webseedAddRequest( tr_webseed *     w,
-                      tr_piece_index_t piece )
+tr_webseedAddRequest( tr_webseed  * w,
+                      uint32_t      pieceIndex,
+                      uint32_t      pieceOffset,
+                      uint32_t      byteCount )
 {
     int ret;
 
-    if( w->dead || w->queueSize >= MAX_QUEUE_SIZE )
+    if( w->busy || w->dead )
     {
         ret = TR_ADDREQ_FULL;
@@ -318 +285 @@
     else
     {
-        int wasEmpty = w->queueSize == 0;
-        w->queue[w->queueSize++] = piece;
-        if( wasEmpty )
-            requestNextChunk( w );
+        w->busy = 1;
+        w->pieceIndex = pieceIndex;
+        w->pieceOffset = pieceOffset;
+        w->byteCount = byteCount;
+        evbuffer_drain( w->content, EVBUFFER_LENGTH( w->content ) );
+        requestNextChunk( w );
         ret = TR_ADDREQ_OK;
     }
@@ -331 +300 @@
 tr_webseedIsActive( const tr_webseed * w )
 {
-    return w->queueSize > 0;
+    return w->busy != 0;
 }
 
@@ -371 +340 @@
     if( w )
     {
-        if( w->queueSize > 0 )
+        if( w->busy )
         {
             w->dead = 1;
@@ -384 +353 @@
     }
 }
-

trunk/libtransmission/webseed.h

@@ -26 +26 @@
 
 tr_addreq_t tr_webseedAddRequest( tr_webseed *     w,
-                                  tr_piece_index_t piece );
+                                  uint32_t         index,
+                                  uint32_t         offset,
+                                  uint32_t         length );
 
 /** @return true if a request is being processed, or false if idle */