Update F1AP new code structure to closer implementing all the procedures

cmake_targets/CMakeLists.txt

@@ -281,7 +281,7 @@ endif (${ENABLE_ITTI})
 # (so creating new asn.1 objects instead of modifying the object attributes)
 # New C code source file, cmake must be re-run (instead of re-running make only)
 #############
-set(asn1c_call "${OPENAIR_CMAKE}/tools/generate_asn1")
+# set(asn1c_call "${OPENAIR_CMAKE}/tools/generate_asn1")
 # set(fix_asn1c_call "${OPENAIR_CMAKE}/tools/fix_asn1")
 set(asn1_generated_dir ${OPENAIR_BIN_DIR})
 
@@ -504,40 +504,30 @@ set(F1AP_ASN_FILES
   ${F1AP_ASN_DIR}/F1AP-Containers.asn
   )
 
-set(F1AP_C_DIR ${asn1_generated_dir}/F1AP_${ASN1RELDIR})
-message("calling ASN1C_PREFIX=F1AP_ asn1c -gen-PER -fcompound-names -no-gen-example -findirect-choice -fno-include-deps -D ${F1AP_C_DIR} ${F1AP_ASN_FILES}")
-execute_process(COMMAND mkdir -p ${F1AP_C_DIR}
-                COMMAND env "ASN1C_PREFIX=F1AP_" asn1c -gen-PER -fcompound-names -no-gen-example -findirect-choice -fno-include-deps -D ${F1AP_C_DIR} ${F1AP_ASN_FILES}
+set(F1AP_ASN_GENERATED_C_DIR ${asn1_generated_dir}/F1AP_${ASN1RELDIR})
+message("calling ASN1C_PREFIX=F1AP_ asn1c -gen-PER -fcompound-names -no-gen-example -findirect-choice -fno-include-deps -D ${F1AP_ASN_GENERATED_C_DIR} ${F1AP_ASN_FILES}")
+execute_process(COMMAND mkdir -p ${F1AP_ASN_GENERATED_C_DIR}
+                COMMAND env "ASN1C_PREFIX=F1AP_" asn1c -gen-PER -fcompound-names -no-gen-example -findirect-choice -fno-include-deps -D ${F1AP_ASN_GENERATED_C_DIR} ${F1AP_ASN_FILES}
                 RESULT_VARIABLE ret
                 OUTPUT_QUIET
                 ERROR_QUIET)
 
 if (NOT ${ret} STREQUAL 0)
-  message(FATAL_ERROR "${asn1c_call}: error")
+  message(FATAL_ERROR "asn1c: error")
 endif (NOT ${ret} STREQUAL 0)
-file(GLOB F1AP_source ${F1AP_C_DIR}/*.c)
-
-file(GLOB f1ap_h ${F1AP_C_DIR}/*.h)
-set(f1ap_h ${f1ap_h} )
 
+file(GLOB F1AP_ASN_GENERATED_C_FILES ${F1AP_ASN_GENERATED_C_DIR}/*.c)
 add_library(F1AP_LIB
-  ${F1AP_source}
-  )
+  ${F1AP_ASN_GENERATED_C_FILES}
+)
 
-include_directories ("${F1AP_C_DIR}")
+include_directories ("${F1AP_ASN_GENERATED_C_DIR}")
 include_directories ("${F1AP_DIR}")
-message(${F1AP_C_DIR})
-message(${F1AP_DIR})
 
+file(GLOB F1AP_C_FILES ${F1AP_DIR}/*.c)
 add_library(F1AP
-  ${F1AP_DIR}/f1ap_du.c
-  ${F1AP_DIR}/f1ap_cu.c
-  ${F1AP_DIR}/f1ap_itti_messaging.c
-  ${F1AP_DIR}/f1ap_encoder.c
-  ${F1AP_DIR}/f1ap_decoder.c
-  ${F1AP_DIR}/f1ap_handlers.c
-  ${F1AP_DIR}/f1ap_common.c
-  )
+  ${F1AP_C_FILES}
+)
 
 
 # Hardware dependant options

openair2/F1AP/f1ap_common.c

@@ -30,10 +30,7 @@
  * \warning
  */
 
-#include <stdint.h>
-
 #include "f1ap_common.h"
-//#include "S1AP-PDU.h"
 
 #if defined(EMIT_ASN_DEBUG_EXTERN)
 int asn_debug = 0;
@@ -211,3 +208,10 @@ uint8_t F1AP_get_next_transaction_identifier(module_id_t enb_mod_idP, module_id_
   //LOG_T(F1AP,"generated xid is %d\n",transaction_identifier[enb_mod_idP+cu_mod_idP]);
   return transaction_identifier[enb_mod_idP+cu_mod_idP];
 }
+
+uint8_t F1AP_get_UE_identifier(module_id_t enb_mod_idP, int CC_idP, int UE_id) {  
+  static uint8_t      UE_identifier[NUMBER_OF_eNB_MAX];
+  UE_identifier[enb_mod_idP+CC_idP+UE_id] = (UE_identifier[enb_mod_idP+CC_idP+UE_id] + 1) % F1AP_UE_IDENTIFIER_NUMBER;
+  //LOG_T(F1AP,"generated xid is %d\n",transaction_identifier[enb_mod_idP+du_mod_idP]);
+  return UE_identifier[enb_mod_idP+CC_idP+UE_id];
+}
\ No newline at end of file

openair2/F1AP/f1ap_common.h

@@ -356,6 +356,17 @@ inline void ASN_DEBUG(const char *fmt, ...);
 #include "F1AP_Cells-To-Be-Broadcast-Item.h"
 #include "F1AP_QCI.h"
 
+#include "conversions.h"
+#include "platform_types.h"
+#include "common/utils/LOG/log.h"
+#include "intertask_interface.h"
+#include "sctp_messages_types.h"
+#include "f1ap_messages_types.h"
+#include <arpa/inet.h>
+#include "T.h"
+#include "common/ran_context.h"
+#include "msc.h"
+
 /* Checking version of ASN1C compiler */
 #if (ASN1C_ENVIRONMENT_VERSION < ASN1C_MINIMUM_VERSION)
 # error "You are compiling f1ap with the wrong version of ASN1C"
@@ -415,5 +426,6 @@ typedef int (*f1ap_message_decoded_callback)(
 
 
 uint8_t F1AP_get_next_transaction_identifier(module_id_t enb_mod_idP, module_id_t cu_mod_idP);
+uint8_t F1AP_get_UE_identifier(module_id_t enb_mod_idP, int CC_idP, int UE_id);
 
 #endif /* F1AP_COMMON_H_ */

openair2/F1AP/f1ap_cu_interface_management.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 f1ap_cu_interface_management.h
+ * \brief f1ap interface management for CU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
+
+#ifndef F1AP_CU_INTERFACE_MANAGEMENT_H_
+#define F1AP_CU_INTERFACE_MANAGEMENT_H_
+
+int CU_handle_F1_SETUP_REQUEST(uint32_t               assoc_id,
+                                 uint32_t               stream,
+                                 F1AP_F1AP_PDU_t       *pdu);
+
+void CU_send_F1_SETUP_RESPONSE(instance_t instance, f1ap_setup_resp_t *f1ap_setup_resp);
+
+void CU_send_F1_SETUP_FAILURE(F1AP_F1SetupFailure_t *F1SetupFailure);
+
+#endif /* F1AP_CU_INTERFACE_MANAGEMENT_H_ */
\ No newline at end of file

openair2/F1AP/f1ap_du_defs.h → openair2/F1AP/f1ap_cu_paging.c

@@ -19,9 +19,13 @@
  *      contact@openairinterface.org
  */
 
-
-#ifndef DU_F1AP_DEFS_H_
-#define DU_F1AP_DEFS_H_
-
-
-#endif /* DU_F1AP_DEFS_H_ */
+/*! \file f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_cu_defs.h → openair2/F1AP/f1ap_cu_paging.h

@@ -19,9 +19,13 @@
  *      contact@openairinterface.org
  */
 
-
-#ifndef CU_F1AP_DEFS_H_
-#define CU_F1AP_DEFS_H_
-
-
-#endif /* CU_F1AP_DEFS_H_ */
+/*! \file f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_cu_rrc_message_transfer.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 f1ap_cu_rrc_message_transfer.c
+ * \brief f1ap rrc message transfer for CU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
+
+#include "f1ap_common.h"
+#include "f1ap_cu_rrc_message_transfer.h"
+
+/*
+    Initial UL RRC Message Transfer
+*/
+
+void CU_handle_UL_INITIAL_RRC_MESSAGE_TRANSFER(void) {
+
+  printf("CU_handle_UL_INITIAL_RRC_MESSAGE_TRANSFER\n");
+  // decode the F1 message
+  // get the rrc message from the contauiner 
+  // call func rrc_eNB_decode_ccch: <-- needs some update here
+
+  // if size > 0 
+  // CU_send_DL_RRC_MESSAGE_TRANSFER(C.rrc[ctxt_pP->module_id]->carrier[CC_id].Srb0.Tx_buffer.Payload, RC.rrc[ctxt_pP->module_id]->carrier[CC_id].Srb0.Tx_buffer.payload_size)
+}
+
+
+/*
+    DL RRC Message Transfer.
+*/
+
+//void CU_send_DL_RRC_MESSAGE_TRANSFER(F1AP_DLRRCMessageTransfer_t *DLRRCMessageTransfer) {
+void CU_send_DL_RRC_MESSAGE_TRANSFER(void) {
+  F1AP_F1AP_PDU_t                pdu;
+  F1AP_DLRRCMessageTransfer_t    *out;
+  F1AP_DLRRCMessageTransferIEs_t *ie;
+
+  uint8_t  *buffer;
+  uint32_t  len;
+
+  /* Create */
+  /* 0. Message Type */
+  memset(&pdu, 0, sizeof(pdu));
+  pdu.present = F1AP_F1AP_PDU_PR_initiatingMessage;
+  pdu.choice.initiatingMessage = (F1AP_InitiatingMessage_t *)calloc(1, sizeof(F1AP_InitiatingMessage_t));
+  pdu.choice.initiatingMessage->procedureCode = F1AP_ProcedureCode_id_DLRRCMessageTransfer;
+  pdu.choice.initiatingMessage->criticality   = F1AP_Criticality_ignore;
+  pdu.choice.initiatingMessage->value.present = F1AP_InitiatingMessage__value_PR_DLRRCMessageTransfer;
+  out = &pdu.choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
+  
+  /* mandatory */
+  /* c1. GNB_CU_UE_F1AP_ID */
+  ie = (F1AP_DLRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_DLRRCMessageTransferIEs_t));
+  ie->id                             = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
+  ie->criticality                    = F1AP_Criticality_reject;
+  ie->value.present                  = F1AP_DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
+  ie->value.choice.GNB_CU_UE_F1AP_ID = 126L;
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* mandatory */
+  /* c2. GNB_DU_UE_F1AP_ID */
+  ie = (F1AP_DLRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_DLRRCMessageTransferIEs_t));
+  ie->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
+  ie->criticality                    = F1AP_Criticality_reject;
+  ie->value.present                  = F1AP_DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
+  ie->value.choice.GNB_DU_UE_F1AP_ID = 651L;
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* optional */
+  /* c3. oldgNB_DU_UE_F1AP_ID */
+  if (0) {
+    ie = (F1AP_DLRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_DLRRCMessageTransferIEs_t));
+    ie->id                            = F1AP_ProtocolIE_ID_id_oldgNB_DU_UE_F1AP_ID;
+    ie->criticality                   = F1AP_Criticality_reject;
+    //ie->value.present                 = F1AP_DLRRCMessageTransferIEs__value_PR_NOTHING;
+    //ie->value.choice.            = 1;
+    ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+  }
+
+  /* mandatory */
+  /* c4. SRBID */
+  ie = (F1AP_DLRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_DLRRCMessageTransferIEs_t));
+  ie->id                            = F1AP_ProtocolIE_ID_id_SRBID;
+  ie->criticality                   = F1AP_Criticality_reject;
+  ie->value.present                 = F1AP_DLRRCMessageTransferIEs__value_PR_SRBID;
+  ie->value.choice.SRBID            = 2L;
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* optional */
+  /* c5. ExecuteDuplication */
+  if (0) {
+    ie = (F1AP_DLRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_DLRRCMessageTransferIEs_t));
+    ie->id                            = F1AP_ProtocolIE_ID_id_ExecuteDuplication;
+    ie->criticality                   = F1AP_Criticality_ignore;
+    ie->value.present                 = F1AP_DLRRCMessageTransferIEs__value_PR_ExecuteDuplication;
+    ie->value.choice.ExecuteDuplication = F1AP_ExecuteDuplication_true;
+    ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+  }
+
+  // issue in here
+  /* mandatory */
+  /* c6. RRCContainer */
+  ie = (F1AP_DLRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_DLRRCMessageTransferIEs_t));
+  ie->id                            = F1AP_ProtocolIE_ID_id_RRCContainer;
+  ie->criticality                   = F1AP_Criticality_reject;
+  ie->value.present                 = F1AP_DLRRCMessageTransferIEs__value_PR_RRCContainer;
+  OCTET_STRING_fromBuf(&ie->value.choice.RRCContainer, "A", strlen("A"));
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* optional */
+  /* c7. RAT_FrequencyPriorityInformation */
+  if (0) {
+    ie = (F1AP_DLRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_DLRRCMessageTransferIEs_t));
+    ie->id                            = F1AP_ProtocolIE_ID_id_RAT_FrequencyPriorityInformation;
+    ie->criticality                   = F1AP_Criticality_reject;
+    ie->value.present                 = F1AP_DLRRCMessageTransferIEs__value_PR_RAT_FrequencyPriorityInformation;
+
+    ie->value.choice.RAT_FrequencyPriorityInformation.present = F1AP_RAT_FrequencyPriorityInformation_PR_subscriberProfileIDforRFP;
+    ie->value.choice.RAT_FrequencyPriorityInformation.choice.subscriberProfileIDforRFP = 123L;
+
+    //ie->value.choice.RAT_FrequencyPriorityInformation.present = F1AP_RAT_FrequencyPriorityInformation_PR_rAT_FrequencySelectionPriority;
+    //ie->value.choice.RAT_FrequencyPriorityInformation.choice.rAT_FrequencySelectionPriority = 123L;
+    ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+  }
+
+  /* encode */
+  if (f1ap_encode_pdu(&pdu, &buffer, &len) < 0) {
+    printf("Failed to encode F1 setup request\n");
+  }
+
+  printf("\n");
+
+  /* decode */
+  if (f1ap_decode_pdu(&pdu, buffer, len) > 0) {
+    printf("Failed to decode F1 setup request\n");
+  }
+  //AssertFatal(1==0,"Not implemented yet\n");
+}
+
+/*
+    UL RRC Message Transfer
+*/
+
+void CU_handle_UL_RRC_MESSAGE_TRANSFER(F1AP_ULRRCMessageTransfer_t *ULRRCMessageTransfer) {
+  AssertFatal(1==0,"Not implemented yet\n");
+}

