Set the RRC status in DU, Reconfigure SRB2, Manage RRC/NAS UL message in DU

openair2/F1AP/f1ap_du_rrc_message_transfer.c

@@ -40,6 +40,7 @@
 
 #include "DL-CCCH-Message.h"
 #include "DL-DCCH-Message.h"
+#include "UL-DCCH-Message.h"
 
 // for SRB1_logicalChannelConfig_defaultValue
 #include "rrc_extern.h"
@@ -181,6 +182,10 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
   ctxt.instance  = instance;
   ctxt.enb_flag  = 1;
 
+ struct rrc_eNB_ue_context_s* ue_context_p = rrc_eNB_get_ue_context(
+                                                RC.rrc[ctxt.module_id],
+                                                ctxt.rnti);
+
   if (srb_id == 0) {
     DL_CCCH_Message_t* dl_ccch_msg=NULL;
     asn_dec_rval_t dec_rval;
@@ -219,7 +224,6 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
           // Get configuration
 
         RRCConnectionSetup_t* rrcConnectionSetup = &dl_ccch_msg->message.choice.c1.choice.rrcConnectionSetup;
-        //	eNB_RRC_UE_t *ue_p = &ue_context_pP->ue_context;
         AssertFatal(rrcConnectionSetup!=NULL,"rrcConnectionSetup is null\n");
         RadioResourceConfigDedicated_t* radioResourceConfigDedicated = &rrcConnectionSetup->criticalExtensions.choice.c1.choice.rrcConnectionSetup_r8.radioResourceConfigDedicated;
 
@@ -257,28 +261,28 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
           );
 
       // This should be somewhere in the f1ap_cudu_ue_inst_t
