Removed temporary values in x2ap and rrc

openair2/COMMON/x2ap_messages_types.h

@@ -315,7 +315,7 @@ typedef struct x2ap_senb_addition_req_ack_s {
 
 typedef struct x2ap_ENDC_sgnb_addition_req_s {
   int ue_x2_id;
-
+  LTE_PhysCellId_t target_physCellId; 
   /* used for RRC->X2AP in source eNB */
   int rnti;
 
@@ -386,6 +386,7 @@ typedef struct x2ap_ENDC_reconf_complete_s {
   int MeNB_ue_x2_id;
 
   int SgNB_ue_x2_id;
+  LTE_PhysCellId_t target_physCellId;
 
   x2ap_sgNB_reconf_response_information_t reconf_response;
 

openair2/RRC/LTE/rrc_eNB.c

@@ -96,6 +96,11 @@
 
 #include "SIMULATION/TOOLS/sim.h" // for taus
 
+#define ASN_MAX_ENCODE_SIZE 1000
+static int add_CG_ConfigInfo(char **enc_buf,rrc_eNB_ue_context_t *const ue_context_pP,int * enc_size);
+static int is_en_dc_supported(LTE_UE_EUTRA_Capability_t *c);
+static void free_rb_config(struct NR_RadioBearerConfig *rb_config);
+static void free_cg_configinfo(struct NR_CG_ConfigInfo *cg_configinfo);
 
 extern RAN_CONTEXT_t RC;
 
@@ -4334,6 +4339,8 @@ rrc_eNB_process_MeasurementReport(
   long ncell_max = -150;
   uint32_t earfcn_dl;
   uint8_t KeNB_star[32] = { 0 };
+  char *enc_buf = NULL;
+  int enc_size = 0;
   T(T_ENB_RRC_MEASUREMENT_REPORT, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->frame),
     T_INT(ctxt_pP->subframe), T_INT(ctxt_pP->rnti));
 
@@ -4396,8 +4403,17 @@ rrc_eNB_process_MeasurementReport(
       MessageDef      *msg;
       ue_context_pP->ue_context.Status = RRC_NR_NSA;
 
+      if(is_en_dc_supported(ue_context_pP->ue_context.UE_Capability)) {
+/** to add gNB as Secondary node CG-ConfigInfo to be added as per 36.423 r15 **/
+	    if(add_CG_ConfigInfo(&enc_buf,ue_context_pP,&enc_size) == RRC_OK)
+	      LOG_I(RRC,"CG-ConfigInfo encoded successfully\n");
           msg = itti_alloc_new_message(TASK_RRC_ENB, X2AP_ENDC_SGNB_ADDITION_REQ);
           X2AP_ENDC_SGNB_ADDITION_REQ(msg).rnti = ctxt_pP->rnti;
+	      memcpy(X2AP_ENDC_SGNB_ADDITION_REQ(msg).rrc_buffer,enc_buf,enc_size);
+	      X2AP_ENDC_SGNB_ADDITION_REQ(msg).rrc_buffer_size = enc_size;
+		  X2AP_ENDC_SGNB_ADDITION_REQ(msg).target_physCellId
+			= measResults2->measResultNeighCells->choice.measResultListEUTRA.list.array[0]->physCellId;
+
 		  //For the moment we have a single E-RAB which will be the one to be added to the gNB
 		  //Not sure how to select bearers to be added if there are multiple.
 		  X2AP_ENDC_SGNB_ADDITION_REQ(msg).nb_e_rabs_tobeadded = 1;
@@ -4416,7 +4432,7 @@ rrc_eNB_process_MeasurementReport(
           return;
       }
   }
-
+}
   if (measResults2->measResultNeighCells == NULL)
     return;
 
@@ -4531,6 +4547,186 @@ rrc_eNB_process_MeasurementReport(
   }
 }
 
+
+//-----------------------------------------------------------------------------
+/**  
+ * @fn		:add_CG_ConfigInfo
+ * @param 	:enc_buf to store the encoded bits 
+ * @param   :ue_context_pP ue context used to fill CG-ConfigInfo
+ * @param   :enc_size to store thre size of encoded size
+ *			this api is to fill and encode CG-ConfigInfo
+ */
+int add_CG_ConfigInfo(
+  char **enc_buf,
+  rrc_eNB_ue_context_t *const ue_context_pP,
+  int * enc_size
+) {
+  struct NR_CG_ConfigInfo *cg_configinfo = NULL;
+  struct NR_RadioBearerConfig *rb_config = NULL;
+  asn_enc_rval_t enc_rval;
+  int RRC_OK = 1;
+  int index = 0;
+
+  rb_config = calloc(1,sizeof( struct NR_RadioBearerConfig));
+  AssertFatal(rb_config != NULL,"failed to allocate memory for rb_config");
+
+  if(ue_context_pP->ue_context.DRB_configList->list.count != 0) {
+    rb_config->drb_ToAddModList = calloc(1,sizeof(struct NR_DRB_ToAddModList ));
+	AssertFatal(rb_config->drb_ToAddModList != NULL,"failed to allocated memory for drbtoaddmodlist");
+	rb_config->drb_ToAddModList->list.count = ue_context_pP->ue_context.DRB_configList->list.count;
+	rb_config->drb_ToAddModList->list.array 
+		= calloc(ue_context_pP->ue_context.DRB_configList->list.count, sizeof(struct LTE_DRB_ToAddMod));
+	AssertFatal( rb_config->drb_ToAddModList->list.array != NULL,
+		"falied to allocate memory for list.array");
+	  for(index = 0;index < ue_context_pP->ue_context.DRB_configList->list.count;index++) {
+	    rb_config->drb_ToAddModList->list.array[index] 
+			= calloc(1,sizeof(struct LTE_DRB_ToAddMod));
+	    AssertFatal(rb_config->drb_ToAddModList->list.array[index] != NULL,
+			"failed to allocate memory for drb_toaddmod");
+	    rb_config->drb_ToAddModList->list.array[index]->drb_Identity
+			=ue_context_pP->ue_context.DRB_configList->list.array[index]->drb_Identity;
+		if(ue_context_pP->ue_context.DRB_configList->list.array[index]->eps_BearerIdentity) {
+	      rb_config->drb_ToAddModList->list.array[index]->cnAssociation
+			  =calloc(1,sizeof(struct NR_DRB_ToAddMod__cnAssociation));
+	      AssertFatal(rb_config->drb_ToAddModList->list.array[index]->cnAssociation != NULL,
+			  "failed to allocate memory cnAssociation");
+	      rb_config->drb_ToAddModList->list.array[index]->cnAssociation->present
+			  =NR_DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity;
+	      rb_config->drb_ToAddModList->list.array[index]->cnAssociation->choice.eps_BearerIdentity
+			  =*(ue_context_pP->ue_context.DRB_configList->list.array[index]->eps_BearerIdentity);
+		}
+	  }
+  }
+
+  cg_configinfo = calloc(1,sizeof(struct NR_CG_ConfigInfo));
+  AssertFatal(cg_configinfo != NULL,"failed to allocate memory for cg_configinfo");
+  cg_configinfo->criticalExtensions.present = NR_CG_ConfigInfo__criticalExtensions_PR_c1;
+  cg_configinfo->criticalExtensions.choice.c1 
+      = calloc(1, sizeof(struct NR_CG_ConfigInfo__criticalExtensions__c1));
+  AssertFatal(cg_configinfo->criticalExtensions.choice.c1 != NULL,
+	  "failed to allocate memory for cg_configinfo->criticalExtensions.choice.c1");
+  cg_configinfo->criticalExtensions.choice.c1->present 
+	  = NR_CG_ConfigInfo__criticalExtensions__c1_PR_cg_ConfigInfo;
+  cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo 
+	  = calloc(1,sizeof(struct NR_CG_ConfigInfo_IEs));
+  AssertFatal(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo != NULL,
+	  "failed to allocate memory for cg_configinfo_IEs");
+  cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo 
+	  = calloc(1,sizeof( OCTET_STRING_t));
+  AssertFatal(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->
+	  ue_CapabilityInfo != NULL, "failed to allocate memory for ue_capabilityinfo");
+  cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo->size 
+	  = ue_context_pP->ue_context.UE_Capability_size;
+  cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo->buf 
+	  = calloc(1,sizeof(ue_context_pP->ue_context.UE_Capability_size));
+  AssertFatal( cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->
+	  ue_CapabilityInfo->buf  != NULL, "failed to allocate memory for buf");
+  memcpy(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo->buf,
+	  ue_context_pP->ue_context.UE_Capability,ue_context_pP->ue_context.UE_Capability_size);
+  cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config 
+	  = calloc(1,sizeof(OCTET_STRING_t));
+  AssertFatal(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->
+	  mcg_RB_Config != NULL, "failed to allocate memory for mcg_rb_config");
+  cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config->size 
+	  = sizeof( struct NR_RadioBearerConfig);
+  cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config->buf 
+	  = calloc(1,sizeof(struct NR_RadioBearerConfig));
+  AssertFatal(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->
+	  mcg_RB_Config->buf != NULL,"failed to allocate memory for buf");
+  memcpy(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config->buf,
+	  rb_config,sizeof(struct NR_RadioBearerConfig));
+  enc_rval = uper_encode_to_buffer(&asn_DEF_NR_CG_ConfigInfo,NULL,(void*)cg_configinfo,
+	  enc_buf,ASN_MAX_ENCODE_SIZE);
+  AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
+	  enc_rval.failed_type->name, enc_rval.encoded);
+  *enc_size = (enc_rval.encoded+7)/8;
+  free_rb_config(rb_config);
+  free_cg_configinfo(cg_configinfo);
+  return RRC_OK;
+  }
+//-----------------------------------------------------------------------------
+
+
+
+/**
+ * @fn		:api to free the all the dynamically allocated memory
+ * @param	:cg_configinfo contains cellgroup configuration
+ */
+void free_cg_configinfo(
+  struct NR_CG_ConfigInfo *cg_configinfo
+) {
+  if(cg_configinfo){
+    if(cg_configinfo->criticalExtensions.choice.c1){
+      if(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo){
+        if(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo){
+          if(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo->buf){
+            if(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config){
+              if(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config->buf){
+				free(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config->buf);
+				cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config->buf =NULL;
+				free(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config);
+				cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->mcg_RB_Config =NULL;
+				free(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo->buf);
+				cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo->buf = NULL;
+				free(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo);
+				cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo->ue_CapabilityInfo =NULL;
+				free(cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo);
+				cg_configinfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo =NULL;
+				free(cg_configinfo->criticalExtensions.choice.c1);
+				cg_configinfo->criticalExtensions.choice.c1 =NULL;
+				free(cg_configinfo);
+				cg_configinfo =NULL;
+			  }
+			}
+		  }			
+		}
+	  }
+    }   
+  }
+  return;
+}
+//-----------------------------------------------------------------------------
+
+
+
+//-----------------------------------------------------------------------------
+/**
+ * @fn		:api to free the all the dynamically allocated memory
+ * @param	:rb_config contains radiobearer configuration
+ */
+void free_rb_config(
+  struct NR_RadioBearerConfig *rb_config
+) {
+  int index = 0;
+   
+  if(rb_config) {
+    if(rb_config->drb_ToAddModList) {
+      if(rb_config->drb_ToAddModList->list.array) {
+        for(index = 0; index < rb_config->drb_ToAddModList->list.count; index++) {
+          if(rb_config->drb_ToAddModList->list.array[index]->cnAssociation) {
+	        free(rb_config->drb_ToAddModList->list.array[index]->cnAssociation);
+	        rb_config->drb_ToAddModList->list.array[index]->cnAssociation = NULL;
+		  }
+	      if(rb_config->drb_ToAddModList->list.array[index]) {
+	       free(rb_config->drb_ToAddModList->list.array[index]);
+	       rb_config->drb_ToAddModList->list.array[index] = NULL;
+		  }
+		}
+		free(rb_config->drb_ToAddModList->list.array);
+		rb_config->drb_ToAddModList->list.array = NULL;
+		free(rb_config->drb_ToAddModList);
+		rb_config->drb_ToAddModList = NULL;
+		free(rb_config);
+		rb_config = NULL;
+	  }
+	}
+  }
+  return;
+}
+//------------------------------------------------------------------------------
+
+
+
 //-----------------------------------------------------------------------------
 void
 rrc_eNB_generate_HandoverPreparationInformation(

openair2/RRC/NR/rrc_gNB_nsa.c

@@ -179,6 +179,8 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
 				  &create_tunnel_resp,
 				  &inde_list[0]);
 		  X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).nb_e_rabs_admitted_tobeadded = m->nb_e_rabs_tobeadded;
