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