# 0 "RAN_Emulation.ttcnpp"
# 0 "<built-in>"
# 0 "<command-line>"
# 1 "RAN_Emulation.ttcnpp"
module RAN_Emulation {
# 33 "RAN_Emulation.ttcnpp"
import from General_Types all;
import from Osmocom_Types all;
import from SCCP_Emulation all;
import from SCCPasp_Types all;
import from IPA_Emulation all;
import from MobileL3_Types all;
import from Misc_Helpers all;
# 58 "RAN_Emulation.ttcnpp"
import from RANAP_CodecPort all;
import from RANAP_PDU_Descriptions all;
import from RANAP_PDU_Contents all;
import from RANAP_Constants all;
import from RANAP_IEs all;
import from RANAP_Templates all;




type component RAN_ConnHdlr {

 port RAN_Conn_PT RAN_CONN;

 port RAN_PROC_PT RAN_CONN_PROC;
}


type record MSC_CONN_PRIM_CONNECT_RES {
};


type record MSC_CONN_PRIM_DISC_IND {
};


type record MSC_CONN_PRIM_DISC_REQ {
 SCCP_PAR_Reason reason
};


type record MSC_CONN_PRIM_CONF_IND {
};


type union RAN_Conn_Prim {
 MSC_CONN_PRIM_CONNECT_RES connect_res,
 MSC_CONN_PRIM_DISC_IND disc_ind,
 MSC_CONN_PRIM_DISC_REQ disc_req,
 MSC_CONN_PRIM_CONF_IND conf_ind
}

template (present) RAN_Conn_Prim tr_MSC_CONN_PRIM_CONNECT_RES := {
 connect_res := ?
}
template (value) RAN_Conn_Prim ts_MSC_CONN_PRIM_CONNECT_RES := {
 connect_res := {}
}

template (present) RAN_Conn_Prim tr_MSC_CONN_PRIM_DISC_IND := {
 disc_ind := ?
}
template (value) RAN_Conn_Prim ts_MSC_CONN_PRIM_DISC_IND := {
 disc_ind := {}
}

template (present) RAN_Conn_Prim tr_MSC_CONN_PRIM_DISC_REQ := {
 disc_req := ?
}
template (value) RAN_Conn_Prim ts_MSC_CONN_PRIM_DISC_REQ(template (value) SCCP_PAR_Reason reason := 0) := {
 disc_req := {
  reason := reason
 }
}

template (present) RAN_Conn_Prim tr_MSC_CONN_PRIM_CONF_IND := {
 conf_ind := ?
}
template (value) RAN_Conn_Prim ts_MSC_CONN_PRIM_CONF_IND := {
 conf_ind := {}
}

type enumerated RAN_Transport {
 BSSAP_TRANSPORT_AoIP,
 BSSAP_TRANSPORT_SCCPlite,
 RANAP_TRANSPORT_IuCS
};


type record PDU_DTAP_MO {
 OCT1 dlci optional,
 boolean skip_seq_patching optional,
 PDU_ML3_MS_NW dtap
}


type record PDU_DTAP_MT {
 OCT1 dlci optional,
 PDU_ML3_NW_MS dtap
}

type record PDU_DTAP_PS_MO {
 OCT1 dlci optional,
 boolean skip_seq_patching optional,
 PDU_L3_MS_SGSN dtap
}

type record PDU_DTAP_PS_MT {
 OCT1 dlci optional,
 PDU_L3_SGSN_MS dtap
}

template PDU_DTAP_MT ts_PDU_DTAP_MT(template PDU_ML3_NW_MS dtap, template OCT1 dlci := omit) := {
 dlci := dlci,
 dtap := dtap
}

template PDU_DTAP_MO ts_PDU_DTAP_MO(template PDU_ML3_MS_NW dtap, template OCT1 dlci := '00'O, boolean skip_seq_patching := false) := {
 dlci := dlci,
 skip_seq_patching := skip_seq_patching,
 dtap := dtap
}

template PDU_DTAP_MT tr_PDU_DTAP_MT(template PDU_ML3_NW_MS dtap, template OCT1 dlci := *) := {
 dlci := dlci,
 dtap := dtap
}

template PDU_DTAP_MO tr_PDU_DTAP_MO(template PDU_ML3_MS_NW dtap, template OCT1 dlci := *) := {
 dlci := dlci,
 skip_seq_patching := ?,
 dtap := dtap
}

template (value) PDU_DTAP_PS_MT ts_PDU_DTAP_PS_MT(template (value) PDU_L3_SGSN_MS dtap, template (omit) OCT1 dlci := omit) := {
 dlci := dlci,
 dtap := dtap
}

template (value) PDU_DTAP_PS_MO ts_PDU_DTAP_PS_MO(template (value) PDU_L3_MS_SGSN dtap, template (value) OCT1 dlci := '00'O,
        boolean skip_seq_patching := false) := {
 dlci := dlci,
 skip_seq_patching := skip_seq_patching,
 dtap := dtap
}

template PDU_DTAP_PS_MT tr_PDU_DTAP_PS_MT(template PDU_L3_SGSN_MS dtap, template OCT1 dlci := *) := {
 dlci := dlci,
 dtap := dtap
}

template PDU_DTAP_PS_MO tr_PDU_DTAP_PS_MO(template PDU_L3_MS_SGSN dtap, template OCT1 dlci := *) := {
 dlci := dlci,
 skip_seq_patching := ?,
 dtap := dtap
}


type port RAN_Conn_PT message {
 inout







  RANAP_PDU,
  RANAP_N_UNITDATA_req,

  RANAP_Conn_Req,

  RANAP_Conn_Ind,






  PDU_DTAP_MO, PDU_DTAP_MT,
  PDU_DTAP_PS_MO, PDU_DTAP_PS_MT,

  RAN_Conn_Prim;
} with { extension "internal" };

type uint2_t N_Sd_Array[4];


type record ConnectionData {

 RAN_ConnHdlr comp_ref,
 integer sccp_conn_id,





 integer cic optional,

 N_Sd_Array n_sd
}

type record ImsiMapping {
 RAN_ConnHdlr comp_ref,
 hexstring imsi optional,
 OCT4 tmsi
}


type record IuSigConIdMapping {
 RAN_ConnHdlr comp_ref,
 IuSignallingConnectionIdentifier sigc_id optional
}


type component RAN_Emulation_CT {





 port RANAP_CODEC_PT RANAP;

 var IuSigConIdMapping IuSigConIdTable[16];


 port RAN_Conn_PT CLIENT;
# 286 "RAN_Emulation.ttcnpp"
 var ConnectionData ConnectionTable[16];


 var ExpectData ExpectTable[16];


 var ImsiMapping ImsiTable[16];


 port RAN_PROC_PT PROC;

 var charstring g_ran_id;
 var integer g_next_e1_ts := 1;
 var RanOps g_ran_ops;
};

private function f_conn_id_known(integer sccp_conn_id)
runs on RAN_Emulation_CT return boolean {
 var integer i;
 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
  if (ConnectionTable[i].sccp_conn_id == sccp_conn_id){
   return true;
  }
 }
 return false;
}

