src/xapp-asn/e2ap/e2ap_control_ack.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  * e2ap_control_ack.cc
  21  *
  22  *      Author: SJana, Ashwin Sridharan
  23  */
  24
  25 #include "e2ap_control_ack.hpp"
  26
  27
  28 E2APControlAcknowledge::E2APControlAcknowledge(ControlAcknowledgeIEs &cntrlObj){
  29         _cntrlIEs = std::make_unique<ControlAcknowledgeIEs>();
  30         *_cntrlIEs = cntrlObj;
  31
  32         _e2ap_pdu_obj = 0;
  33         _e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t));
  34         assert(_e2ap_pdu_obj != 0);
  35
  36         _successMsg = 0;
  37         _successMsg = (SuccessfulOutcome_t * )calloc(1, sizeof(SuccessfulOutcome_t));
  38         assert(_successMsg != 0);
  39
  40         _successMsg->procedureCode = ProcedureCode_id_RICcontrol;
  41         _successMsg->criticality = Criticality_reject;
  42         _successMsg->value.present = SuccessfulOutcome__value_PR_RICcontrolAcknowledge;
  43
  44
  45         IE_array = 0;
  46         IE_array = (RICcontrolAcknowledge_IEs_t *)calloc(RIC_CONTROL_ACK_IES_COUNT, sizeof(RICcontrolAcknowledge_IEs_t));
  47         assert(IE_array != 0);
  48
  49         RICcontrolAcknowledge_t * ric_acknowledge = &(_successMsg->value.choice.RICcontrolAcknowledge);
  50         for(int i = 0; i < RIC_CONTROL_ACK_IES_COUNT; i++){
  51                 ASN_SEQUENCE_ADD(&(ric_acknowledge->protocolIEs), &(IE_array[i]));
  52         }
  53
  54 };
  55
  56 E2APControlAcknowledge::E2APControlAcknowledge(unsigned char *buf, size_t *size){
  57           _e2ap_pdu_obj = 0;
  58           _successMsg = 0;
  59           IE_array = 0;
  60
  61           _cntrlIEs = std::make_unique<ControlAcknowledgeIEs>();
  62            bool status =  this->decode(buf, size);
  63            if(!status)
  64                    throw "E2AP Control Acknowledge Decode Failed: "+this->get_error();
  65 }
  66
  67
  68 // Clear assigned protocolIE list from RIC control_request IE container
  69 E2APControlAcknowledge::~E2APControlAcknowledge(void){
  70
  71         mdclog_write(MDCLOG_DEBUG, "Freeing E2AP Control Response object memory");
  72
  73         RICcontrolAcknowledge_t * ric_acknowledge = &(_successMsg->value.choice.RICcontrolAcknowledge);
  74         for(int i  = 0; i < ric_acknowledge->protocolIEs.list.size; i++){
  75                 ric_acknowledge->protocolIEs.list.array[i] = 0;
  76         }
  77         if (ric_acknowledge->protocolIEs.list.size > 0){
  78                 free(ric_acknowledge->protocolIEs.list.array);
  79                 ric_acknowledge->protocolIEs.list.array = 0;
  80                 ric_acknowledge->protocolIEs.list.count = 0;
  81         }
  82
  83
  84         free(IE_array);
  85         free(_successMsg);
  86
  87         _e2ap_pdu_obj->choice.successfulOutcome = 0;
  88         _e2ap_pdu_obj->present = E2AP_PDU_PR_successfulOutcome;
  89
  90         ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
  91         mdclog_write(MDCLOG_DEBUG, "Freed E2AP Control Response object memory");
  92 }
  93
  94
  95 bool E2APControlAcknowledge::encode(unsigned char *buf, size_t *size){
  96
  97         bool res;
  98         res = setfields(_successMsg);
  99         if (!res){
 100                 return false;
 101         }
 102         _e2ap_pdu_obj->choice.successfulOutcome = _successMsg;
 103         _e2ap_pdu_obj->present = E2AP_PDU_PR_successfulOutcome ;
 104
 105         int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len);
 106         if(ret_constr){
 107                 _error_string.assign(_errbuf, _errbuf_len);
 108                 _error_string = "Constraints failed for encoding control response. Reason = " + _error_string;
 109                 return false;
 110         }
 111
 112         asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size);
 113
 114         if(retval.encoded == -1){
 115                 _error_string.assign(strerror(errno));
 116                 return false;
 117         }
 118         else {
 119                 if(*size < retval.encoded){
 120                         std::stringstream ss;
 121                         ss  <<"Error encoding E2AP Control response . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 122                         _error_string = ss.str();
 123                         return false;
 124                 }
 125         }
 126
 127         *size = retval.encoded;
 128         xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
 129
 130         return true;
 131
 132 }
 133
 134 bool E2APControlAcknowledge::setfields(SuccessfulOutcome_t *successMsg){
 135         unsigned int ie_index;
 136
 137         if (successMsg == 0){
 138                 _error_string = "Invalid reference for E2AP Control Acknowledge in set_fields";
 139                 return false;
 140         }
 141
 142         RICcontrolAcknowledge_t * ric_acknowledge = &(successMsg->value.choice.RICcontrolAcknowledge);
 143         ric_acknowledge->protocolIEs.list.count = 0;
 144
 145         ie_index = 0;
 146         RICcontrolAcknowledge_IEs_t *ies_ricreq = &IE_array[ie_index];
 147         ies_ricreq->criticality = Criticality_reject;
 148         ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
 149         ies_ricreq->value.present = RICcontrolAcknowledge_IEs__value_PR_RICrequestID;
 150
 151         RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 152         ricrequest_ie->ricRequestorID = this->getIEs().get_ricRequestorID();
 153         ricrequest_ie->ricInstanceID = this->getIEs().get_ricInstanceID();
 154         ASN_SEQUENCE_ADD(&(ric_acknowledge->protocolIEs), ies_ricreq);
 155
 156         ie_index = 1;
 157         RICcontrolAcknowledge_IEs_t *ies_ranfunc = &IE_array[ie_index];
 158         ies_ranfunc->criticality = Criticality_reject;
 159         ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 160         ies_ranfunc->value.present = RICcontrolAcknowledge_IEs__value_PR_RANfunctionID;
 161
 162         RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 163         *ranfunction_ie = this->getIEs().get_ranFunctionID();
 164         ASN_SEQUENCE_ADD(&(ric_acknowledge->protocolIEs), ies_ranfunc);
 165
 166         ie_index = 2;
 167         RICcontrolAcknowledge_IEs_t *ies_cntrlstatus = &IE_array[ie_index];
 168         ies_cntrlstatus->criticality = Criticality_reject;
 169         ies_cntrlstatus->id = ProtocolIE_ID_id_RICcontrolStatus;
 170         ies_cntrlstatus->value.present = RICcontrolAcknowledge_IEs__value_PR_RICcontrolStatus;
 171         RICcontrolStatus_t *ricstatus_ie = &ies_cntrlstatus->value.choice.RICcontrolStatus;
 172         *ricstatus_ie = this->getIEs().get_ricControlStatus();
 173
 174         ASN_SEQUENCE_ADD(&(ric_acknowledge->protocolIEs), ies_cntrlstatus);
 175
 176     if(this->getIEs().get_is_ricCallProcessId()){
 177         ie_index++;
 178         RICcontrolAcknowledge_IEs_t *ies_riccallprocessid = &IE_array[ie_index];
 179         ies_riccallprocessid->criticality = Criticality_reject;
 180         ies_riccallprocessid->id = ProtocolIE_ID_id_RICcallProcessID;
 181         ies_riccallprocessid->value.present = RICcontrolAcknowledge_IEs__value_PR_RICcallProcessID;
 182         RICcallProcessID_t *riccallprocessid_ie = &ies_riccallprocessid->value.choice.RICcallProcessID;
 183         riccallprocessid_ie->buf = (uint8_t*)this->getIEs().get_ricCallProcessId();
 184         riccallprocessid_ie->size = this->getIEs().get_ricCallProcessId_size();
 185         ASN_SEQUENCE_ADD(&(ric_acknowledge->protocolIEs), ies_riccallprocessid);
 186
 187     }
 188     if(this->getIEs().get_is_ricControlOutcome()){
 189                 ie_index++;
 190                 RICcontrolAcknowledge_IEs_t *ies_ricControlOutcome = &IE_array[ie_index];
 191                 ies_ricControlOutcome->criticality = Criticality_reject;
 192                 ies_ricControlOutcome->id = ProtocolIE_ID_id_RICcallProcessID;
 193                 ies_ricControlOutcome->value.present = RICcontrolAcknowledge_IEs__value_PR_RICcontrolOutcome;
 194                 RICcontrolOutcome_t *ricControlOutcome_ie = &ies_ricControlOutcome->value.choice.RICcallProcessID;
 195                 ricControlOutcome_ie->buf = (uint8_t*)this->getIEs().get_ricControlOutcome();
 196                 ricControlOutcome_ie->size = this->getIEs().get_ricControlOutcome_size();
 197                 ASN_SEQUENCE_ADD(&(ric_acknowledge->protocolIEs), ies_ricControlOutcome);
 198
 199         }
 200
 201
 202
 203         return true;
 204
 205 };
 206
 207
 208 bool E2APControlAcknowledge::decode(unsigned char *buf, size_t *size)
 209 {
 210         asn_dec_rval_t dec_res  = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&(_e2ap_pdu_obj), buf, *size);
 211         if(dec_res.code != RC_OK){
 212                                  mdclog_write(MDCLOG_ERR, "Failed to decode: %s","RIC Control Ack Message");
 213                                  return false;
 214         } else {
 215                                  mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Control Ack Message");
 216         }
 217
 218           _successMsg = _e2ap_pdu_obj->choice.successfulOutcome;
 219           //write the decoding code.
 220
 221
 222         if (_successMsg == 0){
 223                 _error_string = "Invalid reference for E2AP Control Acknowledge message in get_fields";
 224                 return false;
 225         }
 226
 227
 228         for(int edx = 0; edx < _successMsg->value.choice.RICcontrolAcknowledge.protocolIEs.list.count; edx++) {
 229                 RICcontrolAcknowledge_IEs_t *memb_ptr = _successMsg->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[edx];
 230
 231                 switch(memb_ptr->id)
 232                 {
 233
 234                 case (ProtocolIE_ID_id_RICcallProcessID):
 235                 _cntrlIEs->set_ricCallProcessID(memb_ptr->value.choice.RICcallProcessID.buf, memb_ptr->value.choice.RICcallProcessID.size);
 236                 break;
 237
 238                 case (ProtocolIE_ID_id_RICrequestID):
 239                 _cntrlIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID);
 240                 _cntrlIEs->set_ricInstanceID(memb_ptr->value.choice.RICrequestID.ricInstanceID);
 241                 break;
 242
 243                 case (ProtocolIE_ID_id_RANfunctionID):
 244                 _cntrlIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID);
 245                 break;
 246
 247                 case (ProtocolIE_ID_id_RICcontrolStatus):
 248                         _cntrlIEs->set_ricControlStatus(memb_ptr->value.choice.RICcontrolStatus);
 249                 break;
 250
 251                 case (ProtocolIE_ID_id_RICcontrolOutcome):
 252                 _cntrlIEs->set_ricControlOutcome(memb_ptr->value.choice.RICcontrolOutcome.buf, memb_ptr->value.choice.RICcontrolOutcome.size);
 253                 break;
 254
 255                 }
 256
 257         }
 258 //        xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
 259
 260         return true;
 261
 262 }
 263
 264