X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=udp_recv.c;h=9ea35d8d53ed2db68a54bfd1bc5527866d4f3061;hp=66dc36b904822437851b538499f9fe43203ed3a2;hb=6ba0a5055cfdec25d54d90a56f9345d5d4be09be;hpb=9692b4241bc316665bd5b6810ea8af83057a0a89

diff --git a/udp_recv.c b/udp_recv.c
index 66dc36b9..9ea35d8d 100644
--- a/udp_recv.c
+++ b/udp_recv.c
@@ -8,6 +8,7 @@
 #include <dirent.h>
 
 #include "para.h"
+#include "error.h"
 #include "portable_io.h"
 #include "udp_header.h"
 #include "list.h"
@@ -15,7 +16,6 @@
 #include "ggo.h"
 #include "recv.h"
 #include "udp_recv.cmdline.h"
-#include "error.h"
 #include "audiod.h"
 #include "string.h"
 #include "net.h"
@@ -43,6 +43,10 @@ struct private_udp_recv_data {
 	int have_header;
 	/** The socket file descriptor. */
 	int fd;
+	/** Non-zero on short reads. */
+	uint16_t need_more;
+	/** Copied from the first audio header received. */
+	uint16_t stream_type;
 };
 
 static void udp_recv_pre_select(struct sched *s, struct task *t)
@@ -58,14 +62,74 @@ static int enough_space(size_t nbytes, size_t loaded)
 	return nbytes + loaded < UDP_RECV_CHUNK_SIZE;
 }
 
