fix regressions after merge develop

openair1/SIMULATION/NR_PHY/nr_dummy_functions.c

@@ -74,12 +74,6 @@ int newGtpuDeleteAllTunnels(instance_t instance, ue_id_t ue_id) {
 
 instance_t gtpv1Init(openAddr_t context) {return 0;}
 
-void GtpuUpdateTunnelOutgoingPair(instance_t instance,
-                                  ue_id_t ue_id,
-                                  ebi_t bearer_id,
-                                  teid_t newOutgoingTeid,
-                                  transport_layer_addr_t newRemoteAddr) {}
-
 int
 gtpv1u_create_ngu_tunnel(
   const instance_t instanceP,

openair2/E1AP/e1ap.c

@@ -658,6 +658,11 @@ int fill_BEARER_CONTEXT_SETUP_REQUEST(instance_t instance,
 
 void e1apCUCP_send_BEARER_CONTEXT_SETUP_REQUEST(instance_t instance,
                                                 e1ap_bearer_setup_req_t *const bearerCxt) {
+  if (!getCxtE1(CPtype,instance)) {
+    LOG_E(E1AP, "Received a UE bearer to establish while no CU-UP is connected, response on NGAP to send failure is not developped\n");
+    // Fixme: add response on NGAP to send failure
+    return;
+  }
   E1AP_E1AP_PDU_t pdu = {0};
   fill_BEARER_CONTEXT_SETUP_REQUEST(instance, bearerCxt, &pdu);
   e1ap_encode_send(CPtype, instance, &pdu, 0, __func__);

openair2/F1AP/f1ap_cu_task.c

@@ -131,71 +131,57 @@ void *F1AP_CU_task(void *arg) {
 
   while (1) {
     itti_receive_msg(TASK_CU_F1, &received_msg);
-
+    LOG_I(F1AP, "CU Task Received %s for instance %ld\n",
+          ITTI_MSG_NAME(received_msg), ITTI_MSG_DESTINATION_INSTANCE(received_msg));
     switch (ITTI_MSG_ID(received_msg)) {
       case SCTP_NEW_ASSOCIATION_IND:
-        LOG_I(F1AP, "CU Task Received SCTP_NEW_ASSOCIATION_IND for instance %ld\n",
-              ITTI_MSG_DESTINATION_INSTANCE(received_msg));
         cu_task_handle_sctp_association_ind(ITTI_MSG_ORIGIN_INSTANCE(received_msg),
                                             &received_msg->ittiMsg.sctp_new_association_ind,
                                             IPaddrs);
         break;
 
       case SCTP_NEW_ASSOCIATION_RESP:
-        LOG_I(F1AP, "CU Task Received SCTP_NEW_ASSOCIATION_RESP for instance %ld\n",
-              ITTI_MSG_DESTINATION_INSTANCE(received_msg));
         cu_task_handle_sctp_association_resp(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                                              &received_msg->ittiMsg.sctp_new_association_resp);
         break;
 
       case SCTP_DATA_IND:
-        LOG_I(F1AP, "CU Task Received SCTP_DATA_IND for Instance %ld\n",
-              ITTI_MSG_DESTINATION_INSTANCE(received_msg));
         cu_task_handle_sctp_data_ind(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                                      &received_msg->ittiMsg.sctp_data_ind);
         break;
 
       case F1AP_SETUP_RESP: // from rrc
-        LOG_I(F1AP, "CU Task Received F1AP_SETUP_RESP\n");
         CU_send_F1_SETUP_RESPONSE(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                                   &F1AP_SETUP_RESP(received_msg));
         break;
 
       case F1AP_GNB_CU_CONFIGURATION_UPDATE: // from rrc
-        LOG_I(F1AP, "CU Task Received F1AP_GNB_CU_CONFIGURAITON_UPDATE\n");
-        // CU_send_f1setup_resp(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
-        //                                       &F1AP_SETUP_RESP(received_msg));
         CU_send_gNB_CU_CONFIGURATION_UPDATE(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                                             &F1AP_GNB_CU_CONFIGURATION_UPDATE(received_msg));
         break;
 
       case F1AP_DL_RRC_MESSAGE: // from rrc
-        LOG_I(F1AP, "CU Task Received F1AP_DL_RRC_MESSAGE\n");
         CU_send_DL_RRC_MESSAGE_TRANSFER(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                                         &F1AP_DL_RRC_MESSAGE(received_msg));
         free(F1AP_DL_RRC_MESSAGE(received_msg).rrc_container);
         break;
 
       case F1AP_UE_CONTEXT_SETUP_REQ: // from rrc
-        LOG_I(F1AP, "CU Task Received F1AP_UE_CONTEXT_SETUP_REQ\n");
         CU_send_UE_CONTEXT_SETUP_REQUEST(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                                          &F1AP_UE_CONTEXT_SETUP_REQ(received_msg));
         break;
 
       case F1AP_UE_CONTEXT_MODIFICATION_REQ:
-        LOG_I(F1AP, "CU Task received F1AP_UE_CONTEXT_MODIFICATION_REQ\n");
         CU_send_UE_CONTEXT_MODIFICATION_REQUEST(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                                                 &F1AP_UE_CONTEXT_SETUP_REQ(received_msg));
         break;
 
       case F1AP_UE_CONTEXT_RELEASE_CMD: // from rrc
-        LOG_I(F1AP, "CU Task Received F1AP_UE_CONTEXT_RELEASE_CMD\n");
         CU_send_UE_CONTEXT_RELEASE_COMMAND(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                                            &F1AP_UE_CONTEXT_RELEASE_CMD(received_msg));
         break;
 
       case F1AP_PAGING_IND:
-        LOG_I(F1AP, "CU Task Received F1AP_PAGING_IND\n");
         CU_send_Paging(ITTI_MSG_DESTINATION_INSTANCE(received_msg),
                        &F1AP_PAGING_IND(received_msg));
         break;

openair2/F1AP/f1ap_cu_ue_context_management.c

@@ -1010,7 +1010,7 @@ int CU_handle_UE_CONTEXT_RELEASE_COMPLETE(instance_t       instance,
   f1ap_remove_ue(CUtype, instance, rnti);
   return 0;
 }
-//void CU_send_UE_CONTEXT_MODIFICATION_REQUEST(F1AP_UEContextModificationRequest_t *UEContextModificationRequest) {
+
 int CU_send_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, f1ap_ue_context_setup_t *f1ap_ue_context_modification_req) {
   F1AP_F1AP_PDU_t                        pdu= {0};
   F1AP_UEContextModificationRequest_t    *out;
@@ -1479,18 +1479,6 @@ int CU_send_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, f1ap_ue_context
       for (int j = 0; j < f1ap_ue_context_modification_req->drbs_to_be_setup[i].up_ul_tnl_length; j++) {
         /* Use a dummy address and teid for the outgoing GTP-U tunnel (DU) which will be updated once we get the UE context modification response from the DU */
         transport_layer_addr_t addr = { length: 32, buffer: { 0 } };
-
-        f1ap_ue_context_modification_req->drbs_to_be_setup[i].up_ul_tnl[j].teid = newGtpuCreateTunnel(getCxt(CUtype, instance)->gtpInst,
-                                                                                                      f1ap_ue_context_modification_req->rnti,
-                                                                                                      f1ap_ue_context_modification_req->drbs_to_be_setup[i].drb_id,
-                                                                                                      f1ap_ue_context_modification_req->drbs_to_be_setup[i].drb_id,
-                                                                                                      0xFFFF, // We will set the right value from DU answer
-                                                                                                      -1, // no qfi
-                                                                                                      addr,   // We will set the right value from DU answer
-                                                                                                      f1ap_ue_context_modification_req->drbs_to_be_setup[i].up_dl_tnl[0].port,
-                                                                                                      cu_f1u_data_req,
-                                                                                                      NULL);
-        /*  12.3.1 ULTunnels_ToBeSetup_Item */
         asn1cSequenceAdd(drbs_toBeSetupMod_item->uLUPTNLInformation_ToBeSetup_List.list,
                        F1AP_ULUPTNLInformation_ToBeSetup_Item_t, uLUPTNLInformation_ToBeSetup_Item);
         uLUPTNLInformation_ToBeSetup_Item->uLUPTNLInformation.present = F1AP_UPTransportLayerInformation_PR_gTPTunnel;

openair2/F1AP/f1ap_du_task.c

@@ -107,14 +107,14 @@ void *F1AP_DU_task(void *arg) {
     MessageDef *msg = NULL;
     itti_receive_msg(TASK_DU_F1, &msg);
     instance_t myInstance=ITTI_MSG_DESTINATION_INSTANCE(msg);
-
+    LOG_I(F1AP, "DU Task Received %s for instance %ld\n",
+          ITTI_MSG_NAME(msg),myInstance);
     switch (ITTI_MSG_ID(msg)) {
       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(F1AP, "DU Task Received F1AP_SETUP_REQ\n");
         f1ap_setup_req_t *msgSetup=&F1AP_SETUP_REQ(msg);
         createF1inst(false, myInstance, msgSetup);
         du_task_send_sctp_association_req(myInstance,msgSetup);
@@ -133,20 +133,17 @@ void *F1AP_DU_task(void *arg) {
       case SCTP_NEW_ASSOCIATION_RESP:
         // 1. store the respon
         // 2. send the f1setup_req
-        LOG_I(F1AP, "DU Task Received SCTP_NEW_ASSOCIATION_RESP\n");
         du_task_handle_sctp_association_resp(myInstance,
                                              &msg->ittiMsg.sctp_new_association_resp);
         break;
 
       case SCTP_DATA_IND:
         // ex: any F1 incoming message for DU ends here
-        LOG_I(F1AP, "DU Task Received SCTP_DATA_IND\n");
         du_task_handle_sctp_data_ind(myInstance,
                                      &msg->ittiMsg.sctp_data_ind);
         break;
 
       case F1AP_INITIAL_UL_RRC_MESSAGE: // from rrc
-        LOG_I(F1AP, "DU Task Received F1AP_INITIAL_UL_RRC_MESSAGE\n");
         f1ap_initial_ul_rrc_message_t *msgRrc = &F1AP_INITIAL_UL_RRC_MESSAGE(msg);
         DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(0,0,0,msgRrc->crnti,
                                                 msgRrc->rrc_container,
@@ -157,8 +154,6 @@ void *F1AP_DU_task(void *arg) {
         break;
 
       case F1AP_UL_RRC_MESSAGE: // to rrc
-        LOG_D(F1AP, "DU Task Received F1AP_UL_RRC_MESSAGE\n");
-
         if (RC.nrrrc && RC.nrrrc[0]->node_type == ngran_gNB_DU) {
           DU_send_UL_NR_RRC_MESSAGE_TRANSFER(myInstance,
                                              &F1AP_UL_RRC_MESSAGE(msg));
@@ -174,12 +169,10 @@ void *F1AP_DU_task(void *arg) {
         break;
 
       case F1AP_UE_CONTEXT_MODIFICATION_RESP:
-        LOG_I(F1AP, "DU task received itti message from RRC for F1AP_UE_CONTEXT_MODIFICATION_RESP message generation \n");
         DU_send_UE_CONTEXT_MODIFICATION_RESPONSE(myInstance, &F1AP_UE_CONTEXT_MODIFICATION_RESP(msg));
         break;
 
       case F1AP_UE_CONTEXT_RELEASE_REQ: // from MAC
-        LOG_I(F1AP, "DU Task Received F1AP_UE_CONTEXT_RELEASE_REQ\n");
         DU_send_UE_CONTEXT_RELEASE_REQUEST(myInstance,
                                            &F1AP_UE_CONTEXT_RELEASE_REQ(msg));
         break;

openair2/LAYER2/nr_pdcp/nr_pdcp_e1_api.h

@@ -22,7 +22,7 @@
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
-#include "asn1_utils.h"
+#include "common/utils/oai_asn1.h"
 #include "NR_RadioBearerConfig.h"
 
 #include "pdcp.h"

openair2/RRC/NR/cucp_cuup_direct.c

@@ -89,11 +89,11 @@ void CU_update_UP_DL_tunnel(e1ap_bearer_setup_req_t *const req, instance_t insta
              &drb_p->DlUpParamList[0].tlAddress,
              sizeof(in_addr_t));
 
-      GtpuUpdateTunnelOutgoingPair(instance,
-                                   (ue_id & 0xFFFF),
-                                   (ebi_t)drb_p->id,
-                                   drb_p->DlUpParamList[0].teId,
-                                   newRemoteAddr);
+      GtpuUpdateTunnelOutgoingAddressAndTeid(instance,
+                                             (ue_id & 0xFFFF),
+                                             (ebi_t)drb_p->id,
+                                             *(in_addr_t*)&newRemoteAddr.buffer,
+                                             drb_p->DlUpParamList[0].teId);
     }
   }
 }

openair2/RRC/NR/rrc_gNB.c

@@ -3719,7 +3719,7 @@ void prepare_and_send_ue_context_modification_f1(rrc_gNB_ue_context_t *ue_contex
   // TODO: So many hard codings
   MessageDef *message_p;
   message_p = itti_alloc_new_message (TASK_RRC_GNB, 0, F1AP_UE_CONTEXT_MODIFICATION_REQ);
-  f1ap_ue_context_setup_t *req=&F1AP_UE_CONTEXT_SETUP_REQ (message_p);
+  f1ap_ue_context_setup_t *req=&F1AP_UE_CONTEXT_MODIFICATION_REQ(message_p);
   req->rnti             = ue_context_p->ue_context.rnti;
   req->mcc              = RC.nrrrc[ctxt.module_id]->configuration.mcc[0];
   req->mnc              = RC.nrrrc[ctxt.module_id]->configuration.mnc[0];

openair3/ocp-gtpu/gtp_itf.cpp

@@ -552,7 +552,7 @@ instance_t gtpv1Init(openAddr_t context) {
   return id;
 }
 
-void GtpuUpdateTunnelOutgoingPair(instance_t instance, ue_id_t ue_id, ebi_t bearer_id, teid_t newOutgoingTeid, transport_layer_addr_t newRemoteAddr) {
+void GtpuUpdateTunnelOutgoingAddressAndTeid(instance_t instance, ue_id_t ue_id, ebi_t bearer_id, in_addr_t newOutgoingAddr, teid_t newOutgoingTeid) {
   pthread_mutex_lock(&globGtp.gtp_lock);
   getInstRetVoid(compatInst(instance));
   getUeRetVoid(inst, ue_id);
@@ -567,36 +567,7 @@ void GtpuUpdateTunnelOutgoingPair(instance_t instance, ue_id_t ue_id, ebi_t bear
 
   ptr2->second.outgoing_ip_addr = newOutgoingAddr;
   ptr2->second.teid_outgoing = newOutgoingTeid;
-
-  int addrs_length_in_bytes = newRemoteAddr.length / 8;
-
-  switch (addrs_length_in_bytes) {
-    case 4:
-      memcpy(&ptr2->second.outgoing_ip_addr,newRemoteAddr.buffer,4);
-      break;
-
-    case 16:
-      memcpy(ptr2->second.outgoing_ip6_addr.s6_addr,newRemoteAddr.buffer,
-             16);
-      break;
-
-    case 20:
-      memcpy(&ptr2->second.outgoing_ip_addr,newRemoteAddr.buffer,4);
-      memcpy(ptr2->second.outgoing_ip6_addr.s6_addr,
-             newRemoteAddr.buffer+4,
-             16);
-
-    default:
-      AssertFatal(false, "SGW Address size impossible");
-  }
-
-  char ip4[INET_ADDRSTRLEN];
-  char ip6[INET6_ADDRSTRLEN];
-  LOG_I(GTPU, "[%ld] Tunnel Outgoing TEID updated to %x, remote IPv4 to: %s, IPv6 to: %s\n",
-        instance,
-        ptr2->second.teid_outgoing,
-        inet_ntop(AF_INET,(void *)&ptr2->second.outgoing_ip_addr, ip4,INET_ADDRSTRLEN ),
-        inet_ntop(AF_INET6,(void *)ptr2->second.outgoing_ip6_addr.s6_addr, ip6, INET6_ADDRSTRLEN));
+  LOG_I(GTPU, "[%ld] Tunnel Outgoing TEID updated to %x and address to %x\n", instance, ptr2->second.teid_outgoing, ptr2->second.outgoing_ip_addr);
   pthread_mutex_unlock(&globGtp.gtp_lock);
   return;
 }
@@ -1250,6 +1221,7 @@ void *gtpv1uTask(void *args)  {
     */
     MessageDef *message_p = NULL;
     itti_receive_msg(TASK_GTPV1_U, &message_p);
+
     if (message_p != NULL ) {
       openAddr_t addr= {0};
       const instance_t myInstance = ITTI_MSG_DESTINATION_INSTANCE(message_p);

openair3/ocp-gtpu/gtp_itf.h

@@ -92,11 +92,11 @@ extern "C" {
                              gtpCallback callBack,
                              gtpCallbackSDAP callBackSDAP);
 
-  void GtpuUpdateTunnelOutgoingPair(instance_t instance,
+  void GtpuUpdateTunnelOutgoingAddressAndTeid(instance_t instance,
                                     ue_id_t ue_id,
                                     ebi_t bearer_id,
-                                    teid_t newOutgoingTeid,
-                                    transport_layer_addr_t newRemoteAddr);
+                                              in_addr_t newOutgoingAddr,
+                                              teid_t newOutgoingTeid);
 
   int newGtpuDeleteAllTunnels(instance_t instance, ue_id_t ue_id);
   int newGtpuDeleteTunnels(instance_t instance, ue_id_t ue_id, int nbTunnels, pdusessionid_t *pdusession_id);