paulmataruso/osmo-sgsn
1
0
Fork 0
mirror of https://gitea.osmocom.org/cellular-infrastructure/osmo-sgsn.git synced 2025-11-02 13:13:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Split most of iu_client.{c,h} into sccp.{c,h} and iu_rnc.{c,h}

Browse Source 
* iu_rnc is easily spotted as an object class in the data domain which
  can be put into its own file, handling its specific logic and data.

* SCCP code can also be moved into own specific file, which eases
  self-containment of the layer logic and data.

* As a result, lots of RANAP Rx/Tx code in iu_client.{c,h} can also be
  moved to the already existing gprs_ranap.{c,h}.

All these changes improve a lot readibility of code and makes it a lot
easier to improve/extend the different layers/objects in future patches.

Change-Id: I4c792ae665720460b5a954b5c7cbfe5acbc37473
This commit is contained in:
Pau Espin Pedrol
2025-08-26 14:48:52 +02:00
parent 77cf72ea91
commit 265bc33b05
16 changed files with 1302 additions and 1055 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/osmocom/sgsn/Makefile.am
View File

@@ -28,8 +28,10 @@ noinst_HEADERS = \
gtp_ggsn.h \
gtp_mme.h \
iu_client.h \
iu_rnc.h \
mmctx.h \
pdpctx.h \
sccp.h \
sgsn.h \
sgsn_rim.h \
signal.h \

25
include/osmocom/sgsn/gprs_ranap.h
View File

@@ -6,6 +6,7 @@
#include <osmocom/ranap/ranap_ies_defs.h>
#include <osmocom/ranap/ranap_msg_factory.h>
#include <osmocom/sgsn/iu_client.h>
#include <osmocom/sgsn/sccp.h>
struct sgsn_mm_ctx;
struct sgsn_pdp_ctx;
@@ -14,6 +15,24 @@ void activate_pdp_rabs(struct sgsn_mm_ctx *ctx);
int sgsn_ranap_iu_event(struct ranap_ue_conn_ctx *ctx, enum ranap_iu_event_type type, void *data);
int iu_rab_act_ps(uint8_t rab_id, struct sgsn_pdp_ctx *pdp);
int ranap_iu_tx(struct msgb *msg, uint8_t sapi);
int ranap_iu_rab_act(struct ranap_ue_conn_ctx *ue_ctx, struct msgb *msg);
int ranap_iu_rab_deact(struct ranap_ue_conn_ctx *ue_ctx, uint8_t rab_id);
int ranap_iu_tx_sec_mode_cmd(struct ranap_ue_conn_ctx *uectx, struct osmo_auth_vector *vec,
int send_ck, int new_key);
int ranap_iu_tx_common_id(struct ranap_ue_conn_ctx *ue_ctx, const char *imsi);
int ranap_iu_tx_paging_cmd(struct osmo_sccp_addr *called_addr,
const char *imsi, const uint32_t *tmsi,
bool is_ps, uint32_t paging_cause);
int ranap_iu_tx_release(struct ranap_ue_conn_ctx *ctx, const struct RANAP_Cause *cause);
/* Transmit a Iu Release Command and submit event RANAP_IU_EVENT_IU_RELEASE upon
* Release Complete or timeout. Caller is responsible to free the context and
* closing the SCCP connection (ranap_iu_free_ue) upon recieval of the event. */
void ranap_iu_tx_release_free(struct ranap_ue_conn_ctx *ctx,
const struct RANAP_Cause *cause,
int timeout);
/* free the Iu UE context */
void sgsn_ranap_iu_free(struct sgsn_mm_ctx *ctx);
@@ -21,6 +40,12 @@ void sgsn_ranap_iu_free(struct sgsn_mm_ctx *ctx);
void sgsn_ranap_iu_release_free(struct sgsn_mm_ctx *ctx,
const struct RANAP_Cause *cause);
int sgsn_ranap_iu_rx_cl_msg(struct sgsn_sccp_user_iups *scu_iups, struct osmo_scu_unitdata_param *ud_prim,
uint8_t *data, size_t len);
int sgsn_ranap_iu_rx_co_initial_msg(struct sgsn_sccp_user_iups *scu_iups, const struct osmo_sccp_addr *rem_sccp_addr,
uint32_t conn_id, uint8_t *data, size_t len);
int sgsn_ranap_iu_rx_co_msg(struct ranap_ue_conn_ctx *ue_ctx, uint8_t *data, size_t len);
#else /* ifndef BUILD_IU */
inline static void sgsn_ranap_iu_free(void *ctx) {};
inline static void sgsn_ranap_iu_release_free(void *ctx, void *cause) {};

25
include/osmocom/sgsn/iu_client.h
View File