private function f_comp_known(RAN_ConnHdlr client)
runs on RAN_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;
}

private function f_cic_known(integer cic)
runs on RAN_Emulation_CT return boolean {
 var integer i;
 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
  if (ConnectionTable[i].cic == cic) {
   return true;
  }
 }
 return false;
}


private function f_comp_by_conn_id(integer sccp_conn_id)
runs on RAN_Emulation_CT return RAN_ConnHdlr {
 var integer i;
 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
  if (ConnectionTable[i].sccp_conn_id == sccp_conn_id) {
   return ConnectionTable[i].comp_ref;
  }
 }
 setverdict(fail, "RAN Connection table not found by SCCP Connection ID ", sccp_conn_id);
 mtc.stop;
}
# 377 "RAN_Emulation.ttcnpp"
private function f_comp_by_cic(integer cic)
runs on RAN_Emulation_CT return RAN_ConnHdlr {
 var integer i;
 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
  if (ConnectionTable[i].cic == cic) {
   return ConnectionTable[i].comp_ref;
  }
 }
 setverdict(fail, "RAN Connection table not found by CIC ", cic);
 mtc.stop;
}

private function f_comp_store_cic(RAN_ConnHdlr client, integer cic)
runs on RAN_Emulation_CT {
 var integer i;
 for (i := 0; i < sizeof(ConnectionTable); i := i+1) {
  if (ConnectionTable[i].comp_ref == client) {
   ConnectionTable[i].cic := cic;
   return;
  }
 }
 setverdict(fail, "RAN Connection table not found by component ", client);
 mtc.stop;
}


private function f_conn_id_by_comp(RAN_ConnHdlr client)
runs on RAN_Emulation_CT return integer {
 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
  if (ConnectionTable[i].comp_ref == client) {
   return ConnectionTable[i].sccp_conn_id;
  }
 }
 setverdict(fail, "RAN Connection table not found by component ", client);
 mtc.stop;
}


private function f_idx_by_comp(RAN_ConnHdlr client)
runs on RAN_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_conn_id()
runs on RAN_Emulation_CT return integer {
 var integer conn_id;

 do {
  conn_id := float2int(rnd()*SCCP_Emulation.tsp_max_ConnectionId);
 } while (f_conn_id_known(conn_id) == true);

 return conn_id;
}

private function f_conn_table_init()
runs on RAN_Emulation_CT {
 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
  ConnectionTable[i].comp_ref := null;
  ConnectionTable[i].sccp_conn_id := -1;



  ConnectionTable[i].cic := omit;
  ConnectionTable[i].n_sd := { 0, 0, 0, 0 };
 }
 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;
 }

 for (var integer i := 0; i < sizeof(IuSigConIdTable); i := i+1) {
  IuSigConIdTable[i].comp_ref := null;
  IuSigConIdTable[i].sigc_id := omit;
 }

}

private function f_conn_table_add(RAN_ConnHdlr comp_ref, integer sccp_conn_id)
runs on RAN_Emulation_CT {
 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
  if (ConnectionTable[i].sccp_conn_id == -1) {
   ConnectionTable[i].comp_ref := comp_ref;
   ConnectionTable[i].sccp_conn_id := sccp_conn_id;
   ConnectionTable[i].n_sd := { 0, 0, 0, 0 };
   log("Added conn table entry ", i, comp_ref, sccp_conn_id);
   return;
  }
 }
 setverdict(fail, "RAN Connection table full!");
 mtc.stop;
}

private function f_conn_table_del(integer sccp_conn_id)
runs on RAN_Emulation_CT {
 for (var integer i := 0; i < sizeof(ConnectionTable); i := i+1) {
  if (ConnectionTable[i].sccp_conn_id == sccp_conn_id) {
   log("Deleted conn table entry ", i,
       ConnectionTable[i].comp_ref, sccp_conn_id);
   ConnectionTable[i].sccp_conn_id := -1;
   ConnectionTable[i].comp_ref := null;
   return
  }
 }
 setverdict(fail, "RAN Connection table attempt to delete non-existant ", sccp_conn_id);
 mtc.stop;
}

