ASCI: Support conference briding with 1..n connections

For each RTP packet that is received from a connection, the mode is
checked whether receiving is allowed or not. If not it is discarded.

In case of "confecho" mode, the RTP is also sent by the receiving
connection.

Then a loop is used to send RTP to all sending endpoints except the one
that received the packet.

Because we have a loop that allows to have 1..n connections, we have no
maximum number of allowed connections anymore.

Change-Id: Ic99a55ab5a3a6170e940403fadd52697e99f2f3a

TODO-RELEASE

@@ -24,3 +24,5 @@
 # If any interfaces have been removed or changed since the last public release, a=0.
 #
 #library		what		description / commit summary line
+libosmo-mgcp-client     NEW API         mgcp_client_conf_alloc()
+libosmo-mgcp-client     DEPRECATED      mgcp_client_conf_init()

configure.ac

@@ -52,7 +52,8 @@ PKG_CHECK_MODULES(LIBOSMONETIF, libosmo-netif >= 1.3.0)
 PKG_CHECK_MODULES(LIBOSMOABIS, libosmoabis >= 1.4.0)
 PKG_CHECK_MODULES(LIBOSMOTRAU, libosmotrau >= 1.4.0)
 
-CFLAGS="$CFLAGS -pthread"
+CFLAGS="$CFLAGS -DBUILDING_LIBOSMOMGCPCLIENT -pthread"
+CPPFLAGS="$CPPFLAGS -DBUILDING_LIBOSMOMGCPCLIENT -pthread"
 LDFLAGS="$LDFLAGS -pthread"
 
 AC_ARG_ENABLE(sanitize,

contrib/systemd/osmo-mgw.service

@@ -1,5 +1,7 @@
 [Unit]
 Description=Osmocom Media Gateway (MGW)
+After=network-online.target
+Wants=network-online.target
 
 [Service]
 Type=simple

debian/compat

@@ -1 +1 @@
-9
+10

debian/control

@@ -2,7 +2,7 @@ Source: osmo-mgw
 Section: net
 Priority: extra
 Maintainer: Osmocom team <openbsc@lists.osmocom.org>
-Build-Depends: debhelper (>=9),
+Build-Depends: debhelper (>= 10),
                dh-autoreconf,
                pkg-config,
                autotools-dev,

debian/copyright

@@ -6,7 +6,7 @@ Files:     *
 Copyright: 2009-2014 On-Waves
            2009-2015 Holger Hans Peter Freyther <zecke@selfish.org>
            2013 Jacob Erlbeck <jerlbeck@sysmocom.de>
-           2016-2017 sysmocom s.m.f.c. GmbH <info@sysmocom.de>
+           2016-2017 sysmocom s.f.m.c. GmbH <info@sysmocom.de>
 License:   AGPL-3.0+
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU Affero General Public License as published by
@@ -22,7 +22,7 @@ License:   AGPL-3.0+
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 Files:     src/libosmo-mgcp-client/* include/osmocom/mgcp_client/*
-Copyright: 2016 by sysmocom s.m.f.c. GmbH <info@sysmocom.de>
+Copyright: 2016 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
            Based on OpenBSC interface to quagga VTY (libmsc/vty_interface_layer3.c)
            2009 by Harald Welte <laforge@gnumonks.org>
            2009-2011 by Holger Hans Peter Freyther

doc/manuals/chapters/mgcp_endpoints.adoc

@@ -92,3 +92,9 @@ not yet useable.
 
 NOTE: the VTY command "show mgcp" can be used to get a list of all available
 endpoints (including identifiers)
+
+=== The `null` endpoint
+
+OsmoMGW offers a special `null@<domain>` endpoint which can be audited at all times.
+This is useful for MGCP clients who wish to submit requests to OsmoMGW
+periodically to find out whether it is still reachable and in a working state.

include/Makefile.am

@@ -3,6 +3,7 @@ SUBDIRS = \
 	$(NULL)
 
 nobase_include_HEADERS = \
+	osmocom/mgcp_client/defs.h \
 	osmocom/mgcp_client/mgcp_client.h \
 	osmocom/mgcp_client/mgcp_client_endpoint_fsm.h \
 	osmocom/mgcp_client/mgcp_client_fsm.h \

include/osmocom/mgcp/mgcp_codec.h

@@ -13,9 +13,9 @@ struct mgcp_conn_rtp;
 void mgcp_codec_summary(struct mgcp_conn_rtp *conn);
 void mgcp_codec_reset_all(struct mgcp_conn_rtp *conn);
 int mgcp_codec_add(struct mgcp_conn_rtp *conn, int payload_type, const char *audio_name, const struct mgcp_codec_param *param);
-int mgcp_codec_decide(struct mgcp_conn_rtp *conn);
-int mgcp_codec_pt_translate(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst, int payload_type);
+int mgcp_codec_decide(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst);
 const struct mgcp_rtp_codec *mgcp_codec_pt_find_by_subtype_name(struct mgcp_conn_rtp *conn,
 								const char *subtype_name, unsigned int match_nr);
 bool mgcp_codec_amr_align_mode_is_indicated(const struct mgcp_rtp_codec *codec);
 bool mgcp_codec_amr_is_octet_aligned(const struct mgcp_rtp_codec *codec);
+struct mgcp_rtp_codec *mgcp_codec_from_pt(struct mgcp_conn_rtp *conn, int payload_type);

include/osmocom/mgcp/mgcp_common.h

@@ -47,6 +47,7 @@ enum mgcp_connection_mode {
 	MGCP_CONN_SEND_ONLY = 2,
 	MGCP_CONN_RECV_SEND = MGCP_CONN_RECV_ONLY | MGCP_CONN_SEND_ONLY,
 	MGCP_CONN_LOOPBACK  = 4 | MGCP_CONN_RECV_SEND,
+	MGCP_CONN_CONFECHO  = 8 | MGCP_CONN_RECV_SEND,
 };
 
 #define MGCP_X_OSMO_IGN_HEADER "X-Osmo-IGN:"

include/osmocom/mgcp/mgcp_e1.h

@@ -23,5 +23,5 @@ static const uint8_t e1_offsets[] = { 0, 0, 4, 0, 2, 4, 6, 0, 1, 2, 3, 4, 5, 6,
 
 int mgcp_e1_endp_equip(struct mgcp_endpoint *endp, uint8_t ts, uint8_t ss, uint8_t offs);
 void mgcp_e1_endp_update(struct mgcp_endpoint *endp);
-void mgcp_e1_endp_release(struct mgcp_endpoint *endp);
+void mgcp_e1_endp_release(struct mgcp_endpoint *endp, uint8_t ts);
 int mgcp_e1_send_rtp(struct mgcp_endpoint *endp, struct mgcp_rtp_codec *codec, struct msgb *msg);

include/osmocom/mgcp/mgcp_endp.h

@@ -130,10 +130,10 @@ struct mgcp_endpoint {
 };
 
 struct mgcp_endpoint *mgcp_endp_alloc(struct mgcp_trunk *trunk, unsigned int index);
-void mgcp_endp_release(struct mgcp_endpoint *endp);
 int mgcp_endp_claim(struct mgcp_endpoint *endp, const char *callid);
 void mgcp_endp_update(struct mgcp_endpoint *endp);
 bool mgcp_endp_is_wildcarded(const char *epname);
+bool mgcp_endp_is_null(const char *epname);
 struct mgcp_endpoint *mgcp_endp_by_name_trunk(int *cause, const char *epname,
 					      const struct mgcp_trunk *trunk);
 struct mgcp_endpoint *mgcp_endp_by_name(int *cause, const char *epname,
@@ -145,3 +145,4 @@ void mgcp_endp_strip_name(char *epname_stripped, const char *epname,
 			 const struct mgcp_trunk *trunk);
 struct mgcp_endpoint *mgcp_endp_find_specific(const char *epname,
 			const struct mgcp_trunk *trunk);
+void mgcp_endp_release(struct mgcp_endpoint *endp);

include/osmocom/mgcp/mgcp_trunk.h

@@ -31,8 +31,6 @@ struct mgcp_trunk {
 	int audio_send_ptime;
 	int audio_send_name;
 
-	int no_audio_transcoding;
-
 	int omit_rtcp;
 	int keepalive_interval;
 
@@ -66,7 +64,7 @@ struct mgcp_trunk {
 		/* E1 specific */
 		struct {
 			unsigned int vty_line_nr;
-			bool ts_in_use[NUM_E1_TS-1];
+			uint8_t ts_usecount[NUM_E1_TS-1];
 			struct osmo_i460_timeslot i460_ts[NUM_E1_TS-1];
 			/* Note: on an E1 line TS 0 is devoted to framing and
 			 * alignment and therefore only NUM_E1_TS-1 timeslots

include/osmocom/mgcp_client/defs.h

@@ -0,0 +1,7 @@
+#include <osmocom/core/defs.h>
+
+#if BUILDING_LIBOSMOMGCPCLIENT
+# define OSMO_DEPRECATED_OUTSIDE_LIBOSMOMGCPCLIENT(text)
+#else
+# define OSMO_DEPRECATED_OUTSIDE_LIBOSMOMGCPCLIENT(text) OSMO_DEPRECATED(text)
+#endif

include/osmocom/mgcp_client/mgcp_client.h

@@ -3,6 +3,7 @@
 #include <stdint.h>
 #include <arpa/inet.h>
 
+#include <osmocom/mgcp_client/defs.h>
 #include <osmocom/mgcp_client/mgcp_common.h>
 
 /* See also: RFC 3435, chapter 3.5 Transmission over UDP */
@@ -10,7 +11,7 @@
 #define MGCP_CLIENT_LOCAL_PORT_DEFAULT 0
 #define MGCP_CLIENT_REMOTE_ADDR_DEFAULT "127.0.0.1"
 #define MGCP_CLIENT_REMOTE_PORT_DEFAULT 2427
-
+#define MGCP_CLIENT_KEEPALIVE_DEFAULT_ENDP "null"
 #define MGCP_CLIENT_MGW_STR "Configure MGCP connection to Media Gateway\n"
 
 struct msgb;
@@ -35,6 +36,12 @@ struct mgcp_client_conf {
 
 	/* human readable name / description */
 	char *description;
+
+	struct {
+		uint32_t timeout_sec;
+		uint32_t req_interval_sec;
+		char req_endpoint_name[MGCP_ENDPOINT_MAXLEN];
+	} keepalive;
 };
 
 typedef unsigned int mgcp_trans_id_t;
@@ -45,10 +52,10 @@ enum mgcp_codecs {
 	CODEC_GSM_8000_1 = 3,
 	CODEC_PCMA_8000_1 = 8,
 	CODEC_G729_8000_1 = 18,
-	CODEC_GSMEFR_8000_1 = 110,
-	CODEC_GSMHR_8000_1 = 111,
-	CODEC_AMR_8000_1 = 112,
-	CODEC_AMRWB_16000_1 = 113,
+	CODEC_GSMEFR_8000_1 = 110,	/* 3GPP TS 48.103 table 5.4.2.2.1 */
+	CODEC_GSMHR_8000_1 = 111,	/* 3GPP TS 48.103 table 5.4.2.2.1 */
+	CODEC_AMR_8000_1 = 112,		/* 3GPP TS 48.103 table 5.4.2.2.1 */
+	CODEC_AMRWB_16000_1 = 113,	/* 3GPP TS 48.103 table 5.4.2.2.1 */
 	CODEC_IUFP = 96,
 	CODEC_CLEARMODE = 120,		/* 3GPP TS 48.103 table 5.4.2.2.1 */
 };
@@ -133,7 +140,8 @@ struct mgcp_msg {
 	struct mgcp_codec_param param;
 };
 
-void mgcp_client_conf_init(struct mgcp_client_conf *conf);
+struct mgcp_client_conf *mgcp_client_conf_alloc(void *ctx);
+void mgcp_client_conf_init(struct mgcp_client_conf *conf) OSMO_DEPRECATED_OUTSIDE_LIBOSMOMGCPCLIENT("use mgcp_client_conf_alloc() (or even better, switch to the mgcp_client_pool API!)");
 void mgcp_client_vty_init(void *talloc_ctx, int node, struct mgcp_client_conf *conf);
 int mgcp_client_config_write(struct vty *vty, const char *indent);
 struct mgcp_client_conf *mgcp_client_conf_actual(struct mgcp_client *mgcp);

include/osmocom/mgcp_client/mgcp_client_internal.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <osmocom/core/write_queue.h>
+#include <osmocom/core/timer.h>
 
 #define MSGB_CB_MGCP_TRANS_ID 0
 
@@ -15,13 +16,10 @@ struct mgcp_client {
 	struct osmo_wqueue wq;
 	mgcp_trans_id_t next_trans_id;
 	struct llist_head responses_pending;
-	struct llist_head inuse_endpoints;
 	struct mgcp_client_pool_member *pool_member;
-};
-
-struct mgcp_inuse_endpoint {
-	struct llist_head entry;
-	uint16_t id;
+	struct osmo_timer_list keepalive_tx_timer;
+	struct osmo_timer_list keepalive_rx_timer;
+	bool conn_up;
 };
 
 struct mgcp_response_pending {

include/osmocom/mgcp_client/mgcp_client_pool.h

@@ -12,6 +12,7 @@ void mgcp_client_pool_vty_init(int parent_node, int mgw_node, const char *indent
 int mgcp_client_pool_config_write(struct vty *vty, const char *indent);
 unsigned int mgcp_client_pool_connect(struct mgcp_client_pool *pool);
 void mgcp_client_pool_register_single(struct mgcp_client_pool *pool, struct mgcp_client *mgcp_client);
+bool mgcp_client_pool_empty(const struct mgcp_client_pool *pool);
 
 struct mgcp_client *mgcp_client_pool_get(struct mgcp_client_pool *pool);
 void mgcp_client_pool_put(struct mgcp_client *mgcp_client);

src/Makefile.am

@@ -13,12 +13,6 @@ AM_CFLAGS = \
 	$(COVERAGE_CFLAGS) \
 	$(NULL)
 
-AM_LDFLAGS = \
-	$(LIBOSMOCORE_LIBS) \
-	$(LIBOSMOGSM_LIBS) \
-	$(COVERAGE_LDFLAGS) \
-	$(NULL)
-
 # Libraries
 SUBDIRS = \
 	libosmo-mgcp-client \

src/libosmo-mgcp-client/Makefile.am

@@ -14,8 +14,6 @@ AM_CFLAGS = \
 	$(NULL)
 
 AM_LDFLAGS = \
-	$(LIBOSMOCORE_LIBS) \
-	$(LIBOSMOVTY_LIBS) \
 	$(COVERAGE_LDFLAGS) \
 	$(NULL)
 
@@ -40,3 +38,8 @@ libosmo_mgcp_client_la_LDFLAGS = \
 	-version-info $(MGCP_CLIENT_LIBVERSION) \
 	-no-undefined \
 	$(NULL)
+
+libosmo_mgcp_client_la_LIBADD = \
+	$(LIBOSMOCORE_LIBS) \
+	$(LIBOSMOVTY_LIBS) \
+	$(NULL)

src/libosmo-mgcp-client/mgcp_client.c

@@ -69,17 +69,16 @@ const struct value_string osmo_mgcpc_codec_names[] = {
 static char *extract_codec_name(const char *str)
 {
 	static char buf[64];
-	unsigned int i;
+	char *pos;
 
 	if (!str)
 		return NULL;
 
 	osmo_strlcpy(buf, str, sizeof(buf));
 
-	for (i = 0; i < strlen(buf); i++) {
-		if (buf[i] == '/')
-			buf[i] = '\0';
-	}
+	pos = strchr(buf, '/');
+	if (pos)
+		*pos = '\0';
 
 	return buf;
 }
@@ -148,7 +147,7 @@ unsigned int map_codec_to_pt(const struct ptmap *ptmap, unsigned int ptmap_len,
 	 *  is also ignored and a 1:1 mapping is performed instead. */
 
 	/* we may return the codec directly since enum mgcp_codecs directly
-	 * corresponds to the statićally assigned payload types */
+	 * corresponds to the statically assigned payload types */
 	if (codec < 96 || codec > 127)
 		return codec;
 
@@ -194,9 +193,7 @@ enum mgcp_codecs map_pt_to_codec(struct ptmap *ptmap, unsigned int ptmap_len,
 	return pt;
 }
 
-/*! Initialize MGCP client configuration struct with default values.
- *  \param[out] conf Client configuration.*/
-void mgcp_client_conf_init(struct mgcp_client_conf *conf)
+static void _mgcp_client_conf_init(struct mgcp_client_conf *conf)
 {
 	/* NULL and -1 default to MGCP_CLIENT_*_DEFAULT values */
 	*conf = (struct mgcp_client_conf){
@@ -204,11 +201,39 @@ void mgcp_client_conf_init(struct mgcp_client_conf *conf)
 		.local_port = -1,
 		.remote_addr = NULL,
 		.remote_port = -1,
+		.keepalive = {
+			.timeout_sec = 0, /* disabled */
+			.req_interval_sec = 0, /* disabled */
+			.req_endpoint_name = MGCP_CLIENT_KEEPALIVE_DEFAULT_ENDP,
+		},
 	};
 
 	INIT_LLIST_HEAD(&conf->reset_epnames);
 }
 
+/*! Allocate and initialize MGCP client configuration struct with default values.
+ *  \param[in] ctx talloc context to use as a parent during allocation.
+ *
+ * The returned struct can be freed using talloc_free().
+ */
+struct mgcp_client_conf *mgcp_client_conf_alloc(void *ctx)
+{
+	struct mgcp_client_conf *conf = talloc(ctx, struct mgcp_client_conf);
+	_mgcp_client_conf_init(conf);
+	return conf;
+}
+
+/*! Initialize MGCP client configuration struct with default values.
+ *  \param[out] conf Client configuration.
+ *
+ * This function is deprecated and should not be used, as it may break if size
+ * of struct mgcp_client_conf changes in the future!
+ */
+void mgcp_client_conf_init(struct mgcp_client_conf *conf)
+{
+	_mgcp_client_conf_init(conf);
+}
+
 static void mgcp_client_handle_response(struct mgcp_client *mgcp,
 					struct mgcp_response_pending *pending,
 					struct mgcp_response *response)
@@ -345,7 +370,7 @@ static int mgcp_parse_audio_ptime_rtpmap(struct mgcp_response *r, const char *li
 {
 	unsigned int pt;
 	char codec_resp[64];
-	enum mgcp_codecs codec;
+	int rc;
 
 #define A_PTIME "a=ptime:"
 #define A_RTPMAP "a=rtpmap:"
@@ -366,9 +391,14 @@ static int mgcp_parse_audio_ptime_rtpmap(struct mgcp_response *r, const char *li
 			LOGP(DLMGCP, LOGL_ERROR, "No more space in ptmap array (len=%u)\n", r->ptmap_len);
 			return -ENOSPC;
 		}
-		codec = map_str_to_codec(codec_resp);
+		rc = map_str_to_codec(codec_resp);
+		if (rc < 0) {
+			LOGP(DLMGCP, LOGL_ERROR,
+			     "Failed to parse SDP parameter, can't parse codec in rtpmap: %s\n", osmo_quote_str(line, -1));
+			return -EINVAL;
+		}
 		r->ptmap[r->ptmap_len].pt = pt;
-		r->ptmap[r->ptmap_len].codec = codec;
+		r->ptmap[r->ptmap_len].codec = rc;
 		r->ptmap_len++;
 	}
 
@@ -456,15 +486,15 @@ static char *mgcp_find_section_end(char *string)
 
 	rc = strstr(string, "\n\n");
 	if (rc)
-		return rc;
+		return rc + 2;
 
 	rc = strstr(string, "\n\r\n\r");
 	if (rc)
-		return rc;
+		return rc + 4;
 
 	rc = strstr(string, "\r\n\r\n");
 	if (rc)
-		return rc;
+		return rc + 4;
 
 	return NULL;
 }
@@ -675,6 +705,14 @@ int mgcp_client_rx(struct mgcp_client *mgcp, struct msgb *msg)
 	r = talloc_zero(mgcp, struct mgcp_response);
 	OSMO_ASSERT(r);
 
+	/* Re-arm keepalive timer if enabled */
+	if (OSMO_UNLIKELY(mgcp->conn_up == false)) {
+		LOGPMGW(mgcp, LOGL_NOTICE, "MGCP link to MGW now considered UP\n");
+		mgcp->conn_up = true;
+	}
+	if (mgcp->actual.keepalive.timeout_sec > 0)
+		osmo_timer_schedule(&mgcp->keepalive_rx_timer, mgcp->actual.keepalive.timeout_sec, 0);
+
 	rc = mgcp_response_parse_head(r, msg);
 	if (rc) {
 		LOGPMGW(mgcp, LOGL_ERROR, "Cannot parse MGCP response (head)\n");
@@ -745,13 +783,84 @@ static int mgcp_do_write(struct osmo_fd *fd, struct msgb *msg)
 		osmo_escape_str((const char *)msg->data, OSMO_MIN(42, msg->len)));
 
 	ret = write(fd->fd, msg->data, msg->len);
-	if (ret != msg->len)
+	if (OSMO_UNLIKELY(ret != msg->len))
 		LOGPMGW(mgcp, LOGL_ERROR, "Failed to Tx MGCP: %s: %d='%s'; msg: len=%u '%s'...\n",
 			osmo_sock_get_name2(fd->fd), errno, strerror(errno),
 			msg->len, osmo_escape_str((const char *)msg->data, OSMO_MIN(42, msg->len)));
+
+	/* Re-arm the keepalive Tx timer: */
+	if (mgcp->actual.keepalive.req_interval_sec > 0)
+		osmo_timer_schedule(&mgcp->keepalive_tx_timer, mgcp->actual.keepalive.req_interval_sec, 0);
 	return ret;
 }
 
+static const char *_mgcp_client_name_append_domain(const struct mgcp_client *mgcp, const char *name)
+{
+	static char endpoint[MGCP_ENDPOINT_MAXLEN];
+	int rc;
+
+	rc = snprintf(endpoint, sizeof(endpoint), "%s@%s", name, mgcp_client_endpoint_domain(mgcp));
+	if (rc > sizeof(endpoint) - 1) {
+		LOGPMGW(mgcp, LOGL_ERROR, "MGCP endpoint exceeds maximum length of %zu: '%s@%s'\n",
+			sizeof(endpoint) - 1, name, mgcp_client_endpoint_domain(mgcp));
+		return NULL;
+	}
+	if (rc < 1) {
+		LOGPMGW(mgcp, LOGL_ERROR, "Cannot compose MGCP endpoint name\n");
+		return NULL;
+	}
+	return endpoint;
+}
+
+/* Safely ignore the MGCP response to the DLCX sent via _mgcp_client_send_dlcx() */
+static void _ignore_mgcp_response(struct mgcp_response *response, void *priv) { }
+
+/* Format DLCX message (fire and forget) and send it off to the MGW */
+static void _mgcp_client_send_dlcx(struct mgcp_client *mgcp, const char *epname)
+{
+	struct msgb *msgb_dlcx;
+	struct mgcp_msg mgcp_msg_dlcx = {
+		.verb = MGCP_VERB_DLCX,
+		.presence = MGCP_MSG_PRESENCE_ENDPOINT,
+	};
+	osmo_strlcpy(mgcp_msg_dlcx.endpoint, epname, sizeof(mgcp_msg_dlcx.endpoint));
+	msgb_dlcx = mgcp_msg_gen(mgcp, &mgcp_msg_dlcx);
+	mgcp_client_tx(mgcp, msgb_dlcx, &_ignore_mgcp_response, NULL);
+}
+
+/* Format AuditEndpoint message (fire and forget) and send it off to the MGW */
+static void _mgcp_client_send_auep(struct mgcp_client *mgcp, const char *epname)
+{
+	struct msgb *msgb_auep;
+	struct mgcp_msg mgcp_msg_auep = {
+		.verb = MGCP_VERB_AUEP,
+		.presence = MGCP_MSG_PRESENCE_ENDPOINT,
+	};
+	OSMO_STRLCPY_ARRAY(mgcp_msg_auep.endpoint, epname);
+	msgb_auep = mgcp_msg_gen(mgcp, &mgcp_msg_auep);
+	mgcp_client_tx(mgcp, msgb_auep, &_ignore_mgcp_response, NULL);
+}
+
+static void mgcp_client_keepalive_tx_timer_cb(void *data)
+{
+	struct mgcp_client *mgcp = (struct mgcp_client *)data;
+	LOGPMGW(mgcp, LOGL_INFO, "Triggering keepalive MGCP request\n");
+	const char *epname = _mgcp_client_name_append_domain(mgcp, mgcp->actual.keepalive.req_endpoint_name);
+	_mgcp_client_send_auep(mgcp, epname);
+
+	/* Re-arm the timer: */
+	osmo_timer_schedule(&mgcp->keepalive_tx_timer, mgcp->actual.keepalive.req_interval_sec, 0);
+}
+
+static void mgcp_client_keepalive_rx_timer_cb(void *data)
+{
+	struct mgcp_client *mgcp = (struct mgcp_client *)data;
+	LOGPMGW(mgcp, LOGL_ERROR, "MGCP link to MGW now considered DOWN (keepalive timeout, more than %u seconds with no answer from MGW)\n",
+		mgcp->actual.keepalive.timeout_sec);
+	mgcp->conn_up = false;
+	/* TODO: Potentially time out all ongoing transactions for that MGW. Maybe based on VTY cfg? */
+}
+
 struct mgcp_client *mgcp_client_init(void *ctx,
 				     struct mgcp_client_conf *conf)
 {
@@ -764,7 +873,6 @@ struct mgcp_client *mgcp_client_init(void *ctx,
 		return NULL;
 
 	INIT_LLIST_HEAD(&mgcp->responses_pending);
-	INIT_LLIST_HEAD(&mgcp->inuse_endpoints);
 
 	mgcp->next_trans_id = 1;
 
@@ -797,66 +905,34 @@ struct mgcp_client *mgcp_client_init(void *ctx,
 	if (conf->description)
 		mgcp->actual.description = talloc_strdup(mgcp, conf->description);
 
+	osmo_wqueue_init(&mgcp->wq, 1024);
+	mgcp->wq.read_cb = mgcp_do_read;
+	mgcp->wq.write_cb = mgcp_do_write;
+	osmo_fd_setup(&mgcp->wq.bfd, -1, OSMO_FD_READ, osmo_wqueue_bfd_cb, mgcp, 0);
+
+	memcpy(&mgcp->actual.keepalive, &conf->keepalive, sizeof(conf->keepalive));
+	osmo_timer_setup(&mgcp->keepalive_tx_timer, mgcp_client_keepalive_tx_timer_cb, mgcp);
+	osmo_timer_setup(&mgcp->keepalive_rx_timer, mgcp_client_keepalive_rx_timer_cb, mgcp);
+
 	return mgcp;
 }
 
-/* Safely ignore the MGCP response to the DLCX sent via _mgcp_client_send_dlcx() */
-static void _ignore_mgcp_response(struct mgcp_response *response, void *priv) { }
-
-/* Format DLCX message (fire and forget) and send it off to the MGW */
-static void _mgcp_client_send_dlcx(struct mgcp_client *mgcp, const char *epname)
-{
-	struct msgb *msgb_dlcx;
-	struct mgcp_msg mgcp_msg_dlcx = {
-		.verb = MGCP_VERB_DLCX,
-		.presence = MGCP_MSG_PRESENCE_ENDPOINT,
-	};
-	osmo_strlcpy(mgcp_msg_dlcx.endpoint, epname, sizeof(mgcp_msg_dlcx.endpoint));
-	msgb_dlcx = mgcp_msg_gen(mgcp, &mgcp_msg_dlcx);
-	mgcp_client_tx(mgcp, msgb_dlcx, &_ignore_mgcp_response, NULL);
-}
-
-static const char *_mgcp_client_name_append_domain(const struct mgcp_client *mgcp, const char *name)
-{
-	static char endpoint[MGCP_ENDPOINT_MAXLEN];
-	int rc;
-
-	rc = snprintf(endpoint, sizeof(endpoint), "%s@%s", name, mgcp_client_endpoint_domain(mgcp));
-	if (rc > sizeof(endpoint) - 1) {
-		LOGPMGW(mgcp, LOGL_ERROR, "MGCP endpoint exceeds maximum length of %zu: '%s@%s'\n",
-			sizeof(endpoint) - 1, name, mgcp_client_endpoint_domain(mgcp));
-		return NULL;
-	}
-	if (rc < 1) {
-		LOGPMGW(mgcp, LOGL_ERROR, "Cannot compose MGCP endpoint name\n");
-		return NULL;
-	}
-	return endpoint;
-}
-
 /*! Initialize client connection (opens socket)
  *  \param[in,out] mgcp MGCP client descriptor.
  *  \returns 0 on success, -EINVAL on error. */
 int mgcp_client_connect(struct mgcp_client *mgcp)
 {
-	struct osmo_wqueue *wq;
 	int rc;
 	struct reset_ep *reset_ep;
 	const char *epname;
+	bool some_dlcx_sent = false;
 
 	if (!mgcp) {
 		LOGPMGW(mgcp, LOGL_FATAL, "Client not initialized properly\n");
 		return -EINVAL;
 	}
 
-	wq = &mgcp->wq;
-	osmo_wqueue_init(wq, 1024);
-	wq->read_cb = mgcp_do_read;
-	wq->write_cb = mgcp_do_write;
-
-	osmo_fd_setup(&wq->bfd, -1, OSMO_FD_READ, osmo_wqueue_bfd_cb, mgcp, 0);
-
-	rc = osmo_sock_init2_ofd(&wq->bfd, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, mgcp->actual.local_addr,
+	rc = osmo_sock_init2_ofd(&mgcp->wq.bfd, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, mgcp->actual.local_addr,
 				 mgcp->actual.local_port, mgcp->actual.remote_addr, mgcp->actual.remote_port,
 				 OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
 	if (rc < 0) {
@@ -868,7 +944,7 @@ int mgcp_client_connect(struct mgcp_client *mgcp)
 		goto error_close_fd;
 	}
 
-	LOGPMGW(mgcp, LOGL_INFO, "MGW connection: %s\n", osmo_sock_get_name2(wq->bfd.fd));
+	LOGPMGW(mgcp, LOGL_INFO, "MGW connection: %s\n", osmo_sock_get_name2(mgcp->wq.bfd.fd));
 
 	/* If configured, send a DLCX message to the endpoints that are configured to
 	 * be reset on startup. Usually this is a wildcarded endpoint. */
@@ -876,11 +952,27 @@ int mgcp_client_connect(struct mgcp_client *mgcp)
 		epname = _mgcp_client_name_append_domain(mgcp, reset_ep->name);
 		LOGPMGW(mgcp, LOGL_INFO, "Sending DLCX to: %s\n", epname);
 		_mgcp_client_send_dlcx(mgcp, epname);
+		some_dlcx_sent = true;
 	}
+
+	if (mgcp->actual.keepalive.req_interval_sec > 0) {
+		if (!some_dlcx_sent) {
+			/* Attempt an immediate probe to find out if link is UP or DOWN: */
+			osmo_timer_schedule(&mgcp->keepalive_tx_timer, 0, 0);
+		}
+		/* else: keepalive_tx_timer was already scheduled (if needed) down in the stack during Tx DLCX above */
+	} else {
+		/* Assume link is UP by default, so that this MGW can be selected: */
+		mgcp->conn_up = true;
+	}
+
+	if (mgcp->actual.keepalive.timeout_sec > 0)
+		osmo_timer_schedule(&mgcp->keepalive_rx_timer, mgcp->actual.keepalive.timeout_sec, 0);
+
 	return 0;
 error_close_fd:
-	close(wq->bfd.fd);
-	wq->bfd.fd = -1;
+	close(mgcp->wq.bfd.fd);
+	mgcp->wq.bfd.fd = -1;
 	return rc;
 }
 
@@ -904,13 +996,18 @@ void mgcp_client_disconnect(struct mgcp_client *mgcp)
 		return;
 	}
 
+	/* Disarm keepalive Tx/Rx timer until next connect() */
+	osmo_timer_del(&mgcp->keepalive_rx_timer);
+	osmo_timer_del(&mgcp->keepalive_tx_timer);
+	mgcp->conn_up = false;
+
 	wq = &mgcp->wq;
 	osmo_wqueue_clear(wq);
 	LOGPMGW(mgcp, LOGL_INFO, "MGCP association: %s -- closed!\n", osmo_sock_get_name2(wq->bfd.fd));
-	close(wq->bfd.fd);
-	wq->bfd.fd = -1;
 	if (osmo_fd_is_registered(&wq->bfd))
 		osmo_fd_unregister(&wq->bfd);
+	close(wq->bfd.fd);
+	wq->bfd.fd = -1;
 }
 
 /*! Get the IP-Aaddress of the associated MGW as string.
@@ -1006,11 +1103,8 @@ const char *mgcp_client_e1_epname(void *ctx, const struct mgcp_client *mgcp, uin
 	return epname;
 }
 
-struct mgcp_response_pending * mgcp_client_pending_add(
-					struct mgcp_client *mgcp,
-					mgcp_trans_id_t trans_id,
-					mgcp_response_cb_t response_cb,
-					void *priv)
+struct mgcp_response_pending *mgcp_client_pending_add(struct mgcp_client *mgcp, mgcp_trans_id_t trans_id,
+						      mgcp_response_cb_t response_cb, void *priv)
 {
 	struct mgcp_response_pending *pending;
 
@@ -1138,87 +1232,87 @@ static mgcp_trans_id_t mgcp_client_next_trans_id(struct mgcp_client *mgcp)
 static int add_lco(struct msgb *msg, struct mgcp_msg *mgcp_msg)
 {
 	unsigned int i;
-	int rc = 0;
 	const char *codec;
 	unsigned int pt;
 
-	rc |= msgb_printf(msg, "L:");
+#define MSGB_PRINTF_OR_RET(FMT, ARGS...) do { \
+		if (msgb_printf(msg, FMT, ##ARGS) != 0) { \
+			LOGP(DLMGCP, LOGL_ERROR, "Message buffer too small, can not generate MGCP/SDP message\n"); \
+			return -ENOBUFS; \
+		} \
+	} while (0)
+
+	MSGB_PRINTF_OR_RET("L:");
 
 	if (mgcp_msg->ptime)
-		rc |= msgb_printf(msg, " p:%u,", mgcp_msg->ptime);
+		MSGB_PRINTF_OR_RET(" p:%u,", mgcp_msg->ptime);
 
 	if (mgcp_msg->codecs_len) {
-		rc |= msgb_printf(msg, " a:");
+		MSGB_PRINTF_OR_RET(" a:");
 		for (i = 0; i < mgcp_msg->codecs_len; i++) {
 			pt = mgcp_msg->codecs[i];
 			codec = get_value_string_or_null(osmo_mgcpc_codec_names, pt);
 
 			/* Note: Use codec descriptors from enum mgcp_codecs
 			 * in mgcp_client only! */
-			if (!codec) {
-				msgb_free(msg);
+			if (!codec)
 				return -EINVAL;
-			}
 
-			rc |= msgb_printf(msg, "%s", extract_codec_name(codec));
+			MSGB_PRINTF_OR_RET("%s", extract_codec_name(codec));
 			if (i < mgcp_msg->codecs_len - 1)
-				rc |= msgb_printf(msg, ";");
+				MSGB_PRINTF_OR_RET(";");
 		}
-		rc |= msgb_printf(msg, ",");
+		MSGB_PRINTF_OR_RET(",");
 	}
 
-	rc |= msgb_printf(msg, " nt:IN\r\n");
-
-	if (rc != 0) {
-		LOGP(DLMGCP, LOGL_ERROR,
-		     "message buffer to small, can not generate MGCP message (LCO)\n");
-		msgb_free(msg);
-		return -ENOBUFS;
-	}
+	MSGB_PRINTF_OR_RET(" nt:IN\r\n");
 	return 0;
+
+#undef MSGB_PRINTF_OR_RET
 }
 
 /* Helper function for mgcp_msg_gen(): Add SDP information to MGCP message */
 static int add_sdp(struct msgb *msg, struct mgcp_msg *mgcp_msg, struct mgcp_client *mgcp)
 {
 	unsigned int i;
-	int rc = 0;
 	char local_ip[INET6_ADDRSTRLEN];
 	int local_ip_family, audio_ip_family;
 	const char *codec;
 	unsigned int pt;
 
+#define MSGB_PRINTF_OR_RET(FMT, ARGS...) do { \
+		if (msgb_printf(msg, FMT, ##ARGS) != 0) { \
+			LOGPMGW(mgcp, LOGL_ERROR, "Message buffer too small, can not generate MGCP message (SDP)\n"); \
+			return -ENOBUFS; \
+		} \
+	} while (0)
+
 	/* Add separator to mark the beginning of the SDP block */
-	rc |= msgb_printf(msg, "\r\n");
+	MSGB_PRINTF_OR_RET("\r\n");
 
 	/* Add SDP protocol version */
-	rc |= msgb_printf(msg, "v=0\r\n");
+	MSGB_PRINTF_OR_RET("v=0\r\n");
 
 	/* Determine local IP-Address */
 	if (osmo_sock_local_ip(local_ip, mgcp->actual.remote_addr) < 0) {
 		LOGPMGW(mgcp, LOGL_ERROR,
 			"Could not determine local IP-Address!\n");
-		msgb_free(msg);
 		return -EINVAL;
 	}
 	local_ip_family = osmo_ip_str_type(local_ip);
-	if (local_ip_family == AF_UNSPEC) {
-		msgb_free(msg);
+	if (local_ip_family == AF_UNSPEC)
 		return -EINVAL;
-	}
 	audio_ip_family = osmo_ip_str_type(mgcp_msg->audio_ip);
-	if (audio_ip_family == AF_UNSPEC) {
-		msgb_free(msg);
+	if (audio_ip_family == AF_UNSPEC)
 		return -EINVAL;
-	}
 
 	/* Add owner/creator (SDP) */
-	rc |= msgb_printf(msg, "o=- %x 23 IN IP%c %s\r\n", mgcp_msg->call_id,
+	MSGB_PRINTF_OR_RET("o=- %x 23 IN IP%c %s\r\n", mgcp_msg->call_id,
 			  local_ip_family == AF_INET6 ? '6' : '4',
 			  local_ip);
 
 	/* Add session name (none) */
-	rc |= msgb_printf(msg, "s=-\r\n");
+	MSGB_PRINTF_OR_RET("s=-\r\n");
 
 	/* Add RTP address and port */
 	if (mgcp_msg->audio_port == 0) {
@@ -1233,20 +1327,20 @@ static int add_sdp(struct msgb *msg, struct mgcp_msg *mgcp_msg, struct mgcp_clie
 		msgb_free(msg);
 		return -EINVAL;
 	}
-	rc |= msgb_printf(msg, "c=IN IP%c %s\r\n",
+	MSGB_PRINTF_OR_RET("c=IN IP%c %s\r\n",
 			  audio_ip_family == AF_INET6 ? '6' : '4',
 			  mgcp_msg->audio_ip);
 
 	/* Add time description, active time (SDP) */
-	rc |= msgb_printf(msg, "t=0 0\r\n");
+	MSGB_PRINTF_OR_RET("t=0 0\r\n");
 
-	rc |= msgb_printf(msg, "m=audio %u RTP/AVP", mgcp_msg->audio_port);
+	MSGB_PRINTF_OR_RET("m=audio %u RTP/AVP", mgcp_msg->audio_port);
 	for (i = 0; i < mgcp_msg->codecs_len; i++) {
 		pt = map_codec_to_pt(mgcp_msg->ptmap, mgcp_msg->ptmap_len, mgcp_msg->codecs[i]);
-		rc |= msgb_printf(msg, " %u", pt);
+		MSGB_PRINTF_OR_RET(" %u", pt);
 
 	}
-	rc |= msgb_printf(msg, "\r\n");
+	MSGB_PRINTF_OR_RET("\r\n");
 
 	/* Add optional codec parameters (fmtp) */
 	if (mgcp_msg->param_present) {
@@ -1256,9 +1350,9 @@ static int add_sdp(struct msgb *msg, struct mgcp_msg *mgcp_msg, struct mgcp_clie
 				   continue;
 			pt = map_codec_to_pt(mgcp_msg->ptmap, mgcp_msg->ptmap_len, mgcp_msg->codecs[i]);
 			if (mgcp_msg->param.amr_octet_aligned_present && mgcp_msg->param.amr_octet_aligned)
-				rc |= msgb_printf(msg, "a=fmtp:%u octet-align=1\r\n", pt);
+				MSGB_PRINTF_OR_RET("a=fmtp:%u octet-align=1\r\n", pt);
 			else if (mgcp_msg->param.amr_octet_aligned_present && !mgcp_msg->param.amr_octet_aligned)
-				rc |= msgb_printf(msg, "a=fmtp:%u octet-align=0\r\n", pt);
+				MSGB_PRINTF_OR_RET("a=fmtp:%u octet-align=0\r\n", pt);
 		}
 	}
 
@@ -1273,25 +1367,18 @@ static int add_sdp(struct msgb *msg, struct mgcp_msg *mgcp_msg, struct mgcp_clie
 
 			/* Note: Use codec descriptors from enum mgcp_codecs
 			 * in mgcp_client only! */
-			if (!codec) {
-				msgb_free(msg);
+			if (!codec)
 				return -EINVAL;
-			}
 
-			rc |= msgb_printf(msg, "a=rtpmap:%u %s\r\n", pt, codec);
+			MSGB_PRINTF_OR_RET("a=rtpmap:%u %s\r\n", pt, codec);
 		}
 	}
 
 	if (mgcp_msg->ptime)
-		rc |= msgb_printf(msg, "a=ptime:%u\r\n", mgcp_msg->ptime);
-
-	if (rc != 0) {
-		LOGPMGW(mgcp, LOGL_ERROR, "Message buffer to small, can not generate MGCP message (SDP)\n");
-		msgb_free(msg);
-		return -ENOBUFS;
-	}
+		MSGB_PRINTF_OR_RET("a=ptime:%u\r\n", mgcp_msg->ptime);
 
 	return 0;
+#undef MSGB_PRINTF_OR_RET
 }
 
 /*! Generate an MGCP message
@@ -1303,10 +1390,16 @@ struct msgb *mgcp_msg_gen(struct mgcp_client *mgcp, struct mgcp_msg *mgcp_msg)
 	mgcp_trans_id_t trans_id = mgcp_client_next_trans_id(mgcp);
 	uint32_t mandatory_mask;
 	struct msgb *msg = msgb_alloc_headroom(4096, 128, "MGCP tx");
-	int rc = 0;
 	bool use_sdp = false;
 	char buf[32];
 
+#define MSGB_PRINTF_OR_RET(FMT, ARGS...) do { \
+		if (msgb_printf(msg, FMT, ##ARGS) != 0) { \
+			LOGPMGW(mgcp, LOGL_ERROR, "Message buffer too small, can not generate MGCP/SDP message\n"); \
+			goto exit_error; \
+		} \
+	} while (0)
+
 	msg->l2h = msg->data;
 	msg->cb[MSGB_CB_MGCP_TRANS_ID] = trans_id;
 
@@ -1314,75 +1407,70 @@ struct msgb *mgcp_msg_gen(struct mgcp_client *mgcp, struct mgcp_msg *mgcp_msg)
 	switch (mgcp_msg->verb) {
 	case MGCP_VERB_CRCX:
 		mandatory_mask = MGCP_CRCX_MANDATORY;
-		rc |= msgb_printf(msg, "CRCX %u", trans_id);
+		MSGB_PRINTF_OR_RET("CRCX %u", trans_id);
 		break;
 	case MGCP_VERB_MDCX:
 		mandatory_mask = MGCP_MDCX_MANDATORY;
-		rc |= msgb_printf(msg, "MDCX %u", trans_id);
+		MSGB_PRINTF_OR_RET("MDCX %u", trans_id);
 		break;
 	case MGCP_VERB_DLCX:
 		mandatory_mask = MGCP_DLCX_MANDATORY;
-		rc |= msgb_printf(msg, "DLCX %u", trans_id);
+		MSGB_PRINTF_OR_RET("DLCX %u", trans_id);
 		break;
 	case MGCP_VERB_AUEP:
 		mandatory_mask = MGCP_AUEP_MANDATORY;
-		rc |= msgb_printf(msg, "AUEP %u", trans_id);
+		MSGB_PRINTF_OR_RET("AUEP %u", trans_id);
 		break;
 	case MGCP_VERB_RSIP:
 		mandatory_mask = MGCP_RSIP_MANDATORY;
-		rc |= msgb_printf(msg, "RSIP %u", trans_id);
+		MSGB_PRINTF_OR_RET("RSIP %u", trans_id);
 		break;
 	default:
 		LOGPMGW(mgcp, LOGL_ERROR, "Invalid command verb, can not generate MGCP message\n");
-		msgb_free(msg);
-		return NULL;
+		goto exit_error;
 	}
 
 	/* Check if mandatory fields are missing */
 	if (!((mgcp_msg->presence & mandatory_mask) == mandatory_mask)) {
 		LOGPMGW(mgcp, LOGL_ERROR,
 			"One or more missing mandatory fields, can not generate MGCP message\n");
-		msgb_free(msg);
-		return NULL;
+		goto exit_error;
 	}
 
 	/* Add endpoint name */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_ENDPOINT) {
 		if (strlen(mgcp_msg->endpoint) <= 0) {
 			LOGPMGW(mgcp, LOGL_ERROR, "Empty endpoint name, can not generate MGCP message\n");
-			msgb_free(msg);
-			return NULL;
+			goto exit_error;
 		}
 
 		if (strstr(mgcp_msg->endpoint, "@") == NULL) {
 			LOGPMGW(mgcp, LOGL_ERROR,
 				"Endpoint name (%s) lacks separator (@), can not generate MGCP message\n",
 				mgcp_msg->endpoint);
-			msgb_free(msg);
-			return NULL;
+			goto exit_error;
 		}
 
-		rc |= msgb_printf(msg, " %s", mgcp_msg->endpoint);
+		MSGB_PRINTF_OR_RET(" %s", mgcp_msg->endpoint);
 	}
 
 	/* Add protocol version */
-	rc |= msgb_printf(msg, " MGCP 1.0\r\n");
+	MSGB_PRINTF_OR_RET(" MGCP 1.0\r\n");
 
 	/* Add call id */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_CALL_ID)
-		rc |= msgb_printf(msg, "C: %x\r\n", mgcp_msg->call_id);
+		MSGB_PRINTF_OR_RET("C: %x\r\n", mgcp_msg->call_id);
 
 	/* Add connection id */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_CONN_ID) {
 		if (strlen(mgcp_msg->conn_id) <= 0) {
 			LOGPMGW(mgcp, LOGL_ERROR, "Empty connection id, can not generate MGCP message\n");
-			msgb_free(msg);
-			return NULL;
+			goto exit_error;
 		}
-		rc |= msgb_printf(msg, "I: %s\r\n", mgcp_msg->conn_id);
+		MSGB_PRINTF_OR_RET("I: %s\r\n", mgcp_msg->conn_id);
 	}
 
-	/* Using SDP makes sense when a valid IP/Port combination is specifiec,
+	/* Using SDP makes sense when a valid IP/Port combination is specified,
 	 * if we do not know this information yet, we fall back to LCO */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_AUDIO_IP
 	    && mgcp_msg->presence & MGCP_MSG_PRESENCE_AUDIO_PORT)
@@ -1392,35 +1480,32 @@ struct msgb *mgcp_msg_gen(struct mgcp_client *mgcp, struct mgcp_msg *mgcp_msg)
 	if (!use_sdp
 	    && (mgcp_msg->verb == MGCP_VERB_CRCX
 		|| mgcp_msg->verb == MGCP_VERB_MDCX)) {
-	        if (add_lco(msg, mgcp_msg) < 0)
-			return NULL;
+		if (add_lco(msg, mgcp_msg) < 0) {
+			LOGPMGW(mgcp, LOGL_ERROR, "Failed to add LCO, can not generate MGCP message\n");
+			goto exit_error;
+		}
 	}
 
 	/* Add mode */
 	if (mgcp_msg->presence & MGCP_MSG_PRESENCE_CONN_MODE)
-		rc |=
-		    msgb_printf(msg, "M: %s\r\n",
-				mgcp_client_cmode_name(mgcp_msg->conn_mode));
+		MSGB_PRINTF_OR_RET("M: %s\r\n", mgcp_client_cmode_name(mgcp_msg->conn_mode));
 
 	/* Add X-Osmo-IGN */
 	if ((mgcp_msg->presence & MGCP_MSG_PRESENCE_X_OSMO_IGN)
 	    && (mgcp_msg->x_osmo_ign != 0))
-		rc |=
-		    msgb_printf(msg, MGCP_X_OSMO_IGN_HEADER "%s\r\n",
-				mgcp_msg->x_osmo_ign & MGCP_X_OSMO_IGN_CALLID ? " C": "");
+		MSGB_PRINTF_OR_RET(MGCP_X_OSMO_IGN_HEADER "%s\r\n",
+				   mgcp_msg->x_osmo_ign & MGCP_X_OSMO_IGN_CALLID ? " C" : "");
 
 	/* Add X-Osmo-Osmux */
 	if ((mgcp_msg->presence & MGCP_MSG_PRESENCE_X_OSMO_OSMUX_CID)) {
 		if (mgcp_msg->x_osmo_osmux_cid < -1 || mgcp_msg->x_osmo_osmux_cid > OSMUX_CID_MAX) {
 			LOGPMGW(mgcp, LOGL_ERROR, "Wrong Osmux CID %d, can not generate MGCP message\n",
 				mgcp_msg->x_osmo_osmux_cid);
-			msgb_free(msg);
-			return NULL;
+			goto exit_error;
 		}
 		snprintf(buf, sizeof(buf), " %d", mgcp_msg->x_osmo_osmux_cid);
-		rc |=
-		    msgb_printf(msg, MGCP_X_OSMO_OSMUX_HEADER "%s\r\n",
-				mgcp_msg->x_osmo_osmux_cid == -1 ? " *": buf);
+		MSGB_PRINTF_OR_RET(MGCP_X_OSMO_OSMUX_HEADER "%s\r\n",
+				   mgcp_msg->x_osmo_osmux_cid == -1 ? " *" : buf);
 	}
 
 
@@ -1428,17 +1513,18 @@ struct msgb *mgcp_msg_gen(struct mgcp_client *mgcp, struct mgcp_msg *mgcp_msg)
 	if (use_sdp
 	    && (mgcp_msg->verb == MGCP_VERB_CRCX
 		|| mgcp_msg->verb == MGCP_VERB_MDCX)) {
-	        if (add_sdp(msg, mgcp_msg, mgcp) < 0)
-			return NULL;
+		if (add_sdp(msg, mgcp_msg, mgcp) < 0) {
+			LOGPMGW(mgcp, LOGL_ERROR, "Failed to add SDP, can not generate MGCP message\n");
+			goto exit_error;
 		}
-
-	if (rc != 0) {
-		LOGPMGW(mgcp, LOGL_ERROR, "Message buffer to small, can not generate MGCP message\n");
-		msgb_free(msg);
-		msg = NULL;
 	}
 
 	return msg;
+
+exit_error:
+	msgb_free(msg);
+	return NULL;
+#undef MSGB_PRINTF_OR_RET
 }
 
 /*! Retrieve the MGCP transaction ID from a msgb generated by mgcp_msg_gen()
@@ -1462,6 +1548,7 @@ const struct value_string mgcp_client_connection_mode_strs[] = {
 	{ MGCP_CONN_RECV_SEND, "sendrecv" },
 	{ MGCP_CONN_SEND_ONLY, "sendonly" },
 	{ MGCP_CONN_RECV_ONLY, "recvonly" },
+	{ MGCP_CONN_CONFECHO, "confecho" },
 	{ MGCP_CONN_LOOPBACK, "loopback" },
 	{ 0, NULL }
 };

src/libosmo-mgcp-client/mgcp_client_pool.c

@@ -75,6 +75,11 @@ void mgcp_client_pool_register_single(struct mgcp_client_pool *pool, struct mgcp
 	pool->mgcp_client_single = mgcp_client;
 }
 
+bool mgcp_client_pool_empty(const struct mgcp_client_pool *pool)
+{
+	return llist_empty(&pool->member_list);
+}
+
 /*! Lookup the selected MGCP client config by its reference number */
 struct mgcp_client_pool_member *mgcp_client_pool_find_member_by_nr(struct mgcp_client_pool *pool, unsigned int nr)
 {
@@ -89,7 +94,7 @@ struct mgcp_client_pool_member *mgcp_client_pool_find_member_by_nr(struct mgcp_c
 }
 
 /* Not every pool member may have a functional MGCP client, we will run through the pool once until we meet a
- * pool member that is suitable (has a client, is not blocked, has a low load). */
+ * pool member that is suitable (is not blocked, has a client with a working link, has a low load). */
 static struct mgcp_client_pool_member *mgcp_client_pool_pick(struct mgcp_client_pool *pool)
 {
 	struct mgcp_client_pool_member *pool_member;
@@ -98,14 +103,15 @@ static struct mgcp_client_pool_member *mgcp_client_pool_pick(struct mgcp_client_
 
 	llist_for_each_entry(pool_member, &pool->member_list, list) {
 		n_pool_members++;
-		if (pool_member->blocked == false && pool_member->client) {
+		bool conn_up = pool_member->client && pool_member->client->conn_up;
+		if (pool_member->blocked == false && conn_up) {
 			if (!pool_member_picked)
 				pool_member_picked = pool_member;
 			else if (pool_member_picked->refcount > pool_member->refcount)
 				pool_member_picked = pool_member;
 		} else {
-			LOGPPMGW(pool_member, LOGL_DEBUG, "%s -- MGW %u is unusable (blocked=%u, cli=%u)\n",
-				 __func__, pool_member->nr, pool_member->blocked, !!pool_member->client);
+			LOGPPMGW(pool_member, LOGL_DEBUG, "%s -- MGW %u is unusable (blocked=%u, cli=%u, link=%u)\n",
+				 __func__, pool_member->nr, pool_member->blocked, !!pool_member->client, conn_up);
 		}
 	}
 

src/libosmo-mgcp-client/mgcp_client_vty.c

@@ -1,5 +1,5 @@
 /* MGCP client interface to quagga VTY */
-/* (C) 2016 by sysmocom s.m.f.c. GmbH <info@sysmocom.de>
+/* (C) 2016 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
  * Based on OpenBSC interface to quagga VTY (libmsc/vty_interface_layer3.c)
  * (C) 2009 by Harald Welte <laforge@gnumonks.org>
  * (C) 2009-2011 by Holger Hans Peter Freyther
@@ -28,6 +28,7 @@
 #include <osmocom/vty/command.h>
 #include <osmocom/vty/misc.h>
 #include <osmocom/core/utils.h>
+#include <osmocom/core/timer.h>
 
 #include <osmocom/mgcp_client/mgcp_client.h>
 #include <osmocom/mgcp_client/mgcp_client_internal.h>
@@ -48,19 +49,43 @@ static struct mgcp_client_conf *global_mgcp_client_conf = NULL;
 /* Pointer to the MGCP pool that is managed by mgcp_client_pool_vty_init() */
 static struct mgcp_client_pool *global_mgcp_client_pool = NULL;
 
-struct mgcp_client_conf *get_mgcp_client_config(struct vty *vty)
+static struct mgcp_client_conf *get_mgcp_client_config(struct vty *vty)
 {
 	if (global_mgcp_client_pool && vty->node == global_mgcp_client_pool->vty_node->node)
 		return vty->index;
 
 	/* Global single MGCP config, deprecated: */
 	vty_out(vty, "%% MGCP commands outside of 'mgw' nodes are deprecated. "
-		"You should consider reading User Manual and migrating to 'mgw' node.%s",
+		"You should consider reading the User Manual and migrating to 'mgw' node.%s",
 		VTY_NEWLINE);
 
 	return global_mgcp_client_conf;
 }
 
+static struct mgcp_client *get_mgcp_client(struct vty *vty)
+{
+	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
+	struct mgcp_client_pool_member *pool_member;
+
+	if (global_mgcp_client_pool && vty->node == global_mgcp_client_pool->vty_node->node) {
+		llist_for_each_entry(pool_member, &global_mgcp_client_pool->member_list, list) {
+			/* Find matching the conf pointer: */
+			if (&pool_member->conf != conf)
+				continue;
+			return pool_member->client;
+		}
+	}
+
+	/* Global single MGCP config, deprecated: */
+	vty_out(vty, "%% MGCP commands outside of 'mgw' nodes are deprecated. "
+		"You should consider reading the User Manual and migrating to 'mgw' node.%s",
+		VTY_NEWLINE);
+
+	/* There's no way to obtain the struct mgcp_client in old interface, but anyway it's deprecated. */
+	return NULL;
+}
+
+
 DEFUN(cfg_mgw_local_ip, cfg_mgw_local_ip_cmd,
       "local-ip " VTY_IPV46_CMD,
       "local bind to connect to MGW from\n"
@@ -280,6 +305,91 @@ ALIAS_DEPRECATED(cfg_mgw_no_reset_ep_name,
       NO_STR MGW_STR "remove an endpoint name from the reset-endpoint list, e.g. 'rtpbridge/*'\n"
       "Endpoint name, e.g. 'rtpbridge/*' or 'ds/e1-0/s-3/su16-4'.\n")
 
+DEFUN(cfg_mgw_mgw_keepalive_req_interval,
+      cfg_mgw_mgw_keepalive_req_interval_cmd,
+      "keepalive request-interval <0-4294967295>",
+      "Monitor if the MGCP link against MGW is still usable\n"
+      "Send an MGCP command to the MGW at given interval if no other commands are sent\n"
+      "The interval at which send MGCP commands (s), 0 to disable\n")
+{
+	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
+	struct mgcp_client *mgcp = get_mgcp_client(vty);
+
+	conf->keepalive.req_interval_sec = atoi(argv[0]);
+
+	if (!mgcp)
+		return CMD_SUCCESS;
+
+	/* If client already exists, apply the change immediately if possible: */
+	mgcp->actual.keepalive.req_interval_sec = atoi(argv[0]);
+	if (mgcp->wq.bfd.fd != -1) { /* UDP MGCP socket connected */
+		if (mgcp->actual.keepalive.req_interval_sec > 0) {
+			/* Re-schedule: */
+			osmo_timer_schedule(&mgcp->keepalive_tx_timer, mgcp->actual.keepalive.req_interval_sec, 0);
+		} else {
+			if (osmo_timer_pending(&mgcp->keepalive_tx_timer))
+				osmo_timer_del(&mgcp->keepalive_tx_timer);
+			/* Assume link is UP by default, so that this MGW can be selected: */
+			mgcp->conn_up = true;
+		}
+	} /* else: wait until connect() to do first scheduling */
+
+	return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgw_mgw_keepalive_req_endpoint,
+      cfg_mgw_mgw_keepalive_req_endpoint_cmd,
+      "keepalive request-endpoint NAME",
+      "Monitor if the MGCP link against MGW is still usable\n"
+      "Use a given endpoint name when sending an MGCP command to the MGW for keepalive purposes\n"
+      "The name of the endpoint to use\n")
+{
+	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
+	struct mgcp_client *mgcp = get_mgcp_client(vty);
+
+	OSMO_STRLCPY_ARRAY(conf->keepalive.req_endpoint_name, argv[0]);
+
+	if (!mgcp)
+		return CMD_SUCCESS;
+
+	/* If client already exists, apply the change immediately if possible: */
+	OSMO_STRLCPY_ARRAY(mgcp->actual.keepalive.req_endpoint_name, argv[0]);
+
+	return CMD_SUCCESS;
+}
+
+DEFUN(cfg_mgw_mgw_keepalive_timeout,
+      cfg_mgw_mgw_keepalive_timeout_cmd,
+      "keepalive timeout <0-4294967295>",
+      "Monitor if the MGCP link against MGW is still usable\n"
+      "Consider the link to the MGW to be down after time without receiving any message from it\n"
+      "The timeout (s), 0 to disable\n")
+{
+	struct mgcp_client_conf *conf = get_mgcp_client_config(vty);
+	struct mgcp_client *mgcp = get_mgcp_client(vty);
+
+	conf->keepalive.timeout_sec = atoi(argv[0]);
+
+	if (!mgcp)
+		return CMD_SUCCESS;
+
+	/* If client already exists, apply the change immediately if possible: */
+	mgcp->actual.keepalive.timeout_sec = atoi(argv[0]);
+	if (mgcp->wq.bfd.fd != -1) { /* UDP MGCP socket connected */
+		if (mgcp->actual.keepalive.timeout_sec > 0) {
+			/* Re-schedule: */
+			osmo_timer_schedule(&mgcp->keepalive_rx_timer, mgcp->actual.keepalive.timeout_sec, 0);
+		} else {
+			if (osmo_timer_pending(&mgcp->keepalive_rx_timer))
+				osmo_timer_del(&mgcp->keepalive_rx_timer);
+			/* Assume link is UP by default, so that this MGW can be selected: */
+			mgcp->conn_up = true;
+		}
+	} /* else: wait until connect() to do first scheduling */
+
+	return CMD_SUCCESS;
+}
+
 static int config_write(struct vty *vty, const char *indent, struct mgcp_client_conf *conf)
 {
 	const char *addr;
@@ -317,6 +427,17 @@ static int config_write(struct vty *vty, const char *indent, struct mgcp_client_
 	llist_for_each_entry(reset_ep, &conf->reset_epnames, list)
 		vty_out(vty, "%s%sreset-endpoint %s%s", indent, mgw_prefix, reset_ep->name, VTY_NEWLINE);
 
+	if (conf->keepalive.req_interval_sec != 0)
+		vty_out(vty, "%s%skeepalive request-interval %u%s", indent, mgw_prefix,
+			conf->keepalive.req_interval_sec, VTY_NEWLINE);
+	if (strncmp(conf->keepalive.req_endpoint_name, MGCP_CLIENT_KEEPALIVE_DEFAULT_ENDP,
+		    sizeof(conf->keepalive.req_endpoint_name)) != 0)
+		vty_out(vty, "%s%skeepalive request-endpoint %s%s", indent,  mgw_prefix,
+			conf->keepalive.req_endpoint_name, VTY_NEWLINE);
+	if (conf->keepalive.timeout_sec != 0)
+		vty_out(vty, "%s%skeepalive timeout %u%s", indent,  mgw_prefix,
+			conf->keepalive.timeout_sec, VTY_NEWLINE);
+
 	return CMD_SUCCESS;
 }
 
@@ -347,6 +468,9 @@ static void vty_init_common(void *talloc_ctx, int node)
 	install_lib_element(node, &cfg_mgw_mgw_endpoint_domain_name_cmd);
 	install_lib_element(node, &cfg_mgw_mgw_reset_ep_name_cmd);
 	install_lib_element(node, &cfg_mgw_mgw_no_reset_ep_name_cmd);
+	install_lib_element(node, &cfg_mgw_mgw_keepalive_req_interval_cmd);
+	install_lib_element(node, &cfg_mgw_mgw_keepalive_req_endpoint_cmd);
+	install_lib_element(node, &cfg_mgw_mgw_keepalive_timeout_cmd);
 
 	osmo_fsm_vty_add_cmds();
 }
@@ -553,8 +677,13 @@ DEFUN(mgw_show, mgw_show_cmd, "show mgw-pool", SHOW_STR "Display information abo
 	}
 
 	llist_for_each_entry(pool_member, &global_mgcp_client_pool->member_list, list) {
+		const struct mgcp_client *cli = pool_member->client;
 		vty_out(vty, "%%  MGW %s%s", mgcp_client_pool_member_name(pool_member), VTY_NEWLINE);
-		vty_out(vty, "%%   mgcp-client:   %s%s", pool_member->client ? "connected" : "disconnected",
+		vty_out(vty, "%%   MGCP link:     %s,%s%s",
+			cli && cli->wq.bfd.fd != -1 ? "connected" : "disconnected",
+			cli && cli->conn_up ?
+				((cli->actual.keepalive.timeout_sec > 0) ? "UP" : "MAYBE") :
+				"DOWN",
 			VTY_NEWLINE);
 		vty_out(vty, "%%   service:       %s%s", pool_member->blocked ? "blocked" : "unblocked", VTY_NEWLINE);
 		vty_out(vty, "%%   ongoing calls: %u%s", pool_member->refcount, VTY_NEWLINE);

src/libosmo-mgcp/Makefile.am

@@ -16,12 +16,6 @@ AM_CFLAGS = \
 	$(NULL)
 
 AM_LDFLAGS = \
-	$(LIBOSMOCORE_LIBS) \
-	$(LIBOSMOGSM_LIBS) \
-	$(LIBOSMOVTY_LIBS) \
-	$(LIBOSMONETIF_LIBS) \
-	$(LIBOSMOABIS_LIBS) \
-	$(LIBOSMOTRAU_LIBS) \
 	$(COVERAGE_LDFLAGS) \
 	$(NULL)
 

src/libosmo-mgcp/mgcp_codec.c

@@ -276,87 +276,6 @@ error:
 	return -EINVAL;
 }
 
-/* Check if the given codec is applicable on the specified endpoint
- * Helper function for mgcp_codec_decide() */
-static bool is_codec_compatible(const struct mgcp_endpoint *endp, const struct mgcp_rtp_codec *codec)
-{
-	/* A codec name must be set, if not, this might mean that the codec
-	 * (payload type) that was assigned is unknown to us so we must stop
-	 * here. */
-	if (!strlen(codec->subtype_name))
-		return false;
-
-	/* FIXME: implement meaningful checks to make sure that the given codec
-	 * is compatible with the given endpoint */
-
-	return true;
-}
-
-/*! Decide for one suitable codec
- *  \param[in] conn related rtp-connection.
- *  \returns 0 on success, -EINVAL on failure. */
-int mgcp_codec_decide(struct mgcp_conn_rtp *conn)
-{
-	struct mgcp_rtp_end *rtp;
-	unsigned int i;
-	struct mgcp_endpoint *endp;
-	bool codec_assigned = false;
-
-	endp = conn->conn->endp;
-	rtp = &conn->end;
-
-	/* This function works on the results the SDP/LCO parser has extracted
-	 * from the MGCP message. The goal is to select a suitable codec for
-	 * the given connection. When transcoding is available, the first codec
-	 * from the codec list is taken without further checking. When
-	 * transcoding is not available, then the choice must be made more
-	 * carefully. Each codec in the list is checked until one is found that
-	 * is rated compatible. The rating is done by the helper function
-	 * is_codec_compatible(), which does the actual checking. */
-	for (i = 0; i < rtp->codecs_assigned; i++) {
-		/* When no transcoding is available, avoid codecs that would
-		 * require transcoding. */
-		if (endp->trunk->no_audio_transcoding && !is_codec_compatible(endp, &rtp->codecs[i])) {
-			LOGP(DLMGCP, LOGL_NOTICE, "transcoding not available, skipping codec: %d/%s\n",
-			     rtp->codecs[i].payload_type, rtp->codecs[i].subtype_name);
-			continue;
-		}
-
-		rtp->codec = &rtp->codecs[i];
-		codec_assigned = true;
-		break;
-	}
-
-	/* FIXME: To the reviewes: This is problematic. I do not get why we
-	 * need to reset the packet_duration_ms depending on the codec
-	 * selection. I thought it were all 20ms? Is this to address some
-	 * cornercase. (This piece of code was in the code path before,
-	 * together with the note: "TODO/XXX: Store this per codec and derive
-	 * it on use" */
-	if (codec_assigned) {
-		if (rtp->maximum_packet_time >= 0
-		    && rtp->maximum_packet_time * rtp->codec->frame_duration_den >
-		    rtp->codec->frame_duration_num * 1500)
-			rtp->packet_duration_ms = 0;
-
-		return 0;
-	}
-
-	return -EINVAL;
-}
-
-/* Check if the codec has a specific AMR mode (octet-aligned or bandwith-efficient) set. */
-bool mgcp_codec_amr_align_mode_is_indicated(const struct mgcp_rtp_codec *codec)
-{
-	if (codec->param_present == false)
-		return false;
-	if (!codec->param.amr_octet_aligned_present)
-		return false;
-	if (strcmp(codec->subtype_name, "AMR") != 0)
-		return false;
-	return true;
-}
-
 /* Return true if octet-aligned is set in the given codec. Default to octet-aligned=0, i.e. bandwidth-efficient mode.
  * See RFC4867 "RTP Payload Format for AMR and AMR-WB" sections "8.1. AMR Media Type Registration" and "8.2. AMR-WB
  * Media Type Registration":
@@ -376,10 +295,15 @@ bool mgcp_codec_amr_is_octet_aligned(const struct mgcp_rtp_codec *codec)
 	return codec->param.amr_octet_aligned;
 }
 
-/* Compare two codecs, all parameters must match up, except for the payload type
- * number. */
+/* Compare two codecs, all parameters must match up */
 static bool codecs_same(struct mgcp_rtp_codec *codec_a, struct mgcp_rtp_codec *codec_b)
 {
+	/* All codec properties must match up, except the payload type number. Even though standardisd payload numbers
+	 * exist for certain situations, the call agent may still assign them freely. Hence we must not insist on equal
+	 * payload type numbers. Also the audio_name is not checked since it is already parsed into subtype_name, rate,
+	 * and channels, which are checked. */
+	if (strcmp(codec_a->subtype_name, codec_b->subtype_name))
+		return false;
 	if (codec_a->rate != codec_b->rate)
 		return false;
 	if (codec_a->channels != codec_b->channels)
@@ -388,61 +312,163 @@ static bool codecs_same(struct mgcp_rtp_codec *codec_a, struct mgcp_rtp_codec *c
 		return false;
 	if (codec_a->frame_duration_den != codec_b->frame_duration_den)
 		return false;
-	if (strcmp(codec_a->subtype_name, codec_b->subtype_name))
-		return false;
 
-	/* Note: AMR allows to set the RTP payload format to octet-aligned or bandwith-efficient (octet-aligned=0)
-	 * via SDP. This difference concerns payload format only, but not the actual codec. It is not a difference
-	 * within the meaning of this function. */
+	/* AMR payload may be formatted in two different payload formats, it is still the same codec but since the
+	 * formatting of the payload is different, conversation is required, so we must treat it as a different
+	 * codec here. */
+	if (strcmp(codec_a->subtype_name, "AMR") == 0) {
+		if (mgcp_codec_amr_is_octet_aligned(codec_a) != mgcp_codec_amr_is_octet_aligned(codec_b))
+			return false;
+	}
 
 	return true;
 }
 
-/*! Translate a given payload type number that belongs to the packet of a
- *  source connection to the equivalent payload type number that matches the
- *  configuration of a destination connection.
- *  \param[in] conn_src related source rtp-connection.
- *  \param[in] conn_dst related destination rtp-connection.
- *  \param[in] payload_type number from the source packet or source connection.
- *  \returns translated payload type number on success, -EINVAL on failure. */
-int mgcp_codec_pt_translate(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst, int payload_type)
+/* Compare two codecs, all parameters must match up, except parameters related to payload formatting (not checked). */
+static bool codecs_convertible(struct mgcp_rtp_codec *codec_a, struct mgcp_rtp_codec *codec_b)
 {
-	struct mgcp_rtp_end *rtp_src;
-	struct mgcp_rtp_end *rtp_dst;
-	struct mgcp_rtp_codec *codec_src = NULL;
-	struct mgcp_rtp_codec *codec_dst = NULL;
+	/* OsmoMGW currently has no ability to transcode from one codec to another. However OsmoMGW is still able to
+	 * translate between different payload formats as long as the encoded voice data itself does not change.
+	 * Therefore we must insist on equal codecs but still allow different payload formatting. */
+
+	/* In 3G IuUP, AMR may be encapsulated in IuFP, this means even though the codec name and negotiated rate is
+	 * different, the formatting can still be converted by OsmoMGW. Therefore we won't insist on equal
+	 * subtype_name and rate if we detect IuFP and AMR is used on the same tandem. */
+	if (strcmp(codec_a->subtype_name, "AMR") == 0 && strcmp(codec_b->subtype_name, "VND.3GPP.IUFP") == 0)
+		goto iufp;
+	if (strcmp(codec_a->subtype_name, "VND.3GPP.IUFP") == 0 && strcmp(codec_b->subtype_name, "AMR") == 0)
+		goto iufp;
+
+	if (strcmp(codec_a->subtype_name, codec_b->subtype_name))
+		return false;
+	if (codec_a->rate != codec_b->rate)
+		return false;
+iufp:
+	if (codec_a->channels != codec_b->channels)
+		return false;
+	if (codec_a->frame_duration_num != codec_b->frame_duration_num)
+		return false;
+	if (codec_a->frame_duration_den != codec_b->frame_duration_den)
+		return false;
+
+	return true;
+}
+
+struct mgcp_rtp_codec *mgcp_codec_find_same(struct mgcp_conn_rtp *conn, struct mgcp_rtp_codec *codec)
+{
+	struct mgcp_rtp_end *rtp_end;
 	unsigned int i;
 	unsigned int codecs_assigned;
 
-	rtp_src = &conn_src->end;
-	rtp_dst = &conn_dst->end;
+	rtp_end = &conn->end;
 
-	/* Find the codec information that is used on the source side */
-	codecs_assigned = rtp_src->codecs_assigned;
+	/* Use the codec information from the source and try to find the equivalent of it on the destination side. In
+	 * the first run we will look for an exact match. */
+	codecs_assigned = rtp_end->codecs_assigned;
 	OSMO_ASSERT(codecs_assigned <= MGCP_MAX_CODECS);
 	for (i = 0; i < codecs_assigned; i++) {
-		if (payload_type == rtp_src->codecs[i].payload_type) {
-			codec_src = &rtp_src->codecs[i];
+		if (codecs_same(codec, &rtp_end->codecs[i])) {
+			return &rtp_end->codecs[i];
 			break;
 		}
 	}
-	if (!codec_src)
-		return -EINVAL;
 
-	/* Use the codec information from the source and try to find the
-	 * equivalent of it on the destination side */
-	codecs_assigned = rtp_dst->codecs_assigned;
+	return NULL;
+}
+
+/* For a given codec, find a convertible codec in the given connection. */
+static struct mgcp_rtp_codec *codec_find_convertible(struct mgcp_conn_rtp *conn, struct mgcp_rtp_codec *codec)
+{
+	struct mgcp_rtp_end *rtp_end;
+	unsigned int i;
+	unsigned int codecs_assigned;
+	struct mgcp_rtp_codec *codec_convertible = NULL;
+
+	rtp_end = &conn->end;
+
+	/* Use the codec information from the source and try to find the equivalent of it on the destination side. In
+	 * the first run we will look for an exact match. */
+	codec_convertible = mgcp_codec_find_same(conn, codec);
+	if (codec_convertible)
+		return codec_convertible;
+
+	/* In case we weren't able to find an exact match, we will try to find a match that is the same codec, but the
+	 * payload format may be different. This alternative will require a frame format conversion (i.e. AMR bwe->oe) */
+	codecs_assigned = rtp_end->codecs_assigned;
 	OSMO_ASSERT(codecs_assigned <= MGCP_MAX_CODECS);
 	for (i = 0; i < codecs_assigned; i++) {
-		if (codecs_same(codec_src, &rtp_dst->codecs[i])) {
-			codec_dst = &rtp_dst->codecs[i];
+		if (codecs_convertible(codec, &rtp_end->codecs[i])) {
+			codec_convertible = &rtp_end->codecs[i];
 			break;
 		}
 	}
-	if (!codec_dst)
-		return -EINVAL;
 
-	return codec_dst->payload_type;
+	return codec_convertible;
+}
+
+/*! Decide for one suitable codec on both of the given connections. In case a destination connection is not available,
+ *  a tentative decision is made.
+ *  \param[inout] conn_src related rtp-connection.
+ *  \param[inout] conn_dst related destination rtp-connection (NULL if not present).
+ *  \returns 0 on success, -EINVAL on failure. */
+int mgcp_codec_decide(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp *conn_dst)
+{
+	unsigned int i;
+
+	/* In case no destination connection is available (yet), or in case the destination connection exists but has
+	 * no codecs assigned, we are forced to make a simple tentative decision:
+	 * We just use the first codec of the source connection (conn_src) */
+	OSMO_ASSERT(conn_src->end.codecs_assigned <= MGCP_MAX_CODECS);
+	if (!conn_dst || conn_dst->end.codecs_assigned == 0) {
+		if (conn_src->end.codecs_assigned >= 1) {
+			conn_src->end.codec = &conn_src->end.codecs[0];
+			return 0;
+		} else
+			return -EINVAL;
+	}
+
+	/* Compare all codecs of the source connection (conn_src) to the codecs of the destination connection (conn_dst). In case
+	 * of a match set this codec on both connections. This would be an ideal selection since no codec conversion would be
+	 * required. */
+	for (i = 0; i < conn_src->end.codecs_assigned; i++) {
+		struct mgcp_rtp_codec *codec_conn_dst = mgcp_codec_find_same(conn_dst, &conn_src->end.codecs[i]);
+		if (codec_conn_dst) {
+			/* We found the a codec that is exactly the same (same codec, same payload format etc.) on both
+			 * sides. We now set this codec on both connections. */
+			conn_dst->end.codec = codec_conn_dst;
+			conn_src->end.codec = mgcp_codec_find_same(conn_src, codec_conn_dst);
+			OSMO_ASSERT(conn_src->end.codec);
+			return 0;
+		}
+	}
+
+	/* In case we could not find a codec that is exactly the same, let's at least try to find a codec that we are able
+	 * to convert. */
+	for (i = 0; i < conn_src->end.codecs_assigned; i++) {
+		struct mgcp_rtp_codec *codec_conn_dst = codec_find_convertible(conn_dst, &conn_src->end.codecs[i]);
+		if (codec_conn_dst) {
+			/* We found the a codec that we are able to convert on both sides. We now set this codec on both
+			 * connections. */
+			conn_dst->end.codec = codec_conn_dst;
+			conn_src->end.codec = codec_find_convertible(conn_src, codec_conn_dst);
+			OSMO_ASSERT(conn_src->end.codec);
+			return 0;
+		}
+	}
+
+	return -EINVAL;
+}
+
+/* Check if the codec has a specific AMR mode (octet-aligned or bandwith-efficient) set. */
+bool mgcp_codec_amr_align_mode_is_indicated(const struct mgcp_rtp_codec *codec)
+{
+	if (codec->param_present == false)
+		return false;
+	if (!codec->param.amr_octet_aligned_present)
+		return false;
+	if (strcmp(codec->subtype_name, "AMR") != 0)
+		return false;
+	return true;
 }
 
 /* Find the payload type number configured for a specific codec by SDP.
@@ -452,8 +478,7 @@ int mgcp_codec_pt_translate(struct mgcp_conn_rtp *conn_src, struct mgcp_conn_rtp
  * \param subtype_name  SDP codec name without parameters (e.g. "AMR").
  * \param match_nr  Index for the match found, first being match_nr == 0. Iterate all matches by calling multiple times
  *                  with incrementing match_nr.
- * \return codec definition for that conn matching the subtype_name, or NULL if no such match_nr is found.
- */
+ * \return codec definition for that conn matching the subtype_name, or NULL if no such match_nr is found. */
 const struct mgcp_rtp_codec *mgcp_codec_pt_find_by_subtype_name(struct mgcp_conn_rtp *conn,
 								const char *subtype_name, unsigned int match_nr)
 {
@@ -469,3 +494,26 @@ const struct mgcp_rtp_codec *mgcp_codec_pt_find_by_subtype_name(struct mgcp_conn
 	}
 	return NULL;
 }
+
+/*! Lookup a codec that is assigned to a connection by its payload type number.
+ *  \param[in] conn related rtp-connection.
+ *  \param[in] payload_type number of the codec to look up.
+ *  \returns pointer to codec struct on success, NULL on failure. */
+struct mgcp_rtp_codec *mgcp_codec_from_pt(struct mgcp_conn_rtp *conn, int payload_type)
+{
+	struct mgcp_rtp_end *rtp_end = &conn->end;
+	unsigned int codecs_assigned = rtp_end->codecs_assigned;
+	struct mgcp_rtp_codec *codec = NULL;
+	size_t i;
+
+	OSMO_ASSERT(codecs_assigned <= MGCP_MAX_CODECS);
+
+	for (i = 0; i < codecs_assigned; i++) {
+		if (payload_type == rtp_end->codecs[i].payload_type) {
+			codec = &rtp_end->codecs[i];
+			break;
+		}
+	}
+
+	return codec;
+}

src/libosmo-mgcp/mgcp_conn.c

@@ -173,8 +173,8 @@ struct mgcp_conn *mgcp_conn_alloc(void *ctx, struct mgcp_endpoint *endp,
 	struct mgcp_conn *conn;
 	int rc;
 
-	/* Do not allow more then two connections */
-	if (llist_count(&endp->conns) >= endp->type->max_conns)
+	/* Do not allow more then the maximum number of connections */
+	if (endp->type->max_conns && llist_count(&endp->conns) >= endp->type->max_conns)
 		return NULL;
 
 	/* Create new connection and add it to the list */

src/libosmo-mgcp/mgcp_e1.c

@@ -222,7 +222,7 @@ static void e1_i460_mux_empty_cb(struct osmo_i460_subchan *schan, void *user_dat
 	osmo_i460_mux_enqueue(endp->e1.schan, msg);
 }
 
-/* called by I.460 de-multeiplexer; feed output of I.460 demux into TRAU frame sync */
+/* called by I.460 de-multiplexer; feed output of I.460 demux into TRAU frame sync */
 static void e1_i460_demux_bits_cb(struct osmo_i460_subchan *schan, void *user_data, const ubit_t *bits,
 				  unsigned int num_bits)
 {
@@ -309,8 +309,8 @@ skip:
 	return;
 }
 
-/* Function to handle outgoing E1 traffic */
-static void e1_send(struct e1inp_ts *ts, struct mgcp_trunk *trunk)
+/* handle outgoing E1 traffic */
+static void e1_send_ts_frame(struct e1inp_ts *ts, struct mgcp_trunk *trunk)
 {
 	struct msgb *msg = msgb_alloc_c(trunk, E1_TS_BYTES, "E1-TX-timeslot-bytes");
 	uint8_t *ptr;
@@ -359,19 +359,17 @@ static void e1_recv_cb(struct e1inp_ts *ts, struct msgb *msg)
 	osmo_i460_demux_in(&trunk->e1.i460_ts[ts->num - 1], msgb_data(msg), msgb_length(msg));
 
 	/* Trigger sending of pending E1 traffic */
-	e1_send(ts, trunk);
+	e1_send_ts_frame(ts, trunk);
 
-	/* e1inp_rx_ts() does not free() msgb */
+	/* e1inp_rx_ts(), the caller of this callback does not free() msgb. */
 	msgb_free(msg);
 }
 
-static int e1_init(struct mgcp_trunk *trunk, uint8_t ts_nr)
+static int e1_open(struct mgcp_trunk *trunk, uint8_t ts_nr)
 {
-	/*! Each timeslot needs only to be configured once. The Timeslot then
-	 *  stays open and permanently receives data. It is then up to the
-	 *  I.460 demultiplexer to add/remove subchannels as needed. It is
-	 *  allowed to call this function multiple times since we check if the
-	 *  timeslot is already configured. */
+	/*! One E1 timeslot may serve multiple I.460 subslots. The timeslot is opened as soon as an I.460 subslot is
+	 *  opened and will stay open until the last I.460 subslot is closed (see e1_close below). This function must
+	 *  be called any time a new I.460 subslot is opened in order to maintain constancy of the ts_usecount counter. */
 
 	struct e1inp_line *e1_line;
 	int rc;
@@ -379,12 +377,14 @@ static int e1_init(struct mgcp_trunk *trunk, uint8_t ts_nr)
 	OSMO_ASSERT(ts_nr > 0 || ts_nr < NUM_E1_TS);
 	cfg = trunk->cfg;
 
-	if (trunk->e1.ts_in_use[ts_nr - 1]) {
-		LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u already set up, skipping...\n", ts_nr);
+	if (trunk->e1.ts_usecount[ts_nr - 1] > 0) {
+		LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u already set up and in use by %u subslot(s), using it as it is...\n",
+			  ts_nr, trunk->e1.ts_usecount[ts_nr - 1]);
+		trunk->e1.ts_usecount[ts_nr - 1]++;
 		return 0;
 	}
 
-	/* Get E1 line */
+	/* Find E1 line */
 	e1_line = e1inp_line_find(trunk->e1.vty_line_nr);
 	if (!e1_line) {
 		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "no such E1 line %u - check VTY config!\n",
@@ -401,12 +401,61 @@ static int e1_init(struct mgcp_trunk *trunk, uint8_t ts_nr)
 	}
 	rc = e1inp_line_update(e1_line);
 	if (rc < 0) {
-		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "failed to update E1 timeslot %u.\n", ts_nr);
+		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "failed to update E1 line %u.\n", ts_nr);
 		return -EINVAL;
 	}
 
 	LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u set up successfully.\n", ts_nr);
-	trunk->e1.ts_in_use[ts_nr - 1] = true;
+	trunk->e1.ts_usecount[ts_nr - 1]++;
+	OSMO_ASSERT(trunk->e1.ts_usecount[ts_nr - 1] == 1);
+
+	return 0;
+}
+
+static int e1_close(struct mgcp_trunk *trunk, uint8_t ts_nr)
+{
+	/* See also comment above (e1_open). This function must be called any time an I.460 subslot is closed */
+
+	struct e1inp_line *e1_line;
+	int rc;
+
+	OSMO_ASSERT(ts_nr > 0 || ts_nr < NUM_E1_TS);
+	cfg = trunk->cfg;
+
+	if (trunk->e1.ts_usecount[ts_nr - 1] > 1) {
+		trunk->e1.ts_usecount[ts_nr - 1]--;
+		LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u still in use by %u other subslot(s), leaving it open...\n",
+			  ts_nr, trunk->e1.ts_usecount[ts_nr - 1]);
+		return 0;
+	} else if (trunk->e1.ts_usecount[ts_nr - 1] == 0) {
+		/* This should not be as it means we close the timeslot too often. */
+		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "E1 timeslot %u already closed, leaving it as it is...\n", ts_nr);
+		return -EINVAL;
+	}
+
+	/* Find E1 line */
+	e1_line = e1inp_line_find(trunk->e1.vty_line_nr);
+	if (!e1_line) {
+		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "no such E1 line %u - check VTY config!\n",
+			  trunk->e1.vty_line_nr);
+		return -EINVAL;
+	}
+
+	/* Release E1 timeslot */
+	rc = e1inp_ts_config_none(&e1_line->ts[ts_nr - 1], e1_line);
+	if (rc < 0) {
+		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "failed to disable E1 timeslot %u.\n", ts_nr);
+		return -EINVAL;
+	}
+	rc = e1inp_line_update(e1_line);
+	if (rc < 0) {
+		LOGPTRUNK(trunk, DE1, LOGL_ERROR, "failed to update E1 line %u.\n", trunk->e1.vty_line_nr);
+		return -EINVAL;
+	}
+
+	LOGPTRUNK(trunk, DE1, LOGL_INFO, "E1 timeslot %u closed.\n", ts_nr);
+	trunk->e1.ts_usecount[ts_nr - 1]--;
+	OSMO_ASSERT(trunk->e1.ts_usecount[ts_nr - 1] == 0);
 
 	return 0;
 }
@@ -496,7 +545,7 @@ static bool tf_type_is_amr(enum osmo_trau_frame_type ft)
 	}
 }
 
-/*! Equip E1 endpoint with I.460 mux resources.
+/*! Equip E1 endpoint with I.460 mux and E1 timeslot resources.
  *  \param[in] endp endpoint to equip
  *  \param[in] ts E1 timeslot number.
  *  \param[in] ss E1 subslot number.
@@ -517,7 +566,7 @@ int mgcp_e1_endp_equip(struct mgcp_endpoint *endp, uint8_t ts, uint8_t ss, uint8
 	endp->e1.last_amr_ft = AMR_4_75;
 
 	/* Set up E1 line / timeslot */
-	rc = e1_init(endp->trunk, ts);
+	rc = e1_open(endp->trunk, ts);
 	if (rc != 0)
 		return -EINVAL;
 
@@ -604,9 +653,15 @@ void mgcp_e1_endp_update(struct mgcp_endpoint *endp)
 }
 
 /*! Remove E1 resources from endpoint
- *  \param[in] endp endpoint to release. */
-void mgcp_e1_endp_release(struct mgcp_endpoint *endp)
+ *  \param[in] endp endpoint to release.
+ *  \param[in] ts E1 timeslot number. */
+void mgcp_e1_endp_release(struct mgcp_endpoint *endp, uint8_t ts)
 {
+	/* Guard against multiple calls. In case we don't see a subchannel anymore we can safely assume that all work
+	 * is done. */
+	if (!(endp->e1.schan || endp->e1.trau_rtp_st || endp->e1.trau_sync_fi))
+		return;
+
 	LOGPENDP(endp, DE1, LOGL_DEBUG, "removing I.460 subchannel and sync...\n");
 
 	if (endp->e1.schan)
@@ -615,8 +670,10 @@ void mgcp_e1_endp_release(struct mgcp_endpoint *endp)
 		talloc_free(endp->e1.trau_rtp_st);
 	if (endp->e1.trau_sync_fi)
 		osmo_fsm_inst_term(endp->e1.trau_sync_fi, OSMO_FSM_TERM_REGULAR, NULL);
-
 	memset(&endp->e1, 0, sizeof(endp->e1));
+
+	/* Close E1 timeslot */
+	e1_close(endp->trunk, ts);
 }
 
 /*! Accept RTP message buffer with RTP data and enqueue voice data for E1 transmit.

src/libosmo-mgcp/mgcp_endp.c

@@ -38,7 +38,6 @@
 const struct mgcp_endpoint_typeset ep_typeset = {
 	/* Specify endpoint properties for RTP endpoint */
 	.rtp = {
-		.max_conns = 2,
 		.dispatch_rtp_cb = mgcp_dispatch_rtp_bridge_cb,
 		.cleanup_cb = mgcp_cleanup_rtp_bridge_cb,
 	},
@@ -110,36 +109,6 @@ struct mgcp_endpoint *mgcp_endp_alloc(struct mgcp_trunk *trunk,
 	return endp;
 }
 
-/*! release endpoint, all open connections are closed.
- *  \param[in] endp endpoint to release */
-void mgcp_endp_release(struct mgcp_endpoint *endp)
-{
-	LOGPENDP(endp, DLMGCP, LOGL_DEBUG, "Releasing endpoint\n");
-
-	/* Normally this function should only be called when
-	 * all connections have been removed already. In case
-	 * that there are still connections open (e.g. when
-	 * RSIP is executed), free them all at once. */
-	mgcp_conn_free_all(endp);
-
-	/* We must only decrement the stat item when the endpoint as actually
-	 * claimed. An endpoint is claimed when a call-id is set */
-	if (endp->callid)
-		osmo_stat_item_dec(osmo_stat_item_group_get_item(endp->trunk->stats.common,
-								 TRUNK_STAT_ENDPOINTS_USED), 1);
-
-	/* Reset endpoint parameters and states */
-	talloc_free(endp->callid);
-	endp->callid = NULL;
-	talloc_free(endp->local_options.string);
-	endp->local_options.string = NULL;
-	talloc_free(endp->local_options.codec);
-	endp->local_options.codec = NULL;
-
-	if (endp->trunk->trunk_type == MGCP_TRUNK_E1)
-		mgcp_e1_endp_release(endp);
-}
-
 /* Check if the endpoint name contains the prefix (e.g. "rtpbridge/" or
  * "ds/e1-") and write the epname without the prefix back to the memory
  * pointed at by epname. (per trunk the prefix is the same for all endpoints,
@@ -187,7 +156,6 @@ static void chop_epname_suffix(char *epname, const struct mgcp_trunk *trunk)
 	}
 }
 
-
  /*! Convert all characters in epname to lowercase and strip trunk prefix and
  * endpoint name suffix (domain name) from epname. The result is written to
  * to the memory pointed at by epname_stripped. The expected size of the
@@ -260,6 +228,17 @@ bool mgcp_endp_is_wildcarded(const char *epname)
 	return false;
 }
 
+/*! Check if the given epname refers to a "null" endpoint.
+ *  \param[in] epname endpoint name to check
+ *  \returns true if epname refers to "null"" endpoint, else false. */
+bool mgcp_endp_is_null(const char *epname)
+{
+	if (strncasecmp(epname, "null@", 5) == 0)
+		return true;
+
+	return false;
+}
+
 /*! Find an endpoint by its name on a specified trunk.
  *  \param[out] cause pointer to store cause code, can be NULL.
  *  \param[in] epname endpoint name to lookup.
@@ -675,3 +654,36 @@ void mgcp_endp_remove_conn(struct mgcp_endpoint *endp, struct mgcp_conn *conn)
 	if (llist_empty(&endp->conns))
 		mgcp_endp_release(endp);
 }
+
+/*! release endpoint, all open connections are closed.
+ *  \param[in] endp endpoint to release */
+void mgcp_endp_release(struct mgcp_endpoint *endp)
+{
+	LOGPENDP(endp, DLMGCP, LOGL_DEBUG, "Releasing endpoint\n");
+
+	/* Normally this function should only be called when
+	 * all connections have been removed already. In case
+	 * that there are still connections open (e.g. when
+	 * RSIP is executed), free them all at once. */
+	mgcp_conn_free_all(endp);
+
+	/* We must only decrement the stat item when the endpoint as actually
+	 * claimed. An endpoint is claimed when a call-id is set */
+	if (endp->callid)
+		osmo_stat_item_dec(osmo_stat_item_group_get_item(endp->trunk->stats.common,
+								 TRUNK_STAT_ENDPOINTS_USED), 1);
+
+	/* Reset endpoint parameters and states */
+	talloc_free(endp->callid);
+	endp->callid = NULL;
+	talloc_free(endp->local_options.string);
+	endp->local_options.string = NULL;
+	talloc_free(endp->local_options.codec);
+	endp->local_options.codec = NULL;
+
+	if (endp->trunk->trunk_type == MGCP_TRUNK_E1) {
+		uint8_t ts = e1_ts_nr_from_epname(endp->name);
+		mgcp_e1_endp_release(endp, ts);
+	}
+}
+

src/libosmo-mgcp/mgcp_msg.c

@@ -75,7 +75,7 @@ void mgcp_disp_msg(unsigned char *message, unsigned int len, char *preamble)
 }
 
 /*! Parse connection mode.
- *  \param[in] mode as string (recvonly, sendrecv, sendonly or loopback)
+ *  \param[in] mode as string (recvonly, sendrecv, sendonly confecho or loopback)
  *  \param[in] endp pointer to endpoint (only used for log output)
  *  \param[out] associated connection to be modified accordingly
  *  \returns 0 on success, -1 on error */
@@ -100,6 +100,8 @@ int mgcp_parse_conn_mode(const char *mode, struct mgcp_endpoint *endp,
 		conn->mode = MGCP_CONN_RECV_SEND;
 	else if (strcasecmp(mode, "sendonly") == 0)
 		conn->mode = MGCP_CONN_SEND_ONLY;
+	else if (strcasecmp(mode, "confecho") == 0)
+		conn->mode = MGCP_CONN_CONFECHO;
 	else if (strcasecmp(mode, "loopback") == 0)
 		conn->mode = MGCP_CONN_LOOPBACK;
 	else {

src/libosmo-mgcp/mgcp_network.c

@@ -492,28 +492,24 @@ void mgcp_rtp_annex_count(const struct mgcp_endpoint *endp,
 
 /* There may be different payload type numbers negotiated for two connections.
  * 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, struct msgb *msg)
+ * of the codec that is set for the destination connection (conn_dst) */
+static int mgcp_patch_pt(struct mgcp_conn_rtp *conn_dst, struct msgb *msg)
 {
 	struct rtp_hdr *rtp_hdr;
-	uint8_t pt_in;
-	int pt_out;
 
 	if (msgb_length(msg) < sizeof(struct rtp_hdr)) {
-		LOG_CONN_RTP(conn_src, LOGL_ERROR, "RTP packet too short (%u < %zu)\n",
+		LOG_CONN_RTP(conn_dst, LOGL_NOTICE, "RTP packet too short (%u < %zu)\n",
 			     msgb_length(msg), sizeof(struct rtp_hdr));
 		return -EINVAL;
 	}
-
 	rtp_hdr = (struct rtp_hdr *)msgb_data(msg);
 
-	pt_in = rtp_hdr->payload_type;
-	pt_out = mgcp_codec_pt_translate(conn_src, conn_dst, pt_in);
-	if (pt_out < 0)
+	if (!conn_dst->end.codec) {
+		LOG_CONN_RTP(conn_dst, LOGL_NOTICE, "no codec set on destination connection!\n");
 		return -EINVAL;
+	}
+	rtp_hdr->payload_type = (uint8_t) conn_dst->end.codec->payload_type;
 
-	rtp_hdr->payload_type = (uint8_t) pt_out;
 	return 0;
 }
 
@@ -1134,12 +1130,11 @@ failed:
 /*! Send RTP/RTCP data to a specified destination connection.
  *  \param[in] endp associated endpoint (for configuration, logging).
  *  \param[in] is_rtp flag to specify if the packet is of type RTP or RTCP.
- *  \param[in] spoofed source address (set to NULL to disable).
- *  \param[in] buf buffer that contains the RTP/RTCP data.
- *  \param[in] len length of the buffer that contains the RTP/RTCP data.
+ *  \param[in] addr spoofed source address (set to NULL to disable).
+ *  \param[in] msg message buffer that contains the RTP/RTCP data.
  *  \param[in] conn_src associated source connection.
  *  \param[in] conn_dst associated destination connection.
- *  \returns 0 on success, -1 on ERROR. */
+ *  \returns 0 on success, negative on ERROR. */
 int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr,
 	      struct msgb *msg, struct mgcp_conn_rtp *conn_src,
 	      struct mgcp_conn_rtp *conn_dst)
@@ -1169,18 +1164,9 @@ int mgcp_send(struct mgcp_endpoint *endp, int is_rtp, struct osmo_sockaddr *addr
 	 * IuUP -> AMR: calls this function, skip patching if conn_src is IuUP.
 	 * {AMR or IuUP} -> IuUP: calls mgcp_udp_send() directly, skipping this function: No need to examine dst. */
 	if (is_rtp && !mgcp_conn_rtp_is_iuup(conn_src)) {
-		rc = mgcp_patch_pt(conn_src, conn_dst, msg);
-		if (rc < 0) {
-			/* FIXME: It is legal that the payload type on the egress connection is
-			 * different from the payload type that has been negotiated on the
-			 * ingress connection. Essentially the codecs are the same so we can
-			 * match them and patch the payload type. However, if we can not find
-			 * the codec pendant (everything ist equal except the PT), we are of
-			 * course unable to patch the payload type. A situation like this
-			 * should not occur if transcoding is consequently avoided. Until
-			 * we have transcoding support in osmo-mgw we can not resolve this. */
-			LOGPENDP(endp, DRTP, LOGL_DEBUG,
-				 "can not patch PT because no suitable egress codec was found.\n");
+		if (mgcp_patch_pt(conn_dst, msg) < 0) {
+			LOGPENDP(endp, DRTP, LOGL_NOTICE, "unable to patch payload type RTP packet, discarding...\n");
+			return -EINVAL;
 		}
 	}
 
@@ -1304,8 +1290,10 @@ int mgcp_dispatch_rtp_bridge_cb(struct msgb *msg)
 	struct mgcp_conn_rtp *conn_src = mc->conn_src;
 	struct mgcp_conn *conn = conn_src->conn;
 	struct mgcp_conn *conn_dst;
+	struct mgcp_endpoint *endp = conn->endp;
 	struct osmo_sockaddr *from_addr = mc->from_addr;
 	char ipbuf[INET6_ADDRSTRLEN];
+	int rc = 0;
 
 	/*! NOTE: This callback function implements the endpoint specific
 	 *  dispatch behaviour of an rtp bridge/proxy endpoint. It is assumed
@@ -1337,36 +1325,26 @@ int mgcp_dispatch_rtp_bridge_cb(struct msgb *msg)
 		return mgcp_conn_rtp_dispatch_rtp(conn_src, msg);
 	}
 
-	/* Find a destination connection. */
-	/* NOTE: This code path runs every time an RTP packet is received. The
-	 * function mgcp_find_dst_conn() we use to determine the detination
-	 * connection will iterate the connection list inside the endpoint.
-	 * Since list iterations are quite costly, we will figure out the
-	 * destination only once and use the optional private data pointer of
-	 * the connection to cache the destination connection pointer. */
-	if (!conn->priv) {
-		conn_dst = mgcp_find_dst_conn(conn);
-		conn->priv = conn_dst;
-	} else {
-		conn_dst = (struct mgcp_conn *)conn->priv;
-	}
+	/* If the mode does not allow receiving RTP, we are done. */
+	if (conn->mode != MGCP_CONN_RECV_ONLY &&
+	    conn->mode != MGCP_CONN_RECV_SEND &&
+	    conn->mode != MGCP_CONN_CONFECHO)
+		return rc;
 
-	/* There is no destination conn, stop here */
-	if (!conn_dst) {
-		LOGPCONN(conn, DRTP, LOGL_DEBUG,
-			 "no connection to forward an incoming RTP packet to\n");
-		return -1;
-	}
+	/* If the mode is "confecho", send RTP back to the sender. */
+	if (conn->mode == MGCP_CONN_CONFECHO)
+		rc = mgcp_conn_rtp_dispatch_rtp(conn_src, msg);
 
-	/* The destination conn is not an RTP connection */
-	if (conn_dst->type != MGCP_CONN_TYPE_RTP) {
-		LOGPCONN(conn, DRTP, LOGL_ERROR,
-			 "unable to find suitable destination conn\n");
-		return -1;
+	/* Dispatch RTP packet to all other connection(s) that send audio. */
+	llist_for_each_entry(conn_dst, &endp->conns, entry) {
+		if (conn_dst == conn)
+			continue;
+		if (conn_dst->mode == MGCP_CONN_SEND_ONLY ||
+		    conn_dst->mode == MGCP_CONN_RECV_SEND ||
+		    conn_dst->mode == MGCP_CONN_CONFECHO)
+		rc = mgcp_conn_rtp_dispatch_rtp(&conn_dst->u.rtp, msg);
 	}
-
-	/* Dispatch RTP packet to destination RTP connection */
-	return mgcp_conn_rtp_dispatch_rtp(&conn_dst->u.rtp, msg);
+	return rc;
 }
 
 /*! dispatch incoming RTP packet to E1 subslot, handle RTCP packets locally.
@@ -1676,14 +1654,14 @@ int mgcp_bind_net_rtp_port(struct mgcp_endpoint *endp, int rtp_port,
 void mgcp_free_rtp_port(struct mgcp_rtp_end *end)
 {
 	if (end->rtp.fd != -1) {
+		osmo_fd_unregister(&end->rtp);
 		close(end->rtp.fd);
 		end->rtp.fd = -1;
-		osmo_fd_unregister(&end->rtp);
 	}
 
 	if (end->rtcp.fd != -1) {
+		osmo_fd_unregister(&end->rtcp);
 		close(end->rtcp.fd);
 		end->rtcp.fd = -1;
-		osmo_fd_unregister(&end->rtcp);
 	}
 }

src/libosmo-mgcp/mgcp_protocol.c

@@ -86,6 +86,9 @@ struct mgcp_request_data {
 	/* set to true when the request has been classified as wildcarded */
 	bool wildcarded;
 
+	/* Set to true when the request is targeted at the "null" endpoint */
+	bool null_endp;
+
 	/* contains cause code in case of problems during endp/trunk resolution */
 	int mgcp_cause;
 };
@@ -390,6 +393,9 @@ struct msgb *mgcp_handle_message(struct mgcp_config *cfg, struct msgb *msg)
 	/* Locate endpoint and trunk, if no endpoint can be located try at least to identify the trunk. */
 	rq.pdata = &pdata;
 	rq.wildcarded = mgcp_endp_is_wildcarded(pdata.epname);
+	if (!rq.wildcarded)
+		rq.null_endp = mgcp_endp_is_null(pdata.epname);
+	if (!rq.null_endp)
 		rq.endp = mgcp_endp_by_name(&rc, pdata.epname, pdata.cfg);
 	rq.mgcp_cause = rc;
 	if (!rq.endp) {
@@ -407,14 +413,14 @@ struct msgb *mgcp_handle_message(struct mgcp_config *cfg, struct msgb *msg)
 				     rq.name, pdata.epname);
 				return create_err_response(cfg, NULL, -rq.mgcp_cause, rq.name, pdata.trans);
 			}
-		} else {
+		} else if (!rq.null_endp) {
 			/* If the endpoint name suggests that the request refers to a specific endpoint, then the
 			 * request cannot be handled and we must stop early. */
 			LOGP(DLMGCP, LOGL_NOTICE,
 			     "%s: cannot find endpoint \"%s\", cause=%d -- abort\n", rq.name,
 			     pdata.epname, -rq.mgcp_cause);
 			return create_err_response(cfg, NULL, -rq.mgcp_cause, rq.name, pdata.trans);
-		}
+		} /* else: Handle special "null" endpoint below (with rq.endp=NULL, rq.trunk=NULL) */
 	} else {
 		osmo_strlcpy(debug_last_endpoint_name, rq.endp->name, sizeof(debug_last_endpoint_name));
 		rq.trunk = rq.endp->trunk;
@@ -460,6 +466,11 @@ struct msgb *mgcp_handle_message(struct mgcp_config *cfg, struct msgb *msg)
 static struct msgb *handle_audit_endpoint(struct mgcp_request_data *rq)
 {
 	LOGPENDP(rq->endp, DLMGCP, LOGL_NOTICE, "AUEP: auditing endpoint ...\n");
+
+	/* Auditing "null" endpoint is allowed for keepalive purposes. There's no rq->endp nor rq->trunk in this case. */
+	if (rq->null_endp)
+		return create_ok_response(rq->pdata->cfg, NULL, 200, "AUEP", rq->pdata->trans);
+
 	if (!rq->endp || !mgcp_endp_avail(rq->endp)) {
 		LOGPENDP(rq->endp, DLMGCP, LOGL_ERROR, "AUEP: selected endpoint not available!\n");
 		return create_err_response(rq->trunk, NULL, 501, "AUEP", rq->pdata->trans);
@@ -661,8 +672,8 @@ static int set_local_cx_options(void *ctx, struct mgcp_lco *lco,
 		case 'a':
 			/* FIXME: LCO also supports the negotiation of more than one codec.
 			 * (e.g. a:PCMU;G726-32) But this implementation only supports a single
-			 * codec only. */
-			if (sscanf(lco_id + 1, ":%16[^,]", codec) == 1) {
+			 * codec only. Ignoring all but the first codec. */
+			if (sscanf(lco_id + 1, ":%16[^,;]", codec) == 1) {
 				talloc_free(lco->codec);
 				/* MGCP header is case insensive, and we'll need
 				   codec in uppercase when using it later: */
@@ -761,6 +772,9 @@ static int handle_codec_info(struct mgcp_conn_rtp *conn,
 			     struct mgcp_request_data *rq, int have_sdp, bool crcx)
 {
 	struct mgcp_endpoint *endp = rq->endp;
+	struct mgcp_conn *conn_dst;
+	struct mgcp_conn_rtp *conn_dst_rtp;
+
 	int rc;
 	char *cmd;
 
@@ -802,8 +816,15 @@ static int handle_codec_info(struct mgcp_conn_rtp *conn,
 			goto error;
 	}
 
+	/* Try to find an destination RTP connection that we can include in the codec decision. */
+	conn_dst = mgcp_find_dst_conn(conn->conn);
+	if (conn_dst && conn_dst->type == MGCP_CONN_TYPE_RTP)
+		conn_dst_rtp = &conn_dst->u.rtp;
+	else
+		conn_dst_rtp = NULL;
+
 	/* Make codec decision */
-	if (mgcp_codec_decide(conn) != 0)
+	if (mgcp_codec_decide(conn, conn_dst_rtp) != 0)
 		goto error;
 
 	return 0;
@@ -845,7 +866,7 @@ static struct msgb *handle_create_con(struct mgcp_request_data *rq)
 	struct mgcp_parse_data *pdata = rq->pdata;
 	struct mgcp_trunk *trunk = rq->trunk;
 	struct mgcp_endpoint *endp = rq->endp;
-	struct rate_ctr_group *rate_ctrs = trunk->ratectr.mgcp_crcx_ctr_group;
+	struct rate_ctr_group *rate_ctrs;
 	int error_code = 400;
 	const char *local_options = NULL;
 	const char *callid = NULL;
@@ -859,6 +880,14 @@ static struct msgb *handle_create_con(struct mgcp_request_data *rq)
 
 	LOGPENDP(endp, DLMGCP, LOGL_NOTICE, "CRCX: creating new connection ...\n");
 
+	if (rq->null_endp) {
+		/* trunk not available so rate_ctr aren't available either. */
+		LOGP(DLMGCP, LOGL_ERROR, "CRCX: Not allowed in 'null' endpoint!\n");
+		return create_err_response(pdata->cfg, NULL, 502, "CRCX", pdata->trans);
+	}
+
+	rate_ctrs = trunk->ratectr.mgcp_crcx_ctr_group;
+
 	/* we must have a free ep */
 	if (!endp) {
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_CRCX_FAIL_AVAIL));
@@ -938,7 +967,7 @@ mgcp_header_done:
 	}
 
 	/* Check if we are able to accept the creation of another connection */
-	if (llist_count(&endp->conns) >= endp->type->max_conns) {
+	if (endp->type->max_conns && llist_count(&endp->conns) >= endp->type->max_conns) {
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
 			"CRCX: endpoint full, max. %i connections allowed!\n",
 			endp->type->max_conns);
@@ -1124,7 +1153,7 @@ static struct msgb *handle_modify_con(struct mgcp_request_data *rq)
 	struct mgcp_parse_data *pdata = rq->pdata;
 	struct mgcp_trunk *trunk = rq->trunk;
 	struct mgcp_endpoint *endp = rq->endp;
-	struct rate_ctr_group *rate_ctrs = trunk->ratectr.mgcp_mdcx_ctr_group;
+	struct rate_ctr_group *rate_ctrs;
 	char new_local_addr[INET6_ADDRSTRLEN];
 	int error_code = 500;
 	int silent = 0;
@@ -1139,6 +1168,14 @@ static struct msgb *handle_modify_con(struct mgcp_request_data *rq)
 
 	LOGPENDP(endp, DLMGCP, LOGL_NOTICE, "MDCX: modifying existing connection ...\n");
 
+	if (rq->null_endp) {
+		/* trunk not available so rate_ctr aren't available either. */
+		LOGP(DLMGCP, LOGL_ERROR, "MDCX: Not allowed in 'null' endpoint!\n");
+		return create_err_response(pdata->cfg, NULL, 502, "MDCX", pdata->trans);
+	}
+
+	rate_ctrs = trunk->ratectr.mgcp_mdcx_ctr_group;
+
 	/* Prohibit wildcarded requests */
 	if (rq->wildcarded) {
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
@@ -1350,7 +1387,7 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 	struct mgcp_parse_data *pdata = rq->pdata;
 	struct mgcp_trunk *trunk = rq->trunk;
 	struct mgcp_endpoint *endp = rq->endp;
-	struct rate_ctr_group *rate_ctrs = trunk->ratectr.mgcp_dlcx_ctr_group;
+	struct rate_ctr_group *rate_ctrs;
 	int error_code = 400;
 	int silent = 0;
 	char *line;
@@ -1360,10 +1397,18 @@ static struct msgb *handle_delete_con(struct mgcp_request_data *rq)
 	unsigned int i;
 
 	/* NOTE: In this handler we can not take it for granted that the endp
-	 * pointer will be populated, however a trunk is always guaranteed. */
+	 * pointer will be populated, however a trunk is always guaranteed (except for 'null' endp).
+	 */
 
 	LOGPEPTR(endp, trunk, DLMGCP, LOGL_NOTICE, "DLCX: deleting connection(s) ...\n");
 
+	if (rq->null_endp) {
+		/* trunk not available so rate_ctr aren't available either. */
+		LOGP(DLMGCP, LOGL_ERROR, "DLCX: Not allowed in 'null' endpoint!\n");
+		return create_err_response(pdata->cfg, NULL, 502, "DLCX", pdata->trans);
+	}
+
+	rate_ctrs = trunk->ratectr.mgcp_dlcx_ctr_group;
 	if (endp && !mgcp_endp_avail(endp)) {
 		rate_ctr_inc(rate_ctr_group_get_ctr(rate_ctrs, MGCP_DLCX_FAIL_AVAIL));
 		LOGPENDP(endp, DLMGCP, LOGL_ERROR,
@@ -1514,6 +1559,12 @@ static struct msgb *handle_rsip(struct mgcp_request_data *rq)
 
 	LOGP(DLMGCP, LOGL_NOTICE, "RSIP: resetting all endpoints ...\n");
 
+	if (rq->null_endp) {
+		/* trunk not available so rate_ctr aren't available either. */
+		LOGP(DLMGCP, LOGL_ERROR, "RSIP: Not allowed in 'null' endpoint!\n");
+		return create_err_response(rq->pdata->cfg, NULL, 502, "RSIP", rq->pdata->trans);
+	}
+
 	if (rq->pdata->cfg->reset_cb)
 		rq->pdata->cfg->reset_cb(rq->endp->trunk);
 	return NULL;
@@ -1539,6 +1590,12 @@ static struct msgb *handle_noti_req(struct mgcp_request_data *rq)
 
 	LOGP(DLMGCP, LOGL_NOTICE, "RQNT: processing request for notification ...\n");
 
+	if (rq->null_endp) {
+		/* trunk not available so rate_ctr aren't available either. */
+		LOGP(DLMGCP, LOGL_ERROR, "RQNT: Not allowed in 'null' endpoint!\n");
+		return create_err_response(rq->pdata->cfg, NULL, 502, "RQNT", rq->pdata->trans);
+	}
+
 	for_each_line(line, rq->pdata->save) {
 		switch (toupper(line[0])) {
 		case 'S':

src/libosmo-mgcp/mgcp_sdp.c

@@ -239,13 +239,12 @@ static int fmtp_from_sdp(void *ctx, struct sdp_fmtp_param *fmtp_param, char *sdp
 		if (delimiter == ';' || delimiter == ',')
 			str_ptr[strlen(str_ptr) - 1] = '\0';
 
-		/* AMR octet aligned parameter */
+		/* AMR octet aligned parameter (see also RFC 3267, section 8.3) */
 		if (sscanf(param_str, "octet-align=%d", &amr_octet_aligned) == 1) {
 			fmtp_param->param.amr_octet_aligned_present = true;
 			fmtp_param->param.amr_octet_aligned = false;
 			if (amr_octet_aligned == 1)
 				fmtp_param->param.amr_octet_aligned = true;
-
 		}
 
 		param_str = strtok(NULL, " ");

src/libosmo-mgcp/mgcp_vty.c

@@ -120,8 +120,6 @@ static int config_write_mgcp(struct vty *vty)
 		trunk->audio_send_name ? "" : "no ", VTY_NEWLINE);
 	vty_out(vty, " number endpoints %u%s",
 		trunk->v.vty_number_endpoints, VTY_NEWLINE);
-	vty_out(vty, " %sallow-transcoding%s",
-		trunk->no_audio_transcoding ? "no " : "", VTY_NEWLINE);
 	if (strlen(g_cfg->call_agent_addr))
 		vty_out(vty, " call-agent ip %s%s", g_cfg->call_agent_addr,
 			VTY_NEWLINE);
@@ -513,6 +511,7 @@ DEFUN_DEPRECATED(cfg_mgcp_bind_early,
 		 BIND_STR
 		 "Bind local ports on start up\n" "Bind on demand\n" "Bind on startup\n")
 {
+	vty_out(vty, "%% Deprecated 'bind early (0|1)' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -700,25 +699,19 @@ DEFUN_USRATTR(cfg_mgcp_sdp_fmtp_extra,
 	return CMD_SUCCESS;
 }
 
-DEFUN_USRATTR(cfg_mgcp_allow_transcoding,
+DEFUN_DEPRECATED(cfg_mgcp_allow_transcoding,
 		  cfg_mgcp_allow_transcoding_cmd,
-	      X(MGW_CMD_ATTR_NEWCONN),
 		  "allow-transcoding", "Allow transcoding\n")
 {
-	struct mgcp_trunk *trunk = mgcp_trunk_by_num(g_cfg, MGCP_TRUNK_VIRTUAL, MGCP_VIRT_TRUNK_ID);
-	OSMO_ASSERT(trunk);
-	trunk->no_audio_transcoding = 0;
+	vty_out(vty, "%% Deprecated 'allow-transcoding' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
-DEFUN_USRATTR(cfg_mgcp_no_allow_transcoding,
+DEFUN_DEPRECATED(cfg_mgcp_no_allow_transcoding,
 		 cfg_mgcp_no_allow_transcoding_cmd,
-	      X(MGW_CMD_ATTR_NEWCONN),
 		 "no allow-transcoding", NO_STR "Allow transcoding\n")
 {
-	struct mgcp_trunk *trunk = mgcp_trunk_by_num(g_cfg, MGCP_TRUNK_VIRTUAL, MGCP_VIRT_TRUNK_ID);
-	OSMO_ASSERT(trunk);
-	trunk->no_audio_transcoding = 1;
+	vty_out(vty, "%% Deprecated 'no allow-transcoding' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -729,6 +722,7 @@ DEFUN_DEPRECATED(cfg_mgcp_sdp_payload_number,
       "sdp audio-payload number <0-255>",
       SDP_STR AUDIO_STR "Number\n" "Payload number\n")
 {
+	vty_out(vty, "%% Deprecated 'sdp audio-payload number <0-255>' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -742,6 +736,7 @@ DEFUN_DEPRECATED(cfg_mgcp_sdp_payload_name,
       "sdp audio-payload name NAME",
       SDP_STR AUDIO_STR "Name\n" "Payload name\n")
 {
+	vty_out(vty, "%% Deprecated 'sdp audio-payload name NAME' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -802,6 +797,7 @@ DEFUN_DEPRECATED(cfg_mgcp_loop,
 		 "loop (0|1)",
 		 "Loop audio for all endpoints on main trunk\n" "Don't Loop\n" "Loop\n")
 {
+	vty_out(vty, "%% Deprecated 'loop (0|1)' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -1069,8 +1065,6 @@ static int config_write_trunk(struct vty *vty)
 		if (trunk->audio_fmtp_extra)
 			vty_out(vty, "   sdp audio fmtp-extra %s%s",
 				trunk->audio_fmtp_extra, VTY_NEWLINE);
-		vty_out(vty, "  %sallow-transcoding%s",
-			trunk->no_audio_transcoding ? "no " : "", VTY_NEWLINE);
 	}
 
 	return CMD_SUCCESS;
@@ -1098,6 +1092,7 @@ DEFUN_DEPRECATED(cfg_trunk_payload_number,
       "sdp audio-payload number <0-255>",
       SDP_STR AUDIO_STR "Number\n" "Payload Number\n")
 {
+	vty_out(vty, "%% Deprecated 'sdp audio-payload number <0-255>' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -1110,6 +1105,7 @@ DEFUN_DEPRECATED(cfg_trunk_payload_name,
       "sdp audio-payload name NAME",
       SDP_STR AUDIO_STR "Payload\n" "Payload Name\n")
 {
+	vty_out(vty, "%% Deprecated 'sdp audio-payload name NAME' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -1122,6 +1118,7 @@ DEFUN_DEPRECATED(cfg_trunk_loop,
 		 "loop (0|1)",
 		 "Loop audio for all endpoints on this trunk\n" "Don't Loop\n" "Loop\n")
 {
+	vty_out(vty, "%% Deprecated 'loop (0|1)' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
@@ -1319,23 +1316,19 @@ DEFUN_ATTR(cfg_trunk_no_rtp_keepalive,
 	return CMD_SUCCESS;
 }
 
-DEFUN_USRATTR(cfg_trunk_allow_transcoding,
+DEFUN_DEPRECATED(cfg_trunk_allow_transcoding,
 		 cfg_trunk_allow_transcoding_cmd,
-	      X(MGW_CMD_ATTR_NEWCONN),
 		 "allow-transcoding", "Allow transcoding\n")
 {
-	struct mgcp_trunk *trunk = vty->index;
-	trunk->no_audio_transcoding = 0;
+	vty_out(vty, "%% Deprecated 'allow-transcoding' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 
-DEFUN_USRATTR(cfg_trunk_no_allow_transcoding,
+DEFUN_DEPRECATED(cfg_trunk_no_allow_transcoding,
 		 cfg_trunk_no_allow_transcoding_cmd,
-	      X(MGW_CMD_ATTR_NEWCONN),
 		 "no allow-transcoding", NO_STR "Allow transcoding\n")
 {
-	struct mgcp_trunk *trunk = vty->index;
-	trunk->no_audio_transcoding = 1;
+	vty_out(vty, "%% Deprecated 'no allow-transcoding' config no longer has any effect%s", VTY_NEWLINE);
 	return CMD_SUCCESS;
 }
 

src/osmo-mgw/mgw_main.c

@@ -360,8 +360,7 @@ int main(int argc, char **argv)
 		return rc;
 
 	/* start telnet after reading config for vty_get_bind_addr() */
-	rc = telnet_init_dynif(tall_mgw_ctx, NULL,
-			       vty_get_bind_addr(), OSMO_VTY_PORT_MGW);
+	rc = telnet_init_default(tall_mgw_ctx, NULL, OSMO_VTY_PORT_MGW);
 	if (rc < 0)
 		return rc;
 

tests/Makefile.am

@@ -34,11 +34,11 @@ DISTCLEANFILES = \
 	$(NULL)
 
 if ENABLE_EXT_TESTS
-python-tests: $(BUILT_SOURCES)
+python-tests: $(top_builddir)/src/osmo-mgw/osmo-mgw
 	osmotestvty.py -p $(abs_top_srcdir) -w $(abs_top_builddir) -v
 	osmotestconfig.py -p $(abs_top_srcdir) -w $(abs_top_builddir) -v
 else
-python-tests: $(BUILT_SOURCES)
+python-tests:
 	echo "Not running python-based tests (determined at configure-time)"
 endif
 

tests/mgcp/Makefile.am

@@ -18,6 +18,7 @@ AM_CFLAGS = \
 
 AM_LDFLAGS = \
 	$(COVERAGE_LDFLAGS) \
+	-no-install \
 	$(NULL)
 
 EXTRA_DIST = \

tests/mgcp/mgcp_test.c

@@ -77,6 +77,8 @@ static void test_strline(void)
 #define AUEP1_RET "500 158663169 FAIL\r\n"
 #define AUEP2	"AUEP 18983213 ds/e1-2/1@mgw MGCP 1.0\r\n"
 #define AUEP2_RET "500 18983213 FAIL\r\n"
+#define AUEP_NULL "AUEP 18983215 null@mgw MGCP 1.0\r\n"
+#define AUEP_NULL_RET "200 18983215 OK\r\n"
 #define EMPTY	"\r\n"
 #define EMPTY_RET NULL
 #define SHORT	"CRCX \r\n"
@@ -274,6 +276,12 @@ static void test_strline(void)
 
 #define MDCX_TOO_LONG_CI_RET "510 18983224 FAIL\r\n"
 
+#define MDCX_NULL \
+	"MDCX 9 null@mgw MGCP 1.0\r\n" \
+	"I: %s\n"
+
+#define MDCX_NULL_RET "502 9 FAIL\r\n"
+
 #define SHORT2	"CRCX 1"
 #define SHORT2_RET "510 000000 FAIL\r\n"
 #define SHORT3	"CRCX 1 1@mgw"
@@ -392,6 +400,13 @@ static void test_strline(void)
  #define DLCX_RET_OSMUX DLCX_RET \
 	"X-Osmo-CP: EC TI=0, TO=0\r\n"
 
+#define DLCX_NULL \
+	"DLCX 8 null@mgw MGCP 1.0\r\n" \
+	"I: %s\r\n" \
+	"C: 2\r\n"
+
+#define DLCX_NULL_RET "502 8 FAIL\r\n"
+
 #define RQNT \
 	"RQNT 186908780 1@mgw MGCP 1.0\r\n" \
 	"X: B244F267488\r\n" \
@@ -405,6 +420,13 @@ static void test_strline(void)
 #define RQNT1_RET "200 186908780 OK\r\n"
 #define RQNT2_RET "200 186908781 OK\r\n"
 
+#define RQNT_NULL \
+	"RQNT 186908782 null@mgw MGCP 1.0\r\n" \
+	"X: B244F267488\r\n" \
+	"S: D/9\r\n"
+
+#define RQNT_NULL_RET "502 186908782 FAIL\r\n"
+
 #define PTYPE_IGNORE 0		/* == default initializer */
 #define PTYPE_NONE 128
 #define PTYPE_NYI  PTYPE_NONE
@@ -545,6 +567,20 @@ static void test_strline(void)
 	"m=audio 16008 RTP/AVP 0\r\n" \
 	"a=ptime:20\r\n"
 
+#define CRCX_NULL \
+	"CRCX 2 null@mgw MGCP 1.0\r\n" \
+	"m: recvonly\r\n" \
+	"C: 2\r\n" \
+	"L: p:20\r\n" \
+	"\r\n" \
+	"v=0\r\n" \
+	"c=IN IP4 123.12.12.123\r\n" \
+	"m=audio 5904 RTP/AVP 97\r\n" \
+	"a=rtpmap:97 GSM-EFR/8000\r\n" \
+	"a=ptime:40\r\n"
+
+#define CRCX_NULL_RET "502 2 FAIL\r\n"
+
 struct mgcp_test {
 	const char *name;
 	const char *req;
@@ -586,6 +622,11 @@ static const struct mgcp_test tests[] = {
 	{"CRCX", CRCX_X_OSMO_IGN, CRCX_X_OSMO_IGN_RET, 97},
 	{"MDCX_TOO_LONG_CI", MDCX_TOO_LONG_CI, MDCX_TOO_LONG_CI_RET},
 	{"CRCX", CRCX_AMR_WITH_FMTP, CRCX_AMR_WITH_FMTP_RET},
+	{"AUEP_NULL", AUEP_NULL, AUEP_NULL_RET},
+	{"CRCX_NULL", CRCX_NULL, CRCX_NULL_RET},
+	{"MDCX_NULL", MDCX_NULL, MDCX_NULL_RET},
+	{"DLCX_NULL", DLCX_NULL, DLCX_NULL_RET},
+	{"RQNT_NULL", RQNT_NULL, RQNT_NULL_RET},
 };
 
 static const struct mgcp_test retransmit[] = {
@@ -1467,7 +1508,6 @@ static void test_multilple_codec(void)
 	/* Allocate 5@mgw and let osmo-mgw pick a codec from the list */
 	last_endpoint[0] = '\0';
 	inp = create_msg(CRCX_MULT_GSM_EXACT, NULL);
-	trunk->no_audio_transcoding = 1;
 	resp = mgcp_handle_message(cfg, inp);
 	OSMO_ASSERT(get_conn_id_from_response(resp->data, conn_id,
 					      sizeof(conn_id)) == 0);
@@ -1511,7 +1551,6 @@ static void test_multilple_codec(void)
 
 	last_endpoint[0] = '\0';
 	inp = create_msg(CRCX_MULT_GSM_EXACT, NULL);
-	trunk->no_audio_transcoding = 0;
 	resp = mgcp_handle_message(cfg, inp);
 	OSMO_ASSERT(get_conn_id_from_response(resp->data, conn_id,
 					      sizeof(conn_id)) == 0);
@@ -1769,26 +1808,25 @@ static const struct mgcp_codec_param amr_param_octet_aligned_unset = {
 	.amr_octet_aligned_present = false,
 };
 
-struct testcase_mgcp_codec_pt_translate_codec {
+struct testcase_mgcp_codec_decide_codec {
 	int payload_type;
 	const char *audio_name;
 	const struct mgcp_codec_param *param;
 	int expect_rc;
 };
 
-struct testcase_mgcp_codec_pt_translate_expect {
-	bool end;
+struct testcase_mgcp_codec_decide_expect {
 	int payload_type_map[2];
 };
 
-struct testcase_mgcp_codec_pt_translate {
+struct testcase_mgcp_codec_decide {
 	const char *descr;
 	/* two conns on an endpoint, each with N configured codecs */
-	struct testcase_mgcp_codec_pt_translate_codec codecs[2][10];
-	struct testcase_mgcp_codec_pt_translate_expect expect[32];
+	struct testcase_mgcp_codec_decide_codec codecs[2][10];
+	struct testcase_mgcp_codec_decide_expect expect[2];
 };
 
-static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translate_cases[] = {
+static const struct testcase_mgcp_codec_decide test_mgcp_codec_find_convertible_cases[] = {
 	{
 		.descr = "same order, but differing payload type numbers",
 		.codecs = {
@@ -1805,10 +1843,7 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 		},
 		.expect = {
 			{ .payload_type_map = {112, 96}, },
-			{ .payload_type_map = {0, 0}, },
-			{ .payload_type_map = {111, 97} },
-			{ .payload_type_map = {123, -EINVAL} },
-			{ .end = true },
+			{ .payload_type_map = {112, 96}, },
 		},
 	},
 	{
@@ -1826,11 +1861,8 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {112, 96}, },
 			{ .payload_type_map = {0, 0}, },
-			{ .payload_type_map = {111, 97} },
-			{ .payload_type_map = {123, -EINVAL} },
-			{ .end = true },
+			{ .payload_type_map = {111, 97}, },
 		},
 	},
 	{
@@ -1848,10 +1880,8 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {96, 97}, },
-			{ .payload_type_map = {97, 96}, },
 			{ .payload_type_map = {0, 0}, },
-			{ .end = true },
+			{ .payload_type_map = {96, 97}, },
 		},
 	},
 	{
@@ -1867,10 +1897,8 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {112, -EINVAL}, },
-			{ .payload_type_map = {0, -EINVAL}, },
-			{ .payload_type_map = {111, -EINVAL} },
-			{ .end = true },
+			{ .payload_type_map = {-EINVAL, -EINVAL}, },
+			{ .payload_type_map = {-EINVAL, 96}, },
 		},
 	},
 	{
@@ -1887,28 +1915,60 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 		},
 		.expect = {
 			{ .payload_type_map = {112, -EINVAL}, },
-			{ .payload_type_map = {0, -EINVAL}, },
-			{ .payload_type_map = {111, -EINVAL} },
-			{ .end = true },
+			{ .payload_type_map = {-EINVAL, -EINVAL}, },
 		},
 	},
 	{
-		.descr = "test AMR with differing octet-aligned settings",
+		.descr = "test AMR with differing octet-aligned settings (both <-> both)",
+		.codecs = {
+			{
+				{ 111, "AMR/8000", &amr_param_octet_aligned_true, },
+				{ 112, "AMR/8000", &amr_param_octet_aligned_false, },
+			},
+			{
+				{ 122, "AMR/8000", &amr_param_octet_aligned_false, },
+				{ 121, "AMR/8000", &amr_param_octet_aligned_true, },
+			},
+		},
+		.expect = {
+			{ .payload_type_map = {111, 121}, },
+			{ .payload_type_map = {112, 122} },
+		},
+	},
+	{
+		.descr = "test AMR with differing octet-aligned settings (oa <-> both)",
 		.codecs = {
 			{
 				{ 111, "AMR/8000", &amr_param_octet_aligned_true, },
 			},
 			{
 				{ 122, "AMR/8000", &amr_param_octet_aligned_false, },
+				{ 121, "AMR/8000", &amr_param_octet_aligned_true, },
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {111, 122}, },
-			{ .end = true },
+			{ .payload_type_map = {111, 121}, },
+			{ .payload_type_map = {111, 121}, },
 		},
 	},
 	{
-		.descr = "test AMR with missing octet-aligned settings (defaults to 0)",
+		.descr = "test AMR with differing octet-aligned settings (bwe <-> both)",
+		.codecs = {
+			{
+				{ 112, "AMR/8000", &amr_param_octet_aligned_false, },
+			},
+			{
+				{ 122, "AMR/8000", &amr_param_octet_aligned_false, },
+				{ 121, "AMR/8000", &amr_param_octet_aligned_true, },
+			},
+		},
+		.expect = {
+			{ .payload_type_map = {112, 122}, },
+			{ .payload_type_map = {112, 122}, },
+		},
+	},
+	{
+		.descr = "test AMR with missing octet-aligned settings (oa <-> unset)",
 		.codecs = {
 			{
 				{ 111, "AMR/8000", &amr_param_octet_aligned_true, },
@@ -1919,22 +1979,54 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 		},
 		.expect = {
 			{ .payload_type_map = {111, 122}, },
-			{ .end = true },
+			{ .payload_type_map = {111, 122}, },
 		},
 	},
 	{
-		.descr = "test AMR with NULL param (defaults to 0)",
+		.descr = "test AMR with missing octet-aligned settings (bwe <-> unset)",
 		.codecs = {
 			{
-				{ 111, "AMR/8000", &amr_param_octet_aligned_true, },
+				{ 111, "AMR/8000", &amr_param_octet_aligned_false, },
+			},
+			{
+				{ 122, "AMR/8000", &amr_param_octet_aligned_unset, },
+			},
+		},
+		.expect = {
+			{ .payload_type_map = {111, 122}, },
+			{ .payload_type_map = {111, 122}, },
+		},
+	},
+	{
+		.descr = "test AMR with NULL param (oa <-> null)",
+		.codecs = {
+			{
+				{ 112, "AMR/8000", &amr_param_octet_aligned_true, },
 			},
 			{
 				{ 122, "AMR/8000", NULL, },
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {111, 122}, },
-			{ .end = true },
+			/* Note: Both 111, anbd 112 will translate to 122. The translation from 112 */
+			{ .payload_type_map = {112, 122} },
+			{ .payload_type_map = {112, 122}, },
+		},
+	},
+	{
+		.descr = "test AMR with NULL param (bwe <-> null)",
+		.codecs = {
+			{
+				{ 112, "AMR/8000", &amr_param_octet_aligned_false, },
+			},
+			{
+				{ 122, "AMR/8000", NULL, },
+			},
+		},
+		.expect = {
+			/* Note: Both 111, anbd 112 will translate to 122. The translation from 112 */
+			{ .payload_type_map = {112, 122} },
+			{ .payload_type_map = {112, 122}, },
 		},
 	},
 	{
@@ -1952,11 +2044,8 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {112, 96}, },
 			{ .payload_type_map = {0, 0}, },
-			{ .payload_type_map = {111, 97} },
-			{ .payload_type_map = {123, -EINVAL} },
-			{ .end = true },
+			{ .payload_type_map = {111, 97}, },
 		},
 	},
 	{
@@ -1974,11 +2063,8 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 			},
 		},
 		.expect = {
-			{ .payload_type_map = {112, 96}, },
 			{ .payload_type_map = {0, 0}, },
-			{ .payload_type_map = {111, 97} },
-			{ .payload_type_map = {123, -EINVAL} },
-			{ .end = true },
+			{ .payload_type_map = {111, 97}, },
 		},
 	},
 	{
@@ -1996,45 +2082,97 @@ static const struct testcase_mgcp_codec_pt_translate test_mgcp_codec_pt_translat
 		},
 		.expect = {
 			{ .payload_type_map = {111, 121}, },
-			{ .payload_type_map = {112, -EINVAL} },
-			{ .payload_type_map = {113, -EINVAL} },
-			{ .end = true },
+			{ .payload_type_map = {111, 121} },
 		},
 	},
 };
 
-static void test_mgcp_codec_pt_translate(void)
+static bool codec_decision(struct mgcp_conn_rtp *conn, unsigned int index_conn_src, unsigned int index_conn_dst,
+			   const struct testcase_mgcp_codec_decide_expect *expect)
+{
+	bool ok = true;
+	int payload_type_conn_src;
+	int payload_type_conn_dst;
+
+	printf(" - mgcp_codec_decide(&conn[%u], &conn[%u]):\n", index_conn_src, index_conn_dst);
+	if (mgcp_codec_decide(&conn[index_conn_src], &conn[index_conn_dst]) != 0) {
+		if (expect->payload_type_map[index_conn_src] == -EINVAL
+		    && expect->payload_type_map[index_conn_dst] == -EINVAL)
+			printf("    codec decision failed (expected)!\n");
+		else {
+			printf("    ERROR: codec decision failed!\n");
+			ok = false;
+		}
+	} else {
+		printf("    Codec decision result:\n");
+		if (conn[index_conn_src].end.codec) {
+			payload_type_conn_src = conn[index_conn_src].end.codec->payload_type;
+			printf("    conn[%u]: codec:%s, pt:%d\n",
+			       index_conn_src, conn[index_conn_src].end.codec->subtype_name, payload_type_conn_src);
+		} else {
+			payload_type_conn_src = -EINVAL;
+			printf("    conn[%u]: codec:none, pt:none\n", index_conn_src);
+		}
+
+		if (conn[index_conn_dst].end.codec) {
+			payload_type_conn_dst = conn[index_conn_dst].end.codec->payload_type;
+			printf("    conn[%u]: codec:%s, pt:%d\n",
+			       index_conn_dst, conn[index_conn_dst].end.codec->subtype_name,
+			       payload_type_conn_dst);
+		} else {
+			payload_type_conn_dst = -EINVAL;
+			printf("    conn[%u]: codec:none, pt:none\n", index_conn_dst);
+		}
+
+		if (payload_type_conn_src != expect->payload_type_map[index_conn_src]) {
+			printf("    ERROR: conn[%u] unexpected codec decision, expected pt=%d, got pt=%d\n",
+			       index_conn_src, expect->payload_type_map[index_conn_src], payload_type_conn_src);
+			ok = false;
+		}
+
+		if (payload_type_conn_dst != expect->payload_type_map[index_conn_dst]) {
+			printf("    ERROR: conn[%u] unexpected codec decision, expected pt=%d, got pt=%d\n",
+			       index_conn_dst, expect->payload_type_map[index_conn_dst],
+			       payload_type_conn_dst);
+			ok = false;
+		}
+	}
+
+	return ok;
+}
+
+static void test_mgcp_codec_decide(void)
 {
 	int i;
 	bool ok = true;
-	printf("\nTesting mgcp_codec_pt_translate()\n");
+	printf("\nTesting mgcp_codec_find_convertible()\n");
 
-	for (i = 0; i < ARRAY_SIZE(test_mgcp_codec_pt_translate_cases); i++) {
-		const struct testcase_mgcp_codec_pt_translate *t = &test_mgcp_codec_pt_translate_cases[i];
-		struct mgcp_conn_rtp conn[2] = {};
+	for (i = 0; i < ARRAY_SIZE(test_mgcp_codec_find_convertible_cases); i++) {
+		const struct testcase_mgcp_codec_decide *t = &test_mgcp_codec_find_convertible_cases[i];
+		struct mgcp_conn_rtp conn[2] = { };
 		int rc;
 		int conn_i;
 		int c;
 
 		printf("#%d: %s\n", i, t->descr);
 
+		/* Build testvector (add codecs to conn, set properties etc... */
 		for (conn_i = 0; conn_i < 2; conn_i++) {
 			printf(" - add codecs on conn%d:\n", conn_i);
 			for (c = 0; c < ARRAY_SIZE(t->codecs[conn_i]); c++) {
-				const struct testcase_mgcp_codec_pt_translate_codec *codec = &t->codecs[conn_i][c];
+				const struct testcase_mgcp_codec_decide_codec *codec = &t->codecs[conn_i][c];
 				if (!codec->audio_name)
 					break;
 
-				rc = mgcp_codec_add(&conn[conn_i], codec->payload_type, codec->audio_name, codec->param);
+				rc = mgcp_codec_add(&conn[conn_i], codec->payload_type, codec->audio_name,
+						    codec->param);
 
 				printf("   %2d: %3d %s%s  -> rc=%d\n", c, codec->payload_type, codec->audio_name,
 				       codec->param ?
-					       (codec->param->amr_octet_aligned_present?
-							(codec->param->amr_octet_aligned ?
-								" octet-aligned=1" : " octet-aligned=0")
+				       (codec->param->amr_octet_aligned_present ?
+					(codec->param->amr_octet_aligned ? " octet-aligned=1" : " octet-aligned=0")
 					: " octet-aligned=unset")
-						: "",
-						rc);
+				       : "", rc);
 				if (rc != codec->expect_rc) {
 					printf("     ERROR: expected rc=%d\n", codec->expect_rc);
 					ok = false;
@@ -2044,36 +2182,17 @@ static void test_mgcp_codec_pt_translate(void)
 				printf("    (none)\n");
 		}
 
-		for (c = 0; c < ARRAY_SIZE(t->expect); c++) {
-			const struct testcase_mgcp_codec_pt_translate_expect *expect = &t->expect[c];
-			int result;
-
-			if (expect->end)
-				break;
-
-			result = mgcp_codec_pt_translate(&conn[0], &conn[1], expect->payload_type_map[0]);
-			printf(" - mgcp_codec_pt_translate(conn0, conn1, %d) -> %d\n",
-			       expect->payload_type_map[0], result);
-			if (result != expect->payload_type_map[1]) {
-				printf("     ERROR: expected -> %d\n", expect->payload_type_map[1]);
+		/* Run codec decision and check expectation */
+		if (!codec_decision(conn, 0, 1, &t->expect[0]))
 			ok = false;
-			}
 
-			/* If the expected result is an error, don't do reverse map test */
-			if (expect->payload_type_map[1] < 0)
-				continue;
-
-			result = mgcp_codec_pt_translate(&conn[1], &conn[0], expect->payload_type_map[1]);
-			printf(" - mgcp_codec_pt_translate(conn1, conn0, %d) -> %d\n",
-			       expect->payload_type_map[1], result);
-			if (result != expect->payload_type_map[0]) {
-				printf("     ERROR: expected -> %d\n", expect->payload_type_map[0]);
+		if (!codec_decision(conn, 1, 0, &t->expect[1]))
 			ok = false;
-			}
-		}
 
-		for (conn_i = 0; conn_i < 2; conn_i++)
-			mgcp_codec_reset_all(&conn[conn_i]);
+		if (ok)
+			printf(" ===> SUCCESS: codec decision as expected!\n");
+		else
+			printf(" ===> FAIL: unexpected codec decision!\n");
 	}
 
 	OSMO_ASSERT(ok);
@@ -2233,7 +2352,7 @@ int main(int argc, char **argv)
 	test_osmux_cid();
 	test_get_lco_identifier();
 	test_check_local_cx_options(ctx);
-	test_mgcp_codec_pt_translate();
+	test_mgcp_codec_decide();
 	test_conn_id_matching();
 	test_e1_trunk_nr_from_epname();
 	test_mgcp_is_rtp_dummy_payload();

tests/mgcp/mgcp_test.ok

@@ -525,6 +525,80 @@ Response matches our expectations.
 L: p:20
 
 v=0
+c=IN IP4 123.12.12.123
+m=audio 5904 RTP/AVP 111
+a=rtpmap:111 AMR/8000/1
+a=ptime:20
+a=fmtp:111 mode-change-capability=2; octet-align=1
+
+---------8<---------
+checking response:
+using message with patched conn_id for comparison
+Response matches our expectations.
+(response contains a connection id)
+Dummy packets: 2
+
+================================================
+Testing AUEP_NULL
+creating message from statically defined input:
+---------8<---------
+AUEP 18983215 null@mgw MGCP 1.0
+
+---------8<---------
+checking response:
+using message as statically defined for comparison
+Response matches our expectations.
+(response does not contain a connection id)
+
+================================================
+Testing CRCX_NULL
+creating message from statically defined input:
+---------8<---------
+CRCX 2 null@mgw MGCP 1.0
+m: recvonly
+C: 2
+L: p:20
+
+v=0
+c=IN IP4 123.12.12.123
+m=audio 5904 RTP/AVP 97
+a=rtpmap:97 GSM-EFR/8000
+a=ptime:40
+
+---------8<---------
+checking response:
+using message as statically defined for comparison
+Response matches our expectations.
+(response does not contain a connection id)
+
+================================================
+Testing MDCX_NULL
+creating message from statically defined input:
+---------8<---------
+MDCX 9 null@mgw MGCP 1.0
+I: %s
+
+---------8<---------
+checking response:
+using message as statically defined for comparison
+Response matches our expectations.
+(response does not contain a connection id)
+
+================================================
+Testing DLCX_NULL
+creating message from statically defined input:
+---------8<---------
+DLCX 8 null@mgw MGCP 1.0
+I: %s
+C: 2
+
+---------8<---------
+checking response:
+using message as statically defined for comparison
+Response matches our expectations.
+(response does not contain a connection id)
+
+================================================
 Testing RQNT_NULL
 creating message from statically defined input:
 ---------8<---------
@@ -1276,7 +1350,7 @@ p:10, a:PCMU -> p:10, a:PCMU
 Response matches our expectations.
 Testing get_lco_identifier()
 p:10, a:PCMU -> p:10, a:PCMU
-p:10, a:PCMU -> p:10, a:PCMU
+p:10, a:PCMU -> p:10, a:PCMU
 'XXXX, p:10, a:PCMU' -> 'p:10, a:PCMU'
 'XXXX,p:10,a:PCMU' -> 'p:10,a:PCMU'
 '10,a:PCMU' -> 'a:PCMU'
@@ -1286,13 +1360,15 @@ Testing mgcp_codec_pt_translate()
 ', a:PCMU' -> 'a:PCMU'
 ' a:PCMU' -> 'a:PCMU'
 '' -> '(null)'
-p10, aPCMU -> (null)
-'10,a :PCMU' -> '(null)'
-
-Testing mgcp_codec_pt_translate()
-#0: same order, but differing payload type numbers
- - add codecs on conn0:
-    0: 112 AMR/8000/1 octet-aligned=1  -> rc=0
+p10, aPCMU -> (null)
+'10,a :PCMU' -> '(null)'
+
+Testing mgcp_codec_find_convertible()
+#0: same order, but differing payload type numbers
+ - add codecs on conn0:
+    0: 112 AMR/8000/1 octet-aligned=1  -> rc=0
+    1:   0 PCMU/8000/1  -> rc=0
+    2: 111 GSM-HR-08/8000/1  -> rc=0
  - add codecs on conn1:
     0:  96 AMR/8000/1 octet-aligned=1  -> rc=0
     1:   0 PCMU/8000/1  -> rc=0
@@ -1302,13 +1378,15 @@ Testing mgcp_codec_pt_translate()
     conn[0]: codec:AMR, pt:112
     conn[1]: codec:AMR, pt:96
  - mgcp_codec_decide(&conn[1], &conn[0]):
- - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
- - mgcp_codec_pt_translate(conn0, conn1, 111) -> 97
- - mgcp_codec_pt_translate(conn1, conn0, 97) -> 111
- - mgcp_codec_pt_translate(conn0, conn1, 123) -> -22
-#1: different order and different payload type numbers
- - add codecs on conn0:
-    0:   0 PCMU/8000/1  -> rc=0
+    Codec decision result:
+    conn[1]: codec:AMR, pt:96
+    conn[0]: codec:AMR, pt:112
+ ===> SUCCESS: codec decision as expected!
+#1: different order and different payload type numbers
+ - add codecs on conn0:
+    0:   0 PCMU/8000/1  -> rc=0
+    1: 111 GSM-HR-08/8000/1  -> rc=0
+    2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
  - add codecs on conn1:
     0:  97 GSM-HR-08/8000/1  -> rc=0
     1:   0 PCMU/8000/1  -> rc=0
@@ -1318,12 +1396,15 @@ Testing mgcp_codec_pt_translate()
     conn[0]: codec:PCMU, pt:0
     conn[1]: codec:PCMU, pt:0
  - mgcp_codec_decide(&conn[1], &conn[0]):
- - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
- - mgcp_codec_pt_translate(conn0, conn1, 111) -> 97
- - mgcp_codec_pt_translate(conn1, conn0, 97) -> 111
- - mgcp_codec_pt_translate(conn0, conn1, 123) -> -22
-#2: both sides have the same payload_type numbers assigned to differing codecs
- - add codecs on conn0:
+    Codec decision result:
+    conn[1]: codec:GSM-HR-08, pt:97
+    conn[0]: codec:GSM-HR-08, pt:111
+ ===> SUCCESS: codec decision as expected!
+#2: both sides have the same payload_type numbers assigned to differing codecs
+ - add codecs on conn0:
+    0:   0 PCMU/8000/1  -> rc=0
+    1:  96 GSM-HR-08/8000/1  -> rc=0
+    2:  97 AMR/8000/1 octet-aligned=1  -> rc=0
  - add codecs on conn1:
     0:  97 GSM-HR-08/8000/1  -> rc=0
     1:   0 PCMU/8000/1  -> rc=0
@@ -1331,9 +1412,13 @@ Testing mgcp_codec_pt_translate()
  - mgcp_codec_decide(&conn[0], &conn[1]):
     Codec decision result:
     conn[0]: codec:PCMU, pt:0
- - mgcp_codec_pt_translate(conn0, conn1, 96) -> 97
- - mgcp_codec_pt_translate(conn1, conn0, 97) -> 96
- - mgcp_codec_pt_translate(conn0, conn1, 97) -> 96
+    conn[1]: codec:PCMU, pt:0
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:GSM-HR-08, pt:97
+    conn[0]: codec:GSM-HR-08, pt:96
+ ===> SUCCESS: codec decision as expected!
+#3: conn0 has no codecs
  - add codecs on conn0:
     (none)
  - add codecs on conn1:
@@ -1341,31 +1426,116 @@ Testing mgcp_codec_pt_translate()
     1:   0 PCMU/8000/1  -> rc=0
     2:  97 GSM-HR-08/8000/1  -> rc=0
  - mgcp_codec_decide(&conn[0], &conn[1]):
-    0:  96 AMR/8000/1 octet-aligned=1  -> rc=0
-    1:   0 PCMU/8000/1  -> rc=0
-    2:  97 GSM-HR-08/8000/1  -> rc=0
- - mgcp_codec_pt_translate(conn0, conn1, 112) -> -22
+    codec decision failed (expected)!
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:AMR, pt:96
+    conn[0]: codec:none, pt:none
+ ===> SUCCESS: codec decision as expected!
+#4: conn1 has no codecs
+ - add codecs on conn0:
+    0: 112 AMR/8000/1 octet-aligned=1  -> rc=0
+    1:   0 PCMU/8000/1  -> rc=0
+    2: 111 GSM-HR-08/8000/1  -> rc=0
+ - add codecs on conn1:
+    (none)
+ - mgcp_codec_decide(&conn[0], &conn[1]):
+    Codec decision result:
+    conn[0]: codec:AMR, pt:112
+    conn[1]: codec:none, pt:none
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    codec decision failed (expected)!
+ ===> SUCCESS: codec decision as expected!
+#5: test AMR with differing octet-aligned settings (both <-> both)
+ - add codecs on conn0:
+    0: 111 AMR/8000 octet-aligned=1  -> rc=0
+    1: 112 AMR/8000 octet-aligned=0  -> rc=0
  - add codecs on conn1:
     0: 122 AMR/8000 octet-aligned=0  -> rc=0
     1: 121 AMR/8000 octet-aligned=1  -> rc=0
  - mgcp_codec_decide(&conn[0], &conn[1]):
-    0: 112 AMR/8000/1 octet-aligned=1  -> rc=0
-    1:   0 PCMU/8000/1  -> rc=0
-    2: 111 GSM-HR-08/8000/1  -> rc=0
+    Codec decision result:
+    conn[0]: codec:AMR, pt:111
+    conn[1]: codec:AMR, pt:121
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:AMR, pt:122
+    conn[0]: codec:AMR, pt:112
+ ===> SUCCESS: codec decision as expected!
+#6: test AMR with differing octet-aligned settings (oa <-> both)
+ - add codecs on conn0:
+    0: 111 AMR/8000 octet-aligned=1  -> rc=0
+ - add codecs on conn1:
+    0: 122 AMR/8000 octet-aligned=0  -> rc=0
+    1: 121 AMR/8000 octet-aligned=1  -> rc=0
+ - mgcp_codec_decide(&conn[0], &conn[1]):
+    Codec decision result:
+    conn[0]: codec:AMR, pt:111
+    conn[1]: codec:AMR, pt:121
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:AMR, pt:121
+    conn[0]: codec:AMR, pt:111
+ ===> SUCCESS: codec decision as expected!
+#7: test AMR with differing octet-aligned settings (bwe <-> both)
+ - add codecs on conn0:
+    0: 112 AMR/8000 octet-aligned=0  -> rc=0
  - add codecs on conn1:
     0: 122 AMR/8000 octet-aligned=0  -> rc=0
     1: 121 AMR/8000 octet-aligned=1  -> rc=0
  - mgcp_codec_decide(&conn[0], &conn[1]):
- - mgcp_codec_pt_translate(conn0, conn1, 111) -> -22
-#5: test AMR with differing octet-aligned settings
- - add codecs on conn0:
+    Codec decision result:
+    conn[0]: codec:AMR, pt:112
+    conn[1]: codec:AMR, pt:122
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:AMR, pt:122
+    conn[0]: codec:AMR, pt:112
+ ===> SUCCESS: codec decision as expected!
+#8: test AMR with missing octet-aligned settings (oa <-> unset)
+ - add codecs on conn0:
     0: 111 AMR/8000 octet-aligned=1  -> rc=0
- - add codecs on conn1:
+ - add codecs on conn1:
+    0: 122 AMR/8000 octet-aligned=unset  -> rc=0
+ - mgcp_codec_decide(&conn[0], &conn[1]):
+    Codec decision result:
+    conn[0]: codec:AMR, pt:111
+    conn[1]: codec:AMR, pt:122
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:AMR, pt:122
+    conn[0]: codec:AMR, pt:111
+ ===> SUCCESS: codec decision as expected!
+#9: test AMR with missing octet-aligned settings (bwe <-> unset)
+ - add codecs on conn0:
+    0: 111 AMR/8000 octet-aligned=0  -> rc=0
+ - add codecs on conn1:
     0: 122 AMR/8000 octet-aligned=unset  -> rc=0
  - mgcp_codec_decide(&conn[0], &conn[1]):
- - mgcp_codec_pt_translate(conn1, conn0, 122) -> 111
-#6: test AMR with missing octet-aligned settings (defaults to 0)
- - add codecs on conn0:
+    Codec decision result:
+    conn[0]: codec:AMR, pt:111
+    conn[1]: codec:AMR, pt:122
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:AMR, pt:122
+    conn[0]: codec:AMR, pt:111
+ ===> SUCCESS: codec decision as expected!
+#10: test AMR with NULL param (oa <-> null)
+ - add codecs on conn0:
+    0: 112 AMR/8000 octet-aligned=1  -> rc=0
+ - add codecs on conn1:
+    0: 122 AMR/8000  -> rc=0
+ - mgcp_codec_decide(&conn[0], &conn[1]):
+    Codec decision result:
+    conn[0]: codec:AMR, pt:112
+    conn[1]: codec:AMR, pt:122
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:AMR, pt:122
+    conn[0]: codec:AMR, pt:112
+ ===> SUCCESS: codec decision as expected!
+#11: test AMR with NULL param (bwe <-> null)
+ - add codecs on conn0:
     0: 112 AMR/8000 octet-aligned=0  -> rc=0
  - add codecs on conn1:
     0: 122 AMR/8000  -> rc=0
@@ -1374,14 +1544,16 @@ Testing mgcp_codec_pt_translate()
     conn[0]: codec:AMR, pt:112
     conn[1]: codec:AMR, pt:122
  - mgcp_codec_decide(&conn[1], &conn[0]):
- - add codecs on conn1:
-    0: 122 AMR/8000  -> rc=0
- - mgcp_codec_pt_translate(conn0, conn1, 111) -> 122
- - mgcp_codec_pt_translate(conn1, conn0, 122) -> 111
-#8: match FOO/8000/1 and FOO/8000 as identical, single channel is implicit
- - add codecs on conn0:
-    0:   0 PCMU/8000/1  -> rc=0
-    1: 111 GSM-HR-08/8000/1  -> rc=0
+    Codec decision result:
+    conn[1]: codec:AMR, pt:122
+    conn[0]: codec:AMR, pt:112
+ ===> SUCCESS: codec decision as expected!
+#12: match FOO/8000/1 and FOO/8000 as identical, single channel is implicit
+ - add codecs on conn0:
+    0:   0 PCMU/8000/1  -> rc=0
+    1: 111 GSM-HR-08/8000/1  -> rc=0
+    2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
+ - add codecs on conn1:
     0:  97 GSM-HR-08/8000  -> rc=0
     1:   0 PCMU/8000  -> rc=0
     2:  96 AMR/8000 octet-aligned=1  -> rc=0
@@ -1390,14 +1562,16 @@ Testing mgcp_codec_pt_translate()
     conn[0]: codec:PCMU, pt:0
     conn[1]: codec:PCMU, pt:0
  - mgcp_codec_decide(&conn[1], &conn[0]):
- - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
- - mgcp_codec_pt_translate(conn0, conn1, 111) -> 97
- - mgcp_codec_pt_translate(conn1, conn0, 97) -> 111
- - mgcp_codec_pt_translate(conn0, conn1, 123) -> -22
-#9: match FOO/8000/1 and FOO as identical, 8k and single channel are implicit
- - add codecs on conn0:
-    0:   0 PCMU/8000/1  -> rc=0
-    1: 111 GSM-HR-08/8000/1  -> rc=0
+    Codec decision result:
+    conn[1]: codec:GSM-HR-08, pt:97
+    conn[0]: codec:GSM-HR-08, pt:111
+ ===> SUCCESS: codec decision as expected!
+#13: match FOO/8000/1 and FOO as identical, 8k and single channel are implicit
+ - add codecs on conn0:
+    0:   0 PCMU/8000/1  -> rc=0
+    1: 111 GSM-HR-08/8000/1  -> rc=0
+    2: 112 AMR/8000/1 octet-aligned=1  -> rc=0
+ - add codecs on conn1:
     0:  97 GSM-HR-08  -> rc=0
     1:   0 PCMU  -> rc=0
     2:  96 AMR octet-aligned=1  -> rc=0
@@ -1405,10 +1579,15 @@ Testing mgcp_codec_pt_translate()
     Codec decision result:
     conn[0]: codec:PCMU, pt:0
     conn[1]: codec:PCMU, pt:0
- - mgcp_codec_pt_translate(conn0, conn1, 0) -> 0
- - mgcp_codec_pt_translate(conn1, conn0, 0) -> 0
- - mgcp_codec_pt_translate(conn0, conn1, 111) -> 97
- - mgcp_codec_pt_translate(conn1, conn0, 97) -> 111
+ - mgcp_codec_decide(&conn[1], &conn[0]):
+    Codec decision result:
+    conn[1]: codec:GSM-HR-08, pt:97
+    conn[0]: codec:GSM-HR-08, pt:111
+ ===> SUCCESS: codec decision as expected!
+#14: test whether channel number matching is waterproof
+ - add codecs on conn0:
+    0: 111 GSM-HR-08/8000  -> rc=0
+    1: 112 GSM-HR-08/8000/2  -> rc=-22
     2: 113 GSM-HR-08/8000/3  -> rc=-22
  - add codecs on conn1:
     0: 122 GSM-HR-08/8000/2  -> rc=-22

tests/mgcp_client/Makefile.am

@@ -15,6 +15,7 @@ AM_CFLAGS = \
 
 AM_LDFLAGS = \
 	$(COVERAGE_LDFLAGS) \
+	-no-install \
 	$(NULL)
 
 EXTRA_DIST = \

tests/mgcp_client/mgcp_client_test.c

@@ -73,7 +73,7 @@ static struct msgb *from_str(const char *str)
 	return msg;
 }
 
-static struct mgcp_client_conf conf;
+static struct mgcp_client_conf *conf;
 struct mgcp_client *mgcp = NULL;
 
 static int reply_to(mgcp_trans_id_t trans_id, int code, const char *comment,
@@ -162,7 +162,7 @@ void test_mgcp_msg(void)
 
 	if (mgcp)
 		talloc_free(mgcp);
-	mgcp = mgcp_client_init(ctx, &conf);
+	mgcp = mgcp_client_init(ctx, conf);
 
 	printf("\n");
 
@@ -339,7 +339,7 @@ void test_mgcp_client_cancel(void)
 
 	if (mgcp)
 		talloc_free(mgcp);
-	mgcp = mgcp_client_init(ctx, &conf);
+	mgcp = mgcp_client_init(ctx, conf);
 
 	msg = mgcp_msg_gen(mgcp, &mgcp_msg);
 	trans_id = mgcp_msg_trans_id(msg);
@@ -630,7 +630,7 @@ void test_mgcp_client_e1_epname(void)
 
 	if (mgcp)
 		talloc_free(mgcp);
-	mgcp = mgcp_client_init(ctx, &conf);
+	mgcp = mgcp_client_init(ctx, conf);
 
 	/* Valid endpoint names */
 	epname = (char *)mgcp_client_e1_epname(ctx, mgcp, 1, 15, 64, 0);
@@ -697,7 +697,7 @@ int main(int argc, char **argv)
 
 	log_set_category_filter(osmo_stderr_target, DLMGCP, 1, LOGL_DEBUG);
 
-	mgcp_client_conf_init(&conf);
+	conf = mgcp_client_conf_alloc(ctx);
 
 	test_mgcp_msg();
 	test_mgcp_client_cancel();

tests/mgcp_client/mgcp_client_test.err

@@ -1,5 +1,6 @@
 DLMGCP MGW(mgw) MGCP client: using endpoint domain '@mgw'
-DLMGCP MGW(mgw) Message buffer to small, can not generate MGCP message (SDP)
+DLMGCP MGW(mgw) Message buffer too small, can not generate MGCP message (SDP)
+DLMGCP MGW(mgw) Failed to add SDP, can not generate MGCP message
 
 test_mgcp_client_cancel():
 DLMGCP MGW(mgw) MGCP client: using endpoint domain '@mgw'
@@ -10,6 +11,7 @@ DLMGCP MGW(mgw) Cannot cancel, no such transaction: 1
 - cancel succeeds
 DLMGCP MGW(mgw) Canceled transaction 1
 - late response gets discarded
+DLMGCP MGW(mgw) MGCP link to MGW now considered UP
 DLMGCP MGW(mgw) MGCP client: Rx 200 1 OK
 DLMGCP MGW(mgw) Cannot find matching MGCP transaction for trans_id 1
 - canceling again does nothing