Changeset 1600


Ignore:
Timestamp:
Mar 28, 2007, 6:28:34 AM (15 years ago)
Author:
joshe
Message:

Unbreak azureus peer protocol.
Add more peer debug messages.
Fix pex interval.

Location:
trunk/libtransmission
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/internal.h

    r1595 r1600  
    223223    tr_shared_t  * shared;
    224224
    225     char           id[21];
    226     char           key[21];
     225#define TR_ID_LEN               20
     226    char           id[TR_ID_LEN+1];
     227#define TR_KEY_LEN              20
     228    char           key[TR_KEY_LEN+1];
    227229
    228230    tr_handle_status_t stats[2];
  • trunk/libtransmission/peer.c

    r1595 r1600  
    9595    uint64_t            lastChoke;
    9696
    97     uint8_t             id[20];
     97    uint8_t             id[TR_ID_LEN];
    9898
    9999    /* The pieces that the peer has */
     
    117117    int                 outMessagesSize;
    118118    int                 outMessagesPos;
    119     uint8_t             outBlock[13+16384];
     119    uint8_t             outBlock[25+16384];
    120120    int                 outBlockSize;
    121121    int                 outBlockLoaded;
  • trunk/libtransmission/peeraz.h

    r1595 r1600  
    235235    char * buf;
    236236
     237    peer_dbg( "SEND azureus-pex" );
     238
    237239    assert( !peer->private );
    238240    tr_bencInitStr( &val, tor->info.hash, sizeof( tor->info.hash ), 1 );
     
    268270        return TR_NET_BLOCK;
    269271    }
     272
     273    peer_dbg( "SEND azureus-handshake" );
    270274
    271275    len = peer->outMessagesSize;
     
    299303    if( 9 > msglen )
    300304    {
    301         peer_dbg( "Azureus peer message is too short to make sense" );
     305        peer_dbg( "azureus peer message is too short to make sense" );
    302306        return TR_NET_CLOSE;
    303307    }
     
    307311    if( off + namelen + 1 > msglen )
    308312    {
    309         peer_dbg( "Azureus peer message name is too long to make sense" );
     313        peer_dbg( "azureus peer message name is too long to make sense" );
    310314        return TR_NET_CLOSE;
    311315    }
     
    323327    {
    324328        /* XXX should we close the connection here? */
    325         peer_dbg( "unsupported Azureus message version %hhu", vers );
     329        peer_dbg( "GET  unsupported azureus message version %hhu", vers );
    326330        msgid = AZ_MSG_INVALID;
    327331    }
     
    329333    {
    330334        name[namelen] = '\0';
    331         peer_dbg( "got unknown Azureus message: \"%s\"", name );
     335        peer_dbg( "GET  unknown azureus message: \"%s\"", name );
    332336        name[namelen] = vers;
    333337        msgid = AZ_MSG_INVALID;
     
    353357    if( tr_bencLoad( buf, len, &val, NULL ) )
    354358    {
    355         peer_dbg( "invalid bencoding in Azureus handshake" );
     359        peer_dbg( "GET  azureus-handshake, invalid bencoding" );
    356360        return TR_ERROR;
    357361    }
     
    359363    if( TYPE_DICT != val.type )
    360364    {
    361         peer_dbg( "Azureus handshake is not a dictionary" );
     365        peer_dbg( "GET  azureus-handshake, data not a dictionary" );
    362366        tr_bencFree( &val );
    363367        return TR_ERROR;
     
    379383    {
    380384        tr_bencFree( &val );
    381         peer_dbg( "Azureus handshake is missing 'messages'" );
     385        peer_dbg( "GET  azureus-handshake, missing 'messages'" );
    382386        return TR_ERROR;
    383387    }
     388
     389    peer_dbg( "GET  azureus-handshake, ok" );
    384390
    385391    /* fill bitmask with supported message info */
     
    423429            !tr_bitfieldHas( msgs, ii ) )
    424430        {
    425             peer_dbg( "Azureus message %s not supported", azmsgStr( ii ) );
     431            peer_dbg( "azureus message %s not supported by peer",
     432                      azmsgStr( ii ) );
    426433            tr_bitfieldFree( msgs );
    427434            return TR_ERROR;
     
    442449    if( peer->private || PEX_PEER_CUTOFF <= tor->peerCount )
    443450    {
     451        peer_dbg( "GET  azureus-pex, ignoring p=%i c=(%i<=%i)",
     452                  peer->private, PEX_PEER_CUTOFF, tor->peerCount );
    444453        return TR_OK;
    445454    }
     
    447456    if( tr_bencLoad( buf, len, &val, NULL ) )
    448457    {
    449         peer_dbg( "invalid bencoding in Azureus peer exchange" );
     458        peer_dbg( "GET  azureus-pex, invalid bencoding" );
    450459        return TR_ERROR;
    451460    }
     
    453462    {
    454463        tr_bencFree( &val );
    455         peer_dbg( "Azureus peer exchange is not a dictionary" );
     464        peer_dbg( "GET  azureus-pex, data not a dictionary" );
    456465        return TR_ERROR;
    457466    }
     
    463472    {
    464473        tr_bencFree( &val );
    465         peer_dbg( "Azureus peer exchange has missing or invalid 'infohash'" );
     474        peer_dbg( "GET  azureus-pex, bad infohash" );
    466475        return TR_ERROR;
    467476    }
     
    470479    if( NULL == list || TYPE_LIST != list->type )
    471480    {
     481        peer_dbg( "GET  azureus-pex, no peers" );
    472482        tr_bencFree( &val );
    473483        return TR_OK;
    474484    }
     485
     486    peer_dbg( "GET  azureus-pex, %i peers", list->val.l.count );
    475487
    476488    for( ii = 0; ii < list->val.l.count; ii++ )
  • trunk/libtransmission/peerext.h

    r1595 r1600  
    105105    char * buf, * vers;
    106106
     107    peer_dbg( "SEND extended-handshake, %s pex",
     108              ( peer->private ? "without" : "with" ) );
     109
    107110    /* get human-readable version string */
    108111    vers = NULL;
     
    201204    char     * ret;
    202205
     206    peer_dbg( "SEND extended-pex" );
     207
    203208    assert( !peer->private );
    204209    tr_bencInitStr( &val, NULL, 0, 1 );
     
    211216parseExtendedHandshake( tr_peer_t * peer, uint8_t * buf, int len )
    212217{
    213     benc_val_t     val, * sub;
     218    benc_val_t val, * sub;
     219    int dbgport, dbgpex;
    214220
    215221    if( tr_bencLoad( buf, len, &val, NULL ) )
    216222    {
    217         peer_dbg( "invalid bencoding in extended handshake" );
     223        peer_dbg( "GET  extended-handshake, invalid bencoding" );
    218224        return TR_ERROR;
    219225    }
    220226    if( TYPE_DICT != val.type )
    221227    {
    222         peer_dbg( "extended handshake is not a dictionary" );
     228        peer_dbg( "GET  extended-handshake, not a dictionary" );
    223229        tr_bencFree( &val );
    224230        return TR_ERROR;
     
    227233    /* check supported messages for utorrent pex */
    228234    sub = tr_bencDictFind( &val, "m" );
     235    dbgpex = -1;
    229236    if( NULL != sub && TYPE_DICT == sub->type )
    230237    {
     
    236243            {
    237244                peer->pexStatus = sub->val.i;
     245                dbgpex = sub->val.i;
    238246            }
    239247        }
     
    242250    /* get peer's listening port */
    243251    sub = tr_bencDictFind( &val, "p" );
     252    dbgport = -1;
    244253    if( NULL != sub && TYPE_INT == sub->type &&
    245254        0x0 < sub->val.i && 0xffff >= sub->val.i )
    246255    {
    247256        peer->port = htons( (uint16_t) sub->val.i );
    248         peer_dbg( "got listening port %i", ntohs( peer->port ) );
    249     }
     257        dbgport = sub->val.i;
     258    }
     259
     260    peer_dbg( "GET  extended-handshake, ok port=%i pex=%i", dbgport, dbgpex );
    250261
    251262    tr_bencFree( &val );
     
    260271    if( peer->private || PEX_PEER_CUTOFF <= tor->peerCount )
    261272    {
     273        peer_dbg( "GET  extended-pex, ignoring p=%i c=(%i<=%i)",
     274                  peer->private, PEX_PEER_CUTOFF, tor->peerCount );
    262275        return TR_OK;
    263276    }
     
    265278    if( tr_bencLoad( buf, len, &val, NULL ) )
    266279    {
    267         peer_dbg( "invalid bencoding in extended peer exchange" );
     280        peer_dbg( "GET  extended-pex, invalid bencoding" );
    268281        return TR_ERROR;
    269282    }
     
    271284    {
    272285        tr_bencFree( &val );
    273         peer_dbg( "extended peer exchange is not a dictionary" );
     286        peer_dbg( "GET  extended-pex, not a dictionary" );
    274287        return TR_ERROR;
    275288    }
     
    278291    if( NULL != sub && TYPE_STR == sub->type && 0 == sub->val.s.i % 6 )
    279292    {
     293        peer_dbg( "GET  extended-pex, %i peers", sub->val.s.i / 6 );
    280294        tr_torrentAddCompact( tor, TR_PEER_FROM_PEX,
    281295                              ( uint8_t * )sub->val.s.s, sub->val.s.i / 6 );
    282296    }
     297    else
     298    {
     299        peer_dbg( "GET  extended-pex, no peers" );
     300    }
    283301
    284302    return TR_OK;
  • trunk/libtransmission/peermessages.h

    r1579 r1600  
    5757}
    5858
     59static int
     60getHeaderSize( tr_peer_t * peer, int id )
     61{
     62    int size, index;
     63
     64    size = 4;
     65    if( peer->azproto )
     66    {
     67        index = azmsgIdIndex( id );
     68        assert( 0 <= index );
     69        size += 4 + azmsgLen( index ) + 1;
     70    }
     71    else if( 0 <= id )
     72    {
     73        size++;
     74    }
     75
     76    return size;
     77}
     78
     79static uint8_t *
     80fillHeader( tr_peer_t * peer, int size, int id, uint8_t * buf )
     81{
     82    int index;
     83
     84    TR_HTONL( size - 4, buf );
     85    buf += 4;
     86    if( peer->azproto )
     87    {
     88        index = azmsgIdIndex( id );
     89        assert( 0 <= index );
     90        TR_HTONL( azmsgLen( index ), buf );
     91        buf += 4;
     92        memcpy( buf, azmsgStr( index ), azmsgLen( index ) );
     93        buf += azmsgLen( index );
     94        buf[0] = AZ_EXT_VERSION;
     95        buf++;
     96    }
     97    else if( 0 <= id )
     98    {
     99        assert( 0 <= id && 0xff > id );
     100        *buf = id;
     101        buf++;
     102    }
     103
     104    return buf;
     105}
     106
    59107static uint8_t * blockPending( tr_torrent_t * tor, tr_peer_t * peer,
    60108                               int * size )
     
    62110    if( !peer->outBlockLoaded )
    63111    {
    64         uint8_t * p;
     112        uint8_t      * buf;
    65113        tr_request_t * r;
     114        int            hdrlen;
    66115
    67116        if( peer->amChoking || peer->outRequestCount < 1 )
     
    86135            return NULL;
    87136        }
    88        
    89         p = (uint8_t *) peer->outBlock;
    90 
    91         TR_HTONL( 9 + r->length, p );
    92         p[4] = PEER_MSG_PIECE;
    93         TR_HTONL( r->index, p + 5 );
    94         TR_HTONL( r->begin, p + 9 );
    95 
    96         tr_ioRead( tor->io, r->index, r->begin, r->length, &p[13] );
     137
     138        hdrlen = 4 + 4 + r->length + getHeaderSize( peer, PEER_MSG_PIECE );
     139        assert( hdrlen <= ( signed )sizeof peer->outBlock );
     140        buf = fillHeader( peer, hdrlen, PEER_MSG_PIECE, peer->outBlock );
     141
     142        TR_HTONL( r->index, buf );
     143        buf += 4;
     144        TR_HTONL( r->begin, buf );
     145        buf += 4;
     146
     147        tr_ioRead( tor->io, r->index, r->begin, r->length, buf );
    97148
    98149        if( peer->outRequestCount < 1 )
     
    105156                  r->index, r->begin, r->length );
    106157
    107         peer->outBlockSize   = 13 + r->length;
     158        peer->outBlockSize   = hdrlen;
    108159        peer->outBlockLoaded = 1;
    109160
     
    138189static uint8_t * getMessagePointer( tr_peer_t * peer, int size, int id )
    139190{
    140     uint8_t * p;
    141     int       index = 0;
    142 
    143     size += 4;
    144     if( peer->azproto )
    145     {
    146         index = azmsgIdIndex( id );
    147         assert( 0 <= index );
    148         size += 4 + azmsgLen( index ) + 1;
    149     }
    150     else if( 0 <= id )
    151     {
    152         size++;
    153     }
     191    uint8_t * buf;
     192
     193    size += getHeaderSize( peer, id );
    154194
    155195    if( peer->outMessagesPos + size > peer->outMessagesSize )
     
    160200    }
    161201
    162                        = &peer->outMessages[peer->outMessagesPos];
     202    buf                   = &peer->outMessages[peer->outMessagesPos];
    163203    peer->outMessagesPos += size;
    164204
    165     TR_HTONL( size - 4, p );
    166     p += 4;
    167     if( peer->azproto )
    168     {
    169         TR_HTONL( azmsgLen( index ), p );
    170         memcpy( p + 4, azmsgStr( index ), azmsgLen( index ) );
    171         p[ 4 + azmsgLen( index ) ] = AZ_EXT_VERSION;
    172         p += 4 + azmsgLen( index ) + 1;
    173     }
    174     else if( 0 <= id )
    175     {
    176         *p = id;
    177         p++;
    178     }
    179 
    180     return p;
     205    return fillHeader( peer, size, id, buf );
    181206}
    182207
     
    378403    if( NULL == buf )
    379404    {
    380         return 1;
     405        return TR_ERROR;
    381406    }
    382407
     
    387412    free( buf );
    388413
    389     return 0;
     414    return TR_OK;
    390415}
    391416
     
    404429    if( NULL == buf )
    405430    {
    406         return 1;
     431        return TR_ERROR;
    407432    }
    408433
     
    412437    free( buf );
    413438
    414     return 0;
    415 }
     439    return TR_OK;
     440}
  • trunk/libtransmission/peerparse.h

    r1579 r1600  
    520520                    return parseUTPex( tor, peer, p, len );
    521521                }
    522                 peer_dbg( "Unknown extended message '%hhu'", extid );
     522                peer_dbg( "GET  unknown extended message '%hhu'", extid );
    523523            }
    524524            return 1;
     
    535535    }
    536536
    537     peer_dbg( "Unknown message '%d'", id );
     537    peer_dbg( "GET  unknown message '%d'", id );
    538538    return TR_ERROR;
    539539}
     
    581581}
    582582
     583static inline int parseHandshake( tr_torrent_t * tor, tr_peer_t * peer )
     584{
     585    tr_info_t * inf = &tor->info;
     586    int         ii;
     587    char      * client;
     588
     589    if( memcmp( &peer->buf[28], inf->hash, SHA_DIGEST_LENGTH ) )
     590    {
     591        peer_dbg( "GET  handshake, wrong torrent hash" );
     592        return TR_ERROR;
     593    }
     594
     595    if( !memcmp( &peer->buf[48], tor->id, TR_ID_LEN ) )
     596    {
     597        /* We are connected to ourselves... */
     598        peer_dbg( "GET  handshake, that is us" );
     599        return TR_ERROR;
     600    }
     601
     602    memcpy( peer->id, &peer->buf[48], TR_ID_LEN );
     603
     604    for( ii = 0; ii < tor->peerCount; ii++ )
     605    {
     606        if( tor->peers[ii] == peer )
     607        {
     608            continue;
     609        }
     610        if( !peerCmp( peer, tor->peers[ii] ) )
     611        {
     612            peer_dbg( "GET  handshake, duplicate" );
     613            return TR_ERROR;
     614        }
     615    }
     616
     617    client = tr_clientForId( (uint8_t *) peer->id );
     618    if( PEER_SUPPORTS_EXTENDED_MESSAGES( &peer->buf[20] ) )
     619    {
     620        peer->status = PEER_STATUS_CONNECTED;
     621        peer->extStatus = EXTENDED_SUPPORTED;
     622        peer_dbg( "GET  handshake, ok (%s) extended messaging supported",
     623                  client );
     624    }
     625    else if( PEER_SUPPORTS_AZUREUS_PROTOCOL( &peer->buf[20] ) )
     626    {
     627        peer->status  = PEER_STATUS_AZ_GIVER;
     628        peer->azproto = 1;
     629        peer->date    = tr_date();
     630        peer_dbg( "GET  handshake, ok (%s) will use azureus protocol",
     631                  client );
     632    }
     633    else
     634    {
     635        peer->status = PEER_STATUS_CONNECTED;
     636        peer_dbg( "GET  handshake, ok (%s)", client );
     637    }
     638    free( client );
     639
     640    return TR_OK;
     641}
     642
     643static inline int sendInitial( tr_torrent_t * tor, tr_peer_t * peer )
     644{
     645    if( PEER_STATUS_CONNECTED != peer->status )
     646    {
     647        return TR_OK;
     648    }
     649
     650    if( EXTENDED_SUPPORTED == peer->extStatus )
     651    {
     652        if( sendExtended( tor, peer, EXTENDED_HANDSHAKE_ID ) )
     653        {
     654            return TR_ERROR;
     655        }
     656        peer->extStatus = EXTENDED_HANDSHAKE;
     657    }
     658
     659    sendBitfield( tor, peer );
     660
     661    return TR_OK;
     662}
     663
    583664static inline int parseBuf( tr_torrent_t * tor, tr_peer_t * peer )
    584665{
    585     tr_info_t * inf = &tor->info;
    586 
    587     int       i;
    588     int       len;
    589     uint8_t * p   = peer->buf;
    590     int       ret;
    591     int       msgid;
     666    int       len, ret, msgid;
     667    uint8_t * buf;
     668
     669    buf = peer->buf;
    592670
    593671    if( peer->banned )
     
    602680        if( PEER_STATUS_HANDSHAKE == peer->status )
    603681        {
    604             char * client;
    605 
    606             if( ( ret = parseBufHeader( peer ) ) )
     682            ret = parseBufHeader( peer );
     683            if( ret )
    607684            {
    608685                return ret;
     
    614691            }
    615692
    616             if( memcmp( &p[28], inf->hash, 20 ) )
    617             {
    618                 peer_dbg( "GET  handshake, wrong torrent hash" );
     693            ret = parseHandshake( tor, peer );
     694            if( 0 > ret )
     695            {
     696                return ret;
     697            }
     698            buf       += 68;
     699            peer->pos -= 68;
     700
     701            ret = sendInitial( tor, peer );
     702            if( ret )
     703            {
     704                return ret;
     705            }
     706
     707            continue;
     708        }
     709
     710        if( PEER_STATUS_AZ_RECEIVER == peer->status )
     711        {
     712            ret = parseAZMessageHeader( peer, buf, peer->pos, &msgid, &len );
     713            if( TR_NET_BLOCK & ret )
     714            {
     715                break;
     716            }
     717            else if( TR_NET_CLOSE & ret )
     718            {
    619719                return TR_ERROR;
    620720            }
    621721
    622             if( !memcmp( &p[48], tor->id, 20 ) )
    623             {
    624                 /* We are connected to ourselves... */
    625                 peer_dbg( "GET  handshake, that is us" );
     722            buf       += ret;
     723            peer->pos -= ret;
     724            assert( len <= peer->pos );
     725            if( AZ_MSG_AZ_HANDSHAKE != msgid ||
     726                parseAZHandshake( peer, buf, len ) )
     727            {
    626728                return TR_ERROR;
    627729            }
    628 
     730            buf         += len;
     731            peer->pos   -= len;
     732            assert( 0 <= peer->pos );
    629733            peer->status = PEER_STATUS_CONNECTED;
    630             if( PEER_SUPPORTS_EXTENDED_MESSAGES( &p[20] ) )
    631             {
    632                 peer_dbg( "extended messages supported" );
    633                 peer->extStatus = EXTENDED_SUPPORTED;
    634             }
    635             else if( PEER_SUPPORTS_AZUREUS_PROTOCOL( &p[20] ) )
    636             {
    637                 peer->azproto = 1;
    638                 peer->status  = PEER_STATUS_AZ_GIVER;
    639                 peer->date    = tr_date();
    640             }
    641             memcpy( peer->id, &p[48], 20 );
    642             p            += 68;
    643             peer->pos    -= 68;
    644 
    645             for( i = 0; i < tor->peerCount; i++ )
    646             {
    647                 if( tor->peers[i] == peer )
    648                 {
    649                     continue;
    650                 }
    651                 if( !peerCmp( peer, tor->peers[i] ) )
    652                 {
    653                     peer_dbg( "GET  handshake, duplicate" );
    654                     return TR_ERROR;
    655                 }
    656             }
    657 
    658             client = tr_clientForId( (uint8_t *) peer->id );
    659             peer_dbg( "GET  handshake, ok (%s)", client );
    660             free( client );
    661 
    662           justconnected:
    663             if( PEER_STATUS_CONNECTED == peer->status )
    664             {
    665                 if( EXTENDED_SUPPORTED == peer->extStatus )
    666                 {
    667                     if( sendExtended( tor, peer, EXTENDED_HANDSHAKE_ID ) )
    668                     {
    669                         return TR_ERROR;
    670                     }
    671                     peer->extStatus = EXTENDED_HANDSHAKE;
    672                 }
    673                 sendBitfield( tor, peer );
     734
     735            ret = sendInitial( tor, peer );
     736            if( ret )
     737            {
     738                return ret;
    674739            }
    675740
    676741            continue;
    677742        }
    678         else if( peer->status < PEER_STATUS_CONNECTED )
    679         {
    680             ret = parseAZMessageHeader( peer, p, peer->pos, &msgid, &len );
    681             if( TR_NET_BLOCK & ret )
    682             {
    683                 break;
    684             }
    685             else if( TR_NET_CLOSE & ret )
    686             {
    687                 return TR_ERROR;
    688             }
    689             else
    690             {
    691                 p         += ret;
    692                 peer->pos -= ret;
    693                 assert( len <= peer->pos );
    694                 if( AZ_MSG_AZ_HANDSHAKE != msgid ||
    695                     parseAZHandshake( peer, p, len ) )
    696                 {
    697                     return TR_ERROR;
    698                 }
    699                 p           += len;
    700                 peer->pos   -= len;
    701                 assert( 0 <= peer->pos );
    702                 peer->status = PEER_STATUS_CONNECTED;
    703                 goto justconnected;
    704             }
     743
     744        if( PEER_STATUS_CONNECTED != peer->status )
     745        {
     746            break;
    705747        }
    706748
    707749        if( peer->azproto )
    708750        {
    709             ret = parseAZMessageHeader( peer, p, peer->pos, &msgid, &len );
     751            ret = parseAZMessageHeader( peer, buf, peer->pos, &msgid, &len );
    710752        }
    711753        else
    712754        {
    713             ret = parseMessageHeader( peer, p, peer->pos, &msgid, &len );
     755            ret = parseMessageHeader( peer, buf, peer->pos, &msgid, &len );
    714756        }
    715757        if( TR_NET_BLOCK & ret )
     
    722764        }
    723765
     766#if 0
    724767        if( len > 8 + tor->blockSize )
    725768        {
     
    729772            return TR_ERROR;
    730773        }
    731 
    732         p         += ret;
     774#endif
     775
     776        buf       += ret;
    733777        peer->pos -= ret;
    734778        assert( 0 <= peer->pos );
    735779
    736         if( ( ret = parseMessage( tor, peer, msgid, p, len ) ) )
     780        if( ( ret = parseMessage( tor, peer, msgid, buf, len ) ) )
    737781        {
    738782            return ret;
    739783        }
    740784
    741                += len;
     785        buf       += len;
    742786        peer->pos -= len;
    743787        assert( 0 <= peer->pos );
    744788    }
    745789
    746     memmove( peer->buf, p, peer->pos );
    747 
    748     return TR_OK;
    749 }
     790    if( 0 < peer->pos )
     791    {
     792        memmove( peer->buf, buf, peer->pos );
     793    }
     794
     795    return TR_OK;
     796}
  • trunk/libtransmission/peerutils.h

    r1579 r1600  
    6262    tr_torrent_t * tor = peer->tor;
    6363    uint64_t       now;
     64    int            ret;
    6465
    6566    now = tr_date();
     
    116117            if( now > peer->lastPex + 1000 * PEX_INTERVAL )
    117118            {
    118                 if( ( EXTENDED_HANDSHAKE == peer->extStatus &&
    119                       !sendExtended( tor, peer, EXTENDED_PEX_ID ) ) ||
    120                     ( peer->azproto && !sendAZPex( tor, peer ) ) )
    121                 {
    122                     peer->lastPex = now + 1000 * tr_rand( PEX_INTERVAL / 10 );
    123                 }
     119                if( EXTENDED_HANDSHAKE == peer->extStatus )
     120                {
     121                    ret = sendExtended( tor, peer, EXTENDED_PEX_ID );
     122                }
     123                else if( peer->azproto )
     124                {
     125                    ret = sendAZPex( tor, peer );
     126                }
     127                else
     128                {
     129                    assert( 0 );
     130                    ret = TR_ERROR;
     131                }
     132                if( ret )
     133                {
     134                    return ret;
     135                }
     136                peer->lastPex = now + 1000 *
     137                    ( PEX_INTERVAL + tr_rand( PEX_INTERVAL / 10 ) );
    124138            }
    125139        }
  • trunk/libtransmission/transmission.c

    r1579 r1600  
    5757    snprintf( h->id, sizeof h->id, "-TR%02d%02d-",
    5858              VERSION_MAJOR, VERSION_MINOR );
    59     for( i = 8; i < 20; i++ )
     59    for( i = 8; i < TR_ID_LEN; i++ )
    6060    {
    6161        r        = tr_rand( 36 );
     
    6464
    6565    /* Random key */
    66     for( i = 0; i < 20; i++ )
     66    for( i = 0; i < TR_KEY_LEN; i++ )
    6767    {
    6868        r         = tr_rand( 36 );
Note: See TracChangeset for help on using the changeset viewer.