private function f_imsi_table_find(hexstring imsi, template OCT4 tmsi)
runs on RAN_Emulation_CT return RAN_ConnHdlr {
 for (var integer i := 0; i < sizeof(ImsiTable); i := i+1) {
  if (ImsiTable[i].imsi == imsi or
      isvalue(tmsi) and match(ImsiTable[i].tmsi, tmsi)) {
   return ImsiTable[i].comp_ref;
  }
 }
 return null;
}
# 626 "RAN_Emulation.ttcnpp"
type record RANAP_Conn_Req {
 SCCP_PAR_Address addr_peer,
 SCCP_PAR_Address addr_own,
 RANAP_PDU ranap optional
}

template (value) RANAP_Conn_Req ts_RANAP_Conn_Req(SCCP_PAR_Address peer, SCCP_PAR_Address own,
        template (omit) RANAP_PDU ranap) := {
 addr_peer := peer,
 addr_own := own,
 ranap := ranap
};

template (present) RANAP_Conn_Req tr_RANAP_Conn_Req(template (present) SCCP_PAR_Address peer := ?,
          template (present) SCCP_PAR_Address own := ?,
          template RANAP_PDU ranap := *) := {
 addr_peer := peer,
 addr_own := own,
 ranap := ranap
};

type record RANAP_Conn_Ind {
 SCCP_PAR_Address addr_peer,
 SCCP_PAR_Address addr_own,
 RANAP_PDU ranap optional
}

template (value) RANAP_Conn_Ind ts_RANAP_Conn_Ind(SCCP_PAR_Address peer, SCCP_PAR_Address own,
        template (omit) RANAP_PDU ranap) := {
 addr_peer := peer,
 addr_own := own,
 ranap := ranap
};

template (present) RANAP_Conn_Ind tr_RANAP_Conn_Ind(template (present) SCCP_PAR_Address peer := ?,
          template (present) SCCP_PAR_Address own := ?,
          template RANAP_PDU ranap := *) := {
 addr_peer := peer,
 addr_own := own,
 ranap := ranap
};

private function fake_dlci_from_sapi(template (omit) SAPI sapi) return template (omit) OCT1
{
 if (istemplatekind(sapi, "omit")) {
  return omit;
 } else if (valueof(sapi) == sapi_3) {
  return '03'O;
 }
 return '00'O;
}

private function f_handle_userData_RANAP(RAN_ConnHdlr client, RANAP_PDU ranap)
runs on RAN_Emulation_CT {

 var template (omit) octetstring l3 := f_ranap_extract_l3(ranap);
 if (istemplatekind(l3, "omit") or not g_ran_ops.decode_dtap) {
  CLIENT.send(ranap) to client;
 } else {
  var template (omit) SAPI sapi := f_ranap_extract_sapi(ranap);
  var template (omit) OCT1 dlci := fake_dlci_from_sapi(sapi);
  if (g_ran_ops.role_ms) {

   if (g_ran_ops.ps_domain) {
    var PDU_DTAP_PS_MT mt := {
     dlci := omit,
     dtap := dec_PDU_L3_SGSN_MS(valueof(l3))
    };
    if (isvalue(dlci)) {
     mt.dlci := valueof(dlci);
    }
    CLIENT.send(mt) to client;
   } else {
    var PDU_DTAP_MT mt := {
     dlci := omit,
     dtap := dec_PDU_ML3_NW_MS(valueof(l3))
    };
    if (isvalue(dlci)) {
     mt.dlci := valueof(dlci)
    }
    CLIENT.send(mt) to client;
   }
  } else {

   if (g_ran_ops.ps_domain) {
    var PDU_DTAP_PS_MO mo := {
     dlci := omit,
     dtap := dec_PDU_L3_MS_SGSN(valueof(l3))
    };
    if (isvalue(dlci)) {
     mo.dlci := valueof(dlci);
    }
    CLIENT.send(mo) to client;
   } else {
    var PDU_DTAP_MO mo := {
     dlci := omit,
     dtap := dec_PDU_ML3_MS_NW(valueof(l3))
    };
    if (isvalue(dlci)) {
     mo.dlci := valueof(dlci)
    }
    CLIENT.send(mo) to client;
   }
  }
 }
}



type function RanapCreateCallback(RANAP_N_CONNECT_ind conn_ind, charstring id)
runs on RAN_Emulation_CT return RAN_ConnHdlr;

type function RanapUnitdataCallback(RANAP_PDU ranap)
runs on RAN_Emulation_CT return template RANAP_PDU;

