Ignore:
Timestamp:
Jan 12, 2006, 6:29:20 PM (16 years ago)
Author:
root
Message:

Update 2005-11-17

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/peerutils.h

    r2 r3  
    164164    }
    165165
     166    /* Connect */
     167    if( ( peer->status & PEER_STATUS_IDLE ) &&
     168        !tr_fdSocketWillCreate( tor->fdlimit, 0 ) )
     169    {
     170        peer->socket = tr_netOpen( peer->addr, peer->port );
     171        if( peer->socket < 0 )
     172        {
     173            peer_dbg( "connection failed" );
     174            tr_fdSocketClosed( tor->fdlimit, 0 );
     175            return 1;
     176        }
     177        peer->status = PEER_STATUS_CONNECTING;
     178    }
     179
     180    /* Try to send handshake */
     181    if( peer->status & PEER_STATUS_CONNECTING )
     182    {
     183        uint8_t buf[68];
     184        tr_info_t * inf = &tor->info;
     185        int ret;
     186
     187        buf[0] = 19;
     188        memcpy( &buf[1], "BitTorrent protocol", 19 );
     189        memset( &buf[20], 0, 8 );
     190        memcpy( &buf[28], inf->hash, 20 );
     191        memcpy( &buf[48], tor->id, 20 );
     192
     193        ret = tr_netSend( peer->socket, buf, 68 );
     194        if( ret & TR_NET_CLOSE )
     195        {
     196            peer_dbg( "connection closed" );
     197            return 1;
     198        }
     199        else if( !( ret & TR_NET_BLOCK ) )
     200        {
     201            peer_dbg( "SEND handshake" );
     202            peer->status = PEER_STATUS_HANDSHAKE;
     203        }
     204    }
     205
    166206    return 0;
    167207}
     
    179219    int i;
    180220    int bitfieldSize = ( inf->pieceCount + 7 ) / 8;
     221    uint8_t * bitfield = tr_cpPieceBitfield( tor->completion );
    181222
    182223    if( !peer->bitfield )
     
    188229    for( i = 0; i < bitfieldSize; i++ )
    189230    {
    190         if( ( peer->bitfield[i] & ~(tor->bitfield[i]) ) & 0xFF )
     231        if( ( peer->bitfield[i] & ~(bitfield[i]) ) & 0xFF )
    191232        {
    192233            return 1;
     
    223264    tr_info_t * inf = &tor->info;
    224265
    225     int i, j;
    226     int startBlock, endBlock, countBlocks;
     266    int i;
    227267    int missingBlocks, minMissing;
    228268    int poolSize, * pool;
     
    235275    for( i = 0; i < inf->pieceCount; i++ )
    236276    {
     277        missingBlocks = tr_cpMissingBlocksForPiece( tor->completion, i );
     278        if( missingBlocks < 1 )
     279        {
     280            /* We already have or are downloading all blocks */
     281            continue;
     282        }
    237283        if( !tr_bitfieldHas( peer->bitfield, i ) )
    238284        {
    239285            /* The peer doesn't have this piece */
    240             continue;
    241         }
    242         if( tr_bitfieldHas( tor->bitfield, i ) )
    243         {
    244             /* We already have it */
    245             continue;
    246         }
    247 
    248         /* Count how many blocks from this piece are missing */
    249         startBlock    = tr_pieceStartBlock( i );
    250         countBlocks   = tr_pieceCountBlocks( i );
    251         endBlock      = startBlock + countBlocks;
    252         missingBlocks = countBlocks;
    253         for( j = startBlock; j < endBlock; j++ )
    254         {
    255             /* TODO: optimize */
    256             if( tor->blockHave[j] )
    257             {
    258                 missingBlocks--;
    259             }
    260             if( missingBlocks > minMissing )
    261             {
    262                 break;
    263             }
    264         }
    265 
    266         if( missingBlocks < 1 )
    267         {
    268             /* We are already downloading all blocks */
    269286            continue;
    270287        }
     
    332349
    333350        /* Pick a block in this piece */
    334         startBlock = tr_pieceStartBlock( piece );
    335         endBlock   = startBlock + tr_pieceCountBlocks( piece );
    336         for( i = startBlock; i < endBlock; i++ )
    337         {
    338             if( !tor->blockHave[i] )
    339             {
    340                 block = i;
    341                 goto check;
    342             }
    343         }
    344 
     351        block = tr_cpMissingBlockInPiece( tor->completion, piece );
     352        goto check;
     353    }
     354
     355    free( pool );
     356
     357    /* "End game" mode */
     358    minDownloading = 255;
     359    block = -1;
     360    for( i = 0; i < inf->pieceCount; i++ )
     361    {
     362        int downloaders, block2;
     363        if( !tr_bitfieldHas( peer->bitfield, i ) )
     364        {
     365            /* The peer doesn't have this piece */
     366            continue;
     367        }
     368        if( tr_cpPieceIsComplete( tor->completion, i ) )
     369        {
     370            /* We already have it */
     371            continue;
     372        }
     373        block2 = tr_cpMostMissingBlockInPiece( tor->completion, i, &downloaders );
     374        if( block2 > -1 && downloaders < minDownloading )
     375        {
     376            block = block2;
     377            minDownloading = downloaders;
     378        }
     379    }
     380
     381check:
     382    if( block < 0 )
     383    {
    345384        /* Shouldn't happen */
    346385        return -1;
    347386    }
    348387
    349     free( pool );
    350 
    351     /* "End game" mode */
    352     block          = -1;
    353     minDownloading = TR_MAX_PEER_COUNT + 1;
    354     for( i = 0; i < tor->blockCount; i++ )
    355     {
    356         /* TODO: optimize */
    357         if( tr_bitfieldHas( peer->bitfield, tr_blockPiece( i ) ) &&
    358             tor->blockHave[i] >= 0 && tor->blockHave[i] < minDownloading )
    359         {
    360             block          = i;
    361             minDownloading = tor->blockHave[i];
    362         }
    363     }
    364 
    365     if( block < 0 )
    366     {
    367         /* Shouldn't happen */
    368         return -1;
    369     }
    370 
    371 check:
    372388    for( i = 0; i < peer->inRequestCount; i++ )
    373389    {
Note: See TracChangeset for help on using the changeset viewer.