nos1 ping is ok and initianluemessage with 4gnas

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,

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/COMMON/s1ap_messages_types.h

@@ -386,6 +386,7 @@ typedef struct s1ap_register_enb_req_s {
   uint8_t          nb_mme;
   /* List of MME to connect to */
   net_ip_address_t mme_ip_address[S1AP_MAX_NB_MME_IP_ADDRESS];
+  uint16_t         mme_port[S1AP_MAX_NB_MME_IP_ADDRESS];
   uint8_t          broadcast_plmn_num[S1AP_MAX_NB_MME_IP_ADDRESS];
   uint8_t          broadcast_plmn_index[S1AP_MAX_NB_MME_IP_ADDRESS][PLMN_LIST_MAX_SIZE];
 

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/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/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;
@@ -1105,6 +1107,34 @@ rrc_gNB_decode_dcch(
 
         ue_context_p->ue_context.ue_release_timer = 0;
         break;
+
+        case NR_UL_DCCH_MessageType__c1_PR_ulInformationTransfer:
+            LOG_I(NR_RRC,"Recived RRC GNB UL Information Transfer \n");
+            if(!ue_context_p) {
+                LOG_I(NR_RRC, "Processing ulInformationTransfer UE %x, ue_context_p is NULL\n", ctxt_pP->rnti);
+                break;
+            }
+
+            LOG_D(NR_RRC,"[MSG] RRC UL Information Transfer \n");
+            LOG_DUMPMSG(RRC,DEBUG_RRC,(char *)Rx_sdu,sdu_sizeP,
+                        "[MSG] RRC UL Information Transfer \n");
+            MSC_LOG_RX_MESSAGE(
+              MSC_RRC_GNB,
+              MSC_RRC_UE,
+              Rx_sdu,
+              sdu_sizeP,
+              MSC_AS_TIME_FMT" ulInformationTransfer UE %x size %u",
+              MSC_AS_TIME_ARGS(ctxt_pP),
+              ue_context_p->ue_context.rnti,
+              sdu_sizeP);
+
+            if (AMF_MODE_ENABLED == 1) {
+                rrc_gNB_send_NGAP_UPLINK_NAS(ctxt_pP,
+                                          ue_context_p,
+                                          ul_dcch_msg);
+            }
+            break;
+
       case NR_UL_DCCH_MessageType__c1_PR_securityModeComplete:
         // to avoid segmentation fault
         if(!ue_context_p) {
@@ -1130,6 +1160,31 @@ rrc_gNB_decode_dcch(
         rrc_gNB_generate_UECapabilityEnquiry(ctxt_pP, ue_context_p);
         //rrc_gNB_generate_defaultRRCReconfiguration(ctxt_pP, ue_context_p);
         break;
+        case NR_UL_DCCH_MessageType__c1_PR_securityModeFailure:
+            LOG_DUMPMSG(NR_RRC,DEBUG_RRC,(char *)Rx_sdu,sdu_sizeP,
+                       "[MSG] NR RRC Security Mode Failure\n");
+            MSC_LOG_RX_MESSAGE(
+                MSC_RRC_GNB,
+                MSC_RRC_UE,
+                Rx_sdu,
+                sdu_sizeP,
+                MSC_AS_TIME_FMT" securityModeFailure UE %x size %u",
+                MSC_AS_TIME_ARGS(ctxt_pP),
+                ue_context_p->ue_context.rnti,
+                sdu_sizeP);
+            LOG_W(NR_RRC,
+                  PROTOCOL_RRC_CTXT_UE_FMT" RLC RB %02d --- RLC_DATA_IND %d bytes "
+                  "(securityModeFailure) ---> RRC_gNB\n",
+                  PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP),
+                  DCCH,
+                  sdu_sizeP);
+            
+            if ( LOG_DEBUGFLAG(DEBUG_ASN1) ) {
+              xer_fprint(stdout, &asn_DEF_NR_UL_DCCH_Message, (void *)ul_dcch_msg);
+            }
+            
+            rrc_gNB_generate_UECapabilityEnquiry(ctxt_pP, ue_context_p);
+            break;
 
       case NR_UL_DCCH_MessageType__c1_PR_ueCapabilityInformation:
         if(!ue_context_p) {
@@ -1236,7 +1291,11 @@ rrc_gNB_decode_dcch(
           if(eutra_index == -1)
           break;
       }
-
+      if (AMF_MODE_ENABLED == 1) {
+          rrc_gNB_send_NGAP_UE_CAPABILITIES_IND(ctxt_pP,
+                                    ue_context_p,
+                                    ul_dcch_msg);
+      }
       rrc_gNB_generate_defaultRRCReconfiguration(ctxt_pP, ue_context_p);
       break;
 
@@ -1356,6 +1415,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)
 
@@ -1444,6 +1511,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;
@@ -1582,7 +1657,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
 )
@@ -1593,16 +1668,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);
@@ -1611,14 +1686,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
@@ -1634,6 +1720,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/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/NGAP/ngap_gNB.c

@@ -95,6 +95,7 @@ static void ngap_gNB_register_amf(ngap_gNB_instance_t *instance_p,
   MessageDef                 *message_p                   = NULL;
   sctp_new_association_req_t *sctp_new_association_req_p  = NULL;
   ngap_gNB_amf_data_t        *ngap_amf_data_p             = NULL;
+  struct ngap_gNB_amf_data_s *amf                         = NULL;
   DevAssert(instance_p != NULL);
   DevAssert(amf_ip_address != NULL);
   message_p = itti_alloc_new_message(TASK_NGAP, SCTP_NEW_ASSOCIATION_REQ);
@@ -110,7 +111,9 @@ static void ngap_gNB_register_amf(ngap_gNB_instance_t *instance_p,
          local_ip_addr,
          sizeof(*local_ip_addr));
   NGAP_INFO("[gNB %d] check the amf registration state\n",instance_p->instance);
+  amf = NULL;
 
+  if ( amf == NULL ) {
     /* Create new AMF descriptor */
     ngap_amf_data_p = calloc(1, sizeof(*ngap_amf_data_p));
     DevAssert(ngap_amf_data_p != NULL);
@@ -133,6 +136,25 @@ static void ngap_gNB_register_amf(ngap_gNB_instance_t *instance_p,
     ngap_amf_data_p->state = NGAP_GNB_STATE_WAITING;
     instance_p->ngap_amf_nb ++;
     instance_p->ngap_amf_pending_nb ++;
+  } else if (amf->state == NGAP_GNB_STATE_WAITING) {
+    instance_p->ngap_amf_pending_nb ++;
+    sctp_new_association_req_p->ulp_cnx_id = amf->cnx_id;
+    NGAP_INFO("[gNB %d] AMF already registered, retrive the data (state %d, cnx %d, amf_nb %d, amf_pending_nb %d)\n",
+              instance_p->instance,
+              amf->state, amf->cnx_id,
+              instance_p->ngap_amf_nb, instance_p->ngap_amf_pending_nb);
+    /*ngap_amf_data_p->cnx_id                = amf->cnx_id;
+    sctp_new_association_req_p->ulp_cnx_id = amf->cnx_id;
+
+    ngap_amf_data_p->assoc_id          = -1;
+    ngap_amf_data_p->ngap_gNB_instance = instance_p;
+    */
+  } else {
+    NGAP_WARN("[gNB %d] AMF already registered but not in the waiting state, retrive the data (state %d, cnx %d, amf_nb %d, amf_pending_nb %d)\n",
+              instance_p->instance,
+              amf->state, amf->cnx_id,
+              instance_p->ngap_amf_nb, instance_p->ngap_amf_pending_nb);
+  }
 
   itti_send_msg_to_task(TASK_SCTP, instance_p->instance, message_p);
 }

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_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

@@ -344,11 +344,11 @@ int ngap_gNB_handle_nas_downlink(uint32_t         assoc_id,
   DevAssert(pdu != NULL);
 
   /* UE-related procedure -> stream != 0 */
-  if (stream == 0) {
-    NGAP_ERROR("[SCTP %d] Received UE-related procedure on stream == 0\n",
-               assoc_id);
-    return -1;
-  }
+  // if (stream == 0) {
+  //     NGAP_ERROR("[SCTP %d] Received UE-related procedure on stream == 0\n",
+  //                assoc_id);
+  //     return -1;
+  // }
 
   if ((amf_desc_p = ngap_gNB_get_AMF(NULL, assoc_id, 0)) == NULL) {
     NGAP_ERROR(
@@ -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 */
@@ -579,6 +581,7 @@ int ngap_gNB_nas_non_delivery_ind(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_NASNonDeliveryIndication;
   pdu.choice.initiatingMessage->criticality = NGAP_Criticality_ignore;
   pdu.choice.initiatingMessage->value.present = NGAP_InitiatingMessage__value_PR_NASNonDeliveryIndication;
@@ -685,6 +688,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 +714,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 +754,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 +775,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 +908,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 +1002,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 +1043,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 +1070,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 +1235,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 +1396,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);
 }