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

(libT) patch from jhujhiti to add ipv6 support.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 
Note: See TracChangeset for help on using the changeset viewer.