diff --git a/e2sm/wrapper.c b/e2sm/wrapper.c
new file mode 100644
index 0000000..7704746
--- /dev/null
+++ b/e2sm/wrapper.c
@@ -0,0 +1,1051 @@
+#include <errno.h>
+#include "wrapper.h"
+#include <stdio.h>
+
+/*
+static int write_out(const void *buffer, size_t size, void *app_key) {
+ FILE *out_fp = app_key;
+ size_t wrote = fwrite(buffer, 1, size, out_fp);
+ return (wrote == size) ? 0 :-1;
+}
+*/
+ranCellUeKpi_t buildRanCellUeKpi(const char *hex_values){
+ int BUFFER_SIZE=10240;
+ // Calculate the length of the hex string
+ size_t hex_len = strlen(hex_values);
+
+ // Allocate memory for a char array to store the hex values
+ char *hex_buffer = (char *)malloc(hex_len / 2 + 1); // Each byte is represented by 2 characters, +1 for null terminator
+ ranCellUeKpi_t res;
+ if (hex_buffer == NULL) {
+ fprintf(stderr, "Memory allocation failed\n");
+ return res;
+ }
+
+ // Convert the hex string to binary data
+ for (size_t i = 0; i < hex_len; i += 2) {
+ char byte[3] = {hex_values[i], hex_values[i + 1], '\0'};
+ hex_buffer[i / 2] = (char)strtol(byte, NULL, 16);
+ }
+
+ // Null-terminate the char array
+ hex_buffer[hex_len / 2] = '\0';
+
+ // Now hex_buffer contains the binary data corresponding to the hex values
+
+ // Print the result
+ printf("Hex values as a string: %s\n", hex_buffer);
+ char **name_format1;
+ char **name_format3;
+ int sz1=0;
+ int sz3=0;
+
+ E2SM_KPM_RANfunction_Description_t * e2smKpmRanFunctDescrip=(E2SM_KPM_RANfunction_Description_t * )calloc(1,sizeof(E2SM_KPM_RANfunction_Description_t ));
+
+ enum asn_transfer_syntax syntax;
+
+ syntax = ATS_ALIGNED_BASIC_PER;
+
+ asn_dec_rval_t rval = asn_decode(NULL, syntax, &asn_DEF_E2SM_KPM_RANfunction_Description, (void**)&e2smKpmRanFunctDescrip, hex_buffer, hex_len);
+
+ if(rval.code == RC_OK)
+ {
+ printf( "[INFO] E2SM KPM RAN Function Description decode successfull rval.code = %d \n",rval.code);
+
+ //asn_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, e2smKpmRanFunctDescrip);
+
+ for(int i=0; i< e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.count; i++){
+
+ if(e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->ric_ActionFormat_Type==1){
+ sz1=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.count;
+ name_format1=(char **)malloc(sz1*sizeof(char *));
+ for(int j=0;j<sz1;j++){
+ size_t bufsize=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measName.size;
+ name_format1[j]=(char*)malloc(bufsize);
+ name_format1[j]=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measName.buf;
+
+ }
+
+ }
+
+ if(e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->ric_ActionFormat_Type==3){
+ sz3=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.count;
+ name_format3=(char **)malloc(sz3*sizeof(char *));
+ for(int j=0;j<sz3;j++){
+ size_t bufsize=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measName.size;
+ name_format3[j]=(char*)malloc(bufsize);
+ name_format3[j]=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measName.buf;
+
+ }
+
+ }
+
+
+
+ }
+
+
+ }
+ else
+ {
+ printf("[INFO] E2SM KPM RAN Function Description decode failed rval.code = %d \n", rval.code);
+ }
+
+ res.ueKpi=name_format3;
+ res.cellKpi=name_format1;
+ res.ueKpiSize= sz3;
+ res.cellKpiSize= sz1 ;
+ return res;
+
+}
+void freeMemorydRanCellUeKpi(ranCellUeKpi_t res){
+ if (res.cellKpi !=NULL ){
+
+ for(int i=0; i<res.cellKpiSize;i++){
+ free(res.cellKpi[i]);
+ }
+
+ free(res.cellKpi);
+ }
+
+ if(res.ueKpi!=NULL){
+ for(int i=0; i<res.ueKpiSize;i++){
+ free(res.ueKpi[i]);
+ }
+ free(res.ueKpi);
+ }
+
+
+
+}
+//determine
+//1 for format1 by id, 2 for format1 by name , 3 for format3 by id, 4 for format3 by name
+struct encode_act_Def_result encode_action_Definition(const char *hex_values, int determine){
+
+ encode_act_Def_result_t res;
+ int BUFFER_SIZE=10240;
+ // Calculate the length of the hex string
+ size_t hex_len = strlen(hex_values);
+
+ // Allocate memory for a char array to store the hex values
+ char *hex_buffer = (char *)malloc(hex_len / 2 + 1); // Each byte is represented by 2 characters, +1 for null terminator
+
+ if (hex_buffer == NULL) {
+ fprintf(stderr, "Memory allocation failed\n");
+ return res;
+ }
+
+ // Convert the hex string to binary data
+ for (size_t i = 0; i < hex_len; i += 2) {
+ char byte[3] = {hex_values[i], hex_values[i + 1], '\0'};
+ hex_buffer[i / 2] = (char)strtol(byte, NULL, 16);
+ }
+
+ // Null-terminate the char array
+ hex_buffer[hex_len / 2] = '\0';
+
+ // Now hex_buffer contains the binary data corresponding to the hex values
+
+ // Print the result
+ printf("Hex values as a string: %s\n", hex_buffer);
+
+ long *id_format1;
+ long *id_format3;
+ char **name_format1;
+ char **name_format3;
+ int sz1=0;
+ int sz3=0;
+
+ E2SM_KPM_RANfunction_Description_t * e2smKpmRanFunctDescrip=(E2SM_KPM_RANfunction_Description_t * )calloc(1,sizeof(E2SM_KPM_RANfunction_Description_t ));
+
+ enum asn_transfer_syntax syntax;
+
+ syntax = ATS_ALIGNED_BASIC_PER;
+
+ asn_dec_rval_t rval = asn_decode(NULL, syntax, &asn_DEF_E2SM_KPM_RANfunction_Description, (void**)&e2smKpmRanFunctDescrip, hex_buffer, hex_len);
+
+ if(rval.code == RC_OK)
+ {
+ printf( "[INFO] E2SM KPM RAN Function Description decode successfull rval.code = %d \n",rval.code);
+
+ //asn_fprint(stdout, &asn_DEF_E2SM_KPM_RANfunction_Description, e2smKpmRanFunctDescrip);
+
+ for(int i=0; i< e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.count; i++){
+
+ if(e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->ric_ActionFormat_Type==1){
+ sz1=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.count;
+ id_format1=(long *)calloc(sz1,sizeof(long));
+ name_format1=(char **)malloc(sz1*sizeof(char *));
+ for(int j=0;j<sz1;j++){
+ id_format1[j]=*(e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measID);
+ size_t bufsize=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measName.size;
+ name_format1[j]=(char*)malloc(bufsize);
+ name_format1[j]=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measName.buf;
+
+ }
+
+ }
+
+ if(e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->ric_ActionFormat_Type==3){
+ sz3=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.count;
+ id_format3=(long *)calloc(sz3,sizeof(long));
+ name_format3=(char **)malloc(sz3*sizeof(char *));
+ for(int j=0;j<sz3;j++){
+ id_format3[j]=*(e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measID);
+ size_t bufsize=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measName.size;
+ name_format3[j]=(char*)malloc(bufsize);
+ name_format3[j]=e2smKpmRanFunctDescrip->ric_ReportStyle_List->list.array[i]->measInfo_Action_List.list.array[j]->measName.buf;
+
+ }
+
+ }
+
+
+
+ }
+
+
+ }
+ else
+ {
+ printf("[INFO] E2SM KPM RAN Function Description decode failed rval.code = %d \n", rval.code);
+ }
+ printf("\n");
+ printf("measID format 1\n");
+ for(int i=0;i<sz1;i++){
+ printf("%ld, ",id_format1[i]);
+ }
+ printf("\n");
+ printf("measName format 1\n");
+ for(int i=0;i<sz1;i++){
+ printf("%s, ",name_format1[i]);
+ }
+ printf("\n");
+ printf("measID format 3\n");
+ for(int i=0;i<sz3;i++){
+ printf("%ld, ",id_format3[i]);
+ }
+ printf("\n");
+ printf("measName format 3\n");
+ for(int i=0;i<sz3;i++){
+ printf("%s, ",name_format3[i]);
+ }
+
+
+ unsigned char bufFormat3[BUFFER_SIZE];
+ size_t buf_sizeFormat3 = BUFFER_SIZE;
+
+ long ricStyleTypeFormat3 = 3;
+ unsigned long granulPeriod = 10000;
+
+ int encodedLengthFormat3ByName = e2sm_encode_ric_action_definition_format3_by_name(&bufFormat3[0], &buf_sizeFormat3, name_format3, sz3, ricStyleTypeFormat3, granulPeriod);
+ printf("length of buff= %ld \n",strlen(bufFormat3));
+ printf("size of buff= %ld \n",sizeof(bufFormat3));
+ printf("declared size of buff= %ld \n",BUFFER_SIZE);
+ printf("encoded length of buff= %ld \n",encodedLengthFormat3ByName);
+ int arrayFormat3ByName[encodedLengthFormat3ByName];
+ for(int i=0;i<encodedLengthFormat3ByName;i++){
+ //printf("%d ",(int)bufFormat3[i]);
+ arrayFormat3ByName[i]=(int)bufFormat3[i];
+ }
+
+ unsigned char bufFormat1[BUFFER_SIZE];
+ size_t buf_sizeFormat1 = BUFFER_SIZE;
+
+ long ricStyleTypeFormat1 = 1;
+ //unsigned long granulPeriod = 10000;
+
+ //get plmn id during run time of kpimon
+ unsigned char p[] = {0x00, 0x1F, 0x01};
+
+ //get nr cell id for 5g cell or eutra cell id for 4g cell
+ unsigned char nR []= {0x12, 0x34, 0x56, 0x00, 0x10};
+
+ int encodedLengthFormat1ByName = e2sm_encode_ric_action_definition_format1_by_name(&bufFormat1[0], &buf_sizeFormat1, name_format1, sz1, ricStyleTypeFormat1, granulPeriod, p, nR);
+ printf("\n\n\n");
+ int arrayFormat1ByName[encodedLengthFormat1ByName];
+ for(int i=0;i<encodedLengthFormat1ByName;i++){
+ //printf("%d ",(int)bufFormat1[i]);
+ arrayFormat1ByName[i]=(int)bufFormat1[i];
+ }
+
+ unsigned char bufFormat1ById[BUFFER_SIZE];
+ size_t buf_sizeFormat1ById = BUFFER_SIZE;
+
+ int encodedLengthFormat1ById = e2sm_encode_ric_action_definition_format1_by_id(&bufFormat1ById[0], &buf_sizeFormat1ById, id_format1, sz1, ricStyleTypeFormat1, granulPeriod, p, nR);
+ printf("\n\n\n");
+ int arrayFormat1ById[encodedLengthFormat1ById];
+ for(int i=0;i<encodedLengthFormat1ById;i++){
+ //printf("%d ",(int)bufFormat1ById[i]);
+ arrayFormat1ById[i]=(int)bufFormat1ById[i];
+ }
+
+ unsigned char bufFormat3ById[BUFFER_SIZE];
+ size_t buf_sizeFormat3ById = BUFFER_SIZE;
+
+ int encodedLengthFormat3ById = e2sm_encode_ric_action_definition_format3_by_id(&bufFormat3ById[0], &buf_sizeFormat3ById, id_format3, sz3, ricStyleTypeFormat3, granulPeriod);
+ printf("\n\n\n");
+ int arrayFormat3ById[encodedLengthFormat3ById];
+ for(int i=0;i<encodedLengthFormat3ById;i++){
+ //printf("%d ",(int)bufFormat3ById[i]);
+ arrayFormat3ById[i]=(int)bufFormat3ById[i];
+
+ }
+
+
+
+
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_RANfunction_Description, e2smKpmRanFunctDescrip);
+
+
+
+ // Don't forget to free the allocated memory when done
+ /*
+ free(hex_buffer);
+
+ free(id_format1);
+ free(id_format3);
+ for(int i=0; i<sz1;i++){
+ free(name_format1[i]);
+ }
+ free(name_format1);
+
+
+ for(int i=0; i<sz3;i++){
+ free(name_format3[i]);
+ }
+ */
+ free(name_format3);
+ switch(determine){
+ case 1:
+ res.array=arrayFormat1ById;
+ res.length=encodedLengthFormat1ById-8;//removing hardcoded plmn and cellid
+ return res;
+ case 2:
+ res.array=arrayFormat1ByName;
+ res.length=encodedLengthFormat1ByName-8;//removing hardcoded plmn and cellid
+ return res;
+ case 3:
+ res.array=arrayFormat3ById;
+ res.length=encodedLengthFormat3ById;
+ return res;
+ case 4:
+ res.array=arrayFormat3ByName;
+ res.length=encodedLengthFormat3ByName;
+ return res;
+ break;
+
+ }
+ return res;
+
+
+
+}
+size_t e2sm_encode_ric_action_definition_format1_by_name(unsigned char *buf, size_t *buf_size, const char **id_tmp , size_t measIdcount, long ric_style_type, unsigned long granulPeriod, unsigned char *p, unsigned char *nR) {
+ E2SM_KPM_ActionDefinition_t *actionDef = (E2SM_KPM_ActionDefinition_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_t));
+ if (!actionDef) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ E2SM_KPM_ActionDefinition_Format1_t *actionDefFor1 = (E2SM_KPM_ActionDefinition_Format1_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_Format1_t));
+ if (!actionDefFor1) {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+ CGI_t *cellGlobal = (CGI_t *)calloc(1, sizeof(CGI_t));
+ if (!cellGlobal) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ NR_CGI_t *nrCGIs = (NR_CGI_t *)calloc(1, sizeof(NR_CGI_t));
+ if (!nrCGIs) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+
+ PLMNIdentity_t *PLM=(PLMNIdentity_t *)calloc(1,sizeof(PLMNIdentity_t));
+ PLM->buf=(uint8_t *)calloc(3,sizeof(uint8_t));
+ memcpy(PLM->buf,p, 3);
+ PLM->size=3;
+
+
+ NRCellIdentity_t *NRC=(NRCellIdentity_t *)calloc(1,sizeof(NRCellIdentity_t));
+ NRC->buf=(uint8_t *)calloc(5,sizeof(uint8_t));
+ memcpy(NRC->buf,nR, 5);
+ NRC->size=5;
+ NRC->bits_unused=4;
+
+ nrCGIs->pLMNIdentity=*PLM;
+ nrCGIs->nRCellIdentity=*NRC;
+
+ cellGlobal->present = CGI_PR_nR_CGI;
+ cellGlobal->choice.nR_CGI = nrCGIs;
+
+
+
+
+ MeasurementInfoItem_t **infoItem = (MeasurementInfoItem_t **)calloc(measIdcount, sizeof(MeasurementInfoItem_t *));
+ int Label_Item_count=1;
+
+ long *no_label=(long *) calloc(1,sizeof(long));//not giving label to the cell metrics/// don't know its bheaviour
+ *no_label=0;
+ int index = 0;
+ int c=0;
+ while (index < measIdcount) {
+
+ infoItem[index] = (MeasurementInfoItem_t *)calloc(1, sizeof(MeasurementInfoItem_t ));
+ MeasurementType_t *Mtype=(MeasurementType_t *)calloc(1,sizeof(MeasurementType_t));
+ Mtype->present=MeasurementType_PR_measName;
+ Mtype->choice.measName.buf=(uint8_t *)calloc(strlen(id_tmp[index]),sizeof(uint8_t));
+ memcpy(Mtype->choice.measName.buf,id_tmp[index], strlen(id_tmp[index]));
+ Mtype->choice.measName.size=strlen(id_tmp[index]);
+
+
+ infoItem[index]->measType=*Mtype;
+
+
+ LabelInfoItem_t **L_Item = (LabelInfoItem_t **)calloc(Label_Item_count, sizeof(LabelInfoItem_t *));
+ MeasurementLabel_t *M_Label=(MeasurementLabel_t *)calloc(1,sizeof(MeasurementLabel_t));
+ M_Label->noLabel=no_label;
+ L_Item[0] = (LabelInfoItem_t *)calloc(1, sizeof(LabelInfoItem_t ));
+ L_Item[0]->measLabel=*M_Label;
+ int result1 = ASN_SEQUENCE_ADD(&infoItem[index]->labelInfoList, L_Item[0]);
+ if (result1==-1)
+ {
+ fprintf(stderr,"Unable to assign memory to add labelInfoList %s",strerror(errno));
+ return -1;
+ }
+
+ int result2 = ASN_SEQUENCE_ADD(&actionDefFor1->measInfoList, infoItem[index]);
+ if (result2==-1)
+ {
+ fprintf(stderr,"Unable to assign memory to add measInfoList %s",strerror(errno));
+ return -1;
+ }
+
+
+ index++;
+ }
+
+
+ actionDefFor1->granulPeriod = granulPeriod;
+ actionDefFor1->cellGlobalID = cellGlobal;
+
+
+ actionDef->ric_Style_Type = ric_style_type;
+ actionDef->actionDefinition_formats.present = E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1;
+ actionDef->actionDefinition_formats.choice.actionDefinition_Format1 = actionDefFor1;
+
+
+ char errbuf[128];
+ size_t errbuf_len = 128;
+
+ int ret_constr = asn_check_constraints(&asn_DEF_E2SM_KPM_ActionDefinition, (void *) actionDef, errbuf, &errbuf_len);
+ if(ret_constr){
+ fprintf(stderr,"Constraints failed for encoding subscription request, %s", strerror(errno));
+ return -1;
+ }
+ //ATS_ALIGNED_BASIC_PER
+ //ATS_ALIGNED_CANONICAL_PER
+ //ATS_DER
+ asn_enc_rval_t encode_result = asn_encode_to_buffer(0,ATS_ALIGNED_CANONICAL_PER,&asn_DEF_E2SM_KPM_ActionDefinition,actionDef, buf, *buf_size);
+ //asn_enc_rval_t encode_result = uper_encode_to_buffer(&asn_DEF_E2SM_KPM_ActionDefinition, NULL,actionDef, buf, *buf_size);
+ if (encode_result.encoded == -1) {
+ fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
+ return -1;
+ }
+ else {
+ fprintf(stderr, "successfully\n");
+ //xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ /*
+ FILE *fp = fopen("sandeep.bin", "wb");
+
+ asn_enc_rval_t ec =asn_encode(0, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_E2SM_KPM_ActionDefinition, actionDef, write_out, fp);
+ fclose(fp);
+ if(ec.encoded ==-1) {
+ fprintf(stderr, "Could not encode action def (at %s)\n”,ec.failed_type ? ec.failed_type->name : ”unknown");
+ // exit(1);
+ } else {
+ fprintf(stderr, "Created sandeep binary with ATS_ALIGNED_CANONICAL_PER encoded action def\n");
+ }
+ FILE *fp2 = fopen("sandy.txt", "w");
+ int r=asn_fprint(fp2,&asn_DEF_E2SM_KPM_ActionDefinition,actionDef);
+ fclose(fp2);
+ if (r==-1)
+ fprintf(stderr, "failed asn_fprint\n");
+ else
+ fprintf(stderr, "successfull asn_fprint\n");
+ */
+
+
+
+ return encode_result.encoded;
+ }
+}
+
+size_t e2sm_encode_ric_action_definition_format1_by_id(unsigned char *buf, size_t *buf_size, long *id , size_t measIdcount, long ric_style_type, unsigned long granulPeriod, unsigned char *p, unsigned char *nR) {
+ E2SM_KPM_ActionDefinition_t *actionDef = (E2SM_KPM_ActionDefinition_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_t));
+ if (!actionDef) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ E2SM_KPM_ActionDefinition_Format1_t *actionDefFor1 = (E2SM_KPM_ActionDefinition_Format1_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_Format1_t));
+ if (!actionDefFor1) {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+ CGI_t *cellGlobal = (CGI_t *)calloc(1, sizeof(CGI_t));
+ if (!cellGlobal) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ NR_CGI_t *nrCGIs = (NR_CGI_t *)calloc(1, sizeof(NR_CGI_t));
+ if (!nrCGIs) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+
+ PLMNIdentity_t *PLM=(PLMNIdentity_t *)calloc(1,sizeof(PLMNIdentity_t));
+ PLM->buf=(uint8_t *)calloc(3,sizeof(uint8_t));
+ memcpy(PLM->buf,p, 3);
+ PLM->size=3;
+
+
+ NRCellIdentity_t *NRC=(NRCellIdentity_t *)calloc(1,sizeof(NRCellIdentity_t));
+ NRC->buf=(uint8_t *)calloc(5,sizeof(uint8_t));
+ memcpy(NRC->buf,nR, 5);
+ NRC->size=5;
+ NRC->bits_unused=4;
+
+ nrCGIs->pLMNIdentity=*PLM;
+ nrCGIs->nRCellIdentity=*NRC;
+
+ cellGlobal->present = CGI_PR_nR_CGI;
+ cellGlobal->choice.nR_CGI = nrCGIs;
+
+
+
+
+ MeasurementInfoItem_t **infoItem = (MeasurementInfoItem_t **)calloc(measIdcount, sizeof(MeasurementInfoItem_t *));
+ int Label_Item_count=1;
+
+ long *no_label=(long *) calloc(1,sizeof(long));//not giving label to the cell metrics/// don't know its bheaviour
+ *no_label=0;
+ int index = 0;
+ while (index < measIdcount) {
+
+ infoItem[index] = (MeasurementInfoItem_t *)calloc(1, sizeof(MeasurementInfoItem_t ));
+ MeasurementType_t *Mtype=(MeasurementType_t *)calloc(1,sizeof(MeasurementType_t));
+ Mtype->present=MeasurementType_PR_measID;
+ Mtype->choice.measID = id[index];
+ infoItem[index]->measType=*Mtype;
+
+
+ LabelInfoItem_t **L_Item = (LabelInfoItem_t **)calloc(Label_Item_count, sizeof(LabelInfoItem_t *));
+ MeasurementLabel_t *M_Label=(MeasurementLabel_t *)calloc(1,sizeof(MeasurementLabel_t));
+ M_Label->noLabel=no_label;
+ L_Item[0] = (LabelInfoItem_t *)calloc(1, sizeof(LabelInfoItem_t ));
+ L_Item[0]->measLabel=*M_Label;
+ int result1 = ASN_SEQUENCE_ADD(&infoItem[index]->labelInfoList, L_Item[0]);
+ if (result1==-1)
+ {
+ fprintf(stderr,"Unable to assign memory to add labelInfoList %s",strerror(errno));
+ return -1;
+ }
+
+ int result2 = ASN_SEQUENCE_ADD(&actionDefFor1->measInfoList, infoItem[index]);
+ if (result2==-1)
+ {
+ fprintf(stderr,"Unable to assign memory to add measInfoList %s",strerror(errno));
+ return -1;
+ }
+
+
+ index++;
+ }
+
+
+ actionDefFor1->granulPeriod = granulPeriod;
+ actionDefFor1->cellGlobalID = cellGlobal;
+
+
+ actionDef->ric_Style_Type = ric_style_type;
+ actionDef->actionDefinition_formats.present = E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1;
+ actionDef->actionDefinition_formats.choice.actionDefinition_Format1 = actionDefFor1;
+
+
+ char errbuf[128];
+ size_t errbuf_len = 128;
+
+ int ret_constr = asn_check_constraints(&asn_DEF_E2SM_KPM_ActionDefinition, (void *) actionDef, errbuf, &errbuf_len);
+ if(ret_constr){
+ fprintf(stderr,"Constraints failed for encoding subscription request, %s", strerror(errno));
+ return -1;
+ }
+ //ATS_ALIGNED_BASIC_PER
+ //ATS_ALIGNED_CANONICAL_PER
+ //ATS_DER
+ asn_enc_rval_t encode_result = asn_encode_to_buffer(0,ATS_ALIGNED_CANONICAL_PER,&asn_DEF_E2SM_KPM_ActionDefinition,actionDef, buf, *buf_size);
+ //asn_enc_rval_t encode_result = uper_encode_to_buffer(&asn_DEF_E2SM_KPM_ActionDefinition, NULL,actionDef, buf, *buf_size);
+ if (encode_result.encoded == -1) {
+ fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
+ return -1;
+ }
+ else {
+ fprintf(stderr, "successfully\n");
+ //xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ /*
+ FILE *fp = fopen("sandeep.bin", "wb");
+
+ asn_enc_rval_t ec =asn_encode(0, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_E2SM_KPM_ActionDefinition, actionDef, write_out, fp);
+ fclose(fp);
+ if(ec.encoded ==-1) {
+ fprintf(stderr, "Could not encode action def (at %s)\n”,ec.failed_type ? ec.failed_type->name : ”unknown");
+ exit(1);
+ } else {
+ fprintf(stderr, "Created sandeep binary with ATS_ALIGNED_CANONICAL_PER encoded action def\n");
+ }
+ FILE *fp2 = fopen("sandy.txt", "w");
+ int r=asn_fprint(fp2,&asn_DEF_E2SM_KPM_ActionDefinition,actionDef);
+ fclose(fp2);
+ if (r==-1)
+ fprintf(stderr, "failed asn_fprint\n");
+ else
+ fprintf(stderr, "successfull asn_fprint\n");
+ */
+
+ return encode_result.encoded;
+ }
+}
+
+size_t e2sm_encode_ric_action_definition_format3_by_name(unsigned char *buf, size_t *buf_size, char **id_tmp , size_t measIdcount, long ric_style_type, unsigned long granulPeriod) {
+ E2SM_KPM_ActionDefinition_t *actionDef = (E2SM_KPM_ActionDefinition_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_t));
+ if (!actionDef) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ E2SM_KPM_ActionDefinition_Format3_t *actionDefFor3 = (E2SM_KPM_ActionDefinition_Format3_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_Format3_t));
+ if (!actionDefFor3) {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+
+
+ MeasurementCondItem_t **CondItem = (MeasurementCondItem_t **)calloc(measIdcount, sizeof(MeasurementCondItem_t *));
+ int Label_Item_count=1;
+
+ long *no_label=(long *) calloc(1,sizeof(long));//not giving label to the cell metrics/// don't know its bheaviour
+ *no_label=0;
+ int index = 0;
+ while (index < measIdcount) {
+
+ CondItem[index] = (MeasurementCondItem_t *)calloc(1, sizeof(MeasurementCondItem_t ));
+ MeasurementType_t *Mtype=(MeasurementType_t *)calloc(1,sizeof(MeasurementType_t));
+ Mtype->present=MeasurementType_PR_measName;
+ Mtype->choice.measName.buf=(uint8_t *)calloc(strlen(id_tmp[index]),sizeof(uint8_t));
+ memcpy(Mtype->choice.measName.buf,id_tmp[index], strlen(id_tmp[index]));
+ Mtype->choice.measName.size=strlen(id_tmp[index]);
+ CondItem[index]->measType=*Mtype;
+
+
+
+ MatchingCondItem_t **M_Item = (MatchingCondItem_t **)calloc(Label_Item_count, sizeof(MatchingCondItem_t *));
+ MeasurementLabel_t *M_Label=(MeasurementLabel_t *)calloc(1,sizeof(MeasurementLabel_t));
+ M_Label->noLabel=no_label;
+ M_Item[0] = (MatchingCondItem_t *)calloc(1, sizeof(MatchingCondItem_t ));
+ M_Item[0]->present=MatchingCondItem_PR_measLabel;
+ M_Item[0]->choice.measLabel=M_Label;
+ int result1 = ASN_SEQUENCE_ADD(&CondItem[index]->matchingCond, M_Item[0]);
+ if (result1==-1)
+ {
+ fprintf(stderr,"Unable to assign memory for matchingCond to add matchingCondItem_t %s",strerror(errno));
+ return -1;
+ }
+
+ int result2 = ASN_SEQUENCE_ADD(&actionDefFor3->measCondList, CondItem[index]);
+ if (result2==-1)
+ {
+ fprintf(stderr,"Unable to assign memory for measCondList to add MeasurementCondItem_t %s",strerror(errno));
+ return -1;
+ }
+
+
+ index++;
+ }
+
+
+ actionDefFor3->granulPeriod = granulPeriod;
+
+
+ actionDef->ric_Style_Type = ric_style_type;
+ actionDef->actionDefinition_formats.present = E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3;
+ actionDef->actionDefinition_formats.choice.actionDefinition_Format3 = actionDefFor3;
+
+
+ char errbuf[128];
+ size_t errbuf_len = 128;
+
+ int ret_constr = asn_check_constraints(&asn_DEF_E2SM_KPM_ActionDefinition, (void *) actionDef, errbuf, &errbuf_len);
+ if(ret_constr){
+ fprintf(stderr,"Constraints failed for encoding subscription request, %s", strerror(errno));
+ return -1;
+ }
+ //ATS_ALIGNED_BASIC_PER
+ //ATS_ALIGNED_CANONICAL_PER
+ //ATS_DER
+ asn_enc_rval_t encode_result = asn_encode_to_buffer(0,ATS_ALIGNED_CANONICAL_PER,&asn_DEF_E2SM_KPM_ActionDefinition,actionDef, buf, *buf_size);
+ //asn_enc_rval_t encode_result = uper_encode_to_buffer(&asn_DEF_E2SM_KPM_ActionDefinition, NULL,actionDef, buf, *buf_size);
+ if (encode_result.encoded == -1) {
+ fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
+ return -1;
+ }
+ else {
+ fprintf(stderr, "successfully\n");
+
+ //xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ /*
+ FILE *fp = fopen("sandeep.bin", "wb");
+
+ asn_enc_rval_t ec =asn_encode(0, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_E2SM_KPM_ActionDefinition, actionDef, write_out, fp);
+ fclose(fp);
+ if(ec.encoded ==-1) {
+ fprintf(stderr, "Could not encode action def (at %s)\n”,ec.failed_type ? ec.failed_type->name : ”unknown");
+ exit(1);
+ } else {
+ fprintf(stderr, "Created sandeep binary with ATS_ALIGNED_CANONICAL_PER encoded action def\n");
+ }
+ FILE *fp2 = fopen("sandy.txt", "w");
+ int r=asn_fprint(fp2,&asn_DEF_E2SM_KPM_ActionDefinition,actionDef);
+ fclose(fp2);
+ if (r==-1)
+ fprintf(stderr, "failed asn_fprint\n");
+ else
+ fprintf(stderr, "successfull asn_fprint\n");
+ */
+ return encode_result.encoded;
+ }
+}
+size_t e2sm_encode_ric_action_definition_format3_by_id(unsigned char *buf, size_t *buf_size, long *id , size_t measIdcount, long ric_style_type, unsigned long granulPeriod) {
+ E2SM_KPM_ActionDefinition_t *actionDef = (E2SM_KPM_ActionDefinition_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_t));
+ if (!actionDef) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ E2SM_KPM_ActionDefinition_Format3_t *actionDefFor3 = (E2SM_KPM_ActionDefinition_Format3_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_Format3_t));
+ if (!actionDefFor3) {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+
+
+ MeasurementCondItem_t **CondItem = (MeasurementCondItem_t **)calloc(measIdcount, sizeof(MeasurementCondItem_t *));
+ int Label_Item_count=1;
+
+ long *no_label=(long *) calloc(1,sizeof(long));//not giving label to the cell metrics/// don't know its bheaviour
+ *no_label=0;
+ int index = 0;
+ while (index < measIdcount) {
+
+ CondItem[index] = (MeasurementCondItem_t *)calloc(1, sizeof(MeasurementCondItem_t ));
+ MeasurementType_t *Mtype=(MeasurementType_t *)calloc(1,sizeof(MeasurementType_t));
+ Mtype->present=MeasurementType_PR_measID;
+ Mtype->choice.measID = id[index];
+ CondItem[index]->measType=*Mtype;
+
+
+ //LabelInfoList_t *L_List=(LabelInfoList_t *)calloc(1,sizeof(LabelInfoList_t ));
+ MatchingCondItem_t **M_Item = (MatchingCondItem_t **)calloc(Label_Item_count, sizeof(MatchingCondItem_t *));
+ MeasurementLabel_t *M_Label=(MeasurementLabel_t *)calloc(1,sizeof(MeasurementLabel_t));
+ M_Label->noLabel=no_label;
+ M_Item[0] = (MatchingCondItem_t *)calloc(1, sizeof(MatchingCondItem_t ));
+ M_Item[0]->present=MatchingCondItem_PR_measLabel;
+ M_Item[0]->choice.measLabel=M_Label;
+ int result1 = ASN_SEQUENCE_ADD(&CondItem[index]->matchingCond, M_Item[0]);
+ if (result1==-1)
+ {
+ fprintf(stderr,"Unable to assign memory for matchingCond to add matchingCondItem_t %s",strerror(errno));
+ return -1;
+ }
+
+ int result2 = ASN_SEQUENCE_ADD(&actionDefFor3->measCondList, CondItem[index]);
+ if (result2==-1)
+ {
+ fprintf(stderr,"Unable to assign memory for measCondList to add MeasurementCondItem_t %s",strerror(errno));
+ return -1;
+ }
+
+
+ index++;
+ }
+
+
+ actionDefFor3->granulPeriod = granulPeriod;
+ //actionDefFor3->cellGlobalID = cellGlobal; //optional
+
+
+ actionDef->ric_Style_Type = ric_style_type;
+ actionDef->actionDefinition_formats.present = E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format3;
+ actionDef->actionDefinition_formats.choice.actionDefinition_Format3 = actionDefFor3;
+
+
+ char errbuf[128];
+ size_t errbuf_len = 128;
+
+ int ret_constr = asn_check_constraints(&asn_DEF_E2SM_KPM_ActionDefinition, (void *) actionDef, errbuf, &errbuf_len);
+ if(ret_constr){
+ fprintf(stderr,"Constraints failed for encoding subscription request, %s", strerror(errno));
+ return -1;
+ }
+ //ATS_ALIGNED_BASIC_PER
+ //ATS_ALIGNED_CANONICAL_PER
+ //ATS_DER
+ asn_enc_rval_t encode_result = asn_encode_to_buffer(0,ATS_ALIGNED_CANONICAL_PER,&asn_DEF_E2SM_KPM_ActionDefinition,actionDef, buf, *buf_size);
+ //asn_enc_rval_t encode_result = uper_encode_to_buffer(&asn_DEF_E2SM_KPM_ActionDefinition, NULL,actionDef, buf, *buf_size);
+ if (encode_result.encoded == -1) {
+ fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
+ return -1;
+ }
+ else {
+ fprintf(stderr, "successfully\n");
+ //xer_fprint(stdout, &asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ /*
+ FILE *fp = fopen("sandeep.bin", "wb");
+
+ asn_enc_rval_t ec =asn_encode(0, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_E2SM_KPM_ActionDefinition, actionDef, write_out, fp);
+ fclose(fp);
+ if(ec.encoded ==-1) {
+ fprintf(stderr, "Could not encode action def (at %s)\n”,ec.failed_type ? ec.failed_type->name : ”unknown");
+ exit(1);
+ } else {
+ fprintf(stderr, "Created sandeep binary with ATS_ALIGNED_CANONICAL_PER encoded action def\n");
+ }
+ FILE *fp2 = fopen("sandy.txt", "w");
+ int r=asn_fprint(fp2,&asn_DEF_E2SM_KPM_ActionDefinition,actionDef);
+ fclose(fp2);
+ if (r==-1)
+ fprintf(stderr, "failed asn_fprint\n");
+ else
+ fprintf(stderr, "successfull asn_fprint\n");
+ */
+ return encode_result.encoded;
+ }
+}
+ssize_t e2sm_encode_ric_event_trigger_definition(void *buffer, size_t buf_size, size_t event_trigger_count, long *RT_periods) {
+ E2SM_KPM_EventTriggerDefinition_t *eventTriggerDef = (E2SM_KPM_EventTriggerDefinition_t *)calloc(1, sizeof(E2SM_KPM_EventTriggerDefinition_t));
+ if(!eventTriggerDef) {
+ fprintf(stderr, "Alloc EventTriggerDefinition failed\n");
+ return -1;
+ }
+
+ E2SM_KPM_EventTriggerDefinition_Format1_t *innerDef = (E2SM_KPM_EventTriggerDefinition_Format1_t *)calloc(1, sizeof(E2SM_KPM_EventTriggerDefinition_Format1_t));
+ if(!innerDef) {
+ fprintf(stderr, "alloc EventTriggerDefinition Format1 failed\n");
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTriggerDef);
+ return -1;
+ }
+
+ eventTriggerDef->eventDefinition_formats.present = E2SM_KPM_EventTriggerDefinition__eventDefinition_formats_PR_eventDefinition_Format1;
+ eventTriggerDef->eventDefinition_formats.choice.eventDefinition_Format1 = innerDef;
+
+ // struct E2SM_KPM_EventTriggerDefinition_Format1__policyTest_List *policyTestList = (struct E2SM_KPM_EventTriggerDefinition_Format1__policyTest_List *)calloc(1, sizeof(struct E2SM_KPM_EventTriggerDefinition_Format1__policyTest_List));
+ // innerDef->policyTest_List = policyTestList;
+
+ // int index = 0;
+ // while(index < event_trigger_count) {
+ // Trigger_ConditionIE_Item *triggerCondition = (Trigger_ConditionIE_Item *)calloc(1, sizeof(Trigger_ConditionIE_Item));
+ // assert(triggerCondition != 0);
+ // triggerCondition->report_Period_IE = RT_periods[index];
+ // ASN_SEQUENCE_ADD(&policyTestList->list, triggerCondition);
+ // index++;
+ // }
+
+ asn_enc_rval_t encode_result;
+ encode_result = uper_encode_to_buffer(&asn_DEF_E2SM_KPM_EventTriggerDefinition, NULL, eventTriggerDef, buffer, buf_size);
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_EventTriggerDefinition, eventTriggerDef);
+ if(encode_result.encoded == -1) {
+ fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
+ return -1;
+ } else {
+ return encode_result.encoded;
+ }
+}
+
+
+/*
+ssize_t e2sm_encode_ric_action_definition(void *buffer, size_t buf_size, long action_Def_count, long meas_ID, long ric_style_type, long GR_periods, Plm plm, Nrc nRc) {
+ E2SM_KPM_ActionDefinition_t *actionDef = (E2SM_KPM_ActionDefinition_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_t));
+ if(!actionDef) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ E2SM_KPM_ActionDefinition_Format1_t *actionDefFor1 = (E2SM_KPM_ActionDefinition_Format1_t *)calloc(1, sizeof(E2SM_KPM_ActionDefinition_Format1_t));
+ if(!actionDefFor1) {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+ CGI_t *cellGlobal = (CGI_t *)calloc(1, sizeof(CGI_t));
+ if(!cellGlobal) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ NR_CGI_t *nrCGIs = (NR_CGI_t *)calloc(1, sizeof(NR_CGI_t));
+ if(!nrCGIs) {
+ fprintf(stderr, "alloc RIC ActionDefinition failed\n");
+ return -1;
+ }
+
+ actionDef->ric_Style_Type = ric_style_type;
+ actionDef->actionDefinition_formats.present = E2SM_KPM_ActionDefinition__actionDefinition_formats_PR_actionDefinition_Format1;
+ actionDef->actionDefinition_formats.choice.actionDefinition_Format1 = actionDefFor1;
+ actionDefFor1->granulPeriod = GR_periods;
+ actionDefFor1->cellGlobalID = cellGlobal;
+ cellGlobal->present = CGI_PR_nR_CGI;
+ cellGlobal->choice.nR_CGI = nrCGIs;
+
+
+ int plmSize = plm.size;
+ if(plmSize != 0) {
+
+ }
+
+ PLMNIdentity_t *plms = &nrCGIs->pLMNIdentity;
+ plms->buf = (uint8_t *)calloc(1, plmSize);
+ if(!plms->buf) {
+ fprintf(stderr, "alloc plms failed\n");
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ return -1;
+ }
+
+ memcpy(plms->buf, plm.plms, plmSize);
+ plms->size = plmSize;
+
+
+ int nRcSize = nRc.size;
+
+ NRCellIdentity_t *nRCs = &nrCGIs->nRCellIdentity;
+ nRCs->buf = (uint8_t *)calloc(1, nRcSize);
+ if(!nRCs->buf) {
+ fprintf(stderr, "alloc nRCs failed\n");
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ return -1;
+ }
+
+ memcpy(nRCs->buf, nRc.nRcs, nRcSize);
+ nRCs->size = nRcSize;
+
+
+ MeasurementInfoList_t *infoList = &actionDefFor1->measInfoList;
+
+ int index = 0;
+ while(index < action_Def_count) {
+ MeasurementInfoItem_t *infoItem = (MeasurementInfoItem_t *)calloc(1, sizeof(MeasurementInfoItem_t));
+ // if(!infoItem) {
+ // fprintf(stderr, "alloc Measurement Info Item failed\n");
+ // ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+ // return -1;
+ // }
+ assert(infoItem != 0);
+
+
+ MeasurementType_t *measureType = &infoItem->measType;
+
+ measureType->present = MeasurementType_PR_measID;
+ measureType->choice.measID = meas_ID;
+
+
+ LabelInfoList_t *lableList = &infoItem->labelInfoList;
+
+ ASN_SEQUENCE_ADD(&infoList->list, infoItem);
+ index++;
+ }
+
+ asn_enc_rval_t encode_result;
+ encode_result = uper_encode_to_buffer(&asn_DEF_E2SM_KPM_ActionDefinition, NULL,actionDef, buffer, buf_size);
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_ActionDefinition, actionDef);
+
+ if(encode_result.encoded == -1) {
+ fprintf(stderr, "Cannot encode %s: %s\n", encode_result.failed_type->name, strerror(errno));
+ return -1;
+ } else {
+ fprintf(stderr, "successfully\n");
+ return encode_result.encoded;
+ }
+}
+*/
+E2SM_KPM_IndicationHeader_t* e2sm_decode_ric_indication_header(void *buffer, size_t buf_size) {
+ asn_dec_rval_t decode_result;
+ E2SM_KPM_IndicationHeader_t *indHdr = 0;
+ //fprintf(stderr, "\nbuffer= %p",buffer);
+ //fprintf(stdout, "\nbuf_size=%ld",buf_size);
+ //fprintf(stdout, "\nE2SM_KPM_IndicationHeader_t_size=%ld",sizeof(E2SM_KPM_IndicationHeader_t));
+ //decode_result = uper_decode_complete(NULL, &asn_DEF_E2SM_KPM_IndicationHeader, (void **)&indHdr, (char*)buffer, buf_size);
+ //ATS_ALIGNED_CANONICAL_PER
+ decode_result =asn_decode(0,ATS_ALIGNED_BASIC_PER,&asn_DEF_E2SM_KPM_IndicationHeader,(void **)&indHdr,buffer,buf_size);
+ if(decode_result.code == RC_OK) {
+ // xer_fprint(stderr, &asn_DEF_E2SM_KPM_IndicationHeader, indHdr);
+ return indHdr;
+ }
+ else if (decode_result.code ==RC_WMORE ) {
+ //xer_fprint(stderr, &asn_DEF_E2SM_KPM_IndicationHeader, indHdr);
+ //fprintf(stderr, "\n decode_result.consumed= %ld \n",decode_result.consumed);
+ fprintf(stderr, "\nheader RC_WMORE ");
+ return indHdr;
+ }
+
+ else {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_IndicationHeader, indHdr);
+ return NULL;
+ }
+}
+
+void e2sm_free_ric_indication_header(E2SM_KPM_IndicationHeader_t* indHdr) {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_IndicationHeader, indHdr);
+}
+
+E2SM_KPM_IndicationMessage_t* e2sm_decode_ric_indication_message(void *buffer, size_t buf_size) {
+ asn_dec_rval_t decode_result;
+ E2SM_KPM_IndicationMessage_t *indMsg = 0;
+ //fprintf(stdout, "\nbuffer= %p",buffer);
+ //fprintf(stdout, "\nbuf_size=%ld",buf_size);
+ //fprintf(stdout, "\nE2SM_KPM_IndicationMessage_t size=%ld",sizeof(E2SM_KPM_IndicationMessage_t));
+ //decode_result = uper_decode_complete(NULL, &asn_DEF_E2SM_KPM_IndicationMessage, (void **)&indMsg, (char *)buffer, buf_size);
+ //ATS_ALIGNED_CANONICAL_PER
+ decode_result =asn_decode(0,ATS_ALIGNED_BASIC_PER,&asn_DEF_E2SM_KPM_IndicationMessage,(void **)&indMsg,buffer,buf_size);
+ if(decode_result.code == RC_OK) {
+ //xer_fprint(stdout, &asn_DEF_E2SM_KPM_IndicationMessage, indMsg);
+ return indMsg;
+ }
+ else if (decode_result.code ==RC_WMORE ) {
+ //xer_fprint(stderr, &asn_DEF_E2SM_KPM_IndicationMessage, indMsg);
+ //fprintf(stderr, "\n MSG decode_result.consumed= %ld \n",decode_result.consumed);
+ fprintf(stderr, "\n MSG RC_WMORE ");
+ return NULL;
+ }
+
+ else {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_IndicationMessage, indMsg);
+ return NULL;
+ }
+}
+
+void e2sm_free_ric_indication_message(E2SM_KPM_IndicationMessage_t* indMsg) {
+ ASN_STRUCT_FREE(asn_DEF_E2SM_KPM_IndicationMessage, indMsg);
+}
+
diff --git a/e2sm/wrapper.h b/e2sm/wrapper.h
new file mode 100644
index 0000000..94a2057
--- /dev/null
+++ b/e2sm/wrapper.h
@@ -0,0 +1,138 @@
+#ifndef _WRAPPER_H_
+#define _WRAPPER_H_
+
+#include <E2SM-KPM-EventTriggerDefinition.h>
+#include <E2SM-KPM-EventTriggerDefinition-Format1.h>
+#include <E2SM-KPM-ActionDefinition.h>
+#include <E2SM-KPM-ActionDefinition-Format1.h>
+#include <MeasurementInfoList.h>
+#include <GranularityPeriod.h>
+#include <MeasurementInfoItem.h>
+#include <MeasurementType.h>
+#include <MeasurementTypeID.h>
+#include <LabelInfoItem.h>
+#include <LabelInfoList.h>
+#include <MeasurementLabel.h>
+#include <CGI.h>
+#include <PLMNIdentity.h>
+#include <E2SM-KPM-IndicationHeader.h>
+#include <E2SM-KPM-IndicationHeader-Format1.h>
+//#include <GlobalNGRANNodeID.h>
+#include<GlobalRANNodeID.h>
+#include <GlobalGNB-ID.h>
+#include <GlobalenGNB-ID.h>
+#include <GlobalNgENB-ID.h>
+#include <GlobalENB-ID.h>
+#include <PLMNIdentity.h>
+#include <GNB-ID.h>
+#include <GNB-CU-UP-ID.h>
+#include <GNB-DU-ID.h>
+#include <EN-GNB-ID.h>
+#include <ENB-ID.h>
+#include <NR-CGI.h>
+#include <S-NSSAI.h>
+#include <E2SM-KPM-IndicationMessage.h>
+#include <E2SM-KPM-IndicationMessage-Format1.h>
+#include <E2SM-KPM-IndicationMessage-Format2.h>
+#include<MeasurementDataItem.h>
+#include<MeasurementRecordItem.h>
+#include <TimeStamp.h>
+
+
+#include <stdio.h>
+#include "asn_application.h"
+#include <E2SM-KPM-EventTriggerDefinition.h>
+#include <E2SM-KPM-EventTriggerDefinition-Format1.h>
+#include <E2SM-KPM-ActionDefinition.h>
+#include <E2SM-KPM-ActionDefinition-Format1.h>
+#include <E2SM-KPM-ActionDefinition-Format3.h>
+#include <MeasurementInfoList.h>
+#include <GranularityPeriod.h>
+#include <MeasurementInfoItem.h>
+#include <MeasurementType.h>
+#include<MeasurementCondList.h>
+#include<MeasurementCondItem.h>
+#include<MatchingCondItem.h>
+#include<E2SM-KPM-RANfunction-Description.h>
+#include<RIC-ReportStyle-Item.h>
+#include<MeasurementInfo-Action-Item.h>
+
+#include <MeasurementTypeID.h>
+#include <LabelInfoItem.h>
+#include <LabelInfoList.h>
+#include <MeasurementLabel.h>
+#include <CGI.h>
+#include <PLMNIdentity.h>
+#include <E2SM-KPM-IndicationHeader.h>
+#include <E2SM-KPM-IndicationHeader-Format1.h>
+//#include <GlobalNGRANNodeID.h>
+#include <GlobalGNB-ID.h>
+#include <GlobalenGNB-ID.h>
+#include <GlobalNgENB-ID.h>
+#include <GlobalENB-ID.h>
+#include <PLMNIdentity.h>
+#include <GNB-ID.h>
+#include <GNB-CU-UP-ID.h>
+#include <GNB-DU-ID.h>
+#include <EN-GNB-ID.h>
+#include <ENB-ID.h>
+#include <NR-CGI.h>
+#include <S-NSSAI.h>
+#include <E2SM-KPM-IndicationMessage.h>
+#include <E2SM-KPM-IndicationMessage-Format1.h>
+#include <E2SM-KPM-IndicationMessage-Format2.h>
+#include <TimeStamp.h>
+#include<per_encoder.h>
+#include <errno.h>
+
+/*
+typedef struct Plm {
+ uint8_t *plms;
+ int size;
+} Plm;
+
+
+typedef struct Nrc {
+ uint8_t *nRcs;
+ int size;
+ int bits_unused;
+} Nrc;
+
+*/
+typedef struct encode_act_Def_result{
+ int * array;
+ int length;
+} encode_act_Def_result_t;
+
+typedef struct ranCellUeKpi{
+ char ** ueKpi;
+ char ** cellKpi;
+ int ueKpiSize;
+ int cellKpiSize;
+} ranCellUeKpi_t;
+
+ssize_t e2sm_encode_ric_event_trigger_definition(void *buffer, size_t buf_size, size_t event_trigger_count, long *RT_periods);
+
+//ssize_t e2sm_encode_ric_action_definition(void *buffer, size_t buf_size, long action_Def_count, long meas_ID, long ric_style_type, long GR_periods, Plm plm, Nrc nRc);
+//
+
+ranCellUeKpi_t buildRanCellUeKpi(const char *hex_values);
+
+void freeMemorydRanCellUeKpi(ranCellUeKpi_t res);
+
+struct encode_act_Def_result encode_action_Definition(const char *hex_values, int determine);
+
+size_t e2sm_encode_ric_action_definition_format1_by_name(unsigned char *buf, size_t *buf_size, const char **id_tmp , size_t measIdcount, long ric_style_type, unsigned long granulPeriod, unsigned char *p, unsigned char *nR);
+
+size_t e2sm_encode_ric_action_definition_format1_by_id(unsigned char *buf, size_t *buf_size, long *id , size_t measIdcount, long ric_style_type, unsigned long granulPeriod, unsigned char *p, unsigned char *nR);
+
+size_t e2sm_encode_ric_action_definition_format3_by_name(unsigned char *buf, size_t *buf_size, char **id_tmp , size_t measIdcount, long ric_style_type, unsigned long granulPeriod);
+
+size_t e2sm_encode_ric_action_definition_format3_by_id(unsigned char *buf, size_t *buf_size, long *id , size_t measIdcount, long ric_style_type, unsigned long granulPeriod);
+
+E2SM_KPM_IndicationHeader_t* e2sm_decode_ric_indication_header(void *buffer, size_t buf_size);
+void e2sm_free_ric_indication_header(E2SM_KPM_IndicationHeader_t* indHdr);
+E2SM_KPM_IndicationMessage_t* e2sm_decode_ric_indication_message(void *buffer, size_t buf_size);
+void e2sm_free_ric_indication_message(E2SM_KPM_IndicationMessage_t* indMsg);
+
+#endif /* _WRAPPER_H_ */