module IuUP_Emulation {
/* IuUP emulation, uses the encoding/decoding from IuUP_Types.
*
* rather than running in a separate component with related primitives,
* we just implement a set of functions and data types which can be used
* by other code (such as an RTP endpoint) to implement IuUP support.
*
* (C) 2017 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 Osmocom_Types all;
import from IuUP_Types all;
type record IuUP_RabFlowCombination {
IuUP_RFCI rfci,
/* number of bits per sub-flow */
RecOfU8 sub_flow_bits,
/* IPTI value in number of ITIs for the corresponding RFCI */
uint8_t ipti
};
type record of IuUP_RabFlowCombination IuUP_RabFlowCombinationList;
template (value) IuUP_RabFlowCombination t_IuUP_RFC(IuUP_RFCI rfci, RecOfU8 subflow_bits, uint8_t ipti) := {
rfci := rfci,
sub_flow_bits := subflow_bits,
ipti := ipti
}
template (value) IuUP_RabFlowCombination t_IuUP_RFC_AMR_12_2(IuUP_RFCI rfci) := t_IuUP_RFC(rfci, {81, 103, 60}, 1);
template (value) IuUP_RabFlowCombination t_IuUP_RFC_AMR_SID(IuUP_RFCI rfci) := t_IuUP_RFC(rfci, {39, 0, 0}, 7);
template (value) IuUP_RabFlowCombination t_IuUP_RFC_AMR_NO_DATA(IuUP_RFCI rfci) := t_IuUP_RFC(rfci, {0, 0, 0}, 1);
const IuUP_RabFlowCombinationList c_IuUP_Config_RabFlowCombination_def := {
{
rfci := 0,
sub_flow_bits := {81, 103, 60},
ipti := 1
}, {
rfci := 1,
sub_flow_bits := {39, 0, 0},
ipti := 7
}, {
rfci := 2,
sub_flow_bits := {0, 0, 0},
ipti := 1
}
};
type record IuUP_Config {
/* actively send INIT (true) or only passively respond (false) */
boolean active_init,
boolean data_pdu_type_0,
/* RAB Flow Combinations */
IuUP_RabFlowCombinationList rab_flow_combs
};
template (value) IuUP_Config t_IuUP_Config(boolean active_init := true,
boolean data_pdu_type_0 := true,
template (value) IuUP_RabFlowCombinationList rab_flow_combs :=
c_IuUP_Config_RabFlowCombination_def) := {
active_init := active_init,
data_pdu_type_0 := true,
rab_flow_combs := rab_flow_combs
}
const IuUP_Config c_IuUP_Config_def := {
active_init := true,
data_pdu_type_0 := true,
rab_flow_combs := c_IuUP_Config_RabFlowCombination_def
}
type enumerated IuUP_Em_State {
ST_INIT,
ST_DATA_TRANSFER_READY
};
type record IuUP_Entity {
IuUP_Config cfg,
IuUP_Em_State state,
IuUP_FrameNr tx_next_frame_nr,
IuUP_FrameNr rx_last_frame_nr optional,
IuUP_PDU pending_tx_pdu optional
};
template (value) IuUP_Entity t_IuUP_Entity(template (value) IuUP_Config cfg) := {
cfg := cfg,
state := ST_INIT,
tx_next_frame_nr := 0,
rx_last_frame_nr := omit,
pending_tx_pdu := omit
}
function f_IuUP_Em_rx_decaps(inout IuUP_Entity st, octetstring inp) return octetstring {
var IuUP_PDU pdu := dec_IuUP_PDU(inp);
if (ischosen(pdu.type_0)) {
if (st.cfg.data_pdu_type_0) {
/* FIXME: check header / CRC */
st.rx_last_frame_nr := pdu.type_0.frame_nr;
return pdu.type_0.payload;
} else {
setverdict(fail, "PDU Type 0 received but 1 configured");
mtc.stop;
}
} else if (ischosen(pdu.type_1)) {
if (st.cfg.data_pdu_type_0 == false) {
/* FIXME: check header / CRC */
st.rx_last_frame_nr := pdu.type_1.frame_nr;
return pdu.type_1.payload;
} else {
setverdict(fail, "PDU Type 1 received but 0 configured");
mtc.stop;
}
} else if (ischosen(pdu.type_14)) {
if (match(pdu, tr_IuUP_INIT)) {
if (st.cfg.active_init == true) {
setverdict(fail, "INIT received in ACTIVE role");
mtc.stop;
} else {
/* store an INIT_ACK to be transmitted later */
st.pending_tx_pdu := valueof(ts_IuUP_INIT_ACK(pdu.type_14.frame_nr,
pdu.type_14.u.proc.hdr.iuup_version));
}
} else if (match(pdu, tr_IuUP_INIT_ACK)) {
if (st.cfg.active_init == true) {
log("IuUP INIT_ACK Received");
st.pending_tx_pdu := omit; /* Drop pending Init retrans */
st.state := ST_DATA_TRANSFER_READY;
} else {
setverdict(fail, "INIT_ACK received in PASSIVE role");
mtc.stop;
}
}
return ''O;
} else {
setverdict(fail, "Impossible IuUP PDU decoded from ", inp);
mtc.stop;
}
self.stop;
}
private function f_ts_IuUP_INIT(inout IuUP_Entity st) return IuUP_PDU
{
var IuUP_PDU pdu;
var uint4_t data_pdu_type;
var template (omit) IuUP_InitRfci rfci := omit;
var IuUP_IPTI_List IPTIs := {};
var uint4_t num_rfci := lengthof(st.cfg.rab_flow_combs);
if (st.cfg.data_pdu_type_0 == true) {
data_pdu_type := 0;
} else {
data_pdu_type := 1;
}
/* Build RFCI list: */
for (var integer remain := num_rfci; remain > 0; remain := remain - 1) {
var IuUP_RabFlowCombination comb := st.cfg.rab_flow_combs[remain - 1];
var boolean lri := false;
if (remain == num_rfci) {
lri := true;
}
rfci := ts_IuUP_InitRfci(lri, false, comb.rfci, comb.sub_flow_bits, omit, rfci)
}
/* Build IPTI list: */
for (var integer i := 0; i < num_rfci; i := i + 1) {
IPTIs := IPTIs & { st.cfg.rab_flow_combs[i].ipti };
}
template (value) IuUP_PDU14_ProcSending_INIT tpl := ts_IuUP_PDU14_ProcSending_INIT(
ti := true,
subflows_per_rfci := num_rfci,
chain_ind := false,
rfci := rfci,
IPTIs := IPTIs,
versions_supported := '0000000000000001'B,
data_pdu_type := data_pdu_type
);
pdu := valueof(ts_IuUP_INIT(tpl));
return pdu;
}
function f_IuUP_Em_tx_encap(inout IuUP_Entity st, in octetstring payload) return octetstring {
var IuUP_PDU pdu;
select (st.state) {
case (ST_INIT) {
if (st.cfg.active_init) {
if (not isvalue(st.pending_tx_pdu)) {
/* send INIT */
pdu := f_ts_IuUP_INIT(st);
st.pending_tx_pdu := pdu;
} /* else: wait for INIT-ACK return ''O at the end */
} else {
/* wait for INIT */
if (isvalue(st.pending_tx_pdu)) {
/* we're waiting to transmit the INIT_ACK in response to an
* init (passive) */
pdu := st.pending_tx_pdu;
st.pending_tx_pdu := omit;
st.state := ST_DATA_TRANSFER_READY;
}
}
}
case (ST_DATA_TRANSFER_READY) {
if (st.cfg.data_pdu_type_0) {
pdu := valueof(ts_IuUP_Type0(st.tx_next_frame_nr, 0, payload));
} else {
pdu := valueof(ts_IuUP_Type1(st.tx_next_frame_nr, 0, payload));
}
st.tx_next_frame_nr := (st.tx_next_frame_nr + 1) mod 16;
}
}
if (isvalue(pdu)) {
return f_enc_IuUP_PDU(pdu);
} else {
return ''O;
}
}
}