Create ngap files

common/utils/LOG/log.h

@@ -226,6 +226,7 @@ typedef enum {
   X2AP,
   M2AP,
   M3AP,
+  NGAP,
   GNB_APP,
   NR_RRC,
   NR_MAC,

openair2/COMMON/ngap_messages_def.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
+ */
+
+/* Messages for NGAP logging */
+MESSAGE_DEF(NGAP_UPLINK_NAS_LOG            , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_uplink_nas_log)
+MESSAGE_DEF(NGAP_UE_CAPABILITY_IND_LOG     , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_ue_capability_ind_log)
+MESSAGE_DEF(NGAP_INITIAL_CONTEXT_SETUP_LOG , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_initial_context_setup_log)
+MESSAGE_DEF(NGAP_NAS_NON_DELIVERY_IND_LOG  , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_nas_non_delivery_ind_log)
+MESSAGE_DEF(NGAP_DOWNLINK_NAS_LOG          , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_downlink_nas_log)
+MESSAGE_DEF(NGAP_S1_SETUP_LOG              , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_s1_setup_log)
+MESSAGE_DEF(NGAP_INITIAL_UE_MESSAGE_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_initial_ue_message_log)
+MESSAGE_DEF(NGAP_UE_CONTEXT_RELEASE_REQ_LOG, MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_ue_context_release_req_log)
+MESSAGE_DEF(NGAP_UE_CONTEXT_RELEASE_COMMAND_LOG, MESSAGE_PRIORITY_MED, IttiMsgText                  , ngap_ue_context_release_command_log)
+MESSAGE_DEF(NGAP_UE_CONTEXT_RELEASE_COMPLETE_LOG, MESSAGE_PRIORITY_MED, IttiMsgText                 , ngap_ue_context_release_complete_log)
+MESSAGE_DEF(NGAP_UE_CONTEXT_RELEASE_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_ue_context_release_log)
+MESSAGE_DEF(NGAP_E_RAB_SETUP_REQUEST_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_e_rab_setup_request_log)
+MESSAGE_DEF(NGAP_E_RAB_SETUP_RESPONSE_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_e_rab_setup_response_log)
+MESSAGE_DEF(NGAP_E_RAB_MODIFY_REQUEST_LOG     , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_e_rab_modify_request_log)
+MESSAGE_DEF(NGAP_E_RAB_MODIFY_RESPONSE_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_e_rab_modify_response_log)
+MESSAGE_DEF(NGAP_PAGING_LOG    , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_paging_log)
+MESSAGE_DEF(NGAP_E_RAB_RELEASE_REQUEST_LOG   , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_e_rab_release_request_log)
+MESSAGE_DEF(NGAP_E_RAB_RELEASE_RESPONSE_LOG  , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_e_rab_release_response_log)
+MESSAGE_DEF(NGAP_ERROR_INDICATION_LOG        , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_error_indication_log)
+MESSAGE_DEF(NGAP_PATH_SWITCH_REQ_LOG         , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_path_switch_req_log)
+MESSAGE_DEF(NGAP_PATH_SWITCH_REQ_ACK_LOG     , MESSAGE_PRIORITY_MED, IttiMsgText                      , ngap_path_switch_req_ack_log)
+
+/* gNB application layer -> NGAP messages */
+MESSAGE_DEF(NGAP_REGISTER_GNB_REQ          , MESSAGE_PRIORITY_MED, ngap_register_enb_req_t          , ngap_register_enb_req)
+
+/* NGAP -> gNB application layer messages */
+MESSAGE_DEF(NGAP_REGISTER_GNB_CNF          , MESSAGE_PRIORITY_MED, ngap_register_enb_cnf_t          , ngap_register_enb_cnf)
+MESSAGE_DEF(NGAP_DEREGISTERED_GNB_IND      , MESSAGE_PRIORITY_MED, ngap_deregistered_enb_ind_t      , ngap_deregistered_enb_ind)
+
+/* RRC -> NGAP messages */
+MESSAGE_DEF(NGAP_NAS_FIRST_REQ             , MESSAGE_PRIORITY_MED, ngap_nas_first_req_t             , ngap_nas_first_req)
+MESSAGE_DEF(NGAP_UPLINK_NAS                , MESSAGE_PRIORITY_MED, ngap_uplink_nas_t                , ngap_uplink_nas)
+MESSAGE_DEF(NGAP_UE_CAPABILITIES_IND       , MESSAGE_PRIORITY_MED, ngap_ue_cap_info_ind_t           , ngap_ue_cap_info_ind)
+MESSAGE_DEF(NGAP_INITIAL_CONTEXT_SETUP_RESP, MESSAGE_PRIORITY_MED, ngap_initial_context_setup_resp_t, ngap_initial_context_setup_resp)
+MESSAGE_DEF(NGAP_INITIAL_CONTEXT_SETUP_FAIL, MESSAGE_PRIORITY_MED, ngap_initial_context_setup_fail_t, ngap_initial_context_setup_fail)
+MESSAGE_DEF(NGAP_NAS_NON_DELIVERY_IND      , MESSAGE_PRIORITY_MED, ngap_nas_non_delivery_ind_t      , ngap_nas_non_delivery_ind)
+MESSAGE_DEF(NGAP_UE_CONTEXT_RELEASE_RESP   , MESSAGE_PRIORITY_MED, ngap_ue_release_resp_t           , ngap_ue_release_resp)
+MESSAGE_DEF(NGAP_UE_CONTEXT_RELEASE_COMPLETE, MESSAGE_PRIORITY_MED, ngap_ue_release_complete_t      , ngap_ue_release_complete)
+MESSAGE_DEF(NGAP_UE_CTXT_MODIFICATION_RESP , MESSAGE_PRIORITY_MED, ngap_ue_ctxt_modification_resp_t , ngap_ue_ctxt_modification_resp)
+MESSAGE_DEF(NGAP_UE_CTXT_MODIFICATION_FAIL , MESSAGE_PRIORITY_MED, ngap_ue_ctxt_modification_fail_t , ngap_ue_ctxt_modification_fail)
+MESSAGE_DEF(NGAP_E_RAB_SETUP_RESP          , MESSAGE_PRIORITY_MED, ngap_e_rab_setup_resp_t          , ngap_e_rab_setup_resp)
+MESSAGE_DEF(NGAP_E_RAB_SETUP_REQUEST_FAIL  , MESSAGE_PRIORITY_MED, ngap_e_rab_setup_req_fail_t      , ngap_e_rab_setup_request_fail)
+MESSAGE_DEF(NGAP_E_RAB_MODIFY_RESP          , MESSAGE_PRIORITY_MED, ngap_e_rab_modify_resp_t          , ngap_e_rab_modify_resp)
+MESSAGE_DEF(NGAP_E_RAB_RELEASE_RESPONSE    , MESSAGE_PRIORITY_MED, ngap_e_rab_release_resp_t        , ngap_e_rab_release_resp)
+MESSAGE_DEF(NGAP_PATH_SWITCH_REQ           , MESSAGE_PRIORITY_MED, ngap_path_switch_req_t           , ngap_path_switch_req)
+MESSAGE_DEF(NGAP_PATH_SWITCH_REQ_ACK       , MESSAGE_PRIORITY_MED, ngap_path_switch_req_ack_t       , ngap_path_switch_req_ack)
+MESSAGE_DEF(NGAP_E_RAB_MODIFICATION_IND    , MESSAGE_PRIORITY_MED, ngap_e_rab_modification_ind_t    , ngap_e_rab_modification_ind)
+
+/* NGAP -> RRC messages */
+MESSAGE_DEF(NGAP_DOWNLINK_NAS              , MESSAGE_PRIORITY_MED, ngap_downlink_nas_t              , ngap_downlink_nas )
+MESSAGE_DEF(NGAP_INITIAL_CONTEXT_SETUP_REQ , MESSAGE_PRIORITY_MED, ngap_initial_context_setup_req_t , ngap_initial_context_setup_req )
+MESSAGE_DEF(NGAP_UE_CTXT_MODIFICATION_REQ  , MESSAGE_PRIORITY_MED, ngap_ue_ctxt_modification_req_t  , ngap_ue_ctxt_modification_req)
+MESSAGE_DEF(NGAP_PAGING_IND                , MESSAGE_PRIORITY_MED, ngap_paging_ind_t                , ngap_paging_ind )
+MESSAGE_DEF(NGAP_E_RAB_SETUP_REQ            , MESSAGE_PRIORITY_MED, ngap_e_rab_setup_req_t        , ngap_e_rab_setup_req )
+MESSAGE_DEF(NGAP_E_RAB_MODIFY_REQ           , MESSAGE_PRIORITY_MED, ngap_e_rab_modify_req_t        , ngap_e_rab_modify_req )
+MESSAGE_DEF(NGAP_E_RAB_RELEASE_COMMAND     , MESSAGE_PRIORITY_MED, ngap_e_rab_release_command_t     , ngap_e_rab_release_command)
+MESSAGE_DEF(NGAP_UE_CONTEXT_RELEASE_COMMAND, MESSAGE_PRIORITY_MED, ngap_ue_release_command_t        , ngap_ue_release_command)
+
+/* NGAP <-> RRC messages (can be initiated either by MME or gNB) */
+MESSAGE_DEF(NGAP_UE_CONTEXT_RELEASE_REQ    , MESSAGE_PRIORITY_MED, ngap_ue_release_req_t            , ngap_ue_release_req)

openair2/RRC/NR/MESSAGES/asn1c/ASN1_files/nr-rrc-16.1.0.asn1

@@ -7449,7 +7449,7 @@ ShortMAC-I ::=                      BIT STRING (SIZE (16))
 SINR-Range ::=                      INTEGER(0..127)
 
 -- TAG-SINR-RANGE-STOP
--- TAG–SI-REQUESTCONFIG-START
+-- TAGCSI-REQUESTCONFIG-START
 
 SI-RequestConfig::=                 SEQUENCE {
     rach-OccasionsSI                    SEQUENCE {
@@ -7466,7 +7466,7 @@ SI-RequestResources ::=             SEQUENCE {
     ra-ssb-OccasionMaskIndex            INTEGER (0..15)                                                     OPTIONAL    -- Need R
 }
 
--- TAG–SI-SCHEDULINGINFO-START
+-- TAGCSI-SCHEDULINGINFO-START
 
 SI-SchedulingInfo ::=               SEQUENCE {
     schedulingInfoList                  SEQUENCE (SIZE (1..maxSI-Message)) OF SchedulingInfo,

openair3/NGAP/ngap_common.c

+/*
+ * 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 ngap_common.c
+ * \brief ngap procedures for both gNB and AMF
+ * \author Sebastien ROUX and Navid Nikaein
+ * \email navid.nikaein@eurecom.fr
+ * \date 2012-2015
+ * \version 0.1
+ */
+
+#include <stdint.h>
+
+#include "ngap_common.h"
+#include "NGAP_NGAP-PDU.h"
+
+
+int asn1_xer_print = 0;
+
+
+void ngap_handle_criticality(NGAP_Criticality_t criticality)
+{
+}

openair3/NGAP/ngap_common.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
+ */
+
+/** @defgroup _ngap_impl_ NGAP Layer Reference Implementation
+ * @ingroup _ref_implementation_
+ * @{
+ */
+
+#if HAVE_CONFIG_H_
+# include "config.h"
+#endif
+
+#ifndef NGAP_COMMON_H_
+#define NGAP_COMMON_H_
+
+
+#include "common/utils/LOG/log.h"
+/* replace ASN_DEBUG defined in asn_internal.h by oai tracing system
+   Would be cleaner to modify asn_internal.h but it seems to come
+   from non oai source, with BSD license, so prefer to do that here..
+*/
+#ifdef ASN_DEBUG
+# undef ASN_DEBUG
+#endif
+#define ASN_DEBUG( x... )  LOG_I(ASN, x)
+
+#include "NGAP_ProtocolIE-Field.h"
+#include "NGAP_NGAP-PDU.h"
+#include "NGAP_InitiatingMessage.h"
+#include "NGAP_SuccessfulOutcome.h"
+#include "NGAP_UnsuccessfulOutcome.h"
+#include "NGAP_ProtocolIE-Field.h"
+#include "NGAP_ProtocolIE-FieldPair.h"
+#include "NGAP_ProtocolIE-ContainerPair.h"
+#include "NGAP_ProtocolExtensionField.h"
+#include "NGAP_ProtocolExtensionContainer.h"
+#include "NGAP_asn_constant.h"
+#include "NGAP_SupportedTAs-Item.h"
+#include "NGAP_ServedGUMMEIsItem.h"
+
+/* Checking version of ASN1C compiler */
+#if (ASN1C_ENVIRONMENT_VERSION < ASN1C_MINIMUM_VERSION)
+# error "You are compiling ngap with the wrong version of ASN1C"
+#endif
+
+#ifndef FALSE
+# define FALSE (0)
+#endif
+#ifndef TRUE
+# define TRUE  (!FALSE)
+#endif
+
+#define NGAP_UE_ID_FMT  "0x%06"PRIX32
+
+extern int asn_debug;
+extern int asn1_xer_print;
+
+#if defined(ENB_MODE)
+# include "common/utils/LOG/log.h"
+# include "ngap_eNB_default_values.h"
+# define NGAP_ERROR(x, args...) LOG_E(NGAP, x, ##args)
+# define NGAP_WARN(x, args...)  LOG_W(NGAP, x, ##args)
+# define NGAP_TRAF(x, args...)  LOG_I(NGAP, x, ##args)
+# define NGAP_INFO(x, args...) LOG_I(NGAP, x, ##args)
+# define NGAP_DEBUG(x, args...) LOG_I(NGAP, x, ##args)
+#else
+# include "mme_default_values.h"
+# define NGAP_ERROR(x, args...) do { fprintf(stdout, "[NGAP][E]"x, ##args); } while(0)
+# define NGAP_WARN(x, args...)  do { fprintf(stdout, "[NGAP][W]"x, ##args); } while(0)
+# define NGAP_TRAF(x, args...)  do { fprintf(stdout, "[NGAP][T]"x, ##args); } while(0)
+# define NGAP_INFO(x, args...) do { fprintf(stdout, "[NGAP][I]"x, ##args); } while(0)
+# define NGAP_DEBUG(x, args...) do { fprintf(stdout, "[NGAP][D]"x, ##args); } while(0)
+#endif
+
+
+#define NGAP_FIND_PROTOCOLIE_BY_ID(IE_TYPE, ie, container, IE_ID, mandatory) \
+  do {\
+    IE_TYPE **ptr; \
+    ie = NULL; \
+    for (ptr = container->protocolIEs.list.array; \
+         ptr < &container->protocolIEs.list.array[container->protocolIEs.list.count]; \
+         ptr++) { \
+      if((*ptr)->id == IE_ID) { \
+        ie = *ptr; \
+        break; \
+      } \
+    } \
+    if (ie == NULL ) { \
+      NGAP_ERROR("NGAP_FIND_PROTOCOLIE_BY_ID: %s %d: ie is NULL\n",__FILE__,__LINE__);\
+    } \
+    if (mandatory)  DevAssert(ie != NULL); \
+  } while(0)
+/** \brief Function callback prototype.
+ **/
+typedef int (*ngap_message_decoded_callback)(
+    uint32_t         assoc_id,
+    uint32_t         stream,
+    NGAP_NGAP_PDU_t *pdu
+);
+
+/** \brief Handle criticality
+ \param criticality Criticality of the IE
+ @returns void
+ **/
+void ngap_handle_criticality(NGAP_Criticality_t criticality);
+
+#endif /* NGAP_COMMON_H_ */

openair3/NGAP/ngap_gNB.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
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+
+/** @defgroup _ngap_impl_ NGAP Layer Reference Implementation for gNB
+ * @ingroup _ref_implementation_
+ * @{
+ */
+
+#ifndef NGAP_GNB_H_
+#define NGAP_GNB_H_
+
+typedef struct ngap_gNB_config_s {
+  // MME related params
+  unsigned char mme_enabled;          ///< MME enabled ?
+} ngap_gNB_config_t;
+
+extern ngap_gNB_config_t ngap_config;
+
+#define EPC_MODE_ENABLED       ngap_config.mme_enabled
+
+void *ngap_gNB_process_itti_msg(void*);
+void  ngap_gNB_init(void);
+void *ngap_gNB_task(void *arg);
+
+uint32_t ngap_generate_gNB_id(void);
+
+#endif /* NGAP_GNB_H_ */
+
+/**
+ * @}
+ */

openair3/NGAP/ngap_gNB_context_management_procedures.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
+ */
+
+#ifndef NGAP_GNB_CONTEXT_MANAGEMENT_PROCEDURES_H_
+#define NGAP_GNB_CONTEXT_MANAGEMENT_PROCEDURES_H_
+
+
+int ngap_ue_context_release_complete(instance_t instance,
+                                     ngap_ue_release_complete_t *ue_release_complete_p);
+
+int ngap_ue_context_release_req(instance_t instance,
+                                ngap_ue_release_req_t *ue_release_req_p);
+
+#endif /* NGAP_GNB_CONTEXT_MANAGEMENT_PROCEDURES_H_ */

openair3/NGAP/ngap_gNB_decoder.c

+/*
+ * 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 ngap_gNB_decoder.c
+ * \brief ngap pdu decode procedures for gNB
+ * \author Sebastien ROUX and Navid Nikaein
+ * \email navid.nikaein@eurecom.fr
+ * \date 2013 - 2015
+ * \version 0.1
+ */
+
+#include <stdio.h>
+
+#include "assertions.h"
+
+#include "intertask_interface.h"
+
+#include "ngap_common.h"
+#include "ngap_gNB_decoder.h"
+
+static int ngap_gNB_decode_initiating_message(NGAP_NGAP_PDU_t *pdu) {
+  asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
+  DevAssert(pdu != NULL);
+
+  switch(pdu->choice.initiatingMessage.procedureCode) {
+    case NGAP_ProcedureCode_id_downlinkNASTransport:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_InitialContextSetup:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_UEContextRelease:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_Paging:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      NGAP_INFO("Paging initiating message\n");
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_E_RABSetup:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      NGAP_INFO("E_RABSetup initiating message\n");
+      break;
+
+    case NGAP_ProcedureCode_id_E_RABModify:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      NGAP_INFO("E_RABModify initiating message\n");
+      break;
+
+    case NGAP_ProcedureCode_id_E_RABRelease:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      NGAP_INFO("TODO E_RABRelease initiating message\n");
+      break;
+
+    case NGAP_ProcedureCode_id_ErrorIndication:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      NGAP_INFO("TODO ErrorIndication initiating message\n");
+      break;
+
+    default:
+      NGAP_ERROR("Unknown procedure ID (%d) for initiating message\n",
+                 (int)pdu->choice.initiatingMessage.procedureCode);
+      AssertFatal( 0, "Unknown procedure ID (%d) for initiating message\n",
+                   (int)pdu->choice.initiatingMessage.procedureCode);
+      return -1;
+  }
+
+  return 0;
+}
+
+static int ngap_gNB_decode_successful_outcome(NGAP_NGAP_PDU_t *pdu) {
+  asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
+  DevAssert(pdu != NULL);
+
+  switch(pdu->choice.successfulOutcome.procedureCode) {
+    case NGAP_ProcedureCode_id_S1Setup:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_PathSwitchRequest:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_E_RABModificationIndication:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+
+    default:
+      NGAP_ERROR("Unknown procedure ID (%d) for successfull outcome message\n",
+                 (int)pdu->choice.successfulOutcome.procedureCode);
+      return -1;
+  }
+
+  return 0;
+}
+
+static int ngap_gNB_decode_unsuccessful_outcome(NGAP_NGAP_PDU_t *pdu) {
+  asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
+  DevAssert(pdu != NULL);
+
+  switch(pdu->choice.unsuccessfulOutcome.procedureCode) {
+    case NGAP_ProcedureCode_id_S1Setup:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+   case NGAP_ProcedureCode_id_PathSwitchRequest:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    default:
+      NGAP_ERROR("Unknown procedure ID (%d) for unsuccessfull outcome message\n",
+                 (int)pdu->choice.unsuccessfulOutcome.procedureCode);
+      return -1;
+  }
+
+  return 0;
+}
+
+int ngap_gNB_decode_pdu(NGAP_NGAP_PDU_t *pdu, const uint8_t *const buffer,
+                        const uint32_t length) {
+  asn_dec_rval_t dec_ret;
+  DevAssert(pdu != NULL);
+  DevAssert(buffer != NULL);
+  dec_ret = aper_decode(NULL,
+                        &asn_DEF_NGAP_NGAP_PDU,
+                        (void **)&pdu,
+                        buffer,
+                        length,
+                        0,
+                        0);
+
+  if (dec_ret.code != RC_OK) {
+    NGAP_ERROR("Failed to decode pdu\n");
+    return -1;
+  }
+
+  switch(pdu->present) {
+    case NGAP_NGAP_PDU_PR_initiatingMessage:
+      return ngap_gNB_decode_initiating_message(pdu);
+
+    case NGAP_NGAP_PDU_PR_successfulOutcome:
+      return ngap_gNB_decode_successful_outcome(pdu);
+
+    case NGAP_NGAP_PDU_PR_unsuccessfulOutcome:
+      return ngap_gNB_decode_unsuccessful_outcome(pdu);
+
+    default:
+      NGAP_DEBUG("Unknown presence (%d) or not implemented\n", (int)pdu->present);
+      break;
+  }
+
+  return -1;
+}

openair3/NGAP/ngap_gNB_decoder.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
+ */
+
+#include <stdint.h>
+
+#ifndef NGAP_GNB_DECODER_H_
+#define NGAP_GNB_DECODER_H_
+
+int ngap_gNB_decode_pdu(NGAP_NGAP_PDU_t *pdu, const uint8_t *const buffer,
+                        const uint32_t length) __attribute__ ((warn_unused_result));
+
+#endif /* NGAP_GNB_DECODER_H_ */

openair3/NGAP/ngap_gNB_default_values.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
+ */
+
+#ifndef NGAP_GNB_DEFAULT_VALUES_H_
+#define NGAP_GNB_DEFAULT_VALUES_H_
+
+#define GNB_TAC (1)
+#define GNB_MCC (208)
+#define GNB_MNC (92)
+
+#define GNB_NAME        "Eurecom GNB"
+#define GNB_NAME_FORMAT (GNB_NAME" %u")
+
+#define NGAP_PORT_NUMBER        (36412)
+#define NGAP_SCTP_PPID          (18)
+
+#define X2AP_PORT_NUMBER        (36422)
+#define X2AP_SCTP_PPID          (27)
+
+#endif /* NGAP_GNB_DEFAULT_VALUES_H_ */

openair3/NGAP/ngap_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
+ */
+
+#include <stdint.h>
+
+#include "queue.h"
+#include "tree.h"
+
+#include "sctp_gNB_defs.h"
+
+#ifndef NGAP_GNB_DEFS_H_
+#define NGAP_GNB_DEFS_H_
+
+#define NGAP_GNB_NAME_LENGTH_MAX    (150)
+
+typedef enum {
+  /* Disconnected state: initial state for any association. */
+  NGAP_GNB_STATE_DISCONNECTED = 0x0,
+  /* State waiting for S1 Setup response message if gNB is MME accepted or
+   * S1 Setup failure if MME rejects the gNB.
+   */
+  NGAP_GNB_STATE_WAITING     = 0x1,
+  /* The gNB is successfully connected to MME, UE contexts can be created. */
+  NGAP_GNB_STATE_CONNECTED   = 0x2,
+  /* The MME has sent an overload start message. Once the MME disables the
+   * OVERLOAD marker, the state of the association will be
+   * NGAP_GNB_STATE_CONNECTED.
+   */
+  NGAP_GNB_OVERLOAD          = 0x3,
+  /* Max number of states available */
+  NGAP_GNB_STATE_MAX,
+} ngap_gNB_state_t;
+
+/* If the Overload Action IE in the OVERLOAD START message is set to
+ * - “reject all RRC connection establishments for non-emergency mobile
+ *    originated data transfer “ (i.e. reject traffic corresponding to RRC cause
+ *    “mo-data “ (TS 36.331 [16])), or
+ * - “reject all RRC connection establishments for signalling “ (i.e. reject
+ *    traffic corresponding to RRC cause “modata” and “mo-signalling”
+ *    (TS 36.331 [16])),or
+ * - “only permit RRC connection establishments for emergency sessions and
+ *    mobile terminated services” (i.e. only permit traffic corresponding to RRC
+ *    cause “emergency” and “mt-Access” (TS 36.331 [16])).
+ *
+ * NOTE: When the Overload Action IE is set to “only permit RRC connection
+ * establishments for emergency sessions and mobile terminated services”,
+ * emergency calls with RRC cause “highPriorityAcess” from high priority users
+ * are rejected (TS 24.301 [24]).
+ */
+typedef enum {
+  NGAP_OVERLOAD_REJECT_MO_DATA        = 0x0,
+  NGAP_OVERLOAD_REJECT_ALL_SIGNALLING = 0x1,
+  NGAP_OVERLOAD_ONLY_EMERGENCY_AND_MT = 0x2,
+  NGAP_NO_OVERLOAD                    = 0x3,
+  NGAP_OVERLOAD_MAX,
+} ngap_overload_state_t;
+
+/* Served PLMN identity element */
+struct plmn_identity_s {
+  uint16_t mcc;
+  uint16_t mnc;
+  uint8_t  mnc_digit_length;
+  STAILQ_ENTRY(plmn_identity_s) next;
+};
+
+/* Served group id element */
+struct served_group_id_s {
+  uint16_t mme_group_id;
+  STAILQ_ENTRY(served_group_id_s) next;
+};
+
+/* Served mme code for a particular MME */
+struct mme_code_s {
+  uint8_t mme_code;
+  STAILQ_ENTRY(mme_code_s) next;
+};
+
+/* Served gummei element */
+struct served_gummei_s {
+  /* Number of MME served PLMNs */
+  uint8_t nb_served_plmns;
+  /* List of served PLMNs by MME */
+  STAILQ_HEAD(served_plmns_s, plmn_identity_s) served_plmns;
+
+  /* Number of group id in list */
+  uint8_t nb_group_id;
+  /* Served group id list */
+  STAILQ_HEAD(served_group_ids_s, served_group_id_s) served_group_ids;
+
+  /* Number of MME code */
+  uint8_t nb_mme_code;
+  /* MME Code to uniquely identify an MME within an MME pool area */
+  STAILQ_HEAD(mme_codes_s, mme_code_s) mme_codes;
+
+  /* Next GUMMEI element */
+  STAILQ_ENTRY(served_gummei_s) next;
+};
+
+struct ngap_gNB_instance_s;
+
+/* This structure describes association of a gNB to a MME */
+typedef struct ngap_gNB_mme_data_s {
+  /* MME descriptors tree, ordered by sctp assoc id */
+  RB_ENTRY(ngap_gNB_mme_data_s) entry;
+
+  /* This is the optional name provided by the MME */
+  char *mme_name;
+
+  /* MME NGAP IP address */
+  net_ip_address_t mme_s1_ip;
+
+  /* List of served GUMMEI per MME. There is one GUMMEI per RAT with a max
+   * number of 8 RATs but in our case only one is used. The LTE related pool
+   * configuration is included on the first place in the list.
+   */
+  STAILQ_HEAD(served_gummeis_s, served_gummei_s) served_gummei;
+
+  /* Relative processing capacity of an MME with respect to the other MMEs
+   * in the pool in order to load-balance MMEs within a pool as defined
+   * in TS 23.401.
+   */
+  uint8_t relative_mme_capacity;
+
+  /* Current MME overload information (if any). */
+  ngap_overload_state_t overload_state;
+  /* Current gNB->MME NGAP association state */
+  ngap_gNB_state_t state;
+
+  /* Next usable stream for UE signalling */
+  int32_t nextstream;
+
+  /* Number of input/ouput streams */
+  uint16_t in_streams;
+  uint16_t out_streams;
+
+  /* Connexion id used between SCTP/NGAP */
+  uint16_t cnx_id;
+
+  /* SCTP association id */
+  int32_t  assoc_id;
+
+  /* This is served PLMN IDs communicated to the MME via an index over the
+   * MCC/MNC array in ngap_gNB_instance */
+  uint8_t  broadcast_plmn_num;
+  uint8_t  broadcast_plmn_index[PLMN_LIST_MAX_SIZE];
+
+  /* Only meaningfull in virtual mode */
+  struct ngap_gNB_instance_s *ngap_gNB_instance;
+} ngap_gNB_mme_data_t;
+
+typedef struct ngap_gNB_instance_s {
+  /* Next ngap gNB association.
+   * Only used for virtual mode.
+   */
+  STAILQ_ENTRY(ngap_gNB_instance_s) ngap_gNB_entries;
+
+  /* Number of MME requested by gNB (tree size) */
+  uint32_t ngap_mme_nb;
+  /* Number of MME for which association is pending */
+  uint32_t ngap_mme_pending_nb;
+  /* Number of MME successfully associated to gNB */
+  uint32_t ngap_mme_associated_nb;
+  /* Tree of NGAP MME associations ordered by association ID */
+  RB_HEAD(ngap_mme_map, ngap_gNB_mme_data_s) ngap_mme_head;
+
+  /* TODO: add a map ordered by relative MME capacity */
+
+  /* Tree of UE ordered by gNB_ue_ngap_id's */
+  RB_HEAD(ngap_ue_map, ngap_gNB_ue_context_s) ngap_ue_head;
+
+  /* For virtual mode, mod_id as defined in the rest of the L1/L2 stack */
+  instance_t instance;
+
+  /* Displayable name of gNB */
+  char *gNB_name;
+
+  /* Unique gNB_id to identify the gNB within EPC.
+   * In our case the gNB is a macro gNB so the id will be 20 bits long.
+   * For Home gNB id, this field should be 28 bits long.
+   */
+  uint32_t gNB_id;
+  /* The type of the cell */
+  enum cell_type_e cell_type;
+
+  /* Tracking area code */
+  uint16_t tac;
+
+  /* gNB NGAP IP address */
+  net_ip_address_t gNB_s1_ip;
+  
+  /* Mobile Country Code
+   * Mobile Network Code
+   */
+  uint16_t  mcc[PLMN_LIST_MAX_SIZE];
+  uint16_t  mnc[PLMN_LIST_MAX_SIZE];
+  uint8_t   mnc_digit_length[PLMN_LIST_MAX_SIZE];
+  uint8_t   num_plmn;
+
+  /* Default Paging DRX of the gNB as defined in TS 36.304 */
+  paging_drx_t default_drx;
+} ngap_gNB_instance_t;
+
+typedef struct {
+  /* List of served gNBs
+   * Only used for virtual mode
+   */
+  STAILQ_HEAD(ngap_gNB_instances_head_s, ngap_gNB_instance_s) ngap_gNB_instances_head;
+  /* Nb of registered gNBs */
+  uint8_t nb_registered_gNBs;
+
+  /* Generate a unique connexion id used between NGAP and SCTP */
+  uint16_t global_cnx_id;
+} ngap_gNB_internal_data_t;
+
+int ngap_gNB_compare_assoc_id(
+  struct ngap_gNB_mme_data_s *p1, struct ngap_gNB_mme_data_s *p2);
+
+/* Generate the tree management functions */
+RB_PROTOTYPE(ngap_mme_map, ngap_gNB_mme_data_s, entry,
+             ngap_gNB_compare_assoc_id);
+
+#endif /* NGAP_GNB_DEFS_H_ */

openair3/NGAP/ngap_gNB_encoder.c

+/*
+ * 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 ngap_gNB_encoder.c
+ * \brief ngap pdu encode procedures for gNB
+ * \author Sebastien ROUX and Navid Nikaein
+ * \email navid.nikaein@eurecom.fr
+ * \date 2013 - 2015
+ * \version 0.1
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "assertions.h"
+#include "conversions.h"
+#include "intertask_interface.h"
+#include "ngap_common.h"
+#include "ngap_gNB_encoder.h"
+
+static inline int ngap_gNB_encode_initiating(NGAP_NGAP_PDU_t *pdu,
+    uint8_t **buffer,
+    uint32_t *len);
+
+static inline int ngap_gNB_encode_successfull_outcome(NGAP_NGAP_PDU_t *pdu,
+    uint8_t **buffer, uint32_t *len);
+
+static inline int ngap_gNB_encode_unsuccessfull_outcome(NGAP_NGAP_PDU_t *pdu,
+    uint8_t **buffer, uint32_t *len);
+
+int ngap_gNB_encode_pdu(NGAP_NGAP_PDU_t *pdu, uint8_t **buffer, uint32_t *len) {
+  int ret = -1;
+  DevAssert(pdu != NULL);
+  DevAssert(buffer != NULL);
+  DevAssert(len != NULL);
+
+  switch(pdu->present) {
+    case NGAP_NGAP_PDU_PR_initiatingMessage:
+      ret = ngap_gNB_encode_initiating(pdu, buffer, len);
+      break;
+
+    case NGAP_NGAP_PDU_PR_successfulOutcome:
+      ret = ngap_gNB_encode_successfull_outcome(pdu, buffer, len);
+      break;
+
+    case NGAP_NGAP_PDU_PR_unsuccessfulOutcome:
+      ret = ngap_gNB_encode_unsuccessfull_outcome(pdu, buffer, len);
+      break;
+
+    default:
+      NGAP_DEBUG("Unknown message outcome (%d) or not implemented",
+                 (int)pdu->present);
+      return -1;
+  }
+
+  ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_NGAP_NGAP_PDU, pdu);
+  return ret;
+}
+
+static inline
+int ngap_gNB_encode_initiating(NGAP_NGAP_PDU_t *pdu,
+                               uint8_t **buffer, uint32_t *len) {
+  asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
+  DevAssert(pdu != NULL);
+
+  switch(pdu->choice.initiatingMessage.procedureCode) {
+    case NGAP_ProcedureCode_id_S1Setup:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_uplinkNASTransport:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_UECapabilityInfoIndication:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_initialUEMessage:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_NASNonDeliveryIndication:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_UEContextReleaseRequest:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_PathSwitchRequest:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_E_RABModificationIndication:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    default:
+      NGAP_DEBUG("Unknown procedure ID (%d) for initiating message\n",
+                 (int)pdu->choice.initiatingMessage.procedureCode);
+      return -1;
+  }
+
+  if (asn1_xer_print) {
+    xer_fprint(stdout, &asn_DEF_NGAP_NGAP_PDU, (void *)pdu);
+  }
+
+  memset(&res, 0, sizeof(res));
+  res = asn_encode_to_new_buffer(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+  *buffer = res.buffer;
+  *len = res.result.encoded;
+  return 0;
+}
+
+static inline
+int ngap_gNB_encode_successfull_outcome(NGAP_NGAP_PDU_t *pdu,
+                                        uint8_t **buffer, uint32_t *len) {
+  asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
+  DevAssert(pdu != NULL);
+
+  switch(pdu->choice.successfulOutcome.procedureCode) {
+    case NGAP_ProcedureCode_id_InitialContextSetup:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_UEContextRelease:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    case NGAP_ProcedureCode_id_E_RABSetup:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      NGAP_INFO("E_RABSetup successful message\n");
+      break;
+
+    case NGAP_ProcedureCode_id_E_RABModify:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      NGAP_INFO("E_RABModify successful message\n");
+      break;
+
+    case NGAP_ProcedureCode_id_E_RABRelease:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      NGAP_INFO("E_RAB Release successful message\n");
+      break;
+
+    default:
+      NGAP_WARN("Unknown procedure ID (%d) for successfull outcome message\n",
+                (int)pdu->choice.successfulOutcome.procedureCode);
+      return -1;
+  }
+
+  if (asn1_xer_print) {
+    xer_fprint(stdout, &asn_DEF_NGAP_NGAP_PDU, (void *)pdu);
+  }
+
+  memset(&res, 0, sizeof(res));
+  res = asn_encode_to_new_buffer(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+  *buffer = res.buffer;
+  *len = res.result.encoded;
+  return 0;
+}
+
+static inline
+int ngap_gNB_encode_unsuccessfull_outcome(NGAP_NGAP_PDU_t *pdu,
+    uint8_t **buffer, uint32_t *len) {
+  asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
+  DevAssert(pdu != NULL);
+
+  switch(pdu->choice.unsuccessfulOutcome.procedureCode) {
+    case NGAP_ProcedureCode_id_InitialContextSetup:
+      res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+      free(res.buffer);
+      break;
+
+    default:
+      NGAP_DEBUG("Unknown procedure ID (%d) for unsuccessfull outcome message\n",
+                 (int)pdu->choice.unsuccessfulOutcome.procedureCode);
+      return -1;
+  }
+
+  if (asn1_xer_print) {
+    xer_fprint(stdout, &asn_DEF_NGAP_NGAP_PDU, (void *)pdu);
+  }
+
+  memset(&res, 0, sizeof(res));
+  res = asn_encode_to_new_buffer(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_NGAP_NGAP_PDU, pdu);
+  *buffer = res.buffer;
+  *len = res.result.encoded;
+  return 0;
+}

openair3/NGAP/ngap_gNB_encoder.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
+ */
+
+#ifndef NGAP_GNB_ENCODER_H_
+#define NGAP_GNB_ENCODER_H_
+
+int ngap_gNB_encode_pdu(NGAP_NGAP_PDU_t *pdu, uint8_t **buffer, uint32_t *len)
+__attribute__ ((warn_unused_result));
+
+#endif /* NGAP_GNB_ENCODER_H_ */

openair3/NGAP/ngap_gNB_handlers.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
+ */
+
+#ifndef NGAP_GNB_HANDLERS_H_
+#define NGAP_GNB_HANDLERS_H_
+
+void ngap_handle_s1_setup_message(ngap_gNB_mme_data_t *mme_desc_p, int sctp_shutdown);
+
+int ngap_gNB_handle_message(uint32_t assoc_id, int32_t stream,
+                            const uint8_t * const data, const uint32_t data_length);
+
+#endif /* NGAP_GNB_HANDLERS_H_ */

openair3/NGAP/ngap_gNB_itti_messaging.c

+/*
+ * 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
+ */
+
+#include "intertask_interface.h"
+
+#include "ngap_gNB_itti_messaging.h"
+
+void ngap_gNB_itti_send_sctp_data_req(instance_t instance, int32_t assoc_id, uint8_t *buffer,
+                                      uint32_t buffer_length, uint16_t stream)
+{
+  MessageDef      *message_p;
+  sctp_data_req_t *sctp_data_req;
+
+  message_p = itti_alloc_new_message(TASK_NGAP, SCTP_DATA_REQ);
+
+  sctp_data_req = &message_p->ittiMsg.sctp_data_req;
+
+  sctp_data_req->assoc_id      = assoc_id;
+  sctp_data_req->buffer        = buffer;
+  sctp_data_req->buffer_length = buffer_length;
+  sctp_data_req->stream        = stream;
+
+  itti_send_msg_to_task(TASK_SCTP, instance, message_p);
+}
+
+void ngap_gNB_itti_send_nas_downlink_ind(instance_t instance,
+    uint16_t ue_initial_id,
+    uint32_t gNB_ue_ngap_id,
+    uint8_t *nas_pdu,
+    uint32_t nas_pdu_length)
+{
+  MessageDef          *message_p;
+  ngap_downlink_nas_t *ngap_downlink_nas;
+
+  message_p = itti_alloc_new_message(TASK_NGAP, NGAP_DOWNLINK_NAS);
+
+  ngap_downlink_nas = &message_p->ittiMsg.ngap_downlink_nas;
+
+  ngap_downlink_nas->ue_initial_id  = ue_initial_id;
+  ngap_downlink_nas->gNB_ue_ngap_id = gNB_ue_ngap_id;
+  ngap_downlink_nas->nas_pdu.buffer = malloc(sizeof(uint8_t) * nas_pdu_length);
+  memcpy(ngap_downlink_nas->nas_pdu.buffer, nas_pdu, nas_pdu_length);
+  ngap_downlink_nas->nas_pdu.length = nas_pdu_length;
+
+  itti_send_msg_to_task(TASK_RRC_GNB, instance, message_p);
+}
+
+void ngap_gNB_itti_send_sctp_close_association(instance_t instance, int32_t assoc_id)
+{
+  MessageDef               *message_p = NULL;
+  sctp_close_association_t *sctp_close_association_p = NULL;
+
+  message_p = itti_alloc_new_message(TASK_NGAP, SCTP_CLOSE_ASSOCIATION);
+  sctp_close_association_p = &message_p->ittiMsg.sctp_close_association;
+  sctp_close_association_p->assoc_id      = assoc_id;
+
+  itti_send_msg_to_task(TASK_SCTP, instance, message_p);
+}
+

openair3/NGAP/ngap_gNB_itti_messaging.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
+ */
+
+#ifndef NGAP_GNB_ITTI_MESSAGING_H_
+#define NGAP_GNB_ITTI_MESSAGING_H_
+
+void ngap_gNB_itti_send_sctp_data_req(instance_t instance, int32_t assoc_id, uint8_t *buffer,
+                                      uint32_t buffer_length, uint16_t stream);
+
+void ngap_gNB_itti_send_nas_downlink_ind(instance_t instance,
+    uint16_t ue_initial_id,
+    uint32_t gNB_ue_ngap_id,
+    uint8_t *nas_pdu,
+    uint32_t nas_pdu_length);
+
+void ngap_gNB_itti_send_sctp_close_association(instance_t instance,
+    int32_t assoc_id);
+
+
+#endif /* NGAP_GNB_ITTI_MESSAGING_H_ */

openair3/NGAP/ngap_gNB_management_procedures.c

+/*
+ * 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 ngap_gNB_management_procedures.c
+ * \brief NGAP gNB task 
+ * \author  S. Roux and Navid Nikaein 
+ * \date 2010 - 2016
+ * \email: navid.nikaein@eurecom.fr
+ * \version 1.0
+ * @ingroup _ngap
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "intertask_interface.h"
+
+#include "assertions.h"
+#include "conversions.h"
+
+#include "ngap_common.h"
+#include "ngap_gNB_defs.h"
+#include "ngap_gNB.h"
+
+ngap_gNB_internal_data_t ngap_gNB_internal_data;
+
+RB_GENERATE(ngap_mme_map, ngap_gNB_mme_data_s, entry, ngap_gNB_compare_assoc_id);
+
+int ngap_gNB_compare_assoc_id(
+  struct ngap_gNB_mme_data_s *p1, struct ngap_gNB_mme_data_s *p2)
+{
+  if (p1->assoc_id == -1) {
+    if (p1->cnx_id < p2->cnx_id) {
+      return -1;
+    }
+
+    if (p1->cnx_id > p2->cnx_id) {
+      return 1;
+    }
+  } else {
+    if (p1->assoc_id < p2->assoc_id) {
+      return -1;
+    }
+
+    if (p1->assoc_id > p2->assoc_id) {
+      return 1;
+    }
+  }
+
+  /* Matching reference */
+  return 0;
+}
+
+uint16_t ngap_gNB_fetch_add_global_cnx_id(void)
+{
+  return ++ngap_gNB_internal_data.global_cnx_id;
+}
+
+void ngap_gNB_prepare_internal_data(void)
+{
+  memset(&ngap_gNB_internal_data, 0, sizeof(ngap_gNB_internal_data));
+  STAILQ_INIT(&ngap_gNB_internal_data.ngap_gNB_instances_head);
+}
+
+void ngap_gNB_insert_new_instance(ngap_gNB_instance_t *new_instance_p)
+{
+  DevAssert(new_instance_p != NULL);
+
+  STAILQ_INSERT_TAIL(&ngap_gNB_internal_data.ngap_gNB_instances_head,
+                     new_instance_p, ngap_gNB_entries);
+}
+
+struct ngap_gNB_mme_data_s *ngap_gNB_get_MME(
+  ngap_gNB_instance_t *instance_p,
+  int32_t assoc_id, uint16_t cnx_id)
+{
+  struct ngap_gNB_mme_data_s  temp;
+  struct ngap_gNB_mme_data_s *found;
+
+  memset(&temp, 0, sizeof(struct ngap_gNB_mme_data_s));
+
+  temp.assoc_id = assoc_id;
+  temp.cnx_id   = cnx_id;
+
+  if (instance_p == NULL) {
+    STAILQ_FOREACH(instance_p, &ngap_gNB_internal_data.ngap_gNB_instances_head,
+                   ngap_gNB_entries) {
+      found = RB_FIND(ngap_mme_map, &instance_p->ngap_mme_head, &temp);
+
+      if (found != NULL) {
+        return found;
+      }
+    }
+  } else {
+    return RB_FIND(ngap_mme_map, &instance_p->ngap_mme_head, &temp);
+  }
+
+  return NULL;
+}
+
+struct ngap_gNB_mme_data_s *ngap_gNB_get_MME_from_instance(
+  ngap_gNB_instance_t *instance_p)
+{
+ 
+  struct ngap_gNB_mme_data_s *mme = NULL;
+  struct ngap_gNB_mme_data_s *mme_next = NULL;
+
+  for (mme = RB_MIN(ngap_mme_map, &instance_p->ngap_mme_head); mme!=NULL ; mme = mme_next) {
+    mme_next = RB_NEXT(ngap_mme_map, &instance_p->ngap_mme_head, mme);
+    if (mme->ngap_gNB_instance == instance_p) {
+      return mme;
+    }
+  }
+
+  return NULL;
+}
+
+ngap_gNB_instance_t *ngap_gNB_get_instance(instance_t instance)
+{
+  ngap_gNB_instance_t *temp = NULL;
+
+  STAILQ_FOREACH(temp, &ngap_gNB_internal_data.ngap_gNB_instances_head,
+                 ngap_gNB_entries) {
+    if (temp->instance == instance) {
+      /* Matching occurence */
+      return temp;
+    }
+  }
+
+  return NULL;
+}
+
+void ngap_gNB_remove_mme_desc(ngap_gNB_instance_t * instance) 
+{
+
+    struct ngap_gNB_mme_data_s *mme = NULL;
+    struct ngap_gNB_mme_data_s *mmeNext = NULL;
+    struct plmn_identity_s* plmnInfo;
+    struct served_group_id_s* groupInfo;
+    struct served_gummei_s* gummeiInfo;
+    struct mme_code_s* mmeCode;
+
+    for (mme = RB_MIN(ngap_mme_map, &instance->ngap_mme_head); mme; mme = mmeNext) {
+      mmeNext = RB_NEXT(ngap_mme_map, &instance->ngap_mme_head, mme);
+      RB_REMOVE(ngap_mme_map, &instance->ngap_mme_head, mme);
+      while (!STAILQ_EMPTY(&mme->served_gummei)) {
+        gummeiInfo = STAILQ_FIRST(&mme->served_gummei);
+        STAILQ_REMOVE_HEAD(&mme->served_gummei, next);
+	
+        while (!STAILQ_EMPTY(&gummeiInfo->served_plmns)) {
+	  plmnInfo = STAILQ_FIRST(&gummeiInfo->served_plmns);
+	  STAILQ_REMOVE_HEAD(&gummeiInfo->served_plmns, next);
+	  free(plmnInfo);
+        }
+        while (!STAILQ_EMPTY(&gummeiInfo->served_group_ids)) {
+	  groupInfo = STAILQ_FIRST(&gummeiInfo->served_group_ids);
+	  STAILQ_REMOVE_HEAD(&gummeiInfo->served_group_ids, next);
+	  free(groupInfo);
+        }
+        while (!STAILQ_EMPTY(&gummeiInfo->mme_codes)) {
+	  mmeCode = STAILQ_FIRST(&gummeiInfo->mme_codes);
+	  STAILQ_REMOVE_HEAD(&gummeiInfo->mme_codes, next);
+	  free(mmeCode);
+        }
+        free(gummeiInfo);
+      }
+      free(mme);
+    }
+}

openair3/NGAP/ngap_gNB_management_procedures.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
+ */
+
+#ifndef NGAP_GNB_MANAGEMENT_PROCEDURES_H_
+#define NGAP_GNB_MANAGEMENT_PROCEDURES_H_
+
+struct ngap_gNB_mme_data_s *ngap_gNB_get_MME(
+  ngap_gNB_instance_t *instance_p,
+  int32_t assoc_id, uint16_t cnx_id);
+
+struct ngap_gNB_mme_data_s *ngap_gNB_get_MME_from_instance(ngap_gNB_instance_t *instance_p);
+
+void ngap_gNB_remove_mme_desc(ngap_gNB_instance_t * instance);
+
+void ngap_gNB_insert_new_instance(ngap_gNB_instance_t *new_instance_p);
+
+ngap_gNB_instance_t *ngap_gNB_get_instance(uint8_t mod_id);
+
+uint16_t ngap_gNB_fetch_add_global_cnx_id(void);
+
+void ngap_gNB_prepare_internal_data(void);
+
+#endif /* NGAP_GNB_MANAGEMENT_PROCEDURES_H_ */

openair3/NGAP/ngap_gNB_nas_procedures.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
+ */
+
+#ifndef NGAP_GNB_NAS_PROCEDURES_H_
+#define NGAP_GNB_NAS_PROCEDURES_H_
+
+int ngap_gNB_handle_nas_downlink(
+  uint32_t         assoc_id,
+  uint32_t         stream,
+  NGAP_NGAP_PDU_t *pdu);
+
+int ngap_gNB_nas_uplink(instance_t instance, ngap_uplink_nas_t *ngap_uplink_nas_p);
+
+int ngap_gNB_nas_non_delivery_ind(instance_t instance,
+                                  ngap_nas_non_delivery_ind_t *ngap_nas_non_delivery_ind);
+
+int ngap_gNB_handle_nas_first_req(
+  instance_t instance, ngap_nas_first_req_t *ngap_nas_first_req_p);
+
+int ngap_gNB_initial_ctxt_resp(
+  instance_t instance, ngap_initial_context_setup_resp_t *initial_ctxt_resp_p);
+
+int ngap_gNB_ue_capabilities(instance_t instance,
+                             ngap_ue_cap_info_ind_t *ue_cap_info_ind_p);
+
+int ngap_gNB_e_rab_setup_resp(instance_t instance,
+                              ngap_e_rab_setup_resp_t *e_rab_setup_resp_p);
+
+int ngap_gNB_e_rab_modify_resp(instance_t instance,
+                               ngap_e_rab_modify_resp_t *e_rab_modify_resp_p);
+
+int ngap_gNB_e_rab_release_resp(instance_t instance,
+                                ngap_e_rab_release_resp_t *e_rab_release_resp_p);
+
+int ngap_gNB_path_switch_req(instance_t instance,
+                             ngap_path_switch_req_t *path_switch_req_p);
+
+int ngap_gNB_generate_E_RAB_Modification_Indication(
+		instance_t instance, ngap_e_rab_modification_ind_t *e_rab_modification_ind);
+
+#endif /* NGAP_GNB_NAS_PROCEDURES_H_ */

openair3/NGAP/ngap_gNB_nnsf.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
+ */
+
+#ifndef NGAP_GNB_NNSF_H_
+#define NGAP_GNB_NNSF_H_
+
+struct ngap_gNB_mme_data_s *
+ngap_gNB_nnsf_select_mme(ngap_gNB_instance_t       *instance_p,
+                         rrc_establishment_cause_t  cause);
+
+struct ngap_gNB_mme_data_s *
+ngap_gNB_nnsf_select_mme_by_plmn_id(ngap_gNB_instance_t       *instance_p,
+                                    rrc_establishment_cause_t  cause,
+                                    int                        selected_plmn_identity);
+
+struct ngap_gNB_mme_data_s*
+ngap_gNB_nnsf_select_mme_by_mme_code(ngap_gNB_instance_t       *instance_p,
+                                     rrc_establishment_cause_t  cause,
+                                     int                        selected_plmn_identity,
+                                     uint8_t                    mme_code);
+
+struct ngap_gNB_mme_data_s*
+ngap_gNB_nnsf_select_mme_by_gummei(ngap_gNB_instance_t       *instance_p,
+                                   rrc_establishment_cause_t  cause,
+                                   ngap_gummei_t                   gummei);
+
+struct ngap_gNB_mme_data_s*
+ngap_gNB_nnsf_select_mme_by_gummei_no_cause(ngap_gNB_instance_t       *instance_p,
+                                   ngap_gummei_t                   gummei);
+
+#endif /* NGAP_GNB_NNSF_H_ */

openair3/NGAP/ngap_gNB_overload.c

+/*
+ * 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 ngap_gNB_overload.c
+ * \brief ngap procedures for overload messages within gNB
+ * \author Sebastien ROUX <sebastien.roux@eurecom.fr>
+ * \date 2012
+ * \version 0.1
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "intertask_interface.h"
+
+#include "ngap_common.h"
+#include "ngap_gNB_defs.h"
+
+#include "ngap_gNB.h"
+#include "ngap_gNB_ue_context.h"
+#include "ngap_gNB_encoder.h"
+#include "ngap_gNB_overload.h"
+#include "ngap_gNB_management_procedures.h"
+
+#include "assertions.h"
+
+int ngap_gNB_handle_overload_start(uint32_t         assoc_id,
+                                   uint32_t         stream,
+                                   NGAP_NGAP_PDU_t *pdu)
+{
+    ngap_gNB_mme_data_t     *mme_desc_p;
+    NGAP_OverloadStart_t    *container;
+    NGAP_OverloadStartIEs_t *ie;
+
+    DevAssert(pdu != NULL);
+
+    container = &pdu->choice.initiatingMessage.value.choice.OverloadStart;
+
+    NGAP_FIND_PROTOCOLIE_BY_ID(NGAP_OverloadStartIEs_t, ie, container,
+                               NGAP_ProtocolIE_ID_id_OverloadResponse, true);
+    if (ie != NULL) {
+        DevCheck(ie->value.choice.OverloadResponse.present ==
+                 NGAP_OverloadResponse_PR_overloadAction,
+                 NGAP_OverloadResponse_PR_overloadAction, 0, 0);
+    }
+    /* Non UE-associated signalling -> stream 0 */
+    DevCheck(stream == 0, stream, 0, 0);
+
+    if ((mme_desc_p = ngap_gNB_get_MME(NULL, assoc_id, 0)) == NULL) {
+        /* No MME context associated */
+        return -1;
+    }
+
+    /* Mark the MME as overloaded and set the overload state according to
+     * the value received.
+     */
+    mme_desc_p->state = NGAP_GNB_OVERLOAD;
+    mme_desc_p->overload_state =
+        ie->value.choice.OverloadResponse.choice.overloadAction;
+
+    return 0;
+}
+
+int ngap_gNB_handle_overload_stop(uint32_t         assoc_id,
+                                  uint32_t         stream,
+                                  NGAP_NGAP_PDU_t *pdu)
+{
+    /* We received Overload stop message, meaning that the MME is no more
+     * overloaded. This is an empty message, with only message header and no
+     * Information Element.
+     */
+    DevAssert(pdu != NULL);
+
+    ngap_gNB_mme_data_t *mme_desc_p;
+
+    /* Non UE-associated signalling -> stream 0 */
+    DevCheck(stream == 0, stream, 0, 0);
+
+    if ((mme_desc_p = ngap_gNB_get_MME(NULL, assoc_id, 0)) == NULL) {
+        /* No MME context associated */
+        return -1;
+    }
+
+    mme_desc_p->state = NGAP_GNB_STATE_CONNECTED;
+    mme_desc_p->overload_state = NGAP_NO_OVERLOAD;
+    return 0;
+}