2017-07-23 15:26:17 +00:00
|
|
|
module BSSGP_Emulation {
|
|
|
|
|
2019-05-27 09:54:11 +00:00
|
|
|
/* BSSGP Emulation in TTCN-3
|
|
|
|
* (C) 2018-2019 Harald Welte <laforge@gnumonks.org>
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Released under the terms of GNU General Public License, Version 2 or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
import from General_Types all;
|
|
|
|
import from Osmocom_Types all;
|
2018-02-15 16:45:29 +00:00
|
|
|
import from NS_Types all;
|
|
|
|
import from NS_Emulation all;
|
|
|
|
import from BSSGP_Types all;
|
|
|
|
import from Osmocom_Gb_Types all;
|
|
|
|
import from IPL4asp_Types all;
|
|
|
|
|
2020-09-12 18:51:05 +00:00
|
|
|
#ifdef BSSGP_EM_L3
|
2018-02-15 19:39:13 +00:00
|
|
|
import from MobileL3_GMM_SM_Types all;
|
|
|
|
import from MobileL3_Types all;
|
2020-09-12 18:51:05 +00:00
|
|
|
#endif
|
2018-02-15 19:39:13 +00:00
|
|
|
|
|
|
|
import from LLC_Types all;
|
|
|
|
import from LLC_Templates all;
|
|
|
|
|
2018-02-18 18:03:36 +00:00
|
|
|
import from SNDCP_Types all;
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
/***********************************************************************
|
|
|
|
* Communication between Client Components and Main Component
|
|
|
|
***********************************************************************/
|
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
type record BssgpStatusIndication {
|
|
|
|
Nsei nsei,
|
|
|
|
BssgpBvci bvci,
|
|
|
|
BvcState state
|
|
|
|
}
|
|
|
|
|
|
|
|
template BssgpStatusIndication t_BssgpStsInd(template Nsei nsei, template BssgpBvci bvci, template BvcState state) := {
|
|
|
|
nsei := nsei,
|
|
|
|
bvci := bvci,
|
|
|
|
state := state
|
|
|
|
}
|
|
|
|
|
|
|
|
type enumerated BvcState {
|
|
|
|
BVC_S_BLOCKED,
|
|
|
|
BVC_S_UNBLOCKED
|
|
|
|
};
|
|
|
|
|
|
|
|
/* port from our (internal) point of view */
|
|
|
|
type port BSSGP_SP_PT message {
|
2018-02-15 19:39:13 +00:00
|
|
|
in PDU_BSSGP,
|
2020-09-12 18:51:05 +00:00
|
|
|
PDU_LLC
|
|
|
|
#ifdef BSSGP_EM_L3
|
|
|
|
,
|
2018-02-15 19:39:13 +00:00
|
|
|
PDU_L3_MS_SGSN,
|
2020-09-12 18:51:05 +00:00
|
|
|
PDU_L3_SGSN_MS
|
|
|
|
#endif
|
|
|
|
;
|
2019-05-02 23:29:29 +00:00
|
|
|
out PDU_BSSGP,
|
|
|
|
PDU_LLC,
|
|
|
|
PDU_SN,
|
2018-02-15 16:45:29 +00:00
|
|
|
NsStatusIndication,
|
|
|
|
BssgpStatusIndication,
|
2020-09-12 18:51:05 +00:00
|
|
|
ASP_Event
|
|
|
|
#ifdef BSSGP_EM_L3
|
|
|
|
,
|
2018-02-15 19:39:13 +00:00
|
|
|
PDU_L3_MS_SGSN,
|
2020-09-12 18:51:05 +00:00
|
|
|
PDU_L3_SGSN_MS
|
|
|
|
#endif
|
|
|
|
;
|
2018-02-15 16:45:29 +00:00
|
|
|
} with { extension "internal" };
|
|
|
|
|
|
|
|
/* port from the user point of view */
|
|
|
|
type port BSSGP_PT message {
|
|
|
|
in ASP_Event,
|
|
|
|
NsStatusIndication,
|
|
|
|
BssgpStatusIndication,
|
2019-05-02 23:29:29 +00:00
|
|
|
PDU_BSSGP,
|
|
|
|
PDU_LLC,
|
2020-09-12 18:51:05 +00:00
|
|
|
PDU_SN
|
|
|
|
#ifdef BSSGP_EM_L3
|
|
|
|
,
|
2018-02-15 19:39:13 +00:00
|
|
|
PDU_L3_MS_SGSN,
|
2020-09-12 18:51:05 +00:00
|
|
|
PDU_L3_SGSN_MS
|
|
|
|
#endif
|
|
|
|
;
|
2018-02-15 19:39:13 +00:00
|
|
|
out PDU_BSSGP,
|
2020-09-12 18:51:05 +00:00
|
|
|
PDU_LLC
|
|
|
|
#ifdef BSSGP_EM_L3
|
|
|
|
,
|
2018-02-15 19:39:13 +00:00
|
|
|
PDU_L3_SGSN_MS,
|
2020-09-12 18:51:05 +00:00
|
|
|
PDU_L3_MS_SGSN
|
|
|
|
#endif
|
|
|
|
;
|
2018-02-15 16:45:29 +00:00
|
|
|
} with { extension "internal" };
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
signature BSSGP_register_client(hexstring imsi, OCT4 tlli, BssgpCellId cell_id);
|
|
|
|
signature BSSGP_unregister_client(hexstring imsi);
|
2018-02-17 09:11:19 +00:00
|
|
|
signature BSSGP_llgmm_assign(OCT4 tlli_old, OCT4 tlli);
|
2018-02-15 19:39:13 +00:00
|
|
|
|
|
|
|
type port BSSGP_PROC_PT procedure {
|
2018-02-17 09:11:19 +00:00
|
|
|
inout BSSGP_register_client, BSSGP_unregister_client, BSSGP_llgmm_assign;
|
2018-02-15 19:39:13 +00:00
|
|
|
} with { extension "internal" };
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* Client Component for a single MS/TLLI
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
type component BSSGP_Client_CT {
|
2018-07-28 21:06:00 +00:00
|
|
|
port BSSGP_PT BSSGP[3];
|
|
|
|
port BSSGP_PT BSSGP_SIG[3];
|
|
|
|
port BSSGP_PROC_PT BSSGP_PROC[3];
|
2018-02-15 19:39:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* Main Component
|
|
|
|
***********************************************************************/
|
|
|
|
|
|
|
|
function BssgpStart(BssgpConfig cfg) runs on BSSGP_CT {
|
|
|
|
g_cfg := cfg;
|
2018-02-15 16:45:29 +00:00
|
|
|
f_init();
|
|
|
|
f_ScanEvents();
|
|
|
|
}
|
|
|
|
|
|
|
|
private function f_init() runs on BSSGP_CT {
|
|
|
|
/* Connect the UDP socket */
|
|
|
|
f_change_state(BVC_S_BLOCKED);
|
|
|
|
}
|
|
|
|
|
|
|
|
type component BSSGP_CT {
|
2018-05-03 17:14:28 +00:00
|
|
|
/* UDP ports towards the bottom (IUT) */
|
2018-02-15 16:45:29 +00:00
|
|
|
port NS_PT BSCP;
|
|
|
|
/* NS-User SAP towards the user */
|
|
|
|
port BSSGP_SP_PT BSSGP_SP;
|
2018-05-03 17:14:28 +00:00
|
|
|
port BSSGP_SP_PT BSSGP_SP_SIG;
|
2018-02-15 19:39:13 +00:00
|
|
|
port BSSGP_PROC_PT BSSGP_PROC;
|
|
|
|
|
|
|
|
var BssgpConfig g_cfg;
|
2018-02-15 16:45:29 +00:00
|
|
|
|
|
|
|
var BvcState g_ptp_bvc_state := BVC_S_BLOCKED;
|
|
|
|
timer g_T1 := 15.0;
|
|
|
|
timer g_T2 := 60.0;
|
2018-02-15 19:39:13 +00:00
|
|
|
|
|
|
|
var ClientEntity ClientTable[16];
|
|
|
|
}
|
|
|
|
|
2018-07-31 12:19:36 +00:00
|
|
|
type record length(16) of LLC_Entity LLC_Entities;
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
type record ClientEntity {
|
|
|
|
OCT4 tlli,
|
|
|
|
OCT4 tlli_old optional,
|
|
|
|
hexstring imsi,
|
|
|
|
BssgpCellId cell_id,
|
|
|
|
BSSGP_Client_CT comp_ref,
|
|
|
|
/* LLC entities, one for each SAPI */
|
|
|
|
LLC_Entity llc[16]
|
|
|
|
};
|
|
|
|
|
|
|
|
type record LLC_Entity {
|
|
|
|
boolean sgsn_role,
|
|
|
|
/* N(U) on transmit side for next PDU */
|
|
|
|
uint9_t n_u_tx_next,
|
|
|
|
/* N(U) on receive side, last PDU */
|
|
|
|
uint9_t n_u_rx_last optional
|
|
|
|
};
|
|
|
|
|
2018-07-31 13:37:14 +00:00
|
|
|
function f_llc_create(boolean sgsn_role := false) return LLC_Entities {
|
|
|
|
var LLC_Entities llc;
|
|
|
|
for (var integer i := 0; i < 16; i := i+1) {
|
|
|
|
llc[i] := valueof(t_LLC_init(sgsn_role));
|
|
|
|
}
|
|
|
|
return llc;
|
|
|
|
}
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
private template LLC_Entity t_LLC_init(boolean sgsn_role := false) := {
|
|
|
|
sgsn_role := sgsn_role,
|
|
|
|
n_u_tx_next := 0,
|
|
|
|
n_u_rx_last := -
|
2018-02-15 16:45:29 +00:00
|
|
|
}
|
|
|
|
|
BSSGP_Emulation: add BssgpDecodeDepth
Make the decoding level (BSSGP, LLC, SNDCP, L3) configurable, so the
existing PCU tests, that expect messages only decoded to the BSSGP
level, can pass again. Move the SNDCP decoding in f_dec_bssgp above the
L3 decoding, so f_dec_bssgp goes through the layers in the reverse order
of f_send_bssgp_dec.
I have verified, that all testsuites using the BSSGP Emulation (SGSN,
PCU, PCU-SNS) are still working with this patch.
Related: OS#4180
Fixes: 955aa94504510139a12d223071cf49ef90788a3d ("BSSGP_Emulation: Abandon "BssgpDecoded" intermediate structure")
Change-Id: I8f76385528c1de98c557cee451c0e0dfd182b605
2019-09-02 06:36:36 +00:00
|
|
|
type enumerated BssgpDecodeDepth {
|
|
|
|
BSSGP_DECODE_DEPTH_BSSGP,
|
|
|
|
BSSGP_DECODE_DEPTH_LLC,
|
2020-09-12 18:51:05 +00:00
|
|
|
BSSGP_DECODE_DEPTH_SNDCP
|
|
|
|
#ifdef BSSGP_EM_L3
|
|
|
|
,
|
BSSGP_Emulation: add BssgpDecodeDepth
Make the decoding level (BSSGP, LLC, SNDCP, L3) configurable, so the
existing PCU tests, that expect messages only decoded to the BSSGP
level, can pass again. Move the SNDCP decoding in f_dec_bssgp above the
L3 decoding, so f_dec_bssgp goes through the layers in the reverse order
of f_send_bssgp_dec.
I have verified, that all testsuites using the BSSGP Emulation (SGSN,
PCU, PCU-SNS) are still working with this patch.
Related: OS#4180
Fixes: 955aa94504510139a12d223071cf49ef90788a3d ("BSSGP_Emulation: Abandon "BssgpDecoded" intermediate structure")
Change-Id: I8f76385528c1de98c557cee451c0e0dfd182b605
2019-09-02 06:36:36 +00:00
|
|
|
BSSGP_DECODE_DEPTH_L3
|
2020-09-12 18:51:05 +00:00
|
|
|
#endif
|
BSSGP_Emulation: add BssgpDecodeDepth
Make the decoding level (BSSGP, LLC, SNDCP, L3) configurable, so the
existing PCU tests, that expect messages only decoded to the BSSGP
level, can pass again. Move the SNDCP decoding in f_dec_bssgp above the
L3 decoding, so f_dec_bssgp goes through the layers in the reverse order
of f_send_bssgp_dec.
I have verified, that all testsuites using the BSSGP Emulation (SGSN,
PCU, PCU-SNS) are still working with this patch.
Related: OS#4180
Fixes: 955aa94504510139a12d223071cf49ef90788a3d ("BSSGP_Emulation: Abandon "BssgpDecoded" intermediate structure")
Change-Id: I8f76385528c1de98c557cee451c0e0dfd182b605
2019-09-02 06:36:36 +00:00
|
|
|
};
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
type record BssgpConfig {
|
|
|
|
Nsvci nsei,
|
|
|
|
Nsvci bvci,
|
|
|
|
BssgpCellId cell_id,
|
BSSGP_Emulation: add BssgpDecodeDepth
Make the decoding level (BSSGP, LLC, SNDCP, L3) configurable, so the
existing PCU tests, that expect messages only decoded to the BSSGP
level, can pass again. Move the SNDCP decoding in f_dec_bssgp above the
L3 decoding, so f_dec_bssgp goes through the layers in the reverse order
of f_send_bssgp_dec.
I have verified, that all testsuites using the BSSGP Emulation (SGSN,
PCU, PCU-SNS) are still working with this patch.
Related: OS#4180
Fixes: 955aa94504510139a12d223071cf49ef90788a3d ("BSSGP_Emulation: Abandon "BssgpDecoded" intermediate structure")
Change-Id: I8f76385528c1de98c557cee451c0e0dfd182b605
2019-09-02 06:36:36 +00:00
|
|
|
boolean sgsn_role,
|
|
|
|
BssgpDecodeDepth depth
|
2018-02-15 16:45:29 +00:00
|
|
|
};
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
function f_BnsUdReq(template PDU_BSSGP pdu, BssgpBvci bvci)
|
|
|
|
runs on BSSGP_CT return NsUnitdataRequest {
|
2018-02-15 16:45:29 +00:00
|
|
|
var NsUnitdataRequest udr := {
|
2017-07-23 15:26:17 +00:00
|
|
|
bvci := bvci,
|
2018-02-15 19:39:13 +00:00
|
|
|
nsei := g_cfg.nsei,
|
2018-02-15 16:45:29 +00:00
|
|
|
/* for some weird reason we get "Dynamic test case error: Text encoder: Encoding an
|
|
|
|
* unbound integer value." when trying to send the reocrd rather than the octetstring */
|
|
|
|
//sdu := omit,
|
|
|
|
//bssgp := valueof(pdu)
|
|
|
|
sdu := enc_PDU_BSSGP(valueof(pdu)),
|
|
|
|
bssgp := omit
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
return udr;
|
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
function f_BnsUdInd(template PDU_BSSGP pdu, template BssgpBvci bvci)
|
|
|
|
runs on BSSGP_CT return template NsUnitdataIndication {
|
2018-02-15 16:45:29 +00:00
|
|
|
var template NsUnitdataIndication udi := {
|
|
|
|
bvci := bvci,
|
2018-02-15 19:39:13 +00:00
|
|
|
nsei := g_cfg.nsei,
|
2018-02-15 16:45:29 +00:00
|
|
|
sdu := *,
|
|
|
|
bssgp := pdu
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
return udi;
|
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
private function f_change_state(BvcState new_state) runs on BSSGP_CT {
|
|
|
|
log("BSSGP State Transition: ", g_ptp_bvc_state, " -> ", new_state);
|
|
|
|
g_ptp_bvc_state := new_state;
|
2018-02-15 19:39:13 +00:00
|
|
|
for (var integer i := 0; i < sizeof(ClientTable); i := i+1) {
|
|
|
|
if (isbound(ClientTable[i].comp_ref)) {
|
|
|
|
BSSGP_SP.send(t_BssgpStsInd(g_cfg.nsei, g_cfg.bvci, g_ptp_bvc_state)) to ClientTable[i].comp_ref;
|
|
|
|
}
|
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
private function f_sendReset() runs on BSSGP_CT {
|
2018-02-15 19:39:13 +00:00
|
|
|
var PDU_BSSGP pdu := valueof(ts_BVC_RESET(BSSGP_CAUSE_OM_INTERVENTION, g_cfg.bvci, g_cfg.cell_id));
|
2018-02-15 16:45:29 +00:00
|
|
|
log("PDU: ", pdu);
|
|
|
|
log("ENC: ", enc_PDU_BSSGP(pdu));
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
/* BVC-RESET is always sent via the SIGNALLING BVCI, see Table 5.4.1 */
|
|
|
|
BSCP.send(f_BnsUdReq(pdu, 0));
|
|
|
|
g_T2.start;
|
|
|
|
//f_change_state(BVC_S_WAIT_RESET);
|
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
private function f_sendUnblock() runs on BSSGP_CT {
|
2018-02-15 19:39:13 +00:00
|
|
|
BSCP.send(f_BnsUdReq(t_BVC_UNBLOCK(g_cfg.bvci), 0));
|
2018-02-15 16:45:29 +00:00
|
|
|
g_T1.start;
|
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
private function f_sendBlock(BssgpCause cause) runs on BSSGP_CT {
|
2018-02-15 19:39:13 +00:00
|
|
|
BSCP.send(f_BnsUdReq(t_BVC_BLOCK(g_cfg.bvci, cause), 0));
|
2018-02-15 16:45:29 +00:00
|
|
|
g_T1.start;
|
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
private function f_sendStatus(BssgpCause cause, PDU_BSSGP pdu) runs on BSSGP_CT {
|
|
|
|
/* FIXME: Make sure correct Signaling or PTP BVCI is used! */
|
2018-02-15 19:39:13 +00:00
|
|
|
BSCP.send(f_BnsUdReq(ts_BSSGP_STATUS(g_cfg.bvci, cause, pdu), g_cfg.bvci));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* attempt to extract the TLLI from a BSSGP PDU */
|
|
|
|
function f_bssgp_get_tlli(PDU_BSSGP bssgp) return template OCT4 {
|
|
|
|
if (ischosen(bssgp.pDU_BSSGP_DL_UNITDATA)) {
|
|
|
|
return bssgp.pDU_BSSGP_DL_UNITDATA.tLLI_current;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_UL_UNITDATA)) {
|
|
|
|
return bssgp.pDU_BSSGP_UL_UNITDATA.tLLI;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_RA_CAPABILITY)) {
|
|
|
|
return bssgp.pDU_BSSGP_RA_CAPABILITY.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_RA_CAPABILITY_UPDATE)) {
|
|
|
|
return bssgp.pDU_BSSGP_RA_CAPABILITY_UPDATE.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_RA_CAPABILITY_UPDATE_ACK)) {
|
|
|
|
return bssgp.pDU_BSSGP_RA_CAPABILITY_UPDATE_ACK.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_RADIO_STATUS)) {
|
|
|
|
return bssgp.pDU_BSSGP_RADIO_STATUS.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_SUSPEND)) {
|
|
|
|
return bssgp.pDU_BSSGP_SUSPEND.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_SUSPEND_ACK)) {
|
|
|
|
return bssgp.pDU_BSSGP_SUSPEND_ACK.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_SUSPEND_NACK)) {
|
|
|
|
return bssgp.pDU_BSSGP_SUSPEND_NACK.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_RESUME)) {
|
|
|
|
return bssgp.pDU_BSSGP_RESUME.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_RESUME_ACK)) {
|
|
|
|
return bssgp.pDU_BSSGP_RESUME_ACK.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_RESUME_NACK)) {
|
|
|
|
return bssgp.pDU_BSSGP_RESUME_NACK.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_FLUSH_LL)) {
|
|
|
|
return bssgp.pDU_BSSGP_FLUSH_LL.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_FLUSH_LL_ACK)) {
|
|
|
|
return bssgp.pDU_BSSGP_FLUSH_LL_ACK.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_LLC_DISCARDED)) {
|
|
|
|
return bssgp.pDU_BSSGP_LLC_DISCARDED.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_LLC_DISCARDED)) {
|
|
|
|
return bssgp.pDU_BSSGP_LLC_DISCARDED.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_PAGING_CS) and
|
|
|
|
isvalue(bssgp.pDU_BSSGP_PAGING_CS.tLLI)) {
|
|
|
|
return bssgp.pDU_BSSGP_PAGING_CS.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_FLOW_CONTROL_MS)) {
|
|
|
|
return bssgp.pDU_BSSGP_FLOW_CONTROL_MS.tLLI.tLLI_Value;
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_FLOW_CONTROL_MS_ACK)) {
|
|
|
|
return bssgp.pDU_BSSGP_FLOW_CONTROL_MS_ACK.tLLI.tLLI_Value;
|
|
|
|
}
|
|
|
|
/* TODO: Handover, PFC, LCS */
|
|
|
|
return omit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
private function f_tbl_init() runs on BSSGP_CT {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < sizeof(ImsiTable); i := i+1) {
|
|
|
|
ImsiTable[i] := -;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i := 0; i < sizeof(TlliTable); i := i+1) {
|
|
|
|
TlliTable[i] := -;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
private function f_tbl_client_add(hexstring imsi, OCT4 tlli, BssgpCellId cell_id, BSSGP_Client_CT vc_conn)
|
|
|
|
runs on BSSGP_CT {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < sizeof(ClientTable); i := i+1) {
|
2018-02-18 13:06:12 +00:00
|
|
|
if (not isvalue(ClientTable[i].comp_ref)) {
|
|
|
|
log("Adding Client=", vc_conn, ", IMSI=", imsi, ", TLLI=", tlli, ", index=", i);
|
2018-02-15 19:39:13 +00:00
|
|
|
ClientTable[i] := {
|
|
|
|
tlli := tlli,
|
|
|
|
tlli_old := omit,
|
|
|
|
imsi := imsi,
|
|
|
|
cell_id := cell_id,
|
|
|
|
comp_ref := vc_conn,
|
|
|
|
llc := -
|
|
|
|
};
|
|
|
|
for (var integer j := 0; j < sizeof(ClientTable[i].llc); j := j+1) {
|
|
|
|
ClientTable[i].llc[j] := valueof(t_LLC_init(g_cfg.sgsn_role));
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2018-07-05 15:35:03 +00:00
|
|
|
testcase.stop("Client Table full");
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private function f_tbl_client_del(hexstring imsi, BSSGP_Client_CT vc_conn) runs on BSSGP_CT {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < sizeof(ClientTable); i := i+1) {
|
2018-02-18 13:06:12 +00:00
|
|
|
if (isvalue(ClientTable[i].imsi) and ClientTable[i].imsi == imsi) {
|
2018-02-15 19:39:13 +00:00
|
|
|
if (ClientTable[i].comp_ref != vc_conn) {
|
2018-06-12 16:10:30 +00:00
|
|
|
setverdict(fail, "Cannot unregister index=", i, " IMSI ", imsi, " registred to ",
|
2018-02-15 19:39:13 +00:00
|
|
|
ClientTable[i].comp_ref, " from ", vc_conn);
|
2018-07-05 15:35:03 +00:00
|
|
|
mtc.stop;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
log("Removing Client IMSI=", imsi, ", index=", i);
|
2018-06-12 16:10:30 +00:00
|
|
|
ClientTable[i] := {
|
|
|
|
tlli := -,
|
|
|
|
tlli_old := omit,
|
|
|
|
imsi := ''H,
|
|
|
|
cell_id := -,
|
|
|
|
comp_ref := null,
|
|
|
|
llc := - };
|
2018-02-15 19:39:13 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2018-07-31 13:55:34 +00:00
|
|
|
log("Warning: Could not find client for IMSI ", imsi);
|
|
|
|
return;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
2018-02-17 09:11:19 +00:00
|
|
|
/* TS 44.064 7.2.1.1 LLGMM-ASSIGN */
|
|
|
|
private function f_tbl_client_llgmm_assign(OCT4 tlli_old, OCT4 tlli_new, BSSGP_Client_CT vc_conn)
|
|
|
|
runs on BSSGP_CT {
|
|
|
|
var integer i := f_tbl_idx_by_comp(vc_conn);
|
|
|
|
|
|
|
|
if (tlli_old == 'FFFFFFFF'O and tlli_new != 'FFFFFFFF'O) {
|
|
|
|
/* TLLI assignment */
|
|
|
|
ClientTable[i].tlli := tlli_new;
|
|
|
|
ClientTable[i].tlli_old := omit;
|
|
|
|
} else if (tlli_old != 'FFFFFFFF'O and tlli_new != 'FFFFFFFF'O) {
|
|
|
|
/* TLLI change: both active */
|
|
|
|
ClientTable[i].tlli := tlli_new;
|
|
|
|
ClientTable[i].tlli_old := tlli_old;
|
|
|
|
} else if (tlli_old != 'FFFFFFFF'O and tlli_new == 'FFFFFFFF'O) {
|
|
|
|
/* TLLI unassignment: old shall be unassigned; new stays */
|
|
|
|
ClientTable[i].tlli_old := omit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
private function f_tbl_comp_by_imsi(hexstring imsi) runs on BSSGP_CT return BSSGP_Client_CT {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < sizeof(ClientTable); i := i+1) {
|
2018-02-18 13:06:12 +00:00
|
|
|
if (isvalue(ClientTable[i].imsi) and isvalue(ClientTable[i].comp_ref)
|
2018-02-15 19:39:13 +00:00
|
|
|
and ClientTable[i].imsi == imsi) {
|
|
|
|
return ClientTable[i].comp_ref;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(fail, "Couldn't find Component for IMSI ", imsi);
|
2018-07-05 15:35:03 +00:00
|
|
|
mtc.stop;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private function f_tbl_comp_by_tlli(OCT4 tlli) runs on BSSGP_CT return BSSGP_Client_CT {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < sizeof(ClientTable); i := i+1) {
|
2018-02-18 13:06:12 +00:00
|
|
|
if (isvalue(ClientTable[i].comp_ref) and
|
|
|
|
(isvalue(ClientTable[i].tlli) and (ClientTable[i].tlli == tlli or
|
|
|
|
isvalue(ClientTable[i].tlli_old) and ClientTable[i].tlli_old == tlli) )) {
|
2018-02-15 19:39:13 +00:00
|
|
|
return ClientTable[i].comp_ref;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(fail, "Couldn't find Component for TLLI ", tlli);
|
2018-07-05 15:35:03 +00:00
|
|
|
mtc.stop;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private function f_tbl_idx_by_comp(BSSGP_Client_CT comp_ref) runs on BSSGP_CT return integer {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < sizeof(ClientTable); i := i+1) {
|
2018-02-18 13:06:12 +00:00
|
|
|
if (isvalue(ClientTable[i].comp_ref) and ClientTable[i].comp_ref == comp_ref) {
|
2018-02-15 19:39:13 +00:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(fail, "Couldn't find Client for Component ", comp_ref);
|
2018-07-05 15:35:03 +00:00
|
|
|
mtc.stop;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private function f_tbl_tlli_by_comp(BSSGP_Client_CT comp_ref) runs on BSSGP_CT return OCT4 {
|
|
|
|
var integer i;
|
|
|
|
for (i := 0; i < sizeof(ClientTable); i := i+1) {
|
2018-02-18 13:06:12 +00:00
|
|
|
if (isvalue(ClientTable[i].tlli) and isvalue(ClientTable[i].comp_ref)
|
2018-02-15 19:39:13 +00:00
|
|
|
and ClientTable[i].comp_ref == comp_ref) {
|
|
|
|
return ClientTable[i].tlli;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
setverdict(fail, "Couldn't find TLLI for Component ", comp_ref);
|
2018-07-05 15:35:03 +00:00
|
|
|
mtc.stop;
|
2018-02-15 16:45:29 +00:00
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
altstep as_allstate() runs on BSSGP_CT {
|
2018-02-15 19:39:13 +00:00
|
|
|
var BSSGP_Client_CT vc_conn;
|
2018-02-15 16:45:29 +00:00
|
|
|
var NsUnitdataIndication udi;
|
|
|
|
var NsStatusIndication nsi;
|
|
|
|
var ASP_Event evt;
|
2018-02-15 19:39:13 +00:00
|
|
|
var hexstring imsi;
|
2018-02-17 09:11:19 +00:00
|
|
|
var OCT4 tlli, tlli_old;
|
2018-02-15 19:39:13 +00:00
|
|
|
var BssgpCellId cell_id;
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
/* Respond to BLOCK for wrong NSVCI */
|
|
|
|
[] BSCP.receive(f_BnsUdInd(t_BVC_BLOCK(?, ?), 0)) -> value udi {
|
|
|
|
log("Rx BVC-BLOCK for unknown BVCI");
|
|
|
|
f_sendStatus(BSSGP_CAUSE_BVCI_UNKNOWN, udi.bssgp);
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
/* Respond to RESET with correct BVCI/CellID */
|
2018-02-15 19:39:13 +00:00
|
|
|
[] BSCP.receive(f_BnsUdInd(tr_BVC_RESET(?, g_cfg.bvci, g_cfg.cell_id), 0)) -> value udi {
|
|
|
|
log("Rx BVC-RESET for Our BVCI=", g_cfg.bvci);
|
|
|
|
BSCP.send(f_BnsUdReq(ts_BVC_RESET_ACK(g_cfg.bvci, g_cfg.cell_id), 0));
|
2018-02-15 16:45:29 +00:00
|
|
|
f_change_state(BVC_S_UNBLOCKED);
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
/* Respond to RESET for signalling BVCI 0 */
|
2018-02-15 19:39:13 +00:00
|
|
|
[] BSCP.receive(f_BnsUdInd(tr_BVC_RESET(?, 0, g_cfg.cell_id), 0)) -> value udi {
|
2018-02-15 16:45:29 +00:00
|
|
|
log("Rx BVC-RESET for Signaling BVCI=0");
|
2018-02-15 19:39:13 +00:00
|
|
|
BSCP.send(f_BnsUdReq(ts_BVC_RESET_ACK(0, g_cfg.cell_id), 0));
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
/* Respond to RESET with wrong NSEI/NSVCI */
|
|
|
|
[] BSCP.receive(f_BnsUdInd(tr_BVC_RESET(?, ?, ?), 0)) -> value udi {
|
|
|
|
log("Rx BVC-RESET for unknown BVCI");
|
|
|
|
f_sendStatus(BSSGP_CAUSE_BVCI_UNKNOWN, udi.bssgp);
|
2017-07-23 17:52:33 +00:00
|
|
|
}
|
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
/* default case of handling unknown PDUs */
|
|
|
|
[] BSCP.receive(f_BnsUdInd(?, ?)) -> value udi {
|
|
|
|
log("Rx Unexpected BSSGP PDU ", udi.bssgp," in state ", g_ptp_bvc_state);
|
|
|
|
f_sendStatus(BSSGP_CAUSE_PDU_NOT_COMPATIBLE_WITH_PROTOCOL_STATE, udi.bssgp);
|
|
|
|
}
|
|
|
|
/* Forwarding of ASP_Event and NsStatusIndication to user */
|
2018-02-15 19:39:13 +00:00
|
|
|
[] BSCP.receive(ASP_Event:?) -> value evt {
|
|
|
|
for (var integer i := 0; i < sizeof(ClientTable); i := i+1) {
|
|
|
|
if (isbound(ClientTable[i].comp_ref)) {
|
|
|
|
BSSGP_SP.send(evt) to ClientTable[i].comp_ref;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
[] BSCP.receive(NsStatusIndication:?) -> value nsi {
|
|
|
|
/* if we just became NS-unblocked, send a BCC-RESET */
|
|
|
|
if (nsi.old_state != NSE_S_ALIVE_UNBLOCKED and nsi.new_state == NSE_S_ALIVE_UNBLOCKED) {
|
2018-02-15 19:39:13 +00:00
|
|
|
if (g_cfg.sgsn_role == false) {
|
2018-02-15 16:45:29 +00:00
|
|
|
f_sendReset();
|
|
|
|
}
|
2018-02-15 19:39:13 +00:00
|
|
|
/* Idea: We could send BVC-UNBLOCK here like some SGSN do */
|
|
|
|
}
|
|
|
|
for (var integer i := 0; i < sizeof(ClientTable); i := i+1) {
|
|
|
|
if (isbound(ClientTable[i].comp_ref)) {
|
|
|
|
BSSGP_SP.send(nsi) to ClientTable[i].comp_ref;
|
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
}
|
2018-02-15 19:39:13 +00:00
|
|
|
|
|
|
|
[] BSSGP_PROC.getcall(BSSGP_register_client:{?,?,?}) -> param(imsi, tlli, cell_id) sender vc_conn {
|
|
|
|
f_tbl_client_add(imsi, tlli, cell_id, vc_conn);
|
2018-05-31 20:17:46 +00:00
|
|
|
BSSGP_PROC.reply(BSSGP_register_client:{imsi, tlli, cell_id}) to vc_conn;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
[] BSSGP_PROC.getcall(BSSGP_unregister_client:{?}) -> param(imsi) sender vc_conn {
|
|
|
|
f_tbl_client_del(imsi, vc_conn);
|
2018-05-31 20:17:46 +00:00
|
|
|
BSSGP_PROC.reply(BSSGP_unregister_client:{imsi}) to vc_conn;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
2018-02-17 09:11:19 +00:00
|
|
|
[] BSSGP_PROC.getcall(BSSGP_llgmm_assign:{?,?}) -> param(tlli_old, tlli) sender vc_conn {
|
|
|
|
f_tbl_client_llgmm_assign(tlli_old, tlli, vc_conn);
|
2018-05-31 20:17:46 +00:00
|
|
|
BSSGP_PROC.reply(BSSGP_llgmm_assign:{tlli_old, tlli}) to vc_conn;
|
2018-02-17 09:11:19 +00:00
|
|
|
}
|
|
|
|
|
2018-02-15 16:45:29 +00:00
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
altstep as_blocked() runs on BSSGP_CT {
|
2018-03-02 20:40:03 +00:00
|
|
|
[g_T1.running] g_T1.timeout {
|
2018-02-15 19:39:13 +00:00
|
|
|
f_sendUnblock();
|
|
|
|
}
|
|
|
|
[] BSCP.receive(f_BnsUdInd(t_BVC_UNBLOCK_ACK(g_cfg.bvci), 0)) {
|
|
|
|
g_T1.stop;
|
|
|
|
f_change_state(BVC_S_UNBLOCKED);
|
|
|
|
}
|
|
|
|
[not g_cfg.sgsn_role] BSCP.receive(f_BnsUdInd(tr_BVC_RESET_ACK(g_cfg.bvci, omit), 0)) {
|
|
|
|
f_sendUnblock();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-02 23:29:29 +00:00
|
|
|
private function f_send_bssgp_dec(BssgpDecoded dec, BSSGP_Client_CT vc_conn, BSSGP_SP_PT pt := BSSGP_SP) runs on BSSGP_CT {
|
2020-09-13 16:38:02 +00:00
|
|
|
#ifdef BSSGP_EM_L3
|
2019-05-02 23:29:29 +00:00
|
|
|
if (ispresent(dec.l3_mt)) {
|
|
|
|
pt.send(dec.l3_mt) to vc_conn;
|
|
|
|
} else if (ispresent(dec.l3_mo)) {
|
|
|
|
pt.send(dec.l3_mo) to vc_conn;
|
2020-09-13 16:38:02 +00:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
if (ispresent(dec.sndcp)) {
|
2019-05-02 23:29:29 +00:00
|
|
|
pt.send(dec.sndcp) to vc_conn;
|
|
|
|
} else if (ispresent(dec.llc)) {
|
|
|
|
pt.send(dec.llc) to vc_conn;
|
|
|
|
} else {
|
|
|
|
pt.send(dec.bssgp) to vc_conn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
altstep as_unblocked() runs on BSSGP_CT {
|
|
|
|
var BSSGP_Client_CT vc_conn;
|
2018-02-15 16:45:29 +00:00
|
|
|
var NsUnitdataIndication udi;
|
|
|
|
var PDU_BSSGP bs_pdu;
|
2018-02-18 18:42:17 +00:00
|
|
|
var PDU_LLC llc;
|
2020-09-12 18:51:05 +00:00
|
|
|
#ifdef BSSGP_EM_L3
|
2018-02-15 19:39:13 +00:00
|
|
|
var PDU_L3_MS_SGSN l3_mo;
|
|
|
|
var PDU_L3_SGSN_MS l3_mt;
|
2020-09-12 18:51:05 +00:00
|
|
|
#endif
|
2018-02-15 19:39:13 +00:00
|
|
|
|
|
|
|
/* bogus unblock, just respond with ACK */
|
|
|
|
[] BSCP.receive(f_BnsUdInd(t_BVC_UNBLOCK(g_cfg.bvci), 0)) -> value udi {
|
|
|
|
BSCP.send(f_BnsUdReq(t_BVC_UNBLOCK_ACK(g_cfg.bvci), 0));
|
|
|
|
}
|
|
|
|
/* Respond to BLOCK with BLOCK-ACK + change state */
|
|
|
|
[] BSCP.receive(f_BnsUdInd(t_BVC_BLOCK(g_cfg.bvci, ?), 0)) -> value udi {
|
|
|
|
BSCP.send(f_BnsUdReq(t_BVC_BLOCK_ACK(g_cfg.bvci), 0));
|
|
|
|
g_T1.stop;
|
|
|
|
f_change_state(BVC_S_BLOCKED);
|
|
|
|
}
|
2018-03-02 20:40:03 +00:00
|
|
|
[g_T1.running] g_T1.timeout {
|
2018-02-15 19:39:13 +00:00
|
|
|
f_sendBlock(BSSGP_CAUSE_OM_INTERVENTION);
|
|
|
|
}
|
|
|
|
[] BSCP.receive(f_BnsUdInd(t_BVC_BLOCK_ACK(g_cfg.bvci), 0)) -> value udi {
|
|
|
|
g_T1.stop;
|
|
|
|
f_change_state(BVC_S_BLOCKED);
|
|
|
|
}
|
|
|
|
[] BSCP.receive(f_BnsUdInd(tr_BVC_RESET_ACK(g_cfg.bvci, g_cfg.cell_id), 0)) -> value udi {
|
|
|
|
g_T2.stop;
|
|
|
|
f_change_state(BVC_S_UNBLOCKED);
|
|
|
|
}
|
2017-07-23 17:52:33 +00:00
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
/* simply acknowledge all Flow Control Messages */
|
2018-03-02 21:04:54 +00:00
|
|
|
[g_cfg.sgsn_role] BSCP.receive(f_BnsUdInd(tr_BVC_FC_BVC, g_cfg.bvci)) -> value udi {
|
|
|
|
var OCT1 tag := udi.bssgp.pDU_BSSGP_FLOW_CONTROL_BVC.tag.unstructured_Value;
|
|
|
|
BSCP.send(f_BnsUdReq(t_BVC_FC_BVC_ACK(tag), g_cfg.bvci));
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
2018-03-02 21:04:54 +00:00
|
|
|
/*
|
|
|
|
[g_cfg.sgsn_role] BSCP.receive(f_BnsUdInd(t_BVC_FC_MS, g_cfg.bvci)) {
|
|
|
|
BSCP.send(f_BnsUdReq(t_BVC_FC_MS_ACK, g_cfg.bvci));
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
*/
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
/* FIXME: CS PAGING: dispatch by IMSI */
|
2017-07-23 15:26:17 +00:00
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
/* PS PAGING: dispatch by IMSI */
|
|
|
|
[] BSCP.receive(f_BnsUdInd(tr_BSSGP_PS_PAGING(g_cfg.bvci), g_cfg.bvci)) -> value udi {
|
|
|
|
var hexstring imsi := udi.bssgp.pDU_BSSGP_PAGING_PS.iMSI.digits
|
|
|
|
vc_conn := f_tbl_comp_by_imsi(imsi);
|
2019-05-02 23:29:29 +00:00
|
|
|
f_send_bssgp_dec(f_dec_bssgp(udi.bssgp), vc_conn);
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
|
2019-03-21 20:30:47 +00:00
|
|
|
/* Any other PTP BSSGP message: If it has TLLi, route to component; otherwise broadcast */
|
2018-02-15 19:39:13 +00:00
|
|
|
[] BSCP.receive(f_BnsUdInd(?, g_cfg.bvci)) -> value udi {
|
|
|
|
var BssgpDecoded dec := f_dec_bssgp(udi.bssgp);
|
|
|
|
var template OCT4 tlli := f_bssgp_get_tlli(udi.bssgp);
|
|
|
|
if (isvalue(tlli)) {
|
|
|
|
vc_conn := f_tbl_comp_by_tlli(valueof(tlli));
|
2019-05-02 23:29:29 +00:00
|
|
|
f_send_bssgp_dec(dec, vc_conn);
|
2018-02-15 19:39:13 +00:00
|
|
|
} else {
|
|
|
|
log("No TLLI: Broadcasting ", dec);
|
|
|
|
/* broadcast this message to all components */
|
|
|
|
// TITAN DOESN'T DO THIS, *SIGH*: "BSSGP_SP.send(dec) to all component;"
|
|
|
|
for (var integer i := 0; i < sizeof(ClientTable); i := i+1) {
|
|
|
|
if (isbound(ClientTable[i].comp_ref)) {
|
2019-05-02 23:29:29 +00:00
|
|
|
f_send_bssgp_dec(dec, ClientTable[i].comp_ref);
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|
|
|
|
}
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
2019-03-21 20:30:47 +00:00
|
|
|
/* Any other SIG BSSGP message: If it has TLLi, route to component; otherwise broadcast */
|
|
|
|
[] BSCP.receive(f_BnsUdInd(?, 0)) -> value udi {
|
|
|
|
var BssgpDecoded dec := f_dec_bssgp(udi.bssgp);
|
|
|
|
var template OCT4 tlli := f_bssgp_get_tlli(udi.bssgp);
|
|
|
|
if (isvalue(tlli)) {
|
|
|
|
vc_conn := f_tbl_comp_by_tlli(valueof(tlli));
|
2019-05-02 23:29:29 +00:00
|
|
|
f_send_bssgp_dec(dec, vc_conn, BSSGP_SP_SIG);
|
2019-03-21 20:30:47 +00:00
|
|
|
} else {
|
|
|
|
log("No TLLI: Broadcasting ", dec);
|
|
|
|
/* broadcast this message to all components */
|
|
|
|
// TITAN DOESN'T DO THIS, *SIGH*: "BSSGP_SP.send(dec) to all component;"
|
|
|
|
for (var integer i := 0; i < sizeof(ClientTable); i := i+1) {
|
|
|
|
if (isbound(ClientTable[i].comp_ref)) {
|
2019-08-30 09:48:00 +00:00
|
|
|
f_send_bssgp_dec(dec, ClientTable[i].comp_ref, BSSGP_SP_SIG);
|
2019-03-21 20:30:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-02 22:50:48 +00:00
|
|
|
/* ConnHdlr sends BSSGP on BVCI=0 port: forward it to BSSGP Codec Port */
|
2018-05-03 17:14:28 +00:00
|
|
|
[] BSSGP_SP_SIG.receive(PDU_BSSGP:?)-> value bs_pdu sender vc_conn {
|
|
|
|
BSCP.send(f_BnsUdReq(bs_pdu, 0));
|
|
|
|
}
|
|
|
|
|
2019-05-02 22:50:48 +00:00
|
|
|
/* ConnHdlr sends BSSGP on BVCI=PTP port: forward it to BSSGP Codec Port */
|
2018-02-15 19:39:13 +00:00
|
|
|
[] BSSGP_SP.receive(PDU_BSSGP:?) -> value bs_pdu sender vc_conn {
|
|
|
|
BSCP.send(f_BnsUdReq(bs_pdu, g_cfg.bvci));
|
|
|
|
}
|
|
|
|
|
2020-09-12 18:51:05 +00:00
|
|
|
#ifdef BSSGP_EM_L3
|
2019-05-02 22:50:48 +00:00
|
|
|
/* ConnHdlr sends L3: Encode and send as UL_UD / DL_UD */
|
2018-02-15 19:39:13 +00:00
|
|
|
[g_cfg.sgsn_role] BSSGP_SP.receive(PDU_L3_SGSN_MS:?) -> value l3_mt sender vc_conn {
|
|
|
|
var integer idx := f_tbl_idx_by_comp(vc_conn);
|
|
|
|
var octetstring l3_enc := enc_PDU_L3_SGSN_MS(l3_mt);
|
|
|
|
var BIT4 sapi := f_llc_sapi_by_l3_mt(l3_mt);
|
|
|
|
var integer n_u := f_llc_get_n_u_tx(ClientTable[idx].llc[bit2int(sapi)]);
|
|
|
|
var octetstring llc_enc := enc_PDU_LLC(valueof(ts_LLC_UI(l3_enc, sapi, '1'B, n_u)));
|
2019-05-02 22:41:41 +00:00
|
|
|
BSCP.send(f_BnsUdReq(ts_BSSGP_DL_UD(ClientTable[idx].tlli, llc_enc), g_cfg.bvci));
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
2019-05-02 22:48:46 +00:00
|
|
|
[not g_cfg.sgsn_role] BSSGP_SP.receive(PDU_L3_MS_SGSN:?) -> value l3_mo sender vc_conn {
|
|
|
|
var integer idx := f_tbl_idx_by_comp(vc_conn);
|
|
|
|
var octetstring l3_enc := enc_PDU_L3_MS_SGSN(l3_mo);
|
|
|
|
var BIT4 sapi := f_llc_sapi_by_l3_mo(l3_mo);
|
|
|
|
var integer n_u := f_llc_get_n_u_tx(ClientTable[idx].llc[bit2int(sapi)]);
|
|
|
|
var octetstring llc_enc := enc_PDU_LLC(valueof(ts_LLC_UI(l3_enc, sapi, '1'B, n_u)));
|
|
|
|
BSCP.send(f_BnsUdReq(ts_BSSGP_UL_UD(ClientTable[idx].tlli, ClientTable[idx].cell_id, llc_enc), g_cfg.bvci));
|
|
|
|
}
|
2020-09-12 18:51:05 +00:00
|
|
|
#endif
|
2018-02-18 18:42:17 +00:00
|
|
|
|
2019-05-02 22:49:25 +00:00
|
|
|
/* ConnHdlr sends raw LLC: Encode and send as UL_UD / DL_UD */
|
|
|
|
[not g_cfg.sgsn_role] BSSGP_SP.receive(PDU_LLC:?) -> value llc sender vc_conn {
|
2018-02-18 18:42:17 +00:00
|
|
|
var integer idx := f_tbl_idx_by_comp(vc_conn);
|
|
|
|
var octetstring llc_enc := enc_PDU_LLC(llc);
|
|
|
|
BSCP.send(f_BnsUdReq(ts_BSSGP_UL_UD(ClientTable[idx].tlli, ClientTable[idx].cell_id, llc_enc), g_cfg.bvci));
|
|
|
|
}
|
2019-05-02 22:49:25 +00:00
|
|
|
[g_cfg.sgsn_role] BSSGP_SP.receive(PDU_LLC:?) -> value llc sender vc_conn {
|
|
|
|
var integer idx := f_tbl_idx_by_comp(vc_conn);
|
|
|
|
var octetstring llc_enc := enc_PDU_LLC(llc);
|
|
|
|
BSCP.send(f_BnsUdReq(ts_BSSGP_DL_UD(ClientTable[idx].tlli, llc_enc), g_cfg.bvci));
|
|
|
|
}
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
2018-07-31 13:37:14 +00:00
|
|
|
function f_llc_get_n_u_tx(inout LLC_Entity llc) return uint9_t {
|
2018-02-15 19:39:13 +00:00
|
|
|
var uint9_t ret := llc.n_u_tx_next;
|
|
|
|
llc.n_u_tx_next := llc.n_u_tx_next + 1;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-09-12 18:51:05 +00:00
|
|
|
#ifdef BSSGP_EM_L3
|
2018-07-31 13:37:14 +00:00
|
|
|
function f_llc_sapi_by_l3_mo(PDU_L3_MS_SGSN l3_mo) return BIT4 {
|
2018-02-15 19:39:13 +00:00
|
|
|
if (ischosen(l3_mo.msgs.gprs_mm)) {
|
|
|
|
return c_LLC_SAPI_LLGMM;
|
|
|
|
} else if (ischosen(l3_mo.msgs.gprs_sm)) {
|
2018-02-17 15:45:06 +00:00
|
|
|
return c_LLC_SAPI_LLGMM;
|
2018-02-15 19:39:13 +00:00
|
|
|
} else if (ischosen(l3_mo.msgs.sms)) {
|
|
|
|
return c_LLC_SAPI_LLSMS;
|
|
|
|
}
|
|
|
|
setverdict(fail, "No LLC SAPI for ", l3_mo);
|
2018-07-05 15:35:03 +00:00
|
|
|
mtc.stop;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private function f_llc_sapi_by_l3_mt(PDU_L3_SGSN_MS l3_mt) return BIT4 {
|
|
|
|
if (ischosen(l3_mt.msgs.gprs_mm)) {
|
|
|
|
return c_LLC_SAPI_LLGMM;
|
|
|
|
} else if (ischosen(l3_mt.msgs.gprs_sm)) {
|
2018-02-17 15:45:06 +00:00
|
|
|
return c_LLC_SAPI_LLGMM;
|
2018-02-15 19:39:13 +00:00
|
|
|
} else if (ischosen(l3_mt.msgs.sms)) {
|
|
|
|
return c_LLC_SAPI_LLSMS;
|
|
|
|
}
|
|
|
|
setverdict(fail, "No LLC SAPI for ", l3_mt);
|
2018-07-05 15:35:03 +00:00
|
|
|
mtc.stop;
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
2020-09-12 18:51:05 +00:00
|
|
|
#endif
|
2018-02-15 19:39:13 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private function f_ScanEvents() runs on BSSGP_CT {
|
|
|
|
log("matching against ", tr_BVC_RESET(?, g_cfg.bvci, g_cfg.cell_id));
|
|
|
|
|
|
|
|
while (true) {
|
2018-02-15 16:45:29 +00:00
|
|
|
alt {
|
2018-02-15 19:39:13 +00:00
|
|
|
[g_ptp_bvc_state == BVC_S_BLOCKED] as_blocked();
|
|
|
|
[g_ptp_bvc_state == BVC_S_UNBLOCKED] as_unblocked();
|
|
|
|
[] as_allstate();
|
|
|
|
}
|
|
|
|
} /* while */
|
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
/* PDU_BSSGP enhanced with LLC and possibly L3 decoded payloads */
|
|
|
|
type record BssgpDecoded {
|
|
|
|
PDU_BSSGP bssgp,
|
|
|
|
PDU_LLC llc optional,
|
2020-09-12 18:51:05 +00:00
|
|
|
#ifdef BSSGP_EM_L3
|
2018-02-15 19:39:13 +00:00
|
|
|
PDU_L3_MS_SGSN l3_mo optional,
|
2018-02-18 18:03:36 +00:00
|
|
|
PDU_L3_SGSN_MS l3_mt optional,
|
2020-09-12 18:51:05 +00:00
|
|
|
#endif
|
2018-02-18 18:03:36 +00:00
|
|
|
PDU_SN sndcp optional
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
2017-07-23 17:52:33 +00:00
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
/* Decode a PDU_BSSGP into a BssgpDecoded (i.e. with LLC/L3 decoded, as applicable) */
|
|
|
|
private function f_dec_bssgp(PDU_BSSGP bssgp) runs on BSSGP_CT return BssgpDecoded {
|
|
|
|
var BssgpDecoded dec := {
|
|
|
|
bssgp := bssgp,
|
|
|
|
llc := omit,
|
2020-09-12 18:51:05 +00:00
|
|
|
#ifdef BSSGP_EM_L3
|
2018-02-15 19:39:13 +00:00
|
|
|
l3_mo := omit,
|
2018-02-18 18:03:36 +00:00
|
|
|
l3_mt := omit,
|
2020-09-12 18:51:05 +00:00
|
|
|
#endif
|
2018-02-18 18:03:36 +00:00
|
|
|
sndcp := omit
|
2018-02-15 19:39:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Decode LLC, if it is a PDU that contains LLC */
|
BSSGP_Emulation: add BssgpDecodeDepth
Make the decoding level (BSSGP, LLC, SNDCP, L3) configurable, so the
existing PCU tests, that expect messages only decoded to the BSSGP
level, can pass again. Move the SNDCP decoding in f_dec_bssgp above the
L3 decoding, so f_dec_bssgp goes through the layers in the reverse order
of f_send_bssgp_dec.
I have verified, that all testsuites using the BSSGP Emulation (SGSN,
PCU, PCU-SNS) are still working with this patch.
Related: OS#4180
Fixes: 955aa94504510139a12d223071cf49ef90788a3d ("BSSGP_Emulation: Abandon "BssgpDecoded" intermediate structure")
Change-Id: I8f76385528c1de98c557cee451c0e0dfd182b605
2019-09-02 06:36:36 +00:00
|
|
|
if (g_cfg.depth >= BSSGP_DECODE_DEPTH_LLC) {
|
|
|
|
if (ischosen(bssgp.pDU_BSSGP_DL_UNITDATA)) {
|
|
|
|
dec.llc := dec_PDU_LLC(bssgp.pDU_BSSGP_DL_UNITDATA.lLC_PDU.lLC_PDU);
|
|
|
|
} else if (ischosen(bssgp.pDU_BSSGP_UL_UNITDATA)) {
|
|
|
|
dec.llc := dec_PDU_LLC(bssgp.pDU_BSSGP_UL_UNITDATA.lLC_PDU.lLC_PDU);
|
|
|
|
}
|
2018-02-15 19:39:13 +00:00
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
|
BSSGP_Emulation: add BssgpDecodeDepth
Make the decoding level (BSSGP, LLC, SNDCP, L3) configurable, so the
existing PCU tests, that expect messages only decoded to the BSSGP
level, can pass again. Move the SNDCP decoding in f_dec_bssgp above the
L3 decoding, so f_dec_bssgp goes through the layers in the reverse order
of f_send_bssgp_dec.
I have verified, that all testsuites using the BSSGP Emulation (SGSN,
PCU, PCU-SNS) are still working with this patch.
Related: OS#4180
Fixes: 955aa94504510139a12d223071cf49ef90788a3d ("BSSGP_Emulation: Abandon "BssgpDecoded" intermediate structure")
Change-Id: I8f76385528c1de98c557cee451c0e0dfd182b605
2019-09-02 06:36:36 +00:00
|
|
|
/* Decode SNDCP, if it is a LLC PDU containing user plane data */
|
|
|
|
if (g_cfg.depth >= BSSGP_DECODE_DEPTH_SNDCP) {
|
|
|
|
if (isvalue(dec.llc) and match(dec.llc, tr_LLC_UI_USER)) {
|
|
|
|
dec.sndcp := dec_PDU_SN(dec.llc.pDU_LLC_UI.information_field_UI);
|
2018-02-15 16:45:29 +00:00
|
|
|
}
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|
2018-02-18 18:03:36 +00:00
|
|
|
|
2020-09-12 18:51:05 +00:00
|
|
|
#ifdef BSSGP_EM_L3
|
BSSGP_Emulation: add BssgpDecodeDepth
Make the decoding level (BSSGP, LLC, SNDCP, L3) configurable, so the
existing PCU tests, that expect messages only decoded to the BSSGP
level, can pass again. Move the SNDCP decoding in f_dec_bssgp above the
L3 decoding, so f_dec_bssgp goes through the layers in the reverse order
of f_send_bssgp_dec.
I have verified, that all testsuites using the BSSGP Emulation (SGSN,
PCU, PCU-SNS) are still working with this patch.
Related: OS#4180
Fixes: 955aa94504510139a12d223071cf49ef90788a3d ("BSSGP_Emulation: Abandon "BssgpDecoded" intermediate structure")
Change-Id: I8f76385528c1de98c557cee451c0e0dfd182b605
2019-09-02 06:36:36 +00:00
|
|
|
/* Decode L3, if it is a LLC PDU containing L3 */
|
|
|
|
if (g_cfg.depth >= BSSGP_DECODE_DEPTH_L3) {
|
|
|
|
if (isvalue(dec.llc) and match(dec.llc, tr_LLC_UI_L3)) {
|
|
|
|
if (g_cfg.sgsn_role) {
|
|
|
|
dec.l3_mo := dec_PDU_L3_MS_SGSN(dec.llc.pDU_LLC_UI.information_field_UI);
|
|
|
|
} else {
|
|
|
|
dec.l3_mt := dec_PDU_L3_SGSN_MS(dec.llc.pDU_LLC_UI.information_field_UI);
|
|
|
|
}
|
|
|
|
}
|
2018-02-18 18:03:36 +00:00
|
|
|
}
|
2020-09-12 18:51:05 +00:00
|
|
|
#endif
|
BSSGP_Emulation: add BssgpDecodeDepth
Make the decoding level (BSSGP, LLC, SNDCP, L3) configurable, so the
existing PCU tests, that expect messages only decoded to the BSSGP
level, can pass again. Move the SNDCP decoding in f_dec_bssgp above the
L3 decoding, so f_dec_bssgp goes through the layers in the reverse order
of f_send_bssgp_dec.
I have verified, that all testsuites using the BSSGP Emulation (SGSN,
PCU, PCU-SNS) are still working with this patch.
Related: OS#4180
Fixes: 955aa94504510139a12d223071cf49ef90788a3d ("BSSGP_Emulation: Abandon "BssgpDecoded" intermediate structure")
Change-Id: I8f76385528c1de98c557cee451c0e0dfd182b605
2019-09-02 06:36:36 +00:00
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
return dec;
|
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
|
2018-07-28 21:06:00 +00:00
|
|
|
function f_bssgp_client_register(hexstring imsi, OCT4 tlli, BssgpCellId cell_id, BSSGP_PROC_PT PT := BSSGP_PROC[0])
|
2018-02-15 19:39:13 +00:00
|
|
|
runs on BSSGP_Client_CT {
|
|
|
|
PT.call(BSSGP_register_client:{imsi, tlli, cell_id}) {
|
|
|
|
[] PT.getreply(BSSGP_register_client:{imsi, tlli, cell_id}) {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-28 21:06:00 +00:00
|
|
|
function f_bssgp_client_unregister(hexstring imsi, BSSGP_PROC_PT PT := BSSGP_PROC[0])
|
2018-02-15 19:39:13 +00:00
|
|
|
runs on BSSGP_Client_CT {
|
|
|
|
PT.call(BSSGP_unregister_client:{imsi}) {
|
|
|
|
[] PT.getreply(BSSGP_unregister_client:{imsi}) {};
|
|
|
|
}
|
2018-02-15 16:45:29 +00:00
|
|
|
}
|
|
|
|
|
2018-02-17 09:11:19 +00:00
|
|
|
/* TS 44.064 7.2.1.1 LLGMM-ASSIGN */
|
2018-07-28 21:06:00 +00:00
|
|
|
function f_bssgp_client_llgmm_assign(OCT4 tlli_old, OCT4 tlli_new, BSSGP_PROC_PT PT := BSSGP_PROC[0])
|
2018-02-17 09:11:19 +00:00
|
|
|
runs on BSSGP_Client_CT {
|
|
|
|
PT.call(BSSGP_llgmm_assign:{tlli_old, tlli_new}) {
|
|
|
|
[] PT.getreply(BSSGP_llgmm_assign:{tlli_old, tlli_new}) {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-15 19:39:13 +00:00
|
|
|
|
2017-07-23 15:26:17 +00:00
|
|
|
}
|