ttcn3
/
osmo-ttcn3-hacks
mirror of https://gerrit.osmocom.org/osmo-ttcn3-hacks
10
0
Fork 1
Code Issues Releases Wiki Activity

Add SGsAP_CodecPort + SGsAP_Emulation module 

Change-Id: I530f8f444d1c7ea0bf11d510da7b97f64a2039f5
This commit is contained in:
Harald Welte 2018-10-09 09:20:45 +02:00
parent a07cfd909c
commit af5bce4f97
5 changed files with 591 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
library/SGsAP_CodecPort.ttcn Normal file
View File

@ -0,0 +1,72 @@
module SGsAP_CodecPort {
/* Simple SGsAP Codec Port, translating between raw SCTP primitives with
* octetstring payload towards the IPL4asp provider, and SGsAP primitives
* which carry the decoded SGsAP data types as payload.
*
* (C) 2018 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 IPL4asp_PortType all;
import from IPL4asp_Types all;
import from SGsAP_Types all;
type record SGsAP_RecvFrom {
ConnectionId connId,
HostName remName,
PortNumber remPort,
HostName locName,
PortNumber locPort,
PDU_SGsAP msg
};
template SGsAP_RecvFrom t_SGsAP_RecvFrom(template PDU_SGsAP msg) := {
connId := ?,
remName := ?,
remPort := ?,
locName := ?,
locPort := ?,
msg := msg
}
type record SGsAP_Send {
ConnectionId connId,
PDU_SGsAP msg
}
template SGsAP_Send t_SGsAP_Send(template ConnectionId connId, template PDU_SGsAP msg) := {
connId := connId,
msg := msg
}
private function IPL4_to_SGsAP_RecvFrom(in ASP_RecvFrom pin, out SGsAP_RecvFrom pout) {
pout.connId := pin.connId;
pout.remName := pin.remName;
pout.remPort := pin.remPort;
pout.locName := pin.locName;
pout.locPort := pin.locPort;
pout.msg := dec_PDU_SGsAP(pin.msg);
} with { extension "prototype(fast)" };
private function SGsAP_to_IPL4_Send(in SGsAP_Send pin, out ASP_Send pout) {
pout.connId := pin.connId;
pout.proto := { sctp := {} };
pout.msg := enc_PDU_SGsAP(pin.msg);
} with { extension "prototype(fast)" };
type port SGsAP_CODEC_PT message {
out SGsAP_Send;
in SGsAP_RecvFrom,
ASP_ConnId_ReadyToRelease,
ASP_Event;
} with { extension "user IPL4asp_PT
out(SGsAP_Send -> ASP_Send:function(SGsAP_to_IPL4_Send))
in(ASP_RecvFrom -> SGsAP_RecvFrom: function(IPL4_to_SGsAP_RecvFrom);
ASP_ConnId_ReadyToRelease -> ASP_ConnId_ReadyToRelease: simple;
ASP_Event -> ASP_Event: simple)"
}
}

44
library/SGsAP_CodecPort_CtrlFunct.ttcn Normal file
View File

@ -0,0 +1,44 @@
module SGsAP_CodecPort_CtrlFunct {
import from SGsAP_CodecPort all;
import from IPL4asp_Types all;
external function f_IPL4_listen(
inout SGsAP_CODEC_PT portRef,
in HostName locName,
in PortNumber locPort,
in ProtoTuple proto,
in OptionList options := {}
) return Result;
external function f_IPL4_connect(
inout SGsAP_CODEC_PT portRef,
in HostName remName,
in PortNumber remPort,
in HostName locName,
in PortNumber locPort,
in ConnectionId connId,
in ProtoTuple proto,
in OptionList options := {}
) return Result;
external function f_IPL4_close(
inout SGsAP_CODEC_PT portRef,
in ConnectionId id,
in ProtoTuple proto := { unspecified := {} }
) return Result;
external function f_IPL4_setUserData(
inout SGsAP_CODEC_PT portRef,
in ConnectionId id,
in UserData userData
) return Result;
external function f_IPL4_getUserData(
inout SGsAP_CODEC_PT portRef,
in ConnectionId id,
out UserData userData
) return Result;
}

56
library/SGsAP_CodecPort_CtrlFunctDef.cc Normal file
View File

@ -0,0 +1,56 @@
#include "IPL4asp_PortType.hh"
#include "SGsAP_CodecPort.hh"
#include "IPL4asp_PT.hh"
namespace SGsAP__CodecPort__CtrlFunct {
IPL4asp__Types::Result f__IPL4__listen(
SGsAP__CodecPort::SGsAP__CODEC__PT& portRef,
const IPL4asp__Types::HostName& locName,
const IPL4asp__Types::PortNumber& locPort,
const IPL4asp__Types::ProtoTuple& proto,
const IPL4asp__Types::OptionList& options)
{
return f__IPL4__PROVIDER__listen(portRef, locName, locPort, proto, options);
}
IPL4asp__Types::Result f__IPL4__connect(
SGsAP__CodecPort::SGsAP__CODEC__PT& portRef,
const IPL4asp__Types::HostName& remName,
const IPL4asp__Types::PortNumber& remPort,
const IPL4asp__Types::HostName& locName,
const IPL4asp__Types::PortNumber& locPort,
const IPL4asp__Types::ConnectionId& connId,
const IPL4asp__Types::ProtoTuple& proto,
const IPL4asp__Types::OptionList& options)
{
return f__IPL4__PROVIDER__connect(portRef, remName, remPort,
locName, locPort, connId, proto, options);
}
IPL4asp__Types::Result f__IPL4__close(
SGsAP__CodecPort::SGsAP__CODEC__PT& portRef,
const IPL4asp__Types::ConnectionId& connId,
const IPL4asp__Types::ProtoTuple& proto)
{
return f__IPL4__PROVIDER__close(portRef, connId, proto);
}
IPL4asp__Types::Result f__IPL4__setUserData(
SGsAP__CodecPort::SGsAP__CODEC__PT& portRef,
const IPL4asp__Types::ConnectionId& connId,
const IPL4asp__Types::UserData& userData)
{
return f__IPL4__PROVIDER__setUserData(portRef, connId, userData);
}
IPL4asp__Types::Result f__IPL4__getUserData(
SGsAP__CodecPort::SGsAP__CODEC__PT& portRef,
const IPL4asp__Types::ConnectionId& connId,
IPL4asp__Types::UserData& userData)
{
return f__IPL4__PROVIDER__getUserData(portRef, connId, userData);
}
}

418
library/SGsAP_Emulation.ttcn Normal file
View File

@ -0,0 +1,418 @@
module SGsAP_Emulation {
/* SGsAP Emulation, runs on top of SGsAP_CodecPort. It multiplexes/demultiplexes
* the individual IMSIs/subscribers, so there can be separate TTCN-3 components handling
* each of them.
*
* The SGsAP_Emulation.main() function processes SGsAP primitives from the SGsAP
* socket via the SGsAP_CodecPort, and dispatches them to the per-IMSI components.
*
* For each new IMSI, the SgsapOps.create_cb() is called. It can create
* or resolve a TTCN-3 component, and returns a component reference to which that IMSI
* is routed/dispatched.
*
* If a pre-existing component wants to register to handle a future inbound IMSI, it can
* do so by registering an "expect" with the expected IMSI.
*
* Inbound SGsAP messages without IMSI (such as RESET-IND/ACK) are dispatched to
* the SgsapOps.unitdata_cb() callback, which is registered with an argument to the
* main() function below.
*
* (C) 2018 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 SGsAP_CodecPort all;
import from SGsAP_CodecPort_CtrlFunct all;
import from SGsAP_Types all;
import from SGsAP_Templates all;
import from Osmocom_Types all;
import from IPL4asp_Types all;
type component SGsAP_ConnHdlr {
port SGsAP_Conn_PT SGsAP;
/* procedure based port to register for incoming connections */
port SGsAPEM_PROC_PT SGsAP_PROC;
}
/* port between individual per-connection components and this dispatcher */
type port SGsAP_Conn_PT message {
inout PDU_SGsAP;
} with { extension "internal" };
/* represents a single SGsAP Association */
type record AssociationData {
SGsAP_ConnHdlr comp_ref,
hexstring imsi optional
};
type component SGsAP_Emulation_CT {
/* Port facing to the UDP SUT */
port SGsAP_CODEC_PT SGsAP;
/* All SGsAP_ConnHdlr SGsAP ports connect here
* SGsAP_Emulation_CT.main needs to figure out what messages
* to send where with CLIENT.send() to vc_conn */
port SGsAP_Conn_PT SGsAP_CLIENT;
/* currently tracked connections */
var AssociationData SgsapAssociationTable[16];
/* pending expected CRCX */
var ExpectData SgsapExpectTable[8];
/* procedure based port to register for incoming connections */
port SGsAPEM_PROC_PT SGsAP_PROC;
var charstring g_sgsap_id;
var integer g_sgsap_conn_id := -1;
}
type function SGsAPCreateCallback(PDU_SGsAP msg, hexstring imsi, charstring id)
runs on SGsAP_Emulation_CT return SGsAP_ConnHdlr;
type function SGsAPUnitdataCallback(PDU_SGsAP msg)
runs on SGsAP_Emulation_CT return template PDU_SGsAP;
type record SGsAPOps {
SGsAPCreateCallback create_cb,
SGsAPUnitdataCallback unitdata_cb
}
type record SGsAP_conn_parameters {
HostName remote_ip,
PortNumber remote_sctp_port,
HostName local_ip,
PortNumber local_sctp_port
}
function tr_SGsAP_RecvFrom_R(template PDU_SGsAP msg)
runs on SGsAP_Emulation_CT return template SGsAP_RecvFrom {
var template SGsAP_RecvFrom mrf := {
connId := g_sgsap_conn_id,
remName := ?,
remPort := ?,
locName := ?,
locPort := ?,
msg := msg
}
return mrf;
}
private function f_imsi_known(hexstring imsi)
runs on SGsAP_Emulation_CT return boolean {
var integer i;
for (i := 0; i < sizeof(SgsapAssociationTable); i := i+1) {
if (SgsapAssociationTable[i].imsi == imsi) {
return true;
}
}
return false;
}
private function f_comp_known(SGsAP_ConnHdlr client)
runs on SGsAP_Emulation_CT return boolean {
var integer i;
for (i := 0; i < sizeof(SgsapAssociationTable); i := i+1) {
if (SgsapAssociationTable[i].comp_ref == client) {
return true;
}
}
return false;
}
private function f_comp_by_imsi(hexstring imsi)
runs on SGsAP_Emulation_CT return SGsAP_ConnHdlr {
var integer i;
for (i := 0; i < sizeof(SgsapAssociationTable); i := i+1) {
if (SgsapAssociationTable[i].imsi == imsi) {
return SgsapAssociationTable[i].comp_ref;
}
}
setverdict(fail, "SGsAP Association Table not found by IMSI", imsi);
mtc.stop;
}
private function f_imsi_by_comp(SGsAP_ConnHdlr client)
runs on SGsAP_Emulation_CT return hexstring {
var integer i;
for (i := 0; i < sizeof(SgsapAssociationTable); i := i+1) {
if (SgsapAssociationTable[i].comp_ref == client) {
return SgsapAssociationTable[i].imsi;
}
}
setverdict(fail, "SGsAP Association Table not found by component ", client);
mtc.stop;
}
private function f_imsi_table_add(SGsAP_ConnHdlr comp_ref, hexstring imsi)
runs on SGsAP_Emulation_CT {
var integer i;
for (i := 0; i < sizeof(SgsapAssociationTable); i := i+1) {
if (not isvalue(SgsapAssociationTable[i].imsi)) {
SgsapAssociationTable[i].imsi := imsi;
SgsapAssociationTable[i].comp_ref := comp_ref;
return;
}
}
testcase.stop("SGsAP Association Table full!");
}
private function f_imsi_table_del(SGsAP_ConnHdlr comp_ref, hexstring imsi)
runs on SGsAP_Emulation_CT {
var integer i;
for (i := 0; i < sizeof(SgsapAssociationTable); i := i+1) {
if (SgsapAssociationTable[i].comp_ref == comp_ref and
SgsapAssociationTable[i].imsi == imsi) {
SgsapAssociationTable[i].imsi := omit;
SgsapAssociationTable[i].comp_ref := null;
return;
}
}
setverdict(fail, "SGsAP Association Table: Couldn't find to-be-deleted entry!");
mtc.stop;
}
private function f_imsi_table_init()
runs on SGsAP_Emulation_CT {
for (var integer i := 0; i < sizeof(SgsapAssociationTable); i := i+1) {
SgsapAssociationTable[i].comp_ref := null;
SgsapAssociationTable[i].imsi := omit;
}
}
private function f_SGsAP_get_imsi(PDU_SGsAP pdu) return template (omit) IMSI
{
if (ischosen(pdu.sGsAP_ALERT_ACK)) {
return pdu.sGsAP_ALERT_ACK.iMSI;
} else if (ischosen(pdu.sGsAP_ALERT_REJECT)) {
return pdu.sGsAP_ALERT_REJECT.iMSI;
} else if (ischosen(pdu.sGsAP_ALERT_REQUEST)) {
return pdu.sGsAP_ALERT_REQUEST.iMSI;
} else if (ischosen(pdu.sGsAP_DOWNLINK_UNITDATA)) {
return pdu.sGsAP_DOWNLINK_UNITDATA.iMSI;
} else if (ischosen(pdu.sGsAP_EPS_DETACH_ACK)) {
return pdu.sGsAP_EPS_DETACH_ACK.iMSI;
} else if (ischosen(pdu.sGsAP_EPS_DETACH_INDICATION)) {
return pdu.sGsAP_EPS_DETACH_INDICATION.iMSI;
} else if (ischosen(pdu.sGsAP_IMSI_DETACH_ACK)) {
return pdu.sGsAP_IMSI_DETACH_ACK.iMSI;
} else if (ischosen(pdu.sGsAP_IMSI_DETACH_INDICATION)) {
return pdu.sGsAP_IMSI_DETACH_INDICATION.iMSI;
} else if (ischosen(pdu.sGsAP_LOCATION_UPDATE_ACCEPT)) {
return pdu.sGsAP_LOCATION_UPDATE_ACCEPT.iMSI;
} else if (ischosen(pdu.sGsAP_LOCATION_UPDATE_REJECT)) {
return pdu.sGsAP_LOCATION_UPDATE_REJECT.iMSI;
} else if (ischosen(pdu.sGsAP_LOCATION_UPDATE_REQUEST)) {
return pdu.sGsAP_LOCATION_UPDATE_REQUEST.iMSI;
} else if (ischosen(pdu.sGsAP_MM_INFORMATION_REQUEST)) {
return pdu.sGsAP_MM_INFORMATION_REQUEST.iMSI;
} else if (ischosen(pdu.sGsAP_PAGING_REJECT)) {
return pdu.sGsAP_PAGING_REJECT.iMSI;
} else if (ischosen(pdu.sGsAP_PAGING_REQUEST)) {
return pdu.sGsAP_PAGING_REQUEST.iMSI;
} else if (ischosen(pdu.sGsAP_SERVICE_REQUEST)) {
return pdu.sGsAP_SERVICE_REQUEST.iMSI;
} else if (ischosen(pdu.sGsAP_STATUS)) {
return pdu.sGsAP_STATUS.iMSI;
} else if (ischosen(pdu.sGsAP_TMSI_REALLOCATION_COMPLETE)) {
return pdu.sGsAP_TMSI_REALLOCATION_COMPLETE.iMSI;
} else if (ischosen(pdu.sGsAP_UE_ACTIVITY_INDICATION)) {
return pdu.sGsAP_UE_ACTIVITY_INDICATION.iMSI;
} else if (ischosen(pdu.sGsAP_UE_UNREACHABLE)) {
return pdu.sGsAP_UE_UNREACHABLE.iMSI;
} else if (ischosen(pdu.sGsAP_UPLINK_UNITDATA)) {
return pdu.sGsAP_UPLINK_UNITDATA.iMSI;
} else if (ischosen(pdu.sGsAP_RELEASE_REQUEST)) {
return pdu.sGsAP_RELEASE_REQUEST.iMSI;
} else if (ischosen(pdu.sGsAP_SERVICE_ABORT_REQUEST)) {
return pdu.sGsAP_SERVICE_ABORT_REQUEST.iMSI;
} else if (ischosen(pdu.sGsAP_MO_CSFB_INDICATION)) {
return pdu.sGsAP_MO_CSFB_INDICATION.iMSI;
}
return omit;
}
private template (value) SctpTuple ts_SCTP(template (omit) integer ppid := omit) := {
sinfo_stream := omit,
sinfo_ppid := ppid,
remSocks := omit,
assocId := omit
};
private template PortEvent tr_SctpAssocChange := {
sctpEvent := {
sctpAssocChange := ?
}
}
private template PortEvent tr_SctpPeerAddrChange := {
sctpEvent := {
sctpPeerAddrChange := ?
}
}
private function f_sgsap_xceive(template (value) PDU_SGsAP tx,
template PDU_SGsAP rx_t := ?)
runs on SGsAP_Emulation_CT return PDU_SGsAP {
timer T := 10.0;
var SGsAP_RecvFrom mrf;
SGsAP.send(t_SGsAP_Send(g_sgsap_conn_id, tx));
alt {
[] SGsAP.receive(tr_SGsAP_RecvFrom_R(rx_t)) -> value mrf { }
[] SGsAP.receive(tr_SctpAssocChange) { repeat; }
[] SGsAP.receive(tr_SctpPeerAddrChange) { repeat; }
[] T.timeout {
setverdict(fail, "Timeout waiting for ", rx_t);
mtc.stop;
}
}
return mrf.msg;
}
function main(SGsAPOps ops, SGsAP_conn_parameters p, charstring id) runs on SGsAP_Emulation_CT {
var Result res;
g_sgsap_id := id;
f_imsi_table_init();
f_expect_table_init();
map(self:SGsAP, system:SGsAP_CODEC_PT);
if (p.remote_sctp_port == -1) {
res := SGsAP_CodecPort_CtrlFunct.f_IPL4_listen(SGsAP, p.local_ip, p.local_sctp_port, { sctp := valueof(ts_SCTP) });
} else {
res := SGsAP_CodecPort_CtrlFunct.f_IPL4_connect(SGsAP, p.remote_ip, p.remote_sctp_port,
p.local_ip, p.local_sctp_port, -1, { sctp := valueof(ts_SCTP) });
}
if (not ispresent(res.connId)) {
setverdict(fail, "Could not connect SGsAP socket, check your configuration");
mtc.stop;
}
g_sgsap_conn_id := res.connId;
while (true) {
var SGsAP_ConnHdlr vc_conn;
var template IMSI imsi_t;
var hexstring imsi;
var SGsAP_RecvFrom mrf;
var PDU_SGsAP msg;
alt {
/* SGsAP from client */
[] SGsAP_CLIENT.receive(PDU_SGsAP:?) -> value msg sender vc_conn {
/* Pass message through */
/* TODO: check which ConnectionID client has allocated + store in table? */
SGsAP.send(t_SGsAP_Send(g_sgsap_conn_id, msg));
}
[] SGsAP.receive(tr_SGsAP_RecvFrom_R(?)) -> value mrf {
imsi_t := f_SGsAP_get_imsi(mrf.msg);
if (isvalue(imsi_t)) {
imsi := valueof(imsi_t.iMSI.digits);
if (f_imsi_known(imsi)) {
vc_conn := f_comp_by_imsi(imsi);
SGsAP_CLIENT.send(mrf.msg) to vc_conn;
} else {
vc_conn := ops.create_cb.apply(mrf.msg, imsi, id);
f_imsi_table_add(vc_conn, imsi);
SGsAP_CLIENT.send(mrf.msg) to vc_conn;
}
} else {
/* message contained no IMSI; is not IMSI-oriented */
var template PDU_SGsAP resp := ops.unitdata_cb.apply(mrf.msg);
if (isvalue(resp)) {
SGsAP.send(t_SGsAP_Send(g_sgsap_conn_id, valueof(resp)));
}
}
}
[] SGsAP.receive(tr_SctpAssocChange) { }
[] SGsAP.receive(tr_SctpPeerAddrChange) { }
[] SGsAP_PROC.getcall(SGsAPEM_register:{?,?}) -> param(imsi, vc_conn) {
f_create_expect(imsi, vc_conn);
SGsAP_PROC.reply(SGsAPEM_register:{imsi, vc_conn}) to vc_conn;
}
}
}
}
/* "Expect" Handling */
type record ExpectData {
hexstring imsi optional,
SGsAP_ConnHdlr vc_conn
}
signature SGsAPEM_register(in hexstring imsi, in SGsAP_ConnHdlr hdlr);
type port SGsAPEM_PROC_PT procedure {
inout SGsAPEM_register;
} with { extension "internal" };
/* Function that can be used as create_cb and will usse the expect table */
function ExpectedCreateCallback(PDU_SGsAP msg, hexstring imsi, charstring id)
runs on SGsAP_Emulation_CT return SGsAP_ConnHdlr {
var SGsAP_ConnHdlr ret := null;
var integer i;
for (i := 0; i < sizeof(SgsapExpectTable); i := i+1) {
if (not ispresent(SgsapExpectTable[i].imsi)) {
continue;
}
if (imsi == SgsapExpectTable[i].imsi) {
ret := SgsapExpectTable[i].vc_conn;
/* Release this entry */
SgsapExpectTable[i].imsi := omit;
SgsapExpectTable[i].vc_conn := null;
log("Found Expect[", i, "] for ", msg, " handled at ", ret);
return ret;
}
}
setverdict(fail, "Couldn't find Expect for ", msg);
mtc.stop;
}
private function f_create_expect(hexstring imsi, SGsAP_ConnHdlr hdlr)
runs on SGsAP_Emulation_CT {
var integer i;
/* Check an entry like this is not already presnt */
for (i := 0; i < sizeof(SgsapExpectTable); i := i+1) {
if (imsi == SgsapExpectTable[i].imsi) {
setverdict(fail, "IMSI already present", imsi);
mtc.stop;
}
}
for (i := 0; i < sizeof(SgsapExpectTable); i := i+1) {
if (not ispresent(SgsapExpectTable[i].imsi)) {
SgsapExpectTable[i].imsi := imsi;
SgsapExpectTable[i].vc_conn := hdlr;
log("Created Expect[", i, "] for ", imsi, " to be handled at ", hdlr);
return;
}
}
testcase.stop("No space left in SgsapExpectTable")
}
/* client/conn_hdlr side function to use procedure port to create expect in emulation */
function f_create_sgsap_expect(hexstring imsi) runs on SGsAP_ConnHdlr {
SGsAP_PROC.call(SGsAPEM_register:{imsi, self}) {
[] SGsAP_PROC.getreply(SGsAPEM_register:{?,?}) {};
}
}
private function f_expect_table_init()
runs on SGsAP_Emulation_CT {
var integer i;
for (i := 0; i < sizeof(SgsapExpectTable); i := i + 1) {
SgsapExpectTable[i].imsi := omit;
}
}
function DummyUnitdataCallback(PDU_SGsAP msg)
runs on SGsAP_Emulation_CT return template PDU_SGsAP {
log("Ignoring SGsAP ", msg);
return omit;
}
}

2
regen-makefile.sh
View File

@ -29,7 +29,7 @@ sed -i -e 's/LDFLAGS = /LDFLAGS = -L \/usr\/lib\/titan /' Makefile
# The -DMAKEDEPEND_RUN is a workaround for Debian packaging issue,
# see https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=879816 for details
sed -i -e 's/CPPFLAGS = -D$(PLATFORM) -I$(TTCN3_DIR)\/include/CPPFLAGS = -D$(PLATFORM) -DMAKEDEPEND_RUN -I$(TTCN3_DIR)\/include -I\/usr\/include\/titan/' Makefile
sed -i -e 's/CPPFLAGS = -D$(PLATFORM) -I$(TTCN3_DIR)\/include/CPPFLAGS = -D$(PLATFORM) -DMAKEDEPEND_RUN -DUSE_SCTP -I$(TTCN3_DIR)\/include -I\/usr\/include\/titan/' Makefile
if [ "x$CPPFLAGS_TTCN3" != "x" ]; then
sed -i -e 's/CPPFLAGS_TTCN3 =/CPPFLAGS_TTCN3 = '"$CPPFLAGS_TTCN3"'/' Makefile