osmo-msc/src/libmsc/msc_i.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);
}