Add hnbgw tests
Some tests for osmo-hnbgw with mgw support:
* hnb register
* ranap connect/disconnect
* rab assignment/release
Change-Id: I0a2fb795aec83337eda8d9972e6ff264ead61076
diff --git a/library/RUA_Emulation.ttcn b/library/RUA_Emulation.ttcn
new file mode 100644
index 0000000..2d6291d
--- /dev/null
+++ b/library/RUA_Emulation.ttcn
@@ -0,0 +1,400 @@
+module RUA_Emulation {
+
+/* RUA_Emulation runs on top of Iuh_Emulation. It multiplexes/demultiplexes
+ * the individuao connections, so there can be separate TTCN-3 components
+ * handling each of the connections (one connection per UE).
+ *
+ * The RUA_Emulation.main() function processes RUA messages from the Iuh stack
+ * via the RUA_PT, and dispatches them to the per-connection components.
+ *
+ * Outbound RUA connections are initiated by sending a FIXME primitive to the
+ * RUA_Emulation component.
+ *
+ * For each new inbound connection, the RuaOps.create_cb() is called. It can create
+ * or resolve a TTCN-3 component, and returns a component reference to which that inbound
+ * connection is routed/dispatched.
+ *
+ * If a pre-existing component wants to register to handle future inbound connection,
+ * it can do so by registering an "expect" with the expected RANAP payload.
+
+ * (C) 2022 by 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.
+ */
+
+import from General_Types all;
+import from Osmocom_Types all;
+
+import from Iuh_Emulation all;
+
+import from RUA_Templates all;
+//import from RUA_Constants all;
+import from RUA_PDU_Descriptions all;
+import from RUA_IEs all;
+
+import from RANAP_PDU_Descriptions all;
+//import from RANAP_Constants all;
+import from RANAP_IEs all;
+import from RANAP_Types all;
+import from RANAP_Templates all;
+
+modulepar {
+ integer mp_max_context_id := hex2int('FFFFFF'H);
+}
+
+
+/* General "base class" component definition, of which specific implementations
+ * derive themselves by means of the "extends" feature */
+type component RUA_ConnHdlr {
+ port RUA_Conn_PT RUA;
+}
+
+/* port between individual per-connection components and this dispatcher */
+type port RUA_Conn_PT message {
+ inout RANAP_PDU,
+ RUA_Conn_Req,
+ RUA_Disc_Req,
+ RUA_Disc_Ind;
+} with { extension "internal" };
+
+type record RUA_Conn_Req {
+ boolean ps_domain,
+ RANAP_PDU ranap
+};
+
+type record RUA_Disc_Req {
+ RANAP_PDU ranap,
+ RUA_IEs.Cause cause
+};
+
+type record RUA_Disc_Ind {
+ RUA_IEs.Cause cause
+};
+
+type bitstring ContextId length(24); // with { variant "FIELDLENGTH(24)" };
+
+/* represents a single RANAP connection over RUA */
+type record ConnectionData {
+ RUA_ConnHdlr comp_ref,
+ RUA_IEs.CN_DomainIndicator domain,
+ integer context_id
+}
+
+type component RUA_Emulation_CT {
+ /* port to the bottom side (Iuh) */
+ port RUA_PT RUA;
+
+ /* ports to the upper side (per-connection components) */
+ port RUA_Conn_PT CLIENT;
+
+ /* use 16 as this is also the number of SCCP connections that SCCP_Emulation can handle */
+ var ConnectionData ConnectionTable[16];
+
+ /* pending expected incoming connections */
+ //var ExpectData ExpectTable[8];
+
+ /* tables for mapping inbound unitdata (like paging) */
+ //var ImsiMapping ImsiTable[16];
+
+ /* procedure based port to register for incoming connections */
+ //port RUA_PROC_PT PROC;
+
+ var charstring g_rua_id;
+ var RuaOps g_rua_ops;
+}
+
+type function RanapCreateCallback(ContextId context_id, RUA_IEs.CN_DomainIndicator domain, charstring id)
+runs on RUA_Emulation_CT return RUA_ConnHdlr;
+
+type function RanapUnitdataCallback(RANAP_PDU ranap)
+runs on RUA_Emulation_CT return template RANAP_PDU;
+
+type record RuaOps {
+ RanapCreateCallback create_cb optional,
+ RanapUnitdataCallback unitdata_cb optional
+ //boolean deode_dtap
+ //boolean role_ms
+};
+
+private function f_context_id_known(ContextId context_id)
+runs on RUA_Emulation_CT return boolean {
+ var integer i;
+ for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
+ if (ConnectionTable[i].context_id == bit2int(context_id)){
+ return true;
+ }
+ }
+ return false;
+}
+
+private function f_comp_known(RUA_ConnHdlr client)
+runs on RUA_Emulation_CT return boolean {
+ var integer i;
+ for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
+ if (ConnectionTable[i].comp_ref == client) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* resolve connection ID by component reference */
+private function f_context_id_by_comp(RUA_ConnHdlr client)
+runs on RUA_Emulation_CT return ContextId {
+ for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
+ if (ConnectionTable[i].comp_ref == client) {
+ return int2bit(ConnectionTable[i].context_id, 24);
+ }
+ }
+ setverdict(fail, "RAN Connection table not found by component ", client);
+ mtc.stop;
+}
+
+/* resolve ConnectionTable index component reference */
+private function f_idx_by_comp(RUA_ConnHdlr client)
+runs on RUA_Emulation_CT return integer {
+ for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
+ if (ConnectionTable[i].comp_ref == client) {
+ return i;
+ }
+ }
+ setverdict(fail, "RAN Connection table not found by component ", client);
+ mtc.stop;
+}
+
+private function f_gen_context_id()
+runs on RUA_Emulation_CT return ContextId {
+ var ContextId context_id;
+
+ do {
+ context_id := int2bit(float2int(rnd()*int2float(mp_max_context_id)), 24);
+ } while (f_context_id_known(context_id) == true);
+
+ return context_id;
+}
+
+private function f_conn_table_init()
+runs on RUA_Emulation_CT {
+ for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
+ ConnectionTable[i].comp_ref := null;
+ ConnectionTable[i].context_id := -1;
+ }
+/*
+ for (var integer i := 0; i < sizeof(ImsiTable); i := i+1) {
+ ImsiTable[i].comp_ref := null;
+ ImsiTable[i].imsi := omit;
+ ImsiTable[i].tmsi := 'FFFFFFFF'O;
+ }
+*/
+}
+
+private function f_conn_table_add(RUA_ConnHdlr comp_ref, RUA_IEs.CN_DomainIndicator domain, ContextId context_id)
+runs on RUA_Emulation_CT {
+ var integer int_context_id := bit2int(context_id);
+ for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
+ if (ConnectionTable[i].context_id == -1) {
+ ConnectionTable[i].comp_ref := comp_ref;
+ ConnectionTable[i].domain := domain;
+ ConnectionTable[i].context_id := int_context_id;
+ log("Added conn table entry ", i, comp_ref, int_context_id);
+ return;
+ }
+ }
+ testcase.stop("RUA Connection table full!");
+}
+
+private function f_conn_table_del(ContextId context_id)
+runs on RUA_Emulation_CT {
+ var integer int_context_id := bit2int(context_id);
+ for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
+ if (ConnectionTable[i].context_id == int_context_id) {
+ log("Deleted conn table entry ", i,
+ ConnectionTable[i].comp_ref, int_context_id);
+ ConnectionTable[i].context_id := -1;
+ return
+ }
+ }
+ setverdict(fail, "RUA Connection table attempt to delete non-existant ", int_context_id);
+ mtc.stop;
+}
+
+
+/* resolve component reference by connection ID */
+private function f_comp_by_context_id(ContextId context_id)
+runs on RUA_Emulation_CT return RUA_ConnHdlr {
+ var integer int_context_id := bit2int(context_id);
+ for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
+ if (ConnectionTable[i].context_id == int_context_id) {
+ return ConnectionTable[i].comp_ref;
+ }
+ }
+ setverdict(fail, "RUA Connection table not found by RUA Context ID ", int_context_id);
+ mtc.stop;
+}
+
+private function CommonRanapUnitdataCallback(RANAP_PDU ranap)
+runs on RUA_Emulation_CT return template RANAP_PDU {
+ /* TODO: paging */
+ return g_rua_ops.unitdata_cb.apply(ranap);
+}
+
+private function f_handle_userData_RANAP(RUA_ConnHdlr client, RANAP_PDU ranap)
+runs on RUA_Emulation_CT {
+ /* TODO: L3 decoding, if requested */
+ CLIENT.send(ranap) to client;
+}
+
+
+private altstep as_reset_ack() runs on RUA_Emulation_CT {
+ var RUA_PDU rua_clt;
+ [] RUA.receive(tr_RUA_ConnectionlessTransfer(decmatch tr_RANAP_Reset)) -> value rua_clt {
+ var RANAP_PDU rx := dec_RANAP_PDU(rua_clt.initiatingMessage.value_.connectionlessTransfer.protocolIEs[0].value_.rANAP_Message);
+ var RANAP_IEs.CN_DomainIndicator dom;
+ dom := rx.initiatingMessage.value_.Reset.protocolIEs[1].value_.cN_DomainIndicator;
+ RUA.send(ts_RUA_ConnectionlessTransfer(enc_RANAP_PDU(valueof(ts_RANAP_ResetAck(dom)))));
+ }
+}
+
+private altstep as_main_rua() runs on RUA_Emulation_CT {
+ var RANAP_PDU ranap;
+ var RUA_PDU rua;
+ var octetstring ranap_enc;
+ var ContextId context_id;
+ var RUA_IEs.CN_DomainIndicator domain_ind;
+ var RUA_ConnHdlr vc_conn;
+ var RUA_Conn_Req creq;
+ var RUA_Disc_Req dreq;
+ var RUA_IEs.Cause cause;
+
+ /* RUA -> Client: UNIT-DATA (connectionless RUA) from CN */
+ [] RUA.receive(tr_RUA_ConnectionlessTransfer) -> value rua {
+ ranap := dec_RANAP_PDU(rua.initiatingMessage.value_.connectionlessTransfer.protocolIEs[0].value_.rANAP_Message);
+ var template RANAP_PDU resp;
+ resp := CommonRanapUnitdataCallback(ranap);
+ if (isvalue(resp)) {
+ RUA.send(ts_RUA_ConnectionlessTransfer(enc_RANAP_PDU(valueof(resp))));
+ }
+ }
+
+ /* RUA -> Client: new connection from CN */
+ [] RUA.receive(tr_RUA_Connect) -> value rua {
+ domain_ind := rua.initiatingMessage.value_.connect_.protocolIEs[0].value_.cN_DomainIndicator;
+ context_id := rua.initiatingMessage.value_.connect_.protocolIEs[1].value_.context_ID;
+ ranap_enc := rua.initiatingMessage.value_.connect_.protocolIEs[3].value_.rANAP_Message;
+ ranap := dec_RANAP_PDU(ranap_enc);
+ vc_conn := g_rua_ops.create_cb.apply(context_id, domain_ind, g_rua_id);
+ /* store mapping between client components and RUA contextId */
+ f_conn_table_add(vc_conn, domain_ind, context_id);
+ /* TODO: notify user about incoming connection? */
+ /* handle user payload */
+ f_handle_userData_RANAP(vc_conn, ranap);
+ }
+
+ /* RUA -> Client: connection-oriented data in existing connection */
+ [] RUA.receive(tr_RUA_DirectTransfer) -> value rua {
+ context_id := rua.initiatingMessage.value_.directTransfer.protocolIEs[1].value_.context_ID;
+ vc_conn := f_comp_by_context_id(context_id);
+ ranap_enc := rua.initiatingMessage.value_.directTransfer.protocolIEs[2].value_.rANAP_Message;
+ f_handle_userData_RANAP(vc_conn, dec_RANAP_PDU(ranap_enc));
+ }
+
+ /* RUA -> Client: disconnect of an existing connection */
+ [] RUA.receive(tr_RUA_Disconnect) -> value rua {
+ cause := rua.initiatingMessage.value_.disconnect_.protocolIEs[2].value_.cause;
+ context_id := rua.initiatingMessage.value_.disconnect_.protocolIEs[1].value_.context_ID;
+ vc_conn := f_comp_by_context_id(context_id);
+ /* send contained RANAP message to user */
+ ranap_enc := rua.initiatingMessage.value_.disconnect_.protocolIEs[3].value_.rANAP_Message;
+ f_handle_userData_RANAP(vc_conn, dec_RANAP_PDU(ranap_enc));
+ /* notify user of disconnect */
+ CLIENT.send(RUA_Disc_Ind:{cause});
+ f_conn_table_del(context_id);
+ }
+
+ /* RANAP from client through an existing RANAP connection */
+ [] CLIENT.receive(RANAP_PDU:?) -> value ranap sender vc_conn {
+ var integer idx := f_idx_by_comp(vc_conn);
+ context_id := int2bit(ConnectionTable[idx].context_id, 24);
+ domain_ind := ConnectionTable[idx].domain;
+ RUA.send(ts_RUA_DirectTransfer(domain_ind, context_id, enc_RANAP_PDU(ranap)));
+ }
+
+ /* Disconnect request from client */
+ [] CLIENT.receive(RUA_Disc_Req:?) -> value dreq sender vc_conn {
+ var octetstring enc_ranap := enc_RANAP_PDU(dreq.ranap);
+ var integer idx := f_idx_by_comp(vc_conn);
+ context_id := int2bit(ConnectionTable[idx].context_id, 24);
+ domain_ind := ConnectionTable[idx].domain;
+ RUA.send(ts_RUA_Disconnect(domain_ind, context_id, dreq.cause, enc_ranap));
+ f_conn_table_del(context_id);
+ }
+
+ /* RANAP from client, for a new RANAP connection */
+ [] CLIENT.receive(RUA_Conn_Req:?) -> value creq sender vc_conn {
+ var octetstring enc_ranap := enc_RANAP_PDU(creq.ranap);
+
+ if (f_comp_known(vc_conn) == false) {
+ /* unknown client, create new connection */
+ context_id := f_gen_context_id();
+ if (creq.ps_domain) {
+ domain_ind := ps_domain;
+ } else {
+ domain_ind := cs_domain;
+ }
+
+ f_conn_table_add(vc_conn, domain_ind, context_id);
+ RUA.send(ts_RUA_Connect(domain_ind, context_id, normal_call, enc_ranap));
+ } else {
+ /* known client, send via existing component */
+ context_id := f_context_id_by_comp(vc_conn);
+ RUA.send(ts_RUA_DirectTransfer(domain_ind, context_id, enc_ranap));
+ }
+ }
+
+}
+
+
+
+function f_ranap_reset(RANAP_IEs.CN_DomainIndicator dom) runs on RUA_Emulation_CT {
+ timer T := 5.0;
+
+ var RANAP_PDU tx := valueof(ts_RANAP_Reset(ts_RanapCause_om_intervention,dom));
+ RUA.send(ts_RUA_ConnectionlessTransfer(enc_RANAP_PDU(tx)));
+ T.start;
+ alt {
+ [] RUA.receive(tr_RUA_ConnectionlessTransfer(decmatch tr_RANAP_ResetAck)) {
+ log("RUA-RANAP: Received RESET-ACK in resposne to RESET, we're reay to go!");
+ }
+ [] as_reset_ack();
+ [] RUA.receive { repeat; }
+ [] T.timeout {
+ setverdict(fail, "RUA-RANAP: Timeout waiting for RESET-ACK after sending RESET");
+ mtc.stop;
+ }
+ }
+}
+
+function main(RuaOps ops, charstring id) runs on RUA_Emulation_CT {
+ g_rua_id := id;
+ g_rua_ops := ops;
+ f_conn_table_init();
+ //f_expect_table_init();
+
+ while (true) {
+ alt {
+ [] as_main_rua();
+
+ /*
+ [] PROC.getcall(RUA_Register:{?,?}) -> param(l3_info, vc_hdlr) {
+ f_create_expect(l3_info, vc_hdlr);
+ PROC.reply(RUA_register:{l3_info, vc_hdlr}) to vc_hdlr;
+ }
+ */
+ }
+ }
+}
+
+
+}