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 <vlc_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 },
 101                     &(socklen_t){ sizeof (int) });
 102 #endif
 103
 104 #if defined (WIN32) || defined (UNDER_CE)
 105 # ifndef IPV6_PROTECTION_LEVEL
 106 #  warning Please update your C library headers.
 107 #  define IPV6_PROTECTION_LEVEL 23
 108 #  define PROTECTION_LEVEL_UNRESTRICTED 10
 109 # endif
 110     if (family == AF_INET6)
 111         setsockopt (fd, IPPROTO_IPV6, IPV6_PROTECTION_LEVEL,
 112                     &(int){ PROTECTION_LEVEL_UNRESTRICTED }, sizeof (int));
 113 #endif
 114
 115     return fd;
 116 }
 117
 118
 119 int *net_Listen (vlc_object_t *p_this, const char *psz_host,
 120                  int i_port, int family, int socktype, int protocol)
 121 {
 122     struct addrinfo hints, *res;
 123
 124     memset (&hints, 0, sizeof( hints ));
 125     hints.ai_family = family;
 126     hints.ai_socktype = socktype;
 127     hints.ai_protocol = protocol;
 128     hints.ai_flags = AI_PASSIVE;
 129
 130     msg_Dbg (p_this, "net: listening to %s port %d", psz_host, i_port);
 131
 132     int i_val = vlc_getaddrinfo (p_this, psz_host, i_port, &hints, &res);
 133     if (i_val)
 134     {
 135         msg_Err (p_this, "Cannot resolve %s port %d : %s", psz_host, i_port,
 136                  vlc_gai_strerror (i_val));
 137         return NULL;
 138     }
 139
 140     int *sockv = NULL;
 141     unsigned sockc = 0;
 142
 143     for (struct addrinfo *ptr = res; ptr != NULL; ptr = ptr->ai_next)
 144     {
 145         int fd = net_Socket (p_this, ptr->ai_family, ptr->ai_socktype,
 146                              ptr->ai_protocol);
 147         if (fd == -1)
 148         {
 149             msg_Dbg (p_this, "socket error: %s", net_strerror (net_errno));
 150             continue;
 151         }
 152
 153         /* Bind the socket */
 154 #if defined (WIN32) || defined (UNDER_CE)
 155         /*
 156          * Under Win32 and for multicasting, we bind to INADDR_ANY.
 157          * This is of course a severe bug, since the socket would logically
 158          * receive unicast traffic, and multicast traffic of groups subscribed
 159          * to via other sockets.
 160          */
 161         if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen)
 162          && (sizeof (struct sockaddr_storage) >= ptr->ai_addrlen))
 163         {
 164             // This works for IPv4 too - don't worry!
 165             struct sockaddr_in6 dumb =
 166             {
 167                 .sin6_family = ptr->ai_addr->sa_family,
 168                 .sin6_port =  ((struct sockaddr_in *)(ptr->ai_addr))->sin_port
 169             };
 170
 171             bind (fd, (struct sockaddr *)&dumb, ptr->ai_addrlen);
 172         }
 173         else
 174 #endif
 175         if (bind (fd, ptr->ai_addr, ptr->ai_addrlen))
 176         {
 177             int saved_errno = net_errno;
 178
 179             net_Close (fd);
 180 #if !defined(WIN32) && !defined(UNDER_CE)
 181             fd = rootwrap_bind (ptr->ai_family, ptr->ai_socktype,
 182                                 ptr->ai_protocol, ptr->ai_addr,
 183                                 ptr->ai_addrlen);
 184             if (fd != -1)
 185             {
 186                 msg_Dbg (p_this, "got socket %d from rootwrap", fd);
 187             }
 188             else
 189 #endif
 190             {
 191                 msg_Err (p_this, "socket bind error (%s)",
 192                          net_strerror( saved_errno ) );
 193                 continue;
 194             }
 195         }
 196
 197         if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen))
 198         {
 199             if (net_Subscribe (p_this, fd, ptr->ai_addr, ptr->ai_addrlen))
 200             {
 201                 net_Close (fd);
 202                 continue;
 203             }
 204         }
 205
 206         /* Listen */
 207         switch (ptr->ai_socktype)
 208         {
 209             case SOCK_STREAM:
 210             case SOCK_RDM:
 211             case SOCK_SEQPACKET:
 212                 if (listen (fd, INT_MAX))
 213                 {
 214                     msg_Err (p_this, "socket listen error (%s)",
 215                             net_strerror (net_errno));
 216                     net_Close (fd);
 217                     continue;
 218                 }
 219         }
 220
 221         int *nsockv = (int *)realloc (sockv, (sockc + 2) * sizeof (int));
 222         if (nsockv != NULL)
 223         {
 224             nsockv[sockc++] = fd;
 225             sockv = nsockv;
 226         }
 227         else
 228             net_Close (fd);
 229     }
 230
 231     vlc_freeaddrinfo (res);
 232
 233     if (sockv != NULL)
 234         sockv[sockc] = -1;
 235
 236     return sockv;
 237 }
 238
 239
 240 int net_ListenSingle (vlc_object_t *obj, const char *host, int port,
 241                       int family, int socktype, int protocol)
 242 {
 243     int *fdv = net_Listen (obj, host, port, family, socktype, protocol);
 244     if (fdv == NULL)
 245         return -1;
 246
 247     for (unsigned i = 1; fdv[i] != -1; i++)
 248     {
 249         msg_Warn (obj, "A socket has been dropped!");
 250         net_Close (fdv[i]);
 251     }
 252
 253     int fd = fdv[0];
 254     assert (fd != -1);
 255
 256     if (fdv[1] != -1)
 257     {
 258 #ifdef IPV6_V6ONLY
 259         struct sockaddr_storage addr;
 260
 261         if ((getsockname (fd, (struct sockaddr *)&addr,
 262                           &(socklen_t){ sizeof (addr) }) == 0)
 263          && (addr.ss_family == AF_INET6)
 264          && setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &(int){ 0 },
 265                         &(socklen_t){ sizeof (int) }))
 266 #endif
 267             msg_Err (obj, "Lame IP dual-stack: IPv4 connections might fail.");
 268     }
 269
 270     free (fdv);
 271     return fd;
 272 }
 273
 274
 275
 276 /*****************************************************************************
 277  * __net_Close:
 278  *****************************************************************************
 279  * Close a network handle
 280  *****************************************************************************/
 281 void net_Close (int fd)
 282 {
 283 #ifdef UNDER_CE
 284     CloseHandle ((HANDLE)fd);
 285 #elif defined (WIN32)
 286     closesocket (fd);
 287 #else
 288     (void)close (fd);
 289 #endif
 290 }
 291
 292
 293 static ssize_t
 294 net_ReadInner( vlc_object_t *restrict p_this, unsigned fdc, const int *fdv,
 295                const v_socket_t *const *restrict vsv,
 296                uint8_t *restrict p_buf, size_t i_buflen,
 297                int wait_ms, vlc_bool_t waitall )
 298 {
 299     size_t i_total = 0;
 300
 301     while (i_buflen > 0)
 302     {
 303         unsigned i;
 304         ssize_t n;
 305 #ifdef HAVE_POLL
 306         struct pollfd ufd[fdc];
 307 #else
 308         int maxfd = -1;
 309         fd_set set;
 310 #endif
 311
 312         int delay_ms = 500;
 313         if ((wait_ms != -1) && (wait_ms < 500))
 314             delay_ms = wait_ms;
 315
 316         if (p_this->b_die)
 317         {
 318             errno = EINTR;
 319             goto error;
 320         }
 321
 322 #ifdef HAVE_POLL
 323         memset (ufd, 0, sizeof (ufd));
 324
 325         for( i = 0; i < fdc; i++ )
 326         {
 327             ufd[i].fd = fdv[i];
 328             ufd[i].events = POLLIN;
 329         }
 330
 331         n = poll( ufd, fdc, delay_ms );
 332 #else
 333         FD_ZERO (&set);
 334
 335         for( i = 0; i < fdc; i++ )
 336         {
 337 #if !defined(WIN32) && !defined(UNDER_CE)
 338             if( fdv[i] >= FD_SETSIZE )
 339             {
 340                 /* We don't want to overflow select() fd_set */
 341                 msg_Err( p_this, "select set overflow" );
 342                 return -1;
 343             }
 344 #endif
 345             FD_SET( fdv[i], &set );
 346             if( fdv[i] > maxfd )
 347                 maxfd = fdv[i];
 348         }
 349
 350         n = select( maxfd + 1, &set, NULL, NULL,
 351                     (wait_ms == -1) ? NULL
 352                                   : &(struct timeval){ 0, delay_ms * 1000 } );
 353 #endif
 354         if( n == -1 )
 355             goto error;
 356
 357         assert ((unsigned)n <= fdc);
 358
 359         if (n == 0) // timeout
 360             continue;
 361
 362         for (i = 0;; i++)
 363         {
 364 #ifdef HAVE_POLL
 365             if ((i_total > 0) && (ufd[i].revents & POLLERR))
 366                 return i_total; // error will be dequeued on next run
 367
 368             if ((ufd[i].revents & POLLIN) == 0)
 369 #else
 370             if (!FD_ISSET (fdv[i], &set))
 371                 continue;
 372 #endif
 373             fdc = 1;
 374             fdv += i;
 375             vsv += i;
 376             break;
 377         }
 378
 379         if( (*vsv) != NULL )
 380         {
 381             n = (*vsv)->pf_recv( (*vsv)->p_sys, p_buf, i_buflen );
 382         }
 383         else
 384         {
 385 #if defined(WIN32) || defined(UNDER_CE)
 386             n = recv( *fdv, p_buf, i_buflen, 0 );
 387 #else
 388             n = read( *fdv, p_buf, i_buflen );
 389 #endif
 390         }
 391
 392         if( n == -1 )
 393         {
 394 #if defined(WIN32) || defined(UNDER_CE)
 395             switch( WSAGetLastError() )
 396             {
 397                 case WSAEWOULDBLOCK:
 398                 /* only happens with vs != NULL (SSL) - not really an error */
 399                     continue;
 400
 401                 case WSAEMSGSIZE:
 402                 /* For UDP only */
 403                 /* On Win32, recv() fails if the datagram doesn't fit inside
 404                  * the passed buffer, even though the buffer will be filled
 405                  * with the first part of the datagram. */
 406                     msg_Err( p_this, "Receive error: "
 407                                      "Increase the mtu size (--mtu option)" );
 408                     i_total += i_buflen;
 409                     return i_total;
 410             }
 411 #else
 412             if( errno == EAGAIN ) /* spurious wake-up (sucks if fdc > 1) */
 413                 continue;
 414 #endif
 415             goto error;
 416         }
 417
 418         if (n == 0) // EOF
 419             return i_total;
 420
 421         i_total += n;
 422         p_buf += n;
 423         i_buflen -= n;
 424
 425         if (!waitall)
 426             return i_total;
 427
 428         if (wait_ms != -1)
 429         {
 430             wait_ms -= delay_ms;
 431             if (wait_ms == 0)
 432                 return i_total; // time's up!
 433         }
 434     }
 435     return i_total;
 436
 437 error:
 438     if( errno != EINTR )
 439         msg_Err( p_this, "Read error: %s", net_strerror (net_errno) );
 440     return i_total ? (ssize_t)i_total : -1;
 441 }
 442
 443
 444 /*****************************************************************************
 445  * __net_Read:
 446  *****************************************************************************
 447  * Read from a network socket
 448  * If b_retry is true, then we repeat until we have read the right amount of
 449  * data
 450  *****************************************************************************/
 451 int __net_Read( vlc_object_t *restrict p_this, int fd,
 452                 const v_socket_t *restrict p_vs,
 453                 uint8_t *restrict p_data, int i_data, vlc_bool_t b_retry )
 454 {
 455     return net_ReadInner( p_this, 1, &(int){ fd },
 456                           &(const v_socket_t *){ p_vs },
 457                           p_data, i_data, -1, b_retry );
 458 }
 459
 460
 461 /*****************************************************************************
 462  * __net_ReadNonBlock:
 463  *****************************************************************************
 464  * Read from a network socket, non blocking mode (with timeout)
 465  *****************************************************************************/
 466 int __net_ReadNonBlock( vlc_object_t *restrict p_this, int fd,
 467                         const v_socket_t *restrict p_vs,
 468                         uint8_t *restrict p_data, int i_data, mtime_t i_wait)
 469 {
 470     return net_ReadInner (p_this, 1, &(int){ fd },
 471                           &(const v_socket_t *){ p_vs },
 472                           p_data, i_data, i_wait / 1000, VLC_FALSE);
 473 }
 474
 475
 476 /*****************************************************************************
 477  * __net_Select:
 478  *****************************************************************************
 479  * Read from several sockets (with timeout). Takes data from the first socket
 480  * that has some.
 481  *****************************************************************************/
 482 int __net_Select( vlc_object_t *restrict p_this, const int *restrict pi_fd,
 483                   const v_socket_t *const *restrict pp_vs,
 484                   int i_fd, uint8_t *restrict p_data, int i_data,
 485                   mtime_t i_wait )
 486 {
 487     if( pp_vs == NULL )
 488     {
 489         const v_socket_t *vsv[i_fd];
 490         memset( vsv, 0, sizeof (vsv) );
 491
 492         return net_ReadInner( p_this, i_fd, pi_fd, vsv, p_data, i_data,
 493                               i_wait / 1000, VLC_FALSE );
 494     }
 495
 496     return net_ReadInner( p_this, i_fd, pi_fd, pp_vs, p_data, i_data,
 497                           i_wait / 1000, VLC_FALSE );
 498 }
 499
 500
 501 /* Write exact amount requested */
 502 int __net_Write( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
 503                  const uint8_t *p_data, int i_data )
 504 {
 505     size_t i_total = 0;
 506
 507     while( i_data > 0 )
 508     {
 509         if( p_this->b_die )
 510             return i_total;
 511
 512 #ifdef HAVE_POLL
 513         struct pollfd ufd[1];
 514         memset (ufd, 0, sizeof (ufd));
 515         ufd[0].fd = fd;
 516         ufd[0].events = POLLOUT;
 517
 518         int val = poll (ufd, 1, 500);
 519         if ((val > 0) && (ufd[0].revents & POLLERR) && (i_total > 0))
 520             return i_total; // error will be dequeued separately on next call
 521 #else
 522         fd_set set;
 523         FD_ZERO (&set);
 524
 525 #if !defined(WIN32) && !defined(UNDER_CE)
 526         if (fd >= FD_SETSIZE)
 527         {
 528             /* We don't want to overflow select() fd_set */
 529             msg_Err (p_this, "select set overflow");
 530             return -1;
 531         }
 532 #endif
 533         FD_SET (fd, &set);
 534
 535         int val = select (fd + 1, NULL, &set, NULL,
 536                           &(struct timeval){ 0, 500000 });
 537 #endif
 538         switch (val)
 539         {
 540             case -1:
 541                 if (errno != EINTR)
 542                 {
 543                     msg_Err (p_this, "Write error: %s",
 544                              net_strerror (net_errno));
 545                     return i_total ? (int)i_total : -1;
 546                 }
 547
 548             case 0:
 549                 continue;
 550         }
 551
 552         if (p_vs != NULL)
 553             val = p_vs->pf_send (p_vs->p_sys, p_data, i_data);
 554         else
 555 #if defined(WIN32) || defined(UNDER_CE)
 556             val = send (fd, p_data, i_data, 0);
 557 #else
 558             val = write (fd, p_data, i_data);
 559 #endif
 560
 561         if (val == -1)
 562             return i_total ? (int)i_total : -1;
 563         if (val == 0)
 564             return i_total;
 565
 566         p_data += val;
 567         i_data -= val;
 568         i_total += val;
 569     }
 570
 571     return i_total;
 572 }
 573
 574 char *__net_Gets( vlc_object_t *p_this, int fd, const v_socket_t *p_vs )
 575 {
 576     char *psz_line = NULL, *ptr = NULL;
 577     size_t  i_line = 0, i_max = 0;
 578
 579
 580     for( ;; )
 581     {
 582         if( i_line == i_max )
 583         {
 584             i_max += 1024;
 585             psz_line = realloc( psz_line, i_max );
 586             ptr = psz_line + i_line;
 587         }
 588
 589         if( net_Read( p_this, fd, p_vs, (uint8_t *)ptr, 1, VLC_TRUE ) != 1 )
 590         {
 591             if( i_line == 0 )
 592             {
 593                 free( psz_line );
 594                 return NULL;
 595             }
 596             break;
 597         }
 598
 599         if ( *ptr == '\n' )
 600             break;
 601
 602         i_line++;
 603         ptr++;
 604     }
 605
 606     *ptr-- = '\0';
 607
 608     if( ( ptr >= psz_line ) && ( *ptr == '\r' ) )
 609         *ptr = '\0';
 610
 611     return psz_line;
 612 }
 613
 614 int net_Printf( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
 615                 const char *psz_fmt, ... )
 616 {
 617     int i_ret;
 618     va_list args;
 619     va_start( args, psz_fmt );
 620     i_ret = net_vaPrintf( p_this, fd, p_vs, psz_fmt, args );
 621     va_end( args );
 622
 623     return i_ret;
 624 }
 625
 626 int __net_vaPrintf( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
 627                     const char *psz_fmt, va_list args )
 628 {
 629     char    *psz;
 630     int     i_size, i_ret;
 631
 632     i_size = vasprintf( &psz, psz_fmt, args );
 633     i_ret = __net_Write( p_this, fd, p_vs, (uint8_t *)psz, i_size ) < i_size
 634         ? -1 : i_size;
 635     free( psz );
 636
 637     return i_ret;
 638 }
 639
 640
 641 /*****************************************************************************
 642  * inet_pton replacement for obsolete and/or crap operating systems
 643  *****************************************************************************/
 644 #ifndef HAVE_INET_PTON
 645 int inet_pton(int af, const char *src, void *dst)
 646 {
 647 # ifdef WIN32
 648     /* As we already know, Microsoft always go its own way, so even if they do
 649      * provide IPv6, they don't provide the API. */
 650     struct sockaddr_storage addr;
 651     int len = sizeof( addr );
 652
 653     /* Damn it, they didn't even put LPCSTR for the firs parameter!!! */
 654 #ifdef UNICODE
 655     wchar_t *workaround_for_ill_designed_api =
 656         malloc( MAX_PATH * sizeof(wchar_t) );
 657     mbstowcs( workaround_for_ill_designed_api, src, MAX_PATH );
 658     workaround_for_ill_designed_api[MAX_PATH-1] = 0;
 659 #else
 660     char *workaround_for_ill_designed_api = strdup( src );
 661 #endif
 662
 663     if( !WSAStringToAddress( workaround_for_ill_designed_api, af, NULL,
 664                              (LPSOCKADDR)&addr, &len ) )
 665     {
 666         free( workaround_for_ill_designed_api );
 667         return -1;
 668     }
 669     free( workaround_for_ill_designed_api );
 670
 671     switch( af )
 672     {
 673         case AF_INET6:
 674             memcpy( dst, &((struct sockaddr_in6 *)&addr)->sin6_addr, 16 );
 675             break;
 676
 677         case AF_INET:
 678             memcpy( dst, &((struct sockaddr_in *)&addr)->sin_addr, 4 );
 679             break;
 680
 681         default:
 682             WSASetLastError( WSAEAFNOSUPPORT );
 683             return -1;
 684     }
 685 # else
 686     /* Assume IPv6 is not supported. */
 687     /* Would be safer and more simpler to use inet_aton() but it is most
 688      * likely not provided either. */
 689     uint32_t ipv4;
 690
 691     if( af != AF_INET )
 692     {
 693         errno = EAFNOSUPPORT;
 694         return -1;
 695     }
 696
 697     ipv4 = inet_addr( src );
 698     if( ipv4 == INADDR_NONE )
 699         return -1;
 700
 701     memcpy( dst, &ipv4, 4 );
 702 # endif /* WIN32 */
 703     return 0;
 704 }
 705 #endif /* HAVE_INET_PTON */