X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=e2sim%2Fsrc%2Fencoding%2Fencode_e2apv1.cpp;h=85dae2a77f1fbba3533e0f79216abb5cdc79c0cc;hb=eb80dc1196968a4d34ece42dd1c2e1d31923dec8;hp=6f8c5892391a1d757bcd3293750e1fbc35b6b131;hpb=81cb68102f12ca9ebc9bce56f6e08b02744e66df;p=sim%2Fe2-interface.git

diff --git a/e2sim/src/encoding/encode_e2apv1.cpp b/e2sim/src/encoding/encode_e2apv1.cpp
old mode 100644
new mode 100755
index 6f8c589..85dae2a
--- a/e2sim/src/encoding/encode_e2apv1.cpp
+++ b/e2sim/src/encoding/encode_e2apv1.cpp
@@ -53,6 +53,11 @@ extern "C" {
 #include "RICsubsequentActionType.h"
 #include "RICsubsequentAction.h"  
 #include "RICtimeToWait.h"
+#include "E2nodeComponentInterfaceNG.h"
+// #include "E2nodeComponentGNB-CU-UP-ID.h"
+// #include "E2nodeComponentID.h"
+// #include "E2nodeComponentConfigUpdate.h"
+// #include "E2nodeComponentConfigUpdateGNB.h"
   
 }
 
