library/SGsAP_Emulation.ttcn

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.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

import from SGsAP_CodecPort all;
import from SGsAP_CodecPort_CtrlFunct all;
import from SGsAP_Types all;
import from SGsAP_Templates all;
import from SCTP_Templates all;
import from Osmocom_Types all;
import from IPL4asp_Types all;
import from DNS_Helpers all;
import from MobileL3_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, PDU_ML3_MS_NW, PDU_ML3_NW_MS;
} with { extension "internal" };

/* global test port e.g. for non-imsi/conn specific messages */
type port SGsAP_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;
	/* test port for unit data messages */
	port SGsAP_PT SGsAP_UNIT;

	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 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_SctpTuple) });
	} 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_SctpTuple) });
	}
	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 PDU_ML3_MS_NW l3_mo;
		var PDU_ML3_NW_MS l3_mt;
		var template IMSI imsi_t;
		var hexstring imsi;
		var SGsAP_RecvFrom mrf;
		var PDU_SGsAP msg;
		var charstring vlr_name, mme_name;

		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));
			}
		/* DTAP/MobileL3 from client (emulated MS): wrap in SGsAP-UL-UD and send */
		[] SGsAP_CLIENT.receive(PDU_ML3_MS_NW:?) -> value l3_mo sender vc_conn {
			var octetstring l3_enc := enc_PDU_ML3_MS_NW(l3_mo);
			imsi := f_imsi_by_comp(vc_conn);
			msg := valueof(ts_SGsAP_UL_UD(imsi, l3_enc));
			SGsAP.send(t_SGsAP_Send(g_sgsap_conn_id, msg));
			}
		[] SGsAP_CLIENT.receive(PDU_ML3_NW_MS:?) -> value l3_mt sender vc_conn {
			var octetstring l3_enc := enc_PDU_ML3_NW_MS(l3_mt);
			imsi := f_imsi_by_comp(vc_conn);
			msg := valueof(ts_SGsAP_DL_UD(imsi, l3_enc));
			SGsAP.send(t_SGsAP_Send(g_sgsap_conn_id, msg));
			}

		/* DTAP/MobileL3 from MSC/VLR to MS wrapped in SGsAP-DL-UD: Extract, decode, forward */
		[] SGsAP.receive(tr_SGsAP_RecvFrom_R(tr_SGsAP_DL_UD(?,?))) -> value mrf {
			var octetstring l3_enc := mrf.msg.sGsAP_DOWNLINK_UNITDATA.nAS_MessageContainer.nAS_MessageContainer;
			imsi := mrf.msg.sGsAP_DOWNLINK_UNITDATA.iMSI.iMSI.digits;
			vc_conn := f_comp_by_imsi(imsi);
			l3_mt := dec_PDU_ML3_NW_MS(l3_enc);
			SGsAP_CLIENT.send(l3_mt) to vc_conn;
			}
		[] SGsAP.receive(tr_SGsAP_RecvFrom_R(tr_SGsAP_UL_UD(?,?))) -> value mrf {
			var octetstring l3_enc := mrf.msg.sGsAP_UPLINK_UNITDATA.nAS_MessageContainer.nAS_MessageContainer;
			imsi := mrf.msg.sGsAP_UPLINK_UNITDATA.iMSI.iMSI.digits;
			l3_mo := dec_PDU_ML3_MS_NW(l3_enc);
			vc_conn := f_comp_by_imsi(imsi);
			SGsAP_CLIENT.send(l3_mo) to vc_conn;
			}


		/* any other SGsAP from MSC/VLR */
		[] 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;
			}
		[] SGsAP_PROC.getcall(SGsAPEM_reset_mme:{?,-}) -> param(mme_name) {
			var octetstring mme_enc, vlr_enc;
			mme_enc := f_enc_dns_hostname(mme_name);
			msg := f_sgsap_xceive(ts_SGsAP_RESET_IND_MME(mme_enc));
			vlr_enc := msg.sGsAP_RESET_ACK.vLR_Name.name;
			vlr_name := f_dec_dns_hostname(vlr_enc);
			SGsAP_PROC.reply(SGsAPEM_reset_mme:{mme_name, vlr_name});
			}
		[] SGsAP_PROC.getcall(SGsAPEM_reset_vlr:{?,-}) -> param(vlr_name) {
			var octetstring mme_enc, vlr_enc;
			vlr_enc := f_enc_dns_hostname(vlr_name);
			msg := f_sgsap_xceive(ts_SGsAP_RESET_IND_VLR(vlr_enc));
			mme_enc := msg.sGsAP_RESET_ACK.mME_Name.name;
			mme_name := f_dec_dns_hostname(mme_enc);
			SGsAP_PROC.reply(SGsAPEM_reset_vlr:{vlr_name, mme_name});
			}


		}

	}
}

/* "Expect" Handling */

type record ExpectData {
	hexstring imsi optional,
	SGsAP_ConnHdlr vc_conn
}

signature SGsAPEM_register(in hexstring imsi, in SGsAP_ConnHdlr hdlr);

signature SGsAPEM_reset_vlr(in charstring vlr_name, out charstring mme_name);
signature SGsAPEM_reset_mme(in charstring mme_name, out charstring vlr_name);

type port SGsAPEM_PROC_PT procedure {
	inout SGsAPEM_register, SGsAPEM_reset_vlr, SGsAPEM_reset_mme;
} with { extension "internal" };

/* Function that can be used as create_cb and will use 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:{?,?}) {};
	}
}

/* client/conn_hdlr side function to use procedure port to send RESET from emulated MME */
function f_sgsap_reset_mme(charstring mme_name) runs on SGsAP_ConnHdlr return charstring {
	var charstring vlr_name;
	SGsAP_PROC.call(SGsAPEM_reset_mme:{mme_name, -}) {
		[] SGsAP_PROC.getreply(SGsAPEM_reset_mme:{mme_name,?}) -> param(vlr_name) {
			return vlr_name;
			};
	}
}

/* client/conn_hdlr side function to use procedure port to send RESET from emulated VLR */
function f_sgsap_reset_vlr(charstring vlr_name) runs on SGsAP_ConnHdlr return charstring {
	var charstring mme_name;
	SGsAP_PROC.call(SGsAPEM_reset_vlr:{vlr_name, -}) {
		[] SGsAP_PROC.getreply(SGsAPEM_reset_vlr:{vlr_name,?}) -> param(mme_name) {
			return mme_name;
			};
	}
}

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;
}


}