src/E2AP-c/subscription/subscription_request.cc

   1
   2
   3 /*
   4 ==================================================================================
   5         Copyright (c) 2018-2019 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 #include "subscription_request.hpp"
  23
  24 subscription_request::subscription_request(void){
  25
  26   _name = "default";
  27
  28   e2ap_pdu_obj = 0;
  29   e2ap_pdu_obj = (E2AP_PDU_t * )calloc(1, sizeof(E2AP_PDU_t));
  30   assert(e2ap_pdu_obj != 0);
  31
  32   initMsg = 0;
  33   initMsg = (InitiatingMessage_t * )calloc(1, sizeof(InitiatingMessage_t));
  34   assert(initMsg != 0);
  35
  36   IE_array = 0;
  37   IE_array = (RICsubscriptionRequest_IEs_t *)calloc(NUM_SUBSCRIPTION_REQUEST_IES, sizeof(RICsubscriptionRequest_IEs_t));
  38   assert(IE_array != 0);
  39
  40   action_array = 0;
  41   action_array = (RICaction_ToBeSetup_ItemIEs_t *)calloc(INITIAL_LIST_SIZE, sizeof(RICaction_ToBeSetup_ItemIEs_t));
  42   assert(action_array != 0);
  43   action_array_size = INITIAL_LIST_SIZE;
  44
  45 };
  46
  47
  48
  49 // Clear assigned protocolIE list from RIC indication IE container
  50 subscription_request::~subscription_request(void){
  51
  52   mdclog_write(MDCLOG_INFO, "Freeing subscription request memory for");;
  53
  54   // Sequence of actions to be admitted causes special heart-ache. Free ric subscription element manually and reset the ie pointer
  55   RICsubscription_t * ricsubscription_ie = &(IE_array[2].value.choice.RICsubscription);
  56
  57   for(int i = 0; i < ricsubscription_ie->ricAction_ToBeSetup_List.list.size; i++){
  58     ricsubscription_ie->ricAction_ToBeSetup_List.list.array[i] = 0;
  59   }
  60
  61   if (ricsubscription_ie->ricAction_ToBeSetup_List.list.size > 0){
  62     free(ricsubscription_ie->ricAction_ToBeSetup_List.list.array);
  63     ricsubscription_ie->ricAction_ToBeSetup_List.list.size = 0;
  64     ricsubscription_ie->ricAction_ToBeSetup_List.list.count = 0;
  65     ricsubscription_ie->ricAction_ToBeSetup_List.list.array = 0;
  66   }
  67
  68   free(action_array);
  69   RICsubscriptionRequest_t * subscription_request = &(initMsg->value.choice.RICsubscriptionRequest);
  70
  71   for(int i = 0; i < subscription_request->protocolIEs.list.size; i++){
  72     subscription_request->protocolIEs.list.array[i] = 0;
  73   }
  74
  75   if( subscription_request->protocolIEs.list.size > 0){
  76     free( subscription_request->protocolIEs.list.array);
  77     subscription_request->protocolIEs.list.array = 0;
  78     subscription_request->protocolIEs.list.size = 0;
  79     subscription_request->protocolIEs.list.count = 0;
  80   }
  81
  82   free(IE_array);
  83   free(initMsg);
  84   e2ap_pdu_obj->choice.initiatingMessage = 0;
  85
  86   ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, e2ap_pdu_obj);
  87   mdclog_write(MDCLOG_INFO, "Freed subscription request memory ");
  88 };
  89
  90
  91 bool subscription_request::encode_e2ap_subscription(unsigned char *buf, size_t *size, E2AP_PDU_t *e2ap_pdu, subscription_helper &dinput){
  92
  93   bool res;
  94
  95   e2ap_pdu_obj->choice.initiatingMessage = initMsg;
  96   e2ap_pdu_obj->present = E2AP_PDU_PR_initiatingMessage;
  97
  98   res = set_fields(e2ap_pdu_obj->choice.initiatingMessage, dinput);
  99   if (!res){
 100     return false;
 101   }
 102
 103   //xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2ap_pdu_obj);
 104   int ret_constr = asn_check_constraints(&asn_DEF_E2AP_PDU, (void *) e2ap_pdu_obj, errbuf, &errbuf_len);
 105   if(ret_constr){
 106     error_string.assign(errbuf, errbuf_len);
 107     error_string = "Constraints failed for encoding subscription request. Reason = " + error_string;
 108     return false;
 109   }
 110
 111   asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, e2ap_pdu_obj, buf, *size);
 112
 113   if(retval.encoded == -1){
 114     error_string.assign(strerror(errno));
 115     error_string = "Error encoding Subscription Delete Request. Reason = " + error_string;
 116     return false;
 117   }
 118   else {
 119     if(*size < retval.encoded){
 120       std::stringstream ss;
 121       ss  <<"Error encoding Subscription Delete Request . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
 122       error_string = ss.str();
 123       retval.encoded = -1;
 124       return false;
 125     }
 126   }
 127
 128   *size = retval.encoded;
 129   return true;
 130
 131 }
 132
 133
 134 bool subscription_request::set_fields(InitiatingMessage_t *ref_initMsg, subscription_helper &helper){
 135
 136   if (ref_initMsg == 0){
 137     error_string = "Error : Invalid reference when setting fields for subscription request";
 138     return false;
 139   }
 140
 141   int ie_index;
 142   int result = 0;
 143
 144   ref_initMsg->procedureCode = ProcedureCode_id_ricSubscription;
 145   ref_initMsg->criticality = Criticality_reject;
 146   ref_initMsg->value.present = InitiatingMessage__value_PR_RICsubscriptionRequest;
 147
 148   RICsubscriptionRequest_t * subscription_request = &(ref_initMsg->value.choice.RICsubscriptionRequest);
 149
 150   // Reset field count for protocolIEs
 151   subscription_request->protocolIEs.list.count = 0;
 152
 153   ie_index = 0;
 154   RICsubscriptionRequest_IEs_t *ies_ricreq = &IE_array[ie_index];
 155   ies_ricreq->criticality = Criticality_reject;
 156   ies_ricreq->id = ProtocolIE_ID_id_RICrequestID;
 157   ies_ricreq->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 158   RICrequestID_t *ricrequest_ie = &ies_ricreq->value.choice.RICrequestID;
 159   ricrequest_ie->ricRequestorID = helper.get_request_id();
 160   ricrequest_ie->ricRequestSequenceNumber = helper.get_req_seq();
 161   result = ASN_SEQUENCE_ADD(&subscription_request->protocolIEs, ies_ricreq);
 162   if (result == -1){
 163      error_string = "Erorr : Unable to assign memory to add RIC request id to subscription request";
 164     return false;
 165   }
 166
 167   ie_index = 1;
 168   RICsubscriptionRequest_IEs_t *ies_ranfunc = &IE_array[ie_index];
 169   ies_ranfunc->criticality = Criticality_reject;
 170   ies_ranfunc->id = ProtocolIE_ID_id_RANfunctionID;
 171   ies_ranfunc->value.present = RICsubscriptionRequest_IEs__value_PR_RANfunctionID;
 172   RANfunctionID_t *ranfunction_ie = &ies_ranfunc->value.choice.RANfunctionID;
 173   *ranfunction_ie = helper.get_function_id();
 174   ASN_SEQUENCE_ADD(&subscription_request->protocolIEs, ies_ranfunc);
 175   if (result == -1){
 176     error_string = "Erorr : Unable to assign memory to add RAN function id to subscription request";
 177     return false;
 178   }
 179
 180
 181   ie_index = 2;
 182   RICsubscriptionRequest_IEs_t *ies_actid = &IE_array[ie_index];
 183   ies_actid->criticality = Criticality_reject;
 184   ies_actid->id = ProtocolIE_ID_id_RICsubscription;
 185   ies_actid->value.present = RICsubscriptionRequest_IEs__value_PR_RICsubscription;
 186   RICsubscription_t *ricsubscription_ie = &ies_actid->value.choice.RICsubscription;
 187
 188   ricsubscription_ie->ricEventTriggerDefinition.buf = (uint8_t *) helper.get_event_def();
 189   ricsubscription_ie->ricEventTriggerDefinition.size = helper.get_event_def_size();
 190
 191   std::vector<Action> * ref_action_array = helper.get_list();
 192
 193   // do we need to reallocate ?
 194   if(action_array_size < ref_action_array->size()){
 195     action_array_size = 2 * ref_action_array->size();
 196     RICaction_ToBeSetup_ItemIEs_t * new_ref = 0;
 197     new_ref = (RICaction_ToBeSetup_ItemIEs_t *  )realloc(action_array, action_array_size);
 198     assert(new_ref != 0);
 199     action_array = new_ref;
 200   }
 201
 202   // reset the list count on ricAction_ToBeSetup_List;
 203   ricsubscription_ie->ricAction_ToBeSetup_List.list.count = 0;
 204
 205   for(int i = 0; i < ref_action_array->size(); i ++){
 206     action_array[i].criticality = Criticality_ignore;
 207     action_array[i].id = ProtocolIE_ID_id_RICaction_ToBeSetup_Item ;
 208     action_array[i].value.present = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
 209     action_array[i].value.choice.RICaction_ToBeSetup_Item.ricActionID = (*ref_action_array)[i].get_id();
 210     action_array[i].value.choice.RICaction_ToBeSetup_Item.ricActionType = (*ref_action_array)[i].get_type();
 211
 212     result = ASN_SEQUENCE_ADD(&ricsubscription_ie->ricAction_ToBeSetup_List, &(action_array[i]));
 213     if (result == -1){
 214       error_string = "Erorr : Unable to assign memory to add Action item to set up list";
 215       return false;
 216     }
 217
 218
 219   }
 220
 221   result = ASN_SEQUENCE_ADD(&subscription_request->protocolIEs, ies_actid);
 222   if (result == -1){
 223     error_string = "Erorr : Unable to assign memory to action item to be setup list  subscription request";
 224     return false;
 225   }
 226
 227   return true;
 228 };
 229
 230
 231
 232 bool subscription_request:: get_fields(InitiatingMessage_t * init_msg,  subscription_helper & dout)
 233 {
 234
 235   if (init_msg == 0){
 236     error_string = "Error. Invalid reference when getting fields from subscription request";
 237     return false;
 238   }
 239
 240   RICrequestID_t *requestid;
 241   RANfunctionID_t * ranfunctionid;
 242   RICsubscription_t * ricsubscription;
 243
 244   for(int edx = 0; edx < init_msg->value.choice.RICsubscriptionRequest.protocolIEs.list.count; edx++) {
 245     RICsubscriptionRequest_IEs_t *memb_ptr = init_msg->value.choice.RICsubscriptionRequest.protocolIEs.list.array[edx];
 246
 247     switch(memb_ptr->id)
 248       {
 249       case (ProtocolIE_ID_id_RICrequestID):
 250         requestid = &memb_ptr->value.choice.RICrequestID;
 251         dout.set_request(requestid->ricRequestorID, requestid->ricRequestSequenceNumber);
 252         break;
 253
 254       case (ProtocolIE_ID_id_RANfunctionID):
 255         ranfunctionid = &memb_ptr->value.choice.RANfunctionID;
 256         dout.set_function_id(*ranfunctionid);
 257         break;
 258
 259       case (ProtocolIE_ID_id_RICsubscription):
 260         ricsubscription = &memb_ptr->value.choice.RICsubscription;
 261         dout.set_event_def(ricsubscription->ricEventTriggerDefinition.buf, ricsubscription->ricEventTriggerDefinition.size);
 262
 263         for(int index = 0; index < ricsubscription->ricAction_ToBeSetup_List.list.count; index ++){
 264           RICaction_ToBeSetup_ItemIEs_t * item = (RICaction_ToBeSetup_ItemIEs_t *)ricsubscription->ricAction_ToBeSetup_List.list.array[index];
 265           dout.add_action(item->value.choice.RICaction_ToBeSetup_Item.ricActionID, item->value.choice.RICaction_ToBeSetup_Item.ricActionType);
 266         };
 267
 268         break;
 269       }
 270
 271   }
 272
 273   //asn_fprint(stdout, &asn_DEF_E2AP_PDU, e2pdu);
 274   return true;
 275 };
 276
 277
 278