@@ -60,17 +65,13 @@ long encoding::get_function_id_from_subscription(E2AP_PDU_t *e2ap_pdu) {
 
   RICsubscriptionRequest_t orig_req =
     e2ap_pdu->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
-  
-  RICsubscriptionResponse_IEs_t *ricreqid =
-    (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
-					   
+
   int count = orig_req.protocolIEs.list.count;
   int size = orig_req.protocolIEs.list.size;
   
   RICsubscriptionRequest_IEs_t **ies = (RICsubscriptionRequest_IEs_t**)orig_req.protocolIEs.list.array;
 
-  fprintf(stderr, "count%d\n", count);
-  fprintf(stderr, "size%d\n", size);
+  LOG_I("Number of IEs in original request: %d, size: %d", count, size);
 
   RICsubscriptionRequest_IEs__value_PR pres;
 
@@ -80,17 +81,15 @@ long encoding::get_function_id_from_subscription(E2AP_PDU_t *e2ap_pdu) {
     RICsubscriptionRequest_IEs_t *next_ie = ies[i];
     pres = next_ie->value.present;
     
-    fprintf(stderr, "next present value %d\n", pres);
-    fprintf(stderr, "value of pres ranfuncid is %d\n", RICsubscriptionRequest_IEs__value_PR_RANfunctionID);
+    LOG_D("Next present value: %d, pres RAN func id: %d", pres, RICsubscriptionRequest_IEs__value_PR_RANfunctionID);
 
     if (pres == RICsubscriptionRequest_IEs__value_PR_RANfunctionID) {
-      fprintf(stderr, "equal pres to ranfuncid\n");
+      LOG_E("equal pres to ranfuncid");
       func_id = next_ie->value.choice.RANfunctionID;
     }
-    
   }
 
-  fprintf(stderr, "After loop, func_id is %d\n", func_id);
+  LOG_I("After loop, func_id is %d", func_id);
 
   return func_id;  
 
@@ -98,7 +97,7 @@ long encoding::get_function_id_from_subscription(E2AP_PDU_t *e2ap_pdu) {
 
 void encoding::generate_e2apv1_service_update(E2AP_PDU_t *e2ap_pdu, std::vector<encoding::ran_func_info> all_funcs) {
   char* ran_function_op_type = getenv("RAN_FUNCTION_OP_TYPE");
-  LOG_D("Ran funciton : %s", ran_function_op_type);
+  LOG_D("Ran function : %s", ran_function_op_type);
   ProtocolIE_ID_t prID;
   if (ran_function_op_type != NULL)
   {
@@ -157,9 +156,6 @@ void encoding::generate_e2apv1_service_update(E2AP_PDU_t *e2ap_pdu, std::vector<
 }
 
 void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu, std::vector<ran_func_info> all_funcs) {
-  //						 long ranFunctionId, uint8_t *ranFuncDescEncoded, int ranFuncLength) {
-
-  //  uint8_t *buf = (uint8_t *)"gnb1"
 
   BIT_STRING_t *gnb_bstring = (BIT_STRING_t*)calloc(1, sizeof(BIT_STRING_t));;
   gnb_bstring->buf = (uint8_t*)calloc(1,4);
@@ -181,13 +177,17 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu,
   GNB_ID_Choice_PR pres2 = GNB_ID_Choice_PR_gnb_ID;
   gnbchoice->present = pres2;
   gnbchoice->choice.gnb_ID = *gnb_bstring;
+  if (gnb_bstring) free(gnb_bstring);
 
   GlobalgNB_ID_t *gnb = (GlobalgNB_ID_t*)calloc(1, sizeof(GlobalgNB_ID_t));
   gnb->plmn_id = *plmn;
   gnb->gnb_id = *gnbchoice;
+  if (plmn) free(plmn);
+  if (gnbchoice) free(gnbchoice);
 
   GlobalE2node_gNB_ID_t *e2gnb = (GlobalE2node_gNB_ID_t*)calloc(1, sizeof(GlobalE2node_gNB_ID_t));
   e2gnb->global_gNB_ID = *gnb;
+  if (gnb) free(gnb);
 
   GlobalE2node_ID_t *globale2nodeid = (GlobalE2node_ID_t*)calloc(1, sizeof(GlobalE2node_ID_t));
   GlobalE2node_ID_PR pres;
@@ -202,7 +202,15 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu,
   e2setuprid->criticality = 0;
   e2setuprid->value.choice.GlobalE2node_ID = *globale2nodeid;
   e2setuprid->value.present = pres3;
+  if(globale2nodeid) free(globale2nodeid);
+
 
+  //seting tx id
+  auto *e2txid = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
+  e2txid->id = ProtocolIE_ID_id_TransactionID;
+  e2txid-> criticality = 0;
+  e2txid->value.present = E2setupRequestIEs__value_PR_TransactionID;
+  e2txid->value.choice.TransactionID = 1;
 
   auto *ranFlistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
   ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, ranFlistIEs);
@@ -223,7 +231,7 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu,
     itemIes->criticality = Criticality_reject;
     itemIes->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
     itemIes->value.choice.RANfunction_Item.ranFunctionID = nextRanFuncId;
-
+    itemIes->value.choice.RANfunction_Item.ranFunctionOID = RANfunctionOID_t(*(nextRanFunc.ranFunctionOId));
     int ranFuncLength = strlen((char*)nextRanFuncDesc);
 
     itemIes->value.choice.RANfunction_Item.ranFunctionDefinition = *nextRanFuncDesc;
@@ -233,9 +241,113 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu,
 
   }
 
+auto *e2configIE = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
+e2configIE->id = ProtocolIE_ID_id_E2nodeComponentConfigAddition;
+e2configIE->criticality = Criticality_reject;
+e2configIE->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigAddition_List;
+
+
+auto *e2configAdditionItem = (E2nodeComponentConfigAddition_ItemIEs_t *)calloc(1, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
+e2configAdditionItem->id = ProtocolIE_ID_id_E2nodeComponentConfigAddition_Item;
+e2configAdditionItem->criticality = Criticality_reject;
+e2configAdditionItem->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
+
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_ng;
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeNG;
+
+auto *intfNG = (E2nodeComponentInterfaceNG_t *) calloc(1, sizeof(E2nodeComponentInterfaceNG_t));
+  
+OCTET_STRING_t nginterf;
+nginterf.buf = (uint8_t*)calloc(1,8);
+memcpy(nginterf.buf, (uint8_t *)"nginterf", 8);
+
+nginterf.size = 8;
+intfNG->amf_name = (AMFName_t)(nginterf);
+
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeNG = intfNG;
+
+OCTET_STRING_t reqPart;
+reqPart.buf = (uint8_t*)calloc(1,7);
+memcpy(reqPart.buf, (uint8_t *)"reqpart", 7);
+reqPart.size = 7;
+
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart = reqPart;
+
+OCTET_STRING_t resPart;
+resPart.buf = (uint8_t*)calloc(1,7);
+memcpy(resPart.buf, (uint8_t *)"respart", 7);
+resPart.size = 7;
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart = resPart;
+
+
+ASN_SEQUENCE_ADD(&e2configIE->value.choice.RANfunctions_List.list, e2configAdditionItem);
+/*
+    auto *e2nodeconfigupdatelistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
+  ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, e2nodeconfigupdatelistIEs);
+  e2nodeconfigupdatelistIEs->criticality = 0;
+  e2nodeconfigupdatelistIEs->id = ProtocolIE_ID_id_E2nodeComponentConfigUpdate;
+  e2nodeconfigupdatelistIEs->value.present = E2setupRequestIEs__value_PR_E2nodeComponentConfigUpdate_List;
+
+
+  OCTET_STRING_t *ngAPconfigUpdate =  (OCTET_STRING_t *)calloc(1,sizeof(OCTET_STRING_t));
+  ngAPconfigUpdate->buf = (uint8_t*)calloc(1,13);
+  memcpy(ngAPconfigUpdate->buf, (uint8_t *)"gnbngapupdate", 13);
+  ngAPconfigUpdate->size = 13;
+
+  OCTET_STRING_t *xnAPconfigUpdate =  (OCTET_STRING_t *)calloc(1,sizeof(OCTET_STRING_t));
+  xnAPconfigUpdate->buf = (uint8_t*)calloc(1,13);
+  memcpy(xnAPconfigUpdate->buf, (uint8_t *)"gnbxnapupdate", 13);
+  xnAPconfigUpdate->size = 13;
+
+  OCTET_STRING_t *e1APconfigUpdate =  (OCTET_STRING_t *)calloc(1,sizeof(OCTET_STRING_t));
+  e1APconfigUpdate->buf = (uint8_t*)calloc(1,13);
+  memcpy(e1APconfigUpdate->buf, (uint8_t *)"gnbe1apupdate", 13);
+  e1APconfigUpdate->size = 13;
+
+  OCTET_STRING_t *f1APconfigUpdate =  (OCTET_STRING_t *)calloc(1,sizeof(OCTET_STRING_t));
+  f1APconfigUpdate->buf = (uint8_t*)calloc(1,13);
+  memcpy(f1APconfigUpdate->buf, (uint8_t *)"gnbf1apupdate", 13);
+  f1APconfigUpdate->size = 13;
+
+  E2nodeComponentConfigUpdateGNB_t *e2nodecomponentconfigupdategnb = (E2nodeComponentConfigUpdateGNB_t *)calloc(1,sizeof(E2nodeComponentConfigUpdateGNB_t));
+  e2nodecomponentconfigupdategnb->ngAPconfigUpdate = ngAPconfigUpdate;
+  e2nodecomponentconfigupdategnb->xnAPconfigUpdate = xnAPconfigUpdate;
+  e2nodecomponentconfigupdategnb->e1APconfigUpdate = e1APconfigUpdate;
+  e2nodecomponentconfigupdategnb->f1APconfigUpdate = f1APconfigUpdate;
+
+  E2nodeComponentConfigUpdate_t e2nodecomponentconfigupdate = {};
+  e2nodecomponentconfigupdate.present = E2nodeComponentConfigUpdate_PR_gNBconfigUpdate;
+  e2nodecomponentconfigupdate.choice.gNBconfigUpdate = e2nodecomponentconfigupdategnb;
+
+  GNB_CU_UP_ID_t gnbcuupid = {};
+  gnbcuupid.buf = (uint8_t*)calloc(1,4);
+  memcpy(gnbcuupid.buf, (uint8_t *)"1234", 4);
+  gnbcuupid.size = 4;
+
+  E2nodeComponentGNB_CU_UP_ID_t *e2nodecomponentgnbcuupid = (E2nodeComponentGNB_CU_UP_ID_t *)calloc(1,sizeof(E2nodeComponentGNB_CU_UP_ID_t));
+  e2nodecomponentgnbcuupid->gNB_CU_UP_ID = gnbcuupid;
+
+  E2nodeComponentID_t *e2nodecomponentid = (E2nodeComponentID_t*)calloc(1, sizeof(E2nodeComponentID_t));
+
+  e2nodecomponentid->present = E2nodeComponentID_PR_e2nodeComponentTypeGNB_CU_UP;
+  e2nodecomponentid->choice.e2nodeComponentTypeGNB_CU_UP = e2nodecomponentgnbcuupid;
+
+  auto *configupdateitemIes = (E2nodeComponentConfigUpdate_ItemIEs_t *)calloc(1, sizeof(E2nodeComponentConfigUpdate_ItemIEs_t));
+  configupdateitemIes->id = ProtocolIE_ID_id_E2nodeComponentConfigUpdate_Item;
+  configupdateitemIes->criticality = Criticality_reject;
+  configupdateitemIes->value.present = E2nodeComponentConfigUpdate_ItemIEs__value_PR_E2nodeComponentConfigUpdate_Item;
+  configupdateitemIes->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentType = E2nodeComponentType_gNB_CU_UP;
+  configupdateitemIes->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentID = e2nodecomponentid;
+  configupdateitemIes->value.choice.E2nodeComponentConfigUpdate_Item.e2nodeComponentConfigUpdate = e2nodecomponentconfigupdate;
+
+  ASN_SEQUENCE_ADD(&e2nodeconfigupdatelistIEs->value.choice.E2nodeComponentConfigUpdate_List.list, configupdateitemIes);
+*/
   E2setupRequest_t *e2setupreq = (E2setupRequest_t*)calloc(1, sizeof(E2setupRequest_t));
+  ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2txid);
   ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2setuprid);
   ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, ranFlistIEs);
+  ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2configIE);
+
 
   InitiatingMessage__value_PR pres4;
   pres4 = InitiatingMessage__value_PR_E2setupRequest;
