src/E2AP-c/subscription/subscription_response.cc

   1 \r
   2 \r
   3 /*\r
   4 ==================================================================================\r
   5         Copyright (c) 2018-2019 SAMSUNG and AT&T Intellectual Property.\r
   6 \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
  10 \r
  11        http://www.apache.org/licenses/LICENSE-2.0\r
  12 \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
  19 */\r
  20 \r
  21 \r
  22 #include "subscription_response.hpp"\r
  23 \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
  26 */\r
  27 \r
  28 \r
  29 // Primarly for generation\r
  30 subscription_response::subscription_response(void){\r
  31 \r
  32   e2ap_pdu_obj = 0;\r
  33   e2ap_pdu_obj = (E2AP_PDU_t *)calloc(1, sizeof(E2AP_PDU_t));\r
  34   assert(e2ap_pdu_obj != 0);\r
  35 \r
  36   successMsg = 0;\r
  37   successMsg = (SuccessfulOutcome_t *)calloc(1, sizeof(SuccessfulOutcome_t));\r
  38   assert(successMsg != 0);\r
  39 \r
  40   unsuccessMsg = 0;\r
  41   unsuccessMsg = (UnsuccessfulOutcome_t *)calloc(1, sizeof(UnsuccessfulOutcome_t));\r
  42   assert(unsuccessMsg != 0);\r
  43 \r
  44   IE_array = 0;\r
  45   IE_array = (RICsubscriptionResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_RESPONSE_IES, sizeof(RICsubscriptionResponse_IEs_t));\r
  46   assert(IE_array != 0);\r
  47 \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
  51 \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
  56   \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
  61   \r
  62     \r
  63 };\r
  64 \r
  65   \r
  66 \r
  67 // Clear assigned protocolIE list from RIC indication IE container\r
  68 subscription_response::~subscription_response(void){\r
  69 \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
  72   \r
  73   for(int i = 0; i < response_admitted_list->list.size; i++){\r
  74     response_admitted_list->list.array[i] = 0;\r
  75   }\r
  76 \r
  77   \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
  83   }\r
  84 \r
  85   \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
  89   }\r
  90   \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
  96   }\r
  97      \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
 101   }\r
 102   \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
 108   }\r
 109   \r
 110   \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
 114   }\r
 115 \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
 121   }\r
 122   \r
 123      \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
 127   }\r
 128   \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
 134   }\r
 135 \r
 136   \r
 137 \r
 138   free(ie_admitted_list);  \r
 139   free(ie_not_admitted_list);\r
 140   free(IE_Failure_array);\r
 141   free(IE_array);\r
 142 \r
 143   \r
 144   ASN_STRUCT_FREE(asn_DEF_SuccessfulOutcome, successMsg);\r
 145   ASN_STRUCT_FREE(asn_DEF_UnsuccessfulOutcome, unsuccessMsg);\r
 146 \r
 147   \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
 151 \r
 152   mdclog_write(MDCLOG_INFO, "Freed subscription response memory ");\r
 153 \r
 154   \r
 155 };\r
 156 \r
 157 \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
 159 \r
 160   //memset(e2ap_pdu, 0, sizeof(E2AP_PDU_t));\r
 161 \r
 162   if(is_success){\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
 166   }\r
 167   else{\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
 171   }\r
 172     \r
 173   //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);\r
 174 \r
 175   int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);\r
 176   if(ret_constr){\r
 177     error_string.assign(errbuf, errbuf_len);\r
 178     error_string = "Constraints failed for encoding subscription response. Reason = " + error_string;\r
 179     return false;\r
 180   }\r
 181     \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
 183     \r
 184   if(res.encoded == -1){\r
 185     std::cout <<"Error encoding PDU. Reason =" << strerror(errno) << std::endl;\r
 186     return false;\r
 187   }\r
 188   else {\r
 189     if(*size < res.encoded){\r
 190       fprintf(stderr,  "Buffer assigned too small to encode: %s",(char *)(asn_DEF_E2AP_PDU.name));\r
 191       res.encoded = -1;\r
 192       return false;\r
 193     }\r
 194   }\r
 195     \r
 196   *size = res.encoded;\r
 197   return true;\r
 198     \r
 199 }\r
 200   \r
 201 void subscription_response::set_fields(SuccessfulOutcome_t *success, subscription_response_helper &helper){\r
 202 \r
 203   int ie_index;\r
 204 \r
 205   success->procedureCode = ProcedureCode_id_ricSubscription;\r
 206   success->criticality = Criticality_reject;\r
 207   success->value.present = SuccessfulOutcome__value_PR_RICsubscriptionResponse;   \r
 208  \r
 209   RICsubscriptionResponse_t * subscription_response = &(success->value.choice.RICsubscriptionResponse);\r
 210   subscription_response->protocolIEs.list.count = 0;\r
 211   \r
 212   ie_index = 0;\r
 213   RICsubscriptionResponse_IEs_t *ies_ricreq = &IE_array[ie_index];\r
 214   \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
 222 \r
 223   \r
 224   ie_index = 1;\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
 232     \r
 233   ie_index = 2;\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
 239   \r
 240   std::vector<ActionResponse> * ref_admitted_action_array = helper.get_admitted_list();\r
 241   // realloc ?\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
 248   };\r
 249   \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
 257   }\r
 258   \r
 259   ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_admitted_actid);\r
 260                    \r
 261   ie_index = 3;\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
 267   \r
 268   std::vector<ActionResponse> * ref_notadmitted_action_array = helper.get_not_admitted_list();\r
 269   //realloc ?\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
 276   };\r
 277   \r
 278    \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
 286 \r
 287     int cause = (*ref_notadmitted_action_array)[i].get_cause();\r
 288     switch(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
 291       break;\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
 294       break;\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
 297       break;\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
 300       break;\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
 303       break;\r
 304     default:\r
 305       std::cout <<"Error ! Illegal cause enum" << cause << std::endl;\r
 306       return;\r
 307     }\r
 308 \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
 311   }\r
 312   \r
 313   ASN_SEQUENCE_ADD(&subscription_response->protocolIEs, ies_notadmitted_actid);\r
 314  \r
 315         \r
 316 }\r
 317 \r
 318 void subscription_response:: get_fields(SuccessfulOutcome_t * success_msg,  subscription_response_helper & dout)\r
 319 {\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
 324     \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
 327     \r
 328     switch(memb_ptr->id)\r
 329       {\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
 333         break;\r
 334           \r
 335       case (ProtocolIE_ID_id_RANfunctionID):\r
 336         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;\r
 337         dout.set_function_id(*ranfunctionid);\r
 338         break;\r
 339           \r
 340       case (ProtocolIE_ID_id_RICactions_Admitted):\r
 341         ric_admitted_action_list = &memb_ptr->value.choice.RICaction_Admitted_List;\r
 342           \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
 348         };\r
 349 \r
 350         break;\r
 351 \r
 352       case (ProtocolIE_ID_id_RICactions_NotAdmitted):\r
 353         ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;\r
 354           \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
 359           int sub_cause;\r
 360           switch(cause){\r
 361               \r
 362           case  RICcause_PR_radioNetwork :\r
 363             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;\r
 364             break;\r
 365               \r
 366           case RICcause_PR_transport :\r
 367             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;\r
 368             break;\r
 369               \r
 370           case  RICcause_PR_protocol :\r
 371             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;\r
 372             break;\r
 373               \r
 374           case RICcause_PR_misc :\r
 375             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;\r
 376             break;\r
 377               \r
 378           case RICcause_PR_ric :\r
 379             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;\r
 380             break;\r
 381               \r
 382           default:\r
 383             std::cout <<"Error ! Illegal cause enum" << cause << std::endl;\r
 384             return;\r
 385           }  \r
 386           dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));\r
 387         }\r
 388         break;\r
 389       }\r
 390       \r
 391   }\r
 392     \r
 393   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);\r
 394 }\r
 395 \r
 396 \r
 397 void subscription_response::set_fields(UnsuccessfulOutcome_t *unsuccess, subscription_response_helper &helper){\r
 398 \r
 399   int ie_index;\r
 400 \r
 401   unsuccess->procedureCode = ProcedureCode_id_ricSubscription;\r
 402   unsuccess->criticality = Criticality_reject;\r
 403   unsuccess->value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionFailure;\r
 404 \r
 405   RICsubscriptionFailure_t * ric_subscription_failure = &(unsuccess->value.choice.RICsubscriptionFailure);\r
 406   ric_subscription_failure->protocolIEs.list.count = 0;\r
 407   \r
 408   ie_index = 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
 417   \r
 418   ie_index = 1;\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
 426     \r
 427 \r
 428   ie_index = 2;\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
 433 \r
 434   //realloc ?\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
 441   };\r
 442       \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
 445 \r
 446 \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
 454 \r
 455     int cause = (*ref_notadmitted_action_array)[i].get_cause();\r
 456     switch(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
 459       break;\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
 462       break;\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
 465       break;\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
 468       break;\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
 471       break;\r
 472     default:\r
 473       std::cout <<"Error ! Illegal cause enum" << cause << std::endl;\r
 474       return;\r
 475     }\r
 476 \r
 477     ie_not_admitted_list[i].value.choice.RICaction_NotAdmitted_Item.ricCause.present = (RICcause_PR)cause;\r
 478       \r
 479     ASN_SEQUENCE_ADD(ric_not_admitted_actions_ie, &(ie_not_admitted_list[i]));\r
 480   }\r
 481   \r
 482   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_notadmitted_actid);\r
 483 \r
 484 \r
 485   // // criticality diagnostics is not generated/parsed currently since optional\r
 486   // i = 3;\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
 491 \r
 492     \r
 493 }\r
 494 \r
 495 void subscription_response:: get_fields(UnsuccessfulOutcome_t * unsuccess_msg,  subscription_response_helper & dout)\r
 496 {\r
 497   RICrequestID_t *requestid;\r
 498   RANfunctionID_t * ranfunctionid;\r
 499   RICaction_NotAdmitted_List_t * ric_not_admitted_action_list;\r
 500     \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
 503     \r
 504     switch(memb_ptr->id)\r
 505       {\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
 509         break;\r
 510           \r
 511       case (ProtocolIE_ID_id_RANfunctionID):\r
 512         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;\r
 513         dout.set_function_id(*ranfunctionid);\r
 514         break;\r
 515           \r
 516 \r
 517       case (ProtocolIE_ID_id_RICactions_NotAdmitted):\r
 518         ric_not_admitted_action_list = &memb_ptr->value.choice.RICaction_NotAdmitted_List;\r
 519           \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
 524           int sub_cause;\r
 525           switch(cause){\r
 526               \r
 527           case  RICcause_PR_radioNetwork :\r
 528             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.radioNetwork;\r
 529             break;\r
 530               \r
 531           case RICcause_PR_transport :\r
 532             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.transport;\r
 533             break;\r
 534               \r
 535           case  RICcause_PR_protocol :\r
 536             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.protocol;\r
 537             break;\r
 538               \r
 539           case RICcause_PR_misc :\r
 540             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.misc;\r
 541             break;\r
 542               \r
 543           case RICcause_PR_ric :\r
 544             sub_cause = item->value.choice.RICaction_NotAdmitted_Item.ricCause.choice.ric;\r
 545             break;\r
 546               \r
 547           default:\r
 548             std::cout <<"Error ! Illegal cause enum" << cause << std::endl;\r
 549             return;\r
 550           }  \r
 551           dout.get_not_admitted_list()->push_back(ActionResponse(id, cause, sub_cause));\r
 552         }\r
 553         break;\r
 554       }\r
 555       \r
 556   }\r
 557     \r
 558   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);\r
 559 }\r
 560 \r
 561 \r
 562 \r