src/E2AP-c/subscription/subscription_delete_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_delete_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_delete_response::subscription_delete_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_RICsubscriptionDeleteResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_DELETE_RESPONSE_IES, sizeof(E2N_RICsubscriptionDeleteResponse_IEs_t));
  46   assert(IE_array != 0);
  47
  48   IE_Failure_array = 0;
  49   IE_Failure_array = (E2N_RICsubscriptionDeleteFailure_IEs_t *)calloc(NUM_SUBSCRIPTION_DELETE_FAILURE_IES, sizeof(E2N_RICsubscriptionDeleteFailure_IEs_t));
  50   assert(IE_Failure_array != 0);
  51
  52
  53
  54 };
  55
  56
  57
  58 // Clear assigned protocolIE list from E2N_RIC indication IE container
  59 subscription_delete_response::~subscription_delete_response(void){
  60
  61   mdclog_write(MDCLOG_DEBUG, "Freeing subscription delete response memory");
  62   E2N_RICsubscriptionDeleteResponse_t * ric_subscription_delete_response = &(successMsg->value.choice.RICsubscriptionDeleteResponse);
  63
  64   for(unsigned int i = 0; i < ric_subscription_delete_response->protocolIEs.list.size ; i++){
  65     ric_subscription_delete_response->protocolIEs.list.array[i] = 0;
  66   }
  67
  68
  69   E2N_RICsubscriptionDeleteFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionDeleteFailure);
  70   for(unsigned int i = 0; i < ric_subscription_failure->protocolIEs.list.size; i++){
  71     ric_subscription_failure->protocolIEs.list.array[i] = 0;
  72   }
  73
  74   free(IE_array);
  75   free(IE_Failure_array);
  76
  77   ASN_STRUCT_FREE(asn_DEF_E2N_SuccessfulOutcome, successMsg);
  78
  79   ASN_STRUCT_FREE(asn_DEF_E2N_UnsuccessfulOutcome, unsuccessMsg);
  80
  81   e2ap_pdu_obj->choice.successfulOutcome = NULL;
  82   e2ap_pdu_obj->choice.unsuccessfulOutcome = NULL;
  83
  84   ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj);
  85   mdclog_write(MDCLOG_DEBUG, "Freed subscription delete response memory");
  86
  87 };
  88
  89
  90 bool subscription_delete_response::encode_e2ap_subscription_delete_response(unsigned char *buf, size_t *size,  subscription_response_helper &dinput, bool is_success){
  91
  92   bool res;
  93
  94   if(is_success){
  95     res = set_fields(successMsg, dinput);
  96     if (!res){
  97       return false;
  98     }
  99     e2ap_pdu_obj->present =  E2N_E2AP_PDU_PR_successfulOutcome;
 100     e2ap_pdu_obj->choice.successfulOutcome = successMsg;
 101   }
 102   else{
 103     res = set_fields(unsuccessMsg, dinput);
 104     if(! res){
 105       return false;
 106     }
 107     e2ap_pdu_obj->present = E2N_E2AP_PDU_PR_unsuccessfulOutcome;
 108     e2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg;
 109   }
 110
 111
 112   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
 113   if(ret_constr){
 114     error_string.assign(errbuf, errbuf_len);
 115     return false;
 116   }
 117
 118   //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 119
 120   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj, buf, *size);
 121
 122   if(retval.encoded == -1){
 123     error_string.assign(strerror(errno));
 124     error_string = "Error encoding subcription delete response. Reason = " + error_string;
 125     return false;
 126   }
 127   else {
 128     if(*size < retval.encoded){
 129       std::stringstream ss;
 130       ss  <<"Error encoding Subscription Delete Response . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 131       error_string = ss.str();
 132       retval.encoded = -1;
 133       return false;
 134     }
 135   }
 136
 137   *size = retval.encoded;
 138   return true;
 139
 140 }
 141
 142 bool  subscription_delete_response::set_fields(E2N_SuccessfulOutcome_t *success, subscription_response_helper &helper){
 143
 144   if (success == 0){
 145     error_string = "Invalid reference to success message in set fields  subscription delete response";
 146     return false;
 147   }
 148
 149   unsigned int ie_index;
 150
 151   success->procedureCode = E2N_ProcedureCode_id_ricSubscriptionDelete;
 152   success->criticality = E2N_Criticality_reject;
 153   success->value.present = E2N_SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse;
 154
 155   E2N_RICsubscriptionDeleteResponse_t * subscription_delete_response = &(success->value.choice.RICsubscriptionDeleteResponse);
 156   subscription_delete_response->protocolIEs.list.count = 0;
 157
 158   ie_index = 0;
 159   E2N_RICsubscriptionDeleteResponse_IEs_t *ies_ricreq = &IE_array[ie_index];
 160
 161   ies_ricreq->criticality = E2N_Criticality_reject;
 162   ies_ricreq->id = E2N_ProtocolIE_ID_id_RICrequestID;
 163   ies_ricreq->value.present = E2N_RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
 164   E2N_RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 165   ricrequest_ie->ricRequestorID = helper.get_request_id();
 166   ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
 167   ASN_SEQUENCE_ADD(&subscription_delete_response->protocolIEs, ies_ricreq);
 168
 169
 170   ie_index = 1;
 171   E2N_RICsubscriptionDeleteResponse_IEs_t *ies_ranfunc = &IE_array[ie_index];
 172   ies_ranfunc->criticality = E2N_Criticality_reject;
 173   ies_ranfunc->id = E2N_ProtocolIE_ID_id_RANfunctionID;
 174   ies_ranfunc->value.present = E2N_RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
 175   E2N_RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 176   *ranfunction_ie = helper.get_function_id();
 177   ASN_SEQUENCE_ADD(&subscription_delete_response->protocolIEs, ies_ranfunc);
 178
 179   return true;
 180
 181
 182 }
 183
 184 bool subscription_delete_response:: get_fields(E2N_SuccessfulOutcome_t * success_msg,  subscription_response_helper & dout)
 185 {
 186
 187   if (success_msg == 0){
 188     error_string = "Invalid reference to success message inn get fields subscription delete response";
 189     return false;
 190   }
 191
 192   E2N_RICrequestID_t *requestid;
 193   E2N_RANfunctionID_t * ranfunctionid;
 194
 195   for(int edx = 0; edx < success_msg->value.choice.RICsubscriptionDeleteResponse.protocolIEs.list.count; edx++) {
 196     E2N_RICsubscriptionDeleteResponse_IEs_t *memb_ptr = success_msg->value.choice.RICsubscriptionDeleteResponse.protocolIEs.list.array[edx];
 197
 198     switch(memb_ptr->id)
 199       {
 200       case (E2N_ProtocolIE_ID_id_RICrequestID):
 201         requestid = &memb_ptr->value.choice.RICrequestID;
 202         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 203         break;
 204
 205       case (E2N_ProtocolIE_ID_id_RANfunctionID):
 206         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 207         dout.set_function_id(*ranfunctionid);
 208         break;
 209       }
 210
 211   }
 212
 213   return true;
 214   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 215 }
 216
 217
 218 bool subscription_delete_response::set_fields(E2N_UnsuccessfulOutcome_t *unsuccess, subscription_response_helper &helper){
 219
 220   if (unsuccess == 0){
 221     error_string = "Invalid reference to unsuccess message in set fields  subscription delete response";
 222     return false;
 223   }
 224
 225   unsigned int ie_index;
 226
 227   unsuccess->procedureCode = E2N_ProcedureCode_id_ricSubscriptionDelete;
 228   unsuccess->criticality = E2N_Criticality_reject;
 229   unsuccess->value.present = E2N_UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure;
 230
 231   E2N_RICsubscriptionDeleteFailure_t * ric_subscription_failure = &(unsuccess->value.choice.RICsubscriptionDeleteFailure);
 232   ric_subscription_failure->protocolIEs.list.count = 0;
 233
 234   ie_index = 0;
 235   E2N_RICsubscriptionDeleteFailure_IEs_t *ies_ricreq = &IE_Failure_array[ie_index];
 236
 237   ies_ricreq->criticality = E2N_Criticality_reject;
 238   ies_ricreq->id = E2N_ProtocolIE_ID_id_RICrequestID;
 239   ies_ricreq->value.present = E2N_RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
 240   E2N_RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 241   ricrequest_ie->ricRequestorID = helper.get_request_id();
 242   ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
 243   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ricreq);
 244
 245   ie_index = 1;
 246   E2N_RICsubscriptionDeleteFailure_IEs_t *ies_ranfunc = &IE_Failure_array[ie_index];
 247   ies_ranfunc->criticality = E2N_Criticality_reject;
 248   ies_ranfunc->id = E2N_ProtocolIE_ID_id_RANfunctionID;
 249   ies_ranfunc->value.present = E2N_RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
 250   E2N_RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 251   *ranfunction_ie = helper.get_function_id();
 252   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ranfunc);
 253
 254
 255   return true;
 256
 257 }
 258
 259 bool  subscription_delete_response:: get_fields(E2N_UnsuccessfulOutcome_t * unsuccess_msg,  subscription_response_helper & dout)
 260 {
 261
 262   if (unsuccess_msg == 0){
 263     error_string = "Invalid reference to unsuccess message in get fields  subscription delete response";
 264     return false;
 265   }
 266
 267   E2N_RICrequestID_t *requestid;
 268   E2N_RANfunctionID_t * ranfunctionid;
 269
 270   for(int edx = 0; edx < unsuccess_msg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.count; edx++) {
 271     E2N_RICsubscriptionDeleteFailure_IEs_t *memb_ptr = unsuccess_msg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.array[edx];
 272
 273     switch(memb_ptr->id)
 274       {
 275       case (E2N_ProtocolIE_ID_id_RICrequestID):
 276         requestid = &memb_ptr->value.choice.RICrequestID;
 277         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 278         break;
 279
 280       case (E2N_ProtocolIE_ID_id_RANfunctionID):
 281         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 282         dout.set_function_id(*ranfunctionid);
 283         break;
 284
 285       }
 286
 287   }
 288
 289   return true;
 290   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 291 }
 292
 293
 294