Changeset 1727


Ignore:
Timestamp:
Apr 16, 2007, 9:21:00 PM (15 years ago)
Author:
joshe
Message:

Don't disconnect azureus peers with a newer peer protocol version,

they seem to be able to speak version 1 to us just fine.

Fix a bug with disconnecting peers when attempting to send empty PEX message.

Location:
trunk/libtransmission
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/peeraz.h

    r1720 r1727  
    224224}
    225225
    226 static char *
    227 makeAZPex( tr_torrent_t * tor, tr_peer_t * peer, int * len )
     226static int
     227makeAZPex( tr_torrent_t * tor, tr_peer_t * peer, char ** buf, int * len )
    228228{
    229229    benc_val_t val;
    230     char * buf;
    231 
    232     peer_dbg( "SEND azureus-pex" );
    233230
    234231    assert( !peer->private );
    235232    tr_bencInitStr( &val, tor->info.hash, sizeof( tor->info.hash ), 1 );
    236     buf = makeCommonPex( tor, peer, len, peertreeToBencAZ, "infohash", &val );
    237 
    238     return buf;
     233    return makeCommonPex( tor, peer, peertreeToBencAZ, "infohash", &val,
     234                          buf, len);
    239235}
    240236
     
    428424        subsub = tr_bencDictFind( dict, "ver" );
    429425        if( NULL == subsub || TYPE_STR != subsub->type ||
    430             1 != subsub->val.s.i || AZ_EXT_VERSION != subsub->val.s.s[0] )
     426            1 != subsub->val.s.i || AZ_EXT_VERSION > subsub->val.s.s[0] )
    431427        {
    432428            continue;
  • trunk/libtransmission/peerext.h

    r1720 r1727  
    2626#define EXTENDED_PEX_ID         1
    2727
    28 static char *
    29 makeCommonPex( tr_torrent_t * tor, tr_peer_t * peer, int * len,
     28static int
     29makeCommonPex( tr_torrent_t * tor, tr_peer_t * peer,
    3030               int ( *peerfunc )( tr_peertree_t *, benc_val_t * ),
    31                const char * extrakey, benc_val_t * extraval )
     31               const char * extrakey, benc_val_t * extraval,
     32               char ** retbuf, int * retlen )
    3233{
    3334    tr_peertree_t       * sent, added, common;
     
    3637    tr_peertree_entry_t * found;
    3738    benc_val_t            val, * addval, * delval, * extra;
    38     char                * buf;
    39 
    40     *len = 0;
     39
     40    *retbuf = NULL;
     41    *retlen = 0;
    4142    sent = &peer->sentPeers;
    4243    peertreeInit( &added );
     
    6162            peertreeFree( &added );
    6263            tr_bencFree( extraval );
    63             return NULL;
    64         }
    65     }
    66 
    67     /* build the dictionaries */
    68     tr_bencInit( &val, TYPE_DICT );
    69     if( ( peertreeEmpty( &added ) && peertreeEmpty( sent ) ) ||
    70         tr_bencDictReserve( &val, 3 ) )
    71     {
    72         tr_bencFree( &val );
     64            return 1;
     65        }
     66    }
     67
     68    /* check if there were any added or deleted peers */
     69    if( peertreeEmpty( &added ) && peertreeEmpty( sent ) )
     70    {
    7371        peertreeMerge( sent, &common );
    7472        peertreeFree( &added );
    7573        tr_bencFree( extraval );
    76         return NULL;
     74        return 0;
     75    }
     76
     77    /* build the dictionaries */
     78    tr_bencInit( &val, TYPE_DICT );
     79    if( tr_bencDictReserve( &val, 3 ) )
     80    {
     81        tr_bencFree( &val );
     82        peertreeMerge( sent, &common );
     83        peertreeFree( &added );
     84        tr_bencFree( extraval );
     85        return 1;
    7786    }
    7887    extra  = tr_bencDictAdd( &val, extrakey );
     
    8695        peertreeFree( &added );
    8796        tr_bencFree( extraval );
    88         return NULL;
     97        return 1;
    8998    }
    9099    *extra = *extraval;
    91100    memset( extraval, 0, sizeof( extraval ) );
     101
     102    /* bencode it */
     103    *retbuf = tr_bencSaveMalloc( &val, retlen );
     104    tr_bencFree( &val );
     105    if( NULL == *retbuf )
     106    {
     107        peertreeMerge( sent, &common );
     108        peertreeFree( &added );
     109        return 1;
     110    }
     111
     112    peertreeSwap( sent, &common );
     113    peertreeMerge( sent, &added );
     114    peertreeFree( &common );
     115
     116    return 0;
     117}
     118
     119static char *
     120makeExtendedHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * len )
     121{
     122    benc_val_t val, * msgsval;
     123    char * buf, * vers;
     124
     125    /* get human-readable version string */
     126    vers = NULL;
     127    asprintf( &vers, "%s %s", TR_NAME, VERSION_STRING );
     128    if( NULL == vers )
     129    {
     130        return NULL;
     131    }
     132
     133    /* reserve space in toplevel dictionary for v, m, and possibly p */
     134    tr_bencInit( &val, TYPE_DICT );
     135    if( tr_bencDictReserve( &val, ( 0 < tor->publicPort ? 3 : 2 ) ) )
     136    {
     137        free( vers );
     138        tr_bencFree( &val );
     139        return NULL;
     140    }
     141
     142    /* human readable version string */
     143    tr_bencInitStr( tr_bencDictAdd( &val, "v" ), vers, 0, 0 );
     144
     145    /* create dict of supported extended messages */
     146    msgsval  = tr_bencDictAdd( &val, "m" );
     147    tr_bencInit( msgsval, TYPE_DICT );
     148    if( tr_bencDictReserve( msgsval, 1 ) )
     149    {
     150        tr_bencFree( &val );
     151        return NULL;
     152    }
     153    /* for public torrents advertise utorrent pex message */
     154    tr_bencInitInt( tr_bencDictAdd( msgsval, "ut_pex" ),
     155                    ( peer->private ? 0 : EXTENDED_PEX_ID ) );
     156
     157    /* our listening port */
     158    if( 0 < tor->publicPort )
     159    {
     160        /* XXX should inform peer when we no longer have a valid port */
     161        tr_bencInitInt( tr_bencDictAdd( &val, "p" ), tor->publicPort );
     162    }
    92163
    93164    /* bencode it */
     
    96167    if( NULL == buf )
    97168    {
    98         peertreeMerge( sent, &common );
    99         peertreeFree( &added );
    100169        return NULL;
    101170    }
    102171
    103     peertreeSwap( sent, &common );
    104     peertreeMerge( sent, &added );
    105     peertreeFree( &common );
    106 
    107     return buf;
    108 }
    109 
    110 static char *
    111 makeExtendedHandshake( tr_torrent_t * tor, tr_peer_t * peer, int * len )
    112 {
    113     benc_val_t val, * msgsval;
    114     char * buf, * vers;
    115 
    116     /* get human-readable version string */
    117     vers = NULL;
    118     asprintf( &vers, "%s %s", TR_NAME, VERSION_STRING );
    119     if( NULL == vers )
    120     {
    121         return NULL;
    122     }
    123 
    124     /* reserve space in toplevel dictionary for v, m, and possibly p */
    125     tr_bencInit( &val, TYPE_DICT );
    126     if( tr_bencDictReserve( &val, ( 0 < tor->publicPort ? 3 : 2 ) ) )
    127     {
    128         free( vers );
    129         tr_bencFree( &val );
    130         return NULL;
    131     }
    132 
    133     /* human readable version string */
    134     tr_bencInitStr( tr_bencDictAdd( &val, "v" ), vers, 0, 0 );
    135 
    136     /* create dict of supported extended messages */
    137     msgsval  = tr_bencDictAdd( &val, "m" );
    138     tr_bencInit( msgsval, TYPE_DICT );
    139     if( tr_bencDictReserve( msgsval, 1 ) )
    140     {
    141         tr_bencFree( &val );
    142         return NULL;
    143     }
    144     /* for public torrents advertise utorrent pex message */
    145     tr_bencInitInt( tr_bencDictAdd( msgsval, "ut_pex" ),
    146                     ( peer->private ? 0 : EXTENDED_PEX_ID ) );
    147 
    148     /* our listening port */
    149     if( 0 < tor->publicPort )
    150     {
    151         /* XXX should inform peer when we no longer have a valid port */
    152         tr_bencInitInt( tr_bencDictAdd( &val, "p" ), tor->publicPort );
    153     }
    154 
    155     /* bencode it */
    156     buf = tr_bencSaveMalloc( &val, len );
    157     tr_bencFree( &val );
    158     if( NULL == buf )
    159     {
    160         return NULL;
    161     }
    162 
    163172    peer->advertisedPort = tor->publicPort;
    164 
    165     peer_dbg( "SEND extended-handshake, %s pex",
    166               ( peer->private ? "without" : "with" ) );
    167173
    168174    return buf;
     
    202208}
    203209
    204 static char *
    205 makeUTPex( tr_torrent_t * tor, tr_peer_t * peer, int * len )
     210static int
     211makeUTPex( tr_torrent_t * tor, tr_peer_t * peer, char ** buf, int * len )
    206212{
    207213    benc_val_t val;
    208     char     * ret;
    209 
    210     peer_dbg( "SEND extended-pex" );
    211214
    212215    assert( !peer->private );
    213216    tr_bencInitStr( &val, NULL, 0, 1 );
    214     ret = makeCommonPex( tor, peer, len, peertreeToBencUT, "added.f", &val );
    215 
    216     return ret;
     217    return makeCommonPex( tor, peer, peertreeToBencUT, "added.f", &val,
     218                          buf, len );
    217219}
    218220
  • trunk/libtransmission/peermessages.h

    r1665 r1727  
    406406        case EXTENDED_HANDSHAKE_ID:
    407407            buf = makeExtendedHandshake( tor, peer, &len );
     408            if( NULL == buf )
     409            {
     410                return TR_ERROR;
     411            }
     412            peer_dbg( "SEND extended-handshake, %s pex",
     413                      ( peer->private ? "without" : "with" ) );
    408414            break;
    409415        case EXTENDED_PEX_ID:
    410             buf = makeUTPex( tor, peer, &len );
     416            if( makeUTPex( tor, peer, &buf, &len ) )
     417            {
     418                return TR_ERROR;
     419            }
     420            else if( NULL == buf )
     421            {
     422                return TR_OK;
     423            }
     424            peer_dbg( "SEND extended-pex" );
    411425            break;
    412426        default:
    413427            assert( 0 );
    414428            break;
    415     }
    416     if( NULL == buf )
    417     {
    418         return TR_ERROR;
    419429    }
    420430
     
    439449    int       len;
    440450
    441     buf = makeAZPex( tor, peer, &len );
    442     if( NULL == buf )
     451    if( makeAZPex( tor, peer, &buf, &len ) )
    443452    {
    444453        return TR_ERROR;
     454    }
     455    else if( NULL == buf )
     456    {
     457        return TR_OK;
    445458    }
    446459
     
    450463    free( buf );
    451464
     465    peer_dbg( "SEND azureus-pex" );
     466
    452467    return TR_OK;
    453468}
Note: See TracChangeset for help on using the changeset viewer.