4 ==================================================================================
\r
5 Copyright (c) 2018-2019 AT&T Intellectual Property.
\r
7 Licensed under the Apache License, Version 2.0 (the "License");
\r
8 you may not use this file except in compliance with the License.
\r
9 You may obtain a copy of the License at
\r
11 http://www.apache.org/licenses/LICENSE-2.0
\r
13 Unless required by applicable law or agreed to in writing, software
\r
14 distributed under the License is distributed on an "AS IS" BASIS,
\r
15 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
16 See the License for the specific language governing permissions and
\r
17 limitations under the License.
\r
18 ==================================================================================
\r
22 #include "subscription_response.hpp"
\r
24 /* The xAPP need only worry about the get_fields from a response, since it does
\r
25 not generate a response. Generating response however is included to support testing.
\r
29 // Primarly for generation
\r
30 subscription_response::subscription_response(void){
\r
33 e2ap_pdu_obj = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
\r
34 assert(e2ap_pdu_obj != 0);
\r
37 successMsg = (SuccessfulOutcome_t *)calloc(1, sizeof(SuccessfulOutcome_t));
\r
38 assert(successMsg != 0);
\r
41 unsuccessMsg = (UnsuccessfulOutcome_t *)calloc(1, sizeof(UnsuccessfulOutcome_t));
\r
42 assert(unsuccessMsg != 0);
\r
45 IE_array = (RICsubscriptionResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_RESPONSE_IES, sizeof(RICsubscriptionResponse_IEs_t));
\r
46 assert(IE_array != 0);
\r
48 IE_Failure_array = 0;
\r
49 IE_Failure_array = (RICsubscriptionFailure_IEs_t *)calloc(NUM_SUBSCRIPTION_FAILURE_IES, sizeof(RICsubscriptionFailure_IEs_t));
\r
50 assert(IE_Failure_array != 0);
\r
52 ie_admitted_list = 0;
\r
53 ie_admitted_list = (RICaction_Admitted_ItemIEs_t *)calloc(INITIAL_LIST_SIZE, sizeof(RICaction_Admitted_ItemIEs_t));
\r
54 assert(ie_admitted_list != 0);
\r
55 ie_admitted_list_size = INITIAL_LIST_SIZE;
\r
57 ie_not_admitted_list = 0;
\r
58 ie_not_admitted_list = (RICaction_NotAdmitted_ItemIEs_t *)calloc(INITIAL_LIST_SIZE, sizeof(RICaction_NotAdmitted_ItemIEs_t));
\r
59 assert(ie_not_admitted_list != 0);
\r
60 ie_not_admitted_list_size = INITIAL_LIST_SIZE;
\r
67 // Clear assigned protocolIE list from RIC indication IE container
\r
68 subscription_response::~subscription_response(void){
\r
70 mdclog_write(MDCLOG_INFO, "Freeing subscription response memory for");
\r
71 RICaction_Admitted_List_t * response_admitted_list = (RICaction_Admitted_List_t *) &(IE_array[2].value.choice.RICaction_Admitted_List);
\r
73 for(int i = 0; i < response_admitted_list->list.size; i++){
\r
74 response_admitted_list->list.array[i] = 0;
\r
78 if (response_admitted_list->list.size > 0){
\r
79 free(response_admitted_list->list.array);
\r
80 response_admitted_list->list.array = 0;
\r
81 response_admitted_list->list.size = 0;
\r
82 response_admitted_list->list.count = 0;
\r
86 RICaction_NotAdmitted_List_t * response_not_admitted_list = &(IE_array[3].value.choice.RICaction_NotAdmitted_List);
\r
87 for(int i = 0; i < response_not_admitted_list->list.size; i++){
\r
88 response_not_admitted_list->list.array[i] = 0;
\r
91 if (response_not_admitted_list->list.size > 0){
\r
92 free(response_not_admitted_list->list.array);
\r
93 response_not_admitted_list->list.array = 0;
\r
94 response_not_admitted_list->list.size = 0;
\r
95 response_not_admitted_list->list.count = 0;
\r
98 RICsubscriptionResponse_t * ric_subscription_response = &(successMsg->value.choice.RICsubscriptionResponse);
\r
99 for(int i = 0; i < ric_subscription_response->protocolIEs.list.size ; i++){
\r
100 ric_subscription_response->protocolIEs.list.array[i] = 0;
\r
103 if (ric_subscription_response->protocolIEs.list.size > 0){
\r
104 free(ric_subscription_response->protocolIEs.list.array);
\r
105 ric_subscription_response->protocolIEs.list.array = 0;
\r
106 ric_subscription_response->protocolIEs.list.size = 0;
\r
107 ric_subscription_response->protocolIEs.list.count = 0;
\r
111 RICaction_NotAdmitted_List_t * failure_not_admitted_list = &(IE_Failure_array[2].value.choice.RICaction_NotAdmitted_List);
\r
112 for(int i = 0; i < failure_not_admitted_list->list.size; i++){
\r
113 failure_not_admitted_list->list.array[i] = 0;
\r
116 if ( failure_not_admitted_list->list.size > 0){
\r
117 free( failure_not_admitted_list->list.array);
\r
118 failure_not_admitted_list->list.array = 0;
\r
119 failure_not_admitted_list->list.size = 0;
\r
120 failure_not_admitted_list->list.count = 0;
\r
124 RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionFailure);
\r
125 for(int i = 0; i < ric_subscription_failure->protocolIEs.list.size; i++){
\r
126 ric_subscription_failure->protocolIEs.list.array[i] = 0;
\r
129 if ( ric_subscription_failure->protocolIEs.list.size > 0){
\r
130 free(ric_subscription_failure->protocolIEs.list.array);
\r
131 ric_subscription_failure->protocolIEs.list.array = 0;
\r
132 ric_subscription_failure->protocolIEs.list.size = 0;
\r
133 ric_subscription_failure->protocolIEs.list.count = 0;
\r
138 free(ie_admitted_list);
\r
139 free(ie_not_admitted_list);
\r
140 free(IE_Failure_array);
\r
144 ASN_STRUCT_FREE(asn_DEF_SuccessfulOutcome, successMsg);
\r
145 ASN_STRUCT_FREE(asn_DEF_UnsuccessfulOutcome, unsuccessMsg);
\r
148 e2ap_pdu_obj->choice.initiatingMessage = NULL;
\r
149 e2ap_pdu_obj->present = E2AP_PDU_PR_NOTHING;
\r
150 ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj);
\r
152 mdclog_write(MDCLOG_INFO, "Freed subscription response memory ");
\r
158 bool subscription_response::encode_e2ap_subscription_response(unsigned char *buf, size_t *size, E2AP_PDU_t *e2ap_pdu, subscription_response_helper &dinput, bool is_success){
\r
160 //memset(e2ap_pdu, 0, sizeof(E2AP_PDU_t));
\r
163 set_fields(successMsg, dinput);
\r
164 e2ap_pdu_obj->present = E2AP_PDU_PR_successfulOutcome;
\r
165 e2ap_pdu_obj->choice.successfulOutcome = successMsg;
\r
168 set_fields(unsuccessMsg, dinput);
\r
169 e2ap_pdu_obj->present = E2AP_PDU_PR_unsuccessfulOutcome;
\r
170 e2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg;
\r
173 //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
\r
175 int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
\r
177 error_string.assign(errbuf, errbuf_len);
\r
178 error_string = "Constraints failed for encoding subscription response. Reason = " + error_string;
\r
182 asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size);
\r
184 if(res.encoded == -1){
\r
185 std::cout <<"Error encoding PDU. Reason =" << strerror(errno) << std::endl;
\r
189 if(*size < res.encoded){
\r
190 fprintf(stderr, "Buffer assigned too small to encode: %s",(char *)(asn_DEF_E2AP_PDU.name));
\r
196 *size = res.encoded;
\r
201 void subscription_response::set_fields(SuccessfulOutcome_t *success, subscription_response_helper &helper){
\r
205 success->procedureCode = ProcedureCode_id_ricSubscription;
\r
206 success->criticality = Criticality_reject;
\r
207 success->value.present = SuccessfulOutcome__value_PR_RICsubscriptionResponse;
\r
209 RICsubscriptionResponse_t * subscription_response = &(success->value.choice.RICsubscriptionResponse);
\r
210 subscription_response->protocolIEs.list.count = 0;
\r
213 RICsubscriptionResponse_IEs_t *ies_ricreq = &IE_array[ie_index];
\r
215 ies_ricreq->criticality = Criticality_reject;
\r
216 ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
\r
217 ies_ricreq->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID;
\r
218 RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
\r
219 ricrequest_ie->ricRequestorID = helper.get_request_id();
\r
220 ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
\r
221 ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_ricreq);
\r
225 RICsubscriptionResponse_IEs_t *ies_ranfunc = &IE_array[ie_index];
\r
226 ies_ranfunc->criticality = Criticality_reject;
\r
227 ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
\r
228 ies_ranfunc->value.present = RICsubscriptionResponse_IEs__value_PR_RANfunctionID;
\r
229 RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
\r
230 *ranfunction_ie = helper.get_function_id();
\r
231 ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_ranfunc);
\r
234 RICsubscriptionResponse_IEs_t *ies_admitted_actid = &IE_array[ie_index];
\r
235 ies_admitted_actid->criticality = Criticality_reject;
\r
236 ies_admitted_actid->id = ProtocolIE_ID_id_RICactions_Admitted;
\r
237 ies_admitted_actid->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
\r
238 RICaction_Admitted_List_t *ric_admitted_actions_ie = &ies_admitted_actid->value.choice.RICaction_Admitted_List;
\r
240 std::vector<ActionResponse> * ref_admitted_action_array = helper.get_admitted_list();
\r
242 if (ref_admitted_action_array->size() >= ie_admitted_list_size){
\r
243 RICaction_Admitted_ItemIEs_t * new_ref = 0;
\r
244 ie_admitted_list_size = 2 * ref_admitted_action_array->size();
\r
245 new_ref = (RICaction_Admitted_ItemIEs_t *) realloc(ie_admitted_list, ie_admitted_list_size * sizeof(RICaction_Admitted_ItemIEs_t));
\r
246 assert(new_ref != 0);
\r
247 ie_admitted_list = new_ref;
\r
250 ric_admitted_actions_ie->list.count = 0;
\r
251 for(int i = 0; i < ref_admitted_action_array->size(); i ++){
\r
252 ie_admitted_list[i].criticality = Criticality_ignore;
\r
253 ie_admitted_list[i].id = ProtocolIE_ID_id_RICaction_Admitted_Item ;
\r
254 ie_admitted_list[i].value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
\r
255 ie_admitted_list[i].value.choice.RICaction_Admitted_Item.ricActionID = (*ref_admitted_action_array)[i].get_id();
\r
256 ASN_SEQUENCE_ADD(ric_admitted_actions_ie, &(ie_admitted_list[i]));
\r
259 ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_admitted_actid);
\r
262 RICsubscriptionResponse_IEs_t *ies_notadmitted_actid = &IE_array[ie_index];
\r
263 ies_notadmitted_actid->criticality = Criticality_reject;
\r
264 ies_notadmitted_actid->id = ProtocolIE_ID_id_RICactions_NotAdmitted;
\r
265 ies_notadmitted_actid->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
\r
266 RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List;
\r
268 std::vector<ActionResponse> * ref_notadmitted_action_array = helper.get_not_admitted_list();
\r
270 if (ref_notadmitted_action_array->size() >= ie_not_admitted_list_size){
\r
271 RICaction_NotAdmitted_ItemIEs_t * new_ref = 0;
\r
272 ie_not_admitted_list_size = 2 * ref_notadmitted_action_array->size();
\r
273 new_ref = (RICaction_NotAdmitted_ItemIEs_t *) realloc(ie_not_admitted_list, ie_not_admitted_list_size * sizeof(RICaction_NotAdmitted_ItemIEs_t));
\r
274 assert(new_ref != 0);
\r
275 ie_not_admitted_list = new_ref;
\r
279 // reset the list count
\r
280 ric_not_admitted_actions_ie->list.count = 0;
\r
281 for(int i = 0; i < ref_notadmitted_action_array->size(); i ++){
\r
282 ie_not_admitted_list[i].criticality = Criticality_ignore;
\r
283 ie_not_admitted_list[i].id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item ;
\r
284 ie_not_admitted_list[i].value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;;
\r
285 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_id();
\r
287 int cause = (*ref_notadmitted_action_array)[i].get_cause();
\r
289 case RICcause_PR_radioNetwork:
\r
290 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork = (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
292 case RICcause_PR_transport:
\r
293 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport = (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
295 case RICcause_PR_protocol:
\r
296 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol= (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
298 case RICcause_PR_misc:
\r
299 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc = (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
301 case RICcause_PR_ric:
\r
302 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric = (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
305 std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
\r
309 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.present = (RICcause_PR)cause;
\r
310 ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i]));
\r
313 ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_notadmitted_actid);
\r
318 void subscription_response:: get_fields(SuccessfulOutcome_t * success_msg, subscription_response_helper & dout)
\r
320 RICrequestID_t *requestid;
\r
321 RANfunctionID_t * ranfunctionid;
\r
322 RICaction_Admitted_List_t * ric_admitted_action_list;
\r
323 RICaction_NotAdmitted_List_t * ric_not_admitted_action_list;
\r
325 for(int edx = 0; edx < success_msg->value.choice.RICsubscriptionResponse.protocolIEs.list.count; edx++) {
\r
326 RICsubscriptionResponse_IEs_t *memb_ptr = success_msg->value.choice.RICsubscriptionResponse.protocolIEs.list.array[edx];
\r
328 switch(memb_ptr->id)
\r
330 case (ProtocolIE_ID_id_RICrequestID):
\r
331 requestid = &memb_ptr->value.choice.RICrequestID;
\r
332 dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
\r
335 case (ProtocolIE_ID_id_RANfunctionID):
\r
336 ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
\r
337 dout.set_function_id(*ranfunctionid);
\r
340 case (ProtocolIE_ID_id_RICactions_Admitted):
\r
341 ric_admitted_action_list = &memb_ptr->value.choice.RICaction_Admitted_List;
\r
343 // admitted actions
\r
344 for(int index = 0; index < ric_admitted_action_list->list.count; index ++){
\r
345 RICaction_Admitted_ItemIEs_t * item = (RICaction_Admitted_ItemIEs_t *)ric_admitted_action_list->list.array[index];
\r
346 long int id = item->value.choice.RICaction_Admitted_Item.ricActionID;
\r
347 dout.get_admitted_list()->push_back(ActionResponse(id));
\r
352 case (ProtocolIE_ID_id_RICactions_NotAdmitted):
\r
353 ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;
\r
355 for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){
\r
356 RICaction_NotAdmitted_ItemIEs_t * item = (RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index];
\r
357 long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID;
\r
358 int cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.present;
\r
362 case RICcause_PR_radioNetwork :
\r
363 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;
\r
366 case RICcause_PR_transport :
\r
367 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;
\r
370 case RICcause_PR_protocol :
\r
371 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;
\r
374 case RICcause_PR_misc :
\r
375 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;
\r
378 case RICcause_PR_ric :
\r
379 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;
\r
383 std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
\r
386 dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));
\r
393 //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
\r
397 void subscription_response::set_fields(UnsuccessfulOutcome_t *unsuccess, subscription_response_helper &helper){
\r
401 unsuccess->procedureCode = ProcedureCode_id_ricSubscription;
\r
402 unsuccess->criticality = Criticality_reject;
\r
403 unsuccess->value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionFailure;
\r
405 RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccess->value.choice.RICsubscriptionFailure);
\r
406 ric_subscription_failure->protocolIEs.list.count = 0;
\r
409 RICsubscriptionFailure_IEs_t *ies_ricreq = &IE_Failure_array[ie_index];
\r
410 ies_ricreq->criticality = Criticality_reject;
\r
411 ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
\r
412 ies_ricreq->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
\r
413 RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
\r
414 ricrequest_ie->ricRequestorID = helper.get_request_id();
\r
415 ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
\r
416 ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ricreq);
\r
419 RICsubscriptionFailure_IEs_t *ies_ranfunc = &IE_Failure_array[ie_index];
\r
420 ies_ranfunc->criticality = Criticality_reject;
\r
421 ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
\r
422 ies_ranfunc->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
\r
423 RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
\r
424 *ranfunction_ie = helper.get_function_id();
\r
425 ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ranfunc);
\r
429 RICsubscriptionFailure_IEs_t *ies_notadmitted_actid = &IE_Failure_array[ie_index];
\r
430 ies_notadmitted_actid->criticality = Criticality_reject;
\r
431 ies_notadmitted_actid->id = ProtocolIE_ID_id_RICactions_NotAdmitted;
\r
432 std::vector<ActionResponse> * ref_notadmitted_action_array = helper.get_not_admitted_list();
\r
435 if (ref_notadmitted_action_array->size() >= ie_not_admitted_list_size){
\r
436 RICaction_NotAdmitted_ItemIEs_t * new_ref = 0;
\r
437 ie_not_admitted_list_size = 2 * ref_notadmitted_action_array->size();
\r
438 new_ref = (RICaction_NotAdmitted_ItemIEs_t *) realloc(ie_not_admitted_list, ie_not_admitted_list_size * sizeof(RICaction_NotAdmitted_ItemIEs_t));
\r
439 assert(new_ref != 0);
\r
440 ie_not_admitted_list = new_ref;
\r
443 ies_notadmitted_actid->value.present = RICsubscriptionFailure_IEs__value_PR_RICaction_NotAdmitted_List;
\r
444 RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List;
\r
447 // reset the list count on ricAction_ToBeSetup_List;
\r
448 ric_not_admitted_actions_ie->list.count = 0;
\r
449 for(int i = 0; i < ref_notadmitted_action_array->size(); i ++){
\r
450 ie_not_admitted_list[i].criticality = Criticality_ignore;
\r
451 ie_not_admitted_list[i].id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item ;
\r
452 ie_not_admitted_list[i].value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;;
\r
453 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_id();
\r
455 int cause = (*ref_notadmitted_action_array)[i].get_cause();
\r
457 case RICcause_PR_radioNetwork:
\r
458 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork = (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
460 case RICcause_PR_transport:
\r
461 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport = (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
463 case RICcause_PR_protocol:
\r
464 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol= (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
466 case RICcause_PR_misc:
\r
467 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc = (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
469 case RICcause_PR_ric:
\r
470 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric = (*ref_notadmitted_action_array)[i].get_sub_cause();
\r
473 std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
\r
477 ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.present = (RICcause_PR)cause;
\r
479 ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i]));
\r
482 ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_notadmitted_actid);
\r
485 // // criticality diagnostics is not generated/parsed currently since optional
\r
487 // RICsubscriptionFailure_IEs_t *ies_criticality_diagnostics= &IE_Failure_array[i];
\r
488 // ies_criticality_diagnostics->criticality = Criticality_ignore;
\r
489 // ies_criticality_diagnostics->id = ProtocolIE_ID_id_CriticalityDiagnostics ;
\r
490 // ies_criticality_diagnostics->value.present = RICsubscriptionFailure_IEs__value_PR_NOTHING;
\r
495 void subscription_response:: get_fields(UnsuccessfulOutcome_t * unsuccess_msg, subscription_response_helper & dout)
\r
497 RICrequestID_t *requestid;
\r
498 RANfunctionID_t * ranfunctionid;
\r
499 RICaction_NotAdmitted_List_t * ric_not_admitted_action_list;
\r
501 for(int edx = 0; edx < unsuccess_msg->value.choice.RICsubscriptionFailure.protocolIEs.list.count; edx++) {
\r
502 RICsubscriptionFailure_IEs_t *memb_ptr = unsuccess_msg->value.choice.RICsubscriptionFailure.protocolIEs.list.array[edx];
\r
504 switch(memb_ptr->id)
\r
506 case (ProtocolIE_ID_id_RICrequestID):
\r
507 requestid = &memb_ptr->value.choice.RICrequestID;
\r
508 dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
\r
511 case (ProtocolIE_ID_id_RANfunctionID):
\r
512 ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
\r
513 dout.set_function_id(*ranfunctionid);
\r
517 case (ProtocolIE_ID_id_RICactions_NotAdmitted):
\r
518 ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;
\r
520 for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){
\r
521 RICaction_NotAdmitted_ItemIEs_t * item = (RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index];
\r
522 long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID;
\r
523 int cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.present;
\r
527 case RICcause_PR_radioNetwork :
\r
528 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;
\r
531 case RICcause_PR_transport :
\r
532 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;
\r
535 case RICcause_PR_protocol :
\r
536 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;
\r
539 case RICcause_PR_misc :
\r
540 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;
\r
543 case RICcause_PR_ric :
\r
544 sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;
\r
548 std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
\r
551 dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));
\r
558 //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
\r