1. Transitioned to using latest asn1c compiler

[ric-app/admin.git] / src / E2SM / e2sm.cc

diff --git a/src/E2SM/e2sm.cc b/src/E2SM/e2sm.cc
index 069ac1c..c476c83 100644 (file)
--- a/src/E2SM/e2sm.cc
+++ b/src/E2SM/e2sm.cc
@@ -26,10 +26,10 @@
   //initialize
   e2sm_event_trigger::e2sm_event_trigger(void){
 
-    memset(&gNodeB_ID, 0, sizeof(GlobalGNB_ID_t));
+    memset(&gNodeB_ID, 0, sizeof(E2N_GlobalGNB_ID_t));
 
     event_trigger = 0;
-    event_trigger = ( E2SM_gNB_X2_eventTriggerDefinition_t *)calloc(1, sizeof( E2SM_gNB_X2_eventTriggerDefinition_t));
+    event_trigger = ( E2N_E2SM_gNB_X2_eventTriggerDefinition_t *)calloc(1, sizeof( E2N_E2SM_gNB_X2_eventTriggerDefinition_t));
     assert(event_trigger != 0);
     
     // allocate space for gNodeB id  (used for encoding)
@@ -43,12 +43,12 @@
     assert(gNodeB_ID.pLMN_Identity.buf != 0);
 
     ie_list = 0;
-    ie_list = ( struct InterfaceProtocolIE_Item *) calloc(INITIAL_LIST_SIZE, sizeof( struct InterfaceProtocolIE_Item));
+    ie_list = ( struct E2N_InterfaceProtocolIE_Item *) calloc(INITIAL_LIST_SIZE, sizeof( struct E2N_InterfaceProtocolIE_Item));
     assert(ie_list != 0);
     ie_list_size = INITIAL_LIST_SIZE;
 
     condition_list = 0;
-    condition_list = (E2SM_gNB_X2_eventTriggerDefinition::E2SM_gNB_X2_eventTriggerDefinition__interfaceProtocolIE_List *) calloc(1, sizeof(E2SM_gNB_X2_eventTriggerDefinition::E2SM_gNB_X2_eventTriggerDefinition__interfaceProtocolIE_List ));
+    condition_list = (E2N_E2SM_gNB_X2_eventTriggerDefinition::E2N_E2SM_gNB_X2_eventTriggerDefinition__interfaceProtocolIE_List *) calloc(1, sizeof(E2N_E2SM_gNB_X2_eventTriggerDefinition::E2N_E2SM_gNB_X2_eventTriggerDefinition__interfaceProtocolIE_List ));
     assert(condition_list != 0);
 
  
@@ -57,7 +57,7 @@
   
 e2sm_event_trigger::~e2sm_event_trigger(void){
 
-  mdclog_write(MDCLOG_INFO, "Freeing event trigger object memory");
+  mdclog_write(MDCLOG_DEBUG, "Freeing event trigger object memory");
   for(int i = 0; i < condition_list->list.size; i++){
     condition_list->list.array[i] = 0;
   }
@@ -84,8 +84,8 @@ e2sm_event_trigger::~e2sm_event_trigger(void){
   event_trigger->interface_ID.choice.global_gNB_ID = 0;
   event_trigger->interfaceProtocolIE_List = 0;
   
-  ASN_STRUCT_FREE(asn_DEF_E2SM_gNB_X2_eventTriggerDefinition, event_trigger);
-  mdclog_write(MDCLOG_INFO, "Freed event trigger object memory");
+  ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event_trigger);
+  mdclog_write(MDCLOG_DEBUG, "Freed event trigger object memory");
 
  
 };
@@ -98,15 +98,15 @@ bool e2sm_event_trigger::encode_event_trigger(unsigned char *buf, size_t *size,
     return false;
   }
   
-  int ret_constr = asn_check_constraints(&asn_DEF_E2SM_gNB_X2_eventTriggerDefinition, event_trigger, errbuf, &errbuf_len);
+  int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event_trigger, errbuf, &errbuf_len);
   if(ret_constr){
     error_string.assign(&errbuf[0], errbuf_len);
     return false;
   }
 
