Changeset 7223


Ignore:
Timestamp:
Dec 1, 2008, 8:21:06 PM (12 years ago)
Author:
charles
Message:

(libT) #252: revert r7195 (jhujhiti's IPv6 test patch). It seems to be the culprit in a `thrashing' issue reported by Waldorf and m1b in irc -- the behavior appeared between r7183 and r7187 -- so this commit is to trigger off a nightly build w/o the patch to test with in irc.

Location:
trunk/libtransmission
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/blocklist-test.c

    r7195 r7223  
    5252    char *         tmpfile_bin = "transmission-blocklist-test.bin";
    5353#endif
    54     struct tr_address addr;
     54    struct in_addr addr;
    5555    int            test = 0;
    5656    tr_blocklist * b;
     
    6464
    6565    /* now run some tests */
    66     check( tr_pton( "216.16.1.143", &addr ) );
     66    check( !tr_netResolve( "216.16.1.143", &addr ) );
    6767    check( !_tr_blocklistHasAddress( b, &addr ) );
    68     check( tr_pton( "216.16.1.144", &addr ) );
     68    check( !tr_netResolve( "216.16.1.144", &addr ) );
    6969    check( _tr_blocklistHasAddress( b, &addr ) );
    70     check( tr_pton( "216.16.1.145", &addr ) );
     70    check( !tr_netResolve( "216.16.1.145", &addr ) );
    7171    check( _tr_blocklistHasAddress( b, &addr ) );
    72     check( tr_pton( "216.16.1.146", &addr ) );
     72    check( !tr_netResolve( "216.16.1.146", &addr ) );
    7373    check( _tr_blocklistHasAddress( b, &addr ) );
    74     check( tr_pton( "216.16.1.147", &addr ) );
     74    check( !tr_netResolve( "216.16.1.147", &addr ) );
    7575    check( _tr_blocklistHasAddress( b, &addr ) );
    76     check( tr_pton( "216.16.1.148", &addr ) );
     76    check( !tr_netResolve( "216.16.1.148", &addr ) );
    7777    check( _tr_blocklistHasAddress( b, &addr ) );
    78     check( tr_pton( "216.16.1.149", &addr ) );
     78    check( !tr_netResolve( "216.16.1.149", &addr ) );
    7979    check( _tr_blocklistHasAddress( b, &addr ) );
    80     check( tr_pton( "216.16.1.150", &addr ) );
     80    check( !tr_netResolve( "216.16.1.150", &addr ) );
    8181    check( _tr_blocklistHasAddress( b, &addr ) );
    82     check( tr_pton( "216.16.1.151", &addr ) );
     82    check( !tr_netResolve( "216.16.1.151", &addr ) );
    8383    check( _tr_blocklistHasAddress( b, &addr ) );
    84     check( tr_pton( "216.16.1.152", &addr ) );
     84    check( !tr_netResolve( "216.16.1.152", &addr ) );
    8585    check( !_tr_blocklistHasAddress( b, &addr ) );
    86     check( tr_pton( "216.16.1.153", &addr ) );
     86    check( !tr_netResolve( "216.16.1.153", &addr ) );
    8787    check( !_tr_blocklistHasAddress( b, &addr ) );
    88     check( tr_pton( "217.0.0.1", &addr ) );
     88    check( !tr_netResolve( "217.0.0.1", &addr ) );
    8989    check( !_tr_blocklistHasAddress( b, &addr ) );
    90     check( tr_pton( "255.0.0.1", &addr ) );
     90    check( !tr_netResolve( "255.0.0.1", &addr ) );
    9191
    9292    /* cleanup */
  • trunk/libtransmission/blocklist.c

    r7195 r7223  
    3232#include "platform.h"
    3333#include "blocklist.h"
    34 #include "net.h"
     34#include "net.h" /* tr_netResolve() */
    3535#include "utils.h"
    3636
     
    199199
    200200int
    201 _tr_blocklistHasAddress( tr_blocklist     * b,
    202                          const tr_address * addr )
     201_tr_blocklistHasAddress( tr_blocklist *        b,
     202                         const struct in_addr * addr )
    203203{
    204204    uint32_t                   needle;
     
    212212        return 0;
    213213
    214     needle = ntohl( addr->addr.addr4.s_addr );
     214    needle = ntohl( addr->s_addr );
    215215
    216216    range = bsearch( &needle,
     
    260260        char *             rangeBegin;
    261261        char *             rangeEnd;
    262         tr_address         addr;
     262        struct in_addr     in_addr;
    263263        struct tr_ip_range range;
    264264
     
    271271        *rangeEnd++ = '\0';
    272272
    273         if( !tr_pton( rangeBegin, &addr ) )
     273        if( tr_netResolve( rangeBegin, &in_addr ) )
    274274            tr_err( "blocklist skipped invalid address [%s]\n", rangeBegin );
    275         range.begin = ntohl( addr.addr.addr4.s_addr );
    276 
    277         if( !tr_pton( rangeEnd, &addr ) )
     275        range.begin = ntohl( in_addr.s_addr );
     276
     277        if( tr_netResolve( rangeEnd, &in_addr ) )
    278278            tr_err( "blocklist skipped invalid address [%s]\n", rangeEnd );
    279         range.end = ntohl( addr.addr.addr4.s_addr );
     279        range.end = ntohl( in_addr.s_addr );
    280280
    281281        free( line );
  • trunk/libtransmission/blocklist.h

    r7195 r7223  
    1818#define TR_BLOCKLIST_H
    1919
    20 struct tr_address;
    21 
     20struct in_addr;
    2221typedef struct tr_blocklist tr_blocklist;
    2322
     
    3534int           _tr_blocklistIsEnabled( tr_blocklist * );
    3635
    37 void          _tr_blocklistSetEnabled( tr_blocklist * ,
    38                                        int isEnabled );
     36void          _tr_blocklistSetEnabled(             tr_blocklist *,
     37                                               int isEnabled );
    3938
    40 int           _tr_blocklistHasAddress( tr_blocklist *,
    41                                        const tr_address * addr );
     39int           _tr_blocklistHasAddress(
     40              tr_blocklist *,
     41    const struct
     42    in_addr * addr );
    4243
    43 int           _tr_blocklistSetContent( tr_blocklist *,
    44                                        const char * filename );
     44int           _tr_blocklistSetContent(
     45                 tr_blocklist *,
     46    const char * filename );
    4547
    4648#endif
  • trunk/libtransmission/fdlimit.c

    r7195 r7223  
    472472
    473473int
    474 tr_fdSocketAccept( int          b,
    475                    tr_address * addr,
    476                    tr_port_t  * port )
    477 {
    478     int                     s = -1;
    479     unsigned int            len;
    480     struct sockaddr_storage sock;
     474tr_fdSocketAccept( int              b,
     475                   struct in_addr * addr,
     476                   tr_port_t *      port )
     477{
     478    int                s = -1;
     479    unsigned int       len;
     480    struct sockaddr_in sock;
    481481
    482482    assert( addr );
     
    486486    if( gFd->socketCount < getSocketMax( gFd ) )
    487487    {
    488         len = sizeof( struct sockaddr );
     488        len = sizeof( sock );
    489489        s = accept( b, (struct sockaddr *) &sock, &len );
    490490    }
    491491    if( s > -1 )
    492492    {
    493         /* "The ss_family field of the sockaddr_storage structure will always
    494          * align with the family field of any protocol-specific structure." */
    495         if( sock.ss_family == AF_INET )
    496         {
    497             struct sockaddr_in * sock4 = (struct sockaddr_in *)&sock;
    498             addr->type = TR_AF_INET;
    499             addr->addr.addr4.s_addr = sock4->sin_addr.s_addr;
    500             *port = sock4->sin_port;
    501         }
    502         else
    503         {
    504             struct sockaddr_in6 * sock6 = (struct sockaddr_in6 *)&sock;
    505             addr->type = TR_AF_INET6;
    506             memcpy( &addr->addr, &sock6->sin6_addr,
    507                    sizeof( struct sockaddr_in6 ) );
    508             *port = sock6->sin6_port;
    509         }
     493        *addr = sock.sin_addr;
     494        *port = sock.sin_port;
    510495        ++gFd->socketCount;
    511496    }
  • trunk/libtransmission/fdlimit.h

    r7195 r7223  
    8888int      tr_fdSocketCreate( int type );
    8989
    90 int      tr_fdSocketAccept( int          b,
    91                             tr_address * addr,
    92                             tr_port_t  * port );
     90int      tr_fdSocketAccept( int              b,
     91                            struct in_addr * addr,
     92                            tr_port_t *      port );
    9393
    9494void     tr_fdSocketClose( int s );
  • trunk/libtransmission/handshake.c

    r7195 r7223  
    11971197}
    11981198
    1199 const tr_address *
     1199const struct in_addr *
    12001200tr_handshakeGetAddr( const struct tr_handshake * handshake,
    1201                      uint16_t                  * port )
     1201                                                 uint16_t * port )
    12021202{
    12031203    assert( handshake );
  • trunk/libtransmission/handshake.h

    r7195 r7223  
    2020#include "transmission.h"
    2121
     22struct in_addr;
    2223struct tr_peerIo;
    2324typedef struct tr_handshake tr_handshake;
     
    3536                                        void *             doneUserData );
    3637
    37 const tr_address     * tr_handshakeGetAddr( const struct tr_handshake * handshake,
    38                                             uint16_t                  * setme_port );
     38const struct in_addr * tr_handshakeGetAddr(
     39    const struct tr_handshake * handshake,
     40                                uint16_t
     41    *                           setme_port );
    3942
    4043void                   tr_handshakeAbort( tr_handshake * handshake );
  • trunk/libtransmission/net.c

    r7195 r7223  
    4848#include "utils.h"
    4949
    50 const tr_address tr_in6addr_any = { TR_AF_INET6, { IN6ADDR_ANY_INIT } };
    51 const tr_address tr_inaddr_any = { TR_AF_INET,
    52     { { { { INADDR_ANY, 0x00, 0x00, 0x00 } } } } };
    5350
    5451void
     
    6764}
    6865
    69 const char *
    70 tr_ntop( const tr_address * src,
    71          char * dst,
    72          int size )
    73 {
    74     if( src->type == TR_AF_INET )
    75         return inet_ntop( AF_INET, &src->addr, dst, size );
    76     else
    77         return inet_ntop( AF_INET6, &src->addr, dst, size );
    78 }
    79 
    80 /*
    81  * Non-threadsafe version of tr_ntop, which uses a static memory area for a buffer.
    82  * This function is suitable to be called from libTransmission's networking code,
    83  * which is single-threaded.
    84  */
    85 const char *
    86 tr_ntop_non_ts( const tr_address * src )
    87 {
    88     static char buf[INET6_ADDRSTRLEN];
    89     return tr_ntop( src, buf, sizeof( buf ) );
    90 }
    91 
    92 tr_address *
    93 tr_pton( const char * src,
    94          tr_address * dst )
    95 {
    96     int retval = inet_pton( AF_INET, src, &dst->addr );
    97     if( retval < 0 )
    98         return NULL;
    99     else if( retval == 0 )
    100         retval = inet_pton( AF_INET6, src, &dst->addr );
    101     else
    102     {
    103         dst->type = TR_AF_INET;
    104         return dst;
    105     }
    106    
    107     if( retval < 1 )
    108         return NULL;
    109     dst->type = TR_AF_INET6;
    110     return dst;
    111 }
    112 
    113 /*
    114  * Compare two tr_address structures.
    115  * Returns:
    116  * <0 if a < b
    117  * >0 if a > b
    118  * 0  if a == b
    119  */
    120 int
    121 tr_compareAddresses( const tr_address * a,
    122                      const tr_address * b)
    123 {
    124     int retval;
    125     int addrlen;
    126     /* IPv6 addresses are always "greater than" IPv4 */
    127     if( a->type == TR_AF_INET && b->type == TR_AF_INET6 )
    128         return 1;
    129     if( a->type == TR_AF_INET6 && b->type == TR_AF_INET )
    130         return -1;
    131    
    132     if( a->type == TR_AF_INET )
    133         addrlen = sizeof( struct in_addr );
    134     else
    135         addrlen = sizeof( struct in6_addr );
    136    
    137     retval = memcmp( &a->addr, &b->addr, addrlen );
    138     if( retval == 0 )
    139         return 0;
    140    
    141     return retval;
     66/***********************************************************************
     67 * DNS resolution
     68 *
     69 * Synchronous "resolution": only works with character strings
     70 * representing numbers expressed in the Internet standard `.' notation.
     71 * Returns a non-zero value if an error occurs.
     72 **********************************************************************/
     73int
     74tr_netResolve( const char *     address,
     75               struct in_addr * addr )
     76{
     77    addr->s_addr = inet_addr( address );
     78    return addr->s_addr == 0xFFFFFFFF;
    14279}
    14380
     
    200137}
    201138
    202 static void
    203 setup_sockaddr( const tr_address        * addr,
    204                 tr_port_t                 port,
    205                 struct sockaddr_storage * sockaddr)
    206 {
    207     struct sockaddr_in  sock4;
    208     struct sockaddr_in6 sock6;
    209     if( addr->type == TR_AF_INET )
    210     {
    211         memset( &sock4, 0, sizeof( sock4 ) );
    212         sock4.sin_family      = AF_INET;
    213         sock4.sin_addr.s_addr = addr->addr.addr4.s_addr;
    214         sock4.sin_port        = port;
    215         memcpy( sockaddr, &sock4, sizeof( sock4 ) );
    216     }
    217     else
    218     {
    219         memset( &sock6, 0, sizeof( sock6 ) );
    220         sock6.sin6_family = AF_INET6;
    221         sock6.sin6_port = port;
    222         memcpy( &sock6.sin6_addr, &addr->addr, sizeof( struct in6_addr ) );
    223         memcpy( sockaddr, &sock6, sizeof( sock6 ) );
    224     }
    225 }
    226 
    227 int
    228 tr_netOpenTCP( tr_session        * session,
    229                const tr_address  * addr,
    230                tr_port_t           port )
    231 {
    232     int                     s;
    233     struct sockaddr_storage sock;
    234     const int               type = SOCK_STREAM;
     139int
     140tr_netOpenTCP( tr_session            * session,
     141               const struct in_addr  * addr,
     142               tr_port_t               port )
     143{
     144    int                s;
     145    struct sockaddr_in sock;
     146    const int          type = SOCK_STREAM;
    235147
    236148    if( ( s = createSocket( type ) ) < 0 )
     
    239151    setSndBuf( session, s );
    240152
    241     setup_sockaddr( addr, port, &sock );
     153    memset( &sock, 0, sizeof( sock ) );
     154    sock.sin_family      = AF_INET;
     155    sock.sin_addr.s_addr = addr->s_addr;
     156    sock.sin_port        = port;
    242157
    243158    if( ( connect( s, (struct sockaddr *) &sock,
    244                   sizeof( struct sockaddr ) ) < 0 )
     159                  sizeof( struct sockaddr_in ) ) < 0 )
    245160#ifdef WIN32
    246161      && ( sockerrno != WSAEWOULDBLOCK )
     
    250165        tr_err( _(
    251166                   "Couldn't connect socket %d to %s, port %d (errno %d - %s)" ),
    252                s, tr_ntop_non_ts( addr ), port,
     167               s, inet_ntoa( *addr ), port,
    253168               sockerrno, tr_strerror( sockerrno ) );
    254169        tr_netClose( s );
     
    263178
    264179int
    265 tr_netBindTCP( const tr_address * addr,
    266                int port )
    267 {
    268     int                     s;
    269     struct sockaddr_storage sock;
    270     const int               type = SOCK_STREAM;
     180tr_netBindTCP( int port )
     181{
     182    int                s;
     183    struct sockaddr_in sock;
     184    const int          type = SOCK_STREAM;
    271185
    272186#if defined( SO_REUSEADDR ) || defined( SO_REUSEPORT )
     
    281195    setsockopt( s, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, sizeof( optval ) );
    282196#endif
    283    
    284     setup_sockaddr( addr, htons( port ), &sock );
     197
     198    memset( &sock, 0, sizeof( sock ) );
     199    sock.sin_family      = AF_INET;
     200    sock.sin_addr.s_addr = INADDR_ANY;
     201    sock.sin_port        = htons( port );
    285202
    286203    if( bind( s, (struct sockaddr *) &sock,
    287              sizeof( struct sockaddr ) ) )
    288     {
    289         tr_err( _( "Couldn't bind port %d on %s: %s" ), port,
    290                tr_ntop_non_ts( addr ), tr_strerror( sockerrno ) );
     204             sizeof( struct sockaddr_in ) ) )
     205    {
     206        tr_err( _( "Couldn't bind port %d: %s" ), port,
     207               tr_strerror( sockerrno ) );
    291208        tr_netClose( s );
    292209        return -1;
    293210    }
    294211
    295     tr_dbg(  "Bound socket %d to port %d on %s", s, port,
    296            tr_ntop_non_ts( addr ) );
     212    tr_dbg(  "Bound socket %d to port %d", s, port );
    297213    return s;
    298214}
    299215
    300216int
    301 tr_netAccept( tr_session * session,
    302               int          b,
    303               tr_address * addr,
    304               tr_port_t  * port )
     217tr_netAccept( tr_session      * session,
     218              int               b,
     219              struct in_addr * addr,
     220              tr_port_t       * port )
    305221{
    306222    int fd = makeSocketNonBlocking( tr_fdSocketAccept( b, addr, port ) );
     
    314230    tr_fdSocketClose( s );
    315231}
     232
     233void
     234tr_netNtop( const struct in_addr * addr,
     235            char *                 buf,
     236            int                    len )
     237{
     238    const uint8_t * cast;
     239
     240    cast = (const uint8_t *)addr;
     241    tr_snprintf( buf, len, "%hhu.%hhu.%hhu.%hhu",
     242                 cast[0], cast[1], cast[2], cast[3] );
     243}
     244
  • trunk/libtransmission/net.h

    r7195 r7223  
    6161#endif
    6262
     63struct in_addr;
     64struct sockaddr_in;
    6365struct tr_session;
    6466
    65 #define TR_AF_INET  0
    66 #define TR_AF_INET6 1
    67 
    68 typedef struct tr_address {
    69     unsigned short type : 1;
    70     union {
    71         /* The order here is important for tr_in{,6}addr_any initialization,
    72          * since we can't use C99 designated initializers */
    73         struct in6_addr addr6;
    74         struct in_addr  addr4;
    75     } addr;
    76 } tr_address;
    77 
    78 extern const tr_address tr_inaddr_any;
    79 extern const tr_address tr_in6addr_any;
    80 
    81 const char *tr_ntop( const tr_address * src,
    82                      char * dst,
    83                      int size );
    84 const char *tr_ntop_non_ts( const tr_address * src );
    85 tr_address *tr_pton( const char * src,
    86                      tr_address * dst );
    87 int tr_compareAddresses( const tr_address * a,
    88                          const tr_address * b);
     67/***********************************************************************
     68 * DNS resolution
     69 **********************************************************************/
     70int  tr_netResolve( const  char *,
     71                    struct in_addr * );
    8972
    9073
     
    9275 * Sockets
    9376 **********************************************************************/
    94 int  tr_netOpenTCP( struct tr_handle * session,
    95                     const tr_address * addr,
    96                     tr_port_t          port );
     77int  tr_netOpenTCP( struct tr_handle     * session,
     78                    const struct in_addr * addr,
     79                    tr_port_t              port );
    9780
    98 int  tr_netBindTCP( const tr_address * addr,
    99                     int                port );
     81int  tr_netBindTCP( int port );
    10082
    101 int  tr_netAccept( struct tr_handle * session,
    102                    int                bound,
    103                    tr_address       * setme_addr,
    104                    tr_port_t        * setme_port );
     83int  tr_netAccept( struct tr_handle  * session,
     84                   int                 bound,
     85                   struct in_addr    * setme_addr,
     86                   tr_port_t         * setme_port );
    10587
    10688int  tr_netSetTOS( int s,
     
    10991void tr_netClose( int s );
    11092
     93void tr_netNtop( const struct in_addr * addr,
     94                 char *                 buf,
     95                 int                    len );
     96
    11197void tr_netInit( void );
    11298
  • trunk/libtransmission/peer-io.c

    r7195 r7223  
    2020 #include <winsock2.h>
    2121#else
     22 #include <netinet/in.h> /* struct in_addr */
    2223 #include <arpa/inet.h> /* inet_ntoa */
    2324#endif
     
    9798    tr_session             * session;
    9899
    99     tr_address               addr;
     100    struct in_addr           in_addr;
    100101    struct tr_iobuf        * iobuf;
    101102    tr_list                * output_datatypes; /* struct tr_datatype */
     
    238239
    239240static tr_peerIo*
    240 tr_peerIoNew( tr_session       * session,
    241               const tr_address * addr,
    242               uint16_t           port,
    243               const uint8_t *    torrentHash,
    244               int                isIncoming,
    245               int                socket )
     241tr_peerIoNew( tr_session *          session,
     242              const struct in_addr * in_addr,
     243              uint16_t               port,
     244              const uint8_t *        torrentHash,
     245              int                    isIncoming,
     246              int                    socket )
    246247{
    247248    tr_peerIo * io;
     
    254255    io->crypto = tr_cryptoNew( torrentHash, isIncoming );
    255256    io->session = session;
    256     io->addr = *addr;
     257    io->in_addr = *in_addr;
    257258    io->port = port;
    258259    io->socket = socket;
     
    266267
    267268tr_peerIo*
    268 tr_peerIoNewIncoming( tr_session       * session,
    269                       const tr_address * addr,
    270                       uint16_t           port,
    271                       int                socket )
     269tr_peerIoNewIncoming( tr_session *          session,
     270                      const struct in_addr * in_addr,
     271                      uint16_t               port,
     272                      int                    socket )
    272273{
    273274    assert( session );
    274     assert( addr );
     275    assert( in_addr );
    275276    assert( socket >= 0 );
    276277
    277     return tr_peerIoNew( session, addr, port,
     278    return tr_peerIoNew( session, in_addr, port,
    278279                         NULL, 1,
    279280                         socket );
     
    281282
    282283tr_peerIo*
    283 tr_peerIoNewOutgoing( tr_session       * session,
    284                       const tr_address * addr,
    285                       int                port,
    286                       const uint8_t    * torrentHash )
     284tr_peerIoNewOutgoing( tr_session *          session,
     285                      const struct in_addr * in_addr,
     286                      int                    port,
     287                      const uint8_t *        torrentHash )
    287288{
    288289    int socket;
    289290
    290291    assert( session );
    291     assert( addr );
     292    assert( in_addr );
    292293    assert( port >= 0 );
    293294    assert( torrentHash );
    294295
    295     socket = tr_netOpenTCP( session, addr, port );
     296    socket = tr_netOpenTCP( session, in_addr, port );
    296297
    297298    return socket < 0
    298299           ? NULL
    299            : tr_peerIoNew( session, addr, port, torrentHash, 0, socket );
     300           : tr_peerIoNew( session, in_addr, port, torrentHash, 0, socket );
    300301}
    301302
     
    336337}
    337338
    338 const tr_address*
     339const struct in_addr*
    339340tr_peerIoGetAddress( const tr_peerIo * io,
    340                            uint16_t  * port )
     341                           uint16_t * port )
    341342{
    342343    assert( isPeerIo( io ) );
     
    345346        *port = io->port;
    346347
    347     return &io->addr;
     348    return &io->in_addr;
    348349}
    349350
    350351const char*
    351 tr_peerIoAddrStr( const tr_address * addr,
    352                   uint16_t           port )
     352tr_peerIoAddrStr( const struct in_addr * addr,
     353                  uint16_t               port )
    353354{
    354355    static char buf[512];
    355356
    356     if( addr->type == TR_AF_INET )
    357         tr_snprintf( buf, sizeof( buf ), "%s:%u", tr_ntop_non_ts( addr ),
    358                     ntohs( port ) );
    359     else
    360         tr_snprintf( buf, sizeof( buf ), "[%s]:%u", tr_ntop_non_ts( addr ),
    361                     ntohs( port ) );
     357    tr_snprintf( buf, sizeof( buf ), "%s:%u", inet_ntoa( *addr ),
     358                ntohs( port ) );
    362359    return buf;
    363360}
     
    366363tr_peerIoGetAddrStr( const tr_peerIo * io )
    367364{
    368     return tr_peerIoAddrStr( &io->addr, io->port );
     365    return tr_peerIoAddrStr( &io->in_addr, io->port );
    369366}
    370367
     
    405402        tr_netClose( io->socket );
    406403
    407     io->socket = tr_netOpenTCP( io->session, &io->addr, io->port );
     404    io->socket = tr_netOpenTCP( io->session, &io->in_addr, io->port );
    408405
    409406    if( io->socket >= 0 )
  • trunk/libtransmission/peer-io.h

    r7195 r7223  
    2222**/
    2323
     24struct in_addr;
    2425struct evbuffer;
    2526struct tr_bandwidth;
     
    3233**/
    3334
    34 tr_peerIo*           tr_peerIoNewOutgoing( struct tr_handle * session,
    35                                            const tr_address * addr,
    36                                            int                port,
    37                                            const  uint8_t   * torrentHash );
    38 
    39 tr_peerIo*           tr_peerIoNewIncoming( struct tr_handle * session,
    40                                            const tr_address * addr,
    41                                            uint16_t           port,
    42                                            int                socket );
     35tr_peerIo*           tr_peerIoNewOutgoing( struct tr_handle     * session,
     36                                           const struct in_addr * addr,
     37                                           int                    port,
     38                                           const  uint8_t       * torrentHash );
     39
     40tr_peerIo*           tr_peerIoNewIncoming( struct tr_handle     * session,
     41                                           const struct in_addr * addr,
     42                                           uint16_t               port,
     43                                           int                    socket );
    4344
    4445void                 tr_peerIoFree( tr_peerIo * io );
     
    5960**/
    6061
    61 const char*          tr_peerIoAddrStr( const tr_address * addr,
    62                                        uint16_t           port );
     62const char*          tr_peerIoAddrStr( const struct in_addr * addr,
     63                                       uint16_t               port );
    6364
    6465const char*          tr_peerIoGetAddrStr( const tr_peerIo * io );
    6566
    66 const tr_address *   tr_peerIoGetAddress( const tr_peerIo * io,
     67const struct in_addr*tr_peerIoGetAddress( const tr_peerIo * io,
    6768                                                uint16_t * port );
    6869
  • trunk/libtransmission/peer-mgr-private.h

    r7195 r7223  
    2222#ifdef WIN32
    2323 #include <winsock2.h> /* struct in_addr */
     24#else
     25 #include <netinet/in.h> /* struct in_addr */
    2426#endif
    2527
     
    5153    uint8_t                  encryption_preference;
    5254    uint16_t                 port;
    53     tr_address               addr;
     55    struct in_addr           in_addr;
    5456    struct tr_peerIo       * io;
    5557
  • trunk/libtransmission/peer-mgr.c

    r7199 r7223  
    9696struct peer_atom
    9797{
    98     uint8_t    from;
    99     uint8_t    flags; /* these match the added_f flags */
    100     uint8_t    myflags; /* flags that aren't defined in added_f */
    101     uint16_t   port;
    102     uint16_t   numFails;
    103     tr_address addr;
    104     time_t     time; /* when the peer's connection status last changed */
    105     time_t     piece_data_time;
     98    uint8_t           from;
     99    uint8_t           flags; /* these match the added_f flags */
     100    uint8_t           myflags; /* flags that aren't defined in added_f */
     101    uint16_t          port;
     102    uint16_t          numFails;
     103    struct in_addr    addr;
     104    time_t            time; /* when the peer's connection status last changed */
     105    time_t            piece_data_time;
    106106};
    107107
     
    185185
    186186static int
     187compareAddresses( const struct in_addr * a,
     188                  const struct in_addr * b )
     189{
     190    if( a->s_addr != b->s_addr )
     191        return a->s_addr < b->s_addr ? -1 : 1;
     192
     193    return 0;
     194}
     195
     196static int
    187197handshakeCompareToAddr( const void * va,
    188198                        const void * vb )
     
    190200    const tr_handshake * a = va;
    191201
    192     return tr_compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
     202    return compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
    193203}
    194204
     
    201211
    202212static tr_handshake*
    203 getExistingHandshake( tr_ptrArray      * handshakes,
    204                       const tr_address * addr )
     213getExistingHandshake( tr_ptrArray *          handshakes,
     214                      const struct in_addr * in_addr )
    205215{
    206216    return tr_ptrArrayFindSorted( handshakes,
    207                                   addr,
     217                                  in_addr,
    208218                                  handshakeCompareToAddr );
    209219}
     
    215225    const struct peer_atom * a = va;
    216226
    217     return tr_compareAddresses( &a->addr, vb );
     227    return compareAddresses( &a->addr, vb );
    218228}
    219229
     
    267277    const tr_peer * b = vb;
    268278
    269     return tr_compareAddresses( &a->addr, &b->addr );
     279    return compareAddresses( &a->in_addr, &b->in_addr );
    270280}
    271281
     
    276286    const tr_peer * a = va;
    277287
    278     return tr_compareAddresses( &a->addr, vb );
     288    return compareAddresses( &a->in_addr, vb );
    279289}
    280290
    281291static tr_peer*
    282 getExistingPeer( Torrent          * torrent,
    283                  const tr_address * addr )
     292getExistingPeer( Torrent *              torrent,
     293                 const struct in_addr * in_addr )
    284294{
    285295    assert( torrentIsLocked( torrent ) );
    286     assert( addr );
     296    assert( in_addr );
    287297
    288298    return tr_ptrArrayFindSorted( torrent->peers,
    289                                   addr,
     299                                  in_addr,
    290300                                  peerCompareToAddr );
    291301}
    292302
    293303static struct peer_atom*
    294 getExistingAtom( const Torrent    * t,
    295                  const tr_address * addr )
     304getExistingAtom( const                  Torrent * t,
     305                 const struct in_addr * addr )
    296306{
    297307    assert( torrentIsLocked( t ) );
     
    300310
    301311static int
    302 peerIsInUse( const Torrent    * ct,
    303              const tr_address * addr )
     312peerIsInUse( const Torrent *        ct,
     313             const struct in_addr * addr )
    304314{
    305315    Torrent * t = (Torrent*) ct;
     
    313323
    314324static tr_peer*
    315 peerConstructor( tr_torrent * tor, const tr_address * addr )
     325peerConstructor( tr_torrent * tor, const struct in_addr * in_addr )
    316326{
    317327    tr_peer * p;
    318328
    319329    p = tr_new0( tr_peer, 1 );
    320     memcpy( &p->addr, addr, sizeof( tr_address ) );
     330    memcpy( &p->in_addr, in_addr, sizeof( struct in_addr ) );
    321331    p->bandwidth = tr_bandwidthNew( tor->session, tor->bandwidth );
    322332    return p;
     
    324334
    325335static tr_peer*
    326 getPeer( Torrent          * torrent,
    327          const tr_address * addr )
     336getPeer( Torrent *              torrent,
     337         const struct in_addr * in_addr )
    328338{
    329339    tr_peer * peer;
     
    331341    assert( torrentIsLocked( torrent ) );
    332342
    333     peer = getExistingPeer( torrent, addr );
     343    peer = getExistingPeer( torrent, in_addr );
    334344
    335345    if( peer == NULL )
    336346    {
    337         peer = peerConstructor( torrent->tor, addr );
     347        peer = peerConstructor( torrent->tor, in_addr );
    338348        tr_ptrArrayInsertSorted( torrent->peers, peer, peerCompare );
    339349    }
     
    371381    assert( torrentIsLocked( t ) );
    372382
    373     atom = getExistingAtom( t, &peer->addr );
     383    atom = getExistingAtom( t, &peer->in_addr );
    374384    assert( atom );
    375385    atom->time = time( NULL );
     
    521531
    522532int
    523 tr_peerMgrPeerIsSeed( const tr_peerMgr * mgr,
    524                       const uint8_t    * torrentHash,
    525                       const tr_address * addr )
     533tr_peerMgrPeerIsSeed( const tr_peerMgr *     mgr,
     534                      const uint8_t *        torrentHash,
     535                      const struct in_addr * addr )
    526536{
    527537    int                      isSeed = FALSE;
     
    896906{
    897907    tordbg( t, "increasing peer %s strike count to %d",
    898             tr_peerIoAddrStr( &peer->addr,
     908            tr_peerIoAddrStr( &peer->in_addr,
    899909                              peer->port ), peer->strikes + 1 );
    900910
    901911    if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
    902912    {
    903         struct peer_atom * atom = getExistingAtom( t, &peer->addr );
     913        struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
    904914        atom->myflags |= MYFLAG_BANNED;
    905915        peer->doPurge = 1;
     
    966976            /* update our atom */
    967977            if( peer ) {
    968                 struct peer_atom * a = getExistingAtom( t, &peer->addr );
     978                struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
    969979                a->piece_data_time = now;
    970980            }
     
    9951005            /* update our atom */
    9961006            if( peer ) {
    997                 struct peer_atom * a = getExistingAtom( t, &peer->addr );
     1007                struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
    9981008                a->piece_data_time = now;
    9991009            }
     
    10061016            if( peer )
    10071017            {
    1008                 struct peer_atom * atom = getExistingAtom( t, &peer->addr );
     1018                struct peer_atom * atom = getExistingAtom( t,
     1019                                                           &peer->in_addr );
    10091020                const int          peerIsSeed = e->progress >= 1.0;
    10101021                if( peerIsSeed )
     
    11011112
    11021113static void
    1103 ensureAtomExists( Torrent          * t,
    1104                   const tr_address * addr,
    1105                   uint16_t           port,
    1106                   uint8_t            flags,
    1107                   uint8_t            from )
     1114ensureAtomExists( Torrent *              t,
     1115                  const struct in_addr * addr,
     1116                  uint16_t               port,
     1117                  uint8_t                flags,
     1118                  uint8_t                from )
    11081119{
    11091120    if( getExistingAtom( t, addr ) == NULL )
     
    11421153                   void *          vmanager )
    11431154{
    1144     int                ok = isConnected;
    1145     int                success = FALSE;
    1146     uint16_t           port;
    1147     const tr_address * addr;
    1148     tr_peerMgr *       manager = (tr_peerMgr*) vmanager;
    1149     Torrent *          t;
    1150     tr_handshake *     ours;
     1155    int                    ok = isConnected;
     1156    int                    success = FALSE;
     1157    uint16_t               port;
     1158    const struct in_addr * addr;
     1159    tr_peerMgr *           manager = (tr_peerMgr*) vmanager;
     1160    Torrent *              t;
     1161    tr_handshake *         ours;
    11511162
    11521163    assert( io );
     
    12431254
    12441255void
    1245 tr_peerMgrAddIncoming( tr_peerMgr * manager,
    1246                        tr_address * addr,
    1247                        uint16_t     port,
    1248                        int          socket )
     1256tr_peerMgrAddIncoming( tr_peerMgr *     manager,
     1257                       struct in_addr * addr,
     1258                       uint16_t         port,
     1259                       int              socket )
    12491260{
    12501261    managerLock( manager );
     
    12531264    {
    12541265        tr_dbg( "Banned IP address \"%s\" tried to connect to us",
    1255                tr_ntop_non_ts( addr ) );
     1266               inet_ntoa( *addr ) );
    12561267        tr_netClose( socket );
    12571268    }
     
    12901301
    12911302    t = getExistingTorrent( manager, torrentHash );
    1292     if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
    1293         ensureAtomExists( t, &pex->addr, pex->port, pex->flags, from );
     1303    if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->in_addr ) )
     1304        ensureAtomExists( t, &pex->in_addr, pex->port, pex->flags, from );
    12941305
    12951306    managerUnlock( manager );
     
    13101321    for( i = 0; i < n; ++i )
    13111322    {
    1312         pex[i].addr.type = TR_AF_INET;
    1313         memcpy( &pex[i].addr.addr, walk, 4 ); walk += 4;
     1323        memcpy( &pex[i].in_addr, walk, 4 ); walk += 4;
    13141324        memcpy( &pex[i].port, walk, 2 ); walk += 2;
    13151325        if( added_f && ( n == added_f_len ) )
     
    13481358                    t,
    13491359                    "peer %s contributed to corrupt piece (%d); now has %d strikes",
    1350                     tr_peerIoAddrStr( &peer->addr, peer->port ),
     1360                    tr_peerIoAddrStr( &peer->in_addr, peer->port ),
    13511361                    pieceIndex, (int)peer->strikes + 1 );
    13521362                addStrike( t, peer );
     
    13621372    const tr_pex * a = va;
    13631373    const tr_pex * b = vb;
    1364     int            i = tr_compareAddresses( &a->addr, &b->addr );
     1374    int            i =
     1375        memcmp( &a->in_addr, &b->in_addr, sizeof( struct in_addr ) );
    13651376
    13661377    if( i ) return i;
     
    14101421        {
    14111422            const tr_peer * peer = peers[i];
    1412             walk->addr = peer->addr;
     1423            walk->in_addr = peer->in_addr;
    14131424            walk->port = peer->port;
    14141425            walk->flags = 0;
     
    16471658    {
    16481659        const tr_peer *          peer = peers[i];
    1649         const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
     1660        const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
    16501661
    16511662        if( peer->io == NULL ) /* not connected */
     
    17351746        char *                   pch;
    17361747        const tr_peer *          peer = peers[i];
    1737         const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
     1748        const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
    17381749        tr_peer_stat *           stat = ret + i;
    17391750
    1740         tr_ntop( &peer->addr, stat->addr, sizeof( stat->addr ) );
     1751        tr_netNtop( &peer->in_addr, stat->addr, sizeof( stat->addr ) );
    17411752        tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
    17421753                   sizeof( stat->client ) );
     
    19341945    const tr_torrent *       tor = t->tor;
    19351946    const time_t             now = time( NULL );
    1936     const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
     1947    const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
    19371948
    19381949    /* if it's marked for purging, close it */
     
    21962207        {
    21972208            tr_peer *          peer = connections[i];
    2198             struct peer_atom * atom = getExistingAtom( t, &peer->addr );
     2209            struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
    21992210            if( peer->pieceDataActivityDate )
    22002211                atom->numFails = 0;
  • trunk/libtransmission/peer-mgr.h

    r7195 r7223  
    2222#ifdef WIN32
    2323 #include <winsock2.h> /* struct in_addr */
     24#else
     25 #include <netinet/in.h> /* struct in_addr */
    2426#endif
    2527
    26 #include "net.h"
    27 
     28struct in_addr;
    2829struct tr_handle;
    2930struct tr_peer_stat;
     
    4243typedef struct tr_pex
    4344{
    44     tr_address addr;
    45     uint16_t   port;
    46     uint8_t    flags;
     45    struct in_addr in_addr;
     46    uint16_t    port;
     47    uint8_t     flags;
    4748}
    4849tr_pex;
     
    5455void tr_peerMgrFree( tr_peerMgr * manager );
    5556
    56 int tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
    57                           const uint8_t     * torrentHash,
    58                           const tr_address  * addr );
     57int tr_peerMgrPeerIsSeed( const tr_peerMgr      * mgr,
     58                          const uint8_t         * torrentHash,
     59                          const struct in_addr  * addr );
    5960
    60 void tr_peerMgrAddIncoming( tr_peerMgr * manager,
    61                             tr_address * addr,
    62                             uint16_t     port,
    63                             int          socket );
     61void tr_peerMgrAddIncoming( tr_peerMgr     * manager,
     62                            struct in_addr * addr,
     63                            uint16_t         port,
     64                            int              socket );
    6465
    6566tr_pex * tr_peerMgrCompactToPex( const void    * compact,
  • trunk/libtransmission/peer-msgs.c

    r7219 r7223  
    17641764}
    17651765
    1766 /* TODO: ipv6 pex */
    17671766static void
    17681767sendPex( tr_peermsgs * msgs )
     
    18161815            tmp = walk = tr_new( uint8_t, diffs.addedCount * 6 );
    18171816            for( i = 0; i < diffs.addedCount; ++i ) {
    1818                 memcpy( walk, &diffs.added[i].addr.addr, 4 ); walk += 4;
     1817                memcpy( walk, &diffs.added[i].in_addr, 4 ); walk += 4;
    18191818                memcpy( walk, &diffs.added[i].port, 2 ); walk += 2;
    18201819            }
     
    18341833            tmp = walk = tr_new( uint8_t, diffs.droppedCount * 6 );
    18351834            for( i = 0; i < diffs.droppedCount; ++i ) {
    1836                 memcpy( walk, &diffs.dropped[i].addr.addr, 4 ); walk += 4;
     1835                memcpy( walk, &diffs.dropped[i].in_addr, 4 ); walk += 4;
    18371836                memcpy( walk, &diffs.dropped[i].port, 2 ); walk += 2;
    18381837            }
  • trunk/libtransmission/port-forwarding.c

    r7195 r7223  
    115115        int socket;
    116116        errno = 0;
    117         /* TODO: this is where we want to listen on another socket */
    118         socket = tr_netBindTCP( &tr_inaddr_any, s->publicPort );
     117        socket = tr_netBindTCP( s->publicPort );
    119118        if( socket >= 0 )
    120119        {
     
    140139    for( ; ; ) /* check for new incoming peer connections */
    141140    {
    142         int        socket;
    143         uint16_t   port;
    144         tr_address addr;
     141        int            socket;
     142        uint16_t       port;
     143        struct in_addr addr;
    145144
    146145        if( s->bindSocket < 0 )
  • trunk/libtransmission/resume.c

    r7195 r7223  
    6262***/
    6363
    64 /* TODO: fast resume is done with pex */
    6564static void
    6665savePeers( tr_benc *          dict,
  • trunk/libtransmission/session.c

    r7195 r7223  
    800800
    801801int
    802 tr_sessionIsAddressBlocked( const tr_session * session,
    803                             const tr_address * addr )
     802tr_sessionIsAddressBlocked( const tr_session *     session,
     803                            const struct in_addr * addr )
    804804{
    805805    tr_list * l;
  • trunk/libtransmission/session.h

    r7195 r7223  
    3939 #endif
    4040#endif
    41 
    42 #include "net.h"
    4341
    4442
     
    124122                                       const char * filename );
    125123
    126 int          tr_sessionIsAddressBlocked( const tr_session * session,
    127                                          const tr_address * addr );
     124struct in_addr;
     125
     126int          tr_sessionIsAddressBlocked( const tr_session *     session,
     127                                         const struct in_addr * addr );
    128128
    129129
  • trunk/libtransmission/tracker.c

    r7195 r7223  
    281281               size_t *  byteCount )
    282282{
    283     /* TODO: wtf */
    284283    int       i;
    285284    uint8_t * compact, *walk;
     
    292291    for( i = 0, walk = compact; i < peerCount; ++i )
    293292    {
    294         const char * s;
    295         int64_t      itmp;
    296         tr_address   addr;
    297         tr_port_t    port;
    298         tr_benc *    peer = &bePeers->val.l.vals[i];
    299 
    300         if( tr_bencDictFindStr( peer, "ip", &s ) )
    301         {
    302             if( tr_pton( s, &addr ) == NULL )
    303                 continue;
    304             if( addr.type != TR_AF_INET )
    305                 continue;
    306         }
    307 
    308         memcpy( walk, &addr.addr.addr4.s_addr, 4 );
     293        const char *   s;
     294        int64_t        itmp;
     295        struct in_addr addr;
     296        tr_port_t      port;
     297        tr_benc *      peer = &bePeers->val.l.vals[i];
     298
     299        if( !tr_bencDictFindStr( peer, "ip",
     300                                 &s ) || tr_netResolve( s, &addr ) )
     301            continue;
     302
     303        memcpy( walk, &addr, 4 );
    309304        walk += 4;
    310305
  • trunk/libtransmission/transmission.h

    r7199 r7223  
    5050#endif
    5151#include <time.h> /* time_t */
    52 #include <netinet/in.h> /* INET6_ADDRSTRLEN */
    5352
    5453#define SHA_DIGEST_LENGTH 20
     
    10631062    uint16_t     port;
    10641063
    1065     char         addr[INET6_ADDRSTRLEN];
     1064    char         addr[16];
    10661065    char         client[80];
    10671066    char         flagStr[32];
Note: See TracChangeset for help on using the changeset viewer.