diff --git a/openbsc/src/rtp_proxy.c b/openbsc/src/rtp_proxy.c
index f7eb8b8..61fc385 100644
--- a/openbsc/src/rtp_proxy.c
+++ b/openbsc/src/rtp_proxy.c
@@ -23,15 +23,21 @@
 #include <unistd.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
+#include <arpa/inet.h>
 
 #include <openbsc/talloc.h>
 #include <openbsc/gsm_data.h>
 #include <openbsc/msgb.h>
 #include <openbsc/select.h>
+#include <openbsc/debug.h>
 #include <openbsc/rtp_proxy.h>
 
 static LLIST_HEAD(rtp_sockets);
 
+/* should we mangle the CNAME inside SDES of RTCP packets? We disable
+ * this by default, as it seems to be not needed */
+static int mangle_rtcp_cname = 0;
+
 enum rtp_bfd_priv {
 	RTP_PRIV_NONE,
 	RTP_PRIV_RTP,
@@ -40,6 +46,103 @@
 
 #define RTP_ALLOC_SIZE	1500
 
+/* according to RFC 1889 */
+struct rtcp_hdr {
+	u_int8_t byte0;
+	u_int8_t type;
+	u_int16_t length;
+} __attribute__((packed));
+
+#define RTCP_TYPE_SDES	202
+	
+#define RTCP_IE_CNAME	1
+
+/* iterate over all chunks in one RTCP message, kook for CNAME IEs and
+ * replace all of those with 'new_cname' */
+static int rtcp_sdes_cname_mangle(struct msgb *msg, struct rtcp_hdr *rh,
+				  u_int16_t *rtcp_len, const char *new_cname)
+{
+	u_int8_t *rtcp_end;
+	u_int8_t *cur = (u_int8_t *) rh;
+	u_int8_t tag, len = 0;
+
+	rtcp_end = cur + *rtcp_len;
+	/* move cur to end of RTP header */
+	cur += sizeof(rh);
+
+	/* iterate over Chunks */
+	while (cur+4 < rtcp_end) {
+		/* skip four bytes SSRC/CSRC */
+		cur += 4;
+	
+		/* iterate over IE's inside the chunk */
+		while (cur+1 < rtcp_end) {
+			tag = *cur++;
+			if (tag == 0) {
+				/* end of chunk, skip additional zero */
+				while (*cur++ == 0) { }
+				break;
+			}
+			len = *cur++;
+	
+			if (tag == RTCP_IE_CNAME) {
+				/* we've found the CNAME, lets mangle it */
+				if (len < strlen(new_cname)) {
+					/* we need to make more space */
+					int increase = strlen(new_cname) - len;
+
+					msgb_push(msg, increase);
+					memmove(cur+len+increase, cur+len,
+						rtcp_end - (cur+len));
+					/* FIXME: we have to respect RTCP
+					 * padding/alignment rules! */
+					len += increase;
+					*(cur-1) += increase;
+					rtcp_end += increase;
+					*rtcp_len += increase;
+				}
+				/* copy new CNAME into message */
+				memcpy(cur, new_cname, strlen(new_cname));
+				/* FIXME: zero the padding in case new CNAME
+				 * is smaller than old one !!! */
+			}
+			cur += len;
+		}
+	}
+
+	return 0;
+}
+
+static int rtcp_mangle(struct msgb *msg, struct rtp_socket *rs)
+{
+	struct rtp_sub_socket *rss = &rs->rtcp;
+	struct rtcp_hdr *rtph;
+	u_int16_t old_len;
+	int rc;
+
+	if (!mangle_rtcp_cname)
+		return 0;
+
+	/* iterate over list of RTCP messages */
+	rtph = (struct rtcp_hdr *)msg->data;
+	while ((void *)rtph + sizeof(*rtph) < (void *)msg->data + msg->len) {
+		old_len = (ntohs(rtph->length) + 1) * 4;
+		if (rtph->type == RTCP_TYPE_SDES) {
+			char new_cname[255];
+			strncpy(new_cname, inet_ntoa(rss->sin_local.sin_addr),
+				sizeof(new_cname));
+			new_cname[sizeof(new_cname)-1] = '\0';
+			rc = rtcp_sdes_cname_mangle(msg, rtph, &old_len,
+						    new_cname);
+			if (rc < 0)
+				return rc;
+		}
+		rtph = (void *)rtph + old_len;
+	}
+
+	return 0;
+}
+
 /* read from incoming RTP/RTCP socket */
 static int rtp_socket_read(struct rtp_socket *rs, struct rtp_sub_socket *rss)
 {
@@ -60,13 +163,21 @@
 
 	switch (rs->rx_action) {
 	case RTP_PROXY:
+		if (!rs->proxy.other_sock) {
+			rc = -EIO;
+			goto out_free;
+		}
 		if (rss->bfd.priv_nr == RTP_PRIV_RTP)
 			other_rss = &rs->proxy.other_sock->rtp;
-		else if (rss->bfd.priv_nr == RTP_PRIV_RTCP)
+		else if (rss->bfd.priv_nr == RTP_PRIV_RTCP) {
 			other_rss = &rs->proxy.other_sock->rtcp;
-		else {
-			msgb_free(msg);
-			return -EINVAL;
+			/* modify RTCP SDES CNAME */
+			rc = rtcp_mangle(msg, rs);
+			if (rc < 0)
+				goto out_free;
+		} else {
+			rc = -EINVAL;
+			goto out_free;
 		}
 		msgb_enqueue(&other_rss->tx_queue, msg);
 		other_rss->bfd.when |= BSC_FD_WRITE;
@@ -75,6 +186,10 @@
 	}
 
 	return rc;
+
+out_free:
+	msgb_free(msg);
+	return rc;
 }
 
 /* write from tx_queue to RTP/RTCP socket */
@@ -143,6 +258,8 @@
 	int rc;
 	struct rtp_socket *rs;
 
+	DEBUGP(DMUX, "rtp_socket_create(): ");
+
 	rs = talloc_zero(tall_bsc_ctx, struct rtp_socket);
 	if (!rs)
 		return NULL;
@@ -168,8 +285,16 @@
 	if (rc < 0)
 		goto out_rtcp_socket;
 
+	DEBUGPC(DMUX, "success\n");
+
+	rc = rtp_socket_bind(rs, INADDR_ANY);
+	if (rc < 0)
+		goto out_rtcp_bfd;
+
 	return rs;
 
+out_rtcp_bfd:
+	bsc_unregister_fd(&rs->rtcp.bfd);
 out_rtcp_socket:
 	close(rs->rtcp.bfd.fd);
 out_rtp_bfd:
@@ -178,31 +303,48 @@
 	close(rs->rtp.bfd.fd);
 out_free:
 	talloc_free(rs);
+	DEBUGPC(DMUX, "failed\n");
 	return NULL;
 }
 
 static int rtp_sub_socket_bind(struct rtp_sub_socket *rss, u_int32_t ip,
 				u_int16_t port)
 {
+	int rc;
+	socklen_t alen = sizeof(rss->sin_local);
+
 	rss->sin_local.sin_family = AF_INET;
 	rss->sin_local.sin_addr.s_addr = htonl(ip);
 	rss->sin_local.sin_port = htons(port);
 	rss->bfd.when |= BSC_FD_READ;
 
-	return bind(rss->bfd.fd, (struct sockaddr *)&rss->sin_local,
-		    sizeof(rss->sin_local));
+	rc = bind(rss->bfd.fd, (struct sockaddr *)&rss->sin_local,
+		  sizeof(rss->sin_local));
+	if (rc < 0)
+		return rc;
+
+	/* retrieve the address we actually bound to, in case we
+	 * passed INADDR_ANY as IP address */
+	return getsockname(rss->bfd.fd, (struct sockaddr *)&rss->sin_local,
+			   &alen);
 }
 
 #define RTP_PORT_BASE	30000
-static u_int16_t next_udp_port = RTP_PORT_BASE;
+static unsigned int next_udp_port = RTP_PORT_BASE;
 
 /* bind a RTP socket to a local address */
 int rtp_socket_bind(struct rtp_socket *rs, u_int32_t ip)
 {
-	int rc;
+	int rc = -EIO;
+	struct in_addr ia;
+
+	ia.s_addr = htonl(ip);
+	DEBUGP(DMUX, "rtp_socket_bind(rs=%p, IP=%s): ", rs,
+		inet_ntoa(ia));
 
 	/* try to bind to a consecutive pair of ports */
-	for (next_udp_port; next_udp_port < 0xffff; next_udp_port += 2) {
+	for (next_udp_port = next_udp_port % 0xffff;
+	     next_udp_port < 0xffff; next_udp_port += 2) {
 		rc = rtp_sub_socket_bind(&rs->rtp, ip, next_udp_port);
 		if (rc != 0)
 			continue;
@@ -211,27 +353,45 @@
 		if (rc == 0)
 			break;
 	}
-	if (rc < 0)
+	if (rc < 0) {
+		DEBUGPC(DMUX, "failed\n");
 		return rc;
+	}
 
+	ia.s_addr = rs->rtp.sin_local.sin_addr.s_addr;
+	DEBUGPC(DMUX, "BOUND_IP=%s, BOUND_PORT=%u\n",
+		inet_ntoa(ia), ntohs(rs->rtp.sin_local.sin_port));
 	return ntohs(rs->rtp.sin_local.sin_port);
 }
 
 static int rtp_sub_socket_connect(struct rtp_sub_socket *rss,
 				  u_int32_t ip, u_int16_t port)
 {
+	int rc;
+	socklen_t alen = sizeof(rss->sin_local);
+
 	rss->sin_remote.sin_family = AF_INET;
 	rss->sin_remote.sin_addr.s_addr = htonl(ip);
 	rss->sin_remote.sin_port = htons(port);
 
-	return connect(rss->bfd.fd, (struct sockaddr *) &rss->sin_remote,
-			sizeof(rss->sin_remote));
+	rc = connect(rss->bfd.fd, (struct sockaddr *) &rss->sin_remote,
+		     sizeof(rss->sin_remote));
+	if (rc < 0)
+		return rc;
+
+	return getsockname(rss->bfd.fd, (struct sockaddr *)&rss->sin_local,
+			   &alen);
 }
 
 /* 'connect' a RTP socket to a remote peer */
 int rtp_socket_connect(struct rtp_socket *rs, u_int32_t ip, u_int16_t port)
 {
 	int rc;
+	struct in_addr ia;
+
+	ia.s_addr = htonl(ip);
+	DEBUGP(DMUX, "rtp_socket_connect(rs=%p, ip=%s, port=%u)\n",
+		rs, inet_ntoa(ia), port);
 
 	rc = rtp_sub_socket_connect(&rs->rtp, ip, port);
 	if (rc < 0)
@@ -243,6 +403,9 @@
 /* bind two RTP/RTCP sockets together */
 int rtp_socket_proxy(struct rtp_socket *this, struct rtp_socket *other)
 {
+	DEBUGP(DMUX, "rtp_socket_proxy(this=%p, other=%p)\n",
+		this, other);
+
 	this->rx_action = RTP_PROXY;
 	this->proxy.other_sock = other;
 
@@ -262,6 +425,7 @@
 
 int rtp_socket_free(struct rtp_socket *rs)
 {
+	DEBUGP(DMUX, "rtp_socket_free(rs=%p)\n", rs);
 
 	/* make sure we don't leave references dangling to us */
 	if (rs->rx_action == RTP_PROXY &&