-  //xer_fprint(stdout, &asn_DEF_E2SM_gNB_X2_eventTriggerDefinition, event_trigger);
+  //xer_fprint(stdout, &asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event_trigger);
   
-  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_eventTriggerDefinition, event_trigger, buf, *size);
+  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_eventTriggerDefinition, event_trigger, buf, *size);
   
   if(retval.encoded == -1){
     error_string.assign(strerror(errno));
@@ -126,7 +126,7 @@ bool e2sm_event_trigger::encode_event_trigger(unsigned char *buf, size_t *size,
 }
 
 
-bool e2sm_event_trigger::set_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_event_trigger, e2sm_event_trigger_helper & helper){
+bool e2sm_event_trigger::set_fields(E2N_E2SM_gNB_X2_eventTriggerDefinition_t * ref_event_trigger, e2sm_event_trigger_helper & helper){
   if(ref_event_trigger == 0){
     error_string = "Invalid reference for Event Trigger Definition set fields";
     return false;
@@ -137,7 +137,7 @@ bool e2sm_event_trigger::set_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_e
   ref_event_trigger->interfaceMessageType.typeOfMessage = helper.message_type;
   
   ref_event_trigger->interfaceDirection = helper.interface_direction; 
-  ref_event_trigger->interface_ID.present = Interface_ID_PR_global_gNB_ID;
+  ref_event_trigger->interface_ID.present = E2N_Interface_ID_PR_global_gNB_ID;
   
   ref_event_trigger->interface_ID.choice.global_gNB_ID = &gNodeB_ID;
 
@@ -151,7 +151,7 @@ bool e2sm_event_trigger::set_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_e
   gNodeB_ID.gNB_ID.choice.gNB_ID.size = 3;
   
   // we only do global gNodeB id for now, not eNodeB
-  gNodeB_ID.gNB_ID.present = GNB_ID_PR_gNB_ID;
+  gNodeB_ID.gNB_ID.present = E2N_GNB_ID_PR_gNB_ID;
   //================================================================
   
   
@@ -159,19 +159,18 @@ bool e2sm_event_trigger::set_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_e
   std::vector<Item> * ref_ie_array = helper.get_list();
 
   if (ref_ie_array->size() == 0){
-    event_trigger->interfaceProtocolIE_List = 0;
+    ref_event_trigger->interfaceProtocolIE_List = 0;
     
   }
   else{
-    event_trigger->interfaceProtocolIE_List = condition_list;
+    ref_event_trigger->interfaceProtocolIE_List = condition_list;
     
-    //reallocate ? 
+    //resize memory ? 
     if(ref_ie_array->size() > ie_list_size){
-      struct InterfaceProtocolIE_Item *new_ref = 0;
       ie_list_size = 2 * ref_ie_array->size();
-      new_ref = (struct InterfaceProtocolIE_Item *)realloc(ie_list, ie_list_size);
-      assert(new_ref != 0);
-      ie_list = new_ref;
+      free(ie_list);
+      ie_list = (struct E2N_InterfaceProtocolIE_Item *)calloc(ie_list_size, sizeof(struct E2N_InterfaceProtocolIE_Item));
+      assert(ie_list != 0);
     }
     
     // reset the count so that adds start from the beginning
@@ -185,27 +184,33 @@ bool e2sm_event_trigger::set_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_e
       //switch(ie_list[i].interfaceProtocolIE_Value.present){
       switch((*ref_ie_array)[i].val_type){
        
-      case (InterfaceProtocolIE_Value_PR_valueInt):
-       ie_list[i].interfaceProtocolIE_Value.present = InterfaceProtocolIE_Value_PR_valueInt;
+      case (E2N_InterfaceProtocolIE_Value_PR_valueInt):
+       ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueInt;
        ie_list[i].interfaceProtocolIE_Value.choice.valueInt = (*ref_ie_array)[i].value_n;
        break;
        
-      case (InterfaceProtocolIE_Value_PR_valueEnum):
-       ie_list[i].interfaceProtocolIE_Value.present = InterfaceProtocolIE_Value_PR_valueEnum;
+      case (E2N_InterfaceProtocolIE_Value_PR_valueEnum):
+       ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueEnum;
        ie_list[i].interfaceProtocolIE_Value.choice.valueEnum = (*ref_ie_array)[i].value_n;
        break;
        
-      case (InterfaceProtocolIE_Value_PR_valueBool):
-       ie_list[i].interfaceProtocolIE_Value.present = InterfaceProtocolIE_Value_PR_valueBool;
+      case (E2N_InterfaceProtocolIE_Value_PR_valueBool):
+       ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueBool;
        ie_list[i].interfaceProtocolIE_Value.choice.valueBool = (*ref_ie_array)[i].value_n;
        break;
        
-      case (InterfaceProtocolIE_Value_PR_valueBitS):
-       ie_list[i].interfaceProtocolIE_Value.present = InterfaceProtocolIE_Value_PR_valueBitS;
+      case (E2N_InterfaceProtocolIE_Value_PR_valueBitS):
+       ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueBitS;
        ie_list[i].interfaceProtocolIE_Value.choice.valueBitS.buf = (uint8_t *)(*ref_ie_array)[i].value_s.c_str();
        ie_list[i].interfaceProtocolIE_Value.choice.valueBitS.size = (*ref_ie_array)[i].value_s.length();
        break;
-       
+
+      case (E2N_InterfaceProtocolIE_Value_PR_valueOctS):
+       ie_list[i].interfaceProtocolIE_Value.present = E2N_InterfaceProtocolIE_Value_PR_valueOctS;
+       ie_list[i].interfaceProtocolIE_Value.choice.valueOctS.buf = (uint8_t *)(*ref_ie_array)[i].value_s.c_str();
+       ie_list[i].interfaceProtocolIE_Value.choice.valueOctS.size = (*ref_ie_array)[i].value_s.length();
+       break;
+
       default:
        {
          std::stringstream ss;
@@ -223,7 +228,7 @@ bool e2sm_event_trigger::set_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_e
 };
   
 
-bool e2sm_event_trigger::get_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_event_trigger, e2sm_event_trigger_helper & helper){
+bool e2sm_event_trigger::get_fields(E2N_E2SM_gNB_X2_eventTriggerDefinition_t * ref_event_trigger, e2sm_event_trigger_helper & helper){
 
   if (ref_event_trigger == 0){
     error_string = "Invalid reference for Event Trigger definition get fields";
@@ -236,7 +241,30 @@ bool e2sm_event_trigger::get_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_e
   
   helper.plmn_id.assign((const char *)ref_event_trigger->interface_ID.choice.global_gNB_ID->pLMN_Identity.buf, ref_event_trigger->interface_ID.choice.global_gNB_ID->pLMN_Identity.size);
   helper.egNB_id.assign((const char *)ref_event_trigger->interface_ID.choice.global_gNB_ID->gNB_ID.choice.gNB_ID.buf, ref_event_trigger->interface_ID.choice.global_gNB_ID->gNB_ID.choice.gNB_ID.size);
-
+  for(int i = 0; i < ref_event_trigger->interfaceProtocolIE_List->list.count; i++){
+    struct E2N_InterfaceProtocolIE_Item * ie_item = ref_event_trigger->interfaceProtocolIE_List->list.array[i];
+    switch(ie_item->interfaceProtocolIE_Value.present){
+    case (E2N_InterfaceProtocolIE_Value_PR_valueInt):
+      helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, ie_item->interfaceProtocolIE_Value.choice.valueInt);
+      break;
+    case (E2N_InterfaceProtocolIE_Value_PR_valueEnum):
+      helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, ie_item->interfaceProtocolIE_Value.choice.valueEnum);
+      break;
+    case (E2N_InterfaceProtocolIE_Value_PR_valueBool):
+      helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, ie_item->interfaceProtocolIE_Value.choice.valueBool);            
+      break;
+    case (E2N_InterfaceProtocolIE_Value_PR_valueBitS):
+      helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, std::string((const char *)ie_item->interfaceProtocolIE_Value.choice.valueBitS.buf,ie_item->interfaceProtocolIE_Value.choice.valueBitS.size) );
+      break;
+    case (E2N_InterfaceProtocolIE_Value_PR_valueOctS):
+      helper.add_protocol_ie_item(ie_item->interfaceProtocolIE_ID, ie_item->interfaceProtocolIE_Test, ie_item->interfaceProtocolIE_Value.present, std::string((const char *)ie_item->interfaceProtocolIE_Value.choice.valueOctS.buf,ie_item->interfaceProtocolIE_Value.choice.valueOctS.size) );
+      break;
+    default:
+      mdclog_write(MDCLOG_ERR, "Error : %s, %d: Unkown interface protocol IE type %d in event trigger definition\n", __FILE__, __LINE__, ie_item->interfaceProtocolIE_Value.present);
+      return false;
+    }
+  }
+  
   return true;
 };
     
@@ -246,7 +274,7 @@ bool e2sm_event_trigger::get_fields(E2SM_gNB_X2_eventTriggerDefinition_t * ref_e
 // initialize
 e2sm_indication::e2sm_indication(void) {
   
-  memset(&gNodeB_ID, 0, sizeof(GlobalGNB_ID_t));
+  memset(&gNodeB_ID, 0, sizeof(E2N_GlobalGNB_ID_t));
     
   // allocate space for gNodeB id  (used for encoding)
   gNodeB_ID.gNB_ID.choice.gNB_ID.buf = (uint8_t *)calloc(4, sizeof(uint8_t));
@@ -257,29 +285,29 @@ e2sm_indication::e2sm_indication(void) {
   assert(gNodeB_ID.pLMN_Identity.buf != 0);
 
   header = 0;
-  header = (E2SM_gNB_X2_indicationHeader_t *)calloc(1, sizeof(E2SM_gNB_X2_indicationHeader_t));
+  header = (E2N_E2SM_gNB_X2_indicationHeader_t *)calloc(1, sizeof(E2N_E2SM_gNB_X2_indicationHeader_t));
   assert(header != 0);
 
   message = 0;
-  message = (E2SM_gNB_X2_indicationMessage_t *)calloc(1, sizeof(E2SM_gNB_X2_indicationMessage_t));
+  message = (E2N_E2SM_gNB_X2_indicationMessage_t *)calloc(1, sizeof(E2N_E2SM_gNB_X2_indicationMessage_t));
   assert(message != 0);
 }
   
 e2sm_indication::~e2sm_indication(void){
-  mdclog_write(MDCLOG_INFO, "Freeing E2SM Indication  object memory");
+  mdclog_write(MDCLOG_DEBUG, "Freeing E2N_E2SM Indication  object memory");
 
   free(gNodeB_ID.gNB_ID.choice.gNB_ID.buf);
   free(gNodeB_ID.pLMN_Identity.buf);
   
   header->interface_ID.choice.global_gNB_ID = 0;
 
-  ASN_STRUCT_FREE(asn_DEF_E2SM_gNB_X2_indicationHeader, header);
+  ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, header);
 
   message->interfaceMessage.buf = 0;
   message->interfaceMessage.size = 0;
 
-  ASN_STRUCT_FREE(asn_DEF_E2SM_gNB_X2_indicationMessage, message);
-  mdclog_write(MDCLOG_INFO, "Freed E2SM Indication  object memory");
+  ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, message);
+  mdclog_write(MDCLOG_DEBUG, "Freed E2SM Indication  object memory");
     
 }
   
@@ -293,7 +321,7 @@ bool e2sm_indication::encode_indication_header(unsigned char *buf, size_t *size,
     return false;
   }
 
-  int ret_constr = asn_check_constraints(&asn_DEF_E2SM_gNB_X2_indicationHeader, header, errbuf, &errbuf_len);
+  int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, header, errbuf, &errbuf_len);
   if(ret_constr){
     error_string.assign(&errbuf[0], errbuf_len);
     error_string = "E2SM Indication Header Constraint failed : " + error_string;
@@ -301,11 +329,11 @@ bool e2sm_indication::encode_indication_header(unsigned char *buf, size_t *size,
     return false;
   }
 
-  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_indicationHeader, header, buf, *size);
+  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_indicationHeader, header, buf, *size);
 
   if(retval.encoded == -1){
     error_string.assign(strerror(errno));
-    error_string = "Error encoding E2SM Indication Header. Reason = " + error_string;
+    error_string = "Error encoding E2N_E2SM Indication Header. Reason = " + error_string;
     return false;
   }
   else if (retval.encoded > *size){
@@ -326,14 +354,14 @@ bool e2sm_indication::encode_indication_message(unsigned char *buf, size_t *size
 
   set_message_fields(message, helper); 
 
-  int ret_constr = asn_check_constraints(&asn_DEF_E2SM_gNB_X2_indicationMessage, message, errbuf, &errbuf_len);
+  int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, message, errbuf, &errbuf_len);
   if(ret_constr){
     error_string.assign(&errbuf[0], errbuf_len);
     error_string = "E2SM Indication Message Constraint failed : " + error_string;
     return false;
   }
 
-  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_indicationMessage, message, buf, *size);
+  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_indicationMessage, message, buf, *size);
   if(retval.encoded == -1){
     error_string.assign(strerror(errno));
     error_string = "Error encoding E2SM Indication Header. Reason = " + error_string;
@@ -341,7 +369,7 @@ bool e2sm_indication::encode_indication_message(unsigned char *buf, size_t *size
   }
   else if (retval.encoded > *size){
     std::stringstream ss;
-    ss  <<"Error encoding E2SM Indication Message . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
+    ss  <<"Error encoding E2N_E2SM Indication Message . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
     error_string = ss.str();
     
     return false;
@@ -356,7 +384,7 @@ bool e2sm_indication::encode_indication_message(unsigned char *buf, size_t *size
 
 
 // Used when generating an indication header 
-bool e2sm_indication::set_header_fields(E2SM_gNB_X2_indicationHeader_t *header,  e2sm_header_helper &helper){
+bool e2sm_indication::set_header_fields(E2N_E2SM_gNB_X2_indicationHeader_t *header,  e2sm_header_helper &helper){
 
   if (header == 0){
     error_string = "Invalid reference for E2SM Indication Header set fields";
@@ -365,7 +393,7 @@ bool e2sm_indication::set_header_fields(E2SM_gNB_X2_indicationHeader_t *header,
   
   
   header->interfaceDirection = helper.interface_direction;
-  header->interface_ID.present = Interface_ID_PR_global_gNB_ID;
+  header->interface_ID.present = E2N_Interface_ID_PR_global_gNB_ID;
   header->interface_ID.choice.global_gNB_ID = &gNodeB_ID;
 
 
@@ -378,7 +406,7 @@ bool e2sm_indication::set_header_fields(E2SM_gNB_X2_indicationHeader_t *header,
   gNodeB_ID.gNB_ID.choice.gNB_ID.size = 3;
   
   // we only do global gNodeB id for now, not eNodeB
-  gNodeB_ID.gNB_ID.present = GNB_ID_PR_gNB_ID;
+  gNodeB_ID.gNB_ID.present = E2N_GNB_ID_PR_gNB_ID;
 
   return true;
   
@@ -386,7 +414,7 @@ bool e2sm_indication::set_header_fields(E2SM_gNB_X2_indicationHeader_t *header,
 
 
 // used when decoding an indication header
-bool e2sm_indication::get_header_fields(E2SM_gNB_X2_indicationHeader_t *header,  e2sm_header_helper &helper){
+bool e2sm_indication::get_header_fields(E2N_E2SM_gNB_X2_indicationHeader_t *header,  e2sm_header_helper &helper){
 
   if (header == 0){
     error_string = "Invalid reference for E2SM Indication header get fields";
@@ -405,7 +433,7 @@ bool e2sm_indication::get_header_fields(E2SM_gNB_X2_indicationHeader_t *header,
 
 
 // Used when generating an indication message 
-bool   e2sm_indication::set_message_fields(E2SM_gNB_X2_indicationMessage_t *interface_message,  e2sm_message_helper &helper){
+bool   e2sm_indication::set_message_fields(E2N_E2SM_gNB_X2_indicationMessage_t *interface_message,  e2sm_message_helper &helper){
 
   if(interface_message == 0){
     error_string = "Invalid reference for E2SM Indication Message set fields";
@@ -421,7 +449,7 @@ bool   e2sm_indication::set_message_fields(E2SM_gNB_X2_indicationMessage_t *inte
 };
 
 // used when decoding an indication message
-bool e2sm_indication::get_message_fields( E2SM_gNB_X2_indicationMessage_t *interface_message, e2sm_message_helper &helper){
+bool e2sm_indication::get_message_fields( E2N_E2SM_gNB_X2_indicationMessage_t *interface_message, e2sm_message_helper &helper){
 
   
   if(interface_message == 0){
@@ -442,7 +470,7 @@ bool e2sm_indication::get_message_fields( E2SM_gNB_X2_indicationMessage_t *inter
 // initialize
 e2sm_control::e2sm_control(void) {
   
-  memset(&gNodeB_ID, 0, sizeof(GlobalGNB_ID_t));
+  memset(&gNodeB_ID, 0, sizeof(E2N_GlobalGNB_ID_t));
     
   // allocate space for gNodeB id  (used for encoding)
   gNodeB_ID.gNB_ID.choice.gNB_ID.buf = (uint8_t *)calloc(4, sizeof(uint8_t));
@@ -453,26 +481,26 @@ e2sm_control::e2sm_control(void) {
   assert(gNodeB_ID.pLMN_Identity.buf != 0);
 
   header = 0;
-  header = (E2SM_gNB_X2_controlHeader_t *)calloc(1, sizeof(E2SM_gNB_X2_controlHeader_t));
+  header = (E2N_E2SM_gNB_X2_controlHeader_t *)calloc(1, sizeof(E2N_E2SM_gNB_X2_controlHeader_t));
   assert(header != 0);
 
   message = 0;
-  message = (E2SM_gNB_X2_controlMessage_t *)calloc(1, sizeof(E2SM_gNB_X2_controlMessage_t));
+  message = (E2N_E2SM_gNB_X2_controlMessage_t *)calloc(1, sizeof(E2N_E2SM_gNB_X2_controlMessage_t));
   assert(message != 0);
 }
   
 e2sm_control::~e2sm_control(void){
-  mdclog_write(MDCLOG_INFO, "Freeing E2SM Control  object memory");
+  mdclog_write(MDCLOG_DEBUG, "Freeing E2SM Control  object memory");
 
   free(gNodeB_ID.gNB_ID.choice.gNB_ID.buf);
   free(gNodeB_ID.pLMN_Identity.buf);
   header->interface_ID.choice.global_gNB_ID = 0;
-  ASN_STRUCT_FREE(asn_DEF_E2SM_gNB_X2_controlHeader, header);
+  ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_controlHeader, header);
 
   message->interfaceMessage.buf = 0;
-  ASN_STRUCT_FREE(asn_DEF_E2SM_gNB_X2_controlMessage, message);
+  ASN_STRUCT_FREE(asn_DEF_E2N_E2SM_gNB_X2_controlMessage, message);
 
-  mdclog_write(MDCLOG_INFO, "Freed E2SM Control  object memory");
+  mdclog_write(MDCLOG_DEBUG, "Freed E2SM Control  object memory");
     
 }
   
@@ -486,7 +514,7 @@ bool e2sm_control::encode_control_header(unsigned char *buf, size_t *size, e2sm_
     return false;
   }
 
-  int ret_constr = asn_check_constraints(&asn_DEF_E2SM_gNB_X2_controlHeader, header, errbuf, &errbuf_len);
+  int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_controlHeader, header, errbuf, &errbuf_len);
   if(ret_constr){
     error_string.assign(&errbuf[0], errbuf_len);
     error_string = "E2SM Control Header Constraint failed : " + error_string;
@@ -494,7 +522,7 @@ bool e2sm_control::encode_control_header(unsigned char *buf, size_t *size, e2sm_
     return false;
   }
 
-  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_controlHeader, header, buf, *size);
+  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_controlHeader, header, buf, *size);
 
   if(retval.encoded == -1){
     error_string.assign(strerror(errno));
@@ -503,7 +531,7 @@ bool e2sm_control::encode_control_header(unsigned char *buf, size_t *size, e2sm_
   }
   else if (retval.encoded > *size){
     std::stringstream ss;
-    ss  <<"Error encoding E2SM Control Header . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
+    ss  <<"Error encoding E2N_E2SM Control Header . Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *size << std::endl;
     error_string = ss.str();
     return false;
   }
@@ -519,14 +547,14 @@ bool e2sm_control::encode_control_message(unsigned char *buf, size_t *size, e2sm
 
   set_message_fields(message, helper); 
 
-  int ret_constr = asn_check_constraints(&asn_DEF_E2SM_gNB_X2_controlMessage, message, errbuf, &errbuf_len);
+  int ret_constr = asn_check_constraints(&asn_DEF_E2N_E2SM_gNB_X2_controlMessage, message, errbuf, &errbuf_len);
   if(ret_constr){
     error_string.assign(&errbuf[0], errbuf_len);
     error_string = "E2SM Control Message Constraint failed : " + error_string;
     return false;
   }
 
-  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2SM_gNB_X2_controlMessage, message, buf, *size);
+  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2N_E2SM_gNB_X2_controlMessage, message, buf, *size);
   if(retval.encoded == -1){
     error_string.assign(strerror(errno));
     error_string = "Error encoding E2SM Control Message. Reason = " + error_string;
@@ -549,7 +577,7 @@ bool e2sm_control::encode_control_message(unsigned char *buf, size_t *size, e2sm
 
 
 // Used when generating an indication header 
-bool e2sm_control::set_header_fields(E2SM_gNB_X2_controlHeader_t *header,  e2sm_header_helper &helper){
+bool e2sm_control::set_header_fields(E2N_E2SM_gNB_X2_controlHeader_t *header,  e2sm_header_helper &helper){
 
   if (header == 0){
     error_string = "Invalid reference for E2SM Control Header set fields";
@@ -558,7 +586,7 @@ bool e2sm_control::set_header_fields(E2SM_gNB_X2_controlHeader_t *header,  e2sm_
   
   
   header->interfaceDirection = helper.interface_direction;
-  header->interface_ID.present = Interface_ID_PR_global_gNB_ID;
+  header->interface_ID.present = E2N_Interface_ID_PR_global_gNB_ID;
   header->interface_ID.choice.global_gNB_ID = &gNodeB_ID;
 
 
@@ -571,7 +599,7 @@ bool e2sm_control::set_header_fields(E2SM_gNB_X2_controlHeader_t *header,  e2sm_
   gNodeB_ID.gNB_ID.choice.gNB_ID.size = 3;
   
   // we only do global gNodeB id for now, not eNodeB
-  gNodeB_ID.gNB_ID.present = GNB_ID_PR_gNB_ID;
+  gNodeB_ID.gNB_ID.present = E2N_GNB_ID_PR_gNB_ID;
 
   return true;
   
@@ -579,7 +607,7 @@ bool e2sm_control::set_header_fields(E2SM_gNB_X2_controlHeader_t *header,  e2sm_
 
 
 // used when decoding an indication header
-bool e2sm_control::get_header_fields(E2SM_gNB_X2_controlHeader_t *header,  e2sm_header_helper &helper){
+bool e2sm_control::get_header_fields(E2N_E2SM_gNB_X2_controlHeader_t *header,  e2sm_header_helper &helper){
 
   if (header == 0){
     error_string = "Invalid reference for E2SM Control header get fields";
@@ -598,7 +626,7 @@ bool e2sm_control::get_header_fields(E2SM_gNB_X2_controlHeader_t *header,  e2sm_
 
 
 // Used when generating an indication message 
-bool   e2sm_control::set_message_fields(E2SM_gNB_X2_controlMessage_t *interface_message,  e2sm_message_helper &helper){
+bool   e2sm_control::set_message_fields(E2N_E2SM_gNB_X2_controlMessage_t *interface_message,  e2sm_message_helper &helper){
 
   if(interface_message == 0){
     error_string = "Invalid reference for E2SM Control Message set fields";
@@ -614,7 +642,7 @@ bool   e2sm_control::set_message_fields(E2SM_gNB_X2_controlMessage_t *interface_
 };
 
 // used when decoding an indication message
-bool e2sm_control::get_message_fields( E2SM_gNB_X2_controlMessage_t *interface_message, e2sm_message_helper &helper){
+bool e2sm_control::get_message_fields( E2N_E2SM_gNB_X2_controlMessage_t *interface_message, e2sm_message_helper &helper){
 
   
   if(interface_message == 0){