4 ==================================================================================
5 Copyright (c) 2018-2019 AT&T Intellectual Property.
7 Licensed under the Apache License, Version 2.0 (the "License");
8 you may not use this file except in compliance with the License.
9 You may obtain a copy of the License at
11 http://www.apache.org/licenses/LICENSE-2.0
13 Unless required by applicable law or agreed to in writing, software
14 distributed under the License is distributed on an "AS IS" BASIS,
15 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 See the License for the specific language governing permissions and
17 limitations under the License.
18 ==================================================================================
22 #include "subscription_response.hpp"
24 /* The xAPP need only worry about the get_fields from a response, since it does
25 not generate a response. Generating response however is included to support testing.
29 // Primarly for generation
30 subscription_response::subscription_response(void){
33 e2ap_pdu_obj = (E2N_E2AP_PDU_t *)calloc(1, sizeof(E2N_E2AP_PDU_t));
34 assert(e2ap_pdu_obj != 0);
37 successMsg = (E2N_SuccessfulOutcome_t *)calloc(1, sizeof(E2N_SuccessfulOutcome_t));
38 assert(successMsg != 0);
41 unsuccessMsg = (E2N_UnsuccessfulOutcome_t *)calloc(1, sizeof(E2N_UnsuccessfulOutcome_t));
42 assert(unsuccessMsg != 0);
45 IE_array = (E2N_RICsubscriptionResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_RESPONSE_IES, sizeof(E2N_RICsubscriptionResponse_IEs_t));
46 assert(IE_array != 0);
49 IE_Failure_array = (E2N_RICsubscriptionFailure_IEs_t *)calloc(NUM_SUBSCRIPTION_FAILURE_IES, sizeof(E2N_RICsubscriptionFailure_IEs_t));
50 assert(IE_Failure_array != 0);
53 ie_admitted_list = (E2N_RICaction_Admitted_ItemIEs_t *)calloc(INITIAL_RESPONSE_LIST_SIZE, sizeof(E2N_RICaction_Admitted_ItemIEs_t));
54 assert(ie_admitted_list != 0);
55 ie_admitted_list_size = INITIAL_RESPONSE_LIST_SIZE;
57 ie_not_admitted_list = 0;
58 ie_not_admitted_list = (E2N_RICaction_NotAdmitted_ItemIEs_t *)calloc(INITIAL_RESPONSE_LIST_SIZE, sizeof(E2N_RICaction_NotAdmitted_ItemIEs_t));
59 assert(ie_not_admitted_list != 0);
60 ie_not_admitted_list_size = INITIAL_RESPONSE_LIST_SIZE;
70 // Clear assigned protocolIE list from RIC indication IE container
71 subscription_response::~subscription_response(void){
73 mdclog_write(MDCLOG_DEBUG, "Freeing subscription response memory");
74 E2N_RICaction_Admitted_List_t * response_admitted_list = (E2N_RICaction_Admitted_List_t *) &(IE_array[2].value.choice.RICaction_Admitted_List);
76 for(int i = 0; i < response_admitted_list->list.size; i++){
77 response_admitted_list->list.array[i] = 0;
81 if (response_admitted_list->list.size > 0){
82 free(response_admitted_list->list.array);
83 response_admitted_list->list.array = 0;
84 response_admitted_list->list.size = 0;
85 response_admitted_list->list.count = 0;
89 E2N_RICaction_NotAdmitted_List_t * response_not_admitted_list = &(IE_array[3].value.choice.RICaction_NotAdmitted_List);
90 for(int i = 0; i < response_not_admitted_list->list.size; i++){
91 response_not_admitted_list->list.array[i] = 0;
94 if (response_not_admitted_list->list.size > 0){
95 free(response_not_admitted_list->list.array);
96 response_not_admitted_list->list.array = 0;
97 response_not_admitted_list->list.size = 0;
98 response_not_admitted_list->list.count = 0;
101 E2N_RICsubscriptionResponse_t * ric_subscription_response = &(successMsg->value.choice.RICsubscriptionResponse);
102 for(int i = 0; i < ric_subscription_response->protocolIEs.list.size ; i++){
103 ric_subscription_response->protocolIEs.list.array[i] = 0;
106 if (ric_subscription_response->protocolIEs.list.size > 0){
107 free(ric_subscription_response->protocolIEs.list.array);
108 ric_subscription_response->protocolIEs.list.array = 0;
109 ric_subscription_response->protocolIEs.list.size = 0;
110 ric_subscription_response->protocolIEs.list.count = 0;
114 E2N_RICaction_NotAdmitted_List_t * failure_not_admitted_list = &(IE_Failure_array[2].value.choice.RICaction_NotAdmitted_List);
115 for(int i = 0; i < failure_not_admitted_list->list.size; i++){
116 failure_not_admitted_list->list.array[i] = 0;
119 if ( failure_not_admitted_list->list.size > 0){
120 free( failure_not_admitted_list->list.array);
121 failure_not_admitted_list->list.array = 0;
122 failure_not_admitted_list->list.size = 0;
123 failure_not_admitted_list->list.count = 0;
127 E2N_RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionFailure);
128 for(int i = 0; i < ric_subscription_failure->protocolIEs.list.size; i++){
129 ric_subscription_failure->protocolIEs.list.array[i] = 0;
132 if ( ric_subscription_failure->protocolIEs.list.size > 0){
133 free(ric_subscription_failure->protocolIEs.list.array);
134 ric_subscription_failure->protocolIEs.list.array = 0;
135 ric_subscription_failure->protocolIEs.list.size = 0;
136 ric_subscription_failure->protocolIEs.list.count = 0;
140 free(ie_admitted_list);
141 free(ie_not_admitted_list);
142 free(IE_Failure_array);
146 ASN_STRUCT_FREE(asn_DEF_E2N_SuccessfulOutcome, successMsg);
147 ASN_STRUCT_FREE(asn_DEF_E2N_UnsuccessfulOutcome, unsuccessMsg);
150 e2ap_pdu_obj->choice.initiatingMessage = NULL;
151 e2ap_pdu_obj->present = E2N_E2AP_PDU_PR_NOTHING;
152 ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj);
154 mdclog_write(MDCLOG_DEBUG, "Freed subscription response memory ");
160 bool subscription_response::encode_e2ap_subscription_response(unsigned char *buf, size_t *size, subscription_response_helper &dinput, bool is_success){
164 set_fields_success(dinput);
165 e2ap_pdu_obj->present = E2N_E2AP_PDU_PR_successfulOutcome;
166 e2ap_pdu_obj->choice.successfulOutcome = successMsg;
168 successMsg->procedureCode = E2N_ProcedureCode_id_ricSubscription;
169 successMsg->criticality = E2N_Criticality_reject;
170 successMsg->value.present = E2N_SuccessfulOutcome__value_PR_RICsubscriptionResponse;
174 set_fields_unsuccess(dinput);
175 e2ap_pdu_obj->present = E2N_E2AP_PDU_PR_unsuccessfulOutcome;
176 e2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg;
178 unsuccessMsg->procedureCode = E2N_ProcedureCode_id_ricSubscription;
179 unsuccessMsg->criticality = E2N_Criticality_reject;
180 unsuccessMsg->value.present = E2N_UnsuccessfulOutcome__value_PR_RICsubscriptionFailure;
184 //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
186 int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
188 error_string.assign(errbuf, errbuf_len);
189 error_string = "Constraints failed for encoding subscription response. Reason = " + error_string;
193 asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj, buf, *size);
195 if(res.encoded == -1){
196 std::cout <<"Error encoding PDU. Reason =" << strerror(errno) << std::endl;
200 if(*size < res.encoded){
201 fprintf(stderr, "Buffer assigned too small to encode: %s",(char *)(asn_DEF_E2N_E2AP_PDU.name));
212 void subscription_response::set_fields_success(subscription_response_helper &helper){
216 E2N_RICsubscriptionResponse_t * subscription_response = &(successMsg->value.choice.RICsubscriptionResponse);
217 //reset list count ..
218 subscription_response->protocolIEs.list.count = 0;
221 E2N_RICsubscriptionResponse_IEs_t *ies_ricreq = &IE_array[ie_index];
223 ies_ricreq->criticality = E2N_Criticality_reject;
224 ies_ricreq->id = E2N_ProtocolIE_ID_id_RICrequestID;
225 ies_ricreq->value.present = E2N_RICsubscriptionResponse_IEs__value_PR_RICrequestID;
226 E2N_RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
227 ricrequest_ie->ricRequestorID = helper.get_request_id();
228 ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
229 ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index]));
233 E2N_RICsubscriptionResponse_IEs_t *ies_ranfunc = &IE_array[ie_index];
234 ies_ranfunc->criticality = E2N_Criticality_reject;
235 ies_ranfunc->id = E2N_ProtocolIE_ID_id_RANfunctionID;
236 ies_ranfunc->value.present = E2N_RICsubscriptionResponse_IEs__value_PR_RANfunctionID;
237 E2N_RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
238 *ranfunction_ie = helper.get_function_id();
239 ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index]));
243 E2N_RICsubscriptionResponse_IEs_t *ies_admitted_actid = &IE_array[ie_index];
244 ies_admitted_actid->criticality = E2N_Criticality_reject;
245 ies_admitted_actid->id = E2N_ProtocolIE_ID_id_RICactions_Admitted;
246 E2N_RICaction_Admitted_List_t *ric_admitted_actions_ie = &ies_admitted_actid->value.choice.RICaction_Admitted_List;
247 ric_admitted_actions_ie->list.count = 0;
248 std::vector<ActionResponse> * ref_admitted_action_array = helper.get_admitted_list();
250 if(ref_admitted_action_array->size() == 0){
251 ies_admitted_actid->value.present = E2N_RICsubscriptionResponse_IEs__value_PR_NOTHING;
254 ies_admitted_actid->value.present = E2N_RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
257 if (ref_admitted_action_array->size() >= ie_admitted_list_size){
258 ie_admitted_list_size = 2 * ref_admitted_action_array->size();
259 free(ie_admitted_list);
260 ie_admitted_list = (E2N_RICaction_Admitted_ItemIEs_t *)calloc(ie_admitted_list_size, sizeof(E2N_RICaction_Admitted_ItemIEs_t));
261 assert(ie_admitted_list != 0);
265 for(unsigned int i = 0; i < ref_admitted_action_array->size(); i ++){
266 ie_admitted_list[i].criticality = E2N_Criticality_ignore;
267 ie_admitted_list[i].id = E2N_ProtocolIE_ID_id_RICaction_Admitted_Item ;
268 ie_admitted_list[i].value.present = E2N_RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
269 ie_admitted_list[i].value.choice.RICaction_Admitted_Item.ricActionID = (*ref_admitted_action_array)[i].get_id();
270 ASN_SEQUENCE_ADD(ric_admitted_actions_ie, &(ie_admitted_list[i]));
273 ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index]));
275 // optional IE : add only if non-zero list
277 std::vector<ActionResponse> * ref_notadmitted_action_array = helper.get_not_admitted_list();
278 if (ref_notadmitted_action_array->size() > 0){
280 E2N_RICsubscriptionResponse_IEs_t *ies_notadmitted_actid = &IE_array[ie_index];
281 ies_notadmitted_actid->criticality = E2N_Criticality_reject;
282 ies_notadmitted_actid->id = E2N_ProtocolIE_ID_id_RICactions_NotAdmitted;
284 E2N_RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List;
285 ric_not_admitted_actions_ie->list.count = 0;
288 ies_notadmitted_actid->value.present = E2N_RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
291 if (ref_notadmitted_action_array->size() >= ie_not_admitted_list_size){
292 ie_not_admitted_list_size = 2 * ref_notadmitted_action_array->size();
293 free(ie_not_admitted_list);
294 ie_not_admitted_list = (E2N_RICaction_NotAdmitted_ItemIEs_t *)calloc(ie_not_admitted_list_size, sizeof(E2N_RICaction_NotAdmitted_ItemIEs_t));
295 assert(ie_not_admitted_list != 0);
300 for(unsigned int i = 0; i < ref_notadmitted_action_array->size(); i ++){
301 ie_not_admitted_list[i].criticality = E2N_Criticality_ignore;
302 ie_not_admitted_list[i].id = E2N_ProtocolIE_ID_id_RICaction_NotAdmitted_Item ;
303 ie_not_admitted_list[i].value.present = E2N_RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;;
304 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_id();
306 int cause = (*ref_notadmitted_action_array)[i].get_cause();
308 case E2N_RICcause_PR_radioNetwork:
309 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork = (*ref_notadmitted_action_array)[i].get_sub_cause();
311 case E2N_RICcause_PR_transport:
312 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport = (*ref_notadmitted_action_array)[i].get_sub_cause();
314 case E2N_RICcause_PR_protocol:
315 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol= (*ref_notadmitted_action_array)[i].get_sub_cause();
317 case E2N_RICcause_PR_misc:
318 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc = (*ref_notadmitted_action_array)[i].get_sub_cause();
320 case E2N_RICcause_PR_ric:
321 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric = (*ref_notadmitted_action_array)[i].get_sub_cause();
324 mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause);
328 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.present = (E2N_RICcause_PR)cause;
329 ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i]));
332 ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index]));
337 void subscription_response:: get_fields(E2N_SuccessfulOutcome_t * success_msg, subscription_response_helper & dout)
340 assert(success_msg != NULL);
342 E2N_RICrequestID_t *requestid;
343 E2N_RANfunctionID_t * ranfunctionid;
344 E2N_RICaction_Admitted_List_t * ric_admitted_action_list;
345 E2N_RICaction_NotAdmitted_List_t * ric_not_admitted_action_list;
347 for(int edx = 0; edx < success_msg->value.choice.RICsubscriptionResponse.protocolIEs.list.count; edx++) {
348 E2N_RICsubscriptionResponse_IEs_t *memb_ptr = success_msg->value.choice.RICsubscriptionResponse.protocolIEs.list.array[edx];
352 case (E2N_ProtocolIE_ID_id_RICrequestID):
353 requestid = &memb_ptr->value.choice.RICrequestID;
354 dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
357 case (E2N_ProtocolIE_ID_id_RANfunctionID):
358 ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
359 dout.set_function_id(*ranfunctionid);
362 case (E2N_ProtocolIE_ID_id_RICactions_Admitted):
363 ric_admitted_action_list = &memb_ptr->value.choice.RICaction_Admitted_List;
366 for(int index = 0; index < ric_admitted_action_list->list.count; index ++){
367 E2N_RICaction_Admitted_ItemIEs_t * item = (E2N_RICaction_Admitted_ItemIEs_t *)ric_admitted_action_list->list.array[index];
368 long int id = item->value.choice.RICaction_Admitted_Item.ricActionID;
369 dout.get_admitted_list()->push_back(ActionResponse(id));
374 case (E2N_ProtocolIE_ID_id_RICactions_NotAdmitted):
375 ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;
377 for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){
378 E2N_RICaction_NotAdmitted_ItemIEs_t * item = (E2N_RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index];
379 long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID;
380 int cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.present;
384 case E2N_RICcause_PR_radioNetwork :
385 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;
388 case E2N_RICcause_PR_transport :
389 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;
392 case E2N_RICcause_PR_protocol :
393 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;
396 case E2N_RICcause_PR_misc :
397 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;
400 case E2N_RICcause_PR_ric :
401 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;
405 std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
408 dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));
415 //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
419 void subscription_response::set_fields_unsuccess( subscription_response_helper &helper){
422 E2N_RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionFailure);
424 ric_subscription_failure->protocolIEs.list.count = 0;
427 E2N_RICsubscriptionFailure_IEs_t *ies_ricreq = &IE_Failure_array[ie_index];
428 ies_ricreq->criticality = E2N_Criticality_reject;
429 ies_ricreq->id = E2N_ProtocolIE_ID_id_RICrequestID;
430 ies_ricreq->value.present = E2N_RICsubscriptionFailure_IEs__value_PR_RICrequestID;
431 E2N_RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
432 ricrequest_ie->ricRequestorID = helper.get_request_id();
433 ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
434 ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, &(IE_Failure_array[ie_index]));
437 E2N_RICsubscriptionFailure_IEs_t *ies_ranfunc = &IE_Failure_array[ie_index];
438 ies_ranfunc->criticality = E2N_Criticality_reject;
439 ies_ranfunc->id = E2N_ProtocolIE_ID_id_RANfunctionID;
440 ies_ranfunc->value.present = E2N_RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
441 E2N_RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
442 *ranfunction_ie = helper.get_function_id();
443 ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, &(IE_Failure_array[ie_index]));
446 E2N_RICsubscriptionFailure_IEs_t *ies_notadmitted_actid = &IE_Failure_array[ie_index];
447 ies_notadmitted_actid->criticality = E2N_Criticality_reject;
448 ies_notadmitted_actid->id = E2N_ProtocolIE_ID_id_RICactions_NotAdmitted;
449 E2N_RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List;
450 ric_not_admitted_actions_ie->list.count = 0;
451 std::vector<ActionResponse> * ref_notadmitted_action_array = helper.get_not_admitted_list();
452 if(ref_notadmitted_action_array->size() == 0){
453 ies_notadmitted_actid->value.present = E2N_RICsubscriptionFailure_IEs__value_PR_NOTHING;
456 ies_notadmitted_actid->value.present = E2N_RICsubscriptionFailure_IEs__value_PR_RICaction_NotAdmitted_List;
459 if (ref_notadmitted_action_array->size() >= ie_not_admitted_list_size){
460 ie_not_admitted_list_size = 2 * ref_notadmitted_action_array->size();
461 free(ie_not_admitted_list);
462 ie_not_admitted_list = (E2N_RICaction_NotAdmitted_ItemIEs_t *)calloc(ie_not_admitted_list_size, sizeof(E2N_RICaction_NotAdmitted_ItemIEs_t));
463 assert(ie_not_admitted_list != 0);
467 // reset the list count on ricAction_ToBeSetup_List;
468 for(unsigned int i = 0; i < ref_notadmitted_action_array->size(); i ++){
469 ie_not_admitted_list[i].criticality = E2N_Criticality_ignore;
470 ie_not_admitted_list[i].id = E2N_ProtocolIE_ID_id_RICaction_NotAdmitted_Item ;
471 ie_not_admitted_list[i].value.present = E2N_RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;;
472 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_id();
474 int cause = (*ref_notadmitted_action_array)[i].get_cause();
476 case E2N_RICcause_PR_radioNetwork:
477 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork = (*ref_notadmitted_action_array)[i].get_sub_cause();
479 case E2N_RICcause_PR_transport:
480 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport = (*ref_notadmitted_action_array)[i].get_sub_cause();
482 case E2N_RICcause_PR_protocol:
483 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol= (*ref_notadmitted_action_array)[i].get_sub_cause();
485 case E2N_RICcause_PR_misc:
486 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc = (*ref_notadmitted_action_array)[i].get_sub_cause();
488 case E2N_RICcause_PR_ric:
489 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric = (*ref_notadmitted_action_array)[i].get_sub_cause();
492 mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause);
496 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.present = (E2N_RICcause_PR)cause;
498 ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i]));
502 ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, &(IE_Failure_array[ie_index]));
505 // // criticality diagnostics is not generated/parsed currently since optional
507 // E2N_RICsubscriptionFailure_IEs_t *ies_criticality_diagnostics= &IE_Failure_array[i];
508 // ies_criticality_diagnostics->criticality = E2N_Criticality_ignore;
509 // ies_criticality_diagnostics->id = E2N_ProtocolIE_ID_id_CriticalityDiagnostics ;
510 // ies_criticality_diagnostics->value.present = E2N_RICsubscriptionFailure_IEs__value_PR_NOTHING;
515 void subscription_response:: get_fields(E2N_UnsuccessfulOutcome_t * unsuccess_msg, subscription_response_helper & dout)
518 assert(unsuccess_msg != NULL);
520 E2N_RICrequestID_t *requestid;
521 E2N_RANfunctionID_t * ranfunctionid;
522 E2N_RICaction_NotAdmitted_List_t * ric_not_admitted_action_list;
524 for(int edx = 0; edx < unsuccess_msg->value.choice.RICsubscriptionFailure.protocolIEs.list.count; edx++) {
525 E2N_RICsubscriptionFailure_IEs_t *memb_ptr = unsuccess_msg->value.choice.RICsubscriptionFailure.protocolIEs.list.array[edx];
529 case (E2N_ProtocolIE_ID_id_RICrequestID):
530 requestid = &memb_ptr->value.choice.RICrequestID;
531 dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
534 case (E2N_ProtocolIE_ID_id_RANfunctionID):
535 ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
536 dout.set_function_id(*ranfunctionid);
540 case (E2N_ProtocolIE_ID_id_RICactions_NotAdmitted):
541 ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;
543 for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){
544 E2N_RICaction_NotAdmitted_ItemIEs_t * item = (E2N_RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index];
545 long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID;
546 int cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.present;
550 case E2N_RICcause_PR_radioNetwork :
551 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;
554 case E2N_RICcause_PR_transport :
555 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;
558 case E2N_RICcause_PR_protocol :
559 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;
562 case E2N_RICcause_PR_misc :
563 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;
566 case E2N_RICcause_PR_ric :
567 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;
571 mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause);
574 dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));
581 //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);