src/E2AP-c/subscription/subscription_response.cc

   1
   2
   3 /*
   4 ==================================================================================
   5         Copyright (c) 2018-2019 AT&T Intellectual Property.
   6
   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
  10
  11        http://www.apache.org/licenses/LICENSE-2.0
  12
  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 ==================================================================================
  19 */
  20
  21
  22 #include "subscription_response.hpp"
  23
  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.
  26 */
  27
  28
  29 // Primarly for generation
  30 subscription_response::subscription_response(void){
  31
  32   e2ap_pdu_obj = 0;
  33   e2ap_pdu_obj = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));
  34   assert(e2ap_pdu_obj != 0);
  35
  36   successMsg = 0;
  37   successMsg = (SuccessfulOutcome_t *)calloc(1, sizeof(SuccessfulOutcome_t));
  38   assert(successMsg != 0);
  39
  40   unsuccessMsg = 0;
  41   unsuccessMsg = (UnsuccessfulOutcome_t *)calloc(1, sizeof(UnsuccessfulOutcome_t));
  42   assert(unsuccessMsg != 0);
  43
  44   IE_array = 0;
  45   IE_array = (RICsubscriptionResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_RESPONSE_IES, sizeof(RICsubscriptionResponse_IEs_t));
  46   assert(IE_array != 0);
  47
  48   IE_Failure_array = 0;
  49   IE_Failure_array = (RICsubscriptionFailure_IEs_t *)calloc(NUM_SUBSCRIPTION_FAILURE_IES, sizeof(RICsubscriptionFailure_IEs_t));
  50   assert(IE_Failure_array != 0);
  51
  52   ie_admitted_list = 0;
  53   ie_admitted_list = (RICaction_Admitted_ItemIEs_t *)calloc(INITIAL_LIST_SIZE, sizeof(RICaction_Admitted_ItemIEs_t));
  54   assert(ie_admitted_list != 0);
  55   ie_admitted_list_size = INITIAL_LIST_SIZE;
  56
  57   ie_not_admitted_list = 0;
  58   ie_not_admitted_list = (RICaction_NotAdmitted_ItemIEs_t *)calloc(INITIAL_LIST_SIZE, sizeof(RICaction_NotAdmitted_ItemIEs_t));
  59   assert(ie_not_admitted_list != 0);
  60   ie_not_admitted_list_size = INITIAL_LIST_SIZE;
  61
  62
  63 };
  64
  65
  66
  67 // Clear assigned protocolIE list from RIC indication IE container
  68 subscription_response::~subscription_response(void){
  69
  70   mdclog_write(MDCLOG_INFO, "Freeing subscription response memory for");
  71   RICaction_Admitted_List_t * response_admitted_list = (RICaction_Admitted_List_t *) &(IE_array[2].value.choice.RICaction_Admitted_List);
  72
  73   for(int i = 0; i < response_admitted_list->list.size; i++){
  74     response_admitted_list->list.array[i] = 0;
  75   }
  76
  77
  78   if (response_admitted_list->list.size > 0){
  79     free(response_admitted_list->list.array);
  80     response_admitted_list->list.array = 0;
  81     response_admitted_list->list.size = 0;
  82     response_admitted_list->list.count = 0;
  83   }
  84
  85
  86   RICaction_NotAdmitted_List_t * response_not_admitted_list = &(IE_array[3].value.choice.RICaction_NotAdmitted_List);
  87   for(int i = 0; i < response_not_admitted_list->list.size; i++){
  88     response_not_admitted_list->list.array[i] = 0;
  89   }
  90
  91   if (response_not_admitted_list->list.size > 0){
  92     free(response_not_admitted_list->list.array);
  93     response_not_admitted_list->list.array = 0;
  94     response_not_admitted_list->list.size = 0;
  95     response_not_admitted_list->list.count = 0;
  96   }
  97
  98   RICsubscriptionResponse_t * ric_subscription_response = &(successMsg->value.choice.RICsubscriptionResponse);
  99   for(int i = 0; i < ric_subscription_response->protocolIEs.list.size ; i++){
 100     ric_subscription_response->protocolIEs.list.array[i] = 0;
 101   }
 102
 103   if (ric_subscription_response->protocolIEs.list.size > 0){
 104     free(ric_subscription_response->protocolIEs.list.array);
 105     ric_subscription_response->protocolIEs.list.array = 0;
 106     ric_subscription_response->protocolIEs.list.size = 0;
 107     ric_subscription_response->protocolIEs.list.count = 0;
 108   }
 109
 110
 111   RICaction_NotAdmitted_List_t * failure_not_admitted_list = &(IE_Failure_array[2].value.choice.RICaction_NotAdmitted_List);
 112   for(int i = 0; i < failure_not_admitted_list->list.size; i++){
 113     failure_not_admitted_list->list.array[i] = 0;
 114   }
 115
 116   if ( failure_not_admitted_list->list.size > 0){
 117     free( failure_not_admitted_list->list.array);
 118     failure_not_admitted_list->list.array = 0;
 119     failure_not_admitted_list->list.size = 0;
 120     failure_not_admitted_list->list.count = 0;
 121   }
 122
 123
 124   RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionFailure);
 125   for(int i = 0; i < ric_subscription_failure->protocolIEs.list.size; i++){
 126     ric_subscription_failure->protocolIEs.list.array[i] = 0;
 127   }
 128
 129   if (  ric_subscription_failure->protocolIEs.list.size > 0){
 130     free(ric_subscription_failure->protocolIEs.list.array);
 131     ric_subscription_failure->protocolIEs.list.array = 0;
 132     ric_subscription_failure->protocolIEs.list.size = 0;
 133     ric_subscription_failure->protocolIEs.list.count = 0;
 134   }
 135
 136
 137
 138   free(ie_admitted_list);
 139   free(ie_not_admitted_list);
 140   free(IE_Failure_array);
 141   free(IE_array);
 142
 143
 144   ASN_STRUCT_FREE(asn_DEF_SuccessfulOutcome, successMsg);
 145   ASN_STRUCT_FREE(asn_DEF_UnsuccessfulOutcome, unsuccessMsg);
 146
 147
 148   e2ap_pdu_obj->choice.initiatingMessage = NULL;
 149   e2ap_pdu_obj->present = E2AP_PDU_PR_NOTHING;
 150   ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 151
 152   mdclog_write(MDCLOG_INFO, "Freed subscription response memory ");
 153
 154
 155 };
 156
 157
 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){
 159
 160   //memset(e2ap_pdu, 0, sizeof(E2AP_PDU_t));
 161
 162   if(is_success){
 163     set_fields(successMsg, dinput);
 164     e2ap_pdu_obj->present =  E2AP_PDU_PR_successfulOutcome;
 165     e2ap_pdu_obj->choice.successfulOutcome = successMsg;
 166   }
 167   else{
 168     set_fields(unsuccessMsg, dinput);
 169     e2ap_pdu_obj->present = E2AP_PDU_PR_unsuccessfulOutcome;
 170     e2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg;
 171   }
 172
 173   //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 174
 175   int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
 176   if(ret_constr){
 177     error_string.assign(errbuf, errbuf_len);
 178     error_string = "Constraints failed for encoding subscription response. Reason = " + error_string;
 179     return false;
 180   }
 181
 182   asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size);
 183
 184   if(res.encoded == -1){
 185     std::cout <<"Error encoding PDU. Reason =" << strerror(errno) << std::endl;
 186     return false;
 187   }
 188   else {
 189     if(*size < res.encoded){
 190       fprintf(stderr,  "Buffer assigned too small to encode: %s",(char *)(asn_DEF_E2AP_PDU.name));
 191       res.encoded = -1;
 192       return false;
 193     }
 194   }
 195
 196   *size = res.encoded;
 197   return true;
 198
 199 }
 200
 201 void subscription_response::set_fields(SuccessfulOutcome_t *success, subscription_response_helper &helper){
 202
 203   int ie_index;
 204
 205   success->procedureCode = ProcedureCode_id_ricSubscription;
 206   success->criticality = Criticality_reject;
 207   success->value.present = SuccessfulOutcome__value_PR_RICsubscriptionResponse;
 208
 209   RICsubscriptionResponse_t * subscription_response = &(success->value.choice.RICsubscriptionResponse);
 210   subscription_response->protocolIEs.list.count = 0;
 211
 212   ie_index = 0;
 213   RICsubscriptionResponse_IEs_t *ies_ricreq = &IE_array[ie_index];
 214
 215   ies_ricreq->criticality = Criticality_reject;
 216   ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
 217   ies_ricreq->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID;
 218   RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 219   ricrequest_ie->ricRequestorID = helper.get_request_id();
 220   ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
 221   ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_ricreq);
 222
 223
 224   ie_index = 1;
 225   RICsubscriptionResponse_IEs_t *ies_ranfunc = &IE_array[ie_index];
 226   ies_ranfunc->criticality = Criticality_reject;
 227   ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 228   ies_ranfunc->value.present = RICsubscriptionResponse_IEs__value_PR_RANfunctionID;
 229   RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 230   *ranfunction_ie = helper.get_function_id();
 231   ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_ranfunc);
 232
 233   ie_index = 2;
 234   RICsubscriptionResponse_IEs_t *ies_admitted_actid = &IE_array[ie_index];
 235   ies_admitted_actid->criticality = Criticality_reject;
 236   ies_admitted_actid->id = ProtocolIE_ID_id_RICactions_Admitted;
 237   ies_admitted_actid->value.present =  RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
 238   RICaction_Admitted_List_t *ric_admitted_actions_ie = &ies_admitted_actid->value.choice.RICaction_Admitted_List;
 239
 240   std::vector<ActionResponse> * ref_admitted_action_array = helper.get_admitted_list();
 241   // realloc ?
 242   if (ref_admitted_action_array->size() >= ie_admitted_list_size){
 243     RICaction_Admitted_ItemIEs_t * new_ref = 0;
 244     ie_admitted_list_size = 2 * ref_admitted_action_array->size();
 245     new_ref = (RICaction_Admitted_ItemIEs_t *) realloc(ie_admitted_list, ie_admitted_list_size * sizeof(RICaction_Admitted_ItemIEs_t));
 246     assert(new_ref != 0);
 247     ie_admitted_list = new_ref;
 248   };
 249
 250   ric_admitted_actions_ie->list.count = 0;
 251   for(int i = 0; i < ref_admitted_action_array->size(); i ++){
 252     ie_admitted_list[i].criticality = Criticality_ignore;
 253     ie_admitted_list[i].id = ProtocolIE_ID_id_RICaction_Admitted_Item ;
 254     ie_admitted_list[i].value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
 255     ie_admitted_list[i].value.choice.RICaction_Admitted_Item.ricActionID = (*ref_admitted_action_array)[i].get_id();
 256     ASN_SEQUENCE_ADD(ric_admitted_actions_ie, &(ie_admitted_list[i]));
 257   }
 258
 259   ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_admitted_actid);
 260
 261   ie_index = 3;
 262   RICsubscriptionResponse_IEs_t *ies_notadmitted_actid = &IE_array[ie_index];
 263   ies_notadmitted_actid->criticality = Criticality_reject;
 264   ies_notadmitted_actid->id = ProtocolIE_ID_id_RICactions_NotAdmitted;
 265   ies_notadmitted_actid->value.present =  RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
 266   RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List;
 267
 268   std::vector<ActionResponse> * ref_notadmitted_action_array = helper.get_not_admitted_list();
 269   //realloc ?
 270   if (ref_notadmitted_action_array->size() >= ie_not_admitted_list_size){
 271     RICaction_NotAdmitted_ItemIEs_t * new_ref = 0;
 272     ie_not_admitted_list_size = 2 * ref_notadmitted_action_array->size();
 273     new_ref = (RICaction_NotAdmitted_ItemIEs_t *) realloc(ie_not_admitted_list, ie_not_admitted_list_size * sizeof(RICaction_NotAdmitted_ItemIEs_t));
 274     assert(new_ref != 0);
 275     ie_not_admitted_list = new_ref;
 276   };
 277
 278
 279   // reset the list count
 280   ric_not_admitted_actions_ie->list.count = 0;
 281   for(int i = 0; i < ref_notadmitted_action_array->size(); i ++){
 282     ie_not_admitted_list[i].criticality = Criticality_ignore;
 283     ie_not_admitted_list[i].id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item ;
 284     ie_not_admitted_list[i].value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;;
 285     ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_id();
 286
 287     int cause = (*ref_notadmitted_action_array)[i].get_cause();
 288     switch(cause){
 289     case RICcause_PR_radioNetwork:
 290       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork = (*ref_notadmitted_action_array)[i].get_sub_cause();
 291       break;
 292     case RICcause_PR_transport:
 293       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport = (*ref_notadmitted_action_array)[i].get_sub_cause();
 294       break;
 295     case RICcause_PR_protocol:
 296       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol= (*ref_notadmitted_action_array)[i].get_sub_cause();
 297       break;
 298     case RICcause_PR_misc:
 299       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc = (*ref_notadmitted_action_array)[i].get_sub_cause();
 300       break;
 301     case RICcause_PR_ric:
 302       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric = (*ref_notadmitted_action_array)[i].get_sub_cause();
 303       break;
 304     default:
 305       std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
 306       return;
 307     }
 308
 309     ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.present = (RICcause_PR)cause;
 310     ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i]));
 311   }
 312
 313   ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_notadmitted_actid);
 314
 315
 316 }
 317
 318 void subscription_response:: get_fields(SuccessfulOutcome_t * success_msg,  subscription_response_helper & dout)
 319 {
 320   RICrequestID_t *requestid;
 321   RANfunctionID_t * ranfunctionid;
 322   RICaction_Admitted_List_t  * ric_admitted_action_list;
 323   RICaction_NotAdmitted_List_t * ric_not_admitted_action_list;
 324
 325   for(int edx = 0; edx < success_msg->value.choice.RICsubscriptionResponse.protocolIEs.list.count; edx++) {
 326     RICsubscriptionResponse_IEs_t *memb_ptr = success_msg->value.choice.RICsubscriptionResponse.protocolIEs.list.array[edx];
 327
 328     switch(memb_ptr->id)
 329       {
 330       case (ProtocolIE_ID_id_RICrequestID):
 331         requestid = &memb_ptr->value.choice.RICrequestID;
 332         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 333         break;
 334
 335       case (ProtocolIE_ID_id_RANfunctionID):
 336         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 337         dout.set_function_id(*ranfunctionid);
 338         break;
 339
 340       case (ProtocolIE_ID_id_RICactions_Admitted):
 341         ric_admitted_action_list = &memb_ptr->value.choice.RICaction_Admitted_List;
 342
 343         // admitted actions
 344         for(int index = 0; index < ric_admitted_action_list->list.count; index ++){
 345           RICaction_Admitted_ItemIEs_t * item = (RICaction_Admitted_ItemIEs_t *)ric_admitted_action_list->list.array[index];
 346           long int id = item->value.choice.RICaction_Admitted_Item.ricActionID;
 347           dout.get_admitted_list()->push_back(ActionResponse(id));
 348         };
 349
 350         break;
 351
 352       case (ProtocolIE_ID_id_RICactions_NotAdmitted):
 353         ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;
 354
 355         for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){
 356           RICaction_NotAdmitted_ItemIEs_t * item = (RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index];
 357           long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID;
 358           int cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.present;
 359           int sub_cause;
 360           switch(cause){
 361
 362           case  RICcause_PR_radioNetwork :
 363             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;
 364             break;
 365
 366           case RICcause_PR_transport :
 367             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;
 368             break;
 369
 370           case  RICcause_PR_protocol :
 371             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;
 372             break;
 373
 374           case RICcause_PR_misc :
 375             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;
 376             break;
 377
 378           case RICcause_PR_ric :
 379             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;
 380             break;
 381
 382           default:
 383             std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
 384             return;
 385           }
 386           dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));
 387         }
 388         break;
 389       }
 390
 391   }
 392
 393   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 394 }
 395
 396
 397 void subscription_response::set_fields(UnsuccessfulOutcome_t *unsuccess, subscription_response_helper &helper){
 398
 399   int ie_index;
 400
 401   unsuccess->procedureCode = ProcedureCode_id_ricSubscription;
 402   unsuccess->criticality = Criticality_reject;
 403   unsuccess->value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionFailure;
 404
 405   RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccess->value.choice.RICsubscriptionFailure);
 406   ric_subscription_failure->protocolIEs.list.count = 0;
 407
 408   ie_index = 0;
 409   RICsubscriptionFailure_IEs_t *ies_ricreq = &IE_Failure_array[ie_index];
 410   ies_ricreq->criticality = Criticality_reject;
 411   ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
 412   ies_ricreq->value.present = RICsubscriptionFailure_IEs__value_PR_RICrequestID;
 413   RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 414   ricrequest_ie->ricRequestorID = helper.get_request_id();
 415   ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
 416   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ricreq);
 417
 418   ie_index = 1;
 419   RICsubscriptionFailure_IEs_t *ies_ranfunc = &IE_Failure_array[ie_index];
 420   ies_ranfunc->criticality = Criticality_reject;
 421   ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 422   ies_ranfunc->value.present = RICsubscriptionFailure_IEs__value_PR_RANfunctionID;
 423   RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 424   *ranfunction_ie = helper.get_function_id();
 425   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ranfunc);
 426
 427
 428   ie_index = 2;
 429   RICsubscriptionFailure_IEs_t *ies_notadmitted_actid = &IE_Failure_array[ie_index];
 430   ies_notadmitted_actid->criticality = Criticality_reject;
 431   ies_notadmitted_actid->id = ProtocolIE_ID_id_RICactions_NotAdmitted;
 432   std::vector<ActionResponse> * ref_notadmitted_action_array = helper.get_not_admitted_list();
 433
 434   //realloc ?
 435   if (ref_notadmitted_action_array->size() >= ie_not_admitted_list_size){
 436     RICaction_NotAdmitted_ItemIEs_t * new_ref = 0;
 437     ie_not_admitted_list_size = 2 * ref_notadmitted_action_array->size();
 438     new_ref = (RICaction_NotAdmitted_ItemIEs_t *) realloc(ie_not_admitted_list, ie_not_admitted_list_size * sizeof(RICaction_NotAdmitted_ItemIEs_t));
 439     assert(new_ref != 0);
 440     ie_not_admitted_list = new_ref;
 441   };
 442
 443   ies_notadmitted_actid->value.present =  RICsubscriptionFailure_IEs__value_PR_RICaction_NotAdmitted_List;
 444   RICaction_NotAdmitted_List_t *ric_not_admitted_actions_ie = &ies_notadmitted_actid->value.choice.RICaction_NotAdmitted_List;
 445
 446
 447   // reset the list count on ricAction_ToBeSetup_List;
 448   ric_not_admitted_actions_ie->list.count = 0;
 449   for(int i = 0; i < ref_notadmitted_action_array->size(); i ++){
 450     ie_not_admitted_list[i].criticality = Criticality_ignore;
 451     ie_not_admitted_list[i].id = ProtocolIE_ID_id_RICaction_NotAdmitted_Item ;
 452     ie_not_admitted_list[i].value.present = RICaction_NotAdmitted_ItemIEs__value_PR_RICaction_NotAdmitted_Item;;
 453     ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricActionID = (*ref_notadmitted_action_array)[i].get_id();
 454
 455     int cause = (*ref_notadmitted_action_array)[i].get_cause();
 456     switch(cause){
 457     case RICcause_PR_radioNetwork:
 458       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork = (*ref_notadmitted_action_array)[i].get_sub_cause();
 459       break;
 460     case RICcause_PR_transport:
 461       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport = (*ref_notadmitted_action_array)[i].get_sub_cause();
 462       break;
 463     case RICcause_PR_protocol:
 464       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol= (*ref_notadmitted_action_array)[i].get_sub_cause();
 465       break;
 466     case RICcause_PR_misc:
 467       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc = (*ref_notadmitted_action_array)[i].get_sub_cause();
 468       break;
 469     case RICcause_PR_ric:
 470       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric = (*ref_notadmitted_action_array)[i].get_sub_cause();
 471       break;
 472     default:
 473       std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
 474       return;
 475     }
 476
 477     ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.present = (RICcause_PR)cause;
 478
 479     ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i]));
 480   }
 481
 482   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_notadmitted_actid);
 483
 484
 485   // // criticality diagnostics is not generated/parsed currently since optional
 486   // i = 3;
 487   // RICsubscriptionFailure_IEs_t *ies_criticality_diagnostics= &IE_Failure_array[i];
 488   // ies_criticality_diagnostics->criticality = Criticality_ignore;
 489   // ies_criticality_diagnostics->id = ProtocolIE_ID_id_CriticalityDiagnostics ;
 490   // ies_criticality_diagnostics->value.present = RICsubscriptionFailure_IEs__value_PR_NOTHING;
 491
 492
 493 }
 494
 495 void subscription_response:: get_fields(UnsuccessfulOutcome_t * unsuccess_msg,  subscription_response_helper & dout)
 496 {
 497   RICrequestID_t *requestid;
 498   RANfunctionID_t * ranfunctionid;
 499   RICaction_NotAdmitted_List_t * ric_not_admitted_action_list;
 500
 501   for(int edx = 0; edx < unsuccess_msg->value.choice.RICsubscriptionFailure.protocolIEs.list.count; edx++) {
 502     RICsubscriptionFailure_IEs_t *memb_ptr = unsuccess_msg->value.choice.RICsubscriptionFailure.protocolIEs.list.array[edx];
 503
 504     switch(memb_ptr->id)
 505       {
 506       case (ProtocolIE_ID_id_RICrequestID):
 507         requestid = &memb_ptr->value.choice.RICrequestID;
 508         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 509         break;
 510
 511       case (ProtocolIE_ID_id_RANfunctionID):
 512         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 513         dout.set_function_id(*ranfunctionid);
 514         break;
 515
 516
 517       case (ProtocolIE_ID_id_RICactions_NotAdmitted):
 518         ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;
 519
 520         for(int index = 0; index < ric_not_admitted_action_list->list.count; index ++){
 521           RICaction_NotAdmitted_ItemIEs_t * item = (RICaction_NotAdmitted_ItemIEs_t *)ric_not_admitted_action_list->list.array[index];
 522           long int id = item->value.choice.RICaction_NotAdmitted_Item.ricActionID;
 523           int cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.present;
 524           int sub_cause;
 525           switch(cause){
 526
 527           case  RICcause_PR_radioNetwork :
 528             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;
 529             break;
 530
 531           case RICcause_PR_transport :
 532             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;
 533             break;
 534
 535           case  RICcause_PR_protocol :
 536             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;
 537             break;
 538
 539           case RICcause_PR_misc :
 540             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;
 541             break;
 542
 543           case RICcause_PR_ric :
 544             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;
 545             break;
 546
 547           default:
 548             std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
 549             return;
 550           }
 551           dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));
 552         }
 553         break;
 554       }
 555
 556   }
 557
 558   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 559 }
 560
 561
 562