blob: cc309a3fe879bc6389632d35e95c65ee10b0b7ba [file] [log] [blame]
Philipp Maier87bd9be2017-08-22 16:35:41 +02001/* Message connection list handling */
2
3/*
4 * (C) 2017 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
5 * All Rights Reserved
6 *
7 * Author: Philipp Maier
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Affero General Public License as published by
11 * the Free Software Foundation; either version 3 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU Affero General Public License for more details.
18 *
19 * You should have received a copy of the GNU Affero General Public License
20 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 *
22 */
23
Erica94c56e2021-09-07 00:10:31 +020024#include <stdatomic.h>
Philipp Maier87bd9be2017-08-22 16:35:41 +020025#include <osmocom/mgcp/mgcp_conn.h>
Philipp Maier993ea6b2020-08-04 18:26:50 +020026#include <osmocom/mgcp/mgcp_network.h>
27#include <osmocom/mgcp/mgcp_protocol.h>
Neels Hofmeyr67793542017-09-08 04:25:16 +020028#include <osmocom/mgcp/mgcp_common.h>
Philipp Maier37d11c82018-02-01 14:38:12 +010029#include <osmocom/mgcp/mgcp_endp.h>
Philipp Maierc66ab2c2020-06-02 20:55:34 +020030#include <osmocom/mgcp/mgcp_trunk.h>
Philipp Maierbc0346e2018-06-07 09:52:16 +020031#include <osmocom/mgcp/mgcp_sdp.h>
32#include <osmocom/mgcp/mgcp_codec.h>
Pau Espin Pedrolbb3ccde2021-12-23 19:49:26 +010033#include <osmocom/mgcp/mgcp_iuup.h>
34
Philipp Maierffd75e42017-11-22 11:44:50 +010035#include <osmocom/gsm/gsm_utils.h>
Philipp Maier9e1d1642018-05-09 16:26:34 +020036#include <osmocom/core/rate_ctr.h>
Oliver Smithe36b7752019-01-22 16:31:36 +010037#include <osmocom/core/timer.h>
Philipp Maierffd75e42017-11-22 11:44:50 +010038#include <ctype.h>
39
Pau Espin Pedrol663ba5c2022-09-22 21:43:31 +020040static const struct rate_ctr_group_desc rate_ctr_group_desc = {
Philipp Maier9e1d1642018-05-09 16:26:34 +020041 .group_name_prefix = "conn_rtp",
42 .group_description = "rtp connection statistics",
43 .class_id = 1,
Stefan Sperlingba25eab2018-10-30 14:32:31 +010044 .num_ctr = ARRAY_SIZE(mgcp_conn_rate_ctr_desc),
45 .ctr_desc = mgcp_conn_rate_ctr_desc
Philipp Maier9e1d1642018-05-09 16:26:34 +020046};
47
48
Philipp Maierffd75e42017-11-22 11:44:50 +010049/* Allocate a new connection identifier. According to RFC3435, they must
Philipp Maierf8bfbe82017-11-23 19:32:31 +010050 * be unique only within the scope of the endpoint. (Caller must provide
51 * memory for id) */
Philipp Maierffd75e42017-11-22 11:44:50 +010052static int mgcp_alloc_id(struct mgcp_endpoint *endp, char *id)
53{
Neels Hofmeyra729db62018-08-28 16:20:51 +020054#define MGCP_CONN_ID_GEN_LEN 8
Philipp Maierffd75e42017-11-22 11:44:50 +010055 int i;
56 int k;
57 int rc;
Neels Hofmeyra729db62018-08-28 16:20:51 +020058 uint8_t id_bin[MGCP_CONN_ID_GEN_LEN / 2];
Philipp Maierffd75e42017-11-22 11:44:50 +010059 char *id_hex;
60
61 /* Generate a connection id that is unique for the current endpoint.
62 * Technically a counter would be sufficient, but in order to
63 * be able to find a specific connection in large logfiles and to
64 * prevent unintentional connections we assign the connection
65 * identifiers randomly from a reasonable large number space */
66 for (i = 0; i < 32; i++) {
67 rc = osmo_get_rand_id(id_bin, sizeof(id_bin));
68 if (rc < 0)
69 return rc;
70
71 id_hex = osmo_hexdump_nospc(id_bin, sizeof(id_bin));
72 for (k = 0; k < strlen(id_hex); k++)
73 id_hex[k] = toupper(id_hex[k]);
74
75 /* ensure that the generated conn_id is unique
76 * for this endpoint */
77 if (!mgcp_conn_get_rtp(endp, id_hex)) {
Neels Hofmeyr55e0dcf2018-09-03 21:36:56 +020078 osmo_strlcpy(id, id_hex, MGCP_CONN_ID_MAXLEN);
Philipp Maierffd75e42017-11-22 11:44:50 +010079 return 0;
80 }
81 }
82
Pau Espin Pedrol3239f622019-04-24 18:47:46 +020083 LOGPENDP(endp, DLMGCP, LOGL_ERROR, "unable to generate a unique connectionIdentifier\n");
Philipp Maierffd75e42017-11-22 11:44:50 +010084
85 return -1;
86}
Philipp Maier87bd9be2017-08-22 16:35:41 +020087
Philipp Maierc430d192018-03-16 12:11:18 +010088/* Initialize rtp connection struct with default values */
Harald Welte3ac604e2019-05-08 14:07:41 +020089static int mgcp_rtp_conn_init(struct mgcp_conn_rtp *conn_rtp, struct mgcp_conn *conn)
Philipp Maier87bd9be2017-08-22 16:35:41 +020090{
Philipp Maier892dec02018-03-16 12:32:01 +010091 struct mgcp_rtp_end *end = &conn_rtp->end;
Philipp Maier9e1d1642018-05-09 16:26:34 +020092 /* FIXME: Each new rate counter group requires an unique index. At the
93 * moment we generate this index using this counter, but perhaps there
94 * is a more concious way to assign the indexes. */
Erica94c56e2021-09-07 00:10:31 +020095 static atomic_uint rate_ctr_index = 0;
Philipp Maier87bd9be2017-08-22 16:35:41 +020096
Philipp Maier892dec02018-03-16 12:32:01 +010097 conn_rtp->type = MGCP_RTP_DEFAULT;
Pau Espin Pedrol21779192022-09-23 16:46:33 +020098 conn_rtp->osmux.local_cid_allocated = false;
99 conn_rtp->osmux.local_cid = 0;
100 conn_rtp->osmux.remote_cid_present = false;
101 conn_rtp->osmux.remote_cid = 0;
Philipp Maier892dec02018-03-16 12:32:01 +0100102
103 /* backpointer to the generic part of the connection */
104 conn->u.rtp.conn = conn;
Philipp Maier87bd9be2017-08-22 16:35:41 +0200105
106 end->rtp.fd = -1;
107 end->rtcp.fd = -1;
Philipp Maier87bd9be2017-08-22 16:35:41 +0200108 end->rtp_port = end->rtcp_port = 0;
109 talloc_free(end->fmtp_extra);
110 end->fmtp_extra = NULL;
111
112 /* Set default values */
113 end->frames_per_packet = 0; /* unknown */
114 end->packet_duration_ms = DEFAULT_RTP_AUDIO_PACKET_DURATION_MS;
Pau Espin Pedrol2c401642021-12-24 14:48:26 +0100115 end->output_enabled = false;
Philipp Maierbc0346e2018-06-07 09:52:16 +0200116 end->maximum_packet_time = -1;
Philipp Maier9e1d1642018-05-09 16:26:34 +0200117
Pau Espin Pedroldaf5bce2022-09-22 19:14:24 +0200118 conn_rtp->ctrg = rate_ctr_group_alloc(conn, &rate_ctr_group_desc, rate_ctr_index++);
119 if (!conn_rtp->ctrg)
Harald Welte3ac604e2019-05-08 14:07:41 +0200120 return -1;
121
Pau Espin Pedroldaf5bce2022-09-22 19:14:24 +0200122 conn_rtp->state.in_stream.err_ts_ctr = rate_ctr_group_get_ctr(conn_rtp->ctrg, IN_STREAM_ERR_TSTMP_CTR);
123 conn_rtp->state.out_stream.err_ts_ctr = rate_ctr_group_get_ctr(conn_rtp->ctrg, OUT_STREAM_ERR_TSTMP_CTR);
Philipp Maierbc0346e2018-06-07 09:52:16 +0200124
125 /* Make sure codec table is reset */
126 mgcp_codec_reset_all(conn_rtp);
Harald Welte3ac604e2019-05-08 14:07:41 +0200127
128 return 0;
Philipp Maier87bd9be2017-08-22 16:35:41 +0200129}
130
Philipp Maierd0b470d2018-03-16 12:45:53 +0100131/* Cleanup rtp connection struct */
132static void mgcp_rtp_conn_cleanup(struct mgcp_conn_rtp *conn_rtp)
133{
Pau Espin Pedrol85978da2019-05-17 14:38:19 +0200134 if (mgcp_conn_rtp_is_osmux(conn_rtp))
135 conn_osmux_disable(conn_rtp);
Pau Espin Pedrolbb3ccde2021-12-23 19:49:26 +0100136 if (mgcp_conn_rtp_is_iuup(conn_rtp))
137 mgcp_conn_iuup_cleanup(conn_rtp);
Philipp Maierd0b470d2018-03-16 12:45:53 +0100138 mgcp_free_rtp_port(&conn_rtp->end);
Pau Espin Pedroldaf5bce2022-09-22 19:14:24 +0200139 rate_ctr_group_free(conn_rtp->ctrg);
Neels Hofmeyr401b7402019-08-08 22:14:08 +0200140 mgcp_codec_reset_all(conn_rtp);
Philipp Maierd0b470d2018-03-16 12:45:53 +0100141}
142
Oliver Smithe36b7752019-01-22 16:31:36 +0100143void mgcp_conn_watchdog_cb(void *data)
144{
145 struct mgcp_conn *conn = data;
Pau Espin Pedrol3239f622019-04-24 18:47:46 +0200146 LOGPCONN(conn, DLMGCP, LOGL_ERROR, "connection timed out!\n");
Oliver Smithe36b7752019-01-22 16:31:36 +0100147 mgcp_conn_free(conn->endp, conn->id);
148}
149
150void mgcp_conn_watchdog_kick(struct mgcp_conn *conn)
151{
Ericfbf78d12021-08-23 22:31:39 +0200152 int timeout = conn->endp->trunk->cfg->conn_timeout;
Oliver Smithe36b7752019-01-22 16:31:36 +0100153 if (!timeout)
154 return;
155
Pau Espin Pedrol3239f622019-04-24 18:47:46 +0200156 LOGPCONN(conn, DLMGCP, LOGL_DEBUG, "watchdog kicked\n");
Oliver Smithe36b7752019-01-22 16:31:36 +0100157 osmo_timer_schedule(&conn->watchdog, timeout, 0);
158}
159
Philipp Maier87bd9be2017-08-22 16:35:41 +0200160/*! allocate a new connection list entry.
161 * \param[in] ctx talloc context
162 * \param[in] endp associated endpoint
163 * \param[in] id identification number of the connection
164 * \param[in] type connection type (e.g. MGCP_CONN_TYPE_RTP)
165 * \returns pointer to allocated connection, NULL on error */
166struct mgcp_conn *mgcp_conn_alloc(void *ctx, struct mgcp_endpoint *endp,
Philipp Maierffd75e42017-11-22 11:44:50 +0100167 enum mgcp_conn_type type, char *name)
Philipp Maier87bd9be2017-08-22 16:35:41 +0200168{
169 struct mgcp_conn *conn;
Philipp Maierffd75e42017-11-22 11:44:50 +0100170 int rc;
171
Philipp Maier87bd9be2017-08-22 16:35:41 +0200172 /* Do not allow more then two connections */
173 if (llist_count(&endp->conns) >= endp->type->max_conns)
174 return NULL;
175
Philipp Maier87bd9be2017-08-22 16:35:41 +0200176 /* Create new connection and add it to the list */
177 conn = talloc_zero(ctx, struct mgcp_conn);
178 if (!conn)
179 return NULL;
180 conn->endp = endp;
181 conn->type = type;
182 conn->mode = MGCP_CONN_NONE;
183 conn->mode_orig = MGCP_CONN_NONE;
Philipp Maierf8bfbe82017-11-23 19:32:31 +0100184 osmo_strlcpy(conn->name, name, sizeof(conn->name));
Philipp Maierffd75e42017-11-22 11:44:50 +0100185 rc = mgcp_alloc_id(endp, conn->id);
186 if (rc < 0) {
187 talloc_free(conn);
188 return NULL;
189 }
Philipp Maier87bd9be2017-08-22 16:35:41 +0200190
191 switch (type) {
192 case MGCP_CONN_TYPE_RTP:
Harald Welte3ac604e2019-05-08 14:07:41 +0200193 if (mgcp_rtp_conn_init(&conn->u.rtp, conn) < 0) {
194 talloc_free(conn);
195 return NULL;
196 }
Philipp Maier87bd9be2017-08-22 16:35:41 +0200197 break;
198 default:
199 /* NOTE: This should never be called with an
200 * invalid type, its up to the programmer
201 * to ensure propery types */
202 OSMO_ASSERT(false);
203 }
204
Oliver Smithe36b7752019-01-22 16:31:36 +0100205 /* Initialize watchdog */
206 osmo_timer_setup(&conn->watchdog, mgcp_conn_watchdog_cb, conn);
207 mgcp_conn_watchdog_kick(conn);
Pau Espin Pedrol6d0a59a2020-09-08 16:50:22 +0200208 mgcp_endp_add_conn(endp, conn);
Philipp Maier87bd9be2017-08-22 16:35:41 +0200209
210 return conn;
211}
212
213/*! find a connection by its ID.
214 * \param[in] endp associated endpoint
215 * \param[in] id identification number of the connection
216 * \returns pointer to allocated connection, NULL if not found */
Philipp Maier01d24a32017-11-21 17:26:09 +0100217struct mgcp_conn *mgcp_conn_get(struct mgcp_endpoint *endp, const char *id)
Philipp Maier87bd9be2017-08-22 16:35:41 +0200218{
Philipp Maier87bd9be2017-08-22 16:35:41 +0200219 struct mgcp_conn *conn;
Neels Hofmeyr65317262018-09-03 22:11:05 +0200220 const char *id_upper;
Neels Hofmeyra77eade2018-08-29 02:30:39 +0200221 const char *conn_id;
Neels Hofmeyr65317262018-09-03 22:11:05 +0200222
223 if (!id || !*id)
224 return NULL;
225
Neels Hofmeyra77eade2018-08-29 02:30:39 +0200226 /* Ignore leading zeros in needle */
227 while (*id == '0')
228 id++;
229
Neels Hofmeyr65317262018-09-03 22:11:05 +0200230 /* Use uppercase to compare identifiers, to avoid mismatches: RFC3435 2.1.3.2 "Names of
231 * Connections" defines the id as a hex string, so clients may return lower case hex even though
232 * we sent upper case hex in the CRCX response. */
233 id_upper = osmo_str_toupper(id);
Philipp Maier87bd9be2017-08-22 16:35:41 +0200234
235 llist_for_each_entry(conn, &endp->conns, entry) {
Neels Hofmeyra77eade2018-08-29 02:30:39 +0200236 /* Ignore leading zeros in haystack */
237 for (conn_id=conn->id; *conn_id == '0'; conn_id++);
238
239 if (strcmp(conn_id, id_upper) == 0)
Philipp Maier87bd9be2017-08-22 16:35:41 +0200240 return conn;
241 }
242
243 return NULL;
244}
245
246/*! find an RTP connection by its ID.
247 * \param[in] endp associated endpoint
248 * \param[in] id identification number of the connection
249 * \returns pointer to allocated connection, NULL if not found */
Philipp Maier01d24a32017-11-21 17:26:09 +0100250struct mgcp_conn_rtp *mgcp_conn_get_rtp(struct mgcp_endpoint *endp,
251 const char *id)
Philipp Maier87bd9be2017-08-22 16:35:41 +0200252{
Philipp Maier87bd9be2017-08-22 16:35:41 +0200253 struct mgcp_conn *conn;
254
255 conn = mgcp_conn_get(endp, id);
256 if (!conn)
257 return NULL;
258
259 if (conn->type == MGCP_CONN_TYPE_RTP)
260 return &conn->u.rtp;
261
262 return NULL;
263}
264
Philipp Maierc66ab2c2020-06-02 20:55:34 +0200265static void aggregate_rtp_conn_stats(struct mgcp_endpoint *endp, struct mgcp_conn_rtp *conn_rtp)
Stefan Sperlingba25eab2018-10-30 14:32:31 +0100266{
Philipp Maierc66ab2c2020-06-02 20:55:34 +0200267 struct rate_ctr_group *all_stats = endp->trunk->ratectr.all_rtp_conn_stats;
Pau Espin Pedroldaf5bce2022-09-22 19:14:24 +0200268 struct rate_ctr_group *conn_stats = conn_rtp->ctrg;
Stefan Sperlingba25eab2018-10-30 14:32:31 +0100269
270 if (all_stats == NULL || conn_stats == NULL)
271 return;
272
273 /* Compared to per-connection RTP statistics, aggregated RTP statistics
274 * contain one additional rate couter item (RTP_NUM_CONNECTIONS).
275 * All other counters in both counter groups correspond to each other. */
276 OSMO_ASSERT(conn_stats->desc->num_ctr + 1 == all_stats->desc->num_ctr);
277
Harald Weltea48ff4a2020-03-08 14:45:08 +0100278 /* all other counters are [now] updated in real-time */
Pau Espin Pedrol907744e2021-06-04 17:57:34 +0200279 rate_ctr_add(rate_ctr_group_get_ctr(all_stats, IN_STREAM_ERR_TSTMP_CTR),
280 rate_ctr_group_get_ctr(conn_stats, IN_STREAM_ERR_TSTMP_CTR)->current);
281 rate_ctr_add(rate_ctr_group_get_ctr(all_stats, OUT_STREAM_ERR_TSTMP_CTR),
282 rate_ctr_group_get_ctr(conn_stats, OUT_STREAM_ERR_TSTMP_CTR)->current);
Stefan Sperlingba25eab2018-10-30 14:32:31 +0100283
Pau Espin Pedrol907744e2021-06-04 17:57:34 +0200284 rate_ctr_inc(rate_ctr_group_get_ctr(all_stats, RTP_NUM_CONNECTIONS));
Stefan Sperlingba25eab2018-10-30 14:32:31 +0100285}
286
Philipp Maier87bd9be2017-08-22 16:35:41 +0200287/*! free a connection by its ID.
288 * \param[in] endp associated endpoint
289 * \param[in] id identification number of the connection */
Philipp Maier01d24a32017-11-21 17:26:09 +0100290void mgcp_conn_free(struct mgcp_endpoint *endp, const char *id)
Philipp Maier87bd9be2017-08-22 16:35:41 +0200291{
Philipp Maier87bd9be2017-08-22 16:35:41 +0200292 struct mgcp_conn *conn;
293
294 conn = mgcp_conn_get(endp, id);
295 if (!conn)
296 return;
297
298 switch (conn->type) {
299 case MGCP_CONN_TYPE_RTP:
Philipp Maierc66ab2c2020-06-02 20:55:34 +0200300 aggregate_rtp_conn_stats(endp, &conn->u.rtp);
Philipp Maierd0b470d2018-03-16 12:45:53 +0100301 mgcp_rtp_conn_cleanup(&conn->u.rtp);
Philipp Maier87bd9be2017-08-22 16:35:41 +0200302 break;
303 default:
304 /* NOTE: This should never be called with an
305 * invalid type, its up to the programmer
306 * to ensure propery types */
307 OSMO_ASSERT(false);
308 }
309
Oliver Smithe36b7752019-01-22 16:31:36 +0100310 osmo_timer_del(&conn->watchdog);
Pau Espin Pedrol6d0a59a2020-09-08 16:50:22 +0200311 mgcp_endp_remove_conn(endp, conn);
312 /* WARN: endp may have be freed after call to mgcp_endp_remove_conn */
Philipp Maier87bd9be2017-08-22 16:35:41 +0200313 talloc_free(conn);
314}
315
316/*! free oldest connection in the list.
317 * \param[in] endp associated endpoint */
318void mgcp_conn_free_oldest(struct mgcp_endpoint *endp)
319{
Philipp Maier87bd9be2017-08-22 16:35:41 +0200320 struct mgcp_conn *conn;
321
322 if (llist_empty(&endp->conns))
323 return;
324
325 conn = llist_last_entry(&endp->conns, struct mgcp_conn, entry);
326 if (!conn)
327 return;
328
329 mgcp_conn_free(endp, conn->id);
330}
331
332/*! free all connections at once.
333 * \param[in] endp associated endpoint */
Eric7c0fe312021-11-09 21:45:44 +0100334#if defined(__has_attribute)
335#if __has_attribute(no_sanitize)
336__attribute__((no_sanitize("undefined"))) /* ubsan detects a misaligned load */
337#endif
338#endif
Philipp Maier87bd9be2017-08-22 16:35:41 +0200339void mgcp_conn_free_all(struct mgcp_endpoint *endp)
340{
Philipp Maier87bd9be2017-08-22 16:35:41 +0200341 struct mgcp_conn *conn;
Philipp Maier87bd9be2017-08-22 16:35:41 +0200342
Ericfdbefde2021-09-06 19:49:24 +0200343 /* Drop all items in the list, might be consecutive! */
344 while ((conn = llist_first_entry_or_null(&endp->conns, struct mgcp_conn, entry)))
Philipp Maier87bd9be2017-08-22 16:35:41 +0200345 mgcp_conn_free(endp, conn->id);
Philipp Maier87bd9be2017-08-22 16:35:41 +0200346
347 return;
348}
349
Harald Welte1d1b98f2017-12-25 10:03:40 +0100350/*! dump basic connection information to human readable string.
Philipp Maier87bd9be2017-08-22 16:35:41 +0200351 * \param[in] conn to dump
Harald Welte1d1b98f2017-12-25 10:03:40 +0100352 * \returns human readable string */
Philipp Maier87bd9be2017-08-22 16:35:41 +0200353char *mgcp_conn_dump(struct mgcp_conn *conn)
354{
Philipp Maier01d24a32017-11-21 17:26:09 +0100355 static char str[sizeof(conn->name)+sizeof(conn->id)+256];
Pau Espin Pedrola790f0c2020-08-31 13:29:11 +0200356 char ipbuf[INET6_ADDRSTRLEN];
Philipp Maier87bd9be2017-08-22 16:35:41 +0200357
358 if (!conn) {
359 snprintf(str, sizeof(str), "(null connection)");
360 return str;
361 }
362
363 switch (conn->type) {
364 case MGCP_CONN_TYPE_RTP:
365 /* Dump RTP connection */
Philipp Maier01d24a32017-11-21 17:26:09 +0100366 snprintf(str, sizeof(str), "(%s/rtp, id:0x%s, ip:%s, "
Philipp Maier87bd9be2017-08-22 16:35:41 +0200367 "rtp:%u rtcp:%u)",
368 conn->name,
369 conn->id,
Pau Espin Pedrola790f0c2020-08-31 13:29:11 +0200370 osmo_sockaddr_ntop(&conn->u.rtp.end.addr.u.sa, ipbuf),
Philipp Maier87bd9be2017-08-22 16:35:41 +0200371 ntohs(conn->u.rtp.end.rtp_port),
372 ntohs(conn->u.rtp.end.rtcp_port));
373 break;
374
375 default:
376 /* Should not happen, we should be able to dump
377 * every possible connection type. */
378 snprintf(str, sizeof(str), "(unknown connection type)");
379 break;
380 }
381
382 return str;
383}
384
385/*! find destination connection on a specific endpoint.
386 * \param[in] conn to search a destination for
387 * \returns destination connection, NULL on failure */
388struct mgcp_conn *mgcp_find_dst_conn(struct mgcp_conn *conn)
389{
390 struct mgcp_endpoint *endp;
391 struct mgcp_conn *partner_conn;
392 endp = conn->endp;
393
394 /*! NOTE: This simply works by grabbing the first connection that is
395 * not the supplied connection, which is suitable for endpoints that
396 * do not serve more than two connections. */
397
398 llist_for_each_entry(partner_conn, &endp->conns, entry) {
399 if (conn != partner_conn) {
400 return partner_conn;
401 }
402 }
403
404 return NULL;
405}
Philipp Maier889fe7f2020-07-06 17:44:12 +0200406
407/*! get oldest connection in the list.
408 * \param[in] endp associated endpoint */
409struct mgcp_conn *mgcp_conn_get_oldest(struct mgcp_endpoint *endp)
410{
411 if (llist_empty(&endp->conns))
412 return NULL;
413
414 return llist_last_entry(&endp->conns, struct mgcp_conn, entry);
415}