Reworked NAS Registration Request

* NAS in DEREGISTERED state sends a NAS Registration Request
* NAS -> RRC: RRC receives an ITTI message with NAS message
  that is stored in the RRC instance and later encoded as
  dedicatedNASMessage in RRCSetupComplete
* send indication from NAS to RRC when GUTI is available and
  store 5G-S-TMSI

executables/nr-uesoftmodem.c

@@ -398,6 +398,15 @@ static void trigger_stop(int sig)
   if (!oai_exit)
     itti_wait_tasks_unblock();
 }
+
+static void trigger_registration(uint8_t ue_id)
+{
+  instance_t instance = 0;
+  MessageDef *msg = itti_alloc_new_message(TASK_NAS_NRUE, 0, NAS_REGISTRATION_REQ);
+  NAS_REGISTRATION_REQ(msg).UEid = instance;
+  itti_send_msg_to_task(TASK_NAS_NRUE, instance, msg);
+}
+
 static void trigger_deregistration(int sig)
 {
   if (!stop_immediately) {
@@ -589,6 +598,8 @@ int main(int argc, char **argv)
     printf("cannot create ITTI tasks\n");
     exit(-1); // need a softer mode
   }
+  /* Trigger NAS Registration Request */
+  trigger_registration(ue_id);
 
   // Sleep a while before checking all parameters have been used
   // Some are used directly in external threads, asynchronously

openair2/COMMON/as_message.h

@@ -397,6 +397,16 @@ typedef struct nas_release_ind_s {
   release_cause_t cause;      /* Release cause            */
 } nas_release_ind_t;
 
+typedef struct nas_registration_req_s {
+  /* UE lower layer identifier */
+  uint32_t UEid;
+} nas_registration_req_t;
+
+typedef struct nas_reg_req_ind_s {
+  /* NAS message to transfer */
+  as_nas_info_t nasMsg;
+} nas_reg_req_ind_t;
+
 typedef struct nas_deregistration_req_s {
   release_cause_t cause;
 } nas_deregistration_req_t;
@@ -405,6 +415,13 @@ typedef struct nas_detach_req_s {
   bool wait_release;
 } nas_detach_req_t;
 
+/**
+ * @brief 5GS mobility management information
+ * @ref   clause 9.11.3 of 3GPP TS 24.501
+ */
+typedef struct nas_5gmm_ind_s {
+  uint64_t fiveG_STMSI;
+} nas_5gmm_ind_t;
 /*
  * --------------------------------------------------------------------------
  *              NAS information transfer

openair2/COMMON/rrc_messages_def.h

@@ -63,6 +63,7 @@ MESSAGE_DEF(NAS_CONN_ESTABLI_REQ,       MESSAGE_PRIORITY_MED,       NasConnEstab
 MESSAGE_DEF(NAS_UPLINK_DATA_REQ,        MESSAGE_PRIORITY_MED,       NasUlDataReq,               nas_ul_data_req)
 MESSAGE_DEF(NAS_DETACH_REQ,             MESSAGE_PRIORITY_MED,       NasDetachReq,               nas_detach_req)
 MESSAGE_DEF(NAS_DEREGISTRATION_REQ,     MESSAGE_PRIORITY_MED,       NasDeregistrationReq,       nas_deregistration_req)
+MESSAGE_DEF(NAS_5GMM_IND,               MESSAGE_PRIORITY_MED,       Nas5GMMInd,                 nas_5gmm_ind)
 
 MESSAGE_DEF(NAS_RAB_ESTABLI_RSP,        MESSAGE_PRIORITY_MED,       NasRabEstRsp,               nas_rab_est_rsp)
 
@@ -77,6 +78,8 @@ MESSAGE_DEF(NAS_CONN_RELEASE_IND,       MESSAGE_PRIORITY_MED,       NasConnRelea
 MESSAGE_DEF(NR_NAS_CONN_RELEASE_IND,    MESSAGE_PRIORITY_MED,       NRNasConnReleaseInd,        nr_nas_conn_release_ind)
 MESSAGE_DEF(NAS_UPLINK_DATA_CNF,        MESSAGE_PRIORITY_MED,       NasUlDataCnf,               nas_ul_data_cnf)
 MESSAGE_DEF(NAS_DOWNLINK_DATA_IND,      MESSAGE_PRIORITY_MED,       NasDlDataInd,               nas_dl_data_ind)
+MESSAGE_DEF(NAS_REGISTRATION_REQ,       MESSAGE_PRIORITY_MED,       NasRegistrationReq,         nas_registration_req)
+MESSAGE_DEF(NAS_REG_REQ_IND,            MESSAGE_PRIORITY_MED,       NasRegistrationReqInd,      nas_reg_req_ind)
 
 // xNB: realtime -> RRC messages
 MESSAGE_DEF(RRC_SUBFRAME_PROCESS,       MESSAGE_PRIORITY_MED,       RrcSubframeProcess,         rrc_subframe_process)

openair2/COMMON/rrc_messages_types.h

@@ -76,6 +76,7 @@
 #define NAS_UPLINK_DATA_REQ(mSGpTR)     (mSGpTR)->ittiMsg.nas_ul_data_req
 #define NAS_DETACH_REQ(mSGpTR)          (mSGpTR)->ittiMsg.nas_detach_req
 #define NAS_DEREGISTRATION_REQ(mSGpTR)  (mSGpTR)->ittiMsg.nas_deregistration_req
+#define NAS_5GMM_IND(mSGpTR)            (mSGpTR)->ittiMsg.nas_5gmm_ind
 
 #define NAS_RAB_ESTABLI_RSP(mSGpTR)     (mSGpTR)->ittiMsg.nas_rab_est_rsp
 
@@ -87,6 +88,8 @@
 #define NR_NAS_CONN_RELEASE_IND(mSGpTR) (mSGpTR)->ittiMsg.nr_nas_conn_release_ind
 #define NAS_UPLINK_DATA_CNF(mSGpTR)     (mSGpTR)->ittiMsg.nas_ul_data_cnf
 #define NAS_DOWNLINK_DATA_IND(mSGpTR)   (mSGpTR)->ittiMsg.nas_dl_data_ind
+#define NAS_REGISTRATION_REQ(mSGpTR)    (mSGpTR)->ittiMsg.nas_registration_req
+#define NAS_REG_REQ_IND(mSGpTR)         (mSGpTR)->ittiMsg.nas_reg_req_ind
 
 #define RRC_SUBFRAME_PROCESS(mSGpTR)    (mSGpTR)->ittiMsg.rrc_subframe_process
 #define NRRRC_FRAME_PROCESS(mSGpTR)     (mSGpTR)->ittiMsg.nr_rrc_frame_process
@@ -431,6 +434,7 @@ typedef nas_establish_req_t     NasConnEstabliReq;
 typedef ul_info_transfer_req_t  NasUlDataReq;
 typedef nas_deregistration_req_t NasDeregistrationReq;
 typedef nas_detach_req_t        NasDetachReq;
+typedef nas_5gmm_ind_t          Nas5GMMInd;
 
 typedef rab_establish_rsp_t     NasRabEstRsp;
 
@@ -444,6 +448,8 @@ typedef nas_establish_cnf_t     NasConnEstabCnf;
 typedef nas_release_ind_t       NasConnReleaseInd;
 typedef ul_info_transfer_cnf_t  NasUlDataCnf;
 typedef dl_info_transfer_ind_t  NasDlDataInd;
+typedef nas_registration_req_t  NasRegistrationReq;
+typedef nas_reg_req_ind_t       NasRegistrationReqInd;
 
 // eNB: realtime -> RRC messages
 typedef struct rrc_subframe_process_s {

openair2/RRC/NR_UE/rrc_UE.c

@@ -312,6 +312,8 @@ NR_UE_RRC_INST_t* nr_rrc_init_ue(char* uecap_file, int nb_inst)
     rrc->ul_bwp_id = 0;
     rrc->as_security_activated = false;
     rrc->detach_after_release = false;
+    /* 5G-S-TMSI */
+    rrc->fiveG_S_TMSI = UINT64_MAX;
 
     FILE *f = NULL;
     if (uecap_file)
@@ -892,14 +894,16 @@ static void rrc_ue_generate_RRCSetupComplete(const NR_UE_RRC_INST_t *rrc, const
 {
   uint8_t buffer[100];
   const char *nas_msg;
-  int   nas_msg_length;
+  int nas_msg_length;
 
   if (get_softmodem_params()->sa) {
-    as_nas_info_t initialNasMsg;
-    nr_ue_nas_t *nas = get_ue_nas_info(rrc->ue_id);
-    generateRegistrationRequest(&initialNasMsg, nas);
-    nas_msg = (char*)initialNasMsg.data;
-    nas_msg_length = initialNasMsg.length;
+    if (rrc->nasRegReqMsg.data) {
+      nas_msg = (char *)rrc->nasRegReqMsg.data;
+      nas_msg_length = rrc->nasRegReqMsg.length;
+    } else {
+      LOG_E(NR_RRC, "Failed to complete RRCSetup. NAS Registration Request message not found. \n");
+      return;
+    }
   } else {
     nas_msg = nr_nas_attach_req_imsi_dummy_NSA_case;
     nas_msg_length = sizeof(nr_nas_attach_req_imsi_dummy_NSA_case);
@@ -909,7 +913,6 @@ static void rrc_ue_generate_RRCSetupComplete(const NR_UE_RRC_INST_t *rrc, const
   LOG_I(NR_RRC, "[UE %ld][RAPROC] Logical Channel UL-DCCH (SRB1), Generating RRCSetupComplete (bytes%d)\n", rrc->ue_id, size);
   int srb_id = 1; // RRC setup complete on SRB1
   LOG_D(NR_RRC, "[RRC_UE %ld] PDCP_DATA_REQ/%d Bytes RRCSetupComplete ---> %d\n", rrc->ue_id, size, srb_id);
-
   nr_pdcp_data_req_srb(rrc->ue_id, srb_id, 0, size, buffer, deliver_pdu_srb_rlc, NULL);
 }
 
@@ -1810,6 +1813,19 @@ void *rrc_nrue(void *notUsed)
     break;
   }
 
+  case NAS_5GMM_IND: {
+    Nas5GMMInd *req = &NAS_5GMM_IND(msg_p);
+    rrc->fiveG_S_TMSI = req->fiveG_STMSI;
+    break;
+  }
+
+  case NAS_REG_REQ_IND:
+    LOG_D(NR_RRC, "Received Registration Request indication from NAS\n");
+    NasRegistrationReqInd *ind = &NAS_REG_REQ_IND(msg_p);
+    rrc->nasRegReqMsg.length = ind->nasMsg.length;
+    rrc->nasRegReqMsg.data = calloc(ind->nasMsg.length, sizeof(*ind->nasMsg.data));
+    memcpy(rrc->nasRegReqMsg.data, ind->nasMsg.data, rrc->nasRegReqMsg.length);
+    break;
   default:
     LOG_E(NR_RRC, "[UE %ld] Received unexpected message %s\n", rrc->ue_id, ITTI_MSG_NAME(msg_p));
     break;

openair2/RRC/NR_UE/rrc_defs.h

@@ -222,6 +222,10 @@ typedef struct NR_UE_RRC_INST_s {
   NR_RRCRelease_t *RRCRelease;
   long selected_plmn_identity;
   Rrc_State_NR_t nrRrcState;
+  /* Registration Request NAS message */
+  as_nas_info_t nasRegReqMsg;
+  /* 5G-S-TMSI */
+  uint64_t fiveG_S_TMSI;
 
   //Sidelink params
   NR_SL_PreconfigurationNR_r16_t *sl_preconfig;

openair3/NAS/NR_UE/nr_nas_msg_sim.c

@@ -422,7 +422,7 @@ nr_ue_nas_t *get_ue_nas_info(module_id_t module_id)
   return &nr_ue_nas;
 }
 
-void generateRegistrationRequest(as_nas_info_t *initialNasMsg, nr_ue_nas_t *nas)
+static void generateRegistrationRequest(as_nas_info_t *initialNasMsg, nr_ue_nas_t *nas)
 {
   int size = sizeof(mm_msg_header_t);
   fgs_nas_message_t nas_msg={0};
@@ -921,6 +921,24 @@ static void send_nas_detach_req(instance_t instance, bool wait_release)
   itti_send_msg_to_task(TASK_RRC_NRUE, instance, msg);
 }
 
+static void send_nas_5gmm_ind(instance_t instance, const Guti5GSMobileIdentity_t *guti)
+{
+  MessageDef *msg = itti_alloc_new_message(TASK_NAS_NRUE, 0, NAS_5GMM_IND);
+  nas_5gmm_ind_t *ind = &NAS_5GMM_IND(msg);
+  LOG_I(NR_RRC, "5G-GUTI: AMF pointer %u, AMF Set ID %u, 5G-TMSI %u \n", guti->amfpointer, guti->amfsetid, guti->tmsi);
+  ind->fiveG_STMSI = ((uint64_t)guti->amfsetid << 38) | ((uint64_t)guti->amfpointer << 32) | guti->tmsi;
+  itti_send_msg_to_task(TASK_RRC_NRUE, instance, msg);
+}
+
+static void send_nas_req_req_ind(instance_t instance, as_nas_info_t *initialNasMsg)
+{
+  MessageDef *msg = itti_alloc_new_message(TASK_NAS_NRUE, 0, NAS_REG_REQ_IND);
+  NasRegistrationReqInd *ind = &NAS_REG_REQ_IND(msg);
+  ind->nasMsg.data = (uint8_t *)initialNasMsg->data;
+  ind->nasMsg.length = initialNasMsg->length;
+  itti_send_msg_to_task(TASK_RRC_NRUE, instance, msg);
+}
+
 static void parse_allowed_nssai(nr_nas_msg_snssai_t nssaiList[8], const uint8_t *buf, const uint32_t len)
 {
   int nssai_cnt = 0;
@@ -1052,6 +1070,9 @@ static void handle_registration_accept(instance_t instance,
   decodeRegistrationAccept(pdu_buffer, msg_length, nas);
   get_allowed_nssai(nas_allowed_nssai, pdu_buffer, msg_length);
 
+  if(nas->guti)
+    send_nas_5gmm_ind(instance, nas->guti);
+
   as_nas_info_t initialNasMsg = {0};
   generateRegistrationComplete(nas, &initialNasMsg, NULL);
   if (initialNasMsg.length > 0) {
@@ -1179,6 +1200,18 @@ void *nas_nrue(void *args_p)
 
         break;
 
+      case NAS_REGISTRATION_REQ: {
+        nas_registration_req_t *req = &NAS_REGISTRATION_REQ(msg_p);
+        nr_ue_nas_t *nas = get_ue_nas_info(req->UEid);
+        if (nas->fiveGMM_state == FGS_DEREGISTERED) {
+          LOG_I(NAS, "Generate Registration Request\n");
+          as_nas_info_t initialNasMsg;
+          generateRegistrationRequest(&initialNasMsg, nas);
+          send_nas_req_req_ind(instance, &initialNasMsg);
+        }
+        break;
+      }
+
       case NAS_DEREGISTRATION_REQ: {
         LOG_I(NAS, "[UE %ld] Received %s\n", instance, ITTI_MSG_NAME(msg_p));
         nr_ue_nas_t *nas = get_ue_nas_info(0);

openair3/NAS/NR_UE/nr_nas_msg_sim.h

@@ -194,7 +194,6 @@ typedef struct {
 } dl_nas_transport_t;
 
 nr_ue_nas_t *get_ue_nas_info(module_id_t module_id);
-void generateRegistrationRequest(as_nas_info_t *initialNasMsg, nr_ue_nas_t *nas);
 void *nas_nrue_task(void *args_p);
 void *nas_nrue(void *args_p);