Use F1AP lib Init UL RRC Msg in stack

Co-authored-by: Guido Casati <hello@guidocasati.com>

CMakeLists.txt

@@ -445,7 +445,8 @@ add_library(f1ap
             ${F1AP_DIR}/f1ap_itti_messaging.c)
 target_include_directories(f1ap PUBLIC F1AP_DIR)
 target_link_libraries(f1ap PUBLIC asn1_f1ap L2_NR)
-target_link_libraries(f1ap PRIVATE ngap nr_rrc HASHTABLE)
+target_link_libraries(f1ap PRIVATE ngap nr_rrc HASHTABLE f1ap_lib)
+target_include_directories(f1ap PRIVATE ${F1AP_DIR}/lib)
 
 # LPP
 ##############
@@ -1435,6 +1436,8 @@ add_library(L2_NR
   ${GNB_APP_SRC}
   )
 target_link_libraries(L2_NR PRIVATE ds alg)
+target_link_libraries(L2_NR PRIVATE f1ap_lib)
+target_include_directories(L2_NR PRIVATE ${F1AP_DIR}/lib)
 
 add_library(e1_if
   ${NR_RRC_DIR}/cucp_cuup_direct.c

openair2/F1AP/f1ap_cu_rrc_message_transfer.c

@@ -39,67 +39,25 @@
 #include "openair3/UTILS/conversions.h"
 #include "LAYER2/nr_pdcp/nr_pdcp_oai_api.h"
 
+#include "f1ap_rrc_message_transfer.h"
+
 /*
     Initial UL RRC Message Transfer
 */
 
 int CU_handle_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t instance, sctp_assoc_t assoc_id, uint32_t stream, F1AP_F1AP_PDU_t *pdu)
 {
-  LOG_D(F1AP, "CU_handle_INITIAL_UL_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
-  MessageDef                            *message_p;
-  F1AP_InitialULRRCMessageTransfer_t    *container;
-  F1AP_InitialULRRCMessageTransferIEs_t *ie;
-  DevAssert(pdu != NULL);
-
-  if (stream != 0) {
-    LOG_E(F1AP, "[SCTP %d] Received F1 on stream != 0 (%d)\n",
-          assoc_id, stream);
+  f1ap_initial_ul_rrc_message_t msg;
+  if (!decode_initial_ul_rrc_message_transfer(pdu, &msg)) {
+    LOG_E(F1AP, "cannot decode F1 initial UL RRC message Transfer\n");
     return -1;
   }
 
-  container = &pdu->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
-  /* GNB_DU_UE_F1AP_ID */
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, ie, container,
-                             F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
-  uint32_t du_ue_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
-
-  /* NRCGI
-  * Fixme: process NRCGI
-  */
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, ie, container,
-                             F1AP_ProtocolIE_ID_id_NRCGI, true);
-  uint64_t nr_cellid;
-  BIT_STRING_TO_NR_CELL_IDENTITY(&ie->value.choice.NRCGI.nRCellIdentity,nr_cellid);
-  /* RNTI */
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, ie, container,
-                             F1AP_ProtocolIE_ID_id_C_RNTI, true);
-  rnti_t rnti = ie->value.choice.C_RNTI;
-  F1AP_InitialULRRCMessageTransferIEs_t *rrccont;
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, rrccont, container,
-                             F1AP_ProtocolIE_ID_id_RRCContainer, true);
-  AssertFatal(rrccont!=NULL,"RRCContainer is missing\n");
-
-  F1AP_InitialULRRCMessageTransferIEs_t *du2cu;
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, du2cu, container,
-                             F1AP_ProtocolIE_ID_id_DUtoCURRCContainer, false);
-
   // create an ITTI message and copy SDU
-  message_p = itti_alloc_new_message(TASK_CU_F1, 0, F1AP_INITIAL_UL_RRC_MESSAGE);
+  MessageDef *message_p = itti_alloc_new_message(TASK_CU_F1, 0, F1AP_INITIAL_UL_RRC_MESSAGE);
   message_p->ittiMsgHeader.originInstance = assoc_id;
   f1ap_initial_ul_rrc_message_t *ul_rrc = &F1AP_INITIAL_UL_RRC_MESSAGE(message_p);