+		  X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).target_assoc_id = m->target_assoc_id;
+
 		  for(int i=0; i<ue_context_p->ue_context.nb_of_e_rabs; i++){
 			  X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).e_rabs_admitted_tobeadded[i].e_rab_id = ue_context_p->ue_context.e_rab[i].param.e_rab_id;
 			  X2AP_ENDC_SGNB_ADDITION_REQ_ACK(msg).e_rabs_admitted_tobeadded[i].gtp_teid = create_tunnel_resp.enb_S1u_teid[i];

openair2/X2AP/x2ap_eNB.c

@@ -359,7 +359,7 @@ void x2ap_eNB_handle_sctp_init_msg_multi_cnf(
    * Failure means multi_sd < 0.
    */
   if (instance->multi_sd < 0) {
-    X2AP_ERROR("Error: be sure to properly configure X22 in your configuration file.\n");
+    X2AP_ERROR("Error: be sure to properly configure X2 in your configuration file.\n");
     DevAssert(instance->multi_sd >= 0);
   }
 
@@ -454,10 +454,12 @@ void x2ap_eNB_handle_sgNB_add_req(instance_t instance,
   x2ap_eNB_instance_t *instance_p;
   x2ap_eNB_data_t     *x2ap_eNB_data;
   int                 ue_id;
-
-  /* TODO: remove hardcoded value */
-  x2ap_eNB_data = x2ap_is_eNB_id_in_list(3584);
+  LTE_PhysCellId_t target_pci;
+  target_pci = x2ap_ENDC_sgnb_addition_req->target_physCellId;
+  x2ap_eNB_data = x2ap_is_eNB_pci_in_list(target_pci);
   DevAssert(x2ap_eNB_data != NULL);
+  DevAssert(x2ap_ENDC_sgnb_addition_req != NULL);
+
 
   instance_p = x2ap_eNB_get_instance(instance);
   DevAssert(instance_p != NULL);
@@ -474,7 +476,8 @@ void x2ap_eNB_handle_sgNB_add_req(instance_t instance,
   x2ap_set_ids(id_manager, ue_id, x2ap_ENDC_sgnb_addition_req->rnti, ue_id, -1);
   x2ap_id_set_state(id_manager, ue_id, X2ID_STATE_NSA_PREPARE);
 
-  x2ap_eNB_generate_ENDC_x2_SgNB_addition_request(instance_p, x2ap_ENDC_sgnb_addition_req, x2ap_eNB_data, ue_id);
+  x2ap_eNB_generate_ENDC_x2_SgNB_addition_request(instance_p, x2ap_ENDC_sgnb_addition_req,
+      x2ap_eNB_data, ue_id);
 }
 
 static
@@ -489,16 +492,31 @@ void x2ap_gNB_trigger_sgNB_add_req_ack(instance_t instance,
    * as far as I understand.. CROUX
    */
 
-
+  x2ap_id_manager     *id_manager;
   x2ap_eNB_instance_t *instance_p;
   x2ap_eNB_data_t     *target;
-  /*int source_assoc_id = x2ap_ENDC_sgnb_addition_req_ACK->source_assoc_id;
   int                 ue_id;
+  /*int source_assoc_id = x2ap_ENDC_sgnb_addition_req_ACK->source_assoc_id;
   int                 id_source;
   int                 id_target;*/
 
   instance_p = x2ap_eNB_get_instance(instance);
   DevAssert(instance_p != NULL);
+  target = x2ap_get_eNB(NULL,x2ap_ENDC_sgnb_addition_req_ACK->target_assoc_id, 0);
+  DevAssert(target != NULL);
+	
+  /* allocate x2ap ID */
+  id_manager = &instance_p->id_manager;
+  ue_id = x2ap_allocate_new_id(id_manager);
+  if (ue_id == -1) {
+    X2AP_ERROR("could not allocate a new X2AP UE ID\n");
+    exit(1);
+  }
+  /* id_source is ue_id, id_target is unknown yet */
+  x2ap_set_ids(id_manager, ue_id, x2ap_ENDC_sgnb_addition_req_ACK->rnti, ue_id,
+      x2ap_ENDC_sgnb_addition_req_ACK->MeNB_ue_x2_id);
+  x2ap_id_set_state(id_manager, ue_id, X2ID_STATE_SOURCE_OVERALL);
+	
 
   /*target = x2ap_get_eNB(NULL, source_assoc_id, 0);
   DevAssert(target != NULL);*/
@@ -511,10 +529,36 @@ void x2ap_gNB_trigger_sgNB_add_req_ack(instance_t instance,
   x2ap_set_ids(&instance_p->id_manager, ue_id, x2ap_handover_req_ack->rnti, id_source, id_target);*/
 
 
-  //target = x2ap_get_eNB(NULL, 17, 0);
-  target = x2ap_is_eNB_id_in_list (3585); //Currently hardcoded. Need to extract it differently
+  x2ap_gNB_generate_ENDC_x2_SgNB_addition_request_ACK(instance_p, target,
+      x2ap_ENDC_sgnb_addition_req_ACK, ue_id);
+}
+
+/**
+ * @fn	: Function triggers sgnb reconfiguration complete
+ * @param	: IN instance, IN x2ap_reconf_complete
+**/ 
+static
+void x2ap_eNB_trigger_sgnb_reconfiguration_complete(instance_t instance, 
+    x2ap_ENDC_reconf_complete_t *x2ap_reconf_complete) 
+{
+  x2ap_eNB_instance_t *instance_p = NULL;
+  x2ap_eNB_data_t     *target = NULL;
+  int id_source = -1;
+  int id_target = -1;
+  LTE_PhysCellId_t target_pci;
+	
+  instance_p = x2ap_eNB_get_instance(instance);
+  DevAssert(instance_p != NULL);
+  DevAssert(x2ap_reconf_complete != NULL);
+  
+  target_pci = x2ap_reconf_complete->target_physCellId;
+  target = x2ap_is_eNB_pci_in_list(target_pci);
   DevAssert(target != NULL);
-  x2ap_gNB_generate_ENDC_x2_SgNB_addition_request_ACK(instance_p, target, x2ap_ENDC_sgnb_addition_req_ACK, 0);
+	
+  id_source = x2ap_reconf_complete->MeNB_ue_x2_id;
+  id_target = x2ap_reconf_complete->SgNB_ue_x2_id;
+  x2ap_eNB_generate_ENDC_x2_SgNB_reconfiguration_complete(instance_p, target, id_source, id_target);
+
 }
 
 
@@ -594,6 +638,10 @@ void *x2ap_task(void *arg) {
     	LOG_I(X2AP, "Received elements for X2AP_ENDC_SGNB_ADDITION_REQ_ACK \n");
     	break;
 
+	  case X2AP_ENDC_SGNB_RECONF_COMPLETE:
+		x2ap_eNB_trigger_sgnb_reconfiguration_complete(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+		    &X2AP_ENDC_SGNB_RECONF_COMPLETE(received_msg));
+		break;
       case SCTP_INIT_MSG_MULTI_CNF:
         x2ap_eNB_handle_sctp_init_msg_multi_cnf(ITTI_MESSAGE_GET_INSTANCE(received_msg),
                                                 &received_msg->ittiMsg.sctp_init_msg_multi_cnf);

openair2/X2AP/x2ap_eNB_generate_messages.c

@@ -1496,7 +1496,8 @@ int x2ap_eNB_generate_ENDC_x2_setup_response(
 }
 
 int x2ap_eNB_generate_ENDC_x2_SgNB_addition_request(
-  x2ap_eNB_instance_t *instance_p, x2ap_ENDC_sgnb_addition_req_t *x2ap_ENDC_sgnb_addition_req, x2ap_eNB_data_t *x2ap_eNB_data_p, int ue_id)
+  x2ap_eNB_instance_t *instance_p, x2ap_ENDC_sgnb_addition_req_t *x2ap_ENDC_sgnb_addition_req, 
+  x2ap_eNB_data_t *x2ap_eNB_data_p, int ue_id)
 {
 	X2AP_X2AP_PDU_t                     	 pdu;
 	X2AP_SgNBAdditionRequest_t               *out;
@@ -1507,42 +1508,21 @@ int x2ap_eNB_generate_ENDC_x2_SgNB_addition_request(
 	uint8_t  *buffer;
 	uint32_t  len;
 	int       ret = 0;
-
-	// Currently hardcoded (dummy) values filling the fields of SgNB_addition_request message. To be substituted
-	// with values coming from RRC.
-	uint16_t nRencryptionAlgorithms = 0;
-	uint16_t nRintegrityProtectionAlgorithms = 0;
+	uint16_t nRencryptionAlgorithms = x2ap_ENDC_sgnb_addition_req->security_capabilities.encryption_algorithms; 
+	uint16_t nRintegrityProtectionAlgorithms = x2ap_ENDC_sgnb_addition_req->security_capabilities
+	    .integrity_algorithms;
 	uint8_t  SgNBSecurityKey[32] = { 0 };
-	int uEaggregateMaximumBitRateDownlink = 100000000;
-	int uEaggregateMaximumBitRateUplink = 100000000;
-	int e_rabs_tobeadded = 1;
+	int uEaggregateMaximumBitRateDownlink = x2ap_ENDC_sgnb_addition_req->ue_ambr.br_dl;
+	int uEaggregateMaximumBitRateUplink = x2ap_ENDC_sgnb_addition_req->ue_ambr.br_ul;
+	int e_rabs_tobeadded = x2ap_ENDC_sgnb_addition_req->nb_e_rabs_tobeadded;
 	long int pDCPatSgNB = X2AP_EN_DC_ResourceConfiguration__pDCPatSgNB_present;
 	long int mCGresources = X2AP_EN_DC_ResourceConfiguration__mCGresources_not_present;
 	long int sCGresources = X2AP_EN_DC_ResourceConfiguration__sCGresources_not_present;
-	long qCI = 1;
-	X2AP_Pre_emptionCapability_t pre_emptionCapability = X2AP_Pre_emptionCapability_shall_not_trigger_pre_emption;
-	X2AP_Pre_emptionVulnerability_t pre_emptionVulnerability = X2AP_Pre_emptionVulnerability_not_pre_emptable;
-	priority_level_t priority_level = PRIORITY_LEVEL_NO_PRIORITY;
-	e_rab_tobe_added_t e_MCG_rabs_tobeadded;
-	e_MCG_rabs_tobeadded.gtp_teid = 0;
-	e_MCG_rabs_tobeadded.sgw_addr.length = 24;
-	uint8_t buf[20] = { 0 };
-	memcpy(e_MCG_rabs_tobeadded.sgw_addr.buffer, buf, 20*sizeof(uint8_t));
-
-	FILE *fd;
-	fd = fopen("../../../executables/uecap.raw","r");
-	if (fd != NULL) {
-		OCTET_STRING_t CG_Config_Info;
-		CG_Config_Info.size = 4096;
-		CG_Config_Info.buf = (uint8_t *)calloc(4096, sizeof(uint8_t));
-		int msg_len=fread(CG_Config_Info.buf,1,CG_Config_Info.size,fd);
-		CG_Config_Info.size = msg_len;
-
-		/*char buffer[4096];
-		int msg_len=fread(buffer,1,4096,fd);*/
-		LOG_I(RRC,"Read in %d bytes for uecap\n",msg_len);
-
-
+	long qCI = 0;
+	X2AP_Pre_emptionCapability_t pre_emptionCapability;
+	X2AP_Pre_emptionVulnerability_t pre_emptionVulnerability;
+	priority_level_t priority_level;
+	memcpy(SgNBSecurityKey, x2ap_ENDC_sgnb_addition_req->kgnb, sizeof(x2ap_ENDC_sgnb_addition_req->kgnb));
 	/*OCTET_STRING_t CG_Config_Info;
 	CG_Config_Info.size = 4096;
 	CG_Config_Info.buf = (uint8_t *)calloc(4096, sizeof(uint8_t));*/
@@ -1619,6 +1599,10 @@ int x2ap_eNB_generate_ENDC_x2_SgNB_addition_request(
     	e_RABS_ToBeAdded_SgNBAddReq_Item->en_DC_ResourceConfiguration.sCGresources = sCGresources;
     	if (pDCPatSgNB == X2AP_EN_DC_ResourceConfiguration__pDCPatSgNB_present){
     		e_RABS_ToBeAdded_SgNBAddReq_Item->resource_configuration.present = X2AP_E_RABs_ToBeAdded_SgNBAddReq_Item__resource_configuration_PR_sgNBPDCPpresent;			
+			qCI = x2ap_ENDC_sgnb_addition_req->e_rab_param[i].qos.qci;
+			priority_level = x2ap_ENDC_sgnb_addition_req->e_rab_param[i].qos.allocation_retention_priority.priority_level;
+			pre_emptionCapability = x2ap_ENDC_sgnb_addition_req->e_rab_param[i].qos.allocation_retention_priority.pre_emp_capability;
+			pre_emptionVulnerability = x2ap_ENDC_sgnb_addition_req->e_rab_param[i].qos.allocation_retention_priority.pre_emp_vulnerability;
 
     		e_RABS_ToBeAdded_SgNBAddReq_Item->resource_configuration.choice.sgNBPDCPpresent.full_E_RAB_Level_QoS_Parameters.qCI = qCI;
     		e_RABS_ToBeAdded_SgNBAddReq_Item->resource_configuration.choice.sgNBPDCPpresent.full_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionCapability = pre_emptionCapability;
@@ -1646,25 +1630,24 @@ int x2ap_eNB_generate_ENDC_x2_SgNB_addition_request(
     ie->id = X2AP_ProtocolIE_ID_id_MeNBtoSgNBContainer;
     ie->criticality = X2AP_Criticality_reject;
     ie->value.present = X2AP_SgNBAdditionRequest_IEs__value_PR_MeNBtoSgNBContainer;
-    ie->value.choice.MeNBtoSgNBContainer.buf = (uint8_t *)calloc(CG_Config_Info.size, sizeof(uint8_t));
-    memcpy(ie->value.choice.MeNBtoSgNBContainer.buf, CG_Config_Info.buf, CG_Config_Info.size);
-    ie->value.choice.MeNBtoSgNBContainer.size = CG_Config_Info.size; //4096;
+    if(NULL == (ie->value.choice.MeNBtoSgNBContainer.buf = (uint8_t *)
+		calloc(x2ap_ENDC_sgnb_addition_req->rrc_buffer_size, sizeof(uint8_t)))) {
+			X2AP_ERROR("Memory ALLocation failed\n");
+			exit(1);
+	}
+    memcpy(ie->value.choice.MeNBtoSgNBContainer.buf, x2ap_ENDC_sgnb_addition_req->rrc_buffer,
+		x2ap_ENDC_sgnb_addition_req->rrc_buffer_size);
+    ie->value.choice.MeNBtoSgNBContainer.size = x2ap_ENDC_sgnb_addition_req->rrc_buffer_size;
     ASN_SEQUENCE_ADD(&out->protocolIEs.list, ie);
 
     if (x2ap_eNB_encode_pdu(&pdu, &buffer, &len) < 0) {
         X2AP_ERROR("Failed to encode ENDC X2 SgNB_addition request message\n");
         return -1;
     }
-
+	free(ie->value.choice.MeNBtoSgNBContainer.buf);
     MSC_LOG_TX_MESSAGE (MSC_X2AP_SRC_ENB, MSC_X2AP_TARGET_ENB, NULL, 0, "0 X2Setup/initiatingMessage assoc_id %u", x2ap_eNB_data_p->assoc_id);
 
     x2ap_eNB_itti_send_sctp_data_req(instance_p->instance, x2ap_eNB_data_p->assoc_id, buffer, len, 0);
-	fclose(fd);
-	}
-	else {
-		LOG_I(RRC, "uecap.raw file could not be opened... \n");
-		return -1;
-	}
 
 	return ret;
 
@@ -1684,26 +1667,14 @@ int x2ap_gNB_generate_ENDC_x2_SgNB_addition_request_ACK( x2ap_eNB_instance_t *in
 		uint8_t  *buffer;
 		uint32_t  len;
 		int       ret = 0;
-		int MeNB_UE_X2AP_id = ue_id;
-		int SgNB_UE_X2AP_id = 0;
-
-		// Currently hardcoded (dummy) values filling the fields of SgNB_addition_request message. To be substituted
-		// with values coming from RRC.
-		//uint16_t nRencryptionAlgorithms = 0;
-		//uint16_t nRintegrityProtectionAlgorithms = 0;
-		//uint8_t  SgNBSecurityKey[32] = { 0 };
-		//int uEaggregateMaximumBitRateDownlink = 100000000;
-		//int uEaggregateMaximumBitRateUplink = 100000000;
-
-		int e_rabs_admitted_tobeadded = 1;
+
+		int MeNB_UE_X2AP_id = x2ap_sgnb_addition_req_ACK->MeNB_ue_x2_id;
+		int SgNB_UE_X2AP_id = ue_id;
+		int e_rabs_admitted_tobeadded = x2ap_sgnb_addition_req_ACK->nb_e_rabs_admitted_tobeadded;
 		long int pDCPatSgNB = X2AP_EN_DC_ResourceConfiguration__pDCPatSgNB_present;
 		long int mCGresources = X2AP_EN_DC_ResourceConfiguration__mCGresources_not_present;
 		long int sCGresources = X2AP_EN_DC_ResourceConfiguration__sCGresources_not_present;
-		e_rab_setup_t e_SCG_rabs_tobeadded;
-		e_SCG_rabs_tobeadded.gtp_teid = 0;
-		e_SCG_rabs_tobeadded.eNB_addr.length = 24;
-		uint8_t buf[20] = { 0 };
-		memcpy(e_SCG_rabs_tobeadded.eNB_addr.buffer, buf, 20*sizeof(uint8_t));
+
 
 		DevAssert(instance_p != NULL);
 		DevAssert(x2ap_eNB_data_p != NULL);

openair2/X2AP/x2ap_eNB_handler.c

@@ -1652,7 +1652,6 @@ int x2ap_gNB_handle_ENDC_sGNB_addition_request (instance_t instance,
   x2ap_eNB_instance_t                *instance_p;
   x2ap_eNB_data_t                    *x2ap_eNB_data;
   MessageDef                         *msg;
-  int                                ue_id;
 
   DevAssert (pdu != NULL);
   x2SgNBAdditionRequest = &pdu->choice.initiatingMessage.value.choice.SgNBAdditionRequest;
@@ -1683,20 +1682,9 @@ int x2ap_gNB_handle_ENDC_sGNB_addition_request (instance_t instance,
     X2AP_ERROR("%s %d: ie is a NULL pointer \n",__FILE__,__LINE__);
     return -1;
   }
-
-
-  // allocate a new X2AP UE ID
-  ue_id = x2ap_allocate_new_id(&instance_p->id_manager);
-  if (ue_id == -1) {
-    X2AP_ERROR("could not allocate a new X2AP UE ID\n");
-    // TODO: cancel handover: send HO preparation failure to source eNB
-    exit(1);
-  }
-  // rnti is unknown yet, must not be set to -1, 0 is fine
-  x2ap_set_ids(&instance_p->id_manager, ue_id, 0, ie->value.choice.UE_X2AP_ID, ue_id);
-  x2ap_id_set_state(&instance_p->id_manager, ue_id, X2ID_STATE_TARGET);
-
-  X2AP_ENDC_SGNB_ADDITION_REQ(msg).ue_x2_id = ue_id;
+  /* ue_x2_id = MeNB X2AP Id */
+  X2AP_ENDC_SGNB_ADDITION_REQ(msg).ue_x2_id = ie->value.choice.UE_X2AP_ID;
+  X2AP_ENDC_SGNB_ADDITION_REQ(msg).target_assoc_id = assoc_id;
 
 
   /* X2AP_ProtocolIE_ID_id_NRUESecurityCapabilities */