src/xapp-asn/e2sm/e2sm_subscription.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  * e2sm_subscription.cc
  21  *
  22  *  Created on: Jun 30, 2020
  23  *      Author: sjana
  24  */
  25
  26 #include "e2sm_subscription.hpp"
  27
  28
  29
  30 HWEventTriggerDefinition::HWEventTriggerDefinition(void){
  31
  32         memset(&_event_fmt1, 0, sizeof(E2SM_HelloWorld_EventTriggerDefinition_Format1_t));
  33
  34         _triggerNature = 1; //Making first selection as default since enumerated type.
  35
  36     _event_trigger = 0;
  37     _event_trigger = ( E2SM_HelloWorld_EventTriggerDefinition_t *)calloc(1, sizeof( E2SM_HelloWorld_EventTriggerDefinition_t));
  38     assert(_event_trigger != 0);
  39
  40   };
  41
  42 HWEventTriggerDefinition::~HWEventTriggerDefinition(void){
  43
  44   mdclog_write(MDCLOG_DEBUG, "Freeing event trigger object memory");
  45   _event_trigger->choice.eventDefinition_Format1 = 0;
  46   ASN_STRUCT_FREE(asn_DEF_E2SM_HelloWorld_EventTriggerDefinition, _event_trigger);
  47
  48 };
  49
  50 bool HWEventTriggerDefinition::encode(unsigned char *buf, size_t *size){
  51
  52   ASN_STRUCT_RESET(asn_DEF_E2SM_HelloWorld_EventTriggerDefinition, _event_trigger);
  53
  54   if(_event_trigger == 0){
  55       _error_string = "Invalid reference for Event Trigger Definition set fields";
  56       return false;
  57     }
  58
  59   _event_trigger->present = E2SM_HelloWorld_EventTriggerDefinition_PR_eventDefinition_Format1;
  60   _event_fmt1.triggerNature = this->_triggerNature;
  61   _event_trigger->choice.eventDefinition_Format1 = &_event_fmt1;
  62
  63
  64   int ret_constr = asn_check_constraints(&asn_DEF_E2SM_HelloWorld_EventTriggerDefinition, _event_trigger, _errbuf, &_errbuf_len);
  65   if(ret_constr){
  66     _error_string.assign(&_errbuf[0], _errbuf_len);
  67     return false;
  68   }
  69
  70   xer_fprint(stdout, &asn_DEF_E2SM_HelloWorld_EventTriggerDefinition, _event_trigger);
  71
  72   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_HelloWorld_EventTriggerDefinition, _event_trigger, buf, *size);
  73
  74   if(retval.encoded == -1){
  75     _error_string.assign(strerror(errno));
  76     return false;
  77   }
  78   else if (retval.encoded > *size){
  79     std::stringstream ss;
  80     ss  <<"Error encoding event trigger definition. Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
  81     _error_string = ss.str();
  82     return false;
  83   }
  84   else{
  85     *size = retval.encoded;
  86   }
  87
  88   return true;
  89 }
  90
  91 HWActionDefinition::HWActionDefinition(void){
  92
  93         _param_list = std::make_unique<std::vector<RANParamIEs>>(); _count_list = 0;
  94
  95         memset(&_action_fmt1, 0, sizeof(E2SM_HelloWorld_ActionDefinition_Format1_t));
  96
  97         int SEQOFRANPARAMS = 1;
  98
  99         _ranparam_ie = 0;
 100         _ranparam_ie = (RANparameter_Item_t*)calloc(SEQOFRANPARAMS, sizeof(RANparameter_Item_t));
 101         assert(_ranparam_ie != 0);
 102
 103         _action_defn = 0;
 104     _action_defn = (E2SM_HelloWorld_ActionDefinition_t*)calloc(1, sizeof(E2SM_HelloWorld_ActionDefinition_t));
 105     assert(_action_defn !=0);
 106
 107
 108 };
 109
 110 HWActionDefinition::~HWActionDefinition(void){
 111
 112   mdclog_write(MDCLOG_DEBUG, "Freeing Action Definition object memory");
 113   _action_defn->choice.actionDefinition_Format1 = 0;
 114   free(_ranparam_ie);
 115   ASN_STRUCT_FREE(asn_DEF_E2SM_HelloWorld_ActionDefinition, _action_defn);
 116
 117
 118 };
 119 bool HWActionDefinition::encode(unsigned char *buf, size_t *size){
 120
 121   bool res;
 122   res = this->setfields(this->_action_defn);
 123   if (!res){
 124     return false;
 125   }
 126
 127   int ret_constr = asn_check_constraints(&asn_DEF_E2SM_HelloWorld_ActionDefinition, this->_action_defn, _errbuf, &_errbuf_len);
 128   if(ret_constr){
 129     _error_string.assign(&_errbuf[0], _errbuf_len);
 130     return false;
 131   }
 132
 133   xer_fprint(stdout, &asn_DEF_E2SM_HelloWorld_ActionDefinition, _action_defn);
 134
 135   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_HelloWorld_ActionDefinition, _action_defn, buf, *size);
 136
 137   if(retval.encoded == -1){
 138     _error_string.assign(strerror(errno));
 139     return false;
 140   }
 141   else if (retval.encoded > *size){
 142     std::stringstream ss;
 143     ss  <<"Error encoding action definition. Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 144     _error_string = ss.str();
 145     return false;
 146   }
 147   else{
 148     *size = retval.encoded;
 149   }
 150
 151   return true;
 152 }
 153
 154 bool HWActionDefinition::setfields(E2SM_HelloWorld_ActionDefinition_t *_action_defn){
 155
 156  if(_action_defn == 0){
 157     _error_string = "Invalid reference for Event Action Definition set fields";
 158     return false;
 159   }
 160   _action_defn->present = E2SM_HelloWorld_ActionDefinition_PR_actionDefinition_Format1;
 161
 162   _ranparam_ie = (RANparameter_Item_t*)calloc(this->_count_list, sizeof(RANparameter_Item_t));
 163    assert(_ranparam_ie != 0);
 164
 165   auto paramList = this->get_list();
 166   int i = 0;
 167   for(RANParamIEs item:*paramList){
 168
 169           _ranparam_ie[i].ranParameter_ID = item.get_param_id();
 170           _ranparam_ie[i].ranParameter_Name.buf = item.get_param_name();
 171           _ranparam_ie[i].ranParameter_Name.size = item.get_param_name_size();
 172           _ranparam_ie[i].ranParameter_Test = item.get_param_test();
 173           _ranparam_ie[i].ranParameter_Value.buf = item.get_param_value();
 174           _ranparam_ie[i].ranParameter_Value.size = item.get_param_value_size();
 175
 176          const int res = ASN_SEQUENCE_ADD(&_action_fmt1.ranParameter_List, &(_ranparam_ie[i]));
 177          if (res!=0){
 178                _error_string = "Error : Unable to assign memory to add RAN PARAM item to set up list";
 179                return false;
 180             }
 181           i++;
 182
 183   }
 184
 185   _action_defn->choice.actionDefinition_Format1 = &_action_fmt1;
 186
 187
 188   return true;
 189 };