2016-03-22 13:47:38 +00:00
|
|
|
/*
|
|
|
|
* (C) 2016 by Holger Hans Peter Freyther
|
|
|
|
*
|
|
|
|
* All Rights Reserved
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "call.h"
|
2016-03-22 15:31:26 +00:00
|
|
|
#include "logging.h"
|
|
|
|
|
|
|
|
#include <talloc.h>
|
2016-03-22 13:47:38 +00:00
|
|
|
|
2016-03-22 19:56:45 +00:00
|
|
|
extern void *tall_mncc_ctx;
|
2016-03-22 13:47:38 +00:00
|
|
|
|
|
|
|
LLIST_HEAD(g_call_list);
|
2016-03-22 19:56:45 +00:00
|
|
|
static uint32_t last_call_id = 5000;
|
2016-03-22 15:31:26 +00:00
|
|
|
|
2016-04-04 15:06:29 +00:00
|
|
|
|
|
|
|
const struct value_string call_type_vals[] = {
|
|
|
|
{ CALL_TYPE_NONE, "NONE" },
|
|
|
|
{ CALL_TYPE_SIP, "SIP" },
|
|
|
|
{ CALL_TYPE_MNCC, "MNCC" },
|
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
const struct value_string mncc_state_vals[] = {
|
|
|
|
{ MNCC_CC_INITIAL, "INITIAL" },
|
|
|
|
{ MNCC_CC_PROCEEDING, "PROCEEDING" },
|
|
|
|
{ MNCC_CC_CONNECTED, "CONNECTED" },
|
2019-07-30 14:26:03 +00:00
|
|
|
{ MNCC_CC_HOLD, "ON HOLD" },
|
2016-04-04 15:06:29 +00:00
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
const struct value_string mncc_dir_vals[] = {
|
|
|
|
{ MNCC_DIR_MO, "MO" },
|
|
|
|
{ MNCC_DIR_MT, "MT" },
|
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
const struct value_string sip_state_vals[] = {
|
|
|
|
{ SIP_CC_INITIAL, "INITIAL" },
|
|
|
|
{ SIP_CC_DLG_CNFD, "CONFIRMED" },
|
|
|
|
{ SIP_CC_CONNECTED, "CONNECTED" },
|
2019-07-30 14:26:03 +00:00
|
|
|
{ SIP_CC_HOLD, "ON HOLD" },
|
2016-04-04 15:06:29 +00:00
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
|
|
|
const struct value_string sip_dir_vals[] = {
|
|
|
|
{ SIP_DIR_MO, "MO" },
|
|
|
|
{ SIP_DIR_MT, "MT" },
|
|
|
|
{ 0, NULL },
|
|
|
|
};
|
|
|
|
|
2016-03-22 15:31:26 +00:00
|
|
|
void calls_init(void)
|
|
|
|
{}
|
|
|
|
|
2016-03-22 20:03:19 +00:00
|
|
|
void call_leg_release(struct call_leg *leg)
|
2016-03-22 15:31:26 +00:00
|
|
|
{
|
2016-03-22 20:03:19 +00:00
|
|
|
struct call *call = leg->call;
|
|
|
|
|
|
|
|
|
2016-03-22 15:31:26 +00:00
|
|
|
if (leg == call->initial)
|
|
|
|
call->initial = NULL;
|
|
|
|
else if (leg == call->remote)
|
|
|
|
call->remote = NULL;
|
|
|
|
else {
|
|
|
|
LOGP(DAPP, LOGL_ERROR, "call(%u) with unknown leg(%p/%d)\n",
|
|
|
|
call->id, leg, leg->type);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
talloc_free(leg);
|
|
|
|
if (!call->initial && !call->remote) {
|
2016-03-24 17:47:25 +00:00
|
|
|
uint32_t id = call->id;
|
2016-03-22 15:31:26 +00:00
|
|
|
llist_del(&call->entry);
|
|
|
|
talloc_free(call);
|
2016-03-24 17:47:25 +00:00
|
|
|
LOGP(DAPP, LOGL_DEBUG, "call(%u) released.\n", id);
|
2016-03-22 15:31:26 +00:00
|
|
|
}
|
|
|
|
}
|
2016-03-22 19:56:45 +00:00
|
|
|
|
2016-03-26 17:52:22 +00:00
|
|
|
struct call *call_mncc_create(void)
|
2016-03-22 19:56:45 +00:00
|
|
|
{
|
|
|
|
struct call *call;
|
|
|
|
|
|
|
|
call = talloc_zero(tall_mncc_ctx, struct call);
|
|
|
|
if (!call) {
|
|
|
|
LOGP(DCALL, LOGL_ERROR, "Failed to allocate memory for call\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
call->id = ++last_call_id;
|
|
|
|
|
|
|
|
call->initial = (struct call_leg *) talloc_zero(call, struct mncc_call_leg);
|
|
|
|
if (!call->initial) {
|
|
|
|
LOGP(DCALL, LOGL_ERROR, "Failed to allocate MNCC leg\n");
|
|
|
|
talloc_free(call);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
call->initial->type = CALL_TYPE_MNCC;
|
2016-03-22 20:03:19 +00:00
|
|
|
call->initial->call = call;
|
2016-03-22 19:56:45 +00:00
|
|
|
llist_add(&call->entry, &g_call_list);
|
|
|
|
return call;
|
|
|
|
}
|
2016-03-24 17:48:45 +00:00
|
|
|
|
2016-03-26 18:51:33 +00:00
|
|
|
struct call *call_sip_create(void)
|
|
|
|
{
|
|
|
|
struct call *call;
|
|
|
|
|
|
|
|
call = talloc_zero(tall_mncc_ctx, struct call);
|
|
|
|
if (!call) {
|
|
|
|
LOGP(DCALL, LOGL_ERROR, "Failed to allocate memory for call\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
call->id = ++last_call_id;
|
|
|
|
|
|
|
|
call->initial = (struct call_leg *) talloc_zero(call, struct sip_call_leg);
|
|
|
|
if (!call->initial) {
|
|
|
|
LOGP(DCALL, LOGL_ERROR, "Failed to allocate SIP leg\n");
|
|
|
|
talloc_free(call);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
call->initial->type = CALL_TYPE_SIP;
|
|
|
|
call->initial->call = call;
|
|
|
|
llist_add(&call->entry, &g_call_list);
|
|
|
|
return call;
|
|
|
|
}
|
|
|
|
|
2016-03-24 17:48:45 +00:00
|
|
|
struct call_leg *call_leg_other(struct call_leg *leg)
|
|
|
|
{
|
|
|
|
if (leg->call->initial == leg)
|
|
|
|
return leg->call->remote;
|
|
|
|
if (leg->call->remote == leg)
|
|
|
|
return leg->call->initial;
|
|
|
|
|
|
|
|
LOGP(DAPP, LOGL_NOTICE, "leg(0x%p) not belonging to call(%u)\n",
|
|
|
|
leg, leg->call->id);
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-04-04 15:06:29 +00:00
|
|
|
|
|
|
|
const char *call_leg_type(struct call_leg *leg)
|
|
|
|
{
|
|
|
|
return get_value_string(call_type_vals, leg->type);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *call_leg_state(struct call_leg *leg)
|
|
|
|
{
|
|
|
|
struct mncc_call_leg *mncc;
|
|
|
|
struct sip_call_leg *sip;
|
|
|
|
|
|
|
|
switch (leg->type) {
|
|
|
|
case CALL_TYPE_SIP:
|
|
|
|
sip = (struct sip_call_leg *) leg;
|
|
|
|
return get_value_string(sip_state_vals, sip->state);
|
|
|
|
case CALL_TYPE_MNCC:
|
|
|
|
mncc = (struct mncc_call_leg *) leg;
|
|
|
|
return get_value_string(mncc_state_vals, mncc->state);
|
|
|
|
default:
|
2019-08-06 14:45:12 +00:00
|
|
|
return "Unknown call type";
|
2016-04-04 15:06:29 +00:00
|
|
|
}
|
|
|
|
}
|
forward SDP between SIP and MNCC
We have added support for sending SDP via MNCC a long time ago, but so
far the SDP section remained empty. Now, implement actually forwarding
SDP codec information between SIP and MNCC.
The aim is to let the MSC know about all codec choices the remote SIP
call leg has to offer, so that finding a codec match between local and
remote call leg becomes possible.
Store any SDP info contained in incoming SIP and MNCC messages, and send
the stored SDP to the other call leg in all outgoing SIP and MNCC
messages.
In sdp_create_file(), we used to compose fixed SDP -- instead, take the
other call leg's SDP as-is, only make sure to modify the mode (e.g.
"a=sendrecv") to reflect the current call hold state.
The RTP address and codec info in the MNCC structures is now essentially
a redundant / possibly less accurate copy of the SDP info, but leave all
of that as-is, for backwards compat.
There is codec checking that may reject unexpected codecs. The
overall/future aim is to leave all codec checking up to the MSC, but so
far just leave current behaviour unchanged, until we notice problems.
Related: SYS#5066
Related: osmo-ttcn3-hacks Ib2ae8449e673f5027f01d428d3718c006f76d93e
Change-Id: I3df5d06f38ee2d122706a9ebffde7db4f2bd6bae
2019-08-15 04:12:54 +00:00
|
|
|
|
|
|
|
void call_leg_rx_sdp(struct call_leg *leg, const char *rx_sdp)
|
|
|
|
{
|
|
|
|
/* If no SDP was received, keep whatever SDP was previously seen. */
|
|
|
|
if (!rx_sdp || !*rx_sdp || !strncmp(leg->rx_sdp, rx_sdp, sizeof(leg->rx_sdp))) {
|
|
|
|
LOGP(DAPP, LOGL_DEBUG, "call(%u) leg(0x%p) no new SDP in %s\n", leg->call->id, leg,
|
|
|
|
osmo_quote_str(rx_sdp, -1));
|
|
|
|
LOGP(DAPP, LOGL_DEBUG, "call(%u) leg(0x%p) keep stored SDP=%s\n", leg->call->id, leg,
|
|
|
|
osmo_quote_str(leg->rx_sdp, -1));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
LOGP(DAPP, LOGL_DEBUG, "call(%u) leg(0x%p) received new SDP=%s\n", leg->call->id, leg, osmo_quote_str(rx_sdp, -1));
|
|
|
|
LOGP(DAPP, LOGL_DEBUG, "call(%u) leg(0x%p) replaced old SDP=%s\n", leg->call->id, leg,
|
|
|
|
osmo_quote_str(leg->rx_sdp, -1));
|
|
|
|
OSMO_STRLCPY_ARRAY(leg->rx_sdp, rx_sdp);
|
|
|
|
leg->rx_sdp_changed = true;
|
|
|
|
}
|