static void create_SDP(sout_stream_t *p_stream, sout_access_out_t *p_access)
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
static const struct addrinfo hints = {
// sunqueen modify start
/*.ai_family =*/ AF_UNSPEC,
/*.ai_socktype =*/ SOCK_DGRAM,
/*.ai_protocol =*/ 0,
/*.ai_flags =*/ AI_NUMERICHOST | AI_NUMERICSERV | AI_IDN,
// sunqueen modify end
};
char *shost = var_GetNonEmptyString (p_access, "src-addr");
char *dhost = var_GetNonEmptyString (p_access, "dst-addr");
int sport = var_GetInteger (p_access, "src-port");
int dport = var_GetInteger (p_access, "dst-port");
struct sockaddr_storage src, dst;
socklen_t srclen = 0, dstlen = 0;
struct addrinfo *res;
if (!vlc_getaddrinfo (dhost, dport, &hints, &res))
{
memcpy (&dst, res->ai_addr, dstlen = res->ai_addrlen);
freeaddrinfo (res);
}
if (!vlc_getaddrinfo (shost, sport, &hints, &res))
{
memcpy (&src, res->ai_addr, srclen = res->ai_addrlen);
freeaddrinfo (res);
}
char *head = vlc_sdp_Start (VLC_OBJECT (p_stream), SOUT_CFG_PREFIX,
(struct sockaddr *)&src, srclen,
(struct sockaddr *)&dst, dstlen);
free (shost);
if (head != NULL)
{
char *psz_sdp = NULL;
if (asprintf (&psz_sdp, "%s"
"m=video %d udp mpeg\r\n", head, dport) == -1)
psz_sdp = NULL;
free (head);
/* Register the SDP with the SAP thread */
if (psz_sdp)
{
msg_Dbg (p_stream, "Generated SDP:\n%s", psz_sdp);
p_sys->p_session =
sout_AnnounceRegisterSDP (p_stream, psz_sdp, dhost);
free( psz_sdp );
}
}
free (dhost);
}
/**
* Registers a new session with the announce handler, using a pregenerated SDP
*
* \param obj a VLC object
* \param psz_sdp the SDP to register
* \param psz_dst session address (needed for SAP address auto detection)
* \param p_method an announce method descriptor
* \return the new session descriptor structure
*/
session_descriptor_t *
sout_AnnounceRegisterSDP( vlc_object_t *obj, const char *psz_sdp,
const char *psz_dst, announce_method_t *p_method )
{
assert (p_method == &sap_method);
(void) p_method;
session_descriptor_t *p_session = calloc( 1, sizeof (*p_session) );
if( !p_session )
return NULL;
p_session->psz_sdp = strdup( psz_sdp );
/* GRUIK. We should not convert back-and-forth from string to numbers */
struct addrinfo *res;
if (vlc_getaddrinfo (obj, psz_dst, 0, NULL, &res) == 0)
{
if (res->ai_addrlen <= sizeof (p_session->addr))
memcpy (&p_session->addr, res->ai_addr,
p_session->addrlen = res->ai_addrlen);
vlc_freeaddrinfo (res);
}
vlc_mutex_lock (&sap_mutex);
sap_handler_t *p_sap = libvlc_priv (obj->p_libvlc)->p_sap;
if (p_sap == NULL)
{
p_sap = SAP_Create (VLC_OBJECT (obj->p_libvlc));
libvlc_priv (obj->p_libvlc)->p_sap = p_sap;
vlc_object_set_destructor ((vlc_object_t *)p_sap, sap_destroy);
}
else
vlc_object_hold ((vlc_object_t *)p_sap);
vlc_mutex_unlock (&sap_mutex);
if (p_sap == NULL)
goto error;
msg_Dbg (obj, "adding SAP session");
if (SAP_Add (p_sap, p_session))
{
vlc_mutex_lock (&sap_mutex);
vlc_object_release ((vlc_object_t *)p_sap);
vlc_mutex_unlock (&sap_mutex);
goto error;
}
return p_session;
error:
free (p_session->psz_sdp);
free (p_session);
return NULL;
}
static int ACL_Resolve( vlc_object_t *p_this, uint8_t *p_bytes,
const char *psz_ip )
{
struct addrinfo hints, *res;
int i_family;
memset (&hints, 0, sizeof (hints));
hints.ai_socktype = SOCK_STREAM; /* doesn't matter */
hints.ai_flags = AI_NUMERICHOST;
if( vlc_getaddrinfo( p_this, psz_ip, 0, &hints, &res ) )
{
msg_Err( p_this, "invalid IP address %s", psz_ip );
return -1;
}
p_bytes[16] = 0; /* avoids overflowing when i_bytes_match = 16 */
i_family = res->ai_addr->sa_family;
switch( i_family )
{
case AF_INET:
{
struct sockaddr_in *addr;
addr = (struct sockaddr_in *)res->ai_addr;
memset( p_bytes, 0, 12 );
memcpy( p_bytes + 12, &addr->sin_addr, 4 );
break;
}
#if defined (HAVE_GETADDRINFO) || defined (WIN32)
/* unfortunately many people define AF_INET6
though they don't have struct sockaddr_in6 */
case AF_INET6:
{
struct sockaddr_in6 *addr;
addr = (struct sockaddr_in6 *)res->ai_addr;
memcpy( p_bytes, &addr->sin6_addr, 16 );
break;
}
#endif
default:
msg_Err( p_this, "unknown address family" );
vlc_freeaddrinfo( res );
return -1;
}
vlc_freeaddrinfo( res );
return i_family;
}
else
{
psz_realhost = psz_host;
i_realport = i_port;
msg_Dbg( p_this, "net: connecting to %s port %d", psz_realhost,
i_realport );
}
struct addrinfo hints = {
.ai_socktype = type,
.ai_protocol = proto,
.ai_flags = AI_NUMERICSERV | AI_IDN,
}, *res;
int val = vlc_getaddrinfo (psz_realhost, i_realport, &hints, &res);
if (val)
{
msg_Err (p_this, "cannot resolve %s port %d : %s", psz_realhost,
i_realport, gai_strerror (val));
free( psz_socks );
return -1;
}
free( psz_socks );
int timeout = var_InheritInteger (p_this, "ipv4-timeout");
if (timeout < 0)
timeout = -1;
for (struct addrinfo *ptr = res; ptr != NULL; ptr = ptr->ai_next)
static void create_SDP(sout_stream_t *p_stream, sout_access_out_t *p_access)
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
static const struct addrinfo hints = {
.ai_family = AF_UNSPEC,
.ai_socktype = SOCK_DGRAM,
.ai_protocol = 0,
.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV
};
char *shost = var_GetNonEmptyString (p_access, "src-addr");
char *dhost = var_GetNonEmptyString (p_access, "dst-addr");
int sport = var_GetInteger (p_access, "src-port");
int dport = var_GetInteger (p_access, "dst-port");
struct sockaddr_storage src, dst;
socklen_t srclen = 0, dstlen = 0;
struct addrinfo *res;
if (!vlc_getaddrinfo ( VLC_OBJECT(p_stream), dhost, dport, &hints, &res))
{
memcpy (&dst, res->ai_addr, dstlen = res->ai_addrlen);
freeaddrinfo (res);
}
if (!vlc_getaddrinfo ( VLC_OBJECT(p_stream), shost, sport, &hints, &res))
{
memcpy (&src, res->ai_addr, srclen = res->ai_addrlen);
freeaddrinfo (res);
}
char *head = vlc_sdp_Start (VLC_OBJECT (p_stream), SOUT_CFG_PREFIX,
(struct sockaddr *)&src, srclen,
(struct sockaddr *)&dst, dstlen);
free (shost);
if (head != NULL)
{
char *psz_sdp = NULL;
if (asprintf (&psz_sdp, "%s"
"m=video %d udp mpeg\r\n", head, dport) == -1)
psz_sdp = NULL;
free (head);
/* Register the SDP with the SAP thread */
if (psz_sdp)
{
msg_Dbg (p_stream, "Generated SDP:\n%s", psz_sdp);
p_sys->p_session =
sout_AnnounceRegisterSDP (p_stream->p_sout, psz_sdp, dhost);
free( psz_sdp );
}
}
free (dhost);
}
static const char *getMuxFromAlias( const char *psz_alias )
{
static struct { const char alias[6]; const char mux[32]; } mux_alias[] =
{
{ "avi", "avi" },
{ "ogg", "ogg" },
{ "ogm", "ogg" },
{ "ogv", "ogg" },
{ "flac","raw" },
{ "mp3", "raw" },
{ "mp4", "mp4" },
{ "mov", "mov" },
{ "moov","mov" },
{ "asf", "asf" },
{ "wma", "asf" },
{ "wmv", "asf" },
{ "trp", "ts" },
{ "ts", "ts" },
{ "mpg", "ps" },
{ "mpeg","ps" },
{ "ps", "ps" },
{ "mpeg1","mpeg1" },
{ "wav", "wav" },
{ "flv", "ffmpeg{mux=flv}" },
{ "mkv", "ffmpeg{mux=matroska}"},
{ "webm", "ffmpeg{mux=webm}"},
};
if( !psz_alias )
return NULL;
for( size_t i = 0; i < sizeof mux_alias / sizeof *mux_alias; i++ )
if( !strcasecmp( psz_alias, mux_alias[i].alias ) )
return mux_alias[i].mux;
return NULL;
}
static int fixAccessMux( sout_stream_t *p_stream, char **ppsz_mux,
char **ppsz_access, const char *psz_url )
{
char *psz_mux = *ppsz_mux;
char *psz_access = *ppsz_access;
if( !psz_mux )
{
const char *psz_ext = psz_url ? strrchr( psz_url, '.' ) : NULL;
if( psz_ext )
psz_ext++; /* use extension */
const char *psz_mux_byext = getMuxFromAlias( psz_ext );
if( !psz_access )
{
if( !psz_mux_byext )
{
msg_Err( p_stream, "no access _and_ no muxer" );
return 1;
}
msg_Warn( p_stream,
"no access _and_ no muxer, extension gives file/%s",
psz_mux_byext );
*ppsz_access = strdup("file");
*ppsz_mux = strdup(psz_mux_byext);
}
else
{
if( !strncmp( psz_access, "mmsh", 4 ) )
*ppsz_mux = strdup("asfh");
else if (!strcmp (psz_access, "udp"))
*ppsz_mux = strdup("ts");
else if( psz_mux_byext )
*ppsz_mux = strdup(psz_mux_byext);
else
{
msg_Err( p_stream, "no mux specified or found by extension" );
return 1;
}
}
}
else if( !psz_access )
{
if( !strncmp( psz_mux, "asfh", 4 ) )
*ppsz_access = strdup("mmsh");
else /* default file */
*ppsz_access = strdup("file");
}
return 0;
}
/*****************************************************************************
* net_Connect:
*****************************************************************************
* Open a network connection.
* @return socket handler or -1 on error.
*****************************************************************************/
int net_Connect( vlc_object_t *p_this, const char *psz_host, int i_port,
int type, int proto )
{
struct addrinfo hints, *res, *ptr;
const char *psz_realhost;
char *psz_socks;
int i_realport, i_val, i_handle = -1;
int evfd = vlc_object_waitpipe (p_this);
if (evfd == -1)
return -1;
memset( &hints, 0, sizeof( hints ) );
hints.ai_socktype = type;
hints.ai_protocol = proto;
psz_socks = var_InheritString( p_this, "socks" );
if( psz_socks != NULL )
{
char *psz = strchr( psz_socks, ':' );
if( psz )
*psz++ = '\0';
psz_realhost = psz_socks;
i_realport = ( psz != NULL ) ? atoi( psz ) : 1080;
hints.ai_flags &= ~AI_NUMERICHOST;
msg_Dbg( p_this, "net: connecting to %s port %d (SOCKS) "
"for %s port %d", psz_realhost, i_realport,
psz_host, i_port );
/* We only implement TCP with SOCKS */
switch( type )
{
case 0:
type = SOCK_STREAM;
case SOCK_STREAM:
break;
default:
msg_Err( p_this, "Socket type not supported through SOCKS" );
free( psz_socks );
return -1;
}
switch( proto )
{
case 0:
proto = IPPROTO_TCP;
case IPPROTO_TCP:
break;
default:
msg_Err( p_this, "Transport not supported through SOCKS" );
free( psz_socks );
return -1;
}
}
else
{
psz_realhost = psz_host;
i_realport = i_port;
msg_Dbg( p_this, "net: connecting to %s port %d", psz_realhost,
i_realport );
}
i_val = vlc_getaddrinfo( p_this, psz_realhost, i_realport, &hints, &res );
free( psz_socks );
if( i_val )
{
msg_Err( p_this, "cannot resolve %s port %d : %s", psz_realhost,
i_realport, gai_strerror( i_val ) );
return -1;
}
int timeout = var_InheritInteger (p_this, "ipv4-timeout");
if (timeout < 0)
timeout = -1;
for( ptr = res; ptr != NULL; ptr = ptr->ai_next )
{
int fd = net_Socket( p_this, ptr->ai_family,
ptr->ai_socktype, ptr->ai_protocol );
if( fd == -1 )
{
msg_Dbg( p_this, "socket error: %m" );
continue;
}
if( connect( fd, ptr->ai_addr, ptr->ai_addrlen ) )
{
int val;
if( net_errno != EINPROGRESS && net_errno != EINTR )
{
msg_Err( p_this, "connection failed: %m" );
goto next_ai;
}
struct pollfd ufd[2] = {
{ .fd = fd, .events = POLLOUT },
{ .fd = evfd, .events = POLLIN },
};
/**
* Registers a new session with the announce handler, using a pregenerated SDP
*
* \param obj a VLC object
* \param sdp the SDP to register
* \param dst session address (needed for SAP address auto detection)
* \return the new session descriptor structure
*/
session_descriptor_t *
sout_AnnounceRegisterSDP (vlc_object_t *obj, const char *sdp,
const char *dst)
{
int i;
char psz_addr[NI_MAXNUMERICHOST];
union
{
struct sockaddr a;
struct sockaddr_in in;
struct sockaddr_in6 in6;
} addr;
socklen_t addrlen = 0;
struct addrinfo *res;
msg_Dbg (obj, "adding SAP session");
if (vlc_getaddrinfo (dst, 0, NULL, &res) == 0)
{
if (res->ai_addrlen <= sizeof (addr))
memcpy (&addr, res->ai_addr, res->ai_addrlen);
addrlen = res->ai_addrlen;
freeaddrinfo (res);
}
if (addrlen == 0 || addrlen > sizeof (addr))
{
msg_Err (obj, "No/invalid address specified for SAP announce" );
return NULL;
}
/* Determine SAP multicast address automatically */
switch (addr.a.sa_family)
{
#if defined (HAVE_INET_PTON) || defined (_WIN32)
case AF_INET6:
{
/* See RFC3513 for list of valid IPv6 scopes */
struct in6_addr *a6 = &addr.in6.sin6_addr;
memcpy( a6->s6_addr + 2, "\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x02\x7f\xfe", 14 );
if( IN6_IS_ADDR_MULTICAST( a6 ) )
/* force flags to zero, preserve scope */
a6->s6_addr[1] &= 0xf;
else
/* Unicast IPv6 - assume global scope */
memcpy( a6->s6_addr, "\xff\x0e", 2 );
break;
}
#endif
case AF_INET:
{
/* See RFC2365 for IPv4 scopes */
uint32_t ipv4 = addr.in.sin_addr.s_addr;
/* 224.0.0.0/24 => 224.0.0.255 */
if ((ipv4 & htonl (0xffffff00)) == htonl (0xe0000000))
ipv4 = htonl (0xe00000ff);
else
/* 239.255.0.0/16 => 239.255.255.255 */
if ((ipv4 & htonl (0xffff0000)) == htonl (0xefff0000))
ipv4 = htonl (0xefffffff);
else
/* 239.192.0.0/14 => 239.195.255.255 */
if ((ipv4 & htonl (0xfffc0000)) == htonl (0xefc00000))
ipv4 = htonl (0xefc3ffff);
else
if ((ipv4 & htonl (0xff000000)) == htonl (0xef000000))
ipv4 = 0;
else
/* other addresses => 224.2.127.254 */
ipv4 = htonl (0xe0027ffe);
if( ipv4 == 0 )
{
msg_Err (obj, "Out-of-scope multicast address "
"not supported by SAP");
return NULL;
}
addr.in.sin_addr.s_addr = ipv4;
break;
}
default:
msg_Err (obj, "Address family %d not supported by SAP",
addr.a.sa_family);
return NULL;
}
i = vlc_getnameinfo( &addr.a, addrlen,
psz_addr, sizeof( psz_addr ), NULL, NI_NUMERICHOST );
if( i )
{
msg_Err (obj, "%s", gai_strerror (i));
return NULL;
}
/* Find/create SAP address thread */
sap_address_t *sap_addr;
msg_Dbg (obj, "using SAP address: %s", psz_addr);
vlc_mutex_lock (&sap_mutex);
for (sap_addr = sap_addrs; sap_addr; sap_addr = sap_addr->next)
if (!strcmp (psz_addr, sap_addr->group))
break;
if (sap_addr == NULL)
{
sap_addr = AddressCreate (obj, psz_addr);
if (sap_addr == NULL)
{
vlc_mutex_unlock (&sap_mutex);
return NULL;
}
sap_addr->next = sap_addrs;
sap_addrs = sap_addr;
}
/* Switch locks.
* NEVER take the global SAP lock when holding a SAP thread lock! */
vlc_mutex_lock (&sap_addr->lock);
vlc_mutex_unlock (&sap_mutex);
size_t length = 20;
switch (sap_addr->orig.ss_family)
{
#ifdef AF_INET6
case AF_INET6:
length += 16;
break;
#endif
case AF_INET:
length += 4;
break;
default:
assert (0);
}
/* XXX: Check for dupes */
length += strlen (sdp);
session_descriptor_t *session = malloc (sizeof (*session) + length);
if (unlikely(session == NULL))
{
vlc_mutex_unlock (&sap_addr->lock);
return NULL; /* NOTE: we should destroy the thread if left unused */
}
session->next = sap_addr->first;
sap_addr->first = session;
session->length = length;
/* Build the SAP Headers */
uint8_t *buf = session->data;
/* SAPv1, not encrypted, not compressed */
buf[0] = 0x20;
buf[1] = 0x00; /* No authentication length */
SetWBE(buf + 2, mdate()); /* ID hash */
size_t offset = 4;
switch (sap_addr->orig.ss_family)
{
#ifdef AF_INET6
case AF_INET6:
{
const struct in6_addr *a6 =
&((const struct sockaddr_in6 *)&sap_addr->orig)->sin6_addr;
memcpy (buf + offset, a6, 16);
buf[0] |= 0x10; /* IPv6 flag */
offset += 16;
break;
}
#endif
case AF_INET:
{
const struct in_addr *a4 =
&((const struct sockaddr_in *)&sap_addr->orig)->sin_addr;
memcpy (buf + offset, a4, 4);
offset += 4;
break;
}
}
memcpy (buf + offset, "application/sdp", 16);
offset += 16;
/* Build the final message */
strcpy((char *)buf + offset, sdp);
sap_addr->session_count++;
vlc_cond_signal (&sap_addr->wait);
vlc_mutex_unlock (&sap_addr->lock);
return session;
}
{
net_Close((intptr_t)data);
}
static int vlc_tcp_connect(vlc_object_t *obj, const char *name, unsigned port)
{
struct addrinfo hints =
{
.ai_socktype = SOCK_STREAM,
.ai_protocol = IPPROTO_TCP,
}, *res;
assert(name != NULL);
msg_Dbg(obj, "resolving %s ...", name);
int val = vlc_getaddrinfo(name, port, &hints, &res);
if (val != 0)
{ /* TODO: C locale for gai_strerror() */
msg_Err(obj, "cannot resolve %s port %u: %s", name, port,
gai_strerror(val));
return -1;
}
int fd = -1;
vlc_cleanup_push(cleanup_addrinfo, res);
msg_Dbg(obj, "connecting to %s port %u ...", name, port);
for (const struct addrinfo *p = res; p != NULL; p = p->ai_next)
{
fd = vlc_socket(p->ai_family, p->ai_socktype, p->ai_protocol, false);
}
static bool srt_schedule_reconnect(stream_t *p_stream)
{
int i_latency;
int stat;
char *psz_passphrase = NULL;
struct addrinfo hints = {
.ai_socktype = SOCK_DGRAM,
}, *res = NULL;
stream_sys_t *p_sys = p_stream->p_sys;
bool failed = false;
stat = vlc_getaddrinfo( p_sys->psz_host, p_sys->i_port, &hints, &res );
if ( stat )
{
msg_Err( p_stream, "Cannot resolve [%s]:%d (reason: %s)",
p_sys->psz_host,
p_sys->i_port,
gai_strerror( stat ) );
failed = true;
goto out;
}
/* Always start with a fresh socket */
if (p_sys->sock != SRT_INVALID_SOCK)
{
srt_epoll_remove_usock( p_sys->i_poll_id, p_sys->sock );
int vlc_getaddrinfo_i11e(const char *node, unsigned port,
const struct addrinfo *hints, struct addrinfo **res)
{
return vlc_getaddrinfo(node, port, hints, res);
}
