src/E2AP-c/e2ap_control.cc

   1 /*
   2 ==================================================================================
   3
   4         Copyright (c) 2018-2019 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  * ric_control_request.c
  21  *
  22  *  Created on: Jul 11, 2019
  23  *      Author: sjana, Ashwin Sridharan
  24  */
  25
  26 #include <e2ap_control.hpp>
  27
  28 // Set up the initiating message and also allocate protocolIEs in container
  29 // Note : this bypasses requirement to use ASN_SEQUENCE_ADD. We can directly
  30 // assign pointers to the array in ProtocolIE. However, this also leaves us on the
  31 // hook to manually clear the memory
  32
  33 ric_control_request::ric_control_request(void){
  34
  35   e2ap_pdu_obj = 0;
  36   e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t));
  37   assert(e2ap_pdu_obj != 0);
  38
  39   initMsg = 0;
  40   initMsg = (InitiatingMessage_t * )calloc(1, sizeof(InitiatingMessage_t));
  41   assert(initMsg != 0);
  42
  43   IE_array = 0;
  44   IE_array = (RICcontrolRequest_IEs_t *)calloc(NUM_CONTROL_REQUEST_IES, sizeof(RICcontrolRequest_IEs_t));
  45   assert(IE_array != 0);
  46
  47   e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage;
  48   e2ap_pdu_obj->choice.initiatingMessage = initMsg;
  49
  50   RICcontrolRequest_t * ric_control_request = &(initMsg->value.choice.RICcontrolRequest);
  51   for(int i = 0; i < NUM_CONTROL_REQUEST_IES; i++){
  52     ASN_SEQUENCE_ADD(&(ric_control_request->protocolIEs), &(IE_array[i]));
  53   }
  54
  55 };
  56
  57
  58 // Clear assigned protocolIE list from RIC control_request IE container
  59 ric_control_request::~ric_control_request(void){
  60
  61   mdclog_write(MDCLOG_INFO, "Freeing E2AP Control Request object memory");
  62
  63   RICcontrolRequest_t *ricControl_Request  = &(initMsg->value.choice.RICcontrolRequest);
  64   for(int i = 0; i < ricControl_Request->protocolIEs.list.size; i++){
  65     ricControl_Request->protocolIEs.list.array[i] = 0;
  66   }
  67
  68   if (ricControl_Request->protocolIEs.list.size > 0){
  69     free(ricControl_Request->protocolIEs.list.array);
  70     ricControl_Request->protocolIEs.list.size = 0;
  71     ricControl_Request->protocolIEs.list.count = 0;
  72   }
  73
  74   free(IE_array);
  75   free(initMsg);
  76   e2ap_pdu_obj->choice.initiatingMessage = 0;
  77
  78   ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj);
  79   mdclog_write(MDCLOG_INFO, "Freed E2AP Control Request object mempory");
  80
  81 }
  82
  83
  84 bool ric_control_request::encode_e2ap_control_request(unsigned char *buf, size_t *size, ric_control_helper & dinput){
  85
  86   initMsg->procedureCode = ProcedureCode_id_ricControl;
  87   initMsg->criticality = Criticality_ignore;
  88   initMsg->value.present = InitiatingMessage__value_PR_RICcontrolRequest;
  89
  90   bool res;
  91
  92   res = set_fields(initMsg, dinput);
  93   if (!res){
  94     return false;
  95   }
  96
  97   int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
  98   if(ret_constr){
  99     error_string.assign(errbuf, errbuf_len);
 100     error_string = "Constraints failed for encoding control . Reason = " + error_string;
 101     return false;
 102   }
 103
 104   //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 105
 106   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size);
 107
 108   if(retval.encoded == -1){
 109     error_string.assign(strerror(errno));
 110     return false;
 111   }
 112   else {
 113     if(*size < retval.encoded){
 114       std::stringstream ss;
 115       ss  <<"Error encoding event trigger definition. Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 116       error_string = ss.str();
 117       return false;
 118     }
 119   }
 120
 121   *size = retval.encoded;
 122   return true;
 123
 124 }
 125
 126 bool ric_control_request::set_fields(InitiatingMessage_t *initMsg, ric_control_helper &dinput){
 127   unsigned int ie_index;
 128
 129   if (initMsg == 0){
 130     error_string = "Invalid reference for E2AP Control_Request message in set_fields";
 131     return false;
 132   }
 133
 134   // for(i = 0; i < NUM_CONTROL_REQUEST_IES;i++){
 135   //   memset(&(IE_array[i]), 0, sizeof(RICcontrolRequest_IEs_t));
 136   // }
 137
 138
 139   ie_index = 0;
 140   RICcontrolRequest_IEs_t *ies_ricreq = &IE_array[ie_index];
 141   ies_ricreq->criticality = Criticality_reject;
 142   ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
 143   ies_ricreq->value.present = RICcontrolRequest_IEs__value_PR_RICrequestID;
 144   RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 145   ricrequest_ie->ricRequestorID = dinput.req_id;
 146   ricrequest_ie->ricRequestSequenceNumber = dinput.req_seq_no;
 147
 148   ie_index = 1;
 149   RICcontrolRequest_IEs_t *ies_ranfunc = &IE_array[ie_index];
 150   ies_ranfunc->criticality = Criticality_reject;
 151   ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 152   ies_ranfunc->value.present = RICcontrolRequest_IEs__value_PR_RANfunctionID;
 153   RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 154   *ranfunction_ie = dinput.func_id;
 155
 156
 157   // ie_index = 2;
 158   // RICcontrolRequest_IEs_t *ies_riccallprocessid = &IE_array[ie_index];
 159   // ies_riccallprocessid->criticality = Criticality_reject;
 160   // ies_riccallprocessid->id = ProtocolIE_ID_id_RICcallProcessID;
 161   // ies_riccallprocessid->value.present = RICcontrolRequest_IEs__value_PR_RICcallProcessID;
 162   // RICcallProcessID_t *riccallprocessid_ie = &ies_riccallprocessid->value.choice.RICcallProcessID;
 163   // riccallprocessid_ie->buf = dinput.call_process_id;
 164   // riccallprocessid_ie->size = dinput.call_process_id_size;
 165
 166   ie_index = 2;
 167   RICcontrolRequest_IEs_t *ies_richead = &IE_array[ie_index];
 168   ies_richead->criticality = Criticality_reject;
 169   ies_richead->id = ProtocolIE_ID_id_RICcontrolHeader;
 170   ies_richead->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolHeader;
 171   RICcontrolHeader_t *richeader_ie = &ies_richead->value.choice.RICcontrolHeader;
 172   richeader_ie->buf = dinput.control_header;
 173   richeader_ie->size = dinput.control_header_size;
 174
 175   ie_index = 3;
 176   RICcontrolRequest_IEs_t *ies_indmsg = &IE_array[ie_index];
 177   ies_indmsg->criticality = Criticality_reject;
 178   ies_indmsg->id = ProtocolIE_ID_id_RICcontrolMessage;
 179   ies_indmsg->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolMessage;
 180   RICcontrolMessage_t *ricmsg_ie = &ies_indmsg->value.choice.RICcontrolMessage;
 181   ricmsg_ie->buf = dinput.control_msg;
 182   ricmsg_ie->size = dinput.control_msg_size;
 183
 184   ie_index = 4;
 185   RICcontrolRequest_IEs_t *ies_indtyp = &IE_array[ie_index];
 186   ies_indtyp->criticality = Criticality_reject;
 187   ies_indtyp->id = ProtocolIE_ID_id_RICcontrolAckRequest;
 188   ies_indtyp->value.present = RICcontrolRequest_IEs__value_PR_RICcontrolAckRequest;
 189   RICcontrolAckRequest_t *ricackreq_ie = &ies_indtyp->value.choice.RICcontrolAckRequest;
 190   *ricackreq_ie = dinput.control_ack;
 191
 192   return true;
 193
 194 };
 195
 196
 197
 198
 199 bool ric_control_request:: get_fields(InitiatingMessage_t * init_msg,  ric_control_helper &dout)
 200 {
 201   if (init_msg == 0){
 202     error_string = "Invalid reference for E2AP Control_Request message in get_fields";
 203     return false;
 204   }
 205
 206
 207   for(int edx = 0; edx < init_msg->value.choice.RICcontrolRequest.protocolIEs.list.count; edx++) {
 208     RICcontrolRequest_IEs_t *memb_ptr = init_msg->value.choice.RICcontrolRequest.protocolIEs.list.array[edx];
 209
 210     switch(memb_ptr->id)
 211       {
 212       case (ProtocolIE_ID_id_RICcontrolHeader):
 213         dout.control_header = memb_ptr->value.choice.RICcontrolHeader.buf;
 214         dout.control_header_size = memb_ptr->value.choice.RICcontrolHeader.size;
 215         break;
 216
 217       case (ProtocolIE_ID_id_RICcontrolMessage):
 218         dout.control_msg =  memb_ptr->value.choice.RICcontrolMessage.buf;
 219         dout.control_msg_size = memb_ptr->value.choice.RICcontrolMessage.size;
 220         break;
 221
 222       case (ProtocolIE_ID_id_RICcallProcessID):
 223         dout.call_process_id =  memb_ptr->value.choice.RICcallProcessID.buf;
 224         dout.call_process_id_size = memb_ptr->value.choice.RICcallProcessID.size;
 225         break;
 226
 227       case (ProtocolIE_ID_id_RICrequestID):
 228         dout.req_id = memb_ptr->value.choice.RICrequestID.ricRequestorID;
 229         dout.req_seq_no = memb_ptr->value.choice.RICrequestID.ricRequestSequenceNumber;
 230         break;
 231
 232       case (ProtocolIE_ID_id_RANfunctionID):
 233         dout.func_id = memb_ptr->value.choice.RANfunctionID;
 234         break;
 235
 236       case (ProtocolIE_ID_id_RICcontrolAckRequest):
 237         dout.control_ack = memb_ptr->value.choice.RICcontrolAckRequest;
 238         break;
 239
 240
 241       default:
 242         break;
 243       }
 244
 245   }
 246
 247   return true;
 248
 249 }
 250
 251 InitiatingMessage_t * ric_control_request::get_message(void)  {
 252     return initMsg;
 253 }