385 lines
11 KiB
C
385 lines
11 KiB
C
/* Code to manage a subscriber's MSC-I role */
|
|
/*
|
|
* (C) 2019 by sysmocom - s.m.f.c. GmbH <info@sysmocom.de>
|
|
* All Rights Reserved
|
|
*
|
|
* SPDX-License-Identifier: AGPL-3.0+
|
|
*
|
|
* Author: Neels Hofmeyr
|
|
*
|
|
* 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 Affero 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 <osmocom/msc/gsm_data.h>
|
|
#include <osmocom/msc/msc_i.h>
|
|
#include <osmocom/msc/ran_msg.h>
|
|
#include <osmocom/msc/ran_conn.h>
|
|
#include <osmocom/msc/ran_peer.h>
|
|
#include <osmocom/msc/sccp_ran.h>
|
|
#include <osmocom/msc/msub.h>
|
|
#include <osmocom/msc/msc_a.h>
|
|
#include <osmocom/msc/call_leg.h>
|
|
#include <osmocom/msc/mncc_call.h>
|
|
|
|
static struct osmo_fsm msc_i_fsm;
|
|
|
|
struct ran_infra *msc_i_ran(struct msc_i *msc_i)
|
|
{
|
|
OSMO_ASSERT(msc_i
|
|
&& msc_i->ran_conn
|
|
&& msc_i->ran_conn->ran_peer
|
|
&& msc_i->ran_conn->ran_peer->sri
|
|
&& msc_i->ran_conn->ran_peer->sri->ran);
|
|
return msc_i->ran_conn->ran_peer->sri->ran;
|
|
}
|
|
|
|
static int msc_i_ran_enc(struct msc_i *msc_i, const struct ran_msg *ran_enc_msg)
|
|
{
|
|
struct msgb *l3 = msc_role_ran_encode(msc_i->c.fi, ran_enc_msg);
|
|
if (!l3)
|
|
return -EIO;
|
|
return msc_i_down_l2(msc_i, l3);
|
|
}
|
|
|
|
struct msc_i *msc_i_priv(struct osmo_fsm_inst *fi)
|
|
{
|
|
OSMO_ASSERT(fi);
|
|
OSMO_ASSERT(fi->fsm == &msc_i_fsm);
|
|
OSMO_ASSERT(fi->priv);
|
|
return fi->priv;
|
|
}
|
|
|
|
int msc_i_ready_decode_cb(struct osmo_fsm_inst *msc_i_fi, void *data, const struct ran_msg *msg)
|
|
{
|
|
struct msc_i *msc_i = msc_i_priv(msc_i_fi);
|
|
struct msc_a *msc_a = msub_msc_a(msc_i->c.msub);
|
|
const struct an_apdu *an_apdu = data;
|
|
uint32_t event;
|
|
|
|
event = MSC_A_EV_FROM_I_PROCESS_ACCESS_SIGNALLING_REQUEST;
|
|
|
|
switch (msg->msg_type) {
|
|
case RAN_MSG_HANDOVER_REQUIRED:
|
|
if (msc_a->c.remote_to) {
|
|
/* We're already a remote MSC-B, this hence must be a "subsequent" handover.
|
|
* There is not much difference really from dispatching a Process Access Signalling Request,
|
|
* only that 3GPP TS 29.010 specifies the different message type. */
|
|
event = MSC_A_EV_FROM_I_PREPARE_SUBSEQUENT_HANDOVER_REQUEST;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return msub_role_dispatch(msc_i->c.msub, MSC_ROLE_A, event, an_apdu);
|
|
}
|
|
|
|
void msc_i_fsm_ready(struct osmo_fsm_inst *fi, uint32_t event, void *data)
|
|
{
|
|
struct msc_i *msc_i = msc_i_priv(fi);
|
|
struct msc_a *msc_a = msub_msc_a(msc_i->c.msub);
|
|
struct an_apdu *an_apdu;
|
|
|
|
if (!msc_a) {
|
|
LOG_MSC_I(msc_i, LOGL_ERROR, "No MSC-A role\n");
|
|
return;
|
|
}
|
|
|
|
switch (event) {
|
|
|
|
case MSC_EV_FROM_RAN_COMPLETE_LAYER_3:
|
|
an_apdu = data;
|
|
msub_role_dispatch(msc_i->c.msub, MSC_ROLE_A, MSC_A_EV_FROM_I_COMPLETE_LAYER_3, an_apdu);
|
|
break;
|
|
|
|
case MSC_EV_FROM_RAN_UP_L2:
|
|
an_apdu = data;
|
|
/* To send the correct event types like MSC_A_EV_FROM_I_PREPARE_SUBSEQUENT_HANDOVER_REQUEST and hence
|
|
* reflect the correct GSUP message type on an inter-MSC link, need to decode the message here. */
|
|
msc_role_ran_decode(msc_i->c.fi, an_apdu, msc_i_ready_decode_cb, an_apdu);
|
|
break;
|
|
|
|
case MSC_EV_FROM_RAN_CONN_RELEASED:
|
|
msc_i_cleared(msc_i);
|
|
break;
|
|
|
|
case MSC_EV_CALL_LEG_TERM:
|
|
msc_i->inter_msc.call_leg = NULL;
|
|
if (msc_i->inter_msc.mncc_forwarding_to_remote_cn)
|
|
msc_i->inter_msc.mncc_forwarding_to_remote_cn->rtps = NULL;
|
|
break;
|
|
|
|
case MSC_MNCC_EV_CALL_ENDED:
|
|
msc_i->inter_msc.mncc_forwarding_to_remote_cn = NULL;
|
|
break;
|
|
|
|
case MSC_I_EV_FROM_A_FORWARD_ACCESS_SIGNALLING_REQUEST:
|
|
case MSC_I_EV_FROM_A_PREPARE_SUBSEQUENT_HANDOVER_RESULT:
|
|
case MSC_I_EV_FROM_A_PREPARE_SUBSEQUENT_HANDOVER_ERROR:
|
|
an_apdu = data;
|
|
if (an_apdu->an_proto != msc_i_ran(msc_i)->an_proto) {
|
|
LOG_MSC_I(msc_i, LOGL_ERROR, "Mismatching AN-APDU proto: %s -- Dropping message\n",
|
|
an_proto_name(an_apdu->an_proto));
|
|
msgb_free(an_apdu->msg);
|
|
an_apdu->msg = NULL;
|
|
return;
|
|
}
|
|
msc_i_down_l2(msc_i, an_apdu->msg);
|
|
break;
|
|
|
|
case MSC_I_EV_FROM_A_SEND_END_SIGNAL_RESPONSE:
|
|
msc_i_clear(msc_i);
|
|
break;
|
|
|
|
default:
|
|
OSMO_ASSERT(false);
|
|
}
|
|
}
|
|
|
|
void msc_i_fsm_clearing_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state)
|
|
{
|
|
struct msc_i *msc_i = msc_i_priv(fi);
|
|
struct ran_msg msg = {
|
|
.msg_type = RAN_MSG_CLEAR_COMMAND,
|
|
/* Concerning CSFB (Circuit-Switched FallBack from LTE), for a final Clear Command that might indicate
|
|
* CSFB, the MSC-A has to send the Clear Command. This Clear Command is about detaching an MSC-I when a
|
|
* new MSC-I has shown up after an inter-BSC or inter-MSC Handover succeeded. So never CSFB here. */
|
|
};
|
|
msc_i_ran_enc(msc_i, &msg);
|
|
}
|
|
|
|
int msc_i_clearing_decode_cb(struct osmo_fsm_inst *msc_i_fi, void *data, const struct ran_msg *msg)
|
|
{
|
|
struct msc_i *msc_i = msc_i_fi->priv;
|
|
|
|
switch (msg->msg_type) {
|
|
|
|
case RAN_MSG_CLEAR_COMPLETE:
|
|
switch (msc_i->c.fi->state) {
|
|
case MSC_I_ST_CLEARING:
|
|
osmo_fsm_inst_state_chg(msc_i->c.fi, MSC_I_ST_CLEARED, 0, 0);
|
|
return 0;
|
|
case MSC_I_ST_CLEARED:
|
|
return 0;
|
|
default:
|
|
LOG_MSC_I(msc_i, LOGL_ERROR, "Received Clear Complete, but did not send Clear Command\n");
|
|
{
|
|
struct msc_a *msc_a = msub_msc_a(msc_i->c.msub);
|
|
if (msc_a)
|
|
osmo_fsm_inst_dispatch(msc_a->c.fi, MSC_A_EV_MO_CLOSE, NULL);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
default:
|
|
LOG_MSC_I(msc_i, LOGL_ERROR, "Message not handled: %s\n", ran_msg_type_name(msg->msg_type));
|
|
return -ENOTSUP;
|
|
}
|
|
}
|
|
|
|
void msc_i_fsm_clearing(struct osmo_fsm_inst *fi, uint32_t event, void *data)
|
|
{
|
|
struct msc_i *msc_i = msc_i_priv(fi);
|
|
struct an_apdu *an_apdu;
|
|
|
|
/* We expect a Clear Complete and nothing else. */
|
|
switch (event) {
|
|
case MSC_EV_FROM_RAN_UP_L2:
|
|
an_apdu = data;
|
|
msc_role_ran_decode(msc_i->c.fi, an_apdu, msc_i_clearing_decode_cb, NULL);
|
|
return;
|
|
|
|
case MSC_EV_FROM_RAN_CONN_RELEASED:
|
|
msc_i_cleared(msc_i);
|
|
return;
|
|
|
|
case MSC_EV_CALL_LEG_TERM:
|
|
msc_i->inter_msc.call_leg = NULL;
|
|
if (msc_i->inter_msc.mncc_forwarding_to_remote_cn)
|
|
msc_i->inter_msc.mncc_forwarding_to_remote_cn->rtps = NULL;
|
|
break;
|
|
|
|
case MSC_MNCC_EV_CALL_ENDED:
|
|
msc_i->inter_msc.mncc_forwarding_to_remote_cn = NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void msc_i_fsm_cleared_onenter(struct osmo_fsm_inst *fi, uint32_t prev_state)
|
|
{
|
|
osmo_fsm_inst_term(fi, OSMO_FSM_TERM_REGULAR, fi);
|
|
}
|
|
|
|
void msc_i_fsm_cleanup(struct osmo_fsm_inst *fi, enum osmo_fsm_term_cause cause)
|
|
{
|
|
struct msc_i *msc_i = msc_i_priv(fi);
|
|
|
|
call_leg_release(msc_i->inter_msc.call_leg);
|
|
mncc_call_release(msc_i->inter_msc.mncc_forwarding_to_remote_cn);
|
|
|
|
if (msc_i->ran_conn)
|
|
ran_conn_msc_role_gone(msc_i->ran_conn, msc_i->c.fi);
|
|
}
|
|
|
|
#define S(x) (1 << (x))
|
|
|
|
static const struct osmo_fsm_state msc_i_fsm_states[] = {
|
|
[MSC_I_ST_READY] = {
|
|
.name = "READY",
|
|
.action = msc_i_fsm_ready,
|
|
.in_event_mask = 0
|
|
| S(MSC_EV_FROM_RAN_COMPLETE_LAYER_3)
|
|
| S(MSC_EV_FROM_RAN_UP_L2)
|
|
| S(MSC_EV_FROM_RAN_CONN_RELEASED)
|
|
| S(MSC_EV_CALL_LEG_TERM)
|
|
| S(MSC_MNCC_EV_CALL_ENDED)
|
|
| S(MSC_I_EV_FROM_A_FORWARD_ACCESS_SIGNALLING_REQUEST)
|
|
| S(MSC_I_EV_FROM_A_PREPARE_SUBSEQUENT_HANDOVER_RESULT)
|
|
| S(MSC_I_EV_FROM_A_PREPARE_SUBSEQUENT_HANDOVER_ERROR)
|
|
| S(MSC_I_EV_FROM_A_SEND_END_SIGNAL_RESPONSE)
|
|
,
|
|
.out_state_mask = 0
|
|
| S(MSC_I_ST_CLEARING)
|
|
| S(MSC_I_ST_CLEARED)
|
|
,
|
|
},
|
|
[MSC_I_ST_CLEARING] = {
|
|
.name = "CLEARING",
|
|
.onenter = msc_i_fsm_clearing_onenter,
|
|
.action = msc_i_fsm_clearing,
|
|
.in_event_mask = 0
|
|
| S(MSC_EV_FROM_RAN_UP_L2)
|
|
| S(MSC_EV_FROM_RAN_CONN_RELEASED)
|
|
| S(MSC_EV_CALL_LEG_TERM)
|
|
| S(MSC_MNCC_EV_CALL_ENDED)
|
|
,
|
|
.out_state_mask = 0
|
|
| S(MSC_I_ST_CLEARED)
|
|
,
|
|
},
|
|
[MSC_I_ST_CLEARED] = {
|
|
.name = "CLEARED",
|
|
.onenter = msc_i_fsm_cleared_onenter,
|
|
},
|
|
};
|
|
|
|
const struct value_string msc_i_fsm_event_names[] = {
|
|
OSMO_VALUE_STRING(MSC_REMOTE_EV_RX_GSUP),
|
|
OSMO_VALUE_STRING(MSC_EV_CALL_LEG_RTP_LOCAL_ADDR_AVAILABLE),
|
|
OSMO_VALUE_STRING(MSC_EV_CALL_LEG_RTP_COMPLETE),
|
|
OSMO_VALUE_STRING(MSC_EV_CALL_LEG_TERM),
|
|
OSMO_VALUE_STRING(MSC_MNCC_EV_NEED_LOCAL_RTP),
|
|
OSMO_VALUE_STRING(MSC_MNCC_EV_CALL_PROCEEDING),
|
|
OSMO_VALUE_STRING(MSC_MNCC_EV_CALL_COMPLETE),
|
|
OSMO_VALUE_STRING(MSC_MNCC_EV_CALL_ENDED),
|
|
|
|
OSMO_VALUE_STRING(MSC_EV_FROM_RAN_COMPLETE_LAYER_3),
|
|
OSMO_VALUE_STRING(MSC_EV_FROM_RAN_UP_L2),
|
|
OSMO_VALUE_STRING(MSC_EV_FROM_RAN_CONN_RELEASED),
|
|
|
|
OSMO_VALUE_STRING(MSC_I_EV_FROM_A_FORWARD_ACCESS_SIGNALLING_REQUEST),
|
|
OSMO_VALUE_STRING(MSC_I_EV_FROM_A_PREPARE_SUBSEQUENT_HANDOVER_RESULT),
|
|
OSMO_VALUE_STRING(MSC_I_EV_FROM_A_PREPARE_SUBSEQUENT_HANDOVER_ERROR),
|
|
OSMO_VALUE_STRING(MSC_I_EV_FROM_A_SEND_END_SIGNAL_RESPONSE),
|
|
{}
|
|
};
|
|
|
|
static struct osmo_fsm msc_i_fsm = {
|
|
.name = "msc_i",
|
|
.states = msc_i_fsm_states,
|
|
.num_states = ARRAY_SIZE(msc_i_fsm_states),
|
|
.log_subsys = DMSC,
|
|
.event_names = msc_i_fsm_event_names,
|
|
.cleanup = msc_i_fsm_cleanup,
|
|
};
|
|
|
|
static __attribute__((constructor)) void msc_i_fsm_init(void)
|
|
{
|
|
OSMO_ASSERT(osmo_fsm_register(&msc_i_fsm) == 0);
|
|
}
|
|
|
|
/* Send connection-oriented L3 message to RAN peer (MSC->[BSC|RNC]) */
|
|
int msc_i_down_l2(struct msc_i *msc_i, struct msgb *l3)
|
|
{
|
|
int rc;
|
|
if (!msc_i->ran_conn) {
|
|
LOG_MSC_I(msc_i, LOGL_ERROR, "Cannot Tx L2 message: no RAN conn\n");
|
|
return -EIO;
|
|
}
|
|
|
|
rc = ran_conn_down_l2_co(msc_i->ran_conn, l3, false);
|
|
if (rc)
|
|
LOG_MSC_I(msc_i, LOGL_ERROR, "Failed to transfer message down to subscriber (rc=%d)\n", rc);
|
|
return rc;
|
|
}
|
|
|
|
struct gsm_network *msc_i_net(const struct msc_i *msc_i)
|
|
{
|
|
return msub_net(msc_i->c.msub);
|
|
}
|
|
|
|
struct vlr_subscr *msc_i_vsub(const struct msc_i *msc_i)
|
|
{
|
|
if (!msc_i)
|
|
return NULL;
|
|
return msub_vsub(msc_i->c.msub);
|
|
}
|
|
|
|
struct msc_i *msc_i_alloc(struct msub *msub, struct ran_infra *ran)
|
|
{
|
|
return msub_role_alloc(msub, MSC_ROLE_I, &msc_i_fsm, struct msc_i, ran);
|
|
}
|
|
|
|
/* Send Clear Command and wait for Clear Complete autonomously. "Normally", the MSC-A handles Clear Command and receives
|
|
* Clear Complete, and then terminates MSC-I directly. This is useful to replace an MSC-I with another MSC-I during
|
|
* Handover. */
|
|
void msc_i_clear(struct msc_i *msc_i)
|
|
{
|
|
if (!msc_i)
|
|
return;
|
|
/* sanity timeout */
|
|
osmo_fsm_inst_state_chg(msc_i->c.fi, MSC_I_ST_CLEARING, 60, 0);
|
|
}
|
|
|
|
void msc_i_cleared(struct msc_i *msc_i)
|
|
{
|
|
if (!msc_i)
|
|
return;
|
|
osmo_fsm_inst_state_chg(msc_i->c.fi, MSC_I_ST_CLEARED, 0, 0);
|
|
}
|
|
|
|
void msc_i_set_ran_conn(struct msc_i *msc_i, struct ran_conn *new_conn)
|
|
{
|
|
struct ran_conn *old_conn = msc_i->ran_conn;
|
|
|
|
if (old_conn == new_conn)
|
|
return;
|
|
|
|
msc_i->ran_conn = NULL;
|
|
if (old_conn) {
|
|
old_conn->msc_role = NULL;
|
|
ran_conn_close(old_conn);
|
|
}
|
|
|
|
/* Taking a conn over from another MSC role? Make sure the other side forgets about it. */
|
|
if (new_conn->msc_role)
|
|
msc_role_forget_conn(new_conn->msc_role, new_conn);
|
|
|
|
msc_i->ran_conn = new_conn;
|
|
msc_i->ran_conn->msc_role = msc_i->c.fi;
|
|
|
|
/* Add the RAN conn info to the msub logging */
|
|
msub_update_id(msc_i->c.msub);
|
|
}
|