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/peer.c

    r2 r3  
    170170        r     = &peer->inRequests[j];
    171171        block = tr_block( r->index,r->begin );
    172         if( tor->blockHave[block] > 0 )
    173         {
    174           (tor->blockHave[block])--;
    175         }
     172        tr_cpDownloaderRem( tor->completion, block );
    176173    }
    177174    if( !peer->amChoking )
     
    272269        peer = tor->peers[i];
    273270
    274         /* Connect */
    275         if( ( peer->status & PEER_STATUS_IDLE ) &&
    276             !tr_fdSocketWillCreate( tor->fdlimit, 0 ) )
    277         {
    278             peer->socket = tr_netOpen( peer->addr, peer->port );
    279             if( peer->socket < 0 )
    280             {
    281                 peer_dbg( "connection failed" );
    282                 goto dropPeer;
    283             }
    284             peer->status = PEER_STATUS_CONNECTING;
    285         }
    286 
    287         /* Try to send handshake */
    288         if( peer->status & PEER_STATUS_CONNECTING )
    289         {
    290             uint8_t buf[68];
    291             tr_info_t * inf = &tor->info;
    292 
    293             buf[0] = 19;
    294             memcpy( &buf[1], "BitTorrent protocol", 19 );
    295             memset( &buf[20], 0, 8 );
    296             memcpy( &buf[28], inf->hash, 20 );
    297             memcpy( &buf[48], tor->id, 20 );
    298 
    299             ret = tr_netSend( peer->socket, buf, 68 );
     271        if( peer->status < PEER_STATUS_HANDSHAKE )
     272        {
     273            i++;
     274            continue;
     275        }
     276
     277        /* Try to read */
     278        for( ;; )
     279        {
     280            if( peer->size < 1 )
     281            {
     282                peer->size = 1024;
     283                peer->buf  = malloc( peer->size );
     284            }
     285            else if( peer->pos >= peer->size )
     286            {
     287                peer->size *= 2;
     288                peer->buf   = realloc( peer->buf, peer->size );
     289            }
     290            ret = tr_netRecv( peer->socket, &peer->buf[peer->pos],
     291                              peer->size - peer->pos );
    300292            if( ret & TR_NET_CLOSE )
    301293            {
     
    303295                goto dropPeer;
    304296            }
    305             else if( !( ret & TR_NET_BLOCK ) )
    306             {
    307                 peer_dbg( "SEND handshake" );
    308                 peer->status = PEER_STATUS_HANDSHAKE;
    309             }
    310         }
    311 
    312         /* Try to read */
    313         if( peer->status >= PEER_STATUS_HANDSHAKE )
    314         {
    315             for( ;; )
    316             {
    317                 if( peer->size < 1 )
    318                 {
    319                     peer->size = 1024;
    320                     peer->buf  = malloc( peer->size );
    321                 }
    322                 else if( peer->pos >= peer->size )
    323                 {
    324                     peer->size *= 2;
    325                     peer->buf   = realloc( peer->buf, peer->size );
    326                 }
    327                 ret = tr_netRecv( peer->socket, &peer->buf[peer->pos],
    328                                   peer->size - peer->pos );
    329                 if( ret & TR_NET_CLOSE )
    330                 {
    331                     peer_dbg( "connection closed" );
    332                     goto dropPeer;
    333                 }
    334                 else if( ret & TR_NET_BLOCK )
     297            else if( ret & TR_NET_BLOCK )
     298            {
     299                break;
     300            }
     301            peer->date  = tr_date();
     302            peer->pos  += ret;
     303            if( parseBuf( tor, peer, ret ) )
     304            {
     305                goto dropPeer;
     306            }
     307        }
     308
     309        if( peer->status < PEER_STATUS_CONNECTED )
     310        {
     311            i++;
     312            continue;
     313        }
     314
     315        /* Try to write */
     316writeBegin:
     317
     318        /* Send all smaller messages regardless of the upload cap */
     319        while( ( p = messagesPending( peer, &size ) ) )
     320        {
     321            ret = tr_netSend( peer->socket, p, size );
     322            if( ret & TR_NET_CLOSE )
     323            {
     324                goto dropPeer;
     325            }
     326            else if( ret & TR_NET_BLOCK )
     327            {
     328                goto writeEnd;
     329            }
     330            messagesSent( peer, ret );
     331        }
     332
     333        /* Send pieces if we can */
     334        while( ( p = blockPending( tor, peer, &size ) ) )
     335        {
     336            if( !tr_uploadCanUpload( tor->upload ) )
     337            {
     338                break;
     339            }
     340
     341            ret = tr_netSend( peer->socket, p, size );
     342            if( ret & TR_NET_CLOSE )
     343            {
     344                goto dropPeer;
     345            }
     346            else if( ret & TR_NET_BLOCK )
     347            {
     348                break;
     349            }
     350
     351            blockSent( peer, ret );
     352            tr_uploadUploaded( tor->upload, ret );
     353
     354            tor->uploaded[9] += ret;
     355            peer->outTotal   += ret;
     356            peer->outDate     = tr_date();
     357
     358            /* In case this block is done, you may have messages
     359               pending. Send them before we start the next block */
     360            goto writeBegin;
     361        }
     362writeEnd:
     363
     364        /* Ask for a block whenever possible */
     365        if( !tr_cpIsSeeding( tor->completion ) &&
     366            !peer->amInterested && tor->peerCount > TR_MAX_PEER_COUNT - 2 )
     367        {
     368            /* This peer is no use to us, and it seems there are
     369               more */
     370            peer_dbg( "not interesting" );
     371            tr_peerRem( tor, i );
     372            continue;
     373        }
     374
     375        if( peer->amInterested && !peer->peerChoking )
     376        {
     377            int block;
     378            while( peer->inRequestCount < OUR_REQUEST_COUNT )
     379            {
     380                block = chooseBlock( tor, peer );
     381                if( block < 0 )
    335382                {
    336383                    break;
    337384                }
    338                 peer->date  = tr_date();
    339                 peer->pos  += ret;
    340                 if( parseBuf( tor, peer, ret ) )
    341                 {
    342                     goto dropPeer;
    343                 }
    344             }
    345         }
    346 
    347         /* Try to write */
    348 writeBegin:
    349 
    350         /* Send all smaller messages regardless of the upload cap */
    351         while( ( p = messagesPending( peer, &size ) ) )
    352         {
    353             ret = tr_netSend( peer->socket, p, size );
    354             if( ret & TR_NET_CLOSE )
    355             {
    356                 goto dropPeer;
    357             }
    358             else if( ret & TR_NET_BLOCK )
    359             {
    360                 goto writeEnd;
    361             }
    362             messagesSent( peer, ret );
    363         }
    364 
    365         /* Send pieces if we can */
    366         while( ( p = blockPending( tor, peer, &size ) ) )
    367         {
    368             if( !tr_uploadCanUpload( tor->upload ) )
    369             {
    370                 break;
    371             }
    372 
    373             ret = tr_netSend( peer->socket, p, size );
    374             if( ret & TR_NET_CLOSE )
    375             {
    376                 goto dropPeer;
    377             }
    378             else if( ret & TR_NET_BLOCK )
    379             {
    380                 break;
    381             }
    382 
    383             blockSent( peer, ret );
    384             tr_uploadUploaded( tor->upload, ret );
    385 
    386             tor->uploaded[9] += ret;
    387             peer->outTotal   += ret;
    388             peer->outDate     = tr_date();
    389 
    390             /* In case this block is done, you may have messages
    391                pending. Send them before we start the next block */
    392             goto writeBegin;
    393         }
    394 writeEnd:
    395 
    396         /* Connected peers: ask for a block whenever possible */
    397         if( peer->status & PEER_STATUS_CONNECTED )
    398         {
    399             if( tor->blockHaveCount < tor->blockCount &&
    400                 !peer->amInterested && tor->peerCount > TR_MAX_PEER_COUNT - 2 )
    401             {
    402                 /* This peer is no use to us, and it seems there are
    403                    more */
    404                 peer_dbg( "not interesting" );
    405                 tr_peerRem( tor, i );
    406                 continue;
    407             }
    408 
    409             if( peer->amInterested && !peer->peerChoking )
    410             {
    411                 int block;
    412                 while( peer->inRequestCount < OUR_REQUEST_COUNT )
    413                 {
    414                     block = chooseBlock( tor, peer );
    415                     if( block < 0 )
    416                     {
    417                         break;
    418                     }
    419                     sendRequest( tor, peer, block );
    420                 }
     385                sendRequest( tor, peer, block );
    421386            }
    422387        }
Note: See TracChangeset for help on using the changeset viewer.