openair2/F1AP/f1ap_cu_rrc_message_transfer.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 f1ap_cu_rrc_message_transfer.h
+ * \brief f1ap rrc message transfer for CU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
+
+#ifndef F1AP_CU_RRC_MESSAGE_TRANSFER_H_
+#define F1AP_CU_RRC_MESSAGE_TRANSFER_H_
+
+#endif /* F1AP_CU_RRC_MESSAGE_TRANSFER_H_ */
\ No newline at end of file

openair2/F1AP/f1ap_du.h → openair2/F1AP/f1ap_cu_system_information.c

@@ -19,8 +19,13 @@
  *      contact@openairinterface.org
  */
 
-#ifndef DU_F1AP_DEFS_H_
-#define DU_F1AP_DEFS_H_
-
-
-#endif /* DU_F1AP_DEFS_H_ */
+/*! \file f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_cu_system_information.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_cu_task.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 openair2/F1AP/CU_F1AP.c
+* \brief data structures for F1 interface modules
+* \author EURECOM/NTUST
+* \date 2018
+* \version 0.1
+* \company Eurecom
+* \email: navid.nikaein@eurecom.fr, raymond.knopp@eurecom.fr, bing-kai.hong@eurecom.fr
+* \note
+* \warning
+*/
+
+#include "f1ap_common.h"
+#include "f1ap_handlers.h"
+#include "f1ap_cu_interface_management.h"
+#include "f1ap_cu_task.h"
+
+extern RAN_CONTEXT_t RC;
+
+f1ap_setup_req_t *f1ap_du_data_from_du;
+
+void cu_task_handle_sctp_association_ind(instance_t instance, sctp_new_association_ind_t *sctp_new_association_ind) {
+  // Nothing
+}
+
+void cu_task_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp) {
+
+  DevAssert(sctp_new_association_resp != NULL);
+
+  if (sctp_new_association_resp->sctp_state != SCTP_STATE_ESTABLISHED) {
+    LOG_W(F1AP, "Received unsuccessful result for SCTP association (%u), instance %d, cnx_id %u\n",
+              sctp_new_association_resp->sctp_state,
+              instance,
+              sctp_new_association_resp->ulp_cnx_id);
+
+      //f1ap_handle_setup_message(instance, sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN);
+    return; // exit -1 for debugging 
+  }
+
+  // go to an init func
+  f1ap_du_data_from_du = (f1ap_setup_req_t *)calloc(1, sizeof(f1ap_setup_req_t));
+  // save the assoc id 
+  f1ap_du_data_from_du->assoc_id         = sctp_new_association_resp->assoc_id;
+  f1ap_du_data_from_du->sctp_in_streams  = sctp_new_association_resp->in_streams;
+  f1ap_du_data_from_du->sctp_out_streams = sctp_new_association_resp->out_streams;
+}
+
+void cu_task_handle_sctp_data_ind(sctp_data_ind_t *sctp_data_ind) {
+  int result;
+
+  DevAssert(sctp_data_ind != NULL);
+
+  f1ap_handle_message(sctp_data_ind->assoc_id, sctp_data_ind->stream,
+                          sctp_data_ind->buffer, sctp_data_ind->buffer_length);
+
+  result = itti_free(TASK_UNKNOWN, sctp_data_ind->buffer);
+  AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+}
+
+void cu_task_send_sctp_init_req(instance_t enb_id) {
+  // 1. get the itti msg, and retrive the enb_id from the message
+  // 2. use RC.rrc[enb_id] to fill the sctp_init_t with the ip, port
+  // 3. creat an itti message to init
+
+  LOG_I(CU_F1AP, "F1AP_CU_SCTP_REQ(create socket)\n");
+  MessageDef  *message_p = NULL;
+
+  message_p = itti_alloc_new_message (TASK_CU_F1, SCTP_INIT_MSG);
+  message_p->ittiMsg.sctp_init.port = F1AP_PORT_NUMBER;
+  message_p->ittiMsg.sctp_init.ppid = F1AP_SCTP_PPID;
+  message_p->ittiMsg.sctp_init.ipv4 = 1;
+  message_p->ittiMsg.sctp_init.ipv6 = 0;
+  message_p->ittiMsg.sctp_init.nb_ipv4_addr = 1;
+  message_p->ittiMsg.sctp_init.ipv4_address[0] = inet_addr(RC.rrc[enb_id]->eth_params_s.my_addr);
+  /*
+   * SR WARNING: ipv6 multi-homing fails sometimes for localhost.
+   * * * * Disable it for now.
+   */
+  message_p->ittiMsg.sctp_init.nb_ipv6_addr = 0;
+  message_p->ittiMsg.sctp_init.ipv6_address[0] = "0:0:0:0:0:0:0:1";
+
+  itti_send_msg_to_task(TASK_SCTP, enb_id, message_p);
+}
+
+
+void *F1AP_CU_task(void *arg) {
+
+  MessageDef *received_msg = NULL;
+  int         result;
+
+  LOG_I(CU_F1AP,"Starting F1AP at CU\n");
+
+  itti_mark_task_ready(TASK_CU_F1);
+
+  cu_task_send_sctp_init_req(0);
+
+  while (1) {
+    itti_receive_msg(TASK_CU_F1, &received_msg);
+    switch (ITTI_MSG_ID(received_msg)) {
+
+      case SCTP_NEW_ASSOCIATION_IND:
+        LOG_I(CU_F1AP, "SCTP_NEW_ASSOCIATION_IND\n");
+        cu_task_handle_sctp_association_ind(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+                                         &received_msg->ittiMsg.sctp_new_association_ind);
+        break;
+
+      case SCTP_NEW_ASSOCIATION_RESP:
+        LOG_I(CU_F1AP, "SCTP_NEW_ASSOCIATION_RESP\n");
+        cu_task_handle_sctp_association_resp(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+                                         &received_msg->ittiMsg.sctp_new_association_resp);
+        break;
+
+      case SCTP_DATA_IND:
+        LOG_I(CU_F1AP, "SCTP_DATA_IND\n");
+        cu_task_handle_sctp_data_ind(&received_msg->ittiMsg.sctp_data_ind);
+        break;
+
+      case F1AP_SETUP_RESP: // from rrc
+        LOG_W(CU_F1AP, "F1AP_SETUP_RESP\n");
+        // CU_send_f1setup_resp(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+        //                                       &F1AP_SETUP_RESP(received_msg));
+        CU_send_F1_SETUP_RESPONSE(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+                                               &F1AP_SETUP_RESP(received_msg));
+        break;
+
+
+//    case F1AP_SETUP_RESPONSE: // This is from RRC
+//    CU_send_F1_SETUP_RESPONSE(instance, *f1ap_setup_ind, &(F1AP_SETUP_RESP) f1ap_setup_resp)   
+//        break;
+        
+//    case F1AP_SETUP_FAILURE: // This is from RRC
+//    CU_send_F1_SETUP_FAILURE(instance, *f1ap_setup_ind, &(F1AP_SETUP_FAILURE) f1ap_setup_failure)   
+//       break;
+
+      case TERMINATE_MESSAGE:
+        LOG_W(CU_F1AP, " *** Exiting CU_F1AP thread\n");
+        itti_exit_task();
+        break;
+
+      default:
+        LOG_E(CU_F1AP, "CU Received unhandled message: %d:%s\n",
+                  ITTI_MSG_ID(received_msg), ITTI_MSG_NAME(received_msg));
+        break;
+    } // switch
+    result = itti_free (ITTI_MSG_ORIGIN_ID(received_msg), received_msg);
+    AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+
+    received_msg = NULL;
+  } // while
+
+  return NULL;
+}
\ No newline at end of file