-      int macrlc_instance = 0; 
+      /*int macrlc_instance = 0; 
 
       rnti_t rnti = f1ap_get_rnti_by_du_id(&f1ap_du_ue[0],du_ue_f1ap_id);
       struct rrc_eNB_ue_context_s *ue_context_p = rrc_eNB_get_ue_context(RC.rrc[macrlc_instance],rnti);
-        
+      */  
       eNB_RRC_UE_t *ue_p = &ue_context_p->ue_context; 
       AssertFatal(ue_p->Srb0.Active == 1,"SRB0 is not active\n");
 
       memcpy((void*)ue_p->Srb0.Tx_buffer.Payload,
              (void*)ie->value.choice.RRCContainer.buf,
-             rrc_dl_sdu_len);
+             rrc_dl_sdu_len); // ie->value.choice.RRCContainer.size
 
       ue_p->Srb0.Tx_buffer.payload_size = rrc_dl_sdu_len;
 
       rrc_mac_config_req_eNB(
-          macrlc_instance,
+          ctxt.module_id,
           0, //primaryCC_id,
           0,0,0,0,0,
 #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
           0,
 #endif
-          rnti,
+          ctxt.rnti,
           (BCCH_BCH_Message_t *) NULL,
           (RadioResourceConfigCommonSIB_t *) NULL,
 #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
@@ -316,96 +320,189 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
     }// switch case
     return(0);
   } else if (srb_id == 1) { 
-//     rrc_rlc_config_asn1_req(&ctxt,
-//         SRB_configList,
-//         (DRB_ToAddModList_t*) NULL,
-//         (DRB_ToReleaseList_t*) NULL
-// #if (RRC_VERSION >= MAKE_VERSION(9, 0, 0))
-//         , (PMCH_InfoList_r9_t *) NULL,
-//         0,0
-// #   endif
-//         );
 
     DL_DCCH_Message_t* dl_dcch_msg=NULL;
     asn_dec_rval_t dec_rval;
     dec_rval = uper_decode(NULL,
          &asn_DEF_DL_DCCH_Message,
          (void**)&dl_dcch_msg,
-         ie->value.choice.RRCContainer.buf,
+         &ie->value.choice.RRCContainer.buf[1], // buf[0] includes the pdcp header
          rrc_dl_sdu_len,0,0);
     
+    if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) 
+      LOG_E(DU_F1AP," Failed to decode DL-DCCH (%zu bytes)\n",dec_rval.consumed);
+    else
+      LOG_D(DU_F1AP, "Received message: present %d and c1 present %d\n", 
+        dl_dcch_msg->message.present, dl_dcch_msg->message.choice.c1.present);
+
     if (dl_dcch_msg->message.present == DL_DCCH_MessageType_PR_c1) {
      
       switch (dl_dcch_msg->message.choice.c1.present) {
 	
       case DL_DCCH_MessageType__c1_PR_NOTHING:
-        LOG_I(RRC, "Received PR_NOTHING on DL-DCCH-Message\n");
+        LOG_I(DU_F1AP, "Received PR_NOTHING on DL-DCCH-Message\n");
         return;
-        break;
       case DL_DCCH_MessageType__c1_PR_dlInformationTransfer:
-        LOG_I(RRC,"Received DL Information Transfer\n");
+        LOG_I(DU_F1AP,"Received NAS DL Information Transfer\n");
         break;	
       case DL_DCCH_MessageType__c1_PR_csfbParametersResponseCDMA2000:
+        LOG_I(DU_F1AP,"Received NAS sfbParametersResponseCDMA2000\n");
+        break;  
       case DL_DCCH_MessageType__c1_PR_handoverFromEUTRAPreparationRequest:
+        LOG_I(DU_F1AP,"Received NAS andoverFromEUTRAPreparationRequest\n");
+        break;  
       case DL_DCCH_MessageType__c1_PR_mobilityFromEUTRACommand:
+        LOG_I(DU_F1AP,"Received NAS mobilityFromEUTRACommand\n");
         break;
       case DL_DCCH_MessageType__c1_PR_rrcConnectionReconfiguration:
-	// handle RRCConnectionReconfiguration
+	     // handle RRCConnectionReconfiguration
-        LOG_I(RRC,
+        LOG_I(DU_F1AP,
-	      "Logical Channel DL-DCCH (SRB1), Received RRCConnectionReconfiguration DU_ID %x/RNTI %x\n",  
+	       "Logical Channel DL-DCCH (SRB1), Received RRCConnectionReconfiguration DU_ID %x/RNTI %x\n",  
-	      du_ue_f1ap_id,
+	       du_ue_f1ap_id,
-	      f1ap_get_rnti_by_du_id(&f1ap_du_ue[instance],du_ue_f1ap_id));
+	       f1ap_get_rnti_by_du_id(&f1ap_du_ue[instance],du_ue_f1ap_id));
 	
         RRCConnectionReconfiguration_t* rrcConnectionReconfiguration = &dl_dcch_msg->message.choice.c1.choice.rrcConnectionReconfiguration;
 
-	if (rrcConnectionReconfiguration->criticalExtensions.present == RRCConnectionReconfiguration__criticalExtensions_PR_c1) {
+        if (rrcConnectionReconfiguration->criticalExtensions.present == RRCConnectionReconfiguration__criticalExtensions_PR_c1) {
-	  if (rrcConnectionReconfiguration->criticalExtensions.choice.c1.present ==
+	        if (rrcConnectionReconfiguration->criticalExtensions.choice.c1.present ==
-	      RRCConnectionReconfiguration__criticalExtensions__c1_PR_rrcConnectionReconfiguration_r8) {
+	         RRCConnectionReconfiguration__criticalExtensions__c1_PR_rrcConnectionReconfiguration_r8) {
-	    RRCConnectionReconfiguration_r8_IEs_t* rrcConnectionReconfiguration_r8 =
+	          RRCConnectionReconfiguration_r8_IEs_t* rrcConnectionReconfiguration_r8 =
-	      &rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8;
+	          &rrcConnectionReconfiguration->criticalExtensions.choice.c1.choice.rrcConnectionReconfiguration_r8;
 	    
-	    if (rrcConnectionReconfiguration_r8->mobilityControlInfo) {
+            if (rrcConnectionReconfiguration_r8->mobilityControlInfo) {
-	      LOG_I(RRC,"Mobility Control Information is present\n");
+	            LOG_I(DU_F1AP,"Mobility Control Information is present\n");
-	      AssertFatal(1==0,"Can't handle this yet in DU\n");
+	            AssertFatal(1==0,"Can't handle this yet in DU\n");
-	    }
+	          }
-	    if (rrcConnectionReconfiguration_r8->measConfig != NULL) {
+	          if (rrcConnectionReconfiguration_r8->measConfig != NULL) {
-	      LOG_I(RRC,"Measurement Configuration is present\n");
+	            LOG_I(DU_F1AP,"Measurement Configuration is present\n");
+	          } 
 	    
-	    }
+      	    if (rrcConnectionReconfiguration_r8->radioResourceConfigDedicated) {
+      	      LOG_I(DU_F1AP,"Radio Resource Configuration is present\n");
+      	      RadioResourceConfigDedicated_t* radioResourceConfigDedicated = rrcConnectionReconfiguration_r8->radioResourceConfigDedicated;
+      	      uint8_t DRB2LCHAN[8];
+              long SRB_id,drb_id;
+      	      int i,cnt;
+      	      LogicalChannelConfig_t *SRB1_logicalChannelConfig,*SRB2_logicalChannelConfig;
+      	      DRB_ToAddModList_t*                 DRB_configList = rrcConnectionReconfiguration_r8->radioResourceConfigDedicated->drb_ToAddModList;
+              SRB_ToAddModList_t*                 SRB_configList = rrcConnectionReconfiguration_r8->radioResourceConfigDedicated->srb_ToAddModList;
+              DRB_ToReleaseList_t*                DRB_ReleaseList = rrcConnectionReconfiguration_r8->radioResourceConfigDedicated->drb_ToReleaseList;
+              MAC_MainConfig_t                    *mac_MainConfig = rrcConnectionReconfiguration_r8->radioResourceConfigDedicated->mac_MainConfig;
+              MeasGapConfig_t                    *measGapConfig = NULL;
+              struct PhysicalConfigDedicated**    physicalConfigDedicated = rrcConnectionReconfiguration_r8->radioResourceConfigDedicated->physicalConfigDedicated;
+              rrc_rlc_config_asn1_req(
+                &ctxt,
+                SRB_configList, // NULL,  //LG-RK 14/05/2014 SRB_configList,
+                DRB_configList,
+                DRB_ReleaseList
+      #if (RRC_VERSION >= MAKE_VERSION(9, 0, 0))
+                , (PMCH_InfoList_r9_t *) NULL
+                , 0, 0
+      #endif
+                );
 
-	    if (rrcConnectionReconfiguration_r8->radioResourceConfigDedicated) {
+              if (SRB_configList != NULL) {
-	      LOG_I(RRC,"Radio Resource Configuration is present\n");
+                for (i = 0; (i < SRB_configList->list.count) && (i < 3); i++) {
-	      RadioResourceConfigDedicated_t* radioResourceConfigDedicated = rrcConnectionReconfiguration_r8->radioResourceConfigDedicated;
+                  if (SRB_configList->list.array[i]->srb_Identity == 1 ){
-	      long SRB_id,DRB_id;
+                    ue_context_p->ue_context.Srb1.Active=1;
-	      int i,cnt;
+                  }
-	      LogicalChannelConfig_t *SRB1_logicalChannelConfig,*SRB2_logicalChannelConfig;
+                  else if (SRB_configList->list.array[i]->srb_Identity == 2 )  {
+                    ue_context_p->ue_context.Srb2.Active=1;
+                    ue_context_p->ue_context.Srb2.Srb_info.Srb_id=2;
+                    LOG_I(RRC,"[DU %d] SRB2 is now active\n",ctxt.module_id);
+                  } else {
+                    LOG_W(RRC,"[DU %d] invalide SRB identity %ld\n",ctxt.module_id,
+                   SRB_configList->list.array[i]->srb_Identity);
+                  }
+                }
+              }
 
-	      //	radioResourceConfigDedicated->physicalConfigDedicated;
+              if (DRB_configList != NULL) {
+                for (i = 0; i < DRB_configList->list.count; i++) {  // num max DRB (11-3-8)
+                  if (DRB_configList->list.array[i]) {
+                    drb_id = (int)DRB_configList->list.array[i]->drb_Identity;
+                    LOG_I(RRC,
+                      "[DU %d] Logical Channel UL-DCCH, Received RRCConnectionReconfiguration for UE rnti %x, reconfiguring DRB %d/LCID %d\n",
+                      ctxt.module_id,
+                      ctxt.rnti,
+                      (int)DRB_configList->list.array[i]->drb_Identity,
+                      (int)*DRB_configList->list.array[i]->logicalChannelIdentity);
 
-	    }
+                  if (ue_context_p->ue_context.DRB_active[drb_id] == 0) {
+                    ue_context_p->ue_context.DRB_active[drb_id] = 1;
+
+                    if (DRB_configList->list.array[i]->logicalChannelIdentity) {
+                      DRB2LCHAN[i] = (uint8_t) * DRB_configList->list.array[i]->logicalChannelIdentity;
+                    }
+
+                    rrc_mac_config_req_eNB(
+                      ctxt.module_id,
+                      0,0,0,0,0,0,
+        #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+                   0,
+        #endif
+                   ue_context_p->ue_context.rnti,
+                   (BCCH_BCH_Message_t *) NULL,
+                   (RadioResourceConfigCommonSIB_t *) NULL,
+        #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+                   (RadioResourceConfigCommonSIB_t *) NULL,
+        #endif
+                   physicalConfigDedicated,
+        #if (RRC_VERSION >= MAKE_VERSION(10, 0, 0))
+                   (SCellToAddMod_r10_t *)NULL,
+                   //(struct PhysicalConfigDedicatedSCell_r10 *)NULL,
+        #endif
+                   (MeasObjectToAddMod_t **) NULL,
+                   mac_MainConfig,
+                   DRB2LCHAN[i],
+                   DRB_configList->list.array[i]->logicalChannelConfig,
+                   measGapConfig,
+                   (TDD_Config_t *) NULL,
+                   NULL,
+                   (SchedulingInfoList_t *) NULL,
+                   0, NULL, NULL, (MBSFN_SubframeConfigList_t *) NULL
+        #if (RRC_VERSION >= MAKE_VERSION(9, 0, 0))
+                   , 0, (MBSFN_AreaInfoList_r9_t *) NULL, (PMCH_InfoList_r9_t *) NULL
+        #endif
+        #if (RRC_VERSION >= MAKE_VERSION(13, 0, 0))
+                   ,
+                   (SystemInformationBlockType1_v1310_IEs_t *)NULL
+        #endif
+                   );
+                  }
+
+                } else {        // remove LCHAN from MAC/PHY
+                  AssertFatal(1==0,"Can't handle this yet in DU\n");  
+                } 
+        	     }
+        	   }
+           }
+         }
+       }
 	    break;
-	  case DL_DCCH_MessageType__c1_PR_rrcConnectionRelease:
+  	  case DL_DCCH_MessageType__c1_PR_rrcConnectionRelease:
-	    // handle RRCConnectionRelease
+  	    // handle RRCConnectionRelease
-	    break;
+  	    break;
-	  case DL_DCCH_MessageType__c1_PR_securityModeCommand:
+  	  case DL_DCCH_MessageType__c1_PR_securityModeCommand:
-	  case DL_DCCH_MessageType__c1_PR_ueCapabilityEnquiry:
+         LOG_I(DU_F1AP,"Received securityModeCommand\n");
-	  case DL_DCCH_MessageType__c1_PR_counterCheck:
+          break; 
-#if (RRC_VERSION >= MAKE_VERSION(10, 0, 0))
+  	  case DL_DCCH_MessageType__c1_PR_ueCapabilityEnquiry:
-	  case DL_DCCH_MessageType__c1_PR_loggedMeasurementConfiguration_r10:
+        LOG_I(DU_F1AP,"Received sueCapabilityEnquiry\n");
-	  case DL_DCCH_MessageType__c1_PR_rnReconfiguration_r10:
+          break;
-#endif
+  	  case DL_DCCH_MessageType__c1_PR_counterCheck:
-	  case DL_DCCH_MessageType__c1_PR_spare1:
+  #if (RRC_VERSION >= MAKE_VERSION(10, 0, 0))
-	  case DL_DCCH_MessageType__c1_PR_spare2:
+  	  case DL_DCCH_MessageType__c1_PR_loggedMeasurementConfiguration_r10:
-	  case DL_DCCH_MessageType__c1_PR_spare3:
+  	  case DL_DCCH_MessageType__c1_PR_rnReconfiguration_r10:
-#if (RRC_VERSION < MAKE_VERSION(14, 0, 0))
+  #endif
-	  case DL_DCCH_MessageType__c1_PR_spare4:
+  	  case DL_DCCH_MessageType__c1_PR_spare1:
-#endif
+  	  case DL_DCCH_MessageType__c1_PR_spare2:
-	    break;
+  	  case DL_DCCH_MessageType__c1_PR_spare3:
-	  }
+  #if (RRC_VERSION < MAKE_VERSION(14, 0, 0))
-	  
+  	  case DL_DCCH_MessageType__c1_PR_spare4:
-	}	
+  #endif
-      }
+  	    break;
-    }
+	   } 
+	 }	
   }
   else if (srb_id == 2) {
     
@@ -416,8 +513,17 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
   boolean_t          ret             = TRUE;
   mem_block_t       *pdcp_pdu_p      = NULL; 
   pdcp_pdu_p = get_free_mem_block(rrc_dl_sdu_len, __func__);
-  memset(&pdcp_pdu_p->data[0], 0, rrc_dl_sdu_len);
+  memset(pdcp_pdu_p->data, 0, rrc_dl_sdu_len);
   memcpy(&pdcp_pdu_p->data[0], ie->value.choice.RRCContainer.buf, rrc_dl_sdu_len);
+#ifdef DEBUG_MSG
+  printf ("PRRCContainer size %d:", ie->value.choice.RRCContainer.size);
+  for (int i=0;i<ie->value.choice.RRCContainer.size;i++) printf("%2x ",ie->value.choice.RRCContainer.buf[i]);
+  printf("\n");
+
+  printf ("PDCP PDU size %d:", rrc_dl_sdu_len);
+  for (int i=0;i<rrc_dl_sdu_len;i++) printf("%2x ",pdcp_pdu_p->data[i]);
+  printf("\n");
+#endif 
 
     if (pdcp_pdu_p != NULL) {
       rlc_status = rlc_data_req(&ctxt
@@ -462,7 +568,6 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
       return ret; 
     } // if pdcp_pdu_p
   
-
 #endif
   return 0;
   
@@ -484,6 +589,14 @@ int DU_send_UL_RRC_MESSAGE_TRANSFER(const protocol_ctxt_t* const ctxt_pP,
   uint8_t  *buffer;
   uint32_t  len;
 
+
+ LOG_I(RRC,"[DU %d] Received UL_RRC_MESSAGE_TRANSFER : size %d UE RNTI %x in SRB %d\n", 
+        ctxt_pP->module_id, sdu_sizeP, rnti, rb_idP);
+
+ struct rrc_eNB_ue_context_s* ue_context_p = rrc_eNB_get_ue_context(
+                                                RC.rrc[ctxt_pP->module_id],
+                                                rnti);
+
   /* Create */
   /* 0. Message Type */
   memset(&pdu, 0, sizeof(pdu));
@@ -535,6 +648,97 @@ int DU_send_UL_RRC_MESSAGE_TRANSFER(const protocol_ctxt_t* const ctxt_pP,
   OCTET_STRING_fromBuf(&ie->value.choice.RRCContainer, sdu_pP, sdu_sizeP);
   ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
 
+  if (rb_idP == 1 || rb_idP == 2) { 
+    struct rrc_eNB_ue_context_s* ue_context_p = rrc_eNB_get_ue_context(
+                                                RC.rrc[ctxt_pP->module_id],
+                                                rnti);
+
+   
+    UL_DCCH_Message_t* ul_dcch_msg=NULL;
+    asn_dec_rval_t dec_rval;
+    dec_rval = uper_decode(NULL,
+         &asn_DEF_UL_DCCH_Message,
+         (void**)&ul_dcch_msg,
+         &ie->value.choice.RRCContainer.buf[1], // buf[0] includes the pdcp header
+         sdu_sizeP,0,0);
+    
+    if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) 
+      LOG_E(DU_F1AP," Failed to decode UL-DCCH (%zu bytes)\n",dec_rval.consumed);
+    else
+      LOG_D(RRC, "Received message: present %d and c1 present %d\n", 
+        ul_dcch_msg->message.present, ul_dcch_msg->message.choice.c1.present);
+
+    if (ul_dcch_msg->message.present == UL_DCCH_MessageType_PR_c1) {
+
+      switch (ul_dcch_msg->message.choice.c1.present) {
+      case UL_DCCH_MessageType__c1_PR_NOTHING:   /* No components present */
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_csfbParametersRequestCDMA2000:
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_measurementReport:
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_rrcConnectionReconfigurationComplete:
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_rrcConnectionReestablishmentComplete:
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_rrcConnectionSetupComplete:
+        LOG_I(RRC,"[MSG] RRC UL rrcConnectionSetupComplete \n");
+       if(!ue_context_p){
+          LOG_E(DU_F1AP, "Did not find the UE context associated with UE RNTOI %x, ue_context_p is NULL\n", ctxt_pP->rnti);
+        }else {
+          LOG_I(DU_F1AP, "Processing RRCConnectionSetupComplete UE %x\n", rnti);
+          ue_context_p->ue_context.Status = RRC_CONNECTED;
+        }
+
+        break;
+      case UL_DCCH_MessageType__c1_PR_securityModeComplete:
+         LOG_I(RRC,"[MSG] RRC securityModeComplete \n");
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_securityModeFailure:
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_ueCapabilityInformation:
+           LOG_I(RRC,"[MSG] RRC ueCapabilityInformation \n");
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_ulHandoverPreparationTransfer:
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_ulInformationTransfer:
+        LOG_I(RRC,"[MSG] RRC UL Information Transfer \n");
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_counterCheckResponse:
+        break;
+
+#if (RRC_VERSION >= MAKE_VERSION(9, 0, 0))
+
+      case UL_DCCH_MessageType__c1_PR_ueInformationResponse_r9:
+        break;
+      case UL_DCCH_MessageType__c1_PR_proximityIndication_r9:
+       break;
+#endif
+
+#if (RRC_VERSION >= MAKE_VERSION(10, 0, 0))
+      case UL_DCCH_MessageType__c1_PR_rnReconfigurationComplete_r10:
+        break;
+
+      case UL_DCCH_MessageType__c1_PR_mbmsCountingResponse_r10:
+       break;
+
+      case UL_DCCH_MessageType__c1_PR_interFreqRSTDMeasurementIndication_r10:
+       break;
+#endif
+
+      }
+    }
+  }
     /* encode */
   if (f1ap_encode_pdu(&pdu, &buffer, &len) < 0) {
     LOG_E(DU_F1AP, "Failed to encode F1 setup request\n");

openair2/RRC/LTE/rrc_eNB.c

@@ -206,9 +206,11 @@ init_SI(
     AssertFatal(carrier->sizeof_SIB1 != 255,"FATAL, RC.rrc[enb_mod_idP].carrier[CC_id].sizeof_SIB1 == 255");
 
   }
-  if ((rrc->node_type == ngran_eNB_CU)  || 
+  if (rrc->node_type != ngran_eNB_DU) { 
+
+  	/*if ((rrc->node_type == ngran_eNB_CU)  || 
       (rrc->node_type == ngran_ng_eNB_CU) ||
-      (rrc->node_type == ngran_eNB)) {
+      (rrc->node_type == ngran_eNB)) { */ 
     carrier->SIB23 = (uint8_t*) malloc16(64);
     AssertFatal(carrier->SIB23!=NULL,"cannot allocate memory for SIB");
     carrier->sizeof_SIB23 = do_SIB23(
@@ -630,8 +632,9 @@ static void init_MBMS(
 #endif
                              ,NULL);
     
-    if ((RC.rrc[enb_mod_idP]->node_type  != ngran_eNB_CU) &&
+    if ( (RC.rrc[enb_mod_idP]->node_type  != ngran_eNB_CU) ||
-        (RC.rrc[enb_mod_idP]->node_type  != ngran_ng_eNB_CU)) {
+	 (RC.rrc[enb_mod_idP]->node_type  != ngran_ng_eNB_CU) ||
+	 (RC.rrc[enb_mod_idP]->node_type  != ngran_gNB_CU)   ) {
       rrc_rlc_config_asn1_req(&ctxt,
 			      NULL, // SRB_ToAddModList
 			      NULL,   // DRB_ToAddModList