source: trunk/libtransmission/net.c @ 7851

Last change on this file since 7851 was 7851, checked in by jhujhiti, 13 years ago

(trunk libT) suppress ipv6 EHOSTUNREACH as well as ENETUNREACH

  • Property svn:keywords set to Date Rev Author Id
File size: 15.2 KB
Line 
1/******************************************************************************
2 * $Id: net.c 7851 2009-02-08 22:52:47Z jhujhiti $
3 *
4 * Copyright (c) 2005-2008 Transmission authors and contributors
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *****************************************************************************/
24
25#include <errno.h>
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include <assert.h>
30
31#include <sys/types.h>
32
33#ifdef WIN32
34 #include <winsock2.h> /* inet_addr */
35 #include <WS2tcpip.h>
36#else
37 #include <arpa/inet.h> /* inet_addr */
38 #include <netdb.h>
39 #include <fcntl.h>
40#endif
41
42#include <evutil.h>
43
44#include "transmission.h"
45#include "fdlimit.h"
46#include "natpmp.h"
47#include "net.h"
48#include "peer-io.h"
49#include "platform.h"
50#include "utils.h"
51
52#ifndef IN_MULTICAST
53#define IN_MULTICAST( a ) ( ( ( a ) & 0xf0000000 ) == 0xe0000000 )
54#endif
55
56const tr_address tr_in6addr_any = { TR_AF_INET6, { IN6ADDR_ANY_INIT } }; 
57const tr_address tr_inaddr_any = { TR_AF_INET, 
58    { { { { INADDR_ANY, 0x00, 0x00, 0x00 } } } } }; 
59
60#ifdef WIN32
61static const char *
62inet_ntop(int af, const void *src, char *dst, socklen_t cnt)
63{
64    if (af == AF_INET)
65    {
66        struct sockaddr_in in;
67        memset(&in, 0, sizeof(in));
68        in.sin_family = AF_INET;
69        memcpy(&in.sin_addr, src, sizeof(struct in_addr));
70        getnameinfo((struct sockaddr *)&in, sizeof(struct
71            sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST);
72        return dst;
73    }
74    else if (af == AF_INET6)
75    {
76        struct sockaddr_in6 in;
77        memset(&in, 0, sizeof(in));
78        in.sin6_family = AF_INET6;
79        memcpy(&in.sin6_addr, src, sizeof(struct in_addr6));
80        getnameinfo((struct sockaddr *)&in, sizeof(struct
81            sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST);
82        return dst;
83    }
84    return NULL;
85}
86
87static int
88inet_pton(int af, const char *src, void *dst)
89{
90    struct addrinfo hints;
91    struct addrinfo *res;
92    struct addrinfo *ressave;
93
94    memset(&hints, 0, sizeof(struct addrinfo));
95    hints.ai_family = af;
96
97    if (getaddrinfo(src, NULL, &hints, &res) != 0)
98        return -1;
99
100    ressave = res;
101
102    while (res)
103    {
104        memcpy(dst, res->ai_addr, res->ai_addrlen);
105        res = res->ai_next;
106    }
107
108    freeaddrinfo(ressave);
109    return 0;
110}
111
112#endif
113
114
115void
116tr_netInit( void )
117{
118    static int initialized = FALSE;
119
120    if( !initialized )
121    {
122#ifdef WIN32
123        WSADATA wsaData;
124        WSAStartup( MAKEWORD( 2, 2 ), &wsaData );
125#endif
126        initialized = TRUE;
127    }
128}
129
130void
131tr_suspectAddress( const tr_address * a UNUSED, const char * source UNUSED )
132{
133/* this is overkill for a production environment,
134 * but useful in the nightly builds, so only compile it into the nightlies */
135#ifdef TR_UNSTABLE
136    /* be really aggressive in what we report */
137    if( a->type == TR_AF_INET && !( ntohl( a->addr.addr4.s_addr ) & 0xff000000 ) )
138        tr_err(  "Funny looking address %s from %s", tr_ntop_non_ts( a ), source );
139    /* /16s taken from ipv6 rib on 21 dec, 2008 */
140    /* this is really, really ugly. expedience over quality */
141    if( a->type == TR_AF_INET6 )
142    {
143        uint16_t slash16;
144        uint16_t valid[] = { 0x339, 0x2002, 0x2003, 0x2400, 0x2401, 0x2402,
145            0x2403, 0x2404, 0x2405, 0x2406, 0x2407, 0x2600, 0x2607, 0x2610,
146            0x2620, 0x2800, 0x2801, 0x2a00, 0x2a01, 0x0a02, 0x2001, 0x0000 };
147        uint16_t *p;
148        tr_bool good = FALSE;
149        p = valid;
150        memcpy( &slash16, &a->addr, 2 );
151        slash16 = ntohs( slash16 );
152        while( *p )
153        {
154            if( slash16 == *p )
155                good = TRUE;
156            p++;
157        }
158        if( !good && !IN6_IS_ADDR_V4MAPPED( &a->addr.addr6 ) )
159            tr_err(  "Funny looking address %s from %s", tr_ntop_non_ts( a ), source );
160    }
161#endif
162}
163
164const char * 
165tr_ntop( const tr_address * src, char * dst, int size ) 
166{
167    assert( tr_isAddress( src ) );
168
169    if( src->type == TR_AF_INET ) 
170        return inet_ntop( AF_INET, &src->addr, dst, size ); 
171    else 
172        return inet_ntop( AF_INET6, &src->addr, dst, size ); 
173} 
174
175/*
176 * Non-threadsafe version of tr_ntop, which uses a static memory area for a buffer.
177 * This function is suitable to be called from libTransmission's networking code,
178 * which is single-threaded.
179 */ 
180const char * 
181tr_ntop_non_ts( const tr_address * src ) 
182{ 
183    static char buf[INET6_ADDRSTRLEN]; 
184    return tr_ntop( src, buf, sizeof( buf ) ); 
185} 
186
187tr_address * 
188tr_pton( const char * src, tr_address * dst ) 
189{ 
190    int retval = inet_pton( AF_INET, src, &dst->addr ); 
191    if( retval < 0 ) 
192        return NULL; 
193    else if( retval == 0 ) 
194        retval = inet_pton( AF_INET6, src, &dst->addr ); 
195    else
196    { 
197        dst->type = TR_AF_INET; 
198        return dst; 
199    } 
200
201    if( retval < 1 ) 
202        return NULL; 
203    dst->type = TR_AF_INET6; 
204    return dst; 
205}
206
207void
208tr_normalizeV4Mapped( tr_address * const addr )
209{
210    assert( tr_isAddress( addr ) );
211
212    if( addr->type == TR_AF_INET6 && IN6_IS_ADDR_V4MAPPED( &addr->addr.addr6 ) )
213    {
214        addr->type = TR_AF_INET;
215        memcpy( &addr->addr.addr4.s_addr, addr->addr.addr6.s6_addr + 12, 4 );
216    }
217}
218
219/*
220 * Compare two tr_address structures.
221 * Returns:
222 * <0 if a < b
223 * >0 if a > b
224 * 0  if a == b
225 */ 
226int
227tr_compareAddresses( const tr_address * a, const tr_address * b)
228{
229    int addrlen;
230
231    assert( tr_isAddress( a ) );
232    assert( tr_isAddress( b ) );
233
234    /* IPv6 addresses are always "greater than" IPv4 */ 
235    if( a->type != b->type )
236        return a->type == TR_AF_INET ? 1 : -1;
237
238    if( a->type == TR_AF_INET ) 
239        addrlen = sizeof( struct in_addr ); 
240    else 
241        addrlen = sizeof( struct in6_addr ); 
242    return memcmp( &a->addr, &b->addr, addrlen );
243} 
244
245tr_bool
246tr_net_hasIPv6( tr_port port )
247{
248    static tr_bool alreadyDone = FALSE;
249    static tr_bool result      = FALSE;
250    int s;
251    if( alreadyDone )
252        return result;
253    s = tr_netBindTCP( &tr_in6addr_any, port, TRUE );
254    if( s >= 0 || -s != EAFNOSUPPORT ) /* we support ipv6 */
255    {
256        result = TRUE;
257        tr_netClose( s );
258    }
259    alreadyDone = TRUE;
260    return result;
261}
262
263/***********************************************************************
264 * Socket list housekeeping
265 **********************************************************************/
266struct tr_socketList
267{
268    int             socket;
269    tr_address      addr;
270    tr_socketList * next;
271};
272
273tr_socketList *
274tr_socketListAppend( tr_socketList * const head,
275                     const tr_address * const addr )
276{
277    tr_socketList * tmp;
278
279    assert( head );
280    assert( tr_isAddress( addr ) );
281
282    for( tmp = head; tmp->next; tmp = tmp->next );
283    tmp->next = tr_socketListNew( addr );
284    return tmp->next;
285}
286
287tr_socketList *
288tr_socketListNew( const tr_address * const addr )
289{
290    tr_socketList * tmp;
291
292    assert( tr_isAddress( addr ) );
293
294    tmp = tr_new( tr_socketList, 1 );
295    tmp->socket = -1;
296    tmp->addr = *addr;
297    tmp->next = NULL;
298    return tmp;
299}
300
301void
302tr_socketListFree( tr_socketList * const head )
303{
304    assert( head );
305
306    if( head->next )
307        tr_socketListFree( head->next );
308    tr_free( head );
309}
310
311void
312tr_socketListRemove( tr_socketList * const head,
313                     tr_socketList * const el)
314{
315    tr_socketList * tmp;
316
317    assert( head );
318    assert( el );
319
320    for( tmp = head; tmp->next && tmp->next != el; tmp = tmp->next );
321    tmp->next = el->next;
322    el->next = NULL;
323    tr_socketListFree(el);
324}
325
326void
327tr_socketListTruncate( tr_socketList * const head,
328                       tr_socketList * const start )
329{
330    tr_socketList * tmp;
331
332    assert( head );
333    assert( start );
334
335    for( tmp = head; tmp->next && tmp->next != start; tmp = tmp->next );
336    tr_socketListFree( start );
337    tmp->next = NULL;
338}
339
340#if 0
341int
342tr_socketListGetSocket( const tr_socketList * const el )
343{
344    assert( el );
345
346    return el->socket;
347}
348
349const tr_address *
350tr_socketListGetAddress( const tr_socketList * const el )
351{
352    assert( el );
353    return &el->addr;
354}
355#endif
356
357void
358tr_socketListForEach( tr_socketList * const head,
359                      void ( * cb ) ( int * const,
360                                      tr_address * const,
361                                      void * const),
362                      void * const userData )
363{
364    tr_socketList * tmp;
365    for( tmp = head; tmp; tmp = tmp->next )
366        cb( &tmp->socket, &tmp->addr, userData );
367}
368
369/***********************************************************************
370 * TCP sockets
371 **********************************************************************/
372
373int
374tr_netSetTOS( int s, int tos )
375{
376#ifdef IP_TOS
377    return setsockopt( s, IPPROTO_IP, IP_TOS, (char*)&tos, sizeof( tos ) );
378#else
379    return 0;
380#endif
381}
382
383static int
384makeSocketNonBlocking( int fd )
385{
386    if( fd >= 0 )
387    {
388        if( evutil_make_socket_nonblocking( fd ) )
389        {
390            int tmperrno;
391            tr_err( _( "Couldn't create socket: %s" ),
392                   tr_strerror( sockerrno ) );
393            tmperrno = sockerrno;
394            tr_netClose( fd );
395            fd = -tmperrno;
396        }
397    }
398
399    return fd;
400}
401
402static int
403createSocket( int domain, int type )
404{
405    return makeSocketNonBlocking( tr_fdSocketCreate( domain, type ) );
406}
407
408static void
409setSndBuf( tr_session * session UNUSED, int fd UNUSED )
410{
411#if 0
412    if( fd >= 0 )
413    {
414        const int sndbuf = session->so_sndbuf;
415        const int rcvbuf = session->so_rcvbuf;
416        setsockopt( fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof( sndbuf ) );
417        setsockopt( fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof( rcvbuf ) );
418    }
419#endif
420}
421
422static socklen_t
423setup_sockaddr( const tr_address        * addr,
424                tr_port                   port,
425                struct sockaddr_storage * sockaddr)
426{
427    struct sockaddr_in  sock4;
428    struct sockaddr_in6 sock6;
429
430    assert( tr_isAddress( addr ) );
431
432    if( addr->type == TR_AF_INET )
433    {
434        memset( &sock4, 0, sizeof( sock4 ) );
435        sock4.sin_family      = AF_INET;
436        sock4.sin_addr.s_addr = addr->addr.addr4.s_addr;
437        sock4.sin_port        = port;
438        memcpy( sockaddr, &sock4, sizeof( sock4 ) );
439        return sizeof( struct sockaddr_in );
440    }
441    else
442    {
443        memset( &sock6, 0, sizeof( sock6 ) );
444        sock6.sin6_family = AF_INET6;
445        sock6.sin6_port = port;
446        sock6.sin6_flowinfo = 0;
447        sock6.sin6_addr = addr->addr.addr6;
448        memcpy( sockaddr, &sock6, sizeof( sock6 ) );
449        return sizeof( struct sockaddr_in6 );
450    }
451}
452
453static tr_bool
454isMulticastAddress( const tr_address * addr )
455{
456    if( addr->type == TR_AF_INET && IN_MULTICAST( htonl( addr->addr.addr4.s_addr ) ) )
457        return TRUE;
458
459    if( addr->type == TR_AF_INET6 && ( addr->addr.addr6.s6_addr[0] == 0xff ) )
460        return TRUE;
461
462    return FALSE;
463}
464
465static TR_INLINE tr_bool
466isIPv6LinkLocalAddress( const tr_address * addr )
467{
468    if( addr->type == TR_AF_INET6 &&
469            IN6_IS_ADDR_LINKLOCAL( &addr->addr.addr6 ))
470        return TRUE;
471    return FALSE;
472}
473
474tr_bool
475tr_isValidPeerAddress( const tr_address * addr, tr_port port )
476{
477    if( isMulticastAddress( addr ) || isIPv6LinkLocalAddress( addr ) )
478        return FALSE;
479
480    if( port == 0 )
481        return FALSE;
482
483    return TRUE;
484}
485
486int
487tr_netOpenTCP( tr_session        * session,
488               const tr_address  * addr,
489               tr_port             port )
490{
491    int                     s;
492    struct sockaddr_storage sock;
493    const int               type = SOCK_STREAM;
494    socklen_t               addrlen;
495
496    assert( tr_isAddress( addr ) );
497
498    if( isMulticastAddress( addr ) || isIPv6LinkLocalAddress( addr ))
499        return -EINVAL;
500
501    if( ( s = createSocket( ( addr->type == TR_AF_INET ? AF_INET : AF_INET6 ), type ) ) < 0 )
502        return s;
503
504    setSndBuf( session, s );
505
506    addrlen = setup_sockaddr( addr, port, &sock );
507
508    if( ( connect( s, (struct sockaddr *) &sock,
509                  addrlen ) < 0 )
510#ifdef WIN32
511      && ( sockerrno != WSAEWOULDBLOCK )
512#endif
513      && ( sockerrno != EINPROGRESS ) )
514    {
515        int tmperrno;
516        tmperrno = sockerrno;
517        if( ( tmperrno != ENETUNREACH && tmperrno != EHOSTUNREACH )
518                || addr->type == TR_AF_INET )
519            tr_err( _( "Couldn't connect socket %d to %s, port %d (errno %d - %s)" ),
520                    s, tr_ntop_non_ts( addr ), (int)port, tmperrno,
521                    tr_strerror( tmperrno ) );
522        tr_netClose( s );
523        s = -tmperrno;
524    }
525
526    tr_deepLog( __FILE__, __LINE__, NULL, "New OUTGOING connection %d (%s)",
527               s, tr_peerIoAddrStr( addr, port ) );
528
529    return s;
530}
531
532int
533tr_netBindTCP( const tr_address * addr, tr_port port, tr_bool suppressMsgs )
534{
535    int                     s;
536    struct sockaddr_storage sock;
537    const int               type = SOCK_STREAM;
538    int                     addrlen;
539    int                     retval;
540
541#if defined( SO_REUSEADDR ) || defined( SO_REUSEPORT ) || defined( IPV6_V6ONLY )
542    int                optval = 1;
543#endif
544
545    assert( tr_isAddress( addr ) );
546
547    if( ( s = createSocket( ( addr->type == TR_AF_INET ? AF_INET : AF_INET6 ),
548                            type ) ) < 0 )
549        return s;
550
551#ifdef SO_REUSEADDR
552    setsockopt( s, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, sizeof( optval ) );
553#endif
554
555#ifdef IPV6_V6ONLY
556    if( addr->type == TR_AF_INET6 && 
557        ( retval = setsockopt( s, IPPROTO_IPV6, IPV6_V6ONLY, &optval,
558                             sizeof( optval ) ) ) == -1 ) {
559        /* the kernel may not support this. if not, ignore it */
560        if( errno != ENOPROTOOPT )
561            return -errno;
562    }
563#endif
564
565    addrlen = setup_sockaddr( addr, htons( port ), &sock );
566
567    if( bind( s, (struct sockaddr *) &sock,
568             addrlen ) )
569    {
570        int tmperrno;
571        if( !suppressMsgs )
572            tr_err( _( "Couldn't bind port %d on %s: %s" ), port,
573                    tr_ntop_non_ts( addr ), tr_strerror( sockerrno ) );
574        tmperrno = sockerrno;
575        tr_netClose( s );
576        return -tmperrno;
577    }
578    if( !suppressMsgs )
579        tr_dbg(  "Bound socket %d to port %d on %s",
580                 s, port, tr_ntop_non_ts( addr ) );
581    return s;
582}
583
584int
585tr_netAccept( tr_session  * session,
586              int           b,
587              tr_address  * addr,
588              tr_port     * port )
589{
590    int fd;
591
592    fd = makeSocketNonBlocking( tr_fdSocketAccept( b, addr, port ) );
593    setSndBuf( session, fd );
594    return fd;
595}
596
597void
598tr_netClose( int s )
599{
600    tr_fdSocketClose( s );
601}
Note: See TracBrowser for help on using the repository browser.