openair2/F1AP/f1ap_cu_task.h

@@ -22,6 +22,11 @@
 #ifndef CU_F1AP_TASK_H_
 #define CU_F1AP_TASK_H_
 
+void cu_task_handle_sctp_association_ind(instance_t instance, sctp_new_association_ind_t *sctp_new_association_ind);
+void cu_task_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp);
+void cu_task_handle_sctp_data_ind(sctp_data_ind_t *sctp_data_ind);
+void cu_task_send_sctp_init_req(instance_t enb_id);
+
 void *F1AP_CU_task(void *arg);
 
 #endif /* CU_F1AP_TASK_H_ */

openair2/F1AP/f1ap_cu_ue_context_management.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_cu_warning_message_transmission.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_cu_warning_message_transmission.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_decoder.c

@@ -30,12 +30,6 @@
  * \warning
  */
 
-#include <stdio.h>
-
-#include "assertions.h"
-
-#include "intertask_interface.h"
-
 #include "f1ap_common.h"
 #include "f1ap_decoder.h"
 

openair2/F1AP/f1ap_decoder.h

@@ -33,8 +33,6 @@
 #ifndef F1AP_ENB_ENCODER_H_
 #define F1AP_ENB_ENCODER_H_
 
-#include "f1ap_common.h"
-
 int f1ap_decode_pdu(F1AP_F1AP_PDU_t *pdu, const uint8_t *const buffer, uint32_t length)
 __attribute__ ((warn_unused_result));
 

