diff --git a/openair2/COMMON/f1ap_messages_def.h b/openair2/COMMON/f1ap_messages_def.h
index 125d6a0d6a8da15367e41010714566849e9398d7..9cb63a0a06b7d180f81d9ca739ee52feaa7f7688 100644
--- a/openair2/COMMON/f1ap_messages_def.h
+++ b/openair2/COMMON/f1ap_messages_def.h
@@ -19,6 +19,9 @@
  *      contact@openairinterface.org
  */
 
+/* To setup F1 at DU */
+MESSAGE_DEF(F1AP_DU_REGISTER_REQ, MESSAGE_PRIORITY_MED, f1ap_du_register_req_t, f1ap_du_register_req)
+
 /* eNB_DU application layer -> F1AP messages or CU F1AP -> RRC*/
 MESSAGE_DEF(F1AP_SETUP_REQ          , MESSAGE_PRIORITY_MED, f1ap_setup_req_t          , f1ap_setup_req)
 MESSAGE_DEF(F1AP_GNB_CU_CONFIGURATION_UPDATE_ACKNOWLEDGE         , MESSAGE_PRIORITY_MED, f1ap_gnb_cu_configuration_update_acknowledge_t          , f1ap_gnb_cu_configuration_update_acknowledge)
diff --git a/openair2/COMMON/f1ap_messages_types.h b/openair2/COMMON/f1ap_messages_types.h
index cb51f9f3747f55baf26011b955ee4178c9aaf5fa..2e1fd7e9ad45d802ec6b282ac6122c54694ca935 100644
--- a/openair2/COMMON/f1ap_messages_types.h
+++ b/openair2/COMMON/f1ap_messages_types.h
@@ -30,6 +30,8 @@
 
 #define F1AP_CU_SCTP_REQ(mSGpTR)                   (mSGpTR)->ittiMsg.f1ap_cu_sctp_req
 
+#define F1AP_DU_REGISTER_REQ(mSGpTR)               (mSGpTR)->ittiMsg.f1ap_du_register_req
+
 #define F1AP_SETUP_REQ(mSGpTR)                     (mSGpTR)->ittiMsg.f1ap_setup_req
 #define F1AP_SETUP_RESP(mSGpTR)                    (mSGpTR)->ittiMsg.f1ap_setup_resp
 #define F1AP_GNB_CU_CONFIGURATION_UPDATE(mSGpTR)   (mSGpTR)->ittiMsg.f1ap_gnb_cu_configuration_update
@@ -75,6 +77,13 @@ typedef struct f1ap_net_ip_address_s {
   char ipv6_address[46];
 } f1ap_net_ip_address_t;
 
