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