/*****************************************************************************
- * net.c:
+ * io.c: network I/O functions
*****************************************************************************
- * Copyright (C) 2004-2005 the VideoLAN team
+ * Copyright (C) 2004-2005, 2007 the VideoLAN team
+ * Copyright © 2005-2006 Rémi Denis-Courmont
* $Id$
*
* Authors: Laurent Aimar <fenrir@videolan.org>
* Rémi Denis-Courmont <rem # videolan.org>
+ * Christophe Mutricy <xtophe at videolan dot org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
-#include <stdlib.h>
+
#include <vlc/vlc.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>
+
#include <errno.h>
+#include <assert.h>
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
+#ifdef HAVE_POLL
+# include <poll.h>
+#endif
-#include "network.h"
+#include <vlc_network.h>
#ifndef INADDR_ANY
# define INADDR_ANY 0x00000000
# define INADDR_NONE 0xFFFFFFFF
#endif
-static int SocksNegociate( vlc_object_t *, int fd, int i_socks_version,
- char *psz_socks_user, char *psz_socks_passwd );
-static int SocksHandshakeTCP( vlc_object_t *,
- int fd, int i_socks_version,
- char *psz_socks_user, char *psz_socks_passwd,
- const char *psz_host, int i_port );
+#if defined(WIN32) || defined(UNDER_CE)
+# undef EAFNOSUPPORT
+# define EAFNOSUPPORT WSAEAFNOSUPPORT
+#endif
+
+extern int rootwrap_bind (int family, int socktype, int protocol,
+ const struct sockaddr *addr, size_t alen);
-static int net_Socket( vlc_object_t *p_this, int i_family, int i_socktype,
- int i_protocol )
+int net_SetupSocket (int fd)
{
- int fd, i_val;
-
- fd = socket( i_family, i_socktype, i_protocol );
- if( fd == -1 )
- {
-#if defined(WIN32) || defined(UNDER_CE)
- if( WSAGetLastError ( ) != WSAEAFNOSUPPORT )
- msg_Warn( p_this, "cannot create socket (%i)",
- WSAGetLastError() );
+#if defined (WIN32) || defined (UNDER_CE)
+ ioctlsocket (fd, FIONBIO, &(unsigned long){ 1 });
#else
- if( errno != EAFNOSUPPORT )
- msg_Warn( p_this, "cannot create socket (%s)",
- strerror( errno ) );
+ fcntl (fd, F_SETFD, FD_CLOEXEC);
+ fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
#endif
- return -1;
- }
- /* Set to non-blocking */
-#if defined( WIN32 ) || defined( UNDER_CE )
+ setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof (int));
+ return 0;
+}
+
+
+int net_Socket (vlc_object_t *p_this, int family, int socktype,
+ int protocol)
+{
+ int fd = socket (family, socktype, protocol);
+ if (fd == -1)
{
- unsigned long i_dummy = 1;
- if( ioctlsocket( fd, FIONBIO, &i_dummy ) != 0 )
- msg_Err( p_this, "cannot set socket to non-blocking mode" );
+ if (net_errno != EAFNOSUPPORT)
+ msg_Err (p_this, "cannot create socket: %s",
+ net_strerror (net_errno));
+ return -1;
}
-#else
- if( ( ( i_val = fcntl( fd, F_GETFL, 0 ) ) < 0 ) ||
- ( fcntl( fd, F_SETFL, i_val | O_NONBLOCK ) < 0 ) )
- msg_Err( p_this, "cannot set socket to non-blocking mode (%s)",
- strerror( errno ) );
-#endif
- i_val = 1;
- setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, (void *)&i_val,
- sizeof( i_val ) );
+ net_SetupSocket (fd);
#ifdef IPV6_V6ONLY
/*
- * Accepts only IPv6 connections on IPv6 sockets
- * (and open an IPv4 socket later as well if needed).
- * Only Linux and FreeBSD can map IPv4 connections on IPv6 sockets,
- * so this allows for more uniform handling across platforms. Besides,
- * it makes sure that IPv4 addresses will be printed as w.x.y.z rather
- * than ::ffff:w.x.y.z
+ * Accepts only IPv6 connections on IPv6 sockets.
+ * If possible, we should open two sockets, but it is not always possible.
*/
- if( i_family == AF_INET6 )
- setsockopt( fd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&i_val,
- sizeof( i_val ) );
+ if (family == AF_INET6)
+ setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &(int){ 1 }, sizeof (int));
#endif
-#if defined( WIN32 ) || defined( UNDER_CE )
+#if defined (WIN32) || defined (UNDER_CE)
# ifndef IPV6_PROTECTION_LEVEL
+# warning Please update your C library headers.
# define IPV6_PROTECTION_LEVEL 23
+# define PROTECTION_LEVEL_UNRESTRICTED 10
# endif
- if( i_family == AF_INET6 )
- {
- i_val = 30 /*PROTECTION_LEVEL_UNRESTRICTED*/;
- setsockopt( fd, IPPROTO_IPV6, IPV6_PROTECTION_LEVEL,
- (const char*)&i_val, sizeof( i_val ) );
- }
+ if (family == AF_INET6)
+ setsockopt (fd, IPPROTO_IPV6, IPV6_PROTECTION_LEVEL,
+ &(int){ PROTECTION_LEVEL_UNRESTRICTED }, sizeof (int));
#endif
+
return fd;
}
-/*****************************************************************************
- * __net_ConnectTCP:
- *****************************************************************************
- * Open a TCP connection and return a handle
- *****************************************************************************/
-int __net_ConnectTCP( vlc_object_t *p_this, const char *psz_host, int i_port )
-{
- struct addrinfo hints, *res, *ptr;
- const char *psz_realhost;
- char *psz_socks;
- int i_realport, i_val, i_handle = -1;
- vlc_bool_t b_unreach = VLC_FALSE;
- if( i_port == 0 )
- i_port = 80; /* historical VLC thing */
-
- memset( &hints, 0, sizeof( hints ) );
- hints.ai_socktype = SOCK_STREAM;
-
- psz_socks = var_CreateGetString( p_this, "socks" );
- if( *psz_socks && *psz_socks != ':' )
- {
- char *psz = strchr( psz_socks, ':' );
+int *net_Listen (vlc_object_t *p_this, const char *psz_host,
+ int i_port, int family, int socktype, int protocol)
+{
+ struct addrinfo hints, *res;
- if( psz )
- *psz++ = '\0';
+ memset (&hints, 0, sizeof( hints ));
+ hints.ai_family = family;
+ hints.ai_socktype = socktype;
+ hints.ai_flags = AI_PASSIVE;
- psz_realhost = psz_socks;
- i_realport = ( psz != NULL ) ? atoi( psz ) : 1080;
+ msg_Dbg (p_this, "net: listening to %s port %d", psz_host, i_port);
- msg_Dbg( p_this, "net: connecting to %s port %d for %s port %d",
- psz_realhost, i_realport, psz_host, i_port );
- }
- else
+ int i_val = vlc_getaddrinfo (p_this, psz_host, i_port, &hints, &res);
+ if (i_val)
{
- psz_realhost = psz_host;
- i_realport = i_port;
-
- msg_Dbg( p_this, "net: connecting to %s port %d", psz_realhost,
- i_realport );
+ msg_Err (p_this, "Cannot resolve %s port %d : %s", psz_host, i_port,
+ vlc_gai_strerror (i_val));
+ return NULL;
}
- i_val = vlc_getaddrinfo( p_this, psz_realhost, i_realport, &hints, &res );
- if( i_val )
- {
- msg_Err( p_this, "cannot resolve %s port %d : %s", psz_realhost,
- i_realport, vlc_gai_strerror( i_val ) );
- free( psz_socks );
- return -1;
- }
+ int *sockv = NULL;
+ unsigned sockc = 0;
- for( ptr = res; (ptr != NULL) && (i_handle == -1); ptr = ptr->ai_next )
+ for (struct addrinfo *ptr = res; ptr != NULL; ptr = ptr->ai_next)
{
- int fd;
-
- fd = net_Socket( p_this, ptr->ai_family, ptr->ai_socktype,
- ptr->ai_protocol );
- if( fd == -1 )
+ int fd = net_Socket (p_this, ptr->ai_family, ptr->ai_socktype,
+ protocol ?: ptr->ai_protocol);
+ if (fd == -1)
+ {
+ msg_Dbg (p_this, "socket error: %s", net_strerror (net_errno));
continue;
+ }
- if( connect( fd, ptr->ai_addr, ptr->ai_addrlen ) )
+ /* Bind the socket */
+#if defined (WIN32) || defined (UNDER_CE)
+ /*
+ * Under Win32 and for multicasting, we bind to INADDR_ANY.
+ * This is of course a severe bug, since the socket would logically
+ * receive unicast traffic, and multicast traffic of groups subscribed
+ * to via other sockets.
+ */
+ if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen)
+ && (sizeof (struct sockaddr_storage) >= ptr->ai_addrlen))
{
- socklen_t i_val_size = sizeof( i_val );
- div_t d;
- struct timeval tv;
- vlc_value_t timeout;
-
-#if defined( WIN32 ) || defined( UNDER_CE )
- if( WSAGetLastError() != WSAEWOULDBLOCK )
- {
- if( WSAGetLastError () == WSAENETUNREACH )
- b_unreach = VLC_TRUE;
- else
- msg_Warn( p_this, "connection to %s port %d failed (%d)",
- psz_host, i_port, WSAGetLastError( ) );
- net_Close( fd );
- continue;
- }
-#else
- if( errno != EINPROGRESS )
- {
- if( errno == ENETUNREACH )
- b_unreach = VLC_TRUE;
- else
- msg_Warn( p_this, "connection to %s port %d : %s", psz_host,
- i_port, strerror( errno ) );
- net_Close( fd );
- continue;
- }
-#endif
-
- var_Create( p_this, "ipv4-timeout",
- VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
- var_Get( p_this, "ipv4-timeout", &timeout );
- if( timeout.i_int < 0 )
+ // This works for IPv4 too - don't worry!
+ struct sockaddr_in6 dumb =
{
- msg_Err( p_this, "invalid negative value for ipv4-timeout" );
- timeout.i_int = 0;
- }
- d = div( timeout.i_int, 100 );
+ .sin6_family = ptr->ai_addr->sa_family,
+ .sin6_port = ((struct sockaddr_in *)(ptr->ai_addr))->sin_port
+ };
- msg_Dbg( p_this, "connection in progress" );
- do
+ bind (fd, (struct sockaddr *)&dumb, ptr->ai_addrlen);
+ }
+ else
+#endif
+ if (bind (fd, ptr->ai_addr, ptr->ai_addrlen))
+ {
+ int saved_errno = net_errno;
+
+ net_Close (fd);
+#if !defined(WIN32) && !defined(UNDER_CE)
+ fd = rootwrap_bind (ptr->ai_family, ptr->ai_socktype,
+ protocol ?: ptr->ai_protocol, ptr->ai_addr,
+ ptr->ai_addrlen);
+ if (fd != -1)
{
- fd_set fds;
-
- if( p_this->b_die )
- {
- msg_Dbg( p_this, "connection aborted" );
- net_Close( fd );
- vlc_freeaddrinfo( res );
- free( psz_socks );
- return -1;
- }
-
- /* Initialize file descriptor set */
- FD_ZERO( &fds );
- FD_SET( fd, &fds );
-
- /* We'll wait 0.1 second if nothing happens */
- tv.tv_sec = 0;
- tv.tv_usec = (d.quot > 0) ? 100000 : (1000 * d.rem);
-
- i_val = select( fd + 1, NULL, &fds, NULL, &tv );
-
- if( d.quot <= 0 )
- {
- msg_Dbg( p_this, "connection timed out" );
- net_Close( fd );
- fd = -1;
- break;
- }
-
- d.quot--;
+ msg_Dbg (p_this, "got socket %d from rootwrap", fd);
}
- while( ( i_val == 0 ) || ( ( i_val < 0 ) &&
-#if defined( WIN32 ) || defined( UNDER_CE )
- ( WSAGetLastError() == WSAEWOULDBLOCK )
-#else
- ( errno == EINTR )
+ else
#endif
- ) );
-
- if( fd == -1 )
- continue; /* timeout */
-
- if( i_val < 0 )
{
- msg_Warn( p_this, "connection aborted (select failed)" );
- net_Close( fd );
+ msg_Err (p_this, "socket bind error (%s)",
+ net_strerror( saved_errno ) );
continue;
}
+ }
-#if !defined( SYS_BEOS ) && !defined( UNDER_CE )
- if( getsockopt( fd, SOL_SOCKET, SO_ERROR, (void*)&i_val,
- &i_val_size ) == -1 || i_val != 0 )
+ if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen))
+ {
+ if (net_Subscribe (p_this, fd, ptr->ai_addr, ptr->ai_addrlen))
{
- if( i_val == ENETUNREACH )
- b_unreach = VLC_TRUE;
- else
- {
-#ifdef WIN32
- msg_Warn( p_this, "connection to %s port %d failed (%d)",
- psz_host, i_port, WSAGetLastError( ) );
-#else
- msg_Warn( p_this, "connection to %s port %d : %s", psz_host,
- i_port, strerror( i_val ) );
-#endif
- }
- net_Close( fd );
+ net_Close (fd);
continue;
}
-#endif
}
- i_handle = fd; /* success! */
- }
-
- vlc_freeaddrinfo( res );
-
- if( i_handle == -1 )
- {
- if( b_unreach )
- msg_Err( p_this, "Host %s port %d is unreachable", psz_host,
- i_port );
- return -1;
- }
-
- if( *psz_socks && *psz_socks != ':' )
- {
- char *psz_user = var_CreateGetString( p_this, "socks-user" );
- char *psz_pwd = var_CreateGetString( p_this, "socks-pwd" );
- if( SocksHandshakeTCP( p_this, i_handle, 5, psz_user, psz_pwd,
- psz_host, i_port ) )
+ /* Listen */
+ switch (ptr->ai_socktype)
{
- msg_Err( p_this, "failed to use the SOCKS server" );
- net_Close( i_handle );
- i_handle = -1;
+ case SOCK_STREAM:
+ case SOCK_RDM:
+ case SOCK_SEQPACKET:
+#ifdef SOCK_DCCP
+ case SOCK_DCCP:
+#endif
+ if (listen (fd, INT_MAX))
+ {
+ msg_Err (p_this, "socket listen error (%s)",
+ net_strerror (net_errno));
+ net_Close (fd);
+ continue;
+ }
}
- free( psz_user );
- free( psz_pwd );
+ int *nsockv = (int *)realloc (sockv, (sockc + 2) * sizeof (int));
+ if (nsockv != NULL)
+ {
+ nsockv[sockc++] = fd;
+ sockv = nsockv;
+ }
+ else
+ net_Close (fd);
}
- free( psz_socks );
-
- return i_handle;
-}
+ vlc_freeaddrinfo (res);
-/*****************************************************************************
- * __net_ListenTCP:
- *****************************************************************************
- * Open TCP passive "listening" socket(s)
- * This function returns NULL in case of error.
- *****************************************************************************/
-int *__net_ListenTCP( vlc_object_t *p_this, const char *psz_host, int i_port )
-{
- struct addrinfo hints, *res, *ptr;
- int i_val, *pi_handles, i_size;
+ if (sockv != NULL)
+ sockv[sockc] = -1;
- memset( &hints, 0, sizeof( hints ) );
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_flags = AI_PASSIVE;
-
- msg_Dbg( p_this, "net: listening to %s port %d", psz_host, i_port );
+ return sockv;
+}
- i_val = vlc_getaddrinfo( p_this, psz_host, i_port, &hints, &res );
- if( i_val )
- {
- msg_Err( p_this, "cannot resolve %s port %d : %s", psz_host, i_port,
- vlc_gai_strerror( i_val ) );
- return NULL;
- }
- pi_handles = NULL;
- i_size = 1;
+static ssize_t
+net_ReadInner (vlc_object_t *restrict p_this, unsigned fdc, const int *fdv,
+ const v_socket_t *const *restrict vsv,
+ uint8_t *restrict p_buf, size_t i_buflen, vlc_bool_t waitall)
+{
+ size_t i_total = 0;
- for( ptr = res; ptr != NULL; ptr = ptr->ai_next )
+ while (i_buflen > 0)
{
- int fd, *newpi;
-
- fd = net_Socket( p_this, ptr->ai_family, ptr->ai_socktype,
- ptr->ai_protocol );
- if( fd == -1 )
- continue;
-
- /* Bind the socket */
- if( bind( fd, ptr->ai_addr, ptr->ai_addrlen ) )
+ if( ( p_this->b_die ) || ( p_this->p_libvlc->b_die ) )
{
#if defined(WIN32) || defined(UNDER_CE)
- msg_Warn( p_this, "cannot bind socket (%i)", WSAGetLastError( ) );
+ WSASetLastError (WSAEINTR);
#else
- msg_Warn( p_this, "cannot bind socket (%s)", strerror( errno ) );
+ errno = EINTR;
#endif
- net_Close( fd );
- continue;
+ goto error;
}
- /* Listen */
- if( listen( fd, 100 ) == -1 )
- {
-#if defined(WIN32) || defined(UNDER_CE)
- msg_Err( p_this, "cannot bring socket in listening mode (%i)",
- WSAGetLastError());
-#else
- msg_Err( p_this, "cannot bring the socket in listening mode (%s)",
- strerror( errno ) );
-#endif
- net_Close( fd );
- continue;
- }
+ struct pollfd ufd[fdc];
- newpi = (int *)realloc( pi_handles, (++i_size) * sizeof( int ) );
- if( newpi == NULL )
- {
- net_Close( fd );
- break;
- }
- else
+ for (unsigned i = 0; i < fdc; i++)
{
- newpi[i_size - 2] = fd;
- pi_handles = newpi;
+ ufd[i].fd = fdv[i];
+ ufd[i].events = POLLIN;
+ ufd[i].revents = 0;
}
- }
-
- vlc_freeaddrinfo( res );
-
- if( pi_handles != NULL )
- pi_handles[i_size - 1] = -1;
- return pi_handles;
-}
-
-/*****************************************************************************
- * __net_Accept:
- *****************************************************************************
- * Accept a connection on a set of listening sockets and return it
- *****************************************************************************/
-int __net_Accept( vlc_object_t *p_this, int *pi_fd, mtime_t i_wait )
-{
- vlc_bool_t b_die = p_this->b_die, b_block = (i_wait < 0);
-
- while( p_this->b_die == b_die )
- {
- int i_val = -1, *pi, *pi_end;
- struct timeval timeout;
- fd_set fds_r, fds_e;
- pi = pi_fd;
-
- /* Initialize file descriptor set */
- FD_ZERO( &fds_r );
- FD_ZERO( &fds_e );
-
- for( pi = pi_fd; *pi != -1; pi++ )
+ switch (poll (ufd, fdc, 500))
{
- int i_fd = *pi;
+ case -1:
+ goto error;
- if( i_fd > i_val )
- i_val = i_fd;
-
- FD_SET( i_fd, &fds_r );
- FD_SET( i_fd, &fds_e );
- }
- pi_end = pi;
-
- timeout.tv_sec = 0;
- timeout.tv_usec = b_block ? 500000 : i_wait;
-
- i_val = select( i_val + 1, &fds_r, NULL, &fds_e, &timeout );
- if( ( ( i_val < 0 ) && ( errno == EINTR ) ) || i_val == 0 )
- {
- if( b_block )
+ case 0: // timeout
continue;
- else
- return -1;
- }
- else if( i_val < 0 )
- {
-#if defined(WIN32) || defined(UNDER_CE)
- msg_Err( p_this, "network select error (%i)", WSAGetLastError() );
-#else
- msg_Err( p_this, "network select error (%s)", strerror( errno ) );
-#endif
- return -1;
}
- for( pi = pi_fd; *pi != -1; pi++ )
+ for (unsigned i = 0;; i++)
{
- int i_fd = *pi;
+ assert (i < fdc); /* no events found = bug ! */
- if( !FD_ISSET( i_fd, &fds_r ) && !FD_ISSET( i_fd, &fds_e ) )
+ if (ufd[i].revents == 0)
continue;
- i_val = accept( i_fd, NULL, 0 );
- if( i_val < 0 )
- {
-#if defined(WIN32) || defined(UNDER_CE)
- msg_Err( p_this, "accept failed (%i)", WSAGetLastError() );
-#else
- msg_Err( p_this, "accept failed (%s)", strerror( errno ) );
+#ifndef POLLRDHUP /* This is nice but non-portable */
+# define POLLRDHUP 0
#endif
+ if (i_total > 0)
+ {
+ // Errors (-1) and EOF (0) will be returned on next run
+ if (ufd[i].revents & (POLLERR|POLLNVAL|POLLRDHUP))
+ return i_total;
}
else
{
- /*
- * This round-robin trick ensures that the first sockets in
- * pi_fd won't prevent the last ones from getting accept'ed.
- */
- --pi_end;
- memmove( pi, pi + 1, pi_end - pi );
- *pi_end = i_fd;
- return i_val;
+ if (ufd[i].revents & POLLRDHUP)
+ return 0; // EOF, read() would yield 0
}
- }
- }
-
- return -1;
-}
+ fdc = 1;
+ fdv += i;
+ vsv += i;
-/*****************************************************************************
- * __net_ConnectUDP:
- *****************************************************************************
- * Open a UDP socket to send data to a defined destination, with an optional
- * hop limit.
- *****************************************************************************/
-int __net_ConnectUDP( vlc_object_t *p_this, const char *psz_host, int i_port,
- int hlim )
-{
- struct addrinfo hints, *res, *ptr;
- int i_val, i_handle = -1;
- vlc_bool_t b_unreach = VLC_FALSE;
-
- if( i_port == 0 )
- i_port = 1234; /* historical VLC thing */
-
- memset( &hints, 0, sizeof( hints ) );
- hints.ai_socktype = SOCK_DGRAM;
-
- msg_Dbg( p_this, "net: connecting to %s port %d", psz_host, i_port );
-
- i_val = vlc_getaddrinfo( p_this, psz_host, i_port, &hints, &res );
- if( i_val )
- {
- msg_Err( p_this, "cannot resolve %s port %d : %s", psz_host, i_port,
- vlc_gai_strerror( i_val ) );
- return -1;
- }
-
- for( ptr = res; ptr != NULL; ptr = ptr->ai_next )
- {
- int fd;
-
- fd = net_Socket( p_this, ptr->ai_family, ptr->ai_socktype,
- ptr->ai_protocol );
- if( fd == -1 )
- continue;
-#if !defined( SYS_BEOS )
- else
- {
- int i_val;
-
- /* Increase the receive buffer size to 1/2MB (8Mb/s during 1/2s) to avoid
- * packet loss caused by scheduling problems */
- i_val = 0x80000;
- setsockopt( i_handle, SOL_SOCKET, SO_RCVBUF, (void *)&i_val,
- sizeof( i_val ) );
- i_val = 0x80000;
- setsockopt( i_handle, SOL_SOCKET, SO_SNDBUF, (void *)&i_val,
- sizeof( i_val ) );
- }
-#endif
-
- if( connect( fd, ptr->ai_addr, ptr->ai_addrlen ) == 0 )
- {
- /* success */
- i_handle = fd;
break;
}
-#if defined( WIN32 ) || defined( UNDER_CE )
- if( WSAGetLastError () == WSAENETUNREACH )
-#else
- if( errno == ENETUNREACH )
-#endif
- b_unreach = VLC_TRUE;
- else
- {
- msg_Warn( p_this, "%s port %d : %s", psz_host, i_port,
- strerror( errno ) );
- net_Close( fd );
- continue;
- }
- }
-
- vlc_freeaddrinfo( res );
-
- if( i_handle == -1 )
- {
- if( b_unreach )
- msg_Err( p_this, "Host %s port %d is unreachable", psz_host,
- i_port );
- return -1;
- }
-
- return i_handle;
-}
-
-/*****************************************************************************
- * __net_OpenUDP:
- *****************************************************************************
- * Open a UDP connection and return a handle
- *****************************************************************************/
-int __net_OpenUDP( vlc_object_t *p_this, const char *psz_bind, int i_bind,
- const char *psz_server, int i_server )
-{
- vlc_value_t v4, v6;
- void *private;
- network_socket_t sock;
- module_t *p_network = NULL;
-
- if( ( psz_server != NULL ) && ( psz_server[0] == '\0' ) )
- msg_Warn( p_this, "calling net_OpenUDP with an explicit destination "
- "is obsolete - use net_ConnectUDP instead" );
- if( i_server != 0 )
- msg_Warn( p_this, "calling net_OpenUDP with an explicit destination "
- "port is obsolete - use __net_ConnectUDP instead" );
-
- if( psz_server == NULL ) psz_server = "";
- if( psz_bind == NULL ) psz_bind = "";
-
- /* Prepare the network_socket_t structure */
- sock.psz_bind_addr = psz_bind;
- sock.i_bind_port = i_bind;
- sock.psz_server_addr = psz_server;
- sock.i_server_port = i_server;
- sock.i_ttl = 0;
- sock.v6only = 0;
- sock.i_handle = -1;
-
- msg_Dbg( p_this, "net: connecting to '[%s]:%d@[%s]:%d'",
- psz_server, i_server, psz_bind, i_bind );
-
- /* Check if we have force ipv4 or ipv6 */
- var_Create( p_this, "ipv4", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
- var_Get( p_this, "ipv4", &v4 );
- var_Create( p_this, "ipv6", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
- var_Get( p_this, "ipv6", &v6 );
-
- if( !v4.b_bool )
- {
- if( v6.b_bool )
- sock.v6only = 1;
-
- /* try IPv6 first (unless IPv4 forced) */
- private = p_this->p_private;
- p_this->p_private = (void*)&sock;
- p_network = module_Need( p_this, "network", "ipv6", VLC_TRUE );
-
- if( p_network != NULL )
- module_Unneed( p_this, p_network );
-
- p_this->p_private = private;
-
- /*
- * Check if the IP stack can receive IPv4 packets on IPv6 sockets.
- * If yes, then it is better to use the IPv6 socket.
- * Otherwise, if we also get an IPv4, we have to choose, so we use
- * IPv4 only.
- */
- if( ( sock.i_handle != -1 ) && ( ( sock.v6only == 0 ) || v6.b_bool ) )
- return sock.i_handle;
- }
-
- if( !v6.b_bool )
- {
- int fd6 = sock.i_handle;
-
- /* also try IPv4 (unless IPv6 forced) */
- private = p_this->p_private;
- p_this->p_private = (void*)&sock;
- p_network = module_Need( p_this, "network", "ipv4", VLC_TRUE );
-
- if( p_network != NULL )
- module_Unneed( p_this, p_network );
-
- p_this->p_private = private;
-
- if( fd6 != -1 )
+ ssize_t n;
+ if (*vsv != NULL)
{
- if( sock.i_handle != -1 )
- {
- msg_Warn( p_this, "net: lame IPv6/IPv4 dual-stack present. "
- "Using only IPv4." );
- net_Close( fd6 );
- }
- else
- sock.i_handle = fd6;
+ n = (*vsv)->pf_recv ((*vsv)->p_sys, p_buf, i_buflen);
}
- }
-
- if( sock.i_handle == -1 )
- msg_Dbg( p_this, "net: connection to '[%s]:%d@[%s]:%d' failed",
- psz_server, i_server, psz_bind, i_bind );
-
- return sock.i_handle;
-}
-
-/*****************************************************************************
- * __net_Close:
- *****************************************************************************
- * Close a network handle
- *****************************************************************************/
-void net_Close( int fd )
-{
-#ifdef UNDER_CE
- CloseHandle( (HANDLE)fd );
-#elif defined( WIN32 )
- closesocket( fd );
-#else
- close( fd );
-#endif
-}
-
-void net_ListenClose( int *pi_fd )
-{
- if( pi_fd != NULL )
- {
- int *pi;
-
- for( pi = pi_fd; *pi != -1; pi++ )
- net_Close( *pi );
- free( pi_fd );
- }
-}
-
-/*****************************************************************************
- * __net_Read:
- *****************************************************************************
- * Read from a network socket
- * If b_retry is true, then we repeat until we have read the right amount of
- * data
- *****************************************************************************/
-int __net_Read( vlc_object_t *p_this, int fd, v_socket_t *p_vs,
- uint8_t *p_data, int i_data, vlc_bool_t b_retry )
-{
- struct timeval timeout;
- fd_set fds_r, fds_e;
- int i_recv;
- int i_total = 0;
- int i_ret;
- vlc_bool_t b_die = p_this->b_die;
-
- while( i_data > 0 )
- {
- do
- {
- if( p_this->b_die != b_die )
- {
- return 0;
- }
-
- /* Initialize file descriptor set */
- FD_ZERO( &fds_r );
- FD_SET( fd, &fds_r );
- FD_ZERO( &fds_e );
- FD_SET( fd, &fds_e );
-
- /* We'll wait 0.5 second if nothing happens */
- timeout.tv_sec = 0;
- timeout.tv_usec = 500000;
-
- } while( (i_ret = select(fd + 1, &fds_r, NULL, &fds_e, &timeout)) == 0
- || ( i_ret < 0 && errno == EINTR ) );
-
- if( i_ret < 0 )
+ else
{
-#if defined(WIN32) || defined(UNDER_CE)
- msg_Err( p_this, "network select error (%d)", WSAGetLastError() );
+#ifdef WIN32
+ n = recv (*fdv, p_buf, i_buflen, 0);
#else
- msg_Err( p_this, "network select error (%s)", strerror(errno) );
+ n = read (*fdv, p_buf, i_buflen);
#endif
- return i_total > 0 ? i_total : -1;
}
- if( ( i_recv = (p_vs != NULL)
- ? p_vs->pf_recv( p_vs->p_sys, p_data, i_data )
- : recv( fd, p_data, i_data, 0 ) ) < 0 )
+ if (n == -1)
{
#if defined(WIN32) || defined(UNDER_CE)
- if( WSAGetLastError() == WSAEWOULDBLOCK )
+ switch (WSAGetLastError ())
{
- /* only happens with p_vs (SSL) - not really an error */
- }
- else
- /* For udp only */
- /* On win32 recv() will fail if the datagram doesn't fit inside
- * the passed buffer, even though the buffer will be filled with
- * the first part of the datagram. */
- if( WSAGetLastError() == WSAEMSGSIZE )
- {
- msg_Err( p_this, "recv() failed. "
- "Increase the mtu size (--mtu option)" );
- i_total += i_data;
+ case WSAEWOULDBLOCK:
+ /* only happens with vs != NULL (SSL) - not really an error */
+ continue;
+
+ case WSAEMSGSIZE:
+ /* For UDP only */
+ /* On Win32, recv() fails if the datagram doesn't fit inside
+ * the passed buffer, even though the buffer will be filled
+ * with the first part of the datagram. */
+ msg_Err (p_this, "Receive error: "
+ "Increase the mtu size (--mtu option)");
+ n = i_buflen;
+ break;
+
+ default:
+ goto error;
}
- else if( WSAGetLastError() == WSAEINTR ) continue;
- else msg_Err( p_this, "recv failed (%i)", WSAGetLastError() );
#else
- /* EAGAIN only happens with p_vs (TLS) and it's not an error */
- if( errno != EAGAIN )
- msg_Err( p_this, "recv failed (%s)", strerror(errno) );
+ /* spurious wake-up or TLS did not yield any actual data */
+ if (errno == EAGAIN)
+ continue;
+ goto error;
#endif
- return i_total > 0 ? i_total : -1;
- }
- else if( i_recv == 0 )
- {
- /* Connection closed */
- b_retry = VLC_FALSE;
}
- p_data += i_recv;
- i_data -= i_recv;
- i_total+= i_recv;
- if( !b_retry )
- {
+ i_total += n;
+ p_buf += n;
+ i_buflen -= n;
+
+ if ((n == 0) || !waitall)
break;
- }
}
return i_total;
+
+error:
+ msg_Err (p_this, "Read error: %s", net_strerror (net_errno));
+ return i_total ? (ssize_t)i_total : -1;
}
+
/*****************************************************************************
- * __net_ReadNonBlock:
+ * __net_Read:
*****************************************************************************
- * Read from a network socket, non blocking mode (with timeout)
+ * Read from a network socket
+ * If b_retry is true, then we repeat until we have read the right amount of
+ * data; in that case, a short count means EOF has been reached.
*****************************************************************************/
-int __net_ReadNonBlock( vlc_object_t *p_this, int fd, v_socket_t *p_vs,
- uint8_t *p_data, int i_data, mtime_t i_wait)
+ssize_t __net_Read( vlc_object_t *restrict p_this, int fd,
+ const v_socket_t *restrict p_vs,
+ uint8_t *restrict buf, size_t len, vlc_bool_t b_retry )
{
- struct timeval timeout;
- fd_set fds_r, fds_e;
- int i_recv;
- int i_ret;
-
- /* Initialize file descriptor set */
- FD_ZERO( &fds_r );
- FD_SET( fd, &fds_r );
- FD_ZERO( &fds_e );
- FD_SET( fd, &fds_e );
-
- timeout.tv_sec = 0;
- timeout.tv_usec = i_wait;
-
- i_ret = select(fd + 1, &fds_r, NULL, &fds_e, &timeout);
-
- if( i_ret < 0 && errno == EINTR )
- {
- return 0;
- }
- else if( i_ret < 0 )
- {
-#if defined(WIN32) || defined(UNDER_CE)
- msg_Err( p_this, "network select error (%d)", WSAGetLastError() );
-#else
- msg_Err( p_this, "network select error (%s)", strerror(errno) );
-#endif
- return -1;
- }
- else if( i_ret == 0)
- {
- return 0;
- }
- else
- {
-#if !defined(UNDER_CE)
- if( fd == 0/*STDIN_FILENO*/ ) i_recv = read( fd, p_data, i_data ); else
-#endif
- if( ( i_recv = (p_vs != NULL)
- ? p_vs->pf_recv( p_vs->p_sys, p_data, i_data )
- : recv( fd, p_data, i_data, 0 ) ) < 0 )
- {
-#if defined(WIN32) || defined(UNDER_CE)
- /* For udp only */
- /* On win32 recv() will fail if the datagram doesn't fit inside
- * the passed buffer, even though the buffer will be filled with
- * the first part of the datagram. */
- if( WSAGetLastError() == WSAEMSGSIZE )
- {
- msg_Err( p_this, "recv() failed. "
- "Increase the mtu size (--mtu option)" );
- }
- else msg_Err( p_this, "recv failed (%i)", WSAGetLastError() );
-#else
- msg_Err( p_this, "recv failed (%s)", strerror(errno) );
-#endif
- return -1;
- }
-
- return i_recv ? i_recv : -1; /* !i_recv -> connection closed if tcp */
- }
-
- /* We will never be here */
- return -1;
+ return net_ReadInner( p_this, 1, &(int){ fd },
+ &(const v_socket_t *){ p_vs },
+ buf, len, b_retry );
}
+
/*****************************************************************************
* __net_Select:
*****************************************************************************
- * Read from several sockets (with timeout). Takes data from the first socket
- * that has some.
+ * Read from several sockets. Takes data from the first socket that has some.
*****************************************************************************/
-int __net_Select( vlc_object_t *p_this, int *pi_fd, v_socket_t **pp_vs,
- int i_fd, uint8_t *p_data, int i_data, mtime_t i_wait )
+ssize_t __net_Select( vlc_object_t *restrict p_this,
+ const int *restrict fds, int nfd,
+ uint8_t *restrict buf, size_t len )
{
- struct timeval timeout;
- fd_set fds_r, fds_e;
- int i_recv;
- int i_ret;
- int i;
- int i_max_fd = 0;
-
- /* Initialize file descriptor set */
- FD_ZERO( &fds_r );
- FD_ZERO( &fds_e );
-
- for( i = 0 ; i < i_fd ; i++)
- {
- if( pi_fd[i] > i_max_fd ) i_max_fd = pi_fd[i];
- FD_SET( pi_fd[i], &fds_r );
- FD_SET( pi_fd[i], &fds_e );
- }
-
- timeout.tv_sec = 0;
- timeout.tv_usec = i_wait;
+ const v_socket_t *vsv[nfd];
+ memset( vsv, 0, sizeof (vsv) );
- i_ret = select( i_max_fd + 1, &fds_r, NULL, &fds_e, &timeout );
-
- if( i_ret < 0 && errno == EINTR )
- {
- return 0;
- }
- else if( i_ret < 0 )
- {
- msg_Err( p_this, "network select error (%s)", strerror(errno) );
- return -1;
- }
- else if( i_ret == 0 )
- {
- return 0;
- }
- else
- {
- for( i = 0 ; i < i_fd ; i++)
- {
- if( FD_ISSET( pi_fd[i], &fds_r ) )
- {
- i_recv = ((pp_vs != NULL) && (pp_vs[i] != NULL))
- ? pp_vs[i]->pf_recv( pp_vs[i]->p_sys, p_data, i_data )
- : recv( pi_fd[i], p_data, i_data, 0 );
- if( i_recv < 0 )
- {
-#ifdef WIN32
- /* For udp only */
- /* On win32 recv() will fail if the datagram doesn't
- * fit inside the passed buffer, even though the buffer
- * will be filled with the first part of the datagram. */
- if( WSAGetLastError() == WSAEMSGSIZE )
- {
- msg_Err( p_this, "recv() failed. "
- "Increase the mtu size (--mtu option)" );
- }
- else msg_Err( p_this, "recv failed (%i)",
- WSAGetLastError() );
-#else
- msg_Err( p_this, "recv failed (%s)", strerror(errno) );
-#endif
- return VLC_EGENERIC;
- }
-
- return i_recv;
- }
- }
- }
-
- /* We will never be here */
- return -1;
+ return net_ReadInner( p_this, nfd, fds, vsv,
+ buf, len, VLC_FALSE );
}
/* Write exact amount requested */
-int __net_Write( vlc_object_t *p_this, int fd, v_socket_t *p_vs,
- const uint8_t *p_data, int i_data )
+ssize_t __net_Write( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
+ const uint8_t *p_data, size_t i_data )
{
- struct timeval timeout;
- fd_set fds_w, fds_e;
- int i_send;
- int i_total = 0;
- int i_ret;
-
- vlc_bool_t b_die = p_this->b_die;
+ size_t i_total = 0;
while( i_data > 0 )
{
- do
- {
- if( p_this->b_die != b_die )
- {
- return 0;
- }
+ if( p_this->b_die )
+ break;
- /* Initialize file descriptor set */
- FD_ZERO( &fds_w );
- FD_SET( fd, &fds_w );
- FD_ZERO( &fds_e );
- FD_SET( fd, &fds_e );
+ struct pollfd ufd[1];
+ memset (ufd, 0, sizeof (ufd));
+ ufd[0].fd = fd;
+ ufd[0].events = POLLOUT;
- /* We'll wait 0.5 second if nothing happens */
- timeout.tv_sec = 0;
- timeout.tv_usec = 500000;
+ int val = poll (ufd, 1, 500);
+ switch (val)
+ {
+ case -1:
+ msg_Err (p_this, "Write error: %s", net_strerror (net_errno));
+ goto out;
+
+ case 0:
+ continue;
+ }
- } while( (i_ret = select(fd + 1, NULL, &fds_w, &fds_e, &timeout)) == 0
- || ( i_ret < 0 && errno == EINTR ) );
+ if ((ufd[0].revents & (POLLERR|POLLNVAL|POLLHUP)) && (i_total > 0))
+ return i_total; // error will be dequeued separately on next call
- if( i_ret < 0 )
- {
-#if defined(WIN32) || defined(UNDER_CE)
- msg_Err( p_this, "network select error (%d)", WSAGetLastError() );
+ if (p_vs != NULL)
+ val = p_vs->pf_send (p_vs->p_sys, p_data, i_data);
+ else
+#ifdef WIN32
+ val = send (fd, p_data, i_data, 0);
#else
- msg_Err( p_this, "network select error (%s)", strerror(errno) );
+ val = write (fd, p_data, i_data);
#endif
- return i_total > 0 ? i_total : -1;
- }
- if( ( i_send = (p_vs != NULL)
- ? p_vs->pf_send( p_vs->p_sys, p_data, i_data )
- : send( fd, p_data, i_data, 0 ) ) < 0 )
+ if (val == -1)
{
- /* XXX With udp for example, it will issue a message if the host
- * isn't listening */
- /* msg_Err( p_this, "send failed (%s)", strerror(errno) ); */
- return i_total > 0 ? i_total : -1;
+ msg_Err (p_this, "Write error: %s", net_strerror (net_errno));
+ break;
}
- p_data += i_send;
- i_data -= i_send;
- i_total+= i_send;
+ p_data += val;
+ i_data -= val;
+ i_total += val;
}
- return i_total;
+
+out:
+ if ((i_total > 0) || (i_data == 0))
+ return i_total;
+
+ return -1;
}
-char *__net_Gets( vlc_object_t *p_this, int fd, v_socket_t *p_vs )
+char *__net_Gets( vlc_object_t *p_this, int fd, const v_socket_t *p_vs )
{
char *psz_line = NULL, *ptr = NULL;
size_t i_line = 0, i_max = 0;
return psz_line;
}
-int net_Printf( vlc_object_t *p_this, int fd, v_socket_t *p_vs,
- const char *psz_fmt, ... )
+ssize_t net_Printf( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
+ const char *psz_fmt, ... )
{
int i_ret;
va_list args;
return i_ret;
}
-int __net_vaPrintf( vlc_object_t *p_this, int fd, v_socket_t *p_vs,
- const char *psz_fmt, va_list args )
+ssize_t __net_vaPrintf( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
+ const char *psz_fmt, va_list args )
{
char *psz;
int i_size, i_ret;
}
-
-/*****************************************************************************
- * SocksNegociate:
- *****************************************************************************
- * Negociate authentication with a SOCKS server.
- *****************************************************************************/
-static int SocksNegociate( vlc_object_t *p_obj,
- int fd, int i_socks_version,
- char *psz_socks_user,
- char *psz_socks_passwd )
-{
- uint8_t buffer[128+2*256];
- int i_len;
- vlc_bool_t b_auth = VLC_FALSE;
-
- if( i_socks_version != 5 )
- return VLC_SUCCESS;
-
- /* We negociate authentication */
-
- if( psz_socks_user && psz_socks_passwd &&
- *psz_socks_user && *psz_socks_passwd )
- b_auth = VLC_TRUE;
-
- buffer[0] = i_socks_version; /* SOCKS version */
- if( b_auth )
- {
- buffer[1] = 2; /* Number of methods */
- buffer[2] = 0x00; /* - No auth required */
- buffer[3] = 0x02; /* - USer/Password */
- i_len = 4;
- }
- else
- {
- buffer[1] = 1; /* Number of methods */
- buffer[2] = 0x00; /* - No auth required */
- i_len = 3;
- }
-
- if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
- return VLC_EGENERIC;
- if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
- return VLC_EGENERIC;
-
- msg_Dbg( p_obj, "socks: v=%d method=%x", buffer[0], buffer[1] );
-
- if( buffer[1] == 0x00 )
- {
- msg_Dbg( p_obj, "socks: no authentication required" );
- }
- else if( buffer[1] == 0x02 )
- {
- int i_len1 = __MIN( strlen(psz_socks_user), 255 );
- int i_len2 = __MIN( strlen(psz_socks_passwd), 255 );
- msg_Dbg( p_obj, "socks: username/password authentication" );
-
- /* XXX: we don't support user/pwd > 255 (truncated)*/
- buffer[0] = i_socks_version; /* Version */
- buffer[1] = i_len1; /* User length */
- memcpy( &buffer[2], psz_socks_user, i_len1 );
- buffer[2+i_len1] = i_len2; /* Password length */
- memcpy( &buffer[2+i_len1+1], psz_socks_passwd, i_len2 );
-
- i_len = 3 + i_len1 + i_len2;
-
- if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
- return VLC_EGENERIC;
-
- if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
- return VLC_EGENERIC;
-
- msg_Dbg( p_obj, "socks: v=%d status=%x", buffer[0], buffer[1] );
- if( buffer[1] != 0x00 )
- {
- msg_Err( p_obj, "socks: authentication rejected" );
- return VLC_EGENERIC;
- }
- }
- else
- {
- if( b_auth )
- msg_Err( p_obj, "socks: unsupported authentication method %x",
- buffer[0] );
- else
- msg_Err( p_obj, "socks: authentification needed" );
- return VLC_EGENERIC;
- }
-
- return VLC_SUCCESS;
-}
-
-/*****************************************************************************
- * SocksHandshakeTCP:
- *****************************************************************************
- * Open a TCP connection using a SOCKS server and return a handle (RFC 1928)
- *****************************************************************************/
-static int SocksHandshakeTCP( vlc_object_t *p_obj,
- int fd,
- int i_socks_version,
- char *psz_socks_user, char *psz_socks_passwd,
- const char *psz_host, int i_port )
-{
- uint8_t buffer[128+2*256];
-
- if( i_socks_version != 4 && i_socks_version != 5 )
- {
- msg_Warn( p_obj, "invalid socks protocol version %d", i_socks_version );
- i_socks_version = 5;
- }
-
- if( i_socks_version == 5 &&
- SocksNegociate( p_obj, fd, i_socks_version,
- psz_socks_user, psz_socks_passwd ) )
- return VLC_EGENERIC;
-
- if( i_socks_version == 4 )
- {
- struct addrinfo hints = { 0 }, *p_res;
-
- /* v4 only support ipv4 */
- hints.ai_family = AF_INET;
- if( vlc_getaddrinfo( p_obj, psz_host, 0, &hints, &p_res ) )
- return VLC_EGENERIC;
-
- buffer[0] = i_socks_version;
- buffer[1] = 0x01; /* CONNECT */
- SetWBE( &buffer[2], i_port ); /* Port */
- memcpy( &buffer[4], /* Address */
- &((struct sockaddr_in *)(p_res->ai_addr))->sin_addr, 4 );
- vlc_freeaddrinfo( p_res );
-
- buffer[8] = 0; /* Empty user id */
-
- if( net_Write( p_obj, fd, NULL, buffer, 9 ) != 9 )
- return VLC_EGENERIC;
- if( net_Read( p_obj, fd, NULL, buffer, 8, VLC_TRUE ) != 8 )
- return VLC_EGENERIC;
-
- msg_Dbg( p_obj, "socks: v=%d cd=%d",
- buffer[0], buffer[1] );
-
- if( buffer[1] != 90 )
- return VLC_EGENERIC;
- }
- else if( i_socks_version == 5 )
- {
- int i_hlen = __MIN(strlen( psz_host ), 255);
- int i_len;
-
- buffer[0] = i_socks_version; /* Version */
- buffer[1] = 0x01; /* Cmd: connect */
- buffer[2] = 0x00; /* Reserved */
- buffer[3] = 3; /* ATYP: for now domainname */
-
- buffer[4] = i_hlen;
- memcpy( &buffer[5], psz_host, i_hlen );
- SetWBE( &buffer[5+i_hlen], i_port );
-
- i_len = 5 + i_hlen + 2;
-
-
- if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
- return VLC_EGENERIC;
-
- /* Read the header */
- if( net_Read( p_obj, fd, NULL, buffer, 5, VLC_TRUE ) != 5 )
- return VLC_EGENERIC;
-
- msg_Dbg( p_obj, "socks: v=%d rep=%d atyp=%d",
- buffer[0], buffer[1], buffer[3] );
-
- if( buffer[1] != 0x00 )
- {
- msg_Err( p_obj, "socks: CONNECT request failed\n" );
- return VLC_EGENERIC;
- }
-
- /* Read the remaining bytes */
- if( buffer[3] == 0x01 )
- i_len = 4-1 + 2;
- else if( buffer[3] == 0x03 )
- i_len = buffer[4] + 2;
- else if( buffer[3] == 0x04 )
- i_len = 16-1+2;
- else
- return VLC_EGENERIC;
-
- if( net_Read( p_obj, fd, NULL, buffer, i_len, VLC_TRUE ) != i_len )
- return VLC_EGENERIC;
- }
-
- return VLC_SUCCESS;
-}
-
/*****************************************************************************
* inet_pton replacement for obsolete and/or crap operating systems
*****************************************************************************/
return 0;
}
#endif /* HAVE_INET_PTON */
+
+#ifndef HAVE_INET_NTOP
+#ifdef WIN32
+const char *inet_ntop(int af, const void * src,
+ char * dst, socklen_t cnt)
+{
+ switch( af )
+ {
+#ifdef AF_INET6
+ case AF_INET6:
+ {
+ struct sockaddr_in6 addr;
+ memset(&addr, 0, sizeof(addr));
+ addr.sin6_family = AF_INET6;
+ addr.sin6_addr = *((struct in6_addr*)src);
+ if( 0 == WSAAddressToStringA((LPSOCKADDR)&addr,
+ sizeof(struct sockaddr_in6),
+ NULL, dst, &cnt) )
+ {
+ dst[cnt] = '\0';
+ return dst;
+ }
+ errno = WSAGetLastError();
+ return NULL;
+
+ }
+
+#endif
+ case AF_INET:
+ {
+ struct sockaddr_in addr;
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr = *((struct in_addr*)src);
+ if( 0 == WSAAddressToStringA((LPSOCKADDR)&addr,
+ sizeof(struct sockaddr_in),
+ NULL, dst, &cnt) )
+ {
+ dst[cnt] = '\0';
+ return dst;
+ }
+ errno = WSAGetLastError();
+ return NULL;
+
+ }
+ }
+ errno = EAFNOSUPPORT;
+ return NULL;
+}
+#endif
+#endif
projects / vlc / blobdiff