e2sim/e2apv1sim/encode_kpm.cpp

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <iostream>
   4 #include <unistd.h>
   5 #include <vector>
   6
   7 #include "encode_kpm.hpp";
   8
   9 using namespace std;
  10
  11
  12 void encode_kpm(E2SM_KPM_IndicationMessage_t* indicationmessage) {
  13   ASN_STRUCT_RESET(asn_DEF_E2SM_KPM_IndicationMessage, indicationmessage);
  14   //std::string gn = "GNBCUUP5";
  15   //std::vector<uint8_t> gnvec(gn.begin(), gn.end());
  16   //uint8_t *buf = &gnvec[0];
  17   uint8_t *buf = (uint8_t*)"GNBCUUP5";
  18   OCTET_STRING_t *gnbcuupname = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
  19   gnbcuupname->size = 8;
  20   gnbcuupname->buf = (uint8_t*)calloc(1,8);
  21   memcpy(gnbcuupname->buf, buf, gnbcuupname->size);
  22
  23
  24   INTEGER_t *bytesdl = (INTEGER_t*)calloc(1, sizeof(INTEGER_t));
  25   uint8_t buffer[1];
  26   buffer[0]= 40000;
  27   bytesdl->buf = (uint8_t*)calloc(1,1);
  28   memcpy(bytesdl->buf, buffer,1);
  29   bytesdl->size = 1;
  30
  31   INTEGER_t *bytesul = (INTEGER_t*)calloc(1, sizeof(INTEGER_t));
  32   uint8_t buffer1[1];
  33   buffer1[0] = 50000;
  34   bytesul->buf = (uint8_t*)calloc(1,1);
  35   memcpy(bytesul->buf, buffer1, 1);
  36   bytesul->size = 1;
  37
  38   FQIPERSlicesPerPlmnListItem_t *fqilistitem = (FQIPERSlicesPerPlmnListItem_t*)calloc(1, sizeof(FQIPERSlicesPerPlmnListItem_t));
  39   ASN_STRUCT_RESET(asn_DEF_FQIPERSlicesPerPlmnListItem, fqilistitem);
  40   fqilistitem->fiveQI = 9;
  41   fqilistitem->pDCPBytesDL = bytesdl;
  42   fqilistitem->pDCPBytesUL = bytesul;
  43
  44
  45
  46   //  std::string sl = "SLICE4";
  47   //  std::vector<uint8_t> slvec(sl.begin(), sl.end());
  48   //  uint8_t *buf1 = &slvec[0];
  49   uint8_t *buf1 = (uint8_t*)"4";
  50   OCTET_STRING_t *sst = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
  51   sst->size = 6;
  52   sst->buf = (uint8_t*)calloc(1,6);
  53   memcpy(sst->buf,buf1,sst->size);
  54
  55   //  std::string sd = "SD1";
  56   //  std::vector<uint8_t> sdvec(sd.begin(), sd.end());
  57   //  uint8_t *bufz = &sdvec[0];
  58   uint8_t *bufz = (uint8_t*)"SD1";
  59   OCTET_STRING_t *sds = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
  60   sds->size = 3;
  61   sds->buf = (uint8_t*)calloc(1,3);
  62   memcpy(sds->buf, bufz, sds->size);
  63
  64
  65   SNSSAI_t *snssai = (SNSSAI_t*)calloc(1, sizeof(SNSSAI_t));
  66   ASN_STRUCT_RESET(asn_DEF_SNSSAI,snssai);
  67   snssai->sST.buf = (uint8_t*)calloc(1,1);
  68   snssai->sST.size = 1;
  69   memcpy(snssai->sST.buf, buf1, 1);
  70   snssai->sD = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
  71   snssai->sD->buf = (uint8_t*)calloc(1,3);
  72   snssai->sD->size = 3;
  73   memcpy(snssai->sD->buf, bufz, 3);
  74
  75
  76
  77   SliceToReportListItem_t *slicelistitem = (SliceToReportListItem_t*)calloc(1,sizeof(SliceToReportListItem_t));
  78   ASN_STRUCT_RESET(asn_DEF_SliceToReportListItem, slicelistitem);
  79   slicelistitem->sliceID = *snssai;
  80   int ret = ASN_SEQUENCE_ADD(&slicelistitem->fQIPERSlicesPerPlmnList.list, fqilistitem);
  81
  82   asn_codec_ctx_t *opt_cod;
  83
  84   /*
  85   uint8_t e2smbuffera[8192];
  86   size_t e2smbuffer_sizea = 8192;
  87
  88
  89
  90   asn_enc_rval_t era =
  91     asn_encode_to_buffer(opt_cod,
  92                          ATS_ALIGNED_BASIC_PER,
  93                          &asn_DEF_SliceToReportListItem,
  94                          slicelistitem, e2smbuffera, e2smbuffer_sizea);
  95   fprintf(stderr, "inner er encded is %d\n", era.encoded);
  96   fprintf(stderr, "after encoding message\n");
  97   */
  98
  99   FGC_CUUP_PM_Format_t *pm_format = (FGC_CUUP_PM_Format_t*)calloc(1,sizeof(FGC_CUUP_PM_Format_t));
 100   ASN_STRUCT_RESET(asn_DEF_FGC_CUUP_PM_Format, pm_format);
 101   ret = ASN_SEQUENCE_ADD(&pm_format->sliceToReportList.list, slicelistitem);
 102
 103   uint8_t *buf2 = (uint8_t*)"747";
 104   //  std::string pl = "PLMNID7";
 105   //  std::vector<uint8_t> plvec(pl.begin(), pl.end());
 106   //  uint8_t *buf2 = &plvec[0];
 107
 108   OCTET_STRING_t *plmnid = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
 109   plmnid->buf = (uint8_t*)calloc(3,1);
 110   plmnid->size = 3;
 111   memcpy(plmnid->buf, buf2, plmnid->size);
 112
 113
 114   PlmnID_List_t *plmnidlist = (PlmnID_List_t*)calloc(1,sizeof(PlmnID_List_t));
 115   ASN_STRUCT_RESET(asn_DEF_PlmnID_List, plmnidlist);
 116   plmnidlist->pLMN_Identity = *plmnid;
 117   plmnidlist->cu_UP_PM_5GC = pm_format;
 118
 119   CUUPMeasurement_Container_t *meas_cont = (CUUPMeasurement_Container_t*)calloc(1, sizeof(CUUPMeasurement_Container_t));
 120   ASN_STRUCT_RESET(asn_DEF_CUUPMeasurement_Container, meas_cont);
 121   ret = ASN_SEQUENCE_ADD(&meas_cont->plmnList.list, plmnidlist);
 122
 123
 124
 125
 126   PF_ContainerListItem_t *listitem1 = (PF_ContainerListItem_t*)calloc(1, sizeof(PF_ContainerListItem_t));
 127   ASN_STRUCT_RESET(asn_DEF_PF_ContainerListItem, listitem1);
 128   listitem1->interface_type = 2;
 129   listitem1->o_CU_UP_PM_Container = *meas_cont;
 130
 131   OCUUP_PF_Container_t *cuupcont = (OCUUP_PF_Container_t*)calloc(1,sizeof(OCUUP_PF_Container_t));
 132   ASN_STRUCT_RESET(asn_DEF_OCUUP_PF_Container, cuupcont);
 133   cuupcont->gNB_CU_UP_Name = gnbcuupname;
 134   ret = ASN_SEQUENCE_ADD(&cuupcont->pf_ContainerList.list, listitem1);
 135
 136   PF_Container_PR pres1 = PF_Container_PR_oCU_UP;
 137
 138   PF_Container_t *pfcontainer = (PF_Container_t*)calloc(1, sizeof(PF_Container_t));
 139   ASN_STRUCT_RESET(asn_DEF_PF_Container, pfcontainer);
 140   pfcontainer->present = pres1;
 141   pfcontainer->choice.oCU_UP = *cuupcont;
 142
 143   PM_Containers_List_t *containers_list = (PM_Containers_List_t*)calloc(1, sizeof(PM_Containers_List_t));
 144   ASN_STRUCT_RESET(asn_DEF_PM_Containers_List, containers_list);
 145   containers_list->performanceContainer = pfcontainer;
 146
 147   E2SM_KPM_IndicationMessage_Format1_t *format =
 148     (E2SM_KPM_IndicationMessage_Format1_t*)calloc(1, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
 149   ASN_STRUCT_RESET(asn_DEF_E2SM_KPM_IndicationMessage_Format1, format);
 150
 151   ret = ASN_SEQUENCE_ADD(&format->pm_Containers.list, containers_list);
 152
 153   E2SM_KPM_IndicationMessage_PR pres = E2SM_KPM_IndicationMessage_PR_indicationMessage_Format1;
 154
 155   indicationmessage->present = pres;
 156
 157   indicationmessage->choice.indicationMessage_Format1 = *format;
 158
 159   char *error_buf = (char*)calloc(300, sizeof(char));
 160   size_t errlen;
 161
 162   asn_check_constraints(&asn_DEF_E2SM_KPM_IndicationMessage, indicationmessage, error_buf, &errlen);
 163   printf("error length %d\n", errlen);
 164   printf("error buf %s\n", error_buf);
 165
 166   xer_fprint(stderr, &asn_DEF_E2SM_KPM_IndicationMessage, indicationmessage);
 167
 168
 169   uint8_t e2smbuffer[8192];
 170   size_t e2smbuffer_size = 8192;
 171
 172   uint8_t e2smbuffer2[8192];
 173   size_t e2smbuffer_size2 = 8192;
 174
 175   asn_enc_rval_t er =
 176     asn_encode_to_buffer(opt_cod,
 177                          ATS_ALIGNED_BASIC_PER,
 178                          &asn_DEF_E2SM_KPM_IndicationMessage,
 179                          indicationmessage, e2smbuffer, e2smbuffer_size);
 180
 181   fprintf(stderr, "er encded is %d\n", er.encoded);
 182   fprintf(stderr, "after encoding message\n");
 183
 184
 185 }
 186
 187
 188 void encode_kpm_bak(E2SM_KPM_IndicationMessage_t* indicationmessage) {
 189   ASN_STRUCT_RESET(asn_DEF_E2SM_KPM_IndicationMessage, indicationmessage);
 190   std::string gn = "GNBCUUP5";
 191   std::vector<uint8_t> gnvec(gn.begin(), gn.end());
 192   uint8_t *buf = &gnvec[0];
 193   OCTET_STRING_t *gnbcuupname = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
 194   gnbcuupname->size = 8;
 195   gnbcuupname->buf = (uint8_t*)calloc(1,8);
 196   memcpy(gnbcuupname->buf, buf, gnbcuupname->size);
 197
 198
 199   INTEGER_t *bytesdl = (INTEGER_t*)calloc(1, sizeof(INTEGER_t));
 200   uint8_t buffer[1];
 201   buffer[0]= 40000;
 202   bytesdl->buf = (uint8_t*)calloc(1,1);
 203   memcpy(bytesdl->buf, buffer,1);
 204   bytesdl->size = 1;
 205
 206   INTEGER_t *bytesul = (INTEGER_t*)calloc(1, sizeof(INTEGER_t));
 207   uint8_t buffer1[1];
 208   buffer1[0] = 50000;
 209   bytesul->buf = (uint8_t*)calloc(1,1);
 210   memcpy(bytesul->buf, buffer1, 1);
 211   bytesul->size = 1;
 212
 213   FQIPERSlicesPerPlmnListItem_t *fqilistitem = (FQIPERSlicesPerPlmnListItem_t*)calloc(1, sizeof(FQIPERSlicesPerPlmnListItem_t));
 214   ASN_STRUCT_RESET(asn_DEF_FQIPERSlicesPerPlmnListItem, fqilistitem);
 215   fqilistitem->fiveQI = 9;
 216   fqilistitem->pDCPBytesDL = bytesdl;
 217   fqilistitem->pDCPBytesUL = bytesul;
 218
 219
 220
 221   std::string sl = "SLICE4";
 222   std::vector<uint8_t> slvec(sl.begin(), sl.end());
 223   //  uint8_t *buf1 = &slvec[0];
 224   uint8_t *buf1 = (uint8_t*)"SLICE4";
 225   OCTET_STRING_t *sst = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
 226   sst->size = 6;
 227   sst->buf = (uint8_t*)calloc(1,6);
 228   memcpy(sst->buf,buf1,sst->size);
 229
 230   std::string sd = "SD1";
 231   std::vector<uint8_t> sdvec(sd.begin(), sd.end());
 232   //  uint8_t *bufz = &sdvec[0];
 233   uint8_t *bufz = (uint8_t*)"SD1";
 234   OCTET_STRING_t *sds = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
 235   sds->size = 3;
 236   sds->buf = (uint8_t*)calloc(1,3);
 237   memcpy(sds->buf, bufz, sds->size);
 238
 239
 240   SNSSAI_t *snssai = (SNSSAI_t*)calloc(1, sizeof(SNSSAI_t));
 241   ASN_STRUCT_RESET(asn_DEF_SNSSAI,snssai);
 242   snssai->sST.buf = (uint8_t*)calloc(6,1);
 243   snssai->sST.size = 6;
 244   memcpy(snssai->sST.buf, buf1, 6);
 245   snssai->sD = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
 246   snssai->sD->buf = (uint8_t*)calloc(1,3);
 247   snssai->sD->size = 3;
 248   memcpy(snssai->sD->buf, bufz, 3);
 249
 250
 251
 252   SliceToReportListItem_t *slicelistitem = (SliceToReportListItem_t*)calloc(1,sizeof(SliceToReportListItem_t));
 253   ASN_STRUCT_RESET(asn_DEF_SliceToReportListItem, slicelistitem);
 254   slicelistitem->sliceID = *snssai;
 255   int ret = ASN_SEQUENCE_ADD(&slicelistitem->fQIPERSlicesPerPlmnList.list, fqilistitem);
 256
 257   uint8_t e2smbuffera[8192];
 258   size_t e2smbuffer_sizea = 8192;
 259
 260   auto era =
 261     asn_encode_to_buffer(nullptr,
 262                          ATS_ALIGNED_BASIC_PER,
 263                          &asn_DEF_SliceToReportListItem,
 264                          slicelistitem, e2smbuffera, e2smbuffer_sizea);
 265   fprintf(stderr, "inner er encded is %d\n", era.encoded);
 266   fprintf(stderr, "after encoding message\n");
 267
 268   FGC_CUUP_PM_Format_t *pm_format = (FGC_CUUP_PM_Format_t*)calloc(1,sizeof(FGC_CUUP_PM_Format_t));
 269   ASN_STRUCT_RESET(asn_DEF_FGC_CUUP_PM_Format, pm_format);
 270   ret = ASN_SEQUENCE_ADD(&pm_format->sliceToReportList.list, slicelistitem);
 271
 272   std::string pl = "PLMNID7";
 273   std::vector<uint8_t> plvec(pl.begin(), pl.end());
 274   uint8_t *buf2 = &plvec[0];
 275
 276   OCTET_STRING_t *plmnid = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
 277   plmnid->buf = (uint8_t*)calloc(1,7);
 278   plmnid->size = 7;
 279   memcpy(plmnid->buf, buf2, plmnid->size);
 280
 281
 282   PlmnID_List_t *plmnidlist = (PlmnID_List_t*)calloc(1,sizeof(PlmnID_List_t));
 283   ASN_STRUCT_RESET(asn_DEF_PlmnID_List, plmnidlist);
 284   plmnidlist->pLMN_Identity = *plmnid;
 285   plmnidlist->cu_UP_PM_5GC = pm_format;
 286
 287   CUUPMeasurement_Container_t *meas_cont = (CUUPMeasurement_Container_t*)calloc(1, sizeof(CUUPMeasurement_Container_t));
 288   ASN_STRUCT_RESET(asn_DEF_CUUPMeasurement_Container, meas_cont);
 289   ret = ASN_SEQUENCE_ADD(&meas_cont->plmnList.list, plmnidlist);
 290
 291
 292
 293
 294   PF_ContainerListItem_t *listitem1 = (PF_ContainerListItem_t*)calloc(1, sizeof(PF_ContainerListItem_t));
 295   ASN_STRUCT_RESET(asn_DEF_PF_ContainerListItem, listitem1);
 296   listitem1->interface_type = 2;
 297   listitem1->o_CU_UP_PM_Container = *meas_cont;
 298
 299   OCUUP_PF_Container_t *cuupcont = (OCUUP_PF_Container_t*)calloc(1,sizeof(OCUUP_PF_Container_t));
 300   ASN_STRUCT_RESET(asn_DEF_OCUUP_PF_Container, cuupcont);
 301   cuupcont->gNB_CU_UP_Name = gnbcuupname;
 302   ret = ASN_SEQUENCE_ADD(&cuupcont->pf_ContainerList.list, listitem1);
 303
 304   PF_Container_PR pres1 = PF_Container_PR_oCU_UP;
 305
 306   PF_Container_t *pfcontainer = (PF_Container_t*)calloc(1, sizeof(PF_Container_t));
 307   ASN_STRUCT_RESET(asn_DEF_PF_Container, pfcontainer);
 308   pfcontainer->present = pres1;
 309   pfcontainer->choice.oCU_UP = *cuupcont;
 310
 311   PM_Containers_List_t *containers_list = (PM_Containers_List_t*)calloc(1, sizeof(PM_Containers_List_t));
 312   ASN_STRUCT_RESET(asn_DEF_PM_Containers_List, containers_list);
 313   containers_list->performanceContainer = pfcontainer;
 314
 315   E2SM_KPM_IndicationMessage_Format1_t *format =
 316     (E2SM_KPM_IndicationMessage_Format1_t*)calloc(1, sizeof(E2SM_KPM_IndicationMessage_Format1_t));
 317   ASN_STRUCT_RESET(asn_DEF_E2SM_KPM_IndicationMessage_Format1, format);
 318
 319   ret = ASN_SEQUENCE_ADD(&format->pm_Containers.list, containers_list);
 320
 321   E2SM_KPM_IndicationMessage_PR pres = E2SM_KPM_IndicationMessage_PR_indicationMessage_Format1;
 322
 323   indicationmessage->present = pres;
 324
 325   indicationmessage->choice.indicationMessage_Format1 = *format;
 326
 327   char *error_buf = (char*)calloc(300, sizeof(char));
 328   size_t errlen;
 329
 330   asn_check_constraints(&asn_DEF_E2SM_KPM_IndicationMessage, indicationmessage, error_buf, &errlen);
 331   printf("error length %d\n", errlen);
 332   printf("error buf %s\n", error_buf);
 333
 334
 335   uint8_t e2smbuffer[8192];
 336   size_t e2smbuffer_size = 8192;
 337
 338   uint8_t e2smbuffer2[8192];
 339   size_t e2smbuffer_size2 = 8192;
 340
 341   auto er =
 342     asn_encode_to_buffer(nullptr,
 343                          ATS_ALIGNED_BASIC_PER,
 344                          &asn_DEF_E2SM_KPM_IndicationMessage,
 345                          indicationmessage, e2smbuffer, e2smbuffer_size);
 346
 347   fprintf(stderr, "er encded is %d\n", er.encoded);
 348   fprintf(stderr, "after encoding message\n");
 349
 350
 351 }