add simplistic IuUP FSM and strip/add IuUP headers
This should really be using the FSM in libosmocore/laforge/iu_up: take the best
of both sides and integate in the libosmocore FSM implementation, then use it
here.
- in libosmocore, the FSM definition is nicer.
- here, we have correct header checksums.
Introduce using msgb to receive, pass and send RTP packets.
Add/strip IuUP from RTP data (for which msgb is particularly useful).
The payload type on an IuUP conn is maintained as negotiated in the IuUP
Initialization. For the pure RTP side, an SDP "AMR" ptmap attribute is looked
up, so that payload type numbers are translated between IuUP <-> RTP.
Change-Id: Ibc70e0aa00476926dd1f4ea8139c34f31f9cdfa3
diff --git a/src/libosmo-mgcp/mgcp_network.c b/src/libosmo-mgcp/mgcp_network.c
index c4b9ce6..73a2aca 100644
--- a/src/libosmo-mgcp/mgcp_network.c
+++ b/src/libosmo-mgcp/mgcp_network.c
@@ -45,6 +45,8 @@
#include <osmocom/mgcp/mgcp_codec.h>
#include <osmocom/mgcp/debug.h>
#include <osmocom/codec/codec.h>
+#include <osmocom/mgcp/iuup_cn_node.h>
+#include <osmocom/mgcp/iuup_protocol.h>
#define RTP_SEQ_MOD (1 << 16)
@@ -52,11 +54,13 @@
#define RTP_MAX_MISORDER 100
#define RTP_BUF_SIZE 4096
-enum {
+enum rtp_proto {
MGCP_PROTO_RTP,
MGCP_PROTO_RTCP,
};
+static int rx_rtp(struct msgb *msg);
+
/*! Determine the local rtp bind IP-address.
* \param[out] addr caller provided memory to store the resulting IP-Address
* \param[in] endp mgcp endpoint, that holds a copy of the VTY parameters
@@ -469,21 +473,43 @@
* Patch the payload type of an RTP packet so that it uses the payload type
* that is valid for the destination connection (conn_dst) */
static int mgcp_patch_pt(struct mgcp_conn_rtp *conn_src,
- struct mgcp_conn_rtp *conn_dst, char *data, int len)
+ struct mgcp_conn_rtp *conn_dst, struct msgb *msg)
{
struct rtp_hdr *rtp_hdr;
uint8_t pt_in;
int pt_out;
- if (len < sizeof(struct rtp_hdr))
+ if (msg->len < sizeof(struct rtp_hdr)) {
+ LOG_CONN_RTP(conn_src, LOGL_ERROR, "RTP packet too short (%u < %zu)\n",
+ msg->len, sizeof(struct rtp_hdr));
return -EINVAL;
+ }
- rtp_hdr = (struct rtp_hdr *)data;
+ rtp_hdr = (struct rtp_hdr *)msg->data;
- pt_in = rtp_hdr->payload_type;
- pt_out = mgcp_codec_pt_translate(conn_src, conn_dst, pt_in);
- if (pt_out < 0)
- return -EINVAL;
+ if (conn_src->iuup) {
+ /* The source is an IuUP payload. We have received a dynamic payload type number on the IuUP side, and
+ * towards the pure RTP side it should go out as "AMR/8000". Make sure that the payload type number in
+ * the RTP packet matches the a=rtpmap:N payload type number configured for AMR. */
+ const struct mgcp_rtp_codec *amr_codec = mgcp_codec_pt_find_by_subtype_name(conn_dst, "AMR", 0);
+
+ if (!amr_codec) {
+ /* There is no AMR codec configured on the outgoing conn. */
+ return -EINVAL;
+ }
+
+ pt_out = amr_codec->payload_type;
+ } else if (conn_dst->iuup) {
+ /* The destination is an IuUP payload. Use whatever payload number was negotiated during IuUP
+ * Initialization. */
+ pt_out = conn_dst->iuup->rtp_payload_type;
+ } else {
+ /* Both sides are normal RTP payloads. Consult the rtpmap settings received by SDP. */
+ pt_in = rtp_hdr->payload_type;
+ pt_out = mgcp_codec_pt_translate(conn_src, conn_dst, pt_in);
+ if (pt_out < 0)
+ return -EINVAL;
+ }
rtp_hdr->payload_type = (uint8_t) pt_out;
return 0;
@@ -498,7 +524,7 @@
void mgcp_patch_and_count(struct mgcp_endpoint *endp,
struct mgcp_rtp_state *state,
struct mgcp_rtp_end *rtp_end,
- struct sockaddr_in *addr, char *data, int len)
+ struct sockaddr_in *addr, struct msgb *msg)
{
uint32_t arrival_time;
int32_t transit;
@@ -506,11 +532,12 @@
uint32_t timestamp, ssrc;
struct rtp_hdr *rtp_hdr;
int payload = rtp_end->codec->payload_type;
+ unsigned int len = msg->len;
if (len < sizeof(*rtp_hdr))
return;
- rtp_hdr = (struct rtp_hdr *)data;
+ rtp_hdr = (struct rtp_hdr *)msg->data;
seq = ntohs(rtp_hdr->sequence);
timestamp = ntohl(rtp_hdr->timestamp);
arrival_time = get_current_ts(rtp_end->codec->rate);
@@ -768,15 +795,14 @@
/* Forward data to a debug tap. This is debug function that is intended for
* debugging the voice traffic with tools like gstreamer */
-static void forward_data(int fd, struct mgcp_rtp_tap *tap, const char *buf,
- int len)
+static void forward_data(int fd, struct mgcp_rtp_tap *tap, struct msgb *msg)
{
int rc;
if (!tap->enabled)
return;
- rc = sendto(fd, buf, len, 0, (struct sockaddr *)&tap->forward,
+ rc = sendto(fd, msg->data, msg->len, 0, (struct sockaddr *)&tap->forward,
sizeof(tap->forward));
if (rc < 0)
@@ -794,7 +820,7 @@
* \param[in] conn_dst associated destination connection
* \returns 0 on success, -1 on ERROR */
int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct sockaddr_in *addr,
- char *buf, int len, struct mgcp_conn_rtp *conn_src,
+ struct msgb *msg, struct mgcp_conn_rtp *conn_src,
struct mgcp_conn_rtp *conn_dst)
{
/*! When no destination connection is available (e.g. when only one
@@ -806,6 +832,7 @@
struct mgcp_rtp_state *rtp_state;
char *dest_name;
int rc;
+ int len;
OSMO_ASSERT(conn_src);
OSMO_ASSERT(conn_dst);
@@ -829,7 +856,7 @@
* should not occur if transcoding is consequently avoided. Until
* we have transcoding support in osmo-mgw we can not resolve this. */
if (is_rtp) {
- rc = mgcp_patch_pt(conn_src, conn_dst, buf, len);
+ rc = mgcp_patch_pt(conn_src, conn_dst, msg);
if (rc < 0) {
LOGPENDP(endp, DRTP, LOGL_DEBUG,
"can not patch PT because no suitable egress codec was found.\n");
@@ -854,21 +881,21 @@
} else if (is_rtp) {
int cont;
int nbytes = 0;
- int buflen = len;
+ int buflen = msg->len;
do {
/* Run transcoder */
cont = endp->cfg->rtp_processing_cb(endp, rtp_end,
- buf, &buflen,
+ (char*)msg->data, &buflen,
RTP_BUF_SIZE);
if (cont < 0)
break;
if (addr)
mgcp_patch_and_count(endp, rtp_state, rtp_end,
- addr, buf, buflen);
+ addr, msg);
if (amr_oa_bwe_convert_indicated(conn_dst->end.codec)) {
- rc = amr_oa_bwe_convert(endp, buf, &buflen,
+ rc = amr_oa_bwe_convert(endp, (char*)msg->data, &buflen,
conn_dst->end.codec->param.amr_octet_aligned);
if (rc < 0) {
LOGPENDP(endp, DRTP, LOGL_ERROR,
@@ -879,7 +906,7 @@
else if (rtp_end->rfc5993_hr_convert
&& strcmp(conn_src->end.codec->subtype_name,
"GSM-HR-08") == 0) {
- rc = rfc5993_hr_convert(endp, buf, &buflen);
+ rc = rfc5993_hr_convert(endp, (char*)msg->data, &buflen);
if (rc < 0) {
LOGPENDP(endp, DRTP, LOGL_ERROR, "Error while converting to GSM-HR-08\n");
break;
@@ -895,8 +922,9 @@
/* Forward a copy of the RTP data to a debug ip/port */
forward_data(rtp_end->rtp.fd, &conn_src->tap_out,
- buf, buflen);
+ msg);
+#if 0
/* FIXME: HACK HACK HACK. See OS#2459.
* The ip.access nano3G needs the first RTP payload's first two bytes to read hex
* 'e400', or it will reject the RAB assignment. It seems to not harm other femto
@@ -904,7 +932,7 @@
*/
if (!rtp_state->patched_first_rtp_payload
&& conn_src->conn->mode == MGCP_CONN_LOOPBACK) {
- uint8_t *data = (uint8_t *) & buf[12];
+ uint8_t *data = msg->data + 12;
if (data[0] == 0xe0) {
data[0] = 0xe4;
data[1] = 0x00;
@@ -914,10 +942,13 @@
" to fake an IuUP Initialization Ack\n");
}
}
+#endif
- len = mgcp_udp_send(rtp_end->rtp.fd,
- &rtp_end->addr,
- rtp_end->rtp_port, buf, buflen);
+ if (conn_dst->iuup)
+ len = osmo_iuup_cn_tx_payload(conn_dst->iuup, msg);
+ else
+ len = mgcp_udp_send(rtp_end->rtp.fd, &rtp_end->addr, rtp_end->rtp_port,
+ (char*)msg->data, msg->len);
if (len <= 0)
return len;
@@ -938,7 +969,7 @@
len = mgcp_udp_send(rtp_end->rtcp.fd,
&rtp_end->addr,
- rtp_end->rtcp_port, buf, len);
+ rtp_end->rtcp_port, (char*)msg->data, msg->len);
rate_ctr_inc(&conn_dst->rate_ctr_group->ctr[RTP_PACKETS_TX_CTR]);
rate_ctr_add(&conn_dst->rate_ctr_group->ctr[RTP_OCTETS_TX_CTR], len);
@@ -949,45 +980,6 @@
return 0;
}
-/* Helper function for mgcp_recv(),
- Receive one RTP Packet + Originating address from file descriptor */
-static int receive_from(struct mgcp_endpoint *endp, int fd,
- struct sockaddr_in *addr, char *buf, int bufsize)
-{
- int rc;
- socklen_t slen = sizeof(*addr);
- struct sockaddr_in addr_sink;
- char buf_sink[RTP_BUF_SIZE];
- bool tossed = false;
-
- if (!addr)
- addr = &addr_sink;
- if (!buf) {
- tossed = true;
- buf = buf_sink;
- bufsize = sizeof(buf_sink);
- }
-
- rc = recvfrom(fd, buf, bufsize, 0, (struct sockaddr *)addr, &slen);
-
- LOGPENDP(endp, DRTP, LOGL_DEBUG,
- "receiving %u bytes length packet from %s:%u ...\n",
- rc, inet_ntoa(addr->sin_addr), ntohs(addr->sin_port));
-
- if (rc < 0) {
- LOGPENDP(endp, DRTP, LOGL_ERROR,
- "failed to receive packet, errno: %d/%s\n",
- errno, strerror(errno));
- return -1;
- }
-
- if (tossed) {
- LOGPENDP(endp, DRTP, LOGL_ERROR, "packet tossed\n");
- }
-
- return rc;
-}
-
/* Check if the origin (addr) matches the address/port data of the RTP
* connections. */
static int check_rtp_origin(struct mgcp_conn_rtp *conn,
@@ -1080,7 +1072,7 @@
/* Do some basic checks to make sure that the RTCP packets we are going to
* process are not complete garbage */
-static int check_rtcp(char *buf, unsigned int buf_size)
+static int check_rtcp(struct mgcp_conn_rtp *conn_src, struct msgb *msg)
{
struct rtcp_hdr *hdr;
unsigned int len;
@@ -1088,33 +1080,45 @@
/* RTPC packets that are just a header without data do not make
* any sense. */
- if (buf_size < sizeof(struct rtcp_hdr))
+ if (msg->len < sizeof(struct rtcp_hdr)) {
+ LOG_CONN_RTP(conn_src, LOGL_ERROR, "RTCP packet too short (%u < %zu)\n",
+ msg->len, sizeof(struct rtcp_hdr));
return -EINVAL;
+ }
/* Make sure that the length of the received packet does not exceed
* the available buffer size */
- hdr = (struct rtcp_hdr *)buf;
+ hdr = (struct rtcp_hdr *)msg->data;
len = (osmo_ntohs(hdr->length) + 1) * 4;
- if (len > buf_size)
+ if (len > msg->len) {
+ LOG_CONN_RTP(conn_src, LOGL_ERROR, "RTCP header length exceeds packet size (%u > %u)\n",
+ len, msg->len);
return -EINVAL;
+ }
/* Make sure we accept only packets that have a proper packet type set
* See also: http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml */
type = hdr->type;
- if ((type < 192 || type > 195) && (type < 200 || type > 213))
+ if ((type < 192 || type > 195) && (type < 200 || type > 213)) {
+ LOG_CONN_RTP(conn_src, LOGL_ERROR, "RTCP header: invalid type: %u\n", type);
return -EINVAL;
+ }
return 0;
}
/* Do some basic checks to make sure that the RTP packets we are going to
* process are not complete garbage */
-static int check_rtp(char *buf, unsigned int buf_size)
+static int check_rtp(struct mgcp_conn_rtp *conn_src, struct msgb *msg)
{
- /* RTP packets that are just a header without data do not make
- * any sense. */
- if (buf_size < sizeof(struct rtp_hdr))
- return -EINVAL;
+ size_t min_size = sizeof(struct rtp_hdr);
+ if (conn_src->iuup)
+ min_size += sizeof(struct osmo_iuup_hdr_data);
+ if (msg->len < min_size) {
+ LOG_CONN_RTP(conn_src, LOGL_ERROR, "RTP packet too short (%u < %zu)\n",
+ msg->len, min_size);
+ return -1;
+ }
/* FIXME: Add more checks, the reason why we do not check more than
* the length is because we currently handle IUUP packets as RTP
@@ -1125,86 +1129,14 @@
return 0;
}
-/* Receive RTP data from a specified source connection and dispatch it to a
- * destination connection. */
-static int mgcp_recv(int *proto, struct sockaddr_in *addr, char *buf,
- unsigned int buf_size, struct osmo_fd *fd)
-{
- struct mgcp_endpoint *endp;
- struct mgcp_conn_rtp *conn;
- struct mgcp_trunk_config *tcfg;
- int rc;
-
- conn = (struct mgcp_conn_rtp*) fd->data;
- endp = conn->conn->endp;
- tcfg = endp->tcfg;
-
- LOGPCONN(conn->conn, DRTP, LOGL_DEBUG, "receiving RTP/RTCP packet...\n");
-
- rc = receive_from(endp, fd->fd, addr, buf, buf_size);
- if (rc <= 0)
- return -1;
-
- /* FIXME: The way how we detect the protocol looks odd. We should look
- * into the packet header. Also we should introduce a packet type
- * MGCP_PROTO_IUUP because currently we handle IUUP packets like RTP
- * packets which is problematic. */
- *proto = fd == &conn->end.rtp ? MGCP_PROTO_RTP : MGCP_PROTO_RTCP;
-
- if (*proto == MGCP_PROTO_RTP) {
- if (check_rtp(buf, rc) < 0) {
- LOGPCONN(conn->conn, DRTP, LOGL_ERROR,
- "invalid RTP packet received -- packet tossed\n");
- return -1;
- }
- } else if (*proto == MGCP_PROTO_RTCP) {
- if (check_rtcp(buf, rc) < 0) {
- LOGPCONN(conn->conn, DRTP, LOGL_ERROR,
- "invalid RTCP packet received -- packet tossed\n");
- return -1;
- }
- }
-
- LOGPCONN(conn->conn, DRTP, LOGL_DEBUG, "");
- LOGPC(DRTP, LOGL_DEBUG, "receiving from %s %s %d\n",
- conn->conn->name, inet_ntoa(addr->sin_addr),
- ntohs(addr->sin_port));
- LOGPENDP(endp, DRTP, LOGL_DEBUG, "conn:%s\n", mgcp_conn_dump(conn->conn));
-
- /* Check if the origin of the RTP packet seems plausible */
- if (tcfg->rtp_accept_all == 0) {
- if (check_rtp_origin(conn, addr) != 0)
- return -1;
- }
-
- /* Filter out dummy message */
- if (rc == 1 && buf[0] == MGCP_DUMMY_LOAD) {
- LOGPCONN(conn->conn, DRTP, LOGL_NOTICE,
- "dummy message received\n");
- LOGPCONN(conn->conn, DRTP, LOGL_ERROR,
- "packet tossed\n");
- return 0;
- }
-
- /* Increment RX statistics */
- rate_ctr_inc(&conn->rate_ctr_group->ctr[RTP_PACKETS_RX_CTR]);
- rate_ctr_add(&conn->rate_ctr_group->ctr[RTP_OCTETS_RX_CTR], rc);
-
- /* Forward a copy of the RTP data to a debug ip/port */
- forward_data(fd->fd, &conn->tap_in, buf, rc);
-
- return rc;
-}
-
/* Send RTP data. Possible options are standard RTP packet
* transmission or trsmission via an osmux connection */
-static int mgcp_send_rtp(int proto, struct sockaddr_in *addr, char *buf,
- unsigned int buf_size,
- struct mgcp_conn_rtp *conn_src,
- struct mgcp_conn_rtp *conn_dst)
+static int mgcp_send_rtp(struct mgcp_conn_rtp *conn_dst, struct msgb *msg)
{
- struct mgcp_endpoint *endp;
- endp = conn_src->conn->endp;
+ enum rtp_proto proto = OSMO_RTP_MSG_CTX(msg)->proto;
+ struct mgcp_conn_rtp *conn_src = OSMO_RTP_MSG_CTX(msg)->conn_src;
+ struct sockaddr_in *from_addr = OSMO_RTP_MSG_CTX(msg)->from_addr;
+ struct mgcp_endpoint *endp = conn_src->conn->endp;
LOGPENDP(endp, DRTP, LOGL_DEBUG, "destin conn:%s\n",
mgcp_conn_dump(conn_dst->conn));
@@ -1223,13 +1155,13 @@
"endpoint type is MGCP_RTP_DEFAULT, "
"using mgcp_send() to forward data directly\n");
return mgcp_send(endp, proto == MGCP_PROTO_RTP,
- addr, buf, buf_size, conn_src, conn_dst);
+ from_addr, msg, conn_src, conn_dst);
case MGCP_OSMUX_BSC_NAT:
case MGCP_OSMUX_BSC:
LOGPENDP(endp, DRTP, LOGL_DEBUG,
"endpoint type is MGCP_OSMUX_BSC_NAT, "
"using osmux_xfrm_to_osmux() to forward data through OSMUX\n");
- return osmux_xfrm_to_osmux(buf, buf_size, conn_dst);
+ return osmux_xfrm_to_osmux((char*)msg->data, msg->len, conn_dst);
}
/* If the data has not been handled/forwarded until here, it will
@@ -1247,10 +1179,12 @@
* \param[in] buf_size size data length of buf
* \param[in] conn originating connection
* \returns 0 on success, -1 on ERROR */
-int mgcp_dispatch_rtp_bridge_cb(int proto, struct sockaddr_in *addr, char *buf,
- unsigned int buf_size, struct mgcp_conn *conn)
+int mgcp_dispatch_rtp_bridge_cb(struct msgb *msg)
{
+ struct mgcp_conn_rtp *conn_src = OSMO_RTP_MSG_CTX(msg)->conn_src;
+ struct mgcp_conn *conn = conn_src->conn;
struct mgcp_conn *conn_dst;
+ struct sockaddr_in *from_addr = OSMO_RTP_MSG_CTX(msg)->from_addr;
/*! NOTE: This callback function implements the endpoint specific
* dispatch bahviour of an rtp bridge/proxy endpoint. It is assumed
@@ -1269,11 +1203,10 @@
* address data from the UDP packet header to patch the
* outgoing address in connection on the fly */
if (conn->u.rtp.end.rtp_port == 0) {
- conn->u.rtp.end.addr = addr->sin_addr;
- conn->u.rtp.end.rtp_port = addr->sin_port;
+ conn->u.rtp.end.addr = from_addr->sin_addr;
+ conn->u.rtp.end.rtp_port = from_addr->sin_port;
}
- return mgcp_send_rtp(proto, addr, buf,
- buf_size, &conn->u.rtp, &conn->u.rtp);
+ return mgcp_send_rtp(conn_src, msg);
}
/* Find a destination connection. */
@@ -1305,9 +1238,7 @@
}
/* Dispatch RTP packet to destination RTP connection */
- return mgcp_send_rtp(proto, addr, buf,
- buf_size, &conn->u.rtp, &conn_dst->u.rtp);
-
+ return mgcp_send_rtp(&conn_dst->u.rtp, msg);
}
/*! cleanup an endpoint when a connection on an RTP bridge endpoint is removed.
@@ -1329,6 +1260,76 @@
}
}
+static bool is_dummy_msg(enum rtp_proto proto, struct msgb *msg)
+{
+ return msg->len == 1 && msg->data[0] == MGCP_DUMMY_LOAD;
+}
+
+struct pdu_ctx {
+ struct sockaddr_in *from_addr;
+ struct mgcp_conn_rtp *conn_src;
+};
+
+/* IuUP CN node has stripped an IuUP header and forwards RTP data to distribute to the peers. */
+int iuup_rx_payload(struct msgb *msg, void *node_priv)
+{
+ struct mgcp_conn_rtp *conn_src = OSMO_RTP_MSG_CTX(msg)->conn_src;
+ LOG_CONN_RTP(conn_src, LOGL_DEBUG, "iuup_rx_payload(%u bytes)\n", msg->len);
+ return rx_rtp(msg);
+}
+
+/* IuUP CN node has composed a message that contains an IuUP header and asks us to send to the IuUP peer.
+ */
+int iuup_tx_msg(struct msgb *msg, void *node_priv)
+{
+ const struct in_addr zero_addr = {};
+ struct mgcp_conn_rtp *conn_src = OSMO_RTP_MSG_CTX(msg)->conn_src;
+ struct mgcp_conn_rtp *conn_dst = node_priv;
+ struct sockaddr_in *from_addr = OSMO_RTP_MSG_CTX(msg)->from_addr;
+ struct mgcp_rtp_end *rtp_end = &conn_dst->end;
+ struct in_addr to_addr = rtp_end->addr;
+ uint16_t to_port = rtp_end->rtp_port;
+
+ if (conn_src == conn_dst
+ && !memcmp(&zero_addr, &to_addr, sizeof(zero_addr)) && !to_port) {
+ LOG_CONN_RTP(conn_dst, LOGL_DEBUG, "iuup_tx_msg(): direct IuUP reply\n");
+ /* IuUP wants to send a message back to the same peer that sent an RTP package, but there
+ * is no address configured for that peer yet. It is probably an IuUP Initialization ACK
+ * reply. Use the sender address to send the reply.
+ *
+ * During 3G RAB Assignment, a 3G cell might first probe the MGW and expect an IuUP
+ * Initialization ACK before it replies to the MSC with a successful RAB Assignment; only
+ * after that reply does MSC officially know which RTP address+port the 3G cell wants to
+ * use and can tell this MGW about it, so this "loopback" is, for some 3G cells, the only
+ * chance we have to get a successful RAB Assignment done (particularly the nano3G does
+ * this). */
+ to_addr = from_addr->sin_addr;
+ to_port = from_addr->sin_port;
+ }
+
+ LOG_CONN_RTP(conn_dst, LOGL_DEBUG, "iuup_tx_msg(%u bytes) to %s:%u\n", msg->len,
+ inet_ntoa(to_addr), ntohs(to_port));
+
+ return mgcp_udp_send(rtp_end->rtp.fd, &to_addr, to_port, (char*)msg->data, msg->len);
+}
+
+static void iuup_init(struct mgcp_conn_rtp *conn_src)
+{
+ struct osmo_iuup_cn_cfg cfg = {
+ .node_priv = conn_src,
+ .rx_payload = iuup_rx_payload,
+ .tx_msg = iuup_tx_msg,
+ };
+
+ if (conn_src->iuup) {
+ LOG_CONN_RTP(conn_src, LOGL_NOTICE, "Rx IuUP init, but already initialized. Ignoring.\n");
+ return;
+ }
+
+ conn_src->iuup = osmo_iuup_cn_init(conn_src->conn, &cfg, "endp_%d_conn_%s",
+ ENDPOINT_NUMBER(conn_src->conn->endp), conn_src->conn->id);
+}
+
/* Handle incoming RTP data from NET */
static int rtp_data_net(struct osmo_fd *fd, unsigned int what)
{
@@ -1342,23 +1343,88 @@
struct mgcp_conn_rtp *conn_src;
struct mgcp_endpoint *endp;
struct sockaddr_in addr;
-
- char buf[RTP_BUF_SIZE];
- int proto;
- int len;
+ socklen_t slen = sizeof(addr);
+ int ret;
+ enum rtp_proto proto;
+ struct osmo_rtp_msg_ctx mc;
+ struct msgb *msg = msgb_alloc_headroom(RTP_BUF_SIZE + OSMO_IUUP_HEADROOM,
+ OSMO_IUUP_HEADROOM, "RTP-rx");
+ int rc;
conn_src = (struct mgcp_conn_rtp *)fd->data;
OSMO_ASSERT(conn_src);
endp = conn_src->conn->endp;
OSMO_ASSERT(endp);
- LOGPENDP(endp, DRTP, LOGL_DEBUG, "source conn:%s\n",
- mgcp_conn_dump(conn_src->conn));
+ proto = (fd == &conn_src->end.rtp)? MGCP_PROTO_RTP : MGCP_PROTO_RTCP;
- /* Receive packet */
- len = mgcp_recv(&proto, &addr, buf, sizeof(buf), fd);
- if (len < 0)
- return -1;
+ ret = recvfrom(fd->fd, msg->data, msg->data_len, 0, (struct sockaddr *)&addr, &slen);
+
+ if (ret <= 0) {
+ LOG_CONN_RTP(conn_src, LOGL_ERROR, "recvfrom error: %s\n", strerror(errno));
+ rc = -1;
+ goto out;
+ }
+
+ msgb_put(msg, ret);
+
+ LOG_CONN_RTP(conn_src, LOGL_DEBUG, "%s: rx %u bytes from %s:%u\n",
+ proto == MGCP_PROTO_RTP ? "RTP" : "RTPC",
+ msg->len, inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
+
+ if ((proto == MGCP_PROTO_RTP && check_rtp(conn_src, msg))
+ || (proto == MGCP_PROTO_RTCP && check_rtcp(conn_src, msg))) {
+ /* Logging happened in the two check_ functions */
+ rc = -1;
+ goto out;
+ }
+
+ if (is_dummy_msg(proto, msg)) {
+ LOG_CONN_RTP(conn_src, LOGL_DEBUG, "rx dummy packet (dropped)\n");
+ rc = 0;
+ goto out;
+ }
+
+ mc = (struct osmo_rtp_msg_ctx){
+ .proto = proto,
+ .conn_src = conn_src,
+ .from_addr = &addr,
+ };
+ OSMO_RTP_MSG_CTX(msg) = &mc;
+ LOG_CONN_RTP(conn_src, LOGL_DEBUG, "msg ctx: %d %p %s\n",
+ OSMO_RTP_MSG_CTX(msg)->proto,
+ OSMO_RTP_MSG_CTX(msg)->conn_src,
+ osmo_hexdump((void*)OSMO_RTP_MSG_CTX(msg)->from_addr, sizeof(struct sockaddr_in)));
+
+ /* Increment RX statistics */
+ rate_ctr_inc(&conn_src->rate_ctr_group->ctr[RTP_PACKETS_RX_CTR]);
+ rate_ctr_add(&conn_src->rate_ctr_group->ctr[RTP_OCTETS_RX_CTR], msg->len);
+ /* FIXME: count RTP and RTCP separately, also count IuUP payload-less separately */
+
+ /* Forward a copy of the RTP data to a debug ip/port */
+ forward_data(fd->fd, &conn_src->tap_in, msg);
+
+ if (proto == MGCP_PROTO_RTP && osmo_iuup_is_init(msg))
+ iuup_init(conn_src);
+
+ if (conn_src->iuup && proto == MGCP_PROTO_RTP)
+ rc = osmo_iuup_cn_rx_pdu(conn_src->iuup, msg);
+ else
+ rc = rx_rtp(msg);
+
+out:
+ msgb_free(msg);
+ return rc;
+}
+
+static int rx_rtp(struct msgb *msg)
+{
+ struct mgcp_conn_rtp *conn_src = OSMO_RTP_MSG_CTX(msg)->conn_src;
+ struct sockaddr_in *from_addr = OSMO_RTP_MSG_CTX(msg)->from_addr;
+ struct mgcp_conn *conn = conn_src->conn;
+ struct mgcp_trunk_config *tcfg = conn->endp->tcfg;
+
+ LOG_CONN_RTP(conn_src, LOGL_DEBUG, "rx_rtp(%u bytes)\n", msg->len);
mgcp_conn_watchdog_kick(conn_src->conn);
@@ -1367,17 +1433,20 @@
* define, then we check if the incoming payload matches that
* expectation. */
if (amr_oa_bwe_convert_indicated(conn_src->end.codec)) {
- int oa = amr_oa_check(buf, len);
+ int oa = amr_oa_check((char*)msg->data, msg->len);
if (oa < 0)
return -1;
if (((bool)oa) != conn_src->end.codec->param.amr_octet_aligned)
return -1;
}
+ /* Check if the origin of the RTP packet seems plausible */
+ if (!tcfg->rtp_accept_all && check_rtp_origin(conn_src, from_addr))
+ return -1;
+
/* Execute endpoint specific implementation that handles the
* dispatching of the RTP data */
- return endp->type->dispatch_rtp_cb(proto, &addr, buf, len,
- conn_src->conn);
+ return conn->endp->type->dispatch_rtp_cb(msg);
}
/*! set IP Type of Service parameter.