+typedef struct f1ap_net_config_t {
+  f1ap_net_ip_address_t CU_f1_ip_address;
+  f1ap_net_ip_address_t DU_f1_ip_address;
+  uint16_t CUport;
+  uint16_t DUport;
+} f1ap_net_config_t;
+
 typedef struct cellIDs_s {
 
   // Served Cell Information
@@ -100,24 +109,6 @@ typedef struct cellIDs_s {
 
 typedef struct f1ap_setup_req_s {
 
-  // Midhaul networking parameters
-
-  /* Connexion id used between SCTP/F1AP */
-  uint16_t cnx_id;
-
-  /* SCTP association id */
-  int32_t  assoc_id;
-
-  /* The eNB IP address to bind */
-  f1ap_net_ip_address_t CU_f1_ip_address;
-  f1ap_net_ip_address_t DU_f1_ip_address;
-  uint16_t CUport;
-  uint16_t DUport;
-
-  /* Number of SCTP streams used for a mme association */
-  uint16_t sctp_in_streams;
-  uint16_t sctp_out_streams;
-
   // F1_Setup_Req payload
   uint64_t gNB_DU_id;
   char *gNB_DU_name;
@@ -184,6 +175,11 @@ typedef struct f1ap_setup_req_s {
 
 } f1ap_setup_req_t;
 
+typedef struct f1ap_du_register_req_t {
+  f1ap_setup_req_t setup_req;
+  f1ap_net_config_t net_config;
+} f1ap_du_register_req_t;
+
 typedef struct served_cells_to_activate_s {
   /// mcc of DU cells
   uint16_t mcc;
diff --git a/openair2/F1AP/f1ap_common.c b/openair2/F1AP/f1ap_common.c
index 03fc6cc527f899862af203bd35978f72dea93d04..2e8d6073a8671bd5082305c570c97b8ea4198ad8 100644
--- a/openair2/F1AP/f1ap_common.c
+++ b/openair2/F1AP/f1ap_common.c
@@ -49,10 +49,13 @@ f1ap_cudu_inst_t *getCxt(instance_t instanceP)
   return f1_inst[instanceP];
 }
 
-void createF1inst(instance_t instanceP, f1ap_setup_req_t *req)
+void createF1inst(instance_t instanceP, f1ap_setup_req_t *req, f1ap_net_config_t *nc)
 {
-  AssertFatal(f1_inst[instanceP] == NULL, "Double call to F1 DU init\n");
-  f1_inst[instanceP] = (f1ap_cudu_inst_t *)calloc(1, sizeof(f1ap_cudu_inst_t));
-  if (req)
-    memcpy(&f1_inst[instanceP]->setupReq, req, sizeof(f1ap_setup_req_t));
+  DevAssert(instanceP == 0);
+  DevAssert(req != NULL);
+  AssertFatal(f1_inst[0] == NULL, "Double call to F1 DU init\n");
+  f1_inst[0] = calloc(1, sizeof(f1ap_cudu_inst_t));
+  AssertFatal(f1_inst[0] != NULL, "out of memory\n");
+  f1_inst[0]->setupReq = *req;
+  f1_inst[0]->net_config = *nc;
 }
diff --git a/openair2/F1AP/f1ap_common.h b/openair2/F1AP/f1ap_common.h
index c3f0a402b280197ba0a793eea960957d52408639..d91ee3a0c06d5d9a222e7e719400b258451d8709 100644
--- a/openair2/F1AP/f1ap_common.h
+++ b/openair2/F1AP/f1ap_common.h
@@ -406,8 +406,16 @@ typedef struct f1ap_cudu_ue_inst_s {
 
 typedef struct f1ap_cudu_inst_s {
   f1ap_setup_req_t setupReq;
+
+  /* The eNB IP address to bind */
+  f1ap_net_config_t net_config;
+
+  /* SCTP information */
+  int32_t assoc_id;
   uint16_t sctp_in_streams;
   uint16_t sctp_out_streams;
+
+  /* GTP instance used by F1 */
   instance_t gtpInst;
   uint64_t gNB_DU_id;
   uint16_t num_ues;
@@ -420,7 +428,7 @@ uint8_t F1AP_get_next_transaction_identifier(instance_t mod_idP, instance_t cu_m
 
 f1ap_cudu_inst_t *getCxt(instance_t instanceP);
 
-void createF1inst(instance_t instanceP, f1ap_setup_req_t *req);
+void createF1inst(instance_t instanceP, f1ap_setup_req_t *req, f1ap_net_config_t *nc);
 
 //lts: C struct type is not homogeneous, so we need macros instead of functions
 #define addnRCGI(nRCGi, servedCelL) \
diff --git a/openair2/F1AP/f1ap_cu_task.c b/openair2/F1AP/f1ap_cu_task.c
index d3eb4ec0c717c24d8c87b16b0ab88455d902d51c..0003146d445156145fa8f02f116d565eda9b4f9d 100644
--- a/openair2/F1AP/f1ap_cu_task.c
+++ b/openair2/F1AP/f1ap_cu_task.c
@@ -48,11 +48,12 @@ static instance_t cu_task_create_gtpu_instance(eth_params_t *IPaddrs) {
   return gtpv1Init(tmp);
 }
 
-static void cu_task_handle_sctp_association_ind(instance_t instance, sctp_new_association_ind_t *sctp_new_association_ind,
-    eth_params_t *IPaddrs) {
-  createF1inst(instance, NULL);
+static void cu_task_handle_sctp_association_ind(instance_t instance,
+                                                sctp_new_association_ind_t *sctp_new_association_ind,
+                                                eth_params_t *IPaddrs)
+{
   // save the assoc id
-  f1ap_setup_req_t *f1ap_cu_data = &getCxt(instance)->setupReq;
+  f1ap_cudu_inst_t *f1ap_cu_data = getCxt(instance);
   f1ap_cu_data->assoc_id         = sctp_new_association_ind->assoc_id;
   f1ap_cu_data->sctp_in_streams  = sctp_new_association_ind->in_streams;
   f1ap_cu_data->sctp_out_streams = sctp_new_association_ind->out_streams;
diff --git a/openair2/F1AP/f1ap_du_task.c b/openair2/F1AP/f1ap_du_task.c
index 020d03794b7ad77871732b3e60e326e9dda8a6a3..8ce88a44f8414ca795090f5950a17d937dacd9ef 100644
--- a/openair2/F1AP/f1ap_du_task.c
+++ b/openair2/F1AP/f1ap_du_task.c
@@ -40,8 +40,9 @@
 //Fixme: Uniq dirty DU instance, by global var, datamodel need better management
 instance_t DUuniqInstance=0;
 
-void du_task_send_sctp_association_req(instance_t instance, f1ap_setup_req_t *f1ap_setup_req) {
-  DevAssert(f1ap_setup_req != NULL);
+void du_task_send_sctp_association_req(instance_t instance, f1ap_net_config_t *nc)
+{
+  DevAssert(nc != 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, 0, SCTP_NEW_ASSOCIATION_REQ);
@@ -49,19 +50,13 @@ void du_task_send_sctp_association_req(instance_t instance, f1ap_setup_req_t *f1
   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;
+  sctp_new_association_req_p->in_streams = 2; //du_inst->sctp_in_streams;
+  sctp_new_association_req_p->out_streams = 2; //du_inst->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));
+  memcpy(&sctp_new_association_req_p->remote_address, &nc->CU_f1_ip_address, sizeof(nc->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));
-  //printf("sib itti message %s\n", f1ap_setup_req_t->sib1[0]);
-  //printf("nr_cellid : %llx (%lld)",f1ap_setup_req->nr_cellid[0],f1ap_setup_req->nr_cellid[0]);
-  //du_f1ap_register_to_sctp
+  memcpy(&sctp_new_association_req_p->local_address, &nc->DU_f1_ip_address, sizeof(nc->DU_f1_ip_address));
+  // du_f1ap_register_to_sctp
   itti_send_msg_to_task(TASK_SCTP, instance, message_p);
 }
 
@@ -78,12 +73,12 @@ void du_task_handle_sctp_association_resp(instance_t instance, sctp_new_associat
   }
 
   // save the assoc id
-  f1ap_setup_req_t *f1ap_du_data = &getCxt(instance)->setupReq;
+  f1ap_cudu_inst_t *f1ap_du_data = getCxt(instance);
   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;
   /* setup parameters for F1U and start the server */
-  DU_send_F1_SETUP_REQUEST(instance, f1ap_du_data);
+  DU_send_F1_SETUP_REQUEST(instance, &f1ap_du_data->setupReq);
 }
 
 void du_task_handle_sctp_data_ind(instance_t instance, sctp_data_ind_t *sctp_data_ind) {
@@ -108,14 +103,19 @@ void *F1AP_DU_task(void *arg) {
     LOG_D(F1AP, "DU Task Received %s for instance %ld\n",
           ITTI_MSG_NAME(msg),myInstance);
     switch (ITTI_MSG_ID(msg)) {
-      case F1AP_SETUP_REQ: {
+      case F1AP_SETUP_REQ:
+        AssertFatal(false, "the F1AP_SETUP_REQ should not be received; use the F1AP_DU_REGISTER_REQ instead\n");
+        break;
+
+      case F1AP_DU_REGISTER_REQ: {
         // this is not a true F1 message, but rather an ITTI message sent by gnb_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
-        f1ap_setup_req_t *msgSetup = &F1AP_SETUP_REQ(msg);
-        createF1inst(myInstance, msgSetup);
-        du_task_send_sctp_association_req(myInstance, msgSetup);
+        f1ap_setup_req_t *msgSetup = &F1AP_DU_REGISTER_REQ(msg).setup_req;
+        f1ap_net_config_t *nc = &F1AP_DU_REGISTER_REQ(msg).net_config;
+        createF1inst(myInstance, msgSetup, nc);
+        du_task_send_sctp_association_req(myInstance, nc);
       } break;
 
       case F1AP_GNB_CU_CONFIGURATION_UPDATE_ACKNOWLEDGE:
diff --git a/openair2/F1AP/f1ap_du_task.h b/openair2/F1AP/f1ap_du_task.h
index 2d5195baedea362bef3a1a68150860f5d2a27560..8ce8aacab6237ebacd7d56cbd4e463ea0d786735 100644
--- a/openair2/F1AP/f1ap_du_task.h
+++ b/openair2/F1AP/f1ap_du_task.h
@@ -22,7 +22,8 @@
 #ifndef F1AP_DU_TASK_H_
 #define F1AP_DU_TASK_H_
 
-void du_task_send_sctp_association_req(instance_t instance, f1ap_setup_req_t *f1ap_setup_req);
+struct f1ap_net_config_t;
+void du_task_send_sctp_association_req(instance_t instance, struct f1ap_net_config_t *du_inst);
 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(instance_t instance, sctp_data_ind_t *sctp_data_ind);
 void *F1AP_DU_task(void *arg);
diff --git a/openair2/F1AP/f1ap_du_ue_context_management.c b/openair2/F1AP/f1ap_du_ue_context_management.c
index a99e2eb41886df527bb019cb1bf7ed5cde897bcb..c9cb5ed809836d1d4c62aa2e1a57bee8c17ecc6b 100644
--- a/openair2/F1AP/f1ap_du_ue_context_management.c
+++ b/openair2/F1AP/f1ap_du_ue_context_management.c
@@ -150,7 +150,7 @@ int DU_handle_UE_CONTEXT_SETUP_REQUEST(instance_t       instance,
       BIT_STRING_TO_TRANSPORT_LAYER_ADDRESS_IPv4(&ul_up_tnl0->transportLayerAddress, drb_p->up_ul_tnl[0].tl_address);
       OCTET_STRING_TO_UINT32(&ul_up_tnl0->gTP_TEID, drb_p->up_ul_tnl[0].teid);
       // 3GPP assumes GTP-U is on port 2152, but OAI is configurable
-      drb_p->up_ul_tnl[0].port = getCxt(instance)->setupReq.CUport;
+      drb_p->up_ul_tnl[0].port = getCxt(instance)->net_config.CUport;
 
       switch (drbs_tobesetup_item_p->rLCMode) {
         case F1AP_RLCMode_rlc_am:
@@ -332,7 +332,7 @@ int DU_send_UE_CONTEXT_SETUP_RESPONSE(instance_t instance, f1ap_ue_context_setup
         asn1cCalloc(dLUPTNLInformation_ToBeSetup_Item->dLUPTNLInformation.choice.gTPTunnel,gTPTunnel);
         /* transportLayerAddress */
         struct sockaddr_in addr= {0};
-        inet_pton(AF_INET, getCxt(instance)->setupReq.DU_f1_ip_address.ipv4_address, &addr.sin_addr.s_addr);
+        inet_pton(AF_INET, getCxt(instance)->net_config.DU_f1_ip_address.ipv4_address, &addr.sin_addr.s_addr);
         TRANSPORT_LAYER_ADDRESS_IPv4_TO_BIT_STRING(addr.sin_addr.s_addr,
             &gTPTunnel->transportLayerAddress);
         /* gTP_TEID */
@@ -458,7 +458,9 @@ int DU_send_UE_CONTEXT_SETUP_RESPONSE(instance_t instance, f1ap_ue_context_setup
       F1AP_SCell_FailedtoSetup_Item_t *sCell_FailedtoSetup_item=
         &sCell_FailedtoSetup_item_ies->value.choice.SCell_FailedtoSetup_Item;
       /* sCell_ID */
-      addnRCGI(sCell_FailedtoSetup_item->sCell_ID, getCxt(instance)->setupReq.cell+i);
+      AssertFatal(false, "handle correct CellID\n");
+      cellIDs_t cellID = {0};
+      addnRCGI(sCell_FailedtoSetup_item->sCell_ID, &cellID);
       /* cause */
       asn1cCalloc(sCell_FailedtoSetup_item->cause, tmp);
       // dummy value
@@ -848,7 +850,7 @@ int DU_handle_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, uint32_t asso
       BIT_STRING_TO_TRANSPORT_LAYER_ADDRESS_IPv4(&ul_up_tnl0->transportLayerAddress, drb_p->up_ul_tnl[0].tl_address);
       OCTET_STRING_TO_UINT32(&ul_up_tnl0->gTP_TEID, drb_p->up_ul_tnl[0].teid);
        // 3GPP assumes GTP-U is on port 2152, but OAI is configurable
-      drb_p->up_ul_tnl[0].port = getCxt(instance)->setupReq.CUport;
+      drb_p->up_ul_tnl[0].port = getCxt(instance)->net_config.CUport;
 
       extern instance_t DUuniqInstance;
       if (DUuniqInstance == 0) {
@@ -861,9 +863,9 @@ int DU_handle_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, uint32_t asso
                  (drb_p->up_ul_tnl[0].tl_address >> 16) & 0xff,
                  (drb_p->up_ul_tnl[0].tl_address >> 24) & 0xff);
         getCxt(instance)->gtpInst = du_create_gtpu_instance_to_cu(gtp_tunnel_ip_address,
-                                                                  getCxt(instance)->setupReq.CUport,
-                                                                  getCxt(instance)->setupReq.DU_f1_ip_address.ipv4_address,
-                                                                  getCxt(instance)->setupReq.DUport);
+                                                                  getCxt(instance)->net_config.CUport,
+                                                                  getCxt(instance)->net_config.DU_f1_ip_address.ipv4_address,
+                                                                  getCxt(instance)->net_config.DUport);
         AssertFatal(getCxt(instance)->gtpInst > 0, "Failed to create CU F1-U UDP listener");
         // Fixme: fully inconsistent instances management
         // dirty global var is a bad fix
@@ -1043,7 +1045,7 @@ int DU_send_UE_CONTEXT_MODIFICATION_RESPONSE(instance_t instance, f1ap_ue_contex
         asn1cCalloc(dLUPTNLInformation_ToBeSetup_Item->dLUPTNLInformation.choice.gTPTunnel,gTPTunnel);
         /* transportLayerAddress */
         struct sockaddr_in addr= {0};
-        inet_pton(AF_INET, getCxt(instance)->setupReq.DU_f1_ip_address.ipv4_address, &addr.sin_addr.s_addr);
+        inet_pton(AF_INET, getCxt(instance)->net_config.DU_f1_ip_address.ipv4_address, &addr.sin_addr.s_addr);
         TRANSPORT_LAYER_ADDRESS_IPv4_TO_BIT_STRING(addr.sin_addr.s_addr,
           &gTPTunnel->transportLayerAddress);
         /* gTP_TEID */
@@ -1081,7 +1083,7 @@ int DU_send_UE_CONTEXT_MODIFICATION_RESPONSE(instance_t instance, f1ap_ue_contex
         asn1cCalloc(dLUPTNLInformation_ToBeSetup_Item->dLUPTNLInformation.choice.gTPTunnel, gTPTunnel);
         /* transportLayerAddress */
         struct sockaddr_in addr= {0};
-        inet_pton(AF_INET, getCxt(instance)->setupReq.DU_f1_ip_address.ipv4_address, &addr.sin_addr.s_addr);
+        inet_pton(AF_INET, getCxt(instance)->net_config.DU_f1_ip_address.ipv4_address, &addr.sin_addr.s_addr);
         TRANSPORT_LAYER_ADDRESS_IPv4_TO_BIT_STRING(addr.sin_addr.s_addr, &gTPTunnel->transportLayerAddress);
         /* gTP_TEID */
         INT32_TO_OCTET_STRING(resp->drbs_to_be_modified[i].up_dl_tnl[j].teid, &gTPTunnel->gTP_TEID);
diff --git a/openair2/F1AP/f1ap_itti_messaging.c b/openair2/F1AP/f1ap_itti_messaging.c
index eae58e474394e99b32477e75627a069cf87e104a..d4e112d1d5e811520585f15537aa866a2a0e8b46 100644
--- a/openair2/F1AP/f1ap_itti_messaging.c
+++ b/openair2/F1AP/f1ap_itti_messaging.c
@@ -28,7 +28,7 @@ void f1ap_itti_send_sctp_data_req(instance_t instance, uint8_t *buffer, uint32_t
   sctp_data_req_t *sctp_data_req;
   message_p = itti_alloc_new_message(TASK_CU_F1, 0, SCTP_DATA_REQ);
   sctp_data_req = &message_p->ittiMsg.sctp_data_req;
-  sctp_data_req->assoc_id = getCxt(instance)->setupReq.assoc_id;
+  sctp_data_req->assoc_id = getCxt(instance)->assoc_id;
   sctp_data_req->buffer        = buffer;
   sctp_data_req->buffer_length = buffer_length;
   sctp_data_req->stream = 0;
@@ -42,7 +42,7 @@ void f1ap_itti_send_sctp_close_association(instance_t instance)
   sctp_close_association_t *sctp_close_association_p = NULL;
   message_p = itti_alloc_new_message(TASK_S1AP, 0, SCTP_CLOSE_ASSOCIATION);
   sctp_close_association_p = &message_p->ittiMsg.sctp_close_association;
-  sctp_close_association_p->assoc_id = getCxt(instance)->setupReq.assoc_id;
+  sctp_close_association_p->assoc_id = getCxt(instance)->assoc_id;
   itti_send_msg_to_task(TASK_SCTP, instance, message_p);
 }
 
diff --git a/openair2/GNB_APP/gnb_app.c b/openair2/GNB_APP/gnb_app.c
index 337f907a20698bac71d83472b1e198b5d4af392c..136662441438811b0ce8339042a6899b19622c81 100644
--- a/openair2/GNB_APP/gnb_app.c
+++ b/openair2/GNB_APP/gnb_app.c
@@ -181,7 +181,7 @@ void *gNB_app_task(void *args_p)
       }
       // configure F1AP here for F1C
       LOG_I(GNB_APP,"ngran_gNB_DU: Allocating ITTI message for F1AP_SETUP_REQ\n");
-      msg_p = itti_alloc_new_message (TASK_GNB_APP, 0, F1AP_SETUP_REQ);
+      msg_p = itti_alloc_new_message (TASK_GNB_APP, 0, F1AP_DU_REGISTER_REQ);
       RCconfig_NR_DU_F1(msg_p, 0);
 
       itti_send_msg_to_task (TASK_DU_F1, GNB_MODULE_ID_TO_INSTANCE(0), msg_p);
diff --git a/openair2/GNB_APP/gnb_config.c b/openair2/GNB_APP/gnb_config.c
index 1e924ed725f0f7243c5b4a5ebf353cb12da83cf0..7af5cd0c39e273db34e460e0afcbcf7e1f240d60 100644
--- a/openair2/GNB_APP/gnb_config.c
+++ b/openair2/GNB_APP/gnb_config.c
@@ -47,6 +47,7 @@
 #include "sctp_eNB_task.h"
 #include "sctp_default_values.h"
 #include "F1AP_CauseRadioNetwork.h"
+#include "f1ap_common.h"
 // #include "SystemInformationBlockType2.h"
 // #include "LAYER2/MAC/extern.h"
 // #include "LAYER2/MAC/proto.h"
@@ -1881,6 +1882,32 @@ int RCconfig_NR_X2(MessageDef *msg_p, uint32_t i) {
   return 0;
 }
 
+static f1ap_net_config_t read_DU_IP_config(const eth_params_t* f1_params)
+{
+  f1ap_net_config_t nc = {0};
+
+  nc.CU_f1_ip_address.ipv6 = 0;
+  nc.CU_f1_ip_address.ipv4 = 1;
+  strcpy(nc.CU_f1_ip_address.ipv4_address, f1_params->remote_addr);
+  nc.CUport = f1_params->remote_portd;
+  LOG_I(GNB_APP,
+        "FIAP: CU_ip4_address in DU %p, strlen %d\n",
+        nc.CU_f1_ip_address.ipv4_address,
+        (int)strlen(f1_params->remote_addr));
+
+  nc.DU_f1_ip_address.ipv6 = 0;
+  nc.DU_f1_ip_address.ipv4 = 1;
+  strcpy(nc.DU_f1_ip_address.ipv4_address, f1_params->my_addr);
+  nc.DUport = f1_params->my_portd;
+  LOG_I(GNB_APP,
+        "FIAP: DU_ip4_address in DU %p, strlen %ld\n",
+        nc.DU_f1_ip_address.ipv4_address,
+        strlen(f1_params->my_addr));
+
+  // sctp_in_streams/sctp_out_streams are given by SCTP layer
+  return nc;
+}
+
 int RCconfig_NR_DU_F1(MessageDef *msg_p, uint32_t i) {
   int k;
   paramdef_t GNBSParams[] = GNBSPARAMS_DESC;
@@ -1896,7 +1923,7 @@ int RCconfig_NR_DU_F1(MessageDef *msg_p, uint32_t i) {
     config_getlist( &GNBParamList,GNBParams,sizeof(GNBParams)/sizeof(paramdef_t),NULL);
     AssertFatal(GNBParamList.paramarray[i][GNB_GNB_ID_IDX].uptr != NULL,
                 "gNB id %u is not defined in configuration file\n",i);
-    f1ap_setup_req_t * f1Setup=&F1AP_SETUP_REQ(msg_p);
+    f1ap_setup_req_t *f1Setup = &F1AP_DU_REGISTER_REQ(msg_p).setup_req;
     f1Setup->num_cells_available = 0;
 
     for (k=0; k <num_gnbs ; k++) {
@@ -1912,7 +1939,6 @@ int RCconfig_NR_DU_F1(MessageDef *msg_p, uint32_t i) {
           PLMNParams[I].chkPptr = &(config_check_PLMNParams[I]);
 
         config_getlist(&PLMNParamList, PLMNParams, sizeof(PLMNParams)/sizeof(paramdef_t), aprefix);
-        paramdef_t SCTPParams[]  = SCTPPARAMS_DESC;
         f1Setup->num_cells_available++;
         f1Setup->gNB_DU_id        = *(GNBParamList.paramarray[0][GNB_GNB_ID_IDX].uptr);
         LOG_I(GNB_APP,"F1AP: gNB_DU_id[%d] %ld\n",k,f1Setup->gNB_DU_id);
@@ -1933,26 +1959,9 @@ int RCconfig_NR_DU_F1(MessageDef *msg_p, uint32_t i) {
         f1Setup->cell[k].nr_cellid = (uint64_t)*(GNBParamList.paramarray[i][GNB_NRCELLID_IDX].u64ptr);
         LOG_I(GNB_APP,"F1AP: nr_cellid[%d] %ld\n",k,f1Setup->cell[k].nr_cellid);
         LOG_I(GNB_APP,"F1AP: CU_ip4_address in DU %s\n",RC.nrmac[k]->eth_params_n.remote_addr);
-        LOG_I(GNB_APP,"FIAP: CU_ip4_address in DU %p, strlen %d\n",f1Setup->CU_f1_ip_address.ipv4_address,(int)strlen(RC.nrmac[k]->eth_params_n.remote_addr));
-        f1Setup->CU_f1_ip_address.ipv6 = 0;
-        f1Setup->CU_f1_ip_address.ipv4 = 1;
-        //strcpy(f1Setup->CU_f1_ip_address.ipv6_address, "");
-        strcpy(f1Setup->CU_f1_ip_address.ipv4_address, RC.nrmac[k]->eth_params_n.remote_addr);
-        LOG_I(GNB_APP,"F1AP: DU_ip4_address in DU %s\n",RC.nrmac[k]->eth_params_n.my_addr);
-        LOG_I(GNB_APP,"FIAP: DU_ip4_address in DU %p, strlen %ld\n",
-	      f1Setup->DU_f1_ip_address.ipv4_address,
-	      strlen(RC.nrmac[k]->eth_params_n.my_addr));
-        f1Setup->DU_f1_ip_address.ipv6 = 0;
-        f1Setup->DU_f1_ip_address.ipv4 = 1;
-        //strcpy(f1Setup->DU_f1_ip_address.ipv6_address, "");
-        strcpy(f1Setup->DU_f1_ip_address.ipv4_address, RC.nrmac[k]->eth_params_n.my_addr);
-	f1Setup->DUport= RC.nrmac[k]->eth_params_n.my_portd;
-	f1Setup->CUport= RC.nrmac[k]->eth_params_n.remote_portd;
-        //strcpy(f1Setup->CU_ip_address[l].ipv6_address,*(F1ParamList.paramarray[l][ENB_CU_IPV6_ADDRESS_IDX].strptr));
-        sprintf(aprefix,"%s.[%i].%s",GNB_CONFIG_STRING_GNB_LIST,k,GNB_CONFIG_STRING_SCTP_CONFIG);
-        config_get(SCTPParams,sizeof(SCTPParams)/sizeof(paramdef_t),aprefix);
-        f1Setup->sctp_in_streams = (uint16_t)*(SCTPParams[GNB_SCTP_INSTREAMS_IDX].uptr);
-        f1Setup->sctp_out_streams = (uint16_t)*(SCTPParams[GNB_SCTP_OUTSTREAMS_IDX].uptr);
+
+        F1AP_DU_REGISTER_REQ(msg_p).net_config = read_DU_IP_config(&RC.nrmac[k]->eth_params_n);
+
         gNB_RRC_INST *rrc = RC.nrrrc[k];
         // wait until RRC cell information is configured
         int cell_info_configured = 0;