+/*
+ * Perform some sanity checks on an udp audio file header.
+ *
+ * return: negative on error, 0: discard data, 1: use data
+ */
+static int examine_audio_header(struct private_udp_recv_data *purd,
+		struct udp_audio_header *uah, size_t packet_size)
+{
+	/* payload_len includes header */
+	if (uah->payload_len < uah->header_len)
+		return -E_UDP_BAD_HEADER;
+	switch (uah->packet_type) {
+	case UDP_EOF_PACKET:
+		return -E_RECV_EOF;
+	case UDP_BOF_PACKET:
+		purd->have_header = 1;
+		/* fall through */
+	case UDP_DATA_PACKET:
+		if (uah->header_len) /* header in no-header packet */
+			return -E_UDP_BAD_HEADER;
+		break;
+	case UDP_HEADER_PACKET:
+		if (!uah->header_len) /** no header in header packet */
+			return -E_UDP_BAD_HEADER;
+		break;
+	default: /* bad packet type */
+		return -E_UDP_BAD_HEADER;
+	}
+	/* check stream type */
+	if (uah->stream_type != UDP_PLAIN_STREAM &&
+			uah->stream_type != UDP_HEADER_STREAM)
+		return -E_UDP_BAD_STREAM_TYPE;
+	if (purd->stream_type == UDP_UNKNOWN_STREAM)
+		purd->stream_type = uah->stream_type;
+	/* stream type must not change */
+	if (uah->stream_type != purd->stream_type)
+		return -E_UDP_BAD_STREAM_TYPE;
+	if (!purd->have_header && uah->stream_type == UDP_HEADER_STREAM)
+		/* can't use the data, wait for header packet */
+		return 0;
+	if (packet_size < uah->payload_len + UDP_AUDIO_HEADER_LEN)
+		/* we read only a part of the package */
+		purd->need_more = uah->payload_len
+			+ UDP_AUDIO_HEADER_LEN - packet_size;
+	return 1;
+}
+
+static int add_rn_output(struct receiver_node *rn, char *buf, size_t len)
+{
+	if (!len)
+		return 1;
+	if (!enough_space(len, rn->loaded))
+		return -E_UDP_OVERRUN;
+	memcpy(rn->buf + rn->loaded, buf, len);
+	rn->loaded += len;
+	return 1;
+}
+
 static void udp_recv_post_select(__a_unused struct sched *s, struct task *t)
 {
 	struct receiver_node *rn = container_of(t, struct receiver_node, task);
 	struct private_udp_recv_data *purd = rn->private_data;
 	int ret;
 	char tmpbuf[UDP_RECV_CHUNK_SIZE];
+	uint16_t data_len;
+	char *data_buf;
 	size_t packet_size;
-	uint8_t stream_type, packet_type;
+	struct udp_audio_header uah;
 
 	if (rn->output_error && *rn->output_error < 0) {
 		t->error = *rn->output_error;
@@ -84,71 +148,45 @@ static void udp_recv_post_select(__a_unused struct sched *s, struct task *t)
 	if (!ret)
 		return;
 	packet_size = ret;
-	t->error = -E_UDP_SHORT_PACKET;
-	if (packet_size < UDP_AUDIO_HEADER_LEN)
-		return;
-	t->error = -E_UDP_NO_MAGIC;
-	if (udp_check_magic(tmpbuf, packet_size) < 0)
-		return;
-	stream_type = udp_read_stream_type(tmpbuf);
-	packet_type = udp_read_packet_type(tmpbuf);
-//	PARA_INFO_LOG("packet type: %d, stream type: %d,"
-//		" loaded: %u\n", packet_type,
-//		(unsigned) stream_type, rn->loaded);
-	switch (packet_type) {
-		uint16_t header_len, payload_len;
+	for (;;) {
+		uint16_t num;
 
-	case UDP_EOF_PACKET:
-		t->error = -E_RECV_EOF;
-		return;
-	case UDP_BOF_PACKET:
-		PARA_INFO_LOG("bof (%zu)\n", packet_size);
-		purd->have_header = 1;
-		/* fall through */
-	case UDP_DATA_PACKET:
-		if (!purd->have_header && stream_type == UDP_HEADER_STREAM)
-			/* can't use the data, wait for header */
-			goto success;
-		payload_len = packet_size - UDP_AUDIO_HEADER_LEN;
-		if (!payload_len)
-			goto success;
-		t->error = -E_OVERRUN;
-		if (!enough_space(payload_len, rn->loaded))
-			return;
-		memcpy(rn->buf + rn->loaded, tmpbuf + UDP_AUDIO_HEADER_LEN,
-			payload_len);
-		rn->loaded += payload_len;
-		goto success;
-	case UDP_HEADER_PACKET:
-		header_len = udp_read_header_len(tmpbuf);
-		if (header_len + UDP_AUDIO_HEADER_LEN > packet_size) {
-			t->error = -E_INVALID_HEADER;
-			return;
+		if (!purd->need_more) {
+			ret = read_udp_audio_header(tmpbuf, packet_size, &uah);
+			if (ret >= 0)
+				break;
+			goto success; /* drop data */
 		}
-//		PARA_DEBUG_LOG("header packet (%zu bytes), header len: %d\n",
-//			packet_size, header_len);
-		if (!purd->have_header) {
-			t->error = -E_OVERRUN;
-			if (!enough_space(header_len, rn->loaded))
-				return;
-			purd->have_header = 1;
-			rn->loaded = header_len;
-			memcpy(rn->buf, tmpbuf + UDP_AUDIO_HEADER_LEN,
-				rn->loaded);
+		num = PARA_MIN(purd->need_more, (uint16_t)packet_size);
+		assert(num > 0);
+		t->error = add_rn_output(rn, tmpbuf, num);
+		if (t->error < 0)
+			return;
+		purd->need_more -= num;
+		if (packet_size <= num)
 			goto success;
+		packet_size -= num;
+		memmove(tmpbuf, tmpbuf + num, packet_size);
+	}
+	assert(!purd->need_more);
+	t->error = examine_audio_header(purd, &uah, packet_size);
+	if (t->error <= 0)
+		return;
+	data_len = uah.payload_len;
+	data_buf = tmpbuf + UDP_AUDIO_HEADER_LEN;
+	if (uah.packet_type == UDP_HEADER_PACKET) {
+		if (purd->have_header) { /* skip header */
+			data_buf += uah.header_len;
+			data_len -= uah.header_len;
+		} else { /* only use the header */
+			purd->have_header = 1;
+			data_len = uah.header_len;
 		}
-		payload_len = packet_size - UDP_AUDIO_HEADER_LEN - header_len;
-		if (!payload_len)
-			goto success;
-		t->error = -E_OVERRUN;
-		if (!enough_space(payload_len, rn->loaded))
-			return;
-		memcpy(rn->buf + rn->loaded, tmpbuf + UDP_AUDIO_HEADER_LEN +
-			header_len, payload_len);
-		rn->loaded += payload_len;
 	}
+	t->error = add_rn_output(rn, data_buf, data_len);
+	return;
 success:
-	t->error = 0;
+	t->error = 1;
 }
 
 static void udp_shutdown(void)
@@ -179,25 +217,100 @@ static void *udp_recv_parse_config(int argc, char **argv)
 	return NULL;
 }
 
+/*
+ * Perform AF-independent joining of multicast receive addresses.
+ *
+ * \param fd	Bound socket descriptor.
+ * \param iface	The receiving multicast interface, or NULL for the default.
+ *
+ * \return Zero if okay, negative on error.
+ */
+static int mcast_receiver_setup(int fd, const char *iface)
+{
+	struct sockaddr_storage ss;
+	socklen_t sslen = sizeof(ss);
+	int id = iface == NULL ? 0 : if_nametoindex(iface);
+
+	if (getsockname(fd, (struct sockaddr *)&ss, &sslen) < 0)
+		goto err;
+
+	if (iface != NULL && id == 0)
+		PARA_WARNING_LOG("could not resolve interface %s, using default", iface);
+
+	switch (ss.ss_family) {
+	case AF_INET:
+		if (IN_MULTICAST(htonl(((struct sockaddr_in *)&ss)->sin_addr.s_addr))) {
+#ifdef HAVE_IP_MREQN
+			struct ip_mreqn m4;
+
+			m4.imr_address.s_addr	= INADDR_ANY;
+			m4.imr_ifindex		= id;
+#else
+			struct ip_mreq m4;
+
+			m4.imr_interface.s_addr	= INADDR_ANY;
+			if (id != 0)
+				PARA_ERROR_LOG("Setting IPv4 receiver mcast interface not supported.");
+
+#endif
+			m4.imr_multiaddr	= ((struct sockaddr_in *)&ss)->sin_addr;
+
+			if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &m4, sizeof(m4)) < 0)
+				break;
+		}
+		return 0;
+	case AF_INET6:
+		if (IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *)&ss)->sin6_addr)) {
+			struct ipv6_mreq m6;
+
+			memset(&m6, 0, sizeof(m6));
+			memcpy(&m6.ipv6mr_multiaddr, &((struct sockaddr_in6 *)&ss)->sin6_addr, 16);
+			m6.ipv6mr_interface = id;
+			if (setsockopt(fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, &m6, sizeof(m6)) < 0)
+				break;
+		}
+		return 0;
+	default:
+		PARA_ERROR_LOG("address family %d not supported", ss.ss_family);
+		return -E_ADDRESS_LOOKUP;
+	}
+err:
+	return -ERRNO_TO_PARA_ERROR(errno);
+}
+
 static int udp_recv_open(struct receiver_node *rn)
 {
 	struct private_udp_recv_data *purd;
 	struct udp_recv_args_info *c = rn->conf;
+	char  *iface = c->iface_given ? c->iface_arg : NULL;
 	int ret;
 
 	rn->buf = para_calloc(UDP_RECV_CHUNK_SIZE);
 	rn->private_data = para_calloc(sizeof(struct private_udp_recv_data));
 	purd = rn->private_data;
-	ret = create_udp_recv_socket(c->host_arg, c->port_arg);
+
+	ret = makesock(AF_UNSPEC, IPPROTO_UDP, 1, c->host_arg, c->port_arg);
 	if (ret < 0)
-		return ret;
+		goto err;
 	purd->fd = ret;
+
+	ret = mcast_receiver_setup(purd->fd, iface);
+	if (ret < 0) {
+		close(purd->fd);
+		return ret;
+	}
+
 	ret = mark_fd_nonblocking(purd->fd);
 	if (ret < 0)
-		return ret;
+		goto err;
+	purd->stream_type = UDP_UNKNOWN_STREAM;
 	PARA_NOTICE_LOG("receiving from %s:%d, fd=%d\n", c->host_arg,
 		c->port_arg, purd->fd);
 	return purd->fd;
+err:
+	free(rn->private_data);
+	free(rn->buf);
+	return ret;
 }
 
 /**