src/X2AP/sgnb_addition_response.cc

   1 /*
   2 ==================================================================================
   3         Copyright (c) 2018-2019 AT&T Intellectual Property.
   4
   5    Licensed under the Apache License, Version 2.0 (the "License");
   6    you may not use this file except in compliance with the License.
   7    You may obtain a copy of the License at
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  11    Unless required by applicable law or agreed to in writing, software
  12    distributed under the License is distributed on an "AS IS" BASIS,
  13    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14    See the License for the specific language governing permissions and
  15    limitations under the License.
  16 ==================================================================================
  17 */
  18 /*
  19  * sgnb_addition_response.cc
  20  *
  21  *  Created on: Aug 22, 2019
  22  *      Author: sjana
  23  */
  24
  25 #include <sgnb_addition_response.hpp>
  26
  27 sgnb_addition_response::sgnb_addition_response(void ) {
  28
  29
  30   x2ap_pdu_obj = 0;
  31   x2ap_pdu_obj = (X2N_X2AP_PDU_t * )calloc(1, sizeof(X2N_X2AP_PDU_t));
  32   assert(x2ap_pdu_obj != 0);
  33
  34   successMsg = 0;
  35   successMsg = (X2N_SuccessfulOutcome_t * )calloc(1, sizeof(X2N_SuccessfulOutcome_t));
  36   assert(successMsg != 0);
  37
  38   unsuccessMsg = 0;
  39   unsuccessMsg = (X2N_UnsuccessfulOutcome_t * )calloc(1, sizeof(X2N_UnsuccessfulOutcome_t));
  40   assert(unsuccessMsg != 0);
  41
  42   IE_array = 0;
  43   IE_array = (X2N_SgNBAdditionRequestAcknowledge_IEs_t *)calloc(NUM_SGNB_ADDITION_RESPONSE_ACKNOWLEDGE_IES, sizeof(X2N_SgNBAdditionRequestAcknowledge_IEs_t));
  44   assert(IE_array != 0);
  45
  46   IE_reject_array = 0;
  47   IE_reject_array = (X2N_SgNBAdditionRequestReject_IEs_t *)calloc(NUM_SGNB_ADDITION_RESPONSE_FAILURE_IES, sizeof(X2N_SgNBAdditionRequestReject_IEs_t));
  48   assert(IE_reject_array != 0);
  49
  50
  51   erab_admit_array = 0;
  52   erab_admit_array = (X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs_t * ) calloc(INITIAL_SIZE, sizeof(X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t));
  53   assert(erab_admit_array != 0);
  54   erab_admit_array_size = INITIAL_SIZE;
  55
  56
  57   erab_sgnb_present_array = 0;
  58   erab_sgnb_present_array = (X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t *) calloc(INITIAL_SIZE, sizeof(X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t));
  59   assert(erab_sgnb_present_array != 0);
  60   erab_sgnb_present_array_size = INITIAL_SIZE;
  61
  62   erab_sgnb_notpresent_array = 0;
  63   erab_sgnb_notpresent_array = (X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t *) calloc(INITIAL_SIZE, sizeof(X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t));
  64   assert(erab_sgnb_notpresent_array != 0);
  65   erab_sgnb_notpresent_array_size = INITIAL_SIZE;
  66
  67
  68 }
  69
  70 sgnb_addition_response::~sgnb_addition_response(void){
  71
  72   mdclog_write(MDCLOG_DEBUG, "Freeing X2AP SgNB Addition Response object memory");
  73
  74   X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_t  * erabs_toadd_list = &(IE_array[3].value.choice.E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList);
  75   for(int i = 0; i < erabs_toadd_list->list.size; i++){
  76     erabs_toadd_list->list.array[i] = 0;
  77   }
  78   if (erabs_toadd_list->list.size > 0){
  79     free(erabs_toadd_list->list.array);
  80     erabs_toadd_list->list.array = 0;
  81     erabs_toadd_list->list.size = 0;
  82     erabs_toadd_list->list.count= 0;
  83   }
  84
  85   free(erab_sgnb_present_array);
  86   free(erab_sgnb_notpresent_array);
  87   free(erab_admit_array);
  88
  89   X2N_SgNBAdditionRequestAcknowledge_t *sgnb_ack  = &(successMsg->value.choice.SgNBAdditionRequestAcknowledge);
  90   for(int i = 0; i < sgnb_ack->protocolIEs.list.size; i++){
  91     sgnb_ack->protocolIEs.list.array[i] = 0;
  92   }
  93
  94   if (sgnb_ack->protocolIEs.list.size > 0){
  95     free(sgnb_ack->protocolIEs.list.array);
  96     sgnb_ack->protocolIEs.list.array = 0;
  97     sgnb_ack->protocolIEs.list.size = 0;
  98   }
  99
 100   X2N_SgNBAdditionRequestReject_t *sgnb_reject  = &(unsuccessMsg->value.choice.SgNBAdditionRequestReject);
 101    for(int i = 0; i < sgnb_reject->protocolIEs.list.size; i++){
 102      sgnb_reject->protocolIEs.list.array[i] = 0;
 103    }
 104
 105    if (sgnb_reject->protocolIEs.list.size > 0){
 106      free(sgnb_reject->protocolIEs.list.array);
 107      sgnb_reject->protocolIEs.list.array = 0;
 108      sgnb_reject->protocolIEs.list.size = 0;
 109    }
 110
 111
 112   free(IE_array);
 113   free(IE_reject_array);
 114   free(successMsg);
 115   free(unsuccessMsg);
 116
 117   x2ap_pdu_obj->choice.initiatingMessage = NULL;
 118   x2ap_pdu_obj->present = X2N_X2AP_PDU_PR_NOTHING;
 119
 120   ASN_STRUCT_FREE(asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);
 121
 122   mdclog_write(MDCLOG_DEBUG, "Freed X2AP X2_SgNB Addition Response object memory");
 123 }
 124
 125 bool sgnb_addition_response::set_fields(X2N_UnsuccessfulOutcome_t * unsuccessMsg, sgnb_addition_helper &sgnb_data){
 126
 127   unsigned ie_index = 0;
 128
 129   if (unsuccessMsg == 0){
 130     error_string = "Invalid reference for X2AP Sgnb Addition Reject message in set_fields";
 131     return false;
 132   }
 133
 134   X2N_SgNBAdditionRequestReject_t * sgnb_reject = &(unsuccessMsg->value.choice.SgNBAdditionRequestReject);
 135   X2N_SgNBAdditionRequestReject_IEs_t *ies_sgnb_add_reject;
 136   sgnb_reject->protocolIEs.list.count = 0;
 137
 138   ie_index = 0;
 139   ies_sgnb_add_reject= &IE_reject_array[ie_index];
 140   ies_sgnb_add_reject->criticality = X2N_Criticality_reject;
 141   ies_sgnb_add_reject->id = X2N_ProtocolIE_ID_id_MeNB_UE_X2AP_ID;
 142   ies_sgnb_add_reject->value.present = X2N_SgNBAdditionRequestReject_IEs__value_PR_UE_X2AP_ID;
 143   ies_sgnb_add_reject->value.choice.UE_X2AP_ID = sgnb_data.menb_ue_x2ap_id;
 144   ASN_SEQUENCE_ADD(&(sgnb_reject->protocolIEs), &(IE_reject_array[ie_index]));
 145
 146
 147   ie_index = 1;
 148   ies_sgnb_add_reject= &IE_reject_array[ie_index];
 149   ies_sgnb_add_reject->criticality = X2N_Criticality_reject;
 150   ies_sgnb_add_reject->id = X2N_ProtocolIE_ID_id_SgNB_UE_X2AP_ID;
 151   ies_sgnb_add_reject->value.present = X2N_SgNBAdditionRequestReject_IEs__value_PR_SgNB_UE_X2AP_ID;
 152   ies_sgnb_add_reject->value.choice.SgNB_UE_X2AP_ID = sgnb_data.sgnb_ue_x2ap_id;
 153   ASN_SEQUENCE_ADD(&(sgnb_reject->protocolIEs), &(IE_reject_array[ie_index]));
 154
 155
 156   ie_index = 2;
 157   ies_sgnb_add_reject= &IE_reject_array[ie_index];
 158   ies_sgnb_add_reject->criticality = X2N_Criticality_reject;
 159   ies_sgnb_add_reject->id = X2N_ProtocolIE_ID_id_Cause;
 160   ies_sgnb_add_reject->value.present = X2N_SgNBAdditionRequestReject_IEs__value_PR_Cause;
 161   X2N_Cause_t *caus = &ies_sgnb_add_reject->value.choice.Cause;
 162
 163   switch(sgnb_data.cause)
 164     {
 165     case X2N_Cause_PR_misc: //Misc
 166       caus->present = X2N_Cause_PR_misc;
 167       caus->choice.misc = sgnb_data.cause_desc;
 168       break;
 169     case X2N_Cause_PR_radioNetwork: //radio network
 170       caus->present = X2N_Cause_PR_radioNetwork;
 171       caus->choice.radioNetwork = sgnb_data.cause_desc;
 172       break;
 173     case X2N_Cause_PR_protocol : //protocol
 174       caus->present = X2N_Cause_PR_protocol;
 175       caus->choice.protocol = sgnb_data.cause_desc;
 176       break;
 177     case X2N_Cause_PR_transport: //transport
 178       caus->present = X2N_Cause_PR_transport;
 179       caus->choice.transport = sgnb_data.cause_desc;
 180       break;
 181
 182     default:
 183       caus->present = X2N_Cause_PR_NOTHING;
 184       break;
 185     }
 186
 187   ASN_SEQUENCE_ADD(&(sgnb_reject->protocolIEs), &(IE_reject_array[ie_index]));
 188
 189   return true;
 190
 191 }
 192
 193
 194 bool sgnb_addition_response::set_fields(X2N_SuccessfulOutcome_t * successMsg, sgnb_addition_helper &sgnb_data){
 195
 196   unsigned ie_index = 0;
 197
 198   if (successMsg == 0){
 199     error_string = "Invalid reference for X2AP Sgnb Addition Acknowledge message in set_fields";
 200     return false;
 201   }
 202
 203   X2N_SgNBAdditionRequestAcknowledge_t * sgnb_ack = &(successMsg->value.choice.SgNBAdditionRequestAcknowledge);
 204   sgnb_ack->protocolIEs.list.count = 0;
 205
 206   X2N_SgNBAdditionRequestAcknowledge_IEs_t *ies_sgnb_add_ack;
 207
 208   ie_index = 0;
 209   ies_sgnb_add_ack= &IE_array[ie_index];
 210   ies_sgnb_add_ack->criticality = X2N_Criticality_reject;
 211   ies_sgnb_add_ack->id = X2N_ProtocolIE_ID_id_MeNB_UE_X2AP_ID;
 212   ies_sgnb_add_ack->value.present = X2N_SgNBAdditionRequestAcknowledge_IEs__value_PR_UE_X2AP_ID;
 213   ies_sgnb_add_ack->value.choice.UE_X2AP_ID = sgnb_data.menb_ue_x2ap_id;
 214   ASN_SEQUENCE_ADD(&(sgnb_ack->protocolIEs), &(IE_array[ie_index]));
 215
 216
 217   ie_index = 1;
 218   ies_sgnb_add_ack= &IE_array[ie_index];
 219   ies_sgnb_add_ack->criticality = X2N_Criticality_reject;
 220   ies_sgnb_add_ack->id = X2N_ProtocolIE_ID_id_SgNB_UE_X2AP_ID;
 221   ies_sgnb_add_ack->value.present = X2N_SgNBAdditionRequestAcknowledge_IEs__value_PR_SgNB_UE_X2AP_ID;
 222   ies_sgnb_add_ack->value.choice.SgNB_UE_X2AP_ID = sgnb_data.sgnb_ue_x2ap_id;
 223   ASN_SEQUENCE_ADD(&(sgnb_ack->protocolIEs), &(IE_array[ie_index]));
 224
 225   ie_index = 2;
 226   ies_sgnb_add_ack= &IE_array[ie_index];
 227   ies_sgnb_add_ack->criticality = X2N_Criticality_reject;
 228   ies_sgnb_add_ack->id = X2N_ProtocolIE_ID_id_SgNBtoMeNBContainer;
 229   ies_sgnb_add_ack->value.present = X2N_SgNBAdditionRequestAcknowledge_IEs__value_PR_SgNBtoMeNBContainer;
 230   X2N_SgNBtoMeNBContainer_t *container = &ies_sgnb_add_ack->value.choice.SgNBtoMeNBContainer;
 231   container->buf = sgnb_data.menb_sgnb_container;
 232   container->size = sgnb_data.menb_sgnb_container_size;
 233   ASN_SEQUENCE_ADD(&(sgnb_ack->protocolIEs), &(IE_array[ie_index]));
 234
 235   ie_index = 3;
 236   ies_sgnb_add_ack = &IE_array[ie_index];
 237   ies_sgnb_add_ack->criticality = X2N_Criticality_reject;
 238   ies_sgnb_add_ack->id =  X2N_ProtocolIE_ID_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList;
 239
 240   int lcount = sgnb_data.erab_list.size();
 241   if(lcount > 0){
 242     ies_sgnb_add_ack->value.present = X2N_SgNBAdditionRequestAcknowledge_IEs__value_PR_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList;
 243     X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_t  * erabs_toadd_list = &(ies_sgnb_add_ack->value.choice.E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList);
 244
 245
 246     //std::cout <<"Adding " << lcount << " erabs in response" << std::endl;
 247
 248     //resize empty array in constructor
 249     if (lcount >= erab_admit_array_size){
 250       erab_admit_array_size = 2*lcount;
 251       free(erab_admit_array);
 252       erab_admit_array = (X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs_t * ) calloc(erab_admit_array_size, sizeof(X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t));
 253       assert(erab_admit_array != 0);
 254
 255       erab_sgnb_present_array_size = 2 * lcount;
 256       free(erab_sgnb_present_array);
 257       erab_sgnb_present_array = (X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t *) calloc(erab_sgnb_present_array_size, sizeof(X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t));
 258       assert(erab_sgnb_present_array != 0);
 259
 260       erab_sgnb_notpresent_array_size = 2 * lcount;
 261       free(erab_sgnb_notpresent_array);
 262       erab_sgnb_notpresent_array = (X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t *) calloc(erab_sgnb_notpresent_array_size, sizeof(X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t));
 263       assert(erab_sgnb_notpresent_array != 0);
 264     }
 265
 266     std::vector<struct erab_item> * ref_erab_input  = &(sgnb_data.erab_list);
 267     erabs_toadd_list->list.count = 0;
 268
 269     int sgnb_present_index = 0;
 270     int sgnb_notpresent_index = 0;
 271
 272     for(unsigned int i = 0; i < lcount; i++){
 273
 274       erab_admit_array[i].id = X2N_ProtocolIE_ID_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item ;
 275       erab_admit_array[i].criticality = X2N_Criticality_ignore;
 276       erab_admit_array[i].value.present =  X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs__value_PR_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item;
 277
 278       X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_t * erab_item = &(erab_admit_array[i].value.choice.E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item);
 279
 280       erab_item->e_RAB_ID = (*ref_erab_input)[i].erab_id;
 281       erab_item->en_DC_ResourceConfiguration.pDCPatSgNB =  (*ref_erab_input)[i].pdcp_at_sgnb;
 282       erab_item->en_DC_ResourceConfiguration.mCGresources =  (*ref_erab_input)[i].mcg_resources;
 283       erab_item->en_DC_ResourceConfiguration.sCGresources =  (*ref_erab_input)[i].scg_resources;
 284
 285
 286       erab_item->resource_configuration.present = (X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item__resource_configuration_PR)(*ref_erab_input)[i].sgnb_pdcp_present;
 287       if( erab_item->resource_configuration.present == X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item__resource_configuration_PR_sgNBPDCPpresent){
 288
 289         erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.transportLayerAddress.buf = (*ref_erab_input)[i].sgnb_item.transport_layer_addr;
 290         erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.transportLayerAddress.size = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_size;
 291         erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.transportLayerAddress.bits_unused  = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_unused;
 292
 293         erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.gTP_TEID.buf = (*ref_erab_input)[i].sgnb_item.gtp_tei;
 294         erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.gTP_TEID.size = (*ref_erab_input)[i].sgnb_item.gtp_tei_size;
 295
 296         /* Force all optional parameters that are not set to NULL */
 297         erab_sgnb_present_array[sgnb_present_index].sgNB_UL_GTP_TEIDatPDCP = NULL;
 298
 299         /* validate constraints ..*/
 300         int ret_constr;
 301         ret_constr = asn_check_constraints(&asn_DEF_X2N_GTP_TEI, &erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.gTP_TEID, errbuf, &errbuf_len);
 302         if(ret_constr){
 303           error_string.assign(&errbuf[0], errbuf_len);
 304           error_string = "Error in constraints for GTP TEID.. Reason = " + error_string;
 305           return false;
 306         }
 307
 308         ret_constr = asn_check_constraints(&asn_DEF_X2N_GTPtunnelEndpoint, &erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint, errbuf, &errbuf_len);
 309         if(ret_constr){
 310           error_string.assign(&errbuf[0], errbuf_len);
 311           error_string = "Error in constraints for GTP tunnel endpoint .. Reason = " + error_string;
 312           return false;
 313         }
 314
 315         ret_constr = asn_check_constraints(&asn_DEF_X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent, &erab_sgnb_present_array[sgnb_present_index], errbuf, &errbuf_len);
 316         if(ret_constr){
 317           error_string.assign(&errbuf[0], errbuf_len);
 318           error_string = "Error in constraints for E_RABS_ToBeAdded_SgNBAddReq_SgNBPDCPpresent.. Reason = " + error_string;
 319           return false;
 320         }
 321
 322         erab_item->resource_configuration.choice.sgNBPDCPpresent = &erab_sgnb_present_array[sgnb_present_index];
 323         sgnb_present_index ++;
 324
 325       }
 326       else if (erab_item->resource_configuration.present ==  X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item__resource_configuration_PR_sgNBPDCPnotpresent){
 327
 328         erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.transportLayerAddress.buf = (*ref_erab_input)[i].sgnb_item.transport_layer_addr;
 329         erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.transportLayerAddress.size = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_size;
 330         erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.transportLayerAddress.bits_unused  = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_unused;
 331
 332         erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.gTP_TEID.buf = (unsigned char *)(*ref_erab_input)[i].sgnb_item.gtp_tei;
 333         erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.gTP_TEID.size = (*ref_erab_input)[i].sgnb_item.gtp_tei_size;
 334
 335         erab_sgnb_notpresent_array[sgnb_notpresent_index].secondary_sgNB_DL_GTP_TEIDatSCG = NULL;
 336
 337         /* validate constraints ..*/
 338         int ret_constr;
 339         ret_constr = asn_check_constraints(&asn_DEF_X2N_GTPtunnelEndpoint, &erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG, errbuf, &errbuf_len);
 340         if(ret_constr){
 341           error_string.assign(&errbuf[0], errbuf_len);
 342           error_string = "Error in constraints for GTP tunnel endpoint .. Reason = " + error_string;
 343           return false;
 344         }
 345
 346
 347         ret_constr = asn_check_constraints(&asn_DEF_X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent, &erab_sgnb_notpresent_array[sgnb_notpresent_index], errbuf, &errbuf_len);
 348         if(ret_constr){
 349           error_string.assign(&errbuf[0], errbuf_len);
 350           error_string = "Error in constraints for E_RABS_ToBeAdded_SgNBAddReq_SgNBPDCPnotpresent.. Reason = " + error_string;
 351           return false;
 352         }
 353
 354         erab_item->resource_configuration.choice.sgNBPDCPnotpresent = &erab_sgnb_notpresent_array[sgnb_notpresent_index]; ;
 355         sgnb_notpresent_index ++;
 356       }
 357       else {
 358         std::cerr <<"Could not find a pdcp present or not present flag. not adding erab item .." << std::endl;
 359         continue;
 360       }
 361
 362       // check constraint
 363       int ret_constr = asn_check_constraints(&asn_DEF_X2N_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs, &erab_admit_array[i], errbuf, &errbuf_len);
 364       if(ret_constr){
 365         error_string.assign(&errbuf[0], errbuf_len);
 366         error_string = "Error in constraints for E_RABS_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs.. Reason = " + error_string;
 367         return false;
 368       }
 369
 370       ASN_SEQUENCE_ADD(erabs_toadd_list, &erab_admit_array[i]);
 371     }
 372   }
 373   else{
 374     ies_sgnb_add_ack->value.present = X2N_SgNBAdditionRequestAcknowledge_IEs__value_PR_NOTHING;
 375   }
 376
 377   ASN_SEQUENCE_ADD(&(sgnb_ack->protocolIEs), &(IE_array[ie_index]));
 378   return true;
 379 }
 380
 381 bool sgnb_addition_response::encode_sgnb_addition_response(unsigned char* data_buf, size_t *data_size, sgnb_addition_helper &sgnb_data, bool sgnb_response)
 382 {
 383
 384   bool res;
 385   if(sgnb_response == true){
 386
 387     x2ap_pdu_obj->present = X2N_X2AP_PDU_PR_successfulOutcome;
 388     x2ap_pdu_obj->choice.successfulOutcome = successMsg;
 389
 390     successMsg->procedureCode = X2N_ProcedureCode_id_sgNBAdditionPreparation;
 391     successMsg->criticality = X2N_Criticality_ignore;
 392     successMsg->value.present = X2N_SuccessfulOutcome__value_PR_SgNBAdditionRequestAcknowledge;
 393
 394     res = set_fields(successMsg, sgnb_data);
 395
 396   } else {
 397
 398     x2ap_pdu_obj->present = X2N_X2AP_PDU_PR_unsuccessfulOutcome;
 399     x2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg;
 400
 401
 402     unsuccessMsg->procedureCode = X2N_ProcedureCode_id_sgNBAdditionPreparation;
 403     unsuccessMsg->criticality = X2N_Criticality_ignore;
 404     unsuccessMsg->value.present = X2N_UnsuccessfulOutcome__value_PR_SgNBAdditionRequestReject;
 405
 406     res = set_fields(unsuccessMsg, sgnb_data);
 407   }
 408
 409   if (!res){
 410     return false;
 411   }
 412
 413   int ret_constr = asn_check_constraints(&asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj, errbuf, &errbuf_len);
 414   if(ret_constr){
 415     error_string.assign(&errbuf[0], errbuf_len);
 416     error_string = "Error : constraints failed for  X2AP Sgnb Addition Response  message. Reason = " + error_string;
 417     return false;
 418   }
 419
 420   //xer_fprint(stdout, &asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);
 421
 422   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj, data_buf, *data_size);
 423   if(retval.encoded == -1){
 424     error_string.assign(strerror(errno));
 425     return false;
 426   }
 427
 428   else {
 429     if(*data_size < retval.encoded){
 430       std::stringstream ss;
 431       ss  <<"Error encoding SgNB Addition Request Response. Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *data_size << std::endl;
 432       error_string = ss.str();
 433       return false;
 434     }
 435   }
 436
 437   *data_size = retval.encoded;
 438   return true;
 439 }
 440
 441