X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fnetwork%2Fudp.c;h=d0938b9a9cc070118f26fdd3024299644177174d;hb=d253749f68a85d8c720e66e4a0f7ad9693ba84e3;hp=448f22c2ed0c6d9e0485e73ee1f7bc58cad55ee4;hpb=2cad86262f6f3c1e7d2aec08a1aa8f1a1015f413;p=vlc diff --git a/src/network/udp.c b/src/network/udp.c index 448f22c2ed..d0938b9a9c 100644 --- a/src/network/udp.c +++ b/src/network/udp.c @@ -2,7 +2,7 @@ * udp.c: ***************************************************************************** * Copyright (C) 2004-2006 the VideoLAN team - * Copyright © 2006 Rémi Denis-Courmont + * Copyright © 2006-2007 Rémi Denis-Courmont * * $Id$ * @@ -27,17 +27,19 @@ /***************************************************************************** * Preamble *****************************************************************************/ -#include -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include #include -#include #ifdef HAVE_SYS_TIME_H # include #endif -#include "network.h" +#include #ifdef WIN32 # if defined(UNDER_CE) @@ -55,6 +57,13 @@ # endif #endif +#ifdef HAVE_LINUX_DCCP_H +# include +# ifndef SOCK_DCCP /* provisional API */ +# define SOCK_DCCP 6 +# endif +#endif + #ifndef SOL_IP # define SOL_IP IPPROTO_IP #endif @@ -62,19 +71,123 @@ # define SOL_IPV6 IPPROTO_IPV6 #endif #ifndef IPPROTO_IPV6 -# define IPPROTO_IPV6 41 +# define IPPROTO_IPV6 41 /* IANA */ +#endif +#ifndef SOL_DCCP +# define SOL_DCCP IPPROTO_DCCP +#endif +#ifndef IPPROTO_DCCP +# define IPPROTO_DCCP 33 /* IANA */ +#endif +#ifndef SOL_UDPLITE +# define SOL_UDPLITE IPPROTO_UDPLITE +#endif +#ifndef IPPROTO_UDPLITE +# define IPPROTO_UDPLITE 136 /* IANA */ +#endif + +#if defined (HAVE_NETINET_UDPLITE_H) +# include +#elif defined (__linux__) +/* still missing from glibc 2.6 */ +# define UDPLITE_SEND_CSCOV 10 +# define UDPLITE_RECV_CSCOV 11 #endif extern int net_Socket( vlc_object_t *p_this, int i_family, int i_socktype, int i_protocol ); +static int net_ListenSingle (vlc_object_t *obj, const char *host, int port, + int family, int protocol) +{ + struct addrinfo hints, *res; + + memset (&hints, 0, sizeof( hints )); + hints.ai_family = family; + hints.ai_socktype = SOCK_DGRAM; + hints.ai_flags = AI_PASSIVE; + + if (host && !*host) + host = NULL; + + msg_Dbg (obj, "net: opening %s datagram port %d", host ?: "any", port); + + int val = vlc_getaddrinfo (obj, host, port, &hints, &res); + if (val) + { + msg_Err (obj, "Cannot resolve %s port %d : %s", host, port, + vlc_gai_strerror (val)); + return -1; + } + + val = -1; + + for (const struct addrinfo *ptr = res; ptr != NULL; ptr = ptr->ai_next) + { + int fd = net_Socket (obj, ptr->ai_family, ptr->ai_socktype, + protocol ?: ptr->ai_protocol); + if (fd == -1) + { + msg_Dbg (obj, "socket error: %m"); + continue; + } + + if (ptr->ai_next != NULL) + { +#ifdef IPV6_V6ONLY + if ((ptr->ai_family != AF_INET6) + || setsockopt (fd, SOL_IPV6, IPV6_V6ONLY, &(int){ 0 }, + sizeof (int))) +#endif + { + msg_Err (obj, "Multiple network protocols present"); + msg_Err (obj, "Please select network protocol manually"); + } + } + + /* Bind the socket */ +#if defined (WIN32) || defined (UNDER_CE) + if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen) + && (sizeof (struct sockaddr_storage) >= ptr->ai_addrlen)) + { + struct sockaddr_in6 dumb = + { + .sin6_family = ptr->ai_addr->sa_family, + .sin6_port = ((struct sockaddr_in *)(ptr->ai_addr))->sin_port + }; + bind (fd, (struct sockaddr *)&dumb, ptr->ai_addrlen); + } + else +#endif + if (bind (fd, ptr->ai_addr, ptr->ai_addrlen)) + { + msg_Err (obj, "socket bind error (%m)"); + net_Close (fd); + continue; + } + + if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen) + && net_Subscribe (obj, fd, ptr->ai_addr, ptr->ai_addrlen)) + { + net_Close (fd); + continue; + } + + val = fd; + break; + } + + vlc_freeaddrinfo (res); + return val; +} + static int net_SetMcastHopLimit( vlc_object_t *p_this, int fd, int family, int hlim ) { int proto, cmd; - /* There is some confusion in the world whether IP_MULTICAST_TTL + /* There is some confusion in the world whether IP_MULTICAST_TTL * takes a byte or an int as an argument. * BSD seems to indicate byte so we are going with that and use * int as a fallback to be safe */ @@ -95,7 +208,8 @@ static int net_SetMcastHopLimit( vlc_object_t *p_this, #endif default: - msg_Warn( p_this, "%s", strerror( EAFNOSUPPORT ) ); + errno = EAFNOSUPPORT; + msg_Warn( p_this, "%m" ); return VLC_EGENERIC; } @@ -158,14 +272,14 @@ static int net_SetMcastOut (vlc_object_t *p_this, int fd, int family, int scope = if_nametoindex (iface); if (scope == 0) { - msg_Err (p_this, "%s: invalid interface for multicast", iface); + msg_Err (p_this, "invalid multicast interface: %s", iface); return -1; } if (net_SetMcastOutIface (fd, family, scope) == 0) return 0; - msg_Err (p_this, "%s: %s", iface, net_strerror (net_errno)); + msg_Err (p_this, "%s: %m", iface); } if (addr != NULL) @@ -175,7 +289,7 @@ static int net_SetMcastOut (vlc_object_t *p_this, int fd, int family, struct in_addr ipv4; if (inet_pton (AF_INET, addr, &ipv4) <= 0) { - msg_Err (p_this, "%s: invalid IPv4 address for multicast", + msg_Err (p_this, "invalid IPv4 address for multicast: %s", addr); return -1; } @@ -183,7 +297,7 @@ static int net_SetMcastOut (vlc_object_t *p_this, int fd, int family, if (net_SetMcastOutIPv4 (fd, ipv4) == 0) return 0; - msg_Err (p_this, "%s: %s", addr, net_strerror (net_errno)); + msg_Err (p_this, "%s: %m", addr); } } @@ -191,83 +305,274 @@ static int net_SetMcastOut (vlc_object_t *p_this, int fd, int family, } -int net_Subscribe (vlc_object_t *obj, int fd, const struct sockaddr *addr, - socklen_t addrlen) +/** + * Old-style any-source multicast join. + * In use on Windows XP/2003 and older. + */ +static int +net_IPv4Join (vlc_object_t *obj, int fd, + const struct sockaddr_in *src, const struct sockaddr_in *grp) { - switch (addr->sa_family) - { #ifdef IP_ADD_MEMBERSHIP - case AF_INET: - { - const struct sockaddr_in *v4 = (const struct sockaddr_in *)addr; - if (addrlen < sizeof (*v4)) - return -1; + union + { + struct ip_mreq gr4; +# ifdef IP_ADD_SOURCE_MEMBERSHIP + struct ip_mreq_source gsr4; +# endif + } opt; + int cmd; + struct in_addr id = { .s_addr = INADDR_ANY }; + socklen_t optlen; + + /* Multicast interface IPv4 address */ + char *iface = var_CreateGetNonEmptyString (obj, "miface-addr"); + if ((iface != NULL) + && (inet_pton (AF_INET, iface, &id) <= 0)) + { + msg_Err (obj, "invalid multicast interface address %s", iface); + free (iface); + goto error; + } + free (iface); - struct ip_mreq imr; - memset (&imr, 0, sizeof (imr)); - memcpy (&imr.imr_multiaddr, &v4->sin_addr, 4); + memset (&opt, 0, sizeof (opt)); + if (src != NULL) + { +# ifdef IP_ADD_SOURCE_MEMBERSHIP + cmd = IP_ADD_SOURCE_MEMBERSHIP; + opt.gsr4.imr_multiaddr = grp->sin_addr; + opt.gsr4.imr_sourceaddr = src->sin_addr; + opt.gsr4.imr_interface = id; + optlen = sizeof (opt.gsr4); +# else + errno = ENOSYS; + goto error; +# endif + } + else + { + cmd = IP_ADD_MEMBERSHIP; + opt.gr4.imr_multiaddr = grp->sin_addr; + opt.gr4.imr_interface = id; + optlen = sizeof (opt.gr4); + } - /* FIXME: should use a different option for in and out */ - char *iif = var_CreateGetString (obj, "miface-addr"); - if (iif != NULL) - { - if ((iif[0] != '\0') && - (inet_pton (AF_INET, iif, &imr.imr_interface) <= 0)) - { - msg_Err (obj, "invalid multicast interface address %s", - iif); - free (iif); - return -1; - } - free (iif); - } + msg_Dbg (obj, "IP_ADD_%sMEMBERSHIP multicast request", + (src != NULL) ? "SOURCE_" : ""); - msg_Dbg (obj, "IP_ADD_MEMBERSHIP multicast request"); + if (setsockopt (fd, SOL_IP, cmd, &opt, optlen) == 0) + return 0; - if (setsockopt (fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imr, - sizeof (imr))) - { - msg_Err (obj, "cannot join IPv4 multicast group (%s)", - net_strerror (net_errno)); - return -1; - } - return 0; - } +error: #endif + msg_Err (obj, "cannot join IPv4 multicast group (%m)"); + return -1; +} + + +static int +net_IPv6Join (vlc_object_t *obj, int fd, const struct sockaddr_in6 *src) +{ #ifdef IPV6_JOIN_GROUP + struct ipv6_mreq gr6; + memset (&gr6, 0, sizeof (gr6)); + gr6.ipv6mr_interface = src->sin6_scope_id; + memcpy (&gr6.ipv6mr_multiaddr, &src->sin6_addr, 16); + + msg_Dbg (obj, "IPV6_JOIN_GROUP multicast request"); + + if (!setsockopt (fd, SOL_IPV6, IPV6_JOIN_GROUP, &gr6, sizeof (gr6))) + return 0; +#else + errno = ENOSYS; +#endif + + msg_Err (obj, "cannot join IPv6 any-source multicast group (%m)"); + return -1; +} + + +#if defined (WIN32) && !defined (MCAST_JOIN_SOURCE_GROUP) +/* + * I hate manual definitions: Error-prone. Portability hell. + * Developers shall use UP-TO-DATE compilers. Full point. + * If you remove the warning, you remove the whole ifndef. + */ +# warning Your C headers are out-of-date. Please update. + +# define MCAST_JOIN_GROUP 41 +struct group_req +{ + ULONG gr_interface; + struct sockaddr_storage gr_group; +}; + +# define MCAST_JOIN_SOURCE_GROUP 45 /* from */ +struct group_source_req +{ + uint32_t gsr_interface; + struct sockaddr_storage gsr_group; + struct sockaddr_storage gsr_source; +}; +#endif + +/** + * IP-agnostic multicast join, + * with fallback to old APIs, and fallback from SSM to ASM. + */ +static int +net_SourceSubscribe (vlc_object_t *obj, int fd, + const struct sockaddr *src, socklen_t srclen, + const struct sockaddr *grp, socklen_t grplen) +{ + int level, iid = 0; + + char *iface = var_CreateGetNonEmptyString (obj, "miface"); + if (iface != NULL) + { + iid = if_nametoindex (iface); + if (iid == 0) + { + msg_Err (obj, "invalid multicast interface: %s", iface); + free (iface); + return -1; + } + free (iface); + } + + switch (grp->sa_family) + { +#ifdef AF_INET6 case AF_INET6: + level = SOL_IPV6; + if (((const struct sockaddr_in6 *)grp)->sin6_scope_id) + iid = ((const struct sockaddr_in6 *)grp)->sin6_scope_id; + break; +#endif + + case AF_INET: + level = SOL_IP; + break; + + default: + errno = EAFNOSUPPORT; + return -1; + } + + if (src != NULL) + switch (src->sa_family) { - const struct sockaddr_in6 *v6 = (const struct sockaddr_in6 *)addr; - if (addrlen < sizeof (*v6)) - return -1; +#ifdef AF_INET6 + case AF_INET6: + if (memcmp (&((const struct sockaddr_in6 *)src)->sin6_addr, + &in6addr_any, sizeof (in6addr_any)) == 0) + src = NULL; + break; +#endif + + case AF_INET: + if (((const struct sockaddr_in *)src)->sin_addr.s_addr + == INADDR_ANY) + src = NULL; + break; + } - struct ipv6_mreq imr; - memset (&imr, 0, sizeof (imr)); - imr.ipv6mr_interface = v6->sin6_scope_id; - memcpy (&imr.ipv6mr_multiaddr, &v6->sin6_addr, 16); - msg_Dbg (obj, "IPV6_JOIN_GROUP multicast request"); + /* Agnostic ASM/SSM multicast join */ +#ifdef MCAST_JOIN_SOURCE_GROUP + union + { + struct group_req gr; + struct group_source_req gsr; + } opt; + socklen_t optlen; - if (setsockopt (fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, &imr, - sizeof (imr))) - { - msg_Err (obj, "cannot join IPv6 multicast group (%s)", - net_strerror (net_errno)); + memset (&opt, 0, sizeof (opt)); + + if (src != NULL) + { + if ((grplen > sizeof (opt.gsr.gsr_group)) + || (srclen > sizeof (opt.gsr.gsr_source))) + return -1; + + opt.gsr.gsr_interface = iid; + memcpy (&opt.gsr.gsr_source, src, srclen); + memcpy (&opt.gsr.gsr_group, grp, grplen); + optlen = sizeof (opt.gsr); + } + else + { + if (grplen > sizeof (opt.gr.gr_group)) + return -1; + + opt.gr.gr_interface = iid; + memcpy (&opt.gr.gr_group, grp, grplen); + optlen = sizeof (opt.gr); + } + + msg_Dbg (obj, "Multicast %sgroup join request", src ? "source " : ""); + + if (setsockopt (fd, level, + src ? MCAST_JOIN_SOURCE_GROUP : MCAST_JOIN_GROUP, + (void *)&opt, optlen) == 0) + return 0; +#endif + + /* Fallback to IPv-specific APIs */ + if ((src != NULL) && (src->sa_family != grp->sa_family)) + return -1; + + switch (grp->sa_family) + { + case AF_INET: + if ((grplen < sizeof (struct sockaddr_in)) + || ((src != NULL) && (srclen < sizeof (struct sockaddr_in)))) return -1; - } - return 0; - } + if (net_IPv4Join (obj, fd, (const struct sockaddr_in *)src, + (const struct sockaddr_in *)grp) == 0) + return 0; + break; + +#ifdef AF_INET6 + case AF_INET6: + if ((grplen < sizeof (struct sockaddr_in6)) + || ((src != NULL) && (srclen < sizeof (struct sockaddr_in6)))) + return -1; + + /* IPv6-specific SSM API does not exist. So if we're here + * it means IPv6 SSM is not supported on this OS and we + * directly fallback to ASM */ + + if (net_IPv6Join (obj, fd, (const struct sockaddr_in6 *)grp) == 0) + return 0; + break; #endif } + msg_Err (obj, "Multicast group join error (%m)"); + + if (src != NULL) + { + msg_Warn (obj, "Trying ASM instead of SSM..."); + return net_Subscribe (obj, fd, grp, grplen); + } + msg_Err (obj, "Multicast not supported"); return -1; } -int net_SetDSCP( int fd, uint8_t dscp ) +int net_Subscribe (vlc_object_t *obj, int fd, + const struct sockaddr *addr, socklen_t addrlen) +{ + return net_SourceSubscribe (obj, fd, NULL, 0, addr, addrlen); +} + + +static int net_SetDSCP( int fd, uint8_t dscp ) { struct sockaddr_storage addr; if( getsockname( fd, (struct sockaddr *)&addr, &(socklen_t){ sizeof (addr) }) ) @@ -301,20 +606,17 @@ int net_SetDSCP( int fd, uint8_t dscp ) /***************************************************************************** - * __net_ConnectUDP: + * __net_ConnectDgram: ***************************************************************************** - * Open a UDP socket to send data to a defined destination, with an optional - * hop limit. + * Open a datagram 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 i_hlim ) +int __net_ConnectDgram( vlc_object_t *p_this, const char *psz_host, int i_port, + int i_hlim, int proto ) { 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 */ + bool b_unreach = false; if( i_hlim < 1 ) i_hlim = var_CreateGetInteger( p_this, "ttl" ); @@ -322,12 +624,12 @@ int __net_ConnectUDP( vlc_object_t *p_this, const char *psz_host, int i_port, memset( &hints, 0, sizeof( hints ) ); hints.ai_socktype = SOCK_DGRAM; - msg_Dbg( p_this, "net: connecting to %s port %d", psz_host, i_port ); + msg_Dbg( p_this, "net: connecting to [%s]:%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, + msg_Err( p_this, "cannot resolve [%s]:%d : %s", psz_host, i_port, vlc_gai_strerror( i_val ) ); return -1; } @@ -336,7 +638,7 @@ int __net_ConnectUDP( vlc_object_t *p_this, const char *psz_host, int i_port, { char *str; int fd = net_Socket (p_this, ptr->ai_family, ptr->ai_socktype, - ptr->ai_protocol); + proto ?: ptr->ai_protocol); if (fd == -1) continue; @@ -353,19 +655,17 @@ int __net_ConnectUDP( vlc_object_t *p_this, const char *psz_host, int i_port, if( i_hlim > 0 ) net_SetMcastHopLimit( p_this, fd, ptr->ai_family, i_hlim ); - str = var_CreateGetString (p_this, "miface"); + str = var_CreateGetNonEmptyString (p_this, "miface"); if (str != NULL) { - if (*str) - net_SetMcastOut (p_this, fd, ptr->ai_family, str, NULL); + net_SetMcastOut (p_this, fd, ptr->ai_family, str, NULL); free (str); } - str = var_CreateGetString (p_this, "miface-addr"); + str = var_CreateGetNonEmptyString (p_this, "miface-addr"); if (str != NULL) { - if (*str) - net_SetMcastOut (p_this, fd, ptr->ai_family, NULL, str); + net_SetMcastOut (p_this, fd, ptr->ai_family, NULL, str); free (str); } @@ -383,11 +683,10 @@ int __net_ConnectUDP( vlc_object_t *p_this, const char *psz_host, int i_port, #else if( errno == ENETUNREACH ) #endif - b_unreach = VLC_TRUE; + b_unreach = true; else { - msg_Warn( p_this, "%s port %d : %s", psz_host, i_port, - strerror( errno ) ); + msg_Warn( p_this, "%s port %d : %m", psz_host, i_port); net_Close( fd ); continue; } @@ -408,80 +707,182 @@ int __net_ConnectUDP( vlc_object_t *p_this, const char *psz_host, int i_port, /***************************************************************************** - * __net_OpenUDP: + * __net_OpenDgram: ***************************************************************************** - * Open a UDP connection and return a handle + * OpenDgram a datagram socket 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 ) +int __net_OpenDgram( vlc_object_t *obj, const char *psz_bind, int i_bind, + const char *psz_server, int i_server, + int family, int protocol ) { - void *private; - network_socket_t sock; - module_t *p_network = NULL; + if ((psz_server == NULL) || (psz_server[0] == '\0')) + return net_ListenSingle (obj, psz_bind, i_bind, family, protocol); + + msg_Dbg (obj, "net: connecting to [%s]:%d from [%s]:%d", + psz_server, i_server, psz_bind, i_bind); - if (((psz_server == NULL) || (psz_server[0] == '\0')) && (i_server == 0)) + struct addrinfo hints, *loc, *rem; + int val; + + memset (&hints, 0, sizeof (hints)); + hints.ai_family = family; + hints.ai_socktype = SOCK_DGRAM; + + val = vlc_getaddrinfo (obj, psz_server, i_server, &hints, &rem); + if (val) { - msg_Warn (p_this, - "Obsolete net_OpenUDP with no remote endpoint; " - "Use net_ListenUDP instead"); - return net_ListenUDP1 (p_this, psz_bind, i_bind); + msg_Err (obj, "cannot resolve %s port %d : %s", psz_bind, i_bind, + vlc_gai_strerror (val)); + return -1; } - if (((psz_bind == NULL) || (psz_bind[0] == '\0')) && (i_bind == 0)) + hints.ai_flags = AI_PASSIVE; + val = vlc_getaddrinfo (obj, psz_bind, i_bind, &hints, &loc); + if (val) { - msg_Warn (p_this, - "Obsolete net_OpenUDP with no local endpoint; " - "Use net_ConnectUDP instead"); - return net_ConnectUDP (p_this, psz_server, i_server, -1); + msg_Err (obj, "cannot resolve %s port %d : %s", psz_bind, i_bind, + vlc_gai_strerror (val)); + vlc_freeaddrinfo (rem); + return -1; } - if( psz_server == NULL ) psz_server = ""; - if( psz_bind == NULL ) psz_bind = ""; + for (struct addrinfo *ptr = loc; ptr != NULL; ptr = ptr->ai_next) + { + int fd = net_Socket (obj, ptr->ai_family, ptr->ai_socktype, + protocol ?: ptr->ai_protocol); + if (fd == -1) + continue; // usually, address family not supported + +#ifdef SO_REUSEPORT + setsockopt (fd, SOL_SOCKET, SO_REUSEPORT, &(int){ 1 }, sizeof (int)); +#endif - /* 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.i_handle = -1; +#ifdef SO_RCVBUF + /* Increase the receive buffer size to 1/2MB (8Mb/s during 1/2s) + * to avoid packet loss caused in case of scheduling hiccups */ + setsockopt (fd, SOL_SOCKET, SO_RCVBUF, + (void *)&(int){ 0x80000 }, sizeof (int)); + setsockopt (fd, SOL_SOCKET, SO_SNDBUF, + (void *)&(int){ 0x80000 }, sizeof (int)); +#endif - msg_Dbg( p_this, "net: connecting to '[%s]:%d@[%s]:%d'", - psz_server, i_server, psz_bind, i_bind ); +#if defined (WIN32) || defined (UNDER_CE) + if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen) + && (sizeof (struct sockaddr_storage) >= ptr->ai_addrlen)) + { + // This works for IPv4 too - don't worry! + struct sockaddr_in6 dumb = + { + .sin6_family = ptr->ai_addr->sa_family, + .sin6_port = ((struct sockaddr_in *)(ptr->ai_addr))->sin_port + }; - /* Check if we have force ipv4 or ipv6 */ - vlc_bool_t v4 = var_CreateGetBool (p_this, "ipv4"); - vlc_bool_t v6 = var_CreateGetBool (p_this, "ipv6"); + bind (fd, (struct sockaddr *)&dumb, ptr->ai_addrlen); + } + else +#endif + if (bind (fd, ptr->ai_addr, ptr->ai_addrlen)) + { + net_Close (fd); + continue; + } - if( !v4 ) - { - /* 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 ); + val = -1; + for (struct addrinfo *ptr2 = rem; ptr2 != NULL; ptr2 = ptr2->ai_next) + { + if ((ptr2->ai_family != ptr->ai_family) + || (ptr2->ai_socktype != ptr->ai_socktype) + || (ptr2->ai_protocol != ptr->ai_protocol)) + continue; + + if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen) + ? net_SourceSubscribe (obj, fd, + ptr2->ai_addr, ptr2->ai_addrlen, + ptr->ai_addr, ptr->ai_addrlen) + : connect (fd, ptr2->ai_addr, ptr2->ai_addrlen)) + { + msg_Err (obj, "cannot connect to %s port %d: %m", + psz_server, i_server); + continue; + } + val = fd; + break; + } - if( p_network != NULL ) - module_Unneed( p_this, p_network ); + if (val != -1) + break; - p_this->p_private = private; + close (fd); } - if ((sock.i_handle == -1) && !v6) - { - /* 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 ); + vlc_freeaddrinfo (rem); + vlc_freeaddrinfo (loc); + return val; +} - if( p_network != NULL ) - module_Unneed( p_this, p_network ); - p_this->p_private = private; - } +/** + * net_SetCSCov: + * Sets the send and receive checksum coverage of a socket: + * @param fd socket + * @param sendcov payload coverage of sent packets (bytes), -1 for full + * @param recvcov minimum payload coverage of received packets, -1 for full + */ +int net_SetCSCov (int fd, int sendcov, int recvcov) +{ + int type; - 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 ); + if (getsockopt (fd, SOL_SOCKET, SO_TYPE, + &type, &(socklen_t){ sizeof (type) })) + return VLC_EGENERIC; + + switch (type) + { +#ifdef UDPLITE_RECV_CSCOV + case SOCK_DGRAM: /* UDP-Lite */ + if (sendcov == -1) + sendcov = 0; + else + sendcov += 8; /* partial */ + if (setsockopt (fd, SOL_UDPLITE, UDPLITE_SEND_CSCOV, &sendcov, + sizeof (sendcov))) + return VLC_EGENERIC; + + if (recvcov == -1) + recvcov = 0; + else + recvcov += 8; + if (setsockopt (fd, SOL_UDPLITE, UDPLITE_RECV_CSCOV, + &recvcov, sizeof (recvcov))) + return VLC_EGENERIC; + + return VLC_SUCCESS; +#endif +#ifdef DCCP_SOCKOPT_SEND_CSCOV + case SOCK_DCCP: /* DCCP and its ill-named socket type */ + if ((sendcov == -1) || (sendcov > 56)) + sendcov = 0; + else + sendcov = (sendcov + 3) / 4; + if (setsockopt (fd, SOL_DCCP, DCCP_SOCKOPT_SEND_CSCOV, + &sendcov, sizeof (sendcov))) + return VLC_EGENERIC; + + if ((recvcov == -1) || (recvcov > 56)) + recvcov = 0; + else + recvcov = (recvcov + 3) / 4; + if (setsockopt (fd, SOL_DCCP, DCCP_SOCKOPT_RECV_CSCOV, + &recvcov, sizeof (recvcov))) + return VLC_EGENERIC; + + return VLC_SUCCESS; +#endif + } +#if !defined( UDPLITE_RECV_CSCOV ) && !defined( DCCP_SOCKOPT_SEND_CSCOV ) + VLC_UNUSED(sendcov); + VLC_UNUSED(recvcov); +#endif - return sock.i_handle; + return VLC_EGENERIC; }