src/xapp-formats/e2ap/subscription_delete_response.cc

   1 /*
   2 ==================================================================================
   3         Copyright (c) 2018-2019 AT&T Intellectual Property.
   4
   5    Licensed under the Apache License, Version 2.0 (the "License");
   6    you may not use this file except in compliance with the License.
   7    You may obtain a copy of the License at
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  11    Unless required by applicable law or agreed to in writing, software
  12    distributed under the License is distributed on an "AS IS" BASIS,
  13    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14    See the License for the specific language governing permissions and
  15    limitations under the License.
  16 ==================================================================================
  17 */
  18
  19
  20 #include "subscription_delete_response.hpp"
  21
  22 /* The xAPP need only worry about the get_fields from a response, since it does
  23 not generate a response. Generating response however is included to support testing.
  24 */
  25
  26
  27 // Primarly for generation
  28 subscription_delete_response::subscription_delete_response(void){
  29
  30   e2ap_pdu_obj = 0;
  31   e2ap_pdu_obj = (E2N_E2AP_PDU_t *)calloc(1, sizeof(E2N_E2AP_PDU_t));
  32   assert(e2ap_pdu_obj != 0);
  33
  34   successMsg = 0;
  35   successMsg = (E2N_SuccessfulOutcome_t *)calloc(1, sizeof(E2N_SuccessfulOutcome_t));
  36   assert(successMsg != 0);
  37
  38   unsuccessMsg = 0;
  39   unsuccessMsg = (E2N_UnsuccessfulOutcome_t *)calloc(1, sizeof(E2N_UnsuccessfulOutcome_t));
  40   assert(unsuccessMsg != 0);
  41
  42   IE_array = 0;
  43   IE_array = (E2N_RICsubscriptionDeleteResponse_IEs_t *)calloc(NUM_SUBSCRIPTION_DELETE_RESPONSE_IES, sizeof(E2N_RICsubscriptionDeleteResponse_IEs_t));
  44   assert(IE_array != 0);
  45
  46   IE_Failure_array = 0;
  47   IE_Failure_array = (E2N_RICsubscriptionDeleteFailure_IEs_t *)calloc(NUM_SUBSCRIPTION_DELETE_FAILURE_IES, sizeof(E2N_RICsubscriptionDeleteFailure_IEs_t));
  48   assert(IE_Failure_array != 0);
  49
  50
  51
  52 };
  53
  54
  55
  56 // Clear assigned protocolIE list from E2N_RIC indication IE container
  57 subscription_delete_response::~subscription_delete_response(void){
  58
  59   mdclog_write(MDCLOG_DEBUG, "Freeing subscription delete response memory");
  60   E2N_RICsubscriptionDeleteResponse_t * ric_subscription_delete_response = &(successMsg->value.choice.RICsubscriptionDeleteResponse);
  61
  62   for(unsigned int i = 0; i < ric_subscription_delete_response->protocolIEs.list.size ; i++){
  63     ric_subscription_delete_response->protocolIEs.list.array[i] = 0;
  64   }
  65
  66
  67   E2N_RICsubscriptionDeleteFailure_t * ric_subscription_failure = &(unsuccessMsg->value.choice.RICsubscriptionDeleteFailure);
  68   for(unsigned int i = 0; i < ric_subscription_failure->protocolIEs.list.size; i++){
  69     ric_subscription_failure->protocolIEs.list.array[i] = 0;
  70   }
  71
  72   free(IE_array);
  73   free(IE_Failure_array);
  74
  75   ASN_STRUCT_FREE(asn_DEF_E2N_SuccessfulOutcome, successMsg);
  76
  77   ASN_STRUCT_FREE(asn_DEF_E2N_UnsuccessfulOutcome, unsuccessMsg);
  78
  79   e2ap_pdu_obj->choice.successfulOutcome = NULL;
  80   e2ap_pdu_obj->choice.unsuccessfulOutcome = NULL;
  81
  82   ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj);
  83   mdclog_write(MDCLOG_DEBUG, "Freed subscription delete response memory");
  84
  85 };
  86
  87
  88 bool subscription_delete_response::encode_e2ap_subscription_delete_response(unsigned char *buf, size_t *size,  subscription_response_helper &dinput, bool is_success){
  89
  90   bool res;
  91
  92   if(is_success){
  93     res = set_fields(successMsg, dinput);
  94     if (!res){
  95       return false;
  96     }
  97     e2ap_pdu_obj->present =  E2N_E2AP_PDU_PR_successfulOutcome;
  98     e2ap_pdu_obj->choice.successfulOutcome = successMsg;
  99   }
 100   else{
 101     res = set_fields(unsuccessMsg, dinput);
 102     if(! res){
 103       return false;
 104     }
 105     e2ap_pdu_obj->present = E2N_E2AP_PDU_PR_unsuccessfulOutcome;
 106     e2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg;
 107   }
 108
 109
 110   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
 111   if(ret_constr){
 112     error_string.assign(errbuf, errbuf_len);
 113     return false;
 114   }
 115
 116   //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 117
 118   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj, buf, *size);
 119
 120   if(retval.encoded == -1){
 121     error_string.assign(strerror(errno));
 122     error_string = "Error encoding subcription delete response. Reason = " + error_string;
 123     return false;
 124   }
 125   else {
 126     if(*size < retval.encoded){
 127       std::stringstream ss;
 128       ss  <<"Error encoding Subscription Delete Response . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 129       error_string = ss.str();
 130       retval.encoded = -1;
 131       return false;
 132     }
 133   }
 134
 135   *size = retval.encoded;
 136   return true;
 137
 138 }
 139
 140 bool  subscription_delete_response::set_fields(E2N_SuccessfulOutcome_t *success, subscription_response_helper &helper){
 141
 142   if (success == 0){
 143     error_string = "Invalid reference to success message in set fields  subscription delete response";
 144     return false;
 145   }
 146
 147   unsigned int ie_index;
 148
 149   success->procedureCode = E2N_ProcedureCode_id_ricSubscriptionDelete;
 150   success->criticality = E2N_Criticality_reject;
 151   success->value.present = E2N_SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse;
 152
 153   E2N_RICsubscriptionDeleteResponse_t * subscription_delete_response = &(success->value.choice.RICsubscriptionDeleteResponse);
 154   subscription_delete_response->protocolIEs.list.count = 0;
 155
 156   ie_index = 0;
 157   E2N_RICsubscriptionDeleteResponse_IEs_t *ies_ricreq = &IE_array[ie_index];
 158
 159   ies_ricreq->criticality = E2N_Criticality_reject;
 160   ies_ricreq->id = E2N_ProtocolIE_ID_id_RICrequestID;
 161   ies_ricreq->value.present = E2N_RICsubscriptionDeleteResponse_IEs__value_PR_RICrequestID;
 162   E2N_RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 163   ricrequest_ie->ricRequestorID = helper.get_request_id();
 164   ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
 165   ASN_SEQUENCE_ADD(&subscription_delete_response->protocolIEs, ies_ricreq);
 166
 167
 168   ie_index = 1;
 169   E2N_RICsubscriptionDeleteResponse_IEs_t *ies_ranfunc = &IE_array[ie_index];
 170   ies_ranfunc->criticality = E2N_Criticality_reject;
 171   ies_ranfunc->id = E2N_ProtocolIE_ID_id_RANfunctionID;
 172   ies_ranfunc->value.present = E2N_RICsubscriptionDeleteResponse_IEs__value_PR_RANfunctionID;
 173   E2N_RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 174   *ranfunction_ie = helper.get_function_id();
 175   ASN_SEQUENCE_ADD(&subscription_delete_response->protocolIEs, ies_ranfunc);
 176
 177   return true;
 178
 179
 180 }
 181
 182 bool subscription_delete_response:: get_fields(E2N_SuccessfulOutcome_t * success_msg,  subscription_response_helper & dout)
 183 {
 184
 185   if (success_msg == 0){
 186     error_string = "Invalid reference to success message inn get fields subscription delete response";
 187     return false;
 188   }
 189
 190   E2N_RICrequestID_t *requestid;
 191   E2N_RANfunctionID_t * ranfunctionid;
 192
 193   for(int edx = 0; edx < success_msg->value.choice.RICsubscriptionDeleteResponse.protocolIEs.list.count; edx++) {
 194     E2N_RICsubscriptionDeleteResponse_IEs_t *memb_ptr = success_msg->value.choice.RICsubscriptionDeleteResponse.protocolIEs.list.array[edx];
 195
 196     switch(memb_ptr->id)
 197       {
 198       case (E2N_ProtocolIE_ID_id_RICrequestID):
 199         requestid = &memb_ptr->value.choice.RICrequestID;
 200         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 201         break;
 202
 203       case (E2N_ProtocolIE_ID_id_RANfunctionID):
 204         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 205         dout.set_function_id(*ranfunctionid);
 206         break;
 207       }
 208
 209   }
 210
 211   return true;
 212   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 213 }
 214
 215
 216 bool subscription_delete_response::set_fields(E2N_UnsuccessfulOutcome_t *unsuccess, subscription_response_helper &helper){
 217
 218   if (unsuccess == 0){
 219     error_string = "Invalid reference to unsuccess message in set fields  subscription delete response";
 220     return false;
 221   }
 222
 223   unsigned int ie_index;
 224
 225   unsuccess->procedureCode = E2N_ProcedureCode_id_ricSubscriptionDelete;
 226   unsuccess->criticality = E2N_Criticality_reject;
 227   unsuccess->value.present = E2N_UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure;
 228
 229   E2N_RICsubscriptionDeleteFailure_t * ric_subscription_failure = &(unsuccess->value.choice.RICsubscriptionDeleteFailure);
 230   ric_subscription_failure->protocolIEs.list.count = 0;
 231
 232   ie_index = 0;
 233   E2N_RICsubscriptionDeleteFailure_IEs_t *ies_ricreq = &IE_Failure_array[ie_index];
 234
 235   ies_ricreq->criticality = E2N_Criticality_reject;
 236   ies_ricreq->id = E2N_ProtocolIE_ID_id_RICrequestID;
 237   ies_ricreq->value.present = E2N_RICsubscriptionDeleteFailure_IEs__value_PR_RICrequestID;
 238   E2N_RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 239   ricrequest_ie->ricRequestorID = helper.get_request_id();
 240   ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
 241   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ricreq);
 242
 243   ie_index = 1;
 244   E2N_RICsubscriptionDeleteFailure_IEs_t *ies_ranfunc = &IE_Failure_array[ie_index];
 245   ies_ranfunc->criticality = E2N_Criticality_reject;
 246   ies_ranfunc->id = E2N_ProtocolIE_ID_id_RANfunctionID;
 247   ies_ranfunc->value.present = E2N_RICsubscriptionDeleteFailure_IEs__value_PR_RANfunctionID;
 248   E2N_RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 249   *ranfunction_ie = helper.get_function_id();
 250   ASN_SEQUENCE_ADD(&ric_subscription_failure->protocolIEs, ies_ranfunc);
 251
 252
 253   return true;
 254
 255 }
 256
 257 bool  subscription_delete_response:: get_fields(E2N_UnsuccessfulOutcome_t * unsuccess_msg,  subscription_response_helper & dout)
 258 {
 259
 260   if (unsuccess_msg == 0){
 261     error_string = "Invalid reference to unsuccess message in get fields  subscription delete response";
 262     return false;
 263   }
 264
 265   E2N_RICrequestID_t *requestid;
 266   E2N_RANfunctionID_t * ranfunctionid;
 267
 268   for(int edx = 0; edx < unsuccess_msg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.count; edx++) {
 269     E2N_RICsubscriptionDeleteFailure_IEs_t *memb_ptr = unsuccess_msg->value.choice.RICsubscriptionDeleteFailure.protocolIEs.list.array[edx];
 270
 271     switch(memb_ptr->id)
 272       {
 273       case (E2N_ProtocolIE_ID_id_RICrequestID):
 274         requestid = &memb_ptr->value.choice.RICrequestID;
 275         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 276         break;
 277
 278       case (E2N_ProtocolIE_ID_id_RANfunctionID):
 279         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 280         dout.set_function_id(*ranfunctionid);
 281         break;
 282
 283       }
 284
 285   }
 286
 287   return true;
 288   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 289 }
 290
 291
 292