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 = (E2N_E2AP_PDU_t *)calloc(1, sizeof(E2N_E2AP_PDU_t));
  34   assert(e2ap_pdu_obj != 0);
  35
  36   successMsg = 0;
  37   successMsg = (E2N_SuccessfulOutcome_t *)calloc(1, sizeof(E2N_SuccessfulOutcome_t));
  38   assert(successMsg != 0);
  39
  40   unsuccessMsg = 0;
  41   unsuccessMsg = (E2N_UnsuccessfulOutcome_t *)calloc(1, sizeof(E2N_UnsuccessfulOutcome_t));
  42   assert(unsuccessMsg != 0);
  43
  44   IE_array = 0;
  45   IE_array = (E2N_RICsubscriptionResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_RESPONSE_IES, sizeof(E2N_RICsubscriptionResponse_IEs_t));
  46   assert(IE_array != 0);
  47
  48   IE_Failure_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);
  51
  52   ie_admitted_list = 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;
  56
  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;
  61
  62
  63
  64
  65
  66 };
  67
  68
  69
  70 // Clear assigned protocolIE list from RIC indication IE container
  71 subscription_response::~subscription_response(void){
  72
  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);
  75
  76   for(int i = 0; i < response_admitted_list->list.size; i++){
  77     response_admitted_list->list.array[i] = 0;
  78   }
  79
  80
  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;
  86   }
  87
  88
  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;
  92   }
  93
  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;
  99   }
 100
 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;
 104   }
 105
 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;
 111   }
 112
 113
 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;
 117   }
 118
 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;
 124   }
 125
 126
 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;
 130   }
 131
 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;
 137   }
 138
 139
 140   free(ie_admitted_list);
 141   free(ie_not_admitted_list);
 142   free(IE_Failure_array);
 143   free(IE_array);
 144
 145
 146   ASN_STRUCT_FREE(asn_DEF_E2N_SuccessfulOutcome, successMsg);
 147   ASN_STRUCT_FREE(asn_DEF_E2N_UnsuccessfulOutcome, unsuccessMsg);
 148
 149
 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);
 153
 154   mdclog_write(MDCLOG_DEBUG, "Freed subscription response memory ");
 155
 156
 157 };
 158
 159
 160 bool subscription_response::encode_e2ap_subscription_response(unsigned char *buf, size_t *size, subscription_response_helper &dinput, bool is_success){
 161
 162
 163   if(is_success){
 164     set_fields_success(dinput);
 165     e2ap_pdu_obj->present =  E2N_E2AP_PDU_PR_successfulOutcome;
 166     e2ap_pdu_obj->choice.successfulOutcome = successMsg;
 167
 168     successMsg->procedureCode = E2N_ProcedureCode_id_ricSubscription;
 169     successMsg->criticality = E2N_Criticality_reject;
 170     successMsg->value.present = E2N_SuccessfulOutcome__value_PR_RICsubscriptionResponse;
 171
 172   }
 173   else{
 174     set_fields_unsuccess(dinput);
 175     e2ap_pdu_obj->present = E2N_E2AP_PDU_PR_unsuccessfulOutcome;
 176     e2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg;
 177
 178     unsuccessMsg->procedureCode = E2N_ProcedureCode_id_ricSubscription;
 179     unsuccessMsg->criticality = E2N_Criticality_reject;
 180     unsuccessMsg->value.present = E2N_UnsuccessfulOutcome__value_PR_RICsubscriptionFailure;
 181
 182   }
 183
 184   //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 185
 186   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
 187   if(ret_constr){
 188     error_string.assign(errbuf, errbuf_len);
 189     error_string = "Constraints failed for encoding subscription response. Reason = " + error_string;
 190     return false;
 191   }
 192
 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);
 194
 195   if(res.encoded == -1){
 196     std::cout <<"Error encoding PDU. Reason =" << strerror(errno) << std::endl;
 197     return false;
 198   }
 199   else {
 200     if(*size < res.encoded){
 201       fprintf(stderr,  "Buffer assigned too small to encode: %s",(char *)(asn_DEF_E2N_E2AP_PDU.name));
 202       res.encoded = -1;
 203       return false;
 204     }
 205   }
 206
 207   *size = res.encoded;
 208   return true;
 209
 210 }
 211
 212 void subscription_response::set_fields_success(subscription_response_helper &helper){
 213
 214   int ie_index;
 215
 216   E2N_RICsubscriptionResponse_t * subscription_response = &(successMsg->value.choice.RICsubscriptionResponse);
 217   //reset list count ..
 218   subscription_response->protocolIEs.list.count = 0;
 219
 220   ie_index = 0;
 221   E2N_RICsubscriptionResponse_IEs_t *ies_ricreq = &IE_array[ie_index];
 222
 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]));
 230
 231
 232   ie_index = 1;
 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]));
 240
 241
 242   ie_index = 2;
 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();
 249
 250   if(ref_admitted_action_array->size() ==  0){
 251     ies_admitted_actid->value.present =  E2N_RICsubscriptionResponse_IEs__value_PR_NOTHING;
 252   }
 253   else{
 254     ies_admitted_actid->value.present =  E2N_RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
 255
 256     // resize memory ?
 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);
 262     };
 263
 264
 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]));
 271     }
 272   }
 273   ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index]));
 274
 275   // optional IE : add only if non-zero list
 276   ie_index = 3;
 277   std::vector<ActionResponse> * ref_notadmitted_action_array = helper.get_not_admitted_list();
 278   if (ref_notadmitted_action_array->size() > 0){
 279
 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;
 283
 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;
 286
 287
 288     ies_notadmitted_actid->value.present =  E2N_RICsubscriptionResponse_IEs__value_PR_RICaction_NotAdmitted_List;
 289
 290     // resize memory ?
 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);
 296
 297     };
 298
 299
 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();
 305
 306       int cause = (*ref_notadmitted_action_array)[i].get_cause();
 307       switch(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();
 310         break;
 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();
 313         break;
 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();
 316         break;
 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();
 319         break;
 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();
 322         break;
 323       default:
 324         mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause);
 325         return;
 326       }
 327
 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]));
 330     }
 331
 332     ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, &(IE_array[ie_index]));
 333   }
 334
 335 }
 336
 337 void subscription_response:: get_fields(E2N_SuccessfulOutcome_t * success_msg,  subscription_response_helper & dout)
 338 {
 339
 340   assert(success_msg != NULL);
 341
 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;
 346
 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];
 349
 350     switch(memb_ptr->id)
 351       {
 352       case (E2N_ProtocolIE_ID_id_RICrequestID):
 353         requestid = &memb_ptr->value.choice.RICrequestID;
 354         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 355         break;
 356
 357       case (E2N_ProtocolIE_ID_id_RANfunctionID):
 358         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 359         dout.set_function_id(*ranfunctionid);
 360         break;
 361
 362       case (E2N_ProtocolIE_ID_id_RICactions_Admitted):
 363         ric_admitted_action_list = &memb_ptr->value.choice.RICaction_Admitted_List;
 364
 365         // admitted actions
 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));
 370         };
 371
 372         break;
 373
 374       case (E2N_ProtocolIE_ID_id_RICactions_NotAdmitted):
 375         ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;
 376
 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;
 381           int sub_cause;
 382           switch(cause){
 383
 384           case  E2N_RICcause_PR_radioNetwork :
 385             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;
 386             break;
 387
 388           case E2N_RICcause_PR_transport :
 389             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;
 390             break;
 391
 392           case  E2N_RICcause_PR_protocol :
 393             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;
 394             break;
 395
 396           case E2N_RICcause_PR_misc :
 397             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;
 398             break;
 399
 400           case E2N_RICcause_PR_ric :
 401             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;
 402             break;
 403
 404           default:
 405             std::cout <<"Error ! Illegal cause enum" << cause << std::endl;
 406             return;
 407           }
 408           dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));
 409         }
 410         break;
 411       }
 412
 413   }
 414
 415   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 416 }
 417
 418
 419 void subscription_response::set_fields_unsuccess( subscription_response_helper &helper){
 420
 421   int ie_index;
 422   E2N_RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionFailure);
 423   // reset list count
 424   ric_subscription_failure->protocolIEs.list.count = 0;
 425
 426   ie_index = 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]));
 435
 436   ie_index = 1;
 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]));
 444
 445   ie_index = 2;
 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;
 454   }
 455   else{
 456     ies_notadmitted_actid->value.present =  E2N_RICsubscriptionFailure_IEs__value_PR_RICaction_NotAdmitted_List;
 457
 458     // resize memory  ?
 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);
 464     };
 465
 466
 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();
 473
 474       int cause = (*ref_notadmitted_action_array)[i].get_cause();
 475       switch(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();
 478         break;
 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();
 481         break;
 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();
 484         break;
 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();
 487         break;
 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();
 490         break;
 491       default:
 492         mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause);
 493         return ;
 494       }
 495
 496       ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.present = (E2N_RICcause_PR)cause;
 497
 498       ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i]));
 499     }
 500
 501   }
 502   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, &(IE_Failure_array[ie_index]));
 503
 504
 505   // // criticality diagnostics is not generated/parsed currently since optional
 506   // i = 3;
 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;
 511
 512
 513 }
 514
 515 void subscription_response:: get_fields(E2N_UnsuccessfulOutcome_t * unsuccess_msg,  subscription_response_helper & dout)
 516 {
 517
 518   assert(unsuccess_msg != NULL);
 519
 520   E2N_RICrequestID_t *requestid;
 521   E2N_RANfunctionID_t * ranfunctionid;
 522   E2N_RICaction_NotAdmitted_List_t * ric_not_admitted_action_list;
 523
 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];
 526
 527     switch(memb_ptr->id)
 528       {
 529       case (E2N_ProtocolIE_ID_id_RICrequestID):
 530         requestid = &memb_ptr->value.choice.RICrequestID;
 531         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 532         break;
 533
 534       case (E2N_ProtocolIE_ID_id_RANfunctionID):
 535         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 536         dout.set_function_id(*ranfunctionid);
 537         break;
 538
 539
 540       case (E2N_ProtocolIE_ID_id_RICactions_NotAdmitted):
 541         ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;
 542
 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;
 547           int sub_cause;
 548           switch(cause){
 549
 550           case  E2N_RICcause_PR_radioNetwork :
 551             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;
 552             break;
 553
 554           case E2N_RICcause_PR_transport :
 555             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;
 556             break;
 557
 558           case  E2N_RICcause_PR_protocol :
 559             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;
 560             break;
 561
 562           case E2N_RICcause_PR_misc :
 563             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;
 564             break;
 565
 566           case E2N_RICcause_PR_ric :
 567             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;
 568             break;
 569
 570           default:
 571             mdclog_write(MDCLOG_ERR, "Error :: %s, %d : Unknown RIC cause %d\n", __FILE__, __LINE__, cause);
 572             return;
 573           }
 574           dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));
 575         }
 576         break;
 577       }
 578
 579   }
 580
 581   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 582 }
 583
 584
 585