openair2/F1AP/f1ap_du_interface_management.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
+
+#ifndef F1AP_DU_INTERFACE_MANAGEMENT_H_
+#define F1AP_DU_INTERFACE_MANAGEMENT_H_
+
+void DU_send_F1_SETUP_REQUEST(instance_t instance);
+
+int DU_handle_F1_SETUP_RESPONSE(uint32_t               assoc_id,
+                                 uint32_t               stream,
+                                 F1AP_F1AP_PDU_t       *pdu);
+
+void DU_handle_F1_SETUP_FAILURE(F1AP_F1AP_PDU_t *pdu_p);
+
+#endif /* F1AP_DU_INTERFACE_MANAGEMENT_H_ */
\ No newline at end of file

openair2/F1AP/f1ap_du_paging.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_du_paging.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_du_rrc_message_transfer.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 f1ap_du_rrc_message_transfer.c
+ * \brief f1ap rrc message transfer for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
+
+#include "f1ap_common.h"
+#include "f1ap_du_rrc_message_transfer.h"
+// undefine C_RNTI from
+// openair1/PHY/LTE_TRANSPORT/transport_common.h which
+// replaces in ie->value.choice.C_RNTI, causing
+// a compile error
+#undef C_RNTI 
+
+extern f1ap_setup_req_t *f1ap_du_data;
+
+/*  DL RRC Message Transfer */
+void DU_handle_DL_RRC_MESSAGE_TRANSFER(F1AP_DLRRCMessageTransfer_t *DLRRCMessageTransfer) {
+  AssertFatal(1==0,"Not implemented yet\n");
+}
+
+//void DU_send_UL_RRC_MESSAGE_TRANSFER(F1AP_ULRRCMessageTransfer_t *ULRRCMessageTransfer) {
+void DU_send_UL_RRC_MESSAGE_TRANSFER(void) {
+  F1AP_F1AP_PDU_t                pdu;
+  F1AP_ULRRCMessageTransfer_t    *out;
+  F1AP_ULRRCMessageTransferIEs_t *ie;
+
+  uint8_t  *buffer;
+  uint32_t  len;
+
+  /* Create */
+  /* 0. Message Type */
+  memset(&pdu, 0, sizeof(pdu));
+  pdu.present = F1AP_F1AP_PDU_PR_initiatingMessage;
+  pdu.choice.initiatingMessage = (F1AP_InitiatingMessage_t *)calloc(1, sizeof(F1AP_InitiatingMessage_t));
+  pdu.choice.initiatingMessage->procedureCode = F1AP_ProcedureCode_id_ULRRCMessageTransfer;
+  pdu.choice.initiatingMessage->criticality   = F1AP_Criticality_ignore;
+  pdu.choice.initiatingMessage->value.present = F1AP_InitiatingMessage__value_PR_ULRRCMessageTransfer;
+  out = &pdu.choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
+  
+  /* mandatory */
+  /* c1. GNB_CU_UE_F1AP_ID */
+  ie = (F1AP_ULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_ULRRCMessageTransferIEs_t));
+  ie->id                             = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
+  ie->criticality                    = F1AP_Criticality_reject;
+  ie->value.present                  = F1AP_ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
+  ie->value.choice.GNB_CU_UE_F1AP_ID = 126L;
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* mandatory */
+  /* c2. GNB_DU_UE_F1AP_ID */
+  ie = (F1AP_ULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_ULRRCMessageTransferIEs_t));
+  ie->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
+  ie->criticality                    = F1AP_Criticality_reject;
+  ie->value.present                  = F1AP_ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
+  ie->value.choice.GNB_DU_UE_F1AP_ID = 651L;
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* mandatory */
+  /* c3. SRBID */
+  ie = (F1AP_ULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_ULRRCMessageTransferIEs_t));
+  ie->id                            = F1AP_ProtocolIE_ID_id_SRBID;
+  ie->criticality                   = F1AP_Criticality_reject;
+  ie->value.present                 = F1AP_ULRRCMessageTransferIEs__value_PR_SRBID;
+  ie->value.choice.SRBID            = 1;
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  // issue in here
+  /* mandatory */
+  /* c4. RRCContainer */
+  ie = (F1AP_ULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_ULRRCMessageTransferIEs_t));
+  ie->id                            = F1AP_ProtocolIE_ID_id_RRCContainer;
+  ie->criticality                   = F1AP_Criticality_reject;
+  ie->value.present                 = F1AP_ULRRCMessageTransferIEs__value_PR_RRCContainer;
+  OCTET_STRING_fromBuf(&ie->value.choice.RRCContainer, "asdsa1d32sa1d31asd31as",
+                       strlen("asdsa1d32sa1d31asd31as"));
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+    /* encode */
+  if (f1ap_encode_pdu(&pdu, &buffer, &len) < 0) {
+    printf("Failed to encode F1 setup request\n");
+  }
+
+  printf("\n");
+
+  //du_f1ap_itti_send_sctp_data_req(instance, f1ap_setup_req->assoc_id, buffer, len, 0);
+  /* decode */
+  // if (f1ap_decode_pdu(&pdu, buffer, len) > 0) {
+  //   printf("Failed to decode F1 setup request\n");
+  // }
+  //AssertFatal(1==0,"Not implemented yet\n");
+}
+
+/*  UL RRC Message Transfer */
+void DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(
+  module_id_t     module_idP,
+  int             CC_idP,
+  int             UE_id,
+  rnti_t          rntiP,
+  uint8_t        *sduP,
+  sdu_size_t      sdu_lenP
+) {
+  F1AP_F1AP_PDU_t                       pdu;
+  F1AP_InitialULRRCMessageTransfer_t    *out;
+  F1AP_InitialULRRCMessageTransferIEs_t *ie;
+
+  uint8_t  *buffer;
+  uint32_t  len;
+
+  /* Create */
+  /* 0. Message Type */
+  memset(&pdu, 0, sizeof(pdu));
+  pdu.present = F1AP_F1AP_PDU_PR_initiatingMessage;
+  pdu.choice.initiatingMessage = (F1AP_InitiatingMessage_t *)calloc(1, sizeof(F1AP_InitiatingMessage_t));
+  pdu.choice.initiatingMessage->procedureCode = F1AP_ProcedureCode_id_InitialULRRCMessageTransfer;
+  pdu.choice.initiatingMessage->criticality   = F1AP_Criticality_ignore;
+  pdu.choice.initiatingMessage->value.present = F1AP_InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
+  out = &pdu.choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
+  
+
+  /* mandatory */
+  /* c1. GNB_DU_UE_F1AP_ID */
+  ie = (F1AP_InitialULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_InitialULRRCMessageTransferIEs_t));
+  ie->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
+  ie->criticality                    = F1AP_Criticality_reject;
+  ie->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
+  ie->value.choice.GNB_DU_UE_F1AP_ID = F1AP_get_UE_identifier(module_idP, CC_idP, UE_id);
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* mandatory */
+  /* c2. NRCGI */
+  ie = (F1AP_InitialULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_InitialULRRCMessageTransferIEs_t));
+  ie->id                             = F1AP_ProtocolIE_ID_id_NRCGI;
+  ie->criticality                    = F1AP_Criticality_reject;
+  ie->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_NRCGI;
+
+  F1AP_NRCGI_t nRCGI;
+  MCC_MNC_TO_PLMNID(f1ap_du_data->mcc[0], f1ap_du_data->mnc[0], f1ap_du_data->mnc_digit_length[0],
+                                         &nRCGI.pLMN_Identity);
+  NR_CELL_ID_TO_BIT_STRING(123456, &nRCGI.nRCellIdentity);
+  ie->value.choice.NRCGI = nRCGI;
+
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* mandatory */
+  /* c3. C_RNTI */  // 16
+  ie = (F1AP_InitialULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_InitialULRRCMessageTransferIEs_t));
+  ie->id                             = F1AP_ProtocolIE_ID_id_C_RNTI;
+  ie->criticality                    = F1AP_Criticality_reject;
+  ie->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
+  C_RNTI_TO_BIT_STRING(rntiP, &ie->value.choice.C_RNTI);
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* mandatory */
+  /* c4. RRCContainer */
+  ie = (F1AP_InitialULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_InitialULRRCMessageTransferIEs_t));
+  ie->id                            = F1AP_ProtocolIE_ID_id_RRCContainer;
+  ie->criticality                   = F1AP_Criticality_reject;
+  ie->value.present                 = F1AP_InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
+  OCTET_STRING_fromBuf(&ie->value.choice.RRCContainer, sduP, sdu_lenP);
+  ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+
+  /* optional */
+  /* c5. DUtoCURRCContainer */
+  if (0) {
+    ie = (F1AP_InitialULRRCMessageTransferIEs_t *)calloc(1, sizeof(F1AP_InitialULRRCMessageTransferIEs_t));
+    ie->id                             = F1AP_ProtocolIE_ID_id_DUtoCURRCContainer;
+    ie->criticality                    = F1AP_Criticality_reject;
+    ie->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
+    OCTET_STRING_fromBuf(&ie->value.choice.DUtoCURRCContainer, "dummy_val",
+                       strlen("dummy_val"));
+    ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
+  }
+
+
+    /* encode */
+  if (f1ap_encode_pdu(&pdu, &buffer, &len) < 0) {
+    printf("Failed to encode F1 setup request\n");
+  }
+
+  printf("\n");
+
+  //du_f1ap_itti_send_sctp_data_req(instance, f1ap_setup_req->assoc_id, buffer, len, 0);
+  /* decode */
+  // if (f1ap_decode_pdu(&pdu, buffer, len) > 0) {
+  //   printf("Failed to decode F1 setup request\n");
+  // }
+  //AssertFatal(1==0,"Not implemented yet\n");
+}
\ No newline at end of file

