src/xapp-asn/e2ap/e2ap_subsdel_failure.cc

   1 /*
   2 ==================================================================================
   3
   4         Copyright (c) 2019-2020 AT&T Intellectual Property.
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 /*
  21  * e2ap_subsdel_failure.cc
  22  *
  23  * Author: Shraboni Jana
  24  */
  25
  26
  27
  28 #include "e2ap_subsdel_failure.hpp"
  29
  30 E2APSubscriptionDeleteFailure::E2APSubscriptionDeleteFailure(SubscriptionDeleteFailureIEs& ieObj){
  31
  32
  33
  34   _failureIEs = std::make_unique<SubscriptionDeleteFailureIEs>();
  35   *_failureIEs = ieObj;
  36
  37   _e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t));
  38   assert(_e2ap_pdu_obj != 0);
  39
  40   _unsuccessMsg = (UnsuccessfulOutcome_t * )calloc(1, sizeof(UnsuccessfulOutcome_t));
  41   assert(_unsuccessMsg != 0);
  42
  43   IE_array = (RICsubscriptionDeleteFailure_IEs_t *)calloc(RIC_SUBDEL_FAILURE_IES_COUNT, sizeof(RICsubscriptionDeleteFailure_IEs_t));
  44   assert(IE_array != 0);
  45
  46   RICsubscriptionDeleteFailure_t * subDelfail = &(_unsuccessMsg->value.choice.RICsubscriptionDeleteFailure);
  47   for(int i = 0; i < RIC_SUBDEL_FAILURE_IES_COUNT; i++){
  48     ASN_SEQUENCE_ADD(&subDelfail->protocolIEs, &(IE_array[i]));
  49   }
  50   CD_array = 0;
  51
  52
  53 };
  54
  55 E2APSubscriptionDeleteFailure::E2APSubscriptionDeleteFailure(unsigned char *buf, size_t *size){
  56           _e2ap_pdu_obj = 0;
  57           _unsuccessMsg = 0;
  58           IE_array = 0;
  59           CD_array = 0;
  60           _failureIEs = std::make_unique<SubscriptionDeleteFailureIEs>();
  61
  62            bool status =  this->decode(buf, size);
  63            if(!status)
  64                    throw "E2AP Subscription Delete Failure Decode Failed: "+this->get_error();
  65 }
  66
  67 // Clear assigned protocolIE list from RIC indication IE container
  68 E2APSubscriptionDeleteFailure::~E2APSubscriptionDeleteFailure(void){
  69
  70   mdclog_write(MDCLOG_DEBUG, "Freeing subscription delete request object memory");
  71   RICsubscriptionDeleteFailure_t * E2APSubscriptionDeleteFailure = &(_unsuccessMsg->value.choice.RICsubscriptionDeleteFailure);
  72
  73  for(int i = 0; i < E2APSubscriptionDeleteFailure->protocolIEs.list.size; i++){
  74     E2APSubscriptionDeleteFailure->protocolIEs.list.array[i] = 0;
  75   }
  76
  77   if (E2APSubscriptionDeleteFailure->protocolIEs.list.size > 0){
  78     free(E2APSubscriptionDeleteFailure->protocolIEs.list.array);
  79     E2APSubscriptionDeleteFailure->protocolIEs.list.count = 0;
  80     E2APSubscriptionDeleteFailure->protocolIEs.list.size = 0;
  81     E2APSubscriptionDeleteFailure->protocolIEs.list.array = 0;
  82   }
  83
  84   free(IE_array);
  85   free(CD_array);
  86   free(_unsuccessMsg);
  87   _e2ap_pdu_obj->choice.unsuccessfulOutcome = 0;
  88
  89   ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
  90   mdclog_write(MDCLOG_DEBUG, "Freed subscription delete request object memory");
  91
  92
  93 };
  94
  95
  96
  97 bool E2APSubscriptionDeleteFailure::decode(unsigned char *buf, size_t *size)
  98 {
  99
 100         asn_dec_rval_t dec_res  = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&(_e2ap_pdu_obj), buf, *size);
 101         if(dec_res.code != RC_OK){
 102                                  mdclog_write(MDCLOG_ERR, "Failed to decode: %s","RIC Subscription Delete Failure");
 103                                  return false;
 104         } else {
 105                                  mdclog_write(MDCLOG_INFO, "Unsuccessfully decoded: %s","RIC Subscription Delete Failure");
 106         }
 107
 108     _unsuccessMsg = _e2ap_pdu_obj->choice.unsuccessfulOutcome;
 109     //write the decoding code.
 110
 111     if (_unsuccessMsg == 0){
 112         _error_string = "Invalid reference to success message in get fields subscription delete failure";
 113         return false;
 114     }
 115
 116
 117     for(int edx = 0; edx < _unsuccessMsg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.count; edx++) {
 118                 RICsubscriptionDeleteFailure_IEs_t *memb_ptr = _unsuccessMsg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.array[edx];
 119
 120                 switch(memb_ptr->id)
 121                 {
 122                 //1.
 123                 case (ProtocolIE_ID_id_RICrequestID):
 124                                 _failureIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID);
 125                         _failureIEs->set_ricInstanceID(memb_ptr->value.choice.RICrequestID.ricInstanceID);
 126         break;
 127         //2.
 128                 case (ProtocolIE_ID_id_RANfunctionID):
 129                                 _failureIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID);
 130
 131                 break;
 132                 //3.
 133                 case (ProtocolIE_ID_id_Cause):
 134
 135                                 _failureIEs->set_ricCause(memb_ptr->value.choice.Cause.present);
 136                         switch(memb_ptr->value.choice.Cause.present){
 137                         case  Cause_PR_ricService :
 138                                 _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.ricService);
 139                                 break;
 140                         case Cause_PR_transport :
 141                                 _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.transport);
 142                                 break;
 143                         case  Cause_PR_protocol :
 144                                 _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.protocol);
 145                                 break;
 146                         case Cause_PR_misc :
 147                                 _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.misc);
 148                                 break;
 149                         case Cause_PR_ricRequest :
 150                                 _failureIEs->set_ricSubCause(memb_ptr->value.choice.Cause.choice.ricRequest);
 151                                 break;
 152                         default:
 153                                 _failureIEs->set_ricSubCause(-1);
 154                                 break;
 155                         }
 156
 157
 158         break;
 159     //4.
 160         case (ProtocolIE_ID_id_CriticalityDiagnostics):
 161
 162                 _cdWrapperIEs.set_procedureCode(*(memb_ptr->value.choice.CriticalityDiagnostics.procedureCode));
 163                 _cdWrapperIEs.set_procedureCriticality(*(memb_ptr->value.choice.CriticalityDiagnostics.procedureCriticality));
 164                 _cdWrapperIEs.set_triggeringMessage(*(memb_ptr->value.choice.CriticalityDiagnostics.triggeringMessage));
 165
 166
 167                 RICrequestID_t* ricReq =  (RICrequestID_t*)memb_ptr->value.choice.CriticalityDiagnostics.ricRequestorID;
 168                 _cdWrapperIEs.set_ricRequestorID(ricReq->ricRequestorID);
 169             _cdWrapperIEs.set_ricInstanceID(ricReq->ricInstanceID);
 170
 171         int lstcount = memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.count;
 172         auto *lst = _failureIEs->get_critical_diagnostic()->get_list();
 173         for(int i=0; i < lstcount; i++){
 174                         CriticalityDiagnosticsIEs tmpObj;
 175                         tmpObj.set_iEcriticality(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->iECriticality);
 176                         tmpObj.set_ieID(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->iE_ID);
 177                         tmpObj.set_typeOferror(memb_ptr->value.choice.CriticalityDiagnostics.iEsCriticalityDiagnostics->list.array[i]->typeOfError);
 178                         _cdWrapperIEs.add(tmpObj);
 179             }
 180                         _failureIEs->set_critical_diagnostic(_cdWrapperIEs);
 181          break;
 182
 183       }
 184         }
 185    // xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
 186         return true;
 187 }
 188
 189
 190 bool E2APSubscriptionDeleteFailure::encode(unsigned char *buf, size_t *size){
 191
 192   _e2ap_pdu_obj->choice.unsuccessfulOutcome = _unsuccessMsg;
 193   _e2ap_pdu_obj->present = E2AP_PDU_PR_unsuccessfulOutcome;
 194   bool result = setfields( _unsuccessMsg);
 195   if(!result){
 196           return result;
 197   }
 198   _unsuccessMsg->procedureCode = ProcedureCode_id_RICsubscriptionDelete;
 199   _unsuccessMsg->criticality = Criticality_reject;
 200   _unsuccessMsg->value.present = UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure;
 201
 202   int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len);
 203   if(ret_constr){
 204     _error_string.assign(_errbuf, _errbuf_len);
 205     _error_string = "Constraints failed for encoding subscription delete request. Reason = " + _error_string;
 206     return false;
 207   }
 208
 209   asn_enc_rval_t res = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size);
 210
 211   if(res.encoded == -1){
 212     _error_string.assign(strerror(errno));
 213     _error_string = "Error encoding Subscription Delete Request. Reason = " + _error_string;
 214     return false;
 215   }
 216   else {
 217     if(*size < res.encoded){
 218       std::stringstream ss;
 219       ss  <<"Error encoding Subscription Delete Request . Reason =  encoded pdu size " << res.encoded << " exceeds buffer size " << *size << std::endl;
 220       _error_string = ss.str();
 221       res.encoded = -1;
 222       return false;
 223     }
 224   }
 225
 226   *size = res.encoded;
 227   xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
 228
 229   return true;
 230
 231 }
 232
 233
 234 bool  E2APSubscriptionDeleteFailure::setfields( UnsuccessfulOutcome_t *_unsuccessMsg){
 235   unsigned int ie_index;
 236
 237   ie_index = 0;
 238   RICsubscriptionDeleteFailure_IEs_t *ies_ricreq = &IE_array[ie_index];
 239   ies_ricreq->criticality = Criticality_reject;
 240   ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
 241   ies_ricreq->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
 242   RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 243   ricrequest_ie->ricRequestorID = this->getIEs().get_ricRequestorID();
 244   ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID();
 245
 246
 247   ie_index++;
 248   RICsubscriptionDeleteFailure_IEs_t *ies_ranfunc = &IE_array[ie_index];
 249   ies_ranfunc->criticality = Criticality_reject;
 250   ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 251   ies_ranfunc->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
 252   RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 253   *ranfunction_ie = this->getIEs().get_ranFunctionID();
 254
 255   ie_index++;
 256   RICsubscriptionDeleteFailure_IEs_t *ies_ric_cause = &IE_array[ie_index];
 257         ies_ric_cause->criticality = Criticality_ignore;
 258         ies_ric_cause->id = ProtocolIE_ID_id_Cause;
 259         ies_ric_cause->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_Cause;
 260         Cause_t * ric_cause = &(ies_ric_cause->value.choice.Cause);
 261         ric_cause->present = (Cause_PR)this->getIEs().get_ricCause();
 262         switch(this->getIEs().get_ricCause()){
 263         case Cause_PR_ricService:
 264                 ric_cause->choice.ricService = this->getIEs().get_ricSubCause();
 265                 break;
 266         case Cause_PR_transport:
 267                 ric_cause->choice.transport = this->getIEs().get_ricSubCause();
 268                 break;
 269         case Cause_PR_protocol:
 270                 ric_cause->choice.protocol= this->getIEs().get_ricSubCause();
 271                 break;
 272         case Cause_PR_misc:
 273                 ric_cause->choice.misc = this->getIEs().get_ricSubCause();
 274                 break;
 275         case Cause_PR_ricRequest:
 276                 ric_cause->choice.ricRequest = this->getIEs().get_ricSubCause();
 277                 break;
 278         default:
 279                 _error_string = _error_string + "Error ! Illegal cause enum " + std::to_string(this->getIEs().get_ricCause());
 280                 return false;
 281         }
 282
 283   if(this->getIEs().get_is_criticality_diagnostic()) {
 284   ie_index++;
 285   RICsubscriptionDeleteFailure_IEs_t *ies_criticdiag = &IE_array[ie_index];
 286   ies_criticdiag->criticality =  Criticality_ignore;
 287   ies_criticdiag->id = ProtocolIE_ID_id_CriticalityDiagnostics;
 288   ies_criticdiag->value.present = RICsubscriptionDeleteFailure_IEs__value_PR_CriticalityDiagnostics;
 289   CriticalityDiagnostics_t *critic_diag = &ies_criticdiag->value.choice.CriticalityDiagnostics;
 290
 291   TriggeringMessage_t *tmsg = (TriggeringMessage_t*) calloc(1, sizeof(TriggeringMessage_t));
 292   *tmsg = this->getIEs().get_critical_diagnostic()->get_triggeringMessage();
 293   critic_diag->triggeringMessage= tmsg;
 294
 295   RICrequestID_t *ricreq = (RICrequestID_t *)calloc(1, sizeof(RICrequestID_t));
 296   ricrequest_ie->ricRequestorID = this->getIEs().get_critical_diagnostic()->get_ricRequestorID();
 297   ricrequest_ie->ricInstanceID = this->getIEs().get_critical_diagnostic()->get_ricInstanceID();
 298   critic_diag->ricRequestorID = ricreq;
 299
 300   ProcedureCode_t *pcode = (ProcedureCode_t*)calloc(1, sizeof(ProcedureCode_t));
 301   *pcode = this->getIEs().get_critical_diagnostic()->get_procedureCode();
 302   critic_diag->procedureCode =pcode;
 303
 304   Criticality_t *pcritical = (Criticality_t*)calloc(1, sizeof(Criticality_t));
 305   *pcritical = this->getIEs().get_critical_diagnostic()->get_procedureCriticality();
 306   critic_diag->procedureCriticality = pcritical;
 307
 308
 309   if(this->getIEs().get_critical_diagnostic()->get_is_criticalityDiagnostics_list()){
 310
 311           critic_diag->iEsCriticalityDiagnostics = (CriticalityDiagnostics_IE_List_t*)calloc(1, sizeof(CriticalityDiagnostics_IE_List_t));
 312           critic_diag->iEsCriticalityDiagnostics->list.count=0;
 313
 314           int lst_count = this->getIEs().get_critical_diagnostic()->get_list_count();
 315           auto *lst = this->getIEs().get_critical_diagnostic()->get_list();
 316           CD_array = (CriticalityDiagnostics_IE_Item_t*)calloc(lst_count, sizeof(CriticalityDiagnostics_IE_Item_t));
 317           int i = 0;
 318           for(auto l:*lst){
 319                   CD_array[i].iE_ID =  l.get_typeOferror();
 320                   CD_array[i].typeOfError = l.get_ieID();
 321                   CD_array[i].iECriticality = l.get_iEcriticality();
 322                  int result = ASN_SEQUENCE_ADD(&(critic_diag->iEsCriticalityDiagnostics->list.array), &(CD_array[i]));
 323                  if (result == -1){
 324                        _error_string = "Error : Unable to assign memory to add CriticalityDiagnostics_IE item to set up list";
 325                        return false;
 326                          }
 327                      i++;
 328                   }
 329
 330           }
 331   }
 332
 333   return true;
 334 };
 335
 336
 337
 338
 339