Ignore:
Timestamp:
Jan 12, 2006, 7:12:58 PM (16 years ago)
Author:
root
Message:

Update 2006-01-11

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/peer.c

    r3 r26  
    124124 * tr_peerAddCompact
    125125 ***********************************************************************
    126  * Tries to add a peer. If 's' is a negative value, will use 'addr' and
    127  * 'port' to connect to the peer. Otherwise, use the already connected
    128  * socket 's'.
     126 * Tries to add a peer, using 'addr' and 'port' to connect to the peer.
    129127 **********************************************************************/
    130128void tr_peerAddCompact( tr_torrent_t * tor, struct in_addr addr,
    131                         in_port_t port, int s )
    132 {
    133     tr_peer_t * peer;
    134 
    135     if( s < 0 )
    136     {
    137         addWithAddr( tor, addr, port );
    138         return;
    139     }
    140 
    141     if( !( peer = peerInit( tor ) ) )
    142     {
    143         tr_netClose( s );
    144         tr_fdSocketClosed( tor->fdlimit, 0 );
    145         return;
    146     }
     129                        in_port_t port )
     130{
     131    addWithAddr( tor, addr, port );
     132}
     133
     134/***********************************************************************
     135 * tr_peerInit
     136 ***********************************************************************
     137 * Initializes a new peer.
     138 **********************************************************************/
     139tr_peer_t * tr_peerInit( struct in_addr addr, in_port_t port, int s )
     140{
     141    tr_peer_t * peer = peerInit();
    147142
    148143    peer->socket = s;
     
    150145    peer->port   = port;
    151146    peer->status = PEER_STATUS_CONNECTING;
     147
     148    return peer;
     149}
     150
     151void tr_peerAttach( tr_torrent_t * tor, tr_peer_t * peer )
     152{
     153    peerAttach( tor, peer );
     154}
     155
     156void tr_peerDestroy( tr_fd_t * fdlimit, tr_peer_t * peer )
     157{
     158    if( peer->bitfield )
     159    {
     160        free( peer->bitfield );
     161    }
     162    if( peer->buf )
     163    {
     164        free( peer->buf );
     165    }
     166    if( peer->outMessages )
     167    {
     168        free( peer->outMessages );
     169    }
     170    if( peer->status > PEER_STATUS_IDLE )
     171    {
     172        tr_netClose( peer->socket );
     173        tr_fdSocketClosed( fdlimit, 0 );
     174    }
     175    free( peer );
    152176}
    153177
     
    176200        tr_uploadChoked( tor->upload );
    177201    }
    178     if( peer->bitfield )
    179     {
    180         free( peer->bitfield );
    181     }
    182     if( peer->buf )
    183     {
    184         free( peer->buf );
    185     }
    186     if( peer->outMessages )
    187     {
    188         free( peer->outMessages );
    189     }
    190     if( peer->status > PEER_STATUS_IDLE )
    191     {
    192         tr_netClose( peer->socket );
    193         tr_fdSocketClosed( tor->fdlimit, 0 );
    194     }
    195     free( peer );
     202    tr_peerDestroy( tor->fdlimit, peer );
    196203    tor->peerCount--;
    197204    memmove( &tor->peers[i], &tor->peers[i+1],
    198205             ( tor->peerCount - i ) * sizeof( tr_peer_t * ) );
     206}
     207
     208/***********************************************************************
     209 * tr_peerRead
     210 ***********************************************************************
     211 *
     212 **********************************************************************/
     213int tr_peerRead( tr_torrent_t * tor, tr_peer_t * peer )
     214{
     215    int ret;
     216
     217    /* Try to read */
     218    for( ;; )
     219    {
     220        if( peer->size < 1 )
     221        {
     222            peer->size = 1024;
     223            peer->buf  = malloc( peer->size );
     224        }
     225        else if( peer->pos >= peer->size )
     226        {
     227            peer->size *= 2;
     228            peer->buf   = realloc( peer->buf, peer->size );
     229        }
     230        ret = tr_netRecv( peer->socket, &peer->buf[peer->pos],
     231                          peer->size - peer->pos );
     232        if( ret & TR_NET_CLOSE )
     233        {
     234            peer_dbg( "connection closed" );
     235            return 1;
     236        }
     237        else if( ret & TR_NET_BLOCK )
     238        {
     239            break;
     240        }
     241        peer->date  = tr_date();
     242        peer->pos  += ret;
     243        if( NULL != tor )
     244        {
     245            if( parseBuf( tor, peer, ret ) )
     246            {
     247                return 1;
     248            }
     249        }
     250        else
     251        {
     252            if( parseBufHeader( peer ) )
     253            {
     254                return 1;
     255            }
     256        }
     257    }
     258
     259    return 0;
     260}
     261
     262/***********************************************************************
     263 * tr_peerHash
     264 ***********************************************************************
     265 *
     266 **********************************************************************/
     267uint8_t * tr_peerHash( tr_peer_t * peer )
     268{
     269    return parseBufHash( peer );
    199270}
    200271
     
    235306        return;
    236307    }
    237 
    238     /* Check for incoming connections */
    239     if( tor->bindSocket > -1 &&
    240         tor->peerCount < TR_MAX_PEER_COUNT &&
    241         !tr_fdSocketWillCreate( tor->fdlimit, 0 ) )
    242     {
    243         int            s;
    244         struct in_addr addr;
    245         in_port_t      port;
    246         s = tr_netAccept( tor->bindSocket, &addr, &port );
    247         if( s > -1 )
    248         {
    249             tr_peerAddCompact( tor, addr, port, s );
    250         }
    251         else
    252         {
    253             tr_fdSocketClosed( tor->fdlimit, 0 );
    254         }
    255     }
    256308   
    257309    /* Shuffle peers */
     
    275327        }
    276328
    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 );
    292             if( ret & TR_NET_CLOSE )
    293             {
    294                 peer_dbg( "connection closed" );
    295                 goto dropPeer;
    296             }
    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             }
     329        if( tr_peerRead( tor, tor->peers[i] ) )
     330        {
     331            goto dropPeer;
    307332        }
    308333
Note: See TracChangeset for help on using the changeset viewer.