openair2/F1AP/f1ap_du_rrc_message_transfer.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 f1ap_du_rrc_message_transfer.h
+ * \brief f1ap rrc message transfer for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
+
+
+#ifndef F1AP_DU_RRC_MESSAGE_TRANSFER_H_
+#define F1AP_DU_RRC_MESSAGE_TRANSFER_H_
+
+#endif /* F1AP_DU_RRC_MESSAGE_TRANSFER_H_ */
\ No newline at end of file

openair2/F1AP/f1ap_du_system_information.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_du_system_information.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_du_task.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 openair2/F1AP/DU_F1AP.c
+* \brief data structures for F1 interface modules
+* \author EURECOM/NTUST
+* \date 2018
+* \version 0.1
+* \company Eurecom
+* \email: navid.nikaein@eurecom.fr, raymond.knopp@eurecom.fr, bing-kai.hong@eurecom.fr
+* \note
+* \warning
+*/
+
+#include "f1ap_common.h"
+#include "f1ap_handlers.h"
+#include "f1ap_du_interface_management.h"
+#include "f1ap_du_task.h"
+
+f1ap_setup_req_t *f1ap_du_data;
+
+void du_task_send_sctp_association_req(instance_t instance, f1ap_setup_req_t *f1ap_setup_req) {
+  
+  DevAssert(f1ap_setup_req != NULL);
+
+  MessageDef                 *message_p                   = NULL;
+  sctp_new_association_req_t *sctp_new_association_req_p  = NULL;
+
+  message_p = itti_alloc_new_message(TASK_DU_F1, SCTP_NEW_ASSOCIATION_REQ);
+
+  sctp_new_association_req_p = &message_p->ittiMsg.sctp_new_association_req;
+  sctp_new_association_req_p->ulp_cnx_id = instance;
+  sctp_new_association_req_p->port = F1AP_PORT_NUMBER;
+  sctp_new_association_req_p->ppid = F1AP_SCTP_PPID;
+
+  sctp_new_association_req_p->in_streams  = f1ap_setup_req->sctp_in_streams;
+  sctp_new_association_req_p->out_streams = f1ap_setup_req->sctp_out_streams;
+
+  // remote
+  memcpy(&sctp_new_association_req_p->remote_address,
+         &f1ap_setup_req->CU_f1_ip_address,
+         sizeof(f1ap_setup_req->CU_f1_ip_address));
+
+  // local
+  memcpy(&sctp_new_association_req_p->local_address,
+         &f1ap_setup_req->DU_f1_ip_address,
+         sizeof(f1ap_setup_req->DU_f1_ip_address));
+
+  // store data
+  f1ap_du_data = (f1ap_setup_req_t *)calloc(1, sizeof(f1ap_setup_req_t));
+  *f1ap_du_data = *f1ap_setup_req;
+  //printf("sib itti message %s\n", f1ap_setup_req_t->sib1[0]);
+  printf("sib f1ap context %s\n", f1ap_du_data->sib1[0]);
+  
+  //du_f1ap_register_to_sctp
+  itti_send_msg_to_task(TASK_SCTP, instance, message_p);
+}
+
+void du_task_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp) {
+
+  DevAssert(sctp_new_association_resp != NULL);
+
+  if (sctp_new_association_resp->sctp_state != SCTP_STATE_ESTABLISHED) {
+    LOG_W(F1AP, "Received unsuccessful result for SCTP association (%u), instance %d, cnx_id %u\n",
+              sctp_new_association_resp->sctp_state,
+              instance,
+              sctp_new_association_resp->ulp_cnx_id);
+
+      //f1ap_handle_setup_message(instance, sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN);
+    return; // exit -1 for debugging 
+    }
+
+    // save the assoc id 
+  f1ap_du_data->assoc_id         = sctp_new_association_resp->assoc_id;
+  f1ap_du_data->sctp_in_streams  = sctp_new_association_resp->in_streams;
+  f1ap_du_data->sctp_out_streams = sctp_new_association_resp->out_streams;
+
+
+  DU_send_F1_SETUP_REQUEST(instance);
+}
+
+void du_task_handle_sctp_data_ind(sctp_data_ind_t *sctp_data_ind)
+{
+  int result;
+
+  DevAssert(sctp_data_ind != NULL);
+
+  f1ap_handle_message(sctp_data_ind->assoc_id, sctp_data_ind->stream,
+                          sctp_data_ind->buffer, sctp_data_ind->buffer_length);
+
+  result = itti_free(TASK_UNKNOWN, sctp_data_ind->buffer);
+  AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+}
+
+
+void *F1AP_DU_task(void *arg) {
+
+  //sctp_cu_init();
+  MessageDef *received_msg = NULL;
+  int         result;
+
+  LOG_I(DU_F1AP, "Starting F1AP at DU\n");
+
+  //f1ap_eNB_prepare_internal_data();
+
+  itti_mark_task_ready(TASK_DU_F1);
+
+  // SCTP
+  while (1) {
+    itti_receive_msg(TASK_DU_F1, &received_msg);
+
+    switch (ITTI_MSG_ID(received_msg)) {
+
+      // case TERMINATE_MESSAGE:
+      //   //F1AP_WARN(" *** Exiting F1AP DU thread\n");
+      //   itti_exit_task();
+      //   break;
+
+      case F1AP_SETUP_REQ: // this is not a true F1 message, but rather an ITTI message sent by enb_app
+        // 1. save the itti msg so that you can use it to sen f1ap_setup_req, fill the f1ap_setup_req message, 
+        // 2. store the message in f1ap context, that is also stored in RC
+        // 2. send a sctp_association req
+        LOG_I(DU_F1AP, "F1AP_SETUP_REQ\n");
+        du_task_send_sctp_association_req(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+                                              &F1AP_SETUP_REQ(received_msg));
+        break;
+
+      case SCTP_NEW_ASSOCIATION_RESP:
+        // 1. store the respon
+        // 2. send the f1setup_req
+        LOG_I(DU_F1AP, "SCTP_NEW_ASSOCIATION_RESP\n");
+        du_task_handle_sctp_association_resp(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+                                      &received_msg->ittiMsg.sctp_new_association_resp);
+        break;
+
+      case SCTP_DATA_IND: 
+        // ex: any F1 incoming message for DU ends here
+        LOG_I(DU_F1AP, "SCTP_DATA_IND\n");
+        du_task_handle_sctp_data_ind(&received_msg->ittiMsg.sctp_data_ind);
+        break;
+
+      case TERMINATE_MESSAGE:
+        LOG_W(DU_F1AP, " *** Exiting DU_F1AP thread\n");
+        itti_exit_task();
+        break;
+
+      default:
+        LOG_E(DU_F1AP, "DU Received unhandled message: %d:%s\n",
+                  ITTI_MSG_ID(received_msg), ITTI_MSG_NAME(received_msg));
+        break;
+    } // switch
+    result = itti_free (ITTI_MSG_ORIGIN_ID(received_msg), received_msg);
+    AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
+
+    received_msg = NULL;
+  } // while
+
+  return NULL;
+}
\ No newline at end of file