-  ul_rrc->gNB_DU_ue_id = du_ue_id;
-  ul_rrc->nr_cellid = nr_cellid; // CU instance
-  ul_rrc->crnti = rnti;
-  ul_rrc->rrc_container_length = rrccont->value.choice.RRCContainer.size;
-  ul_rrc->rrc_container = malloc(ul_rrc->rrc_container_length);
-  memcpy(ul_rrc->rrc_container, rrccont->value.choice.RRCContainer.buf, ul_rrc->rrc_container_length);
-  AssertFatal(du2cu != NULL, "no masterCellGroup in initial UL RRC message\n");
-  ul_rrc->du2cu_rrc_container_length = du2cu->value.choice.DUtoCURRCContainer.size;
-  ul_rrc->du2cu_rrc_container = malloc(ul_rrc->du2cu_rrc_container_length);
-  memcpy(ul_rrc->du2cu_rrc_container, du2cu->value.choice.DUtoCURRCContainer.buf, ul_rrc->du2cu_rrc_container_length);
+  *ul_rrc = msg; /* "move" message into ITTI, RRC thread will free it */
   itti_send_msg_to_task(TASK_RRC_GNB, instance, message_p);
 
   return 0;

openair2/F1AP/f1ap_du_rrc_message_transfer.c

@@ -53,6 +53,8 @@
 
 #include "openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.h"
 
+#include "f1ap_rrc_message_transfer.h"
+
 /*  DL RRC Message Transfer */
 int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t instance, sctp_assoc_t assoc_id, uint32_t stream, F1AP_F1AP_PDU_t *pdu)
 {
@@ -141,73 +143,25 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t instance, sctp_assoc_t assoc_id
 /*  UL RRC Message Transfer */
 int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(sctp_assoc_t assoc_id, const f1ap_initial_ul_rrc_message_t *msg)
 {
-  F1AP_F1AP_PDU_t                       pdu= {0};
-  F1AP_InitialULRRCMessageTransfer_t    *out;
-  uint8_t  *buffer=NULL;
-  uint32_t  len=0;
+  F1AP_F1AP_PDU_t *pdu = encode_initial_ul_rrc_message_transfer(msg);
+  /* free F1AP message after encoding */
+  free_initial_ul_rrc_message_transfer(msg);
 
-  /* Create */
-  /* 0. Message Type */
-  pdu.present = F1AP_F1AP_PDU_PR_initiatingMessage;
-  asn1cCalloc(pdu.choice.initiatingMessage, tmp);
-  tmp->procedureCode = F1AP_ProcedureCode_id_InitialULRRCMessageTransfer;
-  tmp->criticality   = F1AP_Criticality_ignore;
-  tmp->value.present = F1AP_InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
-  out = &tmp->value.choice.InitialULRRCMessageTransfer;
-  /* mandatory */
-  /* c1. GNB_DU_UE_F1AP_ID */
-  asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie1);
-  ie1->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
-  ie1->criticality                    = F1AP_Criticality_reject;
-  ie1->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
-  ie1->value.choice.GNB_DU_UE_F1AP_ID = msg->gNB_DU_ue_id;
-  /* mandatory */
-  /* c2. NRCGI */
-  asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie2);
-  ie2->id                             = F1AP_ProtocolIE_ID_id_NRCGI;
-  ie2->criticality                    = F1AP_Criticality_reject;
-  ie2->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_NRCGI;
-  //Fixme: takes always the first cell
-  addnRCGI(ie2->value.choice.NRCGI, &getCxt(0)->setupReq.cell[0].info);
-  /* mandatory */
-  /* c3. C_RNTI */  // 16
-  asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie3);
-  ie3->id                             = F1AP_ProtocolIE_ID_id_C_RNTI;
-  ie3->criticality                    = F1AP_Criticality_reject;
-  ie3->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
-  ie3->value.choice.C_RNTI = msg->crnti;
-  /* mandatory */
-  /* c4. RRCContainer */
-  asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie4);
-  ie4->id                            = F1AP_ProtocolIE_ID_id_RRCContainer;
-  ie4->criticality                   = F1AP_Criticality_reject;
-  ie4->value.present                 = F1AP_InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
-  OCTET_STRING_fromBuf(&ie4->value.choice.RRCContainer, (const char *)msg->rrc_container, msg->rrc_container_length);
-
-  /* optional */
-  /* c5. DUtoCURRCContainer */
-  if (msg->du2cu_rrc_container != NULL) {
-    asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie5);
-    ie5->id                             = F1AP_ProtocolIE_ID_id_DUtoCURRCContainer;
-    ie5->criticality                    = F1AP_Criticality_reject;
-    ie5->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
-    OCTET_STRING_fromBuf(&ie5->value.choice.DUtoCURRCContainer,
-                         (const char *)msg->du2cu_rrc_container,
-                         msg->du2cu_rrc_container_length);
+  if (pdu == NULL) {
+    LOG_E(F1AP, "cannot encode F1 INITIAL UL RRC MESSAGE TRANSFER, can't send message\n");
+    ASN_STRUCT_FREE(asn_DEF_F1AP_F1AP_PDU, pdu);
+    return -1;
   }
