src/X2AP/sgnb_addition_request.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  * ric_indication.h
  20  *
  21  *  Created on: Aug 14, 2019
  22  *      Author: Ashwin Sridharan
  23  */
  24
  25 #include <sgnb_addition_request.hpp>
  26
  27
  28 sgnb_addition_request::sgnb_addition_request(void){
  29   x2ap_pdu_obj = 0;
  30   x2ap_pdu_obj = (X2N_X2AP_PDU_t * )calloc(1, sizeof(X2N_X2AP_PDU_t));
  31   assert(x2ap_pdu_obj != 0);
  32
  33   initMsg = 0;
  34   initMsg = (X2N_InitiatingMessage_t * )calloc(1, sizeof(X2N_InitiatingMessage_t));
  35   assert(initMsg != 0);
  36
  37   IE_array = 0;
  38   IE_array = (X2N_SgNBAdditionRequest_IEs_t *)calloc(NUM_SGNB_ADDITION_REQUEST_IES, sizeof(X2N_SgNBAdditionRequest_IEs_t));
  39   assert(IE_array != 0);
  40
  41   erab_array = 0;
  42   erab_array = (X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t * ) calloc(INITIAL_SIZE, sizeof(X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t));
  43   assert(erab_array != 0);
  44   erab_array_size = INITIAL_SIZE;
  45
  46   erab_sgnb_present_array = 0;
  47   erab_sgnb_present_array = (X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent_t *) calloc(INITIAL_SIZE, sizeof(X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent_t));
  48   assert(erab_sgnb_present_array != 0);
  49   erab_sgnb_present_array_size = INITIAL_SIZE;
  50
  51   erab_sgnb_notpresent_array = 0;
  52   erab_sgnb_notpresent_array = (X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent_t *) calloc(INITIAL_SIZE, sizeof(X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent_t));
  53   assert(erab_sgnb_notpresent_array != 0);
  54   erab_sgnb_notpresent_array_size = INITIAL_SIZE;
  55
  56   x2ap_pdu_obj->present = X2N_X2AP_PDU_PR_initiatingMessage;
  57   x2ap_pdu_obj->choice.initiatingMessage = initMsg;
  58
  59
  60
  61
  62 };
  63
  64
  65 sgnb_addition_request::~sgnb_addition_request(void){
  66
  67   mdclog_write(MDCLOG_DEBUG, "Freeing X2AP SgNB Addition Request object memory");
  68
  69   X2N_E_RABs_ToBeAdded_SgNBAddReqList_t  * erabs_toadd_list = &(IE_array[7].value.choice. E_RABs_ToBeAdded_SgNBAddReqList);
  70   for(int i = 0; i < erabs_toadd_list->list.size; i++){
  71     erabs_toadd_list->list.array[i] = 0;
  72   }
  73
  74
  75   if (erabs_toadd_list->list.size > 0){
  76     free(erabs_toadd_list->list.array);
  77     erabs_toadd_list->list.array = 0;
  78     erabs_toadd_list->list.size = 0;
  79     erabs_toadd_list->list.count= 0;
  80   }
  81
  82   free(erab_sgnb_present_array);
  83
  84   free(erab_sgnb_notpresent_array);
  85
  86   free(erab_array);
  87
  88   // Free BitRate allocation if any
  89   X2N_SgNBAdditionRequest_IEs_t *ies_sgnb_addition_req;
  90   ies_sgnb_addition_req= &IE_array[3];
  91   X2N_UEAggregateMaximumBitRate_t * ue_rates = &(ies_sgnb_addition_req->value.choice.UEAggregateMaximumBitRate);
  92
  93   // clear buffer if previously allocated
  94   if (ue_rates->uEaggregateMaximumBitRateDownlink.size > 0){
  95     ue_rates->uEaggregateMaximumBitRateDownlink.size = 0;
  96     free(ue_rates->uEaggregateMaximumBitRateDownlink.buf);
  97   }
  98
  99
 100   if (ue_rates->uEaggregateMaximumBitRateUplink.size > 0){
 101     ue_rates->uEaggregateMaximumBitRateUplink.size = 0;
 102     free(ue_rates->uEaggregateMaximumBitRateUplink.buf);
 103   }
 104
 105   X2N_SgNBAdditionRequest_t *sgnb_addition  = &(initMsg->value.choice.SgNBAdditionRequest);
 106   for(int i = 0; i < sgnb_addition->protocolIEs.list.size; i++){
 107     sgnb_addition->protocolIEs.list.array[i] = 0;
 108   }
 109
 110
 111   if (sgnb_addition->protocolIEs.list.size > 0){
 112     free(sgnb_addition->protocolIEs.list.array);
 113     sgnb_addition->protocolIEs.list.array = 0;
 114     sgnb_addition->protocolIEs.list.size = 0;
 115   }
 116   free(IE_array);
 117
 118   free(initMsg);
 119
 120   x2ap_pdu_obj->choice.initiatingMessage = 0;
 121   ASN_STRUCT_FREE(asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj);
 122   mdclog_write(MDCLOG_DEBUG, "Freed X2AP SgNB Addition Request object mempory");
 123 }
 124
 125
 126
 127 bool sgnb_addition_request::encode_sgnb_addition_request(unsigned char *buf, size_t *size, sgnb_addition_helper & dinput){
 128
 129   initMsg->procedureCode = X2N_ProcedureCode_id_sgNBAdditionPreparation;
 130   initMsg->criticality = X2N_Criticality_ignore;
 131   initMsg->value.present = X2N_InitiatingMessage__value_PR_SgNBAdditionRequest;
 132
 133   bool res;
 134
 135   res = set_fields(dinput);
 136   if (!res){
 137     return false;
 138   }
 139   mdclog_write(MDCLOG_DEBUG, "Set Sgnb Addition Request fields from helper data\n");
 140
 141   int ret_constr = asn_check_constraints(&asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj, errbuf, &errbuf_len);
 142   if(ret_constr){
 143     error_string.assign(&errbuf[0], errbuf_len);
 144     error_string = "Error encoding X2AP Sgnb Addition Request  message. Reason = " + error_string;
 145     return false;
 146   }
 147   mdclog_write(MDCLOG_DEBUG, "Checked SgNB Addition Data constraints \n");
 148
 149   //xer_fprint(stdout, &asn_DEF_X2AP_PDU, x2ap_pdu_obj);
 150
 151
 152   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj, buf, *size);
 153   if(retval.encoded == -1){
 154     error_string.assign(strerror(errno));
 155     return false;
 156   }
 157
 158   else {
 159     if(*size < retval.encoded){
 160       std::stringstream ss;
 161       ss  <<"Error encoding SgNB Addition Request definition. Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 162       error_string = ss.str();
 163       return false;
 164     }
 165   }
 166
 167   *size = retval.encoded;
 168   return true;
 169
 170 }
 171
 172
 173 bool sgnb_addition_request::set_fields( sgnb_addition_helper &dinput){
 174
 175   unsigned ie_index = 0;
 176
 177   X2N_SgNBAdditionRequest_t * ric_indication = &(initMsg->value.choice.SgNBAdditionRequest);
 178   // reset list count
 179   ric_indication->protocolIEs.list.count = 0;
 180
 181   X2N_SgNBAdditionRequest_IEs_t *ies_sgnb_addition_req;
 182
 183   ie_index = 0;
 184   ies_sgnb_addition_req= &IE_array[ie_index];
 185   ies_sgnb_addition_req->criticality = X2N_Criticality_reject;
 186   ies_sgnb_addition_req->id = X2N_ProtocolIE_ID_id_MeNB_UE_X2AP_ID;
 187   ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_UE_X2AP_ID;
 188   ies_sgnb_addition_req->value.choice.UE_X2AP_ID = dinput.menb_ue_x2ap_id;
 189   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 190
 191   ie_index = 1;
 192   ies_sgnb_addition_req= &IE_array[ie_index];
 193   ies_sgnb_addition_req->criticality = X2N_Criticality_reject;
 194   ies_sgnb_addition_req->id = X2N_ProtocolIE_ID_id_NRUESecurityCapabilities;
 195   ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_NRUESecurityCapabilities;
 196   X2N_NRUESecurityCapabilities_t * nrue_sec = &(ies_sgnb_addition_req->value.choice.NRUESecurityCapabilities);
 197
 198   nrue_sec->nRencryptionAlgorithms.buf =dinput.encryption_algs;
 199   nrue_sec->nRencryptionAlgorithms.size = dinput.encryption_algs_size;
 200   nrue_sec->nRencryptionAlgorithms.bits_unused = dinput.encryption_algs_unused;
 201
 202   nrue_sec->nRintegrityProtectionAlgorithms.buf = dinput.integrity_protection_algs;
 203   nrue_sec->nRintegrityProtectionAlgorithms.size = dinput.integrity_protection_algs_size;
 204   nrue_sec->nRintegrityProtectionAlgorithms.bits_unused = dinput.integrity_protection_algs_unused;
 205   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 206
 207
 208   ie_index = 2;
 209   ies_sgnb_addition_req= &IE_array[ie_index];
 210   ies_sgnb_addition_req->criticality = X2N_Criticality_reject;
 211   ies_sgnb_addition_req->id = X2N_ProtocolIE_ID_id_SgNBSecurityKey ;
 212   ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_SgNBSecurityKey;
 213   X2N_SgNBSecurityKey_t * sgnb_sec = &(ies_sgnb_addition_req->value.choice.SgNBSecurityKey);
 214
 215   sgnb_sec->buf = dinput.sgnb_security_key;
 216   sgnb_sec->size = dinput.sgnb_security_key_size;
 217   sgnb_sec->bits_unused = dinput.sgnb_security_key_unused;
 218   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 219
 220   ie_index = 3;
 221   ies_sgnb_addition_req= &IE_array[ie_index];
 222   ies_sgnb_addition_req->criticality = X2N_Criticality_reject;
 223   ies_sgnb_addition_req->id = X2N_ProtocolIE_ID_id_SgNBUEAggregateMaximumBitRate;
 224   ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_UEAggregateMaximumBitRate;
 225   X2N_UEAggregateMaximumBitRate_t * ue_rates = &(ies_sgnb_addition_req->value.choice.UEAggregateMaximumBitRate);
 226
 227   // clear buffer if previously allocated
 228   if (ue_rates->uEaggregateMaximumBitRateDownlink.size > 0){
 229     ue_rates->uEaggregateMaximumBitRateDownlink.size = 0;
 230     free(ue_rates->uEaggregateMaximumBitRateDownlink.buf);
 231     ue_rates->uEaggregateMaximumBitRateDownlink.buf = 0;
 232   }
 233
 234   if (ue_rates->uEaggregateMaximumBitRateUplink.size > 0){
 235     ue_rates->uEaggregateMaximumBitRateUplink.size = 0;
 236     free(ue_rates->uEaggregateMaximumBitRateUplink.buf);
 237     ue_rates->uEaggregateMaximumBitRateUplink.buf = 0;
 238   }
 239
 240   asn_long2INTEGER(&(ue_rates->uEaggregateMaximumBitRateDownlink), dinput.bit_rate_max_dn);
 241   asn_long2INTEGER(&(ue_rates->uEaggregateMaximumBitRateUplink),   dinput.bit_rate_max_up);
 242   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 243
 244   ie_index = 4;
 245   ies_sgnb_addition_req= &IE_array[ie_index];
 246   ies_sgnb_addition_req->criticality = X2N_Criticality_reject;
 247   ies_sgnb_addition_req->id =  X2N_ProtocolIE_ID_id_MeNBtoSgNBContainer  ;
 248   ies_sgnb_addition_req->value.present =  X2N_SgNBAdditionRequest_IEs__value_PR_MeNBtoSgNBContainer;
 249   X2N_MeNBtoSgNBContainer_t * metosg_container = &(ies_sgnb_addition_req->value.choice.MeNBtoSgNBContainer);
 250
 251   metosg_container->buf = dinput.menb_sgnb_container;
 252   metosg_container->size = dinput.menb_sgnb_container_size;
 253   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 254
 255   ie_index = 5;
 256   ies_sgnb_addition_req= &IE_array[ie_index];
 257   ies_sgnb_addition_req->criticality = X2N_Criticality_reject;
 258   ies_sgnb_addition_req->id = X2N_ProtocolIE_ID_id_MeNBCell_ID ;
 259   ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_ECGI;
 260   X2N_ECGI_t * menb_ecgi = &(ies_sgnb_addition_req->value.choice.ECGI);
 261
 262   menb_ecgi->pLMN_Identity.buf = dinput.plmn_identity;
 263   menb_ecgi->pLMN_Identity.size = dinput.plmn_identity_size;
 264
 265   menb_ecgi->eUTRANcellIdentifier.buf = dinput.eutran_identifier;
 266   menb_ecgi->eUTRANcellIdentifier.size = dinput.eutran_identifier_size;
 267   menb_ecgi->eUTRANcellIdentifier.bits_unused = 4;
 268   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 269
 270   ie_index = 6;
 271   ies_sgnb_addition_req = &IE_array[ie_index];
 272   ies_sgnb_addition_req->criticality = X2N_Criticality_reject;
 273   ies_sgnb_addition_req->id =  X2N_ProtocolIE_ID_id_SubscriberProfileIDforRFP;
 274   ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_SubscriberProfileIDforRFP;
 275   ies_sgnb_addition_req->value.choice.SubscriberProfileIDforRFP = dinput.subscriber_profile_id;
 276   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 277
 278   // add erab-to-be-added list
 279   ie_index = 7;
 280   ies_sgnb_addition_req= &IE_array[ie_index];
 281   ies_sgnb_addition_req->criticality = X2N_Criticality_reject;
 282   ies_sgnb_addition_req->id =  X2N_ProtocolIE_ID_id_E_RABs_ToBeAdded_SgNBAddReqList;
 283   std::vector<struct erab_item> * ref_erab_input  = &(dinput.erab_list);
 284   if(ref_erab_input->size() > 0){
 285
 286     ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_E_RABs_ToBeAdded_SgNBAddReqList;
 287
 288     X2N_E_RABs_ToBeAdded_SgNBAddReqList_t  * erabs_toadd_list = &(ies_sgnb_addition_req->value.choice.E_RABs_ToBeAdded_SgNBAddReqList);
 289     erabs_toadd_list->list.count = 0;
 290
 291
 292     // resize memory ?
 293     if (ref_erab_input->size() >= erab_array_size){
 294       erab_array_size = 2 * ref_erab_input->size();
 295       free(erab_array );
 296       erab_array = (X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t * ) calloc(erab_array_size, sizeof(X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t));
 297       assert(erab_array != 0);
 298       erab_array_size = INITIAL_SIZE;
 299
 300       erab_sgnb_present_array_size = 2 * ref_erab_input->size();
 301       free(erab_sgnb_present_array);
 302       erab_sgnb_present_array = (X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent_t *) calloc(erab_sgnb_present_array_size, sizeof(X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent_t));
 303       assert(erab_sgnb_present_array != 0);
 304
 305       erab_sgnb_notpresent_array_size = 2 * ref_erab_input->size();
 306       free(erab_sgnb_notpresent_array);
 307       erab_sgnb_notpresent_array = (X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent_t *) calloc(  erab_sgnb_notpresent_array_size, sizeof(X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent_t));
 308       assert(erab_sgnb_notpresent_array != 0);
 309
 310     }
 311
 312     int sgnb_present_index = 0;
 313     int sgnb_notpresent_index = 0;
 314
 315     for(unsigned int i = 0; i < ref_erab_input->size(); i++){
 316
 317
 318       erab_array[i].id = X2N_ProtocolIE_ID_id_E_RABs_ToBeAdded_SgNBAddReq_Item ;
 319       erab_array[i].criticality = X2N_Criticality_reject;
 320       erab_array[i].value.present =  X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs__value_PR_E_RABs_ToBeAdded_SgNBAddReq_Item;
 321       X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_t * erab_item = &(erab_array[i].value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item);
 322
 323       erab_item->e_RAB_ID = (*ref_erab_input)[i].erab_id;
 324       erab_item->drb_ID = (*ref_erab_input)[i].drb_id;
 325
 326       erab_item->en_DC_ResourceConfiguration.pDCPatSgNB =  (*ref_erab_input)[i].pdcp_at_sgnb;
 327       erab_item->en_DC_ResourceConfiguration.mCGresources =  (*ref_erab_input)[i].mcg_resources;
 328       erab_item->en_DC_ResourceConfiguration.sCGresources =  (*ref_erab_input)[i].scg_resources;
 329
 330       erab_item->resource_configuration.present = (X2N_E_RABs_ToBeAdded_SgNBAddReq_Item__resource_configuration_PR)(*ref_erab_input)[i].sgnb_pdcp_present;
 331
 332       if( erab_item->resource_configuration.present == X2N_E_RABs_ToBeAdded_SgNBAddReq_Item__resource_configuration_PR_sgNBPDCPpresent){
 333         erab_sgnb_present_array[sgnb_present_index].full_E_RAB_Level_QoS_Parameters.qCI = (*ref_erab_input)[i].sgnb_item.qci;
 334         erab_sgnb_present_array[sgnb_present_index].full_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.priorityLevel = (*ref_erab_input)[i].sgnb_item.priority_level;
 335         erab_sgnb_present_array[sgnb_present_index].full_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionCapability = (*ref_erab_input)[i].sgnb_item.pre_emption_capability;
 336         erab_sgnb_present_array[sgnb_present_index].full_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionVulnerability = (*ref_erab_input)[i].sgnb_item.pre_emption_vulnerability;
 337
 338         erab_sgnb_present_array[sgnb_present_index].s1_UL_GTPtunnelEndpoint.transportLayerAddress.buf = (*ref_erab_input)[i].sgnb_item.transport_layer_addr;
 339         erab_sgnb_present_array[sgnb_present_index].s1_UL_GTPtunnelEndpoint.transportLayerAddress.size = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_size;
 340         erab_sgnb_present_array[sgnb_present_index].s1_UL_GTPtunnelEndpoint.transportLayerAddress.bits_unused  = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_unused;
 341
 342         erab_sgnb_present_array[sgnb_present_index].s1_UL_GTPtunnelEndpoint.gTP_TEID.buf = (*ref_erab_input)[i].sgnb_item.gtp_tei;
 343         erab_sgnb_present_array[sgnb_present_index].s1_UL_GTPtunnelEndpoint.gTP_TEID.size = (*ref_erab_input)[i].sgnb_item.gtp_tei_size;
 344
 345         /* Force all optional parameters that are not set to NULL */
 346         erab_sgnb_present_array[sgnb_present_index].max_MCG_admit_E_RAB_Level_QoS_Parameters = NULL;
 347         erab_sgnb_present_array[sgnb_present_index].dL_Forwarding = NULL;
 348         erab_sgnb_present_array[sgnb_present_index].meNB_DL_GTP_TEIDatMCG = NULL;
 349
 350
 351         erab_item->resource_configuration.choice.sgNBPDCPpresent = &erab_sgnb_present_array[sgnb_present_index];
 352         sgnb_present_index ++;
 353
 354       }
 355       else if (erab_item->resource_configuration.present ==  X2N_E_RABs_ToBeAdded_SgNBAddReq_Item__resource_configuration_PR_sgNBPDCPnotpresent){
 356
 357         erab_sgnb_notpresent_array[sgnb_notpresent_index].requested_SCG_E_RAB_Level_QoS_Parameters.qCI = (*ref_erab_input)[i].sgnb_item.qci;
 358         erab_sgnb_notpresent_array[sgnb_notpresent_index].requested_SCG_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.priorityLevel = (*ref_erab_input)[i].sgnb_item.priority_level;
 359         erab_sgnb_notpresent_array[sgnb_notpresent_index].requested_SCG_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionCapability = (*ref_erab_input)[i].sgnb_item.pre_emption_capability;
 360         erab_sgnb_notpresent_array[sgnb_notpresent_index].requested_SCG_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionVulnerability = (*ref_erab_input)[i].sgnb_item.pre_emption_vulnerability;
 361         erab_sgnb_notpresent_array[sgnb_notpresent_index].requested_SCG_E_RAB_Level_QoS_Parameters.gbrQosInformation = 0;
 362
 363         erab_sgnb_notpresent_array[sgnb_notpresent_index].meNB_UL_GTP_TEIDatPDCP.transportLayerAddress.buf = (*ref_erab_input)[i].sgnb_item.transport_layer_addr;
 364         erab_sgnb_notpresent_array[sgnb_notpresent_index].meNB_UL_GTP_TEIDatPDCP.transportLayerAddress.size = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_size;
 365         erab_sgnb_notpresent_array[sgnb_notpresent_index].meNB_UL_GTP_TEIDatPDCP.transportLayerAddress.bits_unused  = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_unused;
 366
 367         erab_sgnb_notpresent_array[sgnb_notpresent_index].meNB_UL_GTP_TEIDatPDCP.gTP_TEID.buf = (unsigned char *)(*ref_erab_input)[i].sgnb_item.gtp_tei;
 368         erab_sgnb_notpresent_array[sgnb_notpresent_index].meNB_UL_GTP_TEIDatPDCP.gTP_TEID.size = (*ref_erab_input)[i].sgnb_item.gtp_tei_size;
 369
 370         erab_sgnb_notpresent_array[sgnb_notpresent_index].rlc_Mode = (*ref_erab_input)[i].sgnb_item.rlc_mode;
 371
 372         /* Force all optional parameters that are not set to NULL */
 373         erab_sgnb_notpresent_array[sgnb_notpresent_index].uL_Configuration = 0;
 374         erab_sgnb_notpresent_array[sgnb_notpresent_index].secondary_meNB_UL_GTP_TEIDatPDCP = 0;
 375
 376         erab_item->resource_configuration.choice.sgNBPDCPnotpresent = &erab_sgnb_notpresent_array[sgnb_notpresent_index]; ;
 377         sgnb_notpresent_index ++;
 378       }
 379       else{
 380         continue;
 381       }
 382
 383       // check constraint
 384       int ret_constr = asn_check_constraints(&asn_DEF_X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs, &erab_array[i], errbuf, &errbuf_len);
 385       if(ret_constr){
 386         error_string.assign(&errbuf[0], errbuf_len);
 387         error_string = std::string(__FILE__) + "," + std::to_string(__LINE__) + " Error in constraints for E_RABS_ToBeAdded_SgNBAddReq_ItemIEs.. Reason = " + error_string;
 388         return false;
 389       }
 390
 391       ASN_SEQUENCE_ADD(erabs_toadd_list, &erab_array[i]);
 392
 393       // for(unsigned int k = 0; k < erabs_toadd_list->list.count ;k++){
 394       //        std::cout <<"Added erab address = " << erabs_toadd_list->list.array[k] << std::endl;
 395       // }
 396       // std::cout <<"--------------------------" << std::endl;
 397     }
 398
 399   }
 400   else{
 401     ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_NOTHING;
 402   }
 403   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 404
 405   return true;
 406
 407 }
 408
 409
 410 bool sgnb_addition_request::get_fields(X2N_InitiatingMessage_t * init_msg, sgnb_addition_helper & dout){
 411
 412   if (init_msg == 0){
 413     error_string = "Error ! Invalid reference for SgNB Addition Request get_fields";
 414     return false;
 415   }
 416
 417   dout.clear();
 418   int res = 0;
 419
 420   struct erab_item * eitem;
 421   std::vector<struct erab_item> *erab_list;
 422
 423   X2N_SgNBAdditionRequest_IEs_t *memb_ptr;
 424   for(int edx = 0; edx < init_msg->value.choice.SgNBAdditionRequest.protocolIEs.list.count; edx++){
 425     memb_ptr = init_msg->value.choice.SgNBAdditionRequest.protocolIEs.list.array[edx];
 426
 427     switch(memb_ptr->id){
 428
 429     case (X2N_ProtocolIE_ID_id_MeNB_UE_X2AP_ID):
 430       dout.menb_ue_x2ap_id = memb_ptr->value.choice.UE_X2AP_ID;
 431       break;
 432
 433     case (X2N_ProtocolIE_ID_id_SelectedPLMN):
 434       dout.selected_plmn = memb_ptr->value.choice.PLMN_Identity.buf;
 435       dout.selected_plmn_size = memb_ptr->value.choice.PLMN_Identity.size;
 436       break;
 437
 438     case (X2N_ProtocolIE_ID_id_NRUESecurityCapabilities):
 439       dout.encryption_algs = memb_ptr->value.choice.NRUESecurityCapabilities.nRencryptionAlgorithms.buf;
 440       dout.encryption_algs_size = memb_ptr->value.choice.NRUESecurityCapabilities.nRencryptionAlgorithms.size;
 441       dout.encryption_algs_unused = memb_ptr->value.choice.NRUESecurityCapabilities.nRencryptionAlgorithms.bits_unused;
 442
 443       dout.integrity_protection_algs= memb_ptr->value.choice.NRUESecurityCapabilities.nRintegrityProtectionAlgorithms.buf;
 444       dout.integrity_protection_algs_size = memb_ptr->value.choice.NRUESecurityCapabilities.nRintegrityProtectionAlgorithms.size;
 445       dout.integrity_protection_algs_unused = memb_ptr->value.choice.NRUESecurityCapabilities.nRintegrityProtectionAlgorithms.bits_unused;
 446
 447       break;
 448
 449     case (X2N_ProtocolIE_ID_id_SgNBSecurityKey):
 450       dout.sgnb_security_key = memb_ptr->value.choice.SgNBSecurityKey.buf;
 451       dout.sgnb_security_key_size = memb_ptr->value.choice.SgNBSecurityKey.size;
 452       dout.sgnb_security_key_unused = memb_ptr->value.choice.SgNBSecurityKey.bits_unused;
 453
 454       break;
 455
 456     case (X2N_ProtocolIE_ID_id_SgNBUEAggregateMaximumBitRate):
 457       res = asn_INTEGER2long(&(memb_ptr->value.choice.UEAggregateMaximumBitRate.uEaggregateMaximumBitRateDownlink), &dout.bit_rate_max_dn );
 458       if (res == -1){
 459         error_string = "Error converting uEaggregateMaximumBitRateDownlink ";
 460         return false;
 461       }
 462
 463       res = asn_INTEGER2long(&(memb_ptr->value.choice.UEAggregateMaximumBitRate.uEaggregateMaximumBitRateUplink), &dout.bit_rate_max_up );
 464       if (res == -1){
 465         error_string = "Error converting uEaggregateMaximumBitRateUplink ";
 466         return false;
 467       }
 468
 469
 470       break;
 471
 472     case (X2N_ProtocolIE_ID_id_MeNBtoSgNBContainer):
 473       dout.menb_sgnb_container = memb_ptr->value.choice.MeNBtoSgNBContainer.buf;
 474       dout.menb_sgnb_container_size = memb_ptr->value.choice.MeNBtoSgNBContainer.size;
 475       break;
 476
 477     case (X2N_ProtocolIE_ID_id_SgNB_UE_X2AP_ID):
 478       dout.sgnb_ue_x2ap_id = memb_ptr->value.choice.SgNB_UE_X2AP_ID;
 479       break;
 480
 481     case (X2N_ProtocolIE_ID_id_SubscriberProfileIDforRFP):
 482       //sgnb->subscriberprofileidforrfp = memb_ptr->value.choice.SubscriberProfileIDforRFP;
 483       break;
 484
 485     case (X2N_ProtocolIE_ID_id_MeNBCell_ID):
 486
 487       dout.eutran_identifier = memb_ptr->value.choice.ECGI.eUTRANcellIdentifier.buf;
 488       dout.eutran_identifier_size = memb_ptr->value.choice.ECGI.eUTRANcellIdentifier.size;
 489       dout.eutran_identifier_unused = memb_ptr->value.choice.ECGI.eUTRANcellIdentifier.bits_unused;
 490
 491       dout.plmn_identity = memb_ptr->value.choice.ECGI.pLMN_Identity.buf;
 492       dout.plmn_identity_size = memb_ptr->value.choice.ECGI.pLMN_Identity.size;
 493       break;
 494
 495     case (X2N_ProtocolIE_ID_id_E_RABs_ToBeAdded_SgNBAddReqList):
 496
 497       erab_list = & dout.erab_list;
 498
 499       for(int erabs=0; erabs < memb_ptr->value.choice.E_RABs_ToBeAdded_SgNBAddReqList.list.count;erabs++){
 500         X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t * erab_item_ie = (X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t *)memb_ptr->value.choice.E_RABs_ToBeAdded_SgNBAddReqList.list.array[erabs];
 501
 502         erab_list->emplace_back();
 503         eitem = &(*erab_list)[erabs];
 504
 505         //erab_item *eitem = (erab_item*)calloc(1, sizeof(erab_item));
 506
 507         eitem->drb_id = erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.drb_ID;
 508         eitem->erab_id = erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.e_RAB_ID;
 509
 510         eitem->mcg_resources = erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.en_DC_ResourceConfiguration.mCGresources;
 511         eitem->scg_resources = erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.en_DC_ResourceConfiguration.sCGresources;
 512         eitem->pdcp_at_sgnb = erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.en_DC_ResourceConfiguration.pDCPatSgNB;
 513         eitem->sgnb_pdcp_present = erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.resource_configuration.present;
 514
 515         if(erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.resource_configuration.present == X2N_E_RABs_ToBeAdded_SgNBAddReq_Item__resource_configuration_PR_sgNBPDCPpresent){
 516
 517           X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPpresent_t *erab_sgnb_present_ie = erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.resource_configuration.choice.sgNBPDCPpresent;
 518
 519           eitem->sgnb_item.qci = erab_sgnb_present_ie->full_E_RAB_Level_QoS_Parameters.qCI;
 520           eitem->sgnb_item.priority_level = erab_sgnb_present_ie->full_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.priorityLevel;
 521           eitem->sgnb_item.pre_emption_capability = erab_sgnb_present_ie->full_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionCapability;
 522           eitem->sgnb_item.pre_emption_vulnerability = erab_sgnb_present_ie->full_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionVulnerability;
 523
 524
 525           eitem->sgnb_item.gtp_tei =  erab_sgnb_present_ie->s1_UL_GTPtunnelEndpoint.gTP_TEID.buf;
 526           eitem->sgnb_item.gtp_tei_size = erab_sgnb_present_ie->s1_UL_GTPtunnelEndpoint.gTP_TEID.size;
 527
 528           eitem->sgnb_item.transport_layer_addr = erab_sgnb_present_ie->s1_UL_GTPtunnelEndpoint.transportLayerAddress.buf;
 529           eitem->sgnb_item.transport_layer_addr_size = erab_sgnb_present_ie->s1_UL_GTPtunnelEndpoint.transportLayerAddress.size;
 530           eitem->sgnb_item.transport_layer_addr_unused = erab_sgnb_present_ie->s1_UL_GTPtunnelEndpoint.transportLayerAddress.bits_unused;
 531
 532
 533         }
 534         else if(erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.resource_configuration.present == X2N_E_RABs_ToBeAdded_SgNBAddReq_Item__resource_configuration_PR_sgNBPDCPnotpresent){
 535           X2N_E_RABs_ToBeAdded_SgNBAddReq_Item_SgNBPDCPnotpresent_t *erab_sgnb_notpresent_ie = erab_item_ie->value.choice.E_RABs_ToBeAdded_SgNBAddReq_Item.resource_configuration.choice.sgNBPDCPnotpresent;
 536           eitem->sgnb_item.rlc_mode = erab_sgnb_notpresent_ie->rlc_Mode;
 537           eitem->sgnb_item.gtp_tei = erab_sgnb_notpresent_ie->meNB_UL_GTP_TEIDatPDCP.gTP_TEID.buf;
 538           eitem->sgnb_item.gtp_tei_size = erab_sgnb_notpresent_ie->meNB_UL_GTP_TEIDatPDCP.gTP_TEID.size;
 539           eitem->sgnb_item.transport_layer_addr = erab_sgnb_notpresent_ie->meNB_UL_GTP_TEIDatPDCP.transportLayerAddress.buf;
 540           eitem->sgnb_item.transport_layer_addr_size = erab_sgnb_notpresent_ie->meNB_UL_GTP_TEIDatPDCP.transportLayerAddress.size;
 541           eitem->sgnb_item.transport_layer_addr_unused = erab_sgnb_notpresent_ie->meNB_UL_GTP_TEIDatPDCP.transportLayerAddress.bits_unused;
 542
 543           eitem->sgnb_item.qci = erab_sgnb_notpresent_ie->requested_SCG_E_RAB_Level_QoS_Parameters.qCI;
 544           eitem->sgnb_item.pre_emption_capability = erab_sgnb_notpresent_ie->requested_SCG_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionCapability;
 545           eitem->sgnb_item.pre_emption_vulnerability = erab_sgnb_notpresent_ie->requested_SCG_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.pre_emptionVulnerability;
 546           eitem->sgnb_item.priority_level = erab_sgnb_notpresent_ie->requested_SCG_E_RAB_Level_QoS_Parameters.allocationAndRetentionPriority.priorityLevel;
 547
 548         }
 549         else{
 550           mdclog_write(MDCLOG_ERR, "Error :: %s, %d :: E-RAB does not have sgNBPDCP present/not present set flag", __FILE__, __LINE__);
 551           return false;
 552         }
 553
 554       }
 555
 556       break;
 557
 558     default:
 559       break;
 560
 561     }
 562
 563   }
 564   return true;
 565 }