openair2/F1AP/f1ap_du_task.h

@@ -22,6 +22,9 @@
 #ifndef DU_F1AP_TASK_H_
 #define DU_F1AP_TASK_H_
 
+void du_task_send_sctp_association_req(instance_t instance, f1ap_setup_req_t *f1ap_setup_req);
+void du_task_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp);
+void du_task_handle_sctp_data_ind(sctp_data_ind_t *sctp_data_ind);
 void *F1AP_DU_task(void *arg);
 
 #endif /* DU_F1AP_TASK_H_ */

openair2/F1AP/f1ap_du_ue_context_management.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 f1ap_du_ue_context_management.h
+ * \brief f1ap ue context management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
+
+#ifndef F1AP_DU_UE_CONTEXT_MANAGEMENT_H_
+#define F1AP_DU_UE_CONTEXT_MANAGEMENT_H_
+
+#endif /* F1AP_DU_UE_CONTEXT_MANAGEMENT_H_ */
\ No newline at end of file

openair2/F1AP/f1ap_du_warning_message_transmission.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_du_warning_message_transmission.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 f1ap_du_interface_management.h
+ * \brief f1ap interface management for DU
+ * \author EURECOM/NTUST
+ * \date 2018
+ * \version 0.1
+ * \company Eurecom
+ * \email: navid.nikaein@eurecom.fr, bing-kai.hong@eurecom.fr
+ * \note
+ * \warning
+ */
\ No newline at end of file

openair2/F1AP/f1ap_encoder.c

@@ -30,16 +30,6 @@
  * \warning
  */
 
-#include <stdio.h>
-#include <string.h>
-#include <stdint.h>
-
-#include "assertions.h"
-
-#include "conversions.h"
-
-#include "intertask_interface.h"
-
 #include "f1ap_common.h"
 #include "f1ap_encoder.h"
 

openair2/F1AP/f1ap_encoder.h

@@ -33,9 +33,7 @@
 #ifndef F1AP_ENCODER_H_
 #define F1AP_ENCODER_H_
 
-#include "f1ap_common.h"
-
-int f1ap_encode_pdu(F1AP_F1AP_PDU_t *message, uint8_t **buffer, uint32_t *len)
+int f1ap_encode_pdu(F1AP_F1AP_PDU_t *pdu, uint8_t **buffer, uint32_t *length)
 __attribute__ ((warn_unused_result));
 
 #endif /* F1AP_ENCODER_H_ */

openair2/F1AP/f1ap_handlers.c

@@ -30,54 +30,31 @@
  * \warning
  */
 
-#include <stdint.h>
-
-#include "intertask_interface.h"
-
-#include "asn1_conversions.h"
-
 #include "f1ap_common.h"
-// #include "f1ap_eNB.h"
 #include "f1ap_handlers.h"
-#include "f1ap_decoder.h"
-
-#include "f1ap_default_values.h"
-
-#include "assertions.h"
-#include "conversions.h"
-#include "msc.h"
+#include "f1ap_cu_interface_management.h"
+#include "f1ap_du_interface_management.h"
 
 extern f1ap_setup_req_t *f1ap_du_data_from_du;
 
