380 lines
12 KiB
C
380 lines
12 KiB
C
/* E-interface messaging over a GSUP connection */
|
|
/*
|
|
* (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/core/fsm.h>
|
|
#include <osmocom/gsupclient/gsup_client.h>
|
|
|
|
#include <osmocom/msc/gsm_data.h>
|
|
#include <osmocom/msc/gsup_client_mux.h>
|
|
#include <osmocom/msc/e_link.h>
|
|
#include <osmocom/msc/msub.h>
|
|
#include <osmocom/msc/msc_roles.h>
|
|
#include <osmocom/msc/vlr.h>
|
|
#include <osmocom/msc/ran_infra.h>
|
|
#include <osmocom/msc/msc_a.h>
|
|
#include <osmocom/msc/msc_a_remote.h>
|
|
#include <osmocom/msc/msc_i.h>
|
|
#include <osmocom/msc/msc_i_remote.h>
|
|
#include <osmocom/msc/msc_t.h>
|
|
#include <osmocom/msc/msc_t_remote.h>
|
|
|
|
#define LOG_E_LINK(e_link, level, fmt, args...) \
|
|
LOGPFSML(e_link->msc_role, level, fmt, ##args)
|
|
|
|
#define LOG_E_LINK_CAT(e_link, ss, level, fmt, args...) \
|
|
LOGPFSMSL(e_link->msc_role, ss, level, fmt, ##args)
|
|
|
|
void e_link_assign(struct e_link *e, struct osmo_fsm_inst *msc_role)
|
|
{
|
|
struct msc_role_common *c;
|
|
if (e->msc_role) {
|
|
c = e->msc_role->priv;
|
|
if (c->remote_to == e) {
|
|
c->remote_to = NULL;
|
|
msub_update_id(c->msub);
|
|
}
|
|
}
|
|
|
|
c = msc_role->priv;
|
|
e->msc_role = msc_role;
|
|
c->remote_to = e;
|
|
|
|
msub_update_id(c->msub);
|
|
LOG_E_LINK(e, LOGL_DEBUG, "Assigned E-link to %s\n", e_link_name(e));
|
|
}
|
|
|
|
struct e_link *e_link_alloc(struct gsup_client_mux *gcm, struct osmo_fsm_inst *msc_role,
|
|
const uint8_t *remote_name, size_t remote_name_len)
|
|
{
|
|
struct e_link *e;
|
|
struct msc_role_common *c = msc_role->priv;
|
|
size_t use_len;
|
|
|
|
/* use msub as talloc parent, so we can move an e_link from msc_t to msc_i when it is established. */
|
|
e = talloc_zero(c->msub, struct e_link);
|
|
if (!e)
|
|
return NULL;
|
|
|
|
e->gcm = gcm;
|
|
|
|
/* FIXME: this is a braindamaged duality of char* and blob, which we can't seem to get rid of easily.
|
|
* See also osmo-hlr change I01a45900e14d41bcd338f50ad85d9fabf2c61405 which resolved this on the
|
|
* osmo-hlr side, but was abandoned. Not sure which way is the right solution. */
|
|
/* To be able to include a terminating NUL character when sending the IPA name, append one if there is none yet.
|
|
* Current osmo-hlr needs the terminating NUL to be included. */
|
|
use_len = remote_name_len;
|
|
if (remote_name[use_len-1] != '\0')
|
|
use_len++;
|
|
e->remote_name = talloc_size(e, use_len);
|
|
OSMO_ASSERT(e->remote_name);
|
|
memcpy(e->remote_name, remote_name, remote_name_len);
|
|
e->remote_name[use_len-1] = '\0';
|
|
e->remote_name_len = use_len;
|
|
|
|
e_link_assign(e, msc_role);
|
|
return e;
|
|
}
|
|
|
|
void e_link_free(struct e_link *e)
|
|
{
|
|
if (!e)
|
|
return;
|
|
if (e->msc_role) {
|
|
struct msc_role_common *c = e->msc_role->priv;
|
|
if (c->remote_to == e)
|
|
c->remote_to = NULL;
|
|
}
|
|
talloc_free(e);
|
|
}
|
|
|
|
/* Set up IMSI, source and destination names in given gsup_msg struct. */
|
|
int e_prep_gsup_msg(struct e_link *e, struct osmo_gsup_message *gsup_msg)
|
|
{
|
|
struct msc_role_common *c;
|
|
struct vlr_subscr *vsub;
|
|
const char *local_msc_name = NULL;
|
|
|
|
if (e->gcm && e->gcm->gsup_client && e->gcm->gsup_client->ipa_dev) {
|
|
local_msc_name = e->gcm->gsup_client->ipa_dev->serno;
|
|
if (!local_msc_name)
|
|
local_msc_name = e->gcm->gsup_client->ipa_dev->unit_name;
|
|
}
|
|
|
|
if (!local_msc_name) {
|
|
LOG_E_LINK(e, LOGL_ERROR, "Cannot prep E-interface GSUP message: no local MSC name defined\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
c = e->msc_role->priv;
|
|
vsub = c->msub->vsub;
|
|
*gsup_msg = (struct osmo_gsup_message){
|
|
.message_class = OSMO_GSUP_MESSAGE_CLASS_INTER_MSC,
|
|
.source_name = (const uint8_t*)local_msc_name,
|
|
.source_name_len = strlen(local_msc_name)+1, /* include terminating nul */
|
|
.destination_name = (const uint8_t*)e->remote_name,
|
|
.destination_name_len = e->remote_name_len, /* the nul here is also included, from e_link_alloc() */
|
|
};
|
|
|
|
if (vsub)
|
|
OSMO_STRLCPY_ARRAY(gsup_msg->imsi, vsub->imsi);
|
|
return 0;
|
|
}
|
|
|
|
int e_tx(struct e_link *e, const struct osmo_gsup_message *gsup_msg)
|
|
{
|
|
LOG_E_LINK_CAT(e, DLGSUP, LOGL_DEBUG, "Tx GSUP %s to %s\n",
|
|
osmo_gsup_message_type_name(gsup_msg->message_type),
|
|
e_link_name(e));
|
|
return gsup_client_mux_tx(e->gcm, gsup_msg);
|
|
}
|
|
|
|
const char *e_link_name(struct e_link *e)
|
|
{
|
|
return osmo_escape_str((const char*)e->remote_name, e->remote_name_len);
|
|
}
|
|
|
|
static struct msub *msc_new_msc_t_for_handover_request(struct gsm_network *net,
|
|
const struct osmo_gsup_message *gsup_msg)
|
|
{
|
|
struct ran_infra *ran;
|
|
struct msub *msub;
|
|
struct msc_a *msc_a;
|
|
struct vlr_subscr *vsub;
|
|
|
|
switch (gsup_msg->an_apdu.access_network_proto) {
|
|
case OSMO_GSUP_ACCESS_NETWORK_PROTOCOL_TS3G_48006:
|
|
ran = &msc_ran_infra[OSMO_RAT_GERAN_A];
|
|
break;
|
|
case OSMO_GSUP_ACCESS_NETWORK_PROTOCOL_TS3G_25413:
|
|
ran = &msc_ran_infra[OSMO_RAT_UTRAN_IU];
|
|
break;
|
|
default:
|
|
ran = NULL;
|
|
break;
|
|
}
|
|
|
|
if (!ran || !ran->ran_dec_l2) {
|
|
LOGP(DLGSUP, LOGL_ERROR, "Cannot handle AN-proto %s\n",
|
|
an_proto_name(gsup_msg->an_apdu.access_network_proto));
|
|
return NULL;
|
|
}
|
|
|
|
msub = msub_alloc(net);
|
|
|
|
/* To properly compose GSUP messages going back to the remote peer, make sure the incoming IMSI is set in a
|
|
* vlr_subscr associated with the msub. */
|
|
vsub = vlr_subscr_find_or_create_by_imsi(net->vlr, gsup_msg->imsi, __func__, NULL);
|
|
msub_set_vsub(msub, vsub);
|
|
vlr_subscr_put(vsub, __func__);
|
|
|
|
LOG_MSUB_CAT(msub, DLGSUP, LOGL_DEBUG, "New subscriber for incoming inter-MSC Handover Request\n");
|
|
|
|
msc_a = msc_a_remote_alloc(msub, ran, gsup_msg->source_name, gsup_msg->source_name_len);
|
|
if (!msc_a) {
|
|
osmo_fsm_inst_term(msub->fi, OSMO_FSM_TERM_REQUEST, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
LOG_MSC_A_REMOTE_CAT(msc_a, DLGSUP, LOGL_DEBUG, "New subscriber for incoming inter-MSC Handover Request\n");
|
|
return msub;
|
|
}
|
|
|
|
static bool name_matches(const uint8_t *name, size_t len, const uint8_t *match_name, size_t match_len)
|
|
{
|
|
if (!match_name)
|
|
return !name || !len;
|
|
if (len != match_len)
|
|
return false;
|
|
return memcmp(name, match_name, len) == 0;
|
|
}
|
|
|
|
static bool e_link_matches_gsup_msg_source_name(const struct e_link *e, const struct osmo_gsup_message *gsup_msg)
|
|
{
|
|
return name_matches(gsup_msg->source_name, gsup_msg->source_name_len, e->remote_name, e->remote_name_len);
|
|
}
|
|
|
|
static int msc_a_i_t_gsup_rx(struct gsup_client_mux *gcm, void *data, const struct osmo_gsup_message *gsup_msg)
|
|
{
|
|
struct gsm_network *net = data;
|
|
struct vlr_instance *vlr = net->vlr;
|
|
struct vlr_subscr *vsub;
|
|
struct msub *msub;
|
|
struct osmo_fsm_inst *msc_role = NULL;
|
|
struct e_link *e;
|
|
struct msc_role_common *c;
|
|
int i;
|
|
|
|
OSMO_ASSERT(net);
|
|
|
|
vsub = vlr_subscr_find_by_imsi(vlr, gsup_msg->imsi, __func__);
|
|
if (vsub)
|
|
LOGP(DLGSUP, LOGL_DEBUG, "Found VLR entry for IMSI %s\n", gsup_msg->imsi);
|
|
|
|
msub = msub_for_vsub(vsub);
|
|
if (msub)
|
|
LOG_MSUB_CAT(msub, DLGSUP, LOGL_DEBUG, "Found already attached subscriber for IMSI %s\n",
|
|
gsup_msg->imsi);
|
|
|
|
if (vsub) {
|
|
vlr_subscr_put(vsub, __func__);
|
|
vsub = NULL;
|
|
}
|
|
|
|
/* Only for an incoming Handover Request: create a new remote-MSC-A as proxy for the MSC-A that is sending the
|
|
* Handover Request */
|
|
if (!msub && gsup_msg->message_type == OSMO_GSUP_MSGT_E_PREPARE_HANDOVER_REQUEST) {
|
|
msub = msc_new_msc_t_for_handover_request(net, gsup_msg);
|
|
}
|
|
|
|
if (!msub) {
|
|
LOGP(DLGSUP, LOGL_ERROR, "%s: Cannot find subscriber for IMSI %s\n",
|
|
__func__, osmo_quote_str(gsup_msg->imsi, -1));
|
|
return -EINVAL;
|
|
}
|
|
|
|
LOG_MSUB_CAT(msub, DLGSUP, LOGL_DEBUG, "Rx GSUP %s\n", osmo_gsup_message_type_name(gsup_msg->message_type));
|
|
|
|
e = NULL;
|
|
for (i = 0; i < ARRAY_SIZE(msub->role); i++) {
|
|
msc_role = msub->role[i];
|
|
if (!msc_role) {
|
|
LOG_MSUB_CAT(msub, DLGSUP, LOGL_DEBUG, "No %s\n", msc_role_name(i));
|
|
continue;
|
|
}
|
|
c = msc_role->priv;
|
|
if (!c->remote_to) {
|
|
LOG_MSUB_CAT(msub, DLGSUP, LOGL_DEBUG, "%s has no remote\n", msc_role_name(i));
|
|
continue;
|
|
}
|
|
if (!e_link_matches_gsup_msg_source_name(c->remote_to, gsup_msg)) {
|
|
LOG_MSUB_CAT(msub, DLGSUP, LOGL_DEBUG, "%s has remote to mismatching %s\n", msc_role_name(i),
|
|
c->remote_to->remote_name);
|
|
continue;
|
|
}
|
|
/* Found a match. */
|
|
e = c->remote_to;
|
|
break;
|
|
}
|
|
|
|
if (!e) {
|
|
LOG_MSUB_CAT(msub, DLGSUP, LOGL_ERROR,
|
|
"There is no E link that matches: Rx GSUP %s from %s\n",
|
|
osmo_gsup_message_type_name(gsup_msg->message_type),
|
|
osmo_quote_str((const char*)gsup_msg->source_name, gsup_msg->source_name_len));
|
|
return -EINVAL;
|
|
}
|
|
|
|
LOG_MSUB_CAT(msub, DLGSUP, LOGL_DEBUG,
|
|
"Rx GSUP %s from %s %s\n",
|
|
osmo_gsup_message_type_name(gsup_msg->message_type),
|
|
msc_role_name(c->role),
|
|
e_link_name(e));
|
|
|
|
return osmo_fsm_inst_dispatch(msc_role, MSC_REMOTE_EV_RX_GSUP, (void*)gsup_msg);
|
|
}
|
|
|
|
void msc_a_i_t_gsup_init(struct gsm_network *net)
|
|
{
|
|
OSMO_ASSERT(net->gcm);
|
|
OSMO_ASSERT(net->vlr);
|
|
|
|
net->gcm->rx_cb[OSMO_GSUP_MESSAGE_CLASS_INTER_MSC] = (struct gsup_client_mux_rx_cb){
|
|
.func = msc_a_i_t_gsup_rx,
|
|
.data = net,
|
|
};
|
|
}
|
|
|
|
int gsup_msg_assign_an_apdu(struct osmo_gsup_message *gsup_msg, struct an_apdu *an_apdu)
|
|
{
|
|
if (!an_apdu) {
|
|
LOGP(DLGSUP, LOGL_ERROR, "Cannot assign NULL AN-APDU\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
gsup_msg->an_apdu = (struct osmo_gsup_an_apdu){
|
|
.access_network_proto = an_apdu->an_proto,
|
|
};
|
|
|
|
if (an_apdu->msg) {
|
|
gsup_msg->an_apdu.data = msgb_l2(an_apdu->msg);
|
|
gsup_msg->an_apdu.data_len = msgb_l2len(an_apdu->msg);
|
|
if (!gsup_msg->an_apdu.data || !gsup_msg->an_apdu.data_len) {
|
|
LOGP(DLGSUP, LOGL_ERROR, "Cannot assign AN-APDU without msg->l2 to GSUP message: %s\n",
|
|
msgb_hexdump(an_apdu->msg));
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
/* We are composing a struct osmo_gsup_msg from the osmo-msc internal struct an_apdu. The an_apdu may contain
|
|
* additional info in form of a partly filled an_apdu->e_info. Make sure that data ends up in the resulting full
|
|
* osmo_gsup_message. */
|
|
if (an_apdu->e_info) {
|
|
const struct osmo_gsup_message *s = an_apdu->e_info;
|
|
|
|
gsup_msg->msisdn_enc = s->msisdn_enc;
|
|
gsup_msg->msisdn_enc_len = s->msisdn_enc_len;
|
|
|
|
if (s->cause_rr_set) {
|
|
gsup_msg->cause_rr = s->cause_rr;
|
|
gsup_msg->cause_rr_set = true;
|
|
}
|
|
if (s->cause_bssap_set) {
|
|
gsup_msg->cause_bssap = s->cause_bssap;
|
|
gsup_msg->cause_bssap_set = true;
|
|
}
|
|
if (s->cause_sm)
|
|
gsup_msg->cause_sm = s->cause_sm;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Allocate a new msgb to contain the gsup_msg->an_apdu's data as l2h.
|
|
* The msgb will have sufficient headroom to be passed down a RAN peer's SCCP user SAP. */
|
|
struct msgb *gsup_msg_to_msgb(const struct osmo_gsup_message *gsup_msg)
|
|
{
|
|
struct msgb *pdu;
|
|
const uint8_t *pdu_data = gsup_msg->an_apdu.data;
|
|
uint8_t pdu_len = gsup_msg->an_apdu.data_len;
|
|
|
|
if (!pdu_data || !pdu_len)
|
|
return NULL;
|
|
|
|
/* Strictly speaking this is not limited to BSSMAP, but why not just use those sizes. */
|
|
pdu = msgb_alloc_headroom(BSSMAP_MSG_SIZE, BSSMAP_MSG_HEADROOM, "AN-APDU from gsup_msg");
|
|
|
|
pdu->l2h = msgb_put(pdu, pdu_len);
|
|
memcpy(pdu->l2h, pdu_data, pdu_len);
|
|
return pdu;
|
|
}
|
|
|
|
/* Compose a struct an_apdu from the data found in gsup_msg. gsup_msg_to_msgb() is used to wrap the data in a static
|
|
* msgb, so the returned an_apdu->msg must be freed if not NULL. */
|
|
void gsup_msg_to_an_apdu(struct an_apdu *an_apdu, const struct osmo_gsup_message *gsup_msg)
|
|
{
|
|
*an_apdu = (struct an_apdu){
|
|
.an_proto = gsup_msg->an_apdu.access_network_proto,
|
|
.msg = gsup_msg_to_msgb(gsup_msg),
|
|
.e_info = gsup_msg,
|
|
};
|
|
}
|