git.sesse.net Git - vlc/blob - src/network/io.c

   1 /*****************************************************************************
   2  * io.c: network I/O functions
   3  *****************************************************************************
   4  * Copyright (C) 2004-2005 the VideoLAN team
   5  * Copyright © 2005-2006 Rémi Denis-Courmont
   6  * $Id$
   7  *
   8  * Authors: Laurent Aimar <fenrir@videolan.org>
   9  *          Rémi Denis-Courmont <rem # videolan.org>
  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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29
  30 #include <vlc/vlc.h>
  31
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <limits.h>
  35
  36 #include <errno.h>
  37 #include <assert.h>
  38
  39 #ifdef HAVE_FCNTL_H
  40 #   include <fcntl.h>
  41 #endif
  42 #ifdef HAVE_SYS_TIME_H
  43 #    include <sys/time.h>
  44 #endif
  45 #ifdef HAVE_UNISTD_H
  46 #   include <unistd.h>
  47 #endif
  48 #ifdef HAVE_POLL
  49 #   include <poll.h>
  50 #endif
  51
  52 #include "network.h"
  53
  54 #ifndef INADDR_ANY
  55 #   define INADDR_ANY  0x00000000
  56 #endif
  57 #ifndef INADDR_NONE
  58 #   define INADDR_NONE 0xFFFFFFFF
  59 #endif
  60
  61 #if defined(WIN32) || defined(UNDER_CE)
  62 # undef EAFNOSUPPORT
  63 # define EAFNOSUPPORT WSAEAFNOSUPPORT
  64 #endif
  65
  66 extern int rootwrap_bind (int family, int socktype, int protocol,
  67                           const struct sockaddr *addr, size_t alen);
  68
  69 int net_Socket (vlc_object_t *p_this, int family, int socktype,
  70                 int protocol)
  71 {
  72     int fd = socket (family, socktype, protocol);
  73     if (fd == -1)
  74     {
  75         if (net_errno != EAFNOSUPPORT)
  76             msg_Err (p_this, "cannot create socket: %s",
  77                      net_strerror (net_errno));
  78         return -1;
  79     }
  80
  81 #if defined (WIN32) || defined (UNDER_CE)
  82     ioctlsocket (fd, FIONBIO, &(unsigned long){ 1 });
  83 #else
  84     fcntl (fd, F_SETFD, FD_CLOEXEC);
  85     fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
  86 #endif
  87
  88     setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof (int));
  89
  90 #ifdef IPV6_V6ONLY
  91     /*
  92      * Accepts only IPv6 connections on IPv6 sockets
  93      * (and open an IPv4 socket later as well if needed).
  94      * Only Linux and FreeBSD can map IPv4 connections on IPv6 sockets,
  95      * so this allows for more uniform handling across platforms. Besides,
  96      * it makes sure that IPv4 addresses will be printed as w.x.y.z rather
  97      * than ::ffff:w.x.y.z
  98      */
  99     if (family == AF_INET6)
 100         setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &(int){ 1 }, sizeof (int));
 101 #endif
 102
 103 #if defined (WIN32) || defined (UNDER_CE)
 104 # ifndef IPV6_PROTECTION_LEVEL
 105 #  define IPV6_PROTECTION_LEVEL 23
 106 #  define PROTECTION_LEVEL_UNRESTRICTED 30
 107 # endif
 108     if (family == AF_INET6)
 109         setsockopt (fd, IPPROTO_IPV6, IPV6_PROTECTION_LEVEL,
 110                     &(int){ PROTECTION_LEVEL_UNRESTRICTED }, sizeof (int));
 111 #endif
 112
 113     return fd;
 114 }
 115
 116
 117 int *net_Listen (vlc_object_t *p_this, const char *psz_host, int i_port,
 118                  int family, int socktype, int protocol)
 119 {
 120     struct addrinfo hints, *res;
 121
 122     memset (&hints, 0, sizeof( hints ));
 123     hints.ai_family = family;
 124     hints.ai_socktype = socktype;
 125     hints.ai_protocol = protocol;
 126     hints.ai_flags = AI_PASSIVE;
 127
 128     msg_Dbg (p_this, "net: listening to %s port %d", psz_host, i_port);
 129
 130     int i_val = vlc_getaddrinfo (p_this, psz_host, i_port, &hints, &res);
 131     if (i_val)
 132     {
 133         msg_Err (p_this, "Cannot resolve %s port %d : %s", psz_host, i_port,
 134                  vlc_gai_strerror (i_val));
 135         return NULL;
 136     }
 137
 138     int *sockv = NULL;
 139     unsigned sockc = 0;
 140
 141     for (struct addrinfo *ptr = res; ptr != NULL; ptr = ptr->ai_next)
 142     {
 143         int fd = net_Socket (p_this, ptr->ai_family, ptr->ai_socktype,
 144                              ptr->ai_protocol);
 145         if (fd == -1)
 146         {
 147             msg_Dbg (p_this, "socket error: %s", net_strerror (net_errno));
 148             continue;
 149         }
 150
 151         /* Bind the socket */
 152         if (bind (fd, ptr->ai_addr, ptr->ai_addrlen))
 153         {
 154             int saved_errno = net_errno;
 155
 156             net_Close (fd);
 157 #if !defined(WIN32) && !defined(UNDER_CE)
 158             fd = rootwrap_bind (ptr->ai_family, ptr->ai_socktype,
 159                                 ptr->ai_protocol, ptr->ai_addr,
 160                                 ptr->ai_addrlen);
 161             if (fd != -1)
 162             {
 163                 msg_Dbg (p_this, "got socket %d from rootwrap", fd);
 164             }
 165             else
 166 #endif
 167             {
 168                 msg_Err (p_this, "socket bind error (%s)",
 169                          net_strerror( saved_errno ) );
 170                 continue;
 171             }
 172         }
 173
 174         if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen))
 175         {
 176             if (net_Subscribe (p_this, fd, ptr->ai_addr, ptr->ai_addrlen))
 177             {
 178                 net_Close (fd);
 179                 continue;
 180             }
 181         }
 182
 183         /* Listen */
 184         switch (ptr->ai_socktype)
 185         {
 186             case SOCK_STREAM:
 187             case SOCK_RDM:
 188             case SOCK_SEQPACKET:
 189                 if (listen (fd, INT_MAX))
 190                 {
 191                     msg_Err (p_this, "socket listen error (%s)",
 192                             net_strerror (net_errno));
 193                     net_Close (fd);
 194                     continue;
 195                 }
 196         }
 197
 198         int *nsockv = (int *)realloc (sockv, (sockc + 2) * sizeof (int));
 199         if (nsockv != NULL)
 200         {
 201             nsockv[sockc++] = fd;
 202             sockv = nsockv;
 203         }
 204         else
 205             net_Close (fd);
 206     }
 207
 208     vlc_freeaddrinfo (res);
 209
 210     if (sockv != NULL)
 211         sockv[sockc] = -1;
 212
 213     return sockv;
 214 }
 215
 216
 217 /*****************************************************************************
 218  * __net_Close:
 219  *****************************************************************************
 220  * Close a network handle
 221  *****************************************************************************/
 222 void net_Close (int fd)
 223 {
 224 #ifdef UNDER_CE
 225     CloseHandle ((HANDLE)fd);
 226 #elif defined (WIN32)
 227     closesocket (fd);
 228 #else
 229     (void)close (fd);
 230 #endif
 231 }
 232
 233
 234 static ssize_t
 235 net_ReadInner( vlc_object_t *restrict p_this, unsigned fdc, const int *fdv,
 236                const v_socket_t *const *restrict vsv,
 237                uint8_t *restrict p_buf, size_t i_buflen,
 238                int wait_ms, vlc_bool_t waitall )
 239 {
 240     size_t i_total = 0;
 241
 242     while (i_buflen > 0)
 243     {
 244         unsigned i;
 245         ssize_t n;
 246 #ifdef HAVE_POLL
 247         struct pollfd ufd[fdc];
 248 #else
 249         int maxfd = -1;
 250         fd_set set;
 251 #endif
 252
 253         int delay_ms = 500;
 254         if ((wait_ms != -1) && (wait_ms < 500))
 255             delay_ms = wait_ms;
 256
 257         if (p_this->b_die)
 258         {
 259             errno = EINTR;
 260             goto error;
 261         }
 262
 263 #ifdef HAVE_POLL
 264         memset (ufd, 0, sizeof (ufd));
 265
 266         for( i = 0; i < fdc; i++ )
 267         {
 268             ufd[i].fd = fdv[i];
 269             ufd[i].events = POLLIN;
 270         }
 271
 272         n = poll( ufd, fdc, delay_ms );
 273 #else
 274         FD_ZERO (&set);
 275
 276         for( i = 0; i < fdc; i++ )
 277         {
 278 #if !defined(WIN32) && !defined(UNDER_CE)
 279             if( fdv[i] >= FD_SETSIZE )
 280             {
 281                 /* We don't want to overflow select() fd_set */
 282                 msg_Err( p_this, "select set overflow" );
 283                 return -1;
 284             }
 285 #endif
 286             FD_SET( fdv[i], &set );
 287             if( fdv[i] > maxfd )
 288                 maxfd = fdv[i];
 289         }
 290
 291         n = select( maxfd + 1, &set, NULL, NULL,
 292                     (wait_ms == -1) ? NULL
 293                                   : &(struct timeval){ 0, delay_ms * 1000 } );
 294 #endif
 295         if( n == -1 )
 296             goto error;
 297
 298         assert ((unsigned)n <= fdc);
 299
 300         if (n == 0) // timeout
 301             continue;
 302
 303         for (i = 0;; i++)
 304         {
 305 #ifdef HAVE_POLL
 306             if ((i_total > 0) && (ufd[i].revents & POLLERR))
 307                 return i_total; // error will be dequeued on next run
 308
 309             if ((ufd[i].revents & POLLIN) == 0)
 310 #else
 311             if (!FD_ISSET (fdv[i], &set))
 312                 continue;
 313 #endif
 314             fdc = 1;
 315             fdv += i;
 316             vsv += i;
 317             break;
 318         }
 319
 320         if( (*vsv) != NULL )
 321         {
 322             n = (*vsv)->pf_recv( (*vsv)->p_sys, p_buf, i_buflen );
 323         }
 324         else
 325         {
 326 #if defined(WIN32) || defined(UNDER_CE)
 327             n = recv( *fdv, p_buf, i_buflen, 0 );
 328 #else
 329             n = read( *fdv, p_buf, i_buflen );
 330 #endif
 331         }
 332
 333         if( n == -1 )
 334         {
 335 #if defined(WIN32) || defined(UNDER_CE)
 336             switch( WSAGetLastError() )
 337             {
 338                 case WSAEWOULDBLOCK:
 339                 /* only happens with vs != NULL (SSL) - not really an error */
 340                     continue;
 341
 342                 case WSAEMSGSIZE:
 343                 /* For UDP only */
 344                 /* On Win32, recv() fails if the datagram doesn't fit inside
 345                  * the passed buffer, even though the buffer will be filled
 346                  * with the first part of the datagram. */
 347                     msg_Err( p_this, "Receive error: "
 348                                      "Increase the mtu size (--mtu option)" );
 349                     i_total += i_buflen;
 350                     return i_total;
 351             }
 352 #else
 353             if( errno == EAGAIN ) /* spurious wake-up (sucks if fdc > 1) */
 354                 continue;
 355 #endif
 356             goto error;
 357         }
 358
 359         if (n == 0) // EOF
 360             return i_total;
 361
 362         i_total += n;
 363         p_buf += n;
 364         i_buflen -= n;
 365
 366         if (!waitall)
 367             return i_total;
 368
 369         if (wait_ms != -1)
 370         {
 371             wait_ms -= delay_ms;
 372             if (wait_ms == 0)
 373                 return i_total; // time's up!
 374         }
 375     }
 376     return i_total;
 377
 378 error:
 379     msg_Err( p_this, "Read error: %s", net_strerror (net_errno) );
 380     return i_total ? (ssize_t)i_total : -1;
 381 }
 382
 383
 384 /*****************************************************************************
 385  * __net_Read:
 386  *****************************************************************************
 387  * Read from a network socket
 388  * If b_retry is true, then we repeat until we have read the right amount of
 389  * data
 390  *****************************************************************************/
 391 int __net_Read( vlc_object_t *restrict p_this, int fd,
 392                 const v_socket_t *restrict p_vs,
 393                 uint8_t *restrict p_data, int i_data, vlc_bool_t b_retry )
 394 {
 395     return net_ReadInner( p_this, 1, &(int){ fd },
 396                           &(const v_socket_t *){ p_vs },
 397                           p_data, i_data, -1, b_retry );
 398 }
 399
 400
 401 /*****************************************************************************
 402  * __net_ReadNonBlock:
 403  *****************************************************************************
 404  * Read from a network socket, non blocking mode (with timeout)
 405  *****************************************************************************/
 406 int __net_ReadNonBlock( vlc_object_t *restrict p_this, int fd,
 407                         const v_socket_t *restrict p_vs,
 408                         uint8_t *restrict p_data, int i_data, mtime_t i_wait)
 409 {
 410     return net_ReadInner (p_this, 1, &(int){ fd },
 411                           &(const v_socket_t *){ p_vs },
 412                           p_data, i_data, i_wait / 1000, VLC_FALSE);
 413 }
 414
 415
 416 /*****************************************************************************
 417  * __net_Select:
 418  *****************************************************************************
 419  * Read from several sockets (with timeout). Takes data from the first socket
 420  * that has some.
 421  *****************************************************************************/
 422 int __net_Select( vlc_object_t *restrict p_this, const int *restrict pi_fd,
 423                   const v_socket_t *const *restrict pp_vs,
 424                   int i_fd, uint8_t *restrict p_data, int i_data,
 425                   mtime_t i_wait )
 426 {
 427     if( pp_vs == NULL )
 428     {
 429         const v_socket_t *vsv[i_fd];
 430         memset( vsv, 0, sizeof (vsv) );
 431
 432         return net_ReadInner( p_this, i_fd, pi_fd, vsv, p_data, i_data,
 433                               i_wait / 1000, VLC_FALSE );
 434     }
 435
 436     return net_ReadInner( p_this, i_fd, pi_fd, pp_vs, p_data, i_data,
 437                           i_wait / 1000, VLC_FALSE );
 438 }
 439
 440
 441 /* Write exact amount requested */
 442 int __net_Write( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
 443                  const uint8_t *p_data, int i_data )
 444 {
 445     size_t i_total = 0;
 446
 447     while( i_data > 0 )
 448     {
 449         if( p_this->b_die )
 450             return i_total;
 451
 452 #ifdef HAVE_POLL
 453         struct pollfd ufd[1];
 454         memset (ufd, 0, sizeof (ufd));
 455         ufd[0].fd = fd;
 456         ufd[0].events = POLLOUT;
 457
 458         int val = poll (ufd, 1, 500);
 459         if ((val > 0) && (ufd[0].revents & POLLERR) && (i_total > 0))
 460             return i_total; // error will be dequeued separately on next call
 461 #else
 462         fd_set set;
 463         FD_ZERO (&set);
 464
 465 #if !defined(WIN32) && !defined(UNDER_CE)
 466         if (fd >= FD_SETSIZE)
 467         {
 468             /* We don't want to overflow select() fd_set */
 469             msg_Err (p_this, "select set overflow");
 470             return -1;
 471         }
 472 #endif
 473         FD_SET (fd, &set);
 474
 475         int val = select (fd + 1, NULL, &set, NULL,
 476                           &(struct timeval){ 0, 500000 });
 477 #endif
 478         switch (val)
 479         {
 480             case -1:
 481                 if (errno != EINTR)
 482                 {
 483                     msg_Err (p_this, "Write error: %s",
 484                              net_strerror (net_errno));
 485                     return i_total ? (int)i_total : -1;
 486                 }
 487
 488             case 0:
 489                 continue;
 490         }
 491
 492         if (p_vs != NULL)
 493             val = p_vs->pf_send (p_vs->p_sys, p_data, i_data);
 494         else
 495 #if defined(WIN32) || defined(UNDER_CE)
 496             val = send (fd, p_data, i_data, 0);
 497 #else
 498             val = write (fd, p_data, i_data);
 499 #endif
 500
 501         if (val == -1)
 502             return i_total ? (int)i_total : -1;
 503         if (val == 0)
 504             return i_total;
 505
 506         p_data += val;
 507         i_data -= val;
 508         i_total += val;
 509     }
 510
 511     return i_total;
 512 }
 513
 514 char *__net_Gets( vlc_object_t *p_this, int fd, const v_socket_t *p_vs )
 515 {
 516     char *psz_line = NULL, *ptr = NULL;
 517     size_t  i_line = 0, i_max = 0;
 518
 519
 520     for( ;; )
 521     {
 522         if( i_line == i_max )
 523         {
 524             i_max += 1024;
 525             psz_line = realloc( psz_line, i_max );
 526             ptr = psz_line + i_line;
 527         }
 528
 529         if( net_Read( p_this, fd, p_vs, (uint8_t *)ptr, 1, VLC_TRUE ) != 1 )
 530         {
 531             if( i_line == 0 )
 532             {
 533                 free( psz_line );
 534                 return NULL;
 535             }
 536             break;
 537         }
 538
 539         if ( *ptr == '\n' )
 540             break;
 541
 542         i_line++;
 543         ptr++;
 544     }
 545
 546     *ptr-- = '\0';
 547
 548     if( ( ptr >= psz_line ) && ( *ptr == '\r' ) )
 549         *ptr = '\0';
 550
 551     return psz_line;
 552 }
 553
 554 int net_Printf( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
 555                 const char *psz_fmt, ... )
 556 {
 557     int i_ret;
 558     va_list args;
 559     va_start( args, psz_fmt );
 560     i_ret = net_vaPrintf( p_this, fd, p_vs, psz_fmt, args );
 561     va_end( args );
 562
 563     return i_ret;
 564 }
 565
 566 int __net_vaPrintf( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
 567                     const char *psz_fmt, va_list args )
 568 {
 569     char    *psz;
 570     int     i_size, i_ret;
 571
 572     i_size = vasprintf( &psz, psz_fmt, args );
 573     i_ret = __net_Write( p_this, fd, p_vs, (uint8_t *)psz, i_size ) < i_size
 574         ? -1 : i_size;
 575     free( psz );
 576
 577     return i_ret;
 578 }
 579
 580
 581 /*****************************************************************************
 582  * inet_pton replacement for obsolete and/or crap operating systems
 583  *****************************************************************************/
 584 #ifndef HAVE_INET_PTON
 585 int inet_pton(int af, const char *src, void *dst)
 586 {
 587 # ifdef WIN32
 588     /* As we already know, Microsoft always go its own way, so even if they do
 589      * provide IPv6, they don't provide the API. */
 590     struct sockaddr_storage addr;
 591     int len = sizeof( addr );
 592
 593     /* Damn it, they didn't even put LPCSTR for the firs parameter!!! */
 594 #ifdef UNICODE
 595     wchar_t *workaround_for_ill_designed_api =
 596         malloc( MAX_PATH * sizeof(wchar_t) );
 597     mbstowcs( workaround_for_ill_designed_api, src, MAX_PATH );
 598     workaround_for_ill_designed_api[MAX_PATH-1] = 0;
 599 #else
 600     char *workaround_for_ill_designed_api = strdup( src );
 601 #endif
 602
 603     if( !WSAStringToAddress( workaround_for_ill_designed_api, af, NULL,
 604                              (LPSOCKADDR)&addr, &len ) )
 605     {
 606         free( workaround_for_ill_designed_api );
 607         return -1;
 608     }
 609     free( workaround_for_ill_designed_api );
 610
 611     switch( af )
 612     {
 613         case AF_INET6:
 614             memcpy( dst, &((struct sockaddr_in6 *)&addr)->sin6_addr, 16 );
 615             break;
 616
 617         case AF_INET:
 618             memcpy( dst, &((struct sockaddr_in *)&addr)->sin_addr, 4 );
 619             break;
 620
 621         default:
 622             WSASetLastError( WSAEAFNOSUPPORT );
 623             return -1;
 624     }
 625 # else
 626     /* Assume IPv6 is not supported. */
 627     /* Would be safer and more simpler to use inet_aton() but it is most
 628      * likely not provided either. */
 629     uint32_t ipv4;
 630
 631     if( af != AF_INET )
 632     {
 633         errno = EAFNOSUPPORT;
 634         return -1;
 635     }
 636
 637     ipv4 = inet_addr( src );
 638     if( ipv4 == INADDR_NONE )
 639         return -1;
 640
 641     memcpy( dst, &ipv4, 4 );
 642 # endif /* WIN32 */
 643     return 0;
 644 }
 645 #endif /* HAVE_INET_PTON */