-
-static
-int f1ap_handle_f1_setup_request(uint32_t               assoc_id,
-                                 uint32_t               stream,
-                                 F1AP_F1AP_PDU_t        *pdu);
-
-static
-int f1ap_handle_f1_setup_response(uint32_t               assoc_id,
-                                 uint32_t               stream,
-                                 F1AP_F1AP_PDU_t        *pdu);
-
 /* Handlers matrix. Only f1 related procedure present here */
 f1ap_message_decoded_callback f1ap_messages_callback[][3] = {
   
 
   { 0, 0, 0 }, /* Reset */
-  { f1ap_handle_f1_setup_request, f1ap_handle_f1_setup_response, 0 }, /* F1Setup */
+  { CU_handle_F1_SETUP_REQUEST, DU_handle_F1_SETUP_RESPONSE, 0 }, /* F1Setup */
   { 0, 0, 0 }, /* ErrorIndication */
-  { f1ap_handle_f1_setup_request, 0, 0 }, /* gNBDUConfigurationUpdate */
-  { f1ap_handle_f1_setup_request, 0, 0 }, /* gNBCUConfigurationUpdate */
-  { f1ap_handle_f1_setup_request, 0, 0 }, /* UEContextSetup */
+  { CU_handle_F1_SETUP_REQUEST, 0, 0 }, /* gNBDUConfigurationUpdate */
+  { CU_handle_F1_SETUP_REQUEST, 0, 0 }, /* gNBCUConfigurationUpdate */
+  { CU_handle_F1_SETUP_REQUEST, 0, 0 }, /* UEContextSetup */
   { 0, 0, 0 }, /* UEContextRelease */
-  { f1ap_handle_f1_setup_request, 0, 0 }, /* UEContextModification */
+  { CU_handle_F1_SETUP_REQUEST, 0, 0 }, /* UEContextModification */
   { 0, 0, 0 }, /* UEContextModificationRequired */
   { 0, 0, 0 }, /* UEMobilityCommand */
   { 0, 0, 0 }, /* UEContextReleaseRequest */
-  { f1ap_handle_f1_setup_request, 0, 0 }, /* InitialULRRCMessageTransfer */
-  { f1ap_handle_f1_setup_request, 0, 0 }, /* DLRRCMessageTransfer */
-  { f1ap_handle_f1_setup_request, 0, 0 }, /* ULRRCMessageTransfer */
+  { CU_handle_F1_SETUP_REQUEST, 0, 0 }, /* InitialULRRCMessageTransfer */
+  { CU_handle_F1_SETUP_REQUEST, 0, 0 }, /* DLRRCMessageTransfer */
+  { CU_handle_F1_SETUP_REQUEST, 0, 0 }, /* ULRRCMessageTransfer */
   { 0, 0, 0 }, /* privateMessage */
   { 0, 0, 0 }, /* UEInactivityNotification */
   { 0, 0, 0 }, /* GNBDUResourceCoordination */
@@ -141,162 +118,4 @@ int f1ap_handle_message(uint32_t assoc_id, int32_t stream,
         (assoc_id, stream, &pdu);
   ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_F1AP_F1AP_PDU, &pdu);
   return ret;
-}
-
-static
-int f1ap_handle_f1_setup_request(uint32_t               assoc_id,
-                                 uint32_t               stream,
-                                 F1AP_F1AP_PDU_t       *pdu)
-{
-  printf("f1ap_handle_f1_setup_request\n");
-  
-  MessageDef                         *message_p;
-  F1AP_F1SetupRequest_t              *container;
-  F1AP_F1SetupRequestIEs_t           *ie;
-  int i = 0;
-   
-
-  DevAssert(pdu != NULL);
-
-  container = &pdu->choice.initiatingMessage->value.choice.F1SetupRequest;
-
-  /* F1 Setup Request == Non UE-related procedure -> stream 0 */
-  if (stream != 0) {
-    LOG_W(F1AP, "[SCTP %d] Received f1 setup request on stream != 0 (%d)\n",
-              assoc_id, stream);
-  }
-
-  message_p = itti_alloc_new_message(TASK_RRC_ENB, F1AP_SETUP_REQ); 
-  
-  /* assoc_id */
-  F1AP_SETUP_REQ(message_p).assoc_id = assoc_id;
-  
-  /* gNB_DU_id */
-  // this function exits if the ie is mandatory
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_F1SetupRequestIEs_t, ie, container,
-                             F1AP_ProtocolIE_ID_id_gNB_DU_ID, true);
-  asn_INTEGER2ulong(&ie->value.choice.GNB_DU_ID, &F1AP_SETUP_REQ(message_p).gNB_DU_id);
-  printf("F1AP_SETUP_REQ(message_p).gNB_DU_id %lu \n", F1AP_SETUP_REQ(message_p).gNB_DU_id);
-
-  /* gNB_DU_name */
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_F1SetupRequestIEs_t, ie, container,
-                              F1AP_ProtocolIE_ID_id_gNB_DU_Name, true);
-  F1AP_SETUP_REQ(message_p).gNB_DU_name = calloc(ie->value.choice.GNB_DU_Name.size + 1, sizeof(char));
-  memcpy(F1AP_SETUP_REQ(message_p).gNB_DU_name, ie->value.choice.GNB_DU_Name.buf,
-         ie->value.choice.GNB_DU_Name.size);
-  /* Convert the mme name to a printable string */
-  F1AP_SETUP_REQ(message_p).gNB_DU_name[ie->value.choice.GNB_DU_Name.size] = '\0';
-  printf ("F1AP_SETUP_REQ(message_p).gNB_DU_name %s \n", F1AP_SETUP_REQ(message_p).gNB_DU_name);
-
-  /* GNB_DU_Served_Cells_List */
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_F1SetupRequestIEs_t, ie, container,
-                              F1AP_ProtocolIE_ID_id_gNB_DU_Served_Cells_List, true);
-  F1AP_SETUP_REQ(message_p).num_cells_available = ie->value.choice.GNB_DU_Served_Cells_List.list.count;
-  printf ("F1AP_SETUP_REQ(message_p).num_cells_available %d \n", F1AP_SETUP_REQ(message_p).num_cells_available);
-
-  int num_cells_available = F1AP_SETUP_REQ(message_p).num_cells_available;
-
-  for (i=0; i<num_cells_available; i++) {
-    F1AP_GNB_DU_Served_Cells_Item_t *served_celles_item_p;
-
-    served_celles_item_p = &(((F1AP_GNB_DU_Served_Cells_ItemIEs_t *)ie->value.choice.GNB_DU_Served_Cells_List.list.array[i])->value.choice.GNB_DU_Served_Cells_Item);
-    
-    /* tac */
-    // @issue in here
-    OCTET_STRING_TO_INT16(&(served_celles_item_p->served_Cell_Information.fiveGS_TAC), F1AP_SETUP_REQ(message_p).tac[i]);
-    printf ("F1AP_SETUP_REQ(message_p).tac[%d] %d \n", i, F1AP_SETUP_REQ(message_p).tac[i]);
-
-    /* - nRCGI */
-    TBCD_TO_MCC_MNC(&(served_celles_item_p->served_Cell_Information.nRCGI.pLMN_Identity), F1AP_SETUP_REQ(message_p).mcc[i],
-                    F1AP_SETUP_REQ(message_p).mnc[i],
-                    F1AP_SETUP_REQ(message_p).mnc_digit_length[i]);
-    
-    // @issue in here cellID
-    F1AP_SETUP_REQ(message_p).nr_cellid[i] = 1;
-    printf("[SCTP %d] Received nRCGI: MCC %d, MNC %d, CELL_ID %d\n", assoc_id,
-               F1AP_SETUP_REQ(message_p).mcc[i],
-               F1AP_SETUP_REQ(message_p).mnc[i],
-               F1AP_SETUP_REQ(message_p).nr_cellid[i]);
-    
-    /* - nRPCI */
-    F1AP_SETUP_REQ(message_p).nr_pci[i] = served_celles_item_p->served_Cell_Information.nRPCI;
-    printf ("F1AP_SETUP_REQ(message_p).nr_pci[%d] %d \n", i, F1AP_SETUP_REQ(message_p).nr_pci[i]);
-  
-    // System Information
-    /* mib */
-    F1AP_SETUP_REQ(message_p).mib[i] = calloc(served_celles_item_p->gNB_DU_System_Information->mIB_message.size + 1, sizeof(char));
-    memcpy(F1AP_SETUP_REQ(message_p).mib[i], served_celles_item_p->gNB_DU_System_Information->mIB_message.buf,
-           served_celles_item_p->gNB_DU_System_Information->mIB_message.size);
-    /* Convert the mme name to a printable string */
-    F1AP_SETUP_REQ(message_p).mib[i][served_celles_item_p->gNB_DU_System_Information->mIB_message.size] = '\0';
-    F1AP_SETUP_REQ(message_p).mib_length[i] = served_celles_item_p->gNB_DU_System_Information->mIB_message.size;
-    printf ("F1AP_SETUP_REQ(message_p).mib[%d] %s , len = %d \n", i, F1AP_SETUP_REQ(message_p).mib[i], F1AP_SETUP_REQ(message_p).mib_length[i]);
-
-    /* sib1 */
-    F1AP_SETUP_REQ(message_p).sib1[i] = calloc(served_celles_item_p->gNB_DU_System_Information->sIB1_message.size + 1, sizeof(char));
-    memcpy(F1AP_SETUP_REQ(message_p).sib1[i], served_celles_item_p->gNB_DU_System_Information->sIB1_message.buf,
-           served_celles_item_p->gNB_DU_System_Information->sIB1_message.size);
-    /* Convert the mme name to a printable string */
-    F1AP_SETUP_REQ(message_p).sib1[i][served_celles_item_p->gNB_DU_System_Information->sIB1_message.size] = '\0';
-    F1AP_SETUP_REQ(message_p).sib1_length[i] = served_celles_item_p->gNB_DU_System_Information->sIB1_message.size;
-    printf ("F1AP_SETUP_REQ(message_p).sib1[%d] %s , len = %d \n", i, F1AP_SETUP_REQ(message_p).sib1[i], F1AP_SETUP_REQ(message_p).sib1_length[i]);
-  }
-
-  
-  *f1ap_du_data_from_du = F1AP_SETUP_REQ(message_p);
-  // char *measurement_timing_information[F1AP_MAX_NB_CELLS];
-  // uint8_t ranac[F1AP_MAX_NB_CELLS];
-
-  // int fdd_flag = f1ap_setup_req->fdd_flag;
-
-  // union {
-  //   struct {
-  //     uint32_t ul_nr_arfcn;
-  //     uint8_t ul_scs;
-  //     uint8_t ul_nrb;
-
-  //     uint32_t dl_nr_arfcn;
-  //     uint8_t dl_scs;
-  //     uint8_t dl_nrb;
-
-  //     uint32_t sul_active;
-  //     uint32_t sul_nr_arfcn;
-  //     uint8_t sul_scs;
-  //     uint8_t sul_nrb;
-
-  //     uint8_t num_frequency_bands;
-  //     uint16_t nr_band[32];
-  //     uint8_t num_sul_frequency_bands;
-  //     uint16_t nr_sul_band[32];
-  //   } fdd;
-  //   struct {
-
-  //     uint32_t nr_arfcn;
-  //     uint8_t scs;
-  //     uint8_t nrb;
-
-  //     uint32_t sul_active;
-  //     uint32_t sul_nr_arfcn;
-  //     uint8_t sul_scs;
-  //     uint8_t sul_nrb;
-
-  //     uint8_t num_frequency_bands;
-  //     uint16_t nr_band[32];
-  //     uint8_t num_sul_frequency_bands;
-  //     uint16_t nr_sul_band[32];
-
-  //   } tdd;
-  // } nr_mode_info[F1AP_MAX_NB_CELLS];
-
-  return itti_send_msg_to_task(TASK_RRC_ENB, ENB_MODULE_ID_TO_INSTANCE(assoc_id), message_p);
-}
-
-static
-int f1ap_handle_f1_setup_response(uint32_t               assoc_id,
-                                 uint32_t               stream,
-                                 F1AP_F1AP_PDU_t       *pdu)
-{
-   printf("f1ap_handle_f1_setup_response\n");
-
-   return 0;
-}
+}
\ No newline at end of file