@@ -14,13 +14,13 @@ struct msgb;
struct osmo_auth_vector;
struct RANAP_RAB_SetupOrModifiedItemIEs_s;
struct RANAP_Cause;
struct ranap_iu_rnc;
struct ranap_ue_conn_ctx {
struct llist_head list;
struct llist_head list; /* item in sgsn_sccp->ue_conn_ctx_list */
struct ranap_iu_rnc *rnc;
struct sgsn_sccp_user_iups *scu_iups;
uint32_t conn_id;
int integrity_active;
struct gprs_ra_id ra_id;
@@ -70,10 +70,12 @@ typedef int (*ranap_iu_event_cb_t)(struct ranap_ue_conn_ctx *ue_ctx,
typedef int (*ranap_iu_rab_ass_resp_cb_t)(struct ranap_ue_conn_ctx *ue_ctx, uint8_t rab_id,
struct RANAP_RAB_SetupOrModifiedItemIEs_s *setup_ies);
int ranap_iu_init(void *ctx, int log_subsystem, const char *sccp_user_name, struct osmo_sccp_instance *sccp,
ranap_iu_recv_cb_t iu_recv_cb, ranap_iu_event_cb_t iu_event_cb);
int global_iu_event(struct ranap_ue_conn_ctx *ue_ctx,
enum ranap_iu_event_type type,
void *data);
int ranap_iu_tx(struct msgb *msg, uint8_t sapi);
int ranap_iu_init(void *ctx);
int ranap_iu_page_cs(const char *imsi, const uint32_t *tmsi, uint16_t lac)
OSMO_DEPRECATED("Use ranap_iu_page_cs2 instead");
@@ -84,19 +86,8 @@ int ranap_iu_page_ps(const char *imsi, const uint32_t *ptmsi, uint16_t lac, uint
int ranap_iu_page_cs2(const char *imsi, const uint32_t *tmsi, const struct osmo_location_area_id *lai);
int ranap_iu_page_ps2(const char *imsi, const uint32_t *ptmsi, const struct osmo_routing_area_id *rai);
int ranap_iu_rab_act(struct ranap_ue_conn_ctx *ue_ctx, struct msgb *msg);
int ranap_iu_rab_deact(struct ranap_ue_conn_ctx *ue_ctx, uint8_t rab_id);
int ranap_iu_tx_sec_mode_cmd(struct ranap_ue_conn_ctx *uectx, struct osmo_auth_vector *vec,
int send_ck, int new_key);
int ranap_iu_tx_common_id(struct ranap_ue_conn_ctx *ue_ctx, const char *imsi);
int ranap_iu_tx_release(struct ranap_ue_conn_ctx *ctx, const struct RANAP_Cause *cause);
/* Transmit a Iu Release Command and submit event RANAP_IU_EVENT_IU_RELEASE upon
* Release Complete or timeout. Caller is responsible to free the context and
* closing the SCCP connection (ranap_iu_free_ue) upon recieval of the event. */
void ranap_iu_tx_release_free(struct ranap_ue_conn_ctx *ctx,
const struct RANAP_Cause *cause,
int timeout);
struct ranap_ue_conn_ctx *ue_conn_ctx_alloc(struct ranap_iu_rnc *rnc, struct sgsn_sccp_user_iups *scu_iups, uint32_t conn_id);
/* freeing the UE will release all resources
* This will close the SCCP connection connected to the UE */

35
include/osmocom/sgsn/iu_rnc.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include <stdbool.h>
#include <osmocom/core/defs.h>
#include <osmocom/core/linuxlist.h>
#include <osmocom/gsm/gsm48.h>
#include <osmocom/iuh/common.h>
#include <osmocom/sigtran/sccp_sap.h>
struct iu_lac_rac_entry {
struct llist_head entry;
struct osmo_routing_area_id rai;
};
/* A remote RNC (Radio Network Controller, like BSC but for UMTS) that has
* called us and is currently reachable at the given osmo_sccp_addr. So, when we
* know a LAC for a subscriber, we can page it at the RNC matching that LAC or
* RAC. An HNB-GW typically presents itself as if it were a single RNC, even
* though it may have several RNCs in hNodeBs connected to it. Those will then
* share the same RNC id, which they actually receive and adopt from the HNB-GW
* in the HNBAP HNB REGISTER ACCEPT message. */
struct ranap_iu_rnc {
struct llist_head entry;
struct osmo_rnc_id rnc_id;
struct osmo_sccp_addr sccp_addr;
/* A list of struct iu_lac_rac_entry */
struct llist_head lac_rac_list;
};
struct ranap_iu_rnc *iu_rnc_register(struct osmo_rnc_id *rnc_id,
const struct osmo_routing_area_id *rai,
struct osmo_sccp_addr *addr);

39
include/osmocom/sgsn/sccp.h Normal file
View File

@@ -0,0 +1,39 @@
/* SCCP Handling */
/* (C) 2025 by sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
* 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 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/>.
*
*/
#pragma once
#include <osmocom/sigtran/sccp_sap.h>
struct sgsn_instance;
struct sgsn_sccp_user_iups {
struct sgsn_instance *sgsn; /* backpointer */
struct osmo_sccp_instance *sccp; /* backpointer */
struct osmo_sccp_user *scu; /* IuPS */
struct osmo_sccp_addr local_sccp_addr;
struct llist_head ue_conn_ctx_list; /* list of "struct ranap_ue_conn_ctx" */
struct llist_head ue_conn_sccp_addr_list; /* list of "struct iu_new_ctx_entry" */
};
struct sgsn_sccp_user_iups *sgsn_scu_iups_inst_alloc(struct sgsn_instance *sgsn, struct osmo_sccp_instance *sccp);
void sgsn_scu_iups_free(struct sgsn_sccp_user_iups *scu_iups);
int sgsn_sccp_init(struct sgsn_instance *sgsn);
void sgsn_sccp_release(struct sgsn_instance *sgsn);

18
include/osmocom/sgsn/sgsn.h
View File

@@ -1,6 +1,7 @@
#ifndef _SGSN_H
#define _SGSN_H
#include "config.h"
#include <osmocom/core/msgb.h>
#include <osmocom/core/select.h>
@@ -14,9 +15,8 @@
#include <osmocom/gsupclient/gsup_client.h>
#include <osmocom/sgsn/common.h>
#include "../../config.h"
#if BUILD_IU
#include <osmocom/sigtran/sccp_sap.h>
#include <osmocom/sgsn/iu_client.h>
#endif
@@ -27,6 +27,9 @@ struct hostent;
#define SGSN_ERROR_CAUSE_NONE (-1)
/* This rac will be used internally. RAC with 0xff will be rejected */
#define OSMO_RESERVED_RAC 0xff
enum sgsn_auth_policy {
SGSN_AUTH_POLICY_OPEN,
SGSN_AUTH_POLICY_CLOSED,
@@ -162,8 +165,19 @@ struct sgsn_instance {
struct llist_head mme_list; /* list of struct sgsn_mme_ctx */
struct llist_head mm_list; /* list of struct sgsn_mm_ctx */
struct llist_head pdp_list; /* list of struct sgsn_pdp_ctx */
#if BUILD_IU
struct llist_head rnc_list; /* list of struct ranap_iu_rnc */
#endif /* if BUILD_IU */
struct ctrl_handle *ctrlh;
#if BUILD_IU
/* SCCP (Iu) */
struct {
struct osmo_sccp_instance *sccp;
struct sgsn_sccp_user_iups *scu_iups;
} sccp;
#endif /* if BUILD_IU */
};
extern struct sgsn_instance *sgsn;

5
src/sgsn/Makefile.am
View File

@@ -97,6 +97,9 @@ osmo_sgsn_LDADD += \
osmo_sgsn_SOURCES += \
gprs_mm_state_iu_fsm.c \
gprs_ranap.c \
iu_client.c
iu_client.c \
iu_rnc.c \
sccp.c \
$(NULL)
endif

3
src/sgsn/gprs_gmm_attach.c
View File

@@ -1,3 +1,5 @@
#include "config.h"
#include <osmocom/core/tdef.h>
#include <osmocom/crypt/utran_cipher.h>
@@ -7,6 +9,7 @@
#include <osmocom/sgsn/debug.h>
#include <osmocom/sgsn/gprs_gmm.h>
#include <osmocom/sgsn/mmctx.h>
#include <osmocom/sgsn/gprs_ranap.h>
#include <osmocom/sgsn/sgsn.h>
#define X(s) (1 << (s))

512
src/sgsn/gprs_ranap.c
View File

@@ -22,6 +22,9 @@
*/
#include "config.h"
#include <asn1c/asn1helpers.h>
#include <osmocom/gtp/gtp.h>
#include <osmocom/core/rate_ctr.h>
@@ -29,7 +32,11 @@
#include <osmocom/gprs/gprs_msgb.h>
#include <osmocom/ranap/ranap_common.h>
#include <osmocom/ranap/ranap_common_cn.h>
#include <osmocom/ranap/ranap_ies_defs.h>
#include <osmocom/ranap/ranap_msg_factory.h>
#include <osmocom/ranap/iu_helpers.h>
#include <osmocom/sigtran/sccp_helpers.h>
#include <osmocom/sgsn/gprs_gmm.h>
#include <osmocom/sgsn/gprs_sm.h>
@@ -41,9 +48,55 @@
#include <osmocom/sgsn/gprs_routing_area.h>
#include <osmocom/sgsn/gtp_ggsn.h>
#include <osmocom/sgsn/gtp.h>
#include <osmocom/sgsn/iu_rnc.h>
#include <osmocom/sgsn/pdpctx.h>
#include <osmocom/sgsn/mmctx.h>
/* Parsed global RNC id. See also struct RANAP_GlobalRNC_ID, and note that the
* PLMN identity is a BCD representation of the MCC and MNC.
* See iu_grnc_id_parse(). */
struct iu_grnc_id {
struct osmo_plmn_id plmn;
uint16_t rnc_id;
};
static int iu_grnc_id_parse(struct osmo_rnc_id *dst, struct RANAP_GlobalRNC_ID *src)
{
/* The size is coming from arbitrary sender, check it gracefully */
if (src->pLMNidentity.size != 3) {
LOGP(DRANAP, LOGL_ERROR, "Invalid PLMN Identity size: should be 3, is %d\n",
src->pLMNidentity.size);
return -1;
}
osmo_plmn_from_bcd(&src->pLMNidentity.buf[0], &dst->plmn);
dst->rnc_id = (uint16_t)src->rNC_ID;
return 0;
}
#if 0
/* not used at present */
static int iu_grnc_id_compose(struct iu_grnc_id *src, struct RANAP_GlobalRNC_ID *dst)
{
/* The caller must ensure proper size */
OSMO_ASSERT(dst->pLMNidentity.size == 3);
gsm48_mcc_mnc_to_bcd(&dst->pLMNidentity.buf[0],
src->mcc, src->mnc);
dst->rNC_ID = src->rnc_id;
return 0;
}
#endif
struct ranap_iu_event_sccp_new_ue_context {
struct sgsn_sccp_user_iups *scu_iups;
struct osmo_sccp_addr rem_sccp_addr;
uint32_t conn_id;
};
struct ranap_iu_event_cl_msg_ind {
struct sgsn_sccp_user_iups *scu_iups;
struct osmo_scu_unitdata_param *ud_prim;
};
/* Send RAB activation requests for all PDP contexts */
void activate_pdp_rabs(struct sgsn_mm_ctx *ctx)
{
@@ -281,3 +334,462 @@ int iu_rab_act_ps(uint8_t rab_id, struct sgsn_pdp_ctx *pdp)
msg->l2h = msg->data;
return ranap_iu_rab_act(uectx, msg);
}
int ranap_iu_rab_act(struct ranap_ue_conn_ctx *ue_ctx, struct msgb *msg)
{
struct osmo_scu_prim *prim;
/* wrap RANAP message in SCCP N-DATA.req */
prim = (struct osmo_scu_prim *) msgb_push(msg, sizeof(*prim));
prim->u.data.conn_id = ue_ctx->conn_id;
osmo_prim_init(&prim->oph,
SCCP_SAP_USER,
OSMO_SCU_PRIM_N_DATA,
PRIM_OP_REQUEST,
msg);
return osmo_sccp_user_sap_down(ue_ctx->scu_iups->scu, &prim->oph);
}
int ranap_iu_rab_deact(struct ranap_ue_conn_ctx *ue_ctx, uint8_t rab_id)
{
/* FIXME */
return -1;
}
int ranap_iu_tx_sec_mode_cmd(struct ranap_ue_conn_ctx *uectx, struct osmo_auth_vector *vec,
int send_ck, int new_key)
{
struct osmo_scu_prim *prim;
struct msgb *msg;
/* create RANAP message */
msg = ranap_new_msg_sec_mod_cmd(vec->ik, send_ck ? vec->ck : NULL,
new_key ? RANAP_KeyStatus_new : RANAP_KeyStatus_old);
msg->l2h = msg->data;
/* wrap RANAP message in SCCP N-DATA.req */
prim = (struct osmo_scu_prim *) msgb_push(msg, sizeof(*prim));
prim->u.data.conn_id = uectx->conn_id;
osmo_prim_init(&prim->oph, SCCP_SAP_USER,
OSMO_SCU_PRIM_N_DATA,
PRIM_OP_REQUEST, msg);
return osmo_sccp_user_sap_down(uectx->scu_iups->scu, &prim->oph);
}
int ranap_iu_tx_common_id(struct ranap_ue_conn_ctx *uectx, const char *imsi)
{
struct msgb *msg;
struct osmo_scu_prim *prim;
LOGP(DRANAP, LOGL_INFO, "Transmitting RANAP CommonID (SCCP conn_id %u)\n",
uectx->conn_id);
msg = ranap_new_msg_common_id(imsi);
msg->l2h = msg->data;
prim = (struct osmo_scu_prim *) msgb_push(msg, sizeof(*prim));
prim->u.data.conn_id = uectx->conn_id;
osmo_prim_init(&prim->oph, SCCP_SAP_USER,
OSMO_SCU_PRIM_N_DATA,
PRIM_OP_REQUEST, msg);
return osmo_sccp_user_sap_down(uectx->scu_iups->scu, &prim->oph);
}
/* Send a paging command down a given SCCP User. tmsi and paging_cause are
* optional and may be passed NULL and 0, respectively, to disable their use.
* See enum RANAP_PagingCause.
*
* If TMSI is given, the IMSI is not sent over the air interface. Nevertheless,
* the IMSI is still required for resolution in the HNB-GW and/or(?) RNC. */
int ranap_iu_tx_paging_cmd(struct osmo_sccp_addr *called_addr,
const char *imsi, const uint32_t *tmsi,
bool is_ps, uint32_t paging_cause)
{
struct msgb *msg;
msg = ranap_new_msg_paging_cmd(imsi, tmsi, is_ps ? 1 : 0, paging_cause);
msg->l2h = msg->data;
return osmo_sccp_tx_unitdata_msg(sgsn->sccp.scu_iups->scu, &sgsn->sccp.scu_iups->local_sccp_addr, called_addr, msg);
}
int ranap_iu_tx(struct msgb *msg_nas, uint8_t sapi)
{
struct ranap_ue_conn_ctx *uectx = msg_nas->dst;
struct msgb *msg;
struct osmo_scu_prim *prim;
if (!uectx) {
LOGP(DRANAP, LOGL_ERROR,
"Discarding to-be-transmitted L3 Message as RANAP DT with unset dst SCCP conn_id!\n");
return -ENOTCONN;
}
LOGP(DRANAP, LOGL_INFO, "Transmitting L3 Message as RANAP DT (SCCP conn_id %u)\n",
uectx->conn_id);
msg = ranap_new_msg_dt(sapi, msg_nas->data, msgb_length(msg_nas));
msgb_free(msg_nas);
msg->l2h = msg->data;
prim = (struct osmo_scu_prim *) msgb_push(msg, sizeof(*prim));
prim->u.data.conn_id = uectx->conn_id;
osmo_prim_init(&prim->oph, SCCP_SAP_USER,
OSMO_SCU_PRIM_N_DATA,
PRIM_OP_REQUEST, msg);
return osmo_sccp_user_sap_down(uectx->scu_iups->scu, &prim->oph);
}
/* Send Iu Release for the given UE connection.
* If cause is NULL, Normal Release cause is sent, otherwise
* the provided cause. */
int ranap_iu_tx_release(struct ranap_ue_conn_ctx *ctx, const struct RANAP_Cause *cause)
{
struct msgb *msg;
struct osmo_scu_prim *prim;
static const struct RANAP_Cause default_cause = {
.present = RANAP_Cause_PR_nAS,
.choice.radioNetwork = RANAP_CauseNAS_normal_release,
};
if (!cause)
cause = &default_cause;
msg = ranap_new_msg_iu_rel_cmd(cause);
msg->l2h = msg->data;
prim = (struct osmo_scu_prim *) msgb_push(msg, sizeof(*prim));
prim->u.data.conn_id = ctx->conn_id;
osmo_prim_init(&prim->oph, SCCP_SAP_USER,
OSMO_SCU_PRIM_N_DATA,
PRIM_OP_REQUEST, msg);
return osmo_sccp_user_sap_down(ctx->scu_iups->scu, &prim->oph);
}
void ranap_iu_tx_release_free(struct ranap_ue_conn_ctx *ctx,
const struct RANAP_Cause *cause,
int timeout)
{
ctx->notification = false;
ctx->free_on_release = true;
int ret = ranap_iu_tx_release(ctx, cause);
/* On Tx failure, trigger timeout immediately, as the response will never arrive */
if (ret)
timeout = 0;
osmo_timer_schedule(&ctx->release_timeout, timeout, 0);
}
static int ranap_handle_co_initial_ue(void *ctx, RANAP_InitialUE_MessageIEs_t *ies)
{
struct ranap_iu_event_sccp_new_ue_context *new_ctx = ctx;
struct gprs_ra_id ra_id = {};
struct osmo_routing_area_id ra_id2 = {};
struct osmo_rnc_id rnc_id = {};
uint16_t sai;
struct ranap_ue_conn_ctx *ue;
struct msgb *msg = msgb_alloc(256, "RANAP->NAS");
struct ranap_iu_rnc *rnc;
if (ranap_parse_lai(&ra_id, &ies->lai) != 0) {
LOGP(DRANAP, LOGL_ERROR, "Failed to parse RANAP LAI IE\n");
return -1;
}
if (ies->presenceMask & INITIALUE_MESSAGEIES_RANAP_RAC_PRESENT) {
ra_id.rac = asn1str_to_u8(&ies->rac);
if (ra_id.rac == OSMO_RESERVED_RAC) {
LOGP(DRANAP, LOGL_ERROR,
"Rejecting RNC with invalid/internally used RAC 0x%02x\n", ra_id.rac);
return -1;
}
} else {
ra_id.rac = OSMO_RESERVED_RAC;
}
if (iu_grnc_id_parse(&rnc_id, &ies->globalRNC_ID) != 0) {
LOGP(DRANAP, LOGL_ERROR,
"Failed to parse RANAP Global-RNC-ID IE\n");
return -1;
}
sai = asn1str_to_u16(&ies->sai.sAC);
msgb_gmmh(msg) = msgb_put(msg, ies->nas_pdu.size);
memcpy(msgb_gmmh(msg), ies->nas_pdu.buf, ies->nas_pdu.size);
gprs_rai_to_osmo(&ra_id2, &ra_id);
/* Make sure we know the RNC Id and LAC+RAC coming in on this connection. */
rnc = iu_rnc_register(&rnc_id, &ra_id2, &new_ctx->rem_sccp_addr);
ue = ue_conn_ctx_alloc(rnc, new_ctx->scu_iups, new_ctx->conn_id);
OSMO_ASSERT(ue);
ue->ra_id = ra_id;
/* Feed into the MM layer */
msg->dst = ue;
gsm0408_gprs_rcvmsg_iu(msg, &ra_id, &sai);
msgb_free(msg);
return 0;
}
static void cn_ranap_handle_co_initial(void *ctx, ranap_message *message)
{
int rc;
LOGP(DRANAP, LOGL_NOTICE, "handle_co_initial(dir=%u, proc=%u)\n", message->direction, message->procedureCode);
if (message->direction != RANAP_RANAP_PDU_PR_initiatingMessage
|| message->procedureCode != RANAP_ProcedureCode_id_InitialUE_Message) {
LOGP(DRANAP, LOGL_ERROR, "Expected direction 'InitiatingMessage',"
" procedureCode 'InitialUE_Message', instead got %u and %u\n",
message->direction, message->procedureCode);
rc = -1;
} else
rc = ranap_handle_co_initial_ue(ctx, &message->msg.initialUE_MessageIEs);
if (rc) {
LOGP(DRANAP, LOGL_ERROR, "Error in %s (%d)\n", __func__, rc);
/* TODO handling of the error? */
}
}
int sgsn_ranap_iu_rx_co_initial_msg(struct sgsn_sccp_user_iups *scu_iups, const struct osmo_sccp_addr *rem_sccp_addr, uint32_t conn_id, uint8_t *data, size_t len)
{
struct ranap_iu_event_sccp_new_ue_context new_ctx = {
.scu_iups = scu_iups,
.conn_id = conn_id,
.rem_sccp_addr = *rem_sccp_addr,
};
return ranap_cn_rx_co(cn_ranap_handle_co_initial, &new_ctx, data, len);
}
static int ranap_handle_co_dt(void *ctx, RANAP_DirectTransferIEs_t *ies)
{
struct gprs_ra_id _ra_id, *ra_id = NULL;
uint16_t _sai, *sai = NULL;
struct msgb *msg = msgb_alloc(256, "RANAP->NAS");
if (ies->presenceMask & DIRECTTRANSFERIES_RANAP_LAI_PRESENT) {
if (ranap_parse_lai(&_ra_id, &ies->lai) != 0) {
LOGP(DRANAP, LOGL_ERROR, "Failed to parse RANAP LAI IE\n");
return -1;
}
ra_id = &_ra_id;
if (ies->presenceMask & DIRECTTRANSFERIES_RANAP_RAC_PRESENT)
_ra_id.rac = asn1str_to_u8(&ies->rac);
if (ies->presenceMask & DIRECTTRANSFERIES_RANAP_SAI_PRESENT) {
_sai = asn1str_to_u16(&ies->sai.sAC);
sai = &_sai;
}
}
msgb_gmmh(msg) = msgb_put(msg, ies->nas_pdu.size);
memcpy(msgb_gmmh(msg), ies->nas_pdu.buf, ies->nas_pdu.size);
/* Feed into the MM/CC/SMS-CP layer */
msg->dst = ctx;
gsm0408_gprs_rcvmsg_iu(msg, ra_id, sai);
msgb_free(msg);
return 0;
}
static int ranap_handle_co_err_ind(void *ctx, RANAP_ErrorIndicationIEs_t *ies)
{
if (ies->presenceMask & ERRORINDICATIONIES_RANAP_CAUSE_PRESENT)
LOGP(DRANAP, LOGL_ERROR, "Rx Error Indication (%s)\n",
ranap_cause_str(&ies->cause));
else
LOGP(DRANAP, LOGL_ERROR, "Rx Error Indication\n");
return 0;
}
static int ranap_handle_co_iu_rel_req(struct ranap_ue_conn_ctx *ctx, RANAP_Iu_ReleaseRequestIEs_t *ies)
{
LOGP(DRANAP, LOGL_INFO, "Received Iu Release Request, Sending Release Command\n");
ranap_iu_tx_release(ctx, &ies->cause);
return 0;
}
static int ranap_handle_co_rab_ass_resp(struct ranap_ue_conn_ctx *ctx, RANAP_RAB_AssignmentResponseIEs_t *ies)
{
int rc = -1;
LOGP(DRANAP, LOGL_INFO,
"Rx RAB Assignment Response for UE conn_id %u\n", ctx->conn_id);
if (ies->presenceMask & RAB_ASSIGNMENTRESPONSEIES_RANAP_RAB_SETUPORMODIFIEDLIST_PRESENT) {
/* TODO: Iterate over list of SetupOrModifiedList IEs and handle each one */
RANAP_IE_t *ranap_ie = ies->raB_SetupOrModifiedList.raB_SetupOrModifiedList_ies.list.array[0];
RANAP_RAB_SetupOrModifiedItemIEs_t setup_ies;
rc = ranap_decode_rab_setupormodifieditemies_fromlist(&setup_ies, &ranap_ie->value);
if (rc) {
LOGP(DRANAP, LOGL_ERROR, "Error in ranap_decode_rab_setupormodifieditemies()\n");
return rc;
}
rc = global_iu_event(ctx, RANAP_IU_EVENT_RAB_ASSIGN, &setup_ies);
ranap_free_rab_setupormodifieditemies(&setup_ies);
}
/* FIXME: handle RAB Ass failure? */
return rc;
}
/* Entry point for connection-oriented RANAP message */
static void cn_ranap_handle_co(void *ctx, ranap_message *message)
{
int rc;
LOGP(DRANAP, LOGL_NOTICE, "handle_co(dir=%u, proc=%u)\n", message->direction, message->procedureCode);
switch (message->direction) {
case RANAP_RANAP_PDU_PR_initiatingMessage:
switch (message->procedureCode) {
case RANAP_ProcedureCode_id_InitialUE_Message:
LOGP(DRANAP, LOGL_ERROR, "Got InitialUE_Message but this is not a new conn\n");
rc = -1;
break;
case RANAP_ProcedureCode_id_DirectTransfer:
rc = ranap_handle_co_dt(ctx, &message->msg.directTransferIEs);
break;
case RANAP_ProcedureCode_id_ErrorIndication:
rc = ranap_handle_co_err_ind(ctx, &message->msg.errorIndicationIEs);
break;
case RANAP_ProcedureCode_id_Iu_ReleaseRequest:
/* Iu Release Request */
rc = ranap_handle_co_iu_rel_req(ctx, &message->msg.iu_ReleaseRequestIEs);
break;
default:
LOGP(DRANAP, LOGL_ERROR, "Received Initiating Message: unknown Procedure Code %d\n",
message->procedureCode);
rc = -1;
break;
}
break;
case RANAP_RANAP_PDU_PR_successfulOutcome:
switch (message->procedureCode) {
case RANAP_ProcedureCode_id_SecurityModeControl:
/* Security Mode Complete */
rc = global_iu_event(ctx, RANAP_IU_EVENT_SECURITY_MODE_COMPLETE, NULL);
break;
case RANAP_ProcedureCode_id_Iu_Release:
/* Iu Release Complete */
rc = global_iu_event(ctx, RANAP_IU_EVENT_IU_RELEASE, NULL);
if (rc) {
LOGP(DRANAP, LOGL_ERROR, "Iu Release event: Iu Event callback returned %d\n",
rc);
}
break;
default:
LOGP(DRANAP, LOGL_ERROR, "Received Successful Outcome: unknown Procedure Code %d\n",
message->procedureCode);
rc = -1;
break;
}
break;
case RANAP_RANAP_PDU_PR_outcome:
switch (message->procedureCode) {
case RANAP_ProcedureCode_id_RAB_Assignment:
/* RAB Assignment Response */
rc = ranap_handle_co_rab_ass_resp(ctx, &message->msg.raB_AssignmentResponseIEs);
break;
default:
LOGP(DRANAP, LOGL_ERROR, "Received Outcome: unknown Procedure Code %d\n",
message->procedureCode);
rc = -1;
break;
}
break;
case RANAP_RANAP_PDU_PR_unsuccessfulOutcome:
default:
LOGP(DRANAP, LOGL_ERROR, "Received Unsuccessful Outcome: Procedure Code %d\n",
message->procedureCode);
rc = -1;
break;
}
if (rc) {
LOGP(DRANAP, LOGL_ERROR, "Error in %s (%d)\n", __func__, rc);
/* TODO handling of the error? */
}
}
int sgsn_ranap_iu_rx_co_msg(struct ranap_ue_conn_ctx *ue_ctx, uint8_t *data, size_t len)
{
return ranap_cn_rx_co(cn_ranap_handle_co, ue_ctx, data, len);
}
static int ranap_handle_cl_reset_req(struct ranap_iu_event_cl_msg_ind *cl_msg_ind, RANAP_ResetIEs_t *ies)
{
RANAP_GlobalRNC_ID_t *grnc_id = NULL;
struct msgb *resp;
/* FIXME: verify ies.cN_DomainIndicator */
if (ies->presenceMask & RESETIES_RANAP_GLOBALRNC_ID_PRESENT)
grnc_id = &ies->globalRNC_ID;
/* send reset response */
resp = ranap_new_msg_reset_ack(ies->cN_DomainIndicator, grnc_id);
if (!resp)
return -ENOMEM;
resp->l2h = resp->data;
return osmo_sccp_tx_unitdata_msg(cl_msg_ind->scu_iups->scu, &cl_msg_ind->scu_iups->local_sccp_addr, &cl_msg_ind->ud_prim->calling_addr, resp);
}
static int ranap_handle_cl_err_ind(struct ranap_iu_event_cl_msg_ind *cl_msg_ind, RANAP_ErrorIndicationIEs_t *ies)
{
if (ies->presenceMask & ERRORINDICATIONIES_RANAP_CAUSE_PRESENT)
LOGP(DRANAP, LOGL_ERROR, "Rx Error Indication (%s)\n",
ranap_cause_str(&ies->cause));
else
LOGP(DRANAP, LOGL_ERROR, "Rx Error Indication\n");
return 0;
}
/* Entry point for connection-less RANAP message */
static void cn_ranap_handle_cl(void *ctx, ranap_message *message)
{
struct ranap_iu_event_cl_msg_ind *cl_msg_ind = ctx;
int rc;
switch (message->direction) {
case RANAP_RANAP_PDU_PR_initiatingMessage:
switch (message->procedureCode) {
case RANAP_ProcedureCode_id_Reset:
/* received reset.req, send reset.resp */
rc = ranap_handle_cl_reset_req(cl_msg_ind, &message->msg.resetIEs);
break;
case RANAP_ProcedureCode_id_ErrorIndication:
rc = ranap_handle_cl_err_ind(cl_msg_ind, &message->msg.errorIndicationIEs);
break;
default:
rc = -1;
break;
}
break;
case RANAP_RANAP_PDU_PR_successfulOutcome:
case RANAP_RANAP_PDU_PR_unsuccessfulOutcome:
case RANAP_RANAP_PDU_PR_outcome:
default:
rc = -1;
break;
}
if (rc) {
LOGP(DRANAP, LOGL_ERROR, "Error in %s (%d)\n", __func__, rc);
/* TODO handling of the error? */
}
}
int sgsn_ranap_iu_rx_cl_msg(struct sgsn_sccp_user_iups *scu_iups, struct osmo_scu_unitdata_param *ud_prim, uint8_t *data, size_t len)
{
struct ranap_iu_event_cl_msg_ind cl_msg_ind = {
.scu_iups = scu_iups,
.ud_prim = ud_prim,
};
return ranap_cn_rx_cl(cn_ranap_handle_cl, &cl_msg_ind, data, len);
}

1048
src/sgsn/iu_client.c
View File

File diff suppressed because it is too large Load Diff

172
src/sgsn/iu_rnc.c Normal file
View File

@@ -0,0 +1,172 @@
/* A remote RNC (Radio Network Controller), connected over IuPS */
/* (C) 2016-2017 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
* 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 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 "config.h"
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <osmocom/gsm/protocol/gsm_04_08_gprs.h>
#include <osmocom/core/logging.h>
#include <osmocom/crypt/auth.h>
#include <osmocom/gprs/gprs_msgb.h>
#include <osmocom/sigtran/sccp_sap.h>
#include <osmocom/sigtran/sccp_helpers.h>
#include <osmocom/sccp/sccp_types.h>
#include <osmocom/sgsn/debug.h>
#include <osmocom/sgsn/gprs_ranap.h>
#include <osmocom/sgsn/iu_client.h>
#include <osmocom/sgsn/iu_rnc.h>
#include <osmocom/sgsn/sccp.h>
#include <osmocom/sgsn/sgsn.h>
static struct ranap_iu_rnc *iu_rnc_alloc(const struct osmo_rnc_id *rnc_id, struct osmo_sccp_addr *addr)
{
struct ranap_iu_rnc *rnc = talloc_zero(sgsn, struct ranap_iu_rnc);
OSMO_ASSERT(rnc);
INIT_LLIST_HEAD(&rnc->lac_rac_list);
rnc->rnc_id = *rnc_id;
rnc->sccp_addr = *addr;
llist_add(&rnc->entry, &sgsn->rnc_list);
LOGP(DRANAP, LOGL_NOTICE, "New RNC %s at %s\n",
osmo_rnc_id_name(&rnc->rnc_id), osmo_sccp_addr_dump(addr));
return rnc;
}
/* Find a match for the given LAC (and RAC). For CS, pass rac as 0.
* If rnc and lre pointers are not NULL, *rnc / *lre are set to NULL if no match is found, or to the
* match if a match is found. Return true if a match is found. */
static bool iu_rnc_lac_rac_find(struct ranap_iu_rnc **rnc, struct iu_lac_rac_entry **lre,
const struct osmo_routing_area_id *ra_id)
{
struct ranap_iu_rnc *r;
struct iu_lac_rac_entry *e;
if (rnc)
*rnc = NULL;
if (lre)
*lre = NULL;
llist_for_each_entry(r, &sgsn->rnc_list, entry) {
llist_for_each_entry(e, &r->lac_rac_list, entry) {
if (!osmo_rai_cmp(&e->rai, ra_id)) {
if (rnc)
*rnc = r;
if (lre)
*lre = e;
return true;
}
}
}
return false;
}
static struct ranap_iu_rnc *iu_rnc_id_find(struct osmo_rnc_id *rnc_id)
{
struct ranap_iu_rnc *rnc;
llist_for_each_entry(rnc, &sgsn->rnc_list, entry) {
if (!osmo_rnc_id_cmp(&rnc->rnc_id, rnc_id))
return rnc;
}
return NULL;
}
static bool same_sccp_addr(struct osmo_sccp_addr *a, struct osmo_sccp_addr *b)
{
char buf[256];
osmo_strlcpy(buf, osmo_sccp_addr_dump(a), sizeof(buf));
return !strcmp(buf, osmo_sccp_addr_dump(b));
}
static void global_iu_event_new_area(const struct osmo_rnc_id *rnc_id, const struct osmo_routing_area_id *rai)
{
struct ranap_iu_event_new_area new_area = (struct ranap_iu_event_new_area) {
.rnc_id = rnc_id,
.cell_type = RANAP_IU_NEW_RAC
};
if (rai->rac == OSMO_RESERVED_RAC) {
new_area.cell_type = RANAP_IU_NEW_LAC;
new_area.u.lai = &rai->lac;
} else {
new_area.cell_type = RANAP_IU_NEW_RAC;
new_area.u.rai = rai;
}
global_iu_event(NULL, RANAP_IU_EVENT_NEW_AREA, &new_area);
}
struct ranap_iu_rnc *iu_rnc_register(struct osmo_rnc_id *rnc_id,
const struct osmo_routing_area_id *rai,
struct osmo_sccp_addr *addr)
{
struct ranap_iu_rnc *rnc;
struct ranap_iu_rnc *old_rnc;
struct iu_lac_rac_entry *lre;
/* Make sure we know this rnc_id and that this SCCP address is in our records */
rnc = iu_rnc_id_find(rnc_id);
if (rnc) {
if (!same_sccp_addr(&rnc->sccp_addr, addr)) {
LOGP(DRANAP, LOGL_NOTICE, "RNC %s changed its SCCP addr to %s (LAC/RAC %s)\n",
osmo_rnc_id_name(rnc_id), osmo_sccp_addr_dump(addr), osmo_rai_name2(rai));
rnc->sccp_addr = *addr;
}
} else
rnc = iu_rnc_alloc(rnc_id, addr);
/* Detect whether the LAC,RAC is already recorded in another RNC */
iu_rnc_lac_rac_find(&old_rnc, &lre, rai);
if (old_rnc && old_rnc != rnc) {
/* LAC, RAC already exists in a different RNC */
LOGP(DRANAP, LOGL_NOTICE, "LAC/RAC %s moved from RNC %s %s",
osmo_rai_name2(rai),
osmo_rnc_id_name(&old_rnc->rnc_id), osmo_sccp_addr_dump(&old_rnc->sccp_addr));
LOGPC(DRANAP, LOGL_NOTICE, " to RNC %s %s\n",
osmo_rnc_id_name(&rnc->rnc_id), osmo_sccp_addr_dump(&rnc->sccp_addr));
llist_del(&lre->entry);
llist_add(&lre->entry, &rnc->lac_rac_list);
global_iu_event_new_area(rnc_id, rai);
} else if (!old_rnc) {
/* LAC, RAC not recorded yet */
LOGP(DRANAP, LOGL_NOTICE, "RNC %s: new LAC/RAC %s\n",
osmo_rnc_id_name(rnc_id), osmo_rai_name2(rai));
lre = talloc_zero(rnc, struct iu_lac_rac_entry);
lre->rai = *rai;
llist_add(&lre->entry, &rnc->lac_rac_list);
global_iu_event_new_area(rnc_id, rai);
}
/* else, LAC,RAC already recorded with the current RNC. */
return rnc;
}

432
src/sgsn/sccp.c Normal file
View File

@@ -0,0 +1,432 @@
/* SCCP Handling */
/* (C) 2025 by sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
* 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 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 "config.h"
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <osmocom/sigtran/sccp_sap.h>
#include <osmocom/sigtran/sccp_helpers.h>
#include <osmocom/sccp/sccp_types.h>
#include <osmocom/sgsn/debug.h>
#include <osmocom/sgsn/iu_client.h>
#include <osmocom/sgsn/iu_rnc.h>
#include <osmocom/sgsn/gprs_ranap.h>
#include <osmocom/sgsn/sccp.h>
#include <osmocom/sgsn/sgsn.h>
/* Entry to cache conn_id <-> sccp_addr mapping in case we receive an empty CR */
struct iu_new_ctx_entry {
struct llist_head list;
uint32_t conn_id;
struct osmo_sccp_addr sccp_addr;
};
static int sccp_sap_up(struct osmo_prim_hdr *oph, void *_scu);
struct sgsn_sccp_user_iups *sgsn_scu_iups_inst_alloc(struct sgsn_instance *sgsn, struct osmo_sccp_instance *sccp)
{
struct sgsn_sccp_user_iups *scu_iups;
scu_iups = talloc_zero(sgsn, struct sgsn_sccp_user_iups);
OSMO_ASSERT(scu_iups);
scu_iups->sgsn = sgsn;
scu_iups->sccp = sccp;
INIT_LLIST_HEAD(&scu_iups->ue_conn_ctx_list);
INIT_LLIST_HEAD(&scu_iups->ue_conn_sccp_addr_list);
osmo_sccp_local_addr_by_instance(&scu_iups->local_sccp_addr, scu_iups->sccp, OSMO_SCCP_SSN_RANAP);
scu_iups->scu = osmo_sccp_user_bind(scu_iups->sccp, "OsmoSGSN-IuPS", sccp_sap_up, OSMO_SCCP_SSN_RANAP);
osmo_sccp_user_set_priv(scu_iups->scu, scu_iups);
return scu_iups;
}
void sgsn_scu_iups_free(struct sgsn_sccp_user_iups *scu_iups)
{
if (!scu_iups)
return;
if (scu_iups->scu)
osmo_sccp_user_unbind(scu_iups->scu);
talloc_free(scu_iups);
}
static struct ranap_ue_conn_ctx *ue_conn_ctx_find(struct sgsn_sccp_user_iups *scu_iups, uint32_t conn_id)
{
struct ranap_ue_conn_ctx *ctx;
llist_for_each_entry(ctx, &scu_iups->ue_conn_ctx_list, list) {
if (ctx->conn_id == conn_id)
return ctx;
}
return NULL;
}
static void ue_conn_sccp_addr_add(struct sgsn_sccp_user_iups *scu_iups, uint32_t conn_id, const struct osmo_sccp_addr *calling_addr)
{
struct iu_new_ctx_entry *entry = talloc_zero(scu_iups, struct iu_new_ctx_entry);
entry->conn_id = conn_id;
entry->sccp_addr = *calling_addr;
llist_add(&entry->list, &scu_iups->ue_conn_sccp_addr_list);
}
static const struct osmo_sccp_addr *ue_conn_sccp_addr_find(struct sgsn_sccp_user_iups *scu_iups, uint32_t conn_id)
{
struct iu_new_ctx_entry *entry;
llist_for_each_entry(entry, &scu_iups->ue_conn_sccp_addr_list, list) {
if (entry->conn_id == conn_id)
return &entry->sccp_addr;
}
return NULL;
}
static void ue_conn_sccp_addr_del(struct sgsn_sccp_user_iups *scu_iups, uint32_t conn_id)
{
struct iu_new_ctx_entry *entry;
llist_for_each_entry(entry, &scu_iups->ue_conn_sccp_addr_list, list) {
if (entry->conn_id == conn_id) {
llist_del(&entry->list);
talloc_free(entry);
return;
}
}
}
static void ue_ctx_link_invalidated_free(struct ranap_ue_conn_ctx *ue)
{
uint32_t conn_id = ue->conn_id;
struct sgsn_sccp_user_iups *scu_iups = ue->scu_iups;
global_iu_event(ue, RANAP_IU_EVENT_LINK_INVALIDATED, NULL);
/* A RANAP_IU_EVENT_LINK_INVALIDATED, can lead to a free */
ue = ue_conn_ctx_find(scu_iups, conn_id);
if (!ue)
return;
if (ue->free_on_release)
ranap_iu_free_ue(ue);
}
static void handle_notice_ind(struct sgsn_sccp_user_iups *scu_iups, const struct osmo_scu_notice_param *ni)
{
struct ranap_iu_rnc *rnc;
LOGP(DSUA, LOGL_DEBUG, "(calling_addr=%s) N-NOTICE.ind cause=%u='%s' importance=%u\n",
osmo_sccp_addr_dump(&ni->calling_addr),
ni->cause, osmo_sccp_return_cause_name(ni->cause),
ni->importance);
switch (ni->cause) {
case SCCP_RETURN_CAUSE_SUBSYSTEM_CONGESTION:
case SCCP_RETURN_CAUSE_NETWORK_CONGESTION:
/* Transient failures (hopefully), keep going. */
return;
default:
break;
}
/* Messages are not arriving to RNC. Signal to user that all related ue_ctx are invalid. */
llist_for_each_entry(rnc, &sgsn->rnc_list, entry) {
struct ranap_ue_conn_ctx *ue_ctx, *ue_ctx_tmp;
if (osmo_sccp_addr_ri_cmp(&rnc->sccp_addr, &ni->calling_addr))
continue;
LOGP(DSUA, LOGL_NOTICE,
"RNC %s now unreachable: N-NOTICE.ind cause=%u='%s' importance=%u\n",
osmo_rnc_id_name(&rnc->rnc_id),
ni->cause, osmo_sccp_return_cause_name(ni->cause),
ni->importance);
llist_for_each_entry_safe(ue_ctx, ue_ctx_tmp, &scu_iups->ue_conn_ctx_list, list) {
if (ue_ctx->rnc != rnc)
continue;
ue_ctx_link_invalidated_free(ue_ctx);
}
/* TODO: ideally we'd have some event to submit to upper
* layer to inform about peer availability change... */
}
}
static void handle_pcstate_ind(struct sgsn_sccp_user_iups *scu_iups, const struct osmo_scu_pcstate_param *pcst)
{
struct osmo_ss7_instance *cs7 = osmo_sccp_get_ss7(scu_iups->sccp);
struct osmo_sccp_addr rem_addr;
struct ranap_iu_rnc *rnc;
bool connected;
bool disconnected;
LOGP(DSUA, LOGL_DEBUG, "N-PCSTATE ind: affected_pc=%u=%s sp_status=%s remote_sccp_status=%s\n",
pcst->affected_pc, osmo_ss7_pointcode_print(cs7, pcst->affected_pc),
osmo_sccp_sp_status_name(pcst->sp_status),
osmo_sccp_rem_sccp_status_name(pcst->remote_sccp_status));
osmo_sccp_make_addr_pc_ssn(&rem_addr, pcst->affected_pc, OSMO_SCCP_SSN_RANAP);
/* See if this marks the point code to have become available, or to have been lost.
*
* I want to detect two events:
* - connection event (both indicators say PC is reachable).
* - disconnection event (at least one indicator says the PC is not reachable).
*
* There are two separate incoming indicators with various possible values -- the incoming events can be:
*
* - neither connection nor disconnection indicated -- just indicating congestion
* connected == false, disconnected == false --> do nothing.
* - both incoming values indicate that we are connected
* --> trigger connected
* - both indicate we are disconnected
* --> trigger disconnected
* - one value indicates 'connected', the other indicates 'disconnected'
* --> trigger disconnected
*
* Congestion could imply that we're connected, but it does not indicate
* that a PC's reachability changed, so no need to trigger on that.
*/
connected = false;
disconnected = false;
switch (pcst->sp_status) {
case OSMO_SCCP_SP_S_ACCESSIBLE:
connected = true;
break;
case OSMO_SCCP_SP_S_INACCESSIBLE:
disconnected = true;
break;
default:
case OSMO_SCCP_SP_S_CONGESTED:
/* Neither connecting nor disconnecting */
break;
}
switch (pcst->remote_sccp_status) {
case OSMO_SCCP_REM_SCCP_S_AVAILABLE:
if (!disconnected)
connected = true;
break;
case OSMO_SCCP_REM_SCCP_S_UNAVAILABLE_UNKNOWN:
case OSMO_SCCP_REM_SCCP_S_UNEQUIPPED:
case OSMO_SCCP_REM_SCCP_S_INACCESSIBLE:
disconnected = true;
connected = false;
break;
default:
case OSMO_SCCP_REM_SCCP_S_CONGESTED:
/* Neither connecting nor disconnecting */
break;
}
if (disconnected) {
/* A previously usable RNC has disconnected. Signal to user that all related ue_ctx are invalid. */
llist_for_each_entry(rnc, &sgsn->rnc_list, entry) {
struct ranap_ue_conn_ctx *ue_ctx, *ue_ctx_tmp;
if (osmo_sccp_addr_cmp(&rnc->sccp_addr, &rem_addr, OSMO_SCCP_ADDR_T_SSN | OSMO_SCCP_ADDR_T_PC))
continue;
LOGP(DSUA, LOGL_NOTICE,
"RNC %s now unreachable: N-PCSTATE ind: pc=%u=%s sp_status=%s remote_sccp_status=%s\n",
osmo_rnc_id_name(&rnc->rnc_id),
pcst->affected_pc, osmo_ss7_pointcode_print(cs7, pcst->affected_pc),
osmo_sccp_sp_status_name(pcst->sp_status),
osmo_sccp_rem_sccp_status_name(pcst->remote_sccp_status));
llist_for_each_entry_safe(ue_ctx, ue_ctx_tmp, &scu_iups->ue_conn_ctx_list, list) {
if (ue_ctx->rnc != rnc)
continue;
ue_ctx_link_invalidated_free(ue_ctx);
}
/* TODO: ideally we'd have some event to submit to upper
* layer to inform about peer availability change... */
}
} else if (connected) {
llist_for_each_entry(rnc, &sgsn->rnc_list, entry) {
if (osmo_sccp_addr_cmp(&rnc->sccp_addr, &rem_addr, OSMO_SCCP_ADDR_T_SSN | OSMO_SCCP_ADDR_T_PC))
continue;
LOGP(DSUA, LOGL_NOTICE,
"RNC %s now available: N-PCSTATE ind: pc=%u=%s sp_status=%s remote_sccp_status=%s\n",
osmo_rnc_id_name(&rnc->rnc_id),
pcst->affected_pc, osmo_ss7_pointcode_print(cs7, pcst->affected_pc),
osmo_sccp_sp_status_name(pcst->sp_status),
osmo_sccp_rem_sccp_status_name(pcst->remote_sccp_status));
/* TODO: ideally we'd have some event to submit to upper
* layer to inform about peer availability change... */
}
}
}
static struct osmo_prim_hdr *make_conn_resp(struct osmo_scu_connect_param *param)
{
struct msgb *msg = msgb_alloc(1024, "conn_resp");
struct osmo_scu_prim *prim;
prim = (struct osmo_scu_prim *) msgb_put(msg, sizeof(*prim));
osmo_prim_init(&prim->oph, SCCP_SAP_USER,
OSMO_SCU_PRIM_N_CONNECT,
PRIM_OP_RESPONSE, msg);
memcpy(&prim->u.connect, param, sizeof(prim->u.connect));
return &prim->oph;
}
static int sccp_sap_up(struct osmo_prim_hdr *oph, void *_scu)
{
struct osmo_sccp_user *scu = _scu;
struct osmo_scu_prim *prim = (struct osmo_scu_prim *) oph;
struct sgsn_sccp_user_iups *scu_iups = osmo_sccp_user_get_priv(scu);
struct osmo_prim_hdr *resp = NULL;
int rc = -1;
struct ranap_ue_conn_ctx *ue;
uint32_t conn_id;
LOGP(DSUA, LOGL_DEBUG, "sccp_sap_up(%s)\n", osmo_scu_prim_name(oph));
switch (OSMO_PRIM_HDR(oph)) {
case OSMO_PRIM(OSMO_SCU_PRIM_N_CONNECT, PRIM_OP_CONFIRM):
/* confirmation of outbound connection */
break;
case OSMO_PRIM(OSMO_SCU_PRIM_N_CONNECT, PRIM_OP_INDICATION):
/* indication of new inbound connection request*/
conn_id = prim->u.connect.conn_id;
LOGP(DSUA, LOGL_DEBUG, "N-CONNECT.ind(X->%u)\n", conn_id);
/* first ensure the local SCCP socket is ACTIVE */
resp = make_conn_resp(&prim->u.connect);
osmo_sccp_user_sap_down(scu, resp);
/* then handle the RANAP payload */
if (/* prim->u.connect.called_addr.ssn != OSMO_SCCP_SSN_RANAP || */
!msgb_l2(oph->msg) || msgb_l2len(oph->msg) == 0) {
LOGP(DSUA, LOGL_DEBUG,
"Received N-CONNECT.ind without data\n");
ue_conn_sccp_addr_add(scu_iups, conn_id, &prim->u.connect.calling_addr);
} else {
rc = sgsn_ranap_iu_rx_co_initial_msg(scu_iups, &prim->u.connect.calling_addr,
conn_id,
msgb_l2(oph->msg), msgb_l2len(oph->msg));
}
break;
case OSMO_PRIM(OSMO_SCU_PRIM_N_DISCONNECT, PRIM_OP_INDICATION):
/* indication of disconnect */
conn_id = prim->u.disconnect.conn_id;
LOGP(DSUA, LOGL_DEBUG, "N-DISCONNECT.ind(%u)\n", conn_id);
ue_conn_sccp_addr_del(scu_iups, conn_id);
ue = ue_conn_ctx_find(scu_iups, conn_id);
if (!ue)
break;
rc = 0;
if (msgb_l2len(oph->msg) > 0)
rc = sgsn_ranap_iu_rx_co_msg(ue, msgb_l2(oph->msg), msgb_l2len(oph->msg));
/* A Iu Release event might be used to free the UE in cn_ranap_handle_co(). */
ue = ue_conn_ctx_find(scu_iups, conn_id);
if (!ue)
break;
ue_ctx_link_invalidated_free(ue);
break;
case OSMO_PRIM(OSMO_SCU_PRIM_N_DATA, PRIM_OP_INDICATION):
/* connection-oriented data received */
conn_id = prim->u.data.conn_id;
LOGP(DSUA, LOGL_DEBUG, "N-DATA.ind(%u, %s)\n", conn_id,
osmo_hexdump(msgb_l2(oph->msg), msgb_l2len(oph->msg)));
/* resolve UE context */
ue = ue_conn_ctx_find(scu_iups, conn_id);
if (!ue) {
/* Could be an InitialUE-Message after an empty CR, recreate new_ctx */
const struct osmo_sccp_addr *sccp_addr = ue_conn_sccp_addr_find(scu_iups, conn_id);
if (!sccp_addr) {
LOGP(DSUA, LOGL_NOTICE,
"N-DATA.ind for unknown conn_id (%u)\n", conn_id);
break;
}
/* Hold copy of address before deleting it: */
struct osmo_sccp_addr rem_sccp_addr = *sccp_addr;
ue_conn_sccp_addr_del(scu_iups, conn_id);
rc = sgsn_ranap_iu_rx_co_initial_msg(scu_iups, &rem_sccp_addr, conn_id,
msgb_l2(oph->msg), msgb_l2len(oph->msg));
break;
}
rc = sgsn_ranap_iu_rx_co_msg(ue, msgb_l2(oph->msg), msgb_l2len(oph->msg));
break;
case OSMO_PRIM(OSMO_SCU_PRIM_N_UNITDATA, PRIM_OP_INDICATION):
/* connection-less data received */
LOGP(DSUA, LOGL_DEBUG, "N-UNITDATA.ind(%s)\n",
osmo_hexdump(msgb_l2(oph->msg), msgb_l2len(oph->msg)));
rc = sgsn_ranap_iu_rx_cl_msg(scu_iups, &prim->u.unitdata, msgb_l2(oph->msg), msgb_l2len(oph->msg));
break;
case OSMO_PRIM(OSMO_SCU_PRIM_N_NOTICE, PRIM_OP_INDICATION):
LOGP(DSUA, LOGL_DEBUG, "N-NOTICE.ind(%s)\n",
osmo_hexdump(msgb_l2(oph->msg), msgb_l2len(oph->msg)));
handle_notice_ind(scu_iups, &prim->u.notice);
break;
case OSMO_PRIM(OSMO_SCU_PRIM_N_PCSTATE, PRIM_OP_INDICATION):
handle_pcstate_ind(scu_iups, &prim->u.pcstate);
break;
case OSMO_PRIM(OSMO_SCU_PRIM_N_STATE, PRIM_OP_INDICATION):
LOGP(DSUA, LOGL_DEBUG, "SCCP-User-SAP: Ignoring %s.%s\n",
osmo_scu_prim_type_name(oph->primitive),
get_value_string(osmo_prim_op_names, oph->operation));
break;
default:
break;
}
msgb_free(oph->msg);
return rc;
}
int sgsn_sccp_init(struct sgsn_instance *sgi)
{
/* Note that these are mostly defaults and can be overridden from the VTY */
sgi->sccp.sccp = osmo_sccp_simple_client_on_ss7_id(tall_sgsn_ctx,
sgi->cfg.iu.cs7_instance,
"OsmoSGSN",
(23 << 3) + 4,
OSMO_SS7_ASP_PROT_M3UA,
0, "localhost",
0, "localhost");
if (!sgi->sccp.sccp) {
LOGP(DGPRS, LOGL_ERROR, "Setting up SCCP instance on cs7 instance %d failed!\n",
sgi->cfg.iu.cs7_instance);
return -EINVAL;
}
osmo_sccp_set_priv(sgi->sccp.sccp, sgsn);
sgi->sccp.scu_iups = sgsn_scu_iups_inst_alloc(sgsn, sgi->sccp.sccp);
OSMO_ASSERT(sgi->sccp.scu_iups);
return 0;
}
void sgsn_sccp_release(struct sgsn_instance *sgi)
{
sgsn_scu_iups_free(sgi->sccp.scu_iups);
sgi->sccp.scu_iups = NULL;
if (sgi->sccp.sccp) {
osmo_sccp_instance_destroy(sgi->sccp.sccp);
sgi->sccp.sccp = NULL;
}
}

19
src/sgsn/sgsn.c
View File

@@ -21,6 +21,8 @@
#include <stdint.h>
#include "config.h"
#include <osmocom/core/linuxlist.h>
#include <osmocom/core/talloc.h>
#include <osmocom/core/timer.h>
@@ -58,6 +60,9 @@
#include <osmocom/sgsn/gtp.h>
#include <osmocom/sgsn/pdpctx.h>
#include <osmocom/sgsn/gprs_routing_area.h>
#if BUILD_IU
#include <osmocom/sgsn/sccp.h>
#endif /* #if BUILD_IU */
#include <time.h>
@@ -152,6 +157,9 @@ static void sgsn_llme_check_cb(void *data_)
static int sgsn_instance_talloc_destructor(struct sgsn_instance *sgi)
{
sgsn_cdr_release(sgi);
#if BUILD_IU
sgsn_sccp_release(sgi);
#endif /* #if BUILD_IU */
osmo_timer_del(&sgi->llme_timer);
rate_ctr_group_free(sgi->rate_ctrs);
return 0;
@@ -184,6 +192,9 @@ struct sgsn_instance *sgsn_instance_alloc(void *talloc_ctx)
INIT_LLIST_HEAD(&inst->mme_list);
INIT_LLIST_HEAD(&inst->mm_list);
INIT_LLIST_HEAD(&inst->pdp_list);
#if BUILD_IU
INIT_LLIST_HEAD(&inst->rnc_list);
#endif /* #if BUILD_IU */
osmo_timer_setup(&inst->llme_timer, sgsn_llme_check_cb, NULL);
osmo_timer_schedule(&inst->llme_timer, GPRS_LLME_CHECK_TICK, 0);
@@ -218,5 +229,13 @@ int sgsn_inst_init(struct sgsn_instance *sgsn)
LOGP(DGPRS, LOGL_FATAL, "Cannot set up SGSN\n");
return rc;
}
#if BUILD_IU
rc = sgsn_sccp_init(sgsn);
if (rc < 0) {
LOGP(DGPRS, LOGL_FATAL, "Cannot set up SGSN SCCP layer\n");
return rc;
}
#endif /* #if BUILD_IU */
return 0;
}

18
src/sgsn/sgsn_main.c
View File

@@ -372,9 +372,6 @@ static bool file_exists(const char *path)
int main(int argc, char **argv)
{
int rc;
#if BUILD_IU
struct osmo_sccp_instance *sccp;
#endif
srand(time(NULL));
tall_sgsn_ctx = talloc_named_const(NULL, 0, "osmo_sgsn");
@@ -477,20 +474,7 @@ int main(int argc, char **argv)
}
#if BUILD_IU
/* Note that these are mostly defaults and can be overriden from the VTY */
sccp = osmo_sccp_simple_client_on_ss7_id(tall_sgsn_ctx,
sgsn->cfg.iu.cs7_instance,
"OsmoSGSN",
(23 << 3) + 4,
OSMO_SS7_ASP_PROT_M3UA,
0, "localhost",
0, "localhost");
if (!sccp) {
printf("Setting up SCCP client failed.\n");
return 8;
}
ranap_iu_init(tall_sgsn_ctx, DRANAP, "OsmoSGSN-IuPS", sccp, gsm0408_gprs_rcvmsg_iu, sgsn_ranap_iu_event);
ranap_iu_init(tall_sgsn_ctx);
#endif
if (daemonize) {

2
tests/gprs_routing_area/Makefile.am
View File

@@ -88,6 +88,8 @@ gprs_routing_area_test_LDADD += \
$(top_builddir)/src/sgsn/gprs_ranap.o \
$(top_builddir)/src/sgsn/gprs_mm_state_iu_fsm.o \
$(top_builddir)/src/sgsn/iu_client.o \
$(top_builddir)/src/sgsn/iu_rnc.o \
$(top_builddir)/src/sgsn/sccp.o \
$(LIBOSMORANAP_LIBS) \
$(LIBOSMOSIGTRAN_LIBS) \
$(LIBASN1C_LIBS) \

2
tests/sgsn/Makefile.am
View File

@@ -102,6 +102,8 @@ sgsn_test_LDADD += \
$(top_builddir)/src/sgsn/gprs_ranap.o \
$(top_builddir)/src/sgsn/gprs_mm_state_iu_fsm.o \
$(top_builddir)/src/sgsn/iu_client.o \
$(top_builddir)/src/sgsn/iu_rnc.o \
$(top_builddir)/src/sgsn/sccp.o \
$(LIBOSMORANAP_LIBS) \
$(LIBOSMOSIGTRAN_LIBS) \
$(LIBASN1C_LIBS) \