src/xapp-asn/e2ap/e2ap_indication.hpp

   1
   2 /*
   3 ==================================================================================
   4
   5         Copyright (c) 2019-2020 AT&T Intellectual Property.
   6
   7    Licensed under the Apache License, Version 2.0 (the "License");
   8    you may not use this file except in compliance with the License.
   9    You may obtain a copy of the License at
  10
  11        http://www.apache.org/licenses/LICENSE-2.0
  12
  13    Unless required by applicable law or agreed to in writing, software
  14    distributed under the License is distributed on an "AS IS" BASIS,
  15    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16    See the License for the specific language governing permissions and
  17    limitations under the License.
  18 ==================================================================================
  19 */
  20
  21 /*
  22  * indication.hpp
  23  *
  24  *  Created on: Sep 18, 2020
  25  *      Author: Shraboni Jana
  26  */
  27 /*-- **************************************************************
  28 --
  29 -- RIC Indication Elementary Procedure
  30 --
  31 -- **************************************************************
  32 -- **************************************************************
  33 --
  34 -- RIC INDICATION
  35 --
  36 -- **************************************************************
  37 RICindication ::= SEQUENCE {
  38         protocolIEs                                     ProtocolIE-Container    {{RICindication-IEs}},
  39         ...
  40 }
  41
  42 RICindication-IEs E2AP-PROTOCOL-IES ::= {
  43         { ID id-RICrequestID                            CRITICALITY reject      TYPE RICrequestID                                       PRESENCE mandatory      }|
  44         { ID id-RANfunctionID                           CRITICALITY reject      TYPE RANfunctionID                                      PRESENCE mandatory      }|
  45         { ID id-RICactionID                                     CRITICALITY reject      TYPE RICactionID                                        PRESENCE mandatory      }|
  46         { ID id-RICindicationSN                         CRITICALITY reject      TYPE RICindicationSN                            PRESENCE optional       }|
  47         { ID id-RICindicationType                       CRITICALITY reject      TYPE RICindicationType                          PRESENCE mandatory      }|
  48         { ID id-RICindicationHeader                     CRITICALITY reject      TYPE RICindicationHeader                        PRESENCE mandatory      }|
  49         { ID id-RICindicationMessage            CRITICALITY reject      TYPE RICindicationMessage                       PRESENCE mandatory      }|
  50         { ID id-RICcallProcessID                        CRITICALITY reject      TYPE RICcallProcessID                           PRESENCE optional       },
  51         ...
  52 }*/
  53
  54
  55 #ifndef SRC_XAPP_ASN_E2AP_E2AP_INDICATION_HPP_
  56 #define SRC_XAPP_ASN_E2AP_E2AP_INDICATION_HPP_
  57
  58 #include <string>
  59 #include <E2AP-PDU.h>
  60 #include <InitiatingMessage.h>
  61 #include <RICindication.h>
  62 #include <ProtocolIE-Field.h>
  63 #include <iostream>
  64 #include <errno.h>
  65 #include <mdclog/mdclog.h>
  66 #include <sstream>
  67 #include <memory>
  68
  69 #define IE_SIZE ((int)128)
  70
  71 template <typename E2SMIndicationHeader, typename E2SMIndicationMessage>
  72 class E2APIndication{
  73
  74 public:
  75         E2APIndication();
  76         E2APIndication(unsigned char *, size_t *, bool&);
  77         ~E2APIndication(void);
  78         class IndicationIEs{
  79                 private:
  80                         long int ricRequestorID, ranFunctionID, ricActionID, ricIndicationSN, ricIndicationType;
  81                         size_t ricIndicationHeader_size = IE_SIZE;
  82                         unsigned char ricIndicationHeader[IE_SIZE];
  83
  84                         size_t ricIndicationMessage_size = IE_SIZE;
  85                         unsigned char ricIndicationMessage[IE_SIZE];
  86
  87                         unsigned char ricCallProcessId[IE_SIZE];
  88                         size_t ricCallProcessId_size = IE_SIZE;
  89
  90                 public:
  91                         IndicationIEs(void) : ricRequestorID(0), ranFunctionID(0), ricActionID(0),ricIndicationSN(0), ricIndicationType(0){};
  92                         void* get_ricIndicationMessage(){return this->ricIndicationMessage; };
  93                         void* get_ricIndicationHeader(){return this->ricIndicationHeader; };
  94                         void* get_ricCallProcessId(){return this->ricCallProcessId;};
  95
  96                         size_t get_ricIndicationMessageSize(){return this->ricIndicationMessage_size; };
  97                         size_t get_ricIndicationHeaderSize(){return this->ricIndicationHeader_size; };
  98                         size_t get_ricCallProcessIdSize(){return this->ricCallProcessId_size;};
  99
 100                         long int get_ricRequestorID(){return this->ricRequestorID;};
 101                         long int get_ranFunctionID(){return this->ranFunctionID;};
 102                         long int get_ricActionID(){return this->ricActionID;};
 103                         long int get_ricIndicationSN(){return this->ricIndicationSN;};
 104
 105                         IndicationIEs& set_ricIndicationHeader(unsigned char* header, size_t header_size){
 106                                 memcpy(ricIndicationHeader,header,header_size); ricIndicationHeader_size = header_size; return *this;
 107                         }
 108                         IndicationIEs& set_ricIndicationMessage(unsigned char* message, size_t message_size){
 109                                 memcpy(ricIndicationHeader,message,message_size); ricIndicationMessage_size = message_size; return *this;}
 110
 111                         IndicationIEs& set_ricCallProcessID(unsigned char* callproc, size_t callproc_size){
 112                                 memcpy(ricCallProcessId, callproc, callproc_size); ricCallProcessId_size = callproc_size;
 113                                 return *this;
 114                         }
 115
 116                         IndicationIEs& set_ricRequestorID(long int reqID){this->ricRequestorID = reqID; return *this;}
 117                         IndicationIEs& set_ranFunctionID(long int funcID){this->ranFunctionID = funcID; return *this;}
 118                         IndicationIEs& set_ricActionID(long int actID){ this->ricActionID = actID; return *this;}
 119                         IndicationIEs& set_ricIndicationType(long int typ){ this->ricIndicationType = typ; return *this;}
 120                         IndicationIEs& set_ricIndicationSN(long int sn){ this->ricIndicationSN = sn; return *this;}
 121
 122
 123         };
 124
 125   IndicationIEs getIndicationIEs(){ return *_indicationIEs.get(); }
 126
 127   std::string get_error(void) const {return _error_string ; };
 128   bool encode(unsigned char *buf, size_t *size);
 129   bool decode(unsigned char *buf, size_t *size);
 130
 131 private:
 132
 133   E2AP_PDU_t * e2ap_pdu_obj;
 134   InitiatingMessage_t *initMsg;
 135   RICindication_IEs_t *IE_array;
 136   std::unique_ptr<IndicationIEs> _indicationIEs;
 137
 138   unsigned int ricIndicationIEs_Count;
 139
 140   std::string _error_string;
 141   char _errbuf[128];
 142   size_t _errbuf_len = 128;
 143
 144   bool setfields( InitiatingMessage_t *);
 145 };
 146
 147 template<typename T1, typename T2>
 148 E2APIndication<T1,T2>::E2APIndication(){
 149
 150   ricIndicationIEs_Count = 8;
 151
 152   e2ap_pdu_obj = 0;
 153   e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t));
 154   assert(e2ap_pdu_obj != 0);
 155
 156   initMsg = 0;
 157   initMsg = (InitiatingMessage_t * )calloc(1, sizeof(InitiatingMessage_t));
 158   assert(initMsg != 0);
 159
 160   IE_array = 0;
 161   IE_array = (RICindication_IEs_t *)calloc(ricIndicationIEs_Count, sizeof(RICindication_IEs_t));
 162   assert(IE_array != 0);
 163
 164   e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage;
 165   e2ap_pdu_obj->choice.initiatingMessage = initMsg;
 166
 167   _indicationIEs = std::make_unique<IndicationIEs>();
 168
 169 };
 170 template<typename T1, typename T2>
 171 E2APIndication<T1,T2>::E2APIndication(unsigned char *buf, size_t *size, bool &status){
 172           e2ap_pdu_obj = 0;
 173           initMsg = 0;
 174           IE_array = 0;
 175
 176           _indicationIEs = std::make_unique<IndicationIEs>();
 177            status =  this->decode(buf, size);
 178
 179 }
 180
 181
 182 // Clear assigned protocolIE list from RIC indication IE container
 183 template<typename T1, typename T2>
 184 E2APIndication<T1,T2>::~E2APIndication(void){
 185
 186   mdclog_write(MDCLOG_DEBUG, "Freeing E2AP Indication object memory");
 187   RICindication_t *ricIndication  = &(initMsg->value.choice.RICindication);
 188   for(int i = 0; i < ricIndication->protocolIEs.list.size; i++){
 189     ricIndication->protocolIEs.list.array[i] = 0;
 190   }
 191   if (ricIndication->protocolIEs.list.size > 0){
 192     free(ricIndication->protocolIEs.list.array);
 193     ricIndication->protocolIEs.list.array = 0;
 194     ricIndication->protocolIEs.list.count = 0;
 195     ricIndication->protocolIEs.list.size = 0;
 196   }
 197
 198   free(IE_array);
 199   ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 200   mdclog_write(MDCLOG_DEBUG, "Freed E2AP Indication object memory");
 201 }
 202
 203 template<typename T1, typename T2>
 204 bool E2APIndication<T1, T2>::decode(unsigned char *buf, size_t *size)
 205 {
 206
 207         asn_dec_rval_t dec_res  = asn_decode(0,ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void**)&(e2ap_pdu_obj), buf, *size);
 208         if(dec_res.code != RC_OK){
 209                          mdclog_write(MDCLOG_ERR, "Failed to decode: %s","RIC Indication Message");
 210                          return false;
 211         } else {
 212                          mdclog_write(MDCLOG_INFO, "Successfully decoded: %s","RIC Indication Message");
 213         }
 214
 215   xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 216
 217   initMsg = e2ap_pdu_obj->choice.initiatingMessage;
 218   //write the decoding code.
 219   if (initMsg == 0){
 220     _error_string = "Invalid reference for E2AP Indication message in get_fields";
 221     return false;
 222   }
 223
 224
 225   for(int edx = 0; edx < initMsg->value.choice.RICindication.protocolIEs.list.count; edx++) {
 226         RICindication_IEs_t *memb_ptr = initMsg->value.choice.RICindication.protocolIEs.list.array[edx];
 227     switch(memb_ptr->id)
 228      {
 229       case (ProtocolIE_ID_id_RICindicationHeader):
 230                 _indicationIEs->set_ricIndicationHeader(memb_ptr->value.choice.RICindicationHeader.buf, memb_ptr->value.choice.RICindicationHeader.size);
 231       break;
 232
 233       case (ProtocolIE_ID_id_RICindicationMessage):
 234                 _indicationIEs->set_ricIndicationMessage(memb_ptr->value.choice.RICindicationMessage.buf, memb_ptr->value.choice.RICindicationMessage.size);
 235       break;
 236
 237       case (ProtocolIE_ID_id_RICrequestID):
 238                 _indicationIEs->set_ricRequestorID(memb_ptr->value.choice.RICrequestID.ricRequestorID);
 239       break;
 240
 241       case (ProtocolIE_ID_id_RANfunctionID):
 242                 _indicationIEs->set_ranFunctionID(memb_ptr->value.choice.RANfunctionID);
 243           break;
 244
 245       case (ProtocolIE_ID_id_RICindicationSN):
 246                 _indicationIEs->set_ricIndicationSN(memb_ptr->value.choice.RICindicationSN);
 247           break;
 248
 249       case (ProtocolIE_ID_id_RICindicationType):
 250                 _indicationIEs->set_ricIndicationType(memb_ptr->value.choice.RICindicationType);
 251           break;
 252
 253       case (ProtocolIE_ID_id_RICactionID):
 254                 _indicationIEs->set_ricActionID(memb_ptr->value.choice.RICactionID);
 255           break;
 256
 257       case (ProtocolIE_ID_id_RICcallProcessID):
 258                 _indicationIEs->set_ricCallProcessID(memb_ptr->value.choice.RICcallProcessID.buf,memb_ptr->value.choice.RICcallProcessID.size);
 259           break;
 260
 261       default:
 262       break;
 263       }
 264
 265   }
 266
 267   return true;
 268
 269 }
 270
 271 template<typename T1, typename T2>
 272 bool E2APIndication<T1,T2>::encode(unsigned char *buf, size_t *size){
 273
 274   initMsg->procedureCode = ProcedureCode_id_RICindication;
 275   initMsg->criticality = Criticality_ignore;
 276   initMsg->value.present = InitiatingMessage__value_PR_RICindication;
 277
 278   bool res;
 279   asn_enc_rval_t retval;
 280
 281   res = setfields(initMsg);
 282   if (!res){
 283     return false;
 284   }
 285
 286   int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu_obj, _errbuf, &_errbuf_len);
 287   if(ret_constr){
 288     _error_string.assign(&_errbuf[0], _errbuf_len);
 289     _error_string = "Error encoding E2AP Indication message. Reason = " + _error_string;
 290     return false;
 291   }
 292
 293   xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 294
 295   retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size);
 296   if(retval.encoded == -1){
 297     _error_string.assign(strerror(errno));
 298     return false;
 299   }
 300
 301   else {
 302     if(*size < retval.encoded){
 303       std::stringstream ss;
 304       ss  <<"Error encoding E2AP Indication . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 305       _error_string = ss.str();
 306       return false;
 307     }
 308   }
 309
 310   *size = retval.encoded;
 311   return true;
 312
 313 }
 314 template<typename T1, typename T2>
 315 bool E2APIndication<T1,T2>::setfields(InitiatingMessage_t *initMsg){
 316   unsigned int ie_index;
 317
 318   if (initMsg == 0){
 319     _error_string = "Invalid reference for E2AP Indication message in set_fields";
 320     return false;
 321   }
 322
 323
 324   RICindication_t * ric_indication = &(initMsg->value.choice.RICindication);
 325   ric_indication->protocolIEs.list.count = 0;
 326
 327   ie_index = 0;
 328
 329   RICindication_IEs_t *ies_ricreq = &IE_array[ie_index];
 330   ies_ricreq->criticality = Criticality_reject;
 331   ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
 332   ies_ricreq->value.present = RICindication_IEs__value_PR_RICrequestID;
 333   RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 334   ricrequest_ie->ricRequestorID = _indicationIEs->ricRequestorID;
 335   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 336
 337   ie_index = 1;
 338   RICindication_IEs_t *ies_ranfunc = &IE_array[ie_index];
 339   ies_ranfunc->criticality = Criticality_reject;
 340   ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 341   ies_ranfunc->value.present = RICindication_IEs__value_PR_RANfunctionID;
 342   RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 343   *ranfunction_ie = _indicationIEs->ranFunctionID;
 344   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 345
 346   ie_index = 2;
 347   RICindication_IEs_t *ies_actid = &IE_array[ie_index];
 348   ies_actid->criticality = Criticality_reject;
 349   ies_actid->id = ProtocolIE_ID_id_RICactionID;
 350   ies_actid->value.present = RICindication_IEs__value_PR_RICactionID;
 351   RICactionID_t *ricaction_ie = &ies_actid->value.choice.RICactionID;
 352   *ricaction_ie = _indicationIEs->ricActionID;
 353   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 354
 355   ie_index = 3;
 356   RICindication_IEs_t *ies_ricsn = &IE_array[ie_index];
 357   ies_ricsn->criticality = Criticality_reject;
 358   ies_ricsn->id = ProtocolIE_ID_id_RICindicationSN;
 359   ies_ricsn->value.present = RICindication_IEs__value_PR_RICindicationSN;
 360   RICindicationSN_t *ricsn_ie = &ies_ricsn->value.choice.RICindicationSN;
 361   *ricsn_ie = _indicationIEs->ricIndicationSN;
 362   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 363
 364
 365   ie_index = 4;
 366   RICindication_IEs_t *ies_indtyp = &IE_array[ie_index];
 367   ies_indtyp->criticality = Criticality_reject;
 368   ies_indtyp->id = ProtocolIE_ID_id_RICindicationType;
 369   ies_indtyp->value.present = RICindication_IEs__value_PR_RICindicationType;
 370   RICindicationType_t *rictype_ie = &ies_indtyp->value.choice.RICindicationType;
 371   *rictype_ie = _indicationIEs->ricIndicationType;
 372   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 373
 374   ie_index = 5;
 375   RICindication_IEs_t *ies_richead = &IE_array[ie_index];
 376   ies_richead->criticality = Criticality_reject;
 377   ies_richead->id = ProtocolIE_ID_id_RICindicationHeader;
 378   ies_richead->value.present = RICindication_IEs__value_PR_RICindicationHeader;
 379   RICindicationHeader_t *richeader_ie = &ies_richead->value.choice.RICindicationHeader;
 380   richeader_ie->buf = _indicationIEs->ricIndicationHeader;
 381   richeader_ie->size = _indicationIEs->ricIndicationHeader_size;
 382   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 383
 384   ie_index = 6;
 385   RICindication_IEs_t *ies_indmsg = &IE_array[ie_index];
 386   ies_indmsg->criticality = Criticality_reject;
 387   ies_indmsg->id = ProtocolIE_ID_id_RICindicationMessage;
 388   ies_indmsg->value.present = RICindication_IEs__value_PR_RICindicationMessage;
 389   RICindicationMessage_t *ricmsg_ie = &ies_indmsg->value.choice.RICindicationMessage;
 390   ricmsg_ie->buf = _indicationIEs->ricIndicationMessage;
 391   ricmsg_ie->size = _indicationIEs->ricIndicationMessage_size;
 392   ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 393
 394
 395   // optional call process id ..
 396   if (_indicationIEs->call_process_id_size > 0){
 397     ie_index = 7;
 398     RICindication_IEs_t *ies_ind_callprocessid = &IE_array[ie_index];
 399     ies_ind_callprocessid->criticality = Criticality_reject;
 400     ies_ind_callprocessid->id = ProtocolIE_ID_id_RICcallProcessID;
 401     ies_ind_callprocessid->value.present = RICindication_IEs__value_PR_RICcallProcessID;
 402     RICcallProcessID_t *riccallprocessid_ie = &ies_ind_callprocessid->value.choice.RICcallProcessID;
 403     riccallprocessid_ie->buf = _indicationIEs->call_process_id;
 404     riccallprocessid_ie->size = _indicationIEs->call_process_id_size;
 405     ASN_SEQUENCE_ADD(&(ric_indication->protocolIEs), &(IE_array[ie_index]));
 406   }
 407
 408   return true;
 409
 410 };
 411
 412 #endif /* SRC_XAPP_ASN_E2AP_E2AP_INDICATION_HPP_ */