blob: 5450706af0773852c96039884909c34ca72274e7 [file] [log] [blame]
Harald Welte6811d102019-04-14 22:23:14 +02001module RAN_Emulation {
Harald Welte365f4ed2017-11-23 00:00:43 +01002
Harald Welte6811d102019-04-14 22:23:14 +02003/* RAN Emulation, runs on top of BSSAP_CodecPort. It multiplexes/demultiplexes
Harald Welte35bb7162018-01-03 21:07:52 +01004 * the individual connections, so there can be separate TTCN-3 components handling
5 * each of the connections.
6 *
Harald Welte6811d102019-04-14 22:23:14 +02007 * The RAN_Emulation.main() function processes SCCP primitives from the SCCP
Harald Welte35bb7162018-01-03 21:07:52 +01008 * stack via the BSSAP_CodecPort, and dispatches them to the per-connection components.
9 *
10 * Outbound BSSAP/SCCP connections are initiated by sending a BSSAP_Conn_Req primitive
Harald Welte6811d102019-04-14 22:23:14 +020011 * to the component running the RAN_Emulation.main() function.
Harald Welte35bb7162018-01-03 21:07:52 +010012 *
Harald Welte6811d102019-04-14 22:23:14 +020013 * For each new inbound connections, the RanOps.create_cb() is called. It can create
Harald Welte35bb7162018-01-03 21:07:52 +010014 * or resolve a TTCN-3 component, and returns a component reference to which that inbound
15 * connection is routed/dispatched.
16 *
17 * If a pre-existing component wants to register to handle a future inbound connection, it can
18 * do so by registering an "expect" with the expected Layer 3 (DTAP) payload. This is e.g. useful
19 * if you are simulating BTS + MSC, and first trigger a connection from BTS/RSL side in a
20 * component which then subsequently should also handle the MSC emulation.
21 *
Harald Welte6811d102019-04-14 22:23:14 +020022 * Inbound Unit Data messages (such as are dispatched to the RanOps.unitdata_cb() callback,
Harald Welte35bb7162018-01-03 21:07:52 +010023 * which is registered with an argument to the main() function below.
24 *
Harald Welte2fce7882019-04-15 11:48:05 +020025 * (C) 2017-2019 by Harald Welte <laforge@gnumonks.org>
Harald Welte35bb7162018-01-03 21:07:52 +010026 * All rights reserved.
27 *
28 * Released under the terms of GNU General Public License, Version 2 or
29 * (at your option) any later version.
30 */
31
32
Harald Welte0b476062018-01-21 19:07:32 +010033import from General_Types all;
Harald Welte9dadc522018-02-06 13:56:04 +010034import from Osmocom_Types all;
Harald Welteb3414b22017-11-23 18:22:10 +010035import from SCCP_Emulation all;
Harald Welte365f4ed2017-11-23 00:00:43 +010036import from SCCPasp_Types all;
Harald Welte2fce7882019-04-15 11:48:05 +020037import from IPA_Emulation all;
38import from MobileL3_Types all;
Pau Espin Pedrol4d0e5e52019-06-07 19:38:28 +020039import from Misc_Helpers all;
Harald Welte2fce7882019-04-15 11:48:05 +020040
41#ifdef RAN_EMULATION_BSSAP
Harald Welte365f4ed2017-11-23 00:00:43 +010042import from BSSAP_Types all;
Harald Welte004f5fb2017-12-16 17:54:40 +010043import from BSSAP_CodecPort all;
Harald Welte365f4ed2017-11-23 00:00:43 +010044import from BSSMAP_Templates all;
Harald Welte2fce7882019-04-15 11:48:05 +020045#endif
46
47#ifdef RAN_EMULATION_MGCP
Harald Weltec82eef42017-11-24 20:40:12 +010048import from MGCP_Types all;
49import from MGCP_Templates all;
Harald Welte2fce7882019-04-15 11:48:05 +020050#endif
Harald Welte365f4ed2017-11-23 00:00:43 +010051
Pau Espin Pedrol4d0e5e52019-06-07 19:38:28 +020052#ifdef RAN_EMULATION_CTRL
53import from Osmocom_CTRL_Types all;
54import from Osmocom_CTRL_Adapter all;
55#endif
56
Harald Welte5b027622019-04-14 23:40:17 +020057#ifdef RAN_EMULATION_RANAP
58import from RANAP_CodecPort all;
59import from RANAP_PDU_Descriptions all;
60import from RANAP_Constants all;
61import from RANAP_IEs all;
62import from RANAP_Templates all;
63#endif
64
Harald Welte365f4ed2017-11-23 00:00:43 +010065/* General "base class" component definition, of which specific implementations
66 * derive themselves by means of the "extends" feature */
Harald Welte6811d102019-04-14 22:23:14 +020067type component RAN_ConnHdlr {
Harald Welte365f4ed2017-11-23 00:00:43 +010068 /* port towards MSC Emulator core / SCCP connection dispatchar */
Harald Welte6811d102019-04-14 22:23:14 +020069 port RAN_Conn_PT BSSAP;
Harald Welteca519982018-01-21 19:28:26 +010070 /* procedure based port to register for incoming connections */
Harald Welte6811d102019-04-14 22:23:14 +020071 port RAN_PROC_PT BSSAP_PROC;
Harald Welte365f4ed2017-11-23 00:00:43 +010072}
73
74/* Auxiliary primitive that can happen on the port between per-connection client and this dispatcher */
Harald Welte6811d102019-04-14 22:23:14 +020075type enumerated RAN_Conn_Prim {
Harald Welte365f4ed2017-11-23 00:00:43 +010076 /* SCCP tell us that connection was released */
77 MSC_CONN_PRIM_DISC_IND,
78 /* we tell SCCP to release connection */
Harald Welte71b69332018-01-21 20:43:53 +010079 MSC_CONN_PRIM_DISC_REQ,
80 /* Connection confirmed indication */
81 MSC_CONN_PRIM_CONF_IND
Harald Welte365f4ed2017-11-23 00:00:43 +010082}
83
Pau Espin Pedrolc6b78ff2019-06-06 15:58:17 +020084type enumerated RAN_Transport {
85 BSSAP_TRANSPORT_AoIP, /* 3GPP AoIP: SCCP over M3UA over SCTP */
86 BSSAP_TRANSPORT_SCCPlite_SERVER, /* SCCPlite: SCCP over IPA over TCP */
87 BSSAP_TRANSPORT_SCCPlite_CLIENT, /* SCCPlite: SCCP over IPA over TCP */
88 RANAP_TRANSPORT_IuCS /* 3GPP IuCS: SCCP over M3UA over SCTP */
89};
90
Harald Welte0b476062018-01-21 19:07:32 +010091/* similar to PDU_BSSAP with DTAP, but DTAP is already decoded! */
92type record PDU_DTAP_MO {
93 OCT1 dlci optional,
Daniel Willmann92f66272018-02-06 15:50:52 +010094 boolean skip_seq_patching optional,
Harald Welte0b476062018-01-21 19:07:32 +010095 PDU_ML3_MS_NW dtap
96}
97
98/* similar to PDU_BSSAP with DTAP, but DTAP is already decoded! */
99type record PDU_DTAP_MT {
100 OCT1 dlci optional,
101 PDU_ML3_NW_MS dtap
102}
103
Harald Welte717c7302019-04-23 20:31:55 +0200104type record PDU_DTAP_PS_MO {
105 OCT1 dlci optional,
106 boolean skip_seq_patching optional,
107 PDU_L3_MS_SGSN dtap
108}
109
110type record PDU_DTAP_PS_MT {
111 OCT1 dlci optional,
112 PDU_L3_SGSN_MS dtap
113}
114
Harald Welte0b476062018-01-21 19:07:32 +0100115template PDU_DTAP_MT ts_PDU_DTAP_MT(template PDU_ML3_NW_MS dtap, template OCT1 dlci := omit) := {
116 dlci := dlci,
117 dtap := dtap
118}
119
Daniel Willmann92f66272018-02-06 15:50:52 +0100120template PDU_DTAP_MO ts_PDU_DTAP_MO(template PDU_ML3_MS_NW dtap, template OCT1 dlci := '00'O, boolean skip_seq_patching := false) := {
Harald Welte0b476062018-01-21 19:07:32 +0100121 dlci := dlci,
Daniel Willmann92f66272018-02-06 15:50:52 +0100122 skip_seq_patching := skip_seq_patching,
Harald Welte0b476062018-01-21 19:07:32 +0100123 dtap := dtap
124}
125
126template PDU_DTAP_MT tr_PDU_DTAP_MT(template PDU_ML3_NW_MS dtap, template OCT1 dlci := *) := {
127 dlci := dlci,
128 dtap := dtap
129}
130
131template PDU_DTAP_MO tr_PDU_DTAP_MO(template PDU_ML3_MS_NW dtap, template OCT1 dlci := *) := {
132 dlci := dlci,
Harald Welte930d0a72018-03-22 22:08:40 +0100133 skip_seq_patching := ?,
Harald Welte0b476062018-01-21 19:07:32 +0100134 dtap := dtap
135}
136
Harald Welte717c7302019-04-23 20:31:55 +0200137template (value) PDU_DTAP_PS_MT ts_PDU_DTAP_PS_MT(template (value) PDU_L3_SGSN_MS dtap, template (omit) OCT1 dlci := omit) := {
138 dlci := dlci,
139 dtap := dtap
140}
141
142template (value) PDU_DTAP_PS_MO ts_PDU_DTAP_PS_MO(template (value) PDU_L3_MS_SGSN dtap, template (value) OCT1 dlci := '00'O,
143 boolean skip_seq_patching := false) := {
144 dlci := dlci,
145 skip_seq_patching := skip_seq_patching,
146 dtap := dtap
147}
148
149template PDU_DTAP_PS_MT tr_PDU_DTAP_PS_MT(template PDU_L3_SGSN_MS dtap, template OCT1 dlci := *) := {
150 dlci := dlci,
151 dtap := dtap
152}
153
154template PDU_DTAP_PS_MO tr_PDU_DTAP_PS_MO(template PDU_L3_MS_SGSN dtap, template OCT1 dlci := *) := {
155 dlci := dlci,
156 skip_seq_patching := ?,
157 dtap := dtap
158}
159
Harald Welte365f4ed2017-11-23 00:00:43 +0100160/* port between individual per-connection components and this dispatcher */
Harald Welte6811d102019-04-14 22:23:14 +0200161type port RAN_Conn_PT message {
Harald Welte2fce7882019-04-15 11:48:05 +0200162 inout
163#ifdef RAN_EMULATION_BSSAP
164 PDU_BSSAP,
Neels Hofmeyra8264612020-06-08 20:40:22 +0200165 BSSAP_N_UNITDATA_req,
Harald Weltea4ca4462018-02-09 00:17:14 +0100166 /* Client requests us to create SCCP Connection */
167 BSSAP_Conn_Req,
Harald Welte2fce7882019-04-15 11:48:05 +0200168#endif
Harald Welte5b027622019-04-14 23:40:17 +0200169#ifdef RAN_EMULATION_RANAP
170 RANAP_PDU,
171 /* Client requests us to create SCCP Connection */
172 RANAP_Conn_Req,
173#endif
Harald Welte2fce7882019-04-15 11:48:05 +0200174#ifdef RAN_EMULATION_MGCP
Harald Weltea4ca4462018-02-09 00:17:14 +0100175 /* MGCP, only used for IPA SCCPlite (MGCP in IPA mux) */
Harald Welte2fce7882019-04-15 11:48:05 +0200176 MgcpCommand, MgcpResponse,
177#endif
178 /* direct DTAP messages from/to clients */
179 PDU_DTAP_MO, PDU_DTAP_MT,
Harald Welte717c7302019-04-23 20:31:55 +0200180 PDU_DTAP_PS_MO, PDU_DTAP_PS_MT,
Harald Welte2fce7882019-04-15 11:48:05 +0200181 /* misc indications / requests between SCCP and client */
182 RAN_Conn_Prim;
Harald Welte365f4ed2017-11-23 00:00:43 +0100183} with { extension "internal" };
184
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200185type uint2_t N_Sd_Array[4];
Harald Welte365f4ed2017-11-23 00:00:43 +0100186
187/* represents a single BSSAP connection over SCCP */
188type record ConnectionData {
189 /* reference to the instance of the per-connection component */
Harald Welte6811d102019-04-14 22:23:14 +0200190 RAN_ConnHdlr comp_ref,
Harald Weltec82eef42017-11-24 20:40:12 +0100191 integer sccp_conn_id,
Harald Welte2fce7882019-04-15 11:48:05 +0200192#ifdef RAN_EMULATION_MGCP
Harald Weltec82eef42017-11-24 20:40:12 +0100193 /* most recent MGCP transaction ID (Used on MSC side) */
194 MgcpTransId mgcp_trans_id optional,
Harald Welte2fce7882019-04-15 11:48:05 +0200195#endif
Harald Weltec82eef42017-11-24 20:40:12 +0100196 /* CIC that has been used for voice of this channel (BSC side) */
Harald Welte9dadc522018-02-06 13:56:04 +0100197 integer cic optional,
198 /* array of N(SD) values for MO DTAP messages, indexed by discriminator */
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200199 N_Sd_Array n_sd
Harald Welte365f4ed2017-11-23 00:00:43 +0100200}
201
Harald Welte17d21152018-01-27 00:47:11 +0100202type record ImsiMapping {
Harald Welte6811d102019-04-14 22:23:14 +0200203 RAN_ConnHdlr comp_ref,
Harald Welte17d21152018-01-27 00:47:11 +0100204 hexstring imsi optional,
205 OCT4 tmsi
206}
207
Harald Welte6811d102019-04-14 22:23:14 +0200208type component RAN_Emulation_CT {
Harald Welte2fce7882019-04-15 11:48:05 +0200209 /* SCCP ports on the bottom side, using ASP primitives */
210#ifdef RAN_EMULATION_BSSAP
Harald Welte004f5fb2017-12-16 17:54:40 +0100211 port BSSAP_CODEC_PT BSSAP;
Harald Welte2fce7882019-04-15 11:48:05 +0200212#endif
Harald Welte5b027622019-04-14 23:40:17 +0200213#ifdef RAN_EMULATION_RANAP
214 port RANAP_CODEC_PT RANAP;
215#endif
Harald Welte365f4ed2017-11-23 00:00:43 +0100216 /* BSSAP port to the per-connection clients */
Harald Welte6811d102019-04-14 22:23:14 +0200217 port RAN_Conn_PT CLIENT;
Harald Welte2fce7882019-04-15 11:48:05 +0200218#ifdef RAN_EMULATION_MGCP
Harald Weltec82eef42017-11-24 20:40:12 +0100219 /* MGCP port */
220 port IPA_MGCP_PT MGCP;
Harald Welte2fce7882019-04-15 11:48:05 +0200221#endif
Pau Espin Pedrol4d0e5e52019-06-07 19:38:28 +0200222#ifdef RAN_EMULATION_CTRL
223 /* CTRL port */
224 port IPA_CTRL_PT CTRL;
225 port IPA_CTRL_PT CTRL_CLIENT;
226#endif
Harald Welte365f4ed2017-11-23 00:00:43 +0100227
228 /* use 16 as this is also the number of SCCP connections that SCCP_Emulation can handle */
229 var ConnectionData ConnectionTable[16];
Harald Welte66fecd42017-11-24 23:53:23 +0100230
Harald Welte624f9632017-12-16 19:26:04 +0100231 /* pending expected incoming connections */
232 var ExpectData ExpectTable[8];
Harald Welte17d21152018-01-27 00:47:11 +0100233
234 /* tables for mapping inbound unitdata (like paging) */
235 var ImsiMapping ImsiTable[16];
236
Harald Welte624f9632017-12-16 19:26:04 +0100237 /* procedure based port to register for incoming connections */
Harald Welte6811d102019-04-14 22:23:14 +0200238 port RAN_PROC_PT PROC;
Harald Welte624f9632017-12-16 19:26:04 +0100239
Harald Welte6811d102019-04-14 22:23:14 +0200240 var charstring g_ran_id;
Harald Welte66fecd42017-11-24 23:53:23 +0100241 var integer g_next_e1_ts := 1;
Harald Welte6811d102019-04-14 22:23:14 +0200242 var RanOps g_ran_ops;
Harald Welte365f4ed2017-11-23 00:00:43 +0100243};
244
Harald Welteb3414b22017-11-23 18:22:10 +0100245private function f_conn_id_known(integer sccp_conn_id)
Harald Welte6811d102019-04-14 22:23:14 +0200246runs on RAN_Emulation_CT return boolean {
Harald Welteb3414b22017-11-23 18:22:10 +0100247 var integer i;
248 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
249 if (ConnectionTable[i].sccp_conn_id == sccp_conn_id){
250 return true;
251 }
252 }
253 return false;
254}
255
Harald Welte6811d102019-04-14 22:23:14 +0200256private function f_comp_known(RAN_ConnHdlr client)
257runs on RAN_Emulation_CT return boolean {
Harald Welteb3414b22017-11-23 18:22:10 +0100258 var integer i;
259 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
260 if (ConnectionTable[i].comp_ref == client) {
261 return true;
262 }
263 }
264 return false;
265}
Harald Welte365f4ed2017-11-23 00:00:43 +0100266
Harald Weltee98bb2e2017-11-29 12:09:48 +0100267private function f_cic_known(integer cic)
Harald Welte6811d102019-04-14 22:23:14 +0200268runs on RAN_Emulation_CT return boolean {
Harald Weltee98bb2e2017-11-29 12:09:48 +0100269 var integer i;
270 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
271 if (ConnectionTable[i].cic == cic) {
272 return true;
273 }
274 }
275 return false;
276}
277
Harald Welte365f4ed2017-11-23 00:00:43 +0100278/* resolve component reference by connection ID */
279private function f_comp_by_conn_id(integer sccp_conn_id)
Harald Welte6811d102019-04-14 22:23:14 +0200280runs on RAN_Emulation_CT return RAN_ConnHdlr {
Harald Welte365f4ed2017-11-23 00:00:43 +0100281 var integer i;
282 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
283 if (ConnectionTable[i].sccp_conn_id == sccp_conn_id) {
284 return ConnectionTable[i].comp_ref;
285 }
286 }
Harald Welte6811d102019-04-14 22:23:14 +0200287 setverdict(fail, "RAN Connection table not found by SCCP Connection ID ", sccp_conn_id);
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200288 mtc.stop;
Harald Welte365f4ed2017-11-23 00:00:43 +0100289}
290
Harald Welte2fce7882019-04-15 11:48:05 +0200291
292#ifdef RAN_EMULATION_MGCP
Harald Weltec82eef42017-11-24 20:40:12 +0100293/* resolve component reference by CIC */
294private function f_comp_by_mgcp_tid(MgcpTransId tid)
Harald Welte6811d102019-04-14 22:23:14 +0200295runs on RAN_Emulation_CT return RAN_ConnHdlr {
Harald Weltec82eef42017-11-24 20:40:12 +0100296 var integer i;
297 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
298 if (ConnectionTable[i].mgcp_trans_id == tid) {
299 return ConnectionTable[i].comp_ref;
300 }
301 }
Harald Welte6811d102019-04-14 22:23:14 +0200302 setverdict(fail, "RAN Connection table not found by MGCP Transaction ID ", tid);
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200303 mtc.stop;
Harald Weltec82eef42017-11-24 20:40:12 +0100304}
305
Harald Welte6811d102019-04-14 22:23:14 +0200306private function f_comp_store_mgcp_tid(RAN_ConnHdlr client, MgcpTransId tid)
307runs on RAN_Emulation_CT {
Harald Weltec82eef42017-11-24 20:40:12 +0100308 var integer i;
309 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
310 if (ConnectionTable[i].comp_ref == client) {
311 ConnectionTable[i].mgcp_trans_id := tid;
312 return;
313 }
314 }
Harald Welte6811d102019-04-14 22:23:14 +0200315 setverdict(fail, "RAN Connection table not found by component ", client);
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200316 mtc.stop;
Harald Weltec82eef42017-11-24 20:40:12 +0100317}
Harald Welte2fce7882019-04-15 11:48:05 +0200318#endif
Harald Weltec82eef42017-11-24 20:40:12 +0100319
320private function f_comp_by_cic(integer cic)
Harald Welte6811d102019-04-14 22:23:14 +0200321runs on RAN_Emulation_CT return RAN_ConnHdlr {
Harald Weltec82eef42017-11-24 20:40:12 +0100322 var integer i;
323 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
324 if (ConnectionTable[i].cic == cic) {
325 return ConnectionTable[i].comp_ref;
326 }
327 }
Harald Welte6811d102019-04-14 22:23:14 +0200328 setverdict(fail, "RAN Connection table not found by CIC ", cic);
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200329 mtc.stop;
Harald Weltec82eef42017-11-24 20:40:12 +0100330}
331
Harald Welte6811d102019-04-14 22:23:14 +0200332private function f_comp_store_cic(RAN_ConnHdlr client, integer cic)
333runs on RAN_Emulation_CT {
Harald Weltec82eef42017-11-24 20:40:12 +0100334 var integer i;
335 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
336 if (ConnectionTable[i].comp_ref == client) {
337 ConnectionTable[i].cic := cic;
338 return;
339 }
340 }
Harald Welte6811d102019-04-14 22:23:14 +0200341 setverdict(fail, "RAN Connection table not found by component ", client);
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200342 mtc.stop;
Harald Weltec82eef42017-11-24 20:40:12 +0100343}
344
Harald Welte365f4ed2017-11-23 00:00:43 +0100345/* resolve connection ID by component reference */
Harald Welte6811d102019-04-14 22:23:14 +0200346private function f_conn_id_by_comp(RAN_ConnHdlr client)
347runs on RAN_Emulation_CT return integer {
Harald Welte365f4ed2017-11-23 00:00:43 +0100348 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
349 if (ConnectionTable[i].comp_ref == client) {
350 return ConnectionTable[i].sccp_conn_id;
351 }
352 }
Harald Welte6811d102019-04-14 22:23:14 +0200353 setverdict(fail, "RAN Connection table not found by component ", client);
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200354 mtc.stop;
Harald Welte365f4ed2017-11-23 00:00:43 +0100355}
356
Harald Welte9dadc522018-02-06 13:56:04 +0100357/* resolve ConnectionTable index component reference */
Harald Welte6811d102019-04-14 22:23:14 +0200358private function f_idx_by_comp(RAN_ConnHdlr client)
359runs on RAN_Emulation_CT return integer {
Harald Welte9dadc522018-02-06 13:56:04 +0100360 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
361 if (ConnectionTable[i].comp_ref == client) {
362 return i;
363 }
364 }
Harald Welte6811d102019-04-14 22:23:14 +0200365 setverdict(fail, "RAN Connection table not found by component ", client);
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200366 mtc.stop;
Harald Welte9dadc522018-02-06 13:56:04 +0100367}
368
Harald Welteb3414b22017-11-23 18:22:10 +0100369private function f_gen_conn_id()
Harald Welte6811d102019-04-14 22:23:14 +0200370runs on RAN_Emulation_CT return integer {
Harald Welteb3414b22017-11-23 18:22:10 +0100371 var integer conn_id;
372
373 do {
374 conn_id := float2int(rnd()*SCCP_Emulation.tsp_max_ConnectionId);
375 } while (f_conn_id_known(conn_id) == true);
376
377 return conn_id;
378}
379
Harald Welte365f4ed2017-11-23 00:00:43 +0100380private function f_conn_table_init()
Harald Welte6811d102019-04-14 22:23:14 +0200381runs on RAN_Emulation_CT {
Harald Welte365f4ed2017-11-23 00:00:43 +0100382 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
383 ConnectionTable[i].comp_ref := null;
384 ConnectionTable[i].sccp_conn_id := -1;
Harald Welte2fce7882019-04-15 11:48:05 +0200385#ifdef RAN_EMULATION_MGCP
Harald Weltec82eef42017-11-24 20:40:12 +0100386 ConnectionTable[i].mgcp_trans_id := omit;
Harald Welte2fce7882019-04-15 11:48:05 +0200387#endif
Harald Weltec82eef42017-11-24 20:40:12 +0100388 ConnectionTable[i].cic := omit;
Harald Welte9dadc522018-02-06 13:56:04 +0100389 ConnectionTable[i].n_sd := { 0, 0, 0, 0 };
Harald Welte365f4ed2017-11-23 00:00:43 +0100390 }
Harald Welte17d21152018-01-27 00:47:11 +0100391 for (var integer i := 0; i < sizeof(ImsiTable); i := i+1) {
392 ImsiTable[i].comp_ref := null;
393 ImsiTable[i].imsi := omit;
394 ImsiTable[i].tmsi := 'FFFFFFFF'O;
395 }
Harald Welte365f4ed2017-11-23 00:00:43 +0100396}
397
Harald Welte6811d102019-04-14 22:23:14 +0200398private function f_conn_table_add(RAN_ConnHdlr comp_ref, integer sccp_conn_id)
399runs on RAN_Emulation_CT {
Harald Welte365f4ed2017-11-23 00:00:43 +0100400 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
401 if (ConnectionTable[i].sccp_conn_id == -1) {
402 ConnectionTable[i].comp_ref := comp_ref;
403 ConnectionTable[i].sccp_conn_id := sccp_conn_id;
Harald Welte9dadc522018-02-06 13:56:04 +0100404 ConnectionTable[i].n_sd := { 0, 0, 0, 0 };
Harald Welteb3414b22017-11-23 18:22:10 +0100405 log("Added conn table entry ", i, comp_ref, sccp_conn_id);
Harald Welte365f4ed2017-11-23 00:00:43 +0100406 return;
407 }
408 }
Harald Welte6811d102019-04-14 22:23:14 +0200409 testcase.stop("RAN Connection table full!");
Harald Welte365f4ed2017-11-23 00:00:43 +0100410}
411
412private function f_conn_table_del(integer sccp_conn_id)
Harald Welte6811d102019-04-14 22:23:14 +0200413runs on RAN_Emulation_CT {
Harald Welte365f4ed2017-11-23 00:00:43 +0100414 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
415 if (ConnectionTable[i].sccp_conn_id == sccp_conn_id) {
Harald Welteb3414b22017-11-23 18:22:10 +0100416 log("Deleted conn table entry ", i,
417 ConnectionTable[i].comp_ref, sccp_conn_id);
Harald Welte365f4ed2017-11-23 00:00:43 +0100418 ConnectionTable[i].sccp_conn_id := -1;
419 ConnectionTable[i].comp_ref := null;
Harald Welte0a4317a2017-11-25 00:32:46 +0100420 return
Harald Welte365f4ed2017-11-23 00:00:43 +0100421 }
422 }
Harald Welte6811d102019-04-14 22:23:14 +0200423 setverdict(fail, "RAN Connection table attempt to delete non-existant ", sccp_conn_id);
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200424 mtc.stop;
Harald Welte365f4ed2017-11-23 00:00:43 +0100425}
426
Harald Welte17d21152018-01-27 00:47:11 +0100427private function f_imsi_table_find(hexstring imsi, template OCT4 tmsi)
Harald Welte6811d102019-04-14 22:23:14 +0200428runs on RAN_Emulation_CT return RAN_ConnHdlr {
Harald Welte17d21152018-01-27 00:47:11 +0100429 for (var integer i := 0; i < sizeof(ImsiTable); i := i+1) {
430 if (ImsiTable[i].imsi == imsi or
431 isvalue(tmsi) and match(ImsiTable[i].tmsi, tmsi)) {
432 return ImsiTable[i].comp_ref;
433 }
434 }
435 return null;
436}
437
Harald Welte2fce7882019-04-15 11:48:05 +0200438#ifdef RAN_EMULATION_BSSAP
439type record BSSAP_Conn_Req {
440 SCCP_PAR_Address addr_peer,
441 SCCP_PAR_Address addr_own,
442 PDU_BSSAP bssap
443}
444template BSSAP_Conn_Req ts_BSSAP_Conn_Req(SCCP_PAR_Address peer, SCCP_PAR_Address own, PDU_BSSAP bssap) := {
445 addr_peer := peer,
446 addr_own := own,
447 bssap := bssap
448};
449
Harald Welte365f4ed2017-11-23 00:00:43 +0100450/* handle (optional) userData portion of various primitives and dispatch it to the client */
Harald Welte6811d102019-04-14 22:23:14 +0200451private function f_handle_userData(RAN_ConnHdlr client, PDU_BSSAP bssap)
452runs on RAN_Emulation_CT {
Harald Welte365f4ed2017-11-23 00:00:43 +0100453 /* decode + send decoded BSSAP to client */
Harald Welte1b2748e2017-11-24 23:40:16 +0100454
Harald Welte473676b2018-01-27 20:38:01 +0100455 if (ischosen(bssap.pdu.bssmap)) {
456 /* BSC Side: If this is an assignment command, store CIC */
457 if (ischosen(bssap.pdu.bssmap.assignmentRequest) and
458 ispresent(bssap.pdu.bssmap.assignmentRequest.circuitIdentityCode)) {
459 var BSSMAP_IE_CircuitIdentityCode cic_ie :=
460 bssap.pdu.bssmap.assignmentRequest.circuitIdentityCode;
Pau Espin Pedrol43021cb2019-06-18 17:32:15 +0200461 var integer cic := f_bssmap_ie_cic_2_int(cic_ie);
Harald Welte473676b2018-01-27 20:38:01 +0100462 f_comp_store_cic(client, cic);
463 }
Harald Welte1b2748e2017-11-24 23:40:16 +0100464 }
465
Harald Welte6811d102019-04-14 22:23:14 +0200466 if (ischosen(bssap.pdu.dtap) and g_ran_ops.decode_dtap) {
467 if (g_ran_ops.role_ms) {
Harald Welte0b476062018-01-21 19:07:32 +0100468 /* we are the MS, so any message to us must be MT */
469 var PDU_DTAP_MT mt := {
470 dlci := bssap.dlci,
471 dtap := dec_PDU_ML3_NW_MS(bssap.pdu.dtap)
472 };
473 CLIENT.send(mt) to client;
474 } else {
475 /* we are the Network, so any message to us must be MO */
476 var PDU_DTAP_MO mo := {
477 dlci := bssap.dlci,
478 dtap := dec_PDU_ML3_MS_NW(bssap.pdu.dtap)
479 };
480 CLIENT.send(mo) to client;
481 }
482 } else {
483 CLIENT.send(bssap) to client;
484 }
Harald Welte365f4ed2017-11-23 00:00:43 +0100485}
486
487/* call-back type, to be provided by specific implementation; called when new SCCP connection
488 * arrives */
Harald Welte004f5fb2017-12-16 17:54:40 +0100489type function BssmapCreateCallback(BSSAP_N_CONNECT_ind conn_ind, charstring id)
Harald Welte6811d102019-04-14 22:23:14 +0200490runs on RAN_Emulation_CT return RAN_ConnHdlr;
Harald Welte365f4ed2017-11-23 00:00:43 +0100491
492type function BssmapUnitdataCallback(PDU_BSSAP bssap)
Harald Welte6811d102019-04-14 22:23:14 +0200493runs on RAN_Emulation_CT return template PDU_BSSAP;
Harald Welte365f4ed2017-11-23 00:00:43 +0100494
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200495private function append_osmux_ie()
496runs on RAN_Emulation_CT return boolean {
497 return g_ran_ops.use_osmux and (g_ran_ops.transport == BSSAP_TRANSPORT_AoIP);
498}
499
Harald Welte17d21152018-01-27 00:47:11 +0100500/* handle common Unitdata such as Paging */
501private function CommonBssmapUnitdataCallback(PDU_BSSAP bssap)
Harald Welte6811d102019-04-14 22:23:14 +0200502runs on RAN_Emulation_CT return template PDU_BSSAP {
Harald Welte17d21152018-01-27 00:47:11 +0100503 if (match(bssap, tr_BSSMAP_Paging)) {
Harald Welte6811d102019-04-14 22:23:14 +0200504 var RAN_ConnHdlr client := null;
Harald Welte17d21152018-01-27 00:47:11 +0100505 client := f_imsi_table_find(bssap.pdu.bssmap.paging.iMSI.digits,
506 bssap.pdu.bssmap.paging.tMSI.tmsiOctets);
Daniel Willmannabc73e12019-04-15 17:25:56 +0200507 if (client != null) {
Harald Welte17d21152018-01-27 00:47:11 +0100508 log("CommonBssmapUnitdataCallback: IMSI/TMSI found in table, dispatching to ",
509 client);
510 CLIENT.send(bssap) to client;
511 return omit;
512 }
513 log("CommonBssmapUnitdataCallback: IMSI/TMSI not found in table");
514 } else {
515 log("CommonBssmapUnitdataCallback: Not a paging message");
516 }
517 /* ELSE: handle in user callback */
Harald Welte6811d102019-04-14 22:23:14 +0200518 return g_ran_ops.unitdata_cb.apply(bssap);
Harald Welte17d21152018-01-27 00:47:11 +0100519}
520
Harald Welte6811d102019-04-14 22:23:14 +0200521private function f_bssap_wait_for_reset() runs on RAN_Emulation_CT {
Harald Weltea4ca4462018-02-09 00:17:14 +0100522 var BSSAP_N_UNITDATA_ind ud_ind;
523 timer T := 20.0;
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200524 var boolean append_osmux_support := append_osmux_ie();
Harald Weltea4ca4462018-02-09 00:17:14 +0100525
526 T.start;
527 alt {
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200528 [] BSSAP.receive(tr_BSSAP_UNITDATA_ind(?, ?, tr_BSSMAP_Reset(append_osmux_support))) -> value ud_ind {
Harald Weltea4ca4462018-02-09 00:17:14 +0100529 BSSAP.send(ts_BSSAP_UNITDATA_req(ud_ind.callingAddress, ud_ind.calledAddress,
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200530 ts_BSSMAP_ResetAck(append_osmux_support)));
Harald Weltea4ca4462018-02-09 00:17:14 +0100531 }
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200532 [] as_reset_ack(append_osmux_support);
Harald Weltea4ca4462018-02-09 00:17:14 +0100533 [] BSSAP.receive {
534 repeat;
535 }
536 [] T.timeout {
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200537 setverdict(fail, "Timeout waiting for BSSAP RESET");
538 mtc.stop;
Harald Weltea4ca4462018-02-09 00:17:14 +0100539 }
540 }
541}
542
Harald Welte6811d102019-04-14 22:23:14 +0200543function f_bssap_reset(SCCP_PAR_Address peer, SCCP_PAR_Address own) runs on RAN_Emulation_CT {
Harald Weltea4ca4462018-02-09 00:17:14 +0100544 timer T := 5.0;
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200545 var boolean append_osmux_support := append_osmux_ie();
Harald Weltea4ca4462018-02-09 00:17:14 +0100546
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200547 BSSAP.send(ts_BSSAP_UNITDATA_req(peer, own, ts_BSSMAP_Reset(0, append_osmux_support)));
Harald Weltea4ca4462018-02-09 00:17:14 +0100548 T.start;
549 alt {
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200550 [] BSSAP.receive(tr_BSSAP_UNITDATA_ind(own, peer, tr_BSSMAP_ResetAck(append_osmux_support))) {
Harald Weltea4ca4462018-02-09 00:17:14 +0100551 log("Received RESET-ACK in response to RESET, we're ready to go!");
552 }
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200553 [] as_reset_ack(append_osmux_support);
Harald Weltea4ca4462018-02-09 00:17:14 +0100554 [] BSSAP.receive { repeat };
Daniel Willmanne4ff5372018-07-05 17:35:03 +0200555 [] T.timeout {
556 setverdict(fail, "Timeout waiting for RESET-ACK after sending RESET");
557 mtc.stop;
558 }
Harald Weltea4ca4462018-02-09 00:17:14 +0100559 }
560}
561
Harald Welte2fce7882019-04-15 11:48:05 +0200562private function f_bssap_l3_is_rr(PDU_BSSAP bssap) return boolean {
563 var template octetstring l3 := f_bssap_extract_l3(bssap);
564 return f_L3_is_rr(l3);
565}
566#endif
Harald Welte365f4ed2017-11-23 00:00:43 +0100567
Harald Welte5b027622019-04-14 23:40:17 +0200568#ifdef RAN_EMULATION_RANAP
569type record RANAP_Conn_Req {
570 SCCP_PAR_Address addr_peer,
571 SCCP_PAR_Address addr_own,
572 RANAP_PDU ranap
573}
574template (value) RANAP_Conn_Req ts_RANAP_Conn_Req(SCCP_PAR_Address peer, SCCP_PAR_Address own, RANAP_PDU ranap) := {
575 addr_peer := peer,
576 addr_own := own,
577 ranap := ranap
578};
579
580private function fake_dlci_from_sapi(template (omit) SAPI sapi) return template (omit) OCT1
581{
582 if (istemplatekind(sapi, "omit")) {
583 return omit;
584 } else if (valueof(sapi) == sapi_3) {
585 return '03'O;
586 }
587 return '00'O;
588}
589
590private function f_handle_userData_RANAP(RAN_ConnHdlr client, RANAP_PDU ranap)
591runs on RAN_Emulation_CT {
592 /* decode + send decoded RANAP to client */
593 var template (omit) octetstring l3 := f_ranap_extract_l3(ranap);
594 if (istemplatekind(l3, "omit")) {
595 CLIENT.send(ranap) to client;
596 } else {
597 var template (omit) SAPI sapi := f_ranap_extract_sapi(ranap);
598 var template (omit) OCT1 dlci := fake_dlci_from_sapi(sapi);
599 if (g_ran_ops.role_ms) {
600 /* we are the MS, so any message to us must be MT */
Harald Welte717c7302019-04-23 20:31:55 +0200601 if (g_ran_ops.ps_domain) {
602 var PDU_DTAP_PS_MT mt := {
603 dlci := omit,
604 dtap := dec_PDU_L3_SGSN_MS(valueof(l3))
605 };
606 if (isvalue(dlci)) {
607 mt.dlci := valueof(dlci);
608 }
609 CLIENT.send(mt) to client;
610 } else {
611 var PDU_DTAP_MT mt := {
612 dlci := omit,
613 dtap := dec_PDU_ML3_NW_MS(valueof(l3))
614 };
615 if (isvalue(dlci)) {
616 mt.dlci := valueof(dlci)
617 }
618 CLIENT.send(mt) to client;
Harald Welte5b027622019-04-14 23:40:17 +0200619 }
Harald Welte5b027622019-04-14 23:40:17 +0200620 } else {
621 /* we are the Network, so any message to us must be MO */
Harald Welte717c7302019-04-23 20:31:55 +0200622 if (g_ran_ops.ps_domain) {
623 var PDU_DTAP_PS_MO mo := {
624 dlci := omit,
625 dtap := dec_PDU_L3_MS_SGSN(valueof(l3))
626 };
627 if (isvalue(dlci)) {
628 mo.dlci := valueof(dlci);
629 }
630 CLIENT.send(mo) to client;
631 } else {
632 var PDU_DTAP_MO mo := {
633 dlci := omit,
634 dtap := dec_PDU_ML3_MS_NW(valueof(l3))
635 };
636 if (isvalue(dlci)) {
637 mo.dlci := valueof(dlci)
638 }
639 CLIENT.send(mo) to client;
Harald Welte5b027622019-04-14 23:40:17 +0200640 }
Harald Welte5b027622019-04-14 23:40:17 +0200641 }
642 }
643}
644
645/* call-back type, to be provided by specific implementation; called when new SCCP connection
646 * arrives */
647type function RanapCreateCallback(RANAP_N_CONNECT_ind conn_ind, charstring id)
648runs on RAN_Emulation_CT return RAN_ConnHdlr;
649
650type function RanapUnitdataCallback(RANAP_PDU ranap)
651runs on RAN_Emulation_CT return template RANAP_PDU;
652
653private function CommonRanapUnitdataCallback(RANAP_PDU ranap)
654runs on RAN_Emulation_CT return template RANAP_PDU {
655 if (match(ranap, tr_RANAP_Paging(?, ?))) {
656 var RAN_ConnHdlr client := null;
657 /* extract IMSI and (if present) TMSI */
658 var IMSI imsi := ranap.initiatingMessage.value_.paging.protocolIEs[1].value_.permanentNAS_UE_ID.iMSI;
659 var template OCT4 tmsi := omit;
660 if (lengthof(ranap.initiatingMessage.value_.paging.protocolIEs) > 2 and
661 ranap.initiatingMessage.value_.paging.protocolIEs[2].id == id_TemporaryUE_ID) {
662 var TemporaryUE_ID ue_id;
663 ue_id := ranap.initiatingMessage.value_.paging.protocolIEs[2].value_.temporaryUE_ID;
664 if (ischosen(ue_id.tMSI)) {
665 tmsi := ue_id.tMSI;
666 } else {
667 tmsi := ue_id.p_TMSI;
668 }
669 }
670 client := f_imsi_table_find(oct2hex(imsi), tmsi);
Harald Welte03d4e2b2019-05-10 00:42:33 +0200671 if (client != null) {
Harald Welte5b027622019-04-14 23:40:17 +0200672 log("CommonRanapUnitdataCallback: IMSI/TMSI found in table, dispatching to ",
673 client);
674 CLIENT.send(ranap) to client;
675 return omit;
676 }
677 log("CommonRanapUnitdataCallback: IMSI/TMSI not found in table");
678 } else {
679 log("CommonRanapUnitdataCallback: Not a paging message");
680 }
681
682 /* ELSE: handle in user callback */
683 return g_ran_ops.ranap_unitdata_cb.apply(ranap);
684}
685
686private function f_ranap_l3_is_rr(RANAP_PDU ranap) return boolean {
687 var template (omit) SAPI sapi;
688 var template octetstring l3 := f_ranap_extract_l3(ranap);
689 return f_L3_is_rr(l3);
690}
691
692function f_ranap_reset(SCCP_PAR_Address peer, SCCP_PAR_Address own) runs on RAN_Emulation_CT {
693 timer T := 5.0;
694 var CN_DomainIndicator dom;
695 if (g_ran_ops.ps_domain) {
696 dom := ps_domain;
697 } else {
698 dom := cs_domain;
699 }
700
701 RANAP.send(ts_RANAP_UNITDATA_req(peer, own, ts_RANAP_Reset(ts_RanapCause_om_intervention, dom)));
702 T.start;
703 alt {
704 [] RANAP.receive(tr_RANAP_UNITDATA_ind(own, peer, tr_RANAP_ResetAck)) {
705 log("Received RESET-ACK in response to RESET, we're ready to go!");
706 }
707 [] as_reset_ack();
708 [] RANAP.receive { repeat };
709 [] T.timeout {
710 setverdict(fail, "Timeout waiting for RESET-ACK after sending RESET");
711 mtc.stop;
712 }
713 }
714}
715#endif
Harald Welte365f4ed2017-11-23 00:00:43 +0100716
Harald Welte2fce7882019-04-15 11:48:05 +0200717
718type enumerated RanProtocol {
Harald Welte5b027622019-04-14 23:40:17 +0200719 RAN_PROTOCOL_BSSAP,
720 RAN_PROTOCOL_RANAP
Harald Welte2fce7882019-04-15 11:48:05 +0200721}
722
723type record RanOps {
724#ifdef RAN_EMULATION_BSSAP
725 BssmapCreateCallback create_cb optional,
726 BssmapUnitdataCallback unitdata_cb optional,
727#endif
Harald Welte5b027622019-04-14 23:40:17 +0200728#ifdef RAN_EMULATION_RANAP
729 RanapCreateCallback ranap_create_cb optional,
730 RanapUnitdataCallback ranap_unitdata_cb optional,
731 boolean ps_domain,
732#endif
Harald Welte2fce7882019-04-15 11:48:05 +0200733 boolean decode_dtap,
734 boolean role_ms,
735 RanProtocol protocol,
Pau Espin Pedrolc6b78ff2019-06-06 15:58:17 +0200736 RAN_Transport transport,
Pau Espin Pedrolc6a53db2019-05-20 19:31:47 +0200737 boolean use_osmux,
Harald Welte2fce7882019-04-15 11:48:05 +0200738 /* needed for performing BSSMAP RESET */
739 SCCP_PAR_Address sccp_addr_local optional,
740 SCCP_PAR_Address sccp_addr_peer optional
741}
742
743template BIT4 t_ML3_DISC_CC_MM_SS := ('0011'B, '0101'B, '1011'B);
744
745private function f_L3_is_rr(template octetstring l3) return boolean {
746 if (not isvalue(l3)) {
747 return false;
Harald Weltea4ca4462018-02-09 00:17:14 +0100748 }
Harald Welte2fce7882019-04-15 11:48:05 +0200749 var octetstring l3v := valueof(l3);
750 if (lengthof(l3v) < 1) {
751 return false;
752 }
753 /* lower 4 bits of first octet are protocol discriminator */
754 if ((oct2bit(l3v[0]) and4b '00001111'B) == '00000110'B) {
755 return true;
756 }
757 return false;
758}
Harald Weltea4ca4462018-02-09 00:17:14 +0100759
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200760function f_next_n_sd(inout N_Sd_Array n_sd, in integer n_sd_idx) return uint2_t {
Harald Welte2fce7882019-04-15 11:48:05 +0200761 var uint2_t seq_nr;
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200762 if (n_sd_idx == 0) {
763 seq_nr := n_sd[0];
764 n_sd[0] := (n_sd[0] + 1) mod 4;
765 } else if (n_sd_idx >= 1 and n_sd_idx <= 3) {
766 seq_nr := n_sd[n_sd_idx];
767 n_sd[n_sd_idx] := (n_sd[n_sd_idx] + 1) mod 2;
Harald Welte2fce7882019-04-15 11:48:05 +0200768 } else {
769 /* no sequence number to patch */
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200770 seq_nr := 0;
Harald Welte2fce7882019-04-15 11:48:05 +0200771 }
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200772 return seq_nr;
773}
774
775/* patch N(SD) into enc_l3, according to 24.007 11.2.3.2 */
776function f_ML3_patch_seq_nr(in uint2_t seq_nr, inout octetstring enc_l3) {
Harald Welte2fce7882019-04-15 11:48:05 +0200777 log("patching N(SD)=", seq_nr, " into dtap ", enc_l3);
778 enc_l3[1] := (enc_l3[1] and4b '3f'O) or4b bit2oct(int2bit(seq_nr, 8) << 6);
779 log("patched enc_l3: ", enc_l3);
780}
781
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200782function f_ML3_n_sd_idx(in PDU_ML3_MS_NW dtap) return integer {
783 var uint2_t seq_nr;
784 if (ischosen(dtap.msgs.cc) or ischosen(dtap.msgs.mm) or ischosen(dtap.msgs.ss)) {
785 return 0;
786 } else if (ischosen(dtap.msgs.gcc)) {
787 return 1;
788 } else if (ischosen(dtap.msgs.bcc)) {
789 return 2;
790 } else if (ischosen(dtap.msgs.loc)) {
791 return 3;
792 }
793 /* no sequence number to patch */
794 return -1;
795}
796
797/* patch N(SD) into enc_l3, according to 24.007 11.2.3.2 */
798function f_ML3_patch_seq(inout ConnectionData cd, in PDU_ML3_MS_NW dtap, inout octetstring enc_l3) {
799 var integer n_sd_idx := f_ML3_n_sd_idx(dtap);
800 if (n_sd_idx < 0) {
801 return;
802 }
803 var uint2_t seq_nr := f_next_n_sd(cd.n_sd, n_sd_idx);
804 f_ML3_patch_seq_nr(seq_nr, enc_l3);
805}
806
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200807private altstep as_reset_ack(boolean append_osmux_support := false) runs on RAN_Emulation_CT {
Harald Welte2fce7882019-04-15 11:48:05 +0200808#ifdef RAN_EMULATION_BSSAP
809 var BSSAP_N_UNITDATA_ind ud_ind;
810#endif
Harald Welte5b027622019-04-14 23:40:17 +0200811#ifdef RAN_EMULATION_RANAP
812 var RANAP_N_UNITDATA_ind rud_ind;
813#endif
Harald Welte2fce7882019-04-15 11:48:05 +0200814#ifdef RAN_EMULATION_BSSAP
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200815 [] BSSAP.receive(tr_BSSAP_UNITDATA_ind(?, ?, tr_BSSMAP_Reset(append_osmux_support))) -> value ud_ind {
Harald Welte2fce7882019-04-15 11:48:05 +0200816 log("Respoding to inbound RESET with RESET-ACK");
817 BSSAP.send(ts_BSSAP_UNITDATA_req(ud_ind.callingAddress, ud_ind.calledAddress,
Pau Espin Pedrol95549182019-06-06 16:17:30 +0200818 ts_BSSMAP_ResetAck(append_osmux_support)));
Harald Welte2fce7882019-04-15 11:48:05 +0200819 repeat;
820 }
821#endif
Harald Welte5b027622019-04-14 23:40:17 +0200822#ifdef RAN_EMULATION_RANAP
823 [] RANAP.receive(tr_RANAP_UNITDATA_ind(?, ?, tr_RANAP_Reset)) -> value rud_ind {
824 log("Respoding to inbound IuRESET with IuRESET-ACK");
825 var CN_DomainIndicator dom;
826 dom := rud_ind.userData.initiatingMessage.value_.Reset.protocolIEs[1].value_.cN_DomainIndicator;
827 RANAP.send(ts_RANAP_UNITDATA_req(rud_ind.callingAddress, rud_ind.calledAddress,
828 ts_RANAP_ResetAck(dom)));
829 }
830#endif
Harald Welte2fce7882019-04-15 11:48:05 +0200831}
832
833
834private altstep as_main_bssap() runs on RAN_Emulation_CT {
835#ifdef RAN_EMULATION_BSSAP
Harald Welte004f5fb2017-12-16 17:54:40 +0100836 var BSSAP_N_UNITDATA_ind ud_ind;
837 var BSSAP_N_CONNECT_ind conn_ind;
838 var BSSAP_N_CONNECT_cfm conn_cfm;
839 var BSSAP_N_DATA_ind data_ind;
840 var BSSAP_N_DISCONNECT_ind disc_ind;
Harald Welteb3414b22017-11-23 18:22:10 +0100841 var BSSAP_Conn_Req creq;
Harald Welte365f4ed2017-11-23 00:00:43 +0100842 var PDU_BSSAP bssap;
Neels Hofmeyra8264612020-06-08 20:40:22 +0200843 var BSSAP_N_UNITDATA_req bssap_ud;
Harald Welte2fce7882019-04-15 11:48:05 +0200844 var RAN_ConnHdlr vc_conn;
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200845 var integer targetPointCode;
846 var N_Sd_Array last_n_sd;
Harald Welte365f4ed2017-11-23 00:00:43 +0100847
Harald Welte365f4ed2017-11-23 00:00:43 +0100848 /* SCCP -> Client: UNIT-DATA (connectionless SCCP) from a BSC */
Harald Welte004f5fb2017-12-16 17:54:40 +0100849 [] BSSAP.receive(BSSAP_N_UNITDATA_ind:?) -> value ud_ind {
Harald Welte365f4ed2017-11-23 00:00:43 +0100850 /* Connectionless Procedures like RESET */
851 var template PDU_BSSAP resp;
Harald Welte17d21152018-01-27 00:47:11 +0100852 resp := CommonBssmapUnitdataCallback(ud_ind.userData);
Harald Welte365f4ed2017-11-23 00:00:43 +0100853 if (isvalue(resp)) {
Harald Welte004f5fb2017-12-16 17:54:40 +0100854 BSSAP.send(ts_BSSAP_UNITDATA_req(ud_ind.callingAddress,
855 ud_ind.calledAddress, resp));
Harald Welte365f4ed2017-11-23 00:00:43 +0100856 }
857 }
Harald Welte365f4ed2017-11-23 00:00:43 +0100858 /* SCCP -> Client: new connection from BSC */
Harald Welte004f5fb2017-12-16 17:54:40 +0100859 [] BSSAP.receive(BSSAP_N_CONNECT_ind:?) -> value conn_ind {
Harald Welte2fce7882019-04-15 11:48:05 +0200860 vc_conn := g_ran_ops.create_cb.apply(conn_ind, g_ran_id);
Harald Welte365f4ed2017-11-23 00:00:43 +0100861 /* store mapping between client components and SCCP connectionId */
862 f_conn_table_add(vc_conn, conn_ind.connectionId);
863 /* handle user payload */
864 f_handle_userData(vc_conn, conn_ind.userData);
865 /* confirm connection establishment */
Harald Welte004f5fb2017-12-16 17:54:40 +0100866 BSSAP.send(ts_BSSAP_CONNECT_res(conn_ind.connectionId, omit));
Harald Welte365f4ed2017-11-23 00:00:43 +0100867 }
Harald Welte365f4ed2017-11-23 00:00:43 +0100868 /* SCCP -> Client: connection-oriented data in existing connection */
Harald Welte004f5fb2017-12-16 17:54:40 +0100869 [] BSSAP.receive(BSSAP_N_DATA_ind:?) -> value data_ind {
Harald Welte365f4ed2017-11-23 00:00:43 +0100870 vc_conn := f_comp_by_conn_id(data_ind.connectionId);
Harald Welte5cc4aa22017-11-23 18:51:28 +0100871 if (ispresent(data_ind.userData)) {
872 f_handle_userData(vc_conn, data_ind.userData);
873 }
Harald Welte365f4ed2017-11-23 00:00:43 +0100874 }
Harald Welte365f4ed2017-11-23 00:00:43 +0100875 /* SCCP -> Client: disconnect of an existing connection */
Harald Welte004f5fb2017-12-16 17:54:40 +0100876 [] BSSAP.receive(BSSAP_N_DISCONNECT_ind:?) -> value disc_ind {
Harald Welte365f4ed2017-11-23 00:00:43 +0100877 vc_conn := f_comp_by_conn_id(disc_ind.connectionId);
Harald Welte5cc4aa22017-11-23 18:51:28 +0100878 if (ispresent(disc_ind.userData)) {
879 f_handle_userData(vc_conn, disc_ind.userData);
880 }
Harald Welte365f4ed2017-11-23 00:00:43 +0100881 /* notify client about termination */
Harald Welte6811d102019-04-14 22:23:14 +0200882 var RAN_Conn_Prim prim := MSC_CONN_PRIM_DISC_IND;
Harald Welte365f4ed2017-11-23 00:00:43 +0100883 CLIENT.send(prim) to vc_conn;
884 f_conn_table_del(disc_ind.connectionId);
885 /* TOOD: return confirm to other side? */
886 }
Harald Welteb3414b22017-11-23 18:22:10 +0100887 /* SCCP -> Client: connection confirm for outbound connection */
Harald Welte004f5fb2017-12-16 17:54:40 +0100888 [] BSSAP.receive(BSSAP_N_CONNECT_cfm:?) -> value conn_cfm {
Harald Welte71b69332018-01-21 20:43:53 +0100889 vc_conn := f_comp_by_conn_id(conn_cfm.connectionId);
Harald Welte6811d102019-04-14 22:23:14 +0200890 var RAN_Conn_Prim prim := MSC_CONN_PRIM_CONF_IND;
Harald Welte71b69332018-01-21 20:43:53 +0100891 CLIENT.send(prim) to vc_conn;
Harald Welteb3414b22017-11-23 18:22:10 +0100892 /* handle user payload */
Harald Welte5cc4aa22017-11-23 18:51:28 +0100893 if (ispresent(conn_cfm.userData)) {
894 f_handle_userData(vc_conn, conn_cfm.userData);
895 }
Harald Welteb3414b22017-11-23 18:22:10 +0100896 }
Harald Welte2fce7882019-04-15 11:48:05 +0200897 [] CLIENT.receive(PDU_BSSAP:?) -> value bssap sender vc_conn {
898 var integer conn_id := f_conn_id_by_comp(vc_conn);
899 /* send it to dispatcher */
900 BSSAP.send(ts_BSSAP_DATA_req(conn_id, bssap));
901 }
Harald Welteb3414b22017-11-23 18:22:10 +0100902
Neels Hofmeyra8264612020-06-08 20:40:22 +0200903 [] CLIENT.receive(BSSAP_N_UNITDATA_req:?) -> value bssap_ud sender vc_conn {
904 BSSAP.send(bssap_ud);
905 }
906
Harald Welte365f4ed2017-11-23 00:00:43 +0100907 /* Disconnect request client -> SCCP */
Harald Welte6811d102019-04-14 22:23:14 +0200908 [] CLIENT.receive(RAN_Conn_Prim:MSC_CONN_PRIM_DISC_REQ) -> sender vc_conn {
Harald Welte365f4ed2017-11-23 00:00:43 +0100909 var integer conn_id := f_conn_id_by_comp(vc_conn);
Harald Welte004f5fb2017-12-16 17:54:40 +0100910 BSSAP.send(ts_BSSAP_DISC_req(conn_id, 0));
Harald Welte365f4ed2017-11-23 00:00:43 +0100911 f_conn_table_del(conn_id);
912 }
913
914 /* BSSAP from client -> SCCP */
Harald Welteb3414b22017-11-23 18:22:10 +0100915 [] CLIENT.receive(BSSAP_Conn_Req:?) -> value creq sender vc_conn {
916 var integer conn_id;
Harald Welte004f5fb2017-12-16 17:54:40 +0100917 /* send to dispatcher */
Harald Welteb3414b22017-11-23 18:22:10 +0100918
919 if (f_comp_known(vc_conn) == false) {
920 /* unknown client, create new connection */
921 conn_id := f_gen_conn_id();
922
923 /* store mapping between client components and SCCP connectionId */
924 f_conn_table_add(vc_conn, conn_id);
925
Harald Welte004f5fb2017-12-16 17:54:40 +0100926 BSSAP.send(ts_BSSAP_CONNECT_req(creq.addr_peer, creq.addr_own, conn_id,
927 creq.bssap));
Harald Welteb3414b22017-11-23 18:22:10 +0100928 } else {
929 /* known client, send via existing connection */
930 conn_id := f_conn_id_by_comp(vc_conn);
Harald Welte004f5fb2017-12-16 17:54:40 +0100931 BSSAP.send(ts_BSSAP_DATA_req(conn_id, creq.bssap));
Harald Welteb3414b22017-11-23 18:22:10 +0100932 }
933
Harald Welte49518bf2018-02-10 11:39:19 +0100934 /* InitialL3 contains RR (PAG RESP) or MM (CM SRV REQ), we must increment
935 * counter only on MM/CC/SS, but not on RR */
Harald Welte6811d102019-04-14 22:23:14 +0200936 if (g_ran_ops.role_ms and not f_bssap_l3_is_rr(creq.bssap)) {
Harald Welte9dadc522018-02-06 13:56:04 +0100937 /* we have just sent the first MM message, increment the counter */
938 var integer idx := f_idx_by_comp(vc_conn);
939 ConnectionTable[idx].n_sd[0] := 1;
940 log("patch: N(SD) for ConnIdx ", idx, " set to 1");
941 }
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200942 }
Harald Welte9dadc522018-02-06 13:56:04 +0100943
Neels Hofmeyr0ac63152019-05-07 01:20:17 +0200944 [] PROC.getcall(RAN_last_n_sd:{?,-}) -> param(vc_conn) {
945 var integer idx := f_idx_by_comp(vc_conn);
946 last_n_sd := ConnectionTable[idx].n_sd;
947 PROC.reply(RAN_last_n_sd:{vc_conn, last_n_sd}) to vc_conn;
948 }
949
950 [] PROC.getcall(RAN_continue_after_n_sd:{?,?}) -> param(last_n_sd, vc_conn) {
951 var integer idx := f_idx_by_comp(vc_conn);
952 ConnectionTable[idx].n_sd := last_n_sd;
953 PROC.reply(RAN_continue_after_n_sd:{last_n_sd, vc_conn}) to vc_conn;
Harald Welteb3414b22017-11-23 18:22:10 +0100954 }
Harald Welte2fce7882019-04-15 11:48:05 +0200955#else
Harald Welte5b027622019-04-14 23:40:17 +0200956 [false] CLIENT.receive {}
957#endif
958}
959
960private altstep as_main_ranap() runs on RAN_Emulation_CT {
961#ifdef RAN_EMULATION_RANAP
962 var RANAP_N_UNITDATA_ind rud_ind;
963 var RANAP_N_CONNECT_ind rconn_ind;
964 var RANAP_N_CONNECT_cfm rconn_cfm;
965 var RANAP_N_DATA_ind rdata_ind;
966 var RANAP_N_DISCONNECT_ind rdisc_ind;
967 var RANAP_Conn_Req creq;
968 var RANAP_PDU ranap;
969 var RAN_ConnHdlr vc_conn;
Harald Welte717c7302019-04-23 20:31:55 +0200970 var PDU_DTAP_PS_MO ps_mo;
971 var PDU_DTAP_PS_MT ps_mt;
Harald Welte5b027622019-04-14 23:40:17 +0200972
973 /* SCCP -> Client: UNIT-DATA (connectionless SCCP) from a BSC */
974 [] RANAP.receive(RANAP_N_UNITDATA_ind:?) -> value rud_ind {
975 /* Connectionless Procedures like RESET */
976 var template RANAP_PDU resp;
977 resp := CommonRanapUnitdataCallback(rud_ind.userData);
978 if (isvalue(resp)) {
979 RANAP.send(ts_RANAP_UNITDATA_req(rud_ind.callingAddress,
980 rud_ind.calledAddress, resp));
981 }
982 }
983 /* SCCP -> Client: new connection from BSC */
984 [] RANAP.receive(RANAP_N_CONNECT_ind:?) -> value rconn_ind {
985 vc_conn := g_ran_ops.ranap_create_cb.apply(rconn_ind, g_ran_id);
986 /* store mapping between client components and SCCP connectionId */
987 f_conn_table_add(vc_conn, rconn_ind.connectionId);
988 /* handle user payload */
989 f_handle_userData_RANAP(vc_conn, rconn_ind.userData);
990 /* confirm connection establishment */
991 RANAP.send(ts_RANAP_CONNECT_res(rconn_ind.connectionId, omit));
992 }
993 /* SCCP -> Client: connection-oriented data in existing connection */
994 [] RANAP.receive(RANAP_N_DATA_ind:?) -> value rdata_ind {
995 vc_conn := f_comp_by_conn_id(rdata_ind.connectionId);
996 if (ispresent(rdata_ind.userData)) {
997 f_handle_userData_RANAP(vc_conn, rdata_ind.userData);
998 }
999 }
1000 /* SCCP -> Client: disconnect of an existing connection */
1001 [] RANAP.receive(RANAP_N_DISCONNECT_ind:?) -> value rdisc_ind {
1002 vc_conn := f_comp_by_conn_id(rdisc_ind.connectionId);
1003 if (ispresent(rdisc_ind.userData)) {
1004 f_handle_userData_RANAP(vc_conn, rdisc_ind.userData);
1005 }
1006 /* notify client about termination */
1007 var RAN_Conn_Prim prim := MSC_CONN_PRIM_DISC_IND;
1008 CLIENT.send(prim) to vc_conn;
1009 f_conn_table_del(rdisc_ind.connectionId);
1010 /* TOOD: return confirm to other side? */
1011 }
1012 /* SCCP -> Client: connection confirm for outbound connection */
1013 [] RANAP.receive(RANAP_N_CONNECT_cfm:?) -> value rconn_cfm {
1014 vc_conn := f_comp_by_conn_id(rconn_cfm.connectionId);
1015 var RAN_Conn_Prim prim := MSC_CONN_PRIM_CONF_IND;
1016 CLIENT.send(prim) to vc_conn;
1017 /* handle user payload */
1018 if (ispresent(rconn_cfm.userData)) {
1019 f_handle_userData_RANAP(vc_conn, rconn_cfm.userData);
1020 }
1021 }
1022
1023 [] CLIENT.receive(RANAP_PDU:?) -> value ranap sender vc_conn {
1024 var integer conn_id := f_conn_id_by_comp(vc_conn);
1025 /* send it to dispatcher */
1026 RANAP.send(ts_RANAP_DATA_req(conn_id, ranap));
1027 }
1028
1029 /* Disconnect request client -> SCCP */
1030 [] CLIENT.receive(RAN_Conn_Prim:MSC_CONN_PRIM_DISC_REQ) -> sender vc_conn {
1031 var integer conn_id := f_conn_id_by_comp(vc_conn);
1032 RANAP.send(ts_RANAP_DISC_req(conn_id, 0));
1033 f_conn_table_del(conn_id);
1034 }
1035
1036 /* BSSAP from client -> SCCP */
1037 [] CLIENT.receive(RANAP_Conn_Req:?) -> value creq sender vc_conn {
1038 var integer conn_id;
1039 /* send to dispatcher */
1040
1041 if (f_comp_known(vc_conn) == false) {
1042 /* unknown client, create new connection */
1043 conn_id := f_gen_conn_id();
1044
1045 /* store mapping between client components and SCCP connectionId */
1046 f_conn_table_add(vc_conn, conn_id);
1047
1048 RANAP.send(ts_RANAP_CONNECT_req(creq.addr_peer, creq.addr_own, conn_id,
1049 creq.ranap));
1050 } else {
1051 /* known client, send via existing connection */
1052 conn_id := f_conn_id_by_comp(vc_conn);
1053 RANAP.send(ts_RANAP_DATA_req(conn_id, creq.ranap));
1054 }
1055
1056 /* InitialL3 contains RR (PAG RESP) or MM (CM SRV REQ), we must increment
1057 * counter only on MM/CC/SS, but not on RR */
1058 if (g_ran_ops.role_ms and not f_ranap_l3_is_rr(creq.ranap)) {
1059 /* we have just sent the first MM message, increment the counter */
1060 var integer idx := f_idx_by_comp(vc_conn);
1061 ConnectionTable[idx].n_sd[0] := 1;
1062 log("patch: N(SD) for ConnIdx ", idx, " set to 1");
1063 }
1064 }
1065
Harald Welte717c7302019-04-23 20:31:55 +02001066 [g_ran_ops.role_ms] CLIENT.receive(PDU_DTAP_PS_MO:?) -> value ps_mo sender vc_conn {
1067 var integer idx := f_idx_by_comp(vc_conn);
1068 /* convert from decoded DTAP to encoded DTAP */
1069 var octetstring l3_enc := enc_PDU_L3_MS_SGSN(ps_mo.dtap);
1070 /* patch correct L3 send sequence number N(SD) into l3_enc */
1071 if (ps_mo.skip_seq_patching == false) {
1072 //f_ML3_patch_seq(ConnectionTable[idx], ps_mo.dtap, l3_enc);
1073 }
1074 f_xmit_raw_l3(ConnectionTable[idx].sccp_conn_id, ps_mo.dlci, l3_enc);
1075 }
1076
1077 [not g_ran_ops.role_ms] CLIENT.receive(PDU_DTAP_PS_MT:?) -> value ps_mt sender vc_conn {
1078 var integer idx := f_idx_by_comp(vc_conn);
1079 /* convert from decoded DTAP to encoded DTAP */
1080 var octetstring l3_enc := enc_PDU_L3_SGSN_MS(ps_mt.dtap);
1081 f_xmit_raw_l3(ConnectionTable[idx].sccp_conn_id, ps_mt.dlci, l3_enc);
1082 }
1083
1084
Harald Welte5b027622019-04-14 23:40:17 +02001085#else
1086 [false] CLIENT.receive {}
Harald Welte2fce7882019-04-15 11:48:05 +02001087#endif
1088}
Harald Welteb3414b22017-11-23 18:22:10 +01001089
Harald Welte2fce7882019-04-15 11:48:05 +02001090private altstep as_main_mgcp() runs on RAN_Emulation_CT {
1091#ifdef RAN_EMULATION_MGCP
1092 var MgcpCommand mgcp_req;
1093 var MgcpResponse mgcp_resp;
1094 var RAN_ConnHdlr vc_conn;
Harald Welte0b476062018-01-21 19:07:32 +01001095
Harald Weltec82eef42017-11-24 20:40:12 +01001096 /* Handling of MGCP in IPA SCCPLite case. This predates 3GPP AoIP
1097 * and uses a MGCP session in parallel to BSSAP. BSSAP uses CIC
1098 * as usual, and MGCP uses "CIC@mgw" endpoint naming, where CIC
1099 * is printed as hex string, e.g. a@mgw for CIC 10 */
1100
1101 /* CLIENT -> MGCP */
1102 [] CLIENT.receive(MgcpCommand:?) -> value mgcp_req sender vc_conn {
1103 /* MGCP request from Handler (we're MSC) */
1104 /* store the transaction ID we've seen */
1105 f_comp_store_mgcp_tid(vc_conn, mgcp_req.line.trans_id);
1106 /* simply forward any MGCP from the client to the port */
1107 MGCP.send(mgcp_req);
1108 }
1109 [] CLIENT.receive(MgcpResponse:?) -> value mgcp_resp sender vc_conn {
1110 /* MGCP response from Handler (we're BSC/MGW) */
1111 /* simply forward any MGCP from the client to the port */
1112 MGCP.send(mgcp_resp);
1113 }
1114
1115 /* MGCP -> CLIENT */
1116 [] MGCP.receive(MgcpCommand:?) -> value mgcp_req {
1117 /* MGCP request from network side (we're BSC/MGW) */
1118 /* Extract CIC from local part of endpoint name */
1119 var integer cic := f_mgcp_ep_extract_cic(mgcp_req.line.ep);
Harald Weltee98bb2e2017-11-29 12:09:48 +01001120 if (match(mgcp_req, tr_RSIP) and f_cic_known(cic) == false) {
1121 /* ignore RSIP for unknown CIC */
1122 } else {
1123 /* Resolve the vc_conn by the CIC */
1124 vc_conn := f_comp_by_cic(cic);
1125 CLIENT.send(mgcp_req) to vc_conn;
1126 }
Harald Weltec82eef42017-11-24 20:40:12 +01001127 }
1128 [] MGCP.receive(MgcpResponse:?) -> value mgcp_resp {
1129 /* MGCP response from network side (we're MSC) */
1130 /* Resolve the vc_conn by the transaction ID */
1131 vc_conn := f_comp_by_mgcp_tid(mgcp_resp.line.trans_id);
1132 CLIENT.send(mgcp_resp) to vc_conn;
1133 }
Harald Welte2fce7882019-04-15 11:48:05 +02001134#else
1135 [false] CLIENT.receive {}
1136#endif
1137}
Harald Weltec82eef42017-11-24 20:40:12 +01001138
Pau Espin Pedrol4d0e5e52019-06-07 19:38:28 +02001139private altstep as_main_ctrl() runs on RAN_Emulation_CT {
1140#ifdef RAN_EMULATION_CTRL
1141 var CtrlMessage ctrl;
1142 var RAN_ConnHdlr vc_conn;
1143 var ASP_IPA_Event evt;
1144
1145 /* Handling of CTRL in IPA SCCPLite case. This predates 3GPP AoIP
1146 * and uses a CTRL session in parallel to BSSAP. */
1147
1148 /* CTRL_CLIENT -> CTRL */
1149 [] CTRL_CLIENT.receive(CtrlMessage:?) -> value ctrl sender vc_conn {
1150 CTRL.send(ctrl);
1151 }
1152
1153 /* CTRL -> CTRL_CLIENT */
1154 [] CTRL.receive(CtrlMessage:?) -> value ctrl {
1155 CTRL_CLIENT.send(ctrl);
1156 }
1157
Vadim Yanitskiya2afacc2020-05-18 21:16:19 +07001158 [] CTRL.receive(tr_ASP_IPA_EV(ASP_IPA_EVENT_UP)) -> value evt {
Pau Espin Pedrol4d0e5e52019-06-07 19:38:28 +02001159 CTRL_CLIENT.send(evt);
1160 }
Vadim Yanitskiya2afacc2020-05-18 21:16:19 +07001161 [] CTRL.receive(tr_ASP_IPA_EV(ASP_IPA_EVENT_DOWN)) {
Pau Espin Pedrol4d0e5e52019-06-07 19:38:28 +02001162 Misc_Helpers.f_shutdown(__BFILE__, __LINE__, fail, "Lost IPA connection!");
1163 }
Vadim Yanitskiya2afacc2020-05-18 21:16:19 +07001164 [] CTRL.receive(tr_ASP_IPA_EV(ASP_IPA_EVENT_ID_ACK)) {}
Pau Espin Pedrol4d0e5e52019-06-07 19:38:28 +02001165#else
1166 [false] CLIENT.receive {}
1167#endif
1168}
1169
Harald Welte2fce7882019-04-15 11:48:05 +02001170/* send a raw (encoded) L3 message over given SCCP connection */
1171private function f_xmit_raw_l3(integer sccp_conn_id, OCT1 dlci, octetstring l3_enc) runs on RAN_Emulation_CT
1172{
1173 select (g_ran_ops.protocol) {
1174#ifdef RAN_EMULATION_BSSAP
1175 case (RAN_PROTOCOL_BSSAP) {
1176 var PDU_BSSAP bssap;
1177 bssap := valueof(ts_BSSAP_DTAP(l3_enc, dlci));
1178 BSSAP.send(ts_BSSAP_DATA_req(sccp_conn_id, bssap));
1179 }
1180#endif
Harald Welte5b027622019-04-14 23:40:17 +02001181#ifdef RAN_EMULATION_RANAP
1182 case (RAN_PROTOCOL_RANAP) {
Vadim Yanitskiyf2c3fa92019-06-20 05:18:15 +07001183 var template (omit) RANAP_IEs.SAPI sapi := omit;
Harald Welte5b027622019-04-14 23:40:17 +02001184 var RANAP_PDU ranap;
Vadim Yanitskiyf2c3fa92019-06-20 05:18:15 +07001185
1186 /* Perform DLCI -> SAPI transformation (x & 0x07) */
1187 if (dlci and4b '07'O == '03'O) {
1188 sapi := sapi_3;
1189 }
1190
1191 ranap := valueof(ts_RANAP_DirectTransfer(l3_enc, sapi := sapi));
Harald Welte5b027622019-04-14 23:40:17 +02001192 RANAP.send(ts_RANAP_DATA_req(sccp_conn_id, ranap));
1193 }
1194#endif
Harald Welte2fce7882019-04-15 11:48:05 +02001195 }
1196}
1197
1198function main(RanOps ops, charstring id) runs on RAN_Emulation_CT {
1199
1200 g_ran_id := id;
1201 g_ran_ops := ops;
1202 f_conn_table_init();
1203 f_expect_table_init();
1204
1205 if (isvalue(ops.sccp_addr_peer) and isvalue(ops.sccp_addr_local)) {
1206 f_sleep(1.0); /* HACK to wait for M3UA/ASP to be ACTIVE */
Harald Welte5b027622019-04-14 23:40:17 +02001207 select (g_ran_ops.protocol) {
1208#ifdef RAN_EMULATION_BSSAP
1209 case (RAN_PROTOCOL_BSSAP) {
1210 f_bssap_reset(ops.sccp_addr_peer, ops.sccp_addr_local);
1211 }
1212#endif
1213#ifdef RAN_EMULATION_RANAP
1214 case (RAN_PROTOCOL_RANAP) {
1215 f_ranap_reset(ops.sccp_addr_peer, ops.sccp_addr_local);
1216 }
1217#endif
1218 }
Harald Welte2fce7882019-04-15 11:48:05 +02001219 }
1220
1221 while (true) {
1222 var RAN_ConnHdlr vc_conn;
1223 var PDU_DTAP_MO dtap_mo;
1224 var PDU_DTAP_MT dtap_mt;
1225 var RAN_ConnHdlr vc_hdlr;
1226 var octetstring l3_info;
1227 var hexstring imsi;
1228 var OCT4 tmsi;
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001229 var integer targetPointCode;
Harald Welte2fce7882019-04-15 11:48:05 +02001230
1231 alt {
1232 [g_ran_ops.protocol == RAN_PROTOCOL_BSSAP] as_main_bssap();
Harald Welte5b027622019-04-14 23:40:17 +02001233 [g_ran_ops.protocol == RAN_PROTOCOL_RANAP] as_main_ranap();
Harald Welte2fce7882019-04-15 11:48:05 +02001234
1235 [g_ran_ops.role_ms] CLIENT.receive(PDU_DTAP_MO:?) -> value dtap_mo sender vc_conn {
1236 var integer idx := f_idx_by_comp(vc_conn);
1237 /* convert from decoded DTAP to encoded DTAP */
1238 var octetstring l3_enc := enc_PDU_ML3_MS_NW(dtap_mo.dtap);
1239 /* patch correct L3 send sequence number N(SD) into l3_enc */
1240 if (dtap_mo.skip_seq_patching == false) {
1241 f_ML3_patch_seq(ConnectionTable[idx], dtap_mo.dtap, l3_enc);
1242 }
1243 f_xmit_raw_l3(ConnectionTable[idx].sccp_conn_id, dtap_mo.dlci, l3_enc);
1244 }
1245
1246 [not g_ran_ops.role_ms] CLIENT.receive(PDU_DTAP_MT:?) -> value dtap_mt sender vc_conn {
1247 var integer idx := f_idx_by_comp(vc_conn);
1248 /* convert from decoded DTAP to encoded DTAP */
1249 var octetstring l3_enc := enc_PDU_ML3_NW_MS(dtap_mt.dtap);
1250 f_xmit_raw_l3(ConnectionTable[idx].sccp_conn_id, dtap_mt.dlci, l3_enc);
1251 }
1252
1253 [] as_main_mgcp();
Pau Espin Pedrol4d0e5e52019-06-07 19:38:28 +02001254 [] as_main_ctrl();
Harald Welte624f9632017-12-16 19:26:04 +01001255
Harald Welte6811d102019-04-14 22:23:14 +02001256 [] PROC.getcall(RAN_register:{?,?}) -> param(l3_info, vc_hdlr) {
Harald Welte624f9632017-12-16 19:26:04 +01001257 f_create_expect(l3_info, vc_hdlr);
Harald Welte6811d102019-04-14 22:23:14 +02001258 PROC.reply(RAN_register:{l3_info, vc_hdlr}) to vc_hdlr;
Harald Welte624f9632017-12-16 19:26:04 +01001259 }
1260
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001261 [] PROC.getcall(RAN_register_handoverRequest:{?,?}) -> param(targetPointCode, vc_hdlr) {
1262 f_create_expect(omit, vc_hdlr, targetPointCode);
1263 PROC.reply(RAN_register_handoverRequest:{targetPointCode, vc_hdlr}) to vc_hdlr;
1264 }
1265
Harald Welte6811d102019-04-14 22:23:14 +02001266 [] PROC.getcall(RAN_register_imsi:{?,?,?}) -> param(imsi, tmsi, vc_hdlr) {
Harald Welte17d21152018-01-27 00:47:11 +01001267 f_create_imsi(imsi, tmsi, vc_hdlr);
Harald Welte6811d102019-04-14 22:23:14 +02001268 PROC.reply(RAN_register_imsi:{imsi, tmsi, vc_hdlr}) to vc_hdlr;
Harald Welte17d21152018-01-27 00:47:11 +01001269 }
1270
1271
Harald Welte365f4ed2017-11-23 00:00:43 +01001272 }
1273 }
1274}
1275
Harald Welte2fce7882019-04-15 11:48:05 +02001276#ifdef RAN_EMULATION_MGCP
Harald Weltec82eef42017-11-24 20:40:12 +01001277private function f_mgcp_ep_extract_cic(charstring inp) return integer {
Harald Welte525a9c12017-11-24 23:40:41 +01001278 var charstring local_part := regexp(inp, "(*)@*", 0);
Harald Weltec82eef42017-11-24 20:40:12 +01001279 return hex2int(str2hex(local_part));
1280
1281}
Harald Welte2fce7882019-04-15 11:48:05 +02001282#endif
Harald Welte365f4ed2017-11-23 00:00:43 +01001283
Harald Welte624f9632017-12-16 19:26:04 +01001284/***********************************************************************
1285 * "Expect" Handling (mapping for expected incoming SCCP connections)
1286 ***********************************************************************/
1287
1288/* data about an expected future incoming connection */
1289type record ExpectData {
1290 /* L3 payload based on which we can match it */
1291 octetstring l3_payload optional,
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001292 integer handoverRequestPointCode optional,
Harald Welte624f9632017-12-16 19:26:04 +01001293 /* component reference for this connection */
Harald Welte6811d102019-04-14 22:23:14 +02001294 RAN_ConnHdlr vc_conn
Harald Welte624f9632017-12-16 19:26:04 +01001295}
1296
1297/* procedure based port to register for incoming connections */
Harald Welte6811d102019-04-14 22:23:14 +02001298signature RAN_register(in octetstring l3, in RAN_ConnHdlr hdlr);
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001299signature RAN_register_handoverRequest(in integer targetPointCode, in RAN_ConnHdlr hdlr);
Harald Welte624f9632017-12-16 19:26:04 +01001300
Harald Welte17d21152018-01-27 00:47:11 +01001301/* procedure based port to register for incoming IMSI/TMSI */
Harald Welte6811d102019-04-14 22:23:14 +02001302signature RAN_register_imsi(in hexstring imsi, in OCT4 tmsi, in RAN_ConnHdlr hdlr);
Harald Welte17d21152018-01-27 00:47:11 +01001303
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001304/* If DTAP happens across other channels (e.g. GSUP), provide manual advancing of the n_sd sequence number */
1305signature RAN_last_n_sd(in RAN_ConnHdlr hdlr, out N_Sd_Array last_n_sd);
1306
1307/* Update conn's n_sd sequence nr after the connection was taken over from elsewhere */
1308signature RAN_continue_after_n_sd(N_Sd_Array last_n_sd, in RAN_ConnHdlr hdlr);
1309
Harald Welte6811d102019-04-14 22:23:14 +02001310type port RAN_PROC_PT procedure {
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001311 inout RAN_register, RAN_register_imsi, RAN_register_handoverRequest, RAN_last_n_sd, RAN_continue_after_n_sd;
Harald Welte624f9632017-12-16 19:26:04 +01001312} with { extension "internal" };
1313
Harald Welte5b027622019-04-14 23:40:17 +02001314#ifdef RAN_EMULATION_BSSAP
Harald Welte624f9632017-12-16 19:26:04 +01001315/* CreateCallback that can be used as create_cb and will use the expectation table */
1316function ExpectedCreateCallback(BSSAP_N_CONNECT_ind conn_ind, charstring id)
Harald Welte6811d102019-04-14 22:23:14 +02001317runs on RAN_Emulation_CT return RAN_ConnHdlr {
1318 var RAN_ConnHdlr ret := null;
Harald Welte624f9632017-12-16 19:26:04 +01001319 var octetstring l3_info;
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001320 var boolean handoverRequest := false;
1321 var integer handoverRequestPointCode;
Harald Welte624f9632017-12-16 19:26:04 +01001322 var integer i;
1323
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001324 if (ischosen(conn_ind.userData.pdu.bssmap.completeLayer3Information)) {
1325 l3_info := conn_ind.userData.pdu.bssmap.completeLayer3Information.layer3Information.layer3info;
1326 log("ExpectedCreateCallback completeLayer3Information");
1327 } else if (ischosen(conn_ind.userData.pdu.bssmap.handoverRequest)) {
1328 handoverRequest := true;
1329 handoverRequestPointCode := bit2int(conn_ind.calledAddress.signPointCode);
1330 log("ExpectedCreateCallback handoverRequest ", handoverRequestPointCode);
1331 } else {
1332 setverdict(fail, "N-CONNECT.ind with L3 != COMPLETE L3 nor a Handover Request");
Daniel Willmanne4ff5372018-07-05 17:35:03 +02001333 mtc.stop;
Harald Welte624f9632017-12-16 19:26:04 +01001334 return ret;
1335 }
Harald Welte624f9632017-12-16 19:26:04 +01001336
1337 for (i := 0; i < sizeof(ExpectTable); i:= i+1) {
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001338 if (handoverRequest) {
1339 log("ExpectTable[", i, "].handoverRequestPointCode = ", ExpectTable[i].handoverRequestPointCode,
1340 " ==? ", handoverRequestPointCode);
1341 if (ExpectTable[i].handoverRequestPointCode == handoverRequestPointCode) {
1342 ret := ExpectTable[i].vc_conn;
1343 log("Found Expect[", i, "] for handoverRequest handled at ", ret);
1344 return ret;
1345 } else {
1346 continue;
1347 }
1348 }
Harald Welte624f9632017-12-16 19:26:04 +01001349 if (not ispresent(ExpectTable[i].l3_payload)) {
1350 continue;
1351 }
1352 if (l3_info == ExpectTable[i].l3_payload) {
1353 ret := ExpectTable[i].vc_conn;
1354 /* release this entry to be used again */
1355 ExpectTable[i].l3_payload := omit;
1356 ExpectTable[i].vc_conn := null;
1357 log("Found Expect[", i, "] for ", l3_info, " handled at ", ret);
1358 /* return the component reference */
1359 return ret;
1360 }
1361 }
1362 setverdict(fail, "Couldn't find Expect for incoming connection ", conn_ind);
Daniel Willmanne4ff5372018-07-05 17:35:03 +02001363 mtc.stop;
Harald Welte624f9632017-12-16 19:26:04 +01001364 return ret;
1365}
Harald Welte5b027622019-04-14 23:40:17 +02001366#endif
1367
1368#ifdef RAN_EMULATION_RANAP
1369/* CreateCallback that can be used as create_cb and will use the expectation table */
1370function RanapExpectedCreateCallback(RANAP_N_CONNECT_ind conn_ind, charstring id)
1371runs on RAN_Emulation_CT return RAN_ConnHdlr {
1372 var RAN_ConnHdlr ret := null;
1373 var template (omit) octetstring l3_info;
1374 var integer i;
1375
1376 l3_info := f_ranap_extract_l3(conn_ind.userData);
1377 if (istemplatekind(l3_info, "omit")) {
1378 setverdict(fail, "N-CONNECT.ind without NAS payload");
1379 mtc.stop;
1380 return ret;
1381 }
1382
1383 for (i := 0; i < sizeof(ExpectTable); i:= i+1) {
1384 if (not ispresent(ExpectTable[i].l3_payload)) {
1385 continue;
1386 }
1387 if (valueof(l3_info) == ExpectTable[i].l3_payload) {
1388 ret := ExpectTable[i].vc_conn;
1389 /* release this entry to be used again */
1390 ExpectTable[i].l3_payload := omit;
1391 ExpectTable[i].vc_conn := null;
1392 log("Found Expect[", i, "] for ", l3_info, " handled at ", ret);
1393 /* return the component reference */
1394 return ret;
1395 }
1396 }
1397 setverdict(fail, "Couldn't find Expect for incoming connection ", conn_ind);
1398 mtc.stop;
1399 return ret;
1400}
1401#endif
Harald Welte624f9632017-12-16 19:26:04 +01001402
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001403private function f_create_expect(template octetstring l3, RAN_ConnHdlr hdlr,
1404 template integer handoverRequestPointCode := omit)
Harald Welte6811d102019-04-14 22:23:14 +02001405runs on RAN_Emulation_CT {
Harald Welte624f9632017-12-16 19:26:04 +01001406 var integer i;
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001407 log("f_create_expect(l3 := ", l3, ", handoverRequest := ", handoverRequestPointCode);
Harald Welte624f9632017-12-16 19:26:04 +01001408 for (i := 0; i < sizeof(ExpectTable); i := i+1) {
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001409 if (not ispresent(ExpectTable[i].l3_payload)
1410 and not ispresent(ExpectTable[i].handoverRequestPointCode)) {
1411 if (ispresent(l3)) {
1412 ExpectTable[i].l3_payload := valueof(l3);
1413 }
1414 if (ispresent(handoverRequestPointCode)) {
1415 ExpectTable[i].handoverRequestPointCode := valueof(handoverRequestPointCode);
1416 }
Harald Welte624f9632017-12-16 19:26:04 +01001417 ExpectTable[i].vc_conn := hdlr;
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001418 if (ispresent(handoverRequestPointCode)) {
1419 log("Created Expect[", i, "] for handoverRequest to be handled at ", hdlr);
1420 } else {
1421 log("Created Expect[", i, "] for ", l3, " to be handled at ", hdlr);
1422 }
Harald Welte624f9632017-12-16 19:26:04 +01001423 return;
1424 }
1425 }
Daniel Willmanne4ff5372018-07-05 17:35:03 +02001426 testcase.stop("No space left in ExpectTable");
Harald Welte624f9632017-12-16 19:26:04 +01001427}
1428
Harald Welte6811d102019-04-14 22:23:14 +02001429private function f_create_imsi(hexstring imsi, OCT4 tmsi, RAN_ConnHdlr hdlr)
1430runs on RAN_Emulation_CT {
Harald Welte17d21152018-01-27 00:47:11 +01001431 for (var integer i := 0; i < sizeof(ImsiTable); i := i+1) {
1432 if (not ispresent(ImsiTable[i].imsi)) {
1433 ImsiTable[i].imsi := imsi;
1434 ImsiTable[i].tmsi := tmsi;
1435 ImsiTable[i].comp_ref := hdlr;
1436 log("Created IMSI[", i, "] for ", imsi, tmsi, " to be handled at ", hdlr);
1437 return;
1438 }
1439 }
Daniel Willmanne4ff5372018-07-05 17:35:03 +02001440 testcase.stop("No space left in ImsiTable");
Harald Welte17d21152018-01-27 00:47:11 +01001441}
1442
1443
Daniel Willmannd47106b2018-01-17 12:20:56 +01001444private function f_expect_table_init()
Harald Welte6811d102019-04-14 22:23:14 +02001445runs on RAN_Emulation_CT {
Daniel Willmannd47106b2018-01-17 12:20:56 +01001446 for (var integer i := 0; i < sizeof(ExpectTable); i := i+1) {
1447 ExpectTable[i].l3_payload := omit;
Neels Hofmeyr0ac63152019-05-07 01:20:17 +02001448 ExpectTable[i].handoverRequestPointCode := omit;
Daniel Willmannd47106b2018-01-17 12:20:56 +01001449 }
1450}
Harald Welte624f9632017-12-16 19:26:04 +01001451
Harald Welte17d21152018-01-27 00:47:11 +01001452/* helper function for clients to register their IMSI/TMSI */
Vadim Yanitskiyae747742020-01-10 00:23:10 +01001453function f_ran_register_imsi(hexstring imsi, template (omit) OCT4 tmsi_or_omit)
Harald Welte6811d102019-04-14 22:23:14 +02001454runs on RAN_ConnHdlr {
Vadim Yanitskiyae747742020-01-10 00:23:10 +01001455 var OCT4 tmsi;
1456
1457 /* Resolve omit to a special reserved value */
1458 if (istemplatekind(tmsi_or_omit, "omit")) {
1459 tmsi := 'FFFFFFFF'O;
1460 } else {
1461 tmsi := valueof(tmsi_or_omit);
1462 }
1463
Harald Welte6811d102019-04-14 22:23:14 +02001464 BSSAP_PROC.call(RAN_register_imsi:{imsi, tmsi, self}) {
1465 [] BSSAP_PROC.getreply(RAN_register_imsi:{?,?,?}) {};
Harald Welte17d21152018-01-27 00:47:11 +01001466 }
1467}
1468
Harald Welte475a2c12019-05-02 19:05:48 +02001469#ifdef RAN_EMULATION_RANAP
1470/* expect a IuReleaseCommand; Confirm that; expect SCCP-level N-DISCONNET.ind */
1471altstep as_iu_release_compl_disc(float t := 5.0) runs on RAN_ConnHdlr {
1472 var RANAP_PDU ranap;
1473 [] BSSAP.receive(tr_RANAP_IuReleaseCommand(?)) {
1474 BSSAP.send(ts_RANAP_IuReleaseComplete);
1475 alt {
1476 [] BSSAP.receive(RAN_Conn_Prim:MSC_CONN_PRIM_DISC_IND) {
1477 setverdict(pass);
1478 }
1479 [] BSSAP.receive {
1480 setverdict(fail, "Unexpected RANAP while waiting for SCCP Release ");
1481 mtc.stop;
1482 }
1483 }
1484 }
1485 [] BSSAP.receive(RANAP_PDU:?) -> value ranap{
1486 setverdict(fail, "Unexpected RANAP while waiting for IuReleaseCommand", ranap);
1487 mtc.stop;
1488 }
1489}
1490#endif
1491
Harald Welte17d21152018-01-27 00:47:11 +01001492
Harald Welte365f4ed2017-11-23 00:00:43 +01001493}