private function CommonRanapUnitdataCallback(RANAP_PDU ranap)
runs on RAN_Emulation_CT return template RANAP_PDU {
 if (match(ranap, tr_RANAP_Paging(?, ?))) {
  var RAN_ConnHdlr client := null;

  var hexstring imsi := imsi_oct2hex(ranap.initiatingMessage.value_.paging.protocolIEs[1].value_.permanentNAS_UE_ID.iMSI);
  var template (omit) OCT4 tmsi := omit;
  if (lengthof(ranap.initiatingMessage.value_.paging.protocolIEs) > 2 and
      ranap.initiatingMessage.value_.paging.protocolIEs[2].id == id_TemporaryUE_ID) {
   var TemporaryUE_ID ue_id;
   ue_id := ranap.initiatingMessage.value_.paging.protocolIEs[2].value_.temporaryUE_ID;
   if (ischosen(ue_id.tMSI)) {
    tmsi := ue_id.tMSI;
   } else {
    tmsi := ue_id.p_TMSI;
   }
  }
  client := f_imsi_table_find(imsi, tmsi);
  if (client != null) {
   log("CommonRanapUnitdataCallback: IMSI/TMSI found in table, dispatching to ",
    client);
   CLIENT.send(ranap) to client;
   return omit;
  }
  log("CommonRanapUnitdataCallback: IMSI=", imsi, ", TMSI=", tmsi, " not found in table");
 } else if (match(ranap, tr_RANAP_ResetResource(?, ?, ?))) {

  if (lengthof(ranap.initiatingMessage.value_.resetResource.protocolIEs) > 2 and
      ranap.initiatingMessage.value_.resetResource.protocolIEs[2].id == id_IuSigConIdList) {
   var RANAP_PDU_Contents.ResetResourceList res_li := ranap.initiatingMessage.value_.resetResource.protocolIEs[2].value_.resetResourceList;
   for (var integer i := 0; i < lengthof(res_li); i := i + 1) {
    var IuSignallingConnectionIdentifier sigc_id sigc_id := res_li[i][0].value_.resetResourceItem.iuSigConId;
    var RAN_ConnHdlr client := null;
    log("CommonRanapUnitdataCallback: Lookup IuSigConId", sigc_id);
    client := f_IuSigConId_table_find(sigc_id);
    if (client != null) {
     log("CommonRanapUnitdataCallback: IuSigConId found in table, dispatching to ", client);
     CLIENT.send(ranap) to client;
    }
   }
  }
 }


 if (not ispresent(g_ran_ops.ranap_unitdata_cb)) {
  log("CommonRanapUnitdataCallback: Ignoring RANAP msg: ", ranap);
  return omit;
 }
 return g_ran_ops.ranap_unitdata_cb.apply(ranap);
}

private function f_ranap_l3_is_rr(RANAP_PDU ranap) return boolean {
 var template (omit) SAPI sapi;
 var template octetstring l3 := f_ranap_extract_l3(ranap);
 return f_L3_is_rr(l3);
}

function f_ranap_reset(SCCP_PAR_Address peer,
         SCCP_PAR_Address own,
         template (omit) GlobalRNC_ID grnc_id := omit) runs on RAN_Emulation_CT {
 timer T := 5.0;
 var CN_DomainIndicator dom;
 if (g_ran_ops.ps_domain) {
  dom := ps_domain;
 } else {
  dom := cs_domain;
 }

 RANAP.send(ts_RANAP_UNITDATA_req(peer, own, f_ts_RANAP_Reset(ts_RanapCause_om_intervention, dom, grnc_id)));
 T.start;
 alt {
 [] RANAP.receive(tr_RANAP_UNITDATA_ind(own, peer, tr_RANAP_ResetAck)) {
  log("RANAP: Received RESET-ACK in response to RESET, we're ready to go!");
  }
 [] as_reset_ack();
 [] RANAP.receive { repeat };
 [] T.timeout {
  setverdict(fail, "RANAP: Timeout waiting for RESET-ACK after sending RESET");
  mtc.stop;
  }
 }
}



type enumerated RanProtocol {
 RAN_PROTOCOL_BSSAP,
 RAN_PROTOCOL_RANAP
}

type record RanOps {





 RanapCreateCallback ranap_create_cb optional,
 RanapUnitdataCallback ranap_unitdata_cb optional,


 boolean ranap_connect_ind_auto_res,
 boolean ps_domain,
 GlobalRNC_ID grnc_id optional,

 boolean decode_dtap,
 boolean role_ms,
 RanProtocol protocol,
 RAN_Transport transport,
 boolean use_osmux,
 integer bssap_reset_retries,

 SCCP_PAR_Address sccp_addr_local optional,
 SCCP_PAR_Address sccp_addr_peer optional
}

template BIT4 t_ML3_DISC_CC_MM_SS := ('0011'B, '0101'B, '1011'B);

function f_L3_is_rr(template octetstring l3) return boolean {
 if (not isvalue(l3)) {
  return false;
 }
 var octetstring l3v := valueof(l3);
 if (lengthof(l3v) < 1) {
  return false;
 }

 if ((oct2bit(l3v[0]) and4b '00001111'B) == '00000110'B) {
  return true;
 }
 return false;
}

function f_next_n_sd(inout N_Sd_Array n_sd, in integer n_sd_idx) return uint2_t {
 var uint2_t seq_nr;
 if (n_sd_idx == 0) {
  seq_nr := n_sd[0];
  n_sd[0] := (n_sd[0] + 1) mod 4;
 } else if (n_sd_idx >= 1 and n_sd_idx <= 3) {
  seq_nr := n_sd[n_sd_idx];
  n_sd[n_sd_idx] := (n_sd[n_sd_idx] + 1) mod 2;
 } else {

  seq_nr := 0;
 }
 return seq_nr;
}


function f_ML3_patch_seq_nr(in uint2_t seq_nr, inout octetstring enc_l3) {
 log("patching N(SD)=", seq_nr, " into dtap ", enc_l3);
 enc_l3[1] := (enc_l3[1] and4b '3f'O) or4b bit2oct(int2bit(seq_nr, 8) << 6);
 log("patched enc_l3: ", enc_l3);
}

function f_ML3_n_sd_idx(in PDU_ML3_MS_NW dtap) return integer {
 var uint2_t seq_nr;
 if (ischosen(dtap.msgs.cc) or ischosen(dtap.msgs.mm) or ischosen(dtap.msgs.ss)) {
  return 0;
 } else if (ischosen(dtap.msgs.gcc)) {
  return 1;
 } else if (ischosen(dtap.msgs.bcc)) {
  return 2;
 } else if (ischosen(dtap.msgs.loc)) {
  return 3;
 }

 return -1;
}


