src/E2AP-c/e2ap_indication.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_indication.c
  21  *
  22  *  Created on: Jul 11, 2019
  23  *      Author: sjana, Ashwin Sridharan
  24  */
  25
  26 #include <e2ap_indication.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_indication::ric_indication(void){
  34
  35   e2ap_pdu_obj = 0;
  36   e2ap_pdu_obj = (E2N_E2AP_PDU_t * )calloc(1, sizeof(E2N_E2AP_PDU_t));
  37   assert(e2ap_pdu_obj != 0);
  38
  39   initMsg = 0;
  40   initMsg = (E2N_InitiatingMessage_t * )calloc(1, sizeof(E2N_InitiatingMessage_t));
  41   assert(initMsg != 0);
  42
  43   IE_array = 0;
  44   IE_array = (E2N_RICindication_IEs_t *)calloc(NUM_INDICATION_IES, sizeof(E2N_RICindication_IEs_t));
  45   assert(IE_array != 0);
  46
  47   e2ap_pdu_obj->present = E2N_E2AP_PDU_PR_initiatingMessage;
  48   e2ap_pdu_obj->choice.initiatingMessage = initMsg;
  49
  50
  51
  52
  53 };
  54
  55
  56
  57 // Clear assigned protocolIE list from RIC indication IE container
  58 ric_indication::~ric_indication(void){
  59
  60   mdclog_write(MDCLOG_DEBUG, "Freeing E2AP Indication object memory");
  61   E2N_RICindication_t *ricIndication  = &(initMsg->value.choice.RICindication);
  62   for(int i = 0; i < ricIndication->protocolIEs.list.size; i++){
  63     ricIndication->protocolIEs.list.array[i] = 0;
  64   }
  65   if (ricIndication->protocolIEs.list.size > 0){
  66     free(ricIndication->protocolIEs.list.array);
  67     ricIndication->protocolIEs.list.array = 0;
  68     ricIndication->protocolIEs.list.count = 0;
  69     ricIndication->protocolIEs.list.size = 0;
  70   }
  71
  72   free(IE_array);
  73   ASN_STRUCT_FREE(asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj);
  74   mdclog_write(MDCLOG_DEBUG, "Freed E2AP Indication object mempory");
  75 }
  76
  77
  78 bool ric_indication::encode_e2ap_indication(unsigned char *buf, size_t *size, ric_indication_helper & dinput){
  79
  80   initMsg->procedureCode = E2N_ProcedureCode_id_ricIndication;
  81   initMsg->criticality = E2N_Criticality_ignore;
  82   initMsg->value.present = E2N_InitiatingMessage__value_PR_RICindication;
  83
  84   bool res;
  85   asn_enc_rval_t retval;
  86
  87   res = set_fields(initMsg, dinput);
  88   if (!res){
  89     return false;
  90   }
  91
  92   int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj, errbuf, &errbuf_len);
  93   if(ret_constr){
  94     error_string.assign(&errbuf[0], errbuf_len);
  95     error_string = "Error encoding E2AP Indication message. Reason = " + error_string;
  96     return false;
  97   }
  98
  99   // std::cout <<"Constraint check ok ...." << std::endl;
 100   // xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 101
 102   retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2AP_PDU, e2ap_pdu_obj, buf, *size);
 103   if(retval.encoded == -1){
 104     error_string.assign(strerror(errno));
 105     return false;
 106   }
 107
 108   else {
 109     if(*size < retval.encoded){
 110       std::stringstream ss;
 111       ss  <<"Error encoding E2AP Indication . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 112       error_string = ss.str();
 113       return false;
 114     }
 115   }
 116
 117   *size = retval.encoded;
 118   return true;
 119
 120 }
 121
 122 bool ric_indication::set_fields(E2N_InitiatingMessage_t *initMsg, ric_indication_helper &dinput){
 123   unsigned int ie_index;
 124
 125   if (initMsg == 0){
 126     error_string = "Invalid reference for E2AP Indication message in set_fields";
 127     return false;
 128   }
 129
 130
 131   E2N_RICindication_t * ric_indication = &(initMsg->value.choice.RICindication);
 132   ric_indication->protocolIEs.list.count = 0;
 133
 134   ie_index = 0;
 135
 136   E2N_RICindication_IEs_t *ies_ricreq = &IE_array[ie_index];
 137   ies_ricreq->criticality = E2N_Criticality_reject;
 138   ies_ricreq->id = E2N_ProtocolIE_ID_id_RICrequestID;
 139   ies_ricreq->value.present = E2N_RICindication_IEs__value_PR_RICrequestID;
 140   E2N_RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 141   ricrequest_ie->ricRequestorID = dinput.req_id;
 142   ricrequest_ie->ricRequestSequenceNumber = dinput.req_seq_no;
 143   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 144
 145   ie_index = 1;
 146   E2N_RICindication_IEs_t *ies_ranfunc = &IE_array[ie_index];
 147   ies_ranfunc->criticality = E2N_Criticality_reject;
 148   ies_ranfunc->id = E2N_ProtocolIE_ID_id_RANfunctionID;
 149   ies_ranfunc->value.present = E2N_RICindication_IEs__value_PR_RANfunctionID;
 150   E2N_RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 151   *ranfunction_ie = dinput.func_id;
 152   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 153
 154   ie_index = 2;
 155   E2N_RICindication_IEs_t *ies_actid = &IE_array[ie_index];
 156   ies_actid->criticality = E2N_Criticality_reject;
 157   ies_actid->id = E2N_ProtocolIE_ID_id_RICactionID;
 158   ies_actid->value.present = E2N_RICindication_IEs__value_PR_RICactionID;
 159   E2N_RICactionID_t *ricaction_ie = &ies_actid->value.choice.RICactionID;
 160   *ricaction_ie = dinput.action_id;
 161   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 162
 163   ie_index = 3;
 164   E2N_RICindication_IEs_t *ies_ricsn = &IE_array[ie_index];
 165   ies_ricsn->criticality = E2N_Criticality_reject;
 166   ies_ricsn->id = E2N_ProtocolIE_ID_id_RICindicationSN;
 167   ies_ricsn->value.present = E2N_RICindication_IEs__value_PR_RICindicationSN;
 168   E2N_RICindicationSN_t *ricsn_ie = &ies_ricsn->value.choice.RICindicationSN;
 169   *ricsn_ie = dinput.indication_sn;
 170   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 171
 172
 173   ie_index = 4;
 174   E2N_RICindication_IEs_t *ies_indtyp = &IE_array[ie_index];
 175   ies_indtyp->criticality = E2N_Criticality_reject;
 176   ies_indtyp->id = E2N_ProtocolIE_ID_id_RICindicationType;
 177   ies_indtyp->value.present = E2N_RICindication_IEs__value_PR_RICindicationType;
 178   E2N_RICindicationType_t *rictype_ie = &ies_indtyp->value.choice.RICindicationType;
 179   *rictype_ie = dinput.indication_type;
 180   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 181
 182   ie_index = 5;
 183   E2N_RICindication_IEs_t *ies_richead = &IE_array[ie_index];
 184   ies_richead->criticality = E2N_Criticality_reject;
 185   ies_richead->id = E2N_ProtocolIE_ID_id_RICindicationHeader;
 186   ies_richead->value.present = E2N_RICindication_IEs__value_PR_RICindicationHeader;
 187   E2N_RICindicationHeader_t *richeader_ie = &ies_richead->value.choice.RICindicationHeader;
 188   richeader_ie->buf = dinput.indication_header;
 189   richeader_ie->size = dinput.indication_header_size;
 190   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 191
 192   ie_index = 6;
 193   E2N_RICindication_IEs_t *ies_indmsg = &IE_array[ie_index];
 194   ies_indmsg->criticality = E2N_Criticality_reject;
 195   ies_indmsg->id = E2N_ProtocolIE_ID_id_RICindicationMessage;
 196   ies_indmsg->value.present = E2N_RICindication_IEs__value_PR_RICindicationMessage;
 197   E2N_RICindicationMessage_t *ricmsg_ie = &ies_indmsg->value.choice.RICindicationMessage;
 198   ricmsg_ie->buf = dinput.indication_msg;
 199   ricmsg_ie->size = dinput.indication_msg_size;
 200   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 201
 202   return true;
 203
 204 };
 205
 206
 207
 208
 209 bool ric_indication:: get_fields(E2N_InitiatingMessage_t * init_msg,  ric_indication_helper &dout)
 210 {
 211   if (init_msg == 0){
 212     error_string = "Invalid reference for E2AP Indication message in get_fields";
 213     return false;
 214   }
 215
 216
 217   for(int edx = 0; edx < init_msg->value.choice.RICindication.protocolIEs.list.count; edx++) {
 218     E2N_RICindication_IEs_t *memb_ptr = init_msg->value.choice.RICindication.protocolIEs.list.array[edx];
 219
 220     switch(memb_ptr->id)
 221       {
 222       case (E2N_ProtocolIE_ID_id_RICindicationHeader):
 223         dout.indication_header = memb_ptr->value.choice.RICindicationHeader.buf;
 224         dout.indication_header_size = memb_ptr->value.choice.RICindicationHeader.size;
 225         break;
 226
 227       case (E2N_ProtocolIE_ID_id_RICindicationMessage):
 228         dout.indication_msg =  memb_ptr->value.choice.RICindicationMessage.buf;
 229         dout.indication_msg_size = memb_ptr->value.choice.RICindicationMessage.size;
 230         break;
 231
 232       case (E2N_ProtocolIE_ID_id_RICrequestID):
 233         dout.req_id = memb_ptr->value.choice.RICrequestID.ricRequestorID;
 234         dout.req_seq_no = memb_ptr->value.choice.RICrequestID.ricRequestSequenceNumber;
 235         break;
 236
 237       case (E2N_ProtocolIE_ID_id_RANfunctionID):
 238         dout.func_id = memb_ptr->value.choice.RANfunctionID;
 239         break;
 240
 241       case (E2N_ProtocolIE_ID_id_RICindicationSN):
 242         dout.indication_sn = memb_ptr->value.choice.RICindicationSN;
 243         break;
 244
 245       case (E2N_ProtocolIE_ID_id_RICindicationType):
 246         dout.indication_type = memb_ptr->value.choice.RICindicationType;
 247         break;
 248
 249       case (E2N_ProtocolIE_ID_id_RICactionID):
 250         dout.action_id = memb_ptr->value.choice.RICactionID;
 251         break;
 252
 253       default:
 254         break;
 255       }
 256
 257   }
 258
 259   return true;
 260
 261 }
 262
 263 E2N_InitiatingMessage_t * ric_indication::get_message(void)  {
 264     return initMsg;
 265 }