Temporary dirty fix to not block SRB1 traffic once SRB2 is added

-This function will change completely after update with develop

openair2/COMMON/f1ap_messages_def.h

@@ -46,6 +46,8 @@ MESSAGE_DEF(F1AP_DL_RRC_MESSAGE              , MESSAGE_PRIORITY_MED, f1ap_dl_rrc
 //MESSAGE_DEF(F1AP_INITIAL_CONTEXT_SETUP_REQ , MESSAGE_PRIORITY_MED, f1ap_initial_context_setup_req_t , f1ap_initial_context_setup_req )
 MESSAGE_DEF(F1AP_UE_CONTEXT_SETUP_REQ,  MESSAGE_PRIORITY_MED, f1ap_ue_context_setup_t, f1ap_ue_context_setup_req)
 MESSAGE_DEF(F1AP_UE_CONTEXT_SETUP_RESP, MESSAGE_PRIORITY_MED, f1ap_ue_context_setup_t, f1ap_ue_context_setup_resp)
+MESSAGE_DEF(F1AP_UE_CONTEXT_MODIFICATION_REQ,  MESSAGE_PRIORITY_MED, f1ap_ue_context_setup_t, f1ap_ue_context_modification_req)
+MESSAGE_DEF(F1AP_UE_CONTEXT_MODIFICATION_RESP, MESSAGE_PRIORITY_MED, f1ap_ue_context_setup_t, f1ap_ue_context_modification_resp)
 
 
 

openair2/COMMON/f1ap_messages_types.h

@@ -39,15 +39,15 @@
 #define F1AP_INITIAL_UL_RRC_MESSAGE(mSGpTR)        (mSGpTR)->ittiMsg.f1ap_initial_ul_rrc_message
 #define F1AP_UL_RRC_MESSAGE(mSGpTR)                (mSGpTR)->ittiMsg.f1ap_ul_rrc_message
 #define F1AP_UE_CONTEXT_SETUP_REQ(mSGpTR)          (mSGpTR)->ittiMsg.f1ap_ue_context_setup_req
-#define F1AP_UE_CONTEXT_SETUP_RESP(mSGpTR)          (mSGpTR)->ittiMsg.f1ap_ue_context_setup_resp
+#define F1AP_UE_CONTEXT_SETUP_RESP(mSGpTR)         (mSGpTR)->ittiMsg.f1ap_ue_context_setup_resp
 #define F1AP_UE_CONTEXT_RELEASE_RESP(mSGpTR)       (mSGpTR)->ittiMsg.f1ap_ue_context_release_resp
+#define F1AP_UE_CONTEXT_MODIFICATION_REQ(mSGpTR)   (mSGpTR)->ittiMsg.f1ap_ue_context_modification_req
 #define F1AP_UE_CONTEXT_MODIFICATION_RESP(mSGpTR)  (mSGpTR)->ittiMsg.f1ap_ue_context_modification_resp
 #define F1AP_UE_CONTEXT_MODIFICATION_FAIL(mSGpTR)  (mSGpTR)->ittiMsg.f1ap_ue_context_modification_fail
 
 #define F1AP_DL_RRC_MESSAGE(mSGpTR)                (mSGpTR)->ittiMsg.f1ap_dl_rrc_message
 #define F1AP_UE_CONTEXT_RELEASE_REQ(mSGpTR)        (mSGpTR)->ittiMsg.f1ap_ue_context_release_req
 #define F1AP_UE_CONTEXT_RELEASE_CMD(mSGpTR)        (mSGpTR)->ittiMsg.f1ap_ue_context_release_req
-#define F1AP_UE_CONTEXT_MODIFICATION_REQ(mSGpTR)   (mSGpTR)->ittiMsg.f1ap_ue_context_modification_req
 
 /* Length of the transport layer address string
  * 160 bits / 8 bits by char.
@@ -343,6 +343,26 @@ typedef struct f1ap_rb_failed_to_be_setup_s {
   long           rb_id;
 } f1ap_rb_failed_to_be_setup_t;
 
+typedef struct cu_to_du_rrc_information_s {
+  uint8_t * cG_ConfigInfo;
+  uint8_t   cG_ConfigInfo_length;
+  uint8_t * uE_CapabilityRAT_ContainerList;
+  uint8_t   uE_CapabilityRAT_ContainerList_length;
+  uint8_t * measConfig;
+  uint8_t   measConfig_length;
+}cu_to_du_rrc_information_t;
+
+typedef enum QoS_information_e {
+  NG_RAN_QoS    = 0,
+  EUTRAN_QoS    = 1,
+} QoS_information_t;
+
+typedef enum ReconfigurationCompl_e {
+  RRCreconf_info_not_present = 0,
+  RRCreconf_failure          = 1,
+  RRCreconf_success          = 2,
+} ReconfigurationCompl_t;
+
 typedef struct f1ap_ue_context_setup_s {
   uint32_t gNB_CU_ue_id;    // BK: need to replace by use from rnti
   uint32_t gNB_DU_ue_id;
@@ -355,12 +375,13 @@ typedef struct f1ap_ue_context_setup_s {
   uint8_t servCellIndex;
   uint8_t *cellULConfigured;
   uint32_t servCellId;
-  uint8_t *cu_to_du_rrc_information;
+  cu_to_du_rrc_information_t *cu_to_du_rrc_information;
   uint8_t  cu_to_du_rrc_information_length;
   uint8_t *du_to_cu_rrc_information;
   uint8_t  du_to_cu_rrc_information_length;
   f1ap_drb_to_be_setup_t *drbs_to_be_setup; // BK: need to replace by s1ap_initial_context_setup_req
   uint8_t  drbs_to_be_setup_length;       // BK: need to replace by s1ap_initial_context_setup_req
+  QoS_information_t QoS_information_type;
   uint8_t  drbs_failed_to_be_setup_length;
   f1ap_rb_failed_to_be_setup_t *drbs_failed_to_be_setup;
   f1ap_srb_to_be_setup_t *srbs_to_be_setup;
@@ -368,6 +389,7 @@ typedef struct f1ap_ue_context_setup_s {
   uint8_t  srbs_failed_to_be_setup_length;
   f1ap_rb_failed_to_be_setup_t *srbs_failed_to_be_setup;
   s1ap_initial_context_setup_req_t *s1ap_initial_context_setup_req;
+  ReconfigurationCompl_t ReconfigComplOutcome;
    // coniatner for the rrc_eNB_generate_SecurityModeCommand message
   uint8_t *rrc_container;
   int      rrc_container_length;

openair2/F1AP/f1ap_cu_task.c

@@ -181,6 +181,12 @@ void *F1AP_CU_task(void *arg) {
                                          &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_MODIFICATION_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),

openair2/F1AP/f1ap_cu_ue_context_management.h

@@ -72,7 +72,8 @@ int CU_handle_UE_CONTEXT_RELEASE_COMPLETE(instance_t       instance,
 /*
  * UE Context Modification (gNB-CU initiated)
  */
-int CU_send_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance);
+int CU_send_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance,
+    f1ap_ue_context_setup_t *f1ap_ue_context_modification_req);
 int CU_handle_UE_CONTEXT_MODIFICATION_RESPONSE(instance_t       instance,
     uint32_t         assoc_id,
     uint32_t         stream,

openair2/F1AP/f1ap_decoder.c

@@ -78,6 +78,10 @@ static int f1ap_decode_initiating_message(F1AP_F1AP_PDU_t *pdu) {
     case F1AP_ProcedureCode_id_UEContextSetup:
       LOG_I(F1AP, "%s(): F1AP_ProcedureCode_id_UEContextSetup\n", __func__);
       break;
+    
+    case F1AP_ProcedureCode_id_UEContextModification:
+      LOG_I(F1AP, "%s(): F1AP_ProcedureCode_id_UEContextModification\n", __func__);
+      break;
 
     // case F1AP_ProcedureCode_id_InitialContextSetup:
     //   res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_F1AP_F1AP_PDU, pdu);
@@ -123,6 +127,10 @@ static int f1ap_decode_successful_outcome(F1AP_F1AP_PDU_t *pdu) {
       LOG_I(F1AP, "%s(): F1AP_ProcedureCode_id_UEContextSetup\n", __func__);
       break;
 
+    case F1AP_ProcedureCode_id_UEContextModification:
+      LOG_I(F1AP, "%s(): F1AP_ProcedureCode_id_UEContextModification\n", __func__);
+      break;
+
     default:
       LOG_E(F1AP,"Unknown procedure ID (%d) for successfull outcome message\n",
             (int)pdu->choice.successfulOutcome->procedureCode);

openair2/F1AP/f1ap_default_values.h

@@ -40,7 +40,7 @@
 #define ENB_NAME        "Eurecom ENB"
 #define ENB_NAME_FORMAT (ENB_NAME" %u")
 
-#define F1AP_PORT_NUMBER        (30923)
+#define F1AP_PORT_NUMBER        (38472)
 #define F1AP_SCTP_PPID          (62)
 
 #endif /* F1AP_DEFAULT_VALUES_H_ */

openair2/F1AP/f1ap_du_interface_management.c

@@ -175,6 +175,24 @@ int DU_send_F1_SETUP_REQUEST(instance_t instance) {
     MCC_MNC_TO_PLMNID(cell->mcc, cell->mnc, cell->mnc_digit_length, &servedPLMN_item->pLMN_Identity);
     // // /* - CHOICE NR-MODE-Info */
     F1AP_NR_Mode_Info_t *nR_Mode_Info= &served_cell_information->nR_Mode_Info;
+    //if(0){
+      //F1AP_ProtocolExtensionContainer_154P260_t *p_154P260=calloc(1, sizeof(* p_154P260));
+      F1AP_ProtocolExtensionContainer_154P34_t *p_154P34=calloc(1,sizeof(* p_154P34));
+      servedPLMN_item->iE_Extensions = (struct F1AP_ProtocolExtensionContainer *)p_154P34;
+      asn1cSequenceAdd(p_154P34->list, F1AP_ServedPLMNs_ItemExtIEs_t , served_plmns_itemExtIEs);
+      served_plmns_itemExtIEs->criticality = F1AP_Criticality_ignore;
+      served_plmns_itemExtIEs->id = F1AP_ProtocolIE_ID_id_TAISliceSupportList;
+      served_plmns_itemExtIEs->extensionValue.present = F1AP_ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
+      F1AP_SliceSupportList_t *slice_support_list = &served_plmns_itemExtIEs->extensionValue.choice.SliceSupportList;
+
+      asn1cSequenceAdd(slice_support_list->list, F1AP_SliceSupportItem_t, SliceSupport_item);
+      INT8_TO_OCTET_STRING(1,&SliceSupport_item->sNSSAI.sST);
+      //OCTET_STRING_fromBuf(&SliceSupport_item->sNSSAI.sST, "1", 1);
+      asn1cCalloc(SliceSupport_item->sNSSAI.sD, tmp);
+      INT24_TO_OCTET_STRING(1,tmp);
+      //OCTET_STRING_fromBuf(tmp, "1",1);
+    //}
+    
 
     if (f1ap_req(false, instance)->fdd_flag) { // FDD
       nR_Mode_Info->present = F1AP_NR_Mode_Info_PR_fDD;

openair2/F1AP/f1ap_du_rrc_message_transfer.c

@@ -812,6 +812,13 @@ int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t     instanceP,
                          sdu2P,
                          sdu2_lenP);
   }
+  /* 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_F1SetupRequestIEs__value_PR_TransactionID;
+  ie6->value.choice.TransactionID = F1AP_get_next_transaction_identifier(f1ap_req(false, instanceP)->gNB_DU_id, f1ap_req(false, instanceP)->gNB_DU_id);
 
   /* encode */
   if (f1ap_encode_pdu(&pdu, &buffer, &len) < 0) {

openair2/F1AP/f1ap_du_task.c

@@ -192,6 +192,11 @@ void *F1AP_DU_task(void *arg) {
         DU_send_UE_CONTEXT_SETUP_RESPONSE(myInstance, &F1AP_UE_CONTEXT_SETUP_RESP(msg));
         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,

openair2/F1AP/f1ap_du_ue_context_management.h

@@ -74,7 +74,7 @@ int DU_handle_UE_CONTEXT_MODIFICATION_REQUEST(instance_t       instance,
     uint32_t         assoc_id,
     uint32_t         stream,
     F1AP_F1AP_PDU_t *pdu);
-int DU_send_UE_CONTEXT_MODIFICATION_RESPONSE(instance_t instance);
+int DU_send_UE_CONTEXT_MODIFICATION_RESPONSE(instance_t instance, f1ap_ue_context_setup_t *resp);
 int DU_send_UE_CONTEXT_MODIFICATION_FAILURE(instance_t instance);
 
 

openair2/F1AP/f1ap_handlers.c

@@ -50,7 +50,7 @@ f1ap_message_processing_t f1ap_messages_processing[][3] = {
   { DU_handle_gNB_CU_CONFIGURATION_UPDATE, CU_handle_gNB_CU_CONFIGURATION_UPDATE_ACKNOWLEDGE, CU_handle_gNB_CU_CONFIGURATION_UPDATE_FAILURE }, /* gNBCUConfigurationUpdate */
   { DU_handle_UE_CONTEXT_SETUP_REQUEST, CU_handle_UE_CONTEXT_SETUP_RESPONSE, 0 }, /* UEContextSetup */
   { DU_handle_UE_CONTEXT_RELEASE_COMMAND, CU_handle_UE_CONTEXT_RELEASE_COMPLETE, 0 }, /* UEContextRelease */
-  { 0, 0, 0 }, /* UEContextModification */
+  { DU_handle_UE_CONTEXT_MODIFICATION_REQUEST, CU_handle_UE_CONTEXT_MODIFICATION_RESPONSE, 0 }, /* UEContextModification */
   { 0, 0, 0 }, /* UEContextModificationRequired */
   { 0, 0, 0 }, /* UEMobilityCommand */
   { CU_handle_UE_CONTEXT_RELEASE_REQUEST, 0, 0 }, /* UEContextReleaseRequest */

openair2/GNB_APP/gnb_config.c

@@ -1735,9 +1735,43 @@ int RCconfig_NR_DU_F1(MessageDef *msg_p, uint32_t i) {
         f1Setup->measurement_timing_information[k]             = "0";
         f1Setup->ranac[k]                                      = 0;
         f1Setup->mib[k]                                        = rrc->carrier.MIB;
-        f1Setup->sib1[k]                                       = rrc->carrier.SIB1;
         f1Setup->mib_length[k]                                 = rrc->carrier.sizeof_MIB;
-        f1Setup->sib1_length[k]                                = rrc->carrier.sizeof_SIB1;
+        if(0){
+          f1Setup->sib1[k]                                       = rrc->carrier.SIB1;
+          f1Setup->sib1_length[k]                                = rrc->carrier.sizeof_SIB1;
+        }
+        else{
+        NR_BCCH_DL_SCH_Message_t *bcch_message = NULL;
+
+        asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
+            &asn_DEF_NR_BCCH_DL_SCH_Message,
+            (void **)&bcch_message,
+            (const void *)rrc->carrier.SIB1,
+            rrc->carrier.sizeof_SIB1);
+
+        if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
+          LOG_E(RRC,"SIB1 decode error\n");
+          // free the memory
+          SEQUENCE_free( &asn_DEF_NR_BCCH_DL_SCH_Message, bcch_message, 1 );
+          exit(1);
+        }
+       
+        NR_SIB1_t *bcch_SIB1 = bcch_message->message.choice.c1->choice.systemInformationBlockType1;
+        f1Setup->sib1[k] = calloc(1,rrc->carrier.sizeof_SIB1);
+        asn_enc_rval_t enc_rval = uper_encode_to_buffer(&asn_DEF_NR_SIB1,
+            NULL,
+            (void *)bcch_SIB1,
+            f1Setup->sib1[k],
+            NR_MAX_SIB_LENGTH/8);
+        AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
+            enc_rval.failed_type->name, enc_rval.encoded);
+
+        //if ( LOG_DEBUGFLAG(DEBUG_ASN1) ) {
+          LOG_I(NR_RRC, "SIB1 container to be integrated in F1 Setup request:\n");
+          xer_fprint(stdout, &asn_DEF_NR_SIB1,(void *)bcch_message->message.choice.c1->choice.systemInformationBlockType1 );
+        //}
+        f1Setup->sib1_length[k]                                = (enc_rval.encoded+7)/8;
+        }
         break;
       }
     }

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c

@@ -1388,6 +1388,11 @@ void nr_generate_Msg4(module_id_t module_idP, int CC_id, frame_t frameP, sub_fra
 
   if (ra->Msg4_frame == frameP && ra->Msg4_slot == slotP ) {
 
+    if (nr_mac_rrc_check_RRCSetup(module_idP, ra->rnti) <= 0){
+      ra->Msg4_frame++;
+      return;
+    }
+
     uint8_t time_domain_assignment = 0;
     uint8_t mcsIndex = 0;
 
@@ -1463,7 +1468,7 @@ void nr_generate_Msg4(module_id_t module_idP, int CC_id, frame_t frameP, sub_fra
     int r_pucch = ((CCEIndex<<1)/N_cce)+(delta_PRI<<1);
 
     int alloc = nr_acknack_scheduling(module_idP, UE_id, frameP, slotP, r_pucch);
-    AssertFatal(alloc>=0,"Couldn't find a pucch allocation for ack nack (msg4)\n");
+    AssertFatal(alloc>=0,"%d.%d Couldn't find a pucch allocation for ack nack (msg4), r_pucch %d (CCEindex%d,N_cce%d\n",frameP,slotP,r_pucch,CCEIndex,N_cce);
     NR_sched_pucch_t *pucch = &sched_ctrl->sched_pucch[alloc];
     harq->feedback_slot = pucch->ul_slot;
     harq->feedback_frame = pucch->frame;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_dlsch.c

@@ -395,8 +395,14 @@ void nr_store_dlsch_buffer(module_id_t module_id,
       loop_dcch_dtch = DL_SCH_LCID_DTCH;
     else if ((sched_ctrl->lcid_mask&(1<<1)) > 0 && loop_dcch_dtch == DL_SCH_LCID_DTCH)
       loop_dcch_dtch = DL_SCH_LCID_DCCH;
-    else if ((sched_ctrl->lcid_mask&(1<<2)) > 0 && loop_dcch_dtch == DL_SCH_LCID_DCCH)
-      loop_dcch_dtch = DL_SCH_LCID_DCCH1;
+    /*else if ((sched_ctrl->lcid_mask&(1<<2)) > 0 && loop_dcch_dtch == DL_SCH_LCID_DCCH)
+      loop_dcch_dtch = DL_SCH_LCID_DCCH1;*/
+    else if ((sched_ctrl->lcid_mask&(1<<2)) > 0){ //&& loop_dcch_dtch == DL_SCH_LCID_DCCH
+      if (loop_dcch_dtch == DL_SCH_LCID_DCCH)
+        loop_dcch_dtch = DL_SCH_LCID_DCCH1;
+      else if(loop_dcch_dtch == DL_SCH_LCID_DCCH1)
+        loop_dcch_dtch = DL_SCH_LCID_DCCH;
+    }
 
     const int lcid = loop_dcch_dtch;
     // const int lcid = DL_SCH_LCID_DTCH;
@@ -788,6 +794,10 @@ void nr_schedule_ue_spec(module_id_t module_id,
     return;
 
   /* PREPROCESSOR */
+  //Following commented section condition should be removed before update with develop.
+  /*if(slot!= 1 && slot!=11){
+    return;
+  }*/
   gNB_mac->pre_processor_dl(module_id, frame, slot);
 
   const int CC_id = 0;

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c

@@ -1355,7 +1355,7 @@ int nr_acknack_scheduling(int mod_id,
    * for initialCyclicShift 0 (we assume it always has that one), so other
    * initialCyclicShifts can overlap with ICS 0!*/
   if (pucch_Config==NULL) 
-       return -1;
+       return 0;
   const NR_PUCCH_Resource_t *resource = pucch_Config->resourceToAddModList->list.array[pucch->resource_indicator];
   DevAssert(resource->format.present == NR_PUCCH_Resource__format_PR_format0);
   if (resource->format.choice.format0->initialCyclicShift == 0) {

openair2/RRC/NR/L2_nr_interface.c

@@ -304,6 +304,14 @@ int8_t mac_rrc_nr_data_req(const module_id_t Mod_idP,
 
 }
 
+int8_t nr_mac_rrc_check_RRCSetup(const module_id_t Mod_idP,
+                               const rnti_t      rnti) {
+  struct rrc_gNB_ue_context_s *ue_context_p = rrc_gNB_get_ue_context(RC.nrrrc[Mod_idP], rnti);
+  char payload_size = ue_context_p->ue_context.Srb0.Tx_buffer.payload_size;
+  return payload_size;
+
+}
+
 int8_t nr_mac_rrc_data_ind(const module_id_t     module_idP,
                            const int             CC_id,
                            const frame_t         frameP,

openair2/RRC/NR/MESSAGES/asn1_msg.c

@@ -1090,7 +1090,7 @@ void fill_initial_SpCellConfig(rnti_t rnti,
   SpCellConfig->spCellConfigDedicated->tag_Id=0;
 }
 
-void fill_mastercellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, NR_CellGroupConfig_t *ue_context_mastercellGroup) {
+void fill_mastercellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, NR_CellGroupConfig_t *ue_context_mastercellGroup, uint8_t SRB_config_present, uint8_t DRB_config_present) {
 
   cellGroupConfig->cellGroupId = 0;
   cellGroupConfig->rlc_BearerToReleaseList = NULL;
@@ -1098,86 +1098,97 @@ void fill_mastercellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, NR_CellGr
 
   // RLC Bearer Config
   // TS38.331 9.2.1 Default SRB configurations
-  NR_RLC_BearerConfig_t *rlc_BearerConfig                          = NULL;
-  NR_RLC_Config_t *rlc_Config                                      = NULL;
-  NR_LogicalChannelConfig_t *logicalChannelConfig                  = NULL;
-  long *logicalChannelGroup                                        = NULL;
-  rlc_BearerConfig                                                 = calloc(1, sizeof(NR_RLC_BearerConfig_t));
-  rlc_BearerConfig->logicalChannelIdentity                         = 2;
-  rlc_BearerConfig->servedRadioBearer                              = calloc(1, sizeof(*rlc_BearerConfig->servedRadioBearer));
-  rlc_BearerConfig->servedRadioBearer->present                     = NR_RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
-  rlc_BearerConfig->servedRadioBearer->choice.srb_Identity         = 2;
-  rlc_BearerConfig->reestablishRLC                                 = NULL;
-  rlc_Config                                                       = calloc(1, sizeof(NR_RLC_Config_t));
-  rlc_Config->present                                              = NR_RLC_Config_PR_am;
-  rlc_Config->choice.am                                            = calloc(1, sizeof(*rlc_Config->choice.am));
-  rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength                  = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
-  *(rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength)               = NR_SN_FieldLengthAM_size12;
-  rlc_Config->choice.am->dl_AM_RLC.t_Reassembly                    = NR_T_Reassembly_ms35;
-  rlc_Config->choice.am->dl_AM_RLC.t_StatusProhibit                = NR_T_StatusProhibit_ms0;
-  rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength                  = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
-  *(rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength)               = NR_SN_FieldLengthAM_size12;
-  rlc_Config->choice.am->ul_AM_RLC.t_PollRetransmit                = NR_T_PollRetransmit_ms45;
-  rlc_Config->choice.am->ul_AM_RLC.pollPDU                         = NR_PollPDU_infinity;
-  rlc_Config->choice.am->ul_AM_RLC.pollByte                        = NR_PollByte_infinity;
-  rlc_Config->choice.am->ul_AM_RLC.maxRetxThreshold                = NR_UL_AM_RLC__maxRetxThreshold_t8;
-  rlc_BearerConfig->rlc_Config                                     = rlc_Config;
-  logicalChannelConfig                                             = calloc(1, sizeof(NR_LogicalChannelConfig_t));
-  logicalChannelConfig->ul_SpecificParameters                      = calloc(1, sizeof(*logicalChannelConfig->ul_SpecificParameters));
-  logicalChannelConfig->ul_SpecificParameters->priority            = 3;
-  logicalChannelConfig->ul_SpecificParameters->prioritisedBitRate  = NR_LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_infinity;
-  logicalChannelConfig->ul_SpecificParameters->bucketSizeDuration  = NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms5;
-  logicalChannelGroup                                              = CALLOC(1, sizeof(long));
-  *logicalChannelGroup                                             = 0;
-  logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup = logicalChannelGroup;
-  logicalChannelConfig->ul_SpecificParameters->schedulingRequestID = CALLOC(1, sizeof(*logicalChannelConfig->ul_SpecificParameters->schedulingRequestID));
-  *logicalChannelConfig->ul_SpecificParameters->schedulingRequestID = 0;
-  logicalChannelConfig->ul_SpecificParameters->logicalChannelSR_Mask = 0;
-  logicalChannelConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = 0;
-  rlc_BearerConfig->mac_LogicalChannelConfig                       = logicalChannelConfig;
-  ASN_SEQUENCE_ADD(&cellGroupConfig->rlc_BearerToAddModList->list, rlc_BearerConfig);
-  ASN_SEQUENCE_ADD(&ue_context_mastercellGroup->rlc_BearerToAddModList->list, rlc_BearerConfig);
+  if(SRB_config_present){
+    NR_RLC_BearerConfig_t *rlc_BearerConfig                          = NULL;
+    NR_RLC_Config_t *rlc_Config                                      = NULL;
+    NR_LogicalChannelConfig_t *logicalChannelConfig                  = NULL;
+    long *logicalChannelGroup                                        = NULL;
+    rlc_BearerConfig                                                 = calloc(1, sizeof(NR_RLC_BearerConfig_t));
+    rlc_BearerConfig->logicalChannelIdentity                         = 2;
+    rlc_BearerConfig->servedRadioBearer                              = calloc(1, sizeof(*rlc_BearerConfig->servedRadioBearer));
+    rlc_BearerConfig->servedRadioBearer->present                     = NR_RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
+    rlc_BearerConfig->servedRadioBearer->choice.srb_Identity         = 2;
+    rlc_BearerConfig->reestablishRLC                                 = NULL;
+    rlc_Config                                                       = calloc(1, sizeof(NR_RLC_Config_t));
+    rlc_Config->present                                              = NR_RLC_Config_PR_am;
+    rlc_Config->choice.am                                            = calloc(1, sizeof(*rlc_Config->choice.am));
+    rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength                  = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
+    *(rlc_Config->choice.am->dl_AM_RLC.sn_FieldLength)               = NR_SN_FieldLengthAM_size12;
+    rlc_Config->choice.am->dl_AM_RLC.t_Reassembly                    = NR_T_Reassembly_ms35;
+    rlc_Config->choice.am->dl_AM_RLC.t_StatusProhibit                = NR_T_StatusProhibit_ms0;
+    rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength                  = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
+    *(rlc_Config->choice.am->ul_AM_RLC.sn_FieldLength)               = NR_SN_FieldLengthAM_size12;
+    rlc_Config->choice.am->ul_AM_RLC.t_PollRetransmit                = NR_T_PollRetransmit_ms45;
+    rlc_Config->choice.am->ul_AM_RLC.pollPDU                         = NR_PollPDU_infinity;
+    rlc_Config->choice.am->ul_AM_RLC.pollByte                        = NR_PollByte_infinity;
+    rlc_Config->choice.am->ul_AM_RLC.maxRetxThreshold                = NR_UL_AM_RLC__maxRetxThreshold_t8;
+    rlc_BearerConfig->rlc_Config                                     = rlc_Config;
+    logicalChannelConfig                                             = calloc(1, sizeof(NR_LogicalChannelConfig_t));
+    logicalChannelConfig->ul_SpecificParameters                      = calloc(1, sizeof(*logicalChannelConfig->ul_SpecificParameters));
+    logicalChannelConfig->ul_SpecificParameters->priority            = 3;
+    logicalChannelConfig->ul_SpecificParameters->prioritisedBitRate  = NR_LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_infinity;
+    logicalChannelConfig->ul_SpecificParameters->bucketSizeDuration  = NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms5;
+    logicalChannelGroup                                              = CALLOC(1, sizeof(long));
+    *logicalChannelGroup                                             = 0;
+    logicalChannelConfig->ul_SpecificParameters->logicalChannelGroup = logicalChannelGroup;
+    logicalChannelConfig->ul_SpecificParameters->schedulingRequestID = CALLOC(1, sizeof(*logicalChannelConfig->ul_SpecificParameters->schedulingRequestID));
+    *logicalChannelConfig->ul_SpecificParameters->schedulingRequestID = 0;
+    logicalChannelConfig->ul_SpecificParameters->logicalChannelSR_Mask = 0;
+    logicalChannelConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = 0;
+    rlc_BearerConfig->mac_LogicalChannelConfig                       = logicalChannelConfig;
+    ASN_SEQUENCE_ADD(&cellGroupConfig->rlc_BearerToAddModList->list, rlc_BearerConfig);
+    ASN_SEQUENCE_ADD(&ue_context_mastercellGroup->rlc_BearerToAddModList->list, rlc_BearerConfig);
+  }
 
   // DRB Configuration
-  NR_RLC_BearerConfig_t *rlc_BearerConfig_drb                      = NULL;
-  NR_RLC_Config_t *rlc_Config_drb                                  = NULL;
-  NR_LogicalChannelConfig_t *logicalChannelConfig_drb              = NULL;
-  long *logicalChannelGroup_drb                                    = NULL;
-  rlc_BearerConfig_drb                                             = calloc(1, sizeof(NR_RLC_BearerConfig_t));
-  rlc_BearerConfig_drb->logicalChannelIdentity                     = 4;
-  rlc_BearerConfig_drb->servedRadioBearer                          = calloc(1, sizeof(*rlc_BearerConfig_drb->servedRadioBearer));
-  rlc_BearerConfig_drb->servedRadioBearer->present                 = NR_RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
-  rlc_BearerConfig_drb->servedRadioBearer->choice.drb_Identity     = 1;
-  rlc_BearerConfig_drb->reestablishRLC                             = NULL;
-  rlc_Config_drb                                                   = calloc(1, sizeof(NR_RLC_Config_t));
-  rlc_Config_drb->present                                          = NR_RLC_Config_PR_am;
-  rlc_Config_drb->choice.am                                        = calloc(1, sizeof(*rlc_Config_drb->choice.am));
-  rlc_Config_drb->choice.am->dl_AM_RLC.sn_FieldLength              = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
-  *(rlc_Config_drb->choice.am->dl_AM_RLC.sn_FieldLength)           = NR_SN_FieldLengthAM_size18;
-  rlc_Config_drb->choice.am->dl_AM_RLC.t_Reassembly                = NR_T_Reassembly_ms80;
-  rlc_Config_drb->choice.am->dl_AM_RLC.t_StatusProhibit            = NR_T_StatusProhibit_ms10;
-  rlc_Config_drb->choice.am->ul_AM_RLC.sn_FieldLength              = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
-  *(rlc_Config_drb->choice.am->ul_AM_RLC.sn_FieldLength)           = NR_SN_FieldLengthAM_size18;
-  rlc_Config_drb->choice.am->ul_AM_RLC.t_PollRetransmit            = NR_T_PollRetransmit_ms80;
-  rlc_Config_drb->choice.am->ul_AM_RLC.pollPDU                     = NR_PollPDU_p64;
-  rlc_Config_drb->choice.am->ul_AM_RLC.pollByte                    = NR_PollByte_kB125;
-  rlc_Config_drb->choice.am->ul_AM_RLC.maxRetxThreshold            = NR_UL_AM_RLC__maxRetxThreshold_t4;
-  rlc_BearerConfig_drb->rlc_Config                                 = rlc_Config_drb;
-  logicalChannelConfig_drb                                             = calloc(1, sizeof(NR_LogicalChannelConfig_t));
-  logicalChannelConfig_drb->ul_SpecificParameters                      = calloc(1, sizeof(*logicalChannelConfig_drb->ul_SpecificParameters));
-  logicalChannelConfig_drb->ul_SpecificParameters->priority            = 13;
-  logicalChannelConfig_drb->ul_SpecificParameters->prioritisedBitRate  = NR_LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_kBps8;
-  logicalChannelConfig_drb->ul_SpecificParameters->bucketSizeDuration  = NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms100;
-  logicalChannelGroup_drb                                              = CALLOC(1, sizeof(long));
-  *logicalChannelGroup_drb                                             = 1;
-  logicalChannelConfig_drb->ul_SpecificParameters->logicalChannelGroup = logicalChannelGroup_drb;
-  logicalChannelConfig_drb->ul_SpecificParameters->schedulingRequestID = CALLOC(1, sizeof(*logicalChannelConfig_drb->ul_SpecificParameters->schedulingRequestID));
-  *logicalChannelConfig_drb->ul_SpecificParameters->schedulingRequestID = 0;
-  logicalChannelConfig_drb->ul_SpecificParameters->logicalChannelSR_Mask = 0;
-  logicalChannelConfig_drb->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = 0;
-  rlc_BearerConfig_drb->mac_LogicalChannelConfig                       = logicalChannelConfig_drb;
-  ASN_SEQUENCE_ADD(&cellGroupConfig->rlc_BearerToAddModList->list, rlc_BearerConfig_drb);
-  ASN_SEQUENCE_ADD(&ue_context_mastercellGroup->rlc_BearerToAddModList->list, rlc_BearerConfig_drb);
+  if(DRB_config_present){
+    NR_RLC_BearerConfig_t *rlc_BearerConfig_drb                      = NULL;
+    NR_RLC_Config_t *rlc_Config_drb                                  = NULL;
+    NR_LogicalChannelConfig_t *logicalChannelConfig_drb              = NULL;
+    long *logicalChannelGroup_drb                                    = NULL;
+    rlc_BearerConfig_drb                                             = calloc(1, sizeof(NR_RLC_BearerConfig_t));
+    rlc_BearerConfig_drb->logicalChannelIdentity                     = 4;
+    rlc_BearerConfig_drb->servedRadioBearer                          = calloc(1, sizeof(*rlc_BearerConfig_drb->servedRadioBearer));
+    rlc_BearerConfig_drb->servedRadioBearer->present                 = NR_RLC_BearerConfig__servedRadioBearer_PR_drb_Identity;
+    rlc_BearerConfig_drb->servedRadioBearer->choice.drb_Identity     = 1;
+    rlc_BearerConfig_drb->reestablishRLC                             = NULL;
+    rlc_Config_drb                                                   = calloc(1, sizeof(NR_RLC_Config_t));
+    rlc_Config_drb->present                                          = NR_RLC_Config_PR_am;
+    rlc_Config_drb->choice.am                                        = calloc(1, sizeof(*rlc_Config_drb->choice.am));
+    rlc_Config_drb->choice.am->dl_AM_RLC.sn_FieldLength              = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
+    *(rlc_Config_drb->choice.am->dl_AM_RLC.sn_FieldLength)           = NR_SN_FieldLengthAM_size18;
+    rlc_Config_drb->choice.am->dl_AM_RLC.t_Reassembly                = NR_T_Reassembly_ms80;
+    rlc_Config_drb->choice.am->dl_AM_RLC.t_StatusProhibit            = NR_T_StatusProhibit_ms10;
+    rlc_Config_drb->choice.am->ul_AM_RLC.sn_FieldLength              = calloc(1, sizeof(NR_SN_FieldLengthAM_t));
+    *(rlc_Config_drb->choice.am->ul_AM_RLC.sn_FieldLength)           = NR_SN_FieldLengthAM_size18;
+    rlc_Config_drb->choice.am->ul_AM_RLC.t_PollRetransmit            = NR_T_PollRetransmit_ms80;
+    rlc_Config_drb->choice.am->ul_AM_RLC.pollPDU                     = NR_PollPDU_p64;
+    rlc_Config_drb->choice.am->ul_AM_RLC.pollByte                    = NR_PollByte_kB125;
+    rlc_Config_drb->choice.am->ul_AM_RLC.maxRetxThreshold            = NR_UL_AM_RLC__maxRetxThreshold_t4;
+    rlc_BearerConfig_drb->rlc_Config                                 = rlc_Config_drb;
+    logicalChannelConfig_drb                                             = calloc(1, sizeof(NR_LogicalChannelConfig_t));
+    logicalChannelConfig_drb->ul_SpecificParameters                      = calloc(1, sizeof(*logicalChannelConfig_drb->ul_SpecificParameters));
+    logicalChannelConfig_drb->ul_SpecificParameters->priority            = 13;
+    logicalChannelConfig_drb->ul_SpecificParameters->prioritisedBitRate  = NR_LogicalChannelConfig__ul_SpecificParameters__prioritisedBitRate_kBps8;
+    logicalChannelConfig_drb->ul_SpecificParameters->bucketSizeDuration  = NR_LogicalChannelConfig__ul_SpecificParameters__bucketSizeDuration_ms100;
+    logicalChannelGroup_drb                                              = CALLOC(1, sizeof(long));
+    *logicalChannelGroup_drb                                             = 1;
+    logicalChannelConfig_drb->ul_SpecificParameters->logicalChannelGroup = logicalChannelGroup_drb;
+    logicalChannelConfig_drb->ul_SpecificParameters->schedulingRequestID = CALLOC(1, sizeof(*logicalChannelConfig_drb->ul_SpecificParameters->schedulingRequestID));
+    *logicalChannelConfig_drb->ul_SpecificParameters->schedulingRequestID = 0;
+    logicalChannelConfig_drb->ul_SpecificParameters->logicalChannelSR_Mask = 0;
+    logicalChannelConfig_drb->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = 0;
+    rlc_BearerConfig_drb->mac_LogicalChannelConfig                       = logicalChannelConfig_drb;
+    ASN_SEQUENCE_ADD(&cellGroupConfig->rlc_BearerToAddModList->list, rlc_BearerConfig_drb);
+    ASN_SEQUENCE_ADD(&ue_context_mastercellGroup->rlc_BearerToAddModList->list, rlc_BearerConfig_drb);
+  }
+}
+
+void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, NR_CellGroupConfig_t *ue_context_mastercellGroup){
+  /*Function to be filled with the updates on the cellGroupConfig at the UE context,
+   * upon reception of the NR UE capabilities at the gNB. This cellGroupConfig information
+   * should be communicated to the UE through the first (default) RRC Reconfiguration message*/
+  LOG_I(NR_RRC, "Implementation pending \n");
 }
 
 void fill_initial_cellGroupConfig(rnti_t rnti,

openair2/RRC/NR/MESSAGES/asn1_msg.h

@@ -106,7 +106,9 @@ void fill_initial_cellGroupConfig(rnti_t rnti,
 				  NR_CellGroupConfig_t *cellGroupConfig,
 				  NR_ServingCellConfigCommon_t *scc);
 
-void fill_mastercellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, NR_CellGroupConfig_t *ue_context_mastercellGroup);
+void update_cellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, NR_CellGroupConfig_t *ue_context_mastercellGroup);
+
+void fill_mastercellGroupConfig(NR_CellGroupConfig_t *cellGroupConfig, NR_CellGroupConfig_t *ue_context_mastercellGroup, uint8_t SRB_config_present, uint8_t DRB_config_present);
 
 uint8_t do_RRCSetup(rrc_gNB_ue_context_t         *const ue_context_pP,
                     uint8_t                      *const buffer,

openair2/RRC/NR/nr_rrc_defs.h

@@ -440,7 +440,8 @@ typedef struct {
 
   NR_BCCH_BCH_Message_t                     mib;
   NR_BCCH_BCH_Message_t                    *mib_DU;
-  NR_BCCH_DL_SCH_Message_t                 *siblock1_DU;
+  NR_SIB1_t                                *siblock1_DU;
+  //NR_BCCH_DL_SCH_Message_t                 *siblock1_DU;
   NR_SIB1_t                                *sib1;
   NR_SIB2_t                                *sib2;
   NR_SIB3_t                                *sib3;

openair2/RRC/NR/nr_rrc_proto.h

@@ -170,6 +170,12 @@ nr_rrc_data_req(
   const pdcp_transmission_mode_t modeP
 );
 
+int8_t nr_mac_rrc_check_RRCSetup(
+  const module_id_t Mod_idP,
+  const rnti_t      rnti
+
+);
+
 int
 nr_rrc_mac_remove_ue(module_id_t mod_idP,
                   rnti_t rntiP);
@@ -204,4 +210,5 @@ rrc_gNB_generate_dedicatedRRCReconfiguration_release(
 void 
 rrc_gNB_generate_dedicatedRRCReconfiguration(
     const protocol_ctxt_t     *const ctxt_pP,
-    rrc_gNB_ue_context_t      *ue_context_pP);
+    rrc_gNB_ue_context_t      *ue_context_pP,
+    NR_CellGroupConfig_t      *cell_groupConfig_from_DU);

openair2/RRC/NR/rrc_gNB.c

@@ -257,7 +257,7 @@ static void init_NR_SI(gNB_RRC_INST *rrc, gNB_RrcConfigurationReq *configuration
 
   LOG_I(NR_RRC,"Done init_NR_SI\n");
 
-  if (NODE_IS_MONOLITHIC(rrc->node_type)){
+  if (NODE_IS_MONOLITHIC(rrc->node_type) || NODE_IS_DU(rrc->node_type)){
     rrc_mac_config_req_gNB(rrc->module_id,
 			   rrc->carrier.ssb_SubcarrierOffset,
 			   rrc->carrier.pdsch_AntennaPorts,
@@ -746,7 +746,8 @@ rrc_gNB_process_RRCSetupComplete(
 void 
 rrc_gNB_generate_defaultRRCReconfiguration(
   const protocol_ctxt_t     *const ctxt_pP,
-  rrc_gNB_ue_context_t      *ue_context_pP
+  rrc_gNB_ue_context_t      *ue_context_pP,
+  NR_CellGroupConfig_t      *cellGroupConfig
 )
 //-----------------------------------------------------------------------------
 {
@@ -871,7 +872,7 @@ rrc_gNB_generate_defaultRRCReconfiguration(
                                 NULL,
                                 dedicatedNAS_MessageList,
                                 NULL,
-                                NULL);
+                                cellGroupConfig);
 
   free(ue_context_pP->ue_context.nas_pdu.buffer);
 
@@ -960,7 +961,8 @@ rrc_gNB_generate_defaultRRCReconfiguration(
 void
 rrc_gNB_generate_dedicatedRRCReconfiguration(
     const protocol_ctxt_t     *const ctxt_pP,
-    rrc_gNB_ue_context_t      *ue_context_pP
+    rrc_gNB_ue_context_t      *ue_context_pP,
+    NR_CellGroupConfig_t      *cell_groupConfig_from_DU
 )
 //-----------------------------------------------------------------------------
 {
@@ -980,7 +982,7 @@ rrc_gNB_generate_dedicatedRRCReconfiguration(
   NR_QFI_t                       qfi = 0;
   int                            pdu_sessions_done = 0;
   int i;
-  NR_CellGroupConfig_t *cellGroupConfig;
+  NR_CellGroupConfig_t *cellGroupConfig = NULL;
 
   uint8_t xid = rrc_gNB_get_next_transaction_identifier(ctxt_pP->module_id);
 
@@ -1117,8 +1119,14 @@ rrc_gNB_generate_dedicatedRRCReconfiguration(
   }
 
   memset(buffer, 0, RRC_BUF_SIZE);
-  cellGroupConfig = calloc(1, sizeof(NR_CellGroupConfig_t));
-  fill_mastercellGroupConfig(cellGroupConfig, ue_context_pP->ue_context.masterCellGroup);
+  if(cell_groupConfig_from_DU == NULL){
+    cellGroupConfig = calloc(1, sizeof(NR_CellGroupConfig_t));
+    fill_mastercellGroupConfig(cellGroupConfig, ue_context_pP->ue_context.masterCellGroup,1,1);
+  }
+  else{
+    LOG_I(NR_RRC, "Master cell group originating from the DU \n");
+    cellGroupConfig = cell_groupConfig_from_DU;
+  }
   size = do_RRCReconfiguration(ctxt_pP, buffer,
                                 xid,
                                 *SRB_configList2,
@@ -1347,7 +1355,6 @@ rrc_gNB_process_RRCReconfigurationComplete(
                               NULL,
                               get_softmodem_params()->sa ? ue_context_pP->ue_context.masterCellGroup->rlc_BearerToAddModList : NULL);
   /* Refresh SRBs/DRBs */
-
   if (!NODE_IS_CU(RC.nrrrc[ctxt_pP->module_id]->node_type)) {
     rrc_mac_config_req_gNB(rrc->module_id,
                            rrc->carrier.ssb_SubcarrierOffset,
@@ -1367,7 +1374,7 @@ rrc_gNB_process_RRCReconfigurationComplete(
                                NULL,
                                get_softmodem_params()->sa ? ue_context_pP->ue_context.masterCellGroup->rlc_BearerToAddModList : NULL);
   }
-  else if(SRB_configList!=NULL || DRB_configList!=NULL){
+  /*else if(SRB_configList!=NULL || DRB_configList!=NULL){
     MessageDef *message_p;
     message_p = itti_alloc_new_message (TASK_RRC_GNB, 0, F1AP_UE_CONTEXT_SETUP_REQ);
     f1ap_ue_context_setup_t *req=&F1AP_UE_CONTEXT_SETUP_REQ (message_p);
@@ -1409,7 +1416,7 @@ rrc_gNB_process_RRCReconfigurationComplete(
       LOG_I(RRC, "Send F1AP_UE_CONTEXT_SETUP_REQ with ITTI\n");
     }
     itti_send_msg_to_task (TASK_CU_F1, ctxt_pP->module_id, message_p);
-  }
+  }*/
 #endif
 
   /* Set the SRB active in UE context */
@@ -1508,6 +1515,18 @@ rrc_gNB_process_RRCReconfigurationComplete(
     free(DRB_Release_configList2);
     ue_context_pP->ue_context.DRB_Release_configList2[xid] = NULL;
   }
+  //Temporarily trigger artificially UE context release for the CU case just to be able to test it with OAI UE. To be removed later
+  if(0){
+    if(NODE_IS_CU(RC.nrrrc[ctxt_pP->instance]->node_type)){
+      MessageDef *message_p;
+      message_p = itti_alloc_new_message (TASK_RRC_GNB, 0, F1AP_UE_CONTEXT_RELEASE_CMD);
+      f1ap_ue_context_release_cmd_t *rel_cmd=&F1AP_UE_CONTEXT_RELEASE_CMD (message_p);
+      rel_cmd->rnti = ctxt_pP->rnti;
+      rel_cmd->cause = F1AP_CAUSE_RADIO_NETWORK;
+      rel_cmd->cause_value = 10; // 10 = F1AP_CauseRadioNetwork_normal_release
+      itti_send_msg_to_task(TASK_CU_F1, ctxt_pP->module_id, message_p);
+    }
+  }
 }
 
 //-----------------------------------------------------------------------------
@@ -2690,11 +2709,71 @@ rrc_gNB_decode_dcch(
                                     ul_dcch_msg);
       }
 
-      if (ue_context_p->ue_context.established_pdu_sessions_flag == 1) {
-        rrc_gNB_generate_dedicatedRRCReconfiguration(ctxt_pP, ue_context_p);
-      } else {
-        rrc_gNB_generate_defaultRRCReconfiguration(ctxt_pP, ue_context_p);
+      if(!NODE_IS_CU(RC.nrrrc[ctxt_pP->module_id]->node_type)){
+        if (ue_context_p->ue_context.established_pdu_sessions_flag == 1) {
+          rrc_gNB_generate_dedicatedRRCReconfiguration(ctxt_pP, ue_context_p, NULL);
+        } else {
+          rrc_gNB_generate_defaultRRCReconfiguration(ctxt_pP, ue_context_p, NULL);
+        }
       }
+      else{
+        /*Generate a UE context setup request message towards the DU to provide the UE
+         *capability info and get the updates on master cell group config from the DU*/
+        MessageDef *message_p;
+        message_p = itti_alloc_new_message (TASK_RRC_GNB, 0, F1AP_UE_CONTEXT_SETUP_REQ);
+        f1ap_ue_context_setup_t *req=&F1AP_UE_CONTEXT_SETUP_REQ (message_p);
+        //UE_IDs will be extracted from F1AP layer
+        req->gNB_CU_ue_id     = 0;
+        req->gNB_DU_ue_id = 0;
+        req->rnti             = ue_context_p->ue_context.rnti;
+        req->mcc              = RC.nrrrc[ctxt_pP->module_id]->configuration.mcc[0];
+        req->mnc              = RC.nrrrc[ctxt_pP->module_id]->configuration.mnc[0];
+        req->mnc_digit_length = RC.nrrrc[ctxt_pP->module_id]->configuration.mnc_digit_length[0];
+        req->nr_cellid        = RC.nrrrc[ctxt_pP->module_id]->nr_cellid;
+
+        if (ue_context_p->ue_context.established_pdu_sessions_flag == 1) {
+          /*Instruction towards the DU for SRB2 configuration*/
+          req->srbs_to_be_setup = malloc(1*sizeof(f1ap_srb_to_be_setup_t));
+          req->srbs_to_be_setup_length = 1;
+          f1ap_srb_to_be_setup_t *SRBs=req->srbs_to_be_setup;
+          SRBs[0].srb_id = 2;
+          SRBs[0].lcid = 2;
+
+          /*Instruction towards the DU for DRB configuration and tunnel creation*/
+          gtpv1u_gnb_create_tunnel_req_t  create_tunnel_req;
+          memset(&create_tunnel_req, 0, sizeof(gtpv1u_gnb_create_tunnel_req_t));
+          req->drbs_to_be_setup = malloc(1*sizeof(f1ap_drb_to_be_setup_t));
+          req->drbs_to_be_setup_length = 1;
+          f1ap_drb_to_be_setup_t *DRBs=req->drbs_to_be_setup;
+          LOG_I(RRC, "Length of DRB list:%d \n", req->drbs_to_be_setup_length);
+          DRBs[0].drb_id = 1;
+          DRBs[0].rlc_mode = RLC_MODE_AM;
+          DRBs[0].up_ul_tnl[0].tl_address = inet_addr(RC.nrrrc[ctxt_pP->module_id]->eth_params_s.my_addr);
+          DRBs[0].up_ul_tnl[0].port=RC.nrrrc[ctxt_pP->module_id]->eth_params_s.my_portd;
+          DRBs[0].up_ul_tnl_length = 1;
+          DRBs[0].up_dl_tnl[0].tl_address = inet_addr(RC.nrrrc[ctxt_pP->module_id]->eth_params_s.remote_addr);
+          DRBs[0].up_dl_tnl[0].port=RC.nrrrc[ctxt_pP->module_id]->eth_params_s.remote_portd;
+          DRBs[0].up_dl_tnl_length = 1;
+        }
+        if( ul_dcch_msg->message.choice.c1->choice.ueCapabilityInformation->criticalExtensions.present ==
+                NR_UECapabilityInformation__criticalExtensions_PR_ueCapabilityInformation ) {
+          struct NR_UE_CapabilityRAT_ContainerList  *ue_CapabilityRAT_ContainerList =
+              ul_dcch_msg->message.choice.c1->choice.ueCapabilityInformation->criticalExtensions.choice.ueCapabilityInformation->ue_CapabilityRAT_ContainerList;
+
+          req->cu_to_du_rrc_information = calloc(1,sizeof(cu_to_du_rrc_information_t));
+          req->cu_to_du_rrc_information->uE_CapabilityRAT_ContainerList = calloc(1,1024);
+          asn_enc_rval_t enc_rval = uper_encode_to_buffer(&asn_DEF_NR_UE_CapabilityRAT_ContainerList,
+              NULL,
+              (void *)ue_CapabilityRAT_ContainerList,
+              req->cu_to_du_rrc_information->uE_CapabilityRAT_ContainerList,
+              1024);
+          AssertFatal (enc_rval.encoded > 0, "ASN1 ue_CapabilityRAT_ContainerList encoding failed (%s, %jd)!\n",
+                             enc_rval.failed_type->name, enc_rval.encoded);
+          req->cu_to_du_rrc_information->uE_CapabilityRAT_ContainerList_length = (enc_rval.encoded+7)>>3;
+        }
+        itti_send_msg_to_task (TASK_CU_F1, ctxt_pP->module_id, message_p);
+      }
+
 
       break;
 
@@ -2816,11 +2895,11 @@ void rrc_gNB_process_f1_setup_req(f1ap_setup_req_t *f1_setup_req) {
         memset(mib->message.choice.mib,0,sizeof(struct NR_MIB));
         memcpy(mib->message.choice.mib, mib_DU->message.choice.mib, sizeof(struct NR_MIB));
 
-        rrc->carrier.SIB1 = malloc(f1_setup_req->sib1_length[i]);
+        /*rrc->carrier.SIB1 = malloc(f1_setup_req->sib1_length[i]);
         rrc->carrier.sizeof_SIB1 = f1_setup_req->sib1_length[i];
-        memcpy((void *)rrc->carrier.SIB1,f1_setup_req->sib1[i],f1_setup_req->sib1_length[i]);
+        memcpy((void *)rrc->carrier.SIB1,f1_setup_req->sib1[i],f1_setup_req->sib1_length[i]);*/
         dec_rval = uper_decode_complete(NULL,
-                                        &asn_DEF_NR_BCCH_DL_SCH_Message,
+                                        &asn_DEF_NR_SIB1, //&asn_DEF_NR_BCCH_DL_SCH_Message,
                                         (void **)&rrc->carrier.siblock1_DU,
                                         f1_setup_req->sib1[i],
                                         f1_setup_req->sib1_length[i]);
@@ -2830,12 +2909,18 @@ void rrc_gNB_process_f1_setup_req(f1ap_setup_req_t *f1_setup_req) {
                     dec_rval.consumed );
 
         // Parse message and extract SystemInformationBlockType1 field
-        NR_BCCH_DL_SCH_Message_t *bcch_message = rrc->carrier.siblock1_DU;
+        rrc->carrier.sib1 = rrc->carrier.siblock1_DU;
+        if ( LOG_DEBUGFLAG(DEBUG_ASN1)){
+          LOG_I(NR_RRC, "Printing received SIB1 container inside F1 setup request message:\n");
+          xer_fprint(stdout, &asn_DEF_NR_SIB1,(void *)rrc->carrier.sib1);
+        }
+
+        /*NR_BCCH_DL_SCH_Message_t *bcch_message = rrc->carrier.siblock1_DU;
         AssertFatal(bcch_message->message.present == NR_BCCH_DL_SCH_MessageType_PR_c1,
                     "bcch_message->message.present != NR_BCCH_DL_SCH_MessageType_PR_c1\n");
         AssertFatal(bcch_message->message.choice.c1->present == NR_BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1,
                     "bcch_message->message.choice.c1->present != NR_BCCH_DL_SCH_MessageType__c1_PR_systemInformationBlockType1\n");
-        rrc->carrier.sib1 = bcch_message->message.choice.c1->choice.systemInformationBlockType1;
+        rrc->carrier.sib1 = bcch_message->message.choice.c1->choice.systemInformationBlockType1;*/
         rrc->carrier.physCellId = f1_setup_req->cell[i].nr_pci;
 
 	F1AP_GNB_CU_CONFIGURATION_UPDATE (msg_p2).gNB_CU_name                                = rrc->node_name;
@@ -3164,9 +3249,97 @@ static void rrc_DU_process_ue_context_setup_request(MessageDef *msg_p, const cha
   uint32_t incoming_teid = 0;
 
 
+  if(req->cu_to_du_rrc_information!=NULL){
+    if(req->cu_to_du_rrc_information->uE_CapabilityRAT_ContainerList!=NULL){
+      LOG_I(NR_RRC, "Length of ue_CapabilityRAT_ContainerList is: %d \n", (int) req->cu_to_du_rrc_information->uE_CapabilityRAT_ContainerList_length);
+      struct NR_UE_CapabilityRAT_ContainerList  *ue_CapabilityRAT_ContainerList;
+      asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
+          &asn_DEF_NR_UE_CapabilityRAT_ContainerList,
+          (void **)&ue_CapabilityRAT_ContainerList,
+          (uint8_t *)req->cu_to_du_rrc_information->uE_CapabilityRAT_ContainerList,
+          (int) req->cu_to_du_rrc_information->uE_CapabilityRAT_ContainerList_length);
+
+      if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
+        AssertFatal(1==0,"UE Capability RAT ContainerList decode error\n");
+        // free the memory
+        SEQUENCE_free( &asn_DEF_NR_UE_CapabilityRAT_ContainerList, ue_CapabilityRAT_ContainerList, 1 );
+        return;
+      }
+      /*To fill ue_context.UE_Capability_MRDC, ue_context.UE_Capability_nr ...*/
+      int NR_index = -1;
+      for(int i = 0;i < ue_CapabilityRAT_ContainerList->list.count; i++){
+        if(ue_CapabilityRAT_ContainerList->list.array[i]->rat_Type ==
+          NR_RAT_Type_nr){
+          LOG_I(NR_RRC, "DU received NR_RAT_Type_nr UE capabilities Info through the UE Context Setup Request from the CU \n");
+          if(ue_context_p->ue_context.UE_Capability_nr){
+            ASN_STRUCT_FREE(asn_DEF_NR_UE_NR_Capability,ue_context_p->ue_context.UE_Capability_nr);
+            ue_context_p->ue_context.UE_Capability_nr = 0;
+          }
+
+          dec_rval = uper_decode(NULL,
+                                  &asn_DEF_NR_UE_NR_Capability,
+                                  (void**)&ue_context_p->ue_context.UE_Capability_nr,
+                                  ue_CapabilityRAT_ContainerList->list.array[i]->ue_CapabilityRAT_Container.buf,
+                                  ue_CapabilityRAT_ContainerList->list.array[i]->ue_CapabilityRAT_Container.size,
+                                  0,0);
+          if(LOG_DEBUGFLAG(DEBUG_ASN1)){
+            xer_fprint(stdout,&asn_DEF_NR_UE_NR_Capability,ue_context_p->ue_context.UE_Capability_nr);
+          }
+
+          if((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)){
+            LOG_E(NR_RRC, PROTOCOL_NR_RRC_CTXT_UE_FMT" Failed to decode nr UE capabilities (%zu bytes)\n",
+            PROTOCOL_NR_RRC_CTXT_UE_ARGS(&ctxt),dec_rval.consumed);
+            ASN_STRUCT_FREE(asn_DEF_NR_UE_NR_Capability,ue_context_p->ue_context.UE_Capability_nr);
+            ue_context_p->ue_context.UE_Capability_nr = 0;
+          }
+
+          ue_context_p->ue_context.UE_Capability_size =
+          ue_CapabilityRAT_ContainerList->list.array[i]->ue_CapabilityRAT_Container.size;
+          if(NR_index != -1){
+            LOG_E(NR_RRC,"fatal: more than 1 eutra capability\n");
+            exit(1);
+          }
+          NR_index = i;
+        }
+
+        if(ue_CapabilityRAT_ContainerList->list.array[i]->rat_Type ==
+        NR_RAT_Type_eutra_nr){
+          LOG_I(NR_RRC, "DU received NR_RAT_Type_eutra_nr UE capabilities Info through the UE Context Setup Request from the CU \n");
+          if(ue_context_p->ue_context.UE_Capability_MRDC){
+            ASN_STRUCT_FREE(asn_DEF_NR_UE_MRDC_Capability,ue_context_p->ue_context.UE_Capability_MRDC);
+            ue_context_p->ue_context.UE_Capability_MRDC = 0;
+          }
+          dec_rval = uper_decode(NULL,
+              &asn_DEF_NR_UE_MRDC_Capability,
+              (void**)&ue_context_p->ue_context.UE_Capability_MRDC,
+              ue_CapabilityRAT_ContainerList->list.array[i]->ue_CapabilityRAT_Container.buf,
+              ue_CapabilityRAT_ContainerList->list.array[i]->ue_CapabilityRAT_Container.size,
+              0,0);
+          if(LOG_DEBUGFLAG(DEBUG_ASN1)){
+            xer_fprint(stdout,&asn_DEF_NR_UE_MRDC_Capability,ue_context_p->ue_context.UE_Capability_MRDC);
+          }
+
+          if((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)){
+            LOG_E(NR_RRC,PROTOCOL_NR_RRC_CTXT_FMT" Failed to decode nr UE capabilities (%zu bytes)\n",
+              PROTOCOL_NR_RRC_CTXT_UE_ARGS(&ctxt),dec_rval.consumed);
+            ASN_STRUCT_FREE(asn_DEF_NR_UE_MRDC_Capability,ue_context_p->ue_context.UE_Capability_MRDC);
+            ue_context_p->ue_context.UE_Capability_MRDC = 0;
+          }
+          ue_context_p->ue_context.UE_MRDC_Capability_size =
+          ue_CapabilityRAT_ContainerList->list.array[i]->ue_CapabilityRAT_Container.size;
+        }
+
+        if(ue_CapabilityRAT_ContainerList->list.array[i]->rat_Type ==
+        NR_RAT_Type_eutra){
+          //TODO
+        }
+      }
+    }
+  }
+
   NR_CellGroupConfig_t *cellGroupConfig;
   cellGroupConfig = calloc(1, sizeof(NR_CellGroupConfig_t));
-  fill_mastercellGroupConfig(cellGroupConfig, ue_context_p->ue_context.masterCellGroup);
+  update_cellGroupConfig(cellGroupConfig, ue_context_p->ue_context.masterCellGroup);
 
   /* Configure SRB2 */
   NR_SRB_ToAddMod_t            *SRB2_config          = NULL;
@@ -3215,7 +3388,25 @@ static void rrc_DU_process_ue_context_setup_request(MessageDef *msg_p, const cha
     }
   }
 
+  if(req->srbs_to_be_setup_length>0 || req->drbs_to_be_setup_length>0){
+    fill_mastercellGroupConfig(cellGroupConfig, ue_context_p->ue_context.masterCellGroup,
+      req->srbs_to_be_setup_length>0 ? 1:0,
+      req->drbs_to_be_setup_length>0 ? 1:0);
+  }
+  
   apply_macrlc_config(rrc, ue_context_p, &ctxt);
+  
+  if(req->rrc_container_length > 0){
+    mem_block_t *pdcp_pdu_p = get_free_mem_block(req->rrc_container_length, __func__);
+    memcpy(&pdcp_pdu_p->data[0], req->rrc_container, req->rrc_container_length);
+    du_rlc_data_req(&ctxt, 1, 0x00, 1, 1, 0, req->rrc_container_length, pdcp_pdu_p);
+    LOG_I(F1AP, "Printing RRC Container of UE context setup request: \n");
+    for (int j=0; j<req->rrc_container_length; j++){
+      printf("%02x ", pdcp_pdu_p->data[j]);
+    }
+    printf("\n");
+  }
+
   /* Fill the UE context setup response ITTI message to send to F1AP */
   resp->gNB_CU_ue_id = req->gNB_CU_ue_id;
   resp->rnti = ctxt.rnti;
@@ -3250,17 +3441,151 @@ static void rrc_DU_process_ue_context_setup_request(MessageDef *msg_p, const cha
   else{
     LOG_W(NR_RRC, "No SRB added upon reception of F1 UE Context setup request at the DU\n");
   }
+  /* fixme:
+   * Here we should be encoding the updates on cellgroupconfig. Currently the content of
+   * celGroupConfig is empty because update_cellGroupConfig() function that is previously called is empty.
+   */
   resp->du_to_cu_rrc_information = calloc(1,1024*sizeof(uint8_t));
   asn_enc_rval_t enc_rval = uper_encode_to_buffer(&asn_DEF_NR_CellGroupConfig,
                                 NULL,
                                 (void *)cellGroupConfig,
                                 resp->du_to_cu_rrc_information,
                                 1024);
+  if (enc_rval.encoded == -1) {
+        LOG_E(F1AP,"Could not encode ue_context.masterCellGroup, failed element %s\n",enc_rval.failed_type->name);
+        exit(-1);
+  }
   resp->du_to_cu_rrc_information_length = (enc_rval.encoded+7)>>3;
   free(cellGroupConfig);
   itti_send_msg_to_task (TASK_DU_F1, ctxt.module_id, message_p);
 }
 
+static void rrc_DU_process_ue_context_modification_request(MessageDef *msg_p, const char *msg_name, instance_t instance){
+
+  f1ap_ue_context_setup_t * req=&F1AP_UE_CONTEXT_MODIFICATION_REQ(msg_p);
+  protocol_ctxt_t ctxt;
+  ctxt.rnti      = req->rnti;
+  ctxt.module_id = instance;
+  ctxt.instance  = instance;
+  ctxt.enb_flag  = 1;
+  gNB_RRC_INST *rrc = RC.nrrrc[ctxt.module_id];
+  gNB_MAC_INST *mac = RC.nrmac[ctxt.module_id];
+  struct rrc_gNB_ue_context_s *ue_context_p =
+      rrc_gNB_get_ue_context(rrc, ctxt.rnti);
+  MessageDef *message_p;
+  message_p = itti_alloc_new_message (TASK_RRC_GNB, 0, F1AP_UE_CONTEXT_MODIFICATION_RESP);
+  f1ap_ue_context_setup_t * resp=&F1AP_UE_CONTEXT_MODIFICATION_RESP(message_p);
+  uint32_t incoming_teid = 0;
+  NR_CellGroupConfig_t *cellGroupConfig = NULL;
+
+  /* Configure SRB2 */
+  NR_SRB_ToAddMod_t            *SRB2_config          = NULL;
+  NR_SRB_ToAddModList_t        *SRB_configList       = NULL;
+  uint8_t SRBs_before_new_addition = 0;
+
+  if(req->srbs_to_be_setup_length>0){
+    if(ue_context_p->ue_context.SRB_configList == NULL){
+      LOG_W(NR_RRC, "The SRB list of the UE context is empty before the addition of new SRB at the DU \n");
+      ue_context_p->ue_context.SRB_configList = CALLOC(1, sizeof(*ue_context_p->ue_context.SRB_configList));
+    }
+    SRB_configList = ue_context_p->ue_context.SRB_configList;
+    SRBs_before_new_addition = SRB_configList->list.count;
+    for (int i=0; i<req->srbs_to_be_setup_length; i++){
+      SRB2_config = CALLOC(1, sizeof(*SRB2_config));
+      SRB2_config->srb_Identity = req->srbs_to_be_setup[i].srb_id;
+      ASN_SEQUENCE_ADD(&SRB_configList->list, SRB2_config);
+    }
+  }
+
+  /* Configure DRB */
+  NR_DRB_ToAddMod_t            *DRB_config          = NULL;
+  NR_DRB_ToAddModList_t        *DRB_configList      = NULL;
+  if(req->drbs_to_be_setup_length>0){
+    if(ue_context_p->ue_context.DRB_configList == NULL){
+      ue_context_p->ue_context.DRB_configList = CALLOC(1, sizeof(*ue_context_p->ue_context.DRB_configList));
+    }
+    DRB_configList = ue_context_p->ue_context.DRB_configList;
+    for (int i=0; i<req->drbs_to_be_setup_length; i++){
+      DRB_config = CALLOC(1, sizeof(*DRB_config));
+      DRB_config->drb_Identity = req->drbs_to_be_setup[i].drb_id;
+      ASN_SEQUENCE_ADD(&DRB_configList->list, DRB_config);
+      f1ap_drb_to_be_setup_t drb_p = req->drbs_to_be_setup[i];
+      transport_layer_addr_t addr;
+      memcpy(addr.buffer, &drb_p.up_ul_tnl[0].tl_address, sizeof(drb_p.up_ul_tnl[0].tl_address));
+      addr.length=sizeof(drb_p.up_ul_tnl[0].tl_address)*8;
+      extern instance_t DUuniqInstance;
+      incoming_teid=newGtpuCreateTunnel(DUuniqInstance,
+          req->rnti,
+          drb_p.drb_id,
+          drb_p.drb_id,
+          drb_p.up_ul_tnl[0].teid,
+          addr,
+          2152,
+          DURecvCb);
+    }
+  }
+
+  if(req->srbs_to_be_setup_length>0 || req->drbs_to_be_setup_length>0){
+    cellGroupConfig = calloc(1, sizeof(NR_CellGroupConfig_t));
+    fill_mastercellGroupConfig(cellGroupConfig, ue_context_p->ue_context.masterCellGroup,
+      req->srbs_to_be_setup_length>0 ? 1:0,
+      req->drbs_to_be_setup_length>0 ? 1:0);
+     apply_macrlc_config(rrc, ue_context_p, &ctxt);
+  }
+  if(req->ReconfigComplOutcome == RRCreconf_failure){
+    LOG_W(NR_RRC, "CU reporting RRC Reconfiguration failure \n");
+  }
+  else if(req->ReconfigComplOutcome == RRCreconf_success){
+    LOG_I(NR_RRC, "CU reporting RRC Reconfiguration success \n");
+  }
+
+  /* Fill the UE context setup response ITTI message to send to F1AP */
+  resp->gNB_CU_ue_id = req->gNB_CU_ue_id;
+  resp->rnti = ctxt.rnti;
+  if(DRB_configList){
+    if(DRB_configList->list.count > 0){
+      resp->drbs_to_be_setup = calloc(1,DRB_configList->list.count*sizeof(f1ap_drb_to_be_setup_t));
+      resp->drbs_to_be_setup_length = DRB_configList->list.count;
+      for (int i=0; i<DRB_configList->list.count; i++){
+        resp->drbs_to_be_setup[i].drb_id = DRB_configList->list.array[i]->drb_Identity;
+        resp->drbs_to_be_setup[i].rlc_mode = RLC_MODE_AM;
+        resp->drbs_to_be_setup[i].up_dl_tnl[0].teid = incoming_teid;
+        resp->drbs_to_be_setup[i].up_dl_tnl[0].tl_address = inet_addr(mac->eth_params_n.my_addr);
+        resp->drbs_to_be_setup[i].up_dl_tnl_length = 1;
+      }
+    }
+    else{
+      LOG_W(NR_RRC, "No DRB added upon reception of F1 UE context modification request with a DRB to setup list\n");
+    }
+  }
+  if(SRB_configList){
+    if(SRB_configList->list.count >0 && SRBs_before_new_addition < SRB_configList->list.count){
+      resp->srbs_to_be_setup = calloc(1,req->srbs_to_be_setup_length*sizeof(f1ap_srb_to_be_setup_t));
+      resp->srbs_to_be_setup_length = req->srbs_to_be_setup_length;
+      for (int i=SRBs_before_new_addition; i<SRB_configList->list.count; i++){
+        resp->srbs_to_be_setup[i-SRBs_before_new_addition].srb_id = SRB_configList->list.array[i]->srb_Identity;
+      }
+    }
+    else{
+      LOG_W(NR_RRC, "No SRB added upon reception of F1 UE Context modification request at the DU\n");
+    }
+  }
+  else{
+    LOG_W(NR_RRC, "No SRB added upon reception of F1 UE Context modification request at the DU\n");
+  }
+
+  if(cellGroupConfig != NULL) {
+    resp->du_to_cu_rrc_information = calloc(1,1024*sizeof(uint8_t));
+    asn_enc_rval_t enc_rval = uper_encode_to_buffer(&asn_DEF_NR_CellGroupConfig,
+                                NULL,
+                                (void *)cellGroupConfig,
+                                resp->du_to_cu_rrc_information,
+                                1024);
+    resp->du_to_cu_rrc_information_length = (enc_rval.encoded+7)>>3;
+  }
+  itti_send_msg_to_task (TASK_DU_F1, ctxt.module_id, message_p);
+}
+
 static void rrc_CU_process_ue_context_setup_response(MessageDef *msg_p, const char *msg_name, instance_t instance){
 
   f1ap_ue_context_setup_t * resp=&F1AP_UE_CONTEXT_SETUP_RESP(msg_p);
@@ -3292,20 +3617,97 @@ static void rrc_CU_process_ue_context_setup_response(MessageDef *msg_p, const ch
   }
   if(cellGroupConfig->rlc_BearerToAddModList!=NULL){
     if(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList != NULL){
-      LOG_I(NR_RRC, "rlc_BearerToAddModList not empty before filling it \n");
-      free(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList);
+      int ue_ctxt_rlc_Bearers = ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList->list.count;
+      for(int i=ue_ctxt_rlc_Bearers; i<ue_ctxt_rlc_Bearers + cellGroupConfig->rlc_BearerToAddModList->list.count; i++){
+        ASN_SEQUENCE_ADD(&ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList->list,
+          cellGroupConfig->rlc_BearerToAddModList->list.array[i-ue_ctxt_rlc_Bearers]);
+      }
     }
-    ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList = calloc(1, sizeof(*cellGroupConfig->rlc_BearerToAddModList));
-    memcpy(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList, cellGroupConfig->rlc_BearerToAddModList,
+    else{
+      LOG_W(NR_RRC, "Empty rlc_BearerToAddModList at ue_context of the CU before filling the updates from UE context setup response \n");
+      ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList = calloc(1, sizeof(*cellGroupConfig->rlc_BearerToAddModList));
+      memcpy(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList, cellGroupConfig->rlc_BearerToAddModList,
         sizeof(*cellGroupConfig->rlc_BearerToAddModList));
+    }
   }
   xer_fprint(stdout,&asn_DEF_NR_CellGroupConfig, ue_context_p->ue_context.masterCellGroup);
 
+  if (ue_context_p->ue_context.established_pdu_sessions_flag == 1) {
+    rrc_gNB_generate_dedicatedRRCReconfiguration(&ctxt, ue_context_p, cellGroupConfig);
+  } else {
+    rrc_gNB_generate_defaultRRCReconfiguration(&ctxt, ue_context_p, NULL);
+  }
+
   free(cellGroupConfig->rlc_BearerToAddModList);
   free(cellGroupConfig);
 
 }
 
+static void rrc_CU_process_ue_context_modification_response(MessageDef *msg_p, const char *msg_name, instance_t instance){
+
+  f1ap_ue_context_setup_t * resp=&F1AP_UE_CONTEXT_SETUP_RESP(msg_p);
+  protocol_ctxt_t ctxt;
+  ctxt.rnti      = resp->rnti;
+  ctxt.module_id = instance;
+  ctxt.instance  = instance;
+  ctxt.enb_flag  = 1;
+  ctxt.eNB_index = instance;
+  gNB_RRC_INST *rrc = RC.nrrrc[ctxt.module_id];
+  struct rrc_gNB_ue_context_s *ue_context_p = rrc_gNB_get_ue_context(rrc, ctxt.rnti);
+  NR_CellGroupConfig_t *cellGroupConfig = NULL;
+
+  if(resp->du_to_cu_rrc_information!=NULL){
+    asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
+      &asn_DEF_NR_CellGroupConfig,
+      (void **)&cellGroupConfig,
+      (uint8_t *)resp->du_to_cu_rrc_information,
+      (int) resp->du_to_cu_rrc_information_length);
+
+    if((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
+      AssertFatal(1==0,"Cell group config decode error\n");
+      // free the memory
+      SEQUENCE_free( &asn_DEF_NR_CellGroupConfig, cellGroupConfig, 1 );
+      return;
+    }
+    //xer_fprint(stdout,&asn_DEF_NR_CellGroupConfig, cellGroupConfig);
+
+    if(ue_context_p->ue_context.masterCellGroup == NULL){
+      ue_context_p->ue_context.masterCellGroup = calloc(1, sizeof(NR_CellGroupConfig_t));
+    }
+    /*if(cellGroupConfig->rlc_BearerToAddModList!=NULL){
+      if(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList != NULL){
+        LOG_I(NR_RRC, "rlc_BearerToAddModList not empty before filling it \n");
+        free(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList);
+      }
+      ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList = calloc(1, sizeof(*cellGroupConfig->rlc_BearerToAddModList));
+      memcpy(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList, cellGroupConfig->rlc_BearerToAddModList,
+          sizeof(*cellGroupConfig->rlc_BearerToAddModList));
+    }*/
+    if(cellGroupConfig->rlc_BearerToAddModList!=NULL){
+      if(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList != NULL){
+        int ue_ctxt_rlc_Bearers = ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList->list.count;
+        for(int i=ue_ctxt_rlc_Bearers; i<ue_ctxt_rlc_Bearers + cellGroupConfig->rlc_BearerToAddModList->list.count; i++){
+          ASN_SEQUENCE_ADD(&ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList->list,
+              cellGroupConfig->rlc_BearerToAddModList->list.array[i-ue_ctxt_rlc_Bearers]);
+        }
+      }
+      else{
+        LOG_W(NR_RRC, "Empty rlc_BearerToAddModList at ue_context of the CU before filling the updates from UE context setup response \n");
+        ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList = calloc(1, sizeof(*cellGroupConfig->rlc_BearerToAddModList));
+        memcpy(ue_context_p->ue_context.masterCellGroup->rlc_BearerToAddModList, cellGroupConfig->rlc_BearerToAddModList,
+          sizeof(*cellGroupConfig->rlc_BearerToAddModList));
+      }
+    }
+    LOG_I(NR_RRC, "Updated master cell group configuration stored at the UE context of the CU:\n");
+    xer_fprint(stdout,&asn_DEF_NR_CellGroupConfig, ue_context_p->ue_context.masterCellGroup);
+
+    rrc_gNB_generate_dedicatedRRCReconfiguration(&ctxt, ue_context_p, cellGroupConfig);
+
+    free(cellGroupConfig->rlc_BearerToAddModList);
+    free(cellGroupConfig);
+  }
+}
+
 unsigned int mask_flip(unsigned int x) {
   return((((x>>8) + (x<<8))&0xffff)>>6);
 }
@@ -3553,15 +3955,27 @@ void nr_rrc_subframe_process(protocol_ctxt_t *const ctxt_pP, const int CC_id) {
 
         // Remove here the MAC and RRC context when RRC is not connected or gNB is not connected to CN5G
         if(ue_context_p->ue_context.StatusRrc < NR_RRC_CONNECTED || ue_context_p->ue_context.gNB_ue_ngap_id == 0) {
-          mac_remove_nr_ue(ctxt_pP->module_id, ctxt_pP->rnti);
-          rrc_rlc_remove_ue(ctxt_pP);
-          pdcp_remove_UE(ctxt_pP);
+          if(!NODE_IS_CU(RC.nrrrc[ctxt_pP->instance]->node_type)){
+            mac_remove_nr_ue(ctxt_pP->module_id, ctxt_pP->rnti);
+            rrc_rlc_remove_ue(ctxt_pP);
+            pdcp_remove_UE(ctxt_pP);
 
-          /* remove RRC UE Context */
-          ue_context_p = rrc_gNB_get_ue_context(RC.nrrrc[ctxt_pP->module_id], ctxt_pP->rnti);
-          if (ue_context_p) {
-            rrc_gNB_remove_ue_context(ctxt_pP, RC.nrrrc[ctxt_pP->module_id], ue_context_p);
-            LOG_I(NR_RRC, "remove UE %x \n", ctxt_pP->rnti);
+            /* remove RRC UE Context */
+            ue_context_p = rrc_gNB_get_ue_context(RC.nrrrc[ctxt_pP->module_id], ctxt_pP->rnti);
+            if (ue_context_p) {
+              rrc_gNB_remove_ue_context(ctxt_pP, RC.nrrrc[ctxt_pP->module_id], ue_context_p);
+              LOG_I(NR_RRC, "remove UE %x \n", ctxt_pP->rnti);
+            }
+          }
+          // In case of CU trigger UE context release command towards the DU
+          else{
+            MessageDef *message_p;
+            message_p = itti_alloc_new_message (TASK_RRC_GNB, 0, F1AP_UE_CONTEXT_RELEASE_CMD);
+            f1ap_ue_context_release_cmd_t *rel_cmd=&F1AP_UE_CONTEXT_RELEASE_CMD (message_p);
+            rel_cmd->rnti = ctxt_pP->rnti;
+            rel_cmd->cause = F1AP_CAUSE_RADIO_NETWORK;
+            rel_cmd->cause_value = 10; // 10 = F1AP_CauseRadioNetwork_normal_release
+            itti_send_msg_to_task(TASK_CU_F1, ctxt_pP->module_id, message_p);
           }
         }
 
@@ -3796,17 +4210,30 @@ void *rrc_gnb_task(void *args_p) {
         rrc_gNB_process_f1_setup_req(&F1AP_SETUP_REQ(msg_p));
         break;
 	
-    case NR_DU_RRC_DL_INDICATION:
-      rrc_process_DU_DL(msg_p, msg_name_p, instance);
-      break;
+      case NR_DU_RRC_DL_INDICATION:
+        rrc_process_DU_DL(msg_p, msg_name_p, instance);
+        break;
       
-    case F1AP_UE_CONTEXT_SETUP_REQ:
-      rrc_DU_process_ue_context_setup_request(msg_p, msg_name_p, instance);
-      break;
+      case F1AP_UE_CONTEXT_SETUP_REQ:
+        rrc_DU_process_ue_context_setup_request(msg_p, msg_name_p, instance);
+        break;
 
-    case F1AP_UE_CONTEXT_SETUP_RESP:
-      rrc_CU_process_ue_context_setup_response(msg_p, msg_name_p, instance);
-      break;
+      case F1AP_UE_CONTEXT_SETUP_RESP:
+        rrc_CU_process_ue_context_setup_response(msg_p, msg_name_p, instance);
+        break;
+
+      case F1AP_UE_CONTEXT_MODIFICATION_RESP:
+        rrc_CU_process_ue_context_modification_response(msg_p, msg_name_p, instance);
+        break;
+
+      case F1AP_UE_CONTEXT_MODIFICATION_REQ:
+        rrc_DU_process_ue_context_modification_request(msg_p, msg_name_p, instance);
+        break;
+
+      case F1AP_UE_CONTEXT_RELEASE_CMD:
+        LOG_W(NR_RRC, "Received F1AP_UE_CONTEXT_RELEASE_CMD for processing at the RRC layer of the DU. Processing function "
+            "implementation is pending\n");
+        break;
 
       /* Messages from X2AP */
       case X2AP_ENDC_SGNB_ADDITION_REQ:
@@ -4111,5 +4538,6 @@ void nr_rrc_trigger(protocol_ctxt_t *ctxt, int CC_id, int frame, int subframe)
   message_p = itti_alloc_new_message(TASK_RRC_GNB, 0, RRC_SUBFRAME_PROCESS);
   RRC_SUBFRAME_PROCESS(message_p).ctxt  = *ctxt;
   RRC_SUBFRAME_PROCESS(message_p).CC_id = CC_id;
+  LOG_D(NR_RRC, "Time in RRC: %u/ %u \n", frame, subframe);
   itti_send_msg_to_task(TASK_RRC_GNB, ctxt->module_id, message_p);
 }

openair2/RRC/NR/rrc_gNB_NGAP.c

@@ -1111,7 +1111,51 @@ rrc_gNB_process_NGAP_PDUSESSION_SETUP_REQ(
     // TEST 
     // ue_context_p->ue_context.pdusession[0].status = PDU_SESSION_STATUS_DONE;
     // rrc_gNB_send_NGAP_PDUSESSION_SETUP_RESP(&ctxt, ue_context_p, 0);
-    rrc_gNB_generate_dedicatedRRCReconfiguration(&ctxt, ue_context_p);
+    if(!NODE_IS_CU(RC.nrrrc[ctxt.module_id]->node_type)){
+      rrc_gNB_generate_dedicatedRRCReconfiguration(&ctxt, ue_context_p, NULL);
+    }
+    else{
+      /*Generate a UE context modification request message towards the DU to instruct the DU
+       *for SRB2 and DRB configuration and get the updates on master cell group config from the DU*/
+      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_MODIFICATION_REQ (message_p);
+      //UE_IDs will be extracted from F1AP layer
+      req->gNB_CU_ue_id     = 0;
+      req->gNB_DU_ue_id = 0;
+      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];
+      req->mnc_digit_length = RC.nrrrc[ctxt.module_id]->configuration.mnc_digit_length[0];
+      req->nr_cellid        = RC.nrrrc[ctxt.module_id]->nr_cellid;
+
+      //if (ue_context_p->ue_context.established_pdu_sessions_flag == 1) {
+        /*Instruction towards the DU for SRB2 configuration*/
+        req->srbs_to_be_setup = malloc(1*sizeof(f1ap_srb_to_be_setup_t));
+        req->srbs_to_be_setup_length = 1;
+        f1ap_srb_to_be_setup_t *SRBs=req->srbs_to_be_setup;
+        SRBs[0].srb_id = 2;
+        SRBs[0].lcid = 2;
+
+        /*Instruction towards the DU for DRB configuration and tunnel creation*/
+        gtpv1u_gnb_create_tunnel_req_t  create_tunnel_req;
+        memset(&create_tunnel_req, 0, sizeof(gtpv1u_gnb_create_tunnel_req_t));
+        req->drbs_to_be_setup = malloc(1*sizeof(f1ap_drb_to_be_setup_t));
+        req->drbs_to_be_setup_length = 1;
+        f1ap_drb_to_be_setup_t *DRBs=req->drbs_to_be_setup;
+        LOG_I(RRC, "Length of DRB list:%d \n", req->drbs_to_be_setup_length);
+        DRBs[0].drb_id = 1;
+        DRBs[0].rlc_mode = RLC_MODE_AM;
+        DRBs[0].up_ul_tnl[0].tl_address = inet_addr(RC.nrrrc[ctxt.module_id]->eth_params_s.my_addr);
+        DRBs[0].up_ul_tnl[0].port=RC.nrrrc[ctxt.module_id]->eth_params_s.my_portd;
+        DRBs[0].up_ul_tnl_length = 1;
+        DRBs[0].up_dl_tnl[0].tl_address = inet_addr(RC.nrrrc[ctxt.module_id]->eth_params_s.remote_addr);
+        DRBs[0].up_dl_tnl[0].port=RC.nrrrc[ctxt.module_id]->eth_params_s.remote_portd;
+        DRBs[0].up_dl_tnl_length = 1;
+      //}
+
+      itti_send_msg_to_task (TASK_CU_F1, ctxt.module_id, message_p);
+    }
     return(0);
   }
 }