private function f_ML3_patch_seq(inout ConnectionData cd, in PDU_ML3_MS_NW dtap, inout octetstring enc_l3) {
 var integer n_sd_idx := f_ML3_n_sd_idx(dtap);
 if (n_sd_idx < 0) {
  return;
 }
 var uint2_t seq_nr := f_next_n_sd(cd.n_sd, n_sd_idx);
 f_ML3_patch_seq_nr(seq_nr, enc_l3);
}

private altstep as_reset_ack(boolean append_osmux_support := false) runs on RAN_Emulation_CT {




 var RANAP_N_UNITDATA_ind rud_ind;
# 936 "RAN_Emulation.ttcnpp"
 [] RANAP.receive(tr_RANAP_UNITDATA_ind(?, ?, tr_RANAP_Reset)) -> value rud_ind {
  log("RANAP: Responding to inbound IuRESET with IuRESET-ACK");
  var CN_DomainIndicator dom;
  dom := rud_ind.userData.initiatingMessage.value_.Reset.protocolIEs[1].value_.cN_DomainIndicator;
  RANAP.send(ts_RANAP_UNITDATA_req(rud_ind.callingAddress, rud_ind.calledAddress,
      f_ts_RANAP_ResetAck(dom, g_ran_ops.grnc_id)));
 }

}


private altstep as_main_bssap() runs on RAN_Emulation_CT {
# 1069 "RAN_Emulation.ttcnpp"
  [false] CLIENT.receive {}

}

private altstep as_main_ranap() runs on RAN_Emulation_CT {

  var RANAP_N_UNITDATA_ind rud_ind;
  var RANAP_N_CONNECT_ind rconn_ind;
  var RANAP_N_CONNECT_cfm rconn_cfm;
  var RANAP_N_DATA_ind rdata_ind;
  var RANAP_N_DISCONNECT_ind rdisc_ind;
  var RANAP_Conn_Req creq;
  var RANAP_PDU ranap;
  var RANAP_N_UNITDATA_req ranap_ud;
  var RAN_Conn_Prim ran_conn_prim;
  var RAN_ConnHdlr vc_conn;
  var PDU_DTAP_PS_MO ps_mo;
  var PDU_DTAP_PS_MT ps_mt;


  [] RANAP.receive(RANAP_N_UNITDATA_ind:?) -> value rud_ind {

   var template RANAP_PDU resp;
   resp := CommonRanapUnitdataCallback(rud_ind.userData);
   if (isvalue(resp)) {
    RANAP.send(ts_RANAP_UNITDATA_req(rud_ind.callingAddress,
         rud_ind.calledAddress, resp));
   }
   }

  [] RANAP.receive(RANAP_N_CONNECT_ind:?) -> value rconn_ind {
   vc_conn := g_ran_ops.ranap_create_cb.apply(rconn_ind, g_ran_id);

   f_conn_table_add(vc_conn, rconn_ind.connectionId);

   if (ispresent(rconn_ind.userData)) {
    f_handle_userData_RANAP(vc_conn, rconn_ind.userData);
   } else {

    CLIENT.send(ts_RANAP_Conn_Ind(rconn_ind.callingAddress, rconn_ind.calledAddress, omit)) to vc_conn;
   }
   if (g_ran_ops.ranap_connect_ind_auto_res) {

    RANAP.send(ts_RANAP_CONNECT_res(rconn_ind.connectionId, omit));
   }
   }

  [] RANAP.receive(RANAP_N_DATA_ind:?) -> value rdata_ind {
   vc_conn := f_comp_by_conn_id(rdata_ind.connectionId);
   if (ispresent(rdata_ind.userData)) {
    f_handle_userData_RANAP(vc_conn, rdata_ind.userData);
   }
   }

  [] RANAP.receive(RANAP_N_DISCONNECT_ind:?) -> value rdisc_ind {
   vc_conn := f_comp_by_conn_id(rdisc_ind.connectionId);
   if (ispresent(rdisc_ind.userData)) {
    f_handle_userData_RANAP(vc_conn, rdisc_ind.userData);
   }

   var RAN_Conn_Prim prim := valueof(ts_MSC_CONN_PRIM_DISC_IND);
   CLIENT.send(prim) to vc_conn;
   f_conn_table_del(rdisc_ind.connectionId);

   }

  [] RANAP.receive(RANAP_N_CONNECT_cfm:?) -> value rconn_cfm {
   vc_conn := f_comp_by_conn_id(rconn_cfm.connectionId);
   var RAN_Conn_Prim prim := valueof(ts_MSC_CONN_PRIM_CONF_IND);
   CLIENT.send(prim) to vc_conn;

   if (ispresent(rconn_cfm.userData)) {
    f_handle_userData_RANAP(vc_conn, rconn_cfm.userData);
   }
   }

  [] CLIENT.receive(RANAP_PDU:?) -> value ranap sender vc_conn {
   var integer conn_id := f_conn_id_by_comp(vc_conn);

   RANAP.send(ts_RANAP_DATA_req(conn_id, ranap));
   }


  [] CLIENT.receive(RANAP_N_UNITDATA_req:?) -> value ranap_ud sender vc_conn {
   RANAP.send(ranap_ud);
   }


  [] CLIENT.receive(tr_MSC_CONN_PRIM_CONNECT_RES) -> value ran_conn_prim sender vc_conn {
   var integer conn_id := f_conn_id_by_comp(vc_conn);

   RANAP.send(ts_RANAP_CONNECT_res(conn_id, omit));
   }


  [] CLIENT.receive(tr_MSC_CONN_PRIM_DISC_REQ) -> value ran_conn_prim sender vc_conn {
   var integer conn_id := f_conn_id_by_comp(vc_conn);
   RANAP.send(ts_RANAP_DISC_req(conn_id, ran_conn_prim.disc_req.reason));
   f_conn_table_del(conn_id);
   }


  [] CLIENT.receive(RANAP_Conn_Req:?) -> value creq sender vc_conn {
   var integer conn_id;


   if (f_comp_known(vc_conn) == false) {

    conn_id := f_gen_conn_id();


    f_conn_table_add(vc_conn, conn_id);

    RANAP.send(ts_RANAP_CONNECT_req(creq.addr_peer, creq.addr_own, conn_id,
        creq.ranap));
   } else {

    conn_id := f_conn_id_by_comp(vc_conn);
    RANAP.send(ts_RANAP_DATA_req(conn_id, creq.ranap));
   }



   if (g_ran_ops.role_ms and not f_ranap_l3_is_rr(creq.ranap)) {

    var integer idx := f_idx_by_comp(vc_conn);
    ConnectionTable[idx].n_sd[0] := 1;
    log("patch: N(SD) for ConnIdx ", idx, " set to 1");
   }
   }

  [g_ran_ops.role_ms] CLIENT.receive(PDU_DTAP_PS_MO:?) -> value ps_mo sender vc_conn {
   var integer idx := f_idx_by_comp(vc_conn);

   var octetstring l3_enc := enc_PDU_L3_MS_SGSN(ps_mo.dtap);

   if (ps_mo.skip_seq_patching == false) {

   }
   f_xmit_raw_l3(ConnectionTable[idx].sccp_conn_id, ps_mo.dlci, l3_enc);
   }

  [not g_ran_ops.role_ms] CLIENT.receive(PDU_DTAP_PS_MT:?) -> value ps_mt sender vc_conn {
   var integer idx := f_idx_by_comp(vc_conn);

   var octetstring l3_enc := enc_PDU_L3_SGSN_MS(ps_mt.dtap);
   f_xmit_raw_l3(ConnectionTable[idx].sccp_conn_id, ps_mt.dlci, l3_enc);
   }





}

