23728658b4778472cb5056f84c11786bc5b31cdf
[vlc.git] / modules / misc / network / ipv4.c
1 /*****************************************************************************
2  * ipv4.c: IPv4 network abstraction layer
3  *****************************************************************************
4  * Copyright (C) 2001-2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
8  *          Mathias Kretschmer <mathias@research.att.com>
9  *          Alexis de Lattre <alexis@via.ecp.fr>
10  *          RĂ©mi Denis-Courmont <rem # videolan.org>
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include <vlc/vlc.h>
34 #include <errno.h>
35
36 #ifdef HAVE_SYS_TYPES_H
37 #   include <sys/types.h>
38 #endif
39 #ifdef HAVE_SYS_STAT_H
40 #   include <sys/stat.h>
41 #endif
42 #ifdef HAVE_FCNTL_H
43 #   include <fcntl.h>
44 #endif
45
46 #ifdef HAVE_UNISTD_H
47 #   include <unistd.h>
48 #endif
49
50 #if defined(WIN32) || defined(UNDER_CE)
51 #   if defined(UNDER_CE) && defined(sockaddr_storage)
52 #       undef sockaddr_storage
53 #   endif
54 #   include <winsock2.h>
55 #   include <ws2tcpip.h>
56 #   include <iphlpapi.h>
57 #   define close closesocket
58 #   if defined(UNDER_CE)
59 #       undef IP_MULTICAST_TTL
60 #       define IP_MULTICAST_TTL 3
61 #       undef IP_ADD_MEMBERSHIP
62 #       define IP_ADD_MEMBERSHIP 5
63 #   endif
64 #else
65 #   include <netdb.h>                                         /* hostent ... */
66 #   include <sys/socket.h>
67 #   include <netinet/in.h>
68 #   ifdef HAVE_ARPA_INET_H
69 #       include <arpa/inet.h>                    /* inet_ntoa(), inet_aton() */
70 #   endif
71 #endif
72
73 #include "network.h"
74
75 #ifndef INADDR_ANY
76 #   define INADDR_ANY  0x00000000
77 #endif
78 #ifndef INADDR_NONE
79 #   define INADDR_NONE 0xFFFFFFFF
80 #endif
81 #ifndef IN_MULTICAST
82 #   define IN_MULTICAST(a) IN_CLASSD(a)
83 #endif
84
85
86 /*****************************************************************************
87  * Local prototypes
88  *****************************************************************************/
89 static int OpenUDP( vlc_object_t * );
90
91 /*****************************************************************************
92  * Module descriptor
93  *****************************************************************************/
94 vlc_module_begin();
95     set_shortname( "IPv4" );
96     set_description( _("UDP/IPv4 network abstraction layer") );
97     set_capability( "network", 50 );
98     set_category( CAT_INPUT );
99     set_subcategory( SUBCAT_INPUT_GENERAL );
100     set_callbacks( OpenUDP, NULL );
101 vlc_module_end();
102
103 /*****************************************************************************
104  * BuildAddr: utility function to build a struct sockaddr_in
105  *****************************************************************************/
106 static int BuildAddr( struct sockaddr_in * p_socket,
107                       const char * psz_address, int i_port )
108 {
109     /* Reset struct */
110     memset( p_socket, 0, sizeof( struct sockaddr_in ) );
111     p_socket->sin_family = AF_INET;                                /* family */
112     p_socket->sin_port = htons( (uint16_t)i_port );
113     if( !*psz_address )
114     {
115         p_socket->sin_addr.s_addr = INADDR_ANY;
116     }
117     else
118     {
119         struct hostent    * p_hostent;
120
121         /* Try to convert address directly from in_addr - this will work if
122          * psz_address is dotted decimal. */
123 #ifdef HAVE_ARPA_INET_H
124         if( !inet_aton( psz_address, &p_socket->sin_addr ) )
125 #else
126         p_socket->sin_addr.s_addr = inet_addr( psz_address );
127         if( p_socket->sin_addr.s_addr == INADDR_NONE )
128 #endif
129         {
130             /* We have a fqdn, try to find its address */
131             if ( (p_hostent = gethostbyname( psz_address )) == NULL )
132             {
133                 return( -1 );
134             }
135
136             /* Copy the first address of the host in the socket address */
137             memcpy( &p_socket->sin_addr, p_hostent->h_addr_list[0],
138                      p_hostent->h_length );
139         }
140     }
141     return( 0 );
142 }
143
144 #if defined(WIN32) || defined(UNDER_CE)
145 # define WINSOCK_STRERROR_SIZE 20
146 static const char *winsock_strerror( char *buf )
147 {
148     snprintf( buf, WINSOCK_STRERROR_SIZE, "Winsock error %d",
149               WSAGetLastError( ) );
150     buf[WINSOCK_STRERROR_SIZE - 1] = '\0';
151     return buf;
152 }
153 #endif
154
155
156 /*****************************************************************************
157  * OpenUDP: open a UDP socket
158  *****************************************************************************
159  * psz_bind_addr, i_bind_port : address and port used for the bind()
160  *   system call. If psz_bind_addr == "", the socket is bound to
161  *   INADDR_ANY and broadcast reception is enabled. If psz_bind_addr is a
162  *   multicast (class D) address, join the multicast group.
163  * psz_server_addr, i_server_port : address and port used for the connect()
164  *   system call. It can avoid receiving packets from unauthorized IPs.
165  *   Its use leads to great confusion and is currently discouraged.
166  * This function returns -1 in case of error.
167  *****************************************************************************/
168 static int OpenUDP( vlc_object_t * p_this )
169 {
170     network_socket_t * p_socket = p_this->p_private;
171     const char * psz_bind_addr = p_socket->psz_bind_addr;
172     int i_bind_port = p_socket->i_bind_port;
173     const char * psz_server_addr = p_socket->psz_server_addr;
174     int i_server_port = p_socket->i_server_port;
175
176     int i_handle, i_opt;
177     struct sockaddr_in sock;
178     vlc_value_t val;
179 #if defined(WIN32) || defined(UNDER_CE)
180     char strerror_buf[WINSOCK_STRERROR_SIZE];
181 # define strerror( x ) winsock_strerror( strerror_buf )
182 #endif
183
184     /* If IP_ADD_SOURCE_MEMBERSHIP is not defined in the headers
185        (because it's not in glibc for example), we have to define the
186        headers required for IGMPv3 here */
187 #ifndef IP_ADD_SOURCE_MEMBERSHIP
188     #define IP_ADD_SOURCE_MEMBERSHIP  39
189     struct ip_mreq_source {
190         struct in_addr  imr_multiaddr;
191         struct in_addr  imr_interface;
192         struct in_addr  imr_sourceaddr;
193      };
194 #endif
195
196     p_socket->i_handle = -1;
197
198     /* Open a SOCK_DGRAM (UDP) socket, in the AF_INET domain, automatic (0)
199      * protocol */
200     if( (i_handle = socket( AF_INET, SOCK_DGRAM, 0 )) == -1 )
201     {
202         msg_Warn( p_this, "cannot create socket (%s)", strerror(errno) );
203         return 0;
204     }
205
206     /* We may want to reuse an already used socket */
207     i_opt = 1;
208     if( setsockopt( i_handle, SOL_SOCKET, SO_REUSEADDR,
209                     (void *) &i_opt, sizeof( i_opt ) ) == -1 )
210     {
211         msg_Warn( p_this, "cannot configure socket (SO_REUSEADDR: %s)",
212                           strerror(errno));
213         close( i_handle );
214         return 0;
215     }
216
217 #ifdef SO_REUSEPORT
218     i_opt = 1;
219     if( setsockopt( i_handle, SOL_SOCKET, SO_REUSEPORT,
220                     (void *) &i_opt, sizeof( i_opt ) ) == -1 )
221     {
222         msg_Warn( p_this, "cannot configure socket (SO_REUSEPORT)" );
223     }
224 #endif
225
226     /* Increase the receive buffer size to 1/2MB (8Mb/s during 1/2s) to avoid
227      * packet loss caused by scheduling problems */
228 #if !defined( SYS_BEOS )
229     i_opt = 0x80000;
230     if( setsockopt( i_handle, SOL_SOCKET, SO_RCVBUF, (void *) &i_opt,
231                     sizeof( i_opt ) ) == -1 )
232         msg_Dbg( p_this, "cannot configure socket (SO_RCVBUF: %s)",
233                           strerror(errno));
234     i_opt = 0x80000;
235     if( setsockopt( i_handle, SOL_SOCKET, SO_SNDBUF, (void *) &i_opt,
236                     sizeof( i_opt ) ) == -1 )
237         msg_Dbg( p_this, "cannot configure socket (SO_SNDBUF: %s)",
238                           strerror(errno));
239 #endif
240
241     /* Build the local socket */
242
243 #if defined( WIN32 ) || defined( UNDER_CE )
244     /* Under Win32 and for multicasting, we bind to INADDR_ANY,
245      * so let's call BuildAddr with "" instead of psz_bind_addr */
246     if( BuildAddr( &sock, IN_MULTICAST( ntohl( inet_addr(psz_bind_addr) ) ) ?
247                    "" : psz_bind_addr, i_bind_port ) == -1 )
248 #else
249     if( BuildAddr( &sock, psz_bind_addr, i_bind_port ) == -1 )
250 #endif
251     {
252         msg_Dbg( p_this, "could not build local address" );
253         close( i_handle );
254         return 0;
255     }
256
257     /* Bind it */
258     if( bind( i_handle, (struct sockaddr *)&sock, sizeof( sock ) ) < 0 )
259     {
260         msg_Warn( p_this, "cannot bind socket (%s)", strerror(errno) );
261         close( i_handle );
262         return 0;
263     }
264
265 #if defined( WIN32 ) || defined( UNDER_CE )
266     /* Restore the sock struct so we can spare a few #ifdef WIN32 later on */
267     if( IN_MULTICAST( ntohl( inet_addr(psz_bind_addr) ) ) )
268     {
269         if ( BuildAddr( &sock, psz_bind_addr, i_bind_port ) == -1 )
270         {
271             msg_Dbg( p_this, "could not build local address" );
272             close( i_handle );
273             return 0;
274         }
275     }
276 #endif
277
278 #if !defined( SYS_BEOS )
279     /* Allow broadcast reception if we bound on INADDR_ANY */
280     if( !*psz_bind_addr )
281     {
282         i_opt = 1;
283         if( setsockopt( i_handle, SOL_SOCKET, SO_BROADCAST, (void*) &i_opt,
284                         sizeof( i_opt ) ) == -1 )
285             msg_Warn( p_this, "cannot configure socket (SO_BROADCAST: %s)",
286                        strerror(errno) );
287     }
288 #endif
289
290 #if !defined( SYS_BEOS )
291     /* Join the multicast group if the socket is a multicast address */
292     if( IN_MULTICAST( ntohl(sock.sin_addr.s_addr) ) )
293     {
294         /* Determine interface to be used for multicast */
295         char * psz_if_addr = config_GetPsz( p_this, "miface-addr" );
296
297         /* If we have a source address, we use IP_ADD_SOURCE_MEMBERSHIP
298            so that IGMPv3 aware OSes running on IGMPv3 aware networks
299            will do an IGMPv3 query on the network */
300         if( *psz_server_addr )
301         {
302             struct ip_mreq_source imr;
303
304             imr.imr_multiaddr.s_addr = sock.sin_addr.s_addr;
305             imr.imr_sourceaddr.s_addr = inet_addr(psz_server_addr);
306
307             if( psz_if_addr != NULL && *psz_if_addr
308                 && inet_addr(psz_if_addr) != INADDR_NONE )
309             {
310                 imr.imr_interface.s_addr = inet_addr(psz_if_addr);
311             }
312             else
313             {
314                 imr.imr_interface.s_addr = INADDR_ANY;
315             }
316             if( psz_if_addr != NULL ) free( psz_if_addr );
317
318             msg_Dbg( p_this, "IP_ADD_SOURCE_MEMBERSHIP multicast request" );
319             /* Join Multicast group with source filter */
320             if( setsockopt( i_handle, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP,
321                          (char*)&imr,
322                          sizeof(struct ip_mreq_source) ) == -1 )
323             {
324                 msg_Err( p_this, "failed to join IP multicast group (%s)",
325                                   strerror(errno) );
326                 msg_Err( p_this, "are you sure your OS supports IGMPv3?" );
327                 close( i_handle );
328                 return 0;
329             }
330          }
331          /* If there is no source address, we use IP_ADD_MEMBERSHIP */
332          else
333          {
334              struct ip_mreq imr;
335
336              imr.imr_interface.s_addr = INADDR_ANY;
337              imr.imr_multiaddr.s_addr = sock.sin_addr.s_addr;
338              if( psz_if_addr != NULL && *psz_if_addr
339                 && inet_addr(psz_if_addr) != INADDR_NONE )
340             {
341                 imr.imr_interface.s_addr = inet_addr(psz_if_addr);
342             }
343 #if defined (WIN32) || defined (UNDER_CE)
344             else
345             {
346                 typedef DWORD (CALLBACK * GETBESTINTERFACE) ( IPAddr, PDWORD );
347                 typedef DWORD (CALLBACK * GETIPADDRTABLE) ( PMIB_IPADDRTABLE, PULONG, BOOL );
348
349                 GETBESTINTERFACE OurGetBestInterface;
350                 GETIPADDRTABLE OurGetIpAddrTable;
351                 HINSTANCE hiphlpapi = LoadLibrary(_T("Iphlpapi.dll"));
352                 DWORD i_index;
353
354                 if( hiphlpapi )
355                 {
356                     OurGetBestInterface =
357                         (void *)GetProcAddress( hiphlpapi,
358                                                 _T("GetBestInterface") );
359                     OurGetIpAddrTable =
360                         (void *)GetProcAddress( hiphlpapi,
361                                                 _T("GetIpAddrTable") );
362                 }
363
364                 if( hiphlpapi && OurGetBestInterface && OurGetIpAddrTable &&
365                     OurGetBestInterface( sock.sin_addr.s_addr,
366                                          &i_index ) == NO_ERROR )
367                 {
368                     PMIB_IPADDRTABLE p_table;
369                     DWORD i = 0;
370
371                     msg_Dbg( p_this, "Winsock best interface is %lu",
372                              (unsigned long)i_index );
373                     OurGetIpAddrTable( NULL, &i, 0 );
374
375                     p_table = (PMIB_IPADDRTABLE)malloc( i );
376                     if( p_table != NULL )
377                     {
378                         if( OurGetIpAddrTable( p_table, &i, 0 ) == NO_ERROR )
379                         {
380                             for( i = 0; i < p_table->dwNumEntries; i-- )
381                             {
382                                 if( p_table->table[i].dwIndex == i_index )
383                                 {
384                                     imr.imr_interface.s_addr =
385                                                      p_table->table[i].dwAddr;
386                                     msg_Dbg( p_this, "using interface 0x%08x",
387                                              p_table->table[i].dwAddr );
388                                 }
389                             }
390                         }
391                         else msg_Warn( p_this, "GetIpAddrTable failed" );
392                         free( p_table );
393                     }
394                 }
395                 else msg_Dbg( p_this, "GetBestInterface failed" );
396
397                 if( hiphlpapi ) FreeLibrary( hiphlpapi );
398             }
399 #endif
400             if( psz_if_addr != NULL ) free( psz_if_addr );
401
402             msg_Dbg( p_this, "IP_ADD_MEMBERSHIP multicast request" );
403             /* Join Multicast group without source filter */
404             if( setsockopt( i_handle, IPPROTO_IP, IP_ADD_MEMBERSHIP,
405                             (char*)&imr, sizeof(struct ip_mreq) ) == -1 )
406             {
407                 msg_Err( p_this, "failed to join IP multicast group (%s)",
408                                   strerror(errno) );
409                 close( i_handle );
410                 return 0;
411             }
412          }
413     }
414     else
415 #endif
416     if( *psz_server_addr )
417     {
418         /* Build socket for remote connection */
419         if ( BuildAddr( &sock, psz_server_addr, i_server_port ) == -1 )
420         {
421             msg_Warn( p_this, "cannot build remote address" );
422             close( i_handle );
423             return 0;
424         }
425
426         /* Connect the socket */
427         if( connect( i_handle, (struct sockaddr *) &sock,
428                      sizeof( sock ) ) == (-1) )
429         {
430             msg_Warn( p_this, "cannot connect socket (%s)", strerror(errno) );
431             close( i_handle );
432             return 0;
433         }
434
435 #if !defined( SYS_BEOS )
436         if( IN_MULTICAST( ntohl(inet_addr(psz_server_addr) ) ) )
437         {
438             /* set the time-to-live */
439             int i_ttl = p_socket->i_ttl;
440
441             /* set the multicast interface */
442             char * psz_mif_addr = config_GetPsz( p_this, "miface-addr" );
443             if( psz_mif_addr )
444             {
445                 struct in_addr intf;
446                 intf.s_addr = inet_addr(psz_mif_addr);
447                 free( psz_mif_addr  );
448
449                 if( setsockopt( i_handle, IPPROTO_IP, IP_MULTICAST_IF,
450                                 &intf, sizeof( intf ) ) < 0 )
451                 {
452                     msg_Dbg( p_this, "failed to set multicast interface (%s).", strerror(errno) );
453                     close( i_handle );
454                     return 0;
455                 }
456             }
457
458             if( i_ttl <= 0 )
459                 i_ttl = config_GetInt( p_this, "ttl" );
460
461             if( i_ttl > 0 )
462             {
463                 unsigned char ttl = (unsigned char) i_ttl;
464
465                 /* There is some confusion in the world whether IP_MULTICAST_TTL 
466                 * takes a byte or an int as an argument.
467                 * BSD seems to indicate byte so we are going with that and use
468                 * int as a fallback to be safe */
469                 if( setsockopt( i_handle, IPPROTO_IP, IP_MULTICAST_TTL,
470                                 &ttl, sizeof( ttl ) ) < 0 )
471                 {
472                     msg_Dbg( p_this, "failed to set ttl (%s). Let's try it "
473                             "the integer way.", strerror(errno) );
474                     if( setsockopt( i_handle, IPPROTO_IP, IP_MULTICAST_TTL,
475                                     &i_ttl, sizeof( i_ttl ) ) <0 )
476                     {
477                         msg_Err( p_this, "failed to set ttl (%s)",
478                                 strerror(errno) );
479                         close( i_handle );
480                         return 0;
481                     }
482                 }
483             }
484         }
485 #endif
486     }
487
488     p_socket->i_handle = i_handle;
489
490     if( var_Get( p_this, "mtu", &val ) != VLC_SUCCESS )
491     {
492         var_Create( p_this, "mtu", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
493         var_Get( p_this, "mtu", &val );
494     }
495     p_socket->i_mtu = val.i_int;
496
497     return 0;
498 }