Merge branch 'develop_SA_SIM' into develop_SA_L3

 Conflicts:
	common/utils/ocp_itti/intertask_interface.h
	openair2/COMMON/gtpv1_u_messages_types.h
	openair2/GNB_APP/gnb_config.c
	openair2/RRC/NR/MESSAGES/asn1_msg.c
	openair2/RRC/NR/nr_rrc_proto.h
	openair2/RRC/NR/rrc_gNB.c
	openair2/RRC/NR/rrc_gNB_NGAP.c
	openair2/RRC/NR_UE/rrc_UE.c
	openair3/NAS/NR_UE/nr_nas_msg_sim.h
	openair3/NGAP/ngap_gNB_nas_procedures.c

cmake_targets/CMakeLists.txt

@@ -2585,6 +2585,13 @@ if(ITTI_SIM)
 
   set(libnrnas_emm_msg_OBJS
     ${NAS_SRC}COMMON/EMM/MSG/RegistrationRequest.c
+    ${NAS_SRC}COMMON/EMM/MSG/RegistrationAccept.c
+    ${NAS_SRC}COMMON/EMM/MSG/FGSIdentityResponse.c
+    ${NAS_SRC}COMMON/EMM/MSG/FGSAuthenticationResponse.c
+    ${NAS_SRC}COMMON/EMM/MSG/FGSNASSecurityModeComplete.c
+    ${NAS_SRC}COMMON/EMM/MSG/RegistrationComplete.c
+    ${NAS_SRC}COMMON/EMM/MSG/FGSUplinkNasTransport.c
+    ${NAS_SRC}COMMON/ESM/MSG/PduSessionEstablishRequest.c
   )
 
   set(libnrnas_ies_OBJS
@@ -2592,8 +2599,11 @@ if(ITTI_SIM)
     ${NAS_SRC}COMMON/IES/FGSMobileIdentity.c
     ${NAS_SRC}COMMON/IES/FGSRegistrationType.c
     ${NAS_SRC}COMMON/IES/SpareHalfOctet.c
+    ${NAS_SRC}COMMON/IES/FGSRegistrationResult.c
     ${NAS_SRC}COMMON/IES/FGMMCapability.c
     ${NAS_SRC}COMMON/IES/NrUESecurityCapability.c
+    ${NAS_SRC}COMMON/IES/FGCNasMessageContainer.c
+    ${NAS_SRC}COMMON/IES/SORTransparentContainer.c
   )
 
   add_library(LIB_NAS_SIMUE

common/ran_context.h

@@ -47,6 +47,7 @@
 #include "NwGtpv1uMsg.h"
 #include "NwGtpv1uPrivate.h"
 #include "gtpv1u_eNB_defs.h"
+#include "gtpv1u_gNB_defs.h"
 
 #include "PHY/defs_L1_NB_IoT.h"
 #include "RRC/LTE/defs_NB_IoT.h"
@@ -109,6 +110,8 @@ typedef struct {
   struct gNB_MAC_INST_s **nrmac;
   /// GTPu descriptor 
   gtpv1u_data_t *gtpv1u_data_g;
+  /// NR GTPu descriptor 
+  nr_gtpv1u_data_t *nr_gtpv1u_data_g;
   /// RU descriptors. These describe what each radio unit is supposed to do and contain the necessary functions for fronthaul interfaces
   struct RU_t_s **ru;
   /// Mask to indicate fronthaul setup status of RU (hard-limit to 64 RUs)

common/utils/msc/msc.h

@@ -54,6 +54,7 @@ typedef enum {
   MSC_S1AP_ENB,
   MSC_NGAP_GNB,
   MSC_GTPU_ENB,
+  MSC_GTPU_GNB,
   MSC_GTPU_SGW,
   MSC_S1AP_MME,
   MSC_NGAP_AMF,

common/utils/ocp_itti/intertask_interface.h

@@ -260,7 +260,6 @@ typedef struct IttiMsgText_s {
 #include <openair3/GTPV1-U/gtpv1u_gNB_task.h>
 void *rrc_enb_process_itti_msg(void *);
 #include <openair3/SCTP/sctp_eNB_task.h>
-#include <openair3/S1AP/s1ap_eNB.h>
 #include <openair3/NGAP/ngap_gNB.h>
 
 #ifdef ITTI_SIM

openair2/COMMON/gtpv1_u_messages_def.h

@@ -30,3 +30,4 @@ MESSAGE_DEF(GTPV1U_ENB_DATA_FORWARDING_IND, MESSAGE_PRIORITY_MED, gtpv1u_enb_dat
 MESSAGE_DEF(GTPV1U_ENB_END_MARKER_REQ,      MESSAGE_PRIORITY_MED, gtpv1u_enb_end_marker_req_t,    Gtpv1uEndMarkerReq)
 MESSAGE_DEF(GTPV1U_ENB_END_MARKER_IND,      MESSAGE_PRIORITY_MED, gtpv1u_enb_end_marker_ind_t,    Gtpv1uEndMarkerInd)
 MESSAGE_DEF(GTPV1U_ENB_S1_REQ,        MESSAGE_PRIORITY_MED, Gtpv1uS1Req,    gtpv1uS1Req)
+MESSAGE_DEF(GTPV1U_GNB_NG_REQ,        MESSAGE_PRIORITY_MED, Gtpv1uNGReq,    gtpv1uNGReq)

openair2/COMMON/gtpv1_u_messages_types.h

@@ -26,6 +26,7 @@
 
 
 #define GTPV1U_MAX_BEARERS_PER_UE max_val_LTE_DRB_Identity
+#define NR_GTPV1U_MAX_BEARERS_PER_UE max_val_NR_DRB_Identity
 
 #define GTPV1U_ENB_UPDATE_TUNNEL_REQ(mSGpTR)  (mSGpTR)->ittiMsg.Gtpv1uUpdateTunnelReq
 #define GTPV1U_ENB_UPDATE_TUNNEL_RESP(mSGpTR) (mSGpTR)->ittiMsg.Gtpv1uUpdateTunnelResp
@@ -39,6 +40,7 @@
 #define GTPV1U_ENB_END_MARKER_IND(mSGpTR)     (mSGpTR)->ittiMsg.Gtpv1uEndMarkerInd
 
 #define GTPV1U_ENB_S1_REQ(mSGpTR)    (mSGpTR)->ittiMsg.gtpv1uS1Req
+#define GTPV1U_GNB_NG_REQ(mSGpTR)    (mSGpTR)->ittiMsg.gtpv1uNGReq
 
 #define GTPV1U_ALL_TUNNELS_TEID (teid_t)0xFFFFFFFF
 
@@ -172,4 +174,25 @@ typedef struct {
   tcp_udp_port_t        enb_port_for_S1u_S12_S4_up;
 } Gtpv1uS1Req;
 
+typedef struct {
+  in_addr_t             gnb_ip_address_for_NGu_up;
+  tcp_udp_port_t        gnb_port_for_NGu_up;
+} Gtpv1uNGReq;
+typedef struct gtpv1u_gnb_create_tunnel_req_s {
+  rnti_t                 rnti;
+  int                    num_tunnels;
+  teid_t                 upf_NGu_teid[NR_GTPV1U_MAX_BEARERS_PER_UE];  ///< Tunnel Endpoint Identifier
+  pdusessionid_t         pdusession_id[NR_GTPV1U_MAX_BEARERS_PER_UE];
+  transport_layer_addr_t upf_addr[NR_GTPV1U_MAX_BEARERS_PER_UE];
+} gtpv1u_gnb_create_tunnel_req_t;
+
+typedef struct gtpv1u_gnb_create_tunnel_resp_s {
+  uint8_t                status;               ///< Status of S1U endpoint creation (Failed = 0xFF or Success = 0x0)
+  rnti_t                 rnti;
+  int                    num_tunnels;
+  teid_t                 gnb_NGu_teid[NR_GTPV1U_MAX_BEARERS_PER_UE];  ///< Tunnel Endpoint Identifier
+  pdusessionid_t         pdusession_id[NR_GTPV1U_MAX_BEARERS_PER_UE];
+  transport_layer_addr_t gnb_addr;
+} gtpv1u_gnb_create_tunnel_resp_t;
+
 #endif /* GTPV1_U_MESSAGES_TYPES_H_ */

openair2/COMMON/ngap_messages_types.h

@@ -263,8 +263,8 @@ typedef struct ngap_transport_layer_addr_s {
   } while (0)
 
 typedef struct pdusession_level_qos_parameter_s {
-  uint8_t qci;
-
+  uint8_t  qfi;
+  uint64_t fiveQI;
   ngap_allocation_retention_priority_t allocation_retention_priority;
 } pdusession_level_qos_parameter_t;
 
@@ -291,7 +291,7 @@ typedef enum pdusession_qosflow_mapping_ind_e{
 }pdusession_qosflow_mapping_ind_t;
 
 typedef struct pdusession_associate_qosflow_s{
-  uint8_t                           qci;
+  uint8_t                           qfi;
   pdusession_qosflow_mapping_ind_t  qos_flow_mapping_ind;
 }pdusession_associate_qosflow_t;
 
@@ -738,8 +738,17 @@ typedef struct ngap_ue_release_command_s {
 
 //-------------------------------------------------------------------------------------------//
 // NGAP <-- RRC messages
+typedef struct pdusession_release_s {
+  /* Unique pdusession_id for the UE. */
+  uint8_t                     pdusession_id;
+} pdusession_release_t;
+
 typedef struct ngap_ue_release_req_s {
   uint32_t             gNB_ue_ngap_id;
+  /* Number of pdusession resource in the list */
+  uint8_t              nb_of_pdusessions;
+  /* list of pdusession resource by RRC layers */
+  pdusession_release_t pdusessions[NGAP_MAX_PDUSESSION];
   ngap_Cause_t         cause;
   long                 cause_value;
 } ngap_ue_release_req_t, ngap_ue_release_resp_t;
@@ -775,11 +784,6 @@ typedef struct ngap_pdusession_modify_resp_s {
   pdusession_failed_t pdusessions_failed[NGAP_MAX_PDUSESSION];
 } ngap_pdusession_modify_resp_t;
 
-typedef struct pdusession_release_s {
-  /* Unique pdusession_id for the UE. */
-  uint8_t                     pdusession_id;
-} pdusession_release_t;
-
 typedef struct ngap_pdusession_release_command_s {
   /* AMF UE id  */
   uint64_t                       amf_ue_ngap_id:40;

openair2/COMMON/platform_constants.h

@@ -29,6 +29,7 @@
  ***************************************************************************/
 
 #include "LTE_asn_constant.h"
+#include "NR_asn_constant.h"
 
 #ifndef __PLATFORM_CONSTANTS_H__
 #    define __PLATFORM_CONSTANTS_H__
@@ -103,6 +104,7 @@
 #define DEFAULT_RAB_ID 1
 
 #define NB_RB_MAX      (LTE_maxDRB + 3) /* was 11, now 14, maxDRB comes from asn1_constants.h, + 3 because of 3 SRB, one invisible id 0, then id 1 and 2 */
+#define NR_NB_RB_MAX   (NR_maxDRB + 3)
 
 #define NB_RB_MBMS_MAX (LTE_maxSessionPerPMCH*LTE_maxServiceCount)
 

openair2/COMMON/platform_types.h

@@ -222,7 +222,7 @@ typedef enum config_action_e {
 //-----------------------------------------------------------------------------
 typedef uint32_t           teid_t; // tunnel endpoint identifier
 typedef uint8_t            ebi_t;  // eps bearer id
-
+typedef uint8_t            pdusessionid_t;
 
 
 //-----------------------------------------------------------------------------

openair2/GNB_APP/gnb_config.c

@@ -714,19 +714,19 @@ int RCconfig_nr_gtpu(void ) {
 
     if (address) {
       MessageDef *message;
+
+      if (gnb_mode == 1) { // NSA
         AssertFatal((message = itti_alloc_new_message(TASK_GNB_APP, GTPV1U_ENB_S1_REQ))!=NULL,"");
         // IPV4_STR_ADDR_TO_INT_NWBO ( address, RC.gtpv1u_data_g->enb_ip_address_for_S1u_S12_S4_up, "BAD IP ADDRESS FORMAT FOR eNB S1_U !\n" );
         // LOG_I(GTPU,"Configuring GTPu address : %s -> %x\n",address,RC.gtpv1u_data_g->enb_ip_address_for_S1u_S12_S4_up);
-
-
-      if (gnb_mode == 1) { // NSA
         IPV4_STR_ADDR_TO_INT_NWBO (address, GTPV1U_ENB_S1_REQ(message).enb_ip_address_for_S1u_S12_S4_up, "BAD IP ADDRESS FORMAT FOR eNB S1_U !\n" );
         LOG_I(GTPU,"Configuring GTPu address : %s -> %x\n",address,GTPV1U_ENB_S1_REQ(message).enb_ip_address_for_S1u_S12_S4_up);
         GTPV1U_ENB_S1_REQ(message).enb_port_for_S1u_S12_S4_up = gnb_port_for_S1U;
       } else {// TODO SA
-        IPV4_STR_ADDR_TO_INT_NWBO (address, GTPV1U_ENB_S1_REQ(message).enb_ip_address_for_S1u_S12_S4_up, "BAD IP ADDRESS FORMAT FOR gNB NG_U !\n" );
-        LOG_I(GTPU,"Configuring GTPu address : %s -> %x\n",address,GTPV1U_ENB_S1_REQ(message).enb_ip_address_for_S1u_S12_S4_up);
-        GTPV1U_ENB_S1_REQ(message).enb_port_for_S1u_S12_S4_up = gnb_port_for_NGU;
+        AssertFatal((message = itti_alloc_new_message(TASK_GNB_APP, GTPV1U_GNB_NG_REQ))!=NULL,"");
+        IPV4_STR_ADDR_TO_INT_NWBO (address, GTPV1U_GNB_NG_REQ(message).gnb_ip_address_for_NGu_up, "BAD IP ADDRESS FORMAT FOR gNB NG_U !\n" );
+        LOG_I(GTPU,"Configuring GTPu address : %s -> %x\n",address,GTPV1U_GNB_NG_REQ(message).gnb_ip_address_for_NGu_up);
+        GTPV1U_GNB_NG_REQ(message).gnb_port_for_NGu_up = gnb_port_for_NGU;
       }
 
      itti_send_msg_to_task (TASK_GTPV1_U, 0, message); // data model is wrong: gtpu doesn't have enb_id (or module_id)

openair2/RRC/NR/MESSAGES/asn1_msg.c

@@ -68,6 +68,7 @@
 #include "NR_SDAP-Config.h"
 #include "NR_RRCReconfigurationComplete.h"
 #include "NR_RRCReconfigurationComplete-IEs.h"
+#include "NR_DLInformationTransfer.h"
 #if defined(NR_Rel16)
   #include "NR_SCS-SpecificCarrier.h"
   #include "NR_TDD-UL-DL-ConfigCommon.h"
@@ -918,7 +919,7 @@ uint8_t do_NR_SA_UECapabilityEnquiry( const protocol_ctxt_t *const ctxt_pP,
 }
 
 
-uint8_t do_NR_RRCConnectionRelease(uint8_t                            *buffer,
+uint8_t do_NR_RRCRelease(uint8_t                            *buffer,
                          uint8_t                             Transaction_id) {
   asn_enc_rval_t enc_rval;
   NR_DL_DCCH_Message_t dl_dcch_msg;
@@ -927,12 +928,19 @@ uint8_t do_NR_RRCConnectionRelease(uint8_t                            *buffer,
   dl_dcch_msg.message.present           = NR_DL_DCCH_MessageType_PR_c1;
   dl_dcch_msg.message.choice.c1=CALLOC(1,sizeof(struct NR_DL_DCCH_MessageType__c1));
   dl_dcch_msg.message.choice.c1->present = NR_DL_DCCH_MessageType__c1_PR_rrcRelease;
-  dl_dcch_msg.message.choice.c1->choice.rrcRelease = CALLOC(1, sizeof(struct NR_RRCRelease));
+  dl_dcch_msg.message.choice.c1->choice.rrcRelease = CALLOC(1, sizeof(NR_RRCRelease_t));
   rrcConnectionRelease = dl_dcch_msg.message.choice.c1->choice.rrcRelease;
   // RRCConnectionRelease
   rrcConnectionRelease->rrc_TransactionIdentifier = Transaction_id;
   rrcConnectionRelease->criticalExtensions.present = NR_RRCRelease__criticalExtensions_PR_rrcRelease;
-  rrcConnectionRelease->criticalExtensions.choice.rrcRelease = NULL;
+  rrcConnectionRelease->criticalExtensions.choice.rrcRelease = CALLOC(1, sizeof(NR_RRCRelease_IEs_t));
+  rrcConnectionRelease->criticalExtensions.choice.rrcRelease->deprioritisationReq =
+      CALLOC(1, sizeof(struct NR_RRCRelease_IEs__deprioritisationReq));
+  rrcConnectionRelease->criticalExtensions.choice.rrcRelease->deprioritisationReq->deprioritisationType =
+      NR_RRCRelease_IEs__deprioritisationReq__deprioritisationType_nr;
+  rrcConnectionRelease->criticalExtensions.choice.rrcRelease->deprioritisationReq->deprioritisationTimer =
+      NR_RRCRelease_IEs__deprioritisationReq__deprioritisationTimer_min10;
+
   enc_rval = uper_encode_to_buffer(&asn_DEF_NR_DL_DCCH_Message,
                                    NULL,
                                    (void *)&dl_dcch_msg,
@@ -1260,3 +1268,64 @@ int do_DLInformationTransfer_NR (void * p) {
 	return 0;
 }
 
+//------------------------------------------------------------------------------
+uint8_t 
+do_NR_DLInformationTransfer(
+    uint8_t Mod_id,
+    uint8_t **buffer,
+    uint8_t transaction_id,
+    uint32_t pdu_length,
+    uint8_t *pdu_buffer
+)
+//------------------------------------------------------------------------------
+{
+    ssize_t encoded;
+    NR_DL_DCCH_Message_t   dl_dcch_msg;
+    memset(&dl_dcch_msg, 0, sizeof(NR_DL_DCCH_Message_t));
+    dl_dcch_msg.message.present            = NR_DL_DCCH_MessageType_PR_c1;
+    dl_dcch_msg.message.choice.c1          = CALLOC(1, sizeof(struct NR_DL_DCCH_MessageType__c1));
+    dl_dcch_msg.message.choice.c1->present = NR_DL_DCCH_MessageType__c1_PR_dlInformationTransfer;
+
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer = CALLOC(1, sizeof(NR_DLInformationTransfer_t));
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->rrc_TransactionIdentifier = transaction_id;
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->criticalExtensions.present =
+        NR_DLInformationTransfer__criticalExtensions_PR_dlInformationTransfer;
+
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->
+        criticalExtensions.choice.dlInformationTransfer = CALLOC(1, sizeof(NR_DLInformationTransfer_IEs_t));
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->
+        criticalExtensions.choice.dlInformationTransfer->dedicatedNAS_Message = CALLOC(1, sizeof(NR_DedicatedNAS_Message_t));
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->
+        criticalExtensions.choice.dlInformationTransfer->dedicatedNAS_Message->buf = pdu_buffer;
+    dl_dcch_msg.message.choice.c1->choice.dlInformationTransfer->
+        criticalExtensions.choice.dlInformationTransfer->dedicatedNAS_Message->size = pdu_length;
+
+    encoded = uper_encode_to_new_buffer (&asn_DEF_NR_DL_DCCH_Message, NULL, (void *) &dl_dcch_msg, (void **)buffer);
+    AssertFatal(encoded > 0,"ASN1 message encoding failed (%s, %lu)!\n",
+                "DLInformationTransfer", encoded);
+    LOG_D(NR_RRC,"DLInformationTransfer Encoded %zd bytes\n", encoded);
+    return encoded;
+}
+
+uint8_t do_NR_ULInformationTransfer(uint8_t **buffer, uint32_t pdu_length, uint8_t *pdu_buffer) {
+    ssize_t encoded;
+    NR_UL_DCCH_Message_t ul_dcch_msg;
+    memset(&ul_dcch_msg, 0, sizeof(NR_UL_DCCH_Message_t));
+    ul_dcch_msg.message.present           = NR_UL_DCCH_MessageType_PR_c1;
+    ul_dcch_msg.message.choice.c1          = CALLOC(1,sizeof(struct NR_UL_DCCH_MessageType__c1));
+    ul_dcch_msg.message.choice.c1->present = NR_UL_DCCH_MessageType__c1_PR_ulInformationTransfer;
+    ul_dcch_msg.message.choice.c1->choice.ulInformationTransfer = CALLOC(1,sizeof(struct NR_ULInformationTransfer));
+    ul_dcch_msg.message.choice.c1->choice.ulInformationTransfer->criticalExtensions.present = NR_ULInformationTransfer__criticalExtensions_PR_ulInformationTransfer;
+    ul_dcch_msg.message.choice.c1->choice.ulInformationTransfer->criticalExtensions.choice.ulInformationTransfer = CALLOC(1,sizeof(struct NR_ULInformationTransfer_IEs));
+    struct NR_ULInformationTransfer_IEs *ulInformationTransfer = ul_dcch_msg.message.choice.c1->choice.ulInformationTransfer->criticalExtensions.choice.ulInformationTransfer;
+    ulInformationTransfer->dedicatedNAS_Message = CALLOC(1,sizeof(NR_DedicatedNAS_Message_t));
+    ulInformationTransfer->dedicatedNAS_Message->buf = pdu_buffer;
+    ulInformationTransfer->dedicatedNAS_Message->size = pdu_length;
+    ulInformationTransfer->lateNonCriticalExtension = NULL;
+    encoded = uper_encode_to_new_buffer (&asn_DEF_NR_UL_DCCH_Message, NULL, (void *) &ul_dcch_msg, (void **) buffer);
+    AssertFatal(encoded > 0,"ASN1 message encoding failed (%s, %lu)!\n",
+                "ULInformationTransfer",encoded);
+    LOG_D(NR_RRC,"ULInformationTransfer Encoded %zd bytes\n",encoded);
+
+    return encoded;
+}

openair2/RRC/NR/MESSAGES/asn1_msg.h

@@ -103,7 +103,7 @@ uint8_t do_NR_SA_UECapabilityEnquiry( const protocol_ctxt_t *const ctxt_pP,
                                    uint8_t               *const buffer,
                                    const uint8_t                Transaction_id);
 
-uint8_t do_NR_RRCConnectionRelease(uint8_t *buffer,
+uint8_t do_NR_RRCRelease(uint8_t *buffer,
                          uint8_t Transaction_id);
 uint16_t do_RRCReconfiguration(
                     const protocol_ctxt_t        *const ctxt_pP,
@@ -126,3 +126,16 @@ uint8_t do_NR_RRCReconfigurationComplete(
                         uint8_t *buffer,
                         const uint8_t Transaction_id
                       );
+
+uint8_t 
+do_NR_DLInformationTransfer(
+    uint8_t Mod_id,
+    uint8_t **buffer,
+    uint8_t transaction_id,
+    uint32_t pdu_length,
+    uint8_t *pdu_buffer
+);
+
+uint8_t do_NR_ULInformationTransfer(uint8_t **buffer, 
+                        uint32_t pdu_length,
+                        uint8_t *pdu_buffer);
\ No newline at end of file

openair2/RRC/NR/nr_rrc_defs.h

@@ -257,6 +257,21 @@ typedef struct nr_rrc_guami_s {
   uint8_t  amf_pointer;
 } nr_rrc_guami_t;
 
+typedef enum pdu_session_satus_e {
+  PDU_SESSION_STATUS_NEW,
+  PDU_SESSION_STATUS_DONE,
+  PDU_SESSION_STATUS_ESTABLISHED,
+  PDU_SESSION_STATUS_FAILED,
+} pdu_session_status_t;
+
+typedef struct pdu_session_param_s {
+  pdusession_t param;
+  uint8_t status;
+  uint8_t xid; // transaction_id
+  ngap_Cause_t cause;
+  uint8_t cause_value;
+} __attribute__ ((__packed__)) pdu_session_param_t;
+
 typedef struct gNB_RRC_UE_s {
   uint8_t                            primaryCC_id;
   LTE_SCellToAddMod_r10_t            sCell_config[2];
@@ -325,12 +340,16 @@ typedef struct gNB_RRC_UE_s {
   uint8_t                           setup_e_rabs;
   /* Number of e_rab to be setup in the list */
   uint8_t                            nb_of_e_rabs;
+  /* Total number of pdu session already setup in the list */
+  uint8_t                           setup_pdu_sessions;
+  /* Number of pdu session to be setup in the list */
+  uint8_t                            nb_of_pdusessions;
   /* Number of e_rab to be modified in the list */
   uint8_t                            nb_of_modify_e_rabs;
   uint8_t                            nb_of_failed_e_rabs;
   e_rab_param_t                      modify_e_rab[NB_RB_MAX];//[S1AP_MAX_E_RAB];
   /* list of e_rab to be setup by RRC layers */
-  e_rab_param_t                      e_rab[NB_RB_MAX];//[S1AP_MAX_E_RAB];
+  pdu_session_param_t                pdusession[NR_NB_RB_MAX];//[NGAP_MAX_PDU_SESSION];
   //release e_rabs
   uint8_t                            nb_release_of_e_rabs;
   e_rab_failed_t                     e_rabs_release_failed[S1AP_MAX_E_RAB];
@@ -338,12 +357,15 @@ typedef struct gNB_RRC_UE_s {
   uint32_t                           gnb_gtp_teid[S1AP_MAX_E_RAB];
   transport_layer_addr_t             gnb_gtp_addrs[S1AP_MAX_E_RAB];
   rb_id_t                            gnb_gtp_ebi[S1AP_MAX_E_RAB];
+  rb_id_t                            gnb_gtp_psi[S1AP_MAX_E_RAB];
 
   uint32_t                           ul_failure_timer;
   uint32_t                           ue_release_timer;
   uint32_t                           ue_release_timer_thres;
   uint32_t                           ue_release_timer_s1;
   uint32_t                           ue_release_timer_thres_s1;
+  uint32_t                           ue_release_timer_ng;
+  uint32_t                           ue_release_timer_thres_ng;
   uint32_t                           ue_release_timer_rrc;
   uint32_t                           ue_release_timer_thres_rrc;
   uint32_t                           ue_reestablishment_timer;
@@ -424,6 +446,8 @@ typedef struct gNB_RRC_INST_s {
   int                                                 Nb_ue;
   hash_table_t                                        *initial_id2_s1ap_ids; // key is    content is rrc_ue_s1ap_ids_t
   hash_table_t                                        *s1ap_id2_s1ap_ids   ; // key is    content is rrc_ue_s1ap_ids_t
+  hash_table_t                                        *initial_id2_ngap_ids;
+  hash_table_t                                        *ngap_id2_ngap_ids   ;
 
   // other PLMN parameters
   /// Mobile country code
@@ -444,7 +468,6 @@ typedef struct gNB_RRC_INST_s {
 
 } gNB_RRC_INST;
 
-
 #include "nr_rrc_proto.h" //should be put here otherwise compilation error
 
 #endif

openair2/RRC/NR/nr_rrc_proto.h

@@ -110,7 +110,11 @@ rrc_gNB_generate_UECapabilityEnquiry(
   rrc_gNB_ue_context_t  *const ue_context_pP
 );
 
-void nr_rrc_rx_tx(void);
+void
+rrc_gNB_generate_RRCRelease(
+  const protocol_ctxt_t *const ctxt_pP,
+  rrc_gNB_ue_context_t  *const ue_context_pP
+);
 
 /**\brief RRC eNB task.
    \param void *args_p Pointer on arguments to start the task. */

openair2/RRC/NR/rrc_gNB.c

@@ -295,6 +295,8 @@ char openair_rrc_gNB_configuration(const module_id_t gnb_mod_idP, gNB_RrcConfigu
   RB_INIT(&rrc->rrc_ue_head);
   rrc->initial_id2_s1ap_ids = hashtable_create (NUMBER_OF_UE_MAX * 2, NULL, NULL);
   rrc->s1ap_id2_s1ap_ids    = hashtable_create (NUMBER_OF_UE_MAX * 2, NULL, NULL);
+  rrc->initial_id2_ngap_ids = hashtable_create (NUMBER_OF_UE_MAX * 2, NULL, NULL);
+  rrc->ngap_id2_ngap_ids    = hashtable_create (NUMBER_OF_UE_MAX * 2, NULL, NULL);
   rrc->carrier.servingcellconfigcommon = configuration->scc;
   rrc->carrier.ssb_SubcarrierOffset = configuration->ssb_SubcarrierOffset;
   rrc->carrier.pdsch_AntennaPorts = configuration->pdsch_AntennaPorts;
@@ -1340,6 +1342,14 @@ void *rrc_gnb_task(void *args_p) {
                             NR_RRC_DCCH_DATA_IND(msg_p).sdu_size);
         break;
 
+      case NGAP_DOWNLINK_NAS:
+        rrc_gNB_process_NGAP_DOWNLINK_NAS(msg_p, msg_name_p, instance, &rrc_gNB_mui);
+        break;
+
+      case NGAP_PDUSESSION_SETUP_REQ:
+        rrc_gNB_process_NGAP_PDUSESSION_SETUP_REQ(msg_p, msg_name_p, instance);
+        break;
+
       /*
       #if defined(ENABLE_USE_MME)
 
@@ -1428,6 +1438,14 @@ void *rrc_gnb_task(void *args_p) {
         /* nothing to do? */
         break;
 
+      case NGAP_UE_CONTEXT_RELEASE_REQ:
+        rrc_gNB_process_NGAP_UE_CONTEXT_RELEASE_REQ(msg_p, msg_name_p, instance);
+        break;
+
+      case NGAP_UE_CONTEXT_RELEASE_COMMAND:
+        rrc_gNB_process_NGAP_UE_CONTEXT_RELEASE_COMMAND(msg_p, msg_name_p, instance);
+        break;
+
       default:
         LOG_E(NR_RRC, "[gNB %d] Received unexpected message %s\n", instance, msg_name_p);
         break;
@@ -1566,7 +1584,7 @@ rrc_gNB_generate_UECapabilityEnquiry(
 * If received, UE should switch to RRC_IDLE mode.
 */
 void
-rrc_gNB_generate_RRCConnectionRelease(
+rrc_gNB_generate_RRCRelease(
   const protocol_ctxt_t *const ctxt_pP,
   rrc_gNB_ue_context_t  *const ue_context_pP
 )
@@ -1577,16 +1595,16 @@ rrc_gNB_generate_RRCConnectionRelease(
 
   memset(buffer, 0, RRC_BUF_SIZE);
 
-  size = do_NR_RRCConnectionRelease(buffer,rrc_gNB_get_next_transaction_identifier(ctxt_pP->module_id));
+  size = do_NR_RRCRelease(buffer,rrc_gNB_get_next_transaction_identifier(ctxt_pP->module_id));
   ue_context_pP->ue_context.ue_reestablishment_timer = 0;
   ue_context_pP->ue_context.ue_release_timer = 0;
   LOG_I(NR_RRC,
-        PROTOCOL_RRC_CTXT_UE_FMT" Logical Channel DL-DCCH, Generate RRCConnectionRelease (bytes %d)\n",
-        PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),
+        PROTOCOL_NR_RRC_CTXT_UE_FMT" Logical Channel DL-DCCH, Generate RRCRelease (bytes %d)\n",
+        PROTOCOL_NR_RRC_CTXT_UE_ARGS(ctxt_pP),
         size);
   LOG_D(NR_RRC,
-        PROTOCOL_RRC_CTXT_UE_FMT" --- PDCP_DATA_REQ/%d Bytes (rrcConnectionRelease MUI %d) --->[PDCP][RB %u]\n",
-        PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),
+        PROTOCOL_NR_RRC_CTXT_UE_FMT" --- PDCP_DATA_REQ/%d Bytes (rrcRelease MUI %d) --->[PDCP][RB %u]\n",
+        PROTOCOL_NR_RRC_CTXT_UE_ARGS(ctxt_pP),
         size,
         rrc_gNB_mui,
         DCCH);
@@ -1595,14 +1613,25 @@ rrc_gNB_generate_RRCConnectionRelease(
     MSC_RRC_UE,
     buffer,
     size,
-    MSC_AS_TIME_FMT" LTE_RRCConnectionRelease UE %x MUI %d size %u",
+    MSC_AS_TIME_FMT" NR_RRCRelease UE %x MUI %d size %u",
     MSC_AS_TIME_ARGS(ctxt_pP),
     ue_context_pP->ue_context.rnti,
     rrc_gNB_mui,
     size);
 
+#ifdef ITTI_SIM
+    MessageDef *message_p;
+    uint8_t *message_buffer;
+    message_buffer = itti_malloc (TASK_RRC_GNB, TASK_RRC_UE_SIM, size);
+    memcpy (message_buffer, buffer, size);
+    message_p = itti_alloc_new_message (TASK_RRC_GNB, GNB_RRC_DCCH_DATA_IND);
+    GNB_RRC_DCCH_DATA_IND (message_p).rbid = DCCH;
+    GNB_RRC_DCCH_DATA_IND (message_p).sdu = message_buffer;
+    GNB_RRC_DCCH_DATA_IND (message_p).size  = size;
+    itti_send_msg_to_task (TASK_RRC_UE_SIM, ctxt_pP->instance, message_p);
+#else
   if (NODE_IS_CU(RC.rrc[ctxt_pP->module_id]->node_type)) {
-    MessageDef *m = itti_alloc_new_message(TASK_RRC_ENB, F1AP_UE_CONTEXT_RELEASE_CMD);
+    MessageDef *m = itti_alloc_new_message(TASK_RRC_GNB, F1AP_UE_CONTEXT_RELEASE_CMD);
     F1AP_UE_CONTEXT_RELEASE_CMD(m).rnti = ctxt_pP->rnti;
     F1AP_UE_CONTEXT_RELEASE_CMD(m).cause = F1AP_CAUSE_RADIO_NETWORK;
     F1AP_UE_CONTEXT_RELEASE_CMD(m).cause_value = 10; // 10 = F1AP_CauseRadioNetwork_normal_release
@@ -1618,6 +1647,7 @@ rrc_gNB_generate_RRCConnectionRelease(
                  buffer,
                  PDCP_TRANSMISSION_MODE_CONTROL);
   }
+#endif
 }
 void nr_rrc_trigger(protocol_ctxt_t *ctxt, int CC_id, int frame, int subframe)
 {

openair2/RRC/NR/rrc_gNB_GTPV1U.c

@@ -92,3 +92,52 @@ rrc_gNB_process_GTPV1U_CREATE_TUNNEL_RESP(
     return -1;
   }
 }
+
+int
+nr_rrc_gNB_process_GTPV1U_CREATE_TUNNEL_RESP(
+  const protocol_ctxt_t *const ctxt_pP,
+  const gtpv1u_gnb_create_tunnel_resp_t *const create_tunnel_resp_pP,
+  uint8_t                         *inde_list
+) {
+  rnti_t                         rnti;
+  int                            i;
+  struct rrc_gNB_ue_context_s   *ue_context_p = NULL;
+
+  if (create_tunnel_resp_pP) {
+    LOG_D(NR_RRC, PROTOCOL_NR_RRC_CTXT_UE_FMT" RX CREATE_TUNNEL_RESP num tunnels %u \n",
+          PROTOCOL_NR_RRC_CTXT_UE_ARGS(ctxt_pP),
+          create_tunnel_resp_pP->num_tunnels);
+    rnti = create_tunnel_resp_pP->rnti;
+    ue_context_p = rrc_gNB_get_ue_context(
+                     RC.nrrrc[ctxt_pP->module_id],
+                     ctxt_pP->rnti);
+
+    for (i = 0; i < create_tunnel_resp_pP->num_tunnels; i++) {
+      ue_context_p->ue_context.gnb_gtp_teid[inde_list[i]]  = create_tunnel_resp_pP->gnb_NGu_teid[i];
+      ue_context_p->ue_context.gnb_gtp_addrs[inde_list[i]] = create_tunnel_resp_pP->gnb_addr;
+      ue_context_p->ue_context.gnb_gtp_psi[inde_list[i]]   = create_tunnel_resp_pP->pdusession_id[i];
+      LOG_I(NR_RRC, PROTOCOL_NR_RRC_CTXT_UE_FMT" nr_rrc_gNB_process_GTPV1U_CREATE_TUNNEL_RESP tunnel (%u, %u) bearer UE context index %u, msg index %u, id %u, gtp addr len %d \n",
+            PROTOCOL_NR_RRC_CTXT_UE_ARGS(ctxt_pP),
+            create_tunnel_resp_pP->gnb_NGu_teid[i],
+            ue_context_p->ue_context.gnb_gtp_teid[inde_list[i]],
+            inde_list[i],
+            i,
+            create_tunnel_resp_pP->pdusession_id[i],
+            create_tunnel_resp_pP->gnb_addr.length);
+    }
+
+  MSC_LOG_RX_MESSAGE(
+        MSC_RRC_GNB,
+        MSC_GTPU_GNB,
+        NULL,0,
+        MSC_AS_TIME_FMT" CREATE_TUNNEL_RESP RNTI %"PRIx16" ntuns %u psid %u enb-s1u teid %u",
+        0,0,rnti,
+        create_tunnel_resp_pP->num_tunnels,
+        ue_context_p->ue_context.gnb_gtp_psi[0],
+        ue_context_p->ue_context.gnb_gtp_teid[0]);
+        (void)rnti; /* avoid gcc warning "set but not used" */
+    return 0;
+  } else {
+    return -1;
+  }
+}

openair2/RRC/NR/rrc_gNB_GTPV1U.h

@@ -37,3 +37,12 @@ rrc_gNB_process_GTPV1U_CREATE_TUNNEL_RESP(
   const gtpv1u_enb_create_tunnel_resp_t *const create_tunnel_resp_pP,
   uint8_t                         *inde_list
 );
+
+int
+nr_rrc_gNB_process_GTPV1U_CREATE_TUNNEL_RESP(
+  const protocol_ctxt_t *const ctxt_pP,
+  const gtpv1u_gnb_create_tunnel_resp_t *const create_tunnel_resp_pP,
+  uint8_t                         *inde_list
+);
+
+#endif

openair2/RRC/NR/rrc_gNB_NGAP.h

@@ -37,6 +37,7 @@
 
 #include "NR_RRCSetupComplete-IEs.h"
 #include "NR_RegisteredAMF.h"
+#include "NR_UL-DCCH-Message.h"
 
 typedef struct rrc_ue_ngap_ids_s {
   /* Tree related data */
@@ -77,4 +78,68 @@ rrc_gNB_process_security(
   ngap_security_capabilities_t *security_capabilities_pP
 );
 
+int
+rrc_gNB_process_NGAP_DOWNLINK_NAS(
+  MessageDef *msg_p,
+  const char *msg_name,
+  instance_t  instance,
+  mui_t      *rrc_gNB_mui
+);
+
+void
+rrc_gNB_send_NGAP_UPLINK_NAS(
+  const protocol_ctxt_t    *const ctxt_pP,
+  rrc_gNB_ue_context_t     *const ue_context_pP,
+  NR_UL_DCCH_Message_t     *const ul_dcch_msg
+);
+
+void
+rrc_gNB_send_NGAP_PDUSESSION_SETUP_RESP(
+  const protocol_ctxt_t    *const ctxt_pP,
+  rrc_gNB_ue_context_t     *const ue_context_pP,
+  uint8_t                   xid
+);
+
+int
+rrc_gNB_process_NGAP_PDUSESSION_SETUP_REQ(
+    MessageDef *msg_p,
+    const char *msg_name,
+    instance_t instance
+);
+
+void
+rrc_gNB_send_NGAP_UE_CONTEXT_RELEASE_REQ(
+  const module_id_t gnb_mod_idP,
+  const rrc_gNB_ue_context_t *const ue_context_pP,
+  const ngap_Cause_t causeP,
+  const long cause_valueP
+);
+
+int 
+rrc_gNB_process_NGAP_UE_CONTEXT_RELEASE_REQ (
+  MessageDef *msg_p, 
+  const char *msg_name, 
+  instance_t instance
+);
+
+int
+rrc_gNB_process_NGAP_UE_CONTEXT_RELEASE_COMMAND(
+  MessageDef *msg_p,
+  const char *msg_name,
+  instance_t instance
+);
+
+void
+rrc_gNB_NGAP_remove_ue_ids(
+  gNB_RRC_INST *const rrc_instance_pP,
+  struct rrc_ue_ngap_ids_s *const ue_ids_pP
+);
+
+void
+rrc_gNB_send_NGAP_UE_CAPABILITIES_IND(
+  const protocol_ctxt_t    *const ctxt_pP,
+  rrc_gNB_ue_context_t     *const ue_context_pP,
+  NR_UL_DCCH_Message_t     *const ul_dcch_msg
+);
+
 #endif

openair2/RRC/NR/rrc_gNB_UE_context.c

@@ -134,7 +134,7 @@ rrc_gNB_allocate_new_UE_context(
   new_p->local_uid = nr_uid_linear_allocator_new(rrc_instance_pP);
 
   for(int i = 0; i < NB_RB_MAX; i++) {
-    new_p->ue_context.e_rab[i].xid = -1;
+    new_p->ue_context.pdusession[i].xid = -1;
     new_p->ue_context.modify_e_rab[i].xid = -1;
   }
 

openair2/RRC/NR/rrc_gNB_nsa.c

@@ -184,14 +184,14 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
     if (m->nb_e_rabs_tobeadded>0) {
       for (int i=0; i<m->nb_e_rabs_tobeadded; i++) {
         // Add the new E-RABs at the corresponding rrc ue context of the gNB
-        ue_context_p->ue_context.e_rab[i].param.e_rab_id = m->e_rabs_tobeadded[i].e_rab_id;
-        ue_context_p->ue_context.e_rab[i].param.gtp_teid = m->e_rabs_tobeadded[i].gtp_teid;
-        memcpy(&ue_context_p->ue_context.e_rab[i].param.sgw_addr, &m->e_rabs_tobeadded[i].sgw_addr, sizeof(transport_layer_addr_t));
-        ue_context_p->ue_context.nb_of_e_rabs++;
+        ue_context_p->ue_context.pdusession[i].param.pdusession_id = m->e_rabs_tobeadded[i].e_rab_id;
+        ue_context_p->ue_context.pdusession[i].param.gtp_teid = m->e_rabs_tobeadded[i].gtp_teid;
+        memcpy(&ue_context_p->ue_context.pdusession[i].param.upf_addr, &m->e_rabs_tobeadded[i].sgw_addr, sizeof(transport_layer_addr_t));
+        ue_context_p->ue_context.nb_of_pdusessions++;
         //Fill the required E-RAB specific information for the creation of the S1-U tunnel between the gNB and the SGW
-        create_tunnel_req.eps_bearer_id[i]       = ue_context_p->ue_context.e_rab[i].param.e_rab_id;
-        create_tunnel_req.sgw_S1u_teid[i]        = ue_context_p->ue_context.e_rab[i].param.gtp_teid;
-        memcpy(&create_tunnel_req.sgw_addr[i], &ue_context_p->ue_context.e_rab[i].param.sgw_addr, sizeof(transport_layer_addr_t));
+        create_tunnel_req.eps_bearer_id[i]       = ue_context_p->ue_context.pdusession[i].param.pdusession_id;
+        create_tunnel_req.sgw_S1u_teid[i]        = ue_context_p->ue_context.pdusession[i].param.gtp_teid;
+        memcpy(&create_tunnel_req.sgw_addr[i], &ue_context_p->ue_context.pdusession[i].param.upf_addr, sizeof(transport_layer_addr_t));
         inde_list[i] = i;
         LOG_I(RRC,"S1-U tunnel: index %d target sgw ip %d.%d.%d.%d length %d gtp teid %u\n",
               i,
@@ -218,8 +218,8 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
       X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).nb_e_rabs_admitted_tobeadded = m->nb_e_rabs_tobeadded;
       X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).target_assoc_id = m->target_assoc_id;
 
-      for(int i=0; i<ue_context_p->ue_context.nb_of_e_rabs; i++) {
-        X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).e_rabs_admitted_tobeadded[i].e_rab_id = ue_context_p->ue_context.e_rab[i].param.e_rab_id;
+      for(int i=0; i<ue_context_p->ue_context.nb_of_pdusessions; i++) {
+        X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).e_rabs_admitted_tobeadded[i].e_rab_id = ue_context_p->ue_context.pdusession[i].param.pdusession_id;
         X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).e_rabs_admitted_tobeadded[i].gtp_teid = create_tunnel_resp.enb_S1u_teid[i];
         memcpy(&X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).e_rabs_admitted_tobeadded[i].gnb_addr, &create_tunnel_resp.enb_addr, sizeof(transport_layer_addr_t));
         //The length field in the X2AP targetting structure is expected in bits but the create_tunnel_resp returns the address length in bytes

openair2/RRC/NR_UE/rrc_defs.h

@@ -126,6 +126,9 @@ typedef struct NR_UE_RRC_INST_s {
 
     /* KeNB as computed from parameters within USIM card */
     uint8_t kgnb[32];
+
+    /* Used integrity/ciphering algorithms */
+    //RRC_LIST_TYPE(NR_SecurityAlgorithmConfig_t, NR_SecurityAlgorithmConfig) SecurityAlgorithmConfig_list;
     NR_CipheringAlgorithm_t  cipheringAlgorithm;
     e_NR_IntegrityProtAlgorithm  integrityProtAlgorithm;
     

openair2/SIMULATION/NR_RRC/itti_sim.c

@@ -299,7 +299,7 @@ int create_gNB_tasks(uint32_t gnb_nb) {
         }
       }
 
-      if (itti_create_task (TASK_GTPV1_U, &gtpv1u_gNB_task, NULL) < 0) {
+      if (itti_create_task (TASK_GTPV1_U, &nr_gtpv1u_gNB_task, NULL) < 0) {
         LOG_E(GTPU, "Create task for GTPV1U failed\n");
         return -1;
       }
@@ -435,14 +435,14 @@ void *itti_sim_ue_rrc_task( void *args_p) {
         LOG_D(NR_RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p));
         break;
       case GNB_RRC_BCCH_DATA_IND:
-          message_p = itti_alloc_new_message (TASK_RRC_NRUE, NR_RRC_MAC_BCCH_DATA_IND);
+          message_p = itti_alloc_new_message (TASK_RRC_UE_SIM, NR_RRC_MAC_BCCH_DATA_IND);
           memset (NR_RRC_MAC_BCCH_DATA_IND (message_p).sdu, 0, BCCH_SDU_SIZE);
           NR_RRC_MAC_BCCH_DATA_IND (message_p).sdu_size  = GNB_RRC_BCCH_DATA_IND(msg_p).size;
           memcpy (NR_RRC_MAC_BCCH_DATA_IND (message_p).sdu, GNB_RRC_BCCH_DATA_IND(msg_p).sdu, GNB_RRC_BCCH_DATA_IND(msg_p).size);
           itti_send_msg_to_task (TASK_RRC_NRUE, instance, message_p);
         break;
       case GNB_RRC_CCCH_DATA_IND:
-        message_p = itti_alloc_new_message (TASK_RRC_NRUE, NR_RRC_MAC_CCCH_DATA_IND);
+        message_p = itti_alloc_new_message (TASK_RRC_UE_SIM, NR_RRC_MAC_CCCH_DATA_IND);
         printf("receive GNB_RRC_CCCH_DATA_IND\n");
         memset (NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu, 0, CCCH_SDU_SIZE);
         memcpy (NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu, GNB_RRC_CCCH_DATA_IND(msg_p).sdu, GNB_RRC_CCCH_DATA_IND(msg_p).size);
@@ -451,7 +451,7 @@ void *itti_sim_ue_rrc_task( void *args_p) {
         break;
       case GNB_RRC_DCCH_DATA_IND:
         printf("receive GNB_RRC_DCCH_DATA_IND\n");
-        message_p = itti_alloc_new_message (TASK_RRC_NRUE, NR_RRC_DCCH_DATA_IND);
+        message_p = itti_alloc_new_message (TASK_RRC_UE_SIM, NR_RRC_DCCH_DATA_IND);
         NR_RRC_DCCH_DATA_IND (message_p).dcch_index = GNB_RRC_DCCH_DATA_IND(msg_p).rbid;
         NR_RRC_DCCH_DATA_IND (message_p).sdu_size   = GNB_RRC_DCCH_DATA_IND(msg_p).size;
         NR_RRC_DCCH_DATA_IND (message_p).sdu_p      = GNB_RRC_DCCH_DATA_IND(msg_p).sdu;
@@ -492,14 +492,14 @@ void *itti_sim_gnb_rrc_task( void *args_p) {
         LOG_D(NR_RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p));
         break;
       case UE_RRC_CCCH_DATA_IND:
-          message_p = itti_alloc_new_message (TASK_RRC_GNB, NR_RRC_MAC_CCCH_DATA_IND);
+          message_p = itti_alloc_new_message (TASK_RRC_GNB_SIM, NR_RRC_MAC_CCCH_DATA_IND);
           NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu_size = UE_RRC_CCCH_DATA_IND(msg_p).size;
           memset (NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu, 0, CCCH_SDU_SIZE);
           memcpy (NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu, UE_RRC_CCCH_DATA_IND(msg_p).sdu, UE_RRC_CCCH_DATA_IND(msg_p).size);
           itti_send_msg_to_task (TASK_RRC_GNB, instance, message_p);
            break;
       case UE_RRC_DCCH_DATA_IND:
-    	    message_p = itti_alloc_new_message (TASK_RRC_GNB, NR_RRC_DCCH_DATA_IND);
+    	    message_p = itti_alloc_new_message (TASK_RRC_GNB_SIM, NR_RRC_DCCH_DATA_IND);
     	    NR_RRC_DCCH_DATA_IND (message_p).sdu_size   = UE_RRC_DCCH_DATA_IND(msg_p).size;
           NR_RRC_DCCH_DATA_IND (message_p).dcch_index = UE_RRC_DCCH_DATA_IND(msg_p).rbid;
           NR_RRC_DCCH_DATA_IND (message_p).sdu_p      = UE_RRC_DCCH_DATA_IND(msg_p).sdu;
@@ -542,8 +542,9 @@ int main( int argc, char **argv )
     exit(-1);
   }
 
-  // AMF_MODE_ENABLED = !IS_SOFTMODEM_NOS1;
-  AMF_MODE_ENABLED = 0;
+  AMF_MODE_ENABLED = !IS_SOFTMODEM_NOS1;
+ // AMF_MODE_ENABLED = 0;
+  NGAP_CONF_MODE   = !IS_SOFTMODEM_NOS1; //!get_softmodem_params()->phy_test;
 
 #if T_TRACER
   T_Config_Init();

openair2/UTIL/OSA/osa_defs.h

@@ -55,6 +55,8 @@ typedef enum {
 
 int derive_key(algorithm_type_dist_t nas_alg_type, uint8_t nas_enc_alg_id,
                const uint8_t key[32], uint8_t **out);
+int nr_derive_key(algorithm_type_dist_t alg_type, uint8_t alg_id,
+               const uint8_t key[32], uint8_t **out);
 
 //#define derive_key_nas_enc(aLGiD, kEY, kNAS)    derive_key(NAS_ENC_ALG, aLGiD, kEY, kNAS)
 
@@ -72,6 +74,19 @@ int derive_key(algorithm_type_dist_t nas_alg_type, uint8_t nas_enc_alg_id,
 #define derive_key_up_int(aLGiD, kEY, kNAS)  \
     derive_key(UP_INT_ALG, aLGiD, kEY, kNAS)
 
+// 5G SA
+#define nr_derive_key_rrc_enc(aLGiD, kEY, kRRC)  \
+    nr_derive_key(RRC_ENC_ALG, aLGiD, kEY, kRRC)
+
+#define nr_derive_key_rrc_int(aLGiD, kEY, kRRC)  \
+    nr_derive_key(RRC_INT_ALG, aLGiD, kEY, kRRC)
+
+#define nr_derive_key_up_enc(aLGiD, kEY, kUP)  \
+    nr_derive_key(UP_ENC_ALG, aLGiD, kEY, kUP)
+
+#define nr_derive_key_up_int(aLGiD, kEY, kUP)  \
+    nr_derive_key(UP_INT_ALG, aLGiD, kEY, kUP)
+
 typedef struct {
   uint8_t  *key;
   uint32_t  key_length;

openair2/UTIL/OSA/osa_internal.h

@@ -36,6 +36,8 @@
 #define FC_ALG_KEY_DER  (0x15)
 #define FC_KASME_TO_CK  (0x16)
 
+#define NR_FC_ALG_KEY_DER  (0x69)
+
 #ifndef hton_int32
 # define hton_int32(x)   \
 (((x & 0x000000FF) << 24) | ((x & 0x0000FF00) << 8) |  \

openair2/UTIL/OSA/osa_key_deriver.c

@@ -97,6 +97,34 @@ int derive_key(algorithm_type_dist_t alg_type, uint8_t alg_id,
 
   return 0;
 }
+
+int nr_derive_key(algorithm_type_dist_t alg_type, uint8_t alg_id,
+               const uint8_t key[32], uint8_t **out)
+{
+  uint8_t string[7];
+
+  /* FC */
+  string[0] = NR_FC_ALG_KEY_DER;
+
+  /* P0 = algorithm type distinguisher */
+  string[1] = (uint8_t)(alg_type & 0xFF);
+
+  /* L0 = length(P0) = 1 */
+  string[2] = 0x00;
+  string[3] = 0x01;
+
+  /* P1 */
+  string[4] = alg_id;
+
+  /* L1 = length(P1) = 1 */
+  string[5] = 0x00;
+  string[6] = 0x01;
+
+  kdf(string, 7, key, 32, out, 32);
+
+  return 0;
+}
+
 /*
 int derive_keNB(const uint8_t key[32], const uint32_t nas_count, uint8_t **keNB)
 {

openair3/GTPV1-U/gtpv1u_gNB_defs.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/*! \file gtpv1u_gNB_defs.h
+ * \brief 
+ * \author Yoshio INOUE, Masayuki HARADA
+ * \date 2020
+ * \version 0.1
+ * \email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+ *         (yoshio.inoue%40fujitsu.com%2cmasayuki.harada%40fujitsu.com) 
+ */
+
+#include "hashtable.h"
+#include "NR_asn_constant.h"
+
+#ifndef GTPV1U_GNB_DEFS_H_
+#define GTPV1U_GNB_DEFS_H_
+
+#include "NwGtpv1u.h"
+
+#define GTPV1U_UDP_PORT (2152)
+
+#define NR_GTPV1U_MAX_BEARERS_ID     (max_val_NR_DRB_Identity - 3)
+
+#define GTPV1U_SOURCE_GNB (0)
+#define GTPV1U_TARGET_GNB (1)
+#define GTPV1U_MSG_FROM_SOURCE_GNB (0)
+#define GTPV1U_MSG_FROM_UPF (1)
+
+
+typedef struct nr_gtpv1u_teid_data_s {
+  /* UE identifier for oaisim stack */
+  module_id_t     gnb_id;
+  rnti_t          ue_id;
+  pdusessionid_t  pdu_session_id;
+} nr_gtpv1u_teid_data_t;
+
+
+typedef struct nr_gtpv1u_bearer_s {
+  /* TEID used in dl and ul */
+  teid_t          teid_gNB;                ///< gNB TEID
+  uintptr_t       teid_gNB_stack_session;  ///< gNB TEID
+  teid_t          teid_upf;                ///< Remote TEID
+  in_addr_t       upf_ip_addr;
+  struct in6_addr upf_ip6_addr;
+  teid_t          teid_tgNB;
+  in_addr_t       tgnb_ip_addr;				///< target gNB ipv4
+  struct in6_addr tgnb_ip6_addr;				///< target gNB ipv6
+  tcp_udp_port_t  port;
+  //NwGtpv1uStackSessionHandleT stack_session;
+  bearer_state_t state;
+} nr_gtpv1u_bearer_t;
+
+typedef struct nr_gtpv1u_ue_data_s {
+  /* UE identifier for oaisim stack */
+  rnti_t   ue_id;
+
+  /* Unique identifier used between PDCP and GTP-U to distinguish UEs */
+  uint32_t instance_id;
+  int      num_bearers;
+  /* Bearer related data.
+   * Note that the first LCID available for data is 3 and we fixed the maximum
+   * number of e-rab per UE to be (32 [id range]), max RB is 11. The real rb id will 3 + rab_id (3..32).
+   */
+  nr_gtpv1u_bearer_t bearers[NR_GTPV1U_MAX_BEARERS_ID];
+
+  //RB_ENTRY(gtpv1u_ue_data_s) gtpv1u_ue_node;
+} nr_gtpv1u_ue_data_t;
+
+typedef struct nr_gtpv1u_data_s {
+  /* nwgtpv1u stack internal data */
+  NwGtpv1uStackHandleT  gtpv1u_stack;
+
+  /* RB tree of UEs */
+  hash_table_t         *ue_mapping;   // PDCP->GTPV1U
+  hash_table_t         *teid_mapping; // GTPV1U -> PDCP
+
+  //RB_HEAD(gtpv1u_ue_map, gtpv1u_ue_data_s) gtpv1u_ue_map_head;
+  /* Local IP address to use */
+  in_addr_t             gnb_ip_address_for_NGu_up;
+  /* UDP internal data */
+  //udp_data_t            udp_data;
+
+  uint16_t              seq_num;
+  uint8_t               restart_counter;
+
+#ifdef GTPU_IN_KERNEL
+  char                 *interface_name;
+  int                   interface_index;
+
+  struct iovec         *malloc_ring;
+  void                 *sock_mmap_ring[16];
+  int                   sock_desc[16]; // indexed by marking
+#endif
+} nr_gtpv1u_data_t;
+
+
+#endif /* GTPV1U_GNB_DEFS_H_ */

openair3/GTPV1-U/gtpv1u_gNB_task.h

@@ -32,6 +32,13 @@ int   gtpv1u_gNB_init(void);
 
 void *gtpv1u_gNB_task(void *args);
 
+void *nr_gtpv1u_gNB_task(void *args);
+
+int
+gtpv1u_create_ngu_tunnel(
+  const instance_t instanceP,
+  const gtpv1u_gnb_create_tunnel_req_t *  const create_tunnel_req_pP,
+        gtpv1u_gnb_create_tunnel_resp_t * const create_tunnel_resp_pP);
 
 #endif /* GTPV1U_GNB_TASK_H_ */
 

openair3/NAS/COMMON/EMM/MSG/FGSAuthenticationResponse.c

+/*! \file FGSAuthenticationResponse.c
+
+\brief authentication response procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "nas_log.h"
+
+#include "FGSAuthenticationResponse.h"
+
+
+int encode_fgs_authentication_response(fgs_authentication_response_msg *authentication_response, uint8_t *buffer, uint32_t len)
+{
+  int encoded = 0;
+  int encode_result = 0;
+
+
+  if ((encode_result =
+         encode_authentication_response_parameter(&authentication_response->authenticationresponseparameter,
+           AUTHENTICATION_RESPONSE_PARAMETER_IEI, buffer + encoded, len - encoded)) < 0)        //Return in case of error
+    return encode_result;
+  else
+    encoded += encode_result;
+
+  return encoded;
+}
+

openair3/NAS/COMMON/EMM/MSG/FGSAuthenticationResponse.h

+/*! \file FGSAuthenticationResponse.h
+
+\brief authentication response procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "ExtendedProtocolDiscriminator.h"
+#include "SecurityHeaderType.h"
+#include "SpareHalfOctet.h"
+#include "MessageType.h"
+#include "AuthenticationResponseParameter.h"
+
+#ifndef FGS_AUTHENTICATION_RESPONSE_H_
+#define FGS_AUTHENTICATION_RESPONSE_H_
+
+#define AUTHENTICATION_RESPONSE_PARAMETER_IEI     0x2d
+
+/*
+ * Message name: Identity response
+ * Description: This message is sent by the UE to the AMF to provide the requested identity. See table 8.2.22.1.
+ * Significance: dual
+ * Direction: UE to AMF
+ */
+
+typedef struct fgs_authentication_response_msg_tag {
+  /* Mandatory fields */
+  ExtendedProtocolDiscriminator           protocoldiscriminator;
+  SecurityHeaderType                      securityheadertype:4;
+  SpareHalfOctet                          sparehalfoctet:4;
+  MessageType                             messagetype;
+  AuthenticationResponseParameter         authenticationresponseparameter;
+} fgs_authentication_response_msg;
+
+int encode_fgs_authentication_response(fgs_authentication_response_msg *authentication_response, uint8_t *buffer, uint32_t len);
+
+#endif /* ! defined(FGS_AUTHENTICATION_RESPONSE_H_) */
+
+

openair3/NAS/COMMON/EMM/MSG/FGSIdentityResponse.c

+/*! \file FGSIdentityResponse.c
+
+\brief identity response procedures for gNB
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "nas_log.h"
+
+#include "FGSIdentityResponse.h"
+
+
+int encode_identiy_response(fgs_identiy_response_msg *fgs_identity_reps, uint8_t *buffer, uint32_t len)
+{
+  int encoded = 0;
+  int encode_result = 0;
+
+  if ((encode_result =
+         encode_5gs_mobile_identity(&fgs_identity_reps->fgsmobileidentity, 0, buffer +
+                                    encoded, len - encoded)) < 0)        //Return in case of error
+    return encode_result;
+  else
+    encoded += encode_result;
+
+  return encoded;
+}
+
+

openair3/NAS/COMMON/EMM/MSG/FGSIdentityResponse.h

+/*! \file FGSIdentityResponse.h
+
+\brief identity response procedures for gNB
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "ExtendedProtocolDiscriminator.h"
+#include "SecurityHeaderType.h"
+#include "SpareHalfOctet.h"
+#include "FGSMobileIdentity.h"
+#include "MessageType.h"
+
+#ifndef FGS_IDENTITY_RESPONSE_H_
+#define FGS_IDENTITY_RESPONSE_H_
+
+/*
+ * Message name: Identity response
+ * Description: This message is sent by the UE to the AMF to provide the requested identity. See table 8.2.22.1.
+ * Significance: dual
+ * Direction: UE to AMF
+ */
+
+typedef struct fgs_identiy_response_msg_tag {
+  /* Mandatory fields */
+  ExtendedProtocolDiscriminator           protocoldiscriminator;
+  SecurityHeaderType                      securityheadertype:4;
+  SpareHalfOctet                          sparehalfoctet:4;
+  MessageType                             messagetype;
+  FGSMobileIdentity                       fgsmobileidentity;
+
+} fgs_identiy_response_msg;
+
+int encode_identiy_response(fgs_identiy_response_msg *fgs_identity_reps, uint8_t *buffer, uint32_t len);
+
+#endif /* ! defined(FGS_IDENTITY_RESPONSE_H_) */
+
+

openair3/NAS/COMMON/EMM/MSG/FGSNASSecurityModeComplete.c

+/*! \file FGSNASSecurityModeComplete.c
+
+\brief security mode complete procedures for gNB
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "nas_log.h"
+
+#include "FGSNASSecurityModeComplete.h"
+#include "FGSMobileIdentity.h"
+#include "FGCNasMessageContainer.h"
+
+int encode_fgs_security_mode_complete(fgs_security_mode_complete_msg *fgs_security_mode_comp, uint8_t *buffer, uint32_t len)
+{
+    int encoded = 0;
+    int encode_result = 0;
+
+    if ((encode_result =
+          encode_5gs_mobile_identity(&fgs_security_mode_comp->fgsmobileidentity, 0x77, buffer +
+                                     encoded, len - encoded)) < 0) { //Return in case of error
+      return encode_result;
+    } else {
+      encoded += encode_result;
+      if ((encode_result =
+            encode_fgc_nas_message_container(&fgs_security_mode_comp->fgsnasmessagecontainer, 0x71, buffer +
+                                      encoded, len - encoded)) < 0) {
+          return encode_result;
+      } else {
+        encoded += encode_result;
+      }
+    }
+
+    return encoded;
+}
+
+
+

openair3/NAS/COMMON/EMM/MSG/FGSNASSecurityModeComplete.h

+/*! \file FGSNASSecurityModeComplete.h
+
+\brief security mode complete procedures for gNB
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "ExtendedProtocolDiscriminator.h"
+#include "SecurityHeaderType.h"
+#include "SpareHalfOctet.h"
+#include "FGSMobileIdentity.h"
+#include "MessageType.h"
+#include "FGCNasMessageContainer.h"
+
+#ifndef FGS_NAS_SECURITY_MODE_COMPLETE_H_
+#define FGS_NAS_SECURITY_MODE_COMPLETE_H_
+
+/*
+ * Message name: security mode complete
+ * Description: This message is sent by the UE to the AMF in response to a SECURITY MODE COMMAND message. See table 8.2.26.1.1.
+ * Significance: dual
+ * Direction: UE to AMF
+ */
+
+typedef struct fgs_security_mode_complete_msg_tag {
+    /* Mandatory fields */
+    ExtendedProtocolDiscriminator           protocoldiscriminator;
+    SecurityHeaderType                      securityheadertype:4;
+    SpareHalfOctet                          sparehalfoctet:4;
+    MessageType                             messagetype;
+    FGSMobileIdentity                       fgsmobileidentity;
+    FGCNasMessageContainer                  fgsnasmessagecontainer;
+} fgs_security_mode_complete_msg;
+
+int encode_fgs_security_mode_complete(fgs_security_mode_complete_msg *fgs_security_mode_comp, uint8_t *buffer, uint32_t len);
+
+#endif /* ! defined(FGS_NAS_SECURITY_MODE_COMPLETE_H_) */
+

openair3/NAS/COMMON/EMM/MSG/FGSUplinkNasTransport.c

+/*! \file FGSUplinkNasTransport.c
+
+\brief uplink nas transport procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <arpa/inet.h>
+
+#include "FGSUplinkNasTransport.h"
+#include "TLVEncoder.h"
+
+int encode_fgs_payload_container(FGSPayloadContainer *paycontainer, uint8_t iei, uint8_t *buffer, uint32_t len)
+{
+  uint32_t encoded = 0;
+  int encode_result;
+
+  if (iei > 0) {
+    *buffer = iei;
+    encoded++;
+  }
+
+  encoded += 2;
+
+  if ((encode_result = encode_octet_string(&paycontainer->payloadcontainercontents, buffer + encoded, len - encoded)) < 0) {
+    return encode_result;
+  } else {
+    encoded += encode_result;
+  }
+  if(iei > 0){
+    *(uint16_t*) (buffer+1) = htons(encoded - 3);
+  } else {
+    *(uint16_t*) (buffer) = htons(encoded - 2);
+  }
+
+  return encoded;
+}
+
+int encode_nssai(OctetString *nssai, uint8_t iei, uint8_t *buffer)
+{
+  uint32_t encoded = 0;
+  int encode_result;
+
+  if (iei > 0) {
+    *buffer = iei;
+    encoded++;
+  }
+
+  *(buffer + encoded) = nssai->length;
+  encoded++;
+
+
+  if ((encode_result = encode_octet_string(nssai, buffer + encoded, nssai->length)) < 0) {
+    return encode_result;
+  } else {
+    encoded += encode_result;
+  }
+
+  return encoded;
+}
+
+int encode_dnn(OctetString *dnn, uint8_t iei, uint8_t *buffer)
+{
+  uint32_t encoded = 0;
+  int encode_result;
+
+  if (iei > 0) {
+    *buffer = iei;
+    encoded++;
+  }
+
+  *(buffer + encoded) = dnn->length;
+  encoded++;
+
+  if ((encode_result = encode_octet_string(dnn, buffer + encoded, dnn->length)) < 0) {
+    return encode_result;
+  } else {
+    encoded += encode_result;
+  }
+
+  return encoded;
+}
+
+int encode_fgs_uplink_nas_transport(fgs_uplink_nas_transport_msg *fgs_up_nas_transport, uint8_t *buffer, uint32_t len)
+{
+    int encoded = 0;
+    int encode_result = 0;
+
+    *(buffer + encoded) = (fgs_up_nas_transport->payloadcontainertype.iei << 4) | (fgs_up_nas_transport->payloadcontainertype.type &0xf);
+    encoded++;
+
+    if ((encode_result = encode_fgs_payload_container(&fgs_up_nas_transport->fgspayloadcontainer,
+                                                       0, buffer +encoded, len - encoded)) < 0) {
+      return encode_result;
+    } else {
+      encoded += encode_result;
+    }
+
+    *(buffer + encoded) = 0x12;
+    encoded++;
+
+    IES_ENCODE_U8(buffer, encoded, fgs_up_nas_transport->pdusessionid);
+
+    // set request type
+    *(buffer + encoded) = (0x8<<4)|(fgs_up_nas_transport->requesttype &0x7);
+    encoded++;
+
+    if ((encode_result = encode_nssai(&fgs_up_nas_transport->snssai, 0x22, buffer +encoded)) < 0) {
+      return encode_result;
+    } else {
+      encoded += encode_result;
+    }
+
+    if ((encode_result = encode_dnn(&fgs_up_nas_transport->dnn, 0x25, buffer +encoded)) < 0) {
+      return encode_result;
+    } else {
+      encoded += encode_result;
+    }
+
+    return encoded;
+}
+
+

openair3/NAS/COMMON/EMM/MSG/FGSUplinkNasTransport.h

+/*! \file FGSUplinkNasTransport.h
+
+\brief uplink nas transport procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "ExtendedProtocolDiscriminator.h"
+#include "SecurityHeaderType.h"
+#include "SpareHalfOctet.h"
+#include "MessageType.h"
+
+#ifndef FGS_UPLINK_NAS_TRANSPORT_H_
+#define FGS_UPLINK_NAS_TRANSPORT_H_
+
+/*
+ * Message name: uplink nas transpaort
+ * Description: The UL NAS TRANSPORT message transports message payload and associated information to the AMF. See table 8.2.10.1.1.
+ * Significance: dual
+ * Direction: UE to network
+ */
+
+typedef struct PayloadContainerType_tag{
+    uint8_t  iei:4;
+    uint8_t  type:4;
+}PayloadContainerType;
+typedef struct FGSPayloadContainer_tag {
+  OctetString payloadcontainercontents;
+} FGSPayloadContainer;
+
+typedef struct fgs_uplink_nas_transport_msg_tag {
+    /* Mandatory fields */
+    ExtendedProtocolDiscriminator           protocoldiscriminator;
+    SecurityHeaderType                      securityheadertype:4;
+    SpareHalfOctet                          sparehalfoctet:4;
+    MessageType                             messagetype;
+    PayloadContainerType                    payloadcontainertype;
+    FGSPayloadContainer                     fgspayloadcontainer;
+    /* Optional fields */
+    uint16_t                                pdusessionid;
+    uint8_t                                 requesttype;
+    OctetString                             snssai;
+    OctetString                             dnn;
+} fgs_uplink_nas_transport_msg;
+
+int encode_fgs_uplink_nas_transport(fgs_uplink_nas_transport_msg *fgs_security_mode_comp, uint8_t *buffer, uint32_t len);
+
+#endif /* ! defined(FGS_UPLINK_NAS_TRANSPORT_H_) */
+
+

openair3/NAS/COMMON/EMM/MSG/RegistrationAccept.c

+/*! \file RegistrationAccept.c
+
+\brief 5GS registration accept procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+
+#include "TLVEncoder.h"
+#include "TLVDecoder.h"
+#include "RegistrationAccept.h"
+#include "assertions.h"
+
+int decode_registration_accept(registration_accept_msg *registration_accept, uint8_t *buffer, uint32_t len)
+{
+  uint32_t decoded = 0;
+  int decoded_result = 0;
+
+  /* Decoding mandatory fields */
+  if ((decoded_result = decode_fgs_registration_result(&registration_accept->fgsregistrationresult, 0, *(buffer + decoded), len - decoded)) < 0)
+    return decoded_result;
+
+  decoded += decoded_result;
+
+  // todo ,Decoding optional fields
+  return decoded;
+}
+
+int encode_registration_accept(registration_accept_msg *registration_accept, uint8_t *buffer, uint32_t len)
+{
+  int encoded = 0;
+
+  LOG_FUNC_IN;
+
+
+  *(buffer + encoded) = encode_fgs_registration_result(&registration_accept->fgsregistrationresult);
+  encoded = encoded + 2;
+
+  // todo ,Encoding optional fields
+  LOG_FUNC_RETURN(encoded);
+}
+

openair3/NAS/COMMON/EMM/MSG/RegistrationAccept.h

+/*! \file RegistrationAccept.h
+
+\brief 5GS registration accept procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+
+#include "ExtendedProtocolDiscriminator.h"
+#include "SecurityHeaderType.h"
+#include "SpareHalfOctet.h"
+#include "MessageType.h"
+#include "FGSRegistrationResult.h"
+
+#ifndef REGISTRATION_ACCEPT_H_
+#define REGISTRATION_ACCEPT_H_
+
+/*
+ * Message name: Registration accept
+ * Description: The REGISTRATION ACCEPT message is sent by the AMF to the UE. See table 8.2.7.1.1.
+ * Significance: dual
+ * Direction: network to UE
+ */
+
+typedef struct registration_accept_msg_tag {
+  /* Mandatory fields */
+  ExtendedProtocolDiscriminator           protocoldiscriminator;
+  SecurityHeaderType                      securityheadertype:4;
+  SpareHalfOctet                          sparehalfoctet:4;
+  MessageType                             messagetype;
+  FGSRegistrationResult                   fgsregistrationresult;
+} registration_accept_msg;
+
+int decode_registration_accept(registration_accept_msg *registrationaccept, uint8_t *buffer, uint32_t len);
+
+int encode_registration_accept(registration_accept_msg *registrationaccept, uint8_t *buffer, uint32_t len);
+
+#endif /* ! defined(REGISTRATION_ACCEPT_H_) */
+

openair3/NAS/COMMON/ESM/MSG/PduSessionEstablishRequest.c

+/*! \file PduSessionEstablishRequest.c
+
+\brief pdu session establishment request procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+
+#include "TLVEncoder.h"
+#include "TLVDecoder.h"
+#include "PduSessionEstablishRequest.h"
+
+
+int encode_pdu_session_establishment_request(pdu_session_establishment_request_msg *pdusessionestablishrequest, uint8_t *buffer)
+{
+  int encoded = 0;
+
+
+  *(buffer + encoded) = pdusessionestablishrequest->protocoldiscriminator;
+  encoded++;
+  *(buffer + encoded) = pdusessionestablishrequest->pdusessionid;
+  encoded++;
+  *(buffer + encoded) = pdusessionestablishrequest->pti;
+  encoded++;
+  *(buffer + encoded) = pdusessionestablishrequest->pdusessionestblishmsgtype;
+  encoded++;
+
+  IES_ENCODE_U16(buffer, encoded, pdusessionestablishrequest->maxdatarate);
+
+  return encoded;
+}
+
+

openair3/NAS/COMMON/ESM/MSG/PduSessionEstablishRequest.h

+/*! \file PduSessionEstablishRequest.h
+
+\brief pdu session establishment request procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "ExtendedProtocolDiscriminator.h"
+#include "MessageType.h"
+
+#ifndef PDU_SESSION_ESTABLISHMENT_REQUEST_H_
+#define PDU_SESSION_ESTABLISHMENT_REQUEST_H_
+
+
+/*
+ * Message name: pdu session establishment request
+ * Description: The PDU SESSION ESTABLISHMENT REQUEST message is sent by the UE to the SMF to initiate establishment of a PDU session. See table 8.3.1.1.1.
+ * Significance: dual
+ * Direction: UE to network
+ */
+
+typedef struct pdu_session_establishment_request_msg_tag {
+    /* Mandatory fields */
+    ExtendedProtocolDiscriminator           protocoldiscriminator;
+    uint8_t                                 pdusessionid;
+    uint8_t                                 pti;
+    MessageType                             pdusessionestblishmsgtype;
+    uint16_t                                maxdatarate;
+    /* Optional fields */
+} pdu_session_establishment_request_msg;
+
+
+int encode_pdu_session_establishment_request(pdu_session_establishment_request_msg *pdusessionestablishrequest, uint8_t *buffer);
+
+#endif /* ! defined(PDU_SESSION_ESTABLISHMENT_REQUEST_H_) */
+
+

openair3/NAS/COMMON/IES/FGCNasMessageContainer.c

+/*! \file FGCNasMessageContainer.c
+
+\brief security mode complete procedures for gNB
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+
+#include "TLVEncoder.h"
+#include "TLVDecoder.h"
+#include "FGCNasMessageContainer.h"
+
+int decode_fgc_nas_message_container(FGCNasMessageContainer *nasmessagecontainer, uint8_t iei, uint8_t *buffer, uint32_t len)
+{
+  int decoded = 0;
+  uint8_t ielen = 0;
+  int decode_result;
+
+  if (iei > 0) {
+    CHECK_IEI_DECODER(iei, *buffer);
+    decoded++;
+  }
+
+  ielen = *(buffer + decoded);
+  decoded += 2;
+  CHECK_LENGTH_DECODER(len - decoded, ielen);
+
+  if ((decode_result = decode_octet_string(&nasmessagecontainer->nasmessagecontainercontents, ielen, buffer + decoded, len - decoded)) < 0)
+    return decode_result;
+  else
+    decoded += decode_result;
+
+  return decoded;
+}
+int encode_fgc_nas_message_container(FGCNasMessageContainer *nasmessagecontainer, uint8_t iei, uint8_t *buffer, uint32_t len)
+{
+  uint32_t encoded = 0;
+  int encode_result;
+  /* Checking IEI and pointer */
+  CHECK_PDU_POINTER_AND_LENGTH_ENCODER(buffer, FGC_NAS_MESSAGE_CONTAINER_MINIMUM_LENGTH, len);
+
+  if (iei > 0) {
+    *buffer = iei;
+    encoded++;
+  }
+
+  encoded += 2;
+
+  if ((encode_result = encode_octet_string(&nasmessagecontainer->nasmessagecontainercontents, buffer + encoded, len - encoded)) < 0) {
+    return encode_result;
+  } else {
+    *(uint16_t*) (buffer+1) = htons(encoded + encode_result - 3);
+    encoded += encode_result;
+  }
+
+  return encoded;
+}
+
+void dump_fgc_nas_message_container_xml(FGCNasMessageContainer *nasmessagecontainer, uint8_t iei)
+{
+  printf("<Nas Message Container>\n");
+
+  if (iei > 0)
+    /* Don't display IEI if = 0 */
+    printf("    <IEI>0x%X</IEI>\n", iei);
+
+  printf("%s", dump_octet_string_xml(&nasmessagecontainer->nasmessagecontainercontents));
+  printf("</Nas Message Container>\n");
+}
+
+

openair3/NAS/COMMON/IES/FGCNasMessageContainer.h

+/*! \file FGCNasMessageContainer.h
+
+\brief security mode complete procedures for gNB
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "OctetString.h"
+
+#ifndef FGC_NAS_MESSAGE_CONTAINER_H_
+#define FGC_NAS_MESSAGE_CONTAINER_H_
+
+#define FGC_NAS_MESSAGE_CONTAINER_MINIMUM_LENGTH 4
+#define FGC_NAS_MESSAGE_CONTAINER_MAXIMUM_LENGTH 65535
+
+typedef struct FGCNasMessageContainer_tag {
+  OctetString nasmessagecontainercontents;
+} FGCNasMessageContainer;
+
+int encode_fgc_nas_message_container(FGCNasMessageContainer *nasmessagecontainer, uint8_t iei, uint8_t *buffer, uint32_t len);
+
+int decode_fgc_nas_message_container(FGCNasMessageContainer *nasmessagecontainer, uint8_t iei, uint8_t *buffer, uint32_t len);
+
+void dump_fgc_nas_message_container_xml(FGCNasMessageContainer *nasmessagecontainer, uint8_t iei);
+
+#endif /* FGC NAS MESSAGE CONTAINER_H_ */
+

openair3/NAS/COMMON/IES/FGSMobileIdentity.c

@@ -40,6 +40,8 @@
 static int decode_guti_5gs_mobile_identity(Guti5GSMobileIdentity_t *guti, uint8_t *buffer);
 
 static int encode_guti_5gs_mobile_identity(Guti5GSMobileIdentity_t *guti, uint8_t *buffer);
+static int encode_suci_5gs_mobile_identity(Suci5GSMobileIdentity_t *suci, uint8_t *buffer);
+static int encode_imeisv_5gs_mobile_identity(Imeisv5GSMobileIdentity_t *imeisv, uint8_t *buffer);
 
 int decode_5gs_mobile_identity(FGSMobileIdentity *fgsmobileidentity, uint8_t iei, uint8_t *buffer, uint32_t len)
 {
@@ -87,11 +89,26 @@ int encode_5gs_mobile_identity(FGSMobileIdentity *fgsmobileidentity, uint8_t iei
                  buffer + encoded);
   }
 
+  if (fgsmobileidentity->suci.typeofidentity == FGS_MOBILE_IDENTITY_SUCI) {
+    encoded_rc = encode_suci_5gs_mobile_identity(&fgsmobileidentity->suci,
+                 buffer + encoded);
+  }
+
+  if (fgsmobileidentity->imeisv.typeofidentity == FGS_MOBILE_IDENTITY_IMEISV) {
+    encoded_rc = encode_imeisv_5gs_mobile_identity(&fgsmobileidentity->imeisv,
+                 buffer + encoded);
+  }
+
   if (encoded_rc < 0) {
     return encoded_rc;
   }
 
-  *(uint16_t*) buffer = htons(encoded  + encoded_rc - 2 - ((iei > 0) ? 1 : 0));
+  if(iei > 0){
+    *(uint16_t*) (buffer+1) = htons(encoded  + encoded_rc - 3);
+  } else {
+    *(uint16_t*) buffer = htons(encoded  + encoded_rc - 2);
+  }
+
   return (encoded + encoded_rc);
 }
 
@@ -166,10 +183,57 @@ static int encode_guti_5gs_mobile_identity(Guti5GSMobileIdentity_t *guti, uint8_
   *(buffer + encoded) = guti->amfregionid;
   encoded++;
 
-  temp = 0x00 | ((guti->amfsetid & 0x3f) << 6) | (guti->amfpointer & 0x3f);
+  temp = 0x00 | ((guti->amfsetid) << 6) | (guti->amfpointer & 0x3f);
 
   IES_ENCODE_U16(buffer, encoded, temp);
   IES_ENCODE_U32(buffer, encoded, guti->tmsi);
   return encoded;
 }
 
+
+static int encode_suci_5gs_mobile_identity(Suci5GSMobileIdentity_t *suci, uint8_t *buffer)
+{
+  uint32_t encoded = 0;
+  *(buffer + encoded) = 0x00 | (suci->supiformat << 4) | (suci->typeofidentity);
+  encoded++;
+  *(buffer + encoded) = 0x00 | ((suci->mccdigit2 & 0xf) << 4) |
+                        (suci->mccdigit1 & 0xf);
+  encoded++;
+  *(buffer + encoded) = 0x00 | ((suci->mncdigit3 & 0xf) << 4) |
+                        (suci->mccdigit3 & 0xf);
+  encoded++;
+  *(buffer + encoded) = 0x00 | ((suci->mncdigit2 & 0xf) << 4) |
+                        (suci->mncdigit1 & 0xf);
+  encoded++;
+
+  *(buffer + encoded) = 0x00 | ((suci->routingindicatordigit2 & 0xf) << 4) |
+                        (suci->routingindicatordigit1 & 0xf);
+  encoded++;
+
+  *(buffer + encoded) = 0x00 | ((suci->routingindicatordigit4 & 0xf) << 4) |
+                        (suci->routingindicatordigit3 & 0xf);
+  encoded++;
+
+  *(buffer + encoded) = 0x00 | (suci->protectionschemeId & 0xf);
+  encoded++;
+
+  *(buffer + encoded) = suci->homenetworkpki;
+  encoded++;
+
+  IES_ENCODE_U32(buffer, encoded, suci->schemeoutput);
+
+  return encoded;
+}
+
+static int encode_imeisv_5gs_mobile_identity(Imeisv5GSMobileIdentity_t *imeisv, uint8_t *buffer)
+{
+  uint32_t encoded = 0;
+  *(buffer + encoded) = 0x00 | (imeisv->digit1 << 4) | (imeisv->oddeven << 3) | (imeisv->typeofidentity);
+  encoded++;
+
+  *(buffer + encoded) = 0x00 | (imeisv->digitp1 << 4) | (imeisv->digitp);
+  encoded++;
+
+  return encoded;
+}
+

openair3/NAS/COMMON/IES/FGSMobileIdentity.h

@@ -64,6 +64,7 @@ typedef struct {
   uint8_t  spare6:1;
   uint8_t  protectionschemeId:4;
   uint8_t  homenetworkpki;
+  uint32_t schemeoutput;
 } Suci5GSMobileIdentity_t;
 
 typedef struct {

openair3/NAS/COMMON/IES/FGSRegistrationResult.c

+/*! \file FGSRegistrationResult.c
+
+\brief 5GS Registration result for registration request procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+
+#include "TLVEncoder.h"
+#include "TLVDecoder.h"
+#include "FGSRegistrationResult.h"
+
+
+int decode_fgs_registration_result(FGSRegistrationResult *fgsregistrationresult, uint8_t iei, uint16_t value, uint32_t len)
+{
+  int decoded = 0;
+  uint16_t *buffer = &value;
+  fgsregistrationresult->registrationresult = *buffer & 0x7;
+  fgsregistrationresult->smsallowed = *buffer & 0x8;
+  decoded = decoded+2;
+  return decoded;
+}
+
+uint16_t encode_fgs_registration_result(FGSRegistrationResult *fgsregistrationresult)
+{
+  uint16_t bufferReturn;
+  uint16_t *buffer = &bufferReturn;
+  uint8_t encoded = 0;
+  *(buffer + encoded) = 0x00 | (fgsregistrationresult->smsallowed & 0x8) |
+                        (fgsregistrationresult->registrationresult & 0x7);
+  encoded= encoded+2;
+
+  return bufferReturn;
+}
+

openair3/NAS/COMMON/IES/FGSRegistrationResult.h

+/*! \file FGSRegistrationResult.h
+
+\brief 5GS Registration result for registration request procedures
+\author Yoshio INOUE, Masayuki HARADA
+\email: yoshio.inoue@fujitsu.com,masayuki.harada@fujitsu.com
+\date 2020
+\version 0.1
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "OctetString.h"
+
+
+
+#ifndef FGS_REGISTRATION_RESULT_H_
+#define FGS_REGISTRATION_RESULT_H_
+#define FGS_REGISTRATION_RESULT_3GPP                      0b001
+#define FGS_REGISTRATION_RESULT_NON_3GPP                  0b010
+#define FGS_REGISTRATION_RESULT_3GPP_AND_NON_3GPP         0b011
+
+typedef struct {
+  uint8_t  iei;
+  uint8_t  resultlength;
+  uint8_t  spare:4;
+  uint8_t  smsallowed:1;
+  uint8_t  registrationresult:3;
+} FGSRegistrationResult;
+
+
+uint16_t encode_fgs_registration_result(FGSRegistrationResult *fgsregistrationresult);
+
+int decode_fgs_registration_result(FGSRegistrationResult *fgsregistrationresult, uint8_t iei, uint16_t value, uint32_t len);
+
+#endif /* FGS REGISTRATION RESULT_H_*/
+

openair3/NAS/NR_UE/nr_nas_msg_sim.h

@@ -33,16 +33,18 @@
 #define __NR_NAS_MSG_SIM_H__
 
 #include "RegistrationRequest.h"
+#include "FGSIdentityResponse.h"
+#include "FGSAuthenticationResponse.h"
+#include "FGSNASSecurityModeComplete.h"
 #include "RegistrationComplete.h"
 #include "as_message.h"
-
+#include "FGSUplinkNasTransport.h"
 
 #define PLAIN_5GS_MSG                                      0b0000
 #define INTEGRITY_PROTECTED                                0b0001
 #define INTEGRITY_PROTECTED_AND_CIPHERED                   0b0010
-
-#define INITIAL_REGISTRATION                               0b001
-
+#define INTEGRITY_PROTECTED_WITH_NEW_SECU_CTX              0b0011          // only for SECURITY MODE COMMAND
+#define INTEGRITY_PROTECTED_AND_CIPHERED_WITH_NEW_SECU_CTX 0b0100         // only for SECURITY MODE COMPLETE
 
 #define REGISTRATION_REQUEST                               0b01000001 /* 65 = 0x41 */
 #define REGISTRATION_ACCEPT                                0b01000010 /* 66 = 0x42 */
@@ -56,25 +58,28 @@
 #define FIVEGMM_SERVICE_REQUEST                            0b01001100 /* 76 = 0x4c */
 #define FIVEGMM_SERVICE_REJECT                             0b01001101 /* 77 = 0x4d */
 #define FIVEGMM_SERVICE_ACCEPT                             0b01001110 /* 78 = 0x4e */
-
 #define CONFIGURATION_UPDATE_COMMAND                       0b01010100 /* 84 = 0x54 */
 #define CONFIGURATION_UPDATE_COMPLETE                      0b01010101 /* 85 = 0x55 */
-#define AUTHENTICATION_REQUEST                             0b01010110 /* 86 = 0x56 */
-#define AUTHENTICATION_RESPONSE                            0b01010111 /* 87 = 0x57 */
+#define FGS_AUTHENTICATION_REQUEST                         0b01010110 /* 86 = 0x56 */
+#define FGS_AUTHENTICATION_RESPONSE                        0b01010111 /* 87 = 0x57 */
 #define AUTHENTICATION_REJECT                              0b01011000 /* 88 = 0x58 */
 #define AUTHENTICATION_FAILURE                             0b01011001 /* 89 = 0x59 */
 #define AUTHENTICATION_RESULT                              0b01011010 /* 90 = 0x5a */
-#define FIVEGMM_IDENTITY_REQUEST                           0b01011011 /* 91 = 0x5b */
-#define FIVEGMM_IDENTITY_RESPONSE                          0b01011100 /* 92 = 0x5c */
-#define FIVEGMM_SECURITY_MODE_COMMAND                      0b01011101 /* 93 = 0x5d */
-#define FIVEGMM_SECURITY_MODE_COMPLETE                     0b01011110 /* 94 = 0x5e */
+#define FGS_IDENTITY_REQUEST                               0b01011011 /* 91 = 0x5b */
+#define FGS_IDENTITY_RESPONSE                              0b01011100 /* 92 = 0x5c */
+#define FGS_SECURITY_MODE_COMMAND                          0b01011101 /* 93 = 0x5d */
+#define FGS_SECURITY_MODE_COMPLETE                         0b01011110 /* 94 = 0x5e */
 #define FIVEGMM_SECURITY_MODE_REJECT 	                     0b01011111 /* 95 = 0x5f */
 #define FIVEGMM_STATUS                                     0b01100100 /* 100 = 0x64 */
 #define NOTIFICATION                                       0b01100101 /* 101 = 0x65 */
 #define NOTIFICATION_RESPONSE                              0b01100110 /* 102 = 0x66 */
-#define UL_NAS_TRANSPORT                                   0b01100111 /* 103 = 0x67 */
+#define FGS_UPLINK_NAS_TRANSPORT                           0b01100111 /* 103= 0x67 */
 #define DL_NAS_TRANSPORT                                   0b01101000 /* 104 = 0x68 */
 
+// message type for 5GS session management
+#define FGS_PDU_SESSION_ESTABLISHMENT_REQ                  0b11000001 /* 193= 0xc1 */
+
+#define INITIAL_REGISTRATION                               0b001
 
 
 typedef enum fgs_protocol_discriminator_e {
@@ -103,7 +108,11 @@ typedef struct {
 typedef union {
   mm_msg_header_t                        header;
   registration_request_msg               registration_request;
+  fgs_identiy_response_msg               fgs_identity_response;
+  fgs_authentication_response_msg        fgs_auth_response;
+  fgs_security_mode_complete_msg         fgs_security_mode_complete;
   registration_complete_msg              registration_complete;
+  fgs_uplink_nas_transport_msg           uplink_nas_transport;
 } MM_msg;
 
 
@@ -125,5 +134,13 @@ typedef union {
 } fgs_nas_message_t;
 
 void generateRegistrationRequest(as_nas_info_t *initialNasMsg);
-void generateRegistrationComplete(as_nas_info_t *ulNasMsg, SORTransparentContainer *sortransparentcontainer);
+void generateIdentityResponse(as_nas_info_t *initialNasMsg, uint8_t identitytype);
+void generateAuthenticationResp(as_nas_info_t *initialNasMsg, uint8_t *buf);
+void generateSecurityModeComplete(as_nas_info_t *initialNasMsg);
+void generateRegistrationComplete(as_nas_info_t *initialNasMsg, SORTransparentContainer *sortransparentcontainer);
+void generatePduSessionEstablishRequest(as_nas_info_t *initialNasMsg);
+
 #endif /* __NR_NAS_MSG_SIM_H__*/
+
+
+

openair3/NGAP/ngap_gNB_context_management_procedures.c

@@ -49,6 +49,7 @@
 #include "ngap_gNB_nas_procedures.h"
 #include "ngap_gNB_management_procedures.h"
 #include "ngap_gNB_context_management_procedures.h"
+#include "NGAP_PDUSessionResourceItemCxtRelReq.h"
 #include "msc.h"
 
 
@@ -203,6 +204,21 @@ int ngap_ue_context_release_req(instance_t instance,
   ie->value.choice.RAN_UE_NGAP_ID = ue_release_req_p->gNB_ue_ngap_id;
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
 
+  /* optional */
+  if (ue_release_req_p->nb_of_pdusessions > 0) {
+    ie = (NGAP_UEContextReleaseRequest_IEs_t *)calloc(1, sizeof(NGAP_UEContextReleaseRequest_IEs_t));
+    ie->id = NGAP_ProtocolIE_ID_id_PDUSessionResourceListCxtRelReq;
+    ie->criticality = NGAP_Criticality_reject;
+    ie->value.present = NGAP_UEContextReleaseRequest_IEs__value_PR_PDUSessionResourceListCxtRelReq;
+    for (int i = 0; i < ue_release_req_p->nb_of_pdusessions; i++) {
+      NGAP_PDUSessionResourceItemCxtRelReq_t     *item;
+      item = (NGAP_PDUSessionResourceItemCxtRelReq_t *)calloc(1,sizeof(NGAP_PDUSessionResourceItemCxtRelReq_t));
+      item->pDUSessionID = ue_release_req_p->pdusessions[i].pdusession_id;
+      ASN_SEQUENCE_ADD(&ie->value.choice.PDUSessionResourceListCxtRelReq.list, item);
+    }
+    ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+  }
+
   /* mandatory */
   ie = (NGAP_UEContextReleaseRequest_IEs_t *)calloc(1, sizeof(NGAP_UEContextReleaseRequest_IEs_t));
   ie->id = NGAP_ProtocolIE_ID_id_Cause;

openair3/NGAP/ngap_gNB_encoder.c

@@ -73,7 +73,7 @@ int ngap_gNB_encode_pdu(NGAP_NGAP_PDU_t *pdu, uint8_t **buffer, uint32_t *len) {
       return -1;
   }
 
-  ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_NGAP_NGAP_PDU, pdu);
+  //ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_NGAP_NGAP_PDU, pdu);
   return ret;
 }
 

openair3/NGAP/ngap_gNB_handlers.c

@@ -49,6 +49,7 @@
 #include "assertions.h"
 #include "conversions.h"
 #include "msc.h"
+#include "NGAP_NonDynamic5QIDescriptor.h"
 
 static
 int ngap_gNB_handle_ng_setup_response(uint32_t               assoc_id,
@@ -882,11 +883,11 @@ int ngap_gNB_handle_initial_context_request(uint32_t   assoc_id,
   }
 
   /* Initial context request = UE-related procedure -> stream != 0 */
-  if (stream == 0) {
-    NGAP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n",
-               assoc_id, stream);
-    return -1;
-  }
+  //if (stream == 0) {
+  //  NGAP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n",
+  //             assoc_id, stream);
+  //  return -1;
+  //}
 
   ue_desc_p->rx_stream = stream;
   ue_desc_p->amf_ue_ngap_id = amf_ue_ngap_id;
@@ -955,7 +956,7 @@ int ngap_gNB_handle_initial_context_request(uint32_t   assoc_id,
       }
 
 
-      dec_rval = uper_decode(NULL,
+      dec_rval = aper_decode(NULL,
                                &asn_DEF_NGAP_PDUSessionResourceSetupRequestTransfer,
                                (void **)&pdusessionTransfer_p,
                                item_p->pDUSessionResourceSetupRequestTransfer.buf,
@@ -1028,7 +1029,7 @@ int ngap_gNB_handle_initial_context_request(uint32_t   assoc_id,
                 qosFlowItem_p = pdusessionTransfer_ies->value.choice.QosFlowSetupRequestList.list.array[qosIdx];
                 
                 /* Set the QOS informations */
-                NGAP_INITIAL_CONTEXT_SETUP_REQ(message_p).pdusession_param[i].qos[qosIdx].qci = (uint8_t)qosFlowItem_p->qosFlowIdentifier;
+                NGAP_INITIAL_CONTEXT_SETUP_REQ(message_p).pdusession_param[i].qos[qosIdx].qfi = (uint8_t)qosFlowItem_p->qosFlowIdentifier;
               
                 NGAP_INITIAL_CONTEXT_SETUP_REQ(message_p).pdusession_param[i].qos[qosIdx].allocation_retention_priority.priority_level =
                   qosFlowItem_p->qosFlowLevelQosParameters.allocationAndRetentionPriority.priorityLevelARP;
@@ -1289,11 +1290,11 @@ int ngap_gNB_handle_pdusession_setup_request(uint32_t         assoc_id,
   }
 
   /* Initial context request = UE-related procedure -> stream != 0 */
-  if (stream == 0) {
-    NGAP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n",
-               assoc_id, stream);
-    return -1;
-  }
+  // if (stream == 0) {
+  //   NGAP_ERROR("[SCTP %d] Received UE-related procedure on stream (%d)\n",
+  //              assoc_id, stream);
+  //   return -1;
+  // }
 
   ue_desc_p->rx_stream = stream;
 
@@ -1338,7 +1339,7 @@ int ngap_gNB_handle_pdusession_setup_request(uint32_t         assoc_id,
         NGAP_WARN("NAS PDU is not provided, generate a PDUSESSION_SETUP Failure (TBD) back to AMF \n");
       }
 
-      dec_rval = uper_decode(NULL,
+      dec_rval = aper_decode(NULL,
                                &asn_DEF_NGAP_PDUSessionResourceSetupRequestTransfer,
                                (void **)&pdusessionTransfer_p,
                                item_p->pDUSessionResourceSetupRequestTransfer.buf,
@@ -1407,8 +1408,13 @@ int ngap_gNB_handle_pdusession_setup_request(uint32_t         assoc_id,
               qosFlowItem_p = pdusessionTransfer_ies->value.choice.QosFlowSetupRequestList.list.array[qosIdx];
 
               /* Set the QOS informations */
-              NGAP_PDUSESSION_SETUP_REQ(message_p).pdusession_setup_params[i].qos[qosIdx].qci = (uint8_t)qosFlowItem_p->qosFlowIdentifier;
-
+              NGAP_PDUSESSION_SETUP_REQ(message_p).pdusession_setup_params[i].qos[qosIdx].qfi = (uint8_t)qosFlowItem_p->qosFlowIdentifier;
+              if(qosFlowItem_p->qosFlowLevelQosParameters.qosCharacteristics.present == NGAP_QosCharacteristics_PR_nonDynamic5QI){
+                if(qosFlowItem_p->qosFlowLevelQosParameters.qosCharacteristics.choice.nonDynamic5QI != NULL){
+                  NGAP_PDUSESSION_SETUP_REQ(message_p).pdusession_setup_params[i].qos[qosIdx].fiveQI = 
+                    (uint64_t)qosFlowItem_p->qosFlowLevelQosParameters.qosCharacteristics.choice.nonDynamic5QI->fiveQI;
+                }
+              }
               NGAP_PDUSESSION_SETUP_REQ(message_p).pdusession_setup_params[i].qos[qosIdx].allocation_retention_priority.priority_level =
                 qosFlowItem_p->qosFlowLevelQosParameters.allocationAndRetentionPriority.priorityLevelARP;
               NGAP_PDUSESSION_SETUP_REQ(message_p).pdusession_setup_params[i].qos[qosIdx].allocation_retention_priority.pre_emp_capability =
@@ -1668,7 +1674,7 @@ int ngap_gNB_handle_pdusession_modify_request(uint32_t               assoc_id,
         continue;
       }
 
-      dec_rval = uper_decode(NULL,
+      dec_rval = aper_decode(NULL,
                              &asn_DEF_NGAP_PDUSessionResourceModifyRequestTransfer,
                              (void **)&pdusessionTransfer_p,
                              item_p->pDUSessionResourceModifyRequestTransfer.buf,
@@ -1709,7 +1715,7 @@ int ngap_gNB_handle_pdusession_modify_request(uint32_t               assoc_id,
                 qosFlowItem_p = pdusessionTransfer_ies->value.choice.QosFlowAddOrModifyRequestList.list.array[qosIdx];
                 
                 /* Set the QOS informations */
-                NGAP_PDUSESSION_MODIFY_REQ(message_p).pdusession_modify_params[i].qos[qosIdx].qci = (uint8_t)qosFlowItem_p->qosFlowIdentifier;
+                NGAP_PDUSESSION_MODIFY_REQ(message_p).pdusession_modify_params[i].qos[qosIdx].qfi = (uint8_t)qosFlowItem_p->qosFlowIdentifier;
                 if(qosFlowItem_p->qosFlowLevelQosParameters) {
                   NGAP_PDUSESSION_MODIFY_REQ(message_p).pdusession_modify_params[i].qos[qosIdx].allocation_retention_priority.priority_level =
                     qosFlowItem_p->qosFlowLevelQosParameters->allocationAndRetentionPriority.priorityLevelARP;

openair3/NGAP/ngap_gNB_nas_procedures.c

@@ -469,6 +469,7 @@ int ngap_gNB_nas_uplink(instance_t instance, ngap_uplink_nas_t *ngap_uplink_nas_
   /* Prepare the NGAP message to encode */
   memset(&pdu, 0, sizeof(pdu));
   pdu.present = NGAP_NGAP_PDU_PR_initiatingMessage;
+  pdu.choice.initiatingMessage = (NGAP_InitiatingMessage_t *)calloc(1,sizeof(NGAP_InitiatingMessage_t));
   pdu.choice.initiatingMessage->procedureCode = NGAP_ProcedureCode_id_UplinkNASTransport;
   pdu.choice.initiatingMessage->criticality = NGAP_Criticality_ignore;
   pdu.choice.initiatingMessage->value.present = NGAP_InitiatingMessage__value_PR_UplinkNASTransport;
@@ -503,6 +504,7 @@ int ngap_gNB_nas_uplink(instance_t instance, ngap_uplink_nas_t *ngap_uplink_nas_
   ie->value.present = NGAP_UplinkNASTransport_IEs__value_PR_UserLocationInformation;
 
   ie->value.choice.UserLocationInformation.present = NGAP_UserLocationInformation_PR_userLocationInformationNR;
+  ie->value.choice.UserLocationInformation.choice.userLocationInformationNR = CALLOC(1,sizeof(struct NGAP_UserLocationInformationNR));
   userinfo_nr_p = ie->value.choice.UserLocationInformation.choice.userLocationInformationNR;
 
   /* Set nRCellIdentity. default userLocationInformationNR */
@@ -685,6 +687,7 @@ int ngap_gNB_initial_ctxt_resp(
   /* Prepare the NGAP message to encode */
   memset(&pdu, 0, sizeof(pdu));
   pdu.present = NGAP_NGAP_PDU_PR_successfulOutcome;
+  pdu.choice.successfulOutcome = (NGAP_SuccessfulOutcome_t *)calloc(1,sizeof(struct NGAP_SuccessfulOutcome));
   pdu.choice.successfulOutcome->procedureCode = NGAP_ProcedureCode_id_InitialContextSetup;
   pdu.choice.successfulOutcome->criticality = NGAP_Criticality_reject;
   pdu.choice.successfulOutcome->value.present = NGAP_SuccessfulOutcome__value_PR_InitialContextSetupResponse;
@@ -710,6 +713,7 @@ int ngap_gNB_initial_ctxt_resp(
   ie->criticality = NGAP_Criticality_ignore;
   ie->value.present = NGAP_InitialContextSetupResponseIEs__value_PR_PDUSessionResourceSetupListCxtRes;
 
+  if (initial_ctxt_resp_p->nb_of_pdusessions){
     for (i = 0; i < initial_ctxt_resp_p->nb_of_pdusessions; i++) {
       NGAP_PDUSessionResourceSetupItemCxtRes_t *item;
       NGAP_PDUSessionResourceSetupResponseTransfer_t     *pdusessionTransfer_p = NULL;
@@ -749,7 +753,7 @@ int ngap_gNB_initial_ctxt_resp(
         ass_qos_item_p = (NGAP_AssociatedQosFlowItem_t *)calloc(1, sizeof(NGAP_AssociatedQosFlowItem_t));
 
         /* qosFlowIdentifier */
-      ass_qos_item_p->qosFlowIdentifier = initial_ctxt_resp_p->pdusessions[i].associated_qos_flows[j].qci;
+        ass_qos_item_p->qosFlowIdentifier = initial_ctxt_resp_p->pdusessions[i].associated_qos_flows[j].qfi;
 
         /* qosFlowMappingIndication */
         if(initial_ctxt_resp_p->pdusessions[i].associated_qos_flows[j].qos_flow_mapping_ind != QOSFLOW_MAPPING_INDICATION_NON) {
@@ -770,7 +774,7 @@ int ngap_gNB_initial_ctxt_resp(
     }
 
     ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
-
+  }
   /* optional */
   if (initial_ctxt_resp_p->nb_of_pdusessions_failed) {
     ie = (NGAP_InitialContextSetupResponseIEs_t *)calloc(1, sizeof(NGAP_InitialContextSetupResponseIEs_t));
@@ -903,6 +907,7 @@ int ngap_gNB_ue_capabilities(instance_t instance,
   /* Prepare the NGAP message to encode */
   memset(&pdu, 0, sizeof(pdu));
   pdu.present = NGAP_NGAP_PDU_PR_initiatingMessage;
+  pdu.choice.initiatingMessage = (NGAP_InitiatingMessage_t *)calloc(1,sizeof(NGAP_InitiatingMessage_t));
   pdu.choice.initiatingMessage->procedureCode = NGAP_ProcedureCode_id_UERadioCapabilityInfoIndication;
   pdu.choice.initiatingMessage->criticality = NGAP_Criticality_ignore;
   pdu.choice.initiatingMessage->value.present = NGAP_InitiatingMessage__value_PR_UERadioCapabilityInfoIndication;
@@ -996,6 +1001,7 @@ int ngap_gNB_pdusession_setup_resp(instance_t instance,
   /* Prepare the NGAP message to encode */
   memset(&pdu, 0, sizeof(pdu));
   pdu.present = NGAP_NGAP_PDU_PR_successfulOutcome;
+  pdu.choice.successfulOutcome = (NGAP_SuccessfulOutcome_t *)calloc(1,sizeof(struct NGAP_SuccessfulOutcome));
   pdu.choice.successfulOutcome->procedureCode = NGAP_ProcedureCode_id_PDUSessionResourceSetup;
   pdu.choice.successfulOutcome->criticality = NGAP_Criticality_reject;
   pdu.choice.successfulOutcome->value.present = NGAP_SuccessfulOutcome__value_PR_PDUSessionResourceSetupResponse;
@@ -1036,6 +1042,8 @@ int ngap_gNB_pdusession_setup_resp(instance_t instance,
       pdusessionTransfer_p = (NGAP_PDUSessionResourceSetupResponseTransfer_t *)calloc(1, sizeof(NGAP_PDUSessionResourceSetupResponseTransfer_t));
 
       pdusessionTransfer_p->dLQosFlowPerTNLInformation.uPTransportLayerInformation.present = NGAP_UPTransportLayerInformation_PR_gTPTunnel;
+      pdusessionTransfer_p->dLQosFlowPerTNLInformation.uPTransportLayerInformation.choice.gTPTunnel =
+                calloc(1, sizeof(struct NGAP_GTPTunnel));
 
       GTP_TEID_TO_ASN1(pdusession_setup_resp_p->pdusessions[i].gtp_teid, &pdusessionTransfer_p->dLQosFlowPerTNLInformation.uPTransportLayerInformation.choice.gTPTunnel->gTP_TEID);
 
@@ -1061,20 +1069,28 @@ int ngap_gNB_pdusession_setup_resp(instance_t instance,
         ass_qos_item_p = (NGAP_AssociatedQosFlowItem_t *)calloc(1, sizeof(NGAP_AssociatedQosFlowItem_t));
 
         /* qosFlowIdentifier */
-        ass_qos_item_p->qosFlowIdentifier = pdusession_setup_resp_p->pdusessions[i].associated_qos_flows[j].qci;
+        ass_qos_item_p->qosFlowIdentifier = pdusession_setup_resp_p->pdusessions[i].associated_qos_flows[j].qfi;
 
         /* qosFlowMappingIndication */
-        if(pdusession_setup_resp_p->pdusessions[i].associated_qos_flows[j].qos_flow_mapping_ind != QOSFLOW_MAPPING_INDICATION_NON) {
-          ass_qos_item_p->qosFlowMappingIndication = malloc(sizeof(*ass_qos_item_p->qosFlowMappingIndication));
-          *ass_qos_item_p->qosFlowMappingIndication = pdusession_setup_resp_p->pdusessions[i].associated_qos_flows[j].qos_flow_mapping_ind;
-        }
+        //if(pdusession_setup_resp_p->pdusessions[i].associated_qos_flows[j].qos_flow_mapping_ind != QOSFLOW_MAPPING_INDICATION_NON) {
+        //  ass_qos_item_p->qosFlowMappingIndication = malloc(sizeof(*ass_qos_item_p->qosFlowMappingIndication));
+        //  *ass_qos_item_p->qosFlowMappingIndication = pdusession_setup_resp_p->pdusessions[i].associated_qos_flows[j].qos_flow_mapping_ind;
+        //}
         ASN_SEQUENCE_ADD(&pdusessionTransfer_p->dLQosFlowPerTNLInformation.associatedQosFlowList.list, ass_qos_item_p);
       }
 
       memset(&res, 0, sizeof(res));
-      res = asn_encode_to_new_buffer(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_NGAP_PDUSessionResourceSetupResponseTransfer, pdusessionTransfer_p);
-      item->pDUSessionResourceSetupResponseTransfer.buf = res.buffer;
-      item->pDUSessionResourceSetupResponseTransfer.size = res.result.encoded;
+//      res = asn_encode_to_new_buffer(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_NGAP_PDUSessionResourceSetupResponseTransfer, pdusessionTransfer_p);
+//      item->pDUSessionResourceSetupResponseTransfer.buf = res.buffer;
+//      item->pDUSessionResourceSetupResponseTransfer.size = res.result.encoded;
+      uint8_t buffer[100];
+      asn_enc_rval_t  enc_rval = aper_encode_to_buffer(&asn_DEF_NGAP_PDUSessionResourceSetupResponseTransfer, 
+                                  NULL, 
+                                  pdusessionTransfer_p, 
+                                  buffer,100);
+      AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n", enc_rval.failed_type->name, enc_rval.encoded);
+      item->pDUSessionResourceSetupResponseTransfer.buf = buffer;
+      item->pDUSessionResourceSetupResponseTransfer.size = enc_rval.encoded;
 
       ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_NGAP_PDUSessionResourceSetupResponseTransfer, pdusessionTransfer_p);
 
@@ -1218,6 +1234,7 @@ int ngap_gNB_pdusession_modify_resp(instance_t instance,
   /* Prepare the NGAP message to encode */
   memset(&pdu, 0, sizeof(pdu));
   pdu.present = NGAP_NGAP_PDU_PR_successfulOutcome;
+  pdu.choice.successfulOutcome = (NGAP_SuccessfulOutcome_t *)calloc(1,sizeof(struct NGAP_SuccessfulOutcome));
   pdu.choice.successfulOutcome->procedureCode = NGAP_ProcedureCode_id_PDUSessionResourceModify;
   pdu.choice.successfulOutcome->criticality = NGAP_Criticality_reject;
   pdu.choice.successfulOutcome->value.present = NGAP_SuccessfulOutcome__value_PR_PDUSessionResourceModifyResponse;
@@ -1378,6 +1395,7 @@ int ngap_gNB_pdusession_release_resp(instance_t instance,
   /* Prepare the NGAP message to encode */
   memset(&pdu, 0, sizeof(pdu));
   pdu.present = NGAP_NGAP_PDU_PR_successfulOutcome;
+  pdu.choice.successfulOutcome = (NGAP_SuccessfulOutcome_t *)calloc(1,sizeof(struct NGAP_SuccessfulOutcome));
   pdu.choice.successfulOutcome->procedureCode = NGAP_ProcedureCode_id_PDUSessionResourceRelease;
   pdu.choice.successfulOutcome->criticality = NGAP_Criticality_reject;
   pdu.choice.successfulOutcome->value.present = NGAP_SuccessfulOutcome__value_PR_PDUSessionResourceReleaseResponse;

openair3/NGAP/ngap_gNB_ue_context.c

@@ -82,8 +82,8 @@ struct ngap_gNB_ue_context_s *ngap_gNB_get_ue_context(
 
   memset(&temp, 0, sizeof(struct ngap_gNB_ue_context_s));
 
-  /* gNB ue ngap id = 24 bits wide */
-  temp.gNB_ue_ngap_id = gNB_ue_ngap_id & 0x00FFFFFF;
+  /* gNB ue ngap id = 32 bits wide */
+  temp.gNB_ue_ngap_id = gNB_ue_ngap_id & 0xFFFFFFFF;
 
   return RB_FIND(ngap_ue_map, &instance_p->ngap_ue_head, &temp);
 }