Adding emergency registration procedure

lib/include/srsran/interfaces/ue_nas_interfaces.h

@@ -41,6 +41,7 @@ class pdu_session_cfg_t
   apn_types   apn_type = ipv4;
   std::string apn_user;
   std::string apn_pass;
+  bool emergency_registration_5g;
 };
 class nas_interface_rrc
 {

srsue/hdr/stack/upper/nas_5g.h

@@ -209,4 +209,4 @@ class nas_5g : public nas_base, public nas_5g_interface_rrc_nr, public nas_5g_in
   std::array<pdu_session_t, MAX_PDU_SESSIONS> pdu_sessions;
 };
 } // namespace srsue
-#endif
+#endif

srsue/hdr/stack/upper/nas_5g_procedures.h

@@ -57,7 +57,7 @@ class nas_5g::pdu_session_establishment_procedure
 {
 public:
   explicit pdu_session_establishment_procedure(nas_5g_interface_procedures* parent_nas_, srslog::basic_logger& logger_);
-  srsran::proc_outcome_t init(const uint16_t pdu_session_id, const pdu_session_cfg_t& pdu_session);
+  srsran::proc_outcome_t init(const uint16_t pdu_session_id, const pdu_session_cfg_t& pdu_session, const bool emergency_pdu_session);
   srsran::proc_outcome_t react(const srsran::nas_5g::pdu_session_establishment_accept_t& pdu_session_est_accept);
   srsran::proc_outcome_t react(const srsran::nas_5g::pdu_session_establishment_reject_t& pdu_session_est_reject);
   srsran::proc_outcome_t step();
@@ -69,8 +69,9 @@ class nas_5g::pdu_session_establishment_procedure
   nas_5g_interface_procedures* parent_nas;
   uint32_t                     transaction_identity = 0;
   uint16_t                     pdu_session_id       = 0;
+  bool 						   emergency_pdu_session = false;
 };
 
 } // namespace srsue
 
-#endif // SRSUE_NAS_5G_PROCEDURES_H_
+#endif // SRSUE_NAS_5G_PROCEDURES_H_

srsue/hdr/stack/upper/nas_config.h

@@ -67,6 +67,8 @@ class nas_5g_args_t
   std::string                    ia5g;
   std::string                    ea5g;
   std::vector<pdu_session_cfg_t> pdu_session_cfgs;
+  bool emergency_registration_5g;
+
   // slicing configuration
   bool enable_slicing;
   int  nssai_sst;

srsue/src/main.cc

@@ -153,13 +153,14 @@ static int parse_args(all_args_t* args, int argc, char* argv[])
     ("rrc.nr_measurement_pci",  bpo::value<uint32_t>(&args->stack.rrc_nr.sim_nr_meas_pci)->default_value(500),                    "NR PCI for the simulated NR measurement")
     ("rrc.nr_short_sn_support", bpo::value<bool>(&args->stack.rrc_nr.pdcp_short_sn_support)->default_value(true),                 "Announce PDCP short SN support")
 
-    ("nas.apn",               bpo::value<string>(&args->stack.nas.apn_name)->default_value(""),          "Set Access Point Name (APN) for data services")
+	("nas.apn",               bpo::value<string>(&args->stack.nas.apn_name)->default_value(""),          "Set Access Point Name (APN) for data services")
     ("nas.apn_protocol",      bpo::value<string>(&args->stack.nas.apn_protocol)->default_value(""),  "Set Access Point Name (APN) protocol for data services")
     ("nas.user",              bpo::value<string>(&args->stack.nas.apn_user)->default_value(""),  "Username for CHAP authentication")
     ("nas.pass",              bpo::value<string>(&args->stack.nas.apn_pass)->default_value(""),  "Password for CHAP authentication")
     ("nas.force_imsi_attach", bpo::value<bool>(&args->stack.nas.force_imsi_attach)->default_value(false),  "Whether to always perform an IMSI attach")
     ("nas.eia",               bpo::value<string>(&args->stack.nas.eia)->default_value("1,2,3"),  "List of integrity algorithms included in UE capabilities")
     ("nas.eea",               bpo::value<string>(&args->stack.nas.eea)->default_value("0,1,2,3"),  "List of ciphering algorithms included in UE capabilities")
+    ("nas.enable_emergency_reg_5g", bpo::value<bool>(&args->stack.nas_5g.emergency_registration_5g)->default_value(false), "Specifies if it is an anonymous emergency registration.")
 
     ("slicing.enable",        bpo::value<bool>(&args->stack.nas_5g.enable_slicing)->default_value(false),  "enable slicing in the UE")
     ("slicing.nssai-sst",     bpo::value<int>(&args->stack.nas_5g.nssai_sst)->default_value(1),  "sst of requested slice")

srsue/src/stack/upper/nas_5g.cc

@@ -259,13 +259,21 @@ int nas_5g::send_registration_request()
   }
 
   initial_registration_request_stored.hdr.extended_protocol_discriminator =
-      nas_5gs_hdr::extended_protocol_discriminator_opts::extended_protocol_discriminator_5gmm;
+ 		  nas_5gs_hdr::extended_protocol_discriminator_opts::extended_protocol_discriminator_5gmm;
   registration_request_t& reg_req = initial_registration_request_stored.set_registration_request();
-
   reg_req.registration_type_5gs.follow_on_request_bit =
