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

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/net.c

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