/**
* If no filename is given to av_open_input_file because you want to
* get the local port first, then you must call this function to set
* the remote server address.
*
* url syntax: udp://host:port[?option=val...]
* option: 'ttl=n' : set the ttl value (for multicast only)
* 'localport=n' : set the local port
* 'pkt_size=n' : set max packet size
* 'reuse=1' : enable reusing the socket
*
* @param h media file context
* @param uri of the remote server
* @return zero if no error.
*/
static int udp_set_remote_url( obe_udp_ctx *s )
{
/* set the destination address */
s->dest_addr_len = udp_set_url( &s->dest_addr, s->hostname, s->port );
if( s->dest_addr_len < 0 )
return -1;
s->is_multicast = is_multicast_address( (struct sockaddr*) &s->dest_addr );
return 0;
}
int socket_leave_group(int fd, unsigned int group_addr, unsigned int interface_addr)
{
if (!is_multicast_address(group_addr)) return 0; // ignore this case
struct ip_mreq imr;
imr.imr_multiaddr.s_addr = group_addr;
imr.imr_interface.s_addr = interface_addr;
if (setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP,(const char*)&imr, sizeof (struct ip_mreq)) < 0) {
printf("socket_join_group IP_ADD_MEMBERSHIP, %d, %s\n", errno, strerror(errno));
return -1;
}
return 0;
}
/**
* If no filename is given to av_open_input_file because you want to
* get the local port first, then you must call this function to set
* the remote server address.
*
* url syntax: udp://host:port[?option=val...]
* option: 'ttl=n' : set the ttl value (for multicast only)
* 'localport=n' : set the local port
* 'pkt_size=n' : set max packet size
* 'reuse=1' : enable reusing the socket
*
* @param s1 media file context
* @param uri of the remote server
* @return zero if no error.
*/
int udp_set_remote_url(URLContext *h, const char *uri)
{
UDPContext *s = h->priv_data;
char hostname[256];
int port;
url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);
/* set the destination address */
s->dest_addr_len = udp_set_url(&s->dest_addr, hostname, port);
if (s->dest_addr_len < 0) {
return AVERROR(EIO);
}
s->is_multicast = is_multicast_address(&s->dest_addr);
return 0;
}
std::set<port_index_type> switch_::get_targets_for(port_index_type index, boost::asio::const_buffer data)
{
const port_list_type::iterator source_port_entry = m_ports.find(index);
if (source_port_entry != m_ports.end())
{
switch (m_configuration.routing_method)
{
case switch_configuration::RM_HUB:
{
return get_targets_for(source_port_entry);
}
case switch_configuration::RM_SWITCH:
{
asiotap::osi::const_helper<asiotap::osi::ethernet_frame> ethernet_helper(data);
const ethernet_address_type target_address = to_ethernet_address(ethernet_helper.target());
if (is_multicast_address(target_address))
{
return get_targets_for(source_port_entry);
}
else
{
m_ethernet_address_map[to_ethernet_address(ethernet_helper.sender())] = index;
// We exceeded the maximum count for entries: we delete random entries to fix it.
while (m_ethernet_address_map.size() > m_max_entries)
{
ethernet_address_map_type::iterator entry = m_ethernet_address_map.begin();
#if BOOST_VERSION >= 104700
boost::random::mt19937 gen;
std::advance(entry, boost::random::uniform_int_distribution<>(0, static_cast<int>(m_ethernet_address_map.size()) - 1)(gen));
#else
boost::mt19937 gen;
boost::variate_generator<boost::mt19937&, boost::uniform_int<> > vgen(gen, boost::uniform_int<>(0, m_ethernet_address_map.size() - 1));
std::advance(entry, vgen());
#endif
m_ethernet_address_map.erase(entry);
}
// We look in the ethernet address map
const ethernet_address_map_type::iterator target_entry = m_ethernet_address_map.find(target_address);
if (target_entry == m_ethernet_address_map.end())
{
// No target entry: we send the message to everybody.
return get_targets_for(source_port_entry);
}
const port_index_type target_port_index = target_entry->second;
if (!is_registered(target_port_index))
{
// The port does not exist: we delete the entry and send to everybody.
m_ethernet_address_map.erase(target_entry);
return get_targets_for(source_port_entry);
}
std::set<port_index_type> targets;
targets.insert(target_port_index);
return targets;
}
}
}
}
return std::set<port_index_type>();
}
static GstSDPStream *
gst_sdp_demux_create_stream (GstSDPDemux * demux, GstSDPMessage * sdp, gint idx)
{
GstSDPStream *stream;
const gchar *payload, *rtcp;
const GstSDPMedia *media;
const GstSDPConnection *conn;
/* get media, should not return NULL */
media = gst_sdp_message_get_media (sdp, idx);
if (media == NULL)
return NULL;
stream = g_new0 (GstSDPStream, 1);
stream->parent = demux;
/* we mark the pad as not linked, we will mark it as OK when we add the pad to
* the element. */
stream->last_ret = GST_FLOW_OK;
stream->added = FALSE;
stream->disabled = FALSE;
stream->id = demux->numstreams++;
stream->eos = FALSE;
/* we must have a payload. No payload means we cannot create caps */
/* FIXME, handle multiple formats. */
if ((payload = gst_sdp_media_get_format (media, 0))) {
stream->pt = atoi (payload);
/* convert caps */
stream->caps = gst_sdp_demux_media_to_caps (stream->pt, media);
if (stream->pt >= 96) {
/* If we have a dynamic payload type, see if we have a stream with the
* same payload number. If there is one, they are part of the same
* container and we only need to add one pad. */
if (find_stream (demux, GINT_TO_POINTER (stream->pt),
(gpointer) find_stream_by_pt)) {
stream->container = TRUE;
}
}
}
if (!(conn = gst_sdp_media_get_connection (media, 0))) {
if (!(conn = gst_sdp_message_get_connection (sdp)))
goto no_connection;
}
stream->destination = conn->address;
stream->ttl = conn->ttl;
stream->multicast = is_multicast_address (stream->destination);
stream->rtp_port = gst_sdp_media_get_port (media);
if ((rtcp = gst_sdp_media_get_attribute_val (media, "rtcp"))) {
/* FIXME, RFC 3605 */
stream->rtcp_port = stream->rtp_port + 1;
} else {
stream->rtcp_port = stream->rtp_port + 1;
}
GST_DEBUG_OBJECT (demux, "stream %d, (%p)", stream->id, stream);
GST_DEBUG_OBJECT (demux, " pt: %d", stream->pt);
GST_DEBUG_OBJECT (demux, " container: %d", stream->container);
GST_DEBUG_OBJECT (demux, " caps: %" GST_PTR_FORMAT, stream->caps);
/* we keep track of all streams */
demux->streams = g_list_append (demux->streams, stream);
return stream;
/* ERRORS */
no_connection:
{
gst_sdp_demux_stream_free (demux, stream);
return NULL;
}
}
Sock * Sock_connect(char *host, char *port, Sock *binded, sock_type socktype, sock_flags ssl_flag)
{
Sock *s;
char remote_host[128]; /*Unix Domain is largest*/
char local_host[128]; /*Unix Domain is largest*/
int sockfd = -1;
struct sockaddr *sa_p = NULL;
socklen_t sa_len = 0;
int32_t local_port;
int32_t remote_port;
#if HAVE_SSL
SSL *ssl_con;
#endif
if(binded) {
sockfd = binded->fd;
}
if (sock_connect(host, port, &sockfd, socktype)) {
net_log(NET_LOG_ERR, "Sock_connect() failure.\n");
return NULL;
}
#if HAVE_SSL
if(ssl_flag & IS_SSL) {
if (sock_SSL_connect(&ssl_con))
net_log (NET_LOG_ERR, "Sock_connect() failure in SSL init.\n");
sock_close(sockfd);
return NULL;
}
else
#endif
if (binded) {
s = binded;
free(s->local_host);
s->local_host = NULL;
free(s->remote_host);
s->remote_host = NULL;
} else if (!(s = calloc(1, sizeof(Sock)))) {
net_log(NET_LOG_FATAL, "Unable to allocate a Sock struct in Sock_connect().\n");
#if HAVE_SSL
if(ssl_flag & IS_SSL)
sock_SSL_close(ssl_con);
#endif
sock_close (sockfd);
return NULL;
}
s->fd = sockfd;
s->socktype = socktype;
#if HAVE_SSL
if(ssl_flag & IS_SSL)
s->ssl = ssl_con;
#endif
s->flags = ssl_flag;
sa_p = (struct sockaddr *) &(s->local_stg);
sa_len = sizeof(struct sockaddr_storage);
if(getsockname(s->fd, sa_p, &sa_len))
{
net_log(NET_LOG_ERR, "Unable to get remote port in Sock_connect().\n");
Sock_close(s);
return NULL;
}
if(!sock_ntop_host(sa_p, local_host, sizeof(local_host)))
memset(local_host, 0, sizeof(local_host));
if (!(s->local_host = strdup(local_host))) {
net_log(NET_LOG_FATAL, "Unable to allocate local host in Sock_connect().\n");
Sock_close(s);
return NULL;
}
local_port = sock_get_port(sa_p);
if(local_port < 0) {
net_log(NET_LOG_ERR, "Unable to get local port in Sock_connect().\n");
Sock_close(s);
return NULL;
} else
s->local_port = ntohs(local_port);
sa_p = (struct sockaddr *) &(s->remote_stg);
sa_len = sizeof(struct sockaddr_storage);
if(getpeername(s->fd, sa_p, &sa_len))
{
net_log(NET_LOG_ERR, "Unable to get remote address in Sock_connect().\n");
Sock_close(s);
return NULL;
}
if(!sock_ntop_host(sa_p, remote_host, sizeof(remote_host)))
memset(remote_host, 0, sizeof(remote_host));
if (!(s->remote_host = strdup(remote_host))) {
net_log(NET_LOG_FATAL, "Unable to allocate remote host in Sock_connect().\n");
Sock_close(s);
return NULL;
}
remote_port = sock_get_port(sa_p);
if(remote_port < 0) {
net_log(NET_LOG_ERR, "Unable to get remote port in Sock_connect().\n");
Sock_close(s);
return NULL;
} else
s->remote_port = ntohs(remote_port);
net_log(NET_LOG_DEBUG, "Socket connected between local=\"%s\":%u and "
"remote=\"%s\":%u.\n", s->local_host, s->local_port, s->remote_host,
s->remote_port);
if(is_multicast_address(sa_p, s->remote_stg.ss_family)) {
//fprintf(stderr,"IS MULTICAST\n");
if(mcast_join(s->fd, sa_p, NULL, 0, &(s->addr))!=0) {
Sock_close(s);
return NULL;
}
s->flags |= IS_MULTICAST;
}
return s;
}
Sock * Sock_bind(char const *host, char const *port, Sock *sock,
sock_type socktype, void * octx)
{
Sock *s = NULL;
int sockfd = -1;
struct sockaddr *sa_p;
socklen_t sa_len;
char local_host[128];
int local_port;
#if ENABLE_SSL
if ((octx)) {
if(socktype != TCP) {
net_log(NET_LOG_ERR, "SSL can't work on this protocol.\n");
return NULL;
}
}
#endif
if(sock) {
sockfd = sock->fd;
}
if (sock_bind(host, port, &sockfd, socktype)) {
net_log(NET_LOG_ERR, "Error in low level sock_bind().\n");
return NULL;
}
if (!(s = calloc(1, sizeof(Sock)))) {
net_log(NET_LOG_FATAL,
"Unable to allocate a Sock struct in Sock_bind().\n");
sock_close(sockfd);
return NULL;
}
s->fd = sockfd;
s->socktype = socktype;
s->flags = 0;
sa_p = (struct sockaddr *)&(s->local_stg);
sa_len = sizeof(struct sockaddr_storage);
if(getsockname(s->fd, sa_p, &sa_len) < 0) {
Sock_close(s);
return NULL;
}
if(!sock_ntop_host(sa_p, local_host, sizeof(local_host)))
memset(local_host, 0, sizeof(local_host));
if (!(s->local_host = strdup(local_host))) {
net_log(NET_LOG_FATAL,
"Unable to allocate local host in Sock_bind().\n");
Sock_close(s);
return NULL;
}
local_port = sock_get_port(sa_p);
if(local_port < 0) {
net_log(NET_LOG_ERR, "Unable to get local port in Sock_bind().\n");
Sock_close(s);
return NULL;
} else
s->local_port = ntohs(local_port);
net_log(NET_LOG_DEBUG,
"Socket bound with addr=\"%s\" and port=\"%u\".\n",
s->local_host, s->local_port);
if(is_multicast_address(sa_p, s->local_stg.ss_family)) {
if(mcast_join(s->fd, sa_p)) {
Sock_close(s);
return NULL;
}
s->flags |= IS_MULTICAST;
}
return s;
}