-      registration_type_5gs_t::follow_on_request_bit_type_::options::follow_on_request_pending;
+	  registration_type_5gs_t::follow_on_request_bit_type_::options::follow_on_request_pending;
+
+  if(cfg.emergency_registration_5g){
+	   reg_req.registration_type_5gs.registration_type =
+	  		  registration_type_5gs_t::registration_type_type_::options::emergency_registration;
+
+	   mobile_identity_5gs_t::imei_s& imei = reg_req.mobile_identity_5gs.set_imei();
+	        usim->get_imei_vec(imei.imei.data(), 15);
+  }
+  else {
   reg_req.registration_type_5gs.registration_type =
-      registration_type_5gs_t::registration_type_type_::options::initial_registration;
+	  registration_type_5gs_t::registration_type_type_::options::initial_registration;
   mobile_identity_5gs_t::suci_s& suci = reg_req.mobile_identity_5gs.set_suci();
   suci.supi_format                    = mobile_identity_5gs_t::suci_s::supi_format_type_::options::imsi;
   usim->get_home_mcc_bytes(suci.mcc.data(), suci.mcc.size());
@@ -274,6 +282,7 @@ int nas_5g::send_registration_request()
   suci.scheme_output.resize(5);
   usim->get_home_msin_bcd(suci.scheme_output.data(), 5);
   logger.info("Requesting IMSI attach (IMSI=%s)", usim->get_imsi_str().c_str());
+  }
 
   reg_req.ue_security_capability_present = true;
   fill_security_caps(reg_req.ue_security_capability);
@@ -285,10 +294,9 @@ int nas_5g::send_registration_request()
     reg_req.requested_nssai.s_nssai_list.push_back(nssai);
   }
   if (initial_registration_request_stored.pack(pdu) != SRSASN_SUCCESS) {
-    logger.error("Failed to pack registration request");
-    return SRSRAN_ERROR;
+	logger.error("Failed to pack registration request");
+	return SRSRAN_ERROR;
   }
-
   if (pcap != nullptr) {
     pcap->write_nas(pdu.get()->msg, pdu.get()->N_bytes);
   }
@@ -599,13 +607,15 @@ int nas_5g::send_pdu_session_establishment_request(uint32_t                 tran
   ul_nas_msg.pdu_session_id.pdu_session_identity_2_value = pdu_session_id;
 
   ul_nas_msg.request_type_present            = true;
-  ul_nas_msg.request_type.request_type_value = request_type_t::Request_type_value_type_::options::initial_request;
+  ul_nas_msg.request_type.request_type_value = (cfg.emergency_registration_5g)? request_type_t::Request_type_value_type_::initial_emergency_request:
+	request_type_t::Request_type_value_type_::options::initial_request;
 
   if (cfg.enable_slicing) {
-    ul_nas_msg.s_nssai_present = true;
+    ul_nas_msg.s_nssai_present = (cfg.emergency_registration_5g)? false:true;
     set_nssai(ul_nas_msg.s_nssai);
   }
-  ul_nas_msg.dnn_present = true;
+
+  ul_nas_msg.dnn_present = (cfg.emergency_registration_5g)? false:true;
   ul_nas_msg.dnn.dnn_value.resize(pdu_session_cfg.apn_name.size() + 1);
   ul_nas_msg.dnn.dnn_value.data()[0] = static_cast<uint8_t>(pdu_session_cfg.apn_name.size());
 
@@ -1254,7 +1264,7 @@ int nas_5g::trigger_pdu_session_est()
     pdu_session_cfg_t pdu_session_cfg;
     uint16_t          pdu_session_id;
     get_unestablished_pdu_session(pdu_session_id, pdu_session_cfg);
-    pdu_session_establishment_proc.launch(pdu_session_id, pdu_session_cfg);
+    pdu_session_establishment_proc.launch(pdu_session_id, pdu_session_cfg,cfg.emergency_registration_5g);
   }
   return SRSRAN_SUCCESS;
 }

srsue/src/stack/upper/nas_5g_procedures.cc

@@ -52,24 +52,29 @@ nas_5g::pdu_session_establishment_procedure::pdu_session_establishment_procedure
 {}
 
 srsran::proc_outcome_t nas_5g::pdu_session_establishment_procedure::init(const uint16_t           pdu_session_id_,
-                                                                         const pdu_session_cfg_t& pdu_session_cfg)
+                                                                         const pdu_session_cfg_t& pdu_session_cfg,
+																		 const bool emergency_pdu_session_)
 {
   // Get PDU transaction identity
   transaction_identity = parent_nas->allocate_next_proc_trans_id();
   pdu_session_id       = pdu_session_id_;
   parent_nas->send_pdu_session_establishment_request(transaction_identity, pdu_session_id, pdu_session_cfg);
 
+  //Check if emergency registration is enabled
+  emergency_pdu_session = emergency_pdu_session_;
+
   return srsran::proc_outcome_t::yield;
 }
 
 srsran::proc_outcome_t nas_5g::pdu_session_establishment_procedure::react(
     const srsran::nas_5g::pdu_session_establishment_accept_t& pdu_session_est_accept)
 {
-  // TODO check the pdu session values
-  if (pdu_session_est_accept.dnn_present == false) {
+  //TODO check the pdu session values
+  if(pdu_session_est_accept.dnn_present == false and not emergency_pdu_session){
     logger.warning("Expected DNN in PDU session establishment accept");
     return proc_outcome_t::error;
-  }
+  } 
+
   if (pdu_session_est_accept.pdu_address_present == false) {
     logger.warning("Expected PDU Address in PDU session establishment accept");
     return proc_outcome_t::error;
@@ -98,4 +103,4 @@ srsran::proc_outcome_t nas_5g::pdu_session_establishment_procedure::step()
   return srsran::proc_outcome_t::success;
 }
 
-} // namespace srsue
+} // namespace srsue