e2sim/e2apv1sim/encode_e2apv1.cpp

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <iostream>
   4 #include <unistd.h>
   5 #include <vector>
   6
   7
   8 #include "encode_e2apv1.hpp"
   9
  10
  11 void generate_e2apv1_setup_request(E2AP_PDU_t *e2ap_pdu) {
  12
  13   //  uint8_t *buf = (uint8_t *)"gnb1";
  14
  15   BIT_STRING_t *gnb_bstring = (BIT_STRING_t*)calloc(1, sizeof(BIT_STRING_t));;
  16   gnb_bstring->buf = (uint8_t*)calloc(1,4);
  17   gnb_bstring->size = 4;
  18   gnb_bstring->buf[0] = 0xB5;
  19   gnb_bstring->buf[1] = 0xC6;
  20   gnb_bstring->buf[2] = 0x77;
  21   gnb_bstring->buf[3] = 0x88;
  22
  23   gnb_bstring->bits_unused = 0;
  24
  25   uint8_t *buf2 = (uint8_t *)"plmn3";
  26   OCTET_STRING_t *plmn = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
  27   plmn->buf = (uint8_t*)calloc(1,5);
  28   memcpy(plmn->buf, buf2, 5);;
  29   plmn->size = 5;
  30
  31   GNB_ID_Choice_t *gnbchoice = (GNB_ID_Choice_t*)calloc(1,sizeof(GNB_ID_Choice_t));
  32   GNB_ID_Choice_PR pres2 = GNB_ID_Choice_PR_gnb_ID;
  33   gnbchoice->present = pres2;
  34   gnbchoice->choice.gnb_ID = *gnb_bstring;
  35
  36   GlobalgNB_ID_t *gnb = (GlobalgNB_ID_t*)calloc(1, sizeof(GlobalgNB_ID_t));
  37   gnb->plmn_id = *plmn;
  38   gnb->gnb_id = *gnbchoice;
  39
  40   GlobalE2node_gNB_ID_t *e2gnb = (GlobalE2node_gNB_ID_t*)calloc(1, sizeof(GlobalE2node_gNB_ID_t));
  41   e2gnb->global_gNB_ID = *gnb;
  42
  43   GlobalE2node_ID_t *globale2nodeid = (GlobalE2node_ID_t*)calloc(1, sizeof(GlobalE2node_ID_t));
  44   GlobalE2node_ID_PR pres;
  45   pres = GlobalE2node_ID_PR_gNB;
  46   globale2nodeid->present = pres;
  47   globale2nodeid->choice.gNB = e2gnb;
  48
  49   E2setupRequestIEs_t *e2setuprid = (E2setupRequestIEs_t*)calloc(1, sizeof(E2setupRequestIEs_t));;
  50   E2setupRequestIEs__value_PR pres3;
  51   pres3 = E2setupRequestIEs__value_PR_GlobalE2node_ID;
  52   e2setuprid->id = 4;
  53   e2setuprid->criticality = 0;
  54   e2setuprid->value.choice.GlobalE2node_ID = *globale2nodeid;
  55   e2setuprid->value.present = pres3;
  56
  57   /*
  58   auto *ranFlistIEs = (E2setupRequestIEs_t *)calloc(1, sizeof(E2setupRequestIEs_t));
  59   ASN_STRUCT_RESET(asn_DEF_E2setupRequestIEs, ranFlistIEs);
  60   ranFlistIEs->criticality = 0;
  61   ranFlistIEs->id = ProtocolIE_ID_id_RANfunctionsAdded;
  62   ranFlistIEs->value.present = E2setupRequestIEs__value_PR_RANfunctions_List;
  63
  64   auto *itemIes = (RANfunction_ItemIEs_t *)calloc(1, sizeof(RANfunction_ItemIEs_t));
  65   itemIes->id = ProtocolIE_ID_id_RANfunction_Item;
  66   itemIes->criticality = Criticality_reject;
  67   itemIes->value.present = RANfunction_ItemIEs__value_PR_RANfunction_Item;
  68   itemIes->value.choice.RANfunction_Item.ranFunctionID = 1;
  69
  70   ASN_SEQUENCE_ADD(&ranFlistIEs->value.choice.RANfunctions_List.list, itemIes);
  71   */
  72   E2setupRequest_t *e2setupreq = (E2setupRequest_t*)calloc(1, sizeof(E2setupRequest_t));
  73   ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, e2setuprid);
  74   //  ASN_SEQUENCE_ADD(&e2setupreq->protocolIEs.list, ranFlistIEs);
  75
  76   InitiatingMessage__value_PR pres4;
  77   pres4 = InitiatingMessage__value_PR_E2setupRequest;
  78   InitiatingMessage_t *initmsg = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
  79   //  initmsg->procedureCode = 1;
  80   initmsg->procedureCode = ProcedureCode_id_E2setup;
  81   initmsg->criticality = Criticality_reject;
  82   initmsg->value.present = pres4;
  83   initmsg->value.choice.E2setupRequest = *e2setupreq;
  84
  85   E2AP_PDU_PR pres5;
  86   pres5 = E2AP_PDU_PR_initiatingMessage;
  87
  88
  89   e2ap_pdu->present = pres5;
  90   e2ap_pdu->choice.initiatingMessage = initmsg;
  91
  92 }
  93
  94
  95 void generate_e2apv1_setup_response(E2AP_PDU_t *e2ap_pdu) {
  96
  97   E2setupResponseIEs *resp_ies1 = (E2setupResponseIEs_t*)calloc(1, sizeof(E2setupResponseIEs_t));
  98   E2setupResponseIEs *resp_ies2 = (E2setupResponseIEs_t*)calloc(1, sizeof(E2setupResponseIEs_t));
  99   E2setupResponseIEs *resp_ies3 = (E2setupResponseIEs_t*)calloc(1, sizeof(E2setupResponseIEs_t));
 100
 101   uint8_t *buf = (uint8_t *)"gnb1";
 102
 103   BIT_STRING_t *ricid_bstring = (BIT_STRING_t*)calloc(1,sizeof(BIT_STRING_t));
 104   ricid_bstring->buf = buf;
 105   ricid_bstring->size = 4;
 106   ricid_bstring->bits_unused = 0;
 107
 108   uint8_t *buf2 = (uint8_t *)"plmn3";
 109   OCTET_STRING_t *plmn = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
 110   plmn->buf = buf2;
 111   plmn->size = 5;
 112
 113   GlobalRIC_ID_t *globalricid = (GlobalRIC_ID_t*)calloc(1,sizeof(GlobalRIC_ID_t));
 114   globalricid->pLMN_Identity = *plmn;
 115   globalricid->ric_ID = *ricid_bstring;
 116
 117   E2setupResponseIEs__value_PR pres1;
 118   pres1 = E2setupResponseIEs__value_PR_GlobalRIC_ID;
 119
 120   resp_ies1->id = ProtocolIE_ID_id_GlobalRIC_ID;
 121   resp_ies1->criticality = 0;
 122   resp_ies1->value.present = pres1;
 123   resp_ies1->value.choice.GlobalRIC_ID = *globalricid;
 124
 125   E2setupResponse_t *e2setupresp = (E2setupResponse_t*)calloc(1,sizeof(E2setupResponse_t));
 126   int ret = ASN_SEQUENCE_ADD(&e2setupresp->protocolIEs.list, resp_ies1);
 127
 128
 129   SuccessfulOutcome__value_PR pres;
 130   pres = SuccessfulOutcome__value_PR_E2setupResponse;
 131   SuccessfulOutcome_t *successoutcome = (SuccessfulOutcome_t*)calloc(1, sizeof(SuccessfulOutcome_t));
 132   successoutcome->procedureCode = 1;
 133   successoutcome->criticality = 0;
 134   successoutcome->value.present = pres;
 135   successoutcome->value.choice.E2setupResponse = *e2setupresp;
 136
 137   E2AP_PDU_PR pres5 = E2AP_PDU_PR_successfulOutcome;
 138
 139   e2ap_pdu->present = pres5;
 140   e2ap_pdu->choice.successfulOutcome = successoutcome;
 141
 142 }
 143
 144
 145 void generate_e2apv1_subscription_request(E2AP_PDU *e2ap_pdu) {
 146
 147   fprintf(stderr, "in sub 1\n");
 148   RICsubscriptionRequest_IEs_t *ricreqid = (RICsubscriptionRequest_IEs_t*)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 149   fprintf(stderr, "in sub 2\n");
 150   ASN_STRUCT_RESET(asn_DEF_RICsubscriptionRequest_IEs, ricreqid);
 151   fprintf(stderr, "in sub 3\n");
 152   auto *ricsubrid = (RICsubscriptionRequest_IEs_t*)calloc(1, sizeof(RICsubscriptionRequest_IEs_t));
 153   fprintf(stderr, "in sub 4\n");
 154   ASN_STRUCT_RESET(asn_DEF_RICsubscriptionRequest_IEs, ricsubrid);
 155
 156   fprintf(stderr, "in generate sub\n");
 157   uint8_t *buf2 = (uint8_t *)"SubscriptionTriggers";
 158   fprintf(stderr, "in gen sub 1\n");
 159   OCTET_STRING_t *triggerdef = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
 160   triggerdef->buf = (uint8_t *)calloc(1,20);
 161   triggerdef->size = 20;
 162   memcpy(triggerdef->buf, buf2, triggerdef->size);
 163
 164
 165   fprintf(stderr, "sub1\n");
 166   ProtocolIE_ID_t proto_id= ProtocolIE_ID_id_RICaction_ToBeSetup_Item;
 167
 168   RICaction_ToBeSetup_ItemIEs__value_PR pres6;
 169   pres6 = RICaction_ToBeSetup_ItemIEs__value_PR_RICaction_ToBeSetup_Item;
 170
 171   printf("sub2\n");
 172
 173   uint8_t *buf5 = (uint8_t *)"ActionDef";
 174
 175   OCTET_STRING_t *actdef = (OCTET_STRING_t*)calloc(1, sizeof(OCTET_STRING_t));
 176   actdef->buf = (uint8_t *)calloc(1,9);
 177   actdef->size = 9;
 178   memcpy(triggerdef->buf, buf5, 9);
 179
 180   auto *sa = (RICsubsequentAction_t *) calloc(1, sizeof(RICsubsequentAction_t));
 181   ASN_STRUCT_RESET(asn_DEF_RICsubsequentAction, sa);
 182
 183   sa->ricTimeToWait = RICtimeToWait_w500ms;
 184   sa->ricSubsequentActionType = RICsubsequentActionType_continue;
 185
 186   /*
 187   RICaction_ToBeSetup_Item_t *action_item = (RICaction_ToBeSetup_Item_t*)calloc(1, sizeof(RICaction_ToBeSetup_Item_t));
 188   action_item->ricActionID = 5;
 189   action_item->ricActionType = 9;
 190   action_item->ricActionDefinition = actdef;
 191   action_item->ricSubsequentAction = sa;
 192   */
 193   printf("sub3\n");
 194
 195   RICaction_ToBeSetup_ItemIEs_t *action_item_ies = (RICaction_ToBeSetup_ItemIEs_t *)calloc(1, sizeof(RICaction_ToBeSetup_Item_t));
 196   action_item_ies->id = proto_id;
 197   action_item_ies->criticality = 0;
 198
 199   action_item_ies->value.present = pres6;
 200   action_item_ies->value.choice.RICaction_ToBeSetup_Item.ricActionID = 5;
 201   action_item_ies->value.choice.RICaction_ToBeSetup_Item.ricActionType = RICactionType_report;
 202   action_item_ies->value.choice.RICaction_ToBeSetup_Item.ricActionDefinition = actdef;
 203   action_item_ies->value.choice.RICaction_ToBeSetup_Item.ricSubsequentAction = sa;
 204
 205
 206   printf("sub5\n");
 207   /*
 208   RICsubscriptionDetails_t *ricsubdetails = (RICsubscriptionDetails_t*)calloc(1, sizeof(RICsubscriptionDetails_t));
 209   printf("sub5.5\n");
 210
 211   ASN_SEQUENCE_ADD(&ricsubdetails->ricAction_ToBeSetup_List.list, action_item_ies);
 212   ricsubdetails->ricEventTriggerDefinition = *triggerdef;
 213
 214   printf("sub6\n");
 215   */
 216
 217
 218   RICsubscriptionRequest_IEs__value_PR pres3;
 219   printf("sub6.1\n");
 220   pres3 = RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails;
 221   ricsubrid->id = ProtocolIE_ID_id_RICsubscriptionDetails;
 222   printf("sub6.2\n");
 223
 224   ricsubrid->criticality = 0;
 225   ricsubrid->value.present = pres3;
 226   printf("sub6.3\n");
 227
 228   ricsubrid->value.choice.RICsubscriptionDetails.ricEventTriggerDefinition = *triggerdef;
 229   printf("sub6.4\n");
 230
 231   ASN_SEQUENCE_ADD(&ricsubrid->value.choice.RICsubscriptionDetails.ricAction_ToBeSetup_List.list, action_item_ies);
 232
 233   printf("sub7\n");
 234
 235
 236   ricreqid->id = ProtocolIE_ID_id_RICrequestID;
 237   ricreqid->criticality = 0;
 238   ricreqid->value.present = RICsubscriptionRequest_IEs__value_PR_RICrequestID;
 239   ricreqid->value.choice.RICrequestID.ricRequestorID = 22;
 240   ricreqid->value.choice.RICrequestID.ricInstanceID = 6;
 241
 242   RICsubscriptionRequest_t *ricsubreq = (RICsubscriptionRequest_t*)calloc(1, sizeof(RICsubscriptionRequest_t));
 243
 244   ASN_SEQUENCE_ADD(&ricsubreq->protocolIEs.list,ricreqid);
 245   ASN_SEQUENCE_ADD(&ricsubreq->protocolIEs.list,ricsubrid);
 246
 247
 248
 249   InitiatingMessage__value_PR pres4;
 250   pres4 = InitiatingMessage__value_PR_RICsubscriptionRequest;
 251   InitiatingMessage_t *initmsg = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
 252   initmsg->procedureCode = ProcedureCode_id_RICsubscription;
 253   initmsg->criticality = Criticality_reject;
 254   initmsg->value.present = pres4;
 255   initmsg->value.choice.RICsubscriptionRequest = *ricsubreq;
 256
 257   E2AP_PDU_PR pres5;
 258   pres5 = E2AP_PDU_PR_initiatingMessage;
 259
 260
 261   e2ap_pdu->present = pres5;
 262   e2ap_pdu->choice.initiatingMessage = initmsg;
 263
 264   char *error_buf = (char*)calloc(300, sizeof(char));;
 265   size_t errlen;
 266
 267   asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
 268   printf("error length %d\n", errlen);
 269   printf("error buf %s\n", error_buf);
 270
 271   //  xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu);
 272
 273 }
 274
 275 void generate_e2apv1_subscription_response(E2AP_PDU *e2ap_pdu, E2AP_PDU *sub_req_pdu) {
 276
 277   //Gather details of the request
 278
 279   RICsubscriptionRequest_t orig_req =
 280     sub_req_pdu->choice.initiatingMessage->value.choice.RICsubscriptionRequest;
 281
 282   RICsubscriptionResponse_IEs_t *ricreqid =
 283     (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 284
 285   int count = orig_req.protocolIEs.list.count;
 286   int size = orig_req.protocolIEs.list.size;
 287
 288   RICsubscriptionRequest_IEs_t **ies = (RICsubscriptionRequest_IEs_t**)orig_req.protocolIEs.list.array;
 289
 290   fprintf(stderr, "count%d\n", count);
 291   fprintf(stderr, "size%d\n", size);
 292
 293   RICsubscriptionRequest_IEs__value_PR pres;
 294
 295   long responseRequestorId;
 296   long responseInstanceId;
 297   long responseActionId;
 298
 299   std::vector<long> actionIds;
 300
 301   for (int i=0; i < count; i++) {
 302     RICsubscriptionRequest_IEs_t *next_ie = ies[i];
 303     pres = next_ie->value.present;
 304
 305     fprintf(stderr, "next present value %d\n", pres);
 306
 307     switch(pres) {
 308     case RICsubscriptionRequest_IEs__value_PR_RICrequestID:
 309       {
 310         RICrequestID_t reqId = next_ie->value.choice.RICrequestID;
 311         long requestorId = reqId.ricRequestorID;
 312         long instanceId = reqId.ricInstanceID;
 313         fprintf(stderr, "requestorId %d\n", requestorId);
 314         fprintf(stderr, "instanceId %d\n", instanceId);
 315         responseRequestorId = requestorId;
 316         responseInstanceId = instanceId;
 317
 318         break;
 319       }
 320     case RICsubscriptionRequest_IEs__value_PR_RANfunctionID:
 321       break;
 322     case RICsubscriptionRequest_IEs__value_PR_RICsubscriptionDetails:
 323       {
 324         RICsubscriptionDetails_t subDetails = next_ie->value.choice.RICsubscriptionDetails;
 325         RICeventTriggerDefinition_t triggerDef = subDetails.ricEventTriggerDefinition;
 326         RICactions_ToBeSetup_List_t actionList = subDetails.ricAction_ToBeSetup_List;
 327
 328         int actionCount = actionList.list.count;
 329         fprintf(stderr, "action count%d\n", actionCount);
 330
 331         auto **item_array = actionList.list.array;
 332
 333         for (int i=0; i < actionCount; i++) {
 334           //RICaction_ToBeSetup_Item_t
 335           auto *next_item = item_array[i];
 336           RICactionID_t actionId = ((RICaction_ToBeSetup_ItemIEs*)next_item)->value.choice.RICaction_ToBeSetup_Item.ricActionID;
 337           fprintf(stderr, "Next Action ID %ld\n", actionId);
 338           responseActionId = actionId;
 339           actionIds.push_back(responseActionId);
 340         }
 341
 342         break;
 343       }
 344     }
 345
 346   }
 347
 348   fprintf(stderr, "After Processing Subscription Request\n");
 349
 350   fprintf(stderr, "requestorId %d\n", responseRequestorId);
 351   fprintf(stderr, "instanceId %d\n", responseInstanceId);
 352
 353
 354   for (int i=0; i < actionIds.size(); i++) {
 355     fprintf(stderr, "Action ID %d %ld\n", i, actionIds.at(i));
 356
 357   }
 358
 359
 360   RICsubscriptionResponse_IEs_t *respricreqid =
 361     (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 362
 363   respricreqid->id = ProtocolIE_ID_id_RICrequestID;
 364   respricreqid->criticality = 0;
 365   respricreqid->value.present = RICsubscriptionResponse_IEs__value_PR_RICrequestID;
 366   respricreqid->value.choice.RICrequestID.ricRequestorID = responseRequestorId;
 367
 368   respricreqid->value.choice.RICrequestID.ricInstanceID = responseInstanceId;
 369
 370
 371   RICsubscriptionResponse_IEs_t *ricactionadmitted =
 372     (RICsubscriptionResponse_IEs_t*)calloc(1, sizeof(RICsubscriptionResponse_IEs_t));
 373   ricactionadmitted->id = ProtocolIE_ID_id_RICactions_Admitted;
 374   ricactionadmitted->criticality = 0;
 375   ricactionadmitted->value.present = RICsubscriptionResponse_IEs__value_PR_RICaction_Admitted_List;
 376
 377   RICaction_Admitted_List_t* admlist =
 378     (RICaction_Admitted_List_t*)calloc(1,sizeof(RICaction_Admitted_List_t));
 379   ricactionadmitted->value.choice.RICaction_Admitted_List = *admlist;
 380
 381   for (int i=0; i < actionIds.size(); i++) {
 382     fprintf(stderr, "in for loop i = %d\n", i);
 383
 384     long aid = actionIds.at(i);
 385
 386     RICaction_Admitted_ItemIEs_t *admitie = (RICaction_Admitted_ItemIEs_t*)calloc(1,sizeof(RICaction_Admitted_ItemIEs_t));
 387     admitie->id = ProtocolIE_ID_id_RICaction_Admitted_Item;
 388     admitie->criticality = 0;
 389     admitie->value.present = RICaction_Admitted_ItemIEs__value_PR_RICaction_Admitted_Item;
 390     admitie->value.choice.RICaction_Admitted_Item.ricActionID = aid;
 391
 392     ASN_SEQUENCE_ADD(&ricactionadmitted->value.choice.RICaction_Admitted_List.list, admitie);
 393
 394   }
 395
 396
 397   RICsubscriptionResponse_t *ricsubresp = (RICsubscriptionResponse_t*)calloc(1,sizeof(RICsubscriptionResponse_t));
 398
 399   ASN_SEQUENCE_ADD(&ricsubresp->protocolIEs.list, respricreqid);
 400   ASN_SEQUENCE_ADD(&ricsubresp->protocolIEs.list, ricactionadmitted);
 401
 402
 403   SuccessfulOutcome__value_PR pres2;
 404   pres2 = SuccessfulOutcome__value_PR_RICsubscriptionResponse;
 405   SuccessfulOutcome_t *successoutcome = (SuccessfulOutcome_t*)calloc(1, sizeof(SuccessfulOutcome_t));
 406   successoutcome->procedureCode = ProcedureCode_id_RICsubscription;
 407   successoutcome->criticality = 0;
 408   successoutcome->value.present = pres2;
 409   successoutcome->value.choice.RICsubscriptionResponse = *ricsubresp;
 410
 411   E2AP_PDU_PR pres5 = E2AP_PDU_PR_successfulOutcome;
 412
 413   e2ap_pdu->present = pres5;
 414   e2ap_pdu->choice.successfulOutcome = successoutcome;
 415
 416   char *error_buf = (char*)calloc(300, sizeof(char));
 417   size_t errlen;
 418
 419   asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
 420   printf("error length %d\n", errlen);
 421   printf("error buf %s\n", error_buf);
 422
 423 }
 424
 425
 426
 427 void generate_e2apv1_indication_request(E2AP_PDU *e2ap_pdu) {
 428   fprintf(stderr, "ind1\n");
 429   RICindication_IEs_t *ricind_ies = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
 430   RICindication_IEs_t *ricind_ies2 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
 431   RICindication_IEs_t *ricind_ies3 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
 432   RICindication_IEs_t *ricind_ies4 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
 433   RICindication_IEs_t *ricind_ies5 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
 434   RICindication_IEs_t *ricind_ies6 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
 435   RICindication_IEs_t *ricind_ies7 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
 436   RICindication_IEs_t *ricind_ies8 = (RICindication_IEs_t*)calloc(1, sizeof(RICindication_IEs_t));
 437
 438   RICindication_IEs__value_PR pres3;
 439
 440   pres3 = RICindication_IEs__value_PR_RICrequestID;
 441   ricind_ies->id = ProtocolIE_ID_id_RICrequestID;
 442   ricind_ies->criticality = 0;
 443   ricind_ies->value.present = pres3;
 444   ricind_ies->value.choice.RICrequestID.ricRequestorID = 25;
 445   ricind_ies->value.choice.RICrequestID.ricInstanceID = 3;
 446
 447   fprintf(stderr, "ind2\n");
 448
 449   pres3 = RICindication_IEs__value_PR_RANfunctionID;
 450   ricind_ies2->id = ProtocolIE_ID_id_RANfunctionID;
 451   ricind_ies2->criticality = 0;
 452   ricind_ies2->value.present = pres3;
 453   ricind_ies2->value.choice.RANfunctionID = 70;
 454
 455
 456   ricind_ies3->id = ProtocolIE_ID_id_RICactionID;
 457   ricind_ies3->criticality = 0;
 458   pres3 =  RICindication_IEs__value_PR_RICactionID;
 459   ricind_ies3->value.present = pres3;
 460   ricind_ies3->value.choice.RICactionID = 80;
 461
 462
 463   pres3 = RICindication_IEs__value_PR_RICindicationSN;
 464   ricind_ies4->id = ProtocolIE_ID_id_RICindicationSN;
 465   ricind_ies4->criticality = 0;
 466   ricind_ies4->value.present = pres3;
 467   ricind_ies4->value.choice.RICindicationSN = 45;
 468
 469   pres3 = RICindication_IEs__value_PR_RICindicationType;
 470   ricind_ies5->id = ProtocolIE_ID_id_RICindicationType;
 471   ricind_ies5->criticality = 0;
 472   ricind_ies5->value.present = pres3;
 473   ricind_ies5->value.choice.RICindicationType = 0;
 474
 475
 476   uint8_t *buf2 = (uint8_t *)"reportheader";
 477   OCTET_STRING_t *hdr_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
 478   hdr_str->buf = (uint8_t*)calloc(1,12);
 479   hdr_str->size = 12;
 480   memcpy(hdr_str->buf, buf2, 12);
 481
 482   fprintf(stderr, "ind3\n");
 483
 484   ricind_ies6->value.choice.RICindicationHeader.buf = (uint8_t*)calloc(1,12);
 485
 486   pres3 = RICindication_IEs__value_PR_RICindicationHeader;
 487   ricind_ies6->id = ProtocolIE_ID_id_RICindicationHeader;
 488   ricind_ies6->criticality = 0;
 489   ricind_ies6->value.present = pres3;
 490   ricind_ies6->value.choice.RICindicationHeader.size = 12;
 491   memcpy(ricind_ies6->value.choice.RICindicationHeader.buf, buf2, 12);
 492
 493   ricind_ies7->value.choice.RICindicationMessage.buf = (uint8_t*)calloc(1,8192);
 494   //  uint8_t *buf9 = (uint8_t *)"reportmsg";
 495
 496
 497   E2SM_KPM_IndicationMessage_t *e2sm_ind_msg =
 498     (E2SM_KPM_IndicationMessage_t*)calloc(1,sizeof(E2SM_KPM_IndicationMessage_t));
 499
 500   encode_kpm(e2sm_ind_msg);
 501
 502   uint8_t e2smbuffer[8192];
 503   size_t e2smbuffer_size = 8192;
 504
 505   asn_codec_ctx_t *opt_cod;
 506
 507   asn_enc_rval_t er =
 508     asn_encode_to_buffer(opt_cod,
 509                          ATS_ALIGNED_BASIC_PER,
 510                          &asn_DEF_E2SM_KPM_IndicationMessage,
 511                          e2sm_ind_msg, e2smbuffer, e2smbuffer_size);
 512
 513   fprintf(stderr, "er encded is %d\n", er.encoded);
 514   fprintf(stderr, "after encoding message\n");
 515
 516   OCTET_STRING_t *msg_str = (OCTET_STRING_t*)calloc(1,sizeof(OCTET_STRING_t));
 517   msg_str->buf = (uint8_t*)calloc(1,er.encoded);
 518   msg_str->size = er.encoded;
 519   memcpy(msg_str->buf, e2smbuffer, er.encoded);
 520
 521
 522   pres3 = RICindication_IEs__value_PR_RICindicationMessage;
 523   ricind_ies7->id = ProtocolIE_ID_id_RICindicationMessage;
 524   fprintf(stderr, "after encoding message 1\n");
 525
 526   ricind_ies7->criticality = 0;
 527   ricind_ies7->value.present = pres3;
 528
 529   fprintf(stderr, "after encoding message 2\n");
 530
 531   fprintf(stderr, "after encoding message 3\n");
 532   ricind_ies7->value.choice.RICindicationMessage.size = er.encoded;
 533
 534   fprintf(stderr, "after encoding message 4\n");
 535   memcpy(ricind_ies7->value.choice.RICindicationMessage.buf, e2smbuffer, er.encoded);
 536
 537   fprintf(stderr, "after encoding message 5\n");
 538
 539   uint8_t *buf4 = (uint8_t *)"cpid";
 540   OCTET_STRING_t cpid_str;
 541   cpid_str.buf = buf4;
 542   cpid_str.size = 4;
 543
 544
 545   pres3 = RICindication_IEs__value_PR_RICcallProcessID;
 546   ricind_ies8->id = ProtocolIE_ID_id_RICcallProcessID;
 547
 548   ricind_ies8->criticality = 0;
 549   ricind_ies8->value.present = pres3;
 550
 551   ricind_ies8->value.choice.RICcallProcessID = cpid_str;
 552
 553
 554   RICindication_t *ricindication = (RICindication_t*)calloc(1, sizeof(RICindication_t));
 555
 556
 557   int ret;
 558   /*
 559     ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies);
 560
 561     ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies2);
 562
 563     ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies3);
 564     ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies4);
 565     ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies5);
 566
 567     ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies6);
 568   */
 569     ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies7);
 570
 571   ret = ASN_SEQUENCE_ADD(&ricindication->protocolIEs.list, ricind_ies8);
 572
 573
 574   InitiatingMessage__value_PR pres4;
 575   pres4 = InitiatingMessage__value_PR_RICindication;
 576   InitiatingMessage_t *initmsg = (InitiatingMessage_t*)calloc(1, sizeof(InitiatingMessage_t));
 577   initmsg->procedureCode = 5;
 578   initmsg->criticality = 1;
 579   initmsg->value.present = pres4;
 580   initmsg->value.choice.RICindication = *ricindication;
 581
 582   E2AP_PDU_PR pres5;
 583   pres5 = E2AP_PDU_PR_initiatingMessage;
 584
 585   e2ap_pdu->present = pres5;
 586   e2ap_pdu->choice.initiatingMessage = initmsg;
 587
 588   char *error_buf = (char*)calloc(300, sizeof(char));;
 589   size_t errlen;
 590
 591   asn_check_constraints(&asn_DEF_E2AP_PDU, e2ap_pdu, error_buf, &errlen);
 592   printf("error length %d\n", errlen);
 593   printf("error buf %s\n", error_buf);
 594
 595   xer_fprint(stderr, &asn_DEF_E2AP_PDU, e2ap_pdu);
 596 }
 597
 598
 599 void generate_e2apv1_indication_response(E2AP_PDU *e2ap_pdu) {
 600
 601
 602 }