git.sesse.net Git - vlc/blob - plugins/network/ipv6.c

   1 /*****************************************************************************
   2  * ipv6.c: IPv6 network abstraction layer
   3  *****************************************************************************
   4  * Copyright (C) 2002 VideoLAN
   5  * $Id: ipv6.c,v 1.8.2.3 2002/07/29 16:15:49 gbazin Exp $
   6  *
   7  * Authors: Alexis Guillard <alexis.guillard@bt.com>
   8  *          Christophe Massiot <massiot@via.ecp.fr>
   9  *          Remco Poortinga <poortinga@telin.nl>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #include <stdlib.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35
  36 #include <videolan/vlc.h>
  37
  38 #ifdef HAVE_UNISTD_H
  39 #   include <unistd.h>
  40 #elif defined( _MSC_VER ) && defined( _WIN32 )
  41 #   include <io.h>
  42 #endif
  43
  44 #ifdef WIN32
  45 #   include <winsock2.h>
  46 #   include <ws2tcpip.h>
  47 #elif !defined( SYS_BEOS ) && !defined( SYS_NTO )
  48 #   include <netdb.h>                                         /* hostent ... */
  49 #   include <sys/socket.h>
  50 #   include <netinet/in.h>
  51 #   ifdef HAVE_ARPA_INET_H
  52 #       include <arpa/inet.h>                    /* inet_ntoa(), inet_aton() */
  53 #   endif
  54 #endif
  55
  56 #include "network.h"
  57
  58 #if defined(WIN32)
  59 static const struct in6_addr in6addr_any = {{IN6ADDR_ANY_INIT}};
  60 /* the following will have to be removed when w32api defines them */
  61 #ifndef IPPROTO_IPV6
  62 #   define IPPROTO_IPV6 41
  63 #endif
  64 #ifndef IPV6_JOIN_GROUP
  65 #   define IPV6_JOIN_GROUP 20
  66 #endif
  67 #endif
  68
  69 /*****************************************************************************
  70  * Local prototypes
  71  *****************************************************************************/
  72 static void getfunctions( function_list_t * );
  73 static int  NetworkOpen( struct network_socket_s * );
  74
  75 /*****************************************************************************
  76  * Build configuration tree.
  77  *****************************************************************************/
  78 MODULE_CONFIG_START
  79 MODULE_CONFIG_STOP
  80
  81 MODULE_INIT_START
  82     SET_DESCRIPTION( _("IPv6 network abstraction layer") )
  83     ADD_CAPABILITY( NETWORK, 40 )
  84     ADD_SHORTCUT( "ipv6" )
  85 MODULE_INIT_STOP
  86
  87 MODULE_ACTIVATE_START
  88     getfunctions( &p_module->p_functions->network );
  89 MODULE_ACTIVATE_STOP
  90
  91 MODULE_DEACTIVATE_START
  92 MODULE_DEACTIVATE_STOP
  93
  94 /*****************************************************************************
  95  * Functions exported as capabilities. They are declared as static so that
  96  * we don't pollute the namespace too much.
  97  *****************************************************************************/
  98 static void getfunctions( function_list_t * p_function_list )
  99 {
 100 #define f p_function_list->functions.network
 101     f.pf_open = NetworkOpen;
 102 #undef f
 103 }
 104
 105 /*****************************************************************************
 106  * BuildAddr: utility function to build a struct sockaddr_in6
 107  *****************************************************************************/
 108 static int BuildAddr( struct sockaddr_in6 * p_socket,
 109                       char * psz_address, int i_port )
 110 {
 111     char * psz_multicast_interface = "";
 112
 113 #if defined(WIN32)
 114     /* Try to get getaddrinfo() and freeaddrinfo() from wship6.dll */
 115     typedef int (CALLBACK * GETADDRINFO) ( const char *nodename,
 116                                             const char *servname,
 117                                             const struct addrinfo *hints,
 118                                             struct addrinfo **res );
 119     typedef void (CALLBACK * FREEADDRINFO) ( struct addrinfo FAR *ai );
 120
 121     struct addrinfo hints, *res;
 122     GETADDRINFO _getaddrinfo = NULL;
 123     FREEADDRINFO _freeaddrinfo = NULL;
 124
 125     HINSTANCE wship6_dll = LoadLibrary("wship6.dll");
 126     if( wship6_dll )
 127     {
 128         _getaddrinfo = (GETADDRINFO) GetProcAddress( wship6_dll,
 129                                                      "getaddrinfo" );
 130         _freeaddrinfo = (FREEADDRINFO) GetProcAddress( wship6_dll,
 131                                                        "freeaddrinfo" );
 132     }
 133     if( !_getaddrinfo || !_freeaddrinfo )
 134     {
 135         intf_ErrMsg( "ipv6 error: no IPv6 stack installed" );
 136         if( wship6_dll ) FreeLibrary( wship6_dll );
 137         return( -1 );
 138     }
 139 #endif
 140
 141     /* Reset struct */
 142     memset( p_socket, 0, sizeof( struct sockaddr_in6 ) );
 143     p_socket->sin6_family = AF_INET6;                              /* family */
 144     p_socket->sin6_port = htons( i_port );
 145     if( !*psz_address )
 146     {
 147         p_socket->sin6_addr = in6addr_any;
 148     }
 149     else if( psz_address[0] == '['
 150               && psz_address[strlen(psz_address) - 1] == ']' )
 151     {
 152         psz_address++;
 153         /* see if there is an interface name in there... */
 154         if( (psz_multicast_interface = strchr(psz_address, '%')) != NULL )
 155         {
 156             *psz_multicast_interface = '\0';
 157             psz_multicast_interface++;
 158             intf_WarnMsg( 3, "Interface name specified: \"%s\"",
 159                           psz_multicast_interface );
 160             /* now convert that interface name to an index */
 161 #if !defined( WIN32 )
 162             p_socket->sin6_scope_id = if_nametoindex(psz_multicast_interface);
 163 #else
 164             /* FIXME: for now we always use the default interface */
 165             p_socket->sin6_scope_id = 0;
 166             intf_WarnMsg( 3, "Using default interface. This has to be FIXED!");
 167 #endif
 168             intf_WarnMsg( 3, " = #%i\n", p_socket->sin6_scope_id );
 169         }
 170         psz_address[strlen(psz_address) - 1] = '\0' ;
 171
 172 #if !defined( WIN32 )
 173         inet_pton(AF_INET6, psz_address, &p_socket->sin6_addr.s6_addr);
 174
 175 #else
 176         memset(&hints, 0, sizeof(hints));
 177         hints.ai_family = AF_INET6;
 178         hints.ai_flags = AI_NUMERICHOST;
 179
 180         if( _getaddrinfo( psz_address, NULL, &hints, &res ) )
 181         {
 182             FreeLibrary( wship6_dll );
 183             return( -1 );
 184         }
 185         memcpy( &p_socket->sin6_addr,
 186                 &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr,
 187                 sizeof(struct in6_addr) );
 188         _freeaddrinfo( res );
 189
 190 #endif
 191     }
 192     else
 193     {
 194 #ifdef HAVE_GETHOSTBYNAME2
 195         struct hostent    * p_hostent;
 196
 197         /* We have a fqdn, try to find its address */
 198         if ( (p_hostent = gethostbyname2( psz_address, AF_INET6 )) == NULL )
 199         {
 200             intf_ErrMsg( "ipv6 error: unknown host %s", psz_address );
 201             return( -1 );
 202         }
 203
 204         /* Copy the first address of the host in the socket address */
 205         memcpy( &p_socket->sin6_addr, p_hostent->h_addr_list[0],
 206                  p_hostent->h_length );
 207
 208 #elif defined(WIN32)
 209         if( _getaddrinfo( psz_address, NULL, &hints, &res ) )
 210         {
 211             FreeLibrary( wship6_dll );
 212             return( -1 );
 213         }
 214         memcpy( &p_socket->sin6_addr,
 215                 &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr,
 216                 sizeof(struct in6_addr) );
 217         _freeaddrinfo( res );
 218
 219 #else
 220         intf_ErrMsg( "ipv6 error: IPv6 address %s is invalid", psz_address );
 221         return( -1 );
 222 #endif
 223     }
 224
 225 #if defined(WIN32)
 226     FreeLibrary( wship6_dll );
 227 #endif
 228
 229     return( 0 );
 230 }
 231
 232 /*****************************************************************************
 233  * OpenUDP: open a UDP socket
 234  *****************************************************************************
 235  * psz_bind_addr, i_bind_port : address and port used for the bind()
 236  *   system call. If psz_bind_addr == NULL, the socket is bound to
 237  *   in6addr_any and broadcast reception is enabled. If i_bind_port == 0,
 238  *   1234 is used. If psz_bind_addr is a multicast (class D) address,
 239  *   join the multicast group.
 240  * psz_server_addr, i_server_port : address and port used for the connect()
 241  *   system call. It can avoid receiving packets from unauthorized IPs.
 242  *   Its use leads to great confusion and is currently discouraged.
 243  * This function returns -1 in case of error.
 244  *****************************************************************************/
 245 static int OpenUDP( network_socket_t * p_socket )
 246 {
 247     char * psz_bind_addr = p_socket->psz_bind_addr;
 248     int i_bind_port = p_socket->i_bind_port;
 249     char * psz_server_addr = p_socket->psz_server_addr;
 250     int i_server_port = p_socket->i_server_port;
 251
 252     int i_handle, i_opt, i_opt_size;
 253     struct sockaddr_in6 sock;
 254
 255     if( i_bind_port == 0 )
 256     {
 257         i_bind_port = config_GetIntVariable( "server-port" );
 258     }
 259
 260     /* Open a SOCK_DGRAM (UDP) socket, in the AF_INET6 domain, automatic (0)
 261      * protocol */
 262     if( (i_handle = socket( AF_INET6, SOCK_DGRAM, 0 )) == -1 )
 263     {
 264         intf_ErrMsg( "ipv6 error: cannot create socket (%s)", strerror(errno) );
 265         return( -1 );
 266     }
 267
 268     /* We may want to reuse an already used socket */
 269     i_opt = 1;
 270     if( setsockopt( i_handle, SOL_SOCKET, SO_REUSEADDR,
 271                     (void *) &i_opt, sizeof( i_opt ) ) == -1 )
 272     {
 273         intf_ErrMsg( "ipv6 error: cannot configure socket (SO_REUSEADDR: %s)",
 274                      strerror(errno));
 275         close( i_handle );
 276         return( -1 );
 277     }
 278
 279     /* Increase the receive buffer size to 1/2MB (8Mb/s during 1/2s) to avoid
 280      * packet loss caused by scheduling problems */
 281     i_opt = 0x80000;
 282     if( setsockopt( i_handle, SOL_SOCKET, SO_RCVBUF,
 283                     (void *) &i_opt, sizeof( i_opt ) ) == -1 )
 284     {
 285         intf_WarnMsg( 1,
 286                       "ipv6 warning: cannot configure socket (SO_RCVBUF: %s)",
 287                       strerror(errno));
 288     }
 289
 290     /* Check if we really got what we have asked for, because Linux, etc.
 291      * will silently limit the max buffer size to net.core.rmem_max which
 292      * is typically only 65535 bytes */
 293     i_opt = 0;
 294     i_opt_size = sizeof( i_opt );
 295     if( getsockopt( i_handle, SOL_SOCKET, SO_RCVBUF,
 296                     (void*) &i_opt, &i_opt_size ) == -1 )
 297     {
 298         intf_WarnMsg( 1, "ipv6 warning: cannot query socket (SO_RCVBUF: %s)",
 299                          strerror(errno));
 300     }
 301     else if( i_opt < 0x80000 )
 302     {
 303         intf_WarnMsg( 1, "ipv6 warning: socket buffer size is 0x%x"
 304                          " instead of 0x%x", i_opt, 0x80000 );
 305     }
 306
 307     /* Build the local socket */
 308     if ( BuildAddr( &sock, psz_bind_addr, i_bind_port ) == -1 )
 309     {
 310         close( i_handle );
 311         return( -1 );
 312     }
 313
 314     /* Bind it */
 315     if( bind( i_handle, (struct sockaddr *)&sock, sizeof( sock ) ) < 0 )
 316     {
 317         intf_ErrMsg( "ipv6 error: cannot bind socket (%s)", strerror(errno) );
 318         close( i_handle );
 319         return( -1 );
 320     }
 321
 322     /* Allow broadcast reception if we bound on in6addr_any */
 323     if( !*psz_bind_addr )
 324     {
 325         i_opt = 1;
 326         if( setsockopt( i_handle, SOL_SOCKET, SO_BROADCAST,
 327                         (void*) &i_opt, sizeof( i_opt ) ) == -1 )
 328         {
 329             intf_WarnMsg( 1,
 330                     "ipv6 warning: cannot configure socket (SO_BROADCAST: %s)",
 331                     strerror(errno));
 332         }
 333     }
 334
 335     /* Join the multicast group if the socket is a multicast address */
 336     if( IN6_IS_ADDR_MULTICAST(&sock.sin6_addr) )
 337     {
 338         struct ipv6_mreq     imr;
 339         int                  res;
 340
 341         imr.ipv6mr_interface = sock.sin6_scope_id;
 342         imr.ipv6mr_multiaddr = sock.sin6_addr;
 343         res = setsockopt(i_handle, IPPROTO_IPV6, IPV6_JOIN_GROUP, (void *)&imr,
 344                          sizeof(imr));
 345
 346         if( res == -1 )
 347         {
 348             intf_ErrMsg( "ipv6 error: setsockopt JOIN_GROUP failed" );
 349         }
 350     }
 351
 352
 353     if( *psz_server_addr )
 354     {
 355         /* Build socket for remote connection */
 356         if ( BuildAddr( &sock, psz_server_addr, i_server_port ) == -1 )
 357         {
 358             intf_ErrMsg( "ipv6 error: cannot build remote address" );
 359             close( i_handle );
 360             return( -1 );
 361         }
 362
 363         /* Connect the socket */
 364         if( connect( i_handle, (struct sockaddr *) &sock,
 365                      sizeof( sock ) ) == (-1) )
 366         {
 367             intf_ErrMsg( "ipv6 error: cannot connect socket (%s)",
 368                          strerror(errno) );
 369             close( i_handle );
 370             return( -1 );
 371         }
 372     }
 373
 374     p_socket->i_handle = i_handle;
 375     p_socket->i_mtu = config_GetIntVariable( "mtu" );
 376     return( 0 );
 377 }
 378
 379 /*****************************************************************************
 380  * OpenTCP: open a TCP socket
 381  *****************************************************************************
 382  * psz_server_addr, i_server_port : address and port used for the connect()
 383  *   system call. If i_server_port == 0, 80 is used.
 384  * Other parameters are ignored.
 385  * This function returns -1 in case of error.
 386  *****************************************************************************/
 387 static int OpenTCP( network_socket_t * p_socket )
 388 {
 389     char * psz_server_addr = p_socket->psz_server_addr;
 390     int i_server_port = p_socket->i_server_port;
 391
 392     int i_handle;
 393     struct sockaddr_in6 sock;
 394
 395     if( i_server_port == 0 )
 396     {
 397         i_server_port = 80;
 398     }
 399
 400     /* Open a SOCK_STREAM (TCP) socket, in the AF_INET6 domain, automatic (0)
 401      * protocol */
 402     if( (i_handle = socket( AF_INET6, SOCK_STREAM, 0 )) == -1 )
 403     {
 404         intf_ErrMsg( "ipv6 error: cannot create socket (%s)", strerror(errno) );
 405         return( -1 );
 406     }
 407
 408     /* Build remote address */
 409     if ( BuildAddr( &sock, psz_server_addr, i_server_port ) == -1 )
 410     {
 411         close( i_handle );
 412         return( -1 );
 413     }
 414
 415     /* Connect the socket */
 416     if( connect( i_handle, (struct sockaddr *) &sock,
 417                  sizeof( sock ) ) == (-1) )
 418     {
 419         intf_ErrMsg( "ipv6 error: cannot connect socket (%s)",
 420                      strerror(errno) );
 421         close( i_handle );
 422         return( -1 );
 423     }
 424
 425     p_socket->i_handle = i_handle;
 426     p_socket->i_mtu = 0; /* There is no MTU notion in TCP */
 427
 428     return( 0 );
 429 }
 430
 431 /*****************************************************************************
 432  * NetworkOpen: wrapper around OpenUDP and OpenTCP
 433  *****************************************************************************/
 434 static int NetworkOpen( network_socket_t * p_socket )
 435 {
 436     if( p_socket->i_type == NETWORK_UDP )
 437     {
 438         return OpenUDP( p_socket );
 439     }
 440     else
 441     {
 442         return OpenTCP( p_socket );
 443     }
 444 }