-  /* mandatory */
-  /* c6. Transaction ID (integer value) */
-  asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie6);
-  ie6->id                        = F1AP_ProtocolIE_ID_id_TransactionID;
-  ie6->criticality               = F1AP_Criticality_ignore;
-  ie6->value.present             = F1AP_InitialULRRCMessageTransferIEs__value_PR_TransactionID;
-  ie6->value.choice.TransactionID = F1AP_get_next_transaction_identifier(0, 0);
 
   /* encode */
-  if (f1ap_encode_pdu(&pdu, &buffer, &len) < 0) {
+  uint8_t *buffer = NULL;
+  uint32_t len = 0;
+  if (f1ap_encode_pdu(pdu, &buffer, &len) < 0) {
     LOG_E(F1AP, "Failed to encode F1 INITIAL UL RRC MESSAGE TRANSFER\n");
+    ASN_STRUCT_FREE(asn_DEF_F1AP_F1AP_PDU, pdu);
     return -1;
   }
+  ASN_STRUCT_FREE(asn_DEF_F1AP_F1AP_PDU, pdu);
 
   f1ap_itti_send_sctp_data_req(assoc_id, buffer, len);
   return 0;

openair2/F1AP/lib/f1ap_rrc_message_transfer.c

@@ -191,7 +191,7 @@ bool eq_initial_ul_rrc_message_transfer(const f1ap_initial_ul_rrc_message_t *a,
 /**
  * @brief Initial UL RRC Message Transfer memory management
  */
-void free_initial_ul_rrc_message_transfer(f1ap_initial_ul_rrc_message_t *msg)
+void free_initial_ul_rrc_message_transfer(const f1ap_initial_ul_rrc_message_t *msg)
 {
   DevAssert(msg != NULL);
   free(msg->rrc_container);

openair2/F1AP/lib/f1ap_rrc_message_transfer.h

@@ -31,6 +31,6 @@ struct F1AP_F1AP_PDU *encode_initial_ul_rrc_message_transfer(const f1ap_initial_
 bool decode_initial_ul_rrc_message_transfer(const struct F1AP_F1AP_PDU *pdu, f1ap_initial_ul_rrc_message_t *out);
 f1ap_initial_ul_rrc_message_t cp_initial_ul_rrc_message_transfer(const f1ap_initial_ul_rrc_message_t *msg);
 bool eq_initial_ul_rrc_message_transfer(const f1ap_initial_ul_rrc_message_t *a, const f1ap_initial_ul_rrc_message_t *b);
-void free_initial_ul_rrc_message_transfer(f1ap_initial_ul_rrc_message_t *msg);
+void free_initial_ul_rrc_message_transfer(const f1ap_initial_ul_rrc_message_t *msg);
 
 #endif /* F1AP_RRC_MESSAGE_TRANSFER_H_ */

openair2/LAYER2/NR_MAC_gNB/mac_rrc_ul_direct.c

@@ -23,6 +23,7 @@
 #include "intertask_interface.h"
 
 #include "mac_rrc_ul.h"
+#include "f1ap_lib_extern.h"
 
 static void f1_reset_du_initiated_direct(const f1ap_reset_t *reset)
 {
@@ -277,20 +278,8 @@ static void initial_ul_rrc_message_transfer_direct(module_id_t module_id, const
 {
   MessageDef *msg = itti_alloc_new_message(TASK_MAC_GNB, 0, F1AP_INITIAL_UL_RRC_MESSAGE);
   msg->ittiMsgHeader.originInstance = -1; // means monolithic
-  /* copy all fields, but reallocate rrc_containers! */
   f1ap_initial_ul_rrc_message_t *f1ap_msg = &F1AP_INITIAL_UL_RRC_MESSAGE(msg);
-  *f1ap_msg = *ul_rrc;
-
-  f1ap_msg->rrc_container = malloc(ul_rrc->rrc_container_length);
-  DevAssert(f1ap_msg->rrc_container);
-  memcpy(f1ap_msg->rrc_container, ul_rrc->rrc_container, ul_rrc->rrc_container_length);
-  f1ap_msg->rrc_container_length = ul_rrc->rrc_container_length;
-
-  f1ap_msg->du2cu_rrc_container = malloc(ul_rrc->du2cu_rrc_container_length);
-  DevAssert(f1ap_msg->du2cu_rrc_container);
-  memcpy(f1ap_msg->du2cu_rrc_container, ul_rrc->du2cu_rrc_container, ul_rrc->du2cu_rrc_container_length);
-  f1ap_msg->du2cu_rrc_container_length = ul_rrc->du2cu_rrc_container_length;
-
+  *f1ap_msg = cp_initial_ul_rrc_message_transfer(ul_rrc);
   itti_send_msg_to_task(TASK_RRC_GNB, module_id, msg);
 }
 

openair2/LAYER2/NR_MAC_gNB/mac_rrc_ul_f1ap.c

@@ -29,6 +29,8 @@
 
 #include "mac_rrc_ul.h"
 
+#include "f1ap_lib_extern.h"
+
 static f1ap_net_config_t read_DU_IP_config(const eth_params_t* f1_params, const char *f1u_ip_addr)
 {
   f1ap_net_config_t nc = {0};
@@ -265,20 +267,8 @@ static void ue_context_release_complete_f1ap(const f1ap_ue_context_release_compl
 static void initial_ul_rrc_message_transfer_f1ap(module_id_t module_id, const f1ap_initial_ul_rrc_message_t *ul_rrc)
 {
   MessageDef *msg = itti_alloc_new_message(TASK_MAC_GNB, 0, F1AP_INITIAL_UL_RRC_MESSAGE);
-  /* copy all fields, but reallocate rrc_containers! */
   f1ap_initial_ul_rrc_message_t *f1ap_msg = &F1AP_INITIAL_UL_RRC_MESSAGE(msg);
-  *f1ap_msg = *ul_rrc;
-
-  f1ap_msg->rrc_container = malloc(ul_rrc->rrc_container_length);
-  DevAssert(f1ap_msg->rrc_container);
-  memcpy(f1ap_msg->rrc_container, ul_rrc->rrc_container, ul_rrc->rrc_container_length);
-  f1ap_msg->rrc_container_length = ul_rrc->rrc_container_length;
-
-  f1ap_msg->du2cu_rrc_container = malloc(ul_rrc->du2cu_rrc_container_length);
-  DevAssert(f1ap_msg->du2cu_rrc_container);
-  memcpy(f1ap_msg->du2cu_rrc_container, ul_rrc->du2cu_rrc_container, ul_rrc->du2cu_rrc_container_length);
-  f1ap_msg->du2cu_rrc_container_length = ul_rrc->du2cu_rrc_container_length;
-
+  *f1ap_msg = cp_initial_ul_rrc_message_transfer(ul_rrc);
   itti_send_msg_to_task(TASK_DU_F1, module_id, msg);
 }
 

openair2/RRC/NR/rrc_gNB.c

@@ -94,6 +94,7 @@
 #include <openair2/RRC/NR/nr_rrc_proto.h>
 #include "openair2/F1AP/f1ap_common.h"
 #include "openair2/F1AP/f1ap_ids.h"
+#include "openair2/F1AP/lib/f1ap_lib_extern.h"
 #include "openair2/SDAP/nr_sdap/nr_sdap_entity.h"
 #include "openair2/E1AP/e1ap.h"
 #include "cucp_cuup_if.h"
@@ -1839,11 +1840,6 @@ void rrc_gNB_process_initial_ul_rrc_message(sctp_assoc_t assoc_id, const f1ap_in
     }
   }
   ASN_STRUCT_FREE(asn_DEF_NR_UL_CCCH_Message, ul_ccch_msg);
-
-  if (ul_rrc->rrc_container)
-    free(ul_rrc->rrc_container);
-  if (ul_rrc->du2cu_rrc_container)
-    free(ul_rrc->du2cu_rrc_container);
 }
 
 void rrc_gNB_process_release_request(const module_id_t gnb_mod_idP, x2ap_ENDC_sgnb_release_request_t *m)
@@ -2439,6 +2435,7 @@ void *rrc_gnb_task(void *args_p) {
         AssertFatal(NODE_IS_CU(RC.nrrrc[instance]->node_type) || NODE_IS_MONOLITHIC(RC.nrrrc[instance]->node_type),
                     "should not receive F1AP_INITIAL_UL_RRC_MESSAGE, need call by CU!\n");
         rrc_gNB_process_initial_ul_rrc_message(msg_p->ittiMsgHeader.originInstance, &F1AP_INITIAL_UL_RRC_MESSAGE(msg_p));
+        free_initial_ul_rrc_message_transfer(&F1AP_INITIAL_UL_RRC_MESSAGE(msg_p));
         break;
 
       /* Messages from PDCP */