private altstep as_main_mgcp() runs on RAN_Emulation_CT {
# 1269 "RAN_Emulation.ttcnpp"
  [false] CLIENT.receive {}

}

private altstep as_main_ctrl() runs on RAN_Emulation_CT {
# 1300 "RAN_Emulation.ttcnpp"
  [false] CLIENT.receive {}

}


private function f_xmit_raw_l3(integer sccp_conn_id, OCT1 dlci, octetstring l3_enc) runs on RAN_Emulation_CT
{
 select (g_ran_ops.protocol) {
# 1316 "RAN_Emulation.ttcnpp"
 case (RAN_PROTOCOL_RANAP) {
  var template (omit) RANAP_IEs.SAPI sapi := omit;
  var RANAP_PDU ranap;


  if (dlci and4b '07'O == '03'O) {
   sapi := sapi_3;
  }

  ranap := valueof(ts_RANAP_DirectTransfer(l3_enc, sapi := sapi));
  RANAP.send(ts_RANAP_DATA_req(sccp_conn_id, ranap));
  }

 }
}

function main(RanOps ops, charstring id) runs on RAN_Emulation_CT {

 g_ran_id := id;
 g_ran_ops := ops;
 f_conn_table_init();
 f_expect_table_init();

 if (isvalue(ops.sccp_addr_peer) and isvalue(ops.sccp_addr_local)) {
  f_sleep(1.0);
  select (g_ran_ops.protocol) {






  case (RAN_PROTOCOL_RANAP) {
   f_ranap_reset(ops.sccp_addr_peer, ops.sccp_addr_local, ops.grnc_id);
   }

  }
 }

 while (true) {
  var RAN_ConnHdlr vc_conn;
  var PDU_DTAP_MO dtap_mo;
  var PDU_DTAP_MT dtap_mt;
  var RAN_ConnHdlr vc_hdlr;
  var octetstring l3_info;
  var hexstring imsi;
  var OCT4 tmsi;
  var integer targetPointCode;

  var IuSignallingConnectionIdentifier sigc_id;


  alt {
  [g_ran_ops.protocol == RAN_PROTOCOL_BSSAP] as_main_bssap();
  [g_ran_ops.protocol == RAN_PROTOCOL_RANAP] as_main_ranap();

  [g_ran_ops.role_ms] CLIENT.receive(PDU_DTAP_MO:?) -> value dtap_mo sender vc_conn {
   var integer idx := f_idx_by_comp(vc_conn);

   var octetstring l3_enc := enc_PDU_ML3_MS_NW(dtap_mo.dtap);

   if (dtap_mo.skip_seq_patching == false) {
    f_ML3_patch_seq(ConnectionTable[idx], dtap_mo.dtap, l3_enc);
   }
   f_xmit_raw_l3(ConnectionTable[idx].sccp_conn_id, dtap_mo.dlci, l3_enc);
   }

  [not g_ran_ops.role_ms] CLIENT.receive(PDU_DTAP_MT:?) -> value dtap_mt sender vc_conn {
   var integer idx := f_idx_by_comp(vc_conn);

   var octetstring l3_enc := enc_PDU_ML3_NW_MS(dtap_mt.dtap);
   f_xmit_raw_l3(ConnectionTable[idx].sccp_conn_id, dtap_mt.dlci, l3_enc);
   }

  [] as_main_mgcp();
  [] as_main_ctrl();

  [] PROC.getcall(RAN_register:{?,?}) -> param(l3_info, vc_hdlr) {
   f_create_expect(l3_info, vc_hdlr);
   PROC.reply(RAN_register:{l3_info, vc_hdlr}) to vc_hdlr;
   }

  [] PROC.getcall(RAN_register_n_connect:{?,?}) -> param(targetPointCode, vc_hdlr) {
   f_create_expect(omit, vc_hdlr, targetPointCode);
   PROC.reply(RAN_register_n_connect:{targetPointCode, vc_hdlr}) to vc_hdlr;
   }

  [] PROC.getcall(RAN_register_sccp_cr_without_payload:{?}) -> param(vc_hdlr) {
   f_create_expect(omit, vc_hdlr);
   PROC.reply(RAN_register_sccp_cr_without_payload:{vc_hdlr}) to vc_hdlr;
   }

  [] PROC.getcall(RAN_register_imsi:{?,?,?}) -> param(imsi, tmsi, vc_hdlr) {
   f_create_imsi(imsi, tmsi, vc_hdlr);
   PROC.reply(RAN_register_imsi:{imsi, tmsi, vc_hdlr}) to vc_hdlr;
   }
  [] PROC.getcall(RAN_unregister_imsi:{?,?}) -> param(imsi, vc_hdlr) {
   f_destroy_imsi(imsi, vc_hdlr);
   PROC.reply(RAN_unregister_imsi:{imsi, vc_hdlr}) to vc_hdlr;
   }

  [] PROC.getcall(RAN_register_IuSigConId:{?,?}) -> param(sigc_id, vc_hdlr) {
   f_create_IuSigConId(sigc_id, vc_hdlr);
   PROC.reply(RAN_register_IuSigConId:{sigc_id, vc_hdlr}) to vc_hdlr;
   }

  }
 }
}
# 1439 "RAN_Emulation.ttcnpp"
type record ExpectData {

 octetstring l3_payload optional,
 integer n_connectPointCode optional,
 boolean sccp_cr_without_payload,

 RAN_ConnHdlr vc_conn
}


