Changeset 7195


Ignore:
Timestamp:
Nov 30, 2008, 12:47:18 AM (10 years ago)
Author:
charles
Message:

(libT) patch from jhujhiti to add ipv6 support.

Location:
trunk/libtransmission
Files:
21 edited

Legend:

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

    r6795 r7195  
    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

    r7173 r7195  
    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 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        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

    r7151 r7195  
    1818#define TR_BLOCKLIST_H
    1919
    20 struct in_addr;
     20struct tr_address;
     21
    2122typedef struct tr_blocklist tr_blocklist;
    2223
     
    3435int           _tr_blocklistIsEnabled( tr_blocklist * );
    3536
    36 void          _tr_blocklistSetEnabled(             tr_blocklist *,
    37                                                int isEnabled );
     37void          _tr_blocklistSetEnabled( tr_blocklist * ,
     38                                       int isEnabled );
    3839
    39 int           _tr_blocklistHasAddress(
    40               tr_blocklist *,
    41     const struct
    42     in_addr * addr );
     40int           _tr_blocklistHasAddress( tr_blocklist *,
     41                                       const tr_address * addr );
    4342
    44 int           _tr_blocklistSetContent(
    45                  tr_blocklist *,
    46     const char * filename );
     43int           _tr_blocklistSetContent( tr_blocklist *,
     44                                       const char * filename );
    4745
    4846#endif
  • trunk/libtransmission/fdlimit.c

    r7173 r7195  
    472472
    473473int
    474 tr_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;
     474tr_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;
    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

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

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

    r7151 r7195  
    2020#include "transmission.h"
    2121
    22 struct in_addr;
    2322struct tr_peerIo;
    2423typedef struct tr_handshake tr_handshake;
     
    3635                                        void *             doneUserData );
    3736
    38 const struct in_addr * tr_handshakeGetAddr(
    39     const struct tr_handshake * handshake,
    40                                 uint16_t
    41     *                           setme_port );
     37const tr_address     * tr_handshakeGetAddr( const struct tr_handshake * handshake,
     38                                            uint16_t                  * setme_port );
    4239
    4340void                   tr_handshakeAbort( tr_handshake * handshake );
  • trunk/libtransmission/net.c

    r7190 r7195  
    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 } } } } };
    5053
    5154void
     
    6467}
    6568
    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;
     69const char *
     70tr_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 */
     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,
     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 */
     120int
     121tr_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;
    79142}
    80143
     
    137200}
    138201
    139 int
    140 tr_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;
     202static void
     203setup_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
     227int
     228tr_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;
    147235
    148236    if( ( s = createSocket( type ) ) < 0 )
     
    151239    setSndBuf( session, s );
    152240
    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;
     241    setup_sockaddr( addr, port, &sock );
    157242
    158243    if( ( connect( s, (struct sockaddr *) &sock,
    159                   sizeof( struct sockaddr_in ) ) < 0 )
     244                  sizeof( struct sockaddr ) ) < 0 )
    160245#ifdef WIN32
    161246      && ( sockerrno != WSAEWOULDBLOCK )
     
    165250        tr_err( _(
    166251                   "Couldn't connect socket %d to %s, port %d (errno %d - %s)" ),
    167                s, inet_ntoa( *addr ), port,
     252               s, tr_ntop_non_ts( addr ), port,
    168253               sockerrno, tr_strerror( sockerrno ) );
    169254        tr_netClose( s );
     
    178263
    179264int
    180 tr_netBindTCP( int port )
    181 {
    182     int                s;
    183     struct sockaddr_in sock;
    184     const int          type = SOCK_STREAM;
     265tr_netBindTCP( const tr_address * addr,
     266               int port )
     267{
     268    int                     s;
     269    struct sockaddr_storage sock;
     270    const int               type = SOCK_STREAM;
    185271
    186272#if defined( SO_REUSEADDR ) || defined( SO_REUSEPORT )
     
    195281    setsockopt( s, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, sizeof( optval ) );
    196282#endif
    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 );
     283   
     284    setup_sockaddr( addr, htons( port ), &sock );
    202285
    203286    if( bind( s, (struct sockaddr *) &sock,
    204              sizeof( struct sockaddr_in ) ) )
    205     {
    206         tr_err( _( "Couldn't bind port %d: %s" ), port,
    207                tr_strerror( sockerrno ) );
     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 ) );
    208291        tr_netClose( s );
    209292        return -1;
    210293    }
    211294
    212     tr_dbg(  "Bound socket %d to port %d", s, port );
     295    tr_dbg(  "Bound socket %d to port %d on %s", s, port,
     296           tr_ntop_non_ts( addr ) );
    213297    return s;
    214298}
    215299
    216300int
    217 tr_netAccept( tr_session      * session,
    218               int               b,
    219               struct in_addr * addr,
    220               tr_port_t       * port )
     301tr_netAccept( tr_session * session,
     302              int          b,
     303              tr_address * addr,
     304              tr_port_t  * port )
    221305{
    222306    int fd = makeSocketNonBlocking( tr_fdSocketAccept( b, addr, port ) );
     
    230314    tr_fdSocketClose( s );
    231315}
    232 
    233 void
    234 tr_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

    r7151 r7195  
    6161#endif
    6262
    63 struct in_addr;
    64 struct sockaddr_in;
    6563struct tr_session;
    6664
    67 /***********************************************************************
    68  * DNS resolution
    69  **********************************************************************/
    70 int  tr_netResolve( const  char *,
    71                     struct in_addr * );
     65#define TR_AF_INET  0
     66#define TR_AF_INET6 1
     67
     68typedef 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
     78extern const tr_address tr_inaddr_any;
     79extern const tr_address tr_in6addr_any;
     80
     81const char *tr_ntop( const tr_address * src,
     82                     char * dst,
     83                     int size );
     84const char *tr_ntop_non_ts( const tr_address * src );
     85tr_address *tr_pton( const char * src,
     86                     tr_address * dst );
     87int tr_compareAddresses( const tr_address * a,
     88                         const tr_address * b);
    7289
    7390
     
    7592 * Sockets
    7693 **********************************************************************/
    77 int  tr_netOpenTCP( struct tr_handle     * session,
    78                     const struct in_addr * addr,
    79                     tr_port_t              port );
     94int  tr_netOpenTCP( struct tr_handle * session,
     95                    const tr_address * addr,
     96                    tr_port_t          port );
    8097
    81 int  tr_netBindTCP( int port );
     98int  tr_netBindTCP( const tr_address * addr,
     99                    int                port );
    82100
    83 int  tr_netAccept( struct tr_handle  * session,
    84                    int                 bound,
    85                    struct in_addr    * setme_addr,
    86                    tr_port_t         * setme_port );
     101int  tr_netAccept( struct tr_handle * session,
     102                   int                bound,
     103                   tr_address       * setme_addr,
     104                   tr_port_t        * setme_port );
    87105
    88106int  tr_netSetTOS( int s,
     
    91109void tr_netClose( int s );
    92110
    93 void tr_netNtop( const struct in_addr * addr,
    94                  char *                 buf,
    95                  int                    len );
    96 
    97111void tr_netInit( void );
    98112
  • trunk/libtransmission/peer-io.c

    r7186 r7195  
    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               uint16_t               port,
    244               const uint8_t *        torrentHash,
    245               int                    isIncoming,
    246               int                    socket )
     240tr_peerIoNew( tr_session       * session,
     241              const tr_address * addr,
     242              uint16_t           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                       uint16_t               port,
    272                       int                    socket )
     268tr_peerIoNewIncoming( tr_session       * session,
     269                      const tr_address * addr,
     270                      uint16_t           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,
     277    return tr_peerIoNew( session, addr, port,
    279278                         NULL, 1,
    280279                         socket );
     
    282281
    283282tr_peerIo*
    284 tr_peerIoNewOutgoing( tr_session *          session,
    285                       const struct in_addr * in_addr,
    286                       int                    port,
    287                       const uint8_t *        torrentHash )
     283tr_peerIoNewOutgoing( tr_session       * session,
     284                      const tr_address * addr,
     285                      int                port,
     286                      const uint8_t    * torrentHash )
    288287{
    289288    int socket;
    290289
    291290    assert( session );
    292     assert( in_addr );
     291    assert( addr );
    293292    assert( port >= 0 );
    294293    assert( torrentHash );
    295294
    296     socket = tr_netOpenTCP( session, in_addr, port );
     295    socket = tr_netOpenTCP( session, addr, port );
    297296
    298297    return socket < 0
    299298           ? NULL
    300            : tr_peerIoNew( session, in_addr, port, torrentHash, 0, socket );
     299           : tr_peerIoNew( session, addr, port, torrentHash, 0, socket );
    301300}
    302301
     
    337336}
    338337
    339 const struct in_addr*
     338const tr_address*
    340339tr_peerIoGetAddress( const tr_peerIo * io,
    341                            uint16_t * port )
     340                           uint16_t  * port )
    342341{
    343342    assert( isPeerIo( io ) );
     
    346345        *port = io->port;
    347346
    348     return &io->in_addr;
     347    return &io->addr;
    349348}
    350349
    351350const char*
    352 tr_peerIoAddrStr( const struct in_addr * addr,
    353                   uint16_t               port )
     351tr_peerIoAddrStr( const tr_address * addr,
     352                  uint16_t           port )
    354353{
    355354    static char buf[512];
    356355
    357     tr_snprintf( buf, sizeof( buf ), "%s:%u", inet_ntoa( *addr ),
    358                 ntohs( port ) );
     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 ) );
    359362    return buf;
    360363}
     
    363366tr_peerIoGetAddrStr( const tr_peerIo * io )
    364367{
    365     return tr_peerIoAddrStr( &io->in_addr, io->port );
     368    return tr_peerIoAddrStr( &io->addr, io->port );
    366369}
    367370
     
    402405        tr_netClose( io->socket );
    403406
    404     io->socket = tr_netOpenTCP( io->session, &io->in_addr, io->port );
     407    io->socket = tr_netOpenTCP( io->session, &io->addr, io->port );
    405408
    406409    if( io->socket >= 0 )
  • trunk/libtransmission/peer-io.h

    r7186 r7195  
    2222**/
    2323
    24 struct in_addr;
    2524struct evbuffer;
    2625struct tr_bandwidth;
     
    3332**/
    3433
    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                                            uint16_t               port,
    43                                            int                    socket );
     34tr_peerIo*           tr_peerIoNewOutgoing( struct tr_handle * session,
     35                                           const tr_address * addr,
     36                                           int                port,
     37                                           const  uint8_t   * torrentHash );
     38
     39tr_peerIo*           tr_peerIoNewIncoming( struct tr_handle * session,
     40                                           const tr_address * addr,
     41                                           uint16_t           port,
     42                                           int                socket );
    4443
    4544void                 tr_peerIoFree( tr_peerIo * io );
     
    6059**/
    6160
    62 const char*          tr_peerIoAddrStr( const struct in_addr * addr,
    63                                        uint16_t               port );
     61const char*          tr_peerIoAddrStr( const tr_address * addr,
     62                                       uint16_t           port );
    6463
    6564const char*          tr_peerIoGetAddrStr( const tr_peerIo * io );
    6665
    67 const struct in_addr*tr_peerIoGetAddress( const tr_peerIo * io,
     66const tr_address *   tr_peerIoGetAddress( const tr_peerIo * io,
    6867                                                uint16_t * port );
    6968
  • trunk/libtransmission/peer-mgr-private.h

    r7173 r7195  
    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    uint16_t                 port;
    55     struct in_addr           in_addr;
     53    tr_address               addr;
    5654    struct tr_peerIo       * io;
    5755
  • trunk/libtransmission/peer-mgr.c

    r7186 r7195  
    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     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    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;
    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 )
     203getExistingHandshake( tr_ptrArray      * handshakes,
     204                      const tr_address * addr )
    215205{
    216206    return tr_ptrArrayFindSorted( handshakes,
    217                                   in_addr,
     207                                  addr,
    218208                                  handshakeCompareToAddr );
    219209}
     
    225215    const struct peer_atom * a = va;
    226216
    227     return compareAddresses( &a->addr, vb );
     217    return tr_compareAddresses( &a->addr, vb );
    228218}
    229219
     
    277267    const tr_peer * b = vb;
    278268
    279     return compareAddresses( &a->in_addr, &b->in_addr );
     269    return tr_compareAddresses( &a->addr, &b->addr );
    280270}
    281271
     
    286276    const tr_peer * a = va;
    287277
    288     return compareAddresses( &a->in_addr, vb );
     278    return tr_compareAddresses( &a->addr, vb );
    289279}
    290280
    291281static tr_peer*
    292 getExistingPeer( Torrent *              torrent,
    293                  const struct in_addr * in_addr )
     282getExistingPeer( Torrent          * torrent,
     283                 const tr_address * addr )
    294284{
    295285    assert( torrentIsLocked( torrent ) );
    296     assert( in_addr );
     286    assert( addr );
    297287
    298288    return tr_ptrArrayFindSorted( torrent->peers,
    299                                   in_addr,
     289                                  addr,
    300290                                  peerCompareToAddr );
    301291}
    302292
    303293static struct peer_atom*
    304 getExistingAtom( const                  Torrent * t,
    305                  const struct in_addr * addr )
     294getExistingAtom( const Torrent    * t,
     295                 const tr_address * addr )
    306296{
    307297    assert( torrentIsLocked( t ) );
     
    310300
    311301static int
    312 peerIsInUse( const Torrent *        ct,
    313              const struct in_addr * addr )
     302peerIsInUse( const Torrent    * ct,
     303             const tr_address * addr )
    314304{
    315305    Torrent * t = (Torrent*) ct;
     
    323313
    324314static tr_peer*
    325 peerConstructor( tr_torrent * tor, const struct in_addr * in_addr )
     315peerConstructor( tr_torrent * tor, const tr_address * addr )
    326316{
    327317    tr_peer * p;
    328318
    329319    p = tr_new0( tr_peer, 1 );
    330     memcpy( &p->in_addr, in_addr, sizeof( struct in_addr ) );
     320    memcpy( &p->addr, addr, sizeof( tr_address ) );
    331321    p->bandwidth = tr_bandwidthNew( tor->session, tor->bandwidth );
    332322    return p;
     
    334324
    335325static tr_peer*
    336 getPeer( Torrent *              torrent,
    337          const struct in_addr * in_addr )
     326getPeer( Torrent          * torrent,
     327         const tr_address * addr )
    338328{
    339329    tr_peer * peer;
     
    341331    assert( torrentIsLocked( torrent ) );
    342332
    343     peer = getExistingPeer( torrent, in_addr );
     333    peer = getExistingPeer( torrent, addr );
    344334
    345335    if( peer == NULL )
    346336    {
    347         peer = peerConstructor( torrent->tor, in_addr );
     337        peer = peerConstructor( torrent->tor, addr );
    348338        tr_ptrArrayInsertSorted( torrent->peers, peer, peerCompare );
    349339    }
     
    381371    assert( torrentIsLocked( t ) );
    382372
    383     atom = getExistingAtom( t, &peer->in_addr );
     373    atom = getExistingAtom( t, &peer->addr );
    384374    assert( atom );
    385375    atom->time = time( NULL );
     
    531521
    532522int
    533 tr_peerMgrPeerIsSeed( const tr_peerMgr *     mgr,
    534                       const uint8_t *        torrentHash,
    535                       const struct in_addr * addr )
     523tr_peerMgrPeerIsSeed( const tr_peerMgr * mgr,
     524                      const uint8_t    * torrentHash,
     525                      const tr_address * addr )
    536526{
    537527    int                      isSeed = FALSE;
     
    906896{
    907897    tordbg( t, "increasing peer %s strike count to %d",
    908             tr_peerIoAddrStr( &peer->in_addr,
     898            tr_peerIoAddrStr( &peer->addr,
    909899                              peer->port ), peer->strikes + 1 );
    910900
    911901    if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
    912902    {
    913         struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     903        struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    914904        atom->myflags |= MYFLAG_BANNED;
    915905        peer->doPurge = 1;
     
    976966            /* update our atom */
    977967            if( peer ) {
    978                 struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
     968                struct peer_atom * a = getExistingAtom( t, &peer->addr );
    979969                a->piece_data_time = now;
    980970            }
     
    1005995            /* update our atom */
    1006996            if( peer ) {
    1007                 struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
     997                struct peer_atom * a = getExistingAtom( t, &peer->addr );
    1008998                a->piece_data_time = now;
    1009999            }
     
    10161006            if( peer )
    10171007            {
    1018                 struct peer_atom * atom = getExistingAtom( t,
    1019                                                            &peer->in_addr );
     1008                struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    10201009                const int          peerIsSeed = e->progress >= 1.0;
    10211010                if( peerIsSeed )
     
    11121101
    11131102static void
    1114 ensureAtomExists( Torrent *              t,
    1115                   const struct in_addr * addr,
    1116                   uint16_t               port,
    1117                   uint8_t                flags,
    1118                   uint8_t                from )
     1103ensureAtomExists( Torrent          * t,
     1104                  const tr_address * addr,
     1105                  uint16_t           port,
     1106                  uint8_t            flags,
     1107                  uint8_t            from )
    11191108{
    11201109    if( getExistingAtom( t, addr ) == NULL )
     
    11531142                   void *          vmanager )
    11541143{
    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;
     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;
    11621151
    11631152    assert( io );
     
    12541243
    12551244void
    1256 tr_peerMgrAddIncoming( tr_peerMgr *     manager,
    1257                        struct in_addr * addr,
    1258                        uint16_t         port,
    1259                        int              socket )
     1245tr_peerMgrAddIncoming( tr_peerMgr * manager,
     1246                       tr_address * addr,
     1247                       uint16_t     port,
     1248                       int          socket )
    12601249{
    12611250    managerLock( manager );
     
    12641253    {
    12651254        tr_dbg( "Banned IP address \"%s\" tried to connect to us",
    1266                inet_ntoa( *addr ) );
     1255               tr_ntop_non_ts( addr ) );
    12671256        tr_netClose( socket );
    12681257    }
     
    13011290
    13021291    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 );
     1292    if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
     1293        ensureAtomExists( t, &pex->addr, pex->port, pex->flags, from );
    13051294
    13061295    managerUnlock( manager );
     
    13211310    for( i = 0; i < n; ++i )
    13221311    {
    1323         memcpy( &pex[i].in_addr, walk, 4 ); walk += 4;
     1312        pex[i].addr.type = TR_AF_INET;
     1313        memcpy( &pex[i].addr.addr, walk, 4 ); walk += 4;
    13241314        memcpy( &pex[i].port, walk, 2 ); walk += 2;
    13251315        if( added_f && ( n == added_f_len ) )
     
    13581348                    t,
    13591349                    "peer %s contributed to corrupt piece (%d); now has %d strikes",
    1360                     tr_peerIoAddrStr( &peer->in_addr, peer->port ),
     1350                    tr_peerIoAddrStr( &peer->addr, peer->port ),
    13611351                    pieceIndex, (int)peer->strikes + 1 );
    13621352                addStrike( t, peer );
     
    13721362    const tr_pex * a = va;
    13731363    const tr_pex * b = vb;
    1374     int            i =
    1375         memcmp( &a->in_addr, &b->in_addr, sizeof( struct in_addr ) );
     1364    int            i = tr_compareAddresses( &a->addr, &b->addr );
    13761365
    13771366    if( i ) return i;
     
    14211410        {
    14221411            const tr_peer * peer = peers[i];
    1423             walk->in_addr = peer->in_addr;
     1412            walk->addr = peer->addr;
    14241413            walk->port = peer->port;
    14251414            walk->flags = 0;
     
    16591648    {
    16601649        const tr_peer *          peer = peers[i];
    1661         const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1650        const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    16621651
    16631652        if( peer->io == NULL ) /* not connected */
     
    17471736        char *                   pch;
    17481737        const tr_peer *          peer = peers[i];
    1749         const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1738        const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    17501739        tr_peer_stat *           stat = ret + i;
    17511740
    1752         tr_netNtop( &peer->in_addr, stat->addr, sizeof( stat->addr ) );
     1741        tr_ntop( &peer->addr, stat->addr, sizeof( stat->addr ) );
    17531742        tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
    17541743                   sizeof( stat->client ) );
     
    19461935    const tr_torrent *       tor = t->tor;
    19471936    const time_t             now = time( NULL );
    1948     const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1937    const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    19491938
    19501939    /* if it's marked for purging, close it */
     
    22082197        {
    22092198            tr_peer *          peer = connections[i];
    2210             struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     2199            struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    22112200            if( peer->pieceDataActivityDate )
    22122201                atom->numFails = 0;
  • trunk/libtransmission/peer-mgr.h

    r7186 r7195  
    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     uint16_t    port;
    47     uint8_t     flags;
     44    tr_address addr;
     45    uint16_t   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                             uint16_t         port,
    64                             int              socket );
     60void tr_peerMgrAddIncoming( tr_peerMgr * manager,
     61                            tr_address * addr,
     62                            uint16_t     port,
     63                            int          socket );
    6564
    6665tr_pex * tr_peerMgrCompactToPex( const void    * compact,
  • trunk/libtransmission/peer-msgs.c

    r7186 r7195  
    17601760}
    17611761
     1762/* TODO: ipv6 pex */
    17621763static void
    17631764sendPex( tr_peermsgs * msgs )
     
    18071808            tmp = walk = tr_new( uint8_t, diffs.addedCount * 6 );
    18081809            for( i = 0; i < diffs.addedCount; ++i ) {
    1809                 memcpy( walk, &diffs.added[i].in_addr, 4 ); walk += 4;
     1810                memcpy( walk, &diffs.added[i].addr.addr, 4 ); walk += 4;
    18101811                memcpy( walk, &diffs.added[i].port, 2 ); walk += 2;
    18111812            }
     
    18251826            tmp = walk = tr_new( uint8_t, diffs.droppedCount * 6 );
    18261827            for( i = 0; i < diffs.droppedCount; ++i ) {
    1827                 memcpy( walk, &diffs.dropped[i].in_addr, 4 ); walk += 4;
     1828                memcpy( walk, &diffs.dropped[i].addr.addr, 4 ); walk += 4;
    18281829                memcpy( walk, &diffs.dropped[i].port, 2 ); walk += 2;
    18291830            }
  • trunk/libtransmission/port-forwarding.c

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

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

    r7154 r7195  
    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

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

    r7173 r7195  
    281281               size_t *  byteCount )
    282282{
     283    /* TODO: 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_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 );
     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 );
    304309        walk += 4;
    305310
  • trunk/libtransmission/transmission.h

    r7173 r7195  
    5050#endif
    5151#include <time.h> /* time_t */
     52#include <netinet/in.h> /* INET6_ADDRSTRLEN */
    5253
    5354#define SHA_DIGEST_LENGTH 20
     
    10621063    uint16_t     port;
    10631064
    1064     char         addr[16];
     1065    char         addr[INET6_ADDRSTRLEN];
    10651066    char         client[80];
    10661067    char         flagStr[32];
Note: See TracChangeset for help on using the changeset viewer.