openair2/F1AP/f1ap_itti_messaging.c

@@ -19,8 +19,7 @@
  *      contact@openairinterface.org
  */
 
-#include "intertask_interface.h"
-
+#include "f1ap_common.h"
 #include "f1ap_itti_messaging.h"
 
 void cu_f1ap_itti_send_sctp_data_req(instance_t instance, int32_t assoc_id, uint8_t *buffer,

openair2/F1AP/f1ap_messaging.c

@@ -31,58 +31,36 @@
  */
 
 
-#include "intertask_interface.h"
-
+#include "f1ap_common.h"
 #include "f1ap_messaging.h"
 
-void f1ap_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_F1AP, 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 f1ap_send_nas_downlink_ind(instance_t instance,
-    uint16_t ue_initial_id,
-    uint32_t eNB_ue_s1ap_id,
-    uint8_t *nas_pdu,
-    uint32_t nas_pdu_length)
-{
-  MessageDef          *message_p;
-  f1ap_downlink_nas_t *f1ap_downlink_nas;
+// void f1ap_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_F1AP, F1AP_DOWNLINK_NAS);
+//   message_p = itti_alloc_new_message(TASK_F1AP, SCTP_DATA_REQ);
 
-  f1ap_downlink_nas = &message_p->ittiMsg.f1ap_downlink_nas;
+//   sctp_data_req = &message_p->ittiMsg.sctp_data_req;
 
-  f1ap_downlink_nas->ue_initial_id  = ue_initial_id;
-  f1ap_downlink_nas->eNB_ue_s1ap_id = eNB_ue_f1ap_id;
-  f1ap_downlink_nas->nas_pdu.buffer = nas_pdu;
-  f1ap_downlink_nas->nas_pdu.length = nas_pdu_length;
+//   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_RRC_ENB, instance, message_p);
-}
+//   itti_send_msg_to_task(TASK_SCTP, instance, message_p);
+// }
 
-void f1ap_send_sctp_close_association(instance_t instance, int32_t assoc_id)
-{
-  MessageDef               *message_p = NULL;
-  sctp_close_association_t *sctp_close_association_p = NULL;
+// void f1ap_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_F1AP, SCTP_CLOSE_ASSOCIATION);
-  sctp_close_association_p = &message_p->ittiMsg.sctp_close_association;
-  sctp_close_association_p->assoc_id      = assoc_id;
+//   message_p = itti_alloc_new_message(TASK_F1AP, 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);
-}
+//   itti_send_msg_to_task(TASK_SCTP, instance, message_p);
+// }
 

openair2/F1AP/f1ap_messaging.h

@@ -37,12 +37,6 @@
 void f1ap_send_sctp_data_req(instance_t instance, int32_t assoc_id, uint8_t *buffer,
                                       uint32_t buffer_length, uint16_t stream);
 
-void f1ap_send_nas_downlink_ind(instance_t instance,
-    uint16_t ue_initial_id,
-    uint32_t eNB_ue_f1ap_id,
-    uint8_t *nas_pdu,
-    uint32_t nas_pdu_length);
-
 void f1ap_send_sctp_close_association(instance_t instance,
     int32_t assoc_id);