signature RAN_register(in octetstring l3, in RAN_ConnHdlr hdlr);
signature RAN_register_n_connect(in integer targetPointCode, in RAN_ConnHdlr hdlr);
signature RAN_register_sccp_cr_without_payload(in RAN_ConnHdlr hdlr);


signature RAN_register_imsi(in hexstring imsi, in OCT4 tmsi, in RAN_ConnHdlr hdlr);
signature RAN_unregister_imsi(in hexstring imsi, in RAN_ConnHdlr hdlr);


signature RAN_last_n_sd(in RAN_ConnHdlr hdlr, out N_Sd_Array last_n_sd);


signature RAN_continue_after_n_sd(N_Sd_Array last_n_sd, in RAN_ConnHdlr hdlr);

type port RAN_PROC_PT procedure {
 inout RAN_register, RAN_register_imsi, RAN_unregister_imsi, RAN_register_n_connect,
       RAN_register_sccp_cr_without_payload, RAN_last_n_sd, RAN_continue_after_n_sd

  , RAN_register_IuSigConId

 ;
} with { extension "internal" };
# 1539 "RAN_Emulation.ttcnpp"
signature RAN_register_IuSigConId(in IuSignallingConnectionIdentifier sigc_id, in RAN_ConnHdlr hdlr);


function RanapExpectedCreateCallback(RANAP_N_CONNECT_ind conn_ind, charstring id)
runs on RAN_Emulation_CT return RAN_ConnHdlr {
 var RAN_ConnHdlr ret := null;
 var template (omit) octetstring l3_info;
 var boolean rx_sccp_cr_without_payload;
 var integer i;

 if (ispresent(conn_ind.userData)) {
  l3_info := f_ranap_extract_l3(conn_ind.userData);
  rx_sccp_cr_without_payload := false;
  if (istemplatekind(l3_info, "omit") and not rx_sccp_cr_without_payload) {
   setverdict(fail, "N-CONNECT.ind without NAS payload");
   mtc.stop;
   return ret;
  }
 } else {
  l3_info := omit;
  rx_sccp_cr_without_payload := true;
 }

 for (i := 0; i < sizeof(ExpectTable); i:= i+1) {
  if ((rx_sccp_cr_without_payload and ExpectTable[i].sccp_cr_without_payload)
      or (ispresent(ExpectTable[i].l3_payload) and valueof(l3_info) == ExpectTable[i].l3_payload)) {
   ret := ExpectTable[i].vc_conn;

   ExpectTable[i].sccp_cr_without_payload := false;
   ExpectTable[i].l3_payload := omit;
   ExpectTable[i].vc_conn := null;
   log("Found Expect[", i, "] for l3=", l3_info, " handled at ", ret);

   return ret;
  }
 }
 setverdict(fail, "Couldn't find Expect for incoming connection ", conn_ind);
 mtc.stop;
 return ret;
}

private function f_create_IuSigConId(IuSignallingConnectionIdentifier sigc_id, RAN_ConnHdlr hdlr)
runs on RAN_Emulation_CT {
 for (var integer i := 0; i < sizeof(IuSigConIdTable); i := i+1) {
  if (not ispresent(IuSigConIdTable[i].sigc_id)) {
   IuSigConIdTable[i].sigc_id := sigc_id;
   IuSigConIdTable[i].comp_ref := hdlr;
   log("Created IuSigConId[", i, "] for ", sigc_id, " to be handled at ", hdlr);
   return;
  }
 }
 setverdict(fail, "No space left in IuSigConIdTable");
 mtc.stop;
}

private function f_IuSigConId_table_find(IuSignallingConnectionIdentifier sigc_id)
runs on RAN_Emulation_CT return RAN_ConnHdlr {
 for (var integer i := 0; i < sizeof(IuSigConIdTable); i := i+1) {
  if (isvalue(IuSigConIdTable[i].sigc_id) and match(IuSigConIdTable[i].sigc_id, sigc_id)) {
   return IuSigConIdTable[i].comp_ref;
  }
 }
 return null;
}


