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