source: trunk/libtransmission/net.c @ 8242

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

(trunk) #1497 Options to listen on specific network sockets

  • Property svn:keywords set to Date Rev Author Id
File size: 14.9 KB
Line 
1/******************************************************************************
2 * $Id: net.c 8242 2009-04-15 21:05:58Z 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
130const char * 
131tr_ntop( const tr_address * src, char * dst, int size ) 
132{
133    assert( tr_isAddress( src ) );
134
135    if( src->type == TR_AF_INET ) 
136        return inet_ntop( AF_INET, &src->addr, dst, size ); 
137    else 
138        return inet_ntop( AF_INET6, &src->addr, dst, size ); 
139} 
140
141/*
142 * Non-threadsafe version of tr_ntop, which uses a static memory area for a buffer.
143 * This function is suitable to be called from libTransmission's networking code,
144 * which is single-threaded.
145 */ 
146const char * 
147tr_ntop_non_ts( const tr_address * src ) 
148{ 
149    static char buf[INET6_ADDRSTRLEN]; 
150    return tr_ntop( src, buf, sizeof( buf ) ); 
151} 
152
153tr_address * 
154tr_pton( const char * src, tr_address * dst ) 
155{ 
156    int retval = inet_pton( AF_INET, src, &dst->addr ); 
157    assert( dst );
158    if( retval < 0 ) 
159        return NULL; 
160    else if( retval == 0 ) 
161        retval = inet_pton( AF_INET6, src, &dst->addr ); 
162    else
163    { 
164        dst->type = TR_AF_INET; 
165        return dst; 
166    } 
167
168    if( retval < 1 ) 
169        return NULL; 
170    dst->type = TR_AF_INET6; 
171    return dst; 
172}
173
174/*
175 * Compare two tr_address structures.
176 * Returns:
177 * <0 if a < b
178 * >0 if a > b
179 * 0  if a == b
180 */ 
181int
182tr_compareAddresses( const tr_address * a, const tr_address * b)
183{
184    static const int sizes[2] = { sizeof(struct in_addr), sizeof(struct in6_addr) };
185
186    assert( tr_isAddress( a ) );
187    assert( tr_isAddress( b ) );
188
189    /* IPv6 addresses are always "greater than" IPv4 */ 
190    if( a->type != b->type )
191        return a->type == TR_AF_INET ? 1 : -1;
192
193    return memcmp( &a->addr, &b->addr, sizes[a->type] );
194} 
195
196tr_bool
197tr_net_hasIPv6( tr_port port )
198{
199    static tr_bool alreadyDone = FALSE;
200    static tr_bool result      = FALSE;
201    int s;
202    if( alreadyDone )
203        return result;
204    s = tr_netBindTCP( &tr_in6addr_any, port, TRUE );
205    if( s >= 0 || -s != EAFNOSUPPORT ) /* we support ipv6 */
206    {
207        result = TRUE;
208        tr_netClose( s );
209    }
210    alreadyDone = TRUE;
211    return result;
212}
213
214/***********************************************************************
215 * Socket list housekeeping
216 **********************************************************************/
217struct tr_socketList
218{
219    int             socket;
220    tr_address      addr;
221    tr_socketList * next;
222};
223
224tr_socketList *
225tr_socketListAppend( tr_socketList * const head,
226                     const tr_address * const addr )
227{
228    tr_socketList * tmp;
229
230    assert( head );
231    assert( tr_isAddress( addr ) );
232
233    for( tmp = head; tmp->next; tmp = tmp->next );
234    tmp->next = tr_socketListNew( addr );
235    return tmp->next;
236}
237
238tr_socketList *
239tr_socketListNew( const tr_address * const addr )
240{
241    tr_socketList * tmp;
242
243    assert( tr_isAddress( addr ) );
244
245    tmp = tr_new( tr_socketList, 1 );
246    tmp->socket = -1;
247    tmp->addr = *addr;
248    tmp->next = NULL;
249    return tmp;
250}
251
252void
253tr_socketListFree( tr_socketList * const head )
254{
255    assert( head );
256
257    if( head->next )
258        tr_socketListFree( head->next );
259    tr_free( head );
260}
261
262void
263tr_socketListRemove( tr_socketList * const head,
264                     tr_socketList * const el)
265{
266    tr_socketList * tmp;
267
268    assert( head );
269    assert( el );
270
271    for( tmp = head; tmp->next && tmp->next != el; tmp = tmp->next );
272    tmp->next = el->next;
273    el->next = NULL;
274    tr_socketListFree(el);
275}
276
277void
278tr_socketListTruncate( tr_socketList * const head,
279                       tr_socketList * const start )
280{
281    tr_socketList * tmp;
282
283    assert( head );
284    assert( start );
285
286    for( tmp = head; tmp->next && tmp->next != start; tmp = tmp->next );
287    tr_socketListFree( start );
288    tmp->next = NULL;
289}
290
291#if 0
292int
293tr_socketListGetSocket( const tr_socketList * const el )
294{
295    assert( el );
296
297    return el->socket;
298}
299
300const tr_address *
301tr_socketListGetAddress( const tr_socketList * const el )
302{
303    assert( el );
304    return &el->addr;
305}
306#endif
307
308void
309tr_socketListForEach( tr_socketList * const head,
310                      void ( * cb ) ( int * const,
311                                      tr_address * const,
312                                      void * const),
313                      void * const userData )
314{
315    tr_socketList * tmp;
316    for( tmp = head; tmp; tmp = tmp->next )
317        cb( &tmp->socket, &tmp->addr, userData );
318}
319
320const tr_address *
321tr_socketListGetType( const tr_socketList * const el, tr_address_type type )
322{
323    const tr_socketList * tmp = el;
324    while( tmp )
325    {
326        if( tmp->addr.type == type )
327            return &tmp->addr;
328        tmp = tmp->next;
329    }
330    return NULL;
331}
332
333/***********************************************************************
334 * TCP sockets
335 **********************************************************************/
336
337int
338tr_netSetTOS( int s, int tos )
339{
340#ifdef IP_TOS
341    return setsockopt( s, IPPROTO_IP, IP_TOS, (char*)&tos, sizeof( tos ) );
342#else
343    return 0;
344#endif
345}
346
347static int
348makeSocketNonBlocking( int fd )
349{
350    if( fd >= 0 )
351    {
352        if( evutil_make_socket_nonblocking( fd ) )
353        {
354            int tmperrno;
355            tr_err( _( "Couldn't create socket: %s" ),
356                   tr_strerror( sockerrno ) );
357            tmperrno = sockerrno;
358            tr_netClose( fd );
359            fd = -tmperrno;
360        }
361    }
362
363    return fd;
364}
365
366static int
367createSocket( int domain, int type )
368{
369    return makeSocketNonBlocking( tr_fdSocketCreate( domain, type ) );
370}
371
372static void
373setSndBuf( tr_session * session UNUSED, int fd UNUSED )
374{
375#if 0
376    if( fd >= 0 )
377    {
378        const int sndbuf = session->so_sndbuf;
379        const int rcvbuf = session->so_rcvbuf;
380        setsockopt( fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof( sndbuf ) );
381        setsockopt( fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof( rcvbuf ) );
382    }
383#endif
384}
385
386static socklen_t
387setup_sockaddr( const tr_address        * addr,
388                tr_port                   port,
389                struct sockaddr_storage * sockaddr)
390{
391    struct sockaddr_in  sock4;
392    struct sockaddr_in6 sock6;
393
394    assert( tr_isAddress( addr ) );
395
396    if( addr->type == TR_AF_INET )
397    {
398        memset( &sock4, 0, sizeof( sock4 ) );
399        sock4.sin_family      = AF_INET;
400        sock4.sin_addr.s_addr = addr->addr.addr4.s_addr;
401        sock4.sin_port        = port;
402        memcpy( sockaddr, &sock4, sizeof( sock4 ) );
403        return sizeof( struct sockaddr_in );
404    }
405    else
406    {
407        memset( &sock6, 0, sizeof( sock6 ) );
408        sock6.sin6_family = AF_INET6;
409        sock6.sin6_port = port;
410        sock6.sin6_flowinfo = 0;
411        sock6.sin6_addr = addr->addr.addr6;
412        memcpy( sockaddr, &sock6, sizeof( sock6 ) );
413        return sizeof( struct sockaddr_in6 );
414    }
415}
416
417static tr_bool
418isMulticastAddress( const tr_address * addr )
419{
420    if( addr->type == TR_AF_INET && IN_MULTICAST( htonl( addr->addr.addr4.s_addr ) ) )
421        return TRUE;
422
423    if( addr->type == TR_AF_INET6 && ( addr->addr.addr6.s6_addr[0] == 0xff ) )
424        return TRUE;
425
426    return FALSE;
427}
428
429static TR_INLINE tr_bool
430isIPv4MappedOrCompatAddress( const tr_address * addr )
431{
432    if( addr->type == TR_AF_INET6 )
433    {
434        if( IN6_IS_ADDR_V4MAPPED( &addr->addr.addr6 ) ||
435            IN6_IS_ADDR_V4COMPAT( &addr->addr.addr6 ) )
436            return TRUE;
437    }
438    return FALSE;
439}
440
441static TR_INLINE tr_bool
442isIPv6LinkLocalAddress( const tr_address * addr )
443{
444    if( addr->type == TR_AF_INET6 &&
445        IN6_IS_ADDR_LINKLOCAL( &addr->addr.addr6 ) )
446        return TRUE;
447    return FALSE;
448}
449
450tr_bool
451tr_isValidPeerAddress( const tr_address * addr, tr_port port )
452{
453    if( isMulticastAddress( addr ) || isIPv6LinkLocalAddress( addr ) ||
454        isIPv4MappedOrCompatAddress( addr ) )
455        return FALSE;
456
457    if( port == 0 )
458        return FALSE;
459
460    return TRUE;
461}
462
463const tr_socketList * tr_getSessionBindSockets( const tr_session * session );
464
465int
466tr_netOpenTCP( tr_session        * session,
467               const tr_address  * addr,
468               tr_port             port )
469{
470    int                     s;
471    struct sockaddr_storage sock;
472    const int               type = SOCK_STREAM;
473    socklen_t               addrlen;
474    const tr_address      * source_addr;
475    socklen_t               sourcelen;
476    struct sockaddr_storage source_sock;
477
478    assert( tr_isAddress( addr ) );
479
480    if( isMulticastAddress( addr ) || isIPv6LinkLocalAddress( addr ) )
481        return -EINVAL;
482
483    if( ( s = createSocket( ( addr->type == TR_AF_INET ? AF_INET : AF_INET6 ), type ) ) < 0 )
484        return s;
485
486    setSndBuf( session, s );
487
488    addrlen = setup_sockaddr( addr, port, &sock );
489   
490    /* set source address */
491    source_addr = tr_socketListGetType( tr_getSessionBindSockets( session ),
492                                        addr->type );
493    assert( source_addr );
494    sourcelen = setup_sockaddr( source_addr, 0, &source_sock );
495    if( bind( s, ( struct sockaddr * ) &source_sock, sourcelen ) )
496    {
497        tr_err( _( "Couldn't set source address %s on %d: %s" ),
498                tr_ntop_non_ts( source_addr ), s, tr_strerror( errno ) );
499        return -errno;
500    }
501
502    if( ( connect( s, (struct sockaddr *) &sock,
503                  addrlen ) < 0 )
504#ifdef WIN32
505      && ( sockerrno != WSAEWOULDBLOCK )
506#endif
507      && ( sockerrno != EINPROGRESS ) )
508    {
509        int tmperrno;
510        tmperrno = sockerrno;
511        if( ( tmperrno != ENETUNREACH && tmperrno != EHOSTUNREACH )
512                || addr->type == TR_AF_INET )
513            tr_err( _( "Couldn't connect socket %d to %s, port %d (errno %d - %s)" ),
514                    s, tr_ntop_non_ts( addr ), (int)port, tmperrno,
515                    tr_strerror( tmperrno ) );
516        tr_netClose( s );
517        s = -tmperrno;
518    }
519
520    tr_deepLog( __FILE__, __LINE__, NULL, "New OUTGOING connection %d (%s)",
521               s, tr_peerIoAddrStr( addr, port ) );
522
523    return s;
524}
525
526int
527tr_netBindTCP( const tr_address * addr, tr_port port, tr_bool suppressMsgs )
528{
529    int                     s;
530    struct sockaddr_storage sock;
531    const int               type = SOCK_STREAM;
532    int                     addrlen;
533    int                     retval;
534
535#if defined( SO_REUSEADDR ) || defined( SO_REUSEPORT ) || defined( IPV6_V6ONLY )
536    int                optval = 1;
537#endif
538
539    assert( tr_isAddress( addr ) );
540
541    if( ( s = createSocket( ( addr->type == TR_AF_INET ? AF_INET : AF_INET6 ),
542                            type ) ) < 0 )
543        return s;
544
545#ifdef SO_REUSEADDR
546    setsockopt( s, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, sizeof( optval ) );
547#endif
548
549#ifdef IPV6_V6ONLY
550    if( addr->type == TR_AF_INET6 && 
551        ( retval = setsockopt( s, IPPROTO_IPV6, IPV6_V6ONLY, &optval,
552                             sizeof( optval ) ) ) == -1 ) {
553        /* the kernel may not support this. if not, ignore it */
554        if( errno != ENOPROTOOPT )
555            return -errno;
556    }
557#endif
558
559    addrlen = setup_sockaddr( addr, htons( port ), &sock );
560
561    if( bind( s, (struct sockaddr *) &sock,
562             addrlen ) )
563    {
564        int tmperrno;
565        if( !suppressMsgs )
566            tr_err( _( "Couldn't bind port %d on %s: %s" ), port,
567                    tr_ntop_non_ts( addr ), tr_strerror( sockerrno ) );
568        tmperrno = sockerrno;
569        tr_netClose( s );
570        return -tmperrno;
571    }
572    if( !suppressMsgs )
573        tr_dbg(  "Bound socket %d to port %d on %s",
574                 s, port, tr_ntop_non_ts( addr ) );
575    return s;
576}
577
578int
579tr_netAccept( tr_session  * session,
580              int           b,
581              tr_address  * addr,
582              tr_port     * port )
583{
584    int fd;
585
586    fd = makeSocketNonBlocking( tr_fdSocketAccept( b, addr, port ) );
587    setSndBuf( session, fd );
588    return fd;
589}
590
591void
592tr_netClose( int s )
593{
594    tr_fdSocketClose( s );
595}
Note: See TracBrowser for help on using the repository browser.