private function f_create_expect(template octetstring l3, RAN_ConnHdlr hdlr,
     template integer n_connectPointCode := omit)
runs on RAN_Emulation_CT {
 var integer i;
 log("f_create_expect(l3 := ", l3, ", n_connectPointCode := ", n_connectPointCode);
 for (i := 0; i < sizeof(ExpectTable); i := i+1) {
  if (not ispresent(ExpectTable[i].l3_payload)
      and not ExpectTable[i].sccp_cr_without_payload
      and not ispresent(ExpectTable[i].n_connectPointCode)) {
   if (ispresent(l3)) {
    ExpectTable[i].l3_payload := valueof(l3);
   } else {
    ExpectTable[i].sccp_cr_without_payload := true;
   }
   if (ispresent(n_connectPointCode)) {
    ExpectTable[i].n_connectPointCode := valueof(n_connectPointCode);
   }
   ExpectTable[i].vc_conn := hdlr;
   if (ispresent(n_connectPointCode)) {
    log("Created Expect[", i, "] for N-CONNECT to be handled at ", hdlr);
   } else {
    log("Created Expect[", i, "] for ", l3, " to be handled at ", hdlr);
   }
   return;
  }
 }
 setverdict(fail, "No space left in ExpectTable");
 mtc.stop;
}

private function f_create_imsi(hexstring imsi, OCT4 tmsi, RAN_ConnHdlr hdlr)
runs on RAN_Emulation_CT {
 for (var integer i := 0; i < sizeof(ImsiTable); i := i+1) {
  if (not ispresent(ImsiTable[i].imsi)) {
   ImsiTable[i].imsi := imsi;
   ImsiTable[i].tmsi := tmsi;
   ImsiTable[i].comp_ref := hdlr;
   log("Created IMSI[", i, "] for ", imsi, tmsi, " to be handled at ", hdlr);
   return;
  }
 }
 setverdict(fail, "No space left in ImsiTable");
 mtc.stop;
}

private function f_destroy_imsi(hexstring imsi, RAN_ConnHdlr hdlr)
runs on RAN_Emulation_CT {
 for (var integer i := 0; i < sizeof(ImsiTable); i := i+1) {
  if (ImsiTable[i].imsi == imsi and ImsiTable[i].comp_ref == hdlr) {
   ImsiTable[i].comp_ref := null;
   ImsiTable[i].imsi := omit;
   ImsiTable[i].tmsi := 'FFFFFFFF'O;
   log("Removed IMSI[", i, "] for ", imsi, " to be handled at ", hdlr);
   return;
  }
 }
 setverdict(fail, "Unable to find to-be-destroyed IMSI in ImsiTable");
 mtc.stop;
}

private function f_expect_table_init()
runs on RAN_Emulation_CT {
 for (var integer i := 0; i < sizeof(ExpectTable); i := i+1) {
  ExpectTable[i].l3_payload := omit;
  ExpectTable[i].n_connectPointCode := omit;
  ExpectTable[i].sccp_cr_without_payload := false;
 }
}


function f_ran_register_imsi(hexstring imsi, template (omit) OCT4 tmsi_or_omit)
runs on RAN_ConnHdlr {
 var OCT4 tmsi;


 if (istemplatekind(tmsi_or_omit, "omit")) {
  tmsi := 'FFFFFFFF'O;
 } else {
  tmsi := valueof(tmsi_or_omit);
 }

 RAN_CONN_PROC.call(RAN_register_imsi:{imsi, tmsi, self}) {
  [] RAN_CONN_PROC.getreply(RAN_register_imsi:{?,?,?}) {};
 }
}


function f_ran_unregister_imsi(hexstring imsi)
runs on RAN_ConnHdlr {

 RAN_CONN_PROC.call(RAN_unregister_imsi:{imsi, self}) {
  [] RAN_CONN_PROC.getreply(RAN_unregister_imsi:{?,?}) {};
 }
}


function f_ran_register_exp(octetstring l3_enc) runs on RAN_ConnHdlr {
 RAN_CONN_PROC.call(RAN_register:{l3_enc, self}) {
  [] RAN_CONN_PROC.getreply(RAN_register:{?, ?}) {};
 }
}

function f_ran_register_sccp_cr_without_payload() runs on RAN_ConnHdlr {
 RAN_CONN_PROC.call(RAN_register_sccp_cr_without_payload:{self}) {
  [] RAN_CONN_PROC.getreply(RAN_register_sccp_cr_without_payload:{?}) {};
 }
}



function f_ran_register_IuSigConId(IuSignallingConnectionIdentifier sigc_id)
runs on RAN_ConnHdlr {
 RAN_CONN_PROC.call(RAN_register_IuSigConId:{sigc_id, self}) {
  [] RAN_CONN_PROC.getreply(RAN_register_IuSigConId:{?,?}) {};
 }
}


altstep as_iu_release_compl_disc() runs on RAN_ConnHdlr {
 var RANAP_PDU ranap;
 [] RAN_CONN.receive(tr_RANAP_IuReleaseCommand(?)) {
  RAN_CONN.send(ts_RANAP_IuReleaseComplete);
  alt {
  [] RAN_CONN.receive(tr_MSC_CONN_PRIM_DISC_IND) {
   setverdict(pass);
   }
  [] RAN_CONN.receive {
   setverdict(fail, "Unexpected RANAP while waiting for SCCP Release ");
   mtc.stop;
   }
  }
  }
 [] RAN_CONN.receive(RANAP_PDU:?) -> value ranap{
  setverdict(fail, "Unexpected RANAP while waiting for IuReleaseCommand", ranap);
  mtc.stop;
  }
}



}