Changeset 7231


Ignore:
Timestamp:
Dec 2, 2008, 3:41:58 AM (12 years ago)
Author:
charles
Message:

(libT) re-apply jhujhiti's IPv6 patch. This merges in my tr_port cleanup, so any new bugs are mine :/

Location:
trunk/libtransmission
Files:
21 edited

Legend:

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

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

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

    r7223 r7231  
    1818#define TR_BLOCKLIST_H
    1919
    20 struct in_addr;
     20struct tr_address;
    2121typedef struct tr_blocklist tr_blocklist;
    2222
    23 tr_blocklist* _tr_blocklistNew( const char * filename,
    24                                 int          isEnabled );
     23tr_blocklist* _tr_blocklistNew         ( const char              * filename,
     24                                         int                       isEnabled );
    2525
    26 int           _tr_blocklistExists( const tr_blocklist * );
     26int           _tr_blocklistExists      ( const tr_blocklist      * b );
    2727
    28 const char*   _tr_blocklistGetFilename( const tr_blocklist * );
     28const char*   _tr_blocklistGetFilename ( const tr_blocklist      * b );
    2929
    30 int           _tr_blocklistGetRuleCount( const tr_blocklist * );
     30int           _tr_blocklistGetRuleCount( const tr_blocklist      * b );
    3131
    32 void          _tr_blocklistFree( tr_blocklist * );
     32void          _tr_blocklistFree        ( tr_blocklist * );
    3333
    34 int           _tr_blocklistIsEnabled( tr_blocklist * );
     34int           _tr_blocklistIsEnabled   ( tr_blocklist            * b );
    3535
    36 void          _tr_blocklistSetEnabled(             tr_blocklist *,
    37                                                int isEnabled );
     36void          _tr_blocklistSetEnabled  ( tr_blocklist            * b,
     37                                         int                      isEnabled );
    3838
    39 int           _tr_blocklistHasAddress(
    40               tr_blocklist *,
    41     const struct
    42     in_addr * addr );
     39int           _tr_blocklistHasAddress  ( tr_blocklist            * b,
     40                                         const struct tr_address * addr );
    4341
    44 int           _tr_blocklistSetContent(
    45                  tr_blocklist *,
    46     const char * filename );
     42int           _tr_blocklistSetContent  ( tr_blocklist            * b,
     43                                         const char              * filename );
    4744
    4845#endif
  • trunk/libtransmission/fdlimit.c

    r7224 r7231  
    472472
    473473int
    474 tr_fdSocketAccept( int               b,
    475                    struct in_addr  * addr,
    476                    tr_port         * port )
     474tr_fdSocketAccept( int           b,
     475                   tr_address  * addr,
     476                   tr_port     * port )
    477477{
    478478    int                s = -1;
    479479    unsigned int       len;
    480     struct sockaddr_in sock;
     480    struct sockaddr_storage sock;
    481481
    482482    assert( addr );
     
    486486    if( gFd->socketCount < getSocketMax( gFd ) )
    487487    {
    488         len = sizeof( sock );
     488        len = sizeof( struct sockaddr );
    489489        s = accept( b, (struct sockaddr *) &sock, &len );
    490490    }
    491491    if( s > -1 )
    492492    {
    493         *addr = sock.sin_addr;
    494         *port = sock.sin_port;
     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        }
    495510        ++gFd->socketCount;
    496511    }
  • trunk/libtransmission/fdlimit.h

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

    r7224 r7231  
    11971197}
    11981198
    1199 const struct in_addr *
     1199const tr_address *
    12001200tr_handshakeGetAddr( const struct tr_handshake * handshake,
    12011201                     tr_port                   * port )
  • trunk/libtransmission/handshake.h

    r7224 r7231  
    2020#include "transmission.h"
    2121
    22 struct in_addr;
     22struct tr_address;
    2323struct tr_peerIo;
    2424typedef struct tr_handshake tr_handshake;
     
    3636                                        void *             doneUserData );
    3737
    38 const struct in_addr * tr_handshakeGetAddr( const struct tr_handshake  * handshake,
     38const struct tr_address *
     39                      tr_handshakeGetAddr( const struct tr_handshake  * handshake,
    3940                                            tr_port                    * port );
    4041
  • trunk/libtransmission/net.c

    r7224 r7231  
    4848#include "utils.h"
    4949
     50const tr_address tr_in6addr_any = { TR_AF_INET6, { IN6ADDR_ANY_INIT } };
     51const tr_address tr_inaddr_any = { TR_AF_INET,
     52    { { { { INADDR_ANY, 0x00, 0x00, 0x00 } } } } };
     53
    5054
    5155void
     
    6468}
    6569
    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  **********************************************************************/
    73 int
    74 tr_netResolve( const char *     address,
    75                struct in_addr * addr )
    76 {
    77     addr->s_addr = inet_addr( address );
    78     return addr->s_addr == 0xFFFFFFFF;
    79 }
     70
     71const char *
     72tr_ntop( const tr_address * src, char * dst, 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 */
     85const char *
     86tr_ntop_non_ts( const tr_address * src )
     87{
     88    static char buf[INET6_ADDRSTRLEN];
     89    return tr_ntop( src, buf, sizeof( buf ) );
     90}
     91
     92tr_address *
     93tr_pton( const char * src, tr_address * dst )
     94{
     95    int retval = inet_pton( AF_INET, src, &dst->addr );
     96    if( retval < 0 )
     97        return NULL;
     98    else if( retval == 0 )
     99        retval = inet_pton( AF_INET6, src, &dst->addr );
     100    else
     101    {
     102        dst->type = TR_AF_INET;
     103        return dst;
     104    }
     105
     106    if( retval < 1 )
     107        return NULL;
     108    dst->type = TR_AF_INET6;
     109    return dst;
     110}
     111
     112/*
     113 * Compare two tr_address structures.
     114 * Returns:
     115 * <0 if a < b
     116 * >0 if a > b
     117 * 0  if a == b
     118 */
     119int
     120tr_compareAddresses( const tr_address * a, const tr_address * b)
     121{
     122    int retval;
     123    int addrlen;
     124
     125    /* IPv6 addresses are always "greater than" IPv4 */
     126    if( a->type == TR_AF_INET && b->type == TR_AF_INET6 )
     127        return 1;
     128    if( a->type == TR_AF_INET6 && b->type == TR_AF_INET )
     129        return -1;
     130
     131    if( a->type == TR_AF_INET )
     132        addrlen = sizeof( struct in_addr );
     133    else
     134        addrlen = sizeof( struct in6_addr );
     135    retval = memcmp( &a->addr, &b->addr, addrlen );
     136    if( retval == 0 )
     137        return 0;
     138     
     139    return retval;
     140}
    80141
    81142/***********************************************************************
     
    137198}
    138199
    139 int
    140 tr_netOpenTCP( tr_session            * session,
    141                const struct in_addr  * addr,
    142                tr_port                 port )
    143 {
    144     int                s;
    145     struct sockaddr_in sock;
    146     const int          type = SOCK_STREAM;
     200static void
     201setup_sockaddr( const tr_address        * addr,
     202                tr_port                   port,
     203                struct sockaddr_storage * sockaddr)
     204{
     205    struct sockaddr_in  sock4;
     206    struct sockaddr_in6 sock6;
     207
     208    if( addr->type == TR_AF_INET )
     209    {
     210        memset( &sock4, 0, sizeof( sock4 ) );
     211        sock4.sin_family      = AF_INET;
     212        sock4.sin_addr.s_addr = addr->addr.addr4.s_addr;
     213        sock4.sin_port        = port;
     214        memcpy( sockaddr, &sock4, sizeof( sock4 ) );
     215    }
     216    else
     217    {
     218        memset( &sock6, 0, sizeof( sock6 ) );
     219        sock6.sin6_family = AF_INET6;
     220        sock6.sin6_port = port;
     221        memcpy( &sock6.sin6_addr, &addr->addr, sizeof( struct in6_addr ) );
     222        memcpy( sockaddr, &sock6, sizeof( sock6 ) );
     223    }
     224}
     225 
     226int
     227tr_netOpenTCP( tr_session        * session,
     228               const tr_address  * addr,
     229               tr_port             port )
     230{
     231    int                     s;
     232    struct sockaddr_storage sock;
     233    const int               type = SOCK_STREAM;
    147234
    148235    if( ( s = createSocket( type ) ) < 0 )
     
    151238    setSndBuf( session, s );
    152239
    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;
     240    setup_sockaddr( addr, port, &sock );
    157241
    158242    if( ( connect( s, (struct sockaddr *) &sock,
    159                   sizeof( struct sockaddr_in ) ) < 0 )
     243                  sizeof( struct sockaddr ) ) < 0 )
    160244#ifdef WIN32
    161245      && ( sockerrno != WSAEWOULDBLOCK )
     
    164248    {
    165249        tr_err( _( "Couldn't connect socket %d to %s, port %d (errno %d - %s)" ),
    166                s, inet_ntoa( *addr ), (int)port, sockerrno, tr_strerror( sockerrno ) );
     250               s, tr_ntop_non_ts( addr ), (int)port, sockerrno, tr_strerror( sockerrno ) );
    167251        tr_netClose( s );
    168252        s = -1;
     
    176260
    177261int
    178 tr_netBindTCP( int port )
    179 {
    180     int                s;
    181     struct sockaddr_in sock;
    182     const int          type = SOCK_STREAM;
     262tr_netBindTCP( const tr_address * addr, tr_port port )
     263{
     264    int                      s;
     265    struct sockaddr_storage sock;
     266    const int                type = SOCK_STREAM;
    183267
    184268#if defined( SO_REUSEADDR ) || defined( SO_REUSEPORT )
     
    194278#endif
    195279
    196     memset( &sock, 0, sizeof( sock ) );
    197     sock.sin_family      = AF_INET;
    198     sock.sin_addr.s_addr = INADDR_ANY;
    199     sock.sin_port        = htons( port );
     280    setup_sockaddr( addr, htons( port ), &sock );
    200281
    201282    if( bind( s, (struct sockaddr *) &sock,
    202              sizeof( struct sockaddr_in ) ) )
    203     {
    204         tr_err( _( "Couldn't bind port %d: %s" ), port,
    205                tr_strerror( sockerrno ) );
     283             sizeof( struct sockaddr ) ) )
     284    {
     285        tr_err( _( "Couldn't bind port %d on %s: %s" ), port,
     286               tr_ntop_non_ts( addr ), tr_strerror( sockerrno ) );
    206287        tr_netClose( s );
    207288        return -1;
    208289    }
    209290
    210     tr_dbg(  "Bound socket %d to port %d", s, port );
     291    tr_dbg(  "Bound socket %d to port %d on %s",
     292             s, port, tr_ntop_non_ts( addr ) );
    211293    return s;
    212294}
    213295
    214296int
    215 tr_netAccept( tr_session      * session,
    216               int               b,
    217               struct in_addr  * addr,
    218               tr_port         * port )
     297tr_netAccept( tr_session  * session,
     298              int           b,
     299              tr_address  * addr,
     300              tr_port     * port )
    219301{
    220302    int fd = makeSocketNonBlocking( tr_fdSocketAccept( b, addr, port ) );
     
    228310    tr_fdSocketClose( s );
    229311}
    230 
    231 void
    232 tr_netNtop( const struct in_addr * addr,
    233             char *                 buf,
    234             int                    len )
    235 {
    236     const uint8_t * cast;
    237 
    238     cast = (const uint8_t *)addr;
    239     tr_snprintf( buf, len, "%hhu.%hhu.%hhu.%hhu",
    240                  cast[0], cast[1], cast[2], cast[3] );
    241 }
    242 
  • trunk/libtransmission/net.h

    r7224 r7231  
    5858#endif
    5959
    60 struct in_addr;
    61 struct sockaddr_in;
    6260struct tr_session;
    6361
    64 /***********************************************************************
    65  * DNS resolution
    66  **********************************************************************/
    67 int  tr_netResolve( const  char *,
    68                     struct in_addr * );
    69 
     62#define TR_AF_INET  0
     63#define TR_AF_INET6 1
     64 
     65typedef struct tr_address {
     66    unsigned short type : 1;
     67    union {
     68        /* The order here is important for tr_in{,6}addr_any initialization,
     69         * since we can't use C99 designated initializers */
     70        struct in6_addr addr6;
     71        struct in_addr  addr4;
     72    } addr;
     73} tr_address;
     74 
     75extern const tr_address tr_inaddr_any;
     76extern const tr_address tr_in6addr_any;
     77 
     78const char *tr_ntop( const tr_address * src,
     79                     char * dst,
     80                     int size );
     81const char *tr_ntop_non_ts( const tr_address * src );
     82tr_address *tr_pton( const char * src,
     83                     tr_address * dst );
     84int tr_compareAddresses( const tr_address * a,
     85                         const tr_address * b);
    7086
    7187/***********************************************************************
    7288 * Sockets
    7389 **********************************************************************/
    74 int  tr_netOpenTCP( struct tr_handle     * session,
    75                     const struct in_addr * addr,
    76                     tr_port                port );
     90int  tr_netOpenTCP( struct tr_handle * session,
     91                    const tr_address * addr,
     92                    tr_port            port );
    7793
    78 int  tr_netBindTCP( int port );
     94int  tr_netBindTCP( const tr_address * addr,
     95                    tr_port            port );
    7996
    8097int  tr_netAccept( struct tr_handle  * session,
    8198                   int                 bound,
    82                    struct in_addr    * setme_addr,
     99                   tr_address        * setme_addr,
    83100                   tr_port           * setme_port );
    84101
     
    88105void tr_netClose( int s );
    89106
    90 void tr_netNtop( const struct in_addr * addr,
    91                  char *                 buf,
    92                  int                    len );
    93 
    94107void tr_netInit( void );
    95108
  • trunk/libtransmission/peer-io.c

    r7224 r7231  
    2020 #include <winsock2.h>
    2121#else
    22  #include <netinet/in.h> /* struct in_addr */
    2322 #include <arpa/inet.h> /* inet_ntoa */
    2423#endif
     
    9897    tr_session             * session;
    9998
    100     struct in_addr           in_addr;
     99    tr_address               addr;
    101100    struct tr_iobuf        * iobuf;
    102101    tr_list                * output_datatypes; /* struct tr_datatype */
     
    239238
    240239static tr_peerIo*
    241 tr_peerIoNew( tr_session *          session,
    242               const struct in_addr * in_addr,
    243               tr_port                port,
    244               const uint8_t *        torrentHash,
    245               int                    isIncoming,
    246               int                    socket )
     240tr_peerIoNew( tr_session       * session,
     241              const tr_address * addr,
     242              tr_port            port,
     243              const uint8_t    * torrentHash,
     244              int                isIncoming,
     245              int                socket )
    247246{
    248247    tr_peerIo * io;
     
    255254    io->crypto = tr_cryptoNew( torrentHash, isIncoming );
    256255    io->session = session;
    257     io->in_addr = *in_addr;
     256    io->addr = *addr;
    258257    io->port = port;
    259258    io->socket = socket;
     
    267266
    268267tr_peerIo*
    269 tr_peerIoNewIncoming( tr_session *          session,
    270                       const struct in_addr * in_addr,
    271                       tr_port                port,
    272                       int                    socket )
     268tr_peerIoNewIncoming( tr_session       * session,
     269                      const tr_address * addr,
     270                      tr_port            port,
     271                      int                socket )
    273272{
    274273    assert( session );
    275     assert( in_addr );
     274    assert( addr );
    276275    assert( socket >= 0 );
    277276
    278     return tr_peerIoNew( session, in_addr, port,
    279                          NULL, 1,
    280                          socket );
     277    return tr_peerIoNew( session, addr, port, NULL, 1, socket );
    281278}
    282279
    283280tr_peerIo*
    284 tr_peerIoNewOutgoing( tr_session *          session,
    285                       const struct in_addr * in_addr,
    286                       int                    port,
    287                       const uint8_t *        torrentHash )
     281tr_peerIoNewOutgoing( tr_session       * session,
     282                      const tr_address * addr,
     283                      tr_port            port,
     284                      const uint8_t    * torrentHash )
    288285{
    289286    int socket;
    290287
    291288    assert( session );
    292     assert( in_addr );
    293     assert( port >= 0 );
     289    assert( addr );
    294290    assert( torrentHash );
    295291
    296     socket = tr_netOpenTCP( session, in_addr, port );
     292    socket = tr_netOpenTCP( session, addr, port );
    297293
    298294    return socket < 0
    299295           ? NULL
    300            : tr_peerIoNew( session, in_addr, port, torrentHash, 0, socket );
     296           : tr_peerIoNew( session, addr, port, torrentHash, 0, socket );
    301297}
    302298
     
    337333}
    338334
    339 const struct in_addr*
     335const tr_address*
    340336tr_peerIoGetAddress( const tr_peerIo * io,
    341337                           tr_port   * port )
     
    346342        *port = io->port;
    347343
    348     return &io->in_addr;
     344    return &io->addr;
    349345}
    350346
    351347const char*
    352 tr_peerIoAddrStr( const struct in_addr * addr,
    353                   tr_port                port )
     348tr_peerIoAddrStr( const tr_address * addr,
     349                  tr_port            port )
    354350{
    355351    static char buf[512];
    356352
    357     tr_snprintf( buf, sizeof( buf ), "%s:%u", inet_ntoa( *addr ),
    358                 ntohs( port ) );
     353    if( addr->type == TR_AF_INET )
     354        tr_snprintf( buf, sizeof( buf ), "%s:%u", tr_ntop_non_ts( addr ), ntohs( port ) );
     355    else
     356        tr_snprintf( buf, sizeof( buf ), "[%s]:%u", tr_ntop_non_ts( addr ), ntohs( port ) );
    359357    return buf;
    360358}
     
    363361tr_peerIoGetAddrStr( const tr_peerIo * io )
    364362{
    365     return tr_peerIoAddrStr( &io->in_addr, io->port );
     363    return tr_peerIoAddrStr( &io->addr, io->port );
    366364}
    367365
     
    402400        tr_netClose( io->socket );
    403401
    404     io->socket = tr_netOpenTCP( io->session, &io->in_addr, io->port );
     402    io->socket = tr_netOpenTCP( io->session, &io->addr, io->port );
    405403
    406404    if( io->socket >= 0 )
  • trunk/libtransmission/peer-io.h

    r7224 r7231  
    2222**/
    2323
    24 struct in_addr;
    2524struct evbuffer;
     25struct tr_address;
    2626struct tr_bandwidth;
    2727struct tr_crypto;
     
    3333**/
    3434
    35 tr_peerIo*           tr_peerIoNewOutgoing( struct tr_handle     * session,
    36                                            const struct in_addr * addr,
    37                                            int                    port,
    38                                            const  uint8_t       * torrentHash );
    39 
    40 tr_peerIo*           tr_peerIoNewIncoming( struct tr_handle     * session,
    41                                            const struct in_addr * addr,
    42                                            tr_port                port,
    43                                            int                    socket );
    44 
    45 void                 tr_peerIoFree( tr_peerIo * io );
    46 
    47 tr_session*          tr_peerIoGetSession( tr_peerIo * io );
    48 
    49 /**
    50 ***
    51 **/
    52 
    53 void                 tr_peerIoEnableLTEP( tr_peerIo * io,
    54                                           int         flag );
    55 
    56 int                  tr_peerIoSupportsLTEP( const tr_peerIo * io );
    57 
    58 /**
    59 ***
    60 **/
    61 
    62 const char*          tr_peerIoAddrStr( const struct in_addr * addr,
    63                                        tr_port                port );
    64 
    65 const char*          tr_peerIoGetAddrStr( const tr_peerIo * io );
    66 
    67 const struct in_addr*tr_peerIoGetAddress( const tr_peerIo * io,
    68                                           tr_port         * port );
     35tr_peerIo*  tr_peerIoNewOutgoing( struct tr_handle        * session,
     36                                  const struct tr_address * addr,
     37                                  tr_port                   port,
     38                                  const  uint8_t          * torrentHash );
     39
     40tr_peerIo*  tr_peerIoNewIncoming( struct tr_handle        * session,
     41                                  const struct tr_address * addr,
     42                                  tr_port                   port,
     43                                  int                       socket );
     44
     45void        tr_peerIoFree       ( tr_peerIo               * io );
     46
     47
     48/**
     49***
     50**/
     51
     52void        tr_peerIoEnableLTEP( tr_peerIo * io,
     53                                 int         flag );
     54
     55int         tr_peerIoSupportsLTEP( const tr_peerIo * io );
     56
     57/**
     58***
     59**/
     60
     61tr_session* tr_peerIoGetSession ( tr_peerIo * io );
     62
     63const char* tr_peerIoAddrStr( const struct tr_address * addr,
     64                              tr_port                   port );
     65
     66const char* tr_peerIoGetAddrStr( const tr_peerIo * io );
     67
     68const struct tr_address * tr_peerIoGetAddress( const tr_peerIo * io,
     69                                               tr_port         * port );
    6970
    7071const uint8_t*       tr_peerIoGetTorrentHash( tr_peerIo * io );
  • trunk/libtransmission/peer-mgr-private.h

    r7224 r7231  
    2222#ifdef WIN32
    2323 #include <winsock2.h> /* struct in_addr */
    24 #else
    25  #include <netinet/in.h> /* struct in_addr */
    2624#endif
    2725
     
    5351    uint8_t                  encryption_preference;
    5452    tr_port                  port;
    55     struct in_addr           in_addr;
     53    tr_address               addr;
    5654    struct tr_peerIo       * io;
    5755
  • trunk/libtransmission/peer-mgr.c

    r7224 r7231  
    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     tr_port           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;
     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    tr_port     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;
    106106};
    107107
     
    185185
    186186static int
    187 compareAddresses( 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 
    196 static int
    197187handshakeCompareToAddr( const void * va,
    198188                        const void * vb )
     
    200190    const tr_handshake * a = va;
    201191
    202     return compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
     192    return tr_compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
    203193}
    204194
     
    211201
    212202static tr_handshake*
    213 getExistingHandshake( tr_ptrArray *          handshakes,
    214                       const struct in_addr * in_addr )
    215 {
    216     return tr_ptrArrayFindSorted( handshakes,
    217                                   in_addr,
    218                                   handshakeCompareToAddr );
    219 }
    220 
    221 static int
    222 comparePeerAtomToAddress( const void * va,
    223                           const void * vb )
     203getExistingHandshake( tr_ptrArray      * handshakes,
     204                      const tr_address * addr )
     205{
     206    return tr_ptrArrayFindSorted( handshakes, addr, handshakeCompareToAddr );
     207}
     208
     209static int
     210comparePeerAtomToAddress( const void * va, const void * vb )
    224211{
    225212    const struct peer_atom * a = va;
    226213
    227     return compareAddresses( &a->addr, vb );
    228 }
    229 
    230 static int
    231 comparePeerAtoms( const void * va,
    232                   const void * vb )
     214    return tr_compareAddresses( &a->addr, vb );
     215}
     216
     217static int
     218comparePeerAtoms( const void * va, const void * vb )
    233219{
    234220    const struct peer_atom * b = vb;
     
    271257
    272258static int
    273 peerCompare( const void * va,
    274              const void * vb )
     259peerCompare( const void * va, const void * vb )
    275260{
    276261    const tr_peer * a = va;
    277262    const tr_peer * b = vb;
    278263
    279     return compareAddresses( &a->in_addr, &b->in_addr );
    280 }
    281 
    282 static int
    283 peerCompareToAddr( const void * va,
    284                    const void * vb )
     264    return tr_compareAddresses( &a->addr, &b->addr );
     265}
     266
     267static int
     268peerCompareToAddr( const void * va, const void * vb )
    285269{
    286270    const tr_peer * a = va;
    287271
    288     return compareAddresses( &a->in_addr, vb );
     272    return tr_compareAddresses( &a->addr, vb );
    289273}
    290274
    291275static tr_peer*
    292 getExistingPeer( Torrent *              torrent,
    293                  const struct in_addr * in_addr )
     276getExistingPeer( Torrent          * torrent,
     277                 const tr_address * addr )
    294278{
    295279    assert( torrentIsLocked( torrent ) );
    296     assert( in_addr );
    297 
    298     return tr_ptrArrayFindSorted( torrent->peers,
    299                                   in_addr,
    300                                   peerCompareToAddr );
     280    assert( addr );
     281
     282    return tr_ptrArrayFindSorted( torrent->peers, addr, peerCompareToAddr );
    301283}
    302284
    303285static struct peer_atom*
    304 getExistingAtom( const                  Torrent * t,
    305                  const struct in_addr * addr )
     286getExistingAtom( const Torrent    * t,
     287                 const tr_address * addr )
    306288{
    307289    assert( torrentIsLocked( t ) );
     
    310292
    311293static int
    312 peerIsInUse( const Torrent *        ct,
    313              const struct in_addr * addr )
     294peerIsInUse( const Torrent    * ct,
     295             const tr_address * addr )
    314296{
    315297    Torrent * t = (Torrent*) ct;
     
    323305
    324306static tr_peer*
    325 peerConstructor( tr_torrent * tor, const struct in_addr * in_addr )
     307peerConstructor( tr_torrent * tor, const tr_address * addr )
    326308{
    327309    tr_peer * p;
    328310
    329311    p = tr_new0( tr_peer, 1 );
    330     memcpy( &p->in_addr, in_addr, sizeof( struct in_addr ) );
     312    p->addr = *addr;
    331313    p->bandwidth = tr_bandwidthNew( tor->session, tor->bandwidth );
    332314    return p;
     
    334316
    335317static tr_peer*
    336 getPeer( Torrent *              torrent,
    337          const struct in_addr * in_addr )
     318getPeer( Torrent          * torrent,
     319         const tr_address * addr )
    338320{
    339321    tr_peer * peer;
     
    341323    assert( torrentIsLocked( torrent ) );
    342324
    343     peer = getExistingPeer( torrent, in_addr );
     325    peer = getExistingPeer( torrent, addr );
    344326
    345327    if( peer == NULL )
    346328    {
    347         peer = peerConstructor( torrent->tor, in_addr );
     329        peer = peerConstructor( torrent->tor, addr );
    348330        tr_ptrArrayInsertSorted( torrent->peers, peer, peerCompare );
    349331    }
     
    381363    assert( torrentIsLocked( t ) );
    382364
    383     atom = getExistingAtom( t, &peer->in_addr );
     365    atom = getExistingAtom( t, &peer->addr );
    384366    assert( atom );
    385367    atom->time = time( NULL );
     
    531513
    532514int
    533 tr_peerMgrPeerIsSeed( const tr_peerMgr *     mgr,
    534                       const uint8_t *        torrentHash,
    535                       const struct in_addr * addr )
     515tr_peerMgrPeerIsSeed( const tr_peerMgr * mgr,
     516                      const uint8_t    * torrentHash,
     517                      const tr_address * addr )
    536518{
    537519    int                      isSeed = FALSE;
     
    906888{
    907889    tordbg( t, "increasing peer %s strike count to %d",
    908             tr_peerIoAddrStr( &peer->in_addr,
     890            tr_peerIoAddrStr( &peer->addr,
    909891                              peer->port ), peer->strikes + 1 );
    910892
    911893    if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
    912894    {
    913         struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     895        struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    914896        atom->myflags |= MYFLAG_BANNED;
    915897        peer->doPurge = 1;
     
    976958            /* update our atom */
    977959            if( peer ) {
    978                 struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
     960                struct peer_atom * a = getExistingAtom( t, &peer->addr );
    979961                a->piece_data_time = now;
    980962            }
     
    1005987            /* update our atom */
    1006988            if( peer ) {
    1007                 struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
     989                struct peer_atom * a = getExistingAtom( t, &peer->addr );
    1008990                a->piece_data_time = now;
    1009991            }
     
    1016998            if( peer )
    1017999            {
    1018                 struct peer_atom * atom = getExistingAtom( t,
    1019                                                            &peer->in_addr );
     1000                struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    10201001                const int          peerIsSeed = e->progress >= 1.0;
    10211002                if( peerIsSeed )
     
    11121093
    11131094static void
    1114 ensureAtomExists( Torrent *              t,
    1115                   const struct in_addr * addr,
    1116                   tr_port                port,
    1117                   uint8_t                flags,
    1118                   uint8_t                from )
     1095ensureAtomExists( Torrent          * t,
     1096                  const tr_address * addr,
     1097                  tr_port            port,
     1098                  uint8_t            flags,
     1099                  uint8_t            from )
    11191100{
    11201101    if( getExistingAtom( t, addr ) == NULL )
     
    11531134                   void *          vmanager )
    11541135{
    1155     int                    ok = isConnected;
    1156     int                    success = FALSE;
    1157     tr_port                port;
    1158     const struct in_addr * addr;
    1159     tr_peerMgr *           manager = (tr_peerMgr*) vmanager;
    1160     Torrent *              t;
    1161     tr_handshake *        ours;
     1136    int                ok = isConnected;
     1137    int                success = FALSE;
     1138    tr_port            port;
     1139    const tr_address * addr;
     1140    tr_peerMgr       * manager = vmanager;
     1141    Torrent          * t;
     1142    tr_handshake     * ours;
    11621143
    11631144    assert( io );
     
    12541235
    12551236void
    1256 tr_peerMgrAddIncoming( tr_peerMgr *     manager,
    1257                        struct in_addr * addr,
    1258                        tr_port          port,
    1259                        int              socket )
     1237tr_peerMgrAddIncoming( tr_peerMgr * manager,
     1238                       tr_address * addr,
     1239                       tr_port      port,
     1240                       int          socket )
    12601241{
    12611242    managerLock( manager );
     
    12641245    {
    12651246        tr_dbg( "Banned IP address \"%s\" tried to connect to us",
    1266                inet_ntoa( *addr ) );
     1247               tr_ntop_non_ts( addr ) );
    12671248        tr_netClose( socket );
    12681249    }
     
    13011282
    13021283    t = getExistingTorrent( manager, torrentHash );
    1303     if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->in_addr ) )
    1304         ensureAtomExists( t, &pex->in_addr, pex->port, pex->flags, from );
     1284    if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
     1285        ensureAtomExists( t, &pex->addr, pex->port, pex->flags, from );
    13051286
    13061287    managerUnlock( manager );
     
    13211302    for( i = 0; i < n; ++i )
    13221303    {
    1323         memcpy( &pex[i].in_addr, walk, 4 ); walk += 4;
     1304        pex[i].addr.type = TR_AF_INET;
     1305        memcpy( &pex[i].addr.addr, walk, 4 ); walk += 4;
    13241306        memcpy( &pex[i].port, walk, 2 ); walk += 2;
    13251307        if( added_f && ( n == added_f_len ) )
     
    13581340                    t,
    13591341                    "peer %s contributed to corrupt piece (%d); now has %d strikes",
    1360                     tr_peerIoAddrStr( &peer->in_addr, peer->port ),
     1342                    tr_peerIoAddrStr( &peer->addr, peer->port ),
    13611343                    pieceIndex, (int)peer->strikes + 1 );
    13621344                addStrike( t, peer );
     
    13721354    const tr_pex * a = va;
    13731355    const tr_pex * b = vb;
    1374     int            i =
    1375         memcmp( &a->in_addr, &b->in_addr, sizeof( struct in_addr ) );
     1356    int            i = tr_compareAddresses( &a->addr, &b->addr );
    13761357
    13771358    if( i ) return i;
     
    14211402        {
    14221403            const tr_peer * peer = peers[i];
    1423             walk->in_addr = peer->in_addr;
     1404            walk->addr = peer->addr;
    14241405            walk->port = peer->port;
    14251406            walk->flags = 0;
     
    16581639    {
    16591640        const tr_peer *          peer = peers[i];
    1660         const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1641        const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    16611642
    16621643        if( peer->io == NULL ) /* not connected */
     
    17461727        char *                   pch;
    17471728        const tr_peer *          peer = peers[i];
    1748         const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1729        const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    17491730        tr_peer_stat *           stat = ret + i;
    17501731
    1751         tr_netNtop( &peer->in_addr, stat->addr, sizeof( stat->addr ) );
     1732        tr_ntop( &peer->addr, stat->addr, sizeof( stat->addr ) );
    17521733        tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
    17531734                   sizeof( stat->client ) );
     
    19451926    const tr_torrent *       tor = t->tor;
    19461927    const time_t             now = time( NULL );
    1947     const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1928    const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    19481929
    19491930    /* if it's marked for purging, close it */
     
    22072188        {
    22082189            tr_peer *          peer = connections[i];
    2209             struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     2190            struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    22102191            if( peer->pieceDataActivityDate )
    22112192                atom->numFails = 0;
  • trunk/libtransmission/peer-mgr.h

    r7224 r7231  
    2222#ifdef WIN32
    2323 #include <winsock2.h> /* struct in_addr */
    24 #else
    25  #include <netinet/in.h> /* struct in_addr */
    2624#endif
    2725
    28 struct in_addr;
     26#include "net.h"
     27
    2928struct tr_handle;
    3029struct tr_peer_stat;
     
    4342typedef struct tr_pex
    4443{
    45     struct in_addr in_addr;
    46     tr_port     port;
    47     uint8_t     flags;
     44    tr_address addr;
     45    tr_port    port;
     46    uint8_t    flags;
    4847}
    4948tr_pex;
     
    5554void tr_peerMgrFree( tr_peerMgr * manager );
    5655
    57 int tr_peerMgrPeerIsSeed( const tr_peerMgr      * mgr,
    58                           const uint8_t         * torrentHash,
    59                           const struct in_addr  * addr );
     56int tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
     57                          const uint8_t     * torrentHash,
     58                          const tr_address  * addr );
    6059
    61 void tr_peerMgrAddIncoming( tr_peerMgr     * manager,
    62                             struct in_addr * addr,
    63                             tr_port          port,
    64                             int              socket );
     60void tr_peerMgrAddIncoming( tr_peerMgr  * manager,
     61                            tr_address * addr,
     62                            tr_port       port,
     63                            int           socket );
    6564
    6665tr_pex * tr_peerMgrCompactToPex( const void    * compact,
  • trunk/libtransmission/peer-msgs.c

    r7227 r7231  
    17651765}
    17661766
     1767/* TODO: ipv6 pex */
    17671768static void
    17681769sendPex( tr_peermsgs * msgs )
     
    18161817            tmp = walk = tr_new( uint8_t, diffs.addedCount * 6 );
    18171818            for( i = 0; i < diffs.addedCount; ++i ) {
    1818                 memcpy( walk, &diffs.added[i].in_addr, 4 ); walk += 4;
     1819                memcpy( walk, &diffs.added[i].addr.addr, 4 ); walk += 4;
    18191820                memcpy( walk, &diffs.added[i].port, 2 ); walk += 2;
    18201821            }
     
    18341835            tmp = walk = tr_new( uint8_t, diffs.droppedCount * 6 );
    18351836            for( i = 0; i < diffs.droppedCount; ++i ) {
    1836                 memcpy( walk, &diffs.dropped[i].in_addr, 4 ); walk += 4;
     1837                memcpy( walk, &diffs.dropped[i].addr.addr, 4 ); walk += 4;
    18371838                memcpy( walk, &diffs.dropped[i].port, 2 ); walk += 2;
    18381839            }
  • trunk/libtransmission/port-forwarding.c

    r7224 r7231  
    115115        int socket;
    116116        errno = 0;
    117         socket = tr_netBindTCP( s->publicPort );
     117        socket = tr_netBindTCP( &tr_inaddr_any, s->publicPort );
    118118        if( socket >= 0 )
    119119        {
     
    139139    for( ; ; ) /* check for new incoming peer connections */
    140140    {
    141         int            socket;
    142         tr_port        port;
    143         struct in_addr addr;
     141        int         socket;
     142        tr_port     port;
     143        tr_address addr;
    144144
    145145        if( s->bindSocket < 0 )
  • trunk/libtransmission/resume.c

    r7223 r7231  
    6262***/
    6363
     64/* TODO: resume peers6 */
    6465static void
    6566savePeers( tr_benc *          dict,
  • trunk/libtransmission/session.c

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

    r7223 r7231  
    5353};
    5454
     55struct tr_address;
    5556struct tr_bandwidth;
    5657
     
    122123                                       const char * filename );
    123124
    124 struct in_addr;
    125 
    126 int          tr_sessionIsAddressBlocked( const tr_session *     session,
    127                                          const struct in_addr * addr );
     125int          tr_sessionIsAddressBlocked( const tr_session        * session,
     126                                         const struct tr_address * addr );
    128127
    129128
  • trunk/libtransmission/tracker.c

    r7224 r7231  
    281281               size_t *  byteCount )
    282282{
     283    /* TODO: IPv6 wtf */
    283284    int       i;
    284285    uint8_t * compact, *walk;
     
    291292    for( i = 0, walk = compact; i < peerCount; ++i )
    292293    {
    293         const char *   s;
    294         int64_t        itmp;
    295         struct in_addr addr;
    296         tr_port        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 );
     294        const char * s;
     295        int64_t      itmp;
     296        tr_address   addr;
     297        tr_port      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 );
    304309        walk += 4;
    305310
  • trunk/libtransmission/transmission.h

    r7224 r7231  
    5050#endif
    5151#include <time.h> /* time_t */
     52#include <netinet/in.h> /* INET6_ADDRSTRLEN */
    5253
    5354#define SHA_DIGEST_LENGTH 20
     
    10631064    tr_port      port;
    10641065
    1065     char         addr[16];
     1066    char         addr[INET6_ADDRSTRLEN];
    10661067    char         client[80];
    10671068    char         flagStr[32];
Note: See TracChangeset for help on using the changeset viewer.