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         xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
 106
 107         int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) _e2ap_pdu_obj, _errbuf, &_errbuf_len);
 108         if(ret_constr){
 109                 _error_string.assign(_errbuf, _errbuf_len);
 110                 _error_string = "Constraints failed for encoding control response. Reason = " + _error_string;
 111                 return false;
 112         }
 113
 114         asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj, buf, *size);
 115
 116         if(retval.encoded == -1){
 117                 _error_string.assign(strerror(errno));
 118                 return false;
 119         }
 120         else {
 121                 if(*size < retval.encoded){
 122                         std::stringstream ss;
 123                         ss  <<"Error encoding E2AP Control response . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 124                         _error_string = ss.str();
 125                         return false;
 126                 }
 127         }
 128
 129         *size = retval.encoded;
 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           xer_fprint(stdout, &asn_DEF_E2AP_PDU, _e2ap_pdu_obj);
 219
 220           _successMsg = _e2ap_pdu_obj->choice.successfulOutcome;
 221           //write the decoding code.
 222
 223
 224         if (_successMsg == 0){
 225                 _error_string = "Invalid reference for E2AP Control Acknowledge message in get_fields";
 226                 return false;
 227         }
 228
 229
 230         for(int edx = 0; edx < _successMsg->value.choice.RICcontrolAcknowledge.protocolIEs.list.count; edx++) {
 231                 RICcontrolAcknowledge_IEs_t *memb_ptr = _successMsg->value.choice.RICcontrolAcknowledge.protocolIEs.list.array[edx];
 232
 233                 switch(memb_ptr->id)
 234                 {
 235
 236                 case (ProtocolIE_ID_id_RICcallProcessID):
 237                 _cntrlIEs->set_ricCallProcessID(memb_ptr->value.choice.RICcallProcessID.buf, memb_ptr->value.choice.RICcallProcessID.size);
 238                 break;
 239
 240                 case (ProtocolIE_ID_id_RICrequestID):
 241                 _cntrlIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID);
 242                 _cntrlIEs->set_ricInstanceID(memb_ptr->value.choice.RICrequestID.ricInstanceID);
 243                 break;
 244
 245                 case (ProtocolIE_ID_id_RANfunctionID):
 246                 _cntrlIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID);
 247                 break;
 248
 249                 case (ProtocolIE_ID_id_RICcontrolStatus):
 250                         _cntrlIEs->set_ricControlStatus(memb_ptr->value.choice.RICcontrolStatus);
 251                 break;
 252
 253                 case (ProtocolIE_ID_id_RICcontrolOutcome):
 254                 _cntrlIEs->set_ricControlOutcome(memb_ptr->value.choice.RICcontrolOutcome.buf, memb_ptr->value.choice.RICcontrolOutcome.size);
 255                 break;
 256
 257                 }
 258
 259         }
 260
 261         return true;
 262
 263 }
 264
 265