@@ -245,6 +357,7 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu,
   initmsg->criticality = Criticality_reject;
   initmsg->value.present = pres4;
   initmsg->value.choice.E2setupRequest = *e2setupreq;
+  if (e2setupreq) free(e2setupreq);
 
   E2AP_PDU_PR pres5;
   pres5 = E2AP_PDU_PR_initiatingMessage;
@@ -255,7 +368,120 @@ void encoding::generate_e2apv1_setup_request_parameterized(E2AP_PDU_t *e2ap_pdu,
 
 }
 
+void encoding::generate_e2apv2_reset_request(E2AP_PDU *e2ap_pdu) {
+  E2AP_PDU_PR pr = E2AP_PDU_PR_initiatingMessage;
+  e2ap_pdu->present = pr;
+
+  e2ap_pdu->choice.initiatingMessage = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
+  e2ap_pdu->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
+  e2ap_pdu->choice.initiatingMessage->criticality = Criticality_reject;
+
+  e2ap_pdu->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_ResetRequest;
+
+  auto *rrIEs1 = (ResetRequestIEs_t *)calloc(1, sizeof(ResetRequestIEs_t));
+  rrIEs1->id = ProtocolIE_ID_id_Cause;
+  rrIEs1->criticality = Criticality_ignore;
+
+  rrIEs1->value.present = ResetRequestIEs__value_PR_Cause;
+  rrIEs1->value.choice.Cause.present = Cause_PR_e2Node;
+  rrIEs1->value.choice.Cause.choice.ricRequest = CauseE2node_e2node_component_unknown;
+
+  auto *rrIEs2 = (ResetRequestIEs_t *)calloc(1, sizeof(ResetRequestIEs_t));
+  rrIEs2->id = ProtocolIE_ID_id_TransactionID;
+  rrIEs2->criticality = Criticality_ignore;
+  
+  rrIEs2->value.present = ResetRequestIEs__value_PR_TransactionID;
+  rrIEs2->value.choice.TransactionID = 1;
+
+  ASN_SEQUENCE_ADD(&e2ap_pdu->choice.initiatingMessage->value.choice.ResetRequest.protocolIEs.list, rrIEs2);
+  ASN_SEQUENCE_ADD(&e2ap_pdu->choice.initiatingMessage->value.choice.ResetRequest.protocolIEs.list, rrIEs1);
+}
+
+void encoding::generate_e2apv2_reset_response(E2AP_PDU *e2ap_pdu) {
+  e2ap_pdu->present = E2AP_PDU_PR_successfulOutcome;
+  e2ap_pdu->choice.successfulOutcome = (SuccessfulOutcome_t*)calloc(1, sizeof(SuccessfulOutcome));
+
+  e2ap_pdu->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
+  e2ap_pdu->choice.successfulOutcome->criticality = Criticality_ignore;
+
+  e2ap_pdu->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetResponse;
+
+  // auto *rrIEs1 = (ResetResponseIEs_t *)calloc(1, sizeof(ResetResponseIEs_t));
+  // rrIEs1->id = ProtocolIE_ID_id_CriticalityDiagnostics;
+  // rrIEs1->criticality = Criticality_ignore;
+
+  // rrIEs1->value.present = ResetResponseIEs__value_PR_CriticalityDiagnostics;
+  // rrIEs1->value.choice.CriticalityDiagnostics.procedureCode = &ProcedureCode_id_Reset;
+  // rrIEs1->value.choice.CriticalityDiagnostics.choice.ricRequest = CauseE2node_e2node_component_unknown;
+
+  auto *rrIEs2 = (ResetRequestIEs_t *)calloc(1, sizeof(ResetRequestIEs_t));
+  rrIEs2->id = ProtocolIE_ID_id_TransactionID;
+  rrIEs2->criticality = Criticality_ignore;
+  
+  rrIEs2->value.present = ResetRequestIEs__value_PR_TransactionID;
+  rrIEs2->value.choice.TransactionID = 1;
+
+  ASN_SEQUENCE_ADD(&e2ap_pdu->choice.successfulOutcome->value.choice.ResetResponse.protocolIEs.list, rrIEs2);
+}
+
+void encoding::generate_e2apv2_config_update(E2AP_PDU_t *e2ap_pdu){
+ // txid
+ auto *e2txidIE = (E2nodeConfigurationUpdate_IEs_t *)calloc(1, sizeof(E2nodeConfigurationUpdate_IEs_t));
+ e2txidIE->id = ProtocolIE_ID_id_TransactionID;
+ e2txidIE-> criticality = Criticality_reject;
+ e2txidIE->value.present = E2nodeConfigurationUpdate_IEs__value_PR_TransactionID;
+ e2txidIE->value.choice.TransactionID = 1;
+  
+/// config update id for addtion list  
+auto *e2configIE = (E2nodeConfigurationUpdate_IEs_t *)calloc(1, sizeof(E2nodeConfigurationUpdate_IEs_t));
+e2configIE->id = ProtocolIE_ID_id_E2nodeComponentConfigAddition;
+e2configIE->criticality = Criticality_reject;
+e2configIE->value.present = E2nodeConfigurationUpdate_IEs__value_PR_E2nodeComponentConfigAddition_List;
+
+
+auto *e2configAdditionItem = (E2nodeComponentConfigAddition_ItemIEs_t *)calloc(1, sizeof(E2nodeComponentConfigAddition_ItemIEs_t));
+e2configAdditionItem->id = ProtocolIE_ID_id_E2nodeComponentConfigAddition_Item;
+e2configAdditionItem->criticality = Criticality_reject;
+e2configAdditionItem->value.present = E2nodeComponentConfigAddition_ItemIEs__value_PR_E2nodeComponentConfigAddition_Item;
+
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentInterfaceType = E2nodeComponentInterfaceType_ng;
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.present = E2nodeComponentID_PR_e2nodeComponentInterfaceTypeNG;
+
+auto *intfNG = (E2nodeComponentInterfaceNG_t *) calloc(1, sizeof(E2nodeComponentInterfaceNG_t));
+  
+OCTET_STRING_t nginterf;
+nginterf.buf = (uint8_t*)calloc(1,8);
+memcpy(nginterf.buf, (uint8_t *)"nginterf", 8);
+
+nginterf.size = 8;
+intfNG->amf_name = (AMFName_t)(nginterf);
+
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentID.choice.e2nodeComponentInterfaceTypeNG = intfNG;
+
+OCTET_STRING_t reqPart;
+reqPart.buf = (uint8_t*)calloc(1,7);
+memcpy(reqPart.buf, (uint8_t *)"reqpart", 7);
+reqPart.size = 7;
 
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentRequestPart = reqPart;
+
+OCTET_STRING_t resPart;
+resPart.buf = (uint8_t*)calloc(1,7);
+memcpy(resPart.buf, (uint8_t *)"respart", 7);
+resPart.size = 7;
+e2configAdditionItem->value.choice.E2nodeComponentConfigAddition_Item.e2nodeComponentConfiguration.e2nodeComponentResponsePart = resPart;
+
+ASN_SEQUENCE_ADD(&e2configIE->value.choice.E2nodeComponentConfigAddition_List, e2configAdditionItem);
+
+  InitiatingMessage *inititingMsg = (InitiatingMessage *) calloc(1, sizeof(InitiatingMessage));
+  inititingMsg->procedureCode = ProcedureCode_id_E2nodeConfigurationUpdate;
+  inititingMsg->criticality = Criticality_reject;
+  inititingMsg->value.present = InitiatingMessage__value_PR_E2nodeConfigurationUpdate;
+  ASN_SEQUENCE_ADD(&inititingMsg->value.choice.E2nodeConfigurationUpdate.protocolIEs.list, e2txidIE);
+  ASN_SEQUENCE_ADD(&inititingMsg->value.choice.E2nodeConfigurationUpdate.protocolIEs.list, e2configIE);
+  e2ap_pdu->present = E2AP_PDU_PR_initiatingMessage;
+  e2ap_pdu->choice.initiatingMessage = inititingMsg;
+}
 
 void encoding::generate_e2apv1_setup_response(E2AP_PDU_t *e2ap_pdu) {
 
@@ -410,8 +636,8 @@ void encoding::generate_e2apv1_subscription_request(E2AP_PDU *e2ap_pdu) {
   e2ap_pdu->present = pres5;
   e2ap_pdu->choice.initiatingMessage = initmsg;
 
-  char *error_buf = (char*)calloc(300, sizeof(char));;
-  size_t errlen;
+  char error_buf[300] = {0, };
+  size_t errlen = 0;
 									  
   asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
   printf("error length %d\n", errlen);
@@ -439,7 +665,7 @@ void encoding::generate_e2apv1_subscription_response_success(E2AP_PDU *e2ap_pdu,
   respfuncid->id = ProtocolIE_ID_id_RANfunctionID;
   respfuncid->criticality = 0;
   respfuncid->value.present = RICsubscriptionResponse_IEs__value_PR_RANfunctionID;
-  respfuncid->value.choice.RANfunctionID = (long)0;
+  respfuncid->value.choice.RANfunctionID = (long)147;
   
 
   RICsubscriptionResponse_IEs_t *ricactionadmitted =
@@ -451,6 +677,7 @@ void encoding::generate_e2apv1_subscription_response_success(E2AP_PDU *e2ap_pdu,
   RICaction_Admitted_List_t* admlist = 
     (RICaction_Admitted_List_t*)calloc(1,sizeof(RICaction_Admitted_List_t));
   ricactionadmitted->value.choice.RICaction_Admitted_List = *admlist;
+  if (admlist) free(admlist);
 
 
   int numAccept = accept_size;
@@ -515,24 +742,20 @@ void encoding::generate_e2apv1_subscription_response_success(E2AP_PDU *e2ap_pdu,
   successoutcome->criticality = 0;
   successoutcome->value.present = pres2;
   successoutcome->value.choice.RICsubscriptionResponse = *ricsubresp;
+  if (ricsubresp) free(ricsubresp);
 
   E2AP_PDU_PR pres5 = E2AP_PDU_PR_successfulOutcome;
   
   e2ap_pdu->present = pres5;
   e2ap_pdu->choice.successfulOutcome = successoutcome;
 
-  char *error_buf = (char*)calloc(300, sizeof(char));
-  size_t errlen;
+  char error_buf[300] = {0, };
+  size_t errlen = 0;
 
   asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
-  printf("error length %d\n", errlen);
-  printf("error buf %s\n", error_buf);
 
-  printf("now printing xer of subscription response\n");
-  xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu);
-  printf("done printing xer of subscription response\n");  
-
-  
+  LOG_I("Subscription response");
+  xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu); 
 }
 
 void encoding::generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PDU *sub_req_pdu) {
@@ -550,8 +773,7 @@ void encoding::generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PD
   
   RICsubscriptionRequest_IEs_t **ies = (RICsubscriptionRequest_IEs_t**)orig_req.protocolIEs.list.array;
 
-  fprintf(stderr, "count%d\n", count);
-  fprintf(stderr, "size%d\n", size);
+  LOG_I("Number of IEs in original request: %d, size: %d", count, size);
 
   RICsubscriptionRequest_IEs__value_PR pres;
 
@@ -565,61 +787,49 @@ void encoding::generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PD
     RICsubscriptionRequest_IEs_t *next_ie = ies[i];
     pres = next_ie->value.present;
     
-    fprintf(stderr, "next present value %d\n", pres);
+    LOG_D("Next present value %d", pres);
 
     switch(pres) {
     case RICsubscriptionRequest_IEs__value_PR_RICrequestID:
       {
-	RICrequestID_t reqId = next_ie->value.choice.RICrequestID;
-	long requestorId = reqId.ricRequestorID;
-	long instanceId = reqId.ricInstanceID;
-	fprintf(stderr, "requestorId %d\n", requestorId);
-	fprintf(stderr, "instanceId %d\n", instanceId);
-	responseRequestorId = requestorId;
-	responseInstanceId = instanceId;
-		
-	break;
+        RICrequestID_t reqId = next_ie->value.choice.RICrequestID;
+        long requestorId = reqId.ricRequestorID;
+        long instanceId = reqId.ricInstanceID;
+
+        LOG_I("RequestorId %d, InstanceId: %d", requestorId, instanceId);
+        
+        responseRequestorId = requestorId;
+        responseInstanceId = instanceId;
+	      break;
       }
     case RICsubscriptionRequest_IEs__value_PR_RANfunctionID:
       break;
     case RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails:
       {
-	RICsubscriptionDetails_t subDetails = next_ie->value.choice.RICsubscriptionDetails; 
-	RICeventTriggerDefinition_t triggerDef = subDetails.ricEventTriggerDefinition;
-	RICactions_ToBeSetup_List_t actionList = subDetails.ricAction_ToBeSetup_List;
-	
-	int actionCount = actionList.list.count;
-	fprintf(stderr, "action count%d\n", actionCount);
-
-	auto **item_array = actionList.list.array;
-
-	for (int i=0; i < actionCount; i++) {
-	  //RICaction_ToBeSetup_Item_t
-	  auto *next_item = item_array[i];
-	  RICactionID_t actionId = ((RICaction_ToBeSetup_ItemIEs*)next_item)->value.choice.RICaction_ToBeSetup_Item.ricActionID;
-	  fprintf(stderr, "Next Action ID %ld\n", actionId);
-	  responseActionId = actionId;
-	  actionIds.push_back(responseActionId);
-	}
-	
-	break;
+        RICsubscriptionDetails_t subDetails = next_ie->value.choice.RICsubscriptionDetails; 
+        RICeventTriggerDefinition_t triggerDef = subDetails.ricEventTriggerDefinition;
+        RICactions_ToBeSetup_List_t actionList = subDetails.ricAction_ToBeSetup_List;
+        
+        int actionCount = actionList.list.count;
+        LOG_I("Action count%d", actionCount);
+
+        auto **item_array = actionList.list.array;
+
+        for (int i=0; i < actionCount; i++) {
+          //RICaction_ToBeSetup_Item_t
+          auto *next_item = item_array[i];
+          RICactionID_t actionId = ((RICaction_ToBeSetup_ItemIEs*)next_item)->value.choice.RICaction_ToBeSetup_Item.ricActionID;
+          LOG_D("Next Action ID %ld", actionId);
+          responseActionId = actionId;
+          actionIds.push_back(responseActionId);
+        }
+        
+        break;
       }
     }
     
   }
 
-  fprintf(stderr, "After Processing Subscription Request\n");
-
-  fprintf(stderr, "requestorId %d\n", responseRequestorId);
-  fprintf(stderr, "instanceId %d\n", responseInstanceId);
-
-
-  for (int i=0; i < actionIds.size(); i++) {
-    fprintf(stderr, "Action ID %d %ld\n", i, actionIds.at(i));
-    
-  }
-
-
   RICsubscriptionResponse_IEs_t *respricreqid =
     (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
   
@@ -630,7 +840,6 @@ void encoding::generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PD
   
   respricreqid->value.choice.RICrequestID.ricInstanceID = responseInstanceId;
 
-
   RICsubscriptionResponse_IEs_t *ricactionadmitted =
     (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
   ricactionadmitted->id = ProtocolIE_ID_id_RICactions_Admitted;
@@ -642,8 +851,6 @@ void encoding::generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PD
   ricactionadmitted->value.choice.RICaction_Admitted_List = *admlist;
 
   for (int i=0; i < actionIds.size(); i++) {
-    fprintf(stderr, "in for loop i = %d\n", i);
-
     long aid = actionIds.at(i);
 
     RICaction_Admitted_ItemIEs_t *admitie = (RICaction_Admitted_ItemIEs_t*)calloc(1,sizeof(RICaction_Admitted_ItemIEs_t));
@@ -656,7 +863,6 @@ void encoding::generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PD
 
   }
 
-
   RICsubscriptionResponse_t *ricsubresp = (RICsubscriptionResponse_t*)calloc(1,sizeof(RICsubscriptionResponse_t));
   
   ASN_SEQUENCE_ADD(&ricsubresp->protocolIEs.list, respricreqid);
@@ -676,15 +882,10 @@ void encoding::generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PD
   e2ap_pdu->present = pres5;
   e2ap_pdu->choice.successfulOutcome = successoutcome;
 
-  char *error_buf = (char*)calloc(300, sizeof(char));
-  size_t errlen;
+  char error_buf[300] = {0, };
+  size_t errlen = 0;
 
   asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
-  printf("error length %d\n", errlen);
-  printf("error buf %s\n", error_buf);
-
-
-  
 }
 
 void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_pdu,
@@ -698,7 +899,8 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p
 								uint8_t *ind_message_buf,
 								int message_length) {
   
-  fprintf(stderr, "ind1\n");
+  LOG_I("Initializing E2AP request");
+
   RICindication_IEs_t *ricind_ies = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
   RICindication_IEs_t *ricind_ies2 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
   RICindication_IEs_t *ricind_ies3 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
@@ -717,8 +919,6 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p
   ricind_ies->value.choice.RICrequestID.ricRequestorID = requestorId;
   ricind_ies->value.choice.RICrequestID.ricInstanceID = instanceId;
 
-  fprintf(stderr, "ind2\n");
-
   pres3 = RICindication_IEs__value_PR_RANfunctionID;
   ricind_ies2->id = ProtocolIE_ID_id_RANfunctionID;
   ricind_ies2->criticality = 0;
@@ -746,16 +946,6 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p
   ricind_ies5->value.present = pres3;
   ricind_ies5->value.choice.RICindicationType = 0;
 
-
-  uint8_t *buf2 = (uint8_t *)"reportheader";
-  OCTET_STRING_t *hdr_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
-
-  hdr_str->buf = (uint8_t*)calloc(1,header_length);
-  hdr_str->size = header_length;
-  memcpy(hdr_str->buf, ind_header_buf, header_length);
-
-  fprintf(stderr, "ind3\n");
-
   ricind_ies6->value.choice.RICindicationHeader.buf = (uint8_t*)calloc(1,header_length);
 
   pres3 = RICindication_IEs__value_PR_RICindicationHeader;
@@ -768,30 +958,19 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p
   ricind_ies7->value.choice.RICindicationMessage.buf = (uint8_t*)calloc(1,8192);
 
 
-  
-
   pres3 = RICindication_IEs__value_PR_RICindicationMessage;
   ricind_ies7->id = ProtocolIE_ID_id_RICindicationMessage;
-  fprintf(stderr, "after encoding message 1\n");
 
   ricind_ies7->criticality = 0;
   ricind_ies7->value.present = pres3;
 
-  fprintf(stderr, "after encoding message 2\n");
-
-  fprintf(stderr, "after encoding message 3\n");      
   ricind_ies7->value.choice.RICindicationMessage.size = message_length;
 
-  fprintf(stderr, "after encoding message 4\n");
   memcpy(ricind_ies7->value.choice.RICindicationMessage.buf, ind_message_buf, message_length);
 
-  fprintf(stderr, "after encoding message 5\n");
-
   uint8_t *cpid_buf = (uint8_t *)"cpid";
   OCTET_STRING_t cpid_str;
 
-  printf("5.1\n");
-
   int cpid_buf_len = strlen((char*)cpid_buf);
   pres3 = RICindication_IEs__value_PR_RICcallProcessID;
   ricind_ies8->id = ProtocolIE_ID_id_RICcallProcessID;
@@ -804,39 +983,16 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p
 
   memcpy(ricind_ies8->value.choice.RICcallProcessID.buf, cpid_buf, cpid_buf_len);
 
-  printf("5.2\n");
-
   RICindication_t *ricindication = (RICindication_t*)calloc(1, sizeof(RICindication_t));
 
-  
-  int ret;
-
-  ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies);
-  
-  ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies2);
-
-  printf("5.3\n");
-
-  ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies3);
-
-  printf("5.35\n");
-  
-  ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies4);
-
-  printf("5.36\n");
-  
-  ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies5);
-
-  printf("5.4\n");
-  
-  ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies6);
-
-  printf("5.5\n");
-
-  ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies7);  
-  
-  ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies8);    
-
+  ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies);
+  ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies2);
+  ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies3);
+  ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies4);
+  ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies5);
+  ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies6);
+  ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies7);  
+  ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies8);    
 
   InitiatingMessage__value_PR pres4;
   pres4 = InitiatingMessage__value_PR_RICindication;
@@ -845,22 +1001,19 @@ void encoding::generate_e2apv1_indication_request_parameterized(E2AP_PDU *e2ap_p
   initmsg->criticality = 1;
   initmsg->value.present = pres4;
   initmsg->value.choice.RICindication = *ricindication;
+  if (ricindication) free(ricindication);
 
   E2AP_PDU_PR pres5;
   pres5 = E2AP_PDU_PR_initiatingMessage;
   
   e2ap_pdu->present = pres5;
   e2ap_pdu->choice.initiatingMessage = initmsg;
+  char error_buf[300] = {0, };
+  size_t errlen = 0;
 
-  char *error_buf = (char*)calloc(300, sizeof(char));
-  size_t errlen;
-
-  asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
-  printf("error length %d\n", errlen);
-  printf("error buf %s\n", error_buf);
-
-  xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu);  
-
-}
-
+  int ret = asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
 
+  if(ret) {
+    LOG_I("Constraint validation of E2AP PDU message failed: %s\n", error_buf);
+  }
+}
\ No newline at end of file