source: trunk/libtransmission/net.c @ 8407

Last change on this file since 8407 was 8407, checked in by charles, 13 years ago

(trunk libT) fix a minor bug in peer count tabulation

  • Property svn:keywords set to Date Rev Author Id
File size: 11.6 KB
Line 
1/******************************************************************************
2 * $Id: net.c 8407 2009-05-15 12:19:27Z charles $
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#include <unistd.h>
42
43#include <evutil.h>
44
45#include "transmission.h"
46#include "fdlimit.h"
47#include "natpmp.h"
48#include "net.h"
49#include "peer-io.h"
50#include "platform.h"
51#include "session.h"
52#include "utils.h"
53
54#ifndef IN_MULTICAST
55#define IN_MULTICAST( a ) ( ( ( a ) & 0xf0000000 ) == 0xe0000000 )
56#endif
57
58const tr_address tr_in6addr_any = { TR_AF_INET6, { IN6ADDR_ANY_INIT } }; 
59const tr_address tr_inaddr_any = { TR_AF_INET, { { { { INADDR_ANY, 0x00, 0x00, 0x00 } } } } }; 
60
61#ifdef WIN32
62static const char *
63inet_ntop( int af, const void *src, char *dst, socklen_t cnt )
64{
65    if (af == AF_INET)
66    {
67        struct sockaddr_in in;
68        memset( &in, 0, sizeof( in ) );
69        in.sin_family = AF_INET;
70        memcpy( &in.sin_addr, src, sizeof( struct in_addr ) );
71        getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in),
72                    dst, cnt, NULL, 0, NI_NUMERICHOST);
73        return dst;
74    }
75    else if (af == AF_INET6)
76    {
77        struct sockaddr_in6 in;
78        memset( &in, 0, sizeof( in ) );
79        in.sin6_family = AF_INET6;
80        memcpy( &in.sin6_addr, src, sizeof( struct in_addr6 ) );
81        getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in6),
82                    dst, cnt, NULL, 0, NI_NUMERICHOST);
83        return dst;
84    }
85    return NULL;
86}
87
88static int
89inet_pton(int af, const char *src, void *dst)
90{
91    struct addrinfo hints;
92    struct addrinfo *res;
93    struct addrinfo *ressave;
94
95    memset(&hints, 0, sizeof(struct addrinfo));
96    hints.ai_family = af;
97
98    if (getaddrinfo(src, NULL, &hints, &res) != 0)
99        return -1;
100
101    ressave = res;
102
103    while (res)
104    {
105        memcpy(dst, res->ai_addr, res->ai_addrlen);
106        res = res->ai_next;
107    }
108
109    freeaddrinfo(ressave);
110    return 0;
111}
112
113#endif
114
115
116void
117tr_netInit( void )
118{
119    static int initialized = FALSE;
120
121    if( !initialized )
122    {
123#ifdef WIN32
124        WSADATA wsaData;
125        WSAStartup( MAKEWORD( 2, 2 ), &wsaData );
126#endif
127        initialized = TRUE;
128    }
129}
130
131const char * 
132tr_ntop( const tr_address * src, char * dst, int size ) 
133{
134    assert( tr_isAddress( src ) );
135
136    if( src->type == TR_AF_INET ) 
137        return inet_ntop( AF_INET, &src->addr, dst, size ); 
138    else 
139        return inet_ntop( AF_INET6, &src->addr, dst, size ); 
140} 
141
142/*
143 * Non-threadsafe version of tr_ntop, which uses a static memory area for a buffer.
144 * This function is suitable to be called from libTransmission's networking code,
145 * which is single-threaded.
146 */ 
147const char * 
148tr_ntop_non_ts( const tr_address * src ) 
149{ 
150    static char buf[INET6_ADDRSTRLEN]; 
151    return tr_ntop( src, buf, sizeof( buf ) ); 
152} 
153
154tr_address * 
155tr_pton( const char * src, tr_address * dst ) 
156{ 
157    int retval = inet_pton( AF_INET, src, &dst->addr ); 
158    assert( dst );
159    if( retval < 0 ) 
160        return NULL; 
161    else if( retval == 0 ) 
162        retval = inet_pton( AF_INET6, src, &dst->addr ); 
163    else
164    { 
165        dst->type = TR_AF_INET; 
166        return dst; 
167    } 
168
169    if( retval < 1 ) 
170        return NULL; 
171    dst->type = TR_AF_INET6; 
172    return dst; 
173}
174
175/*
176 * Compare two tr_address structures.
177 * Returns:
178 * <0 if a < b
179 * >0 if a > b
180 * 0  if a == b
181 */ 
182int
183tr_compareAddresses( const tr_address * a, const tr_address * b)
184{
185    static const int sizes[2] = { sizeof(struct in_addr), sizeof(struct in6_addr) };
186
187    assert( tr_isAddress( a ) );
188    assert( tr_isAddress( b ) );
189
190    /* IPv6 addresses are always "greater than" IPv4 */ 
191    if( a->type != b->type )
192        return a->type == TR_AF_INET ? 1 : -1;
193
194    return memcmp( &a->addr, &b->addr, sizes[a->type] );
195} 
196
197tr_bool
198tr_net_hasIPv6( tr_port port )
199{
200    static tr_bool result = FALSE;
201    static tr_bool alreadyDone = FALSE;
202
203    if( !alreadyDone )
204    {
205        int fd = tr_netBindTCP( &tr_in6addr_any, port, TRUE );
206        if( fd >= 0 || -fd != EAFNOSUPPORT ) /* we support ipv6 */
207            result = TRUE;
208        if( fd >= 0 )
209            EVUTIL_CLOSESOCKET( fd );
210        alreadyDone = TRUE;
211    }
212
213    return result;
214}
215
216/***********************************************************************
217 * TCP sockets
218 **********************************************************************/
219
220int
221tr_netSetTOS( int s, int tos )
222{
223#ifdef IP_TOS
224    return setsockopt( s, IPPROTO_IP, IP_TOS, (char*)&tos, sizeof( tos ) );
225#else
226    return 0;
227#endif
228}
229
230static socklen_t
231setup_sockaddr( const tr_address        * addr,
232                tr_port                   port,
233                struct sockaddr_storage * sockaddr)
234{
235    assert( tr_isAddress( addr ) );
236
237    if( addr->type == TR_AF_INET )
238    {
239        struct sockaddr_in  sock4;
240        memset( &sock4, 0, sizeof( sock4 ) );
241        sock4.sin_family      = AF_INET;
242        sock4.sin_addr.s_addr = addr->addr.addr4.s_addr;
243        sock4.sin_port        = port;
244        memcpy( sockaddr, &sock4, sizeof( sock4 ) );
245        return sizeof( struct sockaddr_in );
246    }
247    else
248    {
249        struct sockaddr_in6 sock6;
250        memset( &sock6, 0, sizeof( sock6 ) );
251        sock6.sin6_family   = AF_INET6;
252        sock6.sin6_port     = port;
253        sock6.sin6_flowinfo = 0;
254        sock6.sin6_addr     = addr->addr.addr6;
255        memcpy( sockaddr, &sock6, sizeof( sock6 ) );
256        return sizeof( struct sockaddr_in6 );
257    }
258}
259
260static tr_bool
261isMulticastAddress( const tr_address * addr )
262{
263    if( addr->type == TR_AF_INET && IN_MULTICAST( htonl( addr->addr.addr4.s_addr ) ) )
264        return TRUE;
265
266    if( addr->type == TR_AF_INET6 && ( addr->addr.addr6.s6_addr[0] == 0xff ) )
267        return TRUE;
268
269    return FALSE;
270}
271
272static TR_INLINE tr_bool
273isIPv4MappedOrCompatAddress( const tr_address * addr )
274{
275    if( addr->type == TR_AF_INET6 )
276    {
277        if( IN6_IS_ADDR_V4MAPPED( &addr->addr.addr6 ) ||
278            IN6_IS_ADDR_V4COMPAT( &addr->addr.addr6 ) )
279            return TRUE;
280    }
281    return FALSE;
282}
283
284static TR_INLINE tr_bool
285isIPv6LinkLocalAddress( const tr_address * addr )
286{
287    if( addr->type == TR_AF_INET6 &&
288        IN6_IS_ADDR_LINKLOCAL( &addr->addr.addr6 ) )
289        return TRUE;
290    return FALSE;
291}
292
293tr_bool
294tr_isValidPeerAddress( const tr_address * addr, tr_port port )
295{
296    if( isMulticastAddress( addr ) || isIPv6LinkLocalAddress( addr ) ||
297        isIPv4MappedOrCompatAddress( addr ) )
298        return FALSE;
299
300    if( port == 0 )
301        return FALSE;
302
303    return TRUE;
304}
305
306int
307tr_netOpenTCP( tr_session        * session,
308               const tr_address  * addr,
309               tr_port             port )
310{
311    static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
312    int                     s;
313    struct sockaddr_storage sock;
314    socklen_t               addrlen;
315    const tr_address      * source_addr;
316    socklen_t               sourcelen;
317    struct sockaddr_storage source_sock;
318
319    assert( tr_isAddress( addr ) );
320
321    if( isMulticastAddress( addr ) || isIPv6LinkLocalAddress( addr ) )
322        return -EINVAL;
323
324    s = tr_fdSocketCreate( domains[addr->type], SOCK_STREAM );
325    if( s < 0 )
326        return -1;
327
328    if( evutil_make_socket_nonblocking( s ) < 0 ) {
329        tr_netClose( s );
330        return -1;
331    }
332
333    addrlen = setup_sockaddr( addr, port, &sock );
334   
335    /* set source address */
336    source_addr = tr_sessionGetPublicAddress( session, addr->type );
337    assert( source_addr );
338    sourcelen = setup_sockaddr( source_addr, 0, &source_sock );
339    if( bind( s, ( struct sockaddr * ) &source_sock, sourcelen ) )
340    {
341        tr_err( _( "Couldn't set source address %s on %d: %s" ),
342                tr_ntop_non_ts( source_addr ), s, tr_strerror( errno ) );
343        return -errno;
344    }
345
346    if( ( connect( s, (struct sockaddr *) &sock,
347                  addrlen ) < 0 )
348#ifdef WIN32
349      && ( sockerrno != WSAEWOULDBLOCK )
350#endif
351      && ( sockerrno != EINPROGRESS ) )
352    {
353        int tmperrno;
354        tmperrno = sockerrno;
355        if( ( tmperrno != ENETUNREACH && tmperrno != EHOSTUNREACH )
356                || addr->type == TR_AF_INET )
357            tr_err( _( "Couldn't connect socket %d to %s, port %d (errno %d - %s)" ),
358                    s, tr_ntop_non_ts( addr ), (int)port, tmperrno,
359                    tr_strerror( tmperrno ) );
360        tr_netClose( s );
361        s = -tmperrno;
362    }
363
364    tr_deepLog( __FILE__, __LINE__, NULL, "New OUTGOING connection %d (%s)",
365               s, tr_peerIoAddrStr( addr, port ) );
366
367    return s;
368}
369
370int
371tr_netBindTCP( const tr_address * addr, tr_port port, tr_bool suppressMsgs )
372{
373    static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
374    struct sockaddr_storage sock;
375    int fd;
376    int addrlen;
377    int optval;
378
379    assert( tr_isAddress( addr ) );
380
381    fd = socket( domains[addr->type], SOCK_STREAM, 0 );
382    if( fd < 0 )
383        return -1;
384
385    if( evutil_make_socket_nonblocking( fd ) < 0 ) {
386        EVUTIL_CLOSESOCKET( fd );
387        return -1;
388    }
389
390    optval = 1;
391    setsockopt( fd, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval) );
392    setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval) );
393
394#ifdef IPV6_V6ONLY
395    if( addr->type == TR_AF_INET6 )
396        if( setsockopt( fd, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof( optval ) ) == -1 )
397            if( sockerr != ENOPROTOOPT ) /* if the kernel doesn't support it, ignore it */
398                return -sockerr;
399#endif
400
401    addrlen = setup_sockaddr( addr, htons( port ), &sock );
402    if( bind( fd, (struct sockaddr *) &sock, addrlen ) ) {
403        const int err = sockerr;
404        if( !suppressMsgs )
405            tr_err( _( "Couldn't bind port %d on %s: %s" ),
406                    port, tr_ntop_non_ts( addr ), tr_strerror( err ) );
407        EVUTIL_CLOSESOCKET( fd );
408        return -err;
409    }
410
411    if( !suppressMsgs )
412        tr_dbg( "Bound socket %d to port %d on %s", fd, port, tr_ntop_non_ts( addr ) );
413
414    if( listen( fd, 128 ) == -1 ) {
415        EVUTIL_CLOSESOCKET( fd );
416        return -sockerr;
417    }
418
419    return fd;
420}
421
422int
423tr_netAccept( tr_session  * session UNUSED,
424              int           b,
425              tr_address  * addr,
426              tr_port     * port )
427{
428    int fd = tr_fdSocketAccept( b, addr, port );
429
430    if( fd>=0 && evutil_make_socket_nonblocking(fd)<0 ) {
431        tr_netClose( fd );
432        fd = -1;
433    }
434
435    return fd;
436}
437
438void
439tr_netClose( int s )
440{
441    tr_fdSocketClose( s );
442}
Note: See TracBrowser for help on using the repository browser.