2 ==================================================================================
3 Copyright (c) 2018-2019 AT&T Intellectual Property.
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
9 http://www.apache.org/licenses/LICENSE-2.0
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 ==================================================================================
21 * Created on: Aug 14, 2019
22 * Author: Ashwin Sridharan
25 #include <sgnb_addition_request.hpp>
28 sgnb_addition_request::sgnb_addition_request(void){
30 x2ap_pdu_obj = (X2N_X2AP_PDU_t * )calloc(1, sizeof(X2N_X2AP_PDU_t));
31 assert(x2ap_pdu_obj != 0);
34 initMsg = (X2N_InitiatingMessage_t * )calloc(1, sizeof(X2N_InitiatingMessage_t));
38 IE_array = (X2N_SgNBAdditionRequest_IEs_t *)calloc(NUM_SGNB_ADDITION_REQUEST_IES, sizeof(X2N_SgNBAdditionRequest_IEs_t));
39 assert(IE_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;
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;
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;
56 x2ap_pdu_obj->present = X2N_X2AP_PDU_PR_initiatingMessage;
57 x2ap_pdu_obj->choice.initiatingMessage = initMsg;
65 sgnb_addition_request::~sgnb_addition_request(void){
67 mdclog_write(MDCLOG_DEBUG, "Freeing X2AP SgNB Addition Request object memory");
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;
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;
82 free(erab_sgnb_present_array);
84 free(erab_sgnb_notpresent_array);
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);
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);
100 if (ue_rates->uEaggregateMaximumBitRateUplink.size > 0){
101 ue_rates->uEaggregateMaximumBitRateUplink.size = 0;
102 free(ue_rates->uEaggregateMaximumBitRateUplink.buf);
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;
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;
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");
127 bool sgnb_addition_request::encode_sgnb_addition_request(unsigned char *buf, size_t *size, sgnb_addition_helper & dinput){
129 initMsg->procedureCode = X2N_ProcedureCode_id_sgNBAdditionPreparation;
130 initMsg->criticality = X2N_Criticality_ignore;
131 initMsg->value.present = X2N_InitiatingMessage__value_PR_SgNBAdditionRequest;
135 res = set_fields(dinput);
139 mdclog_write(MDCLOG_DEBUG, "Set Sgnb Addition Request fields from helper data\n");
141 int ret_constr = asn_check_constraints(&asn_DEF_X2N_X2AP_PDU, x2ap_pdu_obj, errbuf, &errbuf_len);
143 error_string.assign(&errbuf[0], errbuf_len);
144 error_string = "Error encoding X2AP Sgnb Addition Request message. Reason = " + error_string;
147 mdclog_write(MDCLOG_DEBUG, "Checked SgNB Addition Data constraints \n");
149 //xer_fprint(stdout, &asn_DEF_X2AP_PDU, x2ap_pdu_obj);
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));
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();
167 *size = retval.encoded;
173 bool sgnb_addition_request::set_fields( sgnb_addition_helper &dinput){
175 unsigned ie_index = 0;
177 X2N_SgNBAdditionRequest_t * ric_indication = &(initMsg->value.choice.SgNBAdditionRequest);
179 ric_indication->protocolIEs.list.count = 0;
181 X2N_SgNBAdditionRequest_IEs_t *ies_sgnb_addition_req;
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]));
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);
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;
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]));
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);
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]));
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);
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;
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;
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]));
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);
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]));
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);
262 menb_ecgi->pLMN_Identity.buf = dinput.plmn_identity;
263 menb_ecgi->pLMN_Identity.size = dinput.plmn_identity_size;
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]));
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]));
278 // add erab-to-be-added list
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){
286 ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_E_RABs_ToBeAdded_SgNBAddReqList;
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;
293 if (ref_erab_input->size() >= erab_array_size){
294 erab_array_size = 2 * ref_erab_input->size();
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;
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);
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);
312 int sgnb_present_index = 0;
313 int sgnb_notpresent_index = 0;
315 for(unsigned int i = 0; i < ref_erab_input->size(); i++){
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);
323 erab_item->e_RAB_ID = (*ref_erab_input)[i].erab_id;
324 erab_item->drb_ID = (*ref_erab_input)[i].drb_id;
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;
330 erab_item->resource_configuration.present = (X2N_E_RABs_ToBeAdded_SgNBAddReq_Item__resource_configuration_PR)(*ref_erab_input)[i].sgnb_pdcp_present;
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;
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;
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;
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;
351 erab_item->resource_configuration.choice.sgNBPDCPpresent = &erab_sgnb_present_array[sgnb_present_index];
352 sgnb_present_index ++;
355 else if (erab_item->resource_configuration.present == X2N_E_RABs_ToBeAdded_SgNBAddReq_Item__resource_configuration_PR_sgNBPDCPnotpresent){
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;
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;
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;
370 erab_sgnb_notpresent_array[sgnb_notpresent_index].rlc_Mode = (*ref_erab_input)[i].sgnb_item.rlc_mode;
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;
376 erab_item->resource_configuration.choice.sgNBPDCPnotpresent = &erab_sgnb_notpresent_array[sgnb_notpresent_index]; ;
377 sgnb_notpresent_index ++;
384 int ret_constr = asn_check_constraints(&asn_DEF_X2N_E_RABs_ToBeAdded_SgNBAddReq_ItemIEs, &erab_array[i], errbuf, &errbuf_len);
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;
391 ASN_SEQUENCE_ADD(erabs_toadd_list, &erab_array[i]);
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;
396 // std::cout <<"--------------------------" << std::endl;
401 ies_sgnb_addition_req->value.present = X2N_SgNBAdditionRequest_IEs__value_PR_NOTHING;
403 ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
410 bool sgnb_addition_request::get_fields(X2N_InitiatingMessage_t * init_msg, sgnb_addition_helper & dout){
413 error_string = "Error ! Invalid reference for SgNB Addition Request get_fields";
420 struct erab_item * eitem;
421 std::vector<struct erab_item> *erab_list;
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];
427 switch(memb_ptr->id){
429 case (X2N_ProtocolIE_ID_id_MeNB_UE_X2AP_ID):
430 dout.menb_ue_x2ap_id = memb_ptr->value.choice.UE_X2AP_ID;
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;
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;
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;
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;
456 case (X2N_ProtocolIE_ID_id_SgNBUEAggregateMaximumBitRate):
457 res = asn_INTEGER2long(&(memb_ptr->value.choice.UEAggregateMaximumBitRate.uEaggregateMaximumBitRateDownlink), &dout.bit_rate_max_dn );
459 error_string = "Error converting uEaggregateMaximumBitRateDownlink ";
463 res = asn_INTEGER2long(&(memb_ptr->value.choice.UEAggregateMaximumBitRate.uEaggregateMaximumBitRateUplink), &dout.bit_rate_max_up );
465 error_string = "Error converting uEaggregateMaximumBitRateUplink ";
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;
477 case (X2N_ProtocolIE_ID_id_SgNB_UE_X2AP_ID):
478 dout.sgnb_ue_x2ap_id = memb_ptr->value.choice.SgNB_UE_X2AP_ID;
481 case (X2N_ProtocolIE_ID_id_SubscriberProfileIDforRFP):
482 dout.subscriber_profile_id = memb_ptr->value.choice.SubscriberProfileIDforRFP;
485 case (X2N_ProtocolIE_ID_id_MeNBCell_ID):
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;
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;
495 case (X2N_ProtocolIE_ID_id_E_RABs_ToBeAdded_SgNBAddReqList):
497 erab_list = & dout.erab_list;
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];
502 erab_list->emplace_back();
503 eitem = &(*erab_list)[erabs];
505 //erab_item *eitem = (erab_item*)calloc(1, sizeof(erab_item));
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;
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;
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){
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;
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;
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;
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;
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;
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;
550 mdclog_write(MDCLOG_ERR, "Error :: %s, %d :: E-RAB does not have sgNBPDCP present